mirror of
https://github.com/Z3Prover/z3
synced 2026-02-28 19:01:29 +00:00
Use nullptr.
This commit is contained in:
Bruce Mitchener
parent
f01328c65f
commit
76eb7b9ede
625 changed files with 4639 additions and 4639 deletions
|
|
@ -458,7 +458,7 @@ namespace smt {
|
|||
buffer << "!tmp";
|
||||
buffer << m_fresh_id;
|
||||
m_fresh_id++;
|
||||
return u.mk_skolem(symbol(buffer.c_str()), 0, 0, s);
|
||||
return u.mk_skolem(symbol(buffer.c_str()), 0, nullptr, s);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -617,7 +617,7 @@ namespace smt {
|
|||
ast_manager & m = get_manager();
|
||||
|
||||
expr * args[2] = {n, bound};
|
||||
app * unrollFunc = get_manager().mk_app(get_id(), _OP_RE_UNROLL, 0, 0, 2, args);
|
||||
app * unrollFunc = get_manager().mk_app(get_id(), _OP_RE_UNROLL, 0, nullptr, 2, args);
|
||||
m_trail.push_back(unrollFunc);
|
||||
|
||||
expr_ref_vector items(m);
|
||||
|
|
@ -659,7 +659,7 @@ namespace smt {
|
|||
} else {
|
||||
if (false) {
|
||||
// use cache
|
||||
app * lenTerm = NULL;
|
||||
app * lenTerm = nullptr;
|
||||
if (!length_ast_map.find(e, lenTerm)) {
|
||||
lenTerm = u.str.mk_length(e);
|
||||
length_ast_map.insert(e, lenTerm);
|
||||
|
|
@ -705,14 +705,14 @@ namespace smt {
|
|||
return n1;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
expr * theory_str::mk_concat(expr * n1, expr * n2) {
|
||||
context & ctx = get_context();
|
||||
ast_manager & m = get_manager();
|
||||
ENSURE(n1 != NULL);
|
||||
ENSURE(n2 != NULL);
|
||||
ENSURE(n1 != nullptr);
|
||||
ENSURE(n2 != nullptr);
|
||||
bool n1HasEqcValue = false;
|
||||
bool n2HasEqcValue = false;
|
||||
n1 = get_eqc_value(n1, n1HasEqcValue);
|
||||
|
|
@ -770,7 +770,7 @@ namespace smt {
|
|||
// Z3 treats (ast1) and (ast2) as two different nodes.
|
||||
//-------------------------------------------------------
|
||||
|
||||
expr * concatAst = NULL;
|
||||
expr * concatAst = nullptr;
|
||||
|
||||
if (!concat_astNode_map.find(n1, n2, concatAst)) {
|
||||
concatAst = u.str.mk_concat(n1, n2);
|
||||
|
|
@ -1424,9 +1424,9 @@ namespace smt {
|
|||
void theory_str::instantiate_axiom_Substr(enode * e) {
|
||||
context & ctx = get_context();
|
||||
ast_manager & m = get_manager();
|
||||
expr* substrBase = 0;
|
||||
expr* substrPos = 0;
|
||||
expr* substrLen = 0;
|
||||
expr* substrBase = nullptr;
|
||||
expr* substrPos = nullptr;
|
||||
expr* substrLen = nullptr;
|
||||
|
||||
app * expr = e->get_owner();
|
||||
if (axiomatized_terms.contains(expr)) {
|
||||
|
|
@ -2001,7 +2001,7 @@ namespace smt {
|
|||
}
|
||||
}
|
||||
// give up
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// trace code helper
|
||||
|
|
@ -2091,7 +2091,7 @@ namespace smt {
|
|||
// (Concat n_eqNode arg1) /\ arg1 has eq const
|
||||
|
||||
expr * concatResult = eval_concat(eq_str, arg1);
|
||||
if (concatResult != NULL) {
|
||||
if (concatResult != nullptr) {
|
||||
bool arg1HasEqcValue = false;
|
||||
expr * arg1Value = get_eqc_value(arg1, arg1HasEqcValue);
|
||||
expr_ref implyL(m);
|
||||
|
|
@ -2162,7 +2162,7 @@ namespace smt {
|
|||
// (Concat arg0 n_eqNode) /\ arg0 has eq const
|
||||
|
||||
expr * concatResult = eval_concat(arg0, eq_str);
|
||||
if (concatResult != NULL) {
|
||||
if (concatResult != nullptr) {
|
||||
bool arg0HasEqcValue = false;
|
||||
expr * arg0Value = get_eqc_value(arg0, arg0HasEqcValue);
|
||||
expr_ref implyL(m);
|
||||
|
|
@ -2846,8 +2846,8 @@ namespace smt {
|
|||
//*************************************************************
|
||||
if (is_concat_eq_type2(new_nn1, new_nn2)) {
|
||||
|
||||
expr * y = NULL;
|
||||
expr * m = NULL;
|
||||
expr * y = nullptr;
|
||||
expr * m = nullptr;
|
||||
expr * v1_arg0 = to_app(new_nn1)->get_arg(0);
|
||||
expr * v1_arg1 = to_app(new_nn1)->get_arg(1);
|
||||
expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
|
||||
|
|
@ -2878,8 +2878,8 @@ namespace smt {
|
|||
expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
|
||||
expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
|
||||
|
||||
expr * x = NULL;
|
||||
expr * n = NULL;
|
||||
expr * x = nullptr;
|
||||
expr * n = nullptr;
|
||||
|
||||
if (u.str.is_string(v1_arg0) && !u.str.is_string(v2_arg0)) {
|
||||
n = v1_arg1;
|
||||
|
|
@ -2920,8 +2920,8 @@ namespace smt {
|
|||
expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
|
||||
expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
|
||||
|
||||
expr * y = NULL;
|
||||
expr * m = NULL;
|
||||
expr * y = nullptr;
|
||||
expr * m = nullptr;
|
||||
|
||||
if (u.str.is_string(v1_arg0)) {
|
||||
y = v1_arg1;
|
||||
|
|
@ -3020,9 +3020,9 @@ namespace smt {
|
|||
<< "split type " << splitType << std::endl;
|
||||
);
|
||||
|
||||
expr * t1 = NULL;
|
||||
expr * t2 = NULL;
|
||||
expr * xorFlag = NULL;
|
||||
expr * t1 = nullptr;
|
||||
expr * t2 = nullptr;
|
||||
expr * xorFlag = nullptr;
|
||||
|
||||
std::pair<expr*, expr*> key1(concatAst1, concatAst2);
|
||||
std::pair<expr*, expr*> key2(concatAst2, concatAst1);
|
||||
|
|
@ -3390,10 +3390,10 @@ namespace smt {
|
|||
return;
|
||||
}
|
||||
|
||||
expr * x = NULL;
|
||||
expr * y = NULL;
|
||||
expr * strAst = NULL;
|
||||
expr * m = NULL;
|
||||
expr * x = nullptr;
|
||||
expr * y = nullptr;
|
||||
expr * strAst = nullptr;
|
||||
expr * m = nullptr;
|
||||
|
||||
expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
|
||||
expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
|
||||
|
|
@ -3424,8 +3424,8 @@ namespace smt {
|
|||
|
||||
// setup
|
||||
|
||||
expr * xorFlag = NULL;
|
||||
expr * temp1 = NULL;
|
||||
expr * xorFlag = nullptr;
|
||||
expr * temp1 = nullptr;
|
||||
std::pair<expr*, expr*> key1(concatAst1, concatAst2);
|
||||
std::pair<expr*, expr*> key2(concatAst2, concatAst1);
|
||||
|
||||
|
|
@ -3758,10 +3758,10 @@ namespace smt {
|
|||
expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
|
||||
expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
|
||||
|
||||
expr * x = NULL;
|
||||
expr * y = NULL;
|
||||
expr * strAst = NULL;
|
||||
expr * n = NULL;
|
||||
expr * x = nullptr;
|
||||
expr * y = nullptr;
|
||||
expr * strAst = nullptr;
|
||||
expr * n = nullptr;
|
||||
|
||||
if (u.str.is_string(v1_arg0) && !u.str.is_string(v2_arg0)) {
|
||||
strAst = v1_arg0;
|
||||
|
|
@ -4318,10 +4318,10 @@ namespace smt {
|
|||
expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
|
||||
|
||||
|
||||
expr * str1Ast = NULL;
|
||||
expr * y = NULL;
|
||||
expr * m = NULL;
|
||||
expr * str2Ast = NULL;
|
||||
expr * str1Ast = nullptr;
|
||||
expr * y = nullptr;
|
||||
expr * m = nullptr;
|
||||
expr * str2Ast = nullptr;
|
||||
|
||||
if (u.str.is_string(v1_arg0)) {
|
||||
str1Ast = v1_arg0;
|
||||
|
|
@ -4362,8 +4362,8 @@ namespace smt {
|
|||
}
|
||||
|
||||
//----------------------------------------------------------------
|
||||
expr * commonVar = NULL;
|
||||
expr * xorFlag = NULL;
|
||||
expr * commonVar = nullptr;
|
||||
expr * xorFlag = nullptr;
|
||||
std::pair<expr*, expr*> key1(concatAst1, concatAst2);
|
||||
std::pair<expr*, expr*> key2(concatAst2, concatAst1);
|
||||
|
||||
|
|
@ -4674,7 +4674,7 @@ namespace smt {
|
|||
return dynamic_cast<theory_mi_arith*>(th);
|
||||
}
|
||||
else {
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -4846,7 +4846,7 @@ namespace smt {
|
|||
}
|
||||
|
||||
expr * theory_str::collect_eq_nodes(expr * n, expr_ref_vector & eqcSet) {
|
||||
expr * constStrNode = NULL;
|
||||
expr * constStrNode = nullptr;
|
||||
|
||||
expr * ex = n;
|
||||
do {
|
||||
|
|
@ -4891,7 +4891,7 @@ namespace smt {
|
|||
expr * strAst = itor1->first;
|
||||
expr * substrAst = itor1->second;
|
||||
|
||||
expr * boolVar = NULL;
|
||||
expr * boolVar = nullptr;
|
||||
if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
|
||||
TRACE("str", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
|
||||
}
|
||||
|
|
@ -5028,7 +5028,7 @@ namespace smt {
|
|||
expr * strAst = itor1->first;
|
||||
expr * substrAst = itor1->second;
|
||||
|
||||
expr * boolVar = NULL;
|
||||
expr * boolVar = nullptr;
|
||||
if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
|
||||
TRACE("str", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
|
||||
}
|
||||
|
|
@ -5445,7 +5445,7 @@ namespace smt {
|
|||
expr_ref_vector willEqClass(m);
|
||||
expr * constStrAst_1 = collect_eq_nodes(n1, willEqClass);
|
||||
expr * constStrAst_2 = collect_eq_nodes(n2, willEqClass);
|
||||
expr * constStrAst = (constStrAst_1 != NULL) ? constStrAst_1 : constStrAst_2;
|
||||
expr * constStrAst = (constStrAst_1 != nullptr) ? constStrAst_1 : constStrAst_2;
|
||||
|
||||
TRACE("str", tout << "eqc of n1 is {";
|
||||
for (expr_ref_vector::iterator it = willEqClass.begin(); it != willEqClass.end(); ++it) {
|
||||
|
|
@ -5461,7 +5461,7 @@ namespace smt {
|
|||
);
|
||||
|
||||
// step 1: we may have constant values for Contains checks now
|
||||
if (constStrAst != NULL) {
|
||||
if (constStrAst != nullptr) {
|
||||
expr_ref_vector::iterator itAst = willEqClass.begin();
|
||||
for (; itAst != willEqClass.end(); itAst++) {
|
||||
if (*itAst == constStrAst) {
|
||||
|
|
@ -6405,9 +6405,9 @@ namespace smt {
|
|||
|
||||
expr * constStr_1 = collect_eq_nodes(nn1, eqNodeSet);
|
||||
expr * constStr_2 = collect_eq_nodes(nn2, eqNodeSet);
|
||||
expr * constStr = (constStr_1 != NULL) ? constStr_1 : constStr_2;
|
||||
expr * constStr = (constStr_1 != nullptr) ? constStr_1 : constStr_2;
|
||||
|
||||
if (constStr == NULL) {
|
||||
if (constStr == nullptr) {
|
||||
return;
|
||||
} else {
|
||||
expr_ref_vector::iterator itor = eqNodeSet.begin();
|
||||
|
|
@ -6615,7 +6615,7 @@ namespace smt {
|
|||
} else {
|
||||
// Case 4: Concat(var, var) == const
|
||||
TRACE("str", tout << "Case 4: Concat(var, var) == const" << std::endl;);
|
||||
if (eval_concat(arg1, arg2) == NULL) {
|
||||
if (eval_concat(arg1, arg2) == nullptr) {
|
||||
rational arg1Len, arg2Len;
|
||||
bool arg1Len_exists = get_len_value(arg1, arg1Len);
|
||||
bool arg2Len_exists = get_len_value(arg2, arg2Len);
|
||||
|
|
@ -6860,7 +6860,7 @@ namespace smt {
|
|||
} else {
|
||||
// start binary search as normal
|
||||
expr_ref implLhs(ctx.mk_eq_atom(testvar, str), m);
|
||||
expr_ref implRhs(binary_search_length_test(v, NULL, ""), m);
|
||||
expr_ref implRhs(binary_search_length_test(v, nullptr, ""), m);
|
||||
assert_implication(implLhs, implRhs);
|
||||
}
|
||||
} else {
|
||||
|
|
@ -6992,14 +6992,14 @@ namespace smt {
|
|||
}
|
||||
expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
|
||||
TRACE("str", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
|
||||
if (valueAssert != NULL) {
|
||||
if (valueAssert != nullptr) {
|
||||
assert_axiom(valueAssert);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
int lenTesterCount = fvar_lenTester_map[fVar].size();
|
||||
|
||||
expr * effectiveLenInd = NULL;
|
||||
expr * effectiveLenInd = nullptr;
|
||||
zstring effectiveLenIndiStr = "";
|
||||
for (int i = 0; i < lenTesterCount; ++i) {
|
||||
expr * len_indicator_pre = fvar_lenTester_map[fVar][i];
|
||||
|
|
@ -7017,7 +7017,7 @@ namespace smt {
|
|||
}
|
||||
expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
|
||||
TRACE("str", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
|
||||
if (valueAssert != NULL) {
|
||||
if (valueAssert != nullptr) {
|
||||
assert_axiom(valueAssert);
|
||||
}
|
||||
}
|
||||
|
|
@ -7262,20 +7262,20 @@ namespace smt {
|
|||
simplify_parent(lhs, nn2_value);
|
||||
}
|
||||
|
||||
expr * nn1EqConst = NULL;
|
||||
expr * nn1EqConst = nullptr;
|
||||
std::set<expr*> nn1EqUnrollFuncs;
|
||||
get_eqc_allUnroll(lhs, nn1EqConst, nn1EqUnrollFuncs);
|
||||
expr * nn2EqConst = NULL;
|
||||
expr * nn2EqConst = nullptr;
|
||||
std::set<expr*> nn2EqUnrollFuncs;
|
||||
get_eqc_allUnroll(rhs, nn2EqConst, nn2EqUnrollFuncs);
|
||||
|
||||
if (nn2EqConst != NULL) {
|
||||
if (nn2EqConst != nullptr) {
|
||||
for (std::set<expr*>::iterator itor1 = nn1EqUnrollFuncs.begin(); itor1 != nn1EqUnrollFuncs.end(); itor1++) {
|
||||
process_unroll_eq_const_str(*itor1, nn2EqConst);
|
||||
}
|
||||
}
|
||||
|
||||
if (nn1EqConst != NULL) {
|
||||
if (nn1EqConst != nullptr) {
|
||||
for (std::set<expr*>::iterator itor2 = nn2EqUnrollFuncs.begin(); itor2 != nn2EqUnrollFuncs.end(); itor2++) {
|
||||
process_unroll_eq_const_str(*itor2, nn1EqConst);
|
||||
}
|
||||
|
|
@ -7917,13 +7917,13 @@ namespace smt {
|
|||
if (aliasUnrollSet.find(unrollItor->first) != aliasUnrollSet.end()) {
|
||||
continue;
|
||||
}
|
||||
expr * aRoot = NULL;
|
||||
expr * aRoot = nullptr;
|
||||
enode * e_currEqc = ctx.get_enode(unrollItor->first);
|
||||
enode * e_curr = e_currEqc;
|
||||
do {
|
||||
app * curr = e_currEqc->get_owner();
|
||||
if (u.re.is_unroll(curr)) {
|
||||
if (aRoot == NULL) {
|
||||
if (aRoot == nullptr) {
|
||||
aRoot = curr;
|
||||
}
|
||||
aliasUnrollSet[curr] = aRoot;
|
||||
|
|
@ -7948,11 +7948,11 @@ namespace smt {
|
|||
if (aliasIndexMap.find(varItor->first) != aliasIndexMap.end()) {
|
||||
continue;
|
||||
}
|
||||
expr * aRoot = NULL;
|
||||
expr * aRoot = nullptr;
|
||||
expr * curr = varItor->first;
|
||||
do {
|
||||
if (variable_set.find(curr) != variable_set.end()) {
|
||||
if (aRoot == NULL) {
|
||||
if (aRoot == nullptr) {
|
||||
aRoot = curr;
|
||||
} else {
|
||||
aliasIndexMap[curr] = aRoot;
|
||||
|
|
@ -8040,11 +8040,11 @@ namespace smt {
|
|||
if (concats_eq_index_map.find(concatItor->first) != concats_eq_index_map.end()) {
|
||||
continue;
|
||||
}
|
||||
expr * aRoot = NULL;
|
||||
expr * aRoot = nullptr;
|
||||
expr * curr = concatItor->first;
|
||||
do {
|
||||
if (u.str.is_concat(to_app(curr))) {
|
||||
if (aRoot == NULL) {
|
||||
if (aRoot == nullptr) {
|
||||
aRoot = curr;
|
||||
} else {
|
||||
concats_eq_index_map[curr] = aRoot;
|
||||
|
|
@ -8056,7 +8056,7 @@ namespace smt {
|
|||
|
||||
concatItor = concatMap.begin();
|
||||
for(; concatItor != concatMap.end(); ++concatItor) {
|
||||
expr * deAliasConcat = NULL;
|
||||
expr * deAliasConcat = nullptr;
|
||||
if (concats_eq_index_map.find(concatItor->first) != concats_eq_index_map.end()) {
|
||||
deAliasConcat = concats_eq_index_map[concatItor->first];
|
||||
} else {
|
||||
|
|
@ -8194,15 +8194,15 @@ namespace smt {
|
|||
mostLeftNodes.clear();
|
||||
mostRightNodes.clear();
|
||||
|
||||
expr * mLConst = NULL;
|
||||
expr * mRConst = NULL;
|
||||
expr * mLConst = nullptr;
|
||||
expr * mRConst = nullptr;
|
||||
|
||||
for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
|
||||
expr * concatNode = itor1->first;
|
||||
expr * mLNode = getMostLeftNodeInConcat(concatNode);
|
||||
zstring strval;
|
||||
if (u.str.is_string(to_app(mLNode), strval)) {
|
||||
if (mLConst == NULL && strval.empty()) {
|
||||
if (mLConst == nullptr && strval.empty()) {
|
||||
mLConst = mLNode;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -8211,7 +8211,7 @@ namespace smt {
|
|||
|
||||
expr * mRNode = getMostRightNodeInConcat(concatNode);
|
||||
if (u.str.is_string(to_app(mRNode), strval)) {
|
||||
if (mRConst == NULL && strval.empty()) {
|
||||
if (mRConst == nullptr && strval.empty()) {
|
||||
mRConst = mRNode;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -8219,7 +8219,7 @@ namespace smt {
|
|||
}
|
||||
}
|
||||
|
||||
if (mLConst != NULL) {
|
||||
if (mLConst != nullptr) {
|
||||
// -------------------------------------------------------------------------------------
|
||||
// The left most variable in a concat is constrained by a constant string in eqc concat
|
||||
// -------------------------------------------------------------------------------------
|
||||
|
|
@ -8273,7 +8273,7 @@ namespace smt {
|
|||
}
|
||||
}
|
||||
|
||||
if (mRConst != NULL) {
|
||||
if (mRConst != nullptr) {
|
||||
for (std::map<expr*, expr*>::iterator itor1 = mostRightNodes.begin();
|
||||
itor1 != mostRightNodes.end(); itor1++) {
|
||||
expr * deVar = get_alias_index_ast(aliasIndexMap, itor1->first);
|
||||
|
|
@ -8952,7 +8952,7 @@ namespace smt {
|
|||
// -----------------------------------------------------------
|
||||
std::map<expr*, std::set<expr*> > fv_unrolls_map;
|
||||
std::set<expr*> tmpSet;
|
||||
expr * constValue = NULL;
|
||||
expr * constValue = nullptr;
|
||||
for (std::map<expr*, int>::iterator fvIt2 = freeVar_map.begin(); fvIt2 != freeVar_map.end(); fvIt2++) {
|
||||
expr * var = fvIt2->first;
|
||||
tmpSet.clear();
|
||||
|
|
@ -9036,7 +9036,7 @@ namespace smt {
|
|||
// Assign free variables
|
||||
std::set<expr*> fSimpUnroll;
|
||||
|
||||
constValue = NULL;
|
||||
constValue = nullptr;
|
||||
|
||||
{
|
||||
TRACE("str", tout << "free var map (#" << freeVar_map.size() << "):" << std::endl;
|
||||
|
|
@ -9074,8 +9074,8 @@ namespace smt {
|
|||
continue;
|
||||
}
|
||||
*/
|
||||
expr * toAssert = gen_len_val_options_for_free_var(freeVar, NULL, "");
|
||||
if (toAssert != NULL) {
|
||||
expr * toAssert = gen_len_val_options_for_free_var(freeVar, nullptr, "");
|
||||
if (toAssert != nullptr) {
|
||||
assert_axiom(toAssert);
|
||||
}
|
||||
}
|
||||
|
|
@ -9095,7 +9095,7 @@ namespace smt {
|
|||
gen_assign_unroll_reg(fv_unrolls_map[var]);
|
||||
} else {
|
||||
expr * toAssert = gen_assign_unroll_Str2Reg(var, fSimpUnroll);
|
||||
if (toAssert != NULL) {
|
||||
if (toAssert != nullptr) {
|
||||
assert_axiom(toAssert);
|
||||
}
|
||||
}
|
||||
|
|
@ -9381,7 +9381,7 @@ namespace smt {
|
|||
}
|
||||
|
||||
if (valTesterValueStr == "more") {
|
||||
expr * valTester = NULL;
|
||||
expr * valTester = nullptr;
|
||||
if (i + 1 < testerTotal) {
|
||||
valTester = fvar_valueTester_map[freeVar][len][i + 1].second;
|
||||
refresh_theory_var(valTester);
|
||||
|
|
@ -9394,7 +9394,7 @@ namespace smt {
|
|||
return gen_val_options(freeVar, len_indicator, valTester, len_valueStr, i + 1);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -9627,14 +9627,14 @@ namespace smt {
|
|||
|
||||
int lcm = 1;
|
||||
int coreValueCount = 0;
|
||||
expr * oneUnroll = NULL;
|
||||
expr * oneUnroll = nullptr;
|
||||
zstring oneCoreStr("");
|
||||
for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
|
||||
expr * str2RegFunc = to_app(*itor)->get_arg(0);
|
||||
expr * coreVal = to_app(str2RegFunc)->get_arg(0);
|
||||
zstring coreStr;
|
||||
u.str.is_string(coreVal, coreStr);
|
||||
if (oneUnroll == NULL) {
|
||||
if (oneUnroll == nullptr) {
|
||||
oneUnroll = *itor;
|
||||
oneCoreStr = coreStr;
|
||||
}
|
||||
|
|
@ -10060,7 +10060,7 @@ namespace smt {
|
|||
TRACE("str", tout << "invoked with previousLenTester info matching top of stack" << std::endl;);
|
||||
} else {
|
||||
TRACE("str", tout << "WARNING: unexpected reordering of length testers!" << std::endl;);
|
||||
UNREACHABLE(); return NULL;
|
||||
UNREACHABLE(); return nullptr;
|
||||
}
|
||||
} else {
|
||||
u.str.is_string(lastTesterValue, lastTesterConstant);
|
||||
|
|
@ -10076,7 +10076,7 @@ namespace smt {
|
|||
}
|
||||
TRACE("str", tout << "last bounds are [" << lastBounds.lowerBound << " | " << lastBounds.midPoint << " | " << lastBounds.upperBound << "]!" << lastBounds.windowSize << std::endl;);
|
||||
binary_search_info newBounds;
|
||||
expr * newTester = 0;
|
||||
expr * newTester = nullptr;
|
||||
if (lastTesterConstant == "more") {
|
||||
// special case: if the midpoint, upper bound, and window size are all equal,
|
||||
// we double the window size and adjust the bounds
|
||||
|
|
@ -10144,7 +10144,7 @@ namespace smt {
|
|||
return axiom;
|
||||
}
|
||||
// length is fixed
|
||||
expr * valueAssert = gen_free_var_options(freeVar, lastTester, lastTesterConstant, NULL, zstring(""));
|
||||
expr * valueAssert = gen_free_var_options(freeVar, lastTester, lastTesterConstant, nullptr, zstring(""));
|
||||
return valueAssert;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -10254,7 +10254,7 @@ namespace smt {
|
|||
} else {
|
||||
TRACE("str", tout << "found previous in-scope length assertions" << std::endl;);
|
||||
|
||||
expr * effectiveLenInd = NULL;
|
||||
expr * effectiveLenInd = nullptr;
|
||||
zstring effectiveLenIndiStr("");
|
||||
int lenTesterCount = (int) fvar_lenTester_map[freeVar].size();
|
||||
|
||||
|
|
@ -10355,7 +10355,7 @@ namespace smt {
|
|||
} else {
|
||||
TRACE("str", tout << "length is fixed; generating models for free var" << std::endl;);
|
||||
// length is fixed
|
||||
expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, zstring(""));
|
||||
expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, nullptr, zstring(""));
|
||||
return valueAssert;
|
||||
}
|
||||
} // fVarLenCountMap.find(...)
|
||||
|
|
@ -10409,7 +10409,7 @@ namespace smt {
|
|||
std::set<expr*> eqVarSet;
|
||||
get_var_in_eqc(freeVar, eqVarSet);
|
||||
bool duplicated = false;
|
||||
expr * dupVar = NULL;
|
||||
expr * dupVar = nullptr;
|
||||
for (std::set<expr*>::iterator itorEqv = eqVarSet.begin(); itorEqv != eqVarSet.end(); itorEqv++) {
|
||||
if (eqcRepSet.find(*itorEqv) != eqcRepSet.end()) {
|
||||
duplicated = true;
|
||||
|
|
@ -10417,7 +10417,7 @@ namespace smt {
|
|||
break;
|
||||
}
|
||||
}
|
||||
if (duplicated && dupVar != NULL) {
|
||||
if (duplicated && dupVar != nullptr) {
|
||||
TRACE("str", tout << "Duplicated free variable found:" << mk_pp(freeVar, get_manager())
|
||||
<< " = " << mk_ismt2_pp(dupVar, get_manager()) << " (SKIP)" << std::endl;);
|
||||
continue;
|
||||
|
|
@ -10465,10 +10465,10 @@ namespace smt {
|
|||
|
||||
for(std::set<expr*>::iterator itor1 = leafVarSet.begin();
|
||||
itor1 != leafVarSet.end(); ++itor1) {
|
||||
expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
|
||||
expr * toAssert = gen_len_val_options_for_free_var(*itor1, nullptr, "");
|
||||
// gen_len_val_options_for_free_var() can legally return NULL,
|
||||
// as methods that it calls may assert their own axioms instead.
|
||||
if (toAssert != NULL) {
|
||||
if (toAssert != nullptr) {
|
||||
assert_axiom(toAssert);
|
||||
}
|
||||
}
|
||||
|
|
@ -10477,9 +10477,9 @@ namespace smt {
|
|||
mItor != aloneVars.end(); ++mItor) {
|
||||
std::set<expr*>::iterator itor2 = mItor->second.begin();
|
||||
for(; itor2 != mItor->second.end(); ++itor2) {
|
||||
expr * toAssert = gen_len_val_options_for_free_var(*itor2, NULL, "");
|
||||
expr * toAssert = gen_len_val_options_for_free_var(*itor2, nullptr, "");
|
||||
// same deal with returning a NULL axiom here
|
||||
if(toAssert != NULL) {
|
||||
if(toAssert != nullptr) {
|
||||
assert_axiom(toAssert);
|
||||
}
|
||||
}
|
||||
|
|
@ -10491,7 +10491,7 @@ namespace smt {
|
|||
* and constant string in eqc of node n
|
||||
*/
|
||||
void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet) {
|
||||
constStr = NULL;
|
||||
constStr = nullptr;
|
||||
unrollFuncSet.clear();
|
||||
|
||||
expr * curr = n;
|
||||
|
|
@ -10509,7 +10509,7 @@ namespace smt {
|
|||
|
||||
// Collect simple Unroll functions (whose core is Str2Reg) and constant strings in the EQC of n.
|
||||
void theory_str::get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet) {
|
||||
constStr = NULL;
|
||||
constStr = nullptr;
|
||||
unrollFuncSet.clear();
|
||||
|
||||
expr * curr = n;
|
||||
|
|
@ -10556,7 +10556,7 @@ namespace smt {
|
|||
app * a0_conststr = mk_value_helper(to_app(a0));
|
||||
app * a1_conststr = mk_value_helper(to_app(a1));
|
||||
|
||||
if (a0_conststr != NULL && a1_conststr != NULL) {
|
||||
if (a0_conststr != nullptr && a1_conststr != nullptr) {
|
||||
zstring a0_s, a1_s;
|
||||
u.str.is_string(a0_conststr, a0_s);
|
||||
u.str.is_string(a1_conststr, a1_s);
|
||||
|
|
@ -10571,7 +10571,7 @@ namespace smt {
|
|||
if (hasEqc) {
|
||||
return to_app(n_eqc);
|
||||
} else {
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -10586,7 +10586,7 @@ namespace smt {
|
|||
SASSERT(get_context().e_internalized(owner));
|
||||
|
||||
app * val = mk_value_helper(owner);
|
||||
if (val != NULL) {
|
||||
if (val != nullptr) {
|
||||
return alloc(expr_wrapper_proc, val);
|
||||
} else {
|
||||
TRACE("str", tout << "WARNING: failed to find a concrete value, falling back" << std::endl;);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue