bool for_each_parameter(ptr_vector<ast> & stack, ast_mark & visited, unsigned num_args, parameter const * params) { bool result = true; for (unsigned i = 0; i < num_args; i++) { parameter const& p = params[i]; if (p.is_ast() && !visited.is_marked(p.get_ast())) { stack.push_back(p.get_ast()); result = false; } } return result; }
term(expr_ref const& v, u_map<term*>& app2term) : m_expr(v), m_root(this), m_next(this), m_class_size(1), m_mark(false), m_mark2(false), m_interpreted(false) { if (!is_app(m_expr)) return; for (expr* e : *to_app(m_expr)) { term* t = app2term[e->get_id()]; t->get_root().m_parents.push_back(this); m_children.push_back(t); } }
bool dl_decl_plugin::is_rel_sort(sort* r, ptr_vector<sort>& sorts) { if (!is_sort_of(r, m_family_id, DL_RELATION_SORT)) { m_manager->raise_exception("expected relation sort"); return false; } unsigned n = r->get_num_parameters(); for (unsigned i = 0; i < n; ++i) { parameter const& p = r->get_parameter(i); if (!p.is_ast() || !is_sort(p.get_ast())) { m_manager->raise_exception("exptected sort parameter"); return false; } sorts.push_back(to_sort(p.get_ast())); } return true; }
/** \brief Apply equality resolution rule on the given clause. Store the produced clauses in new_clauses. */ void eq_resolution::operator()(clause * cls, ptr_vector<clause> & new_clauses) { m_subst.reserve_vars(cls->get_num_vars()); unsigned num = cls->get_num_literals(); for (unsigned i = 0; i < num; i++) { literal const & l = cls->get_literal(i); expr * atom = l.atom(); if (l.sign() && m_manager.is_eq(atom)) { expr * lhs = to_app(atom)->get_arg(0); expr * rhs = to_app(atom)->get_arg(1); m_subst.reset(); if (m_unifier(lhs, rhs, m_subst, false) && cls->is_eligible_for_resolution(m_order, l, 0, &m_subst)) { m_stats.m_num_eq_resolution++; new_clauses.push_back(mk_result(cls, i)); } } } }
// Store in result the func_decl that are not attached to any family id. // That is, the uninterpreted constants and function declarations. void symtable::get_func_decls(ptr_vector<func_decl> & result) const { svector<ptr_vector<func_decl>*> tmp; m_ids.get_range(tmp); svector<ptr_vector<func_decl>*>::const_iterator it = tmp.begin(); svector<ptr_vector<func_decl>*>::const_iterator end = tmp.end(); for (; it != end; ++it) { ptr_vector<func_decl> * curr = *it; if (curr) { ptr_vector<func_decl>::const_iterator it2 = curr->begin(); ptr_vector<func_decl>::const_iterator end2 = curr->end(); for (; it2 != end2; ++it2) { func_decl * d = *it2; if (d && d->get_family_id() == null_family_id) { result.push_back(d); } } } } }
void GOrgueMidiRtInPort::addMissingDevices(GOrgueMidi* midi, ptr_vector<GOrgueMidiInPort>& ports) { try { std::vector<RtMidi::Api> apis; RtMidi::getCompiledApi(apis); for(unsigned i = 0; i < apis.size(); i++) { try { RtMidiIn midi_dev(apis[i]); for (unsigned j = 0; j < midi_dev.getPortCount(); j++) { wxString name = GOrgueRtHelpers::GetMidiApiPrefix(apis[i]) + wxString::FromAscii(midi_dev.getPortName(j).c_str()); bool found = false; for(unsigned k = 0; k < ports.size(); k++) if (ports[k] && ports[k]->GetName() == name) found = true; if (!found) ports.push_back(new GOrgueMidiRtInPort(midi, GOrgueRtHelpers::GetMidiApiPrefix(apis[i]), name, apis[i])); } } catch (RtMidiError &e) { wxString error = wxString::FromAscii(e.getMessage().c_str()); wxLogError(_("RtMidi error: %s"), error.c_str()); } } } catch (RtMidiError &e) { wxString error = wxString::FromAscii(e.getMessage().c_str()); wxLogError(_("RtMidi error: %s"), error.c_str()); } }
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 goal::get_formulas(ptr_vector<expr> & result) { unsigned sz = size(); for (unsigned i = 0; i < sz; i++) { result.push_back(form(i)); } }
virtual void get_unsat_core(ptr_vector<expr> & r) { unsigned sz = ctx().get_unsat_core_size(); for (unsigned i = 0; i < sz; i++) r.push_back(ctx().get_unsat_core_expr(i)); }
void visit(func_decl * f, bool & visited) { if (get_color(f) != CLOSED) { m_todo.push_back(f); visited = false; } }
void rule_properties::insert(ptr_vector<rule>& rules, rule* r) { if (rules.empty() || rules.back() != r) { rules.push_back(r); } }
static void mergeClass(ptr_vector<VertexInfo> &infos, NGHolder &g, unsigned eq_class, VertexInfoSet &cur_class_vertices, set<NFAVertex> *toRemove) { DEBUG_PRINTF("Replacing %zd vertices from equivalence class %u with a " "single vertex.\n", cur_class_vertices.size(), eq_class); // replace equivalence class with a single vertex: // 1. create new vertex with matching properties // 2. wire all predecessors to new vertex // 2a. update info for new vertex with new predecessors // 2b. update each predecessor's successor list // 3. wire all successors to new vertex // 3a. update info for new vertex with new successors // 3b. update each successor's predecessor list // 4. remove old vertex // any differences between vertex properties were resolved during // initial partitioning, so we assume that every vertex in equivalence // class has the same CharReach et al. // so, we find the first vertex in our class and get all its properties /* For left equivalence, if the members have different reporting behaviour * we sometimes require two vertices to be created (one connected to accept * and one to accepteod) */ NFAVertex old_v = (*cur_class_vertices.begin())->v; NFAVertex new_v = clone_vertex(g, old_v); /* set up new vertex with same * props */ g[new_v].reports.clear(); /* populated as we pull in succs */ VertexInfo *new_vertex_info = new VertexInfo(new_v, g); // store this vertex in our global vertex list infos.push_back(new_vertex_info); NFAVertex new_v_eod = NGHolder::null_vertex(); VertexInfo *new_vertex_info_eod = nullptr; if (require_separate_eod_vertex(cur_class_vertices, g)) { new_v_eod = clone_vertex(g, old_v); g[new_v_eod].reports.clear(); new_vertex_info_eod = new VertexInfo(new_v_eod, g); infos.push_back(new_vertex_info_eod); } const unsigned edgetop = (*cur_class_vertices.begin())->edge_top; for (VertexInfo *old_vertex_info : cur_class_vertices) { assert(old_vertex_info->equivalence_class == eq_class); // mark this vertex for removal toRemove->insert(old_vertex_info->v); // for each predecessor, add edge to new vertex and update info for (VertexInfo *pred_info : old_vertex_info->pred) { // update info for new vertex new_vertex_info->pred.insert(pred_info); if (new_vertex_info_eod) { new_vertex_info_eod->pred.insert(pred_info); } // update info for predecessor pred_info->succ.erase(old_vertex_info); // if edge doesn't exist, create it NFAEdge e = add_edge_if_not_present(pred_info->v, new_v, g).first; // put edge top, if applicable if (edgetop != (unsigned) -1) { g[e].top = edgetop; } pred_info->succ.insert(new_vertex_info); if (new_v_eod) { NFAEdge ee = add_edge_if_not_present(pred_info->v, new_v_eod, g).first; // put edge top, if applicable if (edgetop != (unsigned) -1) { g[ee].top = edgetop; } pred_info->succ.insert(new_vertex_info_eod); } } // for each successor, add edge from new vertex and update info for (VertexInfo *succ_info : old_vertex_info->succ) { NFAVertex succ_v = succ_info->v; // update info for successor succ_info->pred.erase(old_vertex_info); if (new_v_eod && succ_v == g.acceptEod) { // update info for new vertex new_vertex_info_eod->succ.insert(succ_info); insert(&g[new_v_eod].reports, g[old_vertex_info->v].reports); add_edge_if_not_present(new_v_eod, succ_v, g); succ_info->pred.insert(new_vertex_info_eod); } else { // update info for new vertex new_vertex_info->succ.insert(succ_info); // if edge doesn't exist, create it add_edge_if_not_present(new_v, succ_v, g); succ_info->pred.insert(new_vertex_info); if (is_any_accept(succ_v, g)) { insert(&g[new_v].reports, g[old_vertex_info->v].reports); } } } } // update classmap new_vertex_info->equivalence_class = eq_class; cur_class_vertices.insert(new_vertex_info); }
void set_next_arg(cmd_context & ctx, expr * arg) override { m_targets.push_back(arg); }
void add_parent(term* p) { m_parents.push_back(p); }
GroupUserConfigParam::GroupUserConfigParam(const char* groupName, const char* comment) { this->paramName = groupName; all_params.push_back(this); if(comment != NULL) this->comment = comment; }
virtual void set_next_arg(cmd_context & ctx, expr * arg) { m_targets.push_back(arg); }
virtual void get_unsat_core(ptr_vector<expr> & r) { SASSERT(m_context); unsigned sz = m_context->get_unsat_core_size(); for (unsigned i = 0; i < sz; i++) r.push_back(m_context->get_unsat_core_expr(i)); }