mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-08-27 21:48:56 +00:00
Code Activity

Centralize and document TRACE tags using X-macros (#7657)

Browse source 
* 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 2025-05-28 22:31:25 +09:00 • committed by GitHub
parent d766292dab
commit 0a93ff515d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
583 changed files with 8698 additions and 7299 deletions
Download patch file Download diff file Expand all files Collapse all files

26
src/ast/rewriter/arith_rewriter.cpp
View file

@ -97,7 +97,7 @@ br_status arith_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * c
case OP_ARITH_LSHR: SASSERT(num_args == 2); st = mk_lshr_core(f->get_parameter(0).get_int(), args[0], args[1], result); break;
default: st = BR_FAILED; break;
}
CTRACE("arith_rewriter", st != BR_FAILED, tout << st << ": " << mk_pp(f, m);
CTRACE(arith_rewriter, st != BR_FAILED, tout << st << ": " << mk_pp(f, m);
for (unsigned i = 0; i < num_args; ++i) tout << mk_pp(args[i], m) << " ";
tout << "\n==>\n" << mk_pp(result.get(), m) << "\n";
if (is_app(result)) tout << "args: " << to_app(result)->get_num_args() << "\n";
@ -646,7 +646,7 @@ br_status arith_rewriter::mk_le_ge_eq_core(expr * arg1, expr * arg2, op_kind kin
(is_zero(arg2) && is_reduce_power_target(arg1, kind == EQ)))
return reduce_power(arg1, arg2, kind, result);
br_status st = cancel_monomials(arg1, arg2, m_arith_ineq_lhs || m_arith_lhs, new_arg1, new_arg2);
TRACE("mk_le_bug", tout << "st: " << st << " " << new_arg1 << " " << new_arg2 << "\n";);
TRACE(mk_le_bug, tout << "st: " << st << " " << new_arg1 << " " << new_arg2 << "\n";);
if (st != BR_FAILED) {
arg1 = new_arg1;
arg2 = new_arg2;
@ -656,7 +656,7 @@ br_status arith_rewriter::mk_le_ge_eq_core(expr * arg1, expr * arg2, op_kind kin
if (m_elim_to_real && elim_to_real(arg1, arg2, new_new_arg1, new_new_arg2)) {
arg1 = new_new_arg1;
arg2 = new_new_arg2;
CTRACE("elim_to_real", m_elim_to_real, tout << "after_elim_to_real\n" << mk_ismt2_pp(arg1, m) << "\n" << mk_ismt2_pp(arg2, m) << "\n";);
CTRACE(elim_to_real, m_elim_to_real, tout << "after_elim_to_real\n" << mk_ismt2_pp(arg1, m) << "\n" << mk_ismt2_pp(arg2, m) << "\n";);
if (st == BR_FAILED)
st = BR_DONE;
}
@ -697,10 +697,10 @@ br_status arith_rewriter::mk_le_ge_eq_core(expr * arg1, expr * arg2, op_kind kin
numeral g;
unsigned num_consts = 0;
get_coeffs_gcd(arg1, g, first, num_consts);
TRACE("arith_rewriter_gcd", tout << "[step1] g: " << g << ", num_consts: " << num_consts << "\n";);
TRACE(arith_rewriter_gcd, tout << "[step1] g: " << g << ", num_consts: " << num_consts << "\n";);
if ((first || !g.is_one()) && num_consts <= 1)
get_coeffs_gcd(arg2, g, first, num_consts);
TRACE("arith_rewriter_gcd", tout << "[step2] g: " << g << ", num_consts: " << num_consts << "\n";);
TRACE(arith_rewriter_gcd, tout << "[step2] g: " << g << ", num_consts: " << num_consts << "\n";);
g = abs(g);
if (!first && !g.is_one() && num_consts <= 1) {
bool is_sat = div_polynomial(arg1, g, (kind == LE ? CT_CEIL : (kind == GE ? CT_FLOOR : CT_FALSE)), new_arg1);
@ -1174,7 +1174,7 @@ br_status arith_rewriter::mk_div_core(expr * arg1, expr * arg2, expr_ref & resul
v2 = rational(1);
d = arg2;
}
TRACE("div_bug", tout << "v1: " << v1 << ", v2: " << v2 << "\n";);
TRACE(div_bug, tout << "v1: " << v1 << ", v2: " << v2 << "\n";);
if (!v1.is_one() || !v2.is_one()) {
v1 /= v2;
result = m_util.mk_mul(m_util.mk_numeral(v1, false),
@ -1238,7 +1238,7 @@ br_status arith_rewriter::mk_idiv_core(expr * arg1, expr * arg2, expr_ref & resu
if (change) {
result = m_util.mk_idiv(m.mk_app(to_app(arg1)->get_decl(), args.size(), args.data()), arg2);
result = m_util.mk_add(m_util.mk_numeral(add, true), result);
TRACE("div_bug", tout << "mk_div result: " << result << "\n";);
TRACE(div_bug, tout << "mk_div result: " << result << "\n";);
return BR_REWRITE3;
}
}
@ -1385,7 +1385,7 @@ br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & resul
// propagate mod inside only if there is something to reduce.
if (is_num2 && is_int && v2.is_pos() && (is_add(arg1) || is_mul(arg1))) {
TRACE("mod_bug", tout << "mk_mod:\n" << mk_ismt2_pp(arg1, m) << "\n" << mk_ismt2_pp(arg2, m) << "\n";);
TRACE(mod_bug, tout << "mk_mod:\n" << mk_ismt2_pp(arg1, m) << "\n" << mk_ismt2_pp(arg2, m) << "\n";);
expr_ref_buffer args(m);
bool change = false;
for (expr* arg : *to_app(arg1)) {
@ -1408,7 +1408,7 @@ br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & resul
}
if (change) {
result = m_util.mk_mod(m.mk_app(to_app(arg1)->get_decl(), args.size(), args.data()), arg2);
TRACE("mod_bug", tout << "mk_mod result: " << mk_ismt2_pp(result, m) << "\n";);
TRACE(mod_bug, tout << "mk_mod result: " << mk_ismt2_pp(result, m) << "\n";);
return BR_REWRITE3;
}
}
@ -1482,7 +1482,7 @@ br_status arith_rewriter::mk_rem_core(expr * arg1, expr * arg2, expr_ref & resul
result = m.mk_ite(m_util.mk_ge(arg2, m_util.mk_numeral(rational(0), true)),
mod,
m_util.mk_uminus(mod));
TRACE("elim_rem", tout << "result: " << mk_ismt2_pp(result, m) << "\n";);
TRACE(elim_rem, tout << "result: " << mk_ismt2_pp(result, m) << "\n";);
return BR_REWRITE3;
}
return BR_FAILED;
@ -1639,7 +1639,7 @@ br_status arith_rewriter::mk_power_core(expr * arg1, expr * arg2, expr_ref & res
bool is_num_y = m_util.is_numeral(arg2, y);
auto ensure_real = [&](expr* e) { return m_util.is_int(e) ? m_util.mk_to_real(e) : e; };
TRACE("arith", tout << mk_bounded_pp(arg1, m) << " " << mk_bounded_pp(arg2, m) << "\n";);
TRACE(arith, tout << mk_bounded_pp(arg1, m) << " " << mk_bounded_pp(arg2, m) << "\n";);
if (is_num_x && x.is_one()) {
result = m_util.mk_numeral(x, false);
return BR_DONE;
@ -1991,7 +1991,7 @@ bool arith_rewriter::is_pi_integer(expr * t) {
a = c;
b = d;
}
TRACE("tan", tout << "is_pi_integer " << mk_ismt2_pp(t, m) << "\n";
TRACE(tan, tout << "is_pi_integer " << mk_ismt2_pp(t, m) << "\n";
tout << "a: " << mk_ismt2_pp(a, m) << "\n";
tout << "b: " << mk_ismt2_pp(b, m) << "\n";);
return
@ -2022,7 +2022,7 @@ app * arith_rewriter::mk_sqrt(rational const & k) {
// Return 0 if failed.
expr * arith_rewriter::mk_sin_value(rational const & k) {
rational k_prime = mod(floor(k), rational(2)) + k - floor(k);
TRACE("sine", tout << "k: " << k << ", k_prime: " << k_prime << "\n";);
TRACE(sine, tout << "k: " << k << ", k_prime: " << k_prime << "\n";);
SASSERT(k_prime >= rational(0) && k_prime < rational(2));
bool neg = false;
if (k_prime >= rational(1)) {

6
src/ast/rewriter/array_rewriter.cpp
View file

@ -115,7 +115,7 @@ br_status array_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * c
st = BR_FAILED;
break;
}
CTRACE("array_rewriter", st != BR_FAILED,
CTRACE(array_rewriter, st != BR_FAILED,
tout << mk_pp(f, m()) << "\n";
for (unsigned i = 0; i < num_args; ++i) {
tout << mk_bounded_pp(args[i], m(), 2) << "\n";
@ -459,7 +459,7 @@ br_status array_rewriter::mk_map_core(func_decl * f, unsigned num_args, expr * c
sort_ref s = get_map_array_sort(f, num_args, args);
result = m_util.mk_const_array(s, value);
}
TRACE("array", tout << result << "\n";);
TRACE(array, tout << result << "\n";);
return BR_REWRITE2;
}
@ -819,7 +819,7 @@ expr_ref array_rewriter::expand_store(expr* s) {
}
br_status array_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & result) {
TRACE("array_rewriter", tout << mk_bounded_pp(lhs, m(), 2) << " " << mk_bounded_pp(rhs, m(), 2) << "\n";);
TRACE(array_rewriter, tout << mk_bounded_pp(lhs, m(), 2) << " " << mk_bounded_pp(rhs, m(), 2) << "\n";);
expr* v = nullptr, *w = nullptr;
if (m_util.is_const(rhs) && is_lambda(lhs)) {
std::swap(lhs, rhs);

8
src/ast/rewriter/bit2int.cpp
View file

@ -38,7 +38,7 @@ void bit2int::operator()(expr * n, expr_ref & result, proof_ref& p) {
// TBD: rough
p = m.mk_rewrite(n, result);
}
TRACE("bit2int",
TRACE(bit2int,
tout << mk_pp(n, m) << "======>\n" << result << "\n";);
}
@ -221,7 +221,7 @@ bool bit2int::is_bv_poly(expr* n, expr_ref& pos, expr_ref& neg) {
VERIFY(mk_add(arg1, neg, neg));
}
else {
TRACE("bit2int", tout << "Not a poly: " << mk_pp(n, m) << "\n";);
TRACE(bit2int, tout << "Not a poly: " << mk_pp(n, m) << "\n";);
return false;
}
}
@ -407,12 +407,12 @@ expr * bit2int::get_cached(expr * n) const {
expr* r = nullptr;
proof* p = nullptr;
const_cast<bit2int*>(this)->m_cache.get(n, r, p);
CTRACE("bit2int", !r, tout << mk_pp(n, m) << "\n";);
CTRACE(bit2int, !r, tout << mk_pp(n, m) << "\n";);
return r;
}
void bit2int::cache_result(expr * n, expr * r) {
TRACE("bit2int_verbose", tout << "caching:\n" << mk_pp(n, m) <<
TRACE(bit2int_verbose, tout << "caching:\n" << mk_pp(n, m) <<
"======>\n" << mk_ll_pp(r, m) << "\n";);
m_cache.insert(n, r, nullptr);
}

8
src/ast/rewriter/bit_blaster/bit_blaster.cpp
View file

@ -38,9 +38,9 @@ static void sort_args(expr * & l1, expr * & l2, expr * & l3) {
void bit_blaster_cfg::mk_xor3(expr * l1, expr * l2, expr * l3, expr_ref & r) {
TRACE("xor3", tout << "#" << l1->get_id() << " #" << l2->get_id() << " #" << l3->get_id(););
TRACE(xor3, tout << "#" << l1->get_id() << " #" << l2->get_id() << " #" << l3->get_id(););
sort_args(l1, l2, l3);
TRACE("xor3_sorted", tout << "#" << l1->get_id() << " #" << l2->get_id() << " #" << l3->get_id(););
TRACE(xor3_sorted, tout << "#" << l1->get_id() << " #" << l2->get_id() << " #" << l3->get_id(););
if (m_params.m_bb_ext_gates) {
if (l1 == l2)
r = l3;
@ -77,9 +77,9 @@ void bit_blaster_cfg::mk_xor3(expr * l1, expr * l2, expr * l3, expr_ref & r) {
}
void bit_blaster_cfg::mk_carry(expr * l1, expr * l2, expr * l3, expr_ref & r) {
TRACE("carry", tout << "#" << l1->get_id() << " #" << l2->get_id() << " #" << l3->get_id(););
TRACE(carry, tout << "#" << l1->get_id() << " #" << l2->get_id() << " #" << l3->get_id(););
sort_args(l1, l2, l3);
TRACE("carry_sorted", tout << "#" << l1->get_id() << " #" << l2->get_id() << " #" << l3->get_id(););
TRACE(carry_sorted, tout << "#" << l1->get_id() << " #" << l2->get_id() << " #" << l3->get_id(););
if (m_params.m_bb_ext_gates) {
if ((m().is_false(l1) && m().is_false(l2)) ||
(m().is_false(l1) && m().is_false(l3)) ||

4
src/ast/rewriter/bit_blaster/bit_blaster_rewriter.cpp
View file

@ -379,7 +379,7 @@ MK_PARAMETRIC_UNARY_REDUCE(reduce_sign_extend, mk_sign_extend);
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
result_pr = nullptr;
TRACE("bit_blaster", tout << f->get_name() << " ";
TRACE(bit_blaster, tout << f->get_name() << " ";
for (unsigned i = 0; i < num; ++i) tout << mk_pp(args[i], m()) << " ";
tout << "\n";);
if (num == 0 && f->get_family_id() == null_family_id && butil().is_bv_sort(f->get_range())) {
@ -552,7 +552,7 @@ MK_PARAMETRIC_UNARY_REDUCE(reduce_sign_extend, mk_sign_extend);
case OP_SBV2INT:
return BR_FAILED;
default:
TRACE("bit_blaster", tout << "non-supported operator: " << f->get_name() << "\n";
TRACE(bit_blaster, tout << "non-supported operator: " << f->get_name() << "\n";
for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m()) << std::endl;);
{
expr_ref r(m().mk_app(f, num, args), m());

4
src/ast/rewriter/bit_blaster/bit_blaster_tpl_def.h
View file

@ -425,7 +425,7 @@ void bit_blaster_tpl<Cfg>::mk_udiv_urem(unsigned sz, expr * const * a_bits, expr
for (unsigned i = 0; i < sz; i++) {
SASSERT(q_bits.get(i) != 0);
}});
TRACE("bit_blaster",
TRACE(bit_blaster,
tout << "a: ";
for (unsigned i = 0; i < sz; ++i) tout << mk_pp(a_bits[i], m()) << " ";
tout << "\nb: ";
@ -777,7 +777,7 @@ void bit_blaster_tpl<Cfg>::mk_eq(unsigned sz, expr * const * a_bits, expr * cons
template<typename Cfg>
void bit_blaster_tpl<Cfg>::mk_rotate_left(unsigned sz, expr * const * a_bits, unsigned n, expr_ref_vector & out_bits) {
TRACE("bit_blaster", tout << n << ": " << sz << " ";
TRACE(bit_blaster, tout << n << ": " << sz << " ";
for (unsigned i = 0; i < sz; ++i) {
tout << mk_pp(a_bits[i], m()) << " ";
}

4
src/ast/rewriter/bool_rewriter.cpp
View file

@ -769,12 +769,12 @@ br_status bool_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & result) {
expr* c2, * t2, * e2;
if (m().is_ite(lhs) && m().is_value(rhs)) {
r = try_ite_value(to_app(lhs), to_app(rhs), result);
CTRACE("try_ite_value", r != BR_FAILED,
CTRACE(try_ite_value, r != BR_FAILED,
tout << mk_bounded_pp(lhs, m()) << "\n" << mk_bounded_pp(rhs, m()) << "\n--->\n" << mk_bounded_pp(result, m()) << "\n";);
}
else if (m().is_ite(rhs) && m().is_value(lhs)) {
r = try_ite_value(to_app(rhs), to_app(lhs), result);
CTRACE("try_ite_value", r != BR_FAILED,
CTRACE(try_ite_value, r != BR_FAILED,
tout << mk_bounded_pp(lhs, m()) << "\n" << mk_bounded_pp(rhs, m()) << "\n--->\n" << mk_bounded_pp(result, m()) << "\n";);
}
else if (m().is_ite(lhs, c1, t1, e1) && m().is_ite(rhs, c2, t2, e2) &&

2
src/ast/rewriter/bv2int_translator.cpp
View file

@ -687,7 +687,7 @@ void bv2int_translator::translate_eq(expr* e) {
set_translated(e, m.mk_eq(umod(x, 0), a.mk_int(0)));
}
m_preds.push_back(e);
TRACE("bv", tout << mk_pp(e, m) << " " << mk_pp(translated(e), m) << "\n");
TRACE(bv, tout << mk_pp(e, m) << " " << mk_pp(translated(e), m) << "\n");
ctx.push(push_back_vector(m_preds));
}

42
src/ast/rewriter/bv_bounds.cpp
View file

@ -22,7 +22,7 @@ bv_bounds::~bv_bounds() {
}
bv_bounds::conv_res bv_bounds::record(app * v, numeral lo, numeral hi, bool negated, vector<ninterval>& nis) {
TRACE("bv_bounds", tout << "record0 " << mk_ismt2_pp(v, m_m) << ":" << (negated ? "~[" : "[") << lo << ";" << hi << "]" << std::endl;);
TRACE(bv_bounds, tout << "record0 " << mk_ismt2_pp(v, m_m) << ":" << (negated ? "~[" : "[") << lo << ";" << hi << "]" << std::endl;);
const unsigned bv_sz = m_bv_util.get_bv_size(v);
const numeral& one = numeral::one();
SASSERT(numeral::zero() <= lo);
@ -54,7 +54,7 @@ bv_bounds::conv_res bv_bounds::record(app * v, numeral lo, numeral hi, bool nega
}
if (lo_min) lo = vmin;
if (hi_max) hi = vmax;
TRACE("bv_bounds", tout << "record1 " << mk_ismt2_pp(v, m_m) << ":" << (negated ? "~[" : "[") << lo << ";" << hi << "]" << std::endl;);
TRACE(bv_bounds, tout << "record1 " << mk_ismt2_pp(v, m_m) << ":" << (negated ? "~[" : "[") << lo << ";" << hi << "]" << std::endl;);
if (lo > hi) return negated ? CONVERTED : UNSAT;
if (lo_min && hi_max) return negated ? UNSAT : CONVERTED;
nis.resize(nis.size() + 1);
@ -100,7 +100,7 @@ bool bv_bounds::is_uleq(expr * e, expr * & v, numeral & c) {
}
bv_bounds::conv_res bv_bounds::convert(expr * e, vector<ninterval>& nis, bool negated) {
TRACE("bv_bounds", tout << "new constraint: " << (negated ? "~" : "" ) << mk_ismt2_pp(e, m_m) << std::endl;);
TRACE(bv_bounds, tout << "new constraint: " << (negated ? "~" : "" ) << mk_ismt2_pp(e, m_m) << std::endl;);
if (m_m.is_not(e)) {
negated = !negated;
@ -281,9 +281,9 @@ br_status bv_bounds::rewrite(unsigned limit, func_decl * f, unsigned num, expr *
expr_ref_vector nargs(m_m);
bool has_singls = false;
for (unsigned i = 0; i < num && m_okay; ++i) {
TRACE("bv_bounds", tout << "check red: " << mk_ismt2_pp(args[i], m_m) << std::endl;);
TRACE(bv_bounds, tout << "check red: " << mk_ismt2_pp(args[i], m_m) << std::endl;);
if (ignore[i]) {
TRACE("bv_bounds", tout << "unprocessed" << std::endl;);
TRACE(bv_bounds, tout << "unprocessed" << std::endl;);
nargs.push_back(args[i]);
continue;
}
@ -299,13 +299,13 @@ br_status bv_bounds::rewrite(unsigned limit, func_decl * f, unsigned num, expr *
const numeral& one = numeral::one();
if (!has_lower) tl = numeral::zero();
if (!has_upper) th = (numeral::power_of_two(bv_sz) - one);
TRACE("bv_bounds", tout << "bounds: " << mk_ismt2_pp(v, m_m) << "[" << tl << "-" << th << "]" << std::endl;);
TRACE(bv_bounds, tout << "bounds: " << mk_ismt2_pp(v, m_m) << "[" << tl << "-" << th << "]" << std::endl;);
is_singl = tl == th;
nis_head = lengths[count];
}
if (!redundant && !is_singl) nargs.push_back(args[i]);
has_singls |= is_singl;
CTRACE("bv_bounds", redundant, tout << "redundant: " << mk_ismt2_pp(args[i], m_m) << std::endl;);
CTRACE(bv_bounds, redundant, tout << "redundant: " << mk_ismt2_pp(args[i], m_m) << std::endl;);
++count;
}
@ -330,7 +330,7 @@ br_status bv_bounds::rewrite(unsigned limit, func_decl * f, unsigned num, expr *
}
bool bv_bounds::add_constraint(expr* e) {
TRACE("bv_bounds", tout << "new constraint" << mk_ismt2_pp(e, m_m) << std::endl;);
TRACE(bv_bounds, tout << "new constraint" << mk_ismt2_pp(e, m_m) << std::endl;);
if (!m_okay) return false;
bool negated = false;
@ -450,7 +450,7 @@ bool bv_bounds::add_constraint(expr* e) {
}
bool bv_bounds::add_bound_unsigned(app * v, const numeral& a, const numeral& b, bool negate) {
TRACE("bv_bounds", tout << "bound_unsigned " << mk_ismt2_pp(v, m_m) << ": " << (negate ? "~[" : "[") << a << ";" << b << "]" << std::endl;);
TRACE(bv_bounds, tout << "bound_unsigned " << mk_ismt2_pp(v, m_m) << ": " << (negate ? "~[" : "[") << a << ";" << b << "]" << std::endl;);
const unsigned bv_sz = m_bv_util.get_bv_size(v);
const numeral& zero = numeral::zero();
const numeral& one = numeral::one();
@ -473,7 +473,7 @@ bool bv_bounds::add_bound_unsigned(app * v, const numeral& a, const numeral& b,
}
bv_bounds::conv_res bv_bounds::convert_signed(app * v, const numeral& a, const numeral& b, bool negate, vector<ninterval>& nis) {
TRACE("bv_bounds", tout << "convert_signed " << mk_ismt2_pp(v, m_m) << ":" << (negate ? "~[" : "[") << a << ";" << b << "]" << std::endl;);
TRACE(bv_bounds, tout << "convert_signed " << mk_ismt2_pp(v, m_m) << ":" << (negate ? "~[" : "[") << a << ";" << b << "]" << std::endl;);
const unsigned bv_sz = m_bv_util.get_bv_size(v);
SASSERT(a <= b);
const numeral& zero = numeral::zero();
@ -497,7 +497,7 @@ bv_bounds::conv_res bv_bounds::convert_signed(app * v, const numeral& a, const n
}
bool bv_bounds::add_bound_signed(app * v, const numeral& a, const numeral& b, bool negate) {
TRACE("bv_bounds", tout << "bound_signed " << mk_ismt2_pp(v, m_m) << ":" << (negate ? "~" : " ") << a << ";" << b << std::endl;);
TRACE(bv_bounds, tout << "bound_signed " << mk_ismt2_pp(v, m_m) << ":" << (negate ? "~" : " ") << a << ";" << b << std::endl;);
const unsigned bv_sz = m_bv_util.get_bv_size(v);
SASSERT(a <= b);
const numeral& zero = numeral::zero();
@ -521,7 +521,7 @@ bool bv_bounds::add_bound_signed(app * v, const numeral& a, const numeral& b, bo
bool bv_bounds::bound_lo(app * v, const numeral& l) {
SASSERT(in_range(v, l));
TRACE("bv_bounds", tout << "lower " << mk_ismt2_pp(v, m_m) << ":" << l << std::endl;);
TRACE(bv_bounds, tout << "lower " << mk_ismt2_pp(v, m_m) << ":" << l << std::endl;);
// l <= v
auto& value = m_unsigned_lowers.insert_if_not_there(v, l);
if (!(value < l)) return m_okay;
@ -532,7 +532,7 @@ bool bv_bounds::bound_lo(app * v, const numeral& l) {
bool bv_bounds::bound_up(app * v, const numeral& u) {
SASSERT(in_range(v, u));
TRACE("bv_bounds", tout << "upper " << mk_ismt2_pp(v, m_m) << ":" << u << std::endl;);
TRACE(bv_bounds, tout << "upper " << mk_ismt2_pp(v, m_m) << ":" << u << std::endl;);
// v <= u
auto& value = m_unsigned_uppers.insert_if_not_there(v, u);
if (!(u < value)) return m_okay;
@ -542,7 +542,7 @@ bool bv_bounds::bound_up(app * v, const numeral& u) {
}
bool bv_bounds::add_neg_bound(app * v, const numeral& a, const numeral& b) {
TRACE("bv_bounds", tout << "negative bound " << mk_ismt2_pp(v, m_m) << ":" << a << ";" << b << std::endl;);
TRACE(bv_bounds, tout << "negative bound " << mk_ismt2_pp(v, m_m) << ":" << a << ";" << b << std::endl;);
bv_bounds::interval negative_interval(a, b);
SASSERT(m_bv_util.is_bv(v));
SASSERT(a >= numeral::zero());
@ -597,15 +597,15 @@ struct interval_comp_t {
void bv_bounds::record_singleton(app * v, numeral& singleton_value) {
TRACE("bv_bounds", tout << "singleton:" << mk_ismt2_pp(v, m_m) << ":" << singleton_value << std::endl;);
TRACE(bv_bounds, tout << "singleton:" << mk_ismt2_pp(v, m_m) << ":" << singleton_value << std::endl;);
SASSERT(!m_singletons.find(v, singleton_value));
m_singletons.insert(v, singleton_value);
}
bool bv_bounds::is_sat(app * v) {
TRACE("bv_bounds", tout << "is_sat " << mk_ismt2_pp(v, m_m) << std::endl;);
TRACE(bv_bounds, tout << "is_sat " << mk_ismt2_pp(v, m_m) << std::endl;);
const bool rv = is_sat_core(v);
TRACE("bv_bounds", tout << "is_sat " << mk_ismt2_pp(v, m_m) << "\nres: " << rv << std::endl;);
TRACE(bv_bounds, tout << "is_sat " << mk_ismt2_pp(v, m_m) << "\nres: " << rv << std::endl;);
return rv;
}
@ -620,7 +620,7 @@ bool bv_bounds::is_sat_core(app * v) {
const numeral& one = numeral::one();
if (!has_lower) lower = numeral::zero();
if (!has_upper) upper = (numeral::power_of_two(bv_sz) - one);
TRACE("bv_bounds", tout << "is_sat bound:" << lower << "-" << upper << std::endl;);
TRACE(bv_bounds, tout << "is_sat bound:" << lower << "-" << upper << std::endl;);
intervals * negative_intervals(nullptr);
const bool has_neg_intervals = m_negative_intervals.find(v, negative_intervals);
bool is_sat(false);
@ -641,9 +641,9 @@ bool bv_bounds::is_sat_core(app * v) {
if (new_hi > upper) new_hi = upper;
is_sat = true;
}
TRACE("bv_bounds", tout << "is_sat new_lo, new_hi:" << new_lo << "-" << new_hi << std::endl;);
TRACE(bv_bounds, tout << "is_sat new_lo, new_hi:" << new_lo << "-" << new_hi << std::endl;);
ptr = negative_upper + one;
TRACE("bv_bounds", tout << "is_sat ptr, new_hi:" << ptr << "-" << new_hi << std::endl;);
TRACE(bv_bounds, tout << "is_sat ptr, new_hi:" << ptr << "-" << new_hi << std::endl;);
if (ptr > upper) break;
}
}
@ -655,7 +655,7 @@ bool bv_bounds::is_sat_core(app * v) {
}
if (new_hi < upper) bound_up(v, new_hi);
if (new_lo > lower) bound_lo(v, new_lo);
TRACE("bv_bounds", tout << "is_sat new_lo, new_hi:" << new_lo << "-" << new_hi << std::endl;);
TRACE(bv_bounds, tout << "is_sat new_lo, new_hi:" << new_lo << "-" << new_hi << std::endl;);
const bool is_singleton = is_sat && new_hi == new_lo;
if (is_singleton) record_singleton(v, new_lo);

10
src/ast/rewriter/bv_bounds_base.h
View file

@ -125,7 +125,7 @@ namespace bv {
if (sign && !b.negate(b))
return false;
TRACE("bv", tout << (sign?"(not ":"") << mk_pp(t, m) << (sign ? ")" : "") << ": " << mk_pp(t1, m) << " in " << b << "\n";);
TRACE(bv, tout << (sign?"(not ":"") << mk_pp(t, m) << (sign ? ")" : "") << ": " << mk_pp(t1, m) << " in " << b << "\n";);
map::obj_map_entry* e = m_bound.find_core(t1);
if (e) {
interval& old = e->get_data().m_value;
@ -202,7 +202,7 @@ namespace bv {
if (simplified) {
result = m.mk_app(to_app(t)->get_decl(), m_args);
TRACE("bv", tout << mk_pp(t, m) << " -> " << result << "\n");
TRACE(bv, tout << mk_pp(t, m) << " -> " << result << "\n");
return true;
}
@ -255,10 +255,10 @@ namespace bv {
else if (false && intr != b)
result = mk_bound(t1, intr.lo(), intr.hi());
else {
TRACE("bv", tout << mk_pp(t, m) << " b: " << b << " ctx: " << ctx << " intr " << intr << "\n");
TRACE(bv, tout << mk_pp(t, m) << " b: " << b << " ctx: " << ctx << " intr " << intr << "\n");
}
CTRACE("bv", result, tout << mk_pp(t, m) << " " << b << " (ctx: " << ctx << ") (intr: " << intr << "): " << result << "\n";);
CTRACE(bv, result, tout << mk_pp(t, m) << " " << b << " (ctx: " << ctx << ") (intr: " << intr << "): " << result << "\n";);
if (sign && result)
result = m.mk_not(result);
return result != nullptr;
@ -325,7 +325,7 @@ namespace bv {
}
void pop_core(unsigned num_scopes) {
TRACE("bv", tout << "pop: " << num_scopes << "\n";);
TRACE(bv, tout << "pop: " << num_scopes << "\n";);
if (m_scopes.empty())
return;
unsigned target = m_scopes.size() - num_scopes;

24
src/ast/rewriter/bv_rewriter.cpp
View file

@ -244,7 +244,7 @@ br_status bv_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * cons
return BR_FAILED;
}
CTRACE("bv_verbose", st != BR_FAILED, tout << mk_pp(f, m) << "\n";
CTRACE(bv_verbose, st != BR_FAILED, tout << mk_pp(f, m) << "\n";
for (unsigned i = 0; i < num_args; ++i)
tout << " " << mk_bounded_pp(args[i], m) << "\n";
tout << mk_bounded_pp(result, m, 3) << "\n");
@ -570,7 +570,7 @@ br_status bv_rewriter::mk_leq_core(bool is_signed, expr * a, expr * b, expr_ref
if (m_le_extra) {
const br_status cst = rw_leq_concats(is_signed, a, b, result);
if (cst != BR_FAILED) {
TRACE("le_extra", tout << (is_signed ? "bv_sle\n" : "bv_ule\n")
TRACE(le_extra, tout << (is_signed ? "bv_sle\n" : "bv_ule\n")
<< mk_pp(a, m, 2) << "\n" << mk_pp(b, m, 2) << "\n--->\n"<< mk_pp(result, m, 2) << "\n";);
return cst;
}
@ -579,7 +579,7 @@ br_status bv_rewriter::mk_leq_core(bool is_signed, expr * a, expr * b, expr_ref
if (m_le_extra) {
const br_status cst = rw_leq_overflow(is_signed, a, b, result);
if (cst != BR_FAILED) {
TRACE("le_extra", tout << (is_signed ? "bv_sle\n" : "bv_ule\n")
TRACE(le_extra, tout << (is_signed ? "bv_sle\n" : "bv_ule\n")
<< mk_pp(a, m, 2) << "\n" << mk_pp(b, m, 2) << "\n--->\n"<< mk_pp(result, m, 2) << "\n";);
return cst;
}
@ -857,7 +857,7 @@ br_status bv_rewriter::mk_extract(unsigned high, unsigned low, expr * arg, expr_
const unsigned ep_rm = propagate_extract(high, arg, ep_res);
if (ep_rm != 0) {
result = m_mk_extract(high, low, ep_res);
TRACE("extract_prop", tout << mk_pp(arg, m) << "\n[" << high <<"," << low << "]\n" << ep_rm << "---->\n"
TRACE(extract_prop, tout << mk_pp(arg, m) << "\n[" << high <<"," << low << "]\n" << ep_rm << "---->\n"
<< mk_pp(result.get(), m) << "\n";);
return BR_REWRITE2;
}
@ -1158,7 +1158,7 @@ br_status bv_rewriter::mk_bv_udiv_core(expr * arg1, expr * arg2, bool hi_div0, e
numeral r1, r2;
unsigned bv_size;
TRACE("bv_udiv", tout << "hi_div0: " << hi_div0 << "\n";);
TRACE(bv_udiv, tout << "hi_div0: " << hi_div0 << "\n";);
if (is_numeral(arg2, r2, bv_size)) {
r2 = m_util.norm(r2, bv_size);
@ -1207,7 +1207,7 @@ br_status bv_rewriter::mk_bv_udiv_core(expr * arg1, expr * arg2, bool hi_div0, e
m_util.mk_bv_udiv0(arg1),
m_util.mk_bv_udiv_i(arg1, arg2));
TRACE("bv_udiv", tout << mk_pp(arg1, m) << "\n" << mk_pp(arg2, m) << "\n---->\n" << mk_pp(result, m) << "\n";);
TRACE(bv_udiv, tout << mk_pp(arg1, m) << "\n" << mk_pp(arg2, m) << "\n---->\n" << mk_pp(result, m) << "\n";);
return BR_REWRITE2;
}
@ -1903,7 +1903,7 @@ br_status bv_rewriter::mk_bv_or(unsigned num, expr * const * args, expr_ref & re
}
std::reverse(exs.begin(), exs.end());
result = m_util.mk_concat(exs.size(), exs.data());
TRACE("mask_bug",
TRACE(mask_bug,
tout << "(assert (distinct (bvor (_ bv" << old_v1 << " " << sz << ")\n" << mk_pp(t, m) << ")\n";
tout << mk_pp(result, m) << "))\n";);
return BR_REWRITE2;
@ -2317,7 +2317,7 @@ br_status bv_rewriter::mk_bv_comp(expr * arg1, expr * arg2, expr_ref & result) {
br_status bv_rewriter::mk_bv_add(unsigned num_args, expr * const * args, expr_ref & result) {
br_status st = mk_add_core(num_args, args, result);
if (st != BR_FAILED && st != BR_DONE) {
TRACE("bv", tout << result << "\n";);
TRACE(bv, tout << result << "\n";);
return st;
}
#if 0
@ -2575,7 +2575,7 @@ br_status bv_rewriter::mk_blast_eq_value(expr * lhs, expr * rhs, expr_ref & resu
unsigned sz = get_bv_size(lhs);
if (sz == 1)
return BR_FAILED;
TRACE("blast_eq_value", tout << "sz: " << sz << "\n" << mk_pp(lhs, m) << "\n";);
TRACE(blast_eq_value, tout << "sz: " << sz << "\n" << mk_pp(lhs, m) << "\n";);
if (is_numeral(lhs))
std::swap(lhs, rhs);
@ -2869,13 +2869,13 @@ br_status bv_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & result) {
st = mk_mul_eq(lhs, rhs, result);
if (st != BR_FAILED) {
TRACE("mk_mul_eq", tout << mk_pp(lhs, m) << "\n=\n" << mk_pp(rhs, m) << "\n----->\n" << mk_pp(result,m) << "\n";);
TRACE(mk_mul_eq, tout << mk_pp(lhs, m) << "\n=\n" << mk_pp(rhs, m) << "\n----->\n" << mk_pp(result,m) << "\n";);
return st;
}
st = mk_mul_eq(rhs, lhs, result);
if (st != BR_FAILED) {
TRACE("mk_mul_eq", tout << mk_pp(lhs, m) << "\n=\n" << mk_pp(rhs, m) << "\n----->\n" << mk_pp(result,m) << "\n";);
TRACE(mk_mul_eq, tout << mk_pp(lhs, m) << "\n=\n" << mk_pp(rhs, m) << "\n----->\n" << mk_pp(result,m) << "\n";);
return st;
}
@ -2992,7 +2992,7 @@ bool bv_rewriter::is_eq_bit(expr * t, expr * & x, unsigned & val) {
br_status bv_rewriter::mk_ite_core(expr * c, expr * t, expr * e, expr_ref & result) {
TRACE("bv_ite", tout << "mk_ite_core:\n" << mk_pp(c, m) << "?\n"
TRACE(bv_ite, tout << "mk_ite_core:\n" << mk_pp(c, m) << "?\n"
<< mk_pp(t, m) << "\n:" << mk_pp(e, m) << "\n";);
if (m.are_equal(t, e)) {
result = e;

2
src/ast/rewriter/cached_var_subst.cpp
View file

@ -65,7 +65,7 @@ expr_ref cached_var_subst::operator()() {
// entry was already there
m_new_keys[num_bindings] = m_key; // recycle key
result = entry->get_data().m_value;
SCTRACE("bindings", is_trace_enabled("coming_from_quant"), tout << "(cache)\n";
SCTRACE(bindings, is_trace_enabled(TraceTag::coming_from_quant), tout << "(cache)\n";
for (unsigned i = 0; i < num_bindings; i++)
if (m_key->m_bindings[i])
tout << i << ": " << mk_ismt2_pp(m_key->m_bindings[i], result.m()) << ";\n";

14
src/ast/rewriter/der.cpp
View file

@ -48,7 +48,7 @@ bool der::is_var_diseq(expr * e, unsigned num_decls, var * & v, expr_ref & t) {
auto set_result = [&](var *w, expr* s) {
v = w;
t = s;
TRACE("der", tout << mk_pp(e, m) << "\n";);
TRACE(der, tout << mk_pp(e, m) << "\n";);
return true;
};
@ -97,7 +97,7 @@ bool der::is_var_eq(expr* e, unsigned num_decls, var*& v, expr_ref& t) {
auto set_result = [&](var* w, expr* s) {
v = w;
t = s;
TRACE("der", tout << mk_pp(e, m) << "\n";);
TRACE(der, tout << mk_pp(e, m) << "\n";);
return true;
};
@ -137,7 +137,7 @@ void der::operator()(quantifier * q, expr_ref & r, proof_ref & pr) {
pr = nullptr;
r = q;
TRACE("der", tout << mk_pp(q, m) << "\n";);
TRACE(der, tout << mk_pp(q, m) << "\n";);
auto k = q->get_kind();
// Keep applying it until r doesn't change anymore
@ -226,7 +226,7 @@ void der::reduce1(quantifier * q, expr_ref & r, proof_ref & pr) {
}
}
else {
TRACE("der_bug", tout << "Did not find any diseq\n" << mk_pp(q, m) << "\n";);
TRACE(der_bug, tout << "Did not find any diseq\n" << mk_pp(q, m) << "\n";);
r = q;
}
}
@ -282,7 +282,7 @@ static void der_sort_vars(ptr_vector<var> & vars, expr_ref_vector & definitions,
case AST_VAR:
vidx = to_var(t)->get_idx();
if (fr.second == 0) {
CTRACE("der_bug", vidx >= definitions.size(), tout << "vidx: " << vidx << "\n";);
CTRACE(der_bug, vidx >= definitions.size(), tout << "vidx: " << vidx << "\n";);
// Remark: The size of definitions may be smaller than the number of variables occurring in the quantified formula.
if (definitions.get(vidx, nullptr) != nullptr) {
if (visiting.is_marked(t)) {
@ -341,7 +341,7 @@ static void der_sort_vars(ptr_vector<var> & vars, expr_ref_vector & definitions,
void der::get_elimination_order() {
m_order.reset();
TRACE("top_sort",
TRACE(top_sort,
tout << "DEFINITIONS: " << std::endl;
unsigned i = 0;
for (expr* e : m_map) {
@ -353,7 +353,7 @@ void der::get_elimination_order() {
// der::top_sort ts(m);
der_sort_vars(m_inx2var, m_map, m_order);
TRACE("der",
TRACE(der,
tout << "Elimination m_order:" << "\n";
tout << m_order << "\n";);
}

2
src/ast/rewriter/distribute_forall.cpp
View file

@ -155,7 +155,7 @@ void distribute_forall::operator()(expr * f, expr_ref & result) {
result = get_cached(f);
SASSERT(result!=0);
TRACE("distribute_forall", tout << mk_ll_pp(f, m_manager) << "======>\n"
TRACE(distribute_forall, tout << mk_ll_pp(f, m_manager) << "======>\n"
<< mk_ll_pp(result, m_manager););
}

12
src/ast/rewriter/dom_simplifier.cpp
View file

@ -90,7 +90,7 @@ bool expr_dominators::compute_dominators() {
unsigned iterations = 1;
while (change) {
change = false;
TRACE("simplify",
TRACE(simplify,
for (auto & kv : m_doms) {
tout << mk_bounded_pp(kv.m_key, m) << " |-> " << mk_bounded_pp(kv.m_value, m) << "\n";
});
@ -135,7 +135,7 @@ bool expr_dominators::compile(expr * e) {
compute_post_order();
if (!compute_dominators()) return false;
extract_tree();
TRACE("simplify", display(tout););
TRACE(simplify, display(tout););
return true;
}
@ -263,7 +263,7 @@ public:
if (m.is_true(t))
return !sign;
TRACE("simplify", tout << t->get_id() << ": " << mk_bounded_pp(t, m) << " " << (sign?" - neg":" - pos") << "\n";);
TRACE(simplify, tout << t->get_id() << ": " << mk_bounded_pp(t, m) << " " << (sign?" - neg":" - pos") << "\n";);
m_scoped_substitution.push();
if (!sign) {
@ -284,16 +284,16 @@ public:
m_trail.push_back(lhs);
m_trail.push_back(rhs);
if (is_gt(lhs, rhs)) {
TRACE("propagate_values", tout << "insert " << mk_pp(lhs, m) << " -> " << mk_pp(rhs, m) << "\n";);
TRACE(propagate_values, tout << "insert " << mk_pp(lhs, m) << " -> " << mk_pp(rhs, m) << "\n";);
m_scoped_substitution.insert(lhs, rhs, pr);
return;
}
if (is_gt(rhs, lhs)) {
TRACE("propagate_values", tout << "insert " << mk_pp(rhs, m) << " -> " << mk_pp(lhs, m) << "\n";);
TRACE(propagate_values, tout << "insert " << mk_pp(rhs, m) << " -> " << mk_pp(lhs, m) << "\n";);
m_scoped_substitution.insert(rhs, lhs, m.mk_symmetry(pr));
return;
}
TRACE("propagate_values", tout << "incompatible " << mk_pp(n, m) << "\n";);
TRACE(propagate_values, tout << "incompatible " << mk_pp(n, m) << "\n";);
}
if (m.is_not(n, n1)) {
m_scoped_substitution.insert(n1, m.mk_false(), m.mk_iff_false(pr));

8
src/ast/rewriter/elim_bounds.cpp
View file

@ -151,14 +151,14 @@ bool elim_bounds_cfg::reduce_quantifier(quantifier * q,
}
}
}
TRACE("elim_bounds", tout << "candidates:\n"; for (unsigned i = 0; i < candidates.size(); i++) tout << mk_pp(candidates[i], m) << "\n";);
TRACE(elim_bounds, tout << "candidates:\n"; for (unsigned i = 0; i < candidates.size(); i++) tout << mk_pp(candidates[i], m) << "\n";);
// remove candidates that have lower and upper bounds
for (var * v : candidates) {
if (lowers.contains(v) && uppers.contains(v))
candidate_set.erase(v);
}
TRACE("elim_bounds", tout << "candidates after filter:\n"; for (unsigned i = 0; i < candidates.size(); i++) tout << mk_pp(candidates[i], m) << "\n";);
TRACE(elim_bounds, tout << "candidates after filter:\n"; for (unsigned i = 0; i < candidates.size(); i++) tout << mk_pp(candidates[i], m) << "\n";);
if (candidate_set.empty()) {
return false;
}
@ -182,7 +182,7 @@ bool elim_bounds_cfg::reduce_quantifier(quantifier * q,
case 0:
result = m.mk_false();
result_pr = m.mk_rewrite(q, result);
TRACE("elim_bounds", tout << mk_pp(q, m) << "\n" << result << "\n";);
TRACE(elim_bounds, tout << mk_pp(q, m) << "\n" << result << "\n";);
return true;
case 1:
new_body = atoms[0];
@ -195,7 +195,7 @@ bool elim_bounds_cfg::reduce_quantifier(quantifier * q,
new_q = m.update_quantifier(q, new_body);
result = elim_unused_vars(m, new_q, params_ref());
result_pr = m.mk_rewrite(q, result);
TRACE("elim_bounds", tout << mk_pp(q, m) << "\n" << result << "\n";);
TRACE(elim_bounds, tout << mk_pp(q, m) << "\n" << result << "\n";);
return true;
}

2
src/ast/rewriter/factor_equivs.cpp
View file

@ -86,7 +86,7 @@ expr *choose_rep(expr_equiv_class::eq_class &clazz, ast_manager &m) {
}
}
}
TRACE("equiv",
TRACE(equiv,
tout << "Rep: " << mk_pp(rep, m) << "\n";
for (expr *el : clazz)
tout << mk_pp(el, m) << "\n";

18
src/ast/rewriter/factor_rewriter.cpp
View file

@ -53,7 +53,7 @@ br_status factor_rewriter::mk_eq(expr * arg1, expr * arg2, expr_ref & result) {
return BR_DONE;
}
if (!extract_factors()) {
TRACE("factor_rewriter", tout << mk_pp(arg1, m()) << " = " << mk_pp(arg2, m()) << "\n";);
TRACE(factor_rewriter, tout << mk_pp(arg1, m()) << " = " << mk_pp(arg2, m()) << "\n";);
return BR_FAILED;
}
powers_t::iterator it = m_powers.begin(), end = m_powers.end();
@ -74,7 +74,7 @@ br_status factor_rewriter::mk_le(expr * arg1, expr * arg2, expr_ref & result) {
return BR_DONE;
}
if (!extract_factors()) {
TRACE("factor_rewriter", tout << mk_pp(arg1, m()) << " <= " << mk_pp(arg2, m()) << "\n";);
TRACE(factor_rewriter, tout << mk_pp(arg1, m()) << " <= " << mk_pp(arg2, m()) << "\n";);
return BR_FAILED;
}
@ -87,7 +87,7 @@ br_status factor_rewriter::mk_le(expr * arg1, expr * arg2, expr_ref & result) {
mk_is_negative(neg, eqs);
eqs.push_back(neg);
result = m().mk_or(eqs.size(), eqs.data());
TRACE("factor_rewriter",
TRACE(factor_rewriter,
tout << mk_pp(arg1, m()) << " <= " << mk_pp(arg2, m()) << "\n";
tout << mk_pp(result.get(), m()) << "\n";);
return BR_DONE;
@ -101,7 +101,7 @@ br_status factor_rewriter::mk_lt(expr * arg1, expr * arg2, expr_ref & result) {
return BR_DONE;
}
if (!extract_factors()) {
TRACE("factor_rewriter", tout << mk_pp(arg1, m()) << " < " << mk_pp(arg2, m()) << "\n";);
TRACE(factor_rewriter, tout << mk_pp(arg1, m()) << " < " << mk_pp(arg2, m()) << "\n";);
return BR_FAILED;
}
// a^2 * b^3 * c < 0 ->
@ -116,7 +116,7 @@ br_status factor_rewriter::mk_lt(expr * arg1, expr * arg2, expr_ref & result) {
}
eqs.push_back(neg);
result = m().mk_and(eqs.size(), eqs.data());
TRACE("factor_rewriter", tout << mk_pp(result.get(), m()) << "\n";);
TRACE(factor_rewriter, tout << mk_pp(result.get(), m()) << "\n";);
return BR_DONE;
}
@ -163,7 +163,7 @@ void factor_rewriter::mk_adds(expr* arg1, expr* arg2) {
bool sign = m_adds[i].second;
expr* _e = m_adds[i].first;
TRACE("factor_rewriter", tout << i << " " << mk_pp(_e, m_manager) << "\n";);
TRACE(factor_rewriter, tout << i << " " << mk_pp(_e, m_manager) << "\n";);
if (!is_app(_e)) {
++i;
@ -195,7 +195,7 @@ void factor_rewriter::mk_adds(expr* arg1, expr* arg2) {
++i;
}
}
TRACE("factor_rewriter",
TRACE(factor_rewriter,
for (unsigned i = 0; i < m_adds.size(); ++i) {
if (!m_adds[i].second) tout << "-"; else tout << "+";
tout << mk_pp(m_adds[i].first, m()) << " ";
@ -216,7 +216,7 @@ void factor_rewriter::mk_muls() {
--i;
}
}
TRACE("factor_rewriter",
TRACE(factor_rewriter,
for (unsigned i = 0; i < m_muls.size(); ++i) {
for (unsigned j = 0; j < m_muls[i].size(); ++j) {
tout << mk_pp(m_muls[i][j], m()) << " ";
@ -329,7 +329,7 @@ bool factor_rewriter::extract_factors() {
m_factors.push_back(a().mk_add(trail.size(), trail.data()));
break;
}
TRACE("factor_rewriter",
TRACE(factor_rewriter,
for (unsigned i = 0; i < m_factors.size(); ++i) {
tout << mk_pp(m_factors[i].get(), m()) << " ";
}

26
src/ast/rewriter/fpa_rewriter.cpp
View file

@ -143,7 +143,7 @@ br_status fpa_rewriter::mk_to_fp(func_decl * f, unsigned num_args, expr * const
mpf_exp = m_fm.unbias_exp(ebits, mpf_exp);
m_fm.set(v, ebits, sbits, !mpzm.is_zero(z), mpf_exp, sig);
TRACE("fp_rewriter",
TRACE(fp_rewriter,
tout << "sgn: " << !mpzm.is_zero(z) << std::endl;
tout << "sig: " << mpzm.to_string(sig) << std::endl;
tout << "exp: " << mpf_exp << std::endl;
@ -159,27 +159,27 @@ br_status fpa_rewriter::mk_to_fp(func_decl * f, unsigned num_args, expr * const
if (m_util.au().is_numeral(args[1], r1)) {
// rm + real -> float
TRACE("fp_rewriter", tout << "r: " << r1 << std::endl;);
TRACE(fp_rewriter, tout << "r: " << r1 << std::endl;);
scoped_mpf v(m_fm);
m_fm.set(v, ebits, sbits, rmv, r1.to_mpq());
result = m_util.mk_value(v);
// TRACE("fp_rewriter", tout << "result: " << result << std::endl; );
// TRACE(fp_rewriter, tout << "result: " << result << std::endl; );
return BR_DONE;
}
else if (m_util.is_numeral(args[1], v)) {
// rm + float -> float
TRACE("fp_rewriter", tout << "v: " << m_fm.to_string(v) << std::endl; );
TRACE(fp_rewriter, tout << "v: " << m_fm.to_string(v) << std::endl; );
scoped_mpf vf(m_fm);
m_fm.set(vf, ebits, sbits, rmv, v);
result = m_util.mk_value(vf);
// TRACE("fp_rewriter", tout << "result: " << result << std::endl; );
// TRACE(fp_rewriter, tout << "result: " << result << std::endl; );
return BR_DONE;
}
else if (m_util.bu().is_numeral(args[1], r1, bvs1)) {
// rm + signed bv -> float
TRACE("fp_rewriter", tout << "r1: " << r1 << std::endl;);
TRACE(fp_rewriter, tout << "r1: " << r1 << std::endl;);
r1 = m_util.bu().norm(r1, bvs1, true);
TRACE("fp_rewriter", tout << "r1 norm: " << r1 << std::endl;);
TRACE(fp_rewriter, tout << "r1 norm: " << r1 << std::endl;);
m_fm.set(v, ebits, sbits, rmv, r1.to_mpq());
result = m_util.mk_value(v);
return BR_DONE;
@ -195,7 +195,7 @@ br_status fpa_rewriter::mk_to_fp(func_decl * f, unsigned num_args, expr * const
!m_util.au().is_numeral(args[2], r2))
return BR_FAILED;
TRACE("fp_rewriter", tout << "r1: " << r1 << ", r2: " << r2 << "\n";);
TRACE(fp_rewriter, tout << "r1: " << r1 << ", r2: " << r2 << "\n";);
m_fm.set(v, ebits, sbits, rmv, r2.to_mpq().numerator(), r1.to_mpq());
result = m_util.mk_value(v);
return BR_DONE;
@ -209,7 +209,7 @@ br_status fpa_rewriter::mk_to_fp(func_decl * f, unsigned num_args, expr * const
!m_util.au().is_numeral(args[2], r2))
return BR_FAILED;
TRACE("fp_rewriter", tout << "r1: " << r1 << ", r2: " << r2 << "\n";);
TRACE(fp_rewriter, tout << "r1: " << r1 << ", r2: " << r2 << "\n";);
m_fm.set(v, ebits, sbits, rmv, r1.to_mpq().numerator(), r2.to_mpq());
result = m_util.mk_value(v);
return BR_DONE;
@ -226,7 +226,7 @@ br_status fpa_rewriter::mk_to_fp(func_decl * f, unsigned num_args, expr * const
r1.is_one(),
m_fm.unbias_exp(bvs2, biased_exp),
r3.to_mpq().numerator());
TRACE("fp_rewriter", tout << "v = " << m_fm.to_string(v) << std::endl;);
TRACE(fp_rewriter, tout << "v = " << m_fm.to_string(v) << std::endl;);
result = m_util.mk_value(v);
return BR_DONE;
}
@ -700,7 +700,7 @@ br_status fpa_rewriter::mk_fp(expr * sgn, expr * exp, expr * sig, expr_ref & res
rsgn.is_one(),
m_fm.unbias_exp(bvsz_exp, biased_exp),
rsig.to_mpq().numerator());
TRACE("fp_rewriter", tout << "simplified (fp ...) to " << m_fm.to_string(v) << std::endl;);
TRACE(fp_rewriter, tout << "simplified (fp ...) to " << m_fm.to_string(v) << std::endl;);
result = m_util.mk_value(v);
return BR_DONE;
}
@ -765,11 +765,11 @@ br_status fpa_rewriter::mk_to_sbv(func_decl * f, expr * arg1, expr * arg2, expr_
}
br_status fpa_rewriter::mk_to_ieee_bv(func_decl * f, expr * arg, expr_ref & result) {
TRACE("fp_rewriter", tout << "to_ieee_bv of " << mk_ismt2_pp(arg, m()) << std::endl;);
TRACE(fp_rewriter, tout << "to_ieee_bv of " << mk_ismt2_pp(arg, m()) << std::endl;);
scoped_mpf v(m_fm);
if (m_util.is_numeral(arg, v)) {
TRACE("fp_rewriter", tout << "to_ieee_bv numeral: " << m_fm.to_string(v) << std::endl;);
TRACE(fp_rewriter, tout << "to_ieee_bv numeral: " << m_fm.to_string(v) << std::endl;);
bv_util bu(m());
const mpf & x = v.get();

4
src/ast/rewriter/inj_axiom.cpp
View file

@ -75,7 +75,7 @@ bool simplify_inj_axiom(ast_manager & m, quantifier * q, expr_ref & result) {
}
if (found_vars && !has_free_vars(q)) {
(void)num_vars;
TRACE("inj_axiom",
TRACE(inj_axiom,
tout << "Cadidate for simplification:\n" << mk_ll_pp(q, m) << mk_pp(app1, m) << "\n" << mk_pp(app2, m) << "\n" <<
mk_pp(var1, m) << "\n" << mk_pp(var2, m) << "\nnum_vars: " << num_vars << "\n";);
// Building new (optimized) axiom
@ -128,7 +128,7 @@ bool simplify_inj_axiom(ast_manager & m, quantifier * q, expr_ref & result) {
result = m.mk_forall(decls.size(), decls.data(), names.data(), eq,
0, symbol(), symbol(), 1, &p);
TRACE("inj_axiom", tout << "new axiom:\n" << mk_pp(result, m) << "\n";);
TRACE(inj_axiom, tout << "new axiom:\n" << mk_pp(result, m) << "\n";);
SASSERT(is_well_sorted(m, result));
return true;
}

10
src/ast/rewriter/maximize_ac_sharing.cpp
View file

@ -46,18 +46,18 @@ br_status maximize_ac_sharing::reduce_app(func_decl * f, unsigned num_args, expr
_args.append(num_args, args);
}
TRACE("ac_sharing_detail", tout << "before-reuse: num_args: " << num_args << "\n";);
TRACE(ac_sharing_detail, tout << "before-reuse: num_args: " << num_args << "\n";);
#define MAX_NUM_ARGS_FOR_OPT 128
// Try to reuse already created circuits.
TRACE("ac_sharing_detail", tout << "args: "; for (unsigned i = 0; i < num_args; i++) tout << mk_pp(_args[i], m) << "\n";);
TRACE(ac_sharing_detail, tout << "args: "; for (unsigned i = 0; i < num_args; i++) tout << mk_pp(_args[i], m) << "\n";);
try_to_reuse:
if (num_args > 1 && num_args < MAX_NUM_ARGS_FOR_OPT) {
for (unsigned i = 0; i + 1 < num_args; i++) {
for (unsigned j = i + 1; j < num_args; j++) {
if (contains(f, _args[i], _args[j])) {
TRACE("ac_sharing_detail", tout << "reusing args: " << i << " " << j << "\n";);
TRACE(ac_sharing_detail, tout << "reusing args: " << i << " " << j << "\n";);
_args[i] = m.mk_app(f, _args[i], _args[j]);
SASSERT(num_args > 1);
for (unsigned w = j; w + 1 < num_args; w++) {
@ -73,7 +73,7 @@ br_status maximize_ac_sharing::reduce_app(func_decl * f, unsigned num_args, expr
// Create "tree-like circuit"
while (true) {
TRACE("ac_sharing_detail", tout << "tree-loop: num_args: " << num_args << "\n";);
TRACE(ac_sharing_detail, tout << "tree-loop: num_args: " << num_args << "\n";);
unsigned j = 0;
for (unsigned i = 0; i < num_args; i += 2, j++) {
if (i == num_args - 1) {
@ -92,7 +92,7 @@ br_status maximize_ac_sharing::reduce_app(func_decl * f, unsigned num_args, expr
else {
result = m.mk_app(f, numeral, _args[0]);
}
TRACE("ac_sharing_detail", tout << "result: " << result << "\n";);
TRACE(ac_sharing_detail, tout << "result: " << result << "\n";);
return BR_DONE;
}
}

20
src/ast/rewriter/pb2bv_rewriter.cpp
View file

@ -157,7 +157,7 @@ struct pb2bv_rewriter::imp {
gcd_reduce<is_le>(m_coeffs, k);
unsigned sz = m_args.size();
expr * const* args = m_args.data();
TRACE("pb",
TRACE(pb,
for (unsigned i = 0; i < sz; ++i) {
tout << m_coeffs[i] << "*" << mk_pp(args[i], m) << " ";
if (i + 1 < sz && !m_coeffs[i+1].is_neg()) tout << "+ ";
@ -283,7 +283,7 @@ struct pb2bv_rewriter::imp {
return false;
}
result = m.mk_not(bounded_addition(sz, args, k + 1));
TRACE("pb", tout << result << "\n";);
TRACE(pb, tout << result << "\n";);
return true;
}
@ -301,7 +301,7 @@ struct pb2bv_rewriter::imp {
return false;
}
result = bounded_addition(sz, args, k);
TRACE("pb", tout << result << "\n";);
TRACE(pb, tout << result << "\n";);
return true;
}
@ -449,7 +449,7 @@ struct pb2bv_rewriter::imp {
rational cost(0);
create_basis(m_coeffs, rational::zero(), cost);
m_base = m_min_base;
TRACE("pb",
TRACE(pb,
tout << "Base: ";
for (unsigned i = 0; i < m_base.size(); ++i) {
tout << m_base[i] << " ";
@ -465,7 +465,7 @@ struct pb2bv_rewriter::imp {
\brief Check if 'out mod n >= lim'.
*/
expr_ref mod_ge(ptr_vector<expr> const& out, unsigned n, unsigned lim) {
TRACE("pb", for (unsigned i = 0; i < out.size(); ++i) tout << mk_pp(out[i], m) << " "; tout << "\n";
TRACE(pb, for (unsigned i = 0; i < out.size(); ++i) tout << mk_pp(out[i], m) << " "; tout << "\n";
tout << "n:" << n << " lim: " << lim << "\n";);
if (lim == n) {
return expr_ref(m.mk_false(), m);
@ -514,7 +514,7 @@ struct pb2bv_rewriter::imp {
}
coeffs[j] = div(coeffs[j], b_i);
}
TRACE("pb", tout << "Carry: " << carry << "\n";
TRACE(pb, tout << "Carry: " << carry << "\n";
for (auto c : coeffs) tout << c << " ";
tout << "\n";
);
@ -525,7 +525,7 @@ struct pb2bv_rewriter::imp {
expr_ref ge = mod_ge(out, B, d_i);
result = mk_and(ge, result);
result = mk_or(gt, result);
TRACE("pb", tout << "b: " << b_i << " d: " << d_i << " gt: " << gt << " ge: " << ge << " " << result << "\n";);
TRACE(pb, tout << "b: " << b_i << " d: " << d_i << " gt: " << gt << " ge: " << ge << " " << result << "\n";);
new_carry.reset();
for (unsigned j = B - 1; j < out.size(); j += B) {
@ -534,7 +534,7 @@ struct pb2bv_rewriter::imp {
carry.reset();
carry.append(new_carry);
}
TRACE("pb", tout << "bound: " << bound << " Carry: " << carry << " result: " << result << "\n";);
TRACE(pb, tout << "bound: " << bound << " Carry: " << carry << " result: " << result << "\n";);
return true;
}
@ -685,7 +685,7 @@ struct pb2bv_rewriter::imp {
m_coeffs.push_back(pb.get_coeff(f, i));
m_args.push_back(args[i]);
}
CTRACE("pb", k.is_neg(), tout << expr_ref(m.mk_app(f, sz, args), m) << "\n";);
CTRACE(pb, k.is_neg(), tout << expr_ref(m.mk_app(f, sz, args), m) << "\n";);
SASSERT(!k.is_neg());
switch (kind) {
case OP_PB_GE:
@ -923,7 +923,7 @@ struct pb2bv_rewriter::imp {
else {
result = mk_bv(f, sz, args);
}
TRACE("pb", tout << "full: " << full << " " << expr_ref(m.mk_app(f, sz, args), m) << " " << result << "\n";
TRACE(pb, tout << "full: " << full << " " << expr_ref(m.mk_app(f, sz, args), m) << " " << result << "\n";
);
return true;
}

4
src/ast/rewriter/pb_rewriter.cpp
View file

@ -319,14 +319,14 @@ br_status pb_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * cons
break;
}
}
TRACE("pb_verbose",
TRACE(pb_verbose,
expr_ref tmp(m);
tmp = m.mk_app(f, num_args, args);
tout << tmp << "\n";
tout << result << "\n";
);
TRACE("pb_validate",
TRACE(pb_validate,
validate_rewrite(f, num_args, args, result););
return st;

10
src/ast/rewriter/pb_rewriter_def.h
View file

@ -35,7 +35,7 @@ void pb_rewriter_util<PBU>::display(std::ostream& out, typename PBU::args_t& arg
template<typename PBU>
void pb_rewriter_util<PBU>::unique(typename PBU::args_t& args, typename PBU::numeral& k, bool is_eq) {
TRACE("pb_verbose", display(tout << "pre-unique:", args, k, is_eq););
TRACE(pb_verbose, display(tout << "pre-unique:", args, k, is_eq););
for (unsigned i = 0; i < args.size(); ++i) {
if (m_util.is_negated(args[i].first)) {
args[i].first = m_util.negate(args[i].first);
@ -84,12 +84,12 @@ void pb_rewriter_util<PBU>::unique(typename PBU::args_t& args, typename PBU::num
}
}
args.resize(i);
TRACE("pb_verbose", display(tout << "post-unique:", args, k, is_eq););
TRACE(pb_verbose, display(tout << "post-unique:", args, k, is_eq););
}
template<typename PBU>
lbool pb_rewriter_util<PBU>::normalize(typename PBU::args_t& args, typename PBU::numeral& k, bool is_eq) {
TRACE("pb_verbose", display(tout << "pre-normalize:", args, k, is_eq););
TRACE(pb_verbose, display(tout << "pre-normalize:", args, k, is_eq););
DEBUG_CODE(
bool found = false;
@ -167,7 +167,7 @@ lbool pb_rewriter_util<PBU>::normalize(typename PBU::args_t& args, typename PBU:
return l_false;
}
if (is_eq) {
TRACE("pb_verbose", display(tout << "post-normalize:", args, k, is_eq););
TRACE(pb_verbose, display(tout << "post-normalize:", args, k, is_eq););
return l_undef;
}
@ -265,7 +265,7 @@ lbool pb_rewriter_util<PBU>::normalize(typename PBU::args_t& args, typename PBU:
k = n1 + PBU::numeral::one();
}
}
TRACE("pb_verbose", display(tout << "post-normalize:", args, k, is_eq););
TRACE(pb_verbose, display(tout << "post-normalize:", args, k, is_eq););
return l_undef;
}

22
src/ast/rewriter/poly_rewriter_def.h
View file

@ -187,7 +187,7 @@ br_status poly_rewriter<Config>::mk_flat_mul_core(unsigned num_args, expr * cons
}
}
br_status st = mk_nflat_mul_core(flat_args.size(), flat_args.data(), result);
TRACE("poly_rewriter",
TRACE(poly_rewriter,
tout << "flat mul:\n";
for (unsigned i = 0; i < num_args; i++) tout << mk_bounded_pp(args[i], M()) << "\n";
tout << "---->\n";
@ -292,7 +292,7 @@ br_status poly_rewriter<Config>::mk_nflat_mul_core(unsigned num_args, expr * con
new_add_args.push_back(mk_mul_app(c, to_app(var)->get_arg(i)));
}
result = mk_add_app(new_add_args.size(), new_add_args.data());
TRACE("mul_bug", tout << "result: " << mk_bounded_pp(result, M(), 5) << "\n";);
TRACE(mul_bug, tout << "result: " << mk_bounded_pp(result, M(), 5) << "\n";);
return BR_REWRITE2;
}
}
@ -324,7 +324,7 @@ br_status poly_rewriter<Config>::mk_nflat_mul_core(unsigned num_args, expr * con
new_args.push_back(curr);
prev = curr;
}
TRACE("poly_rewriter",
TRACE(poly_rewriter,
for (unsigned i = 0; i < new_args.size(); i++) {
if (i > 0)
tout << (lt(new_args[i-1], new_args[i]) ? " < " : " !< ");
@ -335,7 +335,7 @@ br_status poly_rewriter<Config>::mk_nflat_mul_core(unsigned num_args, expr * con
return BR_FAILED;
if (!ordered) {
std::sort(new_args.begin(), new_args.end(), lt);
TRACE("poly_rewriter",
TRACE(poly_rewriter,
tout << "after sorting:\n";
for (unsigned i = 0; i < new_args.size(); i++) {
if (i > 0)
@ -347,7 +347,7 @@ br_status poly_rewriter<Config>::mk_nflat_mul_core(unsigned num_args, expr * con
SASSERT(new_args.size() >= 2);
result = mk_mul_app(new_args.size(), new_args.data());
result = mk_mul_app(c, result);
TRACE("poly_rewriter",
TRACE(poly_rewriter,
for (unsigned i = 0; i < num_args; ++i)
tout << mk_ismt2_pp(args[i], M()) << " ";
tout << "\nmk_nflat_mul_core result:\n" << mk_ismt2_pp(result, M()) << "\n";);
@ -375,9 +375,9 @@ br_status poly_rewriter<Config>::mk_nflat_mul_core(unsigned num_args, expr * con
unsigned orig_size = sums.size();
expr_ref_buffer sum(M()); // must be ref_buffer because we may throw an exception
ptr_buffer<expr> m_args;
TRACE("som", tout << "starting soM()...\n";);
TRACE(som, tout << "starting soM()...\n";);
do {
TRACE("som", for (unsigned i = 0; i < it.size(); i++) tout << it[i] << " ";
TRACE(som, for (unsigned i = 0; i < it.size(); i++) tout << it[i] << " ";
tout << "\n";);
if (sum.size() > m_som_blowup * orig_size) {
return BR_FAILED;
@ -564,7 +564,7 @@ br_status poly_rewriter<Config>::mk_nflat_add_core(unsigned num_args, expr * con
}
normalize(c);
SASSERT(m_sort_sums || ordered);
TRACE("rewriter",
TRACE(rewriter,
tout << "ordered: " << ordered << " sort sums: " << m_sort_sums << "\n";
for (unsigned i = 0; i < num_args; i++) tout << mk_ismt2_pp(args[i], M()) << "\n";);
@ -615,14 +615,14 @@ br_status poly_rewriter<Config>::mk_nflat_add_core(unsigned num_args, expr * con
}
}
if (m_sort_sums) {
TRACE("rewriter_bug", tout << "new_args.size(): " << new_args.size() << "\n";);
TRACE(rewriter_bug, tout << "new_args.size(): " << new_args.size() << "\n";);
if (c.is_zero())
std::sort(new_args.data(), new_args.data() + new_args.size(), mon_lt(*this));
else
std::sort(new_args.data() + 1, new_args.data() + new_args.size(), mon_lt(*this));
}
result = mk_add_app(new_args.size(), new_args.data());
TRACE("rewriter", tout << result << "\n";);
TRACE(rewriter, tout << result << "\n";);
if (hoist_multiplication(result)) {
return BR_REWRITE_FULL;
}
@ -881,7 +881,7 @@ br_status poly_rewriter<Config>::cancel_monomials(expr * lhs, expr * rhs, bool m
new_lhs_monomials[0] = insert_c_lhs ? mk_numeral(c) : nullptr;
lhs_result = mk_add_app(new_lhs_monomials.size() - lhs_offset, new_lhs_monomials.data() + lhs_offset);
rhs_result = mk_add_app(new_rhs_monomials.size() - rhs_offset, new_rhs_monomials.data() + rhs_offset);
TRACE("le_bug", tout << lhs_result << " " << rhs_result << "\n";);
TRACE(le_bug, tout << lhs_result << " " << rhs_result << "\n";);
return BR_DONE;
}

4
src/ast/rewriter/push_app_ite.cpp
View file

@ -48,7 +48,7 @@ bool push_app_ite_cfg::is_target(func_decl * decl, unsigned num_args, expr * con
}
}
}
CTRACE("push_app_ite", found_ite, tout << "found target for push app ite:\n";
CTRACE(push_app_ite, found_ite, tout << "found target for push app ite:\n";
tout << "conservative " << m_conservative << "\n";
tout << decl->get_name();
for (unsigned i = 0; i < num_args; i++) tout << " " << mk_pp(args[i], m);
@ -75,7 +75,7 @@ br_status push_app_ite_cfg::reduce_app(func_decl * f, unsigned num, expr * const
expr_ref e_new(m.mk_app(f, num, args_prime), m);
args_prime[ite_arg_idx] = old;
result = m.mk_ite(c, t_new, e_new);
TRACE("push_app_ite", tout << result << "\n";);
TRACE(push_app_ite, tout << result << "\n";);
if (m.proofs_enabled()) {
result_pr = m.mk_rewrite(m.mk_app(f, num, args), result);
}

6
src/ast/rewriter/quant_hoist.cpp
View file

@ -44,7 +44,7 @@ public:
void operator()(expr* fml, app_ref_vector& vars, bool& is_fa, expr_ref& result, bool use_fresh, bool rewrite_ok) {
quantifier_type qt = Q_none_pos;
pull_quantifier(fml, qt, vars, result, use_fresh, rewrite_ok);
TRACE("qe_verbose",
TRACE(qe_verbose,
tout << mk_pp(fml, m) << "\n";
tout << mk_pp(result, m) << "\n";);
SASSERT(is_positive(qt));
@ -54,7 +54,7 @@ public:
void pull_exists(expr* fml, app_ref_vector& vars, expr_ref& result, bool use_fresh, bool rewrite_ok) {
quantifier_type qt = Q_exists_pos;
pull_quantifier(fml, qt, vars, result, use_fresh, rewrite_ok);
TRACE("qe_verbose",
TRACE(qe_verbose,
tout << mk_pp(fml, m) << "\n";
tout << mk_pp(result, m) << "\n";);
}
@ -63,7 +63,7 @@ public:
quantifier_type qt = is_forall?Q_forall_pos:Q_exists_pos;
expr_ref result(m);
pull_quantifier(fml, qt, vars, result, use_fresh, rewrite_ok);
TRACE("qe_verbose",
TRACE(qe_verbose,
tout << mk_pp(fml, m) << "\n";
tout << mk_pp(result, m) << "\n";);
fml = std::move(result);

4
src/ast/rewriter/rewriter.cpp
View file

@ -50,7 +50,7 @@ bool rewriter_core::rewrites_from(expr* t, proof* p) {
}
bool rewriter_core::rewrites_to(expr* t, proof* p) {
CTRACE("rewriter", p && !m().proofs_disabled() && to_app(m().get_fact(p))->get_arg(1) != t,
CTRACE(rewriter, p && !m().proofs_disabled() && to_app(m().get_fact(p))->get_arg(1) != t,
tout << mk_pp(p, m()) << "\n";
tout << mk_pp(t, m()) << "\n";);
return !p || m().proofs_disabled() || (to_app(m().get_fact(p))->get_arg(1) == t);
@ -65,7 +65,7 @@ void rewriter_core::cache_shifted_result(expr * k, unsigned offset, expr * v) {
#endif
SASSERT(!m_proof_gen);
TRACE("rewriter_cache_result", tout << mk_ismt2_pp(k, m()) << "\n--->\n" << mk_ismt2_pp(v, m()) << "\n";);
TRACE(rewriter_cache_result, tout << mk_ismt2_pp(k, m()) << "\n--->\n" << mk_ismt2_pp(v, m()) << "\n";);
SASSERT(k->get_sort() == v->get_sort());

2
src/ast/rewriter/rewriter.h
View file

@ -106,7 +106,7 @@ protected:
void end_scope();
bool is_child_of_top_frame(expr * t) const;
void set_new_child_flag(expr * old_t) {
CTRACE("rewriter_bug", !is_child_of_top_frame(old_t), display_stack(tout, 3););
CTRACE(rewriter_bug, !is_child_of_top_frame(old_t), display_stack(tout, 3););
SASSERT(is_child_of_top_frame(old_t));
if (!m_frame_stack.empty())
m_frame_stack.back().m_new_child = true;

50
src/ast/rewriter/rewriter_def.h
View file

@ -34,7 +34,7 @@ void rewriter_tpl<Config>::process_var(var * v) {
m_pr = nullptr;
}
set_new_child_flag(v);
TRACE("rewriter", tout << mk_ismt2_pp(v, m()) << " -> " << m_r << "\n";);
TRACE(rewriter, tout << mk_ismt2_pp(v, m()) << " -> " << m_r << "\n";);
m_r = nullptr;
return;
}
@ -45,7 +45,7 @@ void rewriter_tpl<Config>::process_var(var * v) {
unsigned index = 0;
expr * r;
if (idx < m_bindings.size() && (index = m_bindings.size() - idx - 1, r = m_bindings[index])) {
CTRACE("rewriter", v->get_sort() != r->get_sort(),
CTRACE(rewriter, v->get_sort() != r->get_sort(),
tout << expr_ref(v, m()) << ":" << sort_ref(v->get_sort(), m()) << " != " << expr_ref(r, m()) << ":" << sort_ref(r->get_sort(), m());
tout << "index " << index << " bindings " << m_bindings.size() << "\n";
display_bindings(tout););
@ -60,13 +60,13 @@ void rewriter_tpl<Config>::process_var(var * v) {
expr_ref tmp(m());
m_shifter(r, shift_amount, tmp);
result_stack().push_back(tmp);
TRACE("rewriter", display_bindings(tout << "shift: " << shift_amount << " idx: " << idx << " --> " << tmp << "\n"););
TRACE(rewriter, display_bindings(tout << "shift: " << shift_amount << " idx: " << idx << " --> " << tmp << "\n"););
cache_shifted_result(r, shift_amount, tmp);
}
}
else {
result_stack().push_back(r);
TRACE("rewriter", tout << idx << " " << mk_ismt2_pp(r, m()) << "\n";);
TRACE(rewriter, tout << idx << " " << mk_ismt2_pp(r, m()) << "\n";);
}
set_new_child_flag(v);
}
@ -83,7 +83,7 @@ bool rewriter_tpl<Config>::process_const(app * t0) {
retry:
SASSERT(t->get_num_args() == 0);
br_status st = m_cfg.reduce_app(t->get_decl(), 0, nullptr, m_r, m_pr);
TRACE("reduce_app",
TRACE(reduce_app,
tout << "t0:" << mk_bounded_pp(t0, m()) << "\n";
if (t != t0) tout << "t: " << mk_bounded_pp(t, m()) << "\n";
tout << "st: " << st;
@ -91,7 +91,7 @@ bool rewriter_tpl<Config>::process_const(app * t0) {
tout << "\n";
if (m_pr) tout << mk_bounded_pp(m_pr, m()) << "\n";
);
CTRACE("reduce_app",
CTRACE(reduce_app,
st != BR_FAILED && m_r->get_sort() != t->get_sort(),
tout << mk_pp(t->get_sort(), m()) << ": " << mk_pp(t, m()) << "\n";
tout << m_r->get_id() << " " << mk_pp(m_r->get_sort(), m()) << ": " << m_r << "\n";);
@ -141,11 +141,11 @@ bool rewriter_tpl<Config>::process_const(app * t0) {
template<typename Config>
template<bool ProofGen>
bool rewriter_tpl<Config>::visit(expr * t, unsigned max_depth) {
TRACE("rewriter_visit", tout << "visiting\n" << mk_ismt2_pp(t, m()) << "\n";);
TRACE(rewriter_visit, tout << "visiting\n" << mk_ismt2_pp(t, m()) << "\n";);
expr * new_t = nullptr;
proof * new_t_pr = nullptr;
if (m_cfg.get_subst(t, new_t, new_t_pr)) {
TRACE("rewriter_subst", tout << "subst\n" << mk_ismt2_pp(t, m()) << "\n---->\n" << mk_ismt2_pp(new_t, m()) << "\n";);
TRACE(rewriter_subst, tout << "subst\n" << mk_ismt2_pp(t, m()) << "\n---->\n" << mk_ismt2_pp(new_t, m()) << "\n";);
SASSERT(t->get_sort() == new_t->get_sort());
result_stack().push_back(new_t);
set_new_child_flag(t, new_t);
@ -196,7 +196,7 @@ bool rewriter_tpl<Config>::visit(expr * t, unsigned max_depth) {
if (to_app(t)->get_num_args() == 0) {
if (process_const<ProofGen>(to_app(t)))
return true;
TRACE("rewriter_const", tout << "process const: " << mk_bounded_pp(t, m()) << " -> " << mk_bounded_pp(m_r, m()) << "\n";);
TRACE(rewriter_const, tout << "process const: " << mk_bounded_pp(t, m()) << " -> " << mk_bounded_pp(m_r, m()) << "\n";);
if (!is_blocked(t)) {
rewriter_tpl rw(m(), false, m_cfg);
for (auto* s : m_blocked)
@ -243,14 +243,14 @@ bool rewriter_tpl<Config>::constant_fold(app * t, frame & fr) {
result_stack().shrink(fr.m_spos);
result_stack().push_back(arg);
fr.m_state = REWRITE_BUILTIN;
TRACE("rewriter_step", tout << "step\n" << mk_ismt2_pp(t, m()) << "\n";);
TRACE(rewriter_step, tout << "step\n" << mk_ismt2_pp(t, m()) << "\n";);
if (visit<false>(arg, fr.m_max_depth)) {
m_r = result_stack().back();
result_stack().pop_back();
result_stack().pop_back();
result_stack().push_back(m_r);
cache_result<false>(t, m_r, m_pr, fr.m_cache_result);
TRACE("rewriter_step", tout << "step 1\n" << mk_ismt2_pp(m_r, m()) << "\n";);
TRACE(rewriter_step, tout << "step 1\n" << mk_ismt2_pp(m_r, m()) << "\n";);
frame_stack().pop_back();
set_new_child_flag(t);
}
@ -315,7 +315,7 @@ void rewriter_tpl<Config>::process_app(app * t, frame & fr) {
}
br_status st = m_cfg.reduce_app(f, new_num_args, new_args, m_r, m_pr2);
CTRACE("reduce_app", true || st != BR_FAILED || new_t,
CTRACE(reduce_app, true || st != BR_FAILED || new_t,
tout << mk_bounded_pp(t, m()) << "\n";
tout << "st: " << st;
if (m_r) tout << " --->\n" << mk_bounded_pp(m_r, m());
@ -425,7 +425,7 @@ void rewriter_tpl<Config>::process_app(app * t, frame & fr) {
}
else {
fr.m_state = EXPAND_DEF;
TRACE("get_macro", tout << "f: " << f->get_name() << ", def: \n" << mk_ismt2_pp(def, m()) << "\n";
TRACE(get_macro, tout << "f: " << f->get_name() << ", def: \n" << mk_ismt2_pp(def, m()) << "\n";
tout << "Args num: " << num_args << "\n";
for (unsigned i = 0; i < num_args; i++) tout << mk_ismt2_pp(new_args[i], m()) << "\n";);
unsigned sz = m_bindings.size();
@ -436,7 +436,7 @@ void rewriter_tpl<Config>::process_app(app * t, frame & fr) {
m_shifts.push_back(sz);
}
result_stack().push_back(def);
TRACE("get_macro", display_bindings(tout););
TRACE(get_macro, display_bindings(tout););
begin_scope();
m_num_qvars += num_args;
m_root = def;
@ -453,7 +453,7 @@ void rewriter_tpl<Config>::process_app(app * t, frame & fr) {
}
}
else {
TRACE("rewriter_reuse", tout << "reusing:\n" << mk_ismt2_pp(t, m()) << "\n";);
TRACE(rewriter_reuse, tout << "reusing:\n" << mk_ismt2_pp(t, m()) << "\n";);
m_r = t;
}
}
@ -557,7 +557,7 @@ void rewriter_tpl<Config>::process_quantifier(quantifier * q, frame & fr) {
expr_ref_vector new_pats(m_manager, num_pats, q->get_patterns());
expr_ref_vector new_no_pats(m_manager, num_no_pats, q->get_no_patterns());
if (rewrite_patterns()) {
TRACE("reduce_quantifier_bug", tout << "rewrite patterns\n";);
TRACE(reduce_quantifier_bug, tout << "rewrite patterns\n";);
expr * const * np = it + 1;
expr * const * nnp = np + num_pats;
unsigned j = 0;
@ -591,18 +591,18 @@ void rewriter_tpl<Config>::process_quantifier(quantifier * q, frame & fr) {
if (m_cfg.reduce_quantifier(new_q, new_body, new_pats.data(), new_no_pats.data(), m_r, pr2)) {
m_pr = m().mk_transitivity(m_pr, pr2);
}
TRACE("reduce_quantifier_bug",if (m_pr) tout << mk_ismt2_pp(m_pr, m()) << "\n"; else tout << "m_pr is_null\n";);
TRACE(reduce_quantifier_bug,if (m_pr) tout << mk_ismt2_pp(m_pr, m()) << "\n"; else tout << "m_pr is_null\n";);
result_pr_stack().shrink(fr.m_spos);
result_pr_stack().push_back(m_pr);
}
else {
TRACE("reduce_quantifier_bug", tout << mk_ismt2_pp(q, m()) << " " << mk_ismt2_pp(new_body, m()) << "\n";);
TRACE(reduce_quantifier_bug, tout << mk_ismt2_pp(q, m()) << " " << mk_ismt2_pp(new_body, m()) << "\n";);
if (!m_cfg.reduce_quantifier(q, new_body, new_pats.data(), new_no_pats.data(), m_r, m_pr)) {
if (fr.m_new_child) {
m_r = m().update_quantifier(q, num_pats, new_pats.data(), num_no_pats, new_no_pats.data(), new_body);
}
else {
TRACE("rewriter_reuse", tout << "reusing:\n" << mk_ismt2_pp(q, m()) << "\n";);
TRACE(rewriter_reuse, tout << "reusing:\n" << mk_ismt2_pp(q, m()) << "\n";);
m_r = q;
}
}
@ -680,8 +680,8 @@ void rewriter_tpl<Config>::set_bindings(unsigned num_bindings, expr * const * bi
m_bindings.push_back(bindings[i]);
m_shifts.push_back(num_bindings);
}
TRACE("rewriter", display_bindings(tout););
SCTRACE("bindings", is_trace_enabled("coming_from_quant"), display_bindings(tout););
TRACE(rewriter, display_bindings(tout););
SCTRACE(bindings, is_trace_enabled(TraceTag::coming_from_quant), display_bindings(tout););
}
template<typename Config>
@ -694,8 +694,8 @@ void rewriter_tpl<Config>::set_inv_bindings(unsigned num_bindings, expr * const
m_bindings.push_back(bindings[i]);
m_shifts.push_back(num_bindings);
}
TRACE("rewriter", display_bindings(tout););
SCTRACE("bindings", is_trace_enabled("coming_from_quant"), display_bindings(tout););
TRACE(rewriter, display_bindings(tout););
SCTRACE(bindings, is_trace_enabled(TraceTag::coming_from_quant), display_bindings(tout););
}
template<typename Config>
@ -741,7 +741,7 @@ void rewriter_tpl<Config>::main_loop(expr * t, expr_ref & result, proof_ref & re
else {
resume_core<ProofGen>(result, result_pr);
}
TRACE("rewriter", tout << mk_ismt2_pp(t, m()) << "\n=>\n" << result << "\n";;);
TRACE(rewriter, tout << mk_ismt2_pp(t, m()) << "\n=>\n" << result << "\n";;);
}
/**
@ -761,7 +761,7 @@ void rewriter_tpl<Config>::resume_core(expr_ref & result, proof_ref & result_pr)
SASSERT(!ProofGen || result_stack().size() == result_pr_stack().size());
frame & fr = frame_stack().back();
expr * t = fr.m_curr;
TRACE("rewriter_step", tout << "step\n" << mk_ismt2_pp(t, m()) << "\n";);
TRACE(rewriter_step, tout << "step\n" << mk_ismt2_pp(t, m()) << "\n";);
m_num_steps++;
check_max_steps();
if (first_visit(fr) && fr.m_cache_result) {

18
src/ast/rewriter/seq_axioms.cpp
View file

@ -191,7 +191,7 @@ namespace seq {
*/
void axioms::extract_axiom(expr* e) {
TRACE("seq", tout << mk_pp(e, m) << "\n";);
TRACE(seq, tout << mk_pp(e, m) << "\n";);
expr* _s = nullptr, *_i = nullptr, *_l = nullptr;
VERIFY(seq.str.is_extract(e, _s, _i, _l));
auto s = purify(_s);
@ -218,7 +218,7 @@ namespace seq {
extract_suffix_axiom(e, s, i);
return;
}
TRACE("seq", tout << s << " " << i << " " << l << "\n";);
TRACE(seq, tout << s << " " << i << " " << l << "\n";);
expr_ref x = m_sk.mk_pre(s, i);
expr_ref ls = mk_len(_s);
expr_ref lx = mk_len(x);
@ -262,14 +262,14 @@ namespace seq {
void axioms::tail_axiom(expr* e, expr* s) {
expr_ref head(m), tail(m);
m_sk.decompose(s, head, tail);
TRACE("seq", tout << "tail " << mk_bounded_pp(e, m, 2) << " " << mk_bounded_pp(s, m, 2) << "\n";);
TRACE(seq, tout << "tail " << mk_bounded_pp(e, m, 2) << " " << mk_bounded_pp(s, m, 2) << "\n";);
expr_ref emp = mk_eq_empty(s);
add_clause(emp, mk_seq_eq(s, mk_concat(head, e)));
add_clause(~emp, mk_eq_empty(e));
}
void axioms::drop_last_axiom(expr* e, expr* s) {
TRACE("seq", tout << "drop last " << mk_bounded_pp(e, m, 2) << " " << mk_bounded_pp(s, m, 2) << "\n";);
TRACE(seq, tout << "drop last " << mk_bounded_pp(e, m, 2) << " " << mk_bounded_pp(s, m, 2) << "\n";);
expr_ref emp = mk_eq_empty(s);
add_clause(emp, mk_seq_eq(s, mk_concat(e, seq.str.mk_unit(m_sk.mk_last(s)))));
add_clause(~emp, mk_eq_empty(e));
@ -331,7 +331,7 @@ namespace seq {
len(s) < l => e = s
*/
void axioms::extract_prefix_axiom(expr* e, expr* s, expr* l) {
TRACE("seq", tout << "prefix " << mk_bounded_pp(e, m, 2) << " " << mk_bounded_pp(s, m, 2) << " " << mk_bounded_pp(l, m, 2) << "\n";);
TRACE(seq, tout << "prefix " << mk_bounded_pp(e, m, 2) << " " << mk_bounded_pp(s, m, 2) << " " << mk_bounded_pp(l, m, 2) << "\n";);
expr_ref le = mk_len(e);
expr_ref ls = mk_len(s);
expr_ref ls_minus_l(mk_sub(ls, l), m);
@ -351,7 +351,7 @@ namespace seq {
i > len(s) => e = empty
*/
void axioms::extract_suffix_axiom(expr* e, expr* s, expr* i) {
TRACE("seq", tout << "suffix " << mk_bounded_pp(e, m, 2) << " " << mk_bounded_pp(s, m, 2) << "\n";);
TRACE(seq, tout << "suffix " << mk_bounded_pp(e, m, 2) << " " << mk_bounded_pp(s, m, 2) << "\n";);
expr_ref x = m_sk.mk_pre(s, i);
expr_ref lx = mk_len(x);
expr_ref ls = mk_len(s);
@ -594,7 +594,7 @@ namespace seq {
*/
void axioms::at_axiom(expr* e) {
TRACE("seq", tout << "at-axiom: " << mk_bounded_pp(e, m) << "\n";);
TRACE(seq, tout << "at-axiom: " << mk_bounded_pp(e, m) << "\n";);
expr* _s = nullptr, *_i = nullptr;
VERIFY(seq.str.is_at(e, _s, _i));
auto s = purify(_s);
@ -667,7 +667,7 @@ namespace seq {
void axioms::itos_axiom(expr* e) {
expr* n = nullptr;
TRACE("seq", tout << mk_pp(e, m) << "\n";);
TRACE(seq, tout << mk_pp(e, m) << "\n";);
VERIFY(seq.str.is_itos(e, n));
// itos(n) = "" <=> n < 0
@ -704,7 +704,7 @@ namespace seq {
stoi(s) >= 0 => len(s) >= 1
*/
void axioms::stoi_axiom(expr* e) {
TRACE("seq", tout << mk_pp(e, m) << "\n";);
TRACE(seq, tout << mk_pp(e, m) << "\n";);
expr_ref ge0 = mk_ge(e, 0);
expr* s = nullptr;
VERIFY (seq.str.is_stoi(e, s));

114
src/ast/rewriter/seq_rewriter.cpp
View file

@ -251,7 +251,7 @@ eautomaton* re2automaton::operator()(expr* e) {
if (r) {
r->compress();
bool_rewriter br(m);
TRACE("seq", display_expr1 disp(m); r->display(tout << mk_pp(e, m) << " -->\n", disp););
TRACE(seq, display_expr1 disp(m); r->display(tout << mk_pp(e, m) << " -->\n", disp););
}
return r;
}
@ -302,7 +302,7 @@ eautomaton* re2automaton::re2aut(expr* e) {
expr_ref _start(m), _stop(m);
if (is_unit_char(e1, _start) &&
is_unit_char(e2, _stop)) {
TRACE("seq", tout << "Range: " << _start << " " << _stop << "\n";);
TRACE(seq, tout << "Range: " << _start << " " << _stop << "\n";);
a = alloc(eautomaton, sm, sym_expr::mk_range(_start, _stop));
return a.detach();
}
@ -360,11 +360,11 @@ eautomaton* re2automaton::re2aut(expr* e) {
}
else if (u.re.is_intersection(e, e1, e2) && m_sa && (a = re2aut(e1)) && (b = re2aut(e2))) {
eautomaton* r = m_sa->mk_product(*a, *b);
TRACE("seq", display_expr1 disp(m); a->display(tout << "a:", disp); b->display(tout << "b:", disp); r->display(tout << "intersection:", disp););
TRACE(seq, display_expr1 disp(m); a->display(tout << "a:", disp); b->display(tout << "b:", disp); r->display(tout << "intersection:", disp););
return r;
}
else {
TRACE("seq", tout << "not handled " << mk_pp(e, m) << "\n";);
TRACE(seq, tout << "not handled " << mk_pp(e, m) << "\n";);
}
return nullptr;
@ -763,7 +763,7 @@ br_status seq_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
if (st == BR_FAILED) {
st = lift_ites_throttled(f, num_args, args, result);
}
CTRACE("seq_verbose", st != BR_FAILED, tout << expr_ref(m().mk_app(f, num_args, args), m()) << " -> " << result << "\n";);
CTRACE(seq_verbose, st != BR_FAILED, tout << expr_ref(m().mk_app(f, num_args, args), m()) << " -> " << result << "\n";);
SASSERT(st == BR_FAILED || result->get_sort() == f->get_range());
return st;
}
@ -777,7 +777,7 @@ br_status seq_rewriter::mk_seq_unit(expr* e, expr_ref& result) {
if (m_util.is_const_char(e, ch) && m_coalesce_chars) {
// convert to string constant
zstring s(ch);
TRACE("seq_verbose", tout << "rewrite seq.unit of 8-bit value " << ch << " to string constant \"" << s<< "\"" << std::endl;);
TRACE(seq_verbose, tout << "rewrite seq.unit of 8-bit value " << ch << " to string constant \"" << s<< "\"" << std::endl;);
result = str().mk_string(s);
return BR_DONE;
}
@ -994,7 +994,7 @@ br_status seq_rewriter::lift_ites_throttled(func_decl* f, unsigned n, expr* cons
new_args[i] = e;
expr_ref arg2(m().mk_app(f, new_args), m());
result = m().mk_ite(c, arg1, arg2);
TRACE("seq_verbose", tout << "lifting ite: " << mk_pp(result, m()) << std::endl;);
TRACE(seq_verbose, tout << "lifting ite: " << mk_pp(result, m()) << std::endl;);
return BR_REWRITE2;
}
return BR_FAILED;
@ -1137,7 +1137,7 @@ bool seq_rewriter::extract_push_offset(expr_ref_vector const& as, expr* b, expr*
t1 = str().mk_concat(as.size() - i, as.data() + i, as[0]->get_sort());
expr_ref t2 = mk_len(pos1, lens);
result = str().mk_substr(t1, t2, c);
TRACE("seq", tout << result << "\n";);
TRACE(seq, tout << result << "\n";);
return true;
}
}
@ -1174,7 +1174,7 @@ bool seq_rewriter::extract_push_length(expr_ref_vector& as, expr* b, expr* c, ex
result = str().mk_substr(t1, b, t2);
as[i] = result;
result = str().mk_concat(i + 1, as.data(), as[0]->get_sort());
TRACE("seq", tout << result << "\n";);
TRACE(seq, tout << result << "\n";);
return true;
}
}
@ -1186,7 +1186,7 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
zstring s;
rational pos, len;
TRACE("seq_verbose", tout << mk_pp(a, m()) << " " << mk_pp(b, m()) << " " << mk_pp(c, m()) << "\n";);
TRACE(seq_verbose, tout << mk_pp(a, m()) << " " << mk_pp(b, m()) << " " << mk_pp(c, m()) << "\n";);
bool constantBase = str().is_string(a, s);
bool constantPos = m_autil.is_numeral(b, pos);
bool constantLen = m_autil.is_numeral(c, len);
@ -1453,7 +1453,7 @@ br_status seq_rewriter::mk_seq_contains(expr* a, expr* b, expr_ref& result) {
str().get_concat_units(a, as);
str().get_concat_units(b, bs);
TRACE("seq", tout << mk_pp(a, m()) << " contains " << mk_pp(b, m()) << "\n";);
TRACE(seq, tout << mk_pp(a, m()) << " contains " << mk_pp(b, m()) << "\n";);
if (bs.empty()) {
result = m().mk_true();
@ -2253,14 +2253,14 @@ br_status seq_rewriter::mk_seq_replace_re(expr* a, expr* b, expr* c, expr_ref& r
}
br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
TRACE("seq", tout << mk_pp(a, m()) << " " << mk_pp(b, m()) << "\n";);
TRACE(seq, tout << mk_pp(a, m()) << " " << mk_pp(b, m()) << "\n";);
zstring s1, s2;
bool isc1 = str().is_string(a, s1);
bool isc2 = str().is_string(b, s2);
sort* sort_a = a->get_sort();
if (isc1 && isc2) {
result = m().mk_bool_val(s1.prefixof(s2));
TRACE("seq", tout << result << "\n";);
TRACE(seq, tout << result << "\n";);
return BR_DONE;
}
if (str().is_empty(a)) {
@ -2278,7 +2278,7 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
if (s1.prefixof(s2)) {
if (a == a1) {
result = m().mk_true();
TRACE("seq", tout << s1 << " " << s2 << " " << result << "\n";);
TRACE(seq, tout << s1 << " " << s2 << " " << result << "\n";);
return BR_DONE;
}
str().get_concat(a, as);
@ -2288,12 +2288,12 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
bs[0] = str().mk_string(s2);
result = str().mk_prefix(str().mk_concat(as.size()-1, as.data()+1, sort_a),
str().mk_concat(bs.size(), bs.data(), sort_a));
TRACE("seq", tout << s1 << " " << s2 << " " << result << "\n";);
TRACE(seq, tout << s1 << " " << s2 << " " << result << "\n";);
return BR_REWRITE_FULL;
}
else {
result = m().mk_false();
TRACE("seq", tout << s1 << " " << s2 << " " << result << "\n";);
TRACE(seq, tout << s1 << " " << s2 << " " << result << "\n";);
return BR_DONE;
}
}
@ -2301,7 +2301,7 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
if (s2.prefixof(s1)) {
if (b == b1) {
result = m().mk_false();
TRACE("seq", tout << s1 << " " << s2 << " " << result << "\n";);
TRACE(seq, tout << s1 << " " << s2 << " " << result << "\n";);
return BR_DONE;
}
str().get_concat(a, as);
@ -2311,12 +2311,12 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
as[0] = str().mk_string(s1);
result = str().mk_prefix(str().mk_concat(as.size(), as.data(), sort_a),
str().mk_concat(bs.size()-1, bs.data()+1, sort_a));
TRACE("seq", tout << s1 << " " << s2 << " " << result << "\n";);
TRACE(seq, tout << s1 << " " << s2 << " " << result << "\n";);
return BR_REWRITE_FULL;
}
else {
result = m().mk_false();
TRACE("seq", tout << s1 << " " << s2 << " " << result << "\n";);
TRACE(seq, tout << s1 << " " << s2 << " " << result << "\n";);
return BR_DONE;
}
}
@ -2342,7 +2342,7 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
}
if (i == as.size()) {
result = mk_and(eqs);
TRACE("seq", tout << result << "\n";);
TRACE(seq, tout << result << "\n";);
return BR_REWRITE3;
}
SASSERT(i < as.size());
@ -2351,7 +2351,7 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
eqs.push_back(str().mk_is_empty(as.get(j)));
}
result = mk_and(eqs);
TRACE("seq", tout << result << "\n";);
TRACE(seq, tout << result << "\n";);
return BR_REWRITE3;
}
if (i > 0) {
@ -2360,7 +2360,7 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
b = str().mk_concat(bs.size() - i, bs.data() + i, sort_a);
eqs.push_back(str().mk_prefix(a, b));
result = mk_and(eqs);
TRACE("seq", tout << result << "\n";);
TRACE(seq, tout << result << "\n";);
return BR_REWRITE3;
}
@ -2420,7 +2420,7 @@ br_status seq_rewriter::mk_seq_suffix(expr* a, expr* b, expr_ref& result) {
}
if (i > sza) {
result = mk_and(eqs);
TRACE("seq", tout << result << "\n";);
TRACE(seq, tout << result << "\n";);
return BR_REWRITE3;
}
if (i > szb) {
@ -2429,7 +2429,7 @@ br_status seq_rewriter::mk_seq_suffix(expr* a, expr* b, expr_ref& result) {
eqs.push_back(str().mk_is_empty(aj));
}
result = mk_and(eqs);
TRACE("seq", tout << result << "\n";);
TRACE(seq, tout << result << "\n";);
return BR_REWRITE3;
}
@ -2439,7 +2439,7 @@ br_status seq_rewriter::mk_seq_suffix(expr* a, expr* b, expr_ref& result) {
b = str().mk_concat(szb - i + 1, bs.data(), sort_a);
eqs.push_back(str().mk_suffix(a, b));
result = mk_and(eqs);
TRACE("seq", tout << result << "\n";);
TRACE(seq, tout << result << "\n";);
return BR_REWRITE3;
}
@ -2889,14 +2889,14 @@ expr_ref seq_rewriter::re_predicate(expr* cond, sort* seq_sort) {
}
expr_ref seq_rewriter::is_nullable(expr* r) {
STRACE("seq_verbose", tout << "is_nullable: "
STRACE(seq_verbose, tout << "is_nullable: "
<< mk_pp(r, m()) << std::endl;);
expr_ref result(m_op_cache.find(_OP_RE_IS_NULLABLE, r, nullptr, nullptr), m());
if (!result) {
result = is_nullable_rec(r);
m_op_cache.insert(_OP_RE_IS_NULLABLE, r, nullptr, nullptr, result);
}
STRACE("seq_verbose", tout << "is_nullable result: "
STRACE(seq_verbose, tout << "is_nullable result: "
<< result << std::endl;);
return result;
}
@ -3144,12 +3144,12 @@ br_status seq_rewriter::mk_re_derivative(expr* ele, expr* r, expr_ref& result) {
*/
bool seq_rewriter::check_deriv_normal_form(expr* r, int level) {
if (level == 3) { // top level
STRACE("seq_verbose", tout
STRACE(seq_verbose, tout
<< "Checking derivative normal form invariant...";);
}
expr *r1 = nullptr, *r2 = nullptr, *p = nullptr, *s = nullptr;
unsigned lo = 0, hi = 0;
STRACE("seq_verbose", tout << " (level " << level << ")";);
STRACE(seq_verbose, tout << " (level " << level << ")";);
int new_level = 0;
if (re().is_antimirov_union(r)) {
SASSERT(level >= 2);
@ -3193,7 +3193,7 @@ bool seq_rewriter::check_deriv_normal_form(expr* r, int level) {
SASSERT(false);
}
if (level == 3) {
STRACE("seq_verbose", tout << " passed!" << std::endl;);
STRACE(seq_verbose, tout << " passed!" << std::endl;);
}
return true;
}
@ -3218,8 +3218,8 @@ expr_ref seq_rewriter::mk_antimirov_deriv(expr* e, expr* r, expr* path) {
if (!result) {
mk_antimirov_deriv_rec(e, r, path, result);
m_op_cache.insert(OP_RE_DERIVATIVE, e, r, path, result);
STRACE("seq_regex", tout << "D(" << mk_pp(e, m()) << "," << mk_pp(r, m()) << "," << mk_pp(path, m()) << ")" << std::endl;);
STRACE("seq_regex", tout << "= " << mk_pp(result, m()) << std::endl;);
STRACE(seq_regex, tout << "D(" << mk_pp(e, m()) << "," << mk_pp(r, m()) << "," << mk_pp(path, m()) << ")" << std::endl;);
STRACE(seq_regex, tout << "= " << mk_pp(result, m()) << std::endl;);
}
return result;
}
@ -3851,7 +3851,7 @@ bool seq_rewriter::le_char(expr* ch1, expr* ch2) {
- a and b are char <= constraints, or negations of char <= constraints
*/
bool seq_rewriter::pred_implies(expr* a, expr* b) {
STRACE("seq_verbose", tout << "pred_implies: "
STRACE(seq_verbose, tout << "pred_implies: "
<< "," << mk_pp(a, m())
<< "," << mk_pp(b, m()) << std::endl;);
expr *cha1 = nullptr, *cha2 = nullptr, *nota = nullptr,
@ -3912,7 +3912,7 @@ bool seq_rewriter::ite_bdds_compatible(expr* a, expr* b) {
- result is in normal form (check_deriv_normal_form)
*/
expr_ref seq_rewriter::mk_der_op_rec(decl_kind k, expr* a, expr* b) {
STRACE("seq_verbose", tout << "mk_der_op_rec: " << k
STRACE(seq_verbose, tout << "mk_der_op_rec: " << k
<< "," << mk_pp(a, m())
<< "," << mk_pp(b, m()) << std::endl;);
expr* ca = nullptr, *a1 = nullptr, *a2 = nullptr;
@ -4076,7 +4076,7 @@ expr_ref seq_rewriter::mk_der_op(decl_kind k, expr* a, expr* b) {
}
expr_ref seq_rewriter::mk_der_compl(expr* r) {
STRACE("seq_verbose", tout << "mk_der_compl: " << mk_pp(r, m())
STRACE(seq_verbose, tout << "mk_der_compl: " << mk_pp(r, m())
<< std::endl;);
expr_ref result(m_op_cache.find(OP_RE_COMPLEMENT, r, nullptr, nullptr), m());
if (!result) {
@ -4115,7 +4115,7 @@ expr_ref seq_rewriter::mk_der_compl(expr* r) {
Postcondition: result is in BDD form
*/
expr_ref seq_rewriter::mk_der_cond(expr* cond, expr* ele, sort* seq_sort) {
STRACE("seq_verbose", tout << "mk_der_cond: "
STRACE(seq_verbose, tout << "mk_der_cond: "
<< mk_pp(cond, m()) << ", " << mk_pp(ele, m()) << std::endl;);
sort *ele_sort = nullptr;
VERIFY(u().is_seq(seq_sort, ele_sort));
@ -4160,7 +4160,7 @@ expr_ref seq_rewriter::mk_der_cond(expr* cond, expr* ele, sort* seq_sort) {
else {
result = re_predicate(cond, seq_sort);
}
STRACE("seq_verbose", tout << "mk_der_cond result: "
STRACE(seq_verbose, tout << "mk_der_cond result: "
<< mk_pp(result, m()) << std::endl;);
CASSERT("seq_regex", check_deriv_normal_form(result));
return result;
@ -4264,7 +4264,7 @@ expr_ref seq_rewriter::mk_derivative_rec(expr* ele, expr* r) {
if (get_head_tail(r1, hd, tl)) {
// head must be equal; if so, derivative is tail
// Use mk_der_cond to normalize
STRACE("seq_verbose", tout << "deriv to_re" << std::endl;);
STRACE(seq_verbose, tout << "deriv to_re" << std::endl;);
result = m().mk_eq(ele, hd);
result = mk_der_cond(result, ele, seq_sort);
expr_ref r1(re().mk_to_re(tl), m());
@ -4305,7 +4305,7 @@ expr_ref seq_rewriter::mk_derivative_rec(expr* ele, expr* r) {
expr_ref hd(m()), tl(m());
if (get_head_tail_reversed(r2, hd, tl)) {
// Use mk_der_cond to normalize
STRACE("seq_verbose", tout << "deriv reverse to_re" << std::endl;);
STRACE(seq_verbose, tout << "deriv reverse to_re" << std::endl;);
result = m().mk_eq(ele, tl);
result = mk_der_cond(result, ele, seq_sort);
result = mk_der_concat(result, re().mk_reverse(re().mk_to_re(hd)));
@ -4334,7 +4334,7 @@ expr_ref seq_rewriter::mk_derivative_rec(expr* ele, expr* r) {
expr_ref ch1(m_util.mk_char(s1[0]), m());
expr_ref ch2(m_util.mk_char(s2[0]), m());
// Use mk_der_cond to normalize
STRACE("seq_verbose", tout << "deriv range zstring" << std::endl;);
STRACE(seq_verbose, tout << "deriv range zstring" << std::endl;);
expr_ref p1(u().mk_le(ch1, ele), m());
p1 = mk_der_cond(p1, ele, seq_sort);
expr_ref p2(u().mk_le(ele, ch2), m());
@ -4350,7 +4350,7 @@ expr_ref seq_rewriter::mk_derivative_rec(expr* ele, expr* r) {
if (str().is_unit(r1, e1) && str().is_unit(r2, e2)) {
SASSERT(u().is_char(e1));
// Use mk_der_cond to normalize
STRACE("seq_verbose", tout << "deriv range str" << std::endl;);
STRACE(seq_verbose, tout << "deriv range str" << std::endl;);
expr_ref p1(u().mk_le(e1, ele), m());
p1 = mk_der_cond(p1, ele, seq_sort);
expr_ref p2(u().mk_le(ele, e2), m());
@ -4367,7 +4367,7 @@ expr_ref seq_rewriter::mk_derivative_rec(expr* ele, expr* r) {
expr* args[2] = { p, ele };
result = array.mk_select(2, args);
// Use mk_der_cond to normalize
STRACE("seq_verbose", tout << "deriv of_pred" << std::endl;);
STRACE(seq_verbose, tout << "deriv of_pred" << std::endl;);
return mk_der_cond(result, ele, seq_sort);
}
// stuck cases: re.derivative, re variable,
@ -4547,7 +4547,7 @@ This will help propagate cases like "abc"X in opt(to_re(X)) to equalities.
*/
br_status seq_rewriter::mk_str_in_regexp(expr* a, expr* b, expr_ref& result) {
STRACE("seq_verbose", tout << "mk_str_in_regexp: " << mk_pp(a, m())
STRACE(seq_verbose, tout << "mk_str_in_regexp: " << mk_pp(a, m())
<< ", " << mk_pp(b, m()) << std::endl;);
if (re().is_empty(b)) {
@ -5423,7 +5423,7 @@ br_status seq_rewriter::mk_le_core(expr * l, expr * r, expr_ref & result) {
}
br_status seq_rewriter::mk_eq_core(expr * l, expr * r, expr_ref & result) {
TRACE("seq", tout << mk_pp(l, m()) << " == " << mk_pp(r, m()) << "\n");
TRACE(seq, tout << mk_pp(l, m()) << " == " << mk_pp(r, m()) << "\n");
expr_ref_vector res(m());
expr_ref_pair_vector new_eqs(m());
if (m_util.is_re(l)) {
@ -5436,20 +5436,20 @@ br_status seq_rewriter::mk_eq_core(expr * l, expr * r, expr_ref & result) {
#if 0
if (reduce_arith_eq(l, r, res) || reduce_arith_eq(r, l, res)) {
result = mk_and(res);
TRACE("seq_verbose", tout << result << "\n";);
TRACE(seq_verbose, tout << result << "\n";);
return BR_REWRITE3;
}
if (reduce_extract(l, r, res)) {
result = mk_and(res);
TRACE("seq_verbose", tout << result << "\n";);
TRACE(seq_verbose, tout << result << "\n";);
return BR_REWRITE3;
}
#endif
if (!reduce_eq(l, r, new_eqs, changed)) {
result = m().mk_false();
TRACE("seq_verbose", tout << result << "\n";);
TRACE(seq_verbose, tout << result << "\n";);
return BR_DONE;
}
if (!changed) {
@ -5459,7 +5459,7 @@ br_status seq_rewriter::mk_eq_core(expr * l, expr * r, expr_ref & result) {
res.push_back(m().mk_eq(p.first, p.second));
}
result = mk_and(res);
TRACE("seq_verbose", tout << result << "\n";);
TRACE(seq_verbose, tout << result << "\n";);
return BR_REWRITE3;
}
@ -5600,11 +5600,11 @@ bool seq_rewriter::reduce_front(expr_ref_vector& ls, expr_ref_vector& rs, expr_r
}
else if (str().is_string(l, s1) &&
str().is_string(r, s2)) {
TRACE("seq", tout << s1 << " - " << s2 << " " << s1.length() << " " << s2.length() << "\n";);
TRACE(seq, tout << s1 << " - " << s2 << " " << s1.length() << " " << s2.length() << "\n";);
unsigned min_l = std::min(s1.length(), s2.length());
for (unsigned i = 0; i < min_l; ++i) {
if (s1[i] != s2[i]) {
TRACE("seq", tout << "different at position " << i << " " << s1[i] << " " << s2[i] << "\n";);
TRACE(seq, tout << "different at position " << i << " " << s1[i] << " " << s2[i] << "\n";);
return false;
}
}
@ -5638,7 +5638,7 @@ bool seq_rewriter::reduce_front(expr_ref_vector& ls, expr_ref_vector& rs, expr_r
- sets change to true if some simplification occurred
*/
bool seq_rewriter::reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_pair_vector& eqs, bool& change) {
TRACE("seq_verbose", tout << ls << "\n"; tout << rs << "\n";);
TRACE(seq_verbose, tout << ls << "\n"; tout << rs << "\n";);
unsigned hash_l = ls.hash();
unsigned hash_r = rs.hash();
unsigned sz_eqs = eqs.size();
@ -5675,7 +5675,7 @@ bool seq_rewriter::reduce_eq(expr* l, expr* r, expr_ref_pair_vector& new_eqs, bo
return true;
}
else {
TRACE("seq", tout << mk_bounded_pp(l, m()) << " != " << mk_bounded_pp(r, m()) << "\n";);
TRACE(seq, tout << mk_bounded_pp(l, m()) << " != " << mk_bounded_pp(r, m()) << "\n";);
return false;
}
}
@ -5703,7 +5703,7 @@ void seq_rewriter::add_seqs(expr_ref_vector const& ls, expr_ref_vector const& rs
bool seq_rewriter::reduce_contains(expr* a, expr* b, expr_ref_vector& disj) {
m_lhs.reset();
str().get_concat(a, m_lhs);
TRACE("seq", tout << expr_ref(a, m()) << " " << expr_ref(b, m()) << "\n";);
TRACE(seq, tout << expr_ref(a, m()) << " " << expr_ref(b, m()) << "\n";);
sort* sort_a = a->get_sort();
zstring s;
for (unsigned i = 0; i < m_lhs.size(); ++i) {
@ -6201,7 +6201,7 @@ bool seq_rewriter::reduce_subsequence(expr_ref_vector& ls, expr_ref_vector& rs,
str().mk_concat(rs, srt));
ls.reset();
rs.reset();
TRACE("seq", tout << "subsequence " << eqs << "\n";);
TRACE(seq, tout << "subsequence " << eqs << "\n";);
}
return true;
}
@ -6230,9 +6230,9 @@ void seq_rewriter::op_cache::cleanup() {
if (m_table.size() >= m_max_cache_size) {
m_trail.reset();
m_table.reset();
STRACE("seq_regex", tout << "Op cache reset!" << std::endl;);
STRACE("seq_regex_brief", tout << "(OP CACHE RESET) ";);
STRACE("seq_verbose", tout << "Derivative op cache reset" << std::endl;);
STRACE(seq_regex, tout << "Op cache reset!" << std::endl;);
STRACE(seq_regex_brief, tout << "(OP CACHE RESET) ";);
STRACE(seq_verbose, tout << "Derivative op cache reset" << std::endl;);
}
}

12
src/ast/rewriter/th_rewriter.cpp
View file

@ -548,7 +548,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
func_decl * f_prime = nullptr;
expr_ref new_t(m()), new_e(m()), common(m());
bool first;
TRACE("push_ite", tout << "unifying:\n" << mk_ismt2_pp(t, m()) << "\n" << mk_ismt2_pp(e, m()) << "\n";);
TRACE(push_ite, tout << "unifying:\n" << mk_ismt2_pp(t, m()) << "\n" << mk_ismt2_pp(e, m()) << "\n";);
if (unify(t, e, f_prime, new_t, new_e, common, first)) {
if (first)
result = m().mk_app(f_prime, common, m().mk_ite(c, new_t, new_e));
@ -556,7 +556,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
result = m().mk_app(f_prime, m().mk_ite(c, new_t, new_e), common);
return BR_DONE;
}
TRACE("push_ite", tout << "failed\n";);
TRACE(push_ite, tout << "failed\n";);
return BR_FAILED;
}
@ -632,7 +632,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
}
if (st != BR_DONE && st != BR_FAILED) {
CTRACE("th_rewriter_step", st != BR_FAILED,
CTRACE(th_rewriter_step, st != BR_FAILED,
tout << f->get_name() << "\n";
for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m()) << "\n";
tout << "---------->\n" << mk_ismt2_pp(result, m()) << "\n";);
@ -654,7 +654,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
st = m_ar_rw.mk_app_core(f, num, args, result);
}
CTRACE("th_rewriter_step", st != BR_FAILED,
CTRACE(th_rewriter_step, st != BR_FAILED,
tout << f->get_name() << "\n";
for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m()) << "\n";
tout << "---------->\n" << mk_ismt2_pp(result, m()) << "\n";);
@ -823,7 +823,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
new_patterns_buf.size(), new_patterns_buf.data(), new_no_patterns_buf.size(), new_no_patterns_buf.data(),
new_body);
m_pinned.reset();
TRACE("reduce_quantifier", tout << mk_ismt2_pp(old_q, m()) << "\n----->\n" << mk_ismt2_pp(q1, m()) << "\n";);
TRACE(reduce_quantifier, tout << mk_ismt2_pp(old_q, m()) << "\n----->\n" << mk_ismt2_pp(q1, m()) << "\n";);
SASSERT(is_well_sorted(m(), q1));
if (m().proofs_enabled() && q1 != old_q) {
p1 = m().mk_rewrite(old_q, q1);
@ -841,7 +841,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
result_pr = m().mk_transitivity(p1, p2);
}
TRACE("reduce_quantifier", tout << "after elim_unused_vars:\n" << result << " " << result_pr << "\n" ;);
TRACE(reduce_quantifier, tout << "after elim_unused_vars:\n" << result << " " << result_pr << "\n" ;);
proof_ref p2(m());
expr_ref r(m());

2
src/ast/rewriter/value_sweep.cpp
View file

@ -111,7 +111,7 @@ void value_sweep::propagate_values() {
m_args.push_back(get_value(arg));
expr_ref new_value(m.mk_app(p->get_decl(), m_args), m);
m_rewrite(new_value);
TRACE("value_sweep", tout << "propagate " << mk_pp(p, m) << " " << new_value << "\n";);
TRACE(value_sweep, tout << "propagate " << mk_pp(p, m) << " " << new_value << "\n";);
set_value_core(p, new_value);
m_queue.push_back(p);
}

12
src/ast/rewriter/var_subst.cpp
View file

@ -31,7 +31,7 @@ expr_ref var_subst::operator()(expr * n, unsigned num_args, expr * const * args)
result = n;
//application does not have free variables or nested quantifiers.
//There is no need to print the bindings here?
SCTRACE("bindings", is_trace_enabled("coming_from_quant"),
SCTRACE(bindings, is_trace_enabled(TraceTag::coming_from_quant),
tout << "(ground)\n";
for (unsigned i = 0; i < num_args; i++) {
if (args[i]) {
@ -78,7 +78,7 @@ expr_ref var_subst::operator()(expr * n, unsigned num_args, expr * const * args)
m_reducer.set_bindings(num_args, args);
m_reducer(n, result);
SASSERT(is_well_sorted(m, result));
TRACE("var_subst_bug",
TRACE(var_subst_bug,
tout << "m_std_order: " << m_std_order << "\n" << mk_ismt2_pp(n, m) << "\nusing\n";
for (unsigned i = 0; i < num_args; i++) tout << mk_ismt2_pp(args[i], m) << "\n";
tout << "\n------>\n";
@ -95,7 +95,7 @@ unused_vars_eliminator::unused_vars_eliminator(ast_manager & m, params_ref const
expr_ref unused_vars_eliminator::operator()(quantifier* q) {
expr_ref result(m);
SASSERT(is_well_sorted(m, q));
TRACE("elim_unused_vars", tout << expr_ref(q, m) << "\n";);
TRACE(elim_unused_vars, tout << expr_ref(q, m) << "\n";);
if (is_lambda(q)) {
result = q;
return result;
@ -207,7 +207,7 @@ expr_ref unused_vars_eliminator::operator()(quantifier* q) {
expr_ref elim_unused_vars(ast_manager & m, quantifier * q, params_ref const & params) {
unused_vars_eliminator el(m, params);
expr_ref result = el(q);
TRACE("elim_unused_vars", tout << expr_ref(q, m) << " -> " << result << "\n";);
TRACE(elim_unused_vars, tout << expr_ref(q, m) << " -> " << result << "\n";);
return result;
}
@ -215,11 +215,11 @@ expr_ref instantiate(ast_manager & m, quantifier * q, expr * const * exprs) {
var_subst subst(m);
expr_ref new_expr(m), result(m);
new_expr = subst(q->get_expr(), q->get_num_decls(), exprs);
TRACE("var_subst", tout << mk_pp(q, m) << "\n" << new_expr << "\n";);
TRACE(var_subst, tout << mk_pp(q, m) << "\n" << new_expr << "\n";);
inv_var_shifter shift(m);
shift(new_expr, q->get_num_decls(), result);
SASSERT(is_well_sorted(m, result));
TRACE("instantiate_bug", tout << mk_ismt2_pp(q, m) << "\nusing\n";
TRACE(instantiate_bug, tout << mk_ismt2_pp(q, m) << "\nusing\n";
for (unsigned i = 0; i < q->get_num_decls(); i++) tout << mk_ismt2_pp(exprs[i], m) << "\n";
tout << "\n----->\n" << mk_ismt2_pp(result, m) << "\n";);
return result;