static SCM lookup (SCM x, SCM env) { int d = 0; for (; scm_is_pair (env); env = CDR (env), d++) { SCM link = CAR (env); if (env_link_is_flat (link)) { int w; SCM vars; for (vars = env_link_vars (link), w = scm_ilength (vars) - 1; scm_is_pair (vars); vars = CDR (vars), w--) if (scm_is_eq (x, (CAAR (vars)))) return make_pos (d, w); env_link_add_flat_var (link, x, lookup (x, CDR (env))); return make_pos (d, scm_ilength (env_link_vars (link)) - 1); } else { int w = try_lookup_rib (x, env_link_vars (link)); if (w < 0) continue; return make_pos (d, w); } } abort (); }
repv sys_get_mouse_pos(Lisp_Window *w) { int x, y; /* XXX track mouse pointer position in gtk_jade.c.. */ gtk_widget_get_pointer (GTK_WIDGET (w->w_Window), &x, &y); return make_pos((x - w->pixel_left) / w->font_width, (y - w->pixel_top) / w->font_height); }
/* * Handle the XML declaration so that we can determine its encoding. */ static void xmlDecl(IterParser *self, const XML_Char *version, const XML_Char *encoding, int standalone) { PyObject* tuple = NULL; PyObject* xml_str = NULL; PyObject* attrs = NULL; PyObject* encoding_str = NULL; PyObject* version_str = NULL; if (self->queue_write_idx < self->queue_size) { tuple = PyTuple_New(4); if (tuple == NULL) { XML_StopParser(self->parser, 0); return; } Py_INCREF(Py_True); PyTuple_SET_ITEM(tuple, 0, Py_True); xml_str = PyUnicode_FromString("xml"); PyTuple_SET_ITEM(tuple, 1, xml_str); attrs = PyDict_New(); if (encoding) { encoding_str = PyUnicode_FromString(encoding); } else { encoding_str = PyUnicode_FromString(""); } PyDict_SetItemString(attrs, "encoding", encoding_str); Py_DECREF(encoding_str); if (version) { version_str = PyUnicode_FromString(version); } else { version_str = PyUnicode_FromString(""); } PyDict_SetItemString(attrs, "version", version_str); Py_DECREF(version_str); PyTuple_SET_ITEM(tuple, 2, attrs); self->last_line = (unsigned long)XML_GetCurrentLineNumber( self->parser); self->last_col = (unsigned long)XML_GetCurrentColumnNumber( self->parser); PyTuple_SET_ITEM(tuple, 3, make_pos(self)); self->queue[self->queue_write_idx++] = tuple; } else { PyErr_SetString( PyExc_RuntimeError, "XML queue overflow in xmlDecl. This most likely indicates an internal bug."); } }
Particle( const double _pos [3], const double _vel [3], const double _acc2[3], const double _jrk6[3], const double _mass, const double _time) : time(_time) { make_pos(_pos, &_mass); vel = make_v4sf(_vel); acc2 = make_v4sf(_acc2); jrk6 = make_v4sf(_jrk6); }
Particle( const double _pos [3], const double _vel [3], const double _acc2[3], const double _jrk6[3], const double _mass, const double _time) { make_pos(_pos, &_mass); vel = make_v4sf(_vel); acc2 = make_v4sf(_acc2); jrk6 = make_v4sf(_jrk6); time = (v2df){_time, _time}; }
void predicate_image_satqe( message_handlert &message_handler, const std::vector<exprt> &deref_curr_predicates, const std::vector<exprt> &deref_next_predicates, const std::list<exprt> &constraints, symex_target_equationt &equation, const namespacet &ns, abstract_transition_relationt & abstract_transition_relation) { const std::set<unsigned> &from_predicates= abstract_transition_relation.from_predicates; const std::set<unsigned> &to_predicates= abstract_transition_relation.to_predicates; assert(to_predicates.size()!=0); // create SAT solver object satqe_satcheckt satqe; bv_pointerst solver(satqe); solver.unbounded_array=boolbvt::U_ALL; solver.set_message_handler(message_handler); // turn equation into CNF equation.convert(solver); for(std::set<unsigned>::const_iterator it=from_predicates.begin(); it!=from_predicates.end(); it++) { unsigned i=*it; literalt li=make_pos(ns, solver, deref_curr_predicates[i]); satqe.quantify(li); } for(std::set<unsigned>::const_iterator it=to_predicates.begin(); it!=to_predicates.end(); it++) { unsigned i=*it; literalt lo=make_pos(ns, solver, deref_next_predicates[i]); satqe.quantify(lo); } // we want cubes cube_sett cube_set; satqe.set_cube_set(cube_set); // solve it switch(solver.dec_solve()) { case decision_proceduret::D_UNSATISFIABLE: // OK, this is what we expect break; default: throw "unexpected result from satqe.solve()"; } message_handler.print(9, "Generated "+ i2string(cube_set.no_insertions())+" cube(s)"); #if 0 std::cout << cube_set; #endif exprt constraint_cubes_disj = true_exprt(); // convert the cubes into constraints for(cubest::star_mapt::const_iterator it=cube_set.star_map.begin(); it!=cube_set.star_map.end(); it++) { for(cubest::bitssett::const_iterator it2=it->second.begin(); it2!=it->second.end(); it2++) { exprt constraint_cube_conj; unsigned bit=0; unsigned i=0; /* Assume it->first[i] is true iff the i-th predicate is in the cube. Assume predicates are stored in it->first in the order of from_predicates followed by to_predicates. Scan it->first and from/to_predicates in parallel to get the cube. */ for(std::set<unsigned>::const_iterator it3=from_predicates.begin(); it3!=from_predicates.end(); it3++) { unsigned id=*it3; if(!it->first[i]) { constraint_cube_conj.operands().push_back(exprt()); exprt &e=constraint_cube_conj.operands().back(); e=exprt(ID_predicate_symbol, typet(ID_bool)); e.set(ID_identifier, id); if(!(*it2)[bit]) e.make_not(); bit++; #if 0 std::cout << "C: " << from_expr(ns, "", e) << std::endl; #endif } i++; } for(std::set<unsigned>::const_iterator it3=to_predicates.begin(); it3!=to_predicates.end(); it3++) { unsigned id=*it3; if(!it->first[i]) { constraint_cube_conj.operands().push_back(exprt()); exprt &e=constraint_cube_conj.operands().back(); e=exprt(ID_predicate_next_symbol, typet(ID_bool)); e.set(ID_identifier, id); if(!(*it2)[bit]) e.make_not(); bit++; #if 0 std::cout << "C: " << from_expr(ns, "", e) << std::endl; #endif } i++; } assert(i==it->first.size()); /* Convert the cube into a conjunct. */ gen_and(constraint_cube_conj); /* Add the conjunct in disjunction to previous cubes. */ if(constraint_cubes_disj.is_true()) constraint_cubes_disj=constraint_cube_conj; else constraint_cubes_disj=gen_or( constraint_cubes_disj, constraint_cube_conj); } } /* Add the cubes to the contraints of the abstract transition relation. Warning: we may want to remove old constrains. */ abstract_transition_relation.constraints.push_back(constraint_cubes_disj); }
bool refiner_wpt::refine_prefix( predicatest &predicates, abstract_modelt &abstract_model, const fail_infot &fail_info) { status("Refining set of predicates according to counterexample (WP)"); reset_num_predicates_added(); bool found_new=false; // keep track of the loops that we're in (may be nested) std::list<fail_infot::induction_infot> loops; exprt invariant; if(fail_info.use_invariants) status("Using recurrence predicates detected by loop detection."); print(10, "refiner_wpt::refine_prefix_async 1"); print(10, "Inconsistent prefix:"); for(abstract_counterexamplet::stepst::const_reverse_iterator r_it=fail_info.steps.rbegin(); r_it!=fail_info.steps.rend(); r_it++) { std::stringstream str; abstract_programt::targett abstract_pc=r_it->pc; goto_programt::const_targett concrete_pc= abstract_pc->code.concrete_pc; if(concrete_pc->is_goto()) str << "GUARD: " << (r_it->branch_taken?"(":"!(") << from_expr(concrete_model.ns, "", concrete_pc->guard) << ")"; else if(concrete_pc->is_assert()) str << "ASSERT: " << from_expr(concrete_model.ns, "", concrete_pc->guard); else if(concrete_pc->is_location()) str << "LOC" << std::endl; else if(concrete_pc->is_other() || concrete_pc->is_assign() || concrete_pc->is_decl()) str << from_expr(concrete_model.ns, "", concrete_pc->code); else { str << concrete_pc->type; } str << " // " << (concrete_pc->location); str << std::endl << "**********"; print(10, str.str()); } { // get the constraint causing the failure exprt predicate=fail_info.guard; #ifdef DEBUG std::cout << "P start0: " << from_expr(concrete_model.ns, "", predicate) << std::endl; #endif simplify(predicate, concrete_model.ns); abstract_counterexamplet::stepst::const_iterator it=--fail_info.steps.end(); // there must be at least two steps, or it's odd assert(it!=fail_info.steps.begin()); { abstract_programt::targett abstract_pc=it->pc; #ifdef DEBUG std::cout << "P start1: " << from_expr(concrete_model.ns, "", predicate) << std::endl; #endif add_predicates( abstract_pc, predicates, predicate, found_new, FROM); } // now do the WPs goto_symex_statet renaming_state; renaming_state.source.thread_nr=it->thread_nr; renaming_state.rename(predicate, concrete_model.ns, goto_symex_statet::L0); for(it--; // skip last instruction it!=fail_info.steps.begin(); it--) { #ifdef DEBUG std::cout << "refiner_wpt::refine_prefix_async 2\n"; #endif // handle loops if(fail_info.use_invariants) { if(it->is_loop_begin()) { loops.pop_back(); // pop induction_info if we leave loop #ifdef DEBUG std::cout << "INV: " << from_expr(concrete_model.ns, "", invariant) << std::endl; #endif exprt wp(ID_and, typet(ID_bool)); wp.operands().resize(2); wp.op0().swap(invariant); wp.op1().swap(predicate); predicate.swap(wp); } else if (it->is_loop_end()) { push_induction_info(fail_info, it, loops); invariant.make_true(); } } if(!it->is_state()) continue; if(predicate.is_true() && found_new) { // ok, refuted it, done break; } // add the predicate goto_programt::const_targett concrete_pc= it->pc->code.concrete_pc; abstract_programt::targett abstract_pc=it->pc; #ifdef DEBUG std::cout << from_expr(concrete_model.ns, "", predicate) << std::endl; #endif exprt no_tid_predicate=predicate; renaming_state.get_original_name(no_tid_predicate); add_predicates(abstract_pc, predicates, no_tid_predicate, found_new, TO); // skip irrelevant instructions if(!it->relevant) continue; exprt pred_bak=predicate; #ifdef DEBUG goto_programt tmp; tmp.output_instruction(concrete_model.ns, "", std::cerr, concrete_pc); #endif // compute weakest precondition switch(it->pc->type) { case ASSUME: // we only do this for assumptions // if we haven't found a new predicate so far if(1/*!found_new*/) { exprt tid_guard=concrete_pc->guard; renaming_state.source.thread_nr=it->thread_nr; renaming_state.rename(tid_guard, concrete_model.ns, goto_symex_statet::L0); predicate=implies_exprt(tid_guard, predicate); simplify(predicate, concrete_model.ns); } break; case GOTO: { exprt tid_guard=concrete_pc->guard; if(!it->branch_taken) tid_guard.make_not(); renaming_state.source.thread_nr=it->thread_nr; renaming_state.rename(tid_guard, concrete_model.ns, goto_symex_statet::L0); predicate=implies_exprt(tid_guard, predicate); simplify(predicate, concrete_model.ns); } break; case OTHER: /* Ignore if user-specified predicate, otherwise treat like assign */ if(it->pc->code.concrete_pc->code.get_statement()==ID_user_specified_predicate || it->pc->code.concrete_pc->code.get_statement()==ID_user_specified_parameter_predicates || it->pc->code.concrete_pc->code.get_statement()==ID_user_specified_return_predicates) break; case DECL: case ASSIGN: #ifdef DEBUG std::cout << "OTHER/ASSIGN/DECL\n"; #endif { codet tid_tmp_code; if(!fail_info.use_invariants || !get_instruction(concrete_pc, loops, tid_tmp_code, invariant)) tid_tmp_code=to_code(concrete_pc->code); #ifdef DEBUG std::cout << "A P before: " << from_expr(concrete_model.ns, "", predicate) << std::endl; std::cout << "Code: " << from_expr(concrete_model.ns, "", tid_tmp_code) << std::endl; #endif // compute weakest precondition if(tid_tmp_code.get_statement()==ID_assign) approximate_nondet(to_code_assign(tid_tmp_code).rhs()); renaming_state.source.thread_nr=it->thread_nr; renaming_state.rename(tid_tmp_code, concrete_model.ns, goto_symex_statet::L0); exprt predicate_wp=wp(tid_tmp_code, predicate, concrete_model.ns); simplify(predicate_wp, concrete_model.ns); predicate=predicate_wp; #ifdef DEBUG std::cout << "A P after: " << from_expr(concrete_model.ns, "", predicate) << std::endl; #endif } break; default: // ignore break; } #ifdef DEBUG std::cout << "B P to-check: " << from_expr(concrete_model.ns, "", predicate) << std::endl; #endif if(pred_bak != predicate) { satcheckt satcheck; bv_pointerst solver(concrete_model.ns, satcheck); solver.unbounded_array=boolbvt::U_NONE; literalt li=make_pos(concrete_model.ns, solver, predicate); satcheck.set_assumptions(bvt(1, li)); propt::resultt result=satcheck.prop_solve(); assert(propt::P_SATISFIABLE==result || propt::P_UNSATISFIABLE==result); if(propt::P_UNSATISFIABLE==result) predicate.make_false(); else { satcheck.set_assumptions(bvt(1, li.negation())); propt::resultt result=satcheck.prop_solve(); assert(propt::P_SATISFIABLE==result || propt::P_UNSATISFIABLE==result); if(propt::P_UNSATISFIABLE==result) { predicate.make_true(); if(it->pc->type==ASSIGN) { const codet &code=concrete_pc->code; if(code.get_statement()==ID_assign) { equal_exprt pred_new(to_code_assign(code).lhs(), to_code_assign(code).rhs()); simplify(pred_new, concrete_model.ns); #ifdef DEBUG std::cout << "Adding new predicate as we arrived at TRUE: " << from_expr(concrete_model.ns, "", pred_new) << std::endl; #endif no_tid_predicate=pred_new; renaming_state.get_original_name(no_tid_predicate); add_predicates(abstract_pc, predicates, no_tid_predicate, found_new, FROM); } } else if(it->pc->type==ASSUME || it->pc->type==GOTO) { exprt pred_new=concrete_pc->guard; simplify(pred_new, concrete_model.ns); #ifdef DEBUG std::cout << "Adding new predicate as we arrived at TRUE: " << from_expr(concrete_model.ns, "", pred_new) << std::endl; #endif no_tid_predicate=pred_new; renaming_state.get_original_name(no_tid_predicate); add_predicates(abstract_pc, predicates, no_tid_predicate, found_new, FROM); } } } } #ifdef DEBUG std::cout << "B P after: " << from_expr(concrete_model.ns, "", predicate) << std::endl; #endif no_tid_predicate=predicate; renaming_state.get_original_name(no_tid_predicate); add_predicates(abstract_pc, predicates, no_tid_predicate, found_new, FROM); } if(!predicate.is_true() && fail_info.warn_on_failure) { warning("Failed to refute spurious trace with WPs (got "+ from_expr(concrete_model.ns, "", predicate)+")"); } } if(found_new && fail_info.use_invariants) { add_induction_predicates( fail_info, abstract_model, predicates); } // make sure we have progress return !found_new; }
/* * Handle the expat endElement event. */ static void endElement(IterParser *self, const XML_Char *name) { PyObject* pyname = NULL; PyObject* tuple = NULL; PyObject* pytext = NULL; const XML_Char* name_start = NULL; XML_Char* end; PyObject* pos = NULL; /* If we've already had an error in a previous call, don't make things worse. */ if (PyErr_Occurred() != NULL) { XML_StopParser(self->parser, 0); return; } /* Don't overflow the queue -- in practice this should *never* happen */ if (self->queue_write_idx < self->queue_size) { tuple = PyTuple_New(4); if (tuple == NULL) { goto fail; } Py_INCREF(Py_False); PyTuple_SET_ITEM(tuple, 0, Py_False); /* This is an egregious but effective optimization. Since by far the most frequently occurring element name in a large VOTABLE file is TD, we explicitly check for it here with integer comparison to avoid the lookup in the interned string table in PyString_InternFromString, and return a singleton string for "TD" */ if ((*(int*)name & TD_AS_INT_MASK) == TD_AS_INT) { Py_INCREF(self->td_singleton); PyTuple_SetItem(tuple, 1, self->td_singleton); } else { name_start = remove_namespace(name); pyname = PyUnicode_FromString(name_start); if (pyname == NULL) { goto fail; } PyTuple_SetItem(tuple, 1, pyname); pyname = NULL; } /* Cut whitespace off the end of the string */ end = self->text + self->text_size - 1; while (end >= self->text && IS_WHITESPACE(*end)) { --end; --self->text_size; } pytext = PyUnicode_FromStringAndSize(self->text, self->text_size); if (pytext == NULL) { goto fail; } PyTuple_SetItem(tuple, 2, pytext); pytext = NULL; pos = make_pos(self); if (pos == NULL) { goto fail; } PyTuple_SetItem(tuple, 3, pos); pos = NULL; self->keep_text = 0; self->queue[self->queue_write_idx++] = tuple; } else { PyErr_SetString( PyExc_RuntimeError, "XML queue overflow in endElement. This most likely indicates an internal bug."); goto fail; } return; fail: Py_XDECREF(tuple); XML_StopParser(self->parser, 0); }
/* * Handle the expat startElement event. */ static void startElement(IterParser *self, const XML_Char *name, const XML_Char **atts) { PyObject* pyname = NULL; PyObject* pyatts = NULL; const XML_Char** att_ptr = atts; const XML_Char* name_start = NULL; PyObject* tuple = NULL; PyObject* key = NULL; PyObject* val = NULL; PyObject* pos = NULL; /* If we've already had an error in a previous call, don't make things worse. */ if (PyErr_Occurred() != NULL) { XML_StopParser(self->parser, 0); return; } /* Don't overflow the queue -- in practice this should *never* happen */ if (self->queue_write_idx < self->queue_size) { tuple = PyTuple_New(4); if (tuple == NULL) { goto fail; } Py_INCREF(Py_True); PyTuple_SET_ITEM(tuple, 0, Py_True); /* This is an egregious but effective optimization. Since by far the most frequently occurring element name in a large VOTABLE file is TD, we explicitly check for it here with integer comparison to avoid the lookup in the interned string table in PyString_InternFromString, and return a singleton string for "TD" */ if ((*(int*)name & TD_AS_INT_MASK) == TD_AS_INT) { Py_INCREF(self->td_singleton); PyTuple_SetItem(tuple, 1, self->td_singleton); } else { name_start = remove_namespace(name); pyname = PyUnicode_FromString(name_start); if (pyname == NULL) { goto fail; } PyTuple_SetItem(tuple, 1, pyname); pyname = NULL; } if (*att_ptr) { pyatts = PyDict_New(); if (pyatts == NULL) { goto fail; } do { if (*(*(att_ptr + 1)) != 0) { key = PyUnicode_FromString(*att_ptr); if (key == NULL) { goto fail; } val = PyUnicode_FromString(*(att_ptr + 1)); if (val == NULL) { Py_DECREF(key); goto fail; } if (PyDict_SetItem(pyatts, key, val)) { Py_DECREF(key); Py_DECREF(val); goto fail; } Py_DECREF(key); Py_DECREF(val); key = val = NULL; } att_ptr += 2; } while (*att_ptr); } else { Py_INCREF(self->dict_singleton); pyatts = self->dict_singleton; } PyTuple_SetItem(tuple, 2, pyatts); pyatts = NULL; self->last_line = (unsigned long)XML_GetCurrentLineNumber( self->parser); self->last_col = (unsigned long)XML_GetCurrentColumnNumber( self->parser); pos = make_pos(self); if (pos == NULL) { goto fail; } PyTuple_SetItem(tuple, 3, pos); pos = NULL; text_clear(self); self->keep_text = 1; self->queue[self->queue_write_idx++] = tuple; } else { PyErr_SetString( PyExc_RuntimeError, "XML queue overflow in startElement. This most likely indicates an internal bug."); goto fail; } return; fail: Py_XDECREF(tuple); Py_XDECREF(pyatts); XML_StopParser(self->parser, 0); }
bool transition_refinert::check_guarded_transition( const predicatest &predicates, const abstract_stept &abstract_state_from, unsigned passive_id, bool &inconsistent_initial_state) { // get the concrete basic block const goto_programt::instructiont &c_instruction= *abstract_state_from.pc->code.concrete_pc; if (!c_instruction.is_goto() && !c_instruction.is_assume()) return false; // whatever // this is the original guard exprt guard=c_instruction.guard; if(guard.is_true()) // boring return false; // we might need to negate it if the branch was not taken if (c_instruction.is_goto() && !abstract_state_from.branch_taken) guard.make_not(); abstract_transition_relationt &abstract_transition_relation= abstract_state_from.pc->code.get_transition_relation(); #ifdef SATCHECK_MINISAT2 satcheck_minisat_no_simplifiert satcheck; #else satcheckt satcheck; #endif bv_pointerst solver(concrete_model.ns, satcheck); solver.unbounded_array=boolbvt::U_NONE; // Note that we take "thread_nr" from "abstract_state_from", not from "abstract_state_to", as the "from" state determines which thread is executing const unsigned active_id=abstract_state_from.thread_nr; const unsigned num_threads=abstract_state_from.thread_states.size(); std::vector<predicatest> active_passive_preds(num_threads, predicatest()); for(unsigned int t=0; t < num_threads; ++t) { if(active_id!=t && passive_id < num_threads && t!=passive_id) continue; for(unsigned int i = 0; i < predicates.size(); i++) { active_passive_preds[t].lookup(active_id==t? predicates[i] : predicatest::make_expr_passive(predicates[i], concrete_model.ns, t)); } assert(active_passive_preds[t].size() == predicates.size()); } std::vector<std::vector<literalt> > predicate_variables_from(num_threads, std::vector<literalt>(predicates.size(), literalt())); bvt assumptions; std::vector<abstract_stept::thread_to_predicate_valuest::const_iterator> from_predicates(num_threads, abstract_state_from.thread_states.end()); for(unsigned int t=0; t < num_threads; ++t) { from_predicates[t]=abstract_state_from.thread_states.find(t); assert(abstract_state_from.thread_states.end() != from_predicates[t]); } // we use all predicates in order to also find constraints over invalid // from states for(unsigned i=0; i < predicates.size(); ++i) { for(unsigned int t=0; t < num_threads; ++t) { if(active_id!=t && passive_id < num_threads && t!=passive_id) continue; // not sure whether we really want the following check if(active_id!=t && active_passive_preds[t][i]==predicates[i]) continue; literalt li=make_pos(concrete_model.ns, solver, active_passive_preds[t][i]); predicate_variables_from[t][i]=li; assumptions.push_back(li.cond_negation( !from_predicates[t]->second[i])); #ifdef DEBUG const std::string predname= (active_id==t?"P#":"PP"+i2string(t)+"#")+i2string(i); std::cerr << "G-F: " << predname << ": " << (from_predicates[t]->second[i]?"":"!") << "(" << from_expr(concrete_model.ns, "", active_passive_preds[t][i]) << ")" << std::endl; #endif } } satcheck.set_assumptions(assumptions); if(!is_satisfiable(solver)) { if(passive_id >= num_threads) { const std::string opt="Invalid states requiring more than 1 passive thread"; assert(stats.find(opt)!=stats.end()); ++(stats[opt].val); } inconsistent_initial_state = true; print(9, "Guarded transition spurious due to invalid abstract state"); return false; // this has to be fixed in the respective assignment } // now add the guard solver.set_to_true(guard); // solve it incrementally if(is_satisfiable(solver)) { print(9, "Transition is OK"); #ifdef DEBUG std::cout << "********\n"; solver.print_assignment(std::cout); std::cout << "********\n"; #endif return false; // ok } if(passive_id >= num_threads) { const std::string opt="Spurious guard transitions requiring more than 1 passive thread"; assert(stats.find(opt)!=stats.end()); ++(stats[opt].val); return false; // can't do anything } print(9, "Guarded transition is spurious, refining"); exprt condition; for(unsigned i=0; i < predicates.size(); ++i) { if(satcheck.is_in_conflict(predicate_variables_from[active_id][i])) { condition.operands().push_back(exprt()); exprt &e=condition.operands().back(); e=exprt(ID_predicate_symbol, bool_typet()); e.set(ID_identifier, i); if(!from_predicates[active_id]->second[i]) e.make_not(); #ifdef DEBUG std::cout << "G-C: " << from_expr(concrete_model.ns, "", e) << std::endl; #endif } if(passive_id!=active_id && satcheck.is_in_conflict(predicate_variables_from[passive_id][i])) { condition.operands().push_back(exprt()); exprt &e=condition.operands().back(); e=exprt(ID_predicate_passive_symbol, bool_typet()); e.set(ID_identifier, i); if(!from_predicates[passive_id]->second[i]) e.make_not(); #ifdef DEBUG std::cout << "G-C-F: " << from_expr(concrete_model.ns, "", e) << std::endl; #endif } } gen_and(condition); if(c_instruction.is_goto()) { bool neg=abstract_state_from.branch_taken; constrain_goto_transition(abstract_transition_relation, condition, neg); } else { assert(c_instruction.is_assume()); constrain_assume_transition(abstract_transition_relation, condition); } // spurious return true; }
bool transition_refinert::check_assignment_transition( const predicatest &predicates, const abstract_stept &abstract_state_from, const abstract_stept &abstract_state_to, unsigned passive_id) { // Note that we take "thread_nr" from "abstract_state_from", not from "abstract_state_to", as the "from" state determines which thread is executing const unsigned active_id=abstract_state_from.thread_nr; const unsigned num_threads=abstract_state_from.thread_states.size(); std::vector<predicatest> active_passive_preds(num_threads, predicatest()); std::vector<std::vector<exprt> > predicates_wp(num_threads, std::vector<exprt>()); std::list<exprt> constraints; for(unsigned int t=0; t < num_threads; ++t) { if(active_id!=t && passive_id < num_threads && t!=passive_id) continue; for(unsigned int i = 0; i < predicates.size(); i++) { active_passive_preds[t].lookup(active_id==t? predicates[i] : predicatest::make_expr_passive(predicates[i], concrete_model.ns, t)); } assert(active_passive_preds[t].size() == predicates.size()); std::list<exprt> constraints_t; build_equation( concrete_model.ns, active_passive_preds[t], abstract_state_from.pc->code.concrete_pc, constraints_t, predicates_wp[t]); constraints.splice(constraints.end(), constraints_t); } // create SAT solver object satcheckt satcheck; bv_pointerst solver(concrete_model.ns, satcheck); solver.unbounded_array=boolbvt::U_NONE; // convert constraints for(std::list<exprt>::const_iterator it=constraints.begin(); it!=constraints.end(); it++) { exprt tmp(*it); solver.set_to_true(tmp); } abstract_transition_relationt &abstract_transition_relation= abstract_state_from.pc->code.get_transition_relation(); std::vector<std::vector<literalt> > predicate_variables_from(num_threads, std::vector<literalt>(predicates.size(), literalt())), predicate_variables_to(num_threads, std::vector<literalt>(predicates.size(), literalt())); bvt assumptions; std::vector<abstract_stept::thread_to_predicate_valuest::const_iterator> from_predicates(num_threads, abstract_state_from.thread_states.end()), to_predicates(num_threads, abstract_state_to.thread_states.end()); for(unsigned int t=0; t < num_threads; ++t) { from_predicates[t]=abstract_state_from.thread_states.find(t); assert(abstract_state_from.thread_states.end() != from_predicates[t]); to_predicates[t]=abstract_state_to.thread_states.find(t); assert(abstract_state_to.thread_states.end() != to_predicates[t]); } // we use all predicates in order to also find constraints over invalid // from/to states for(unsigned i=0; i < predicates.size(); ++i) { assert(abstract_transition_relation.to_predicates.find(i) != abstract_transition_relation.to_predicates.end() || abstract_transition_relation.from_predicates.find(i) != abstract_transition_relation.from_predicates.end() || (from_predicates[active_id]->second[i] == to_predicates[active_id]->second[i] && (passive_id >= num_threads || from_predicates[passive_id]->second[i] == to_predicates[passive_id]->second[i]))); for(unsigned int t=0; t < num_threads; ++t) { if(active_id!=t && passive_id < num_threads && t!=passive_id) continue; // not sure whether we really want the following check if(active_id!=t && active_passive_preds[t][i]==predicates[i]) continue; literalt li=make_pos(concrete_model.ns, solver, active_passive_preds[t][i]); predicate_variables_from[t][i]=li; assumptions.push_back(li.cond_negation( !from_predicates[t]->second[i])); #ifdef DEBUG const std::string predname= (active_id==t?"P#":"PP"+i2string(t)+"#")+i2string(i); std::cerr << "F: " << predname << ": " << (from_predicates[t]->second[i]?"":"!") << "(" << from_expr(concrete_model.ns, "", active_passive_preds[t][i]) << ")" << std::endl; #endif literalt lo=make_pos(concrete_model.ns, solver, predicates_wp[t][i]); predicate_variables_to[t][i]=lo; assumptions.push_back(lo.cond_negation( !to_predicates[t]->second[i])); #ifdef DEBUG std::cerr << "T: " << predname << ": " << (to_predicates[t]->second[i]?"":"!") << "(" << from_expr(concrete_model.ns, "", predicates_wp[t][i]) << ")" << std::endl; #endif } } satcheck.set_assumptions(assumptions); // solve it if(is_satisfiable(solver)) { print(9, "Transition is OK"); #ifdef DEBUG std::cout << "********\n"; solver.print_assignment(std::cout); std::cout << "********\n"; #endif return false; // ok } if(passive_id >= num_threads) { const std::string opt="Spurious assignment transitions requiring more than 1 passive thread"; assert(stats.find(opt)!=stats.end()); ++(stats[opt].val); return false; // can't do anything } print(9, "Assignment transition is spurious, refining"); exprt constraint; for(unsigned i=0; i < predicates.size(); ++i) { if(satcheck.is_in_conflict(predicate_variables_from[active_id][i])) { constraint.operands().push_back(exprt()); exprt &e=constraint.operands().back(); e=exprt(ID_predicate_symbol, bool_typet()); e.set(ID_identifier, i); if(from_predicates[active_id]->second[i]) e.make_not(); #ifdef DEBUG std::cout << "C-F: " << from_expr(concrete_model.ns, "", e) << std::endl; #endif } if(passive_id!=active_id && satcheck.is_in_conflict(predicate_variables_from[passive_id][i])) { constraint.operands().push_back(exprt()); exprt &e=constraint.operands().back(); e=exprt(ID_predicate_passive_symbol, bool_typet()); e.set(ID_identifier, i); if(from_predicates[passive_id]->second[i]) e.make_not(); #ifdef DEBUG std::cout << "C-F: " << from_expr(concrete_model.ns, "", e) << std::endl; #endif } if(satcheck.is_in_conflict(predicate_variables_to[active_id][i])) { constraint.operands().push_back(exprt()); exprt &e=constraint.operands().back(); e=exprt(ID_predicate_next_symbol, bool_typet()); e.set(ID_identifier, i); if(to_predicates[active_id]->second[i]) e.make_not(); #ifdef DEBUG std::cout << "C-T: " << from_expr(concrete_model.ns, "", e) << std::endl; #endif } if(passive_id!=active_id && satcheck.is_in_conflict(predicate_variables_to[passive_id][i])) { constraint.operands().push_back(exprt()); exprt &e=constraint.operands().back(); e=exprt(ID_next_symbol, bool_typet()); e.operands().resize(1); e.op0()=exprt(ID_predicate_passive_symbol, bool_typet()); e.op0().set(ID_identifier, i); if(to_predicates[passive_id]->second[i]) e.make_not(); #ifdef DEBUG std::cout << "C-T: " << from_expr(concrete_model.ns, "", e) << std::endl; #endif } } #ifdef DEBUG ::std::cerr << "Spurious in thread " << passive_id << " (active: " << abstract_state_from.thread_nr << "): " << ::std::endl; ::std::cerr << abstract_state_from << ::std::endl; goto_programt tmp; tmp.output_instruction(concrete_model.ns, "", std::cerr, abstract_state_from.pc->code.concrete_pc); ::std::cerr << abstract_state_to << ::std::endl; #endif if(constraint.operands().empty()) constraint.make_false(); // this can happen if else // the invariants are inconsistent gen_or(constraint); abstract_transition_relation.constraints.push_back(constraint); // spurious! return true; }
/* * Handle the expat startElement event. */ static void startElement(IterParser *self, const XML_Char *name, const XML_Char **atts) { PyObject* pyname = NULL; PyObject* pyatts = NULL; const XML_Char** att_ptr = atts; const XML_Char* name_start = NULL; PyObject* tuple = NULL; PyObject* key = NULL; PyObject* val = NULL; /* If we've already had an error in a previous call, don't make things worse. */ if (PyErr_Occurred() != NULL) { XML_StopParser(self->parser, 0); return; } /* Don't overflow the queue -- in practice this should *never* happen */ if (self->queue_write_idx < self->queue_size) { tuple = PyTuple_New(4); if (tuple == NULL) { XML_StopParser(self->parser, 0); return; } Py_INCREF(Py_True); PyTuple_SET_ITEM(tuple, 0, Py_True); /* This is an egregious but effective optimization. Since by far the most frequently occurring element name in a large VOTABLE file is TD, we explicitly check for it here with integer comparison to avoid the lookup in the interned string table in PyString_InternFromString, and return a singleton string for "TD" */ if ((*(int*)name & TD_AS_INT_MASK) == TD_AS_INT) { Py_INCREF(self->td_singleton); PyTuple_SetItem(tuple, 1, self->td_singleton); } else { name_start = remove_namespace(name); pyname = PyUnicode_FromString(name_start); if (pyname == NULL) { Py_DECREF(tuple); XML_StopParser(self->parser, 0); return; } PyTuple_SetItem(tuple, 1, pyname); } if (*att_ptr) { pyatts = PyDict_New(); if (pyatts == NULL) { Py_DECREF(tuple); XML_StopParser(self->parser, 0); return; } do { if (*(*(att_ptr + 1)) != 0) { /* Python < 2.6.5 can't handle unicode keyword arguments. Since those were coming from here (the dictionary of attributes), we use byte strings for the keys instead. Should be fine for VOTable, since it has ascii attribute names, but that's not true of XML in general. */ #if PY_VERSION_HEX < 0x02060500 /* Due to Python issue #4978 */ key = PyBytes_FromString(*att_ptr); #else key = PyUnicode_FromString(*att_ptr); #endif if (key == NULL) { Py_DECREF(tuple); XML_StopParser(self->parser, 0); return; } val = PyUnicode_FromString(*(att_ptr + 1)); if (val == NULL) { Py_DECREF(key); Py_DECREF(tuple); XML_StopParser(self->parser, 0); return; } if (PyDict_SetItem(pyatts, key, val)) { Py_DECREF(pyatts); Py_DECREF(tuple); Py_DECREF(key); Py_DECREF(val); XML_StopParser(self->parser, 0); return; } Py_DECREF(key); Py_DECREF(val); } att_ptr += 2; } while (*att_ptr); } else { Py_INCREF(self->dict_singleton); pyatts = self->dict_singleton; } PyTuple_SetItem(tuple, 2, pyatts); self->last_line = (unsigned long)XML_GetCurrentLineNumber( self->parser); self->last_col = (unsigned long)XML_GetCurrentColumnNumber( self->parser); PyTuple_SetItem(tuple, 3, make_pos(self)); text_clear(self); self->keep_text = 1; self->queue[self->queue_write_idx++] = tuple; } else { PyErr_SetString( PyExc_RuntimeError, "XML queue overflow in startElement. This most likely indicates an internal bug."); } }