mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-06-06 14:13:23 +00:00
Code Activity

Merge branch 'unstable' of https://github.com/Z3Prover/z3 into unstable

Browse source
This commit is contained in:
Nuno Lopes 2015-07-08 13:39:26 +01:00
commit 5703abd3f1
12 changed files with 118 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/cmd_context/context_params.cpp
View file

@ -45,7 +45,9 @@ void context_params::set_bool(bool & opt, char const * param, char const * value
opt = false; opt = false;
} }
else { else {
throw default_exception("invalid value '%s' for Boolean parameter '%s'", value, param); std::stringstream strm;
strm << "invalid value '" << value << "' for Boolean parameter '" << param;
throw default_exception(strm.str());
} }
} }

6
src/muz/base/hnf.cpp
View file

@ -112,6 +112,12 @@ public:
expr* n1, *n2; expr* n1, *n2;
while (is_forall(n)) n = to_quantifier(n)->get_expr(); while (is_forall(n)) n = to_quantifier(n)->get_expr();
if (m.is_implies(n, n1, n2) && is_predicate(n2)) { if (m.is_implies(n, n1, n2) && is_predicate(n2)) {
if (is_var(n1)) {
return true;
}
if (is_quantifier(n1)) {
return false;
}
app* a1 = to_app(n1); app* a1 = to_app(n1);
if (m.is_and(a1)) { if (m.is_and(a1)) {
for (unsigned i = 0; i < a1->get_num_args(); ++i) { for (unsigned i = 0; i < a1->get_num_args(); ++i) {

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

@ -665,7 +665,7 @@ protected:
dtoken unexpected(dtoken tok, char const* msg) { dtoken unexpected(dtoken tok, char const* msg) {
#if 1 #if 1
throw default_exception("%s at line %u '%s' found '%s'\n", msg, throw default_exception(default_exception::fmt(), "%s at line %u '%s' found '%s'\n", msg,
m_lexer->get_line(), m_lexer->get_token_data(), dtoken_strings[tok]); m_lexer->get_line(), m_lexer->get_token_data(), dtoken_strings[tok]);
SASSERT(false); SASSERT(false);
@ -958,7 +958,7 @@ protected:
m_vars.insert(data.bare_str(), v); m_vars.insert(data.bare_str(), v);
} }
else if (s != m_manager.get_sort(v)) { else if (s != m_manager.get_sort(v)) {
throw default_exception("sort: %s expected, but got: %s\n", throw default_exception(default_exception::fmt(), "sort: %s expected, but got: %s\n",
s->get_name().bare_str(), m_manager.get_sort(v)->get_name().bare_str()); s->get_name().bare_str(), m_manager.get_sort(v)->get_name().bare_str());
} }
args.push_back(v); args.push_back(v);
@ -1074,7 +1074,7 @@ protected:
sort * register_finite_sort(symbol name, uint64 domain_size, context::sort_kind k) { sort * register_finite_sort(symbol name, uint64 domain_size, context::sort_kind k) {
if(m_sort_dict.contains(name.bare_str())) { if(m_sort_dict.contains(name.bare_str())) {
throw default_exception("sort %s already declared", name.bare_str()); throw default_exception(default_exception::fmt(), "sort %s already declared", name.bare_str());
} }
sort * s = m_decl_util.mk_sort(name, domain_size); sort * s = m_decl_util.mk_sort(name, domain_size);
m_context.register_finite_sort(s, k); m_context.register_finite_sort(s, k);
@ -1084,7 +1084,7 @@ protected:
sort * register_int_sort(symbol name) { sort * register_int_sort(symbol name) {
if(m_sort_dict.contains(name.bare_str())) { if(m_sort_dict.contains(name.bare_str())) {
throw default_exception("sort %s already declared", name.bare_str()); throw default_exception(default_exception::fmt(), "sort %s already declared", name.bare_str());
} }
sort * s = m_arith.mk_int(); sort * s = m_arith.mk_int();
m_sort_dict.insert(name.bare_str(), s); m_sort_dict.insert(name.bare_str(), s);
@ -1094,7 +1094,7 @@ protected:
sort * get_sort(const char* str) { sort * get_sort(const char* str) {
sort * res; sort * res;
if(!m_sort_dict.find(str, res)) { if(!m_sort_dict.find(str, res)) {
throw default_exception("unknown sort \"%s\"", str); throw default_exception(default_exception::fmt(), "unknown sort \"%s\"", str);
} }
return res; return res;
} }
@ -1104,7 +1104,7 @@ protected:
if(m_arith.is_int(s)) { if(m_arith.is_int(s)) {
uint64 val; uint64 val;
if(!string_to_uint64(name.bare_str(), val)) { if(!string_to_uint64(name.bare_str(), val)) {
throw default_exception("Invalid integer: \"&s\"", name.bare_str()); throw default_exception(default_exception::fmt(), "Invalid integer: \"%s\"", name.bare_str());
} }
res = m_arith.mk_numeral(rational(val, rational::ui64()), s); res = m_arith.mk_numeral(rational(val, rational::ui64()), s);
} }
@ -1295,7 +1295,7 @@ private:
if(num==0) { if(num==0) {
const_name = symbol("<zero element>"); const_name = symbol("<zero element>");
} else if(!m_number_names.find(num, const_name)) { } else if(!m_number_names.find(num, const_name)) {
throw default_exception("unknown symbol number %I64u on line %d in file %s", throw default_exception(default_exception::fmt(), "unknown symbol number %I64u on line %d in file %s",
num, m_current_line, m_current_file.c_str()); num, m_current_line, m_current_file.c_str());
} }
res = mk_table_const(const_name, s); res = mk_table_const(const_name, s);
@ -1334,11 +1334,12 @@ private:
} }
uint64 num; uint64 num;
if(!read_uint64(ptr, num)) { if(!read_uint64(ptr, num)) {
throw default_exception("number expected on line %d in file %s", throw default_exception(default_exception::fmt(), "number expected on line %d in file %s",
m_current_line, m_current_file.c_str()); m_current_line, m_current_file.c_str());
} }
if(*ptr!=' ' && *ptr!=0) { if(*ptr!=' ' && *ptr!=0) {
throw default_exception("' ' expected to separate numbers on line %d in file %s, got '%s'", throw default_exception(default_exception::fmt(),
"' ' expected to separate numbers on line %d in file %s, got '%s'",
m_current_line, m_current_file.c_str(), ptr); m_current_line, m_current_file.c_str(), ptr);
} }
args.push_back(num); args.push_back(num);
@ -1359,7 +1360,7 @@ private:
func_decl * pred = m_context.try_get_predicate_decl(predicate_name); func_decl * pred = m_context.try_get_predicate_decl(predicate_name);
if(!pred) { if(!pred) {
throw default_exception("tuple file %s for undeclared predicate %s", throw default_exception(default_exception::fmt(), "tuple file %s for undeclared predicate %s",
m_current_file.c_str(), predicate_name.bare_str()); m_current_file.c_str(), predicate_name.bare_str());
} }
unsigned pred_arity = pred->get_arity(); unsigned pred_arity = pred->get_arity();
@ -1381,7 +1382,7 @@ private:
continue; continue;
} }
if(args.size()!=pred_arity) { if(args.size()!=pred_arity) {
throw default_exception("invalid number of arguments on line %d in file %s", throw default_exception(default_exception::fmt(), "invalid number of arguments on line %d in file %s",
m_current_line, m_current_file.c_str()); m_current_line, m_current_file.c_str());
} }
@ -1450,10 +1451,12 @@ private:
const char * ptr = full_line; const char * ptr = full_line;
if(!read_uint64(ptr, num)) { if(!read_uint64(ptr, num)) {
throw default_exception("number expected at line %d in file %s", m_current_line, m_current_file.c_str()); throw default_exception(default_exception::fmt(),
"number expected at line %d in file %s", m_current_line, m_current_file.c_str());
} }
if(*ptr!=' ') { if(*ptr!=' ') {
throw default_exception("' ' expected after the number at line %d in file %s", m_current_line, m_current_file.c_str()); throw default_exception(default_exception::fmt(),
"' ' expected after the number at line %d in file %s", m_current_line, m_current_file.c_str());
} }
ptr++; ptr++;

18
src/muz/rel/dl_instruction.cpp
View file

@ -385,7 +385,8 @@ namespace datalog {
if (!find_fn(r1, r2, fn)) { if (!find_fn(r1, r2, fn)) {
fn = r1.get_manager().mk_join_fn(r1, r2, m_cols1, m_cols2); fn = r1.get_manager().mk_join_fn(r1, r2, m_cols1, m_cols2);
if (!fn) { if (!fn) {
throw default_exception("trying to perform unsupported join operation on relations of kinds %s and %s", throw default_exception(default_exception::fmt(),
"trying to perform unsupported join operation on relations of kinds %s and %s",
r1.get_plugin().get_name().bare_str(), r2.get_plugin().get_name().bare_str()); r1.get_plugin().get_name().bare_str(), r2.get_plugin().get_name().bare_str());
} }
store_fn(r1, r2, fn); store_fn(r1, r2, fn);
@ -447,7 +448,7 @@ namespace datalog {
if (!find_fn(r, fn)) { if (!find_fn(r, fn)) {
fn = r.get_manager().mk_filter_equal_fn(r, m_value, m_col); fn = r.get_manager().mk_filter_equal_fn(r, m_value, m_col);
if (!fn) { if (!fn) {
throw default_exception( throw default_exception(default_exception::fmt(),
"trying to perform unsupported filter_equal operation on a relation of kind %s", "trying to perform unsupported filter_equal operation on a relation of kind %s",
r.get_plugin().get_name().bare_str()); r.get_plugin().get_name().bare_str());
} }
@ -496,7 +497,7 @@ namespace datalog {
if (!find_fn(r, fn)) { if (!find_fn(r, fn)) {
fn = r.get_manager().mk_filter_identical_fn(r, m_cols.size(), m_cols.c_ptr()); fn = r.get_manager().mk_filter_identical_fn(r, m_cols.size(), m_cols.c_ptr());
if (!fn) { if (!fn) {
throw default_exception( throw default_exception(default_exception::fmt(),
"trying to perform unsupported filter_identical operation on a relation of kind %s", "trying to perform unsupported filter_identical operation on a relation of kind %s",
r.get_plugin().get_name().bare_str()); r.get_plugin().get_name().bare_str());
} }
@ -542,7 +543,7 @@ namespace datalog {
if (!find_fn(r, fn)) { if (!find_fn(r, fn)) {
fn = r.get_manager().mk_filter_interpreted_fn(r, m_cond); fn = r.get_manager().mk_filter_interpreted_fn(r, m_cond);
if (!fn) { if (!fn) {
throw default_exception( throw default_exception(default_exception::fmt(),
"trying to perform unsupported filter_interpreted operation on a relation of kind %s", "trying to perform unsupported filter_interpreted operation on a relation of kind %s",
r.get_plugin().get_name().bare_str()); r.get_plugin().get_name().bare_str());
} }
@ -598,7 +599,7 @@ namespace datalog {
if (!find_fn(reg, fn)) { if (!find_fn(reg, fn)) {
fn = reg.get_manager().mk_filter_interpreted_and_project_fn(reg, m_cond, m_cols.size(), m_cols.c_ptr()); fn = reg.get_manager().mk_filter_interpreted_and_project_fn(reg, m_cond, m_cols.size(), m_cols.c_ptr());
if (!fn) { if (!fn) {
throw default_exception( throw default_exception(default_exception::fmt(),
"trying to perform unsupported filter_interpreted_and_project operation on a relation of kind %s", "trying to perform unsupported filter_interpreted_and_project operation on a relation of kind %s",
reg.get_plugin().get_name().bare_str()); reg.get_plugin().get_name().bare_str());
} }
@ -838,7 +839,8 @@ namespace datalog {
if (!find_fn(r1, r2, fn)) { if (!find_fn(r1, r2, fn)) {
fn = r1.get_manager().mk_join_project_fn(r1, r2, m_cols1, m_cols2, m_removed_cols); fn = r1.get_manager().mk_join_project_fn(r1, r2, m_cols1, m_cols2, m_removed_cols);
if (!fn) { if (!fn) {
throw default_exception("trying to perform unsupported join-project operation on relations of kinds %s and %s", throw default_exception(default_exception::fmt(),
"trying to perform unsupported join-project operation on relations of kinds %s and %s",
r1.get_plugin().get_name().bare_str(), r2.get_plugin().get_name().bare_str()); r1.get_plugin().get_name().bare_str(), r2.get_plugin().get_name().bare_str());
} }
store_fn(r1, r2, fn); store_fn(r1, r2, fn);
@ -905,7 +907,7 @@ namespace datalog {
const relation_base & s = *ctx.reg(m_source_reg); const relation_base & s = *ctx.reg(m_source_reg);
if (!s.from_table()) { if (!s.from_table()) {
throw default_exception("relation is not a table %s", throw default_exception(default_exception::fmt(), "relation is not a table %s",
s.get_plugin().get_name().bare_str()); s.get_plugin().get_name().bare_str());
} }
++ctx.m_stats.m_min; ++ctx.m_stats.m_min;
@ -963,7 +965,7 @@ namespace datalog {
if (!find_fn(r, fn)) { if (!find_fn(r, fn)) {
fn = r.get_manager().mk_select_equal_and_project_fn(r, m_value, m_col); fn = r.get_manager().mk_select_equal_and_project_fn(r, m_value, m_col);
if (!fn) { if (!fn) {
throw default_exception( throw default_exception(default_exception::fmt(),
"trying to perform unsupported select_equal_and_project operation on a relation of kind %s", "trying to perform unsupported select_equal_and_project operation on a relation of kind %s",
r.get_plugin().get_name().bare_str()); r.get_plugin().get_name().bare_str());
} }

44
src/smt/theory_arith_aux.h
View file

@ -1321,8 +1321,10 @@ namespace smt {
typename svector<col_entry>::iterator end = c.end_entries(); typename svector<col_entry>::iterator end = c.end_entries();
init_gains(x_j, inc, min_gain, max_gain); init_gains(x_j, inc, min_gain, max_gain);
has_shared |= ctx.is_shared(get_enode(x_j)); has_shared |= ctx.is_shared(get_enode(x_j));
bool empty_column = true;
for (; it != end; ++it) { for (; it != end; ++it) {
if (it->is_dead()) continue; if (it->is_dead()) continue;
empty_column = false;
row const & r = m_rows[it->m_row_id]; row const & r = m_rows[it->m_row_id];
theory_var s = r.get_base_var(); theory_var s = r.get_base_var();
numeral const & coeff_ij = r[it->m_row_idx].m_coeff; numeral const & coeff_ij = r[it->m_row_idx].m_coeff;
@ -1333,7 +1335,6 @@ namespace smt {
} }
has_shared |= ctx.is_shared(get_enode(s)); has_shared |= ctx.is_shared(get_enode(s));
} }
bool empty_column = (c.begin_entries() == end);
TRACE("opt", TRACE("opt",
tout << (safe_gain(min_gain, max_gain)?"safe":"unsafe") << "\n"; tout << (safe_gain(min_gain, max_gain)?"safe":"unsafe") << "\n";
tout << "min gain: " << min_gain; tout << "min gain: " << min_gain;
@ -1373,7 +1374,7 @@ namespace smt {
template<typename Ext> template<typename Ext>
void theory_arith<Ext>::normalize_gain(numeral const& divisor, inf_numeral & max_gain) const { void theory_arith<Ext>::normalize_gain(numeral const& divisor, inf_numeral & max_gain) const {
SASSERT(divisor.is_int()); SASSERT(divisor.is_int());
if (!divisor.is_minus_one() && !divisor.is_one() && !max_gain.is_minus_one()) { if (!divisor.is_minus_one() && !max_gain.is_minus_one()) {
max_gain = floor(max_gain/divisor)*divisor; max_gain = floor(max_gain/divisor)*divisor;
} }
} }
@ -1403,6 +1404,7 @@ namespace smt {
<< "min gain: " << min_gain << " " << "min gain: " << min_gain << " "
<< "max gain: " << max_gain << "\n";); << "max gain: " << max_gain << "\n";);
SASSERT(max_gain.is_minus_one() || !max_gain.is_neg()); SASSERT(max_gain.is_minus_one() || !max_gain.is_neg());
SASSERT(min_gain.is_minus_one() || min_gain.is_one()); SASSERT(min_gain.is_minus_one() || min_gain.is_one());
SASSERT(!is_int(x) || max_gain.is_int()); SASSERT(!is_int(x) || max_gain.is_int());
@ -1423,6 +1425,8 @@ namespace smt {
// a_ij < 0, !inc -> decrement x_i // a_ij < 0, !inc -> decrement x_i
// a_ij denominator // a_ij denominator
SASSERT(!a_ij.is_zero());
if (!safe_gain(min_gain, max_gain)) return false; if (!safe_gain(min_gain, max_gain)) return false;
inf_numeral max_inc = inf_numeral::minus_one(); inf_numeral max_inc = inf_numeral::minus_one();
@ -1438,8 +1442,13 @@ namespace smt {
if (is_int(x_i)) den_aij = denominator(a_ij); if (is_int(x_i)) den_aij = denominator(a_ij);
SASSERT(den_aij.is_pos() && den_aij.is_int()); SASSERT(den_aij.is_pos() && den_aij.is_int());
if (is_int(x_i) && !den_aij.is_one() && min_gain.is_pos()) { if (is_int(x_i) && !den_aij.is_one()) {
if (min_gain.is_neg()) {
min_gain = inf_numeral(den_aij);
}
else {
min_gain = inf_numeral(lcm(min_gain.get_rational(), den_aij)); min_gain = inf_numeral(lcm(min_gain.get_rational(), den_aij));
}
normalize_gain(min_gain.get_rational(), max_gain); normalize_gain(min_gain.get_rational(), max_gain);
} }
@ -1467,11 +1476,12 @@ namespace smt {
<< "min gain: " << min_gain << " " << "min gain: " << min_gain << " "
<< "max gain: " << max_gain << " tighter: " << "max gain: " << max_gain << " tighter: "
<< (is_tighter?"true":"false") << "\n";); << (is_tighter?"true":"false") << "\n";);
SASSERT(max_gain.is_minus_one() || !max_gain.is_neg()); SASSERT(max_gain.is_minus_one() || !max_gain.is_neg());
SASSERT(min_gain.is_minus_one() || !min_gain.is_neg()); SASSERT(min_gain.is_minus_one() || !min_gain.is_neg());
//SASSERT(!is_int(x_i) || min_gain.is_pos()); SASSERT(!is_int(x_i) || min_gain.is_pos());
//SASSERT(!is_int(x_i) || min_gain.is_int()); SASSERT(!is_int(x_i) || min_gain.is_int());
//SASSERT(!is_int(x_i) || max_gain.is_int()); SASSERT(!is_int(x_i) || max_gain.is_int());
return is_tighter; return is_tighter;
} }
@ -1510,6 +1520,7 @@ namespace smt {
context& ctx = get_context(); context& ctx = get_context();
SASSERT(!maintain_integrality || valid_assignment()); SASSERT(!maintain_integrality || valid_assignment());
SASSERT(satisfy_bounds());
numeral a_ij, curr_a_ij, coeff, curr_coeff; numeral a_ij, curr_a_ij, coeff, curr_coeff;
inf_numeral min_gain, max_gain, curr_min_gain, curr_max_gain; inf_numeral min_gain, max_gain, curr_min_gain, curr_max_gain;
@ -1538,15 +1549,17 @@ namespace smt {
// variable cannot be used for max/min. // variable cannot be used for max/min.
continue; continue;
} }
if (!pick_var_to_leave(curr_x_j, curr_inc, curr_a_ij, bool picked_var = pick_var_to_leave(curr_x_j, curr_inc, curr_a_ij,
curr_min_gain, curr_max_gain, curr_min_gain, curr_max_gain,
has_shared, curr_x_i)) { has_shared, curr_x_i);
SASSERT(!picked_var || safe_gain(curr_min_gain, curr_max_gain));
if (!picked_var) {
best_efforts++; best_efforts++;
} }
else { else if (curr_x_i == null_theory_var) {
SASSERT(safe_gain(curr_min_gain, curr_max_gain));
}
if (curr_x_i == null_theory_var) {
TRACE("opt", tout << "unbounded\n";); TRACE("opt", tout << "unbounded\n";);
// we can increase/decrease curr_x_j as much as we want. // we can increase/decrease curr_x_j as much as we want.
x_i = null_theory_var; // unbounded x_i = null_theory_var; // unbounded
@ -1584,6 +1597,7 @@ namespace smt {
if (x_j == null_theory_var) { if (x_j == null_theory_var) {
TRACE("opt", tout << "row is " << (max ? "maximized" : "minimized") << "\n";); TRACE("opt", tout << "row is " << (max ? "maximized" : "minimized") << "\n";);
SASSERT(!maintain_integrality || valid_assignment()); SASSERT(!maintain_integrality || valid_assignment());
SASSERT(satisfy_bounds());
result = OPTIMIZED; result = OPTIMIZED;
break; break;
} }
@ -1599,14 +1613,17 @@ namespace smt {
update_value(x_j, max_gain); update_value(x_j, max_gain);
TRACE("opt", tout << "moved v" << x_j << " to upper bound\n";); TRACE("opt", tout << "moved v" << x_j << " to upper bound\n";);
SASSERT(!maintain_integrality || valid_assignment()); SASSERT(!maintain_integrality || valid_assignment());
SASSERT(satisfy_bounds());
continue; continue;
} }
if (!inc && lower(x_j)) { if (!inc && lower(x_j)) {
SASSERT(!unbounded_gain(max_gain)); SASSERT(!unbounded_gain(max_gain));
SASSERT(max_gain.is_pos());
max_gain.neg(); max_gain.neg();
update_value(x_j, max_gain); update_value(x_j, max_gain);
TRACE("opt", tout << "moved v" << x_j << " to lower bound\n";); TRACE("opt", tout << "moved v" << x_j << " to lower bound\n";);
SASSERT(!maintain_integrality || valid_assignment()); SASSERT(!maintain_integrality || valid_assignment());
SASSERT(satisfy_bounds());
continue; continue;
} }
#if 0 #if 0
@ -1642,6 +1659,7 @@ namespace smt {
} }
update_value(x_j, max_gain); update_value(x_j, max_gain);
SASSERT(!maintain_integrality || valid_assignment()); SASSERT(!maintain_integrality || valid_assignment());
SASSERT(satisfy_bounds());
continue; continue;
} }
@ -1670,6 +1688,7 @@ namespace smt {
add_tmp_row(r, coeff, r2); add_tmp_row(r, coeff, r2);
SASSERT(r.get_idx_of(x_j) == -1); SASSERT(r.get_idx_of(x_j) == -1);
SASSERT(!maintain_integrality || valid_assignment()); SASSERT(!maintain_integrality || valid_assignment());
SASSERT(satisfy_bounds());
} }
TRACE("opt", display(tout);); TRACE("opt", display(tout););
return (best_efforts>0)?BEST_EFFORT:result; return (best_efforts>0)?BEST_EFFORT:result;
@ -1749,6 +1768,7 @@ namespace smt {
expr* e = get_enode(v)->get_owner(); expr* e = get_enode(v)->get_owner();
SASSERT(!maintain_integrality || valid_assignment()); SASSERT(!maintain_integrality || valid_assignment());
SASSERT(satisfy_bounds());
SASSERT(!is_quasi_base(v)); SASSERT(!is_quasi_base(v));
if ((max && at_upper(v)) || (!max && at_lower(v))) { if ((max && at_upper(v)) || (!max && at_lower(v))) {
TRACE("opt", tout << "At bound: " << mk_pp(e, get_manager()) << "...\n";); TRACE("opt", tout << "At bound: " << mk_pp(e, get_manager()) << "...\n";);

1
src/smt/theory_arith_core.h
View file

@ -2154,6 +2154,7 @@ namespace smt {
CASSERT("arith", wf_rows()); CASSERT("arith", wf_rows());
CASSERT("arith", wf_columns()); CASSERT("arith", wf_columns());
CASSERT("arith", valid_row_assignment()); CASSERT("arith", valid_row_assignment());
CASSERT("arith", satisfy_bounds());
return true; return true;
} }

1
src/smt/theory_arith_inv.h
View file

@ -196,6 +196,7 @@ namespace smt {
CTRACE("bound_bug", below_lower(v) || above_upper(v), display_var(tout, v); display(tout);); CTRACE("bound_bug", below_lower(v) || above_upper(v), display_var(tout, v); display(tout););
SASSERT(!below_lower(v)); SASSERT(!below_lower(v));
SASSERT(!above_upper(v)); SASSERT(!above_upper(v));
if (below_lower(v) || above_upper(v)) return false;
} }
return true; return true;
} }

3
src/smt/theory_arith_nl.h
View file

@ -2238,6 +2238,9 @@ namespace smt {
m_nl_gb_exhausted = true; m_nl_gb_exhausted = true;
warn = true; warn = true;
} }
if (get_context().get_cancel_flag()) {
return GB_FAIL;
}
TRACE("non_linear_gb", tout << "after:\n"; gb.display(tout);); TRACE("non_linear_gb", tout << "after:\n"; gb.display(tout););
// Scan the grobner basis eqs, and look for inconsistencies. // Scan the grobner basis eqs, and look for inconsistencies.
eqs.reset(); eqs.reset();

2
src/test/ex.cpp
View file

@ -54,7 +54,7 @@ static void tst1() {
static void tst2() { static void tst2() {
try { try {
throw default_exception("Format %d %s", 12, "twelve"); throw default_exception(default_exception::fmt(), "Format %d %s", 12, "twelve");
} }
catch (z3_exception& ex) { catch (z3_exception& ex) {
std::cerr << ex.msg() << "\n"; std::cerr << ex.msg() << "\n";

55
src/util/gparams.cpp
View file

@ -205,12 +205,17 @@ public:
if (mod_name == symbol::null) { if (mod_name == symbol::null) {
char const * new_name = get_new_param_name(param_name); char const * new_name = get_new_param_name(param_name);
if (new_name) { if (new_name) {
throw exception("the parameter '%s' was renamed to '%s', invoke 'z3 -p' to obtain the new parameter list, and 'z3 -pp:%s' for the full description of the parameter", std::stringstream strm;
param_name.bare_str(), new_name, new_name); strm << "the parameter '" << param_name
<< "', invoke 'z3 -p' to obtain the new parameter list, and 'z3 -pp:" << new_name
<< "' for the full description of the parameter";
throw exception(strm.str());
} }
else if (is_old_param_name(param_name)) { else if (is_old_param_name(param_name)) {
throw exception("unknown parameter '%s', this is an old parameter name, invoke 'z3 -p' to obtain the new parameter list", std::stringstream strm;
param_name.bare_str()); strm << "unknown parameter '" << param_name
<< "', this is an old parameter name, invoke 'z3 -p' to obtain the new parameter list";
throw default_exception(strm.str());
} }
else { else {
std::stringstream strm; std::stringstream strm;
@ -290,10 +295,12 @@ public:
ps.set_bool(param_name, false); ps.set_bool(param_name, false);
} }
else { else {
if (mod_name == symbol::null) std::stringstream strm;
throw exception("invalid value '%s' for Boolean parameter '%s'", value, param_name.bare_str()); strm << "invalid value '" << value << "' for Boolean parameter '" << param_name << "'";
else if (mod_name == symbol::null) {
throw exception("invalid value '%s' for Boolean parameter '%s' at module '%s'", value, param_name.bare_str(), mod_name.bare_str()); strm << " at module '" << mod_name << "'";
}
throw default_exception(strm.str());
} }
} }
else if (k == CPK_SYMBOL) { else if (k == CPK_SYMBOL) {
@ -312,10 +319,12 @@ public:
ps.set_str(param_name, symbol(value).bare_str()); ps.set_str(param_name, symbol(value).bare_str());
} }
else { else {
if (mod_name == symbol::null) std::stringstream strm;
throw exception("unsupported parameter type '%s'", param_name.bare_str()); strm << "unsupported parameter type '" << param_name << "'";
else if (mod_name == symbol::null) {
throw exception("unsupported parameter type '%s' at module '%s'", param_name.bare_str(), mod_name.bare_str()); strm << " at module '" << mod_name << "'";
}
throw exception(strm.str());
} }
} }
@ -338,7 +347,9 @@ public:
set(*d, p, value, m); set(*d, p, value, m);
} }
else { else {
throw exception("invalid parameter, unknown module '%s'", m.bare_str()); std::stringstream strm;
strm << "invalid parameter, unknown module '" << m << "'";
throw exception(strm.str());
} }
} }
} }
@ -396,7 +407,9 @@ public:
r = get_default(*d, p, m); r = get_default(*d, p, m);
} }
else { else {
throw exception("unknown module '%s'", m.bare_str()); std::stringstream strm;
strm << "unknown module '" << m << "'";
throw exception(strm.str());
} }
} }
} }
@ -488,8 +501,11 @@ public:
{ {
try { try {
param_descrs * d = 0; param_descrs * d = 0;
if (!get_module_param_descrs().find(module_name, d)) if (!get_module_param_descrs().find(module_name, d)) {
throw exception("unknown module '%s'", module_name.bare_str()); std::stringstream strm;
strm << "unknown module '" << module_name << "'";
throw exception(strm.str());
}
out << "[module] " << module_name; out << "[module] " << module_name;
char const * descr = 0; char const * descr = 0;
if (get_module_descrs().find(module_name, descr)) { if (get_module_descrs().find(module_name, descr)) {
@ -522,8 +538,11 @@ public:
d = &get_param_descrs(); d = &get_param_descrs();
} }
else { else {
if (!get_module_param_descrs().find(m, d)) if (!get_module_param_descrs().find(m, d)) {
throw exception("unknown module '%s'", m.bare_str()); std::stringstream strm;
strm << "unknown module '" << m << "'";
throw exception(strm.str());
}
} }
if (!d->contains(p)) if (!d->contains(p))
throw_unknown_parameter(p, *d, m); throw_unknown_parameter(p, *d, m);

2
src/util/z3_exception.cpp
View file

@ -58,7 +58,7 @@ unsigned z3_error::error_code() const {
return m_error_code; return m_error_code;
} }
default_exception::default_exception(char const* msg, ...) { default_exception::default_exception(fmt, char const* msg, ...) {
std::stringstream out; std::stringstream out;
va_list args; va_list args;
va_start(args, msg); va_start(args, msg);

3
src/util/z3_exception.h
View file

@ -40,8 +40,9 @@ public:
class default_exception : public z3_exception { class default_exception : public z3_exception {
std::string m_msg; std::string m_msg;
public: public:
struct fmt {};
default_exception(std::string const& msg); default_exception(std::string const& msg);
default_exception(char const* msg, ...); default_exception(fmt, char const* msg, ...);
virtual ~default_exception() {} virtual ~default_exception() {}
virtual char const * msg() const; virtual char const * msg() const;
}; };