mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-05-02 13:27:01 +00:00
Code Activity

merge with master

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2018-03-25 14:57:01 -07:00
commit c513f3ca09
883 changed files with 13979 additions and 16480 deletions
Download patch file Download diff file Expand all files Collapse all files

56
src/muz/fp/datalog_parser.cpp
View file

@ -104,7 +104,7 @@ public:
m_ok = (m_file != NULL) && (err == 0);
#else
m_file = fopen(fname, "rb");
m_ok = (m_file != NULL);
m_ok = (m_file != nullptr);
#endif
}
~line_reader() {
@ -171,7 +171,7 @@ class char_reader {
public:
char_reader(char const* file):
m_line_reader(file),
m_line(0)
m_line(nullptr)
{}
bool operator()() { return m_line_reader(); }
@ -184,7 +184,7 @@ public:
m_line = m_line_reader.get_line();
}
if (!(m_line[0])) {
m_line = 0;
m_line = nullptr;
return '\n';
}
char result = m_line[0];
@ -266,8 +266,8 @@ public:
}
dlexer():
m_input(0),
m_reader(0),
m_input(nullptr),
m_reader(nullptr),
m_prev_char(0),
m_curr_char(0),
m_line(1),
@ -494,27 +494,27 @@ public:
{
}
virtual bool parse_file(char const * filename) {
bool parse_file(char const * filename) override {
reset();
if (filename != 0) {
if (filename != nullptr) {
set_path(filename);
char_reader reader(filename);
if (!reader()) {
get_err() << "ERROR: could not open file '" << filename << "'.\n";
return false;
}
return parse_stream(0, &reader);
return parse_stream(nullptr, &reader);
}
else {
return parse_stream(&std::cin, 0);
return parse_stream(&std::cin, nullptr);
}
}
virtual bool parse_string(char const * string) {
bool parse_string(char const * string) override {
reset();
std::string s(string);
std::istringstream is(s);
return parse_stream(&is, 0);
return parse_stream(&is, nullptr);
}
protected:
@ -701,7 +701,7 @@ protected:
if(is_predicate_declaration) {
return unexpected(tok, "predicate declaration should not end with '.'");
}
add_rule(pred, 0, 0, 0);
add_rule(pred, 0, nullptr, nullptr);
return m_lexer->next_token();
case TK_LEFT_ARROW:
return parse_body(pred);
@ -777,7 +777,7 @@ protected:
dtoken parse_infix(dtoken tok1, char const* td, app_ref& pred) {
symbol td1(td);
expr_ref v1(m_manager), v2(m_manager);
sort* s = 0;
sort* s = nullptr;
dtoken tok2 = m_lexer->next_token();
if (tok2 != TK_NEQ && tok2 != TK_GT && tok2 != TK_LT && tok2 != TK_EQ) {
return unexpected(tok2, "built-in infix operator");
@ -790,12 +790,12 @@ protected:
symbol td2(td);
if (tok1 == TK_ID) {
expr* _v1 = 0;
expr* _v1 = nullptr;
m_vars.find(td1.bare_str(), _v1);
v1 = _v1;
}
if (tok3 == TK_ID) {
expr* _v2 = 0;
expr* _v2 = nullptr;
m_vars.find(td2.bare_str(), _v2);
v2 = _v2;
}
@ -842,8 +842,8 @@ protected:
svector<symbol> arg_names;
func_decl* f = m_context.try_get_predicate_decl(s);
tok = parse_args(tok, f, args, arg_names);
is_predicate_declaration = f==0;
if (f==0) {
is_predicate_declaration = f==nullptr;
if (f==nullptr) {
//we're in a declaration
unsigned arity = args.size();
ptr_vector<sort> domain;
@ -884,7 +884,7 @@ protected:
tok = m_lexer->next_token();
while (tok != TK_EOS && tok != TK_ERROR) {
symbol alias;
sort* s = 0;
sort* s = nullptr;
if(!f) {
//we're in a predicate declaration
@ -951,7 +951,7 @@ protected:
symbol data (m_lexer->get_token_data());
if (is_var(data.bare_str())) {
unsigned idx = 0;
expr* v = 0;
expr* v = nullptr;
if (!m_vars.find(data.bare_str(), v)) {
idx = m_num_vars++;
v = m_manager.mk_var(idx, s);
@ -1014,7 +1014,7 @@ protected:
dlexer lexer;
{
flet<dlexer*> lexer_let(m_lexer, &lexer);
m_lexer->set_stream(0, &stream);
m_lexer->set_stream(nullptr, &stream);
tok = m_lexer->next_token();
if(parsing_domain) {
tok = parse_domains(tok);
@ -1186,7 +1186,7 @@ class wpa_parser_impl : public wpa_parser, dparser {
bool m_use_map_names;
uint64_set& ensure_sort_content(symbol sort_name) {
sym2nums::entry * e = m_sort_contents.insert_if_not_there2(sort_name, 0);
sym2nums::entry * e = m_sort_contents.insert_if_not_there2(sort_name, nullptr);
if(!e->get_data().m_value) {
e->get_data().m_value = alloc(uint64_set);
}
@ -1200,13 +1200,13 @@ public:
m_short_sort(ctx.get_manager()),
m_use_map_names(ctx.use_map_names()) {
}
~wpa_parser_impl() {
~wpa_parser_impl() override {
reset_dealloc_values(m_sort_contents);
}
void reset() {
}
virtual bool parse_directory(char const * path) {
bool parse_directory(char const * path) override {
bool result = false;
try {
result = parse_directory_core(path);
@ -1303,7 +1303,7 @@ private:
}
}
void parse_rules_file(std::string fname) {
void parse_rules_file(const std::string & fname) {
SASSERT(file_exists(fname));
flet<std::string> flet_cur_file(m_current_file, fname);
@ -1312,10 +1312,10 @@ private:
dlexer lexer;
m_lexer = &lexer;
m_lexer->set_stream(&stm, 0);
m_lexer->set_stream(&stm, nullptr);
dtoken tok = m_lexer->next_token();
tok = parse_decls(tok);
m_lexer = 0;
m_lexer = nullptr;
}
bool parse_rel_line(char * full_line, uint64_vector & args) {
@ -1347,7 +1347,7 @@ private:
return true;
}
void parse_rel_file(std::string fname) {
void parse_rel_file(const std::string & fname) {
SASSERT(file_exists(fname));
IF_VERBOSE(10, verbose_stream() << "Parsing relation file " << fname << "\n";);
@ -1496,7 +1496,7 @@ private:
return true;
}
void parse_map_file(std::string fname) {
void parse_map_file(const std::string & fname) {
SASSERT(file_exists(fname));
IF_VERBOSE(10, verbose_stream() << "Parsing map file " << fname << "\n";);

104
src/muz/fp/dl_cmds.cpp
View file

@ -56,7 +56,7 @@ struct dl_context {
m_cmd(ctx),
m_collected_cmds(collected_cmds),
m_ref_count(0),
m_decl_plugin(0),
m_decl_plugin(nullptr),
m_trail(*this) {}
void inc_ref() {
@ -88,7 +88,7 @@ struct dl_context {
}
void reset() {
m_context = 0;
m_context = nullptr;
}
void register_predicate(func_decl* pred, unsigned num_kinds, symbol const* kinds) {
@ -164,12 +164,12 @@ public:
cmd("rule"),
m_dl_ctx(dl_ctx),
m_arg_idx(0),
m_t(0),
m_t(nullptr),
m_bound(UINT_MAX) {}
virtual char const * get_usage() const { return "(forall (q) (=> (and body) head)) :optional-name :optional-recursion-bound"; }
virtual char const * get_descr(cmd_context & ctx) const { return "add a Horn rule."; }
virtual unsigned get_arity() const { return VAR_ARITY; }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
char const * get_usage() const override { return "(forall (q) (=> (and body) head)) :optional-name :optional-recursion-bound"; }
char const * get_descr(cmd_context & ctx) const override { return "add a Horn rule."; }
unsigned get_arity() const override { return VAR_ARITY; }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
switch(m_arg_idx) {
case 0: return CPK_EXPR;
case 1: return CPK_SYMBOL;
@ -177,23 +177,23 @@ public:
default: return CPK_SYMBOL;
}
}
virtual void set_next_arg(cmd_context & ctx, expr * t) {
void set_next_arg(cmd_context & ctx, expr * t) override {
m_t = t;
m_arg_idx++;
}
virtual void set_next_arg(cmd_context & ctx, symbol const & s) {
void set_next_arg(cmd_context & ctx, symbol const & s) override {
m_name = s;
m_arg_idx++;
}
virtual void set_next_arg(cmd_context & ctx, unsigned bound) {
void set_next_arg(cmd_context & ctx, unsigned bound) override {
m_bound = bound;
m_arg_idx++;
}
virtual void reset(cmd_context & ctx) { m_dl_ctx->reset(); prepare(ctx); m_t = nullptr; }
virtual void prepare(cmd_context& ctx) { m_arg_idx = 0; m_name = symbol::null; m_bound = UINT_MAX; }
virtual void finalize(cmd_context & ctx) {
void reset(cmd_context & ctx) override { m_dl_ctx->reset(); prepare(ctx); m_t = nullptr; }
void prepare(cmd_context& ctx) override { m_arg_idx = 0; m_name = symbol::null; m_bound = UINT_MAX; }
void finalize(cmd_context & ctx) override {
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
if (!m_t) throw cmd_exception("invalid rule, expected formula");
m_dl_ctx->add_rule(m_t, m_name, m_bound);
}
@ -206,19 +206,19 @@ public:
dl_query_cmd(dl_context * dl_ctx):
parametric_cmd("query"),
m_dl_ctx(dl_ctx),
m_target(0) {
m_target(nullptr) {
}
virtual char const * get_usage() const { return "predicate"; }
virtual char const * get_main_descr() const {
char const * get_usage() const override { return "predicate"; }
char const * get_main_descr() const override {
return "pose a query to a predicate based on the Horn rules.";
}
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
if (m_target == 0) return CPK_FUNC_DECL;
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
if (m_target == nullptr) return CPK_FUNC_DECL;
return parametric_cmd::next_arg_kind(ctx);
}
virtual void set_next_arg(cmd_context & ctx, func_decl* t) {
void set_next_arg(cmd_context & ctx, func_decl* t) override {
m_target = t;
if (t->get_family_id() != null_family_id) {
throw cmd_exception("Invalid query argument, expected uinterpreted function name, but argument is interpreted");
@ -229,14 +229,14 @@ public:
}
}
virtual void prepare(cmd_context & ctx) {
void prepare(cmd_context & ctx) override {
ctx.m(); // ensure manager is initialized.
parametric_cmd::prepare(ctx);
m_target = 0;
m_target = nullptr;
}
virtual void execute(cmd_context& ctx) {
if (m_target == 0) {
void execute(cmd_context& ctx) override {
if (m_target == nullptr) {
throw cmd_exception("invalid query command, argument expected");
}
if (m_dl_ctx->collect_query(m_target)) {
@ -318,10 +318,10 @@ public:
}
dlctx.cleanup();
print_statistics(ctx);
m_target = 0;
m_target = nullptr;
}
virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) {
void init_pdescrs(cmd_context & ctx, param_descrs & p) override {
m_dl_ctx->dlctx().collect_params(p);
}
@ -385,30 +385,30 @@ public:
m_dl_ctx(dl_ctx),
m_domain(0) {}
virtual char const * get_usage() const { return "<symbol> (<arg1 sort> ...) <representation>*"; }
virtual char const * get_descr(cmd_context & ctx) const { return "declare new relation"; }
virtual unsigned get_arity() const { return VAR_ARITY; }
char const * get_usage() const override { return "<symbol> (<arg1 sort> ...) <representation>*"; }
char const * get_descr(cmd_context & ctx) const override { return "declare new relation"; }
unsigned get_arity() const override { return VAR_ARITY; }
virtual void prepare(cmd_context & ctx) {
void prepare(cmd_context & ctx) override {
ctx.m(); // ensure manager is initialized.
m_arg_idx = 0;
m_query_arg_idx = 0;
m_domain.reset();
m_kinds.reset();
}
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
switch(m_query_arg_idx++) {
case 0: return CPK_SYMBOL; // relation name
case 1: return CPK_SORT_LIST; // arguments
default: return CPK_SYMBOL; // optional representation specification
}
}
virtual void set_next_arg(cmd_context & ctx, unsigned num, sort * const * slist) {
void set_next_arg(cmd_context & ctx, unsigned num, sort * const * slist) override {
m_domain.reset();
m_domain.append(num, slist);
m_arg_idx++;
}
virtual void set_next_arg(cmd_context & ctx, symbol const & s) {
void set_next_arg(cmd_context & ctx, symbol const & s) override {
if(m_arg_idx==0) {
m_rel_name = s;
}
@ -418,7 +418,7 @@ public:
}
m_arg_idx++;
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
if(m_arg_idx<2) {
throw cmd_exception("at least 2 arguments expected");
}
@ -444,15 +444,15 @@ public:
m_dl_ctx(dl_ctx)
{}
virtual char const * get_usage() const { return "<symbol> <sort>"; }
virtual char const * get_descr(cmd_context & ctx) const { return "declare constant as variable"; }
virtual unsigned get_arity() const { return 2; }
char const * get_usage() const override { return "<symbol> <sort>"; }
char const * get_descr(cmd_context & ctx) const override { return "declare constant as variable"; }
unsigned get_arity() const override { return 2; }
virtual void prepare(cmd_context & ctx) {
void prepare(cmd_context & ctx) override {
ctx.m(); // ensure manager is initialized.
m_arg_idx = 0;
}
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
SASSERT(m_arg_idx <= 1);
if (m_arg_idx == 0) {
return CPK_SYMBOL;
@ -460,19 +460,19 @@ public:
return CPK_SORT;
}
virtual void set_next_arg(cmd_context & ctx, sort* s) {
void set_next_arg(cmd_context & ctx, sort* s) override {
m_var_sort = s;
++m_arg_idx;
}
virtual void set_next_arg(cmd_context & ctx, symbol const & s) {
void set_next_arg(cmd_context & ctx, symbol const & s) override {
m_var_name = s;
++m_arg_idx;
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
ast_manager& m = ctx.m();
func_decl_ref var(m.mk_func_decl(m_var_name, 0, static_cast<sort*const*>(0), m_var_sort), m);
func_decl_ref var(m.mk_func_decl(m_var_name, 0, static_cast<sort*const*>(nullptr), m_var_sort), m);
ctx.insert(var);
m_dl_ctx->dlctx().register_variable(var);
}
@ -489,10 +489,10 @@ public:
m_dl_ctx(dl_ctx)
{}
virtual char const * get_usage() const { return ""; }
virtual char const * get_descr(cmd_context & ctx) const { return "push the fixedpoint context"; }
virtual unsigned get_arity() const { return 0; }
virtual void execute(cmd_context & ctx) {
char const * get_usage() const override { return ""; }
char const * get_descr(cmd_context & ctx) const override { return "push the fixedpoint context"; }
unsigned get_arity() const override { return 0; }
void execute(cmd_context & ctx) override {
m_dl_ctx->push();
}
};
@ -508,10 +508,10 @@ public:
m_dl_ctx(dl_ctx)
{}
virtual char const * get_usage() const { return ""; }
virtual char const * get_descr(cmd_context & ctx) const { return "pop the fixedpoint context"; }
virtual unsigned get_arity() const { return 0; }
virtual void execute(cmd_context & ctx) {
char const * get_usage() const override { return ""; }
char const * get_descr(cmd_context & ctx) const override { return "pop the fixedpoint context"; }
unsigned get_arity() const override { return 0; }
void execute(cmd_context & ctx) override {
m_dl_ctx->pop();
}
};
@ -528,7 +528,7 @@ static void install_dl_cmds_aux(cmd_context& ctx, dl_collected_cmds* collected_c
}
void install_dl_cmds(cmd_context & ctx) {
install_dl_cmds_aux(ctx, 0);
install_dl_cmds_aux(ctx, nullptr);
}
void install_dl_collect_cmds(dl_collected_cmds& collected_cmds, cmd_context & ctx) {

6
src/muz/fp/dl_register_engine.cpp
View file

@ -27,7 +27,7 @@ Revision History:
#include "muz/spacer/spacer_dl_interface.h"
namespace datalog {
register_engine::register_engine(): m_ctx(0) {}
register_engine::register_engine(): m_ctx(nullptr) {}
engine_base* register_engine::mk_engine(DL_ENGINE engine_type) {
switch(engine_type) {
@ -51,10 +51,10 @@ namespace datalog {
return alloc(ddnf, *m_ctx);
case LAST_ENGINE:
UNREACHABLE();
return 0;
return nullptr;
}
UNREACHABLE();
return 0;
return nullptr;
}
}

4
src/muz/fp/dl_register_engine.h
View file

@ -27,8 +27,8 @@ namespace datalog {
context* m_ctx;
public:
register_engine();
engine_base* mk_engine(DL_ENGINE engine_type);
void set_context(context* ctx) { m_ctx = ctx; }
engine_base* mk_engine(DL_ENGINE engine_type) override;
void set_context(context* ctx) override { m_ctx = ctx; }
};
}

24
src/muz/fp/horn_tactic.cpp
View file

@ -65,7 +65,7 @@ class horn_tactic : public tactic {
void normalize(expr_ref& f) {
bool is_positive = true;
expr* e = 0;
expr* e = nullptr;
while (true) {
if (is_forall(f) && is_positive) {
f = to_quantifier(f)->get_expr();
@ -141,7 +141,7 @@ class horn_tactic : public tactic {
ast_mark mark;
expr_ref_vector args(m), body(m);
expr_ref head(m);
expr* a = 0, *a1 = 0;
expr* a = nullptr, *a1 = nullptr;
flatten_or(tmp, args);
for (unsigned i = 0; i < args.size(); ++i) {
a = args[i].get();
@ -270,7 +270,7 @@ class horn_tactic : public tactic {
if (produce_proofs) {
proof_ref proof = m_ctx.get_proof();
pc = proof2proof_converter(m, proof);
g->assert_expr(m.mk_false(), proof, 0);
g->assert_expr(m.mk_false(), proof, nullptr);
}
else {
g->assert_expr(m.mk_false());
@ -365,40 +365,40 @@ public:
m_imp = alloc(imp, t, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(horn_tactic, m_is_simplify, m, m_params);
}
virtual ~horn_tactic() {
~horn_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
m_imp->collect_param_descrs(r);
}
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result) {
void operator()(goal_ref const & in,
goal_ref_buffer & result) override {
(*m_imp)(in, result);
}
virtual void collect_statistics(statistics & st) const {
void collect_statistics(statistics & st) const override {
m_imp->collect_statistics(st);
st.copy(m_stats);
}
virtual void reset_statistics() {
void reset_statistics() override {
m_stats.reset();
m_imp->reset_statistics();
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m;
m_imp->collect_statistics(m_stats);
dealloc(m_imp);