hide bit-vector dependencies under seq_util

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/ast/rewriter/seq_rewriter.cpp

@@ -45,14 +45,13 @@ expr_ref sym_expr::accept(expr* e) {
         result = m.mk_eq(e, m_t);
         break;
     case t_range: {
-        bv_util bv(m);
-        rational r1, r2, r3;
-        unsigned sz;
-        if (bv.is_numeral(m_t, r1, sz) && bv.is_numeral(e, r2, sz) && bv.is_numeral(m_s, r3, sz)) {
+        seq_util u(m);
+        unsigned r1, r2, r3;
+        if (u.is_const_char(m_t, r1) && u.is_const_char(e, r2) && u.is_const_char(m_s, r3)) {
             result = m.mk_bool_val((r1 <= r2) && (r2 <= r3));            
         }
         else {
-            result = m.mk_and(bv.mk_ule(m_t, e), bv.mk_ule(e, m_s));
+            result = m.mk_and(u.mk_le(m_t, e), u.mk_le(e, m_s));
         }
         break;
     }
@@ -190,7 +189,7 @@ public:
     }*/
 };
 
-re2automaton::re2automaton(ast_manager& m): m(m), u(m), bv(m), m_ba(nullptr), m_sa(nullptr) {}
+re2automaton::re2automaton(ast_manager& m): m(m), u(m), m_ba(nullptr), m_sa(nullptr) {}
 
 re2automaton::~re2automaton() {}
 
@@ -248,9 +247,8 @@ eautomaton* re2automaton::re2aut(expr* e) {
             s1.length() == 1 && s2.length() == 1) {
             unsigned start = s1[0];
             unsigned stop = s2[0];
-            unsigned nb = s1.num_bits();
-            expr_ref _start(bv.mk_numeral(start, nb), m);
-            expr_ref _stop(bv.mk_numeral(stop, nb), m);
+            expr_ref _start(u.mk_char(start), m);
+            expr_ref _stop(u.mk_char(stop), m);
             TRACE("seq", tout << "Range: " << start << " " << stop << "\n";);
             a = alloc(eautomaton, sm, sym_expr::mk_range(_start, _stop));
             return a.detach();
@@ -463,14 +461,12 @@ br_status seq_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
  * (seq.unit (_ BitVector 8)) ==> String constant
  */
 br_status seq_rewriter::mk_seq_unit(expr* e, expr_ref& result) {
-    bv_util bvu(m());
-    rational n_val;
-    unsigned int n_size;
+    unsigned ch;
     // specifically we want (_ BitVector 8)
-    if (bvu.is_bv(e) && bvu.is_numeral(e, n_val, n_size) && n_size == 8) {
+    if (m_util.is_const_char(e, ch)) {
         // convert to string constant
-        zstring str(n_val.get_unsigned());
-        TRACE("seq_verbose", tout << "rewrite seq.unit of 8-bit value " << n_val.to_string() << " to string constant \"" << str<< "\"" << std::endl;);
+        zstring str(ch);
+        TRACE("seq_verbose", tout << "rewrite seq.unit of 8-bit value " << ch << " to string constant \"" << str<< "\"" << std::endl;);
         result = m_util.str.mk_string(str);
         return BR_DONE;
     }
@@ -1977,15 +1973,13 @@ bool seq_rewriter::min_length(unsigned n, expr* const* es, unsigned& len) {
 bool seq_rewriter::is_string(unsigned n, expr* const* es, zstring& s) const {
     zstring s1;
     expr* e;
-    bv_util bv(m());
-    rational val;
-    unsigned sz;
+    unsigned ch;
     for (unsigned i = 0; i < n; ++i) {
         if (m_util.str.is_string(es[i], s1)) {
             s = s + s1;
         }
-        else if (m_util.str.is_unit(es[i], e) && bv.is_numeral(e, val, sz)) {
-            s = s + zstring(val.get_unsigned());
+        else if (m_util.str.is_unit(es[i], e) && m_util.is_const_char(e, ch)) {
+            s = s + zstring(ch);
         }
         else {
             return false;

src/ast/rewriter/seq_rewriter.h

@@ -77,7 +77,6 @@ class re2automaton {
     ast_manager& m;
     sym_expr_manager sm;
     seq_util     u;     
-    bv_util      bv;
     scoped_ptr<expr_solver>         m_solver;
     scoped_ptr<boolean_algebra_t>   m_ba;
     scoped_ptr<symbolic_automata_t> m_sa;

src/ast/seq_decl_plugin.cpp

@@ -20,6 +20,7 @@ Revision History:
 #include "ast/arith_decl_plugin.h"
 #include "ast/array_decl_plugin.h"
 #include "ast/ast_pp.h"
+#include "ast/bv_decl_plugin.h"
 #include <sstream>
 
 static bool is_hex_digit(char ch, unsigned& d) {
@@ -967,6 +968,24 @@ app*  seq_util::str::mk_char(char ch) const {
     return mk_char(s, 0);
 }
 
+bool seq_util::is_const_char(expr* e, unsigned& c) const {
+    bv_util bv(m);
+    rational r;    
+    unsigned sz;
+    return bv.is_numeral(e, r, sz) && r.is_unsigned(), c = r.get_unsigned(), true;
+}
+
+app* seq_util::mk_char(unsigned ch) const {
+    bv_util bv(m);
+    return bv.mk_numeral(rational(ch), 8);
+}
+
+app* seq_util::mk_le(expr* ch1, expr* ch2) const {
+    bv_util bv(m);
+    return bv.mk_ule(ch1, ch2);
+}
+
+
 bool seq_util::str::is_string(expr const* n, zstring& s) const {
     if (is_string(n)) {
         s = zstring(to_app(n)->get_decl()->get_parameter(0).get_symbol().bare_str());

src/ast/seq_decl_plugin.h

@@ -22,7 +22,6 @@ Revision History:
 #define SEQ_DECL_PLUGIN_H_
 
 #include "ast/ast.h"
-#include "ast/bv_decl_plugin.h"
 
 
 enum seq_sort_kind {
@@ -221,6 +220,9 @@ public:
     bool is_re(expr* e) const { return is_re(m.get_sort(e)); }
     bool is_re(expr* e, sort*& seq) const { return is_re(m.get_sort(e), seq); }
     bool is_char(expr* e) const { return is_char(m.get_sort(e)); }
+    bool is_const_char(expr* e, unsigned& c) const;
+    app* mk_char(unsigned ch) const;
+    app* mk_le(expr* ch1, expr* ch2) const;
 
     app* mk_skolem(symbol const& name, unsigned n, expr* const* args, sort* range);
     bool is_skolem(expr const* e) const { return is_app_of(e, m_fid, _OP_SEQ_SKOLEM); }