recursive function definitions; combine model-building functionality

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

src/model/model.cpp

@@ -30,20 +30,6 @@ model::model(ast_manager & m):
 }
 
 model::~model() {
-    decl2expr::iterator it1  = m_interp.begin();
-    decl2expr::iterator end1 = m_interp.end();
-    for (; it1 != end1; ++it1) {
-        m_manager.dec_ref(it1->m_key);
-        m_manager.dec_ref(it1->m_value);
-    }
-
-    decl2finterp::iterator it2  = m_finterp.begin();
-    decl2finterp::iterator end2 = m_finterp.end();
-    for (; it2 != end2; ++it2) {
-        m_manager.dec_ref(it2->m_key);
-        dealloc(it2->m_value);
-    }
-    
     sort2universe::iterator it3  = m_usort2universe.begin();
     sort2universe::iterator end3 = m_usort2universe.end();
     for (; it3 != end3; ++it3) {
@@ -53,43 +39,6 @@ model::~model() {
     }
 }
 
-void model::register_decl(func_decl * d, expr * v) {
-    SASSERT(d->get_arity() == 0);
-    decl2expr::obj_map_entry * entry = m_interp.insert_if_not_there2(d, 0);
-    if (entry->get_data().m_value == 0) {
-        // new entry
-        m_decls.push_back(d);
-        m_const_decls.push_back(d);
-        m_manager.inc_ref(d);
-        m_manager.inc_ref(v);
-        entry->get_data().m_value = v;
-    }
-    else {
-        // replacing entry
-        m_manager.inc_ref(v);
-        m_manager.dec_ref(entry->get_data().m_value);
-        entry->get_data().m_value = v;
-    }
-}
-
-void model::register_decl(func_decl * d, func_interp * fi) {
-    SASSERT(d->get_arity() > 0);
-    SASSERT(&fi->m() == &m_manager);
-    decl2finterp::obj_map_entry * entry = m_finterp.insert_if_not_there2(d, 0);
-    if (entry->get_data().m_value == 0) {
-        // new entry
-        m_decls.push_back(d);
-        m_func_decls.push_back(d);
-        m_manager.inc_ref(d);
-        entry->get_data().m_value = fi;
-    }
-    else {
-        // replacing entry
-        if (fi != entry->get_data().m_value)
-            dealloc(entry->get_data().m_value);
-        entry->get_data().m_value = fi;
-    }
-}
 
 
 void model::copy_const_interps(model const & source) {

src/model/model.h

@@ -44,8 +44,7 @@ public:
     bool eval(func_decl * f, expr_ref & r) const { return model_core::eval(f, r); }
     bool eval(expr * e, expr_ref & result, bool model_completion = false);
     
-    expr * get_some_value(sort * s);
-
+    virtual expr * get_some_value(sort * s);
     virtual ptr_vector<expr> const & get_universe(sort * s) const;
     virtual unsigned get_num_uninterpreted_sorts() const;
     virtual sort * get_uninterpreted_sort(unsigned idx) const;
@@ -54,8 +53,6 @@ public:
     //
     // Primitives for building models
     //
-    void register_decl(func_decl * d, expr * v);
-    void register_decl(func_decl * f, func_interp * fi);
     void register_usort(sort * s, unsigned usize, expr * const * universe);
 
     // Model translation

src/model/model_core.cpp

@@ -18,6 +18,23 @@ Revision History:
 --*/
 #include"model_core.h"
 
+model_core::~model_core() {
+    decl2expr::iterator it1  = m_interp.begin();
+    decl2expr::iterator end1 = m_interp.end();
+    for (; it1 != end1; ++it1) {
+        m_manager.dec_ref(it1->m_key);
+        m_manager.dec_ref(it1->m_value);
+    }
+
+    decl2finterp::iterator it2  = m_finterp.begin();
+    decl2finterp::iterator end2 = m_finterp.end();
+    for (; it2 != end2; ++it2) {
+        func_decl* d = it2->m_key;
+        m_manager.dec_ref(it2->m_key);
+        dealloc(it2->m_value);
+    }   
+}
+
 bool model_core::eval(func_decl* f, expr_ref & r) const {
     if (f->get_arity() == 0) {
         r = get_const_interp(f);
@@ -32,3 +49,42 @@ bool model_core::eval(func_decl* f, expr_ref & r) const {
         return false;
     }
 }
+
+void model_core::register_decl(func_decl * d, expr * v) {
+    SASSERT(d->get_arity() == 0);
+    decl2expr::obj_map_entry * entry = m_interp.insert_if_not_there2(d, 0);
+    if (entry->get_data().m_value == 0) {
+        // new entry
+        m_decls.push_back(d);
+        m_const_decls.push_back(d);
+        m_manager.inc_ref(d);
+        m_manager.inc_ref(v);
+        entry->get_data().m_value = v;
+    }
+    else {
+        // replacing entry
+        m_manager.inc_ref(v);
+        m_manager.dec_ref(entry->get_data().m_value);
+        entry->get_data().m_value = v;
+    }
+}
+
+void model_core::register_decl(func_decl * d, func_interp * fi) {
+    SASSERT(d->get_arity() > 0);
+    SASSERT(&fi->m() == &m_manager);
+    decl2finterp::obj_map_entry * entry = m_finterp.insert_if_not_there2(d, 0);
+    if (entry->get_data().m_value == 0) {
+        // new entry
+        m_decls.push_back(d);
+        m_func_decls.push_back(d);
+        m_manager.inc_ref(d);
+        entry->get_data().m_value = fi;
+    }
+    else {
+        // replacing entry
+        if (fi != entry->get_data().m_value)
+            dealloc(entry->get_data().m_value);
+        entry->get_data().m_value = fi;
+    }
+}
+

src/model/model_core.h

@@ -36,8 +36,8 @@ protected:
     ptr_vector<func_decl>         m_func_decls;  
     
 public:
-    model_core(ast_manager & m):m_manager(m), m_ref_count(0) {}
-    virtual ~model_core() {}
+    model_core(ast_manager & m):m_manager(m), m_ref_count(0) { }
+    virtual ~model_core();
 
     ast_manager & get_manager() const { return m_manager; }
 
@@ -58,6 +58,11 @@ public:
     virtual unsigned get_num_uninterpreted_sorts() const = 0;
     virtual sort * get_uninterpreted_sort(unsigned idx) const = 0;
 
+    void register_decl(func_decl * d, expr * v);
+    void register_decl(func_decl * f, func_interp * fi);
+
+    virtual expr * get_some_value(sort * s) = 0;
+
     //
     // Reference counting
     //
@@ -68,6 +73,7 @@ public:
             dealloc(this);
         }
     }
+
 };
 
 #endif

src/model/model_evaluator.cpp

@@ -32,7 +32,7 @@ Revision History:
 #include"cooperate.h"
 
 struct evaluator_cfg : public default_rewriter_cfg {
-    model &                         m_model;
+    model_core &                         m_model;
     bool_rewriter                   m_b_rw;
     arith_rewriter                  m_a_rw;
     bv_rewriter                     m_bv_rw;
@@ -46,7 +46,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
     bool                            m_model_completion;
     bool                            m_cache;
 
-    evaluator_cfg(ast_manager & m, model & md, params_ref const & p):
+    evaluator_cfg(ast_manager & m, model_core & md, params_ref const & p):
         m_model(md),
         m_b_rw(m),
         // We must allow customers to set parameters for arithmetic rewriter/evaluator.
@@ -231,7 +231,7 @@ template class rewriter_tpl<evaluator_cfg>;
 
 struct model_evaluator::imp : public rewriter_tpl<evaluator_cfg> {
     evaluator_cfg m_cfg;
-    imp(model & md, params_ref const & p):
+    imp(model_core & md, params_ref const & p):
         rewriter_tpl<evaluator_cfg>(md.get_manager(),
                                     false, // no proofs for evaluator
                                     m_cfg),
@@ -239,7 +239,7 @@ struct model_evaluator::imp : public rewriter_tpl<evaluator_cfg> {
     }
 };
 
-model_evaluator::model_evaluator(model & md, params_ref const & p) {
+model_evaluator::model_evaluator(model_core & md, params_ref const & p) {
     m_imp = alloc(imp, md, p);
 }
 
@@ -269,7 +269,7 @@ unsigned model_evaluator::get_num_steps() const {
 
 
 void model_evaluator::cleanup(params_ref const & p) {
-    model & md = m_imp->cfg().m_model;
+    model_core & md = m_imp->cfg().m_model;
     #pragma omp critical (model_evaluator)
     {
         dealloc(m_imp);

src/model/model_evaluator.h

@@ -30,7 +30,7 @@ class model_evaluator {
     struct imp;
     imp *  m_imp;
 public:
-    model_evaluator(model & m, params_ref const & p = params_ref());
+    model_evaluator(model_core & m, params_ref const & p = params_ref());
     ~model_evaluator();
 
     ast_manager & m () const;