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););
