C++ obj_map::insert方法代码示例

 void mk_const(func_decl * f, expr_ref & result) {
     SASSERT(f->get_family_id() == null_family_id);
     SASSERT(f->get_arity() == 0);
     expr * r;
     if (m_const2bits.find(f, r)) {
         result = r;
         return;
     }
     sort * s = f->get_range();
     SASSERT(butil().is_bv_sort(s));
     unsigned bv_size = butil().get_bv_size(s);
     if (bv_size == 1) {
         result = m().mk_const(f);
         return;
     }
     sort * b = butil().mk_sort(1);
     ptr_buffer<expr> bits;
     for (unsigned i = 0; i < bv_size; i++) {
         bits.push_back(m().mk_fresh_const(0, b));
     }
     r = butil().mk_concat(bits.size(), bits.c_ptr());
     m_saved.push_back(r);
     m_const2bits.insert(f, r);
     result = r;
 }

    proof *mk_lemma_core(proof *pf, expr *fact)
    {
        ptr_buffer<expr> args;
        expr_ref lemma(m);

        if (m.is_or(fact)) {
            for (unsigned i = 0, sz = to_app(fact)->get_num_args(); i < sz; ++i) {
                expr *a = to_app(fact)->get_arg(i);
                if (!is_reduced(a))
                { args.push_back(a); }
            }
        } else if (!is_reduced(fact))
        { args.push_back(fact); }


        if (args.size() == 0) { return pf; }
        else if (args.size() == 1) {
            lemma = args.get(0);
        } else {
            lemma = m.mk_or(args.size(), args.c_ptr());
        }
        proof* res = m.mk_lemma(pf, lemma);
        m_pinned.push_back(res);

        if (m_hyps.contains(lemma))
        { m_units.insert(lemma, res); }
        return res;
    }

 func_decl * remap(func_decl * f) {
     ptr_buffer<sort> new_domain;
     sort * new_range = remap(f->get_range());
     for (unsigned i = 0; i < f->get_arity(); i++)
         new_domain.push_back(remap(f->get_domain(i)));
     func_decl * new_f = m().mk_func_decl(f->get_name(), new_domain.size(), new_domain.c_ptr(), new_range);
     m_asts.push_back(new_f);
     m_asts.push_back(f);
     m_f2f.insert(f, new_f);
     return new_f;
 }

 void add_entry(app* term, expr* value,
     obj_map<func_decl, func_interp*>& interpretations) {
     func_interp* fi = nullptr;
     func_decl * const declaration = term->get_decl();
     const unsigned sz = declaration->get_arity();
     SASSERT(sz == term->get_num_args());
     if (!interpretations.find(declaration, fi)) {
         fi = alloc(func_interp, m_m, sz);
         interpretations.insert(declaration, fi);
     }
     fi->insert_new_entry(term->get_args(), value);
 }

 void cache_result(expr * t, subpaving::var x, mpz const & n, mpz const & d) {
     SASSERT(!m_cache.contains(t));
     SASSERT(m_cached_numerators.size()   == m_cached_vars.size());
     SASSERT(m_cached_denominators.size() == m_cached_vars.size());
     if (t->get_ref_count() <= 1) 
         return;
     unsigned idx = m_cached_vars.size();
     m_cache.insert(t, idx);
     m().inc_ref(t);
     m_cached_vars.push_back(x);
     m_cached_numerators.push_back(n);
     m_cached_denominators.push_back(d);
 }

 void compute_marks(proof* pr)  {
     proof *p;
     proof_post_order pit(pr, m);
     while (pit.hasNext()) {
         p = pit.next();
         if (m.is_hypothesis(p)) {
             m_hypmark.mark(p, true);
             m_hyps.insert(m.get_fact(p));
         } 
         else {
             bool hyp_mark = compute_mark1(p);
             // collect units that are hyp-free and are used as hypotheses somewhere
             if (!hyp_mark && m.has_fact(p) && m_hyps.contains(m.get_fact(p))) { 
                 m_units.insert(m.get_fact(p), p); 
             }
         }
     }
 }

    void reduce(proof* pf, proof_ref &out)
    {
        proof *res = nullptr;

        m_todo.reset();
        m_todo.push_back(pf);
        ptr_buffer<proof> args;
        bool dirty = false;

        while (!m_todo.empty()) {
            proof *p, *tmp, *pp;
            unsigned todo_sz;

            p = m_todo.back();
            if (m_cache.find(p, tmp)) {
                res = tmp;
                m_todo.pop_back();
                continue;
            }

            dirty = false;
            args.reset();
            todo_sz = m_todo.size();
            for (unsigned i = 0, sz = m.get_num_parents(p); i < sz; ++i) {
                pp = m.get_parent(p, i);
                if (m_cache.find(pp, tmp)) {
                    args.push_back(tmp);
                    dirty = dirty || pp != tmp;
                } else {
                    m_todo.push_back(pp);
                }
            }

            if (todo_sz < m_todo.size()) { continue; }
            else { m_todo.pop_back(); }

            if (m.is_hypothesis(p)) {
                // hyp: replace by a corresponding unit
                if (m_units.find(m.get_fact(p), tmp)) {
                    res = tmp;
                } else { res = p; }
            }

            else if (!dirty) { res = p; }

            else if (m.is_lemma(p)) {
                //lemma: reduce the premise; remove reduced consequences from conclusion
                SASSERT(args.size() == 1);
                res = mk_lemma_core(args.get(0), m.get_fact(p));
                compute_mark1(res);
            } else if (m.is_unit_resolution(p)) {
                // unit: reduce units; reduce the first premise; rebuild unit resolution
                res = mk_unit_resolution_core(args.size(), args.c_ptr());
                compute_mark1(res);
            } else  {
                // other: reduce all premises; reapply
                if (m.has_fact(p)) { args.push_back(to_app(m.get_fact(p))); }
                SASSERT(p->get_decl()->get_arity() == args.size());
                res = m.mk_app(p->get_decl(), args.size(), (expr * const*)args.c_ptr());
                m_pinned.push_back(res);
                compute_mark1(res);
            }

            SASSERT(res);
            m_cache.insert(p, res);

            if (m.has_fact(res) && m.is_false(m.get_fact(res))) { break; }
        }

        out = res;
    }

 void insert(expr* a, expr* b) {
     m_trail.push_back(b);
     m_mem.insert(a, b);
 }