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

* Introduce X-macro-based trace tag definition
- Created trace_tags.def to centralize TRACE tag definitions
- Each tag includes a symbolic name and description
- Set up enum class TraceTag for type-safe usage in TRACE macros

* Add script to generate Markdown documentation from trace_tags.def
- Python script parses trace_tags.def and outputs trace_tags.md

* Refactor TRACE_NEW to prepend TraceTag and pass enum to is_trace_enabled

* trace: improve trace tag handling system with hierarchical tagging

- Introduce hierarchical tag-class structure: enabling a tag class activates all child tags
- Unify TRACE, STRACE, SCTRACE, and CTRACE under enum TraceTag
- Implement initial version of trace_tag.def using X(tag, tag_class, description)
  (class names and descriptions to be refined in a future update)

* trace: replace all string-based TRACE tags with enum TraceTag
- Migrated all TRACE, STRACE, SCTRACE, and CTRACE macros to use enum TraceTag values instead of raw string literals

* trace : add cstring header

* trace : Add Markdown documentation generation from trace_tags.def via mk_api_doc.py

* trace : rename macro parameter 'class' to 'tag_class' and remove Unicode comment in trace_tags.h.

* trace : Add TODO comment for future implementation of tag_class activation

* trace : Disable code related to tag_class until implementation is ready (#7663).

src/sat/smt/bv_internalize.cpp

@@ -90,7 +90,7 @@ namespace bv {
         m_wpos.push_back(0);
         m_zero_one_bits.push_back(zero_one_bits());       
         ctx.attach_th_var(n, this, r);        
-        TRACE("bv", tout << "mk-var: v" << r << " " << n->get_expr_id() << " " << mk_bounded_pp(n->get_expr(), m) << "\n";);
+        TRACE(bv, tout << "mk-var: v" << r << " " << n->get_expr_id() << " " << mk_bounded_pp(n->get_expr(), m) << "\n";);
         return r;
     }
 
@@ -240,7 +240,7 @@ namespace bv {
     }
 
     void solver::mk_bits(theory_var v) {
-        TRACE("bv", tout << "v" << v << "@" << s().scope_lvl() << "\n";);
+        TRACE(bv, tout << "v" << v << "@" << s().scope_lvl() << "\n";);
         expr* e = var2expr(v);
         unsigned bv_size = get_bv_size(v);
         m_bits[v].reset();
@@ -248,7 +248,7 @@ namespace bv {
             expr_ref b2b(bv.mk_bit2bool(e, i), m);
             m_bits[v].push_back(sat::null_literal);
             sat::literal lit = ctx.internalize(b2b, false, false);
-            TRACE("bv", tout << "add-bit: " << lit << " " << literal2expr(lit) << "\n";);
+            TRACE(bv, tout << "add-bit: " << lit << " " << literal2expr(lit) << "\n";);
             if (m_bits[v].back() == sat::null_literal)
                 m_bits[v].back() = lit;
             SASSERT(m_bits[v].back() == lit);
@@ -293,7 +293,7 @@ namespace bv {
         SASSERT(l == mk_true() || ~l == mk_true());
         bool is_true = l == mk_true();
         zero_one_bits& bits = m_zero_one_bits[v];
-        TRACE("bv", tout << "register v" << v << " " << l << " " << mk_true() << "\n";);
+        TRACE(bv, tout << "register v" << v << " " << l << " " << mk_true() << "\n";);
         bits.push_back(zero_one_bit(v, idx, is_true));
     }
 
@@ -303,7 +303,7 @@ namespace bv {
     void solver::add_bit(theory_var v, literal l) {
         unsigned idx = m_bits[v].size();
         m_bits[v].push_back(l);
-        TRACE("bv", tout << "add-bit: v" << v << "[" << idx << "] " << l << " " << literal2expr(l) << "@" << s().scope_lvl() << "\n";);
+        TRACE(bv, tout << "add-bit: v" << v << "[" << idx << "] " << l << " " << literal2expr(l) << "@" << s().scope_lvl() << "\n";);
         SASSERT(m_num_scopes == 0);
         s().set_external(l.var());
         euf::enode* n = bool_var2enode(l.var());
@@ -346,7 +346,7 @@ namespace bv {
             unsigned i = 0;
             for (expr* bit : bits) {
                 sat::literal lit = ctx.internalize(bit, false, false);
-                TRACE("bv", tout << "set " << m_bits[v][i] << " == " << lit << "\n";);
+                TRACE(bv, tout << "set " << m_bits[v][i] << " == " << lit << "\n";);
                 add_clause(~lit, m_bits[v][i]);
                 add_clause(lit, ~m_bits[v][i]);
                 ++i;
@@ -589,7 +589,7 @@ namespace bv {
             bits.swap(new_bits);
         }        
         init_bits(e, bits);
-        TRACE("bv_verbose", tout << arg_bits << " " << bits << " " << new_bits << "\n";);
+        TRACE(bv_verbose, tout << arg_bits << " " << bits << " " << new_bits << "\n";);
     }
 
     void solver::internalize_novfl(app* n, std::function<void(unsigned, expr* const*, expr* const*, expr_ref&)>& fn) {
@@ -675,7 +675,7 @@ namespace bv {
         sat::literal lit0 = m_bits[v_arg][idx];
         if (lit0 == sat::null_literal) {
             m_bits[v_arg][idx] = lit;
-            TRACE("bv", tout << "add-bit: " << lit << " " << literal2expr(lit) << "\n";);
+            TRACE(bv, tout << "add-bit: " << lit << " " << literal2expr(lit) << "\n";);
             atom* a = new (get_region()) atom(lit.var());
             a->m_occs = new (get_region()) var_pos_occ(v_arg, idx);
             insert_bv2a(lit.var(), a);
@@ -760,7 +760,7 @@ namespace bv {
         expr_ref oe = mk_var_eq(v1, v2);
         literal oeq = ctx.internalize(oe, false, false);
         unsigned sz = m_bits[v1].size();
-        TRACE("bv", tout << "ackerman-eq: " << s().scope_lvl() << " " << oe << "\n";);
+        TRACE(bv, tout << "ackerman-eq: " << s().scope_lvl() << " " << oe << "\n";);
         literal_vector eqs;
         eqs.push_back(oeq);
         for (unsigned i = 0; i < sz; ++i) {
@@ -771,7 +771,7 @@ namespace bv {
             add_clause(eq, ~oeq);
             eqs.push_back(~eq);
         }
-        TRACE("bv", for (auto l : eqs) tout << mk_bounded_pp(literal2expr(l), m) << " "; tout << "\n";);
+        TRACE(bv, for (auto l : eqs) tout << mk_bounded_pp(literal2expr(l), m) << " "; tout << "\n";);
         euf::th_proof_hint* ph = ctx.mk_smt_clause(name(), eqs.size(), eqs.data());
         s().mk_clause(eqs, sat::status::th(true, m.get_basic_family_id(), ph));
     }