static void dump_unbound (FILE *f, const struct binding_t *funcs, struct keymap_t *map, struct keymap_t *aux) { int i; for (i = 0; funcs[i].name; i++) { if (! is_bound (map, funcs[i].op) && (!aux || ! is_bound (aux, funcs[i].op))) format_line (f, 0, funcs[i].name, "", _(HelpStrings[funcs[i].op])); } }
void build_b14_from_bonds(PyObject *atomlist ) { int i,k, l; int natoms = PySequence_Length(atomlist); for(i=0;i<natoms;i++){ PyObject *atom = PySequence_GetItem(atomlist, i); PyObject *b14 = PyObject_GetAttrString(atom,"b14"); int atom_id = PyInt_AsLong (PyObject_GetAttrString(atom,"id") ); PyObject *b13 = PyObject_GetAttrString(atom,"b13"); int len_b13 = PySequence_Length(b13); for(k=0;k<len_b13;k++){ PyObject *bb = PySequence_GetItem(b13, k); PyObject *bb_bonds = PyObject_GetAttrString(bb,"bonds"); int len_bonds = PySequence_Length(bb_bonds); for(l=0;l<len_bonds;l++){ PyObject *bond = PySequence_GetItem(bb_bonds, l); int atom_id2 = PyInt_AsLong (PyObject_GetAttrString(bond,"id") ); if( atom_id < atom_id2 && ! is_bound(atom, atom_id2 -1 )) { PyObject *bb14 = PyObject_GetAttrString(bond,"b14"); PyList_Append(b14, bond ); PyList_Append(bb14, atom ); } } } } }
void elim_bounds::operator()(quantifier * q, expr_ref & r) { if (!q->is_forall()) { r = q; return; } expr * n = q->get_expr(); ptr_buffer<expr> atoms; if (m_manager.is_or(n)) atoms.append(to_app(n)->get_num_args(), to_app(n)->get_args()); else atoms.push_back(n); used_vars m_used_vars; // collect non-candidates unsigned sz = atoms.size(); for (unsigned i = 0; i < sz; i++) { expr * a = atoms[i]; if (!is_bound(a)) m_used_vars.process(a); } if (m_used_vars.uses_all_vars(q->get_num_decls())) { r = q; return; } // collect candidates obj_hashtable<var> m_lowers; obj_hashtable<var> m_uppers; obj_hashtable<var> m_candidate_set; ptr_buffer<var> m_candidates; #define ADD_CANDIDATE(V) if (!m_lowers.contains(V) && !m_uppers.contains(V)) { m_candidate_set.insert(V); m_candidates.push_back(V); } for (unsigned i = 0; i < sz; i++) { expr * a = atoms[i]; var * lower = 0; var * upper = 0; if (is_bound(a, lower, upper)) { if (lower != 0 && !m_used_vars.contains(lower->get_idx())) { ADD_CANDIDATE(lower); m_lowers.insert(lower); } if (upper != 0 && !m_used_vars.contains(upper->get_idx())) { ADD_CANDIDATE(upper); m_uppers.insert(upper); } } } TRACE("elim_bounds", tout << "candidates:\n"; for (unsigned i = 0; i < m_candidates.size(); i++) tout << mk_pp(m_candidates[i], m_manager) << "\n";);
bool elim_bounds_cfg::reduce_quantifier(quantifier * q, expr * n, expr * const * new_patterns, expr * const * new_no_patterns, expr_ref & result, proof_ref & result_pr) { if (!is_forall(q)) { return false; } unsigned num_vars = q->get_num_decls(); ptr_buffer<expr> atoms; if (m.is_or(n)) atoms.append(to_app(n)->get_num_args(), to_app(n)->get_args()); else atoms.push_back(n); used_vars used_vars; // collect non-candidates for (expr * a : atoms) { if (!is_bound(a)) used_vars.process(a); } if (used_vars.uses_all_vars(q->get_num_decls())) { return false; } // collect candidates obj_hashtable<var> lowers; obj_hashtable<var> uppers; obj_hashtable<var> candidate_set; ptr_buffer<var> candidates; #define ADD_CANDIDATE(V) if (!lowers.contains(V) && !uppers.contains(V)) { candidate_set.insert(V); candidates.push_back(V); } for (expr * a : atoms) { var * lower = nullptr; var * upper = nullptr; if (is_bound(a, lower, upper)) { if (lower != nullptr && !used_vars.contains(lower->get_idx()) && lower->get_idx() < num_vars) { ADD_CANDIDATE(lower); lowers.insert(lower); } if (upper != nullptr && !used_vars.contains(upper->get_idx()) && upper->get_idx() < num_vars) { ADD_CANDIDATE(upper); uppers.insert(upper); } } } TRACE("elim_bounds", tout << "candidates:\n"; for (unsigned i = 0; i < candidates.size(); i++) tout << mk_pp(candidates[i], m) << "\n";);
void delete_prog(unsigned int prog) { RPCB reg; register rpcblist_ptr rbl; for (rbl = list_rbl; rbl != NULL; rbl = rbl->rpcb_next) { if ((rbl->rpcb_map.r_prog != prog)) continue; if (is_bound(rbl->rpcb_map.r_netid, rbl->rpcb_map.r_addr)) continue; reg.r_prog = rbl->rpcb_map.r_prog; reg.r_vers = rbl->rpcb_map.r_vers; reg.r_netid = strdup(rbl->rpcb_map.r_netid); (void) map_unset(®, "superuser"); free(reg.r_netid); } }
void Label::patch_instructions(MacroAssembler* masm) { assert(is_bound(), "Label is bound"); CodeBuffer* cb = masm->code(); int target_sect = CodeBuffer::locator_sect(loc()); address target = cb->locator_address(loc()); while (_patch_index > 0) { --_patch_index; int branch_loc; if (_patch_index >= PatchCacheSize) { branch_loc = _patch_overflow->pop(); } else { branch_loc = _patches[_patch_index]; } int branch_sect = CodeBuffer::locator_sect(branch_loc); address branch = cb->locator_address(branch_loc); if (branch_sect == CodeBuffer::SECT_CONSTS) { // The thing to patch is a constant word. *(address*)branch = target; continue; } #ifdef ASSERT // Cross-section branches only work if the // intermediate section boundaries are frozen. if (target_sect != branch_sect) { for (int n = MIN2(target_sect, branch_sect), nlimit = (target_sect + branch_sect) - n; n < nlimit; n++) { CodeSection* cs = cb->code_section(n); assert(cs->is_frozen(), "cross-section branch needs stable offsets"); } } #endif //ASSERT // Push the target offset into the branch instruction. masm->pd_patch_instruction(branch, target); } }
bool elim_bounds::is_bound(expr * n) { var * lower, * upper; return is_bound(n, lower, upper); }
oop bound_arg_oop() { assert(is_bound(), ""); return BoundMethodHandle_argument_oop(); }
int bound_arg_slot() { assert(is_bound(), ""); return _arg_slot; }
BasicType bound_arg_type() { assert(is_bound(), ""); return _arg_type; }
virtual void operator()( goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core) { SASSERT(g->is_well_sorted()); mc = 0; pc = 0; core = 0; m_trail.reset(); m_fd.reset(); m_max.reset(); m_nonfd.reset(); m_bounds.reset(); ref<bvmc> mc1 = alloc(bvmc); tactic_report report("eq2bv", *g); m_bounds(*g); for (unsigned i = 0; i < g->size(); i++) { collect_fd(g->form(i)); } cleanup_fd(mc1); if (m_max.empty()) { result.push_back(g.get()); return; } for (unsigned i = 0; i < g->size(); i++) { expr_ref new_curr(m); proof_ref new_pr(m); if (is_bound(g->form(i))) { g->update(i, m.mk_true(), 0, 0); continue; } m_rw(g->form(i), new_curr, new_pr); if (m.proofs_enabled() && !new_pr) { new_pr = m.mk_rewrite(g->form(i), new_curr); new_pr = m.mk_modus_ponens(g->pr(i), new_pr); } g->update(i, new_curr, new_pr, g->dep(i)); } obj_map<expr, unsigned>::iterator it = m_max.begin(), end = m_max.end(); for (; it != end; ++it) { expr* c = it->m_key; bool strict; rational r; if (m_bounds.has_lower(c, r, strict)) { SASSERT(!strict); expr* d = m_fd.find(c); g->assert_expr(bv.mk_ule(bv.mk_numeral(r, m.get_sort(d)), d), m_bounds.lower_dep(c)); } if (m_bounds.has_upper(c, r, strict)) { SASSERT(!strict); expr* d = m_fd.find(c); g->assert_expr(bv.mk_ule(d, bv.mk_numeral(r, m.get_sort(d))), m_bounds.upper_dep(c)); } } g->inc_depth(); mc = mc1.get(); result.push_back(g.get()); TRACE("pb", g->display(tout););