mirror of
https://github.com/Z3Prover/z3
synced 2025-10-28 10:19:23 +00:00
merge with master
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner
commit
c513f3ca09
883 changed files with 13979 additions and 16480 deletions
|
|
@ -82,7 +82,7 @@ namespace datalog {
|
|||
void get_labels(proof* p, labels&);
|
||||
|
||||
public:
|
||||
boogie_proof(ast_manager& m): m(m), m_proof(m), m_model(0) {}
|
||||
boogie_proof(ast_manager& m): m(m), m_proof(m), m_model(nullptr) {}
|
||||
|
||||
void set_proof(proof* p);
|
||||
|
||||
|
|
|
|||
|
|
@ -90,10 +90,10 @@ namespace datalog {
|
|||
return idx;
|
||||
}
|
||||
|
||||
virtual unsigned get_constant_count() const {
|
||||
unsigned get_constant_count() const override {
|
||||
return m_el_names.size();
|
||||
}
|
||||
virtual void print_element(finite_element el_num, std::ostream & out) {
|
||||
void print_element(finite_element el_num, std::ostream & out) override {
|
||||
if (el_num>=m_el_names.size()) {
|
||||
out << el_num;
|
||||
return;
|
||||
|
|
@ -132,10 +132,10 @@ namespace datalog {
|
|||
}
|
||||
return idx;
|
||||
}
|
||||
virtual unsigned get_constant_count() const {
|
||||
unsigned get_constant_count() const override {
|
||||
return m_el_names.size();
|
||||
}
|
||||
virtual void print_element(finite_element el_num, std::ostream & out) {
|
||||
void print_element(finite_element el_num, std::ostream & out) override {
|
||||
if (el_num >= m_el_names.size()) {
|
||||
out << "<unk " << m_sort->get_name() << ":" << el_num << '>';
|
||||
return;
|
||||
|
|
@ -154,14 +154,14 @@ namespace datalog {
|
|||
rule_set* m_old_rules;
|
||||
void reset() {
|
||||
dealloc(m_old_rules);
|
||||
m_old_rules = 0;
|
||||
m_old_rules = nullptr;
|
||||
}
|
||||
public:
|
||||
restore_rules(rule_set& r): m_old_rules(alloc(rule_set, r)) {}
|
||||
|
||||
virtual ~restore_rules() {}
|
||||
~restore_rules() override {}
|
||||
|
||||
virtual void undo(context& ctx) {
|
||||
void undo(context& ctx) override {
|
||||
ctx.replace_rules(*m_old_rules);
|
||||
reset();
|
||||
}
|
||||
|
|
@ -173,8 +173,8 @@ namespace datalog {
|
|||
unsigned m_old_size;
|
||||
public:
|
||||
restore_vec_size_trail(Vec& v): m_vector(v), m_old_size(v.size()) {}
|
||||
virtual ~restore_vec_size_trail() {}
|
||||
virtual void undo(Ctx& ctx) { m_vector.shrink(m_old_size); }
|
||||
~restore_vec_size_trail() override {}
|
||||
void undo(Ctx& ctx) override { m_vector.shrink(m_old_size); }
|
||||
};
|
||||
|
||||
void context::push() {
|
||||
|
|
@ -221,9 +221,9 @@ namespace datalog {
|
|||
m_rule_fmls_head(0),
|
||||
m_rule_fmls(m),
|
||||
m_background(m),
|
||||
m_mc(0),
|
||||
m_rel(0),
|
||||
m_engine(0),
|
||||
m_mc(nullptr),
|
||||
m_rel(nullptr),
|
||||
m_engine(nullptr),
|
||||
m_closed(false),
|
||||
m_saturation_was_run(false),
|
||||
m_enable_bind_variables(true),
|
||||
|
|
@ -251,8 +251,8 @@ namespace datalog {
|
|||
m_preds.reset();
|
||||
m_preds_by_name.reset();
|
||||
reset_dealloc_values(m_sorts);
|
||||
m_engine = 0;
|
||||
m_rel = 0;
|
||||
m_engine = nullptr;
|
||||
m_rel = nullptr;
|
||||
}
|
||||
|
||||
bool context::is_fact(app * head) const {
|
||||
|
|
@ -400,7 +400,7 @@ namespace datalog {
|
|||
}
|
||||
uint64 res;
|
||||
if (!try_get_sort_constant_count(srt, res)) {
|
||||
sort_size sz = srt->get_num_elements();
|
||||
const sort_size & sz = srt->get_num_elements();
|
||||
if (sz.is_finite()) {
|
||||
res = sz.size();
|
||||
}
|
||||
|
|
@ -411,7 +411,7 @@ namespace datalog {
|
|||
return res;
|
||||
}
|
||||
|
||||
void context::set_argument_names(const func_decl * pred, svector<symbol> var_names)
|
||||
void context::set_argument_names(const func_decl * pred, const svector<symbol> & var_names)
|
||||
{
|
||||
SASSERT(!m_argument_var_names.contains(pred));
|
||||
m_argument_var_names.insert(pred, var_names);
|
||||
|
|
@ -465,7 +465,7 @@ namespace datalog {
|
|||
scoped_proof_mode _scp(m, generate_proof_trace()?PGM_ENABLED:PGM_DISABLED);
|
||||
while (m_rule_fmls_head < m_rule_fmls.size()) {
|
||||
expr* fml = m_rule_fmls[m_rule_fmls_head].get();
|
||||
proof* p = generate_proof_trace()?m.mk_asserted(fml):0;
|
||||
proof* p = generate_proof_trace()?m.mk_asserted(fml):nullptr;
|
||||
rm.mk_rule(fml, p, m_rule_set, m_rule_names[m_rule_fmls_head]);
|
||||
++m_rule_fmls_head;
|
||||
}
|
||||
|
|
@ -478,7 +478,7 @@ namespace datalog {
|
|||
//
|
||||
void context::update_rule(expr* rl, symbol const& name) {
|
||||
datalog::rule_manager& rm = get_rule_manager();
|
||||
proof* p = 0;
|
||||
proof* p = nullptr;
|
||||
if (generate_proof_trace()) {
|
||||
p = m.mk_asserted(rl);
|
||||
}
|
||||
|
|
@ -493,7 +493,7 @@ namespace datalog {
|
|||
// The new rule is inserted last:
|
||||
rule_ref r(m_rule_set.get_rule(size_before), rm);
|
||||
rule_ref_vector const& rls = m_rule_set.get_rules();
|
||||
rule* old_rule = 0;
|
||||
rule* old_rule = nullptr;
|
||||
for (unsigned i = 0; i < size_before; ++i) {
|
||||
if (rls[i]->name() == name) {
|
||||
if (old_rule) {
|
||||
|
|
@ -861,8 +861,8 @@ namespace datalog {
|
|||
lbool context::query(expr* query) {
|
||||
m_mc = mk_skip_model_converter();
|
||||
m_last_status = OK;
|
||||
m_last_answer = 0;
|
||||
m_last_ground_answer = 0;
|
||||
m_last_answer = nullptr;
|
||||
m_last_ground_answer = nullptr;
|
||||
switch (get_engine()) {
|
||||
case DATALOG_ENGINE:
|
||||
case SPACER_ENGINE:
|
||||
|
|
@ -890,8 +890,8 @@ namespace datalog {
|
|||
lbool context::query_from_lvl (expr* query, unsigned lvl) {
|
||||
m_mc = mk_skip_model_converter();
|
||||
m_last_status = OK;
|
||||
m_last_answer = 0;
|
||||
m_last_ground_answer = 0;
|
||||
m_last_answer = nullptr;
|
||||
m_last_ground_answer = nullptr;
|
||||
switch (get_engine()) {
|
||||
case DATALOG_ENGINE:
|
||||
case SPACER_ENGINE:
|
||||
|
|
@ -933,7 +933,7 @@ namespace datalog {
|
|||
}
|
||||
|
||||
lbool context::rel_query(unsigned num_rels, func_decl * const* rels) {
|
||||
m_last_answer = 0;
|
||||
m_last_answer = nullptr;
|
||||
ensure_engine();
|
||||
return m_engine->query(num_rels, rels);
|
||||
}
|
||||
|
|
@ -1059,7 +1059,7 @@ namespace datalog {
|
|||
for (unsigned i = m_rule_fmls_head; i < m_rule_fmls.size(); ++i) {
|
||||
m_free_vars(m_rule_fmls[i].get());
|
||||
if (!m_free_vars.empty()) {
|
||||
rm.mk_rule(m_rule_fmls[i].get(), 0, m_rule_set, m_rule_names[i]);
|
||||
rm.mk_rule(m_rule_fmls[i].get(), nullptr, m_rule_set, m_rule_names[i]);
|
||||
m_rule_fmls[i] = m_rule_fmls.back();
|
||||
m_rule_names[i] = m_rule_names.back();
|
||||
m_rule_fmls.pop_back();
|
||||
|
|
@ -1106,6 +1106,16 @@ namespace datalog {
|
|||
names.push_back(m_rule_names[i]);
|
||||
}
|
||||
}
|
||||
|
||||
static std::ostream& display_symbol(std::ostream& out, symbol const& nm) {
|
||||
if (is_smt2_quoted_symbol(nm)) {
|
||||
out << mk_smt2_quoted_symbol(nm);
|
||||
}
|
||||
else {
|
||||
out << nm;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
void context::display_smt2(unsigned num_queries, expr* const* qs, std::ostream& out) {
|
||||
ast_manager& m = get_manager();
|
||||
|
|
@ -1148,13 +1158,13 @@ namespace datalog {
|
|||
if (!use_fixedpoint_extensions) {
|
||||
out << "(set-logic HORN)\n";
|
||||
}
|
||||
for (func_decl * f : rels)
|
||||
visitor.remove_decl(f);
|
||||
|
||||
visitor.display_decls(out);
|
||||
func_decl_set::iterator it = rels.begin(), end = rels.end();
|
||||
for (; it != end; ++it) {
|
||||
func_decl* f = *it;
|
||||
|
||||
for (func_decl * f : rels)
|
||||
display_rel_decl(out, f);
|
||||
}
|
||||
|
||||
if (use_fixedpoint_extensions && do_declare_vars) {
|
||||
declare_vars(rules, fresh_names, out);
|
||||
|
|
@ -1185,13 +1195,7 @@ namespace datalog {
|
|||
nm = symbol(s.str().c_str());
|
||||
}
|
||||
fresh_names.add(nm);
|
||||
if (is_smt2_quoted_symbol(nm)) {
|
||||
out << mk_smt2_quoted_symbol(nm);
|
||||
}
|
||||
else {
|
||||
out << nm;
|
||||
}
|
||||
out << ")";
|
||||
display_symbol(out, nm) << ")";
|
||||
}
|
||||
out << ")\n";
|
||||
}
|
||||
|
|
@ -1219,7 +1223,8 @@ namespace datalog {
|
|||
PP(qfn);
|
||||
out << ")\n";
|
||||
}
|
||||
out << "(query " << fn->get_name() << ")\n";
|
||||
out << "(query ";
|
||||
display_symbol(out, fn->get_name()) << ")\n";
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
|
@ -1238,7 +1243,8 @@ namespace datalog {
|
|||
|
||||
void context::display_rel_decl(std::ostream& out, func_decl* f) {
|
||||
smt2_pp_environment_dbg env(m);
|
||||
out << "(declare-rel " << f->get_name() << " (";
|
||||
out << "(declare-rel ";
|
||||
display_symbol(out, f->get_name()) << " (";
|
||||
for (unsigned i = 0; i < f->get_arity(); ++i) {
|
||||
ast_smt2_pp(out, f->get_domain(i), env);
|
||||
if (i + 1 < f->get_arity()) {
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ namespace datalog {
|
|||
class rel_context_base : public engine_base {
|
||||
public:
|
||||
rel_context_base(ast_manager& m, char const* name): engine_base(m, name) {}
|
||||
virtual ~rel_context_base() {}
|
||||
~rel_context_base() override {}
|
||||
virtual relation_manager & get_rmanager() = 0;
|
||||
virtual const relation_manager & get_rmanager() const = 0;
|
||||
virtual relation_base & get_relation(func_decl * pred) = 0;
|
||||
|
|
@ -146,9 +146,9 @@ namespace datalog {
|
|||
context const& ctx;
|
||||
public:
|
||||
contains_pred(context& ctx): ctx(ctx) {}
|
||||
virtual ~contains_pred() {}
|
||||
~contains_pred() override {}
|
||||
|
||||
virtual bool operator()(expr* e) {
|
||||
bool operator()(expr* e) override {
|
||||
return ctx.is_predicate(e);
|
||||
}
|
||||
};
|
||||
|
|
@ -331,7 +331,7 @@ namespace datalog {
|
|||
names. Generally, the names coming from the parses are registered here.
|
||||
*/
|
||||
func_decl * try_get_predicate_decl(symbol const& pred_name) const {
|
||||
func_decl * res = 0;
|
||||
func_decl * res = nullptr;
|
||||
m_preds_by_name.find(pred_name, res);
|
||||
return res;
|
||||
}
|
||||
|
|
@ -341,7 +341,7 @@ namespace datalog {
|
|||
|
||||
*/
|
||||
func_decl * mk_fresh_head_predicate(symbol const & prefix, symbol const & suffix,
|
||||
unsigned arity, sort * const * domain, func_decl* orig_pred=0);
|
||||
unsigned arity, sort * const * domain, func_decl* orig_pred=nullptr);
|
||||
|
||||
|
||||
/**
|
||||
|
|
@ -368,7 +368,7 @@ namespace datalog {
|
|||
These names are used when printing out the relations to make the output conform
|
||||
to the one of bddbddb.
|
||||
*/
|
||||
void set_argument_names(const func_decl * pred, svector<symbol> var_names);
|
||||
void set_argument_names(const func_decl * pred, const svector<symbol> & var_names);
|
||||
symbol get_argument_name(const func_decl * pred, unsigned arg_index);
|
||||
|
||||
void set_predicate_representation(func_decl * pred, unsigned relation_name_cnt,
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ namespace datalog {
|
|||
//
|
||||
// -----------------------------------
|
||||
|
||||
cost_recorder::cost_recorder() : m_obj(0) {
|
||||
cost_recorder::cost_recorder() : m_obj(nullptr) {
|
||||
m_stopwatch = alloc(stopwatch);
|
||||
m_stopwatch->start();
|
||||
}
|
||||
|
|
@ -149,7 +149,7 @@ namespace datalog {
|
|||
c.milliseconds+=time_delta;
|
||||
m_obj->m_being_recorded = false;
|
||||
}
|
||||
m_running = obj!=0;
|
||||
m_running = obj!=nullptr;
|
||||
m_obj = obj;
|
||||
m_last_time = curr_time;
|
||||
if(obj) {
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ namespace datalog {
|
|||
costs m_processed_cost;
|
||||
bool m_being_recorded;
|
||||
protected:
|
||||
accounted_object() : m_context(0), m_parent_object(0), m_being_recorded(false) {}
|
||||
accounted_object() : m_context(nullptr), m_parent_object(nullptr), m_being_recorded(false) {}
|
||||
~accounted_object();
|
||||
public:
|
||||
|
||||
|
|
@ -107,7 +107,7 @@ namespace datalog {
|
|||
before separately.
|
||||
*/
|
||||
void start(accounted_object *);
|
||||
void finish() { start(0); }
|
||||
void finish() { start(nullptr); }
|
||||
};
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ namespace datalog {
|
|||
}
|
||||
|
||||
var_idx_set& rule_manager::collect_vars(expr* e) {
|
||||
return collect_vars(e, 0);
|
||||
return collect_vars(e, nullptr);
|
||||
}
|
||||
|
||||
var_idx_set& rule_manager::collect_vars(expr* e1, expr* e2) {
|
||||
|
|
@ -274,11 +274,11 @@ namespace datalog {
|
|||
bind_variables(query, false, q);
|
||||
|
||||
quantifier_hoister qh(m);
|
||||
qh.pull_quantifier(false, q, 0, &names);
|
||||
qh.pull_quantifier(false, q, nullptr, &names);
|
||||
// retrieve free variables.
|
||||
m_free_vars(q);
|
||||
vars.append(m_free_vars.size(), m_free_vars.c_ptr());
|
||||
if (vars.contains(static_cast<sort*>(0))) {
|
||||
if (vars.contains(static_cast<sort*>(nullptr))) {
|
||||
var_subst sub(m, false);
|
||||
expr_ref_vector args(m);
|
||||
// [s0, 0, s2, ..]
|
||||
|
|
@ -306,7 +306,7 @@ namespace datalog {
|
|||
}
|
||||
body.push_back(to_app(q));
|
||||
flatten_body(body);
|
||||
func_decl* body_pred = 0;
|
||||
func_decl* body_pred = nullptr;
|
||||
for (unsigned i = 0; i < body.size(); i++) {
|
||||
if (is_uninterp(body[i].get())) {
|
||||
body_pred = body[i]->get_decl();
|
||||
|
|
@ -472,7 +472,7 @@ namespace datalog {
|
|||
r->m_head = head;
|
||||
r->m_name = name;
|
||||
r->m_tail_size = n;
|
||||
r->m_proof = 0;
|
||||
r->m_proof = nullptr;
|
||||
m.inc_ref(r->m_head);
|
||||
|
||||
app * * uninterp_tail = r->m_tail; //grows upwards
|
||||
|
|
@ -482,7 +482,7 @@ namespace datalog {
|
|||
bool has_neg = false;
|
||||
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
bool is_neg = (is_negated != 0 && is_negated[i]);
|
||||
bool is_neg = (is_negated != nullptr && is_negated[i]);
|
||||
app * curr = tail[i];
|
||||
|
||||
if (is_neg && !m_ctx.is_predicate(curr)) {
|
||||
|
|
@ -548,7 +548,7 @@ namespace datalog {
|
|||
r->m_tail_size = n;
|
||||
r->m_positive_cnt = source->m_positive_cnt;
|
||||
r->m_uninterp_cnt = source->m_uninterp_cnt;
|
||||
r->m_proof = 0;
|
||||
r->m_proof = nullptr;
|
||||
m.inc_ref(r->m_head);
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
r->m_tail[i] = source->m_tail[i];
|
||||
|
|
@ -978,7 +978,7 @@ namespace datalog {
|
|||
subst_vals.push_back(m.mk_var(next_fresh_var++, var_srt));
|
||||
}
|
||||
else {
|
||||
subst_vals.push_back(0);
|
||||
subst_vals.push_back(nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ namespace datalog {
|
|||
bool m_found;
|
||||
func_decl* m_func;
|
||||
uninterpreted_function_finder_proc(ast_manager& m):
|
||||
m(m), m_dt(m), m_dl(m), m_found(false), m_func(0) {}
|
||||
m(m), m_dt(m), m_dl(m), m_found(false), m_func(nullptr) {}
|
||||
void operator()(var * n) { }
|
||||
void operator()(quantifier * n) { }
|
||||
void operator()(app * n) {
|
||||
|
|
@ -71,7 +71,7 @@ namespace datalog {
|
|||
}
|
||||
}
|
||||
}
|
||||
void reset() { m_found = false; m_func = 0; }
|
||||
void reset() { m_found = false; m_func = nullptr; }
|
||||
|
||||
bool found(func_decl*& f) const { f = m_func; return m_found; }
|
||||
};
|
||||
|
|
@ -209,7 +209,7 @@ namespace datalog {
|
|||
|
||||
\remark A tail may contain negation. tail[i] is assumed to be negated if is_neg != 0 && is_neg[i] == true
|
||||
*/
|
||||
rule * mk(app * head, unsigned n, app * const * tail, bool const * is_neg = 0,
|
||||
rule * mk(app * head, unsigned n, app * const * tail, bool const * is_neg = nullptr,
|
||||
symbol const& name = symbol::null, bool normalize = true);
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -282,7 +282,7 @@ namespace datalog {
|
|||
m_rule_manager(ctx.get_rule_manager()),
|
||||
m_rules(m_rule_manager),
|
||||
m_deps(ctx),
|
||||
m_stratifier(0),
|
||||
m_stratifier(nullptr),
|
||||
m_refs(ctx.get_manager()) {
|
||||
}
|
||||
|
||||
|
|
@ -291,7 +291,7 @@ namespace datalog {
|
|||
m_rule_manager(other.m_rule_manager),
|
||||
m_rules(m_rule_manager),
|
||||
m_deps(other.m_context),
|
||||
m_stratifier(0),
|
||||
m_stratifier(nullptr),
|
||||
m_refs(m_context.get_manager()) {
|
||||
add_rules(other);
|
||||
if (other.m_stratifier) {
|
||||
|
|
@ -307,7 +307,7 @@ namespace datalog {
|
|||
m_rules.reset();
|
||||
reset_dealloc_values(m_head2rules);
|
||||
m_deps.reset();
|
||||
m_stratifier = 0;
|
||||
m_stratifier = nullptr;
|
||||
m_output_preds.reset();
|
||||
m_orig2pred.reset();
|
||||
m_pred2orig.reset();
|
||||
|
|
@ -401,7 +401,7 @@ namespace datalog {
|
|||
m_deps.populate(*this);
|
||||
m_stratifier = alloc(rule_stratifier, m_deps);
|
||||
if (!stratified_negation()) {
|
||||
m_stratifier = 0;
|
||||
m_stratifier = nullptr;
|
||||
m_deps.reset();
|
||||
return false;
|
||||
}
|
||||
|
|
@ -410,7 +410,7 @@ namespace datalog {
|
|||
|
||||
void rule_set::reopen() {
|
||||
if (is_closed()) {
|
||||
m_stratifier = 0;
|
||||
m_stratifier = nullptr;
|
||||
m_deps.reset();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ namespace datalog {
|
|||
(higher priority plugins will be applied first).
|
||||
*/
|
||||
plugin(unsigned priority, bool can_destratify_negation = false) : m_priority(priority),
|
||||
m_can_destratify_negation(can_destratify_negation), m_transformer(0) {}
|
||||
m_can_destratify_negation(can_destratify_negation), m_transformer(nullptr) {}
|
||||
|
||||
public:
|
||||
virtual ~plugin() {}
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ Revision History:
|
|||
|
||||
namespace datalog {
|
||||
|
||||
verbose_action::verbose_action(char const* msg, unsigned lvl): m_lvl(lvl), m_sw(0) {
|
||||
verbose_action::verbose_action(char const* msg, unsigned lvl): m_lvl(lvl), m_sw(nullptr) {
|
||||
IF_VERBOSE(m_lvl,
|
||||
(verbose_stream() << msg << "...").flush();
|
||||
m_sw = alloc(stopwatch);
|
||||
|
|
@ -87,7 +87,7 @@ namespace datalog {
|
|||
else {
|
||||
SASSERT(is_var(arg));
|
||||
int vidx = to_var(arg)->get_idx();
|
||||
var * new_var = 0;
|
||||
var * new_var = nullptr;
|
||||
if (!varidx2var.find(vidx, new_var)) {
|
||||
new_var = m.mk_var(next_idx, to_var(arg)->get_sort());
|
||||
next_idx++;
|
||||
|
|
@ -277,16 +277,21 @@ namespace datalog {
|
|||
return get_max_var(has_var);
|
||||
}
|
||||
|
||||
void del_rule(horn_subsume_model_converter* mc, rule& r) {
|
||||
void del_rule(horn_subsume_model_converter* mc, rule& r, bool unreachable) {
|
||||
if (mc) {
|
||||
ast_manager& m = mc->get_manager();
|
||||
expr_ref_vector body(m);
|
||||
for (unsigned i = 0; i < r.get_tail_size(); ++i) {
|
||||
if (r.is_neg_tail(i)) {
|
||||
body.push_back(m.mk_not(r.get_tail(i)));
|
||||
}
|
||||
else {
|
||||
body.push_back(r.get_tail(i));
|
||||
if (unreachable) {
|
||||
body.push_back(m.mk_false());
|
||||
}
|
||||
else {
|
||||
for (unsigned i = 0; i < r.get_tail_size(); ++i) {
|
||||
if (r.is_neg_tail(i)) {
|
||||
body.push_back(m.mk_not(r.get_tail(i)));
|
||||
}
|
||||
else {
|
||||
body.push_back(r.get_tail(i));
|
||||
}
|
||||
}
|
||||
}
|
||||
TRACE("dl_dr",
|
||||
|
|
@ -431,7 +436,7 @@ namespace datalog {
|
|||
|
||||
unsigned tgt_sz = max_var_idx+1;
|
||||
unsigned tgt_ofs = tgt_sz-1;
|
||||
tgt.resize(tgt_sz, 0);
|
||||
tgt.resize(tgt_sz, nullptr);
|
||||
for(unsigned i=0; i<src_sz; i++) {
|
||||
expr * e = src[src_ofs-i];
|
||||
if(!e) {
|
||||
|
|
@ -449,7 +454,7 @@ namespace datalog {
|
|||
out << "(";
|
||||
for(int i=len-1; i>=0; i--) {
|
||||
out << (len-1-i) <<"->";
|
||||
if(cont.get(i)==0) {
|
||||
if(cont.get(i)==nullptr) {
|
||||
out << "{none}";
|
||||
}
|
||||
else {
|
||||
|
|
@ -547,7 +552,7 @@ namespace datalog {
|
|||
//
|
||||
// -----------------------------------
|
||||
|
||||
void get_file_names(std::string directory, std::string extension, bool traverse_subdirs,
|
||||
void get_file_names(std::string directory, const std::string & extension, bool traverse_subdirs,
|
||||
string_vector & res) {
|
||||
|
||||
if(directory[directory.size()-1]!='\\' && directory[directory.size()-1]!='/') {
|
||||
|
|
@ -595,7 +600,7 @@ namespace datalog {
|
|||
#endif
|
||||
}
|
||||
|
||||
bool file_exists(std::string name) {
|
||||
bool file_exists(const std::string & name) {
|
||||
struct stat st;
|
||||
if(stat(name.c_str(),&st) == 0) {
|
||||
return true;
|
||||
|
|
@ -603,7 +608,7 @@ namespace datalog {
|
|||
return false;
|
||||
}
|
||||
|
||||
bool is_directory(std::string name) {
|
||||
bool is_directory(const std::string & name) {
|
||||
if(!file_exists(name)) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -612,9 +617,9 @@ namespace datalog {
|
|||
return (status.st_mode&S_IFDIR)!=0;
|
||||
}
|
||||
|
||||
std::string get_file_name_without_extension(std::string name) {
|
||||
std::string get_file_name_without_extension(const std::string & name) {
|
||||
size_t slash_index = name.find_last_of("\\/");
|
||||
size_t dot_index = name.rfind(".");
|
||||
size_t dot_index = name.rfind('.');
|
||||
size_t ofs = (slash_index==std::string::npos) ? 0 : slash_index+1;
|
||||
size_t count = (dot_index!=std::string::npos && dot_index>ofs) ?
|
||||
(dot_index-ofs) : std::string::npos;
|
||||
|
|
|
|||
|
|
@ -290,7 +290,7 @@ namespace datalog {
|
|||
}
|
||||
|
||||
template<class T>
|
||||
void project_out_vector_columns(T & container, const unsigned_vector removed_cols) {
|
||||
void project_out_vector_columns(T & container, const unsigned_vector & removed_cols) {
|
||||
project_out_vector_columns(container, removed_cols.size(), removed_cols.c_ptr());
|
||||
}
|
||||
|
||||
|
|
@ -342,7 +342,7 @@ namespace datalog {
|
|||
}
|
||||
|
||||
template<class T>
|
||||
void permutate_by_cycle(T & container, const unsigned_vector permutation_cycle) {
|
||||
void permutate_by_cycle(T & container, const unsigned_vector & permutation_cycle) {
|
||||
permutate_by_cycle(container, permutation_cycle.size(), permutation_cycle.c_ptr());
|
||||
}
|
||||
|
||||
|
|
@ -354,7 +354,7 @@ namespace datalog {
|
|||
unsigned get_max_rule_var(const rule& r);
|
||||
};
|
||||
|
||||
void del_rule(horn_subsume_model_converter* mc, rule& r);
|
||||
void del_rule(horn_subsume_model_converter* mc, rule& r, bool unreachable);
|
||||
|
||||
void resolve_rule(rule_manager& rm,
|
||||
replace_proof_converter* pc, rule const& r1, rule const& r2, unsigned idx,
|
||||
|
|
@ -578,13 +578,13 @@ namespace datalog {
|
|||
//
|
||||
// -----------------------------------
|
||||
|
||||
void get_file_names(std::string directory, std::string extension, bool traverse_subdirs,
|
||||
void get_file_names(std::string directory, const std::string & extension, bool traverse_subdirs,
|
||||
string_vector & res);
|
||||
|
||||
bool file_exists(std::string name);
|
||||
bool is_directory(std::string name);
|
||||
bool file_exists(const std::string & name);
|
||||
bool is_directory(const std::string & name);
|
||||
|
||||
std::string get_file_name_without_extension(std::string name);
|
||||
std::string get_file_name_without_extension(const std::string & name);
|
||||
|
||||
// -----------------------------------
|
||||
//
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ def_module_params('fixedpoint',
|
|||
"updated relation was modified or not"),
|
||||
('datalog.compile_with_widening', BOOL, False,
|
||||
"widening will be used to compile recursive rules"),
|
||||
('datalog.default_table_checked', BOOL, False, "if true, the detault " +
|
||||
('datalog.default_table_checked', BOOL, False, "if true, the default " +
|
||||
'table will be default_table inside a wrapper that checks that its results ' +
|
||||
'are the same as of default_table_checker table'),
|
||||
('datalog.default_table_checker', SYMBOL, 'null', "see default_table_checked"),
|
||||
|
|
@ -59,7 +59,7 @@ def_module_params('fixedpoint',
|
|||
('duality.full_expand', BOOL, False, 'Fully expand derivation trees'),
|
||||
('duality.no_conj', BOOL, False, 'No forced covering (conjectures)'),
|
||||
('duality.feasible_edges', BOOL, True,
|
||||
'Don\'t expand definitley infeasible edges'),
|
||||
'Don\'t expand definitely infeasible edges'),
|
||||
('duality.use_underapprox', BOOL, False, 'Use underapproximations'),
|
||||
('duality.stratified_inlining', BOOL, False, 'Use stratified inlining'),
|
||||
('duality.recursion_bound', UINT, UINT_MAX,
|
||||
|
|
@ -130,7 +130,7 @@ def_module_params('fixedpoint',
|
|||
('xform.magic', BOOL, False,
|
||||
"perform symbolic magic set transformation"),
|
||||
('xform.scale', BOOL, False,
|
||||
"add scaling variable to linear real arithemtic clauses"),
|
||||
"add scaling variable to linear real arithmetic clauses"),
|
||||
('xform.inline_linear', BOOL, True, "try linear inlining method"),
|
||||
('xform.inline_eager', BOOL, True, "try eager inlining of rules"),
|
||||
('xform.inline_linear_branch', BOOL, False,
|
||||
|
|
@ -176,7 +176,7 @@ def_module_params('fixedpoint',
|
|||
('spacer.elim_aux', BOOL, True, "Eliminate auxiliary variables in reachability facts"),
|
||||
('spacer.reach_as_init', BOOL, True, "Extend initial rules with computed reachability facts"),
|
||||
('spacer.blast_term_ite', BOOL, True, "Expand non-Boolean ite-terms"),
|
||||
('spacer.nondet_tie_break', BOOL, False, "Break ties in obligation queue non-deterministicly"),
|
||||
('spacer.nondet_tie_break', BOOL, False, "Break ties in obligation queue non-deterministically"),
|
||||
('spacer.reach_dnf', BOOL, True, "Restrict reachability facts to DNF"),
|
||||
('bmc.linear_unrolling_depth', UINT, UINT_MAX, "Maximal level to explore"),
|
||||
('spacer.split_farkas_literals', BOOL, False, "Split Farkas literals"),
|
||||
|
|
|
|||
|
|
@ -153,7 +153,7 @@ public:
|
|||
m_fresh_predicates.reset();
|
||||
m_todo.push_back(n);
|
||||
m_proofs.push_back(p);
|
||||
m_produce_proofs = p != 0;
|
||||
m_produce_proofs = p != nullptr;
|
||||
while (!m_todo.empty() && checkpoint()) {
|
||||
fml = m_todo.back();
|
||||
pr = m_proofs.back();
|
||||
|
|
@ -269,7 +269,7 @@ private:
|
|||
expr* const* args = _or->get_args();
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
m_todo.push_back(bind_variables(m.mk_implies(args[i], head)));
|
||||
m_proofs.push_back(0);
|
||||
m_proofs.push_back(nullptr);
|
||||
}
|
||||
|
||||
if (premise) {
|
||||
|
|
@ -284,7 +284,7 @@ private:
|
|||
m_proofs[m_proofs.size()-sz+i] = m.mk_and_elim(p2, i);
|
||||
}
|
||||
}
|
||||
fml = 0;
|
||||
fml = nullptr;
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -330,7 +330,7 @@ private:
|
|||
bool is_disj = false;
|
||||
expr_ref_vector _body(m);
|
||||
unsigned num_disj = 0;
|
||||
expr* const* disjs = 0;
|
||||
expr* const* disjs = nullptr;
|
||||
if (!contains_predicate(b)) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -356,7 +356,7 @@ private:
|
|||
negate_args = false;
|
||||
}
|
||||
if (is_disj) {
|
||||
app* old_head = 0;
|
||||
app* old_head = nullptr;
|
||||
if (m_memoize_disj.find(b, old_head)) {
|
||||
body = old_head;
|
||||
}
|
||||
|
|
@ -369,7 +369,7 @@ private:
|
|||
e = m.mk_not(e);
|
||||
}
|
||||
m_todo.push_back(bind_variables(m.mk_implies(e, head)));
|
||||
m_proofs.push_back(0);
|
||||
m_proofs.push_back(nullptr);
|
||||
if (produce_proofs()) {
|
||||
defs.push_back(m.mk_def_intro(m_todo.back()));
|
||||
m_proofs[m_proofs.size()-1] = defs.back();
|
||||
|
|
@ -423,7 +423,7 @@ private:
|
|||
if (!is_predicate(e)) {
|
||||
app_ref head = mk_fresh_head(e);
|
||||
m_todo.push_back(bind_variables(m.mk_implies(e, head)));
|
||||
m_proofs.push_back(0);
|
||||
m_proofs.push_back(nullptr);
|
||||
body = m.update_quantifier(q, head);
|
||||
if (produce_proofs()) {
|
||||
proof* def_intro = m.mk_def_intro(m_todo.back());
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue