mirror of
https://github.com/Z3Prover/z3
synced 2025-06-28 08:58:44 +00:00
Centralize and document TRACE tags using X-macros (#7657)
* Introduce X-macro-based trace tag definition - Created trace_tags.def to centralize TRACE tag definitions - Each tag includes a symbolic name and description - Set up enum class TraceTag for type-safe usage in TRACE macros * Add script to generate Markdown documentation from trace_tags.def - Python script parses trace_tags.def and outputs trace_tags.md * Refactor TRACE_NEW to prepend TraceTag and pass enum to is_trace_enabled * trace: improve trace tag handling system with hierarchical tagging - Introduce hierarchical tag-class structure: enabling a tag class activates all child tags - Unify TRACE, STRACE, SCTRACE, and CTRACE under enum TraceTag - Implement initial version of trace_tag.def using X(tag, tag_class, description) (class names and descriptions to be refined in a future update) * trace: replace all string-based TRACE tags with enum TraceTag - Migrated all TRACE, STRACE, SCTRACE, and CTRACE macros to use enum TraceTag values instead of raw string literals * trace : add cstring header * trace : Add Markdown documentation generation from trace_tags.def via mk_api_doc.py * trace : rename macro parameter 'class' to 'tag_class' and remove Unicode comment in trace_tags.h. * trace : Add TODO comment for future implementation of tag_class activation * trace : Disable code related to tag_class until implementation is ready (#7663).
This commit is contained in:
LeeYoungJoon
GitHub
parent
d766292dab
commit
0a93ff515d
583 changed files with 8698 additions and 7299 deletions
|
|
@ -129,7 +129,7 @@ namespace smt {
|
|||
|
||||
expr_ref final_diseq(mk_and(branch), sub_m);
|
||||
fixed_length_assumptions.push_back(final_diseq);
|
||||
TRACE("str_fl", tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
TRACE(str_fl, tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
fixed_length_lesson.insert(final_diseq, std::make_tuple(PFUN, f, f));
|
||||
|
||||
return true;
|
||||
|
|
@ -183,7 +183,7 @@ namespace smt {
|
|||
|
||||
expr_ref final_diseq(mk_not(sub_m, mk_and(branch)), sub_m);
|
||||
fixed_length_assumptions.push_back(final_diseq);
|
||||
TRACE("str_fl", tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
TRACE(str_fl, tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
fixed_length_lesson.insert(final_diseq, std::make_tuple(NFUN, f, f));
|
||||
|
||||
return true;
|
||||
|
|
@ -245,7 +245,7 @@ namespace smt {
|
|||
|
||||
expr_ref final_diseq(mk_and(branch), sub_m);
|
||||
fixed_length_assumptions.push_back(final_diseq);
|
||||
TRACE("str_fl", tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
TRACE(str_fl, tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
fixed_length_lesson.insert(final_diseq, std::make_tuple(PFUN, f, f));
|
||||
|
||||
return true;
|
||||
|
|
@ -298,7 +298,7 @@ namespace smt {
|
|||
|
||||
expr_ref final_diseq(mk_not(sub_m, mk_and(branch)), sub_m);
|
||||
fixed_length_assumptions.push_back(final_diseq);
|
||||
TRACE("str_fl", tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
TRACE(str_fl, tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
fixed_length_lesson.insert(final_diseq, std::make_tuple(NFUN, f, f));
|
||||
|
||||
return true;
|
||||
|
|
@ -365,7 +365,7 @@ namespace smt {
|
|||
|
||||
expr_ref final_diseq(mk_or(branches), sub_m);
|
||||
fixed_length_assumptions.push_back(final_diseq);
|
||||
TRACE("str_fl", tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
TRACE(str_fl, tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
fixed_length_lesson.insert(final_diseq, std::make_tuple(PFUN, f, f));
|
||||
|
||||
return true;
|
||||
|
|
@ -425,7 +425,7 @@ namespace smt {
|
|||
|
||||
expr_ref final_diseq(mk_not(sub_m, mk_or(branches)), sub_m);
|
||||
fixed_length_assumptions.push_back(final_diseq);
|
||||
TRACE("str_fl", tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
TRACE(str_fl, tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
fixed_length_lesson.insert(final_diseq, std::make_tuple(NFUN, f, f));
|
||||
|
||||
return true;
|
||||
|
|
@ -476,17 +476,17 @@ namespace smt {
|
|||
}
|
||||
}
|
||||
if (!zero_solution && polarity) {
|
||||
TRACE("str_fl", tout << "contradiction: regex has no zero-length solutions, but our string must be a solution" << std::endl;);
|
||||
TRACE(str_fl, tout << "contradiction: regex has no zero-length solutions, but our string must be a solution" << std::endl;);
|
||||
cex = m.mk_or(m.mk_not(f), m.mk_not(ctx.mk_eq_atom(mk_strlen(str), mk_int(0))));
|
||||
ctx.get_rewriter()(cex);
|
||||
return false;
|
||||
} else if (zero_solution && !polarity) {
|
||||
TRACE("str_fl", tout << "contradiction: regex has zero-length solutions, but our string must not be a solution" << std::endl;);
|
||||
TRACE(str_fl, tout << "contradiction: regex has zero-length solutions, but our string must not be a solution" << std::endl;);
|
||||
cex = m.mk_or(f, m.mk_not(ctx.mk_eq_atom(mk_strlen(str), mk_int(0))));
|
||||
ctx.get_rewriter()(cex);
|
||||
return false;
|
||||
} else {
|
||||
TRACE("str_fl", tout << "regex constraint satisfied without asserting constraints to subsolver" << std::endl;);
|
||||
TRACE(str_fl, tout << "regex constraint satisfied without asserting constraints to subsolver" << std::endl;);
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -551,7 +551,7 @@ namespace smt {
|
|||
expr_ref result(mk_or(ors), sub_m);
|
||||
th_rewriter rw(sub_m);
|
||||
rw(result);
|
||||
TRACE("str_fl", tout << "regex path constraint: " << mk_pp(result, sub_m) << std::endl;);
|
||||
TRACE(str_fl, tout << "regex path constraint: " << mk_pp(result, sub_m) << std::endl;);
|
||||
|
||||
if (sub_m.is_false(result)) {
|
||||
// There are no solutions of that length in the automaton.
|
||||
|
|
@ -588,7 +588,7 @@ namespace smt {
|
|||
ctx.get_rewriter()(cex);
|
||||
return false;
|
||||
} else {
|
||||
TRACE("str_fl", tout << "regex constraint satisfied without asserting constraints to subsolver" << std::endl;);
|
||||
TRACE(str_fl, tout << "regex constraint satisfied without asserting constraints to subsolver" << std::endl;);
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -633,11 +633,11 @@ namespace smt {
|
|||
rational varLen_value;
|
||||
bool var_hasLen = fixed_length_get_len_value(term, varLen_value);
|
||||
if (!var_hasLen || varLen_value.is_neg()) {
|
||||
TRACE("str_fl", tout << "variable " << mk_pp(term, m) << " has no length assignment or impossible length assignment - asserting conflict axiom" << std::endl;);
|
||||
TRACE(str_fl, tout << "variable " << mk_pp(term, m) << " has no length assignment or impossible length assignment - asserting conflict axiom" << std::endl;);
|
||||
cex = expr_ref(m_autil.mk_ge(mk_strlen(term), mk_int(0)), m);
|
||||
return false;
|
||||
}
|
||||
TRACE("str_fl", tout << "creating character terms for variable " << mk_pp(term, m) << ", length = " << varLen_value << std::endl;);
|
||||
TRACE(str_fl, tout << "creating character terms for variable " << mk_pp(term, m) << ", length = " << varLen_value << std::endl;);
|
||||
chars = alloc(expr_ref_vector, m);
|
||||
for (rational i = rational::zero(); i < varLen_value; ++i) {
|
||||
// TODO we can probably name these better for the sake of debugging
|
||||
|
|
@ -683,7 +683,7 @@ namespace smt {
|
|||
cex = expr_ref(m.mk_or(m_autil.mk_ge(arg2, mk_int(0)), m_autil.mk_le(arg2, mk_int(0))), m);
|
||||
return false;
|
||||
}
|
||||
TRACE("str_fl", tout << "reduce substring term: base=" << mk_pp(term, m) << " (length="<<base_chars.size()<<"), pos=" << pos.to_string() << ", len=" << len.to_string() << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce substring term: base=" << mk_pp(term, m) << " (length="<<base_chars.size()<<"), pos=" << pos.to_string() << ", len=" << len.to_string() << std::endl;);
|
||||
// Case 1: pos < 0 or pos >= strlen(base) or len < 0
|
||||
// ==> (Substr ...) = ""
|
||||
if (pos.is_neg() || pos >= rational(base_chars.size()) || len.is_neg()) {
|
||||
|
|
@ -724,7 +724,7 @@ namespace smt {
|
|||
cex = m.mk_or(m_autil.mk_ge(pos, mk_int(0)), m_autil.mk_le(pos, mk_int(0)));
|
||||
return false;
|
||||
}
|
||||
TRACE("str_fl", tout << "reduce str.at: base=" << mk_pp(base, m) << ", pos=" << pos_value.to_string() << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce str.at: base=" << mk_pp(base, m) << ", pos=" << pos_value.to_string() << std::endl;);
|
||||
if (pos_value.is_neg() || pos_value >= rational(base_chars.size())) {
|
||||
// return the empty string
|
||||
eqc_chars.reset();
|
||||
|
|
@ -751,7 +751,7 @@ namespace smt {
|
|||
cex = expr_ref(m.mk_or(m_autil.mk_ge(mk_strlen(term), mk_int(0)), m_autil.mk_le(mk_strlen(term), mk_int(0))), m);
|
||||
return false;
|
||||
}
|
||||
TRACE("str_fl", tout << "reduce int.to.str: n=" << iValue << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce int.to.str: n=" << iValue << std::endl;);
|
||||
if (iValue.is_neg()) {
|
||||
if (!termLen.is_zero()) {
|
||||
// conflict
|
||||
|
|
@ -776,17 +776,17 @@ namespace smt {
|
|||
return true;
|
||||
}
|
||||
} else {
|
||||
TRACE("str_fl", tout << "string term " << mk_pp(term, m) << " handled as uninterpreted function" << std::endl;);
|
||||
TRACE(str_fl, tout << "string term " << mk_pp(term, m) << " handled as uninterpreted function" << std::endl;);
|
||||
expr_ref_vector *chars = nullptr;
|
||||
if (!uninterpreted_to_char_subterm_map.find(term, chars)) {
|
||||
rational ufLen_value;
|
||||
bool uf_hasLen = fixed_length_get_len_value(term, ufLen_value);
|
||||
if (!uf_hasLen || ufLen_value.is_neg()) {
|
||||
TRACE("str_fl", tout << "uninterpreted function " << mk_pp(term, m) << " has no length assignment or impossible length assignment - asserting conflict axiom" << std::endl;);
|
||||
TRACE(str_fl, tout << "uninterpreted function " << mk_pp(term, m) << " has no length assignment or impossible length assignment - asserting conflict axiom" << std::endl;);
|
||||
cex = expr_ref(m_autil.mk_ge(mk_strlen(term), mk_int(0)), m);
|
||||
return false;
|
||||
}
|
||||
TRACE("str_fl", tout << "creating character terms for uninterpreted function " << mk_pp(term, m) << ", length = " << ufLen_value << std::endl;);
|
||||
TRACE(str_fl, tout << "creating character terms for uninterpreted function " << mk_pp(term, m) << ", length = " << ufLen_value << std::endl;);
|
||||
chars = alloc(expr_ref_vector, m);
|
||||
for (rational i = rational::zero(); i < ufLen_value; ++i) {
|
||||
expr_ref ch(mk_fresh_const("char", u.mk_char_sort()), m);
|
||||
|
|
@ -816,7 +816,7 @@ namespace smt {
|
|||
}
|
||||
|
||||
if (lhs_chars.size() != rhs_chars.size()) {
|
||||
TRACE("str_fl", tout << "length information inconsistent: " << mk_pp(lhs, m) << " has " << lhs_chars.size() <<
|
||||
TRACE(str_fl, tout << "length information inconsistent: " << mk_pp(lhs, m) << " has " << lhs_chars.size() <<
|
||||
" chars, " << mk_pp(rhs, m) << " has " << rhs_chars.size() << " chars" << std::endl;);
|
||||
// equal strings ought to have equal lengths
|
||||
cex = m.mk_or(m.mk_not(ctx.mk_eq_atom(lhs, rhs)), ctx.mk_eq_atom(mk_strlen(lhs), mk_strlen(rhs)));
|
||||
|
|
@ -827,7 +827,7 @@ namespace smt {
|
|||
expr_ref cRHS(rhs_chars.get(i), sub_m);
|
||||
expr_ref _e(sub_m.mk_eq(cLHS, cRHS), sub_m);
|
||||
fixed_length_assumptions.push_back(_e);
|
||||
TRACE("str_fl", tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
TRACE(str_fl, tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
fixed_length_lesson.insert(_e, std::make_tuple(rational(i), lhs, rhs));
|
||||
}
|
||||
return true;
|
||||
|
|
@ -861,7 +861,7 @@ namespace smt {
|
|||
}
|
||||
|
||||
if (lhsLen != rhsLen) {
|
||||
TRACE("str", tout << "skip disequality: len(lhs) = " << lhsLen << ", len(rhs) = " << rhsLen << std::endl;);
|
||||
TRACE(str, tout << "skip disequality: len(lhs) = " << lhsLen << ", len(rhs) = " << rhsLen << std::endl;);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -875,7 +875,7 @@ namespace smt {
|
|||
|
||||
expr_ref final_diseq(mk_or(diseqs), sub_m);
|
||||
fixed_length_assumptions.push_back(final_diseq);
|
||||
TRACE("str_fl", tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
TRACE(str_fl, tout << "inserting into fixed_lesson" <<std::endl;);
|
||||
fixed_length_lesson.insert(final_diseq, std::make_tuple(NEQ, lhs, rhs));
|
||||
|
||||
return true;
|
||||
|
|
@ -887,7 +887,7 @@ namespace smt {
|
|||
|
||||
ast_manager & m = get_manager();
|
||||
|
||||
TRACE("str",
|
||||
TRACE(str,
|
||||
ast_manager & m = get_manager();
|
||||
tout << "dumping all formulas:" << std::endl;
|
||||
for (expr_ref_vector::iterator i = formulas.begin(); i != formulas.end(); ++i) {
|
||||
|
|
@ -920,10 +920,10 @@ namespace smt {
|
|||
sort * bool_sort = m.mk_bool_sort();
|
||||
|
||||
for (expr * var : free_variables) {
|
||||
TRACE("str_fl", tout << "initialize free variable " << mk_pp(var, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "initialize free variable " << mk_pp(var, m) << std::endl;);
|
||||
rational var_lenVal;
|
||||
if (!fixed_length_get_len_value(var, var_lenVal)) {
|
||||
TRACE("str_fl", tout << "free variable " << mk_pp(var, m) << " has no length assignment" << std::endl;);
|
||||
TRACE(str_fl, tout << "free variable " << mk_pp(var, m) << " has no length assignment" << std::endl;);
|
||||
expr_ref var_len_assertion(m_autil.mk_ge(mk_strlen(var), mk_int(0)), m);
|
||||
assert_axiom(var_len_assertion);
|
||||
add_persisted_axiom(var_len_assertion);
|
||||
|
|
@ -932,7 +932,7 @@ namespace smt {
|
|||
expr_ref_vector var_chars(m);
|
||||
expr_ref str_counterexample(m);
|
||||
if (!fixed_length_reduce_string_term(subsolver, var, var_chars, str_counterexample)) {
|
||||
TRACE("str_fl", tout << "free variable " << mk_pp(var, m) << " caused a conflict; asserting and continuing" << std::endl;);
|
||||
TRACE(str_fl, tout << "free variable " << mk_pp(var, m) << " caused a conflict; asserting and continuing" << std::endl;);
|
||||
assert_axiom(str_counterexample);
|
||||
return l_undef;
|
||||
}
|
||||
|
|
@ -943,13 +943,13 @@ namespace smt {
|
|||
expr * subformula = nullptr;
|
||||
if (m.is_not(f, subformula)) {
|
||||
if (!get_context().is_relevant(subformula)) {
|
||||
TRACE("str_fl", tout << "skip reducing formula " << mk_pp(f, m) << ", not relevant (and neither is its subformula)" << std::endl;);
|
||||
TRACE(str_fl, tout << "skip reducing formula " << mk_pp(f, m) << ", not relevant (and neither is its subformula)" << std::endl;);
|
||||
continue;
|
||||
} else {
|
||||
TRACE("str_fl", tout << "considering formula " << mk_pp(f, m) << ", its subformula is relevant but it is not" << std::endl;);
|
||||
TRACE(str_fl, tout << "considering formula " << mk_pp(f, m) << ", its subformula is relevant but it is not" << std::endl;);
|
||||
}
|
||||
} else {
|
||||
TRACE("str_fl", tout << "skip reducing formula " << mk_pp(f, m) << ", not relevant" << std::endl;);
|
||||
TRACE(str_fl, tout << "skip reducing formula " << mk_pp(f, m) << ", not relevant" << std::endl;);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
|
@ -963,7 +963,7 @@ namespace smt {
|
|||
if (m.is_eq(f, lhs, rhs)) {
|
||||
sort * lhs_sort = lhs->get_sort();
|
||||
if (lhs_sort == str_sort) {
|
||||
TRACE("str_fl", tout << "reduce string equality: " << mk_pp(lhs, m) << " == " << mk_pp(rhs, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce string equality: " << mk_pp(lhs, m) << " == " << mk_pp(rhs, m) << std::endl;);
|
||||
expr_ref cex(m);
|
||||
expr_ref left(lhs, m);
|
||||
expr_ref right(rhs, m);
|
||||
|
|
@ -975,10 +975,10 @@ namespace smt {
|
|||
}
|
||||
fixed_length_reduced_boolean_formulas.push_back(f);
|
||||
} else {
|
||||
TRACE("str_fl", tout << "skip reducing formula " << mk_pp(f, m) << ", not an equality over strings" << std::endl;);
|
||||
TRACE(str_fl, tout << "skip reducing formula " << mk_pp(f, m) << ", not an equality over strings" << std::endl;);
|
||||
}
|
||||
} else if (u.str.is_in_re(f)) {
|
||||
TRACE("str_fl", tout << "reduce regex membership: " << mk_pp(f, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce regex membership: " << mk_pp(f, m) << std::endl;);
|
||||
expr_ref cex_clause(m);
|
||||
expr_ref re(f, m);
|
||||
if (!fixed_length_reduce_regex_membership(subsolver, re, cex_clause, true)) {
|
||||
|
|
@ -991,10 +991,10 @@ namespace smt {
|
|||
// TODO in some cases (e.g. len(haystack) is only slightly greater than len(needle))
|
||||
// we might be okay to assert the full disjunction because there are very few disjuncts
|
||||
if (m_params.m_FixedLengthRefinement) {
|
||||
TRACE("str_fl", tout << "abstracting out positive contains: " << mk_pp(f, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "abstracting out positive contains: " << mk_pp(f, m) << std::endl;);
|
||||
abstracted_boolean_formulas.push_back(f);
|
||||
} else {
|
||||
TRACE("str_fl", tout << "reduce positive contains: " << mk_pp(f, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce positive contains: " << mk_pp(f, m) << std::endl;);
|
||||
expr_ref cex(m);
|
||||
expr_ref cont(f, m);
|
||||
if (!fixed_length_reduce_contains(subsolver, cont, cex)) {
|
||||
|
|
@ -1005,7 +1005,7 @@ namespace smt {
|
|||
fixed_length_reduced_boolean_formulas.push_back(f);
|
||||
}
|
||||
} else if (u.str.is_prefix(f)) {
|
||||
TRACE("str_fl", tout << "reduce positive prefix: " << mk_pp(f, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce positive prefix: " << mk_pp(f, m) << std::endl;);
|
||||
expr_ref cex(m);
|
||||
expr_ref pref(f, m);
|
||||
if (!fixed_length_reduce_prefix(subsolver, pref, cex)) {
|
||||
|
|
@ -1015,7 +1015,7 @@ namespace smt {
|
|||
}
|
||||
fixed_length_reduced_boolean_formulas.push_back(f);
|
||||
} else if (u.str.is_suffix(f)) {
|
||||
TRACE("str_fl", tout << "reduce positive suffix: " << mk_pp(f, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce positive suffix: " << mk_pp(f, m) << std::endl;);
|
||||
expr_ref cex(m);
|
||||
expr_ref suf(f, m);
|
||||
if (!fixed_length_reduce_suffix(subsolver, suf, cex)) {
|
||||
|
|
@ -1029,7 +1029,7 @@ namespace smt {
|
|||
if (m.is_eq(subterm, lhs, rhs)) {
|
||||
sort * lhs_sort = lhs->get_sort();
|
||||
if (lhs_sort == str_sort) {
|
||||
TRACE("str_fl", tout << "reduce string disequality: " << mk_pp(lhs, m) << " != " << mk_pp(rhs, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce string disequality: " << mk_pp(lhs, m) << " != " << mk_pp(rhs, m) << std::endl;);
|
||||
expr_ref cex(m);
|
||||
expr_ref left(lhs, m);
|
||||
expr_ref right(rhs, m);
|
||||
|
|
@ -1042,7 +1042,7 @@ namespace smt {
|
|||
fixed_length_reduced_boolean_formulas.push_back(f);
|
||||
}
|
||||
} else if (u.str.is_in_re(subterm)) {
|
||||
TRACE("str_fl", tout << "reduce negative regex membership: " << mk_pp(f, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce negative regex membership: " << mk_pp(f, m) << std::endl;);
|
||||
expr_ref cex_clause(m);
|
||||
expr_ref re(subterm, m);
|
||||
if (!fixed_length_reduce_regex_membership(subsolver, re, cex_clause, false)) {
|
||||
|
|
@ -1052,7 +1052,7 @@ namespace smt {
|
|||
}
|
||||
fixed_length_reduced_boolean_formulas.push_back(f);
|
||||
} else if (u.str.is_contains(subterm)) {
|
||||
TRACE("str_fl", tout << "reduce negative contains: " << mk_pp(subterm, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce negative contains: " << mk_pp(subterm, m) << std::endl;);
|
||||
expr_ref cex(m);
|
||||
expr_ref cont(subterm, m);
|
||||
if (!fixed_length_reduce_negative_contains(subsolver, cont, cex)) {
|
||||
|
|
@ -1062,7 +1062,7 @@ namespace smt {
|
|||
}
|
||||
fixed_length_reduced_boolean_formulas.push_back(f);
|
||||
} else if (u.str.is_prefix(subterm)) {
|
||||
TRACE("str_fl", tout << "reduce negative prefix: " << mk_pp(subterm, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce negative prefix: " << mk_pp(subterm, m) << std::endl;);
|
||||
expr_ref cex(m);
|
||||
expr_ref pref(subterm, m);
|
||||
if (!fixed_length_reduce_negative_prefix(subsolver, pref, cex)) {
|
||||
|
|
@ -1072,7 +1072,7 @@ namespace smt {
|
|||
}
|
||||
fixed_length_reduced_boolean_formulas.push_back(f);
|
||||
} else if (u.str.is_suffix(subterm)) {
|
||||
TRACE("str_fl", tout << "reduce negative suffix: " << mk_pp(subterm, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "reduce negative suffix: " << mk_pp(subterm, m) << std::endl;);
|
||||
expr_ref cex(m);
|
||||
expr_ref suf(subterm, m);
|
||||
if (!fixed_length_reduce_negative_suffix(subsolver, suf, cex)) {
|
||||
|
|
@ -1082,14 +1082,14 @@ namespace smt {
|
|||
}
|
||||
fixed_length_reduced_boolean_formulas.push_back(f);
|
||||
} else {
|
||||
TRACE("str_fl", tout << "skip reducing formula " << mk_pp(f, m) << ", not a boolean formula we handle" << std::endl;);
|
||||
TRACE(str_fl, tout << "skip reducing formula " << mk_pp(f, m) << ", not a boolean formula we handle" << std::endl;);
|
||||
}
|
||||
} else {
|
||||
TRACE("str_fl", tout << "skip reducing formula " << mk_pp(f, m) << ", not a boolean formula we handle" << std::endl;);
|
||||
TRACE(str_fl, tout << "skip reducing formula " << mk_pp(f, m) << ", not a boolean formula we handle" << std::endl;);
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
TRACE("str_fl", tout << "skip reducing formula " << mk_pp(f, m) << ", not relevant to strings" << std::endl;);
|
||||
TRACE(str_fl, tout << "skip reducing formula " << mk_pp(f, m) << ", not relevant to strings" << std::endl;);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
|
@ -1100,7 +1100,7 @@ namespace smt {
|
|||
arith_value v(get_manager());
|
||||
v.init(&get_context());
|
||||
for (auto e : string_int_conversion_terms) {
|
||||
TRACE("str_fl", tout << "pre-run check str-int term " << mk_pp(e, get_manager()) << std::endl;);
|
||||
TRACE(str_fl, tout << "pre-run check str-int term " << mk_pp(e, get_manager()) << std::endl;);
|
||||
expr* _arg;
|
||||
if (u.str.is_stoi(e, _arg)) {
|
||||
expr_ref arg(_arg, m);
|
||||
|
|
@ -1111,11 +1111,11 @@ namespace smt {
|
|||
add_persisted_axiom(stoi_cex);
|
||||
return l_undef;
|
||||
}
|
||||
TRACE("str_fl", tout << "length of term is " << slen << std::endl;);
|
||||
TRACE(str_fl, tout << "length of term is " << slen << std::endl;);
|
||||
|
||||
rational ival;
|
||||
if (v.get_value(e, ival)) {
|
||||
TRACE("str_fl", tout << "integer theory assigns " << ival << " to " << mk_pp(e, get_manager()) << std::endl;);
|
||||
TRACE(str_fl, tout << "integer theory assigns " << ival << " to " << mk_pp(e, get_manager()) << std::endl;);
|
||||
// if ival is non-negative, because we know the length of arg, we can add a character constraint for arg
|
||||
if (ival.is_nonneg()) {
|
||||
zstring ival_str(ival.to_string());
|
||||
|
|
@ -1145,14 +1145,14 @@ namespace smt {
|
|||
fixed_length_reduced_boolean_formulas.push_back(m.mk_eq(e, mk_int(ival)));
|
||||
}
|
||||
} else {
|
||||
TRACE("str_fl", tout << "integer theory has no assignment for " << mk_pp(e, get_manager()) << std::endl;);
|
||||
TRACE(str_fl, tout << "integer theory has no assignment for " << mk_pp(e, get_manager()) << std::endl;);
|
||||
// consistency needs to be checked after the string is assigned
|
||||
}
|
||||
} else if (u.str.is_to_code(e, _arg)) {
|
||||
expr_ref arg(_arg, m);
|
||||
rational ival;
|
||||
if (v.get_value(e, ival)) {
|
||||
TRACE("str_fl", tout << "integer theory assigns " << ival << " to " << mk_pp(e, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "integer theory assigns " << ival << " to " << mk_pp(e, m) << std::endl;);
|
||||
if (ival >= rational::zero() && ival <= rational(u.max_char())) {
|
||||
zstring ival_str(ival.get_unsigned());
|
||||
expr_ref arg_char_expr(mk_string(ival_str), m);
|
||||
|
|
@ -1169,7 +1169,7 @@ namespace smt {
|
|||
fixed_length_reduced_boolean_formulas.push_back(m.mk_eq(e, mk_int(ival)));
|
||||
}
|
||||
} else {
|
||||
TRACE("str_fl", tout << "integer theory has no assignment for " << mk_pp(e, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "integer theory has no assignment for " << mk_pp(e, m) << std::endl;);
|
||||
// consistency needs to be checked after the string is assigned
|
||||
}
|
||||
} else if (u.str.is_itos(e, _arg)) {
|
||||
|
|
@ -1181,10 +1181,10 @@ namespace smt {
|
|||
add_persisted_axiom(stoi_cex);
|
||||
return l_undef;
|
||||
}
|
||||
TRACE("str_fl", tout << "length of term is " << slen << std::endl;);
|
||||
TRACE(str_fl, tout << "length of term is " << slen << std::endl;);
|
||||
rational ival;
|
||||
if (v.get_value(arg, ival)) {
|
||||
TRACE("str_fl", tout << "integer theory assigns " << ival << " to " << mk_pp(arg, get_manager()) << std::endl;);
|
||||
TRACE(str_fl, tout << "integer theory assigns " << ival << " to " << mk_pp(arg, get_manager()) << std::endl;);
|
||||
zstring ival_str;
|
||||
if (ival.is_neg()) {
|
||||
// e must be the empty string, i.e. have length 0
|
||||
|
|
@ -1211,14 +1211,14 @@ namespace smt {
|
|||
}
|
||||
fixed_length_reduced_boolean_formulas.push_back(m.mk_eq(arg, mk_int(ival)));
|
||||
} else {
|
||||
TRACE("str_fl", tout << "integer theory has no assignment for " << mk_pp(arg, get_manager()) << std::endl;);
|
||||
TRACE(str_fl, tout << "integer theory has no assignment for " << mk_pp(arg, get_manager()) << std::endl;);
|
||||
// consistency needs to be checked after the string is assigned
|
||||
}
|
||||
} else if (u.str.is_from_code(e, _arg)) {
|
||||
expr_ref arg(_arg, m);
|
||||
rational ival;
|
||||
if (v.get_value(arg, ival)) {
|
||||
TRACE("str_fl", tout << "integer theory assigns " << ival << " to " << mk_pp(arg, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "integer theory assigns " << ival << " to " << mk_pp(arg, m) << std::endl;);
|
||||
if (ival >= rational::zero() && ival <= rational(u.max_char())) {
|
||||
zstring ival_str(ival.get_unsigned());
|
||||
expr_ref arg_char_expr(mk_string(ival_str), m);
|
||||
|
|
@ -1236,7 +1236,7 @@ namespace smt {
|
|||
fixed_length_reduced_boolean_formulas.push_back(m.mk_eq(e, mk_int(ival)));
|
||||
}
|
||||
} else {
|
||||
TRACE("str_fl", tout << "integer theory has no assignment for " << mk_pp(arg, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "integer theory has no assignment for " << mk_pp(arg, m) << std::endl;);
|
||||
// consistency needs to be checked after the string is assigned
|
||||
}
|
||||
}
|
||||
|
|
@ -1249,7 +1249,7 @@ namespace smt {
|
|||
precondition.push_back(m.mk_eq(u.str.mk_length(var), mk_int(val)));
|
||||
}
|
||||
|
||||
TRACE("str_fl",
|
||||
TRACE(str_fl,
|
||||
tout << "formulas asserted to subsolver:" << std::endl;
|
||||
for (auto e : fixed_length_assumptions) {
|
||||
tout << mk_pp(e, subsolver.m()) << std::endl;
|
||||
|
|
@ -1268,12 +1268,12 @@ namespace smt {
|
|||
}
|
||||
);
|
||||
|
||||
TRACE("str_fl", tout << "calling subsolver" << std::endl;);
|
||||
TRACE(str_fl, tout << "calling subsolver" << std::endl;);
|
||||
|
||||
lbool subproblem_status = subsolver.check(fixed_length_assumptions);
|
||||
|
||||
if (subproblem_status == l_true) {
|
||||
TRACE("str_fl", tout << "subsolver found SAT; reconstructing model" << std::endl;);
|
||||
TRACE(str_fl, tout << "subsolver found SAT; reconstructing model" << std::endl;);
|
||||
model_ref subModel;
|
||||
subsolver.get_model(subModel);
|
||||
|
||||
|
|
@ -1296,7 +1296,7 @@ namespace smt {
|
|||
model.insert(var, strValue);
|
||||
subst.insert(var, mk_string(strValue));
|
||||
}
|
||||
TRACE("str_fl",
|
||||
TRACE(str_fl,
|
||||
for (auto entry : model) {
|
||||
tout << mk_pp(entry.m_key, m) << " = " << entry.m_value << std::endl;
|
||||
}
|
||||
|
|
@ -1326,7 +1326,7 @@ namespace smt {
|
|||
arith_value v(get_manager());
|
||||
v.init(&get_context());
|
||||
for (auto e : string_int_conversion_terms) {
|
||||
TRACE("str_fl", tout << "post-run check str-int term " << mk_pp(e, get_manager()) << std::endl;);
|
||||
TRACE(str_fl, tout << "post-run check str-int term " << mk_pp(e, get_manager()) << std::endl;);
|
||||
expr* _arg;
|
||||
if (u.str.is_stoi(e, _arg)) {
|
||||
expr_ref arg(_arg, m);
|
||||
|
|
@ -1335,7 +1335,7 @@ namespace smt {
|
|||
expr_ref arg_subst(arg, m);
|
||||
(*replacer)(arg, arg_subst);
|
||||
rw(arg_subst);
|
||||
TRACE("str_fl", tout << "ival = " << ival << ", string arg evaluates to " << mk_pp(arg_subst, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "ival = " << ival << ", string arg evaluates to " << mk_pp(arg_subst, m) << std::endl;);
|
||||
|
||||
zstring arg_zstr;
|
||||
if (u.str.is_string(arg_subst, arg_zstr)) {
|
||||
|
|
@ -1363,7 +1363,7 @@ namespace smt {
|
|||
expr_ref arg_subst(arg, m);
|
||||
(*replacer)(arg, arg_subst);
|
||||
rw(arg_subst);
|
||||
TRACE("str_fl", tout << "ival = " << ival << ", string arg evaluates to " << mk_pp(arg_subst, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "ival = " << ival << ", string arg evaluates to " << mk_pp(arg_subst, m) << std::endl;);
|
||||
zstring arg_zstr;
|
||||
if (u.str.is_string(arg_subst, arg_zstr)) {
|
||||
if (ival >= rational::zero() && ival <= rational(u.max_char())) {
|
||||
|
|
@ -1392,7 +1392,7 @@ namespace smt {
|
|||
expr_ref e_subst(e, m);
|
||||
(*replacer)(e, e_subst);
|
||||
rw(e_subst);
|
||||
TRACE("str_fl", tout << "ival = " << ival << ", string arg evaluates to " << mk_pp(e_subst, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "ival = " << ival << ", string arg evaluates to " << mk_pp(e_subst, m) << std::endl;);
|
||||
|
||||
zstring e_zstr;
|
||||
if (u.str.is_string(e_subst, e_zstr)) {
|
||||
|
|
@ -1432,7 +1432,7 @@ namespace smt {
|
|||
expr_ref e_subst(e, m);
|
||||
(*replacer)(e, e_subst);
|
||||
rw(e_subst);
|
||||
TRACE("str_fl", tout << "ival = " << ival << ", string arg evaluates to " << mk_pp(e_subst, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "ival = " << ival << ", string arg evaluates to " << mk_pp(e_subst, m) << std::endl;);
|
||||
zstring e_zstr;
|
||||
if (u.str.is_string(e_subst, e_zstr)) {
|
||||
// if arg is out of range, e must be empty
|
||||
|
|
@ -1470,11 +1470,11 @@ namespace smt {
|
|||
th_rewriter rw(m);
|
||||
if (!abstracted_boolean_formulas.empty()) {
|
||||
for (auto f : abstracted_boolean_formulas) {
|
||||
TRACE("str_fl", tout << "refinement of boolean formula: " << mk_pp(f, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "refinement of boolean formula: " << mk_pp(f, m) << std::endl;);
|
||||
expr_ref f_new(m);
|
||||
(*replacer)(f, f_new);
|
||||
rw(f_new);
|
||||
TRACE("str_fl", tout << "after substitution and simplification, evaluates to: " << mk_pp(f_new, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "after substitution and simplification, evaluates to: " << mk_pp(f_new, m) << std::endl;);
|
||||
// now there are three cases, depending on what f_new evaluates to:
|
||||
// true -> OK, do nothing
|
||||
// false -> refine abstraction by generating conflict clause
|
||||
|
|
@ -1493,7 +1493,7 @@ namespace smt {
|
|||
cex.push_back(ctx.mk_eq_atom(needle, needle_assignment));
|
||||
return l_false;
|
||||
} else {
|
||||
TRACE("str_fl", tout << "error: unhandled refinement term " << mk_pp(f, m) << std::endl;);
|
||||
TRACE(str_fl, tout << "error: unhandled refinement term " << mk_pp(f, m) << std::endl;);
|
||||
NOT_IMPLEMENTED_YET();
|
||||
}
|
||||
} else {
|
||||
|
|
@ -1506,7 +1506,7 @@ namespace smt {
|
|||
return l_true;
|
||||
} else if (subproblem_status == l_false) {
|
||||
if (m_params.m_FixedLengthNaiveCounterexamples) {
|
||||
TRACE("str_fl", tout << "subsolver found UNSAT; constructing length counterexample" << std::endl;);
|
||||
TRACE(str_fl, tout << "subsolver found UNSAT; constructing length counterexample" << std::endl;);
|
||||
for (auto e : fixed_length_used_len_terms) {
|
||||
expr * var = &e.get_key();
|
||||
rational val = e.get_value();
|
||||
|
|
@ -1517,17 +1517,17 @@ namespace smt {
|
|||
}
|
||||
return l_false;
|
||||
} else {
|
||||
TRACE("str_fl", tout << "subsolver found UNSAT; reconstructing unsat core" << std::endl;);
|
||||
TRACE("str_fl", tout << "unsat core has size " << subsolver.get_unsat_core_size() << std::endl;);
|
||||
TRACE(str_fl, tout << "subsolver found UNSAT; reconstructing unsat core" << std::endl;);
|
||||
TRACE(str_fl, tout << "unsat core has size " << subsolver.get_unsat_core_size() << std::endl;);
|
||||
bool negate_pre = false;
|
||||
for (unsigned i = 0; i < subsolver.get_unsat_core_size(); ++i) {
|
||||
TRACE("str", tout << "entry " << i << " = " << mk_pp(subsolver.get_unsat_core_expr(i), m) << std::endl;);
|
||||
TRACE(str, tout << "entry " << i << " = " << mk_pp(subsolver.get_unsat_core_expr(i), m) << std::endl;);
|
||||
rational index;
|
||||
expr* lhs;
|
||||
expr* rhs;
|
||||
TRACE("str_fl", tout << fixed_length_lesson.size() << std::endl;);
|
||||
TRACE(str_fl, tout << fixed_length_lesson.size() << std::endl;);
|
||||
std::tie(index, lhs, rhs) = fixed_length_lesson.find(subsolver.get_unsat_core_expr(i));
|
||||
TRACE("str_fl", tout << "lesson: " << mk_pp(lhs, m) << " == " << mk_pp(rhs, m) << " at index " << index << std::endl;);
|
||||
TRACE(str_fl, tout << "lesson: " << mk_pp(lhs, m) << " == " << mk_pp(rhs, m) << " at index " << index << std::endl;);
|
||||
cex.push_back(refine(lhs, rhs, index));
|
||||
if (index < rational(0)) {
|
||||
negate_pre = true;
|
||||
|
|
@ -1541,7 +1541,7 @@ namespace smt {
|
|||
return l_false;
|
||||
}
|
||||
} else { // l_undef
|
||||
TRACE("str_fl", tout << "WARNING: subsolver found UNKNOWN" << std::endl;);
|
||||
TRACE(str_fl, tout << "WARNING: subsolver found UNKNOWN" << std::endl;);
|
||||
return l_undef;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue