mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-25 18:15:32 +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

8
src/parsers/smt/CMakeLists.txt
View file

@ -1,8 +0,0 @@
z3_add_component(smtparser
SOURCES
smtlib.cpp
smtlib_solver.cpp
smtparser.cpp
COMPONENT_DEPENDENCIES
portfolio
)

258
src/parsers/smt/smtlib.cpp
View file

@ -1,258 +0,0 @@
/*++
Copyright (c) 2015 Microsoft Corporation
--*/
#include "parsers/smt/smtlib.h"
#include "ast/ast_pp.h"
#include "ast/ast_smt2_pp.h"
#ifdef _WINDOWS
#ifdef ARRAYSIZE
#undef ARRAYSIZE
#endif
#include <windows.h>
#include <strsafe.h>
#endif
#include <iostream>
using namespace smtlib;
// --------------------------------------------------------------------------
// symtable
symtable::~symtable() {
reset();
}
void symtable::reset() {
svector<ptr_vector<func_decl>*> range;
m_ids.get_range(range);
for (unsigned i = 0; i < range.size(); ++i) {
ptr_vector<func_decl> const & v = *range[i];
for (unsigned j = 0; j < v.size(); ++j) {
m_manager.dec_ref(v[j]);
}
dealloc(range[i]);
}
m_ids.reset();
ptr_vector<sort> sorts;
m_sorts1.get_range(sorts);
for (unsigned i = 0; i < sorts.size(); ++i) {
m_manager.dec_ref(sorts[i]);
}
m_sorts1.reset();
ptr_vector<sort_builder> sort_builders;
m_sorts.get_range(sort_builders);
for (unsigned i = 0; i < sort_builders.size(); ++i) {
dealloc(sort_builders[i]);
}
m_sorts.reset();
}
void symtable::insert(symbol s, func_decl * d) {
ptr_vector<func_decl>* decls = 0;
m_manager.inc_ref(d);
if (!m_ids.find(s, decls)) {
SASSERT(!decls);
decls = alloc(ptr_vector<func_decl>);
decls->push_back(d);
m_ids.insert(s, decls);
}
else {
SASSERT(decls);
if ((*decls)[0] != d) {
decls->push_back(d);
}
else {
m_manager.dec_ref(d);
}
}
}
bool symtable::find1(symbol s, func_decl*& d) {
ptr_vector<func_decl>* decls = 0;
if (!m_ids.find(s, decls)) {
SASSERT(!decls);
return false;
}
SASSERT(decls && !decls->empty());
d = (*decls)[0];
return true;
}
bool symtable::find_overload(symbol s, ptr_vector<sort> const & dom, func_decl * & d) {
ptr_vector<func_decl>* decls = 0;
d = 0;
if (!m_ids.find(s, decls)) {
SASSERT(!decls);
return false;
}
SASSERT(decls);
for (unsigned i = 0; i < decls->size(); ++i) {
func_decl* decl = (*decls)[i];
if (decl->is_associative() && decl->get_arity() > 0) {
for (unsigned j = 0; j < dom.size(); ++j) {
if (dom[j] != decl->get_domain(0)) {
goto try_next;
}
}
d = decl;
return true;
}
if (decl->get_arity() != dom.size()) {
goto try_next;
}
for (unsigned j = 0; j < decl->get_arity(); ++j) {
if (decl->get_domain(j) != dom[j]) {
goto try_next;
}
}
d = decl;
return true;
try_next:
if (decl->get_family_id() == m_manager.get_basic_family_id() && decl->get_decl_kind() == OP_DISTINCT) {
// we skip type checking for 'distinct'
d = decl;
return true;
}
}
return false;
}
// Store in result the func_decl that are not attached to any family id.
// That is, the uninterpreted constants and function declarations.
void symtable::get_func_decls(ptr_vector<func_decl> & result) const {
svector<ptr_vector<func_decl>*> tmp;
m_ids.get_range(tmp);
svector<ptr_vector<func_decl>*>::const_iterator it = tmp.begin();
svector<ptr_vector<func_decl>*>::const_iterator end = tmp.end();
for (; it != end; ++it) {
ptr_vector<func_decl> * curr = *it;
if (curr) {
ptr_vector<func_decl>::const_iterator it2 = curr->begin();
ptr_vector<func_decl>::const_iterator end2 = curr->end();
for (; it2 != end2; ++it2) {
func_decl * d = *it2;
if (d && d->get_family_id() == null_family_id) {
result.push_back(d);
}
}
}
}
}
void symtable::insert(symbol s, sort_builder* sb) {
m_sorts.insert(s, sb);
}
bool symtable::lookup(symbol s, sort_builder*& sb) {
return m_sorts.find(s, sb);
}
void symtable::push_sort(symbol name, sort* srt) {
m_sorts.begin_scope();
sort_builder* sb = alloc(basic_sort_builder,srt);
m_sorts.insert(name, sb);
m_sorts_trail.push_back(sb);
}
void symtable::pop_sorts(unsigned num_sorts) {
while (num_sorts > 0) {
dealloc(m_sorts_trail.back());
m_sorts_trail.pop_back();
m_sorts.end_scope();
}
}
void symtable::get_sorts(ptr_vector<sort>& result) const {
vector<sort*,false> tmp;
m_sorts1.get_range(tmp);
for (unsigned i = 0; i < tmp.size(); ++i) {
if (tmp[i]->get_family_id() == null_family_id) {
result.push_back(tmp[i]);
}
}
}
// --------------------------------------------------------------------------
// theory
func_decl * theory::declare_func(symbol const & id, sort_ref_buffer & domain, sort * range,
bool is_assoc, bool is_comm, bool is_inj) {
func_decl * decl = m_ast_manager.mk_func_decl(id, domain.size(), domain.c_ptr(), range,
is_assoc, is_comm, is_inj);
m_symtable.insert(id, decl);
m_asts.push_back(decl);
return decl;
}
sort * theory::declare_sort(symbol const & id) {
sort * decl = m_ast_manager.mk_uninterpreted_sort(id);
m_symtable.insert(id, decl);
m_asts.push_back(decl);
return decl;
}
bool theory::get_func_decl(symbol id, func_decl * & decl) {
return m_symtable.find1(id, decl);
}
bool theory::get_sort(symbol id, sort* & s) {
return m_symtable.find(id, s);
}
bool theory::get_const(symbol id, expr * & term) {
func_decl* decl = 0;
if (!get_func_decl(id,decl)) {
return false;
}
if (decl->get_arity() != 0) {
return false;
}
term = m_ast_manager.mk_const(decl);
m_asts.push_back(term);
return true;
}
void benchmark::display_as_smt2(std::ostream & out) const {
if (m_logic != symbol::null)
out << "(set-logic " << m_logic << ")\n";
out << "(set-info :smt-lib-version 2.0)\n";
out << "(set-info :status ";
switch (m_status) {
case SAT: out << "sat"; break;
case UNSAT: out << "unsat"; break;
default: out << "unknown"; break;
}
out << ")\n";
#if 0
ast_manager & m = m_ast_manager;
ptr_vector<func_decl> decls;
m_symtable.get_func_decls(decls);
ptr_vector<func_decl>::const_iterator it = decls.begin();
ptr_vector<func_decl>::const_iterator end = decls.end();
for (; it != end; ++it) {
func_decl * f = *it;
out << "(declare-fun " << f->get_name() << " (";
for (unsigned i = 0; i < f->get_arity(); i++) {
if (i > 0) out << " ";
out << mk_ismt2_pp(f->get_domain(i), m);
}
out << ") " << mk_ismt2_pp(f->get_range(), m);
out << ")\n";
}
#endif
}

232
src/parsers/smt/smtlib.h
View file

@ -1,232 +0,0 @@
/*++
Copyright (c) 2006 Microsoft Corporation
Module Name:
smtlib.h
Abstract:
SMT library utilities
Author:
Nikolaj Bjorner (nbjorner) 2006-09-29
Revision History:
--*/
#ifndef SMTLIB_H_
#define SMTLIB_H_
#include "ast/ast.h"
#include "util/symbol_table.h"
#include "util/map.h"
#include "ast/arith_decl_plugin.h"
namespace smtlib {
class sort_builder {
public:
virtual ~sort_builder() {}
virtual bool apply(unsigned num_params, parameter const* params, sort_ref& result) = 0;
virtual char const* error_message() { return ""; }
};
class basic_sort_builder : public sort_builder {
sort* m_sort;
public:
basic_sort_builder(sort* s) : m_sort(s) {}
virtual bool apply(unsigned np, parameter const*, sort_ref& result) {
result = m_sort;
return m_sort && np != 0;
}
};
class symtable {
ast_manager& m_manager;
symbol_table<sort*> m_sorts1;
symbol_table<sort_builder*> m_sorts;
ptr_vector<sort_builder> m_sorts_trail;
symbol_table<ptr_vector<func_decl>* > m_ids;
public:
symtable(ast_manager& m): m_manager(m) {}
~symtable();
void reset();
void insert(symbol s, func_decl * d);
bool find(symbol s, ptr_vector<func_decl> * & decls) {
return m_ids.find(s, decls);
}
bool find1(symbol s, func_decl * & d);
bool find_overload(symbol s, ptr_vector<sort> const & dom, func_decl * & d);
void insert(symbol s, sort * d) {
sort * d2;
if (m_sorts1.find(s, d2)) {
m_manager.dec_ref(d2);
}
m_manager.inc_ref(d);
m_sorts1.insert(s, d);
}
bool find(symbol s, sort * & d) {
return m_sorts1.find(s, d);
}
void insert(symbol s, sort_builder* sb);
bool lookup(symbol s, sort_builder*& sb);
void push_sort(symbol s, sort*);
void pop_sorts(unsigned num_sorts);
void get_func_decls(ptr_vector<func_decl> & result) const;
void get_sorts(ptr_vector<sort>& result) const;
};
class theory {
public:
typedef ptr_vector<expr>::const_iterator expr_iterator;
theory(ast_manager & ast_manager, symbol const& name):
m_name(name),
m_ast_manager(ast_manager),
m_symtable(ast_manager),
m_asts(ast_manager)
{}
virtual ~theory() {}
symtable * get_symtable() { return &m_symtable; }
void insert(sort * s) { m_symtable.insert(s->get_name(), s); }
void insert(func_decl * c) { m_symtable.insert(c->get_name(), c); }
func_decl * declare_func(symbol const & id, sort_ref_buffer & domain, sort * range,
bool is_assoc, bool is_comm, bool is_inj);
sort * declare_sort(symbol const & id);
void add_axiom(expr * axiom) {
m_asts.push_back(axiom);
m_axioms.push_back(axiom);
}
expr_iterator begin_axioms() const {
return m_axioms.begin();
}
unsigned get_num_axioms() const {
return m_axioms.size();
}
expr * const * get_axioms() const {
return m_axioms.c_ptr();
}
expr_iterator end_axioms() const {
return m_axioms.end();
}
void add_assumption(expr * axiom) {
m_asts.push_back(axiom);
m_assumptions.push_back(axiom);
}
unsigned get_num_assumptions() const {
return m_assumptions.size();
}
expr * const * get_assumptions() const {
return m_assumptions.c_ptr();
}
bool get_func_decl(symbol, func_decl*&);
bool get_sort(symbol, sort*&);
bool get_const(symbol, expr*&);
void set_name(symbol const& name) { m_name = name; }
symbol const get_name() const { return m_name; }
protected:
symbol m_name;
ast_manager& m_ast_manager;
ptr_vector<expr> m_axioms;
ptr_vector<expr> m_assumptions;
symtable m_symtable;
ast_ref_vector m_asts;
private:
theory& operator=(theory const&);
theory(theory const&);
};
class benchmark : public theory {
public:
enum status {
UNKNOWN,
SAT,
UNSAT
};
benchmark(ast_manager & ast_manager, symbol const & name) :
theory(ast_manager, name),
m_status(UNKNOWN) {}
virtual ~benchmark() {}
status get_status() const { return m_status; }
void set_status(status status) { m_status = status; }
symbol get_logic() const {
if (m_logic == symbol::null) {
return symbol("ALL");
}
return m_logic;
}
void set_logic(symbol const & s) { m_logic = s; }
unsigned get_num_formulas() const {
return m_formulas.size();
}
expr_iterator begin_formulas() const {
return m_formulas.begin();
}
expr_iterator end_formulas() const {
return m_formulas.end();
}
void add_formula(expr * formula) {
m_asts.push_back(formula);
m_formulas.push_back(formula);
}
void display_as_smt2(std::ostream & out) const;
private:
status m_status;
symbol m_logic;
ptr_vector<expr> m_formulas;
};
};
#endif

119
src/parsers/smt/smtlib_solver.cpp
View file

@ -1,119 +0,0 @@
/*++
Copyright (c) 2006 Microsoft Corporation
Module Name:
smtlib_solver.cpp
Abstract:
SMT based solver.
Author:
Nikolaj Bjorner (nbjorner) 2006-11-3.
Revision History:
--*/
#include "parsers/smt/smtparser.h"
#include "parsers/smt/smtlib_solver.h"
#include "util/warning.h"
#include "ast/ast_pp.h"
#include "ast/ast_ll_pp.h"
#include "ast/well_sorted.h"
#include "model/model.h"
#include "model/model_v2_pp.h"
#include "solver/solver.h"
#include "tactic/portfolio/smt_strategic_solver.h"
#include "cmd_context/cmd_context.h"
#include "model/model_params.hpp"
#include "parsers/util/parser_params.hpp"
namespace smtlib {
solver::solver():
m_ast_manager(m_params.m_proof ? PGM_ENABLED : PGM_DISABLED,
m_params.m_trace ? m_params.m_trace_file_name.c_str() : 0),
m_ctx(0),
m_error_code(0) {
parser_params ps;
m_parser = parser::create(m_ast_manager, ps.ignore_user_patterns());
m_parser->initialize_smtlib();
}
solver::~solver() {
if (m_ctx)
dealloc(m_ctx);
}
bool solver::solve_smt(char const * benchmark_file) {
IF_VERBOSE(100, verbose_stream() << "parsing...\n";);
if (!m_parser->parse_file(benchmark_file)) {
if (benchmark_file) {
warning_msg("could not parse file '%s'.", benchmark_file);
}
else {
warning_msg("could not parse input stream.");
}
m_error_code = ERR_PARSER;
return false;
}
benchmark * benchmark = m_parser->get_benchmark();
solve_benchmark(*benchmark);
return true;
}
bool solver::solve_smt_string(char const * benchmark_string) {
if (!m_parser->parse_string(benchmark_string)) {
warning_msg("could not parse string '%s'.", benchmark_string);
return false;
}
benchmark * benchmark = m_parser->get_benchmark();
solve_benchmark(*benchmark);
return true;
}
void solver::display_statistics() {
if (m_ctx)
m_ctx->display_statistics();
}
void solver::solve_benchmark(benchmark & benchmark) {
if (benchmark.get_num_formulas() == 0) {
// Hack: it seems SMT-LIB allow benchmarks without any :formula
benchmark.add_formula(m_ast_manager.mk_true());
}
m_ctx = alloc(cmd_context, true, &m_ast_manager, benchmark.get_logic());
m_ctx->set_solver_factory(mk_smt_strategic_solver_factory());
theory::expr_iterator fit = benchmark.begin_formulas();
theory::expr_iterator fend = benchmark.end_formulas();
for (; fit != fend; ++fit)
solve_formula(benchmark, *fit);
}
void solver::solve_formula(benchmark const & benchmark, expr * f) {
IF_VERBOSE(100, verbose_stream() << "starting...\n";);
m_ctx->reset();
for (unsigned i = 0; i < benchmark.get_num_axioms(); i++)
m_ctx->assert_expr(benchmark.get_axioms()[i]);
m_ctx->assert_expr(f);
m_ctx->check_sat(benchmark.get_num_assumptions(), benchmark.get_assumptions());
check_sat_result * r = m_ctx->get_check_sat_result();
if (r != 0) {
proof * pr = r->get_proof();
if (pr != 0 && m_params.m_proof)
std::cout << mk_ll_pp(pr, m_ast_manager, false, false);
model_ref md;
if (r->status() != l_false) r->get_model(md);
if (md.get() != 0 && m_params.m_model) {
model_params p;
model_v2_pp(std::cout, *(md.get()), p.partial());
}
}
else {
m_error_code = ERR_UNKNOWN_RESULT;
}
}
};

48
src/parsers/smt/smtlib_solver.h
View file

@ -1,48 +0,0 @@
/*++
Copyright (c) 2006 Microsoft Corporation
Module Name:
smtlib_solver.h
Abstract:
SMT based solver.
Author:
Nikolaj Bjorner (nbjorner) 2006-11-3.
Revision History:
--*/
#ifndef SMTLIB_SOLVER_H_
#define SMTLIB_SOLVER_H_
#include "parsers/smt/smtparser.h"
#include "cmd_context/context_params.h"
#include "util/lbool.h"
class cmd_context;
namespace smtlib {
class solver {
context_params m_params;
ast_manager m_ast_manager;
cmd_context * m_ctx;
scoped_ptr<parser> m_parser;
unsigned m_error_code;
public:
solver();
~solver();
bool solve_smt(char const * benchmark_file);
bool solve_smt_string(char const * benchmark_string);
void display_statistics();
unsigned get_error_code() const { return m_error_code; }
private:
void solve_benchmark(benchmark & benchmark);
void solve_formula(benchmark const & benchmark, expr * f);
};
};
#endif

2760
src/parsers/smt/smtparser.cpp
View file

File diff suppressed because it is too large Load diff

48
src/parsers/smt/smtparser.h
View file

@ -1,48 +0,0 @@
/*++
Copyright (c) 2006 Microsoft Corporation
Module Name:
smtparser.h
Abstract:
SMT parsing utilities
Author:
Nikolaj Bjorner (nbjorner) 2006-09-25
Revision History:
--*/
#ifndef SMT_PARSER_H_
#define SMT_PARSER_H_
#include<iostream>
#include "ast/ast.h"
#include "util/vector.h"
#include "parsers/smt/smtlib.h"
namespace smtlib {
class parser {
public:
static parser * create(ast_manager & ast_manager, bool ignore_user_patterns = false);
virtual ~parser() {}
virtual void add_builtin_op(char const *, family_id fid, decl_kind kind) = 0;
virtual void add_builtin_type(char const *, family_id fid, decl_kind kind) = 0;
virtual void initialize_smtlib() = 0;
virtual void set_error_stream(std::ostream& strm) = 0;
virtual bool parse_file(char const * path) = 0;
virtual bool parse_string(char const * string) = 0;
virtual benchmark * get_benchmark() = 0;
};
};
#endif

2
src/parsers/smt2/marshal.cpp
View file

@ -36,7 +36,7 @@ std::string marshal(expr_ref e, ast_manager &m) {
expr_ref unmarshal(std::istream &is, ast_manager &m) {
cmd_context ctx(false, &m);
ctx.set_ignore_check(true);
if (!parse_smt2_commands(ctx, is)) { return expr_ref(0, m); }
if (!parse_smt2_commands(ctx, is)) { return expr_ref(nullptr, m); }
ptr_vector<expr>::const_iterator it = ctx.begin_assertions();
ptr_vector<expr>::const_iterator end = ctx.end_assertions();

127
src/parsers/smt2/smt2parser.cpp
View file

@ -46,7 +46,7 @@ namespace smt2 {
struct local {
expr * m_term;
unsigned m_level;
local():m_term(0), m_level(0) {}
local():m_term(nullptr), m_level(0) {}
local(expr * t, unsigned l):m_term(t), m_level(l) {}
};
symbol_table<local> m_env;
@ -224,31 +224,31 @@ namespace smt2 {
}
psort_ref_vector & psort_stack() {
if (m_psort_stack.get() == 0)
if (m_psort_stack.get() == nullptr)
m_psort_stack = alloc(psort_ref_vector, pm());
return *(m_psort_stack.get());
}
sort_ref_vector & sort_stack() {
if (m_sort_stack.get() == 0)
if (m_sort_stack.get() == nullptr)
m_sort_stack = alloc(sort_ref_vector, m());
return *(m_sort_stack.get());
}
expr_ref_vector & expr_stack() {
if (m_expr_stack.get() == 0)
if (m_expr_stack.get() == nullptr)
m_expr_stack = alloc(expr_ref_vector, m());
return *(m_expr_stack.get());
}
template<typename T>
static unsigned size(scoped_ptr<T> & v) {
return v.get() == 0 ? 0 : v->size();
return v.get() == nullptr ? 0 : v->size();
}
template<typename T>
static void shrink(scoped_ptr<T> & v, unsigned old_sz) {
if (v.get() == 0) {
if (v.get() == nullptr) {
SASSERT(old_sz == 0);
}
else {
@ -257,13 +257,13 @@ namespace smt2 {
}
expr_ref_vector & pattern_stack() {
if (m_pattern_stack.get() == 0)
if (m_pattern_stack.get() == nullptr)
m_pattern_stack = alloc(expr_ref_vector, m());
return *(m_pattern_stack.get());
}
expr_ref_vector & nopattern_stack() {
if (m_nopattern_stack.get() == 0)
if (m_nopattern_stack.get() == nullptr)
m_nopattern_stack = alloc(expr_ref_vector, m());
return *(m_nopattern_stack.get());
}
@ -273,44 +273,44 @@ namespace smt2 {
}
sexpr_ref_vector & sexpr_stack() {
if (m_sexpr_stack.get() == 0)
if (m_sexpr_stack.get() == nullptr)
m_sexpr_stack = alloc(sexpr_ref_vector, sm());
return *(m_sexpr_stack.get());
}
arith_util & autil() {
if (m_arith_util.get() == 0)
if (m_arith_util.get() == nullptr)
m_arith_util = alloc(arith_util, m());
return *(m_arith_util.get());
}
datatype_util & dtutil() {
if (m_datatype_util.get() == 0)
if (m_datatype_util.get() == nullptr)
m_datatype_util = alloc(datatype_util, m());
return *(m_datatype_util.get());
}
seq_util & sutil() {
if (m_seq_util.get() == 0)
if (m_seq_util.get() == nullptr)
m_seq_util = alloc(seq_util, m());
return *(m_seq_util.get());
}
bv_util & butil() {
if (m_bv_util.get() == 0)
if (m_bv_util.get() == nullptr)
m_bv_util = alloc(bv_util, m());
return *(m_bv_util.get());
}
pattern_validator & pat_validator() {
if (m_pattern_validator.get() == 0) {
if (m_pattern_validator.get() == nullptr) {
m_pattern_validator = alloc(pattern_validator, m());
}
return *(m_pattern_validator.get());
}
var_shifter & shifter() {
if (m_var_shifter.get() == 0)
if (m_var_shifter.get() == nullptr)
m_var_shifter = alloc(var_shifter, m());
return *(m_var_shifter.get());
}
@ -571,12 +571,12 @@ namespace smt2 {
SASSERT(curr_is_identifier());
symbol id = curr_id();
psort_decl * d = m_ctx.find_psort_decl(id);
if (d == 0)
if (d == nullptr)
unknown_sort(id, context);
if (!d->has_var_params() && d->get_num_params() != 0)
throw parser_exception("sort constructor expects parameters");
sort * r = d->instantiate(pm());
if (r == 0)
if (r == nullptr)
throw parser_exception("invalid sort application");
next();
return r;
@ -586,7 +586,7 @@ namespace smt2 {
SASSERT(curr_is_identifier());
symbol id = curr_id();
psort_decl * d = m_ctx.find_psort_decl(id);
if (d != 0) {
if (d != nullptr) {
if (!d->has_var_params() && d->get_num_params() != 0)
throw parser_exception("sort constructor expects parameters");
next();
@ -603,7 +603,7 @@ namespace smt2 {
unknown_sort(id);
UNREACHABLE();
}
return 0;
return nullptr;
}
}
}
@ -614,7 +614,7 @@ namespace smt2 {
next();
symbol id = check_identifier_next("invalid indexed sort, symbol expected");
psort_decl * d = m_ctx.find_psort_decl(id);
if (d == 0)
if (d == nullptr)
unknown_sort(id);
sbuffer<unsigned> args;
while (!curr_is_rparen()) {
@ -626,7 +626,7 @@ namespace smt2 {
if (args.empty())
throw parser_exception("invalid indexed sort, index expected");
sort * r = d->instantiate(pm(), args.size(), args.c_ptr());
if (r == 0)
if (r == nullptr)
throw parser_exception("invalid sort application");
next();
return r;
@ -636,7 +636,7 @@ namespace smt2 {
SASSERT(curr_is_identifier());
symbol id = curr_id();
psort_decl * d = m_ctx.find_psort_decl(id);
if (d == 0) {
if (d == nullptr) {
unknown_sort(id);
}
next();
@ -699,7 +699,7 @@ namespace smt2 {
SASSERT(curr_is_identifier());
symbol id = curr_id();
psort_decl * d = m_ctx.find_psort_decl(id);
if (d == 0)
if (d == nullptr)
unknown_sort(id);
next();
void * mem = m_stack.allocate(sizeof(sort_frame));
@ -719,7 +719,7 @@ namespace smt2 {
throw parser_exception("invalid number of parameters to sort constructor");
}
sort * r = d->instantiate(pm(), num, sort_stack().c_ptr() + spos);
if (r == 0)
if (r == nullptr)
throw parser_exception("invalid sort application");
sort_stack().shrink(spos);
sort_stack().push_back(r);
@ -785,7 +785,7 @@ namespace smt2 {
SASSERT(curr_is_identifier());
psort * p = parse_psort_name(true);
ptype result;
if (p != 0) {
if (p != nullptr) {
result = ptype(p);
}
else {
@ -830,7 +830,7 @@ namespace smt2 {
symbol r_name(r_str.c_str());
next();
TRACE("datatype_parser_bug", tout << ct_name << " " << r_name << "\n";);
ct_decls.push_back(pm().mk_pconstructor_decl(m_sort_id2param_idx.size(), ct_name, r_name, 0, 0));
ct_decls.push_back(pm().mk_pconstructor_decl(m_sort_id2param_idx.size(), ct_name, r_name, 0, nullptr));
}
else {
check_lparen_next("invalid datatype declaration, '(' or ')' expected");
@ -869,7 +869,7 @@ namespace smt2 {
throw parser_exception("invalid datatype declaration, too many data-type bodies defined");
}
symbol dt_name = m_dt_names[i];
parse_datatype_dec(new_ct_decls);
parse_datatype_dec(nullptr, new_ct_decls);
d = pm().mk_pdatatype_decl(m_dt_name2arity.find(dt_name), dt_name, new_ct_decls.size(), new_ct_decls.c_ptr());
}
else {
@ -944,7 +944,7 @@ namespace smt2 {
pdatatype_decl_ref d(pm());
pconstructor_decl_ref_buffer new_ct_decls(pm());
parse_datatype_dec(new_ct_decls);
parse_datatype_dec(&dt_name, new_ct_decls);
d = pm().mk_pdatatype_decl(m_sort_id2param_idx.size(), dt_name, new_ct_decls.size(), new_ct_decls.c_ptr());
check_missing(d, line, pos);
@ -958,16 +958,23 @@ namespace smt2 {
// datatype_dec ::= ( constructor_dec+ ) | ( par ( symbol+ ) ( constructor_dec+ ) )
void parse_datatype_dec(pconstructor_decl_ref_buffer & ct_decls) {
void parse_datatype_dec(symbol* dt_name, pconstructor_decl_ref_buffer & ct_decls) {
check_lparen_next("invalid datatype declaration, '(' expected");
if (curr_id() == m_par) {
next();
parse_sort_decl_params();
check_lparen_next("invalid constructor declaration after par, '(' expected");
unsigned sz = m_sort_id2param_idx.size();
if (sz > 0 && dt_name) {
m_ctx.insert(pm().mk_psort_dt_decl(sz, *dt_name));
}
parse_constructor_decls(ct_decls);
check_rparen_next("invalid datatype declaration, ')' expected");
}
else {
if (dt_name) {
m_ctx.insert(pm().mk_psort_dt_decl(0, *dt_name));
}
parse_constructor_decls(ct_decls);
}
check_rparen_next("invalid datatype declaration, ')' expected");
@ -997,13 +1004,13 @@ namespace smt2 {
TRACE("name_expr", tout << "naming: " << s << " ->\n" << mk_pp(n, m()) << "\n";);
if (!is_ground(n) && has_free_vars(n))
throw parser_exception("invalid named expression, expression contains free variables");
m_ctx.insert(s, 0, 0, n);
m_ctx.insert(s, 0, nullptr, n);
m_last_named_expr.first = s;
m_last_named_expr.second = n;
}
bool in_quant_ctx(attr_expr_frame * fr) {
return fr != 0 && fr->m_prev != 0 && fr->m_prev->m_kind == EF_QUANT;
return fr != nullptr && fr->m_prev != nullptr && fr->m_prev->m_kind == EF_QUANT;
}
void check_in_quant_ctx(attr_expr_frame * fr) {
@ -1016,7 +1023,7 @@ namespace smt2 {
return;
if (fr->m_last_symbol == m_pattern) {
expr * pat = expr_stack().back();
if (pat == 0) {
if (pat == nullptr) {
if (!ignore_bad_patterns())
throw parser_exception("invalid empty pattern");
}
@ -1189,7 +1196,7 @@ namespace smt2 {
if (!ignore_bad_patterns())
throw parser_exception("invalid pattern, '(' expected");
consume_sexpr();
expr_stack().push_back(0); // empty pattern
expr_stack().push_back(nullptr); // empty pattern
return;
}
@ -1201,7 +1208,7 @@ namespace smt2 {
}
else if (curr_is_rparen()) {
next();
expr_stack().push_back(0); // empty pattern
expr_stack().push_back(nullptr); // empty pattern
}
else {
// unary pattern
@ -1209,7 +1216,7 @@ namespace smt2 {
// when Simplify benchmarks were converted into SMT2 ones.
if (curr_is_identifier()) {
symbol id = curr_id();
func_decl * f = 0;
func_decl * f = nullptr;
try {
f = m_ctx.find_func_decl(id);
}
@ -1221,7 +1228,7 @@ namespace smt2 {
while (!curr_is_rparen())
consume_sexpr();
next();
expr_stack().push_back(0); // empty pattern
expr_stack().push_back(nullptr); // empty pattern
return; // no frame is created
}
}
@ -1409,7 +1416,7 @@ namespace smt2 {
else {
SASSERT(is_app(pattern));
func_decl * f = to_app(pattern)->get_decl();
func_decl * r = dtutil().get_constructor_recognizer(f);
func_decl * r = dtutil().get_constructor_is(f);
ptr_vector<func_decl> const * acc = dtutil().get_constructor_accessors(f);
shifter()(t, acc->size(), tsh);
for (func_decl* a : *acc) {
@ -1759,7 +1766,7 @@ namespace smt2 {
return;
}
expr_ref t_ref(m());
m_ctx.mk_app(r, 0, 0, num_indices, m_param_stack.c_ptr() + param_spos, has_as ? sort_stack().back() : 0, t_ref);
m_ctx.mk_app(r, 0, nullptr, num_indices, m_param_stack.c_ptr() + param_spos, has_as ? sort_stack().back() : nullptr, t_ref);
m_param_stack.shrink(param_spos);
expr_stack().push_back(t_ref.get());
if (has_as) {
@ -1849,7 +1856,7 @@ namespace smt2 {
expr_stack().c_ptr() + fr->m_expr_spos,
num_indices,
m_param_stack.c_ptr() + fr->m_param_spos,
fr->m_as_sort ? sort_stack().back() : 0,
fr->m_as_sort ? sort_stack().back() : nullptr,
t_ref);
expr_stack().shrink(fr->m_expr_spos);
m_param_stack.shrink(fr->m_param_spos);
@ -2048,7 +2055,7 @@ namespace smt2 {
parse_bv_numeral();
break;
case scanner::LEFT_PAREN:
push_expr_frame(m_num_expr_frames == 0 ? 0 : static_cast<expr_frame*>(m_stack.top()));
push_expr_frame(m_num_expr_frames == 0 ? nullptr : static_cast<expr_frame*>(m_stack.top()));
break;
case scanner::KEYWORD_TOKEN:
throw parser_exception("invalid expression, unexpected keyword");
@ -2147,17 +2154,17 @@ namespace smt2 {
check_identifier("invalid sort declaration, symbol expected");
symbol id = curr_id();
if (m_ctx.find_psort_decl(id) != 0)
if (m_ctx.find_psort_decl(id) != nullptr)
throw parser_exception("invalid sort declaration, sort already declared/defined");
next();
if (curr_is_rparen()) {
psort_decl * decl = pm().mk_psort_user_decl(0, id, 0);
psort_decl * decl = pm().mk_psort_user_decl(0, id, nullptr);
m_ctx.insert(decl);
}
else {
check_int("invalid sort declaration, arity (<numeral>) or ')' expected");
unsigned u = curr_unsigned();
psort_decl * decl = pm().mk_psort_user_decl(u, id, 0);
psort_decl * decl = pm().mk_psort_user_decl(u, id, nullptr);
m_ctx.insert(decl);
next();
check_rparen("invalid sort declaration, ')' expected");
@ -2172,7 +2179,7 @@ namespace smt2 {
next();
check_identifier("invalid sort definition, symbol expected");
symbol id = curr_id();
if (m_ctx.find_psort_decl(id) != 0)
if (m_ctx.find_psort_decl(id) != nullptr)
throw parser_exception("invalid sort definition, sort already declared/defined");
next();
parse_sort_decl_params();
@ -2374,7 +2381,7 @@ namespace smt2 {
parse_expr();
if (m().get_sort(expr_stack().back()) != sort_stack().back())
throw parser_exception("invalid constant definition, sort mismatch");
m_ctx.insert(id, 0, 0, expr_stack().back());
m_ctx.insert(id, 0, nullptr, expr_stack().back());
check_rparen("invalid constant definition, ')' expected");
expr_stack().pop_back();
sort_stack().pop_back();
@ -2819,7 +2826,7 @@ namespace smt2 {
void parse_ext_cmd(int line, int pos) {
symbol s = curr_id();
m_curr_cmd = m_ctx.find_cmd(s);
if (m_curr_cmd == 0) {
if (m_curr_cmd == nullptr) {
parse_unknown_cmd();
return;
}
@ -2838,7 +2845,7 @@ namespace smt2 {
throw parser_exception("invalid command, argument(s) missing");
m_curr_cmd->execute(m_ctx);
next();
m_curr_cmd = 0;
m_curr_cmd = nullptr;
shrink(m_sort_stack, sort_spos);
shrink(m_expr_stack, expr_spos);
shrink(m_sexpr_stack, sexpr_spos);
@ -2946,12 +2953,12 @@ namespace smt2 {
}
public:
parser(cmd_context & ctx, std::istream & is, bool interactive, params_ref const & p, char const * filename=0):
parser(cmd_context & ctx, std::istream & is, bool interactive, params_ref const & p, char const * filename=nullptr):
m_ctx(ctx),
m_params(p),
m_scanner(ctx, is, interactive),
m_curr(scanner::NULL_TOKEN),
m_curr_cmd(0),
m_curr_cmd(nullptr),
m_num_bindings(0),
m_let("let"),
m_bang("!"),
@ -3013,23 +3020,23 @@ namespace smt2 {
void reset() {
reset_stack();
m_num_bindings = 0;
m_psort_stack = 0;
m_sort_stack = 0;
m_expr_stack = 0;
m_pattern_stack = 0;
m_nopattern_stack = 0;
m_sexpr_stack = 0;
m_psort_stack = nullptr;
m_sort_stack = nullptr;
m_expr_stack = nullptr;
m_pattern_stack = nullptr;
m_nopattern_stack = nullptr;
m_sexpr_stack = nullptr;
m_symbol_stack .reset();
m_param_stack .reset();
m_env .reset();
m_sort_id2param_idx .reset();
m_dt_name2idx .reset();
m_bv_util = 0;
m_arith_util = 0;
m_seq_util = 0;
m_pattern_validator = 0;
m_var_shifter = 0;
m_bv_util = nullptr;
m_arith_util = nullptr;
m_seq_util = nullptr;
m_pattern_validator = nullptr;
m_var_shifter = nullptr;
}
bool operator()() {

2
src/parsers/smt2/smt2parser.h
View file

@ -21,6 +21,6 @@ Revision History:
#include "cmd_context/cmd_context.h"
bool parse_smt2_commands(cmd_context & ctx, std::istream & is, bool interactive = false, params_ref const & p = params_ref(), char const * filename = 0);
bool parse_smt2_commands(cmd_context & ctx, std::istream & is, bool interactive = false, params_ref const & p = params_ref(), char const * filename = nullptr);
#endif

6
src/parsers/util/cost_parser.h
View file

@ -27,9 +27,9 @@ class cost_parser : public simple_parser {
var_ref_vector m_vars;
public:
cost_parser(ast_manager & m);
virtual ~cost_parser() {}
virtual expr * parse_int(rational const & r);
virtual expr * parse_float(rational const & r);
~cost_parser() override {}
expr * parse_int(rational const & r) override;
expr * parse_float(rational const & r) override;
unsigned add_var(symbol name);
unsigned add_var(char const * name) { return add_var(symbol(name)); }
void reset_vars();

6
src/parsers/util/simple_parser.cpp
View file

@ -87,7 +87,7 @@ expr * simple_parser::parse_expr(scanner & s) {
}
throw parser_error();
case scanner::RIGHT_PAREN:
return 0;
return nullptr;
case scanner::ID_TOKEN:
if (m_builtin.find(s.get_id(), op)) {
expr * r = m_manager.mk_const(op.m_family_id, op.m_kind);
@ -123,7 +123,7 @@ bool simple_parser::parse(std::istream & in, expr_ref & result) {
return false;
}
m_exprs.reset();
return result.get() != 0;
return result.get() != nullptr;
}
bool simple_parser::parse_string(char const * str, expr_ref & result) {
@ -133,7 +133,7 @@ bool simple_parser::parse_string(char const * str, expr_ref & result) {
}
bool simple_parser::parse_file(char const * file, expr_ref & result) {
if (file != 0) {
if (file != nullptr) {
std::ifstream stream(file);
if (!stream) {
warning_msg("ERROR: could not open file '%s'.", file);