From f39773f15b5937f634855ae0adb7b6b7e948c876 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 30 Aug 2015 15:23:31 -0400
Subject: [PATCH 001/401] update readme
---
README | 2 ++
1 file changed, 2 insertions(+)
diff --git a/README b/README
index 22fc58c7a..afd4876ca 100644
--- a/README
+++ b/README
@@ -2,6 +2,8 @@ Z3 is a theorem prover from Microsoft Research.
Z3 is licensed under the MIT license.
Z3 can be built using Visual Studio Command Prompt and make/g++.
+This fork of Z3 adds support for solving equations in the theory of strings.
+
1) Building Z3 on Windows using Visual Studio Command Prompt
32-bit builds, start with:
From b30d4f757db057253dc64f61b84f12b7f820a7ef Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 2 Sep 2015 18:08:58 -0400
Subject: [PATCH 002/401] ignore Z3-str source
---
.gitignore | 3 +++
1 file changed, 3 insertions(+)
diff --git a/.gitignore b/.gitignore
index 93194fc1b..037d9abd7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -74,3 +74,6 @@ src/api/ml/z3.mllib
*.bak
doc/api
doc/code
+# reference code for z3str2
+Z3-str/**
+
From 1f96e19211eece215d6deaec3d53018d9c53579f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 2 Sep 2015 18:55:45 -0400
Subject: [PATCH 003/401] failing test case: SMT2 parse string constants
---
src/test/smt2print_parse.cpp | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/src/test/smt2print_parse.cpp b/src/test/smt2print_parse.cpp
index 39543d141..349a3c9c8 100644
--- a/src/test/smt2print_parse.cpp
+++ b/src/test/smt2print_parse.cpp
@@ -98,6 +98,12 @@ void tst_smt2print_parse() {
test_parseprint(spec5);
+ // Test strings
+ char const* spec6 =
+ "(assert (= \"abc\" \"abc\"))";
+
+ test_parseprint(spec6);
+
// Test ?
}
From e48ac4a97af1150ac3ce72c454dd2102f35bb32f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 2 Sep 2015 21:12:03 -0400
Subject: [PATCH 004/401] create and register string theory plugin the parser
gets a little bit further now! rejects input with "unexpected character"
---
.gitignore | 1 +
src/ast/ast.cpp | 5 +++
src/ast/ast.h | 6 +++
src/ast/reg_decl_plugins.cpp | 4 ++
src/ast/str_decl_plugin.cpp | 74 ++++++++++++++++++++++++++++++++
src/ast/str_decl_plugin.h | 75 +++++++++++++++++++++++++++++++++
src/parsers/smt2/smt2parser.cpp | 18 ++++++++
7 files changed, 183 insertions(+)
create mode 100644 src/ast/str_decl_plugin.cpp
create mode 100644 src/ast/str_decl_plugin.h
diff --git a/.gitignore b/.gitignore
index 037d9abd7..97ca67cf4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -75,5 +75,6 @@ src/api/ml/z3.mllib
doc/api
doc/code
# reference code for z3str2
+Z3-str
Z3-str/**
diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp
index 3a6275e33..5a2dc4a52 100644
--- a/src/ast/ast.cpp
+++ b/src/ast/ast.cpp
@@ -17,6 +17,7 @@ Revision History:
--*/
#include<sstream>
+#include<cstring>
#include"ast.h"
#include"ast_pp.h"
#include"ast_ll_pp.h"
@@ -58,6 +59,7 @@ parameter& parameter::operator=(parameter const& other) {
case PARAM_SYMBOL: new (m_symbol) symbol(other.get_symbol()); break;
case PARAM_RATIONAL: new (m_rational) rational(other.get_rational()); break;
case PARAM_DOUBLE: m_dval = other.m_dval; break;
+ case PARAM_STRING: m_string = other.m_string; break;
case PARAM_EXTERNAL: m_ext_id = other.m_ext_id; break;
default:
UNREACHABLE();
@@ -90,6 +92,7 @@ bool parameter::operator==(parameter const & p) const {
case PARAM_SYMBOL: return get_symbol() == p.get_symbol();
case PARAM_RATIONAL: return get_rational() == p.get_rational();
case PARAM_DOUBLE: return m_dval == p.m_dval;
+ case PARAM_STRING: return (m_string == NULL && p.m_string == NULL) || strcmp(m_string, p.m_string)==0;
case PARAM_EXTERNAL: return m_ext_id == p.m_ext_id;
default: UNREACHABLE(); return false;
}
@@ -103,6 +106,7 @@ unsigned parameter::hash() const {
case PARAM_SYMBOL: b = get_symbol().hash(); break;
case PARAM_RATIONAL: b = get_rational().hash(); break;
case PARAM_DOUBLE: b = static_cast<unsigned>(m_dval); break;
+ case PARAM_STRING: /* TODO */ b = 42; break;
case PARAM_EXTERNAL: b = m_ext_id; break;
}
return (b << 2) | m_kind;
@@ -115,6 +119,7 @@ std::ostream& parameter::display(std::ostream& out) const {
case PARAM_RATIONAL: return out << get_rational();
case PARAM_AST: return out << "#" << get_ast()->get_id();
case PARAM_DOUBLE: return out << m_dval;
+ case PARAM_STRING: return out << m_string;
case PARAM_EXTERNAL: return out << "@" << m_ext_id;
default:
UNREACHABLE();
diff --git a/src/ast/ast.h b/src/ast/ast.h
index a5f5c286f..9c1044ec7 100644
--- a/src/ast/ast.h
+++ b/src/ast/ast.h
@@ -86,6 +86,7 @@ public:
PARAM_SYMBOL,
PARAM_RATIONAL,
PARAM_DOUBLE,
+ PARAM_STRING,
// PARAM_EXTERNAL is used for handling decl_plugin specific parameters.
// For example, it is used for handling mpf numbers in float_decl_plugin,
// and irrational algebraic numbers in arith_decl_plugin.
@@ -104,6 +105,7 @@ private:
char m_symbol[sizeof(symbol)]; // for PARAM_SYMBOL
char m_rational[sizeof(rational)]; // for PARAM_RATIONAL
double m_dval; // for PARAM_DOUBLE (remark: this is not used in float_decl_plugin)
+ const char* m_string; // for PARAM_STRING
unsigned m_ext_id; // for PARAM_EXTERNAL
};
@@ -116,6 +118,7 @@ public:
explicit parameter(symbol const & s): m_kind(PARAM_SYMBOL) { new (m_symbol) symbol(s); }
explicit parameter(rational const & r): m_kind(PARAM_RATIONAL) { new (m_rational) rational(r); }
explicit parameter(double d):m_kind(PARAM_DOUBLE), m_dval(d) {}
+ explicit parameter(const char *s):m_kind(PARAM_STRING), m_string(s) {}
explicit parameter(unsigned ext_id, bool):m_kind(PARAM_EXTERNAL), m_ext_id(ext_id) {}
parameter(parameter const&);
@@ -129,6 +132,7 @@ public:
bool is_symbol() const { return m_kind == PARAM_SYMBOL; }
bool is_rational() const { return m_kind == PARAM_RATIONAL; }
bool is_double() const { return m_kind == PARAM_DOUBLE; }
+ bool is_string() const { return m_kind == PARAM_STRING; }
bool is_external() const { return m_kind == PARAM_EXTERNAL; }
bool is_int(int & i) const { return is_int() && (i = get_int(), true); }
@@ -136,6 +140,7 @@ public:
bool is_symbol(symbol & s) const { return is_symbol() && (s = get_symbol(), true); }
bool is_rational(rational & r) const { return is_rational() && (r = get_rational(), true); }
bool is_double(double & d) const { return is_double() && (d = get_double(), true); }
+ // TODO is_string(char*)
bool is_external(unsigned & id) const { return is_external() && (id = get_ext_id(), true); }
/**
@@ -155,6 +160,7 @@ public:
symbol const & get_symbol() const { SASSERT(is_symbol()); return *(reinterpret_cast<const symbol *>(m_symbol)); }
rational const & get_rational() const { SASSERT(is_rational()); return *(reinterpret_cast<const rational *>(m_rational)); }
double get_double() const { SASSERT(is_double()); return m_dval; }
+ const char * get_string() const { SASSERT(is_string()); return m_string; }
unsigned get_ext_id() const { SASSERT(is_external()); return m_ext_id; }
bool operator==(parameter const & p) const;
diff --git a/src/ast/reg_decl_plugins.cpp b/src/ast/reg_decl_plugins.cpp
index f46dd76d4..6a7e7b30c 100644
--- a/src/ast/reg_decl_plugins.cpp
+++ b/src/ast/reg_decl_plugins.cpp
@@ -25,6 +25,7 @@ Revision History:
#include"dl_decl_plugin.h"
#include"seq_decl_plugin.h"
#include"fpa_decl_plugin.h"
+#include"str_decl_plugin.h"
void reg_decl_plugins(ast_manager & m) {
if (!m.get_plugin(m.mk_family_id(symbol("arith")))) {
@@ -48,4 +49,7 @@ void reg_decl_plugins(ast_manager & m) {
if (!m.get_plugin(m.mk_family_id(symbol("fpa")))) {
m.register_plugin(symbol("fpa"), alloc(fpa_decl_plugin));
}
+ if (!m.get_plugin(m.mk_family_id(symbol("str")))) {
+ m.register_plugin(symbol("str"), alloc(str_decl_plugin));
+ }
}
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
new file mode 100644
index 000000000..540cd89c0
--- /dev/null
+++ b/src/ast/str_decl_plugin.cpp
@@ -0,0 +1,74 @@
+/*++
+Module Name:
+
+ str_decl_plugin.h
+
+Abstract:
+
+ <abstract>
+
+Author:
+
+ Murphy Berzish (mtrberzi) 2015-09-02.
+
+Revision History:
+
+--*/
+#include<sstream>
+#include"str_decl_plugin.h"
+#include"string_buffer.h"
+#include"warning.h"
+#include"ast_pp.h"
+#include"ast_smt2_pp.h"
+
+str_decl_plugin::str_decl_plugin():
+ m_strv_sym("String"),
+ m_str_decl(0){
+}
+
+str_decl_plugin::~str_decl_plugin(){
+}
+
+void str_decl_plugin::finalize(void) {
+ #define DEC_REF(decl) if (decl) { m_manager->dec_ref(decl); } ((void) 0)
+ DEC_REF(m_str_decl);
+}
+
+void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
+ decl_plugin::set_manager(m, id);
+ m_str_decl = m->mk_sort(symbol("String"), sort_info(id, STRING_SORT));
+ m->inc_ref(m_str_decl);
+ sort * s = m_str_decl;
+ /* TODO mk_pred, etc. */
+}
+
+decl_plugin * str_decl_plugin::mk_fresh() {
+ return alloc(str_decl_plugin);
+}
+
+sort * str_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) {
+ switch (k) {
+ case STRING_SORT: return m_str_decl;
+ default: return 0;
+ }
+}
+
+func_decl * str_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
+ unsigned arity, sort * const * domain, sort * range) {
+ /* TODO */
+ m_manager->raise_exception("str_decl_plugin::mk_func_decl() not yet implemented"); return 0;
+}
+
+app * str_decl_plugin::mk_string(const char * val) {
+ parameter p[1] = {parameter(val)};
+ func_decl * d;
+ d = m_manager->mk_const_decl(m_strv_sym, m_str_decl, func_decl_info(m_family_id, OP_STR, 1, p));
+ return m_manager->mk_const(d);
+}
+
+str_util::str_util(ast_manager &m) :
+ str_recognizers(m.mk_family_id(symbol("str"))),
+ m_manager(m) {
+ SASSERT(m.has_plugin(symbol("str")));
+ m_plugin = static_cast<str_decl_plugin*>(m.get_plugin(m.mk_family_id(symbol("str"))));
+}
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
new file mode 100644
index 000000000..2fd1db022
--- /dev/null
+++ b/src/ast/str_decl_plugin.h
@@ -0,0 +1,75 @@
+/*++
+Module Name:
+
+ str_decl_plugin.h
+
+Abstract:
+
+ <abstract>
+
+Author:
+
+ Murphy Berzish (mtrberzi) 2015-09-02.
+
+Revision History:
+
+--*/
+#ifndef _STR_DECL_PLUGIN_H_
+#define _STR_DECL_PLUGIN_H_
+
+#include"ast.h"
+
+enum str_sort_kind {
+ STRING_SORT,
+};
+
+enum str_op_kind {
+ OP_STR, /* string constants */
+
+ LAST_STR_OP
+};
+
+class str_decl_plugin : public decl_plugin {
+protected:
+ symbol m_strv_sym;
+ sort * m_str_decl;
+
+ virtual void set_manager(ast_manager * m, family_id id);
+public:
+ str_decl_plugin();
+ virtual ~str_decl_plugin();
+ virtual void finalize();
+
+ virtual decl_plugin * mk_fresh();
+ virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
+ virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
+ unsigned arity, sort * const * domain, sort * range);
+
+ app * mk_string(const char * val);
+ // TODO
+};
+
+class str_recognizers {
+ family_id m_afid;
+public:
+ str_recognizers(family_id fid):m_afid(fid) {}
+ family_id get_fid() const { return m_afid; }
+ family_id get_family_id() const { return get_fid(); }
+ // TODO
+};
+
+class str_util : public str_recognizers {
+ ast_manager & m_manager;
+ str_decl_plugin * m_plugin;
+public:
+ str_util(ast_manager & m);
+ ast_manager & get_manager() const { return m_manager; }
+ str_decl_plugin & plugin() { return *m_plugin; }
+
+ app * mk_string(const char * val) {
+ return m_plugin->mk_string(val);
+ }
+ // TODO
+};
+
+#endif /* _STR_DECL_PLUGIN_H_ */
diff --git a/src/parsers/smt2/smt2parser.cpp b/src/parsers/smt2/smt2parser.cpp
index 785f578f3..af752c82d 100644
--- a/src/parsers/smt2/smt2parser.cpp
+++ b/src/parsers/smt2/smt2parser.cpp
@@ -22,6 +22,7 @@ Revision History:
#include"datatype_decl_plugin.h"
#include"bv_decl_plugin.h"
#include"arith_decl_plugin.h"
+#include"str_decl_plugin.h"
#include"ast_pp.h"
#include"well_sorted.h"
#include"pattern_validation.h"
@@ -64,6 +65,7 @@ namespace smt2 {
scoped_ptr<bv_util> m_bv_util;
scoped_ptr<arith_util> m_arith_util;
+ scoped_ptr<str_util> m_str_util;
scoped_ptr<pattern_validator> m_pattern_validator;
scoped_ptr<var_shifter> m_var_shifter;
@@ -272,6 +274,12 @@ namespace smt2 {
return *(m_bv_util.get());
}
+ str_util & strutil() {
+ if (m_str_util.get() == 0)
+ m_str_util = alloc(str_util, m());
+ return *(m_str_util.get());
+ }
+
pattern_validator & pat_validator() {
if (m_pattern_validator.get() == 0) {
m_pattern_validator = alloc(pattern_validator, m());
@@ -1054,6 +1062,13 @@ namespace smt2 {
next();
}
+ void parse_string() {
+ SASSERT(curr() == scanner::STRING_TOKEN);
+ TRACE("parse_string", tout << "new string constant: " << m_scanner.get_string() << "\n";);
+ expr_stack().push_back(strutil().mk_string(m_scanner.get_string()));
+ next();
+ }
+
void push_pattern_frame() {
// TODO: It seems the only reliable way to parse patterns is:
// Parse as an S-Expr, then try to convert it to an useful pattern.
@@ -1713,6 +1728,9 @@ namespace smt2 {
case scanner::BV_TOKEN:
parse_bv_numeral();
break;
+ case scanner::STRING_TOKEN:
+ parse_string();
+ break;
case scanner::LEFT_PAREN:
push_expr_frame(m_num_expr_frames == 0 ? 0 : static_cast<expr_frame*>(m_stack.top()));
break;
From 02345ee5f190d7033373523743329ec5de016b78 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 3 Sep 2015 00:17:05 -0400
Subject: [PATCH 005/401] fix string constant representation in parser spec1
loopback OK
---
src/ast/ast.h | 4 +++-
src/ast/ast_smt_pp.cpp | 9 +++++++++
src/ast/str_decl_plugin.cpp | 8 ++++++++
src/ast/str_decl_plugin.h | 2 ++
src/parsers/smt2/smt2parser.cpp | 9 +++++++--
src/test/smt2print_parse.cpp | 13 +++++++++----
6 files changed, 38 insertions(+), 7 deletions(-)
diff --git a/src/ast/ast.h b/src/ast/ast.h
index 9c1044ec7..14b869e51 100644
--- a/src/ast/ast.h
+++ b/src/ast/ast.h
@@ -118,7 +118,9 @@ public:
explicit parameter(symbol const & s): m_kind(PARAM_SYMBOL) { new (m_symbol) symbol(s); }
explicit parameter(rational const & r): m_kind(PARAM_RATIONAL) { new (m_rational) rational(r); }
explicit parameter(double d):m_kind(PARAM_DOUBLE), m_dval(d) {}
- explicit parameter(const char *s):m_kind(PARAM_STRING), m_string(s) {}
+ explicit parameter(const char *s):m_kind(PARAM_STRING), m_string(s) {
+ TRACE("parse_string", tout << "parameter(const char *): " << s << "\n";);
+ }
explicit parameter(unsigned ext_id, bool):m_kind(PARAM_EXTERNAL), m_ext_id(ext_id) {}
parameter(parameter const&);
diff --git a/src/ast/ast_smt_pp.cpp b/src/ast/ast_smt_pp.cpp
index 805f3070f..0785c7bfc 100644
--- a/src/ast/ast_smt_pp.cpp
+++ b/src/ast/ast_smt_pp.cpp
@@ -24,6 +24,7 @@ Revision History:
#include"ast_smt_pp.h"
#include"arith_decl_plugin.h"
#include"bv_decl_plugin.h"
+#include"str_decl_plugin.h"
#include"array_decl_plugin.h"
#include"datatype_decl_plugin.h"
#include"vector.h"
@@ -160,8 +161,10 @@ class smt_printer {
unsigned m_num_lets;
arith_util m_autil;
bv_util m_bvutil;
+ str_util m_strutil;
family_id m_basic_fid;
family_id m_bv_fid;
+ family_id m_str_fid;
family_id m_arith_fid;
family_id m_array_fid;
family_id m_dt_fid;
@@ -394,6 +397,7 @@ class smt_printer {
void visit_app(app* n) {
rational val;
+ const char *str;
bool is_int, pos;
buffer<symbol> names;
unsigned bv_size;
@@ -436,6 +440,9 @@ class smt_printer {
m_out << ") bv1[1])";
}
}
+ else if (m_strutil.is_string(n, &str)) {
+ m_out << "\"" << str << "\"";
+ }
else if (m_manager.is_label(n, pos, names) && names.size() >= 1) {
if (m_is_smt2) {
m_out << "(! ";
@@ -797,6 +804,7 @@ public:
m_num_lets(0),
m_autil(m),
m_bvutil(m),
+ m_strutil(m),
m_logic(logic),
m_AUFLIRA("AUFLIRA"),
// It's much easier to read those testcases with that.
@@ -809,6 +817,7 @@ public:
m_bv_fid = m.mk_family_id("bv");
m_arith_fid = m.mk_family_id("arith");
m_array_fid = m.mk_family_id("array");
+ m_str_fid = m.mk_family_id("str");
m_dt_fid = m.mk_family_id("datatype");
}
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 540cd89c0..66b6c23fc 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -66,6 +66,14 @@ app * str_decl_plugin::mk_string(const char * val) {
return m_manager->mk_const(d);
}
+bool str_recognizers::is_string(expr const * n, const char ** val) const {
+ if (!is_app_of(n, m_afid, OP_STR))
+ return false;
+ func_decl * decl = to_app(n)->get_decl();
+ *val = decl->get_parameter(0).get_string();
+ return true;
+}
+
str_util::str_util(ast_manager &m) :
str_recognizers(m.mk_family_id(symbol("str"))),
m_manager(m) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 2fd1db022..2d629e006 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -55,6 +55,8 @@ public:
str_recognizers(family_id fid):m_afid(fid) {}
family_id get_fid() const { return m_afid; }
family_id get_family_id() const { return get_fid(); }
+
+ bool is_string(expr const * n, const char ** val) const;
// TODO
};
diff --git a/src/parsers/smt2/smt2parser.cpp b/src/parsers/smt2/smt2parser.cpp
index af752c82d..5c8d60700 100644
--- a/src/parsers/smt2/smt2parser.cpp
+++ b/src/parsers/smt2/smt2parser.cpp
@@ -1064,8 +1064,13 @@ namespace smt2 {
void parse_string() {
SASSERT(curr() == scanner::STRING_TOKEN);
- TRACE("parse_string", tout << "new string constant: " << m_scanner.get_string() << "\n";);
- expr_stack().push_back(strutil().mk_string(m_scanner.get_string()));
+ char const *original_token = m_scanner.get_string();
+ size_t bufsize = strlen(original_token);
+ char * buf = alloc_svect(char, bufsize + 1);
+ strncpy(buf, original_token, bufsize);
+ buf[bufsize] = '\0';
+ TRACE("parse_string", tout << "new string constant: " << buf << " length=" << bufsize << "\n";);
+ expr_stack().push_back(strutil().mk_string(buf));
next();
}
diff --git a/src/test/smt2print_parse.cpp b/src/test/smt2print_parse.cpp
index 349a3c9c8..1b491a022 100644
--- a/src/test/smt2print_parse.cpp
+++ b/src/test/smt2print_parse.cpp
@@ -7,8 +7,9 @@
void test_print(Z3_context ctx, Z3_ast a) {
Z3_set_ast_print_mode(ctx, Z3_PRINT_SMTLIB2_COMPLIANT);
char const* spec1 = Z3_benchmark_to_smtlib_string(ctx, "test", 0, 0, 0, 0, 0, a);
- std::cout << spec1 << "\n";
+ std::cout << "spec1: benchmark->string\n" << spec1 << "\n";
+ std::cout << "attempting to parse spec1...\n";
Z3_ast b =
Z3_parse_smtlib2_string(ctx,
spec1,
@@ -18,14 +19,14 @@ void test_print(Z3_context ctx, Z3_ast a) {
0,
0,
0);
-
+ std::cout << "parse successful, converting ast->string\n";
char const* spec2 = Z3_ast_to_string(ctx, b);
- std::cout << spec2 << "\n";
+ std::cout << "spec2: string->ast->string\n" << spec2 << "\n";
}
void test_parseprint(char const* spec) {
Z3_context ctx = Z3_mk_context(0);
- std::cout << spec << "\n";
+ std::cout << "spec:\n" << spec << "\n";
Z3_ast a =
Z3_parse_smtlib2_string(ctx,
@@ -37,8 +38,12 @@ void test_parseprint(char const* spec) {
0,
0);
+ std::cout << "done parsing\n";
+
test_print(ctx, a);
+ std::cout << "done printing\n";
+
Z3_del_context(ctx);
}
From 744d2e3c9ca7b2407fb66b27ad9f150fe02dbd29 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 3 Sep 2015 01:12:08 -0400
Subject: [PATCH 006/401] pretty-printing of string constants in AST spec2
looks good now
---
src/ast/ast_smt2_pp.cpp | 15 +++++++++++++++
src/ast/ast_smt2_pp.h | 7 ++++++-
src/ast/str_decl_plugin.cpp | 5 +++++
src/ast/str_decl_plugin.h | 1 +
src/cmd_context/cmd_context.cpp | 5 ++++-
5 files changed, 31 insertions(+), 2 deletions(-)
diff --git a/src/ast/ast_smt2_pp.cpp b/src/ast/ast_smt2_pp.cpp
index 035e228fb..0006d508c 100644
--- a/src/ast/ast_smt2_pp.cpp
+++ b/src/ast/ast_smt2_pp.cpp
@@ -298,6 +298,18 @@ format * smt2_pp_environment::mk_float(rational const & val) const {
return mk_string(get_manager(), s.c_str());
}
+format * smt2_pp_environment::pp_str_literal(app * t) {
+ TRACE("parse_string", tout << "pp_str_literal\n";);
+ str_util & u = get_strutil();
+ SASSERT(u.is_string(t));
+ const char * val;
+ u.is_string(t, &val);
+ ast_manager & m = get_manager();
+ string_buffer<> buf;
+ buf << "\"" << val << "\"";
+ return mk_string(m, buf.c_str());
+}
+
format * smt2_pp_environment::pp_arith_literal(app * t, bool decimal, unsigned decimal_prec) {
arith_util & u = get_autil();
SASSERT(u.is_numeral(t) || u.is_irrational_algebraic_numeral(t));
@@ -581,6 +593,9 @@ class smt2_printer {
else if (m_env.get_dlutil().is_numeral(c)) {
f = m_env.pp_datalog_literal(c);
}
+ else if (m_env.get_strutil().is_string(c)) {
+ f = m_env.pp_str_literal(c);
+ }
else {
buffer<symbol> names;
if (m().is_label_lit(c, names)) {
diff --git a/src/ast/ast_smt2_pp.h b/src/ast/ast_smt2_pp.h
index 8aac71b8c..17bc322bc 100644
--- a/src/ast/ast_smt2_pp.h
+++ b/src/ast/ast_smt2_pp.h
@@ -29,6 +29,7 @@ Revision History:
#include"array_decl_plugin.h"
#include"fpa_decl_plugin.h"
#include"dl_decl_plugin.h"
+#include"str_decl_plugin.h"
#include"smt2_util.h"
class smt2_pp_environment {
@@ -47,12 +48,14 @@ public:
virtual bv_util & get_bvutil() = 0;
virtual array_util & get_arutil() = 0;
virtual fpa_util & get_futil() = 0;
+ virtual str_util & get_strutil() = 0;
virtual datalog::dl_decl_util& get_dlutil() = 0;
virtual bool uses(symbol const & s) const = 0;
virtual format_ns::format * pp_fdecl(func_decl * f, unsigned & len);
virtual format_ns::format * pp_bv_literal(app * t, bool use_bv_lits, bool bv_neg);
virtual format_ns::format * pp_arith_literal(app * t, bool decimal, unsigned prec);
virtual format_ns::format * pp_float_literal(app * t, bool use_bv_lits, bool use_float_real_lits);
+ virtual format_ns::format * pp_str_literal(app * t);
virtual format_ns::format * pp_datalog_literal(app * t);
virtual format_ns::format * pp_sort(sort * s);
virtual format_ns::format * pp_fdecl_ref(func_decl * f);
@@ -70,14 +73,16 @@ class smt2_pp_environment_dbg : public smt2_pp_environment {
bv_util m_bvutil;
array_util m_arutil;
fpa_util m_futil;
+ str_util m_strutil;
datalog::dl_decl_util m_dlutil;
public:
- smt2_pp_environment_dbg(ast_manager & m):m_manager(m), m_autil(m), m_bvutil(m), m_arutil(m), m_futil(m), m_dlutil(m) {}
+ smt2_pp_environment_dbg(ast_manager & m):m_manager(m), m_autil(m), m_bvutil(m), m_arutil(m), m_futil(m), m_strutil(m), m_dlutil(m) {}
virtual ast_manager & get_manager() const { return m_manager; }
virtual arith_util & get_autil() { return m_autil; }
virtual bv_util & get_bvutil() { return m_bvutil; }
virtual array_util & get_arutil() { return m_arutil; }
virtual fpa_util & get_futil() { return m_futil; }
+ virtual str_util & get_strutil() { return m_strutil; }
virtual datalog::dl_decl_util& get_dlutil() { return m_dlutil; }
virtual bool uses(symbol const & s) const { return false; }
};
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 66b6c23fc..3bd81970d 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -74,6 +74,11 @@ bool str_recognizers::is_string(expr const * n, const char ** val) const {
return true;
}
+bool str_recognizers::is_string(expr const * n) const {
+ const char * tmp = 0;
+ return is_string(n, & tmp);
+}
+
str_util::str_util(ast_manager &m) :
str_recognizers(m.mk_family_id(symbol("str"))),
m_manager(m) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 2d629e006..57829d542 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -57,6 +57,7 @@ public:
family_id get_family_id() const { return get_fid(); }
bool is_string(expr const * n, const char ** val) const;
+ bool is_string(expr const * n) const;
// TODO
};
diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp
index 0c60d876b..77cbfe132 100644
--- a/src/cmd_context/cmd_context.cpp
+++ b/src/cmd_context/cmd_context.cpp
@@ -25,6 +25,7 @@ Notes:
#include"datatype_decl_plugin.h"
#include"seq_decl_plugin.h"
#include"fpa_decl_plugin.h"
+#include"str_decl_plugin.h"
#include"ast_pp.h"
#include"var_subst.h"
#include"pp.h"
@@ -241,6 +242,7 @@ protected:
bv_util m_bvutil;
array_util m_arutil;
fpa_util m_futil;
+ str_util m_strutil;
datalog::dl_decl_util m_dlutil;
format_ns::format * pp_fdecl_name(symbol const & s, func_decls const & fs, func_decl * f, unsigned & len) {
@@ -261,13 +263,14 @@ protected:
}
public:
- pp_env(cmd_context & o):m_owner(o), m_autil(o.m()), m_bvutil(o.m()), m_arutil(o.m()), m_futil(o.m()), m_dlutil(o.m()) {}
+ pp_env(cmd_context & o):m_owner(o), m_autil(o.m()), m_bvutil(o.m()), m_arutil(o.m()), m_futil(o.m()), m_strutil(o.m()), m_dlutil(o.m()) {}
virtual ~pp_env() {}
virtual ast_manager & get_manager() const { return m_owner.m(); }
virtual arith_util & get_autil() { return m_autil; }
virtual bv_util & get_bvutil() { return m_bvutil; }
virtual array_util & get_arutil() { return m_arutil; }
virtual fpa_util & get_futil() { return m_futil; }
+ virtual str_util & get_strutil() { return m_strutil; }
virtual datalog::dl_decl_util& get_dlutil() { return m_dlutil; }
virtual bool uses(symbol const & s) const {
return
From 8137e022e3dc27e579521d4bc32fa944462d473c Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 6 Sep 2015 20:53:08 -0400
Subject: [PATCH 007/401] load str decl plugin; recognize String sorted
constants
---
src/ast/str_decl_plugin.cpp | 10 ++++
src/ast/str_decl_plugin.h | 4 ++
src/cmd_context/cmd_context.cpp | 9 ++-
src/cmd_context/cmd_context.h | 1 +
src/smt/smt_setup.cpp | 18 ++++++
src/smt/smt_setup.h | 2 +
src/smt/theory_str.cpp | 97 +++++++++++++++++++++++++++++++++
src/smt/theory_str.h | 50 +++++++++++++++++
8 files changed, 190 insertions(+), 1 deletion(-)
create mode 100644 src/smt/theory_str.cpp
create mode 100644 src/smt/theory_str.h
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 3bd81970d..b6ec25c46 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -66,6 +66,16 @@ app * str_decl_plugin::mk_string(const char * val) {
return m_manager->mk_const(d);
}
+void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol const & logic) {
+ // TODO
+ // we would do something like:
+ // op_names.push_back(builtin_name("<=",OP_LE));
+}
+
+void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
+ sort_names.push_back(builtin_name("String", STRING_SORT));
+}
+
bool str_recognizers::is_string(expr const * n, const char ** val) const {
if (!is_app_of(n, m_afid, OP_STR))
return false;
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 57829d542..854431366 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -46,6 +46,10 @@ public:
unsigned arity, sort * const * domain, sort * range);
app * mk_string(const char * val);
+
+ virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
+
+ virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
// TODO
};
diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp
index 77cbfe132..a7db2f16c 100644
--- a/src/cmd_context/cmd_context.cpp
+++ b/src/cmd_context/cmd_context.cpp
@@ -563,6 +563,10 @@ bool cmd_context::logic_has_fpa() const {
return !has_logic() || m_logic == "QF_FP" || m_logic == "QF_FPBV";
}
+bool cmd_context::logic_has_str() const {
+ return !has_logic() || m_logic == "QF_S";
+}
+
bool cmd_context::logic_has_array_core(symbol const & s) const {
return
s == "QF_AX" ||
@@ -605,6 +609,7 @@ void cmd_context::init_manager_core(bool new_manager) {
register_plugin(symbol("datatype"), alloc(datatype_decl_plugin), logic_has_datatype());
register_plugin(symbol("seq"), alloc(seq_decl_plugin), logic_has_seq());
register_plugin(symbol("fpa"), alloc(fpa_decl_plugin), logic_has_fpa());
+ register_plugin(symbol("str"), alloc(str_decl_plugin), logic_has_str());
}
else {
// the manager was created by an external module
@@ -618,6 +623,7 @@ void cmd_context::init_manager_core(bool new_manager) {
load_plugin(symbol("datatype"), logic_has_datatype(), fids);
load_plugin(symbol("seq"), logic_has_seq(), fids);
load_plugin(symbol("fpa"), logic_has_fpa(), fids);
+ load_plugin(symbol("str"), logic_has_str(), fids);
svector<family_id>::iterator it = fids.begin();
svector<family_id>::iterator end = fids.end();
@@ -671,7 +677,8 @@ bool cmd_context::supported_logic(symbol const & s) const {
logic_has_arith_core(s) || logic_has_bv_core(s) ||
logic_has_array_core(s) || logic_has_seq_core(s) ||
logic_has_horn(s) ||
- s == "QF_FP" || s == "QF_FPBV";
+ s == "QF_FP" || s == "QF_FPBV" ||
+ s == "QF_S";
}
bool cmd_context::set_logic(symbol const & s) {
diff --git a/src/cmd_context/cmd_context.h b/src/cmd_context/cmd_context.h
index f9e50e611..37dccab8a 100644
--- a/src/cmd_context/cmd_context.h
+++ b/src/cmd_context/cmd_context.h
@@ -242,6 +242,7 @@ protected:
bool logic_has_array() const;
bool logic_has_datatype() const;
bool logic_has_fpa() const;
+ bool logic_has_str() const;
bool supported_logic(symbol const & s) const;
void print_unsupported_msg() { regular_stream() << "unsupported" << std::endl; }
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index e6d21a1e2..5e4af91fd 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -31,6 +31,7 @@ Revision History:
#include"theory_dl.h"
#include"theory_seq_empty.h"
#include"theory_fpa.h"
+#include"theory_str.h"
namespace smt {
@@ -117,6 +118,8 @@ namespace smt {
setup_QF_FP();
else if (m_logic == "QF_FPBV")
setup_QF_FPBV();
+ else if (m_logic == "QF_S")
+ setup_QF_S();
else
setup_unknown();
}
@@ -158,6 +161,8 @@ namespace smt {
setup_QF_BVRE();
else if (m_logic == "QF_AUFLIA")
setup_QF_AUFLIA(st);
+ else if (m_logic == "QF_S")
+ setup_QF_S();
else if (m_logic == "AUFLIA")
setup_AUFLIA(st);
else if (m_logic == "AUFLIRA")
@@ -694,6 +699,11 @@ namespace smt {
m_context.register_plugin(alloc(smt::theory_fpa, m_manager));
}
+ void setup::setup_QF_S() {
+ setup_QF_LIA();
+ m_context.register_plugin(alloc(smt::theory_str, m_manager));
+ }
+
bool is_arith(static_features const & st) {
return st.m_num_arith_ineqs > 0 || st.m_num_arith_terms > 0 || st.m_num_arith_eqs > 0;
}
@@ -800,6 +810,11 @@ namespace smt {
m_context.register_plugin(alloc(theory_fpa, m_manager));
}
+ void setup::setup_str() {
+ setup_arith();
+ m_context.register_plugin(alloc(theory_str, m_manager));
+ }
+
void setup::setup_unknown() {
setup_arith();
setup_arrays();
@@ -808,6 +823,7 @@ namespace smt {
setup_dl();
setup_seq();
setup_fpa();
+ setup_str();
}
void setup::setup_unknown(static_features & st) {
@@ -906,6 +922,8 @@ namespace smt {
return;
}
+ // TODO setup_str() by features
+
setup_unknown();
}
diff --git a/src/smt/smt_setup.h b/src/smt/smt_setup.h
index 6cbcb9602..6beb0b239 100644
--- a/src/smt/smt_setup.h
+++ b/src/smt/smt_setup.h
@@ -77,6 +77,7 @@ namespace smt {
void setup_QF_AUFLIA(static_features const & st);
void setup_QF_FP();
void setup_QF_FPBV();
+ void setup_QF_S();
void setup_LRA();
void setup_AUFLIA(bool simple_array = true);
void setup_AUFLIA(static_features const & st);
@@ -98,6 +99,7 @@ namespace smt {
void setup_i_arith();
void setup_mi_arith();
void setup_fpa();
+ void setup_str();
public:
setup(context & c, smt_params & params);
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
new file mode 100644
index 000000000..bc1b59551
--- /dev/null
+++ b/src/smt/theory_str.cpp
@@ -0,0 +1,97 @@
+/*++
+Module Name:
+
+ theory_str.cpp
+
+Abstract:
+
+ String Theory Plugin
+
+Author:
+
+ Murphy Berzish (mtrberzi) 2015-09-03
+
+Revision History:
+
+--*/
+#include"ast_smt2_pp.h"
+#include"smt_context.h"
+#include"theory_str.h"
+#include"smt_model_generator.h"
+
+namespace smt {
+
+theory_str::theory_str(ast_manager &m):
+ theory(m.mk_family_id("str"))
+{
+}
+
+theory_str::~theory_str() {
+}
+
+bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
+ // TODO I have no idea if this is correct.
+ TRACE("t_str", tout << "internalizing atom: " << mk_ismt2_pp(atom, get_manager()) << "\n";);
+ SASSERT(atom->get_family_id() == get_family_id());
+
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ if (ctx.b_internalized(atom))
+ return true;
+
+ unsigned num_args = atom->get_num_args();
+ for (unsigned i = 0; i < num_args; i++)
+ ctx.internalize(atom->get_arg(i), false);
+
+ literal l(ctx.mk_bool_var(atom));
+ ctx.set_var_theory(l.var(), get_id());
+
+ return true;
+}
+
+bool theory_str::internalize_term(app * term) {
+ // TODO I have no idea if this is correct either.
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ TRACE("t_str", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << "\n";);
+ SASSERT(term->get_family_id() == get_family_id());
+ SASSERT(!ctx.e_internalized(term));
+
+ unsigned num_args = term->get_num_args();
+ for (unsigned i = 0; i < num_args; i++)
+ ctx.internalize(term->get_arg(i), false);
+
+ enode * e = (ctx.e_internalized(term)) ? ctx.get_enode(term) :
+ ctx.mk_enode(term, false, false, true);
+
+ if (is_attached_to_var(e))
+ return false;
+
+ attach_new_th_var(e);
+
+ return true;
+}
+
+void theory_str::attach_new_th_var(enode * n) {
+ context & ctx = get_context();
+ theory_var v = mk_var(n);
+ ctx.attach_th_var(n, this, v);
+ TRACE("t_str_detail", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := " << v << "\n";);
+}
+
+void theory_str::new_eq_eh(theory_var x, theory_var y) {
+ // TODO
+ TRACE("t_str", tout << "new eq: " << x << " = " << y << std::endl;);
+ TRACE("t_str_detail", tout << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
+ mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
+}
+
+void theory_str::new_diseq_eh(theory_var x, theory_var y) {
+ // TODO
+ TRACE("t_str", tout << "new diseq: " << x << " != " << y << std::endl;);
+ TRACE("t_str_detail", tout << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
+ mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
+}
+
+}; /* namespace smt */
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
new file mode 100644
index 000000000..7bb5b5148
--- /dev/null
+++ b/src/smt/theory_str.h
@@ -0,0 +1,50 @@
+/*++
+Module Name:
+
+ theory_str.h
+
+Abstract:
+
+ String Theory Plugin
+
+Author:
+
+ Murphy Berzish (mtrberzi) 2015-09-03
+
+Revision History:
+
+--*/
+#ifndef _THEORY_STR_H_
+#define _THEORY_STR_H_
+
+#include"smt_theory.h"
+#include"trail.h"
+#include"th_rewriter.h"
+#include"value_factory.h"
+#include"smt_model_generator.h"
+
+namespace smt {
+
+ class str_value_factory : public value_factory {
+ // TODO
+ };
+
+ class theory_str : public theory {
+ // TODO
+ protected:
+ virtual bool internalize_atom(app * atom, bool gate_ctx);
+ virtual bool internalize_term(app * term);
+
+ virtual void new_eq_eh(theory_var, theory_var);
+ virtual void new_diseq_eh(theory_var, theory_var);
+ virtual theory* mk_fresh(context*) { return alloc(theory_str, get_manager()); }
+ public:
+ theory_str(ast_manager& m);
+ virtual ~theory_str();
+ protected:
+ void attach_new_th_var(enode * n);
+ };
+
+};
+
+#endif /* _THEORY_STR_H_ */
From f0c301e920affab0ae2586a762a74280b488412f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 6 Sep 2015 21:05:32 -0400
Subject: [PATCH 008/401] register Concat function now reaches
str_decl_plugin::mk_func_decl()
---
src/ast/str_decl_plugin.cpp | 19 ++++++++++++++-----
src/ast/str_decl_plugin.h | 5 ++++-
2 files changed, 18 insertions(+), 6 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index b6ec25c46..eb309ecf0 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -23,7 +23,8 @@ Revision History:
str_decl_plugin::str_decl_plugin():
m_strv_sym("String"),
- m_str_decl(0){
+ m_str_decl(0),
+ m_concat_decl(0){
}
str_decl_plugin::~str_decl_plugin(){
@@ -39,7 +40,17 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_str_decl = m->mk_sort(symbol("String"), sort_info(id, STRING_SORT));
m->inc_ref(m_str_decl);
sort * s = m_str_decl;
- /* TODO mk_pred, etc. */
+
+#define MK_AC_OP(FIELD, NAME, KIND, SORT) { \
+ func_decl_info info(id, KIND); \
+ info.set_associative(); \
+ info.set_flat_associative(); \
+ info.set_commutative(); \
+ FIELD = m->mk_func_decl(symbol(NAME), SORT, SORT, SORT, info); \
+ m->inc_ref(FIELD); \
+ }
+
+ MK_AC_OP(m_concat_decl, "Concat", OP_STRCAT, s);
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -67,9 +78,7 @@ app * str_decl_plugin::mk_string(const char * val) {
}
void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol const & logic) {
- // TODO
- // we would do something like:
- // op_names.push_back(builtin_name("<=",OP_LE));
+ op_names.push_back(builtin_name("Concat", OP_STRCAT));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 854431366..16e1ef4a3 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -25,7 +25,8 @@ enum str_sort_kind {
enum str_op_kind {
OP_STR, /* string constants */
-
+ //
+ OP_STRCAT,
LAST_STR_OP
};
@@ -34,6 +35,8 @@ protected:
symbol m_strv_sym;
sort * m_str_decl;
+ func_decl * m_concat_decl;
+
virtual void set_manager(ast_manager * m, family_id id);
public:
str_decl_plugin();
From 7f0d9157ac9ec470f958902401e957e72871f177 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 6 Sep 2015 21:47:57 -0400
Subject: [PATCH 009/401] at least for now, Concat is no longer associative
this means that we'll always have (Concat a b) instead of variadic forms
---
src/ast/str_decl_plugin.cpp | 31 ++++++++++++++++++++-----------
src/ast/str_decl_plugin.h | 2 ++
2 files changed, 22 insertions(+), 11 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index eb309ecf0..70c8a6ebe 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -41,16 +41,11 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m->inc_ref(m_str_decl);
sort * s = m_str_decl;
-#define MK_AC_OP(FIELD, NAME, KIND, SORT) { \
- func_decl_info info(id, KIND); \
- info.set_associative(); \
- info.set_flat_associative(); \
- info.set_commutative(); \
- FIELD = m->mk_func_decl(symbol(NAME), SORT, SORT, SORT, info); \
- m->inc_ref(FIELD); \
- }
+#define MK_OP(FIELD, NAME, KIND, SORT) \
+ FIELD = m->mk_func_decl(symbol(NAME), SORT, SORT, SORT, func_decl_info(id, KIND)); \
+ m->inc_ref(FIELD)
- MK_AC_OP(m_concat_decl, "Concat", OP_STRCAT, s);
+ MK_OP(m_concat_decl, "Concat", OP_STRCAT, s);
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -64,10 +59,24 @@ sort * str_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter
}
}
+func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
+ switch(k) {
+ case OP_STRCAT: return m_concat_decl;
+ default: return 0;
+ }
+}
+
func_decl * str_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) {
- /* TODO */
- m_manager->raise_exception("str_decl_plugin::mk_func_decl() not yet implemented"); return 0;
+ if (k == OP_STR) {
+ m_manager->raise_exception("OP_STR not yet implemented in mk_func_decl!");
+ return 0;
+ }
+ if (arity == 0) {
+ m_manager->raise_exception("no arguments supplied to string operator");
+ return 0;
+ }
+ return mk_func_decl(k);
}
app * str_decl_plugin::mk_string(const char * val) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 16e1ef4a3..d190e9ff7 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -38,6 +38,8 @@ protected:
func_decl * m_concat_decl;
virtual void set_manager(ast_manager * m, family_id id);
+
+ func_decl * mk_func_decl(decl_kind k);
public:
str_decl_plugin();
virtual ~str_decl_plugin();
From dc86385e7fb635484b596fc9fdd7ab17274e0e55 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 7 Sep 2015 16:13:48 -0400
Subject: [PATCH 010/401] add Length function to theory of strings
---
src/ast/str_decl_plugin.cpp | 13 +++++++++++++
src/ast/str_decl_plugin.h | 6 ++++++
src/smt/theory_str.cpp | 37 +++++++++++++++++++++++++++++++++++--
src/smt/theory_str.h | 8 ++++++++
4 files changed, 62 insertions(+), 2 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 70c8a6ebe..fa0a26f25 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -33,6 +33,9 @@ str_decl_plugin::~str_decl_plugin(){
void str_decl_plugin::finalize(void) {
#define DEC_REF(decl) if (decl) { m_manager->dec_ref(decl); } ((void) 0)
DEC_REF(m_str_decl);
+ DEC_REF(m_concat_decl);
+ DEC_REF(m_length_decl);
+ DEC_REF(m_int_sort);
}
void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
@@ -41,11 +44,19 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m->inc_ref(m_str_decl);
sort * s = m_str_decl;
+ m_arith_fid = m_manager->mk_family_id("arith");
+ m_int_sort = m_manager->mk_sort(m_arith_fid, INT_SORT);
+ SASSERT(m_int_sort != 0); // arith_decl_plugin must be installed before str_decl_plugin.
+ m_manager->inc_ref(m_int_sort);
+ sort * i = m_int_sort;
+
#define MK_OP(FIELD, NAME, KIND, SORT) \
FIELD = m->mk_func_decl(symbol(NAME), SORT, SORT, SORT, func_decl_info(id, KIND)); \
m->inc_ref(FIELD)
MK_OP(m_concat_decl, "Concat", OP_STRCAT, s);
+
+ m_length_decl = m->mk_func_decl(symbol("Length"), s, i); m_manager->inc_ref(m_length_decl);
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -62,6 +73,7 @@ sort * str_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter
func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
switch(k) {
case OP_STRCAT: return m_concat_decl;
+ case OP_STRLEN: return m_length_decl;
default: return 0;
}
}
@@ -88,6 +100,7 @@ app * str_decl_plugin::mk_string(const char * val) {
void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol const & logic) {
op_names.push_back(builtin_name("Concat", OP_STRCAT));
+ op_names.push_back(builtin_name("Length", OP_STRLEN));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index d190e9ff7..3fd5fb7e6 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -18,6 +18,7 @@ Revision History:
#define _STR_DECL_PLUGIN_H_
#include"ast.h"
+#include"arith_decl_plugin.h"
enum str_sort_kind {
STRING_SORT,
@@ -27,6 +28,7 @@ enum str_op_kind {
OP_STR, /* string constants */
//
OP_STRCAT,
+ OP_STRLEN,
LAST_STR_OP
};
@@ -35,7 +37,11 @@ protected:
symbol m_strv_sym;
sort * m_str_decl;
+ sort * m_int_sort;
+ family_id m_arith_fid;
+
func_decl * m_concat_decl;
+ func_decl * m_length_decl;
virtual void set_manager(ast_manager * m, family_id id);
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index bc1b59551..2bf67ed81 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -31,7 +31,7 @@ theory_str::~theory_str() {
bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
// TODO I have no idea if this is correct.
- TRACE("t_str", tout << "internalizing atom: " << mk_ismt2_pp(atom, get_manager()) << "\n";);
+ TRACE("t_str", tout << "internalizing atom: " << mk_ismt2_pp(atom, get_manager()) << std::endl;);
SASSERT(atom->get_family_id() == get_family_id());
ast_manager & m = get_manager();
@@ -54,7 +54,7 @@ bool theory_str::internalize_term(app * term) {
// TODO I have no idea if this is correct either.
ast_manager & m = get_manager();
context & ctx = get_context();
- TRACE("t_str", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << "\n";);
+ TRACE("t_str", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
SASSERT(term->get_family_id() == get_family_id());
SASSERT(!ctx.e_internalized(term));
@@ -80,6 +80,20 @@ void theory_str::attach_new_th_var(enode * n) {
TRACE("t_str_detail", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := " << v << "\n";);
}
+void theory_str::init_search_eh() {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ TRACE("t_str",
+ tout << "search started, assignments are:" << std::endl;
+ expr_ref_vector assignment(m);
+ ctx.get_assignments(assignment);
+ for (expr_ref_vector::iterator i = assignment.begin(); i != assignment.end(); ++i) {
+ expr * ex = *i;
+ tout << mk_ismt2_pp(ex, m) << std::endl;
+ }
+ );
+}
+
void theory_str::new_eq_eh(theory_var x, theory_var y) {
// TODO
TRACE("t_str", tout << "new eq: " << x << " = " << y << std::endl;);
@@ -94,4 +108,23 @@ void theory_str::new_diseq_eh(theory_var x, theory_var y) {
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
}
+void theory_str::relevant_eh(app * n) {
+ TRACE("t_str", tout << "relevant: " << mk_ismt2_pp(n, get_manager()) << "\n";);
+}
+
+void theory_str::assign_eh(bool_var v, bool is_true) {
+ context & ctx = get_context();
+ TRACE("t_str", tout << "assert: v" << v << " #" << ctx.bool_var2expr(v)->get_id() << " is_true: " << is_true << "\n";);
+}
+
+void theory_str::push_scope_eh() {
+ TRACE("t_str", tout << "push" << std::endl;);
+}
+
+final_check_status theory_str::final_check_eh() {
+ // TODO
+ TRACE("t_str", tout << "final check" << std::endl;);
+ return FC_DONE;
+}
+
}; /* namespace smt */
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 7bb5b5148..5ee5502de 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -38,6 +38,14 @@ namespace smt {
virtual void new_eq_eh(theory_var, theory_var);
virtual void new_diseq_eh(theory_var, theory_var);
virtual theory* mk_fresh(context*) { return alloc(theory_str, get_manager()); }
+
+ virtual void init_search_eh();
+
+ virtual void relevant_eh(app * n);
+ virtual void assign_eh(bool_var v, bool is_true);
+ virtual void push_scope_eh();
+
+ virtual final_check_status final_check_eh();
public:
theory_str(ast_manager& m);
virtual ~theory_str();
From 9b04f1570f45b55d409f981bd389c46dc14825e0 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 7 Sep 2015 19:40:25 -0400
Subject: [PATCH 011/401] instantiate length axiom for concatenation
---
src/ast/str_decl_plugin.cpp | 3 +-
src/smt/theory_str.cpp | 80 ++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 15 ++++++-
3 files changed, 94 insertions(+), 4 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index fa0a26f25..0e74493ff 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -24,7 +24,8 @@ Revision History:
str_decl_plugin::str_decl_plugin():
m_strv_sym("String"),
m_str_decl(0),
- m_concat_decl(0){
+ m_concat_decl(0),
+ m_length_decl(0){
}
str_decl_plugin::~str_decl_plugin(){
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 2bf67ed81..c6d51b1a4 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -18,17 +18,39 @@ Revision History:
#include"smt_context.h"
#include"theory_str.h"
#include"smt_model_generator.h"
+#include"ast_pp.h"
+#include"ast_ll_pp.h"
namespace smt {
-theory_str::theory_str(ast_manager &m):
- theory(m.mk_family_id("str"))
+theory_str::theory_str(ast_manager & m):
+ theory(m.mk_family_id("str")),
+ search_started(false),
+ m_autil(m)
{
}
theory_str::~theory_str() {
}
+void theory_str::assert_axiom(unsigned num_lits, literal * lits) {
+ context & ctx = get_context();
+ TRACE("t_str_detail",
+ tout << "assert_axiom: literals:\n";
+ for (unsigned i = 0; i < num_lits; ++i) {
+ expr * e = ctx.bool_var2expr(lits[i].var());
+ if (lits[i].sign())
+ tout << "not ";
+ tout << mk_pp(e, get_manager()) << " ";
+ tout << "\n";
+ });
+ ctx.mk_th_axiom(get_id(), num_lits, lits);
+}
+
+void theory_str::assert_axiom(literal l) {
+ assert_axiom(1, &l);
+}
+
bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
// TODO I have no idea if this is correct.
TRACE("t_str", tout << "internalizing atom: " << mk_ismt2_pp(atom, get_manager()) << std::endl;);
@@ -70,9 +92,62 @@ bool theory_str::internalize_term(app * term) {
attach_new_th_var(e);
+ if (is_concat(term)) {
+ instantiate_concat_axiom(e);
+ }
+
return true;
}
+app * theory_str::mk_strlen(app * e) {
+ expr * args[1] = {e};
+ return get_manager().mk_app(get_id(), OP_STRLEN, 0, 0, 1, args);
+}
+
+/*
+ * Instantiate an axiom of the following form:
+ * Length(Concat(x, y)) = Length(x) + Length(y)
+ */
+void theory_str::instantiate_concat_axiom(enode * cat) {
+ SASSERT(is_concat(cat));
+ app * a_cat = cat->get_owner();
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ // build LHS
+ expr_ref len_xy(m);
+ // TODO re-use ASTs for length subexpressions, like in old Z3-str?
+ // TODO should we use str_util for these and other expressions?
+ len_xy = mk_strlen(a_cat);
+ SASSERT(len_xy);
+
+ // build RHS: start by extracting x and y from Concat(x, y)
+ unsigned nArgs = a_cat->get_num_args();
+ SASSERT(nArgs == 2);
+ app * a_x = to_app(a_cat->get_arg(0));
+ app * a_y = to_app(a_cat->get_arg(1));
+
+ expr_ref len_x(m);
+ len_x = mk_strlen(a_x);
+ SASSERT(len_x);
+
+ expr_ref len_y(m);
+ len_y = mk_strlen(a_y);
+ SASSERT(len_y);
+
+ // now build len_x + len_y
+ app * len_x_plus_len_y = m_autil.mk_add(len_x, len_y);
+ SASSERT(len_x_plus_len_y);
+
+ TRACE("t_str", tout << mk_bounded_pp(len_xy, m) << " = " << mk_bounded_pp(len_x_plus_len_y, m) << "\n";);
+
+ // finally assert equality between the two subexpressions
+ literal l(mk_eq(len_xy, len_x_plus_len_y, true));
+ ctx.mark_as_relevant(l);
+ assert_axiom(l);
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
@@ -92,6 +167,7 @@ void theory_str::init_search_eh() {
tout << mk_ismt2_pp(ex, m) << std::endl;
}
);
+ search_started = true;
}
void theory_str::new_eq_eh(theory_var x, theory_var y) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 5ee5502de..867c4316b 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -22,6 +22,7 @@ Revision History:
#include"th_rewriter.h"
#include"value_factory.h"
#include"smt_model_generator.h"
+#include"arith_decl_plugin.h"
namespace smt {
@@ -31,6 +32,8 @@ namespace smt {
class theory_str : public theory {
// TODO
+ protected:
+ bool search_started;
protected:
virtual bool internalize_atom(app * atom, bool gate_ctx);
virtual bool internalize_term(app * term);
@@ -46,9 +49,19 @@ namespace smt {
virtual void push_scope_eh();
virtual final_check_status final_check_eh();
+
+ void assert_axiom(unsigned num_lits, literal * lits);
+ void assert_axiom(literal l);
+
+ app * mk_strlen(app * e);
+
+ bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
+ bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
+ void instantiate_concat_axiom(enode * cat);
public:
- theory_str(ast_manager& m);
+ theory_str(ast_manager & m);
virtual ~theory_str();
+ arith_util m_autil;
protected:
void attach_new_th_var(enode * n);
};
From 799fd07c85f8ec89552454334fe8a3e4c3f0273e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 7 Sep 2015 19:51:52 -0400
Subject: [PATCH 012/401] optimization: return integer consts for strlen() over
constant strings
---
src/smt/theory_str.cpp | 14 +++++++++++---
src/smt/theory_str.h | 3 ++-
2 files changed, 13 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index c6d51b1a4..568e6b5ae 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -26,7 +26,8 @@ namespace smt {
theory_str::theory_str(ast_manager & m):
theory(m.mk_family_id("str")),
search_started(false),
- m_autil(m)
+ m_autil(m),
+ m_strutil(m)
{
}
@@ -100,8 +101,15 @@ bool theory_str::internalize_term(app * term) {
}
app * theory_str::mk_strlen(app * e) {
- expr * args[1] = {e};
- return get_manager().mk_app(get_id(), OP_STRLEN, 0, 0, 1, args);
+ if (m_strutil.is_string(e)) {
+ const char * strval = 0;
+ m_strutil.is_string(e, &strval);
+ int len = strlen(strval);
+ return m_autil.mk_numeral(rational(len), true);
+ } else {
+ expr * args[1] = {e};
+ return get_manager().mk_app(get_id(), OP_STRLEN, 0, 0, 1, args);
+ }
}
/*
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 867c4316b..a583a106e 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -34,6 +34,8 @@ namespace smt {
// TODO
protected:
bool search_started;
+ arith_util m_autil;
+ str_util m_strutil;
protected:
virtual bool internalize_atom(app * atom, bool gate_ctx);
virtual bool internalize_term(app * term);
@@ -61,7 +63,6 @@ namespace smt {
public:
theory_str(ast_manager & m);
virtual ~theory_str();
- arith_util m_autil;
protected:
void attach_new_th_var(enode * n);
};
From 992fff8ba8c882b0724aafca2620bd8dd151365a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 10 Sep 2015 18:43:14 -0400
Subject: [PATCH 013/401] set up theory of arithmetic correctly closes #1
---
src/cmd_context/cmd_context.cpp | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp
index a7db2f16c..394350879 100644
--- a/src/cmd_context/cmd_context.cpp
+++ b/src/cmd_context/cmd_context.cpp
@@ -517,7 +517,8 @@ bool cmd_context::logic_has_arith_core(symbol const & s) const {
s == "LRA" ||
s == "QF_FP" ||
s == "QF_FPBV" ||
- s == "HORN";
+ s == "HORN" ||
+ s == "QF_S";
}
bool cmd_context::logic_has_arith() const {
From 4d5a0ea53f42258e375be664aea15bbcbbc66a12 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 26 Sep 2015 18:51:02 -0400
Subject: [PATCH 014/401] WIP add axioms
---
src/ast/str_decl_plugin.cpp | 9 ++-
src/ast/str_decl_plugin.h | 1 +
src/smt/theory_str.cpp | 125 ++++++++++++++++++++++++++++--------
src/smt/theory_str.h | 25 ++++----
4 files changed, 120 insertions(+), 40 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 0e74493ff..1502e3d3a 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -25,7 +25,10 @@ str_decl_plugin::str_decl_plugin():
m_strv_sym("String"),
m_str_decl(0),
m_concat_decl(0),
- m_length_decl(0){
+ m_length_decl(0),
+ m_arith_plugin(0),
+ m_arith_fid(0),
+ m_int_sort(0){
}
str_decl_plugin::~str_decl_plugin(){
@@ -45,7 +48,11 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m->inc_ref(m_str_decl);
sort * s = m_str_decl;
+ SASSERT(m_manager->has_plugin(symbol("arith")));
m_arith_fid = m_manager->mk_family_id("arith");
+ m_arith_plugin = static_cast<arith_decl_plugin*>(m_manager->get_plugin(m_arith_fid));
+ SASSERT(m_arith_plugin);
+
m_int_sort = m_manager->mk_sort(m_arith_fid, INT_SORT);
SASSERT(m_int_sort != 0); // arith_decl_plugin must be installed before str_decl_plugin.
m_manager->inc_ref(m_int_sort);
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 3fd5fb7e6..7e75fbaf0 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -37,6 +37,7 @@ protected:
symbol m_strv_sym;
sort * m_str_decl;
+ arith_decl_plugin * m_arith_plugin;
sort * m_int_sort;
family_id m_arith_fid;
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 568e6b5ae..ff4b3dd76 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -34,22 +34,25 @@ theory_str::theory_str(ast_manager & m):
theory_str::~theory_str() {
}
-void theory_str::assert_axiom(unsigned num_lits, literal * lits) {
+void theory_str::assert_axiom(ast * a) {
+ /*
+ if (search_started) {
+ // effectively Z3_theory_assert_axiom
+ NOT_IMPLEMENTED_YET();
+ } else {
+ // effectively Z3_assert_cnstr
+ context & ctx = get_context();
+ ctx.assert_expr(to_expr(a));
+ }
+ */
+ TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(a, get_manager()) << "\n";);
+ expr * e = to_expr(a);
context & ctx = get_context();
- TRACE("t_str_detail",
- tout << "assert_axiom: literals:\n";
- for (unsigned i = 0; i < num_lits; ++i) {
- expr * e = ctx.bool_var2expr(lits[i].var());
- if (lits[i].sign())
- tout << "not ";
- tout << mk_pp(e, get_manager()) << " ";
- tout << "\n";
- });
- ctx.mk_th_axiom(get_id(), num_lits, lits);
-}
-
-void theory_str::assert_axiom(literal l) {
- assert_axiom(1, &l);
+ ctx.internalize(e, false);
+ literal lit(ctx.get_literal(e));
+ ctx.mark_as_relevant(lit);
+ ctx.mk_th_axiom(get_id(), 1, &lit);
+ TRACE("t_str_detail", tout << "done asserting " << mk_ismt2_pp(a, get_manager()) << "\n";);
}
bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
@@ -93,15 +96,17 @@ bool theory_str::internalize_term(app * term) {
attach_new_th_var(e);
+ /*
if (is_concat(term)) {
instantiate_concat_axiom(e);
}
+ */
return true;
}
app * theory_str::mk_strlen(app * e) {
- if (m_strutil.is_string(e)) {
+ /*if (m_strutil.is_string(e)) {*/ if (false) {
const char * strval = 0;
m_strutil.is_string(e, &strval);
int len = strlen(strval);
@@ -145,22 +150,90 @@ void theory_str::instantiate_concat_axiom(enode * cat) {
SASSERT(len_y);
// now build len_x + len_y
- app * len_x_plus_len_y = m_autil.mk_add(len_x, len_y);
+ expr_ref len_x_plus_len_y(m);
+ len_x_plus_len_y = m_autil.mk_add(len_x, len_y);
SASSERT(len_x_plus_len_y);
- TRACE("t_str", tout << mk_bounded_pp(len_xy, m) << " = " << mk_bounded_pp(len_x_plus_len_y, m) << "\n";);
-
// finally assert equality between the two subexpressions
- literal l(mk_eq(len_xy, len_x_plus_len_y, true));
- ctx.mark_as_relevant(l);
- assert_axiom(l);
+ app * eq = m.mk_eq(len_xy, len_x_plus_len_y);
+ SASSERT(eq);
+ TRACE("t_str", tout << mk_bounded_pp(eq, m) << std::endl;);
+ assert_axiom(eq);
+}
+
+/*
+ * Add axioms that are true for any string variable:
+ * 1. Length(x) >= 0
+ * 2. Length(x) == 0 <=> x == ""
+ */
+void theory_str::instantiate_basic_string_axioms(enode * str) {
+ // generate a stronger axiom for constant strings
+ if (m_strutil.is_string(str->get_owner())) {
+ // TODO
+ } else {
+ // TODO keep track of which enodes we have added axioms for, so we don't add the same ones twice?
+ app * a_str = str->get_owner();
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ // TODO find out why these are crashing the SMT solver
+
+ // build axiom 1: Length(a_str) >= 0
+ {
+ // build LHS
+ expr_ref len_str(m);
+ len_str = mk_strlen(a_str);
+ SASSERT(len_str);
+ // build RHS
+ expr_ref zero(m);
+ zero = m_autil.mk_numeral(rational(0), true);
+ SASSERT(zero);
+ // build LHS >= RHS and assert
+ app * lhs_ge_rhs = m_autil.mk_ge(len_str, zero);
+ SASSERT(lhs_ge_rhs);
+ // TODO verify that this works
+ TRACE("t_str_detail", tout << "string axiom 1: " << mk_bounded_pp(lhs_ge_rhs, m) << std::endl;);
+ assert_axiom(lhs_ge_rhs);
+ }
+
+ /*
+ // build axiom 2: Length(a_str) == 0 <=> a_str == ""
+ {
+ // build LHS of iff
+ expr_ref len_str(m);
+ len_str = mk_strlen(a_str);
+ SASSERT(len_str);
+ expr_ref zero(m);
+ zero = m_autil.mk_numeral(rational(0), true);
+ SASSERT(zero);
+ expr_ref lhs(m);
+ lhs = ctx.mk_eq_atom(len_str, zero);
+ SASSERT(lhs);
+ // build RHS of iff
+ expr_ref empty_str(m);
+ empty_str = m_strutil.mk_string("");
+ SASSERT(empty_str);
+ expr_ref rhs(m);
+ rhs = ctx.mk_eq_atom(a_str, empty_str);
+ SASSERT(rhs);
+ // build LHS <=> RHS and assert
+ TRACE("t_str_detail", tout << "string axiom 2: " << mk_bounded_pp(lhs, m) << " <=> " << mk_bounded_pp(rhs, m) << std::endl;);
+ // TODO this is kind of a hack, maybe just ctx.assert_expr() will be enough?
+ literal l(mk_eq(lhs, rhs, true));
+ ctx.mark_as_relevant(l);
+ assert_axiom(l);
+ }
+ */
+ }
}
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
ctx.attach_th_var(n, this, v);
- TRACE("t_str_detail", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := " << v << "\n";);
+ TRACE("t_str_detail", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := v#" << v << std::endl;);
+ // probably okay...note however that this seems to miss constants and functions
+ //instantiate_basic_string_axioms(n);
}
void theory_str::init_search_eh() {
@@ -180,14 +253,14 @@ void theory_str::init_search_eh() {
void theory_str::new_eq_eh(theory_var x, theory_var y) {
// TODO
- TRACE("t_str", tout << "new eq: " << x << " = " << y << std::endl;);
+ TRACE("t_str", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
TRACE("t_str_detail", tout << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
}
void theory_str::new_diseq_eh(theory_var x, theory_var y) {
// TODO
- TRACE("t_str", tout << "new diseq: " << x << " != " << y << std::endl;);
+ TRACE("t_str", tout << "new diseq: v#" << x << " != v#" << y << std::endl;);
TRACE("t_str_detail", tout << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
}
@@ -198,7 +271,7 @@ void theory_str::relevant_eh(app * n) {
void theory_str::assign_eh(bool_var v, bool is_true) {
context & ctx = get_context();
- TRACE("t_str", tout << "assert: v" << v << " #" << ctx.bool_var2expr(v)->get_id() << " is_true: " << is_true << "\n";);
+ TRACE("t_str", tout << "assert: v" << v << " #" << ctx.bool_var2expr(v)->get_id() << " is_true: " << is_true << std::endl;);
}
void theory_str::push_scope_eh() {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index a583a106e..0e7b0bcc8 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -36,6 +36,18 @@ namespace smt {
bool search_started;
arith_util m_autil;
str_util m_strutil;
+ protected:
+ void assert_axiom(ast * e);
+
+ app * mk_strlen(app * e);
+
+ bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
+ bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
+ void instantiate_concat_axiom(enode * cat);
+ void instantiate_basic_string_axioms(enode * str);
+ public:
+ theory_str(ast_manager & m);
+ virtual ~theory_str();
protected:
virtual bool internalize_atom(app * atom, bool gate_ctx);
virtual bool internalize_term(app * term);
@@ -51,19 +63,6 @@ namespace smt {
virtual void push_scope_eh();
virtual final_check_status final_check_eh();
-
- void assert_axiom(unsigned num_lits, literal * lits);
- void assert_axiom(literal l);
-
- app * mk_strlen(app * e);
-
- bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
- bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
- void instantiate_concat_axiom(enode * cat);
- public:
- theory_str(ast_manager & m);
- virtual ~theory_str();
- protected:
void attach_new_th_var(enode * n);
};
From f6affe64d0cb72f1e434e05d69d4d7845600fb0a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 26 Sep 2015 21:02:56 -0400
Subject: [PATCH 015/401] deferred addition of basic string axioms no longer
crashes the solver and got our first correct UNSAT!
---
src/smt/theory_str.cpp | 53 +++++++++++++++++++++++++++++++++++-------
src/smt/theory_str.h | 7 ++++++
2 files changed, 51 insertions(+), 9 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ff4b3dd76..b99087f29 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -117,6 +117,20 @@ app * theory_str::mk_strlen(app * e) {
}
}
+bool theory_str::can_propagate() {
+ return !m_basicstr_axiom_todo.empty();
+}
+
+void theory_str::propagate() {
+ TRACE("t_str_detail", tout << "trying to propagate..." << std::endl;);
+ while (can_propagate()) {
+ for (unsigned i = 0; i < m_basicstr_axiom_todo.size(); ++i) {
+ instantiate_basic_string_axioms(m_basicstr_axiom_todo[i]);
+ }
+ m_basicstr_axiom_todo.reset();
+ }
+}
+
/*
* Instantiate an axiom of the following form:
* Length(Concat(x, y)) = Length(x) + Length(y)
@@ -165,17 +179,32 @@ void theory_str::instantiate_concat_axiom(enode * cat) {
* Add axioms that are true for any string variable:
* 1. Length(x) >= 0
* 2. Length(x) == 0 <=> x == ""
+ * If the term is a string constant, we can assert something stronger:
+ * Length(x) == strlen(x)
*/
void theory_str::instantiate_basic_string_axioms(enode * str) {
- // generate a stronger axiom for constant strings
- if (m_strutil.is_string(str->get_owner())) {
- // TODO
- } else {
- // TODO keep track of which enodes we have added axioms for, so we don't add the same ones twice?
- app * a_str = str->get_owner();
- context & ctx = get_context();
- ast_manager & m = get_manager();
+ // TODO keep track of which enodes we have added axioms for, so we don't add the same ones twice?
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ // generate a stronger axiom for constant strings
+ app * a_str = str->get_owner();
+ if (m_strutil.is_string(str->get_owner())) {
+ expr_ref len_str(m);
+ len_str = mk_strlen(a_str);
+ SASSERT(len_str);
+
+ const char * strconst = 0;
+ m_strutil.is_string(str->get_owner(), & strconst);
+ TRACE("t_str_detail", tout << "instantiating constant string axioms for \"" << strconst << "\"" << std::endl;);
+ int l = strlen(strconst);
+ expr_ref len(m_autil.mk_numeral(rational(l), true), m);
+
+ literal lit(mk_eq(len_str, len, false));
+ ctx.mark_as_relevant(lit);
+ ctx.mk_th_axiom(get_id(), 1, &lit);
+ } else {
// TODO find out why these are crashing the SMT solver
// build axiom 1: Length(a_str) >= 0
@@ -233,7 +262,13 @@ void theory_str::attach_new_th_var(enode * n) {
ctx.attach_th_var(n, this, v);
TRACE("t_str_detail", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := v#" << v << std::endl;);
// probably okay...note however that this seems to miss constants and functions
- //instantiate_basic_string_axioms(n);
+ m_basicstr_axiom_todo.push_back(n);
+}
+
+void theory_str::reset_eh() {
+ TRACE("t_str", tout << "resetting" << std::endl;);
+ m_basicstr_axiom_todo.reset();
+ pop_scope_eh(0);
}
void theory_str::init_search_eh() {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 0e7b0bcc8..a336ec649 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -36,6 +36,8 @@ namespace smt {
bool search_started;
arith_util m_autil;
str_util m_strutil;
+
+ ptr_vector<enode> m_basicstr_axiom_todo;
protected:
void assert_axiom(ast * e);
@@ -62,6 +64,11 @@ namespace smt {
virtual void assign_eh(bool_var v, bool is_true);
virtual void push_scope_eh();
+ virtual void reset_eh();
+
+ virtual bool can_propagate();
+ virtual void propagate();
+
virtual final_check_status final_check_eh();
void attach_new_th_var(enode * n);
};
From 4085db99906b01321921132d458c736ef1ea4239 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 26 Sep 2015 23:35:23 -0400
Subject: [PATCH 016/401] recursive descent through all assertions to discover
all String terms set up axioms on these terms to be asserted during
propagation
---
src/smt/theory_str.cpp | 56 +++++++++++++++++++++++++++++++++---------
src/smt/theory_str.h | 2 ++
2 files changed, 47 insertions(+), 11 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b99087f29..63378a700 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -122,13 +122,14 @@ bool theory_str::can_propagate() {
}
void theory_str::propagate() {
- TRACE("t_str_detail", tout << "trying to propagate..." << std::endl;);
while (can_propagate()) {
+ TRACE("t_str_detail", tout << "propagating..." << std::endl;);
for (unsigned i = 0; i < m_basicstr_axiom_todo.size(); ++i) {
instantiate_basic_string_axioms(m_basicstr_axiom_todo[i]);
}
m_basicstr_axiom_todo.reset();
}
+ TRACE("t_str_detail", tout << "done propagating" << std::endl;);
}
/*
@@ -205,8 +206,6 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
ctx.mark_as_relevant(lit);
ctx.mk_th_axiom(get_id(), 1, &lit);
} else {
- // TODO find out why these are crashing the SMT solver
-
// build axiom 1: Length(a_str) >= 0
{
// build LHS
@@ -261,8 +260,6 @@ void theory_str::attach_new_th_var(enode * n) {
theory_var v = mk_var(n);
ctx.attach_th_var(n, this, v);
TRACE("t_str_detail", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := v#" << v << std::endl;);
- // probably okay...note however that this seems to miss constants and functions
- m_basicstr_axiom_todo.push_back(n);
}
void theory_str::reset_eh() {
@@ -271,18 +268,55 @@ void theory_str::reset_eh() {
pop_scope_eh(0);
}
+void theory_str::set_up_axioms(expr * ex) {
+ // TODO check to make sure we don't set up axioms on the same term twice
+ TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) << std::endl;);
+
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ sort * ex_sort = m.get_sort(ex);
+ sort * str_sort = m.mk_sort(get_family_id(), STRING_SORT);
+
+ if (ex_sort == str_sort) {
+ TRACE("t_str_detail", tout << "expr is of sort String" << std::endl;);
+ // set up basic string axioms
+ enode * n = ctx.get_enode(ex);
+ SASSERT(n);
+ m_basicstr_axiom_todo.push_back(n);
+ } else {
+ TRACE("t_str_detail", tout << "expr is of wrong sort, ignoring" << std::endl;);
+ }
+
+ // if expr is an application, recursively inspect all arguments
+ if (is_app(ex)) {
+ app * term = (app*)ex;
+ unsigned num_args = term->get_num_args();
+ for (unsigned i = 0; i < num_args; i++) {
+ set_up_axioms(term->get_arg(i));
+ }
+ }
+}
+
void theory_str::init_search_eh() {
ast_manager & m = get_manager();
context & ctx = get_context();
- TRACE("t_str",
- tout << "search started, assignments are:" << std::endl;
- expr_ref_vector assignment(m);
- ctx.get_assignments(assignment);
- for (expr_ref_vector::iterator i = assignment.begin(); i != assignment.end(); ++i) {
- expr * ex = *i;
+
+ TRACE("t_str_detail",
+ tout << "dumping all asserted formulas:" << std::endl;
+ unsigned nFormulas = ctx.get_num_asserted_formulas();
+ for (unsigned i = 0; i < nFormulas; ++i) {
+ expr * ex = ctx.get_asserted_formula(i);
tout << mk_ismt2_pp(ex, m) << std::endl;
}
);
+ // recursive descent through all asserted formulas to set up axioms
+ unsigned nFormulas = ctx.get_num_asserted_formulas();
+ for (unsigned i = 0; i < nFormulas; ++i) {
+ expr * ex = ctx.get_asserted_formula(i);
+ set_up_axioms(ex);
+ }
+
search_started = true;
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index a336ec649..23abc3c9d 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -47,6 +47,8 @@ namespace smt {
bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
+
+ void set_up_axioms(expr * ex);
public:
theory_str(ast_manager & m);
virtual ~theory_str();
From 91e9cf272a58dd87f8f523c1f26320953479584a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 27 Sep 2015 00:12:04 -0400
Subject: [PATCH 017/401] assert string axiom 2
---
src/smt/theory_str.cpp | 6 ++----
1 file changed, 2 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 63378a700..ee230d027 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -224,7 +224,6 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
assert_axiom(lhs_ge_rhs);
}
- /*
// build axiom 2: Length(a_str) == 0 <=> a_str == ""
{
// build LHS of iff
@@ -246,12 +245,11 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
SASSERT(rhs);
// build LHS <=> RHS and assert
TRACE("t_str_detail", tout << "string axiom 2: " << mk_bounded_pp(lhs, m) << " <=> " << mk_bounded_pp(rhs, m) << std::endl;);
- // TODO this is kind of a hack, maybe just ctx.assert_expr() will be enough?
literal l(mk_eq(lhs, rhs, true));
ctx.mark_as_relevant(l);
- assert_axiom(l);
+ ctx.mk_th_axiom(get_id(), 1, &l);
}
- */
+
}
}
From 114b51dec89319412031c18c71e43f6b63ccc8f2 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 27 Sep 2015 17:26:52 -0400
Subject: [PATCH 018/401] only handle equalities in assignments during
init_search_eh
---
src/smt/theory_str.cpp | 34 +++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 5 ++---
2 files changed, 35 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ee230d027..ab0324a57 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -266,6 +266,10 @@ void theory_str::reset_eh() {
pop_scope_eh(0);
}
+void theory_str::handle_equality(expr * lhs, expr * rhs) {
+
+}
+
void theory_str::set_up_axioms(expr * ex) {
// TODO check to make sure we don't set up axioms on the same term twice
TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) << std::endl;);
@@ -308,13 +312,40 @@ void theory_str::init_search_eh() {
tout << mk_ismt2_pp(ex, m) << std::endl;
}
);
- // recursive descent through all asserted formulas to set up axioms
+ /*
+ * Recursive descent through all asserted formulas to set up axioms.
+ * Note that this is just the input structure and not necessarily things
+ * that we know to be true or false. We're just doing this to see
+ * which terms are explicitly mentioned.
+ */
unsigned nFormulas = ctx.get_num_asserted_formulas();
for (unsigned i = 0; i < nFormulas; ++i) {
expr * ex = ctx.get_asserted_formula(i);
set_up_axioms(ex);
}
+ /*
+ * Similar recursive descent, except over all initially assigned terms.
+ * This is done to find equalities between terms, etc. that we otherwise
+ * wouldn't get a chance to see.
+ */
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+ for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
+ expr * ex = *i;
+ TRACE("t_str_detail", tout << "processing assignment " << mk_ismt2_pp(ex, m) << std::endl;);
+ if (m.is_eq(ex)) {
+ TRACE("t_str_detail", tout << "expr is equality" << std::endl;);
+ app * eq = (app*)ex;
+ SASSERT(eq->get_num_args() == 2);
+ expr * lhs = eq->get_arg(0);
+ expr * rhs = eq->get_arg(1);
+ handle_equality(lhs, rhs);
+ } else {
+ TRACE("t_str_detail", tout << "expr ignored" << std::endl;);
+ }
+ }
+
search_started = true;
}
@@ -323,6 +354,7 @@ void theory_str::new_eq_eh(theory_var x, theory_var y) {
TRACE("t_str", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
TRACE("t_str_detail", tout << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
+ handle_equality(get_enode(x)->get_owner(), get_enode(y)->get_owner());
}
void theory_str::new_diseq_eh(theory_var x, theory_var y) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 23abc3c9d..f58ddea91 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -49,6 +49,7 @@ namespace smt {
void instantiate_basic_string_axioms(enode * str);
void set_up_axioms(expr * ex);
+ void handle_equality(expr * lhs, expr * rhs);
public:
theory_str(ast_manager & m);
virtual ~theory_str();
@@ -58,14 +59,12 @@ namespace smt {
virtual void new_eq_eh(theory_var, theory_var);
virtual void new_diseq_eh(theory_var, theory_var);
+
virtual theory* mk_fresh(context*) { return alloc(theory_str, get_manager()); }
-
virtual void init_search_eh();
-
virtual void relevant_eh(app * n);
virtual void assign_eh(bool_var v, bool is_true);
virtual void push_scope_eh();
-
virtual void reset_eh();
virtual bool can_propagate();
From 6481fe941ae853e87b462edc0e84b95287c5d37d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 27 Sep 2015 17:48:53 -0400
Subject: [PATCH 019/401] instantiate string-eq length-eq axiom
---
src/smt/theory_str.cpp | 66 +++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 2 ++
2 files changed, 67 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ab0324a57..3b9054132 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -118,7 +118,7 @@ app * theory_str::mk_strlen(app * e) {
}
bool theory_str::can_propagate() {
- return !m_basicstr_axiom_todo.empty();
+ return !m_basicstr_axiom_todo.empty() || !m_str_eq_length_axiom_todo.empty();
}
void theory_str::propagate() {
@@ -128,6 +128,14 @@ void theory_str::propagate() {
instantiate_basic_string_axioms(m_basicstr_axiom_todo[i]);
}
m_basicstr_axiom_todo.reset();
+
+ for (unsigned i = 0; i < m_str_eq_length_axiom_todo.size(); ++i) {
+ std::pair<enode*,enode*> pair = m_str_eq_length_axiom_todo[i];
+ enode * lhs = pair.first;
+ enode * rhs = pair.second;
+ instantiate_str_eq_length_axiom(lhs, rhs);
+ }
+ m_str_eq_length_axiom_todo.reset();
}
TRACE("t_str_detail", tout << "done propagating" << std::endl;);
}
@@ -253,6 +261,33 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
}
}
+/*
+ * Add an axiom of the form:
+ * (lhs == rhs) -> ( Length(lhs) == Length(rhs) )
+ */
+void theory_str::instantiate_str_eq_length_axiom(enode * lhs, enode * rhs) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * a_lhs = lhs->get_owner();
+ app * a_rhs = rhs->get_owner();
+
+ // build premise: (lhs == rhs)
+ expr_ref premise(ctx.mk_eq_atom(a_lhs, a_rhs), m);
+
+ // build conclusion: ( Length(lhs) == Length(rhs) )
+ expr_ref len_lhs(mk_strlen(a_lhs), m);
+ SASSERT(len_lhs);
+ expr_ref len_rhs(mk_strlen(a_rhs), m);
+ SASSERT(len_rhs);
+ expr_ref conclusion(ctx.mk_eq_atom(len_lhs, len_rhs), m);
+
+ // build (premise -> conclusion) and assert
+ expr_ref axiom(m.mk_implies(premise, conclusion), m);
+ TRACE("t_str_detail", tout << "string-eq length-eq axiom: " << mk_bounded_pp(axiom, m) << std::endl;);
+ assert_axiom(axiom);
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
@@ -263,11 +298,40 @@ void theory_str::attach_new_th_var(enode * n) {
void theory_str::reset_eh() {
TRACE("t_str", tout << "resetting" << std::endl;);
m_basicstr_axiom_todo.reset();
+ m_str_eq_length_axiom_todo.reset();
pop_scope_eh(0);
}
void theory_str::handle_equality(expr * lhs, expr * rhs) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ // both terms must be of sort String
+ sort * lhs_sort = m.get_sort(lhs);
+ sort * rhs_sort = m.get_sort(rhs);
+ sort * str_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ if (lhs_sort != str_sort || rhs_sort != str_sort) {
+ TRACE("t_str_detail", tout << "skip equality: not String sort" << std::endl;);
+ return;
+ }
+
+ // TODO freeVarAttempt()?
+
+ // TODO simplify concat?
+
+ // TODO newEqCheck()?
+
+ // BEGIN new_eq_handler() in strTheory
+
+ // TODO there's some setup with getLenValue() that I don't think is necessary
+ // because we should already be generating the string length axioms for all string terms
+
+ // set up string length axiom:
+ // (lhs == rhs) -> (Length(lhs) == Length(rhs))
+ enode * e_lhs = ctx.get_enode(lhs);
+ enode * e_rhs = ctx.get_enode(rhs);
+ std::pair<enode*,enode*> eq_pair(e_lhs, e_rhs);
+ m_str_eq_length_axiom_todo.push_back(eq_pair);
}
void theory_str::set_up_axioms(expr * ex) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index f58ddea91..b9c11c2f0 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -38,6 +38,7 @@ namespace smt {
str_util m_strutil;
ptr_vector<enode> m_basicstr_axiom_todo;
+ svector<std::pair<enode*,enode*> > m_str_eq_length_axiom_todo;
protected:
void assert_axiom(ast * e);
@@ -47,6 +48,7 @@ namespace smt {
bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
+ void instantiate_str_eq_length_axiom(enode * lhs, enode * rhs);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From 86e60877187049d3a8800fa27fda8c07a565e4c7 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 27 Sep 2015 21:30:45 -0400
Subject: [PATCH 020/401] starting solve_concat_eq_str(); currently there is an
unsoundness bug
---
src/smt/theory_str.cpp | 206 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 9 ++
2 files changed, 212 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3b9054132..faaa7fb70 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -144,6 +144,7 @@ void theory_str::propagate() {
* Instantiate an axiom of the following form:
* Length(Concat(x, y)) = Length(x) + Length(y)
*/
+// TODO this isn't used yet
void theory_str::instantiate_concat_axiom(enode * cat) {
SASSERT(is_concat(cat));
app * a_cat = cat->get_owner();
@@ -302,6 +303,99 @@ void theory_str::reset_eh() {
pop_scope_eh(0);
}
+/*
+ * Check equality among equivalence class members of LHS and RHS
+ * to discover an incorrect LHS == RHS.
+ * For example, if we have y2 == "str3"
+ * and the equivalence classes are
+ * { y2, (Concat ce m2) }
+ * { "str3", (Concat abc x2) }
+ * then y2 can't be equal to "str3".
+ * Then add an assertion: (y2 == (Concat ce m2)) AND ("str3" == (Concat abc x2)) -> (y2 != "str3")
+ */
+bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
+ // TODO this involves messing around with enodes and equivalence classes
+ return true;
+}
+
+void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ enode * nNode = ctx.get_enode(n);
+ enode * eqcNode = nNode;
+ do {
+ app * ast = eqcNode->get_owner();
+ if (is_concat(eqcNode)) {
+ // TODO simplify_concat
+ /*
+ Z3_ast simConcat = simplifyConcat(t, eqcNode);
+ if (simConcat != eqcNode) {
+ if (isConcatFunc(t, simConcat)) {
+ concats.insert(simConcat);
+ } else {
+ if (isConstStr(t, simConcat)) {
+ constStrs.insert(simConcat);
+ } else {
+ vars.insert(simConcat);
+ }
+ }
+ } else {
+ concats.insert(simConcat);
+ }
+ */
+ concats.insert(ast);
+ } else if (is_string(eqcNode)) {
+ consts.insert(ast);
+ } else {
+ vars.insert(ast);
+ }
+ eqcNode = eqcNode->get_next();
+ } while (eqcNode != nNode);
+}
+
+void theory_str::simplify_concat_equality(expr * lhs, expr * rhs) {
+ // TODO strArgmt::simplifyConcatEq()
+}
+
+/*
+ * strArgmt::solve_concat_eq_str()
+ * Solve concatenations of the form:
+ * const == Concat(const, X)
+ * const == Concat(X, const)
+ */
+void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ TRACE("t_str_detail", tout << mk_ismt2_pp(concat, m) << " == " << mk_ismt2_pp(str, m) << std::endl;);
+
+ if (is_concat(to_app(concat)) && is_string(to_app(str))) {
+ const char * tmp = 0;
+ m_strutil.is_string(str, & tmp);
+ std::string const_str(tmp);
+ app * a_concat = to_app(concat);
+ SASSERT(a_concat->get_num_args() == 2);
+ expr * a1 = a_concat->get_arg(0);
+ expr * a2 = a_concat->get_arg(1);
+
+ if (const_str == "") {
+ TRACE("t_str", tout << "quick path: concat == \"\"" << std::endl;);
+ // assert the following axiom:
+ // ( (Concat a1 a2) == str ) -> ( (a1 == "") AND (a2 == "") )
+ expr_ref premise(ctx.mk_eq_atom(concat, str), m);
+ expr_ref empty_str(m_strutil.mk_string(""), m);
+ expr_ref c1(ctx.mk_eq_atom(a1, empty_str), m);
+ expr_ref c2(ctx.mk_eq_atom(a2, empty_str), m);
+ expr_ref conclusion(m.mk_and(c1, c2), m);
+ expr_ref axiom(m.mk_implies(premise, conclusion), m);
+ TRACE("t_str_detail", tout << "learn " << mk_ismt2_pp(axiom, m) << std::endl;);
+ assert_axiom(axiom);
+ return;
+ }
+ // TODO the rest...
+ }
+}
+
void theory_str::handle_equality(expr * lhs, expr * rhs) {
ast_manager & m = get_manager();
context & ctx = get_context();
@@ -319,7 +413,10 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
// TODO simplify concat?
- // TODO newEqCheck()?
+ // newEqCheck() -- check consistency wrt. existing equivalence classes
+ if (!new_eq_check(lhs, rhs)) {
+ return;
+ }
// BEGIN new_eq_handler() in strTheory
@@ -332,6 +429,94 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
enode * e_rhs = ctx.get_enode(rhs);
std::pair<enode*,enode*> eq_pair(e_lhs, e_rhs);
m_str_eq_length_axiom_todo.push_back(eq_pair);
+
+ // group terms by equivalence class (groupNodeInEqc())
+ std::set<expr*> eqc_lhs_concat;
+ std::set<expr*> eqc_lhs_var;
+ std::set<expr*> eqc_lhs_const;
+ group_terms_by_eqc(lhs, eqc_lhs_concat, eqc_lhs_var, eqc_lhs_const);
+
+ TRACE("t_str_detail",
+ tout << "eqc[lhs]:" << std::endl;
+ tout << "Concats:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_lhs_concat.begin(); it != eqc_lhs_concat.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ tout << "Variables:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_lhs_var.begin(); it != eqc_lhs_var.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ tout << "Constants:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_lhs_const.begin(); it != eqc_lhs_const.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ );
+
+ std::set<expr*> eqc_rhs_concat;
+ std::set<expr*> eqc_rhs_var;
+ std::set<expr*> eqc_rhs_const;
+ group_terms_by_eqc(rhs, eqc_rhs_concat, eqc_rhs_var, eqc_rhs_const);
+
+ TRACE("t_str_detail",
+ tout << "eqc[rhs]:" << std::endl;
+ tout << "Concats:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_rhs_concat.begin(); it != eqc_rhs_concat.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ tout << "Variables:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_rhs_var.begin(); it != eqc_rhs_var.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ tout << "Constants:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_rhs_const.begin(); it != eqc_rhs_const.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ );
+
+ // step 1: Concat == Concat
+ bool hasCommon = false;
+ if (eqc_lhs_concat.size() != 0 && eqc_rhs_concat.size() != 0) {
+ std::set<expr*>::iterator itor1 = eqc_lhs_concat.begin();
+ std::set<expr*>::iterator itor2 = eqc_rhs_concat.begin();
+ for (; itor1 != eqc_lhs_concat.end(); ++itor1) {
+ if (eqc_rhs_concat.find(*itor1) != eqc_rhs_concat.end()) {
+ hasCommon = true;
+ break;
+ }
+ }
+ for (; !hasCommon && itor2 != eqc_rhs_concat.end(); ++itor2) {
+ if (eqc_lhs_concat.find(*itor2) != eqc_lhs_concat.end()) {
+ hasCommon = true;
+ break;
+ }
+ }
+ if (!hasCommon) {
+ simplify_concat_equality(*(eqc_lhs_concat.begin()), *(eqc_rhs_concat.begin()));
+ }
+ }
+
+ // step 2: Concat == Constant
+ if (eqc_lhs_const.size() != 0) {
+ expr * conStr = *(eqc_lhs_const.begin());
+ std::set<expr*>::iterator itor2 = eqc_rhs_concat.begin();
+ for (; itor2 != eqc_rhs_concat.end(); ++itor2) {
+ solve_concat_eq_str(*itor2, conStr);
+ }
+ } else if (eqc_rhs_const.size() != 0) {
+ expr * conStr = *(eqc_rhs_const.begin());
+ std::set<expr*>::iterator itor1 = eqc_lhs_concat.begin();
+ for (; itor1 != eqc_lhs_concat.end(); ++itor1) {
+ solve_concat_eq_str(*itor1, conStr);
+ }
+ }
+
+ // TODO regex unroll? (much later)
}
void theory_str::set_up_axioms(expr * ex) {
@@ -368,6 +553,9 @@ void theory_str::init_search_eh() {
ast_manager & m = get_manager();
context & ctx = get_context();
+ // TODO it would be better to refactor this function so that instead of deferring the axioms
+ // instead we defer the evaluation of the expression
+
TRACE("t_str_detail",
tout << "dumping all asserted formulas:" << std::endl;
unsigned nFormulas = ctx.get_num_asserted_formulas();
@@ -410,11 +598,11 @@ void theory_str::init_search_eh() {
}
}
+ TRACE("t_str", tout << "search started" << std::endl;);
search_started = true;
}
void theory_str::new_eq_eh(theory_var x, theory_var y) {
- // TODO
TRACE("t_str", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
TRACE("t_str_detail", tout << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
@@ -422,7 +610,6 @@ void theory_str::new_eq_eh(theory_var x, theory_var y) {
}
void theory_str::new_diseq_eh(theory_var x, theory_var y) {
- // TODO
TRACE("t_str", tout << "new diseq: v#" << x << " != v#" << y << std::endl;);
TRACE("t_str_detail", tout << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
@@ -442,8 +629,21 @@ void theory_str::push_scope_eh() {
}
final_check_status theory_str::final_check_eh() {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
// TODO
TRACE("t_str", tout << "final check" << std::endl;);
+
+ TRACE("t_str_detail",
+ tout << "dumping all assignments:" << std::endl;
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+ for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
+ expr * ex = *i;
+ tout << mk_ismt2_pp(ex, m) << std::endl;
+ }
+ );
+
return FC_DONE;
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index b9c11c2f0..286de818a 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -23,6 +23,7 @@ Revision History:
#include"value_factory.h"
#include"smt_model_generator.h"
#include"arith_decl_plugin.h"
+#include<set>
namespace smt {
@@ -46,12 +47,20 @@ namespace smt {
bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
+ bool is_string(app const * a) const { return a->is_app_of(get_id(), OP_STR); }
+ bool is_string(enode const * n) const { return is_string(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
void instantiate_str_eq_length_axiom(enode * lhs, enode * rhs);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
+
+ void simplify_concat_equality(expr * lhs, expr * rhs);
+ void solve_concat_eq_str(expr * concat, expr * str);
+
+ bool new_eq_check(expr * lhs, expr * rhs);
+ void group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts);
public:
theory_str(ast_manager & m);
virtual ~theory_str();
From 02cb329ca5b980c02b825bb54dc163149b3f75dc Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 27 Sep 2015 23:24:41 -0400
Subject: [PATCH 021/401] defer equalities uncovered during init_search
---
src/smt/theory_str.cpp | 34 +++++++++++++++-------------------
src/smt/theory_str.h | 2 +-
2 files changed, 16 insertions(+), 20 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index faaa7fb70..bba37f5f0 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -118,7 +118,7 @@ app * theory_str::mk_strlen(app * e) {
}
bool theory_str::can_propagate() {
- return !m_basicstr_axiom_todo.empty() || !m_str_eq_length_axiom_todo.empty();
+ return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty();
}
void theory_str::propagate() {
@@ -129,13 +129,13 @@ void theory_str::propagate() {
}
m_basicstr_axiom_todo.reset();
- for (unsigned i = 0; i < m_str_eq_length_axiom_todo.size(); ++i) {
- std::pair<enode*,enode*> pair = m_str_eq_length_axiom_todo[i];
+ for (unsigned i = 0; i < m_str_eq_todo.size(); ++i) {
+ std::pair<enode*,enode*> pair = m_str_eq_todo[i];
enode * lhs = pair.first;
enode * rhs = pair.second;
- instantiate_str_eq_length_axiom(lhs, rhs);
+ handle_equality(lhs->get_owner(), rhs->get_owner());
}
- m_str_eq_length_axiom_todo.reset();
+ m_str_eq_todo.reset();
}
TRACE("t_str_detail", tout << "done propagating" << std::endl;);
}
@@ -299,7 +299,7 @@ void theory_str::attach_new_th_var(enode * n) {
void theory_str::reset_eh() {
TRACE("t_str", tout << "resetting" << std::endl;);
m_basicstr_axiom_todo.reset();
- m_str_eq_length_axiom_todo.reset();
+ m_str_eq_todo.reset();
pop_scope_eh(0);
}
@@ -382,10 +382,10 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
TRACE("t_str", tout << "quick path: concat == \"\"" << std::endl;);
// assert the following axiom:
// ( (Concat a1 a2) == str ) -> ( (a1 == "") AND (a2 == "") )
- expr_ref premise(ctx.mk_eq_atom(concat, str), m);
+ expr_ref premise(m.mk_eq(concat, str), m);
expr_ref empty_str(m_strutil.mk_string(""), m);
- expr_ref c1(ctx.mk_eq_atom(a1, empty_str), m);
- expr_ref c2(ctx.mk_eq_atom(a2, empty_str), m);
+ expr_ref c1(m.mk_eq(a1, empty_str), m);
+ expr_ref c2(m.mk_eq(a2, empty_str), m);
expr_ref conclusion(m.mk_and(c1, c2), m);
expr_ref axiom(m.mk_implies(premise, conclusion), m);
TRACE("t_str_detail", tout << "learn " << mk_ismt2_pp(axiom, m) << std::endl;);
@@ -423,12 +423,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
// TODO there's some setup with getLenValue() that I don't think is necessary
// because we should already be generating the string length axioms for all string terms
- // set up string length axiom:
- // (lhs == rhs) -> (Length(lhs) == Length(rhs))
- enode * e_lhs = ctx.get_enode(lhs);
- enode * e_rhs = ctx.get_enode(rhs);
- std::pair<enode*,enode*> eq_pair(e_lhs, e_rhs);
- m_str_eq_length_axiom_todo.push_back(eq_pair);
+ instantiate_str_eq_length_axiom(ctx.get_enode(lhs), ctx.get_enode(rhs));
// group terms by equivalence class (groupNodeInEqc())
std::set<expr*> eqc_lhs_concat;
@@ -553,9 +548,6 @@ void theory_str::init_search_eh() {
ast_manager & m = get_manager();
context & ctx = get_context();
- // TODO it would be better to refactor this function so that instead of deferring the axioms
- // instead we defer the evaluation of the expression
-
TRACE("t_str_detail",
tout << "dumping all asserted formulas:" << std::endl;
unsigned nFormulas = ctx.get_num_asserted_formulas();
@@ -592,7 +584,11 @@ void theory_str::init_search_eh() {
SASSERT(eq->get_num_args() == 2);
expr * lhs = eq->get_arg(0);
expr * rhs = eq->get_arg(1);
- handle_equality(lhs, rhs);
+
+ enode * e_lhs = ctx.get_enode(lhs);
+ enode * e_rhs = ctx.get_enode(rhs);
+ std::pair<enode*,enode*> eq_pair(e_lhs, e_rhs);
+ m_str_eq_todo.push_back(eq_pair);
} else {
TRACE("t_str_detail", tout << "expr ignored" << std::endl;);
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 286de818a..76bef4561 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -39,7 +39,7 @@ namespace smt {
str_util m_strutil;
ptr_vector<enode> m_basicstr_axiom_todo;
- svector<std::pair<enode*,enode*> > m_str_eq_length_axiom_todo;
+ svector<std::pair<enode*,enode*> > m_str_eq_todo;
protected:
void assert_axiom(ast * e);
From 0d54e4e4ae99933b4330fba9df9224f9486ee361 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 27 Sep 2015 23:57:41 -0400
Subject: [PATCH 022/401] implement str_decl_plugin::is_value() and
::is_unique_value() we can now prove that (= "abc" "def") is unsatisfiable
---
src/ast/str_decl_plugin.cpp | 12 ++++++++++++
src/ast/str_decl_plugin.h | 4 +++-
2 files changed, 15 insertions(+), 1 deletion(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 1502e3d3a..60db88b63 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -115,6 +115,18 @@ void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol
sort_names.push_back(builtin_name("String", STRING_SORT));
}
+bool str_decl_plugin::is_value(app * e) const {
+ if (e->get_family_id() != m_family_id) {
+ return false;
+ }
+ switch (e->get_decl_kind()) {
+ case OP_STR:
+ return true;
+ default:
+ return false;
+ }
+}
+
bool str_recognizers::is_string(expr const * n, const char ** val) const {
if (!is_app_of(n, m_afid, OP_STR))
return false;
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 7e75fbaf0..a64e0c05f 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -60,8 +60,10 @@ public:
app * mk_string(const char * val);
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
-
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
+
+ virtual bool is_value(app * e) const;
+ virtual bool is_unique_value(app * e) const { return is_value(e); }
// TODO
};
From 7da3854a8b488188641b4b8c2d691e5d59df1df8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Sep 2015 01:56:13 -0400
Subject: [PATCH 023/401] really lousy model-building, WIP
---
src/smt/theory_str.cpp | 46 ++++++++++++++++++++++++++++--------------
src/smt/theory_str.h | 23 ++++++++++++++++++++-
2 files changed, 53 insertions(+), 16 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index bba37f5f0..aaae3e373 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -35,18 +35,9 @@ theory_str::~theory_str() {
}
void theory_str::assert_axiom(ast * a) {
- /*
- if (search_started) {
- // effectively Z3_theory_assert_axiom
- NOT_IMPLEMENTED_YET();
- } else {
- // effectively Z3_assert_cnstr
- context & ctx = get_context();
- ctx.assert_expr(to_expr(a));
- }
- */
- TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(a, get_manager()) << "\n";);
expr * e = to_expr(a);
+ if (get_manager().is_true(e)) return;
+ TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(a, get_manager()) << "\n";);
context & ctx = get_context();
ctx.internalize(e, false);
literal lit(ctx.get_literal(e));
@@ -381,11 +372,11 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
if (const_str == "") {
TRACE("t_str", tout << "quick path: concat == \"\"" << std::endl;);
// assert the following axiom:
- // ( (Concat a1 a2) == str ) -> ( (a1 == "") AND (a2 == "") )
- expr_ref premise(m.mk_eq(concat, str), m);
+ // ( (Concat a1 a2) == "" ) -> ( (a1 == "") AND (a2 == "") )
expr_ref empty_str(m_strutil.mk_string(""), m);
- expr_ref c1(m.mk_eq(a1, empty_str), m);
- expr_ref c2(m.mk_eq(a2, empty_str), m);
+ expr_ref premise(ctx.mk_eq_atom(concat, empty_str), m);
+ expr_ref c1(ctx.mk_eq_atom(a1, empty_str), m);
+ expr_ref c2(ctx.mk_eq_atom(a2, empty_str), m);
expr_ref conclusion(m.mk_and(c1, c2), m);
expr_ref axiom(m.mk_implies(premise, conclusion), m);
TRACE("t_str_detail", tout << "learn " << mk_ismt2_pp(axiom, m) << std::endl;);
@@ -643,4 +634,29 @@ final_check_status theory_str::final_check_eh() {
return FC_DONE;
}
+void theory_str::init_model(model_generator & mg) {
+ TRACE("t_str", tout << "initializing model" << std::endl; display(tout););
+ m_factory = alloc(str_value_factory, get_manager(), get_family_id());
+ mg.register_factory(m_factory);
+}
+
+model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
+ TRACE("t_str", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), get_manager()) <<
+ " (sort " << mk_ismt2_pp(get_manager().get_sort(n->get_owner()), get_manager()) << ")\n";);
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ app_ref owner(m);
+ owner = n->get_owner();
+
+ // If the owner is not internalized, it doesn't have an enode associated.
+ SASSERT(ctx.e_internalized(owner));
+
+ if (m_strutil.is_string(owner)) {
+ return alloc(expr_wrapper_proc, owner);
+ }
+ NOT_IMPLEMENTED_YET(); // TODO
+}
+
+void theory_str::finalize_model(model_generator & mg) {}
+
}; /* namespace smt */
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 76bef4561..65a401580 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -28,7 +28,22 @@ Revision History:
namespace smt {
class str_value_factory : public value_factory {
- // TODO
+ str_util m_util;
+ public:
+ str_value_factory(ast_manager & m, family_id fid) :
+ value_factory(m, fid),
+ m_util(m) {}
+ virtual ~str_value_factory() {}
+ virtual expr * get_some_value(sort * s) {
+ return m_util.mk_string("some value");
+ }
+ virtual bool get_some_values(sort * s, expr_ref & v1, expr_ref & v2) {
+ v1 = m_util.mk_string("value 1");
+ v2 = m_util.mk_string("value 2");
+ return true;
+ }
+ virtual expr * get_fresh_value(sort * s) { NOT_IMPLEMENTED_YET(); }
+ virtual void register_value(expr * n) { /* Ignore */ }
};
class theory_str : public theory {
@@ -38,6 +53,8 @@ namespace smt {
arith_util m_autil;
str_util m_strutil;
+ str_value_factory * m_factory;
+
ptr_vector<enode> m_basicstr_axiom_todo;
svector<std::pair<enode*,enode*> > m_str_eq_todo;
protected:
@@ -83,6 +100,10 @@ namespace smt {
virtual final_check_status final_check_eh();
void attach_new_th_var(enode * n);
+
+ virtual void init_model(model_generator & m);
+ virtual model_value_proc * mk_value(enode * n, model_generator & mg);
+ virtual void finalize_model(model_generator & mg);
};
};
From 87b5765e3d3ef04aface95303666ed3f4daf7026 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Sep 2015 02:04:35 -0400
Subject: [PATCH 024/401] clean up traces and make them much easier to read
---
src/smt/theory_str.cpp | 24 ++++++++++++------------
1 file changed, 12 insertions(+), 12 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index aaae3e373..467d94c5f 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -128,7 +128,6 @@ void theory_str::propagate() {
}
m_str_eq_todo.reset();
}
- TRACE("t_str_detail", tout << "done propagating" << std::endl;);
}
/*
@@ -507,8 +506,6 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
void theory_str::set_up_axioms(expr * ex) {
// TODO check to make sure we don't set up axioms on the same term twice
- TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) << std::endl;);
-
ast_manager & m = get_manager();
context & ctx = get_context();
@@ -516,13 +513,15 @@ void theory_str::set_up_axioms(expr * ex) {
sort * str_sort = m.mk_sort(get_family_id(), STRING_SORT);
if (ex_sort == str_sort) {
- TRACE("t_str_detail", tout << "expr is of sort String" << std::endl;);
+ TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ ": expr is of sort String" << std::endl;);
// set up basic string axioms
enode * n = ctx.get_enode(ex);
SASSERT(n);
m_basicstr_axiom_todo.push_back(n);
} else {
- TRACE("t_str_detail", tout << "expr is of wrong sort, ignoring" << std::endl;);
+ TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ ": expr is of wrong sort, ignoring" << std::endl;);
}
// if expr is an application, recursively inspect all arguments
@@ -568,9 +567,9 @@ void theory_str::init_search_eh() {
ctx.get_assignments(assignments);
for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
expr * ex = *i;
- TRACE("t_str_detail", tout << "processing assignment " << mk_ismt2_pp(ex, m) << std::endl;);
if (m.is_eq(ex)) {
- TRACE("t_str_detail", tout << "expr is equality" << std::endl;);
+ TRACE("t_str_detail", tout << "processing assignment " << mk_ismt2_pp(ex, m) <<
+ ": expr is equality" << std::endl;);
app * eq = (app*)ex;
SASSERT(eq->get_num_args() == 2);
expr * lhs = eq->get_arg(0);
@@ -581,7 +580,8 @@ void theory_str::init_search_eh() {
std::pair<enode*,enode*> eq_pair(e_lhs, e_rhs);
m_str_eq_todo.push_back(eq_pair);
} else {
- TRACE("t_str_detail", tout << "expr ignored" << std::endl;);
+ TRACE("t_str_detail", tout << "processing assignment " << mk_ismt2_pp(ex, m)
+ << ": expr ignored" << std::endl;);
}
}
@@ -590,15 +590,15 @@ void theory_str::init_search_eh() {
}
void theory_str::new_eq_eh(theory_var x, theory_var y) {
- TRACE("t_str", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
- TRACE("t_str_detail", tout << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
+ //TRACE("t_str_detail", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
+ TRACE("t_str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
handle_equality(get_enode(x)->get_owner(), get_enode(y)->get_owner());
}
void theory_str::new_diseq_eh(theory_var x, theory_var y) {
- TRACE("t_str", tout << "new diseq: v#" << x << " != v#" << y << std::endl;);
- TRACE("t_str_detail", tout << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
+ //TRACE("t_str_detail", tout << "new diseq: v#" << x << " != v#" << y << std::endl;);
+ TRACE("t_str", tout << "new diseq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
}
From 5fe129b5716aabca5313adfb0f5e77f3b3ea3fc9 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Sep 2015 02:09:35 -0400
Subject: [PATCH 025/401] use mk_ismt2_pp() instead of mk_bounded_pp()
---
src/smt/theory_str.cpp | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 467d94c5f..b3780265d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -171,7 +171,7 @@ void theory_str::instantiate_concat_axiom(enode * cat) {
// finally assert equality between the two subexpressions
app * eq = m.mk_eq(len_xy, len_x_plus_len_y);
SASSERT(eq);
- TRACE("t_str", tout << mk_bounded_pp(eq, m) << std::endl;);
+ TRACE("t_str", tout << mk_ismt2_pp(eq, m) << std::endl;);
assert_axiom(eq);
}
@@ -219,7 +219,7 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
app * lhs_ge_rhs = m_autil.mk_ge(len_str, zero);
SASSERT(lhs_ge_rhs);
// TODO verify that this works
- TRACE("t_str_detail", tout << "string axiom 1: " << mk_bounded_pp(lhs_ge_rhs, m) << std::endl;);
+ TRACE("t_str_detail", tout << "string axiom 1: " << mk_ismt2_pp(lhs_ge_rhs, m) << std::endl;);
assert_axiom(lhs_ge_rhs);
}
@@ -243,7 +243,7 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
rhs = ctx.mk_eq_atom(a_str, empty_str);
SASSERT(rhs);
// build LHS <=> RHS and assert
- TRACE("t_str_detail", tout << "string axiom 2: " << mk_bounded_pp(lhs, m) << " <=> " << mk_bounded_pp(rhs, m) << std::endl;);
+ TRACE("t_str_detail", tout << "string axiom 2: " << mk_ismt2_pp(lhs, m) << " <=> " << mk_ismt2_pp(rhs, m) << std::endl;);
literal l(mk_eq(lhs, rhs, true));
ctx.mark_as_relevant(l);
ctx.mk_th_axiom(get_id(), 1, &l);
@@ -275,7 +275,7 @@ void theory_str::instantiate_str_eq_length_axiom(enode * lhs, enode * rhs) {
// build (premise -> conclusion) and assert
expr_ref axiom(m.mk_implies(premise, conclusion), m);
- TRACE("t_str_detail", tout << "string-eq length-eq axiom: " << mk_bounded_pp(axiom, m) << std::endl;);
+ TRACE("t_str_detail", tout << "string-eq length-eq axiom: " << mk_ismt2_pp(axiom, m) << std::endl;);
assert_axiom(axiom);
}
From bccadedfee53f5d1cd097300044bfc39c1a5bdac Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Sep 2015 03:20:13 -0400
Subject: [PATCH 026/401] instead of building axiom (=> x y), build (or (not x)
y) this may be a bug in Z3 as it suggests that implications are ignored e.g.
I can assert the axiom (=> true false) and Z3 is okay with this
---
src/smt/theory_str.cpp | 23 +++++++++++++++--------
src/smt/theory_str.h | 1 +
2 files changed, 16 insertions(+), 8 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b3780265d..6d2284d67 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -39,7 +39,9 @@ void theory_str::assert_axiom(ast * a) {
if (get_manager().is_true(e)) return;
TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(a, get_manager()) << "\n";);
context & ctx = get_context();
- ctx.internalize(e, false);
+ if (!ctx.b_internalized(e)) {
+ ctx.internalize(e, true);
+ }
literal lit(ctx.get_literal(e));
ctx.mark_as_relevant(lit);
ctx.mk_th_axiom(get_id(), 1, &lit);
@@ -372,14 +374,15 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
TRACE("t_str", tout << "quick path: concat == \"\"" << std::endl;);
// assert the following axiom:
// ( (Concat a1 a2) == "" ) -> ( (a1 == "") AND (a2 == "") )
- expr_ref empty_str(m_strutil.mk_string(""), m);
- expr_ref premise(ctx.mk_eq_atom(concat, empty_str), m);
- expr_ref c1(ctx.mk_eq_atom(a1, empty_str), m);
- expr_ref c2(ctx.mk_eq_atom(a2, empty_str), m);
+
+
+ expr_ref premise(ctx.mk_eq_atom(concat, str), m);
+ expr_ref c1(ctx.mk_eq_atom(a1, str), m);
+ expr_ref c2(ctx.mk_eq_atom(a2, str), m);
expr_ref conclusion(m.mk_and(c1, c2), m);
- expr_ref axiom(m.mk_implies(premise, conclusion), m);
- TRACE("t_str_detail", tout << "learn " << mk_ismt2_pp(axiom, m) << std::endl;);
+ expr_ref axiom(m.mk_or(m.mk_not(premise), conclusion), m);
assert_axiom(axiom);
+
return;
}
// TODO the rest...
@@ -561,7 +564,7 @@ void theory_str::init_search_eh() {
/*
* Similar recursive descent, except over all initially assigned terms.
* This is done to find equalities between terms, etc. that we otherwise
- * wouldn't get a chance to see.
+ * might not get a chance to see.
*/
expr_ref_vector assignments(m);
ctx.get_assignments(assignments);
@@ -615,6 +618,10 @@ void theory_str::push_scope_eh() {
TRACE("t_str", tout << "push" << std::endl;);
}
+void theory_str::pop_scope_eh(unsigned num_scopes) {
+ TRACE("t_str", tout << "pop " << num_scopes << std::endl;);
+}
+
final_check_status theory_str::final_check_eh() {
ast_manager & m = get_manager();
context & ctx = get_context();
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 65a401580..afac8b7f1 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -93,6 +93,7 @@ namespace smt {
virtual void relevant_eh(app * n);
virtual void assign_eh(bool_var v, bool is_true);
virtual void push_scope_eh();
+ virtual void pop_scope_eh(unsigned num_scopes);
virtual void reset_eh();
virtual bool can_propagate();
From 62cd633b63b3452f913faaec383676900ec91052 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Sep 2015 03:26:46 -0400
Subject: [PATCH 027/401] create helper function
theory_str::assert_implication()
---
src/smt/theory_str.cpp | 23 +++++++++++++----------
src/smt/theory_str.h | 3 ++-
2 files changed, 15 insertions(+), 11 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 6d2284d67..3ef2f06e5 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -34,10 +34,9 @@ theory_str::theory_str(ast_manager & m):
theory_str::~theory_str() {
}
-void theory_str::assert_axiom(ast * a) {
- expr * e = to_expr(a);
+void theory_str::assert_axiom(expr * e) {
if (get_manager().is_true(e)) return;
- TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(a, get_manager()) << "\n";);
+ TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << "\n";);
context & ctx = get_context();
if (!ctx.b_internalized(e)) {
ctx.internalize(e, true);
@@ -45,7 +44,13 @@ void theory_str::assert_axiom(ast * a) {
literal lit(ctx.get_literal(e));
ctx.mark_as_relevant(lit);
ctx.mk_th_axiom(get_id(), 1, &lit);
- TRACE("t_str_detail", tout << "done asserting " << mk_ismt2_pp(a, get_manager()) << "\n";);
+ TRACE("t_str_detail", tout << "done asserting " << mk_ismt2_pp(e, get_manager()) << "\n";);
+}
+
+void theory_str::assert_implication(expr * premise, expr * conclusion) {
+ ast_manager & m = get_manager();
+ expr_ref axiom(m.mk_or(m.mk_not(premise), conclusion), m);
+ assert_axiom(axiom);
}
bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
@@ -275,10 +280,9 @@ void theory_str::instantiate_str_eq_length_axiom(enode * lhs, enode * rhs) {
SASSERT(len_rhs);
expr_ref conclusion(ctx.mk_eq_atom(len_lhs, len_rhs), m);
- // build (premise -> conclusion) and assert
- expr_ref axiom(m.mk_implies(premise, conclusion), m);
- TRACE("t_str_detail", tout << "string-eq length-eq axiom: " << mk_ismt2_pp(axiom, m) << std::endl;);
- assert_axiom(axiom);
+ TRACE("t_str_detail", tout << "string-eq length-eq axiom: "
+ << mk_ismt2_pp(premise, m) << " -> " << mk_ismt2_pp(conclusion, m) << std::endl;);
+ assert_implication(premise, conclusion);
}
void theory_str::attach_new_th_var(enode * n) {
@@ -380,8 +384,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
expr_ref c1(ctx.mk_eq_atom(a1, str), m);
expr_ref c2(ctx.mk_eq_atom(a2, str), m);
expr_ref conclusion(m.mk_and(c1, c2), m);
- expr_ref axiom(m.mk_or(m.mk_not(premise), conclusion), m);
- assert_axiom(axiom);
+ assert_implication(premise, conclusion);
return;
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index afac8b7f1..c7a4a5952 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -58,7 +58,8 @@ namespace smt {
ptr_vector<enode> m_basicstr_axiom_todo;
svector<std::pair<enode*,enode*> > m_str_eq_todo;
protected:
- void assert_axiom(ast * e);
+ void assert_axiom(expr * e);
+ void assert_implication(expr * premise, expr * conclusion);
app * mk_strlen(app * e);
From 9bc685b21d86ffd815300dd77a4a996a73be71de Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Sep 2015 10:43:34 -0400
Subject: [PATCH 028/401] solve_concat_eq_str() for concat(const,const) ==
const
---
src/smt/theory_str.cpp | 107 ++++++++++++++++++++++++++++++++++++++---
src/smt/theory_str.h | 3 ++
2 files changed, 103 insertions(+), 7 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3ef2f06e5..f3e6496b7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -54,11 +54,9 @@ void theory_str::assert_implication(expr * premise, expr * conclusion) {
}
bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
- // TODO I have no idea if this is correct.
TRACE("t_str", tout << "internalizing atom: " << mk_ismt2_pp(atom, get_manager()) << std::endl;);
SASSERT(atom->get_family_id() == get_family_id());
- ast_manager & m = get_manager();
context & ctx = get_context();
if (ctx.b_internalized(atom))
@@ -75,8 +73,6 @@ bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
}
bool theory_str::internalize_term(app * term) {
- // TODO I have no idea if this is correct either.
- ast_manager & m = get_manager();
context & ctx = get_context();
TRACE("t_str", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
SASSERT(term->get_family_id() == get_family_id());
@@ -115,6 +111,16 @@ app * theory_str::mk_strlen(app * e) {
}
}
+app * theory_str::mk_concat(app * e1, app * e2) {
+ ast_manager & m = get_manager();
+ if (e1 == NULL || e2 == NULL) {
+ m.raise_exception("strings to be concatenated cannot be NULL");
+ }
+ // TODO there's a *TON* of missing code here from strTheory::mk_concat()
+ expr * args[2] = {e1, e2};
+ return get_manager().mk_app(get_id(), OP_STRCAT, 0, 0, 2, args);
+}
+
bool theory_str::can_propagate() {
return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty();
}
@@ -225,7 +231,6 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
// build LHS >= RHS and assert
app * lhs_ge_rhs = m_autil.mk_ge(len_str, zero);
SASSERT(lhs_ge_rhs);
- // TODO verify that this works
TRACE("t_str_detail", tout << "string axiom 1: " << mk_ismt2_pp(lhs_ge_rhs, m) << std::endl;);
assert_axiom(lhs_ge_rhs);
}
@@ -315,7 +320,6 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
}
void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts) {
- ast_manager & m = get_manager();
context & ctx = get_context();
enode * nNode = ctx.get_enode(n);
enode * eqcNode = nNode;
@@ -352,6 +356,27 @@ void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::se
void theory_str::simplify_concat_equality(expr * lhs, expr * rhs) {
// TODO strArgmt::simplifyConcatEq()
}
+/*
+ * Look through the equivalence class of n to find a string constant.
+ * Return that constant if it is found, and set hasEqcValue to true.
+ * Otherwise, return n, and set hasEqcValue to false.
+ */
+expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
+ context & ctx = get_context();
+ enode * nNode = ctx.get_enode(n);
+ enode * eqcNode = nNode;
+ do {
+ app * ast = eqcNode->get_owner();
+ if (is_string(eqcNode)) {
+ hasEqcValue = true;
+ return ast;
+ }
+ eqcNode = eqcNode->get_next();
+ } while (eqcNode != nNode);
+ // not found
+ hasEqcValue = false;
+ return n;
+}
/*
* strArgmt::solve_concat_eq_str()
@@ -388,7 +413,75 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
return;
}
- // TODO the rest...
+ bool arg1_has_eqc_value = false;
+ bool arg2_has_eqc_value = false;
+ expr * arg1 = get_eqc_value(a1, arg1_has_eqc_value);
+ expr * arg2 = get_eqc_value(a2, arg2_has_eqc_value);
+ expr_ref newConcat(m);
+ if (arg1 != a1 || arg2 != a2) {
+ TRACE("t_str", tout << "resolved concat argument(s) to eqc string constants" << std::endl;);
+ int iPos = 0;
+ app * item1[2];
+ if (a1 != arg1) {
+ item1[iPos++] = ctx.mk_eq_atom(a1, arg1);
+ }
+ if (a2 != arg2) {
+ item1[iPos++] = ctx.mk_eq_atom(a2, arg2);
+ }
+ expr_ref implyL1(m);
+ if (iPos == 1) {
+ implyL1 = item1[0];
+ } else {
+ implyL1 = m.mk_and(item1[0], item1[1]);
+ }
+ newConcat = mk_concat(to_app(arg1), to_app(arg2));
+ if (newConcat != str) {
+ expr_ref implyR1(ctx.mk_eq_atom(concat, newConcat), m);
+ assert_implication(implyL1, implyR1);
+ }
+ } else {
+ newConcat = concat;
+ }
+ if (newConcat == str) {
+ return;
+ }
+ if (!is_concat(to_app(newConcat))) {
+ return;
+ }
+ if (arg1_has_eqc_value && arg2_has_eqc_value) {
+ // Case 1: Concat(const, const) == const
+ TRACE("t_str", tout << "Case 1: Concat(const, const) == const" << std::endl;);
+ const char * str1;
+ m_strutil.is_string(arg1, & str1);
+ std::string arg1_str(str1);
+
+ const char * str2;
+ m_strutil.is_string(arg2, & str2);
+ std::string arg2_str(str2);
+
+ std::string result_str = arg1_str + arg2_str;
+ if (result_str != const_str) {
+ // Inconsistency
+ TRACE("t_str", tout << "inconsistency detected: \""
+ << arg1_str << "\" + \"" << arg2_str <<
+ "\" != \"" << const_str << "\"" << std::endl;);
+ expr_ref equality(ctx.mk_eq_atom(concat, str), m);
+ expr_ref diseq(m.mk_not(equality), m);
+ assert_axiom(diseq);
+ }
+ } else if (!arg1_has_eqc_value && arg2_has_eqc_value) {
+ // Case 2: Concat(var, const) == const
+ TRACE("t_str", tout << "Case 2: Concat(var, const) == const" << std::endl;);
+ NOT_IMPLEMENTED_YET();
+ } else if (arg1_has_eqc_value && !arg2_has_eqc_value) {
+ // Case 3: Concat(const, var) == const
+ TRACE("t_str", tout << "Case 3: Concat(const, var) == const" << std::endl;);
+ NOT_IMPLEMENTED_YET();
+ } else {
+ // Case 4: Concat(var, var) == const
+ TRACE("t_str", tout << "Case 4: Concat(var, var) == const" << std::endl;);
+ NOT_IMPLEMENTED_YET();
+ }
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index c7a4a5952..4839b417b 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -62,6 +62,7 @@ namespace smt {
void assert_implication(expr * premise, expr * conclusion);
app * mk_strlen(app * e);
+ app * mk_concat(app * e1, app * e2);
bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
@@ -74,6 +75,8 @@ namespace smt {
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
+ expr * get_eqc_value(expr * n, bool & hasEqcValue);
+
void simplify_concat_equality(expr * lhs, expr * rhs);
void solve_concat_eq_str(expr * concat, expr * str);
From 876af399e394c1974019c897d081df76160e2177 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Sep 2015 14:44:25 -0400
Subject: [PATCH 029/401] probably fix duplication of mk_string() terms also
implement Case 2 of solve_concat_eq_str()
---
src/ast/str_decl_plugin.cpp | 22 +++++++++++++++++----
src/ast/str_decl_plugin.h | 7 +++++++
src/smt/theory_str.cpp | 39 ++++++++++++++++++++++++++++++++++++-
3 files changed, 63 insertions(+), 5 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 60db88b63..9398dbf34 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -99,11 +99,25 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters,
return mk_func_decl(k);
}
+app * str_decl_plugin::mk_string(std::string & val) {
+ std::map<std::string, app*>::iterator it = string_cache.find(val);
+ if (it == string_cache.end()) {
+ char * new_buffer = alloc_svect(char, val.length() + 1);
+ strcpy(new_buffer, val.c_str());
+ parameter p[1] = {parameter(new_buffer)};
+ func_decl * d;
+ d = m_manager->mk_const_decl(m_strv_sym, m_str_decl, func_decl_info(m_family_id, OP_STR, 1, p));
+ app * str = m_manager->mk_const(d);
+ string_cache[val] = str;
+ return str;
+ } else {
+ return it->second;
+ }
+}
+
app * str_decl_plugin::mk_string(const char * val) {
- parameter p[1] = {parameter(val)};
- func_decl * d;
- d = m_manager->mk_const_decl(m_strv_sym, m_str_decl, func_decl_info(m_family_id, OP_STR, 1, p));
- return m_manager->mk_const(d);
+ std::string key(val);
+ return mk_string(key);
}
void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index a64e0c05f..f84c1ec31 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -19,6 +19,7 @@ Revision History:
#include"ast.h"
#include"arith_decl_plugin.h"
+#include<map>
enum str_sort_kind {
STRING_SORT,
@@ -44,6 +45,8 @@ protected:
func_decl * m_concat_decl;
func_decl * m_length_decl;
+ std::map<std::string, app*> string_cache;
+
virtual void set_manager(ast_manager * m, family_id id);
func_decl * mk_func_decl(decl_kind k);
@@ -58,6 +61,7 @@ public:
unsigned arity, sort * const * domain, sort * range);
app * mk_string(const char * val);
+ app * mk_string(std::string & val);
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
@@ -90,6 +94,9 @@ public:
app * mk_string(const char * val) {
return m_plugin->mk_string(val);
}
+ app * mk_string(std::string & val) {
+ return m_plugin->mk_string(val);
+ }
// TODO
};
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f3e6496b7..08f83fdd3 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -468,11 +468,48 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
expr_ref equality(ctx.mk_eq_atom(concat, str), m);
expr_ref diseq(m.mk_not(equality), m);
assert_axiom(diseq);
+ return;
}
} else if (!arg1_has_eqc_value && arg2_has_eqc_value) {
// Case 2: Concat(var, const) == const
TRACE("t_str", tout << "Case 2: Concat(var, const) == const" << std::endl;);
- NOT_IMPLEMENTED_YET();
+ const char * str2;
+ m_strutil.is_string(arg2, & str2);
+ std::string arg2_str(str2);
+ int resultStrLen = const_str.length();
+ int arg2StrLen = arg2_str.length();
+ if (resultStrLen < arg2StrLen) {
+ // Inconsistency
+ TRACE("t_str", tout << "inconsistency detected: \""
+ << arg2_str <<
+ "\" is longer than \"" << const_str << "\","
+ << " so cannot be concatenated with anything to form it" << std::endl;);
+ expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref diseq(m.mk_not(equality), m);
+ assert_axiom(diseq);
+ return;
+ } else {
+ int varStrLen = resultStrLen - arg2StrLen;
+ std::string firstPart = const_str.substr(0, varStrLen);
+ std::string secondPart = const_str.substr(varStrLen, arg2StrLen);
+ if (arg2_str != secondPart) {
+ // Inconsistency
+ TRACE("t_str", tout << "inconsistency detected: "
+ << "suffix of concatenation result expected \"" << secondPart << "\", "
+ << "actually \"" << arg2_str << "\""
+ << std::endl;);
+ expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref diseq(m.mk_not(equality), m);
+ assert_axiom(diseq);
+ return;
+ } else {
+ expr_ref tmpStrConst(m_strutil.mk_string(firstPart), m);
+ expr_ref premise(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref conclusion(ctx.mk_eq_atom(arg1, tmpStrConst), m);
+ assert_implication(premise, conclusion);
+ return;
+ }
+ }
} else if (arg1_has_eqc_value && !arg2_has_eqc_value) {
// Case 3: Concat(const, var) == const
TRACE("t_str", tout << "Case 3: Concat(const, var) == const" << std::endl;);
From 871b08bd8cd42dd35a9ed19a8bc4e2d77fca4155 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Sep 2015 14:52:43 -0400
Subject: [PATCH 030/401] solve_concat_eq_str() case 3
---
src/smt/theory_str.cpp | 38 +++++++++++++++++++++++++++++++++++++-
1 file changed, 37 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 08f83fdd3..d6edc2f6b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -513,7 +513,43 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
} else if (arg1_has_eqc_value && !arg2_has_eqc_value) {
// Case 3: Concat(const, var) == const
TRACE("t_str", tout << "Case 3: Concat(const, var) == const" << std::endl;);
- NOT_IMPLEMENTED_YET();
+ const char * str1;
+ m_strutil.is_string(arg1, & str1);
+ std::string arg1_str(str1);
+ int resultStrLen = const_str.length();
+ int arg1StrLen = arg1_str.length();
+ if (resultStrLen < arg1StrLen) {
+ // Inconsistency
+ TRACE("t_str", tout << "inconsistency detected: \""
+ << arg1_str <<
+ "\" is longer than \"" << const_str << "\","
+ << " so cannot be concatenated with anything to form it" << std::endl;);
+ expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref diseq(m.mk_not(equality), m);
+ assert_axiom(diseq);
+ return;
+ } else {
+ int varStrLen = resultStrLen - arg1StrLen;
+ std::string firstPart = const_str.substr(0, arg1StrLen);
+ std::string secondPart = const_str.substr(arg1StrLen, varStrLen);
+ if (arg1_str != firstPart) {
+ // Inconsistency
+ TRACE("t_str", tout << "inconsistency detected: "
+ << "prefix of concatenation result expected \"" << secondPart << "\", "
+ << "actually \"" << arg1_str << "\""
+ << std::endl;);
+ expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref diseq(m.mk_not(equality), m);
+ assert_axiom(diseq);
+ return;
+ } else {
+ expr_ref tmpStrConst(m_strutil.mk_string(secondPart), m);
+ expr_ref premise(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref conclusion(ctx.mk_eq_atom(arg2, tmpStrConst), m);
+ assert_implication(premise, conclusion);
+ return;
+ }
+ }
} else {
// Case 4: Concat(var, var) == const
TRACE("t_str", tout << "Case 4: Concat(var, var) == const" << std::endl;);
From f473b92d5c20352cb8cafcea0adb9d02fcc87f4a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Sep 2015 17:41:01 -0400
Subject: [PATCH 031/401] solve_concat_eq_str() case 4 WIP
---
src/smt/theory_str.cpp | 174 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 5 ++
2 files changed, 177 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index d6edc2f6b..458786110 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -27,7 +27,8 @@ theory_str::theory_str(ast_manager & m):
theory(m.mk_family_id("str")),
search_started(false),
m_autil(m),
- m_strutil(m)
+ m_strutil(m),
+ tmpXorVarCount(0)
{
}
@@ -99,6 +100,31 @@ bool theory_str::internalize_term(app * term) {
return true;
}
+Z3_ast mk_internal_xor_var(Z3_theory t) {
+ Z3_context ctx = Z3_theory_get_context(t);
+ std::stringstream ss;
+ ss << tmpXorVarCount;
+ tmpXorVarCount++;
+ std::string name = "$$_xor_" + ss.str();
+ return mk_int_var(ctx, name.c_str());
+}
+
+app * theory_str::mk_internal_xor_var() {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ std::stringstream ss;
+ ss << tmpXorVarCount;
+ tmpXorVarCount++;
+ std::string name = "$$_xor_" + ss.str();
+ // Z3_sort r = of_sort(mk_c(c)->m().mk_sort(mk_c(c)->get_arith_fid(), INT_SORT));
+ sort * int_sort = m.mk_sort(m_autil.get_family_id(), INT_SORT);
+ symbol sym(name);
+
+ app* a = m.mk_const(m.mk_const_decl(sym, int_sort));
+ // TODO ctx.save_ast_trail(a)?
+ return a;
+}
+
app * theory_str::mk_strlen(app * e) {
/*if (m_strutil.is_string(e)) {*/ if (false) {
const char * strval = 0;
@@ -553,7 +579,151 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
} else {
// Case 4: Concat(var, var) == const
TRACE("t_str", tout << "Case 4: Concat(var, var) == const" << std::endl;);
- NOT_IMPLEMENTED_YET();
+ // TODO large additions required in this section
+ if (true) { /* if (Concat(arg1, arg2) == NULL) { */
+ int arg1Len = -1; /* = getLenValue(arg1); */
+ int arg2Len = -1; /* = getLenValue(arg2); */
+ if (arg1Len != -1 || arg2Len != -1) {
+ NOT_IMPLEMENTED_YET(); // TODO
+ } else {
+ /*
+ Z3_ast xorFlag = NULL;
+ std::pair<Z3_ast, Z3_ast> key1(arg1, arg2);
+ std::pair<Z3_ast, Z3_ast> key2(arg2, arg1);
+ if (varForBreakConcat.find(key1) == varForBreakConcat.end() && varForBreakConcat.find(key2) == varForBreakConcat.end()) {
+ xorFlag = mk_internal_xor_var(t);
+ varForBreakConcat[key1][0] = xorFlag;
+ } else {
+ if (varForBreakConcat.find(key1) != varForBreakConcat.end()) {
+ xorFlag = varForBreakConcat[key1][0];
+ } else {
+ xorFlag = varForBreakConcat[key2][0];
+ }
+ }
+
+ int concatStrLen = const_str.length();
+ int xor_pos = 0;
+ int and_count = 1;
+ Z3_ast * xor_items = new Z3_ast[concatStrLen + 1];
+ Z3_ast * and_items = new Z3_ast[4 * (concatStrLen + 1) + 1];
+ Z3_ast arg1_eq = NULL;
+ Z3_ast arg2_eq = NULL;
+ for (int i = 0; i < concatStrLen + 1; i++) {
+ std::string prefixStr = const_str.substr(0, i);
+ std::string suffixStr = const_str.substr(i, concatStrLen - i);
+
+ // skip invalidate options
+ if (isConcatFunc(t, arg1) && canConcatEqStr(t, arg1, prefixStr) == 0) {
+ continue;
+ }
+ if (isConcatFunc(t, arg2) && canConcatEqStr(t, arg2, suffixStr) == 0) {
+ continue;
+ }
+
+ Z3_ast xorAst = Z3_mk_eq(ctx, xorFlag, mk_int(ctx, xor_pos));
+ xor_items[xor_pos++] = xorAst;
+
+ Z3_ast prefixAst = my_mk_str_value(t, prefixStr.c_str());
+ arg1_eq = Z3_mk_eq(ctx, arg1, prefixAst);
+ and_items[and_count++] = Z3_mk_eq(ctx, xorAst, arg1_eq);
+
+ Z3_ast suffixAst = my_mk_str_value(t, suffixStr.c_str());
+ arg2_eq = Z3_mk_eq(ctx, arg2, suffixAst);
+ and_items[and_count++] = Z3_mk_eq(ctx, xorAst, arg2_eq);
+ }
+ */
+ expr_ref xorFlag(m);
+ std::pair<expr*, expr*> key1(arg1, arg2);
+ std::pair<expr*, expr*> key2(arg2, arg1);
+ std::map<std::pair<expr*, expr*>, std::map<int, expr*> >::iterator varBreak_key1 =
+ varForBreakConcat.find(key1);
+ std::map<std::pair<expr*, expr*>, std::map<int, expr*> >::iterator varBreak_key2 =
+ varForBreakConcat.find(key2);
+ if (varBreak_key1 == varForBreakConcat.end() && varBreak_key2 == varForBreakConcat.end()) {
+ xorFlag = mk_internal_xor_var();
+ varForBreakConcat[key1][0] = xorFlag;
+ } else if (varBreak_key1 != varForBreakConcat.end()) {
+ xorFlag = varForBreakConcat[key1][0];
+ } else { // varBreak_key2 != varForBreakConcat.end()
+ xorFlag = varForBreakConcat[key2][0];
+ }
+
+ int concatStrLen = const_str.length();
+ int xor_pos = 0;
+ int and_count = 1;
+ expr * xor_items[] = new expr*[concatStrLen + 1];
+ expr * and_items[] = new expr*[4 * (concatStrLen+1) + 1];
+
+ expr_ref arg1_eq(m);
+ expr_ref arg2_eq(m);
+
+ for (int i = 0; i < concatStrLen + 1; ++i) {
+ std::string prefixStr = const_str.substr(0, i);
+ std::string suffixStr = const_str.substr(i, concatStrLen - i);
+ // skip invalid options
+ // TODO canConcatEqStr() checks:
+ /*
+ if (isConcatFunc(t, arg1) && canConcatEqStr(t, arg1, prefixStr) == 0) {
+ continue;
+ }
+ if (isConcatFunc(t, arg2) && canConcatEqStr(t, arg2, suffixStr) == 0) {
+ continue;
+ }
+ */
+ expr_ref xorAst(ctx.mk_eq_atom(xorFlag, mk_int(xor_pos)), m);
+ xor_items[xor_pos++] = xorAst;
+
+ expr_ref prefixAst(m_strutil.mk_string(prefixStr), m);
+ arg1_eq = ctx.mk_eq_atom(arg1, prefixAst);
+ and_items[and_count++] = ctx.mk_eq_atom(xorAst, arg1_eq);
+
+ expr_ref suffixAst(m_strutil.mk_string(prefixStr), m);
+ arg2_eq = ctx.mk_eq_atom(arg2, suffixAst);
+ and_items[and_count++] = ctx.mk_eq_atom(xorAst, arg2_eq);
+ }
+
+ expr_ref implyL(ctx.mk_eq_atom(concat, str), m);
+ expr_ref implyR(m);
+ if (xor_pos == 0) {
+ // negate
+ expr_ref concat_eq_str(ctx.mk_eq_atom(concat, str), m);
+ expr_ref negate_ast(m.mk_not(concat_eq_str), m);
+ assert_axiom(negate_ast);
+ } else {
+ // TODO
+ if (xor_pos == 1) {
+
+ } else {
+
+ }
+ }
+ delete[] xor_items;
+ delete[] and_items;
+
+ /*
+
+ Z3_ast implyL = Z3_mk_eq(ctx, concatAst, constStr);
+ Z3_ast implyR1 = NULL;
+ if (xor_pos == 0) {
+ // negate
+ Z3_ast negateAst = Z3_mk_not(ctx, Z3_mk_eq(ctx, concatAst, constStr));
+ addAxiom(t, negateAst, __LINE__);
+ } else {
+ if (xor_pos == 1) {
+ and_items[0] = xor_items[0];
+ implyR1 = Z3_mk_and(ctx, and_count, and_items);
+ } else {
+ and_items[0] = Z3_mk_or(ctx, xor_pos, xor_items);
+ implyR1 = Z3_mk_and(ctx, and_count, and_items);
+ }
+ Z3_ast implyToAssert = Z3_mk_implies(ctx, implyL, implyR1);
+ addAxiom(t, implyToAssert, __LINE__);
+ }
+ delete[] xor_items;
+ delete[] and_items;
+ */
+ }
+ }
}
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 4839b417b..ea6ec8551 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -57,6 +57,9 @@ namespace smt {
ptr_vector<enode> m_basicstr_axiom_todo;
svector<std::pair<enode*,enode*> > m_str_eq_todo;
+
+ int tmpXorVarCount;
+ std::map<std::pair<expr*, expr*>, std::map<int, expr*> > varForBreakConcat;
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
@@ -64,6 +67,8 @@ namespace smt {
app * mk_strlen(app * e);
app * mk_concat(app * e1, app * e2);
+ app * mk_internal_xor_var();
+
bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
bool is_string(app const * a) const { return a->is_app_of(get_id(), OP_STR); }
From 2320b6dc48106a2ccbb8748781b7820d62304e5e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 29 Sep 2015 17:46:51 -0400
Subject: [PATCH 032/401] solve_concat_eq_str() case 4: somewhat working
something's wrong but it may be very simple to fix
---
src/ast/str_decl_plugin.h | 8 +--
src/smt/theory_str.cpp | 120 +++++++-------------------------------
2 files changed, 26 insertions(+), 102 deletions(-)
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index f84c1ec31..61d1bc2f2 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -38,13 +38,13 @@ protected:
symbol m_strv_sym;
sort * m_str_decl;
- arith_decl_plugin * m_arith_plugin;
- sort * m_int_sort;
- family_id m_arith_fid;
-
func_decl * m_concat_decl;
func_decl * m_length_decl;
+ arith_decl_plugin * m_arith_plugin;
+ family_id m_arith_fid;
+ sort * m_int_sort;
+
std::map<std::string, app*> string_cache;
virtual void set_manager(ast_manager * m, family_id id);
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 458786110..e2896f4f5 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -37,7 +37,7 @@ theory_str::~theory_str() {
void theory_str::assert_axiom(expr * e) {
if (get_manager().is_true(e)) return;
- TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << "\n";);
+ TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
context & ctx = get_context();
if (!ctx.b_internalized(e)) {
ctx.internalize(e, true);
@@ -45,11 +45,12 @@ void theory_str::assert_axiom(expr * e) {
literal lit(ctx.get_literal(e));
ctx.mark_as_relevant(lit);
ctx.mk_th_axiom(get_id(), 1, &lit);
- TRACE("t_str_detail", tout << "done asserting " << mk_ismt2_pp(e, get_manager()) << "\n";);
+ TRACE("t_str_detail", tout << "done asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
}
void theory_str::assert_implication(expr * premise, expr * conclusion) {
ast_manager & m = get_manager();
+ TRACE("t_str_detail", tout << "asserting implication " << mk_ismt2_pp(premise, m) << " -> " << mk_ismt2_pp(conclusion, m) << std::endl;);
expr_ref axiom(m.mk_or(m.mk_not(premise), conclusion), m);
assert_axiom(axiom);
}
@@ -100,15 +101,6 @@ bool theory_str::internalize_term(app * term) {
return true;
}
-Z3_ast mk_internal_xor_var(Z3_theory t) {
- Z3_context ctx = Z3_theory_get_context(t);
- std::stringstream ss;
- ss << tmpXorVarCount;
- tmpXorVarCount++;
- std::string name = "$$_xor_" + ss.str();
- return mk_int_var(ctx, name.c_str());
-}
-
app * theory_str::mk_internal_xor_var() {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -118,7 +110,9 @@ app * theory_str::mk_internal_xor_var() {
std::string name = "$$_xor_" + ss.str();
// Z3_sort r = of_sort(mk_c(c)->m().mk_sort(mk_c(c)->get_arith_fid(), INT_SORT));
sort * int_sort = m.mk_sort(m_autil.get_family_id(), INT_SORT);
- symbol sym(name);
+ char * new_buffer = alloc_svect(char, name.length() + 1);
+ strcpy(new_buffer, name.c_str());
+ symbol sym(new_buffer);
app* a = m.mk_const(m.mk_const_decl(sym, int_sort));
// TODO ctx.save_ast_trail(a)?
@@ -585,53 +579,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
int arg2Len = -1; /* = getLenValue(arg2); */
if (arg1Len != -1 || arg2Len != -1) {
NOT_IMPLEMENTED_YET(); // TODO
- } else {
- /*
- Z3_ast xorFlag = NULL;
- std::pair<Z3_ast, Z3_ast> key1(arg1, arg2);
- std::pair<Z3_ast, Z3_ast> key2(arg2, arg1);
- if (varForBreakConcat.find(key1) == varForBreakConcat.end() && varForBreakConcat.find(key2) == varForBreakConcat.end()) {
- xorFlag = mk_internal_xor_var(t);
- varForBreakConcat[key1][0] = xorFlag;
- } else {
- if (varForBreakConcat.find(key1) != varForBreakConcat.end()) {
- xorFlag = varForBreakConcat[key1][0];
- } else {
- xorFlag = varForBreakConcat[key2][0];
- }
- }
-
- int concatStrLen = const_str.length();
- int xor_pos = 0;
- int and_count = 1;
- Z3_ast * xor_items = new Z3_ast[concatStrLen + 1];
- Z3_ast * and_items = new Z3_ast[4 * (concatStrLen + 1) + 1];
- Z3_ast arg1_eq = NULL;
- Z3_ast arg2_eq = NULL;
- for (int i = 0; i < concatStrLen + 1; i++) {
- std::string prefixStr = const_str.substr(0, i);
- std::string suffixStr = const_str.substr(i, concatStrLen - i);
-
- // skip invalidate options
- if (isConcatFunc(t, arg1) && canConcatEqStr(t, arg1, prefixStr) == 0) {
- continue;
- }
- if (isConcatFunc(t, arg2) && canConcatEqStr(t, arg2, suffixStr) == 0) {
- continue;
- }
-
- Z3_ast xorAst = Z3_mk_eq(ctx, xorFlag, mk_int(ctx, xor_pos));
- xor_items[xor_pos++] = xorAst;
-
- Z3_ast prefixAst = my_mk_str_value(t, prefixStr.c_str());
- arg1_eq = Z3_mk_eq(ctx, arg1, prefixAst);
- and_items[and_count++] = Z3_mk_eq(ctx, xorAst, arg1_eq);
-
- Z3_ast suffixAst = my_mk_str_value(t, suffixStr.c_str());
- arg2_eq = Z3_mk_eq(ctx, arg2, suffixAst);
- and_items[and_count++] = Z3_mk_eq(ctx, xorAst, arg2_eq);
- }
- */
+ } else { /* ! (arg1Len != 1 || arg2Len != 1) */
expr_ref xorFlag(m);
std::pair<expr*, expr*> key1(arg1, arg2);
std::pair<expr*, expr*> key2(arg2, arg1);
@@ -651,11 +599,8 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
int concatStrLen = const_str.length();
int xor_pos = 0;
int and_count = 1;
- expr * xor_items[] = new expr*[concatStrLen + 1];
- expr * and_items[] = new expr*[4 * (concatStrLen+1) + 1];
-
- expr_ref arg1_eq(m);
- expr_ref arg2_eq(m);
+ expr ** xor_items = new expr*[concatStrLen + 1];
+ expr ** and_items = new expr*[4 * (concatStrLen+1) + 1];
for (int i = 0; i < concatStrLen + 1; ++i) {
std::string prefixStr = const_str.substr(0, i);
@@ -670,60 +615,39 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
continue;
}
*/
- expr_ref xorAst(ctx.mk_eq_atom(xorFlag, mk_int(xor_pos)), m);
+ expr_ref xorAst(ctx.mk_eq_atom(xorFlag, m_autil.mk_numeral(rational(xor_pos), true)), m);
xor_items[xor_pos++] = xorAst;
expr_ref prefixAst(m_strutil.mk_string(prefixStr), m);
- arg1_eq = ctx.mk_eq_atom(arg1, prefixAst);
+ expr_ref arg1_eq (ctx.mk_eq_atom(arg1, prefixAst), m);
and_items[and_count++] = ctx.mk_eq_atom(xorAst, arg1_eq);
expr_ref suffixAst(m_strutil.mk_string(prefixStr), m);
- arg2_eq = ctx.mk_eq_atom(arg2, suffixAst);
+ expr_ref arg2_eq (ctx.mk_eq_atom(arg2, suffixAst), m);
and_items[and_count++] = ctx.mk_eq_atom(xorAst, arg2_eq);
}
expr_ref implyL(ctx.mk_eq_atom(concat, str), m);
- expr_ref implyR(m);
+ expr_ref implyR1(m);
if (xor_pos == 0) {
// negate
expr_ref concat_eq_str(ctx.mk_eq_atom(concat, str), m);
expr_ref negate_ast(m.mk_not(concat_eq_str), m);
assert_axiom(negate_ast);
} else {
- // TODO
if (xor_pos == 1) {
-
+ and_items[0] = xor_items[0];
+ implyR1 = m.mk_and(and_count, and_items);
} else {
-
+ and_items[0] = m.mk_or(xor_pos, xor_items);
+ implyR1 = m.mk_and(and_count, and_items);
}
+ assert_implication(implyL, implyR1);
}
delete[] xor_items;
delete[] and_items;
-
- /*
-
- Z3_ast implyL = Z3_mk_eq(ctx, concatAst, constStr);
- Z3_ast implyR1 = NULL;
- if (xor_pos == 0) {
- // negate
- Z3_ast negateAst = Z3_mk_not(ctx, Z3_mk_eq(ctx, concatAst, constStr));
- addAxiom(t, negateAst, __LINE__);
- } else {
- if (xor_pos == 1) {
- and_items[0] = xor_items[0];
- implyR1 = Z3_mk_and(ctx, and_count, and_items);
- } else {
- and_items[0] = Z3_mk_or(ctx, xor_pos, xor_items);
- implyR1 = Z3_mk_and(ctx, and_count, and_items);
- }
- Z3_ast implyToAssert = Z3_mk_implies(ctx, implyL, implyR1);
- addAxiom(t, implyToAssert, __LINE__);
- }
- delete[] xor_items;
- delete[] and_items;
- */
- }
- }
+ } /* (arg1Len != 1 || arg2Len != 1) */
+ } /* if (Concat(arg1, arg2) == NULL) */
}
}
}
@@ -945,7 +869,7 @@ void theory_str::new_diseq_eh(theory_var x, theory_var y) {
}
void theory_str::relevant_eh(app * n) {
- TRACE("t_str", tout << "relevant: " << mk_ismt2_pp(n, get_manager()) << "\n";);
+ TRACE("t_str", tout << "relevant: " << mk_ismt2_pp(n, get_manager()) << std::endl;);
}
void theory_str::assign_eh(bool_var v, bool is_true) {
@@ -988,7 +912,7 @@ void theory_str::init_model(model_generator & mg) {
model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
TRACE("t_str", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), get_manager()) <<
- " (sort " << mk_ismt2_pp(get_manager().get_sort(n->get_owner()), get_manager()) << ")\n";);
+ " (sort " << mk_ismt2_pp(get_manager().get_sort(n->get_owner()), get_manager()) << ")" << std::endl;);
ast_manager & m = get_manager();
context & ctx = get_context();
app_ref owner(m);
From 191c50b529310cae9f39463d371eb92b896560d5 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 29 Sep 2015 17:52:19 -0400
Subject: [PATCH 033/401] fix solve_concat_eq_str() case 4: prefixStr should
have been suffixStr
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index e2896f4f5..f9fb7e3a4 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -622,7 +622,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
expr_ref arg1_eq (ctx.mk_eq_atom(arg1, prefixAst), m);
and_items[and_count++] = ctx.mk_eq_atom(xorAst, arg1_eq);
- expr_ref suffixAst(m_strutil.mk_string(prefixStr), m);
+ expr_ref suffixAst(m_strutil.mk_string(suffixStr), m);
expr_ref arg2_eq (ctx.mk_eq_atom(arg2, suffixAst), m);
and_items[and_count++] = ctx.mk_eq_atom(xorAst, arg2_eq);
}
From 8ed86d2f19a074dd68d10ca5832a4cfa18351cbb Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 29 Sep 2015 18:02:05 -0400
Subject: [PATCH 034/401] add concatenation axiom
---
src/smt/theory_str.cpp | 16 ++++++++++++++--
src/smt/theory_str.h | 1 +
2 files changed, 15 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f9fb7e3a4..ea7b84d62 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -142,7 +142,7 @@ app * theory_str::mk_concat(app * e1, app * e2) {
}
bool theory_str::can_propagate() {
- return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty();
+ return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty();
}
void theory_str::propagate() {
@@ -160,6 +160,11 @@ void theory_str::propagate() {
handle_equality(lhs->get_owner(), rhs->get_owner());
}
m_str_eq_todo.reset();
+
+ for (unsigned i = 0; i < m_concat_axiom_todo.empty(); ++i) {
+ instantiate_concat_axiom(m_concat_axiom_todo[i]);
+ }
+ m_concat_axiom_todo.reset();
}
}
@@ -167,7 +172,6 @@ void theory_str::propagate() {
* Instantiate an axiom of the following form:
* Length(Concat(x, y)) = Length(x) + Length(y)
*/
-// TODO this isn't used yet
void theory_str::instantiate_concat_axiom(enode * cat) {
SASSERT(is_concat(cat));
app * a_cat = cat->get_owner();
@@ -321,6 +325,7 @@ void theory_str::reset_eh() {
TRACE("t_str", tout << "resetting" << std::endl;);
m_basicstr_axiom_todo.reset();
m_str_eq_todo.reset();
+ m_concat_axiom_todo.reset();
pop_scope_eh(0);
}
@@ -767,6 +772,8 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
}
}
+ // TODO simplify_parent over eqc
+
// TODO regex unroll? (much later)
}
@@ -785,6 +792,11 @@ void theory_str::set_up_axioms(expr * ex) {
enode * n = ctx.get_enode(ex);
SASSERT(n);
m_basicstr_axiom_todo.push_back(n);
+
+ // if additionally ex is a concatenation, set up concatenation axioms
+ if (is_app(ex) && is_concat(to_app(ex))) {
+ m_concat_axiom_todo.push_back(n);
+ }
} else {
TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
": expr is of wrong sort, ignoring" << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index ea6ec8551..458287392 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -57,6 +57,7 @@ namespace smt {
ptr_vector<enode> m_basicstr_axiom_todo;
svector<std::pair<enode*,enode*> > m_str_eq_todo;
+ ptr_vector<enode> m_concat_axiom_todo;
int tmpXorVarCount;
std::map<std::pair<expr*, expr*>, std::map<int, expr*> > varForBreakConcat;
From 1cdfe159b8d23a458a5b97c8c76325c86e2fe366 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 29 Sep 2015 20:19:43 -0400
Subject: [PATCH 035/401] simplify_concat_equality() and easy cases there still
WIP especially wrt. model generation but what's here does work
---
src/ast/str_decl_plugin.cpp | 2 +-
src/smt/theory_str.cpp | 392 +++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 12 +-
3 files changed, 401 insertions(+), 5 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 9398dbf34..c72a5dbc2 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -102,7 +102,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters,
app * str_decl_plugin::mk_string(std::string & val) {
std::map<std::string, app*>::iterator it = string_cache.find(val);
if (it == string_cache.end()) {
- char * new_buffer = alloc_svect(char, val.length() + 1);
+ char * new_buffer = alloc_svect(char, (val.length() + 1));
strcpy(new_buffer, val.c_str());
parameter p[1] = {parameter(new_buffer)};
func_decl * d;
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ea7b84d62..92edbc22b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -119,7 +119,7 @@ app * theory_str::mk_internal_xor_var() {
return a;
}
-app * theory_str::mk_strlen(app * e) {
+app * theory_str::mk_strlen(expr * e) {
/*if (m_strutil.is_string(e)) {*/ if (false) {
const char * strval = 0;
m_strutil.is_string(e, &strval);
@@ -378,9 +378,258 @@ void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::se
} while (eqcNode != nNode);
}
-void theory_str::simplify_concat_equality(expr * lhs, expr * rhs) {
- // TODO strArgmt::simplifyConcatEq()
+void theory_str::get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList) {
+ app * a_node = to_app(node);
+ if (!is_concat(a_node)) {
+ nodeList.push_back(node);
+ return;
+ } else {
+ SASSERT(a_node->get_num_args() == 2);
+ expr * leftArg = a_node->get_arg(0);
+ expr * rightArg = a_node->get_arg(1);
+ get_nodes_in_concat(leftArg, nodeList);
+ get_nodes_in_concat(rightArg, nodeList);
+ }
}
+
+/*
+ * The inputs:
+ * ~ nn: non const node
+ * ~ eq_str: the equivalent constant string of nn
+ * Iterate the parent of all eqc nodes of nn, looking for:
+ * ~ concat node
+ * to see whether some concat nodes can be simplified.
+ */
+
+void theory_str::simplify_parent(expr * nn, expr * eq_str) {
+ // TODO strTheory::simplifyParent()
+}
+
+expr * theory_str::simplify_concat(expr * node) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ std::map<expr*, expr*> resolvedMap;
+ ptr_vector<expr> argVec;
+ get_nodes_in_concat(node, argVec);
+
+ for (unsigned i = 0; i < argVec.size(); ++i) {
+ bool vArgHasEqcValue = false;
+ expr * vArg = get_eqc_value(argVec[i], vArgHasEqcValue);
+ if (vArg != argVec[i]) {
+ resolvedMap[argVec[i]] = vArg;
+ }
+ }
+
+ if (resolvedMap.size() == 0) {
+ // no simplification possible
+ return node;
+ } else {
+ app * resultAst = m_strutil.mk_string("");
+ for (unsigned i = 0; i < argVec.size(); ++i) {
+ bool vArgHasEqcValue = false;
+ expr * vArg = get_eqc_value(argVec[i], vArgHasEqcValue);
+ resultAst = mk_concat(to_app(resultAst), to_app(vArg));
+ }
+ TRACE("t_str_detail", tout << mk_ismt2_pp(node, m) << " is simplified to " << mk_ismt2_pp(resultAst, m) << std::endl;);
+
+ if (in_same_eqc(node, resultAst)) {
+ TRACE("t_str_detail", tout << "SKIP: both concats are already in the same equivalence class" << std::endl;);
+ } else {
+ expr ** items = alloc_svect(expr*, resolvedMap.size());
+ int pos = 0;
+ std::map<expr*, expr*>::iterator itor = resolvedMap.begin();
+ for (; itor != resolvedMap.end(); ++itor) {
+ items[pos++] = ctx.mk_eq_atom(itor->first, itor->second);
+ }
+ expr_ref premise(m);
+ if (pos == 1) {
+ premise = items[0];
+ } else {
+ premise = m.mk_and(pos, items);
+ }
+ expr_ref conclusion(ctx.mk_eq_atom(node, resultAst), m);
+ assert_implication(premise, conclusion);
+ }
+ return resultAst;
+ }
+
+}
+
+/*
+ * Handle two equivalent Concats.
+ */
+void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ app * a_nn1 = to_app(nn1);
+ SASSERT(a_nn1->get_num_args() == 2);
+ app * a_nn2 = to_app(nn2);
+ SASSERT(a_nn2->get_num_args() == 2);
+
+ expr * a1_arg0 = a_nn1->get_arg(0);
+ expr * a1_arg1 = a_nn1->get_arg(1);
+ expr * a2_arg0 = a_nn2->get_arg(0);
+ expr * a2_arg1 = a_nn2->get_arg(1);
+
+ // TODO
+ /*
+ int a1_arg0_len = getLenValue(t, a1_arg0);
+ int a1_arg1_len = getLenValue(t, a1_arg1);
+ int a2_arg0_len = getLenValue(t, a2_arg0);
+ int a2_arg1_len = getLenValue(t, a2_arg1);
+ */
+ int a1_arg0_len = -1;
+ int a1_arg1_len = -1;
+ int a2_arg0_len = -1;
+ int a2_arg1_len = -1;
+
+ TRACE("t_str", tout << "nn1 = " << mk_ismt2_pp(nn1, m) << std::endl
+ << "nn2 = " << mk_ismt2_pp(nn2, m) << std::endl;);
+
+ // TODO inferLenConcatEq(nn1, nn2);
+
+ if (a1_arg0 == a2_arg0) {
+ if (!in_same_eqc(a1_arg1, a2_arg1)) {
+ expr_ref premise(ctx.mk_eq_atom(nn1, nn2), m);
+ expr_ref eq1(ctx.mk_eq_atom(a1_arg1, a2_arg1), m);
+ expr_ref eq2(ctx.mk_eq_atom(mk_strlen(a1_arg1), mk_strlen(a2_arg1)), m);
+ expr_ref conclusion(m.mk_and(eq1, eq2), m);
+ assert_implication(premise, conclusion);
+ }
+ TRACE("t_str_detail", tout << "SKIP: a1_arg0 == a2_arg0" << std::endl;);
+ return;
+ }
+
+ if (a1_arg1 == a2_arg1) {
+ if (!in_same_eqc(a1_arg0, a2_arg0)) {
+ expr_ref premise(ctx.mk_eq_atom(nn1, nn2), m);
+ expr_ref eq1(ctx.mk_eq_atom(a1_arg0, a2_arg0), m);
+ expr_ref eq2(ctx.mk_eq_atom(mk_strlen(a1_arg0), mk_strlen(a2_arg0)), m);
+ expr_ref conclusion(m.mk_and(eq1, eq2), m);
+ assert_implication(premise, conclusion);
+ }
+ TRACE("t_str_detail", tout << "SKIP: a1_arg1 == a2_arg1" << std::endl;);
+ return;
+ }
+
+ // quick path
+
+ if (in_same_eqc(a1_arg0, a2_arg0)) {
+ if (in_same_eqc(a1_arg1, a2_arg1)) {
+ TRACE("t_str_detail", tout << "SKIP: a1_arg0 =~ a2_arg0 and a1_arg1 =~ a2_arg1" << std::endl;);
+ return;
+ } else {
+ TRACE("t_str_detail", tout << "quick path 1-1: a1_arg0 =~ a2_arg0" << std::endl;);
+ expr_ref premise(m.mk_and(ctx.mk_eq_atom(nn1, nn2), ctx.mk_eq_atom(a1_arg0, a2_arg0)), m);
+ expr_ref conclusion(m.mk_and(ctx.mk_eq_atom(a1_arg1, a2_arg1), ctx.mk_eq_atom(mk_strlen(a1_arg1), mk_strlen(a2_arg1))), m);
+ assert_implication(premise, conclusion);
+ return;
+ }
+ } else {
+ if (in_same_eqc(a1_arg1, a2_arg1)) {
+ TRACE("t_str_detail", tout << "quick path 1-2: a1_arg1 =~ a2_arg1" << std::endl;);
+ expr_ref premise(m.mk_and(ctx.mk_eq_atom(nn1, nn2), ctx.mk_eq_atom(a1_arg1, a2_arg1)), m);
+ expr_ref conclusion(m.mk_and(ctx.mk_eq_atom(a1_arg0, a2_arg0), ctx.mk_eq_atom(mk_strlen(a1_arg0), mk_strlen(a2_arg0))), m);
+ assert_implication(premise, conclusion);
+ return;
+ }
+ }
+
+ // TODO quick path 1-2
+ /*
+ if(a1_arg0_len != -1 && a2_arg0_len != -1 && a1_arg0_len == a2_arg0_len){
+ if (! inSameEqc(t, a1_arg0, a2_arg0)) {
+ __debugPrint(logFile, ">> [simplifyConcatEq] Quick Path 2-1: len(nn1.arg0) == len(nn2.arg0)\n");
+ Z3_ast ax_l1 = Z3_mk_eq(ctx, nn1, nn2);
+ Z3_ast ax_l2 = Z3_mk_eq(ctx, mk_length(t, a1_arg0), mk_length(t, a2_arg0));
+ Z3_ast ax_r1 = Z3_mk_eq(ctx, a1_arg0, a2_arg0);
+ Z3_ast ax_r2 = Z3_mk_eq(ctx, a1_arg1, a2_arg1);
+ Z3_ast toAdd = Z3_mk_implies(ctx, mk_2_and(t, ax_l1, ax_l2), mk_2_and(t, ax_r1, ax_r2));
+ addAxiom(t, toAdd, __LINE__);
+ return;
+ }
+ }
+
+ if (a1_arg1_len != -1 && a2_arg1_len != -1 && a1_arg1_len == a2_arg1_len)
+ {
+ if (!inSameEqc(t, a1_arg1, a2_arg1)) {
+ __debugPrint(logFile, ">> [simplifyConcatEq] Quick Path 2-2: len(nn1.arg1) == len(nn2.arg1)\n");
+ Z3_ast ax_l1 = Z3_mk_eq(ctx, nn1, nn2);
+ Z3_ast ax_l2 = Z3_mk_eq(ctx, mk_length(t, a1_arg1), mk_length(t, a2_arg1));
+ Z3_ast ax_r1 = Z3_mk_eq(ctx, a1_arg0, a2_arg0);
+ Z3_ast ax_r2 = Z3_mk_eq(ctx, a1_arg1, a2_arg1);
+ Z3_ast toAdd = Z3_mk_implies(ctx, mk_2_and(t, ax_l1, ax_l2), mk_2_and(t, ax_r1, ax_r2));
+ addAxiom(t, toAdd, __LINE__);
+ return;
+ }
+ }
+ */
+
+ expr * new_nn1 = simplify_concat(nn1);
+ expr * new_nn2 = simplify_concat(nn2);
+ app * a_new_nn1 = to_app(new_nn1);
+ app * a_new_nn2 = to_app(new_nn2);
+ expr * v1_arg0 = a_new_nn1->get_arg(0);
+ expr * v1_arg1 = a_new_nn1->get_arg(1);
+ expr * v2_arg0 = a_new_nn2->get_arg(0);
+ expr * v2_arg1 = a_new_nn2->get_arg(1);
+
+ TRACE("t_str_detail", tout << "new_nn1 = " << mk_ismt2_pp(new_nn1, m) << std::endl
+ << "new_nn2 = " << mk_ismt2_pp(new_nn2, m) << std::endl;);
+
+ if (new_nn1 == new_nn2) {
+ TRACE("t_str_detail", tout << "equal concats, return" << std::endl;);
+ return;
+ }
+
+ if (!can_two_nodes_eq(new_nn1, new_nn2)) {
+ expr_ref detected(m.mk_not(ctx.mk_eq_atom(new_nn1, new_nn2)), m);
+ TRACE("t_str_detail", tout << "inconsistency detected: " << mk_ismt2_pp(detected, m) << std::endl;);
+ assert_axiom(detected);
+ return;
+ }
+
+ // check whether new_nn1 and new_nn2 are still concats
+
+ bool n1IsConcat = is_concat(a_new_nn1);
+ bool n2IsConcat = is_concat(a_new_nn2);
+ if (!n1IsConcat && n2IsConcat) {
+ TRACE("t_str_detail", tout << "nn1_new is not a concat" << std::endl;);
+ if (is_string(a_new_nn1)) {
+ simplify_parent(new_nn2, new_nn1);
+ }
+ return;
+ } else if (n1IsConcat && !n2IsConcat) {
+ TRACE("t_str_detail", tout << "nn2_new is not a concat" << std::endl;);
+ if (is_string(a_new_nn2)) {
+ simplify_parent(new_nn1, new_nn2);
+ }
+ return;
+ }
+
+ if (!in_same_eqc(new_nn1, new_nn2) && (nn1 != new_nn1 || nn2 != new_nn2)) {
+ int ii4 = 0;
+ expr* item[3];
+ if (nn1 != new_nn1) {
+ item[ii4++] = ctx.mk_eq_atom(nn1, new_nn1);
+ }
+ if (nn2 != new_nn2) {
+ item[ii4++] = ctx.mk_eq_atom(nn2, new_nn2);
+ }
+ item[ii4++] = ctx.mk_eq_atom(nn1, nn2);
+ expr_ref premise(m.mk_and(ii4, item), m);
+ expr_ref conclusion(ctx.mk_eq_atom(new_nn1, new_nn2), m);
+ assert_implication(premise, conclusion);
+ }
+
+ // start to split both concats
+
+ // TODO
+ NOT_IMPLEMENTED_YET();
+
+}
+
/*
* Look through the equivalence class of n to find a string constant.
* Return that constant if it is found, and set hasEqcValue to true.
@@ -403,6 +652,119 @@ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
return n;
}
+/*
+ * Decide whether n1 and n2 are already in the same equivalence class.
+ * This only checks whether the core considers them to be equal;
+ * they may not actually be equal.
+ */
+bool theory_str::in_same_eqc(expr * n1, expr * n2) {
+ if (n1 == n2) return true;
+ context & ctx = get_context();
+ enode * n1Node = ctx.get_enode(n1);
+ enode * n2Node = ctx.get_enode(n2);
+
+ // here's what the old Z3str2 would have done; we can do something much better
+ /*
+ n1Node->get_root();
+ enode * curr = n1Node->get_next();
+ while (curr != n1Node) {
+ if (curr == n2Node) {
+ return true;
+ }
+ curr = curr->get_next();
+ }
+ return false;
+ */
+ return n1Node->get_root() == n2Node->get_root();
+}
+
+/*
+bool canTwoNodesEq(Z3_theory t, Z3_ast n1, Z3_ast n2) {
+ Z3_ast n1_curr = n1;
+ Z3_ast n2_curr = n2;
+
+ // case 0: n1_curr is const string, n2_curr is const string
+ if (isConstStr(t, n1_curr) && isConstStr(t, n2_curr)) {
+ if (n1_curr != n2_curr) {
+ return false;
+ }
+ }
+ // case 1: n1_curr is concat, n2_curr is const string
+ else if (isConcatFunc(t, n1_curr) && isConstStr(t, n2_curr)) {
+ std::string n2_curr_str = getConstStrValue(t, n2_curr);
+ if (canConcatEqStr(t, n1_curr, n2_curr_str) != 1) {
+ return false;
+ }
+ }
+ // case 2: n2_curr is concat, n1_curr is const string
+ else if (isConcatFunc(t, n2_curr) && isConstStr(t, n1_curr)) {
+ std::string n1_curr_str = getConstStrValue(t, n1_curr);
+ if (canConcatEqStr(t, n2_curr, n1_curr_str) != 1) {
+ return false;
+ }
+ } else if (isConcatFunc(t, n1_curr) && isConcatFunc(t, n2_curr)) {
+ if (canConcatEqConcat(t, n1_curr, n2_curr) != 1) {
+ return false;
+ }
+ }
+
+ return true;
+}
+*/
+
+bool theory_str::can_concat_eq_str(expr * concat, std::string str) {
+ // TODO
+ return true;
+}
+
+bool theory_str::can_concat_eq_concat(expr * concat1, expr * concat2) {
+ // TODO
+ return true;
+}
+
+/*
+ * Check whether n1 and n2 could be equal.
+ * Returns true if n1 could equal n2 (maybe),
+ * and false if n1 is definitely not equal to n2 (no).
+ */
+bool theory_str::can_two_nodes_eq(expr * n1, expr * n2) {
+ app * n1_curr = to_app(n1);
+ app * n2_curr = to_app(n2);
+
+ // case 0: n1_curr is const string, n2_curr is const string
+ if (is_string(n1_curr) && is_string(n2_curr)) {
+ if (n1_curr != n2_curr) {
+ return false;
+ }
+ }
+ // case 1: n1_curr is concat, n2_curr is const string
+ else if (is_concat(n1_curr) && is_string(n2_curr)) {
+ const char * tmp = 0;
+ m_strutil.is_string(n2_curr, & tmp);
+ std::string n2_curr_str(tmp);
+ if (!can_concat_eq_str(n1_curr, n2_curr_str)) {
+ return false;
+ }
+ }
+ // case 2: n2_curr is concat, n1_curr is const string
+ else if (is_concat(n2_curr) && is_string(n1_curr)) {
+ const char * tmp = 0;
+ m_strutil.is_string(n1_curr, & tmp);
+ std::string n1_curr_str(tmp);
+ if (!can_concat_eq_str(n2_curr, n1_curr_str)) {
+ return false;
+ }
+ }
+ // case 3: both are concats
+ else if (is_concat(n1_curr) && is_concat(n2_curr)) {
+ if (!can_concat_eq_concat(n1_curr, n2_curr)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
/*
* strArgmt::solve_concat_eq_str()
* Solve concatenations of the form:
@@ -604,8 +966,12 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
int concatStrLen = const_str.length();
int xor_pos = 0;
int and_count = 1;
+ /*
expr ** xor_items = new expr*[concatStrLen + 1];
expr ** and_items = new expr*[4 * (concatStrLen+1) + 1];
+ */
+ expr ** xor_items = alloc_svect(expr*, (concatStrLen+1));
+ expr ** and_items = alloc_svect(expr*, (4 * (concatStrLen+1) + 1));
for (int i = 0; i < concatStrLen + 1; ++i) {
std::string prefixStr = const_str.substr(0, i);
@@ -736,6 +1102,11 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
);
// step 1: Concat == Concat
+ // I'm disabling this entire code block for now. It may no longer be useful.
+ // Z3 seems to be putting LHS and RHS into the same equivalence class extremely early.
+ // As a result, simplify_concat_equality() is never getting called,
+ // and if it were called, it would probably get called with the same element on both sides.
+ /*
bool hasCommon = false;
if (eqc_lhs_concat.size() != 0 && eqc_rhs_concat.size() != 0) {
std::set<expr*>::iterator itor1 = eqc_lhs_concat.begin();
@@ -756,6 +1127,21 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
simplify_concat_equality(*(eqc_lhs_concat.begin()), *(eqc_rhs_concat.begin()));
}
}
+ */
+ if (eqc_lhs_concat.size() != 0 && eqc_rhs_concat.size() != 0) {
+ // let's pick the first concat in the LHS's eqc
+ // and find some concat in the RHS's eqc that is
+ // distinct from the first one we picked
+ expr * lhs = *eqc_lhs_concat.begin();
+ std::set<expr*>::iterator itor2 = eqc_rhs_concat.begin();
+ for (; itor2 != eqc_rhs_concat.end(); ++itor2) {
+ expr * rhs = *itor2;
+ if (lhs != rhs) {
+ simplify_concat_equality(lhs, rhs);
+ break;
+ }
+ }
+ }
// step 2: Concat == Constant
if (eqc_lhs_const.size() != 0) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 458287392..c3641016f 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -65,7 +65,7 @@ namespace smt {
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
- app * mk_strlen(app * e);
+ app * mk_strlen(expr * e);
app * mk_concat(app * e1, app * e2);
app * mk_internal_xor_var();
@@ -82,6 +82,16 @@ namespace smt {
void handle_equality(expr * lhs, expr * rhs);
expr * get_eqc_value(expr * n, bool & hasEqcValue);
+ bool in_same_eqc(expr * n1, expr * n2);
+
+ bool can_two_nodes_eq(expr * n1, expr * n2);
+ bool can_concat_eq_str(expr * concat, std::string str);
+ bool can_concat_eq_concat(expr * concat1, expr * concat2);
+
+ void get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList);
+ expr * simplify_concat(expr * node);
+
+ void simplify_parent(expr * nn, expr * eq_str);
void simplify_concat_equality(expr * lhs, expr * rhs);
void solve_concat_eq_str(expr * concat, expr * str);
From a62d15403e434fe5358523b52cfc1442bad11917 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 29 Sep 2015 22:31:11 -0400
Subject: [PATCH 036/401] start simplify_concat_eq(), WIP but some cases OK
also fix model generation for concats and nested concats
---
src/smt/theory_str.cpp | 116 +++++++++++++++++++++++++++++++++++++----
src/smt/theory_str.h | 4 +-
2 files changed, 108 insertions(+), 12 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 92edbc22b..3f8de3d6f 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -131,14 +131,60 @@ app * theory_str::mk_strlen(expr * e) {
}
}
-app * theory_str::mk_concat(app * e1, app * e2) {
+/*
+ * Returns the simplified concatenation of two expressions,
+ * where either both expressions are constant strings
+ * or one expression is the empty string.
+ * If this precondition does not hold, the function returns NULL.
+ * (note: this function was strTheory::Concat())
+ */
+expr * theory_str::mk_concat_const_str(expr * n1, expr * n2) {
+ bool n1HasEqcValue = false;
+ bool n2HasEqcValue = false;
+ expr * v1 = get_eqc_value(n1, n1HasEqcValue);
+ expr * v2 = get_eqc_value(n2, n2HasEqcValue);
+ if (n1HasEqcValue && n2HasEqcValue) {
+ const char * n1_str_tmp;
+ m_strutil.is_string(v1, & n1_str_tmp);
+ std::string n1_str(n1_str_tmp);
+ const char * n2_str_tmp;
+ m_strutil.is_string(v2, & n2_str_tmp);
+ std::string n2_str(n2_str_tmp);
+ std::string result = n1_str + n2_str;
+ return m_strutil.mk_string(result);
+ } else if (n1HasEqcValue && !n2HasEqcValue) {
+ const char * n1_str_tmp;
+ m_strutil.is_string(v1, & n1_str_tmp);
+ if (strcmp(n1_str_tmp, "") == 0) {
+ return n2;
+ }
+ } else if (!n1HasEqcValue && n2HasEqcValue) {
+ const char * n2_str_tmp;
+ m_strutil.is_string(v2, & n2_str_tmp);
+ if (strcmp(n2_str_tmp, "") == 0) {
+ return n1;
+ }
+ }
+ return NULL;
+}
+
+expr * theory_str::mk_concat(expr * n1, expr * n2) {
ast_manager & m = get_manager();
- if (e1 == NULL || e2 == NULL) {
+ if (n1 == NULL || n2 == NULL) {
m.raise_exception("strings to be concatenated cannot be NULL");
}
- // TODO there's a *TON* of missing code here from strTheory::mk_concat()
- expr * args[2] = {e1, e2};
- return get_manager().mk_app(get_id(), OP_STRCAT, 0, 0, 2, args);
+ bool n1HasEqcValue = false;
+ bool n2HasEqcValue = false;
+ n1 = get_eqc_value(n1, n1HasEqcValue);
+ n2 = get_eqc_value(n2, n2HasEqcValue);
+ if (n1HasEqcValue && n2HasEqcValue) {
+ return mk_concat_const_str(n1, n2);
+ } else {
+ // TODO there's a *TON* of missing code here from strTheory::mk_concat()
+ // if all else fails, just build the application AST
+ expr * args[2] = {n1, n2};
+ return get_manager().mk_app(get_id(), OP_STRCAT, 0, 0, 2, args);
+ }
}
bool theory_str::can_propagate() {
@@ -424,11 +470,11 @@ expr * theory_str::simplify_concat(expr * node) {
// no simplification possible
return node;
} else {
- app * resultAst = m_strutil.mk_string("");
+ expr * resultAst = m_strutil.mk_string("");
for (unsigned i = 0; i < argVec.size(); ++i) {
bool vArgHasEqcValue = false;
expr * vArg = get_eqc_value(argVec[i], vArgHasEqcValue);
- resultAst = mk_concat(to_app(resultAst), to_app(vArg));
+ resultAst = mk_concat(resultAst, vArg);
}
TRACE("t_str_detail", tout << mk_ismt2_pp(node, m) << " is simplified to " << mk_ismt2_pp(resultAst, m) << std::endl;);
@@ -821,7 +867,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
} else {
implyL1 = m.mk_and(item1[0], item1[1]);
}
- newConcat = mk_concat(to_app(arg1), to_app(arg2));
+ newConcat = mk_concat(arg1, arg2);
if (newConcat != str) {
expr_ref implyR1(ctx.mk_eq_atom(concat, newConcat), m);
assert_implication(implyL1, implyR1);
@@ -1308,6 +1354,52 @@ void theory_str::init_model(model_generator & mg) {
mg.register_factory(m_factory);
}
+/*
+ * Helper function for mk_value().
+ * Attempts to resolve the expression 'n' to a string constant.
+ * Stronger than get_eqc_value() in that it will perform recursive descent
+ * through every subexpression and attempt to resolve those to concrete values as well.
+ * Returns the concrete value obtained from this process,
+ * guaranteed to satisfy m_strutil.is_string(),
+ * if one could be obtained,
+ * or else returns NULL if no concrete value was derived.
+ */
+app * theory_str::mk_value_helper(app * n) {
+ if (m_strutil.is_string(n)) {
+ return n;
+ } else if (is_concat(n)) {
+ // recursively call this function on each argument
+ SASSERT(n->get_num_args() == 2);
+ expr * a0 = n->get_arg(0);
+ expr * a1 = n->get_arg(1);
+
+ app * a0_conststr = mk_value_helper(to_app(a0));
+ app * a1_conststr = mk_value_helper(to_app(a1));
+
+ if (a0_conststr != NULL && a1_conststr != NULL) {
+ const char * a0_str = 0;
+ m_strutil.is_string(a0_conststr, &a0_str);
+
+ const char * a1_str = 0;
+ m_strutil.is_string(a1_conststr, &a1_str);
+
+ std::string a0_s(a0_str);
+ std::string a1_s(a1_str);
+ std::string result = a0_s + a1_s;
+ return m_strutil.mk_string(result);
+ }
+ }
+ // fallback path
+ // try to find some constant string, anything, in the equivalence class of n
+ bool hasEqc = false;
+ expr * n_eqc = get_eqc_value(n, hasEqc);
+ if (hasEqc) {
+ return to_app(n_eqc);
+ } else {
+ return NULL;
+ }
+}
+
model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
TRACE("t_str", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), get_manager()) <<
" (sort " << mk_ismt2_pp(get_manager().get_sort(n->get_owner()), get_manager()) << ")" << std::endl;);
@@ -1319,10 +1411,12 @@ model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
// If the owner is not internalized, it doesn't have an enode associated.
SASSERT(ctx.e_internalized(owner));
- if (m_strutil.is_string(owner)) {
- return alloc(expr_wrapper_proc, owner);
+ app * val = mk_value_helper(owner);
+ if (val != NULL) {
+ return alloc(expr_wrapper_proc, val);
+ } else {
+ m.raise_exception("failed to find concrete value"); return NULL;
}
- NOT_IMPLEMENTED_YET(); // TODO
}
void theory_str::finalize_model(model_generator & mg) {}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index c3641016f..daa5656bb 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -66,7 +66,8 @@ namespace smt {
void assert_implication(expr * premise, expr * conclusion);
app * mk_strlen(expr * e);
- app * mk_concat(app * e1, app * e2);
+ expr * mk_concat(expr * n1, expr * n2);
+ expr * mk_concat_const_str(expr * n1, expr * n2);
app * mk_internal_xor_var();
@@ -81,6 +82,7 @@ namespace smt {
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
+ app * mk_value_helper(app * n);
expr * get_eqc_value(expr * n, bool & hasEqcValue);
bool in_same_eqc(expr * n1, expr * n2);
From ed7b343822e2829f63c9eb2378b454b333d01d18 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 30 Sep 2015 05:15:14 -0400
Subject: [PATCH 037/401] detect and process concat eq type 1 (WIP UNTESTED)
---
src/smt/theory_str.cpp | 462 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 37 +++-
2 files changed, 495 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3f8de3d6f..fc4548f7a 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -28,7 +28,10 @@ theory_str::theory_str(ast_manager & m):
search_started(false),
m_autil(m),
m_strutil(m),
- tmpXorVarCount(0)
+ tmpStringVarCount(0),
+ tmpXorVarCount(0),
+ avoidLoopCut(true),
+ loopDetected(false)
{
}
@@ -101,6 +104,122 @@ bool theory_str::internalize_term(app * term) {
return true;
}
+static void cut_vars_map_copy(std::map<expr*, int> & dest, std::map<expr*, int> & src) {
+ std::map<expr*, int>::iterator itor = src.begin();
+ for (; itor != src.end(); itor++) {
+ dest[itor->first] = 1;
+ }
+}
+
+/*
+bool hasSelfCut(Z3_ast n1, Z3_ast n2) {
+ if (cut_VARMap.find(n1) == cut_VARMap.end())
+ return false;
+
+ if (cut_VARMap.find(n2) == cut_VARMap.end())
+ return false;
+
+ if (cut_VARMap[n1].empty() || cut_VARMap[n2].empty())
+ return false;
+
+ std::map<Z3_ast, int>::iterator itor = cut_VARMap[n1].top()->vars.begin();
+ for (; itor != cut_VARMap[n1].top()->vars.end(); itor++) {
+ if (cut_VARMap[n2].top()->vars.find(itor->first) != cut_VARMap[n2].top()->vars.end())
+ return true;
+ }
+ return false;
+}
+*/
+
+bool theory_str::has_self_cut(expr * n1, expr * n2) {
+ if (cut_var_map.find(n1) == cut_var_map.end()) {
+ return false;
+ }
+ if (cut_var_map.find(n2) == cut_var_map.end()) {
+ return false;
+ }
+ if (cut_var_map[n1].empty() || cut_var_map[n2].empty()) {
+ return false;
+ }
+
+ std::map<expr*, int>::iterator itor = cut_var_map[n1].top()->vars.begin();
+ for (; itor != cut_var_map[n1].top()->vars.end(); ++itor) {
+ if (cut_var_map[n2].top()->vars.find(itor->first) != cut_var_map[n2].top()->vars.end()) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node) {
+ if (cut_var_map.find(baseNode) == cut_var_map.end()) {
+ T_cut * varInfo = alloc(T_cut);
+ varInfo->level = slevel;
+ varInfo->vars[node] = 1;
+ cut_var_map[baseNode].push(varInfo);
+ } else {
+ if (cut_var_map[baseNode].empty()) {
+ T_cut * varInfo = alloc(T_cut);
+ varInfo->level = slevel;
+ varInfo->vars[node] = 1;
+ cut_var_map[baseNode].push(varInfo);
+ } else {
+ if (cut_var_map[baseNode].top()->level < slevel) {
+ T_cut * varInfo = alloc(T_cut);
+ varInfo->level = slevel;
+ cut_vars_map_copy(varInfo->vars, cut_var_map[baseNode].top()->vars);
+ varInfo->vars[node] = 1;
+ cut_var_map[baseNode].push(varInfo);
+ } else if (cut_var_map[baseNode].top()->level == slevel) {
+ cut_var_map[baseNode].top()->vars[node] = 1;
+ } else {
+ get_manager().raise_exception("entered illegal state during add_cut_info_one_node()");
+ }
+ }
+ }
+}
+
+void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode) {
+ if (cut_var_map.find(srcNode) == cut_var_map.end()) {
+ get_manager().raise_exception("illegal state in add_cut_info_merge(): cut_var_map doesn't contain srcNode");
+ }
+
+ if (cut_var_map[srcNode].empty()) {
+ get_manager().raise_exception("illegal state in add_cut_info_merge(): cut_var_map[srcNode] is empty");
+ }
+
+ if (cut_var_map.find(destNode) == cut_var_map.end()) {
+ T_cut * varInfo = alloc(T_cut);
+ varInfo->level = slevel;
+ cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
+ cut_var_map[destNode].push(varInfo);
+ } else {
+ if (cut_var_map[destNode].empty() || cut_var_map[destNode].top()->level < slevel) {
+ T_cut * varInfo = alloc(T_cut);
+ varInfo->level = slevel;
+ cut_vars_map_copy(varInfo->vars, cut_var_map[destNode].top()->vars);
+ cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
+ cut_var_map[destNode].push(varInfo);
+ } else if (cut_var_map[destNode].top()->level == slevel) {
+ cut_vars_map_copy(cut_var_map[destNode].top()->vars, cut_var_map[srcNode].top()->vars);
+ } else {
+ get_manager().raise_exception("illegal state in add_cut_info_merge(): inconsistent slevels");
+ }
+ }
+}
+
+void theory_str::check_and_init_cut_var(expr * node) {
+ if (cut_var_map.find(node) != cut_var_map.end()) {
+ return;
+ } else if (!m_strutil.is_string(node)) {
+ add_cut_info_one_node(node, -1, node);
+ }
+}
+
+app * theory_str::mk_int(int n) {
+ return m_autil.mk_numeral(rational(n), true);
+}
+
app * theory_str::mk_internal_xor_var() {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -119,6 +238,49 @@ app * theory_str::mk_internal_xor_var() {
return a;
}
+/*
+ Z3_context ctx = Z3_theory_get_context(t);
+ PATheoryData * td = (PATheoryData *) Z3_theory_get_ext_data(t);
+ std::stringstream ss;
+ ss << tmpStringVarCount;
+ tmpStringVarCount++;
+ std::string name = "$$_str" + ss.str();
+ Z3_ast varAst = mk_var(ctx, name.c_str(), td->String);
+ nonEmptyStrVarAxiom(t, varAst, __LINE__);
+ return varAst;
+*/
+
+app * theory_str::mk_nonempty_str_var() {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ std::stringstream ss;
+ ss << tmpStringVarCount;
+ tmpStringVarCount++;
+ std::string name = "$$_str" + ss.str();
+ sort * string_sort = m.mk_sort(m_strutil.get_family_id(), STRING_SORT);
+ char * new_buffer = alloc_svect(char, name.length() + 1);
+ strcpy(new_buffer, name.c_str());
+ symbol sym(new_buffer);
+
+ app* a = m.mk_const(m.mk_const_decl(sym, string_sort));
+ // assert a variation of the basic string axioms that ensures this string is nonempty
+ {
+ // build LHS
+ expr_ref len_str(m);
+ len_str = mk_strlen(a);
+ SASSERT(len_str);
+ // build RHS
+ expr_ref zero(m);
+ zero = m_autil.mk_numeral(rational(0), true);
+ SASSERT(zero);
+ // build LHS > RHS and assert
+ app * lhs_gt_rhs = m_autil.mk_gt(len_str, zero);
+ SASSERT(lhs_gt_rhs);
+ assert_axiom(lhs_gt_rhs);
+ }
+ return a;
+}
+
app * theory_str::mk_strlen(expr * e) {
/*if (m_strutil.is_string(e)) {*/ if (false) {
const char * strval = 0;
@@ -372,7 +534,7 @@ void theory_str::reset_eh() {
m_basicstr_axiom_todo.reset();
m_str_eq_todo.reset();
m_concat_axiom_todo.reset();
- pop_scope_eh(0);
+ pop_scope_eh(get_context().get_scope_level());
}
/*
@@ -670,9 +832,289 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
}
// start to split both concats
+ check_and_init_cut_var(v1_arg0);
+ check_and_init_cut_var(v1_arg1);
+ check_and_init_cut_var(v2_arg0);
+ check_and_init_cut_var(v2_arg1);
+ //*************************************************************
+ // case 1: concat(x, y) = concat(m, n)
+ //*************************************************************
+ if (is_concat_eq_type1(new_nn1, new_nn2)) {
+ process_concat_eq_type1(new_nn1, new_nn2);
+ return;
+ }
+
+ //*************************************************************
+ // case 2: concat(x, y) = concat(m, "str")
+ //*************************************************************
+ if (is_concat_eq_type2(new_nn1, new_nn2)) {
+ process_concat_eq_type2(new_nn1, new_nn2);
+ return;
+ }
+
+ //*************************************************************
+ // case 3: concat(x, y) = concat("str", n)
+ //*************************************************************
+ if (is_concat_eq_type3(new_nn1, new_nn2)) {
+ process_concat_eq_type3(new_nn1, new_nn2);
+ return;
+ }
+
+ //*************************************************************
+ // case 4: concat("str1", y) = concat("str2", n)
+ //*************************************************************
+ if (is_concat_eq_type4(new_nn1, new_nn2)) {
+ process_concat_eq_type4(new_nn1, new_nn2);
+ return;
+ }
+
+ //*************************************************************
+ // case 5: concat(x, "str1") = concat(m, "str2")
+ //*************************************************************
+ if (is_concat_eq_type5(new_nn1, new_nn2)) {
+ process_concat_eq_type5(new_nn1, new_nn2);
+ return;
+ }
+ //*************************************************************
+ // case 6: concat("str1", y) = concat(m, "str2")
+ //*************************************************************
+ if (is_concat_eq_type6(new_nn1, new_nn2)) {
+ process_concat_eq_type6(new_nn1, new_nn2);
+ return;
+ }
+
+}
+
+bool theory_str::is_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+ expr * x = to_app(concatAst1)->get_arg(0);
+ expr * y = to_app(concatAst1)->get_arg(1);
+ expr * m = to_app(concatAst2)->get_arg(0);
+ expr * n = to_app(concatAst2)->get_arg(1);
+
+ if (!m_strutil.is_string(x) && !m_strutil.is_string(y) && !m_strutil.is_string(m) && !m_strutil.is_string(n)) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
+void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+ TRACE("t_str_detail", tout << "process_concat_eq TYPE 1" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, m) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, m) << std::endl;
+ );
+
+ if (!is_concat(to_app(concatAst1))) {
+ TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
+ }
+ if (!is_concat(to_app(concatAst2))) {
+ TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
+ }
+ expr * x = to_app(concatAst1)->get_arg(0);
+ expr * y = to_app(concatAst1)->get_arg(1);
+ expr * m = to_app(concatAst2)->get_arg(0);
+ expr * n = to_app(concatAst2)->get_arg(1);
+
+ /* TODO query the integer theory:
+ int x_len = getLenValue(t, x);
+ int y_len = getLenValue(t, y);
+ int m_len = getLenValue(t, m);
+ int n_len = getLenValue(t, n);
+ */
+ int x_len = -1;
+ int y_len = -1;
+ int m_len = -1;
+ int n_len = -1;
+
+ int splitType = -1;
+ if (x_len != -1 && m_len != -1) {
+ if (x_len < m_len)
+ splitType = 0;
+ else if (x_len == m_len)
+ splitType = 1;
+ else
+ splitType = 2;
+ }
+
+ if (splitType == -1 && y_len != -1 && n_len != -1) {
+ if (y_len > n_len)
+ splitType = 0;
+ else if (y_len == n_len)
+ splitType = 1;
+ else
+ splitType = 2;
+ }
+
+ TRACE("t_str_detail", tout << "split type " << splitType << std::endl;);
+
+ expr * t1 = NULL;
+ expr * t2 = NULL;
+ expr * xorFlag = NULL;
+
+ std::pair<expr*, expr*> key1(concatAst1, concatAst2);
+ std::pair<expr*, expr*> key2(concatAst2, concatAst1);
+
+ if (varForBreakConcat.find(key1) == varForBreakConcat.end() && varForBreakConcat.find(key2) == varForBreakConcat.end()) {
+ t1 = mk_nonempty_str_var();
+ t2 = mk_nonempty_str_var();
+ xorFlag = mk_internal_xor_var();
+ check_and_init_cut_var(t1);
+ check_and_init_cut_var(t2);
+ varForBreakConcat[key1][0] = t1;
+ varForBreakConcat[key1][1] = t2;
+ varForBreakConcat[key1][2] = xorFlag;
+ } else {
+ // match found
+ if (varForBreakConcat.find(key1) != varForBreakConcat.end()) {
+ t1 = varForBreakConcat[key1][0];
+ t2 = varForBreakConcat[key1][1];
+ xorFlag = varForBreakConcat[key1][2];
+ } else {
+ t1 = varForBreakConcat[key2][0];
+ t2 = varForBreakConcat[key2][1];
+ xorFlag = varForBreakConcat[key2][2];
+ }
+ }
+
+ // For split types 0 through 2, we can get away with providing
+ // fewer split options since more length information is available.
+ if (splitType == 0) {
+ NOT_IMPLEMENTED_YET(); // TODO
+ } else if (splitType == 1) {
+ NOT_IMPLEMENTED_YET(); // TODO
+ } else if (splitType == 2) {
+ NOT_IMPLEMENTED_YET(); // TODO
+ } else if (splitType == -1) {
+ // Here we don't really have a choice. We have no length information at all...
+ expr ** or_item = alloc_svect(expr*, 3);
+ expr ** and_item = alloc_svect(expr*, 20);
+ int option = 0;
+ int pos = 1;
+
+ // break option 1: m cuts y
+ // len(x) < len(m) || len(y) > len(n)
+ if (!avoidLoopCut || !has_self_cut(m, y)) {
+ // break down option 1-1
+ expr * x_t1 = mk_concat(x, t1);
+ expr * t1_n = mk_concat(t1, n);
+ or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(m, x_t1));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, t1_n));
+
+ expr_ref x_plus_t1(m_autil.mk_add(mk_strlen(x), mk_strlen(t1)), mgr);
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(m), x_plus_t1));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], m_autil.mk_gt(mk_strlen(m), mk_strlen(x)));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], m_autil.mk_gt(mk_strlen(y), mk_strlen(n)));
+
+ option++;
+
+ add_cut_info_merge(t1, ctx.get_scope_level(), m);
+ add_cut_info_merge(t1, ctx.get_scope_level(), y);
+ } else {
+ loopDetected = true;
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ // TODO printCutVar(m, y);
+ }
+
+ // break option 2:
+ // x = m || y = n
+ if (!avoidLoopCut || !has_self_cut(x, n)) {
+ // break down option 1-2
+ expr * m_t2 = mk_concat(m, t2);
+ expr * t2_y = mk_concat(t2, y);
+ or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(x, m_t2));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(n, t2_y));
+
+
+ expr_ref m_plus_t2(m_autil.mk_add(mk_strlen(m), mk_strlen(t2)), mgr);
+
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x), m_plus_t2));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(n), mk_strlen(y)));
+
+
+ option++;
+
+ add_cut_info_merge(t2, sLevel, x);
+ add_cut_info_merge(t2, sLevel, n);
+ } else {
+ loopDetected = true;
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ // TODO printCutVar(x, n);
+ }
+
+ if (can_two_nodes_eq(x, m) && can_two_nodes_eq(y, n)) {
+ or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(x, m));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, n));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n)));
+ ++option;
+ }
+
+ if (option > 0) {
+ if (option == 1) {
+ and_item[0] = or_item[0];
+ } else {
+ and_item[0] = mgr.mk_or(option, or_item);
+ }
+ expr_ref premise(ctx.mk_eq_atom(concatAst1, concatAst2), m);
+ expr_ref conclusion(mgr.mk_and(pos, and_item), m);
+ assert_implication(premise, conclusion);
+ } else {
+ TRACE("t_str", tout << "STOP: no split option found for two EQ concats." << std::endl;);
+ }
+ } // (splitType == -1)
+}
+
+bool theory_str::is_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
// TODO
- NOT_IMPLEMENTED_YET();
+ return false;
+}
+
+void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+
+}
+
+bool theory_str::is_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
+ // TODO
+ return false;
+}
+
+void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+
+}
+
+bool theory_str::is_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
+ // TODO
+ return false;
+}
+
+void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+
+}
+
+bool theory_str::is_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
+ // TODO
+ return false;
+}
+
+void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+
+}
+
+bool theory_str::is_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
+ // TODO
+ return false;
+}
+
+void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
@@ -1327,6 +1769,20 @@ void theory_str::push_scope_eh() {
void theory_str::pop_scope_eh(unsigned num_scopes) {
TRACE("t_str", tout << "pop " << num_scopes << std::endl;);
+ context & ctx = get_context();
+ unsigned sLevel = ctx.get_scope_level();
+ std::map<expr*, std::stack<T_cut *> >::iterator varItor = cut_var_map.begin();
+ while (varItor != cut_var_map.end()) {
+ while ((varItor->second.size() > 0) && (varItor->second.top()->level != 0) && (varItor->second.top()->level >= sLevel)) {
+ T_cut * aCut = varItor->second.top();
+ varItor->second.pop();
+ dealloc(aCut);
+ }
+ if (varItor->second.size() == 0) {
+ cut_var_map.erase(varItor);
+ }
+ ++varItor;
+ }
}
final_check_status theory_str::final_check_eh() {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index daa5656bb..b66eef4ad 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -47,7 +47,15 @@ namespace smt {
};
class theory_str : public theory {
- // TODO
+ struct T_cut
+ {
+ int level;
+ std::map<expr*, int> vars;
+
+ T_cut() {
+ level = -100;
+ }
+ };
protected:
bool search_started;
arith_util m_autil;
@@ -59,8 +67,13 @@ namespace smt {
svector<std::pair<enode*,enode*> > m_str_eq_todo;
ptr_vector<enode> m_concat_axiom_todo;
+ int tmpStringVarCount;
int tmpXorVarCount;
std::map<std::pair<expr*, expr*>, std::map<int, expr*> > varForBreakConcat;
+
+ bool avoidLoopCut = true;
+ bool loopDetected = false;
+ std::map<expr*, std::stack<T_cut *> > cut_var_map;
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
@@ -69,6 +82,14 @@ namespace smt {
expr * mk_concat(expr * n1, expr * n2);
expr * mk_concat_const_str(expr * n1, expr * n2);
+ app * mk_int(int n);
+
+ void check_and_init_cut_var(expr * node);
+ void add_cut_info_one_node(expr * baseNode, int slevel, expr * node);
+ void add_cut_info_merge(expr * destNode, int slevel, expr * srcNode);
+ bool has_self_cut(expr * n1, expr * n2);
+
+ app * mk_nonempty_str_var();
app * mk_internal_xor_var();
bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
@@ -98,6 +119,20 @@ namespace smt {
void simplify_concat_equality(expr * lhs, expr * rhs);
void solve_concat_eq_str(expr * concat, expr * str);
+ bool is_concat_eq_type1(expr * concatAst1, expr * concatAst2);
+ bool is_concat_eq_type2(expr * concatAst1, expr * concatAst2);
+ bool is_concat_eq_type3(expr * concatAst1, expr * concatAst2);
+ bool is_concat_eq_type4(expr * concatAst1, expr * concatAst2);
+ bool is_concat_eq_type5(expr * concatAst1, expr * concatAst2);
+ bool is_concat_eq_type6(expr * concatAst1, expr * concatAst2);
+
+ void process_concat_eq_type1(expr * concatAst1, expr * concatAst2);
+ void process_concat_eq_type2(expr * concatAst1, expr * concatAst2);
+ void process_concat_eq_type3(expr * concatAst1, expr * concatAst2);
+ void process_concat_eq_type4(expr * concatAst1, expr * concatAst2);
+ void process_concat_eq_type5(expr * concatAst1, expr * concatAst2);
+ void process_concat_eq_type6(expr * concatAst1, expr * concatAst2);
+
bool new_eq_check(expr * lhs, expr * rhs);
void group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts);
public:
From e2901fff1ea1394bdba0a892e60d06263ff38db4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 30 Sep 2015 05:21:16 -0400
Subject: [PATCH 038/401] fix compilation errors
---
src/smt/theory_str.cpp | 22 +++++++++++-----------
src/smt/theory_str.h | 5 +++--
2 files changed, 14 insertions(+), 13 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index fc4548f7a..3458ec60c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -903,8 +903,8 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
ast_manager & mgr = get_manager();
context & ctx = get_context();
TRACE("t_str_detail", tout << "process_concat_eq TYPE 1" << std::endl
- << "concatAst1 = " << mk_ismt2_pp(concatAst1, m) << std::endl
- << "concatAst2 = " << mk_ismt2_pp(concatAst2, m) << std::endl;
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
if (!is_concat(to_app(concatAst1))) {
@@ -1041,8 +1041,8 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
option++;
- add_cut_info_merge(t2, sLevel, x);
- add_cut_info_merge(t2, sLevel, n);
+ add_cut_info_merge(t2, ctx.get_scope_level(), x);
+ add_cut_info_merge(t2, ctx.get_scope_level(), n);
} else {
loopDetected = true;
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
@@ -1064,8 +1064,8 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
} else {
and_item[0] = mgr.mk_or(option, or_item);
}
- expr_ref premise(ctx.mk_eq_atom(concatAst1, concatAst2), m);
- expr_ref conclusion(mgr.mk_and(pos, and_item), m);
+ expr_ref premise(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref conclusion(mgr.mk_and(pos, and_item), mgr);
assert_implication(premise, conclusion);
} else {
TRACE("t_str", tout << "STOP: no split option found for two EQ concats." << std::endl;);
@@ -1078,7 +1078,7 @@ bool theory_str::is_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
return false;
}
-void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
}
@@ -1087,7 +1087,7 @@ bool theory_str::is_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
return false;
}
-void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
}
@@ -1096,7 +1096,7 @@ bool theory_str::is_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
return false;
}
-void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
}
@@ -1105,7 +1105,7 @@ bool theory_str::is_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
return false;
}
-void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
}
@@ -1114,7 +1114,7 @@ bool theory_str::is_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
return false;
}
-void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index b66eef4ad..5d0ec96db 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -24,6 +24,7 @@ Revision History:
#include"smt_model_generator.h"
#include"arith_decl_plugin.h"
#include<set>
+#include<stack>
namespace smt {
@@ -71,8 +72,8 @@ namespace smt {
int tmpXorVarCount;
std::map<std::pair<expr*, expr*>, std::map<int, expr*> > varForBreakConcat;
- bool avoidLoopCut = true;
- bool loopDetected = false;
+ bool avoidLoopCut;
+ bool loopDetected;
std::map<expr*, std::stack<T_cut *> > cut_var_map;
protected:
void assert_axiom(expr * e);
From ecb2116927eecd15ff2898cb03b42ffe77cfc8e9 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 30 Sep 2015 05:23:22 -0400
Subject: [PATCH 039/401] fix memory corruption bug caused by invalid use of
delete[]
---
src/smt/theory_str.cpp | 2 --
1 file changed, 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3458ec60c..071f07619 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1503,8 +1503,6 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
}
assert_implication(implyL, implyR1);
}
- delete[] xor_items;
- delete[] and_items;
} /* (arg1Len != 1 || arg2Len != 1) */
} /* if (Concat(arg1, arg2) == NULL) */
}
From 5189c24d42c1fa8648bee09f2548e127d05ef294 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 30 Sep 2015 05:45:16 -0400
Subject: [PATCH 040/401] fix theory of arithmetic complaints about wanting to
write A > B "what could possibly go wrong?"
---
src/smt/theory_str.cpp | 17 ++++++++++++++---
1 file changed, 14 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 071f07619..440aaeb9f 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -274,7 +274,8 @@ app * theory_str::mk_nonempty_str_var() {
zero = m_autil.mk_numeral(rational(0), true);
SASSERT(zero);
// build LHS > RHS and assert
- app * lhs_gt_rhs = m_autil.mk_gt(len_str, zero);
+ // we have to build !(LHS <= RHS) instead
+ app * lhs_gt_rhs = m.mk_not(m_autil.mk_le(len_str, zero));
SASSERT(lhs_gt_rhs);
assert_axiom(lhs_gt_rhs);
}
@@ -1008,8 +1009,18 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr_ref x_plus_t1(m_autil.mk_add(mk_strlen(x), mk_strlen(t1)), mgr);
and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(m), x_plus_t1));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], m_autil.mk_gt(mk_strlen(m), mk_strlen(x)));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], m_autil.mk_gt(mk_strlen(y), mk_strlen(n)));
+ // TODO these are crashing the solvers because the integer theory
+ // expects a constant on the right-hand side.
+ // The things we want to assert here are len(m) > len(x) and len(y) > len(n).
+ // We rewrite A > B as A-B > 0 and then as not(A-B <= 0),
+ // and then, *because we aren't allowed to use subtraction*,
+ // as not(A + -1*B <= 0)
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option],
+ mgr.mk_not(m_autil.mk_le(m_autil.mk_add(mk_strlen(m),
+ m_autil.mk_mul(mk_int(-1), mk_strlen(x))), mk_int(0))) );
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option],
+ mgr.mk_not(m_autil.mk_le(m_autil.mk_add(mk_strlen(y),
+ m_autil.mk_mul(mk_int(-1), mk_strlen(n))), mk_int(0))) );
option++;
From f8c13792a355f5af3505c77e6f9cf883794910ad Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 30 Sep 2015 09:45:00 -0400
Subject: [PATCH 041/401] mark the position of the bug I found so I can recall
it later in process_concat_eq_type1() line 1048
---
src/smt/theory_str.cpp | 35 +++++++++++++++++++++++------------
src/smt/theory_str.h | 2 ++
2 files changed, 25 insertions(+), 12 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 440aaeb9f..aad15bec8 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1045,6 +1045,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr_ref m_plus_t2(m_autil.mk_add(mk_strlen(m), mk_strlen(t2)), mgr);
+ // TODO here is the bug: these EQs should be GTs
and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x), m_plus_t2));
and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)));
and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(n), mk_strlen(y)));
@@ -1724,6 +1725,7 @@ void theory_str::init_search_eh() {
* This is done to find equalities between terms, etc. that we otherwise
* might not get a chance to see.
*/
+ /*
expr_ref_vector assignments(m);
ctx.get_assignments(assignments);
for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
@@ -1745,6 +1747,7 @@ void theory_str::init_search_eh() {
<< ": expr ignored" << std::endl;);
}
}
+ */
TRACE("t_str", tout << "search started" << std::endl;);
search_started = true;
@@ -1755,12 +1758,16 @@ void theory_str::new_eq_eh(theory_var x, theory_var y) {
TRACE("t_str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
handle_equality(get_enode(x)->get_owner(), get_enode(y)->get_owner());
+
+ TRACE("t_str_detail", dump_assignments(););
}
void theory_str::new_diseq_eh(theory_var x, theory_var y) {
//TRACE("t_str_detail", tout << "new diseq: v#" << x << " != v#" << y << std::endl;);
TRACE("t_str", tout << "new diseq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
+
+ TRACE("t_str_detail", dump_assignments(););
}
void theory_str::relevant_eh(app * n) {
@@ -1779,7 +1786,7 @@ void theory_str::push_scope_eh() {
void theory_str::pop_scope_eh(unsigned num_scopes) {
TRACE("t_str", tout << "pop " << num_scopes << std::endl;);
context & ctx = get_context();
- unsigned sLevel = ctx.get_scope_level();
+ int sLevel = ctx.get_scope_level();
std::map<expr*, std::stack<T_cut *> >::iterator varItor = cut_var_map.begin();
while (varItor != cut_var_map.end()) {
while ((varItor->second.size() > 0) && (varItor->second.top()->level != 0) && (varItor->second.top()->level >= sLevel)) {
@@ -1794,21 +1801,25 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
}
}
+void theory_str::dump_assignments() {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ TRACE("t_str_detail",
+ tout << "dumping all assignments:" << std::endl;
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+ for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
+ expr * ex = *i;
+ tout << mk_ismt2_pp(ex, m) << std::endl;
+ }
+ );
+}
+
final_check_status theory_str::final_check_eh() {
- ast_manager & m = get_manager();
- context & ctx = get_context();
// TODO
TRACE("t_str", tout << "final check" << std::endl;);
- TRACE("t_str_detail",
- tout << "dumping all assignments:" << std::endl;
- expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
- for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
- expr * ex = *i;
- tout << mk_ismt2_pp(ex, m) << std::endl;
- }
- );
+ TRACE("t_str_detail", dump_assignments(););
return FC_DONE;
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 5d0ec96db..930c8e9c8 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -136,6 +136,8 @@ namespace smt {
bool new_eq_check(expr * lhs, expr * rhs);
void group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts);
+
+ void dump_assignments();
public:
theory_str(ast_manager & m);
virtual ~theory_str();
From fb5f3cbc136651a0c4113f7a857d84d3aad13dba Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 30 Sep 2015 11:41:55 -0400
Subject: [PATCH 042/401] fix greater-than bug now we just have to tweak model
gen for internal variables
---
src/smt/theory_str.cpp | 26 +++++++++++++++++---------
1 file changed, 17 insertions(+), 9 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index aad15bec8..7514f8a23 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1016,11 +1016,13 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
// and then, *because we aren't allowed to use subtraction*,
// as not(A + -1*B <= 0)
and_item[pos++] = ctx.mk_eq_atom(or_item[option],
- mgr.mk_not(m_autil.mk_le(m_autil.mk_add(mk_strlen(m),
- m_autil.mk_mul(mk_int(-1), mk_strlen(x))), mk_int(0))) );
+ mgr.mk_not(m_autil.mk_le(
+ m_autil.mk_add(mk_strlen(m), m_autil.mk_mul(mk_int(-1), mk_strlen(x))),
+ mk_int(0))) );
and_item[pos++] = ctx.mk_eq_atom(or_item[option],
- mgr.mk_not(m_autil.mk_le(m_autil.mk_add(mk_strlen(y),
- m_autil.mk_mul(mk_int(-1), mk_strlen(n))), mk_int(0))) );
+ mgr.mk_not(m_autil.mk_le(
+ m_autil.mk_add(mk_strlen(y),m_autil.mk_mul(mk_int(-1), mk_strlen(n))),
+ mk_int(0))) );
option++;
@@ -1045,10 +1047,16 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr_ref m_plus_t2(m_autil.mk_add(mk_strlen(m), mk_strlen(t2)), mgr);
- // TODO here is the bug: these EQs should be GTs
and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x), m_plus_t2));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(n), mk_strlen(y)));
+ // want len(x) > len(m) and len(n) > len(y)
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option],
+ mgr.mk_not(m_autil.mk_le(
+ m_autil.mk_add(mk_strlen(x), m_autil.mk_mul(mk_int(-1), mk_strlen(m))),
+ mk_int(0))) );
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option],
+ mgr.mk_not(m_autil.mk_le(
+ m_autil.mk_add(mk_strlen(n), m_autil.mk_mul(mk_int(-1), mk_strlen(y))),
+ mk_int(0))) );
option++;
@@ -1759,7 +1767,7 @@ void theory_str::new_eq_eh(theory_var x, theory_var y) {
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
handle_equality(get_enode(x)->get_owner(), get_enode(y)->get_owner());
- TRACE("t_str_detail", dump_assignments(););
+ TRACE("t_str_dump_assign", dump_assignments(););
}
void theory_str::new_diseq_eh(theory_var x, theory_var y) {
@@ -1767,7 +1775,7 @@ void theory_str::new_diseq_eh(theory_var x, theory_var y) {
TRACE("t_str", tout << "new diseq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
- TRACE("t_str_detail", dump_assignments(););
+ TRACE("t_str_dump_assign", dump_assignments(););
}
void theory_str::relevant_eh(app * n) {
From bdf755156cd761c1247d83cbb034306455b45a28 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 1 Oct 2015 20:31:40 -0400
Subject: [PATCH 043/401] fix model generation: don't build interpretations for
Length()
---
src/ast/str_decl_plugin.cpp | 16 +++++++++-
src/ast/str_decl_plugin.h | 4 +++
src/smt/theory_str.cpp | 60 ++++++++++++++++++++++++++++++++-----
src/smt/theory_str.h | 9 +++++-
4 files changed, 80 insertions(+), 9 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index c72a5dbc2..5589db56c 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -64,7 +64,7 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
MK_OP(m_concat_decl, "Concat", OP_STRCAT, s);
- m_length_decl = m->mk_func_decl(symbol("Length"), s, i); m_manager->inc_ref(m_length_decl);
+ m_length_decl = m->mk_func_decl(symbol("Length"), s, i, func_decl_info(id, OP_STRLEN)); m_manager->inc_ref(m_length_decl);
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -120,6 +120,20 @@ app * str_decl_plugin::mk_string(const char * val) {
return mk_string(key);
}
+app * str_decl_plugin::mk_fresh_string() {
+ // cheating.
+ // take the longest string in the cache, append the letter "A", and call it fresh.
+ std::string longestString = "";
+ std::map<std::string, app*>::iterator it = string_cache.begin();
+ for (; it != string_cache.end(); ++it) {
+ if (it->first.length() > longestString.length()) {
+ longestString = it->first;
+ }
+ }
+ longestString += "A";
+ return mk_string(longestString);
+}
+
void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol const & logic) {
op_names.push_back(builtin_name("Concat", OP_STRCAT));
op_names.push_back(builtin_name("Length", OP_STRLEN));
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 61d1bc2f2..f1978ab8b 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -62,6 +62,7 @@ public:
app * mk_string(const char * val);
app * mk_string(std::string & val);
+ app * mk_fresh_string();
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
@@ -97,6 +98,9 @@ public:
app * mk_string(std::string & val) {
return m_plugin->mk_string(val);
}
+ app * mk_fresh_string() {
+ return m_plugin->mk_fresh_string();
+ }
// TODO
};
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 7514f8a23..221f472d2 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -279,6 +279,11 @@ app * theory_str::mk_nonempty_str_var() {
SASSERT(lhs_gt_rhs);
assert_axiom(lhs_gt_rhs);
}
+
+ // add 'a' to variable sets, so we can keep track of it
+ variable_set.insert(a);
+ internal_variable_set.insert(a);
+
return a;
}
@@ -1685,9 +1690,17 @@ void theory_str::set_up_axioms(expr * ex) {
SASSERT(n);
m_basicstr_axiom_todo.push_back(n);
- // if additionally ex is a concatenation, set up concatenation axioms
- if (is_app(ex) && is_concat(to_app(ex))) {
- m_concat_axiom_todo.push_back(n);
+
+ if (is_app(ex)) {
+ app * ap = to_app(ex);
+ if (is_concat(ap)) {
+ // if ex is a concat, set up concat axioms later
+ m_concat_axiom_todo.push_back(n);
+ } else if (ap->get_num_args() == 0 && !is_string(ap)) {
+ // if ex is a variable, add it to our list of variables
+ TRACE("t_str_detail", tout << "tracking variable" << std::endl;);
+ variable_set.insert(ex);
+ }
}
} else {
TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
@@ -1824,12 +1837,41 @@ void theory_str::dump_assignments() {
}
final_check_status theory_str::final_check_eh() {
- // TODO
- TRACE("t_str", tout << "final check" << std::endl;);
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ TRACE("t_str", tout << "final check" << std::endl;);
TRACE("t_str_detail", dump_assignments(););
- return FC_DONE;
+ // Check every variable to see if it's eq. to some string constant.
+ // If not, mark it as free.
+ bool needToAssignFreeVars = false;
+ std::set<expr*> free_variables;
+ for (std::set<expr*>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
+ bool has_eqc_value = false;
+ get_eqc_value(*it, has_eqc_value);
+ if (!has_eqc_value) {
+ needToAssignFreeVars = true;
+ free_variables.insert(*it);
+ }
+ }
+
+ if (!needToAssignFreeVars) {
+ TRACE("t_str", tout << "All variables are assigned. Done!" << std::endl;);
+ return FC_DONE;
+ }
+
+ for (std::set<expr*>::iterator it = free_variables.begin(); it != free_variables.end(); ++it) {
+ expr * var = *it;
+ if (internal_variable_set.find(var) != internal_variable_set.end()) {
+ TRACE("t_str", tout << "assigning arbitrary string to internal variable " << mk_ismt2_pp(var, m) << std::endl;);
+ app * val = m_strutil.mk_string("**unused**");
+ assert_axiom(ctx.mk_eq_atom(var, val));
+ } else {
+ NOT_IMPLEMENTED_YET(); // TODO free variable assignment from strTheory::cb_final_check()
+ }
+ }
+ return FC_CONTINUE;
}
void theory_str::init_model(model_generator & mg) {
@@ -1899,7 +1941,11 @@ model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
if (val != NULL) {
return alloc(expr_wrapper_proc, val);
} else {
- m.raise_exception("failed to find concrete value"); return NULL;
+ TRACE("t_str", tout << "WARNING: failed to find a concrete value, falling back" << std::endl;);
+ // TODO make absolutely sure the reason we can't find a concrete value is because of an unassigned temporary
+ // e.g. for an expression like (Concat X $$_str0)
+ //return alloc(expr_wrapper_proc, m_strutil.mk_string(""));
+ NOT_IMPLEMENTED_YET();
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 930c8e9c8..1c2e2fbee 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -43,7 +43,11 @@ namespace smt {
v2 = m_util.mk_string("value 2");
return true;
}
- virtual expr * get_fresh_value(sort * s) { NOT_IMPLEMENTED_YET(); }
+ virtual expr * get_fresh_value(sort * s) {
+ // TODO this may be causing crashes in model gen? investigate
+ //return m_util.mk_fresh_string();
+ NOT_IMPLEMENTED_YET();
+ }
virtual void register_value(expr * n) { /* Ignore */ }
};
@@ -75,6 +79,9 @@ namespace smt {
bool avoidLoopCut;
bool loopDetected;
std::map<expr*, std::stack<T_cut *> > cut_var_map;
+
+ std::set<expr*> variable_set;
+ std::set<expr*> internal_variable_set;
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
From 96d99dfb3888852cd1cb4521fb3513f7b9c7a817 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 2 Oct 2015 14:05:17 -0400
Subject: [PATCH 044/401] process_concat_eq_type2 implementation, not tested
WIP
---
src/smt/theory_str.cpp | 184 ++++++++++++++++++++++++++++++++++++++++-
1 file changed, 182 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 221f472d2..a6bdc4944 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1098,13 +1098,193 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
} // (splitType == -1)
}
+/*************************************************************
+ * Type 2: concat(x, y) = concat(m, "str")
+ *************************************************************/
bool theory_str::is_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
- // TODO
- return false;
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ if ((!m_strutil.is_string(v1_arg0)) && m_strutil.is_string(v1_arg1)
+ && (!m_strutil.is_string(v2_arg0)) && (!m_strutil.is_string(v2_arg1))) {
+ return true;
+ } else if ((!m_strutil.is_string(v2_arg0)) && m_strutil.is_string(v2_arg1)
+ && (!m_strutil.is_string(v1_arg0)) && (!m_strutil.is_string(v1_arg1))) {
+ return true;
+ } else {
+ return false;
+ }
}
void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+ TRACE("t_str_detail", tout << "process_concat_eq TYPE 2" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
+ );
+ if (!is_concat(to_app(concatAst1))) {
+ TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
+ }
+ if (!is_concat(to_app(concatAst2))) {
+ TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
+ }
+
+ expr * x = NULL;
+ expr * y = NULL;
+ expr * strAst = NULL;
+ expr * m = NULL;
+
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ if (m_strutil.is_string(v1_arg1) && !m_strutil.is_string(v2_arg1)) {
+ m = v1_arg0;
+ strAst = v1_arg1;
+ x = v2_arg0;
+ y = v2_arg1;
+ } else {
+ m = v2_arg0;
+ strAst = v2_arg1;
+ x = v1_arg0;
+ y = v1_arg1;
+ }
+
+ const char * strValue_tmp = 0;
+ m_strutil.is_string(strAst, &strValue_tmp);
+ std::string strValue(strValue_tmp);
+ // TODO integer theory interaction
+ /*
+ int x_len = getLenValue(t, x);
+ int y_len = getLenValue(t, y);
+ int m_len = getLenValue(t, m);
+ int str_len = getLenValue(t, strAst);
+ */
+
+ int x_len = -1;
+ int y_len = -1;
+ int m_len = -1;
+ int str_len = -1;
+
+ // setup
+
+ expr * xorFlag = NULL;
+ expr * temp1 = NULL;
+ std::pair<expr*, expr*> key1(concatAst1, concatAst2);
+ std::pair<expr*, expr*> key2(concatAst2, concatAst1);
+
+ if (varForBreakConcat.find(key1) == varForBreakConcat.end()
+ && varForBreakConcat.find(key2) == varForBreakConcat.end()) {
+ temp1 = mk_nonempty_str_var();
+ xorFlag = mk_internal_xor_var();
+ varForBreakConcat[key1][0] = temp1;
+ varForBreakConcat[key1][1] = xorFlag;
+ } else {
+ if (varForBreakConcat.find(key1) != varForBreakConcat.end()) {
+ temp1 = varForBreakConcat[key1][0];
+ xorFlag = varForBreakConcat[key1][1];
+ } else if (varForBreakConcat.find(key2) != varForBreakConcat.end()) {
+ temp1 = varForBreakConcat[key2][0];
+ xorFlag = varForBreakConcat[key2][1];
+ }
+ }
+
+ int splitType = -1;
+ if (x_len != -1 && m_len != -1) {
+ if (x_len < m_len)
+ splitType = 0;
+ else if (x_len == m_len)
+ splitType = 1;
+ else
+ splitType = 2;
+ }
+ if (splitType == -1 && y_len != -1 && str_len != -1) {
+ if (y_len > str_len)
+ splitType = 0;
+ else if (y_len == str_len)
+ splitType = 1;
+ else
+ splitType = 2;
+ }
+
+ TRACE("t_str_detail", tout << "Split type " << splitType << std::endl;);
+
+ // Provide fewer split options when length information is available.
+
+ if (splitType == 0) {
+ NOT_IMPLEMENTED_YET(); // TODO
+ } else if (splitType == 1) {
+ NOT_IMPLEMENTED_YET(); // TODO
+ } else if (splitType == 2) {
+ NOT_IMPLEMENTED_YET(); // TODO
+ } else {
+ // Split type -1: no idea about the length...
+ int optionTotal = 2 + strValue.length();
+ expr ** or_item = alloc_svect(expr*, optionTotal);
+ expr ** and_item = alloc_svect(expr*, (1 + 6 + 4 * (strValue.length() + 1)));
+ int option = 0;
+ int pos = 1;
+
+ expr_ref temp1_strAst(mk_concat(temp1, strAst), mgr); // TODO assert concat axioms?
+
+ // m cuts y
+ if (can_two_nodes_eq(y, temp1_strAst)) {
+ if (!avoidLoopCut || !has_self_cut(m, y)) {
+ // break down option 2-1
+ // TODO
+ or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+ expr_ref x_temp1(mk_concat(x, temp1), mgr); // TODO assert concat axioms?
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(m, x_temp1));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, temp1_strAst));
+
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(m),
+ m_autil.mk_add(mk_strlen(x), mk_strlen(temp1))));
+
+ ++option;
+ add_cut_info_merge(temp1, ctx.get_scope_level(), y);
+ add_cut_info_merge(temp1, ctx.get_scope_level(), m);
+ } else {
+ loopDetected = true;
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ // TODO printCutVar(m, y)
+ }
+ }
+
+ for (int i = 0; i <= (int)strValue.size(); ++i) {
+ std::string part1Str = strValue.substr(0, i);
+ std::string part2Str = strValue.substr(i, strValue.size() - i);
+ expr_ref prefixStr(m_strutil.mk_string(part1Str), mgr);
+ expr_ref x_concat(mk_concat(m, prefixStr), mgr); // TODO concat axioms?
+ expr_ref cropStr(m_strutil.mk_string(part2Str), mgr);
+ if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
+ // break down option 2-2
+ or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(x, x_concat));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, cropStr));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(y), mk_int(part2Str.length())));
+ ++option;
+ }
+ }
+
+ if (option > 0) {
+ if (option == 1) {
+ and_item[0] = or_item[0];
+ } else {
+ and_item[0] = mgr.mk_or(option, or_item);
+ }
+ expr_ref implyR(mgr.mk_and(pos, and_item), mgr);
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ } else {
+ TRACE("t_str", tout << "STOP: Should not split two EQ concats." << std::endl;);
+ }
+ } // (splitType == -1)
}
bool theory_str::is_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
From ff4706dd40b3334724d81b385ed2cad1fcc0f8ba Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 3 Oct 2015 12:07:55 -0400
Subject: [PATCH 045/401] process_concat_eq_type3 still wip because i'm just
trying to get these all done
---
src/smt/theory_str.cpp | 199 ++++++++++++++++++++++++++++++++++++++++-
1 file changed, 197 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a6bdc4944..7b555d6bb 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -892,6 +892,10 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
}
+/*************************************************************
+ * Type 1: concat(x, y) = concat(m, n)
+ * x, y, m and n all variables
+ *************************************************************/
bool theory_str::is_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr * x = to_app(concatAst1)->get_arg(0);
expr * y = to_app(concatAst1)->get_arg(1);
@@ -1287,12 +1291,203 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
} // (splitType == -1)
}
+/*************************************************************
+ * Type 3: concat(x, y) = concat("str", n)
+ *************************************************************/
bool theory_str::is_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
- // TODO
- return false;
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ if (m_strutil.is_string(v1_arg0) && (!m_strutil.is_string(v1_arg1))
+ && (!m_strutil.is_string(v2_arg0)) && (!m_strutil.is_string(v2_arg1))) {
+ return true;
+ } else if (m_strutil.is_string(v2_arg0) && (!m_strutil.is_string(v2_arg1))
+ && (!m_strutil.is_string(v1_arg0)) && (!m_strutil.is_string(v1_arg1))) {
+ return true;
+ } else {
+ return false;
+ }
}
void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+ TRACE("t_str_detail", tout << "process_concat_eq TYPE 3" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
+ );
+
+ if (!is_concat(to_app(concatAst1))) {
+ TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
+ }
+ if (!is_concat(to_app(concatAst2))) {
+ TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
+ }
+
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ expr * x = NULL;
+ expr * y = NULL;
+ expr * strAst = NULL;
+ expr * n = NULL;
+
+ if (m_strutil.is_string(v1_arg0) && !m_strutil.is_string(v2_arg0)) {
+ strAst = v1_arg0;
+ n = v1_arg1;
+ x = v2_arg0;
+ y = v2_arg1;
+ } else {
+ strAst = v2_arg0;
+ n = v2_arg1;
+ x = v1_arg0;
+ y = v1_arg1;
+ }
+
+ const char * strValue_tmp = 0;
+ m_strutil.is_string(strAst, &strValue_tmp);
+ std::string strValue(strValue_tmp);
+ // TODO integer theory interaction
+ /*
+ int x_len = getLenValue(t, x);
+ int y_len = getLenValue(t, y);
+ int str_len = getLenValue(t, strAst);
+ int n_len = getLenValue(t, n);
+ */
+ int x_len = -1;
+ int y_len = -1;
+ int str_len = -1;
+ int n_len = -1;
+
+ expr_ref xorFlag(mgr);
+ expr_ref temp1(mgr);
+ std::pair<expr*, expr*> key1(concatAst1, concatAst2);
+ std::pair<expr*, expr*> key2(concatAst2, concatAst1);
+ if (varForBreakConcat.find(key1) == varForBreakConcat.end() && varForBreakConcat.find(key2) == varForBreakConcat.end()) {
+ temp1 = mk_nonempty_str_var();
+ xorFlag = mk_internal_xor_var();
+
+ varForBreakConcat[key1][0] = temp1;
+ varForBreakConcat[key1][1] = xorFlag;
+ } else {
+ if (varForBreakConcat.find(key1) != varForBreakConcat.end()) {
+ temp1 = varForBreakConcat[key1][0];
+ xorFlag = varForBreakConcat[key1][1];
+ } else if (varForBreakConcat.find(key2) != varForBreakConcat.end()) {
+ temp1 = varForBreakConcat[key2][0];
+ xorFlag = varForBreakConcat[key2][1];
+ }
+ }
+
+
+
+ int splitType = -1;
+ if (x_len != -1) {
+ if (x_len < str_len)
+ splitType = 0;
+ else if (x_len == str_len)
+ splitType = 1;
+ else
+ splitType = 2;
+ }
+ if (splitType == -1 && y_len != -1 && n_len != -1) {
+ if (y_len > n_len)
+ splitType = 0;
+ else if (y_len == n_len)
+ splitType = 1;
+ else
+ splitType = 2;
+ }
+
+ TRACE("t_str_detail", tout << "Split type " << splitType << std::endl;);
+
+ // Provide fewer split options when length information is available.
+ if (splitType == 0) {
+ NOT_IMPLEMENTED_YET(); // TODO
+ }
+ else if (splitType == 1) {
+ NOT_IMPLEMENTED_YET(); // TODO
+ }
+ else if (splitType == 2) {
+ NOT_IMPLEMENTED_YET(); // TODO
+ }
+ else {
+ // Split type -1. We know nothing about the length...
+
+ int optionTotal = 2 + strValue.length();
+ expr ** or_item = alloc_svect(expr*, optionTotal);
+ int option = 0;
+ expr ** and_item = alloc_svect(expr*, (2 + 4 * optionTotal));
+ int pos = 1;
+ for (int i = 0; i <= (int) strValue.size(); i++) {
+ std::string part1Str = strValue.substr(0, i);
+ std::string part2Str = strValue.substr(i, strValue.size() - i);
+ expr_ref cropStr(m_strutil.mk_string(part1Str), mgr);
+ expr_ref suffixStr(m_strutil.mk_string(part2Str), mgr);
+ expr_ref y_concat(mk_concat(suffixStr, n), mgr); // TODO concat axioms?
+
+ if (can_two_nodes_eq(x, cropStr) && can_two_nodes_eq(y, y_concat)) {
+ // break down option 3-1
+ expr_ref x_eq_str(ctx.mk_eq_atom(x, cropStr), mgr);
+ or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], x_eq_str);
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, y_concat));
+
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x), mk_strlen(cropStr)));
+ // and_item[pos++] = Z3_mk_eq(ctx, or_item[option], Z3_mk_eq(ctx, mk_length(t, y), mk_length(t, y_concat)));
+
+ // adding length constraint for _ = constStr seems slowing things down.
+ option++;
+ }
+ }
+
+ expr_ref strAst_temp1(mk_concat(strAst, temp1), mgr);
+
+
+ //--------------------------------------------------------
+ // x cut n
+ //--------------------------------------------------------
+ if (can_two_nodes_eq(x, strAst_temp1)) {
+ if (!avoidLoopCut || !(has_self_cut(x, n))) {
+ // break down option 3-2
+ or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+
+ expr_ref temp1_y(mk_concat(temp1, y), mgr);
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(x, strAst_temp1));
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(n, temp1_y));
+
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x),
+ m_autil.mk_add(mk_strlen(strAst), mk_strlen(temp1)) ));
+ option++;
+
+ add_cut_info_merge(temp1, ctx.get_scope_level(), x);
+ add_cut_info_merge(temp1, ctx.get_scope_level(), n);
+ } else {
+ loopDetected = true;
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
+ // TODO printCutVAR(x, n)
+ }
+ }
+
+
+ if (option > 0) {
+ if (option == 1) {
+ and_item[0] = or_item[0];
+ } else {
+ and_item[0] = mgr.mk_or(option, or_item);
+ }
+ expr_ref implyR(mgr.mk_and(pos, and_item), mgr);
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ } else {
+ TRACE("t_str", tout << "STOP: should not split two eq. concats" << std::endl;);
+ }
+ }
}
From f7bc785a56f1bd4dade92a5812a843b634500fc5 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 3 Oct 2015 12:19:55 -0400
Subject: [PATCH 046/401] process_concat_eq_type4, still WIP not tested
---
src/smt/theory_str.cpp | 82 ++++++++++++++++++++++++++++++++++++++++--
1 file changed, 80 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 7b555d6bb..5033ca978 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1491,13 +1491,91 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
}
+/*************************************************************
+ * Type 4: concat("str1", y) = concat("str2", n)
+ *************************************************************/
bool theory_str::is_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
- // TODO
- return false;
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ if (m_strutil.is_string(v1_arg0) && (!m_strutil.is_string(v1_arg1))
+ && m_strutil.is_string(v2_arg0) && (!m_strutil.is_string(v2_arg1))) {
+ return true;
+ } else {
+ return false;
+ }
}
void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+ TRACE("t_str_detail", tout << "process_concat_eq TYPE 4" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
+ );
+ if (!is_concat(to_app(concatAst1))) {
+ TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
+ }
+ if (!is_concat(to_app(concatAst2))) {
+ TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
+ }
+
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ expr * str1Ast = v1_arg0;
+ expr * y = v1_arg1;
+ expr * str2Ast = v2_arg0;
+ expr * n = v2_arg1;
+
+ const char *tmp = 0;
+ m_strutil.is_string(str1Ast, &tmp);
+ std::string str1Value(tmp);
+ m_strutil.is_string(str2Ast, &tmp);
+ std::string str2Value(tmp);
+
+ int str1Len = str1Value.length();
+ int str2Len = str2Value.length();
+
+ int commonLen = (str1Len > str2Len) ? str2Len : str1Len;
+ if (str1Value.substr(0, commonLen) != str2Value.substr(0, commonLen)) {
+ TRACE("t_str_detail", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
+ << " has no common prefix with " << mk_ismt2_pp(concatAst2, mgr) << std::endl;);
+ expr_ref toNegate(mgr.mk_not(ctx.mk_eq_atom(concatAst1, concatAst2)), mgr);
+ assert_axiom(toNegate);
+ return;
+ } else {
+ if (str1Len > str2Len) {
+ std::string deltaStr = str1Value.substr(str2Len, str1Len - str2Len);
+ expr_ref tmpAst(mk_concat(m_strutil.mk_string(deltaStr), y), mgr);
+ if (!in_same_eqc(tmpAst, n)) {
+ // break down option 4-1
+ expr_ref implyR(ctx.mk_eq_atom(n, tmpAst), mgr);
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ } else if (str1Len == str2Len) {
+ if (!in_same_eqc(n, y)) {
+ //break down option 4-2
+ expr_ref implyR(ctx.mk_eq_atom(n, y), mgr);
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ } else {
+ std::string deltaStr = str2Value.substr(str1Len, str2Len - str1Len);
+ expr_ref tmpAst(mk_concat(m_strutil.mk_string(deltaStr), n), mgr);
+ if (!in_same_eqc(y, tmpAst)) {
+ //break down option 4-3
+ expr_ref implyR(ctx.mk_eq_atom(y, tmpAst), mgr);
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ }
+ }
}
bool theory_str::is_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
From be7972338224e149356632e96171cc18b74112c4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 3 Oct 2015 12:26:30 -0400
Subject: [PATCH 047/401] process_concat_eq_type5 wip
---
src/smt/theory_str.cpp | 80 ++++++++++++++++++++++++++++++++++++++++--
1 file changed, 78 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 5033ca978..f052d293a 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1578,13 +1578,89 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
}
}
+/*************************************************************
+ * case 5: concat(x, "str1") = concat(m, "str2")
+ *************************************************************/
bool theory_str::is_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
- // TODO
- return false;
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ if ((!m_strutil.is_string(v1_arg0)) && m_strutil.is_string(v1_arg1)
+ && (!m_strutil.is_string(v2_arg0)) && m_strutil.is_string(v2_arg1)) {
+ return true;
+ } else {
+ return false;
+ }
}
void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+ TRACE("t_str_detail", tout << "process_concat_eq TYPE 5" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
+ );
+ if (!is_concat(to_app(concatAst1))) {
+ TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
+ }
+ if (!is_concat(to_app(concatAst2))) {
+ TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
+ }
+
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ expr * x = v1_arg0;
+ expr * str1Ast = v1_arg1;
+ expr * m = v2_arg0;
+ expr * str2Ast = v2_arg1;
+
+ const char *tmp = 0;
+ m_strutil.is_string(str1Ast, &tmp);
+ std::string str1Value(tmp);
+ m_strutil.is_string(str2Ast, &tmp);
+ std::string str2Value(tmp);
+
+ int str1Len = str1Value.length();
+ int str2Len = str2Value.length();
+
+ int cLen = (str1Len > str2Len) ? str2Len : str1Len;
+ if (str1Value.substr(str1Len - cLen, cLen) != str2Value.substr(str2Len - cLen, cLen)) {
+ TRACE("t_str_detail", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
+ << " has no common suffix with " << mk_ismt2_pp(concatAst2, mgr) << std::endl;);
+ expr_ref toNegate(mgr.mk_not(ctx.mk_eq_atom(concatAst1, concatAst2)), mgr);
+ assert_axiom(toNegate);
+ return;
+ } else {
+ if (str1Len > str2Len) {
+ std::string deltaStr = str1Value.substr(0, str1Len - str2Len);
+ expr_ref x_deltaStr(mk_concat(x, m_strutil.mk_string(deltaStr)), mgr);
+ if (!in_same_eqc(m, x_deltaStr)) {
+ expr_ref implyR(ctx.mk_eq_atom(m, x_deltaStr), mgr);
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ } else if (str1Len == str2Len) {
+ // test
+ if (!in_same_eqc(x, m)) {
+ expr_ref implyR(ctx.mk_eq_atom(x, m), mgr);
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ } else {
+ std::string deltaStr = str2Value.substr(0, str2Len - str1Len);
+ expr_ref m_deltaStr(mk_concat(m, m_strutil.mk_string(deltaStr)), mgr);
+ if (!in_same_eqc(x, m_deltaStr)) {
+ expr_ref implyR(ctx.mk_eq_atom(x, m_deltaStr), mgr);
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ }
+ }
}
bool theory_str::is_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
From 6791db64c01ac7dfbac7c0c6a883be9692e513da Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 3 Oct 2015 13:34:42 -0400
Subject: [PATCH 048/401] process_concat_eq_type6 that's the last one!
---
src/smt/theory_str.cpp | 162 ++++++++++++++++++++++++++++++++++++++++-
1 file changed, 160 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f052d293a..aebaec572 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -20,6 +20,7 @@ Revision History:
#include"smt_model_generator.h"
#include"ast_pp.h"
#include"ast_ll_pp.h"
+#include<list>
namespace smt {
@@ -1663,13 +1664,170 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
}
}
+/*************************************************************
+ * case 6: concat("str1", y) = concat(m, "str2")
+ *************************************************************/
bool theory_str::is_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
- // TODO
- return false;
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ if (m_strutil.is_string(v1_arg0) && (!m_strutil.is_string(v1_arg1))
+ && (!m_strutil.is_string(v2_arg0)) && m_strutil.is_string(v2_arg1)) {
+ return true;
+ } else if (m_strutil.is_string(v2_arg0) && (!m_strutil.is_string(v2_arg1))
+ && (!m_strutil.is_string(v1_arg0)) && m_strutil.is_string(v1_arg1)) {
+ return true;
+ } else {
+ return false;
+ }
}
void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+ TRACE("t_str_detail", tout << "process_concat_eq TYPE 6" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
+ );
+ if (!is_concat(to_app(concatAst1))) {
+ TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
+ }
+ if (!is_concat(to_app(concatAst2))) {
+ TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
+ }
+
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+
+ expr * str1Ast = NULL;
+ expr * y = NULL;
+ expr * m = NULL;
+ expr * str2Ast = NULL;
+
+ if (m_strutil.is_string(v1_arg0)) {
+ str1Ast = v1_arg0;
+ y = v1_arg1;
+ m = v2_arg0;
+ str2Ast = v2_arg1;
+ } else {
+ str1Ast = v2_arg0;
+ y = v2_arg1;
+ m = v1_arg0;
+ str2Ast = v1_arg1;
+ }
+
+ const char *tmp = 0;
+ m_strutil.is_string(str1Ast, &tmp);
+ std::string str1Value(tmp);
+ m_strutil.is_string(str2Ast, &tmp);
+ std::string str2Value(tmp);
+
+ int str1Len = str1Value.length();
+ int str2Len = str2Value.length();
+
+ //----------------------------------------
+ //(a) |---str1---|----y----|
+ // |--m--|-----str2-----|
+ //
+ //(b) |---str1---|----y----|
+ // |-----m----|--str2---|
+ //
+ //(c) |---str1---|----y----|
+ // |------m------|-str2-|
+ //----------------------------------------
+
+ std::list<int> overlapLen;
+ overlapLen.push_back(0);
+
+ for (int i = 1; i <= str1Len && i <= str2Len; i++) {
+ if (str1Value.substr(str1Len - i, i) == str2Value.substr(0, i))
+ overlapLen.push_back(i);
+ }
+
+ //----------------------------------------------------------------
+ expr * commonVar = NULL;
+ expr * xorFlag = NULL;
+ std::pair<expr*, expr*> key1(concatAst1, concatAst2);
+ std::pair<expr*, expr*> key2(concatAst2, concatAst1);
+ if (varForBreakConcat.find(key1) == varForBreakConcat.end() && varForBreakConcat.find(key2) == varForBreakConcat.end()) {
+ commonVar = mk_nonempty_str_var();
+ xorFlag = mk_internal_xor_var();
+ varForBreakConcat[key1][0] = commonVar;
+ varForBreakConcat[key1][1] = xorFlag;
+ } else {
+ if (varForBreakConcat.find(key1) != varForBreakConcat.end()) {
+ commonVar = varForBreakConcat[key1][0];
+ xorFlag = varForBreakConcat[key1][1];
+ } else {
+ commonVar = varForBreakConcat[key2][0];
+ xorFlag = varForBreakConcat[key2][1];
+ }
+ }
+
+ expr ** or_item = alloc_svect(expr*, (overlapLen.size() + 1));
+ int option = 0;
+ expr ** and_item = alloc_svect(expr*, (1 + 4 * (overlapLen.size() + 1)));
+ int pos = 1;
+
+ if (!avoidLoopCut || !has_self_cut(m, y)) {
+ or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+
+ expr_ref str1_commonVar(mk_concat(str1Ast, commonVar), mgr);
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(m, str1_commonVar));
+
+ expr_ref commonVar_str2(mk_concat(commonVar, str2Ast), mgr);
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, commonVar_str2));
+
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(m),
+ m_autil.mk_add(mk_strlen(str1Ast), mk_strlen(commonVar)) ));
+
+ // addItems[0] = mk_length(t, commonVar);
+ // addItems[1] = mk_length(t, str2Ast);
+ // and_item[pos++] = Z3_mk_eq(ctx, or_item[option], Z3_mk_eq(ctx, mk_length(t, y), Z3_mk_add(ctx, 2, addItems)));
+
+ option++;
+ } else {
+ loopDetected = true;
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
+ // TODO printCutVAR(m, y)
+ }
+
+ for (std::list<int>::iterator itor = overlapLen.begin(); itor != overlapLen.end(); itor++) {
+ int overLen = *itor;
+ std::string prefix = str1Value.substr(0, str1Len - overLen);
+ std::string suffix = str2Value.substr(overLen, str2Len - overLen);
+ or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+
+ expr_ref prefixAst(m_strutil.mk_string(prefix), mgr);
+ expr_ref x_eq_prefix(ctx.mk_eq_atom(m, prefixAst), mgr);
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], x_eq_prefix);
+
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option],
+ ctx.mk_eq_atom(mk_strlen(m), mk_strlen(prefixAst)));
+
+ // adding length constraint for _ = constStr seems slowing things down.
+
+ expr_ref suffixAst(m_strutil.mk_string(suffix), mgr);
+ expr_ref y_eq_suffix(ctx.mk_eq_atom(y, suffixAst), mgr);
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], y_eq_suffix);
+
+ and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(y), mk_strlen(suffixAst)));
+
+ option++;
+ }
+
+ // case 6: concat("str1", y) = concat(m, "str2")
+ and_item[0] = mgr.mk_or(option, or_item);
+ expr_ref implyR(mgr.mk_and(pos, and_item), mgr);
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
}
/*
From b494804c9c75b083767dd1a63d75f1abf8ebc717 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 6 Oct 2015 19:31:26 -0400
Subject: [PATCH 049/401] ignore tests dir
---
.gitignore | 3 +++
1 file changed, 3 insertions(+)
diff --git a/.gitignore b/.gitignore
index 97ca67cf4..b4a69f69e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -77,4 +77,7 @@ doc/code
# reference code for z3str2
Z3-str
Z3-str/**
+# test cases
+tests
+tests/**
From e521ab2c3af04c7c4b4082a2ffc81b0c6caf864a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 18 Oct 2015 19:39:55 -0400
Subject: [PATCH 050/401] fix concat_axiom loop in propagate(): compare against
size()......
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index aebaec572..47165997d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -376,7 +376,7 @@ void theory_str::propagate() {
}
m_str_eq_todo.reset();
- for (unsigned i = 0; i < m_concat_axiom_todo.empty(); ++i) {
+ for (unsigned i = 0; i < m_concat_axiom_todo.size(); ++i) {
instantiate_concat_axiom(m_concat_axiom_todo[i]);
}
m_concat_axiom_todo.reset();
From 3ee8f27588bcb88220f0ff515526ee0003716c43 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 18 Oct 2015 20:20:09 -0400
Subject: [PATCH 051/401] possibly fix internalization bug mentioned in #2
(this leads to a not-implemented-yet in final_check_eh() due to missing code
surrounding free variable production)
---
src/smt/theory_str.cpp | 2 ++
1 file changed, 2 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 47165997d..15253bcfd 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1837,6 +1837,8 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
*/
expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
context & ctx = get_context();
+ // I hope this works
+ ctx.internalize(n, false);
enode * nNode = ctx.get_enode(n);
enode * eqcNode = nNode;
do {
From c08f4371f4b9b0f98001eae4c111dbe91cf53d8f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 21 Oct 2015 21:32:38 -0400
Subject: [PATCH 052/401] begin model generation, wip
---
src/smt/theory_str.cpp | 97 ++++++++++++++++++++++++++++++++++++++++++
src/smt/theory_str.h | 5 +++
2 files changed, 102 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 15253bcfd..3e6b637d1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2525,6 +2525,88 @@ void theory_str::dump_assignments() {
);
}
+// NOTE: this function used to take an argument `Z3_ast node`;
+// it was not used and so was removed from the signature
+void theory_str::classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
+ std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap) {
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+
+ for (expr_ref_vector::iterator it = assignments.begin(); it != assignments.end(); ++it) {
+ expr * argAst = *it;
+ // TODO
+ NOT_IMPLEMENTED_YET();
+ /*
+ * according to getNodeType(), the following things are considered "functions":
+ * Contains, StartsWith, EndsWith, RegexIn
+ * Length, Indexof, Indexof2, LastIndexof
+ * Concat, SubString, Replace, Unroll, CharAt
+ * RegexConcat, RegexStar, RegexPlus, RegexCharRange, RegexUnion, Str2Reg
+ * something about Z3_ARRAY_SORT?
+ * Z3 native functions that aren't considered "uninterpreted"
+ * "real" uninterpreted functions declared in the input (domainSize != 0)
+ */
+
+ /*
+ if (getNodeType(t, argAst) == my_Z3_Func) {
+ Z3_app func_app = Z3_to_app(ctx, argAst);
+ Z3_decl_kind func_decl = Z3_get_decl_kind(ctx, Z3_get_app_decl(ctx, func_app));
+
+ if (isInterestingFuncKind(func_decl)) {
+ classifyAstByType(t, argAst, varMap, concatMap, unrollMap);
+ }
+ }
+ */
+ }
+}
+
+/*
+ * Dependence analysis from current context assignment
+ * - "freeVarMap" contains a set of variables that doesn't constrained by Concats.
+ * But it's possible that it's bounded by unrolls
+ * For the case of
+ * (1) var1 = unroll(r1, t1)
+ * var1 is in the freeVarMap
+ * > should unroll r1 for var1
+ * (2) var1 = unroll(r1, t1) /\ var1 = Concat(var2, var3)
+ * var2, var3 are all in freeVar
+ * > should split the unroll function so that var2 and var3 are bounded by new unrolls
+ */
+int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr*, int> & freeVarMap,
+ std::map<expr*, std::set<expr*> > & unrollGroupMap) {
+ std::map<expr*, int> concatMap;
+ std::map<expr*, int> unrollMap;
+ std::map<expr*, expr*> aliasIndexMap;
+ std::map<expr*, expr*> var_eq_constStr_map;
+ std::map<expr*, expr*> concat_eq_constStr_map;
+ std::map<expr*, std::map<expr*, int> > var_eq_concat_map;
+ std::map<expr*, std::map<expr*, int> > var_eq_unroll_map;
+ std::map<expr*, std::map<expr*, int> > concat_eq_concat_map;
+ std::map<expr*, std::map<expr*, int> > depMap;
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ // note that the old API concatenated these assignments into
+ // a massive conjunction; we may have the opportunity to avoid that here
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+
+ // Step 1: get variables / concat AST appearing in the context
+ // TODO build this map; see strTheory::checkInputVar()
+ // it should just be variable_set - internal_variable_set?
+ for(std::map<expr*, int>::iterator it = inputVarMap.begin(); it != inputVarMap.end(); ++it) {
+ strVarMap[it->first] = 1;
+ }
+ classify_ast_by_type_in_positive_context(assignments, strVarMap, concatMap, unrollMap);
+
+ // TODO the rest
+ NOT_IMPLEMENTED_YET();
+}
+
final_check_status theory_str::final_check_eh() {
ast_manager & m = get_manager();
context & ctx = get_context();
@@ -2532,6 +2614,20 @@ final_check_status theory_str::final_check_eh() {
TRACE("t_str", tout << "final check" << std::endl;);
TRACE("t_str_detail", dump_assignments(););
+ // run dependence analysis to find free string variables
+ std::map<expr*, int> varAppearInAssign;
+ std::map<expr*, int> freeVar_map;
+ std::map<expr*, std::set<expr*> > unrollGroup_map;
+ int conflictInDep = ctx_dep_analysis(varAppearInAssign, freeVar_map, unrollGroup_map);
+ if (conflictInDep == -1) {
+ // return Z3_TRUE;
+ return FC_DONE;
+ }
+
+ // TODO the rest...
+ NOT_IMPLEMENTED_YET();
+
+ /*
// Check every variable to see if it's eq. to some string constant.
// If not, mark it as free.
bool needToAssignFreeVars = false;
@@ -2561,6 +2657,7 @@ final_check_status theory_str::final_check_eh() {
}
}
return FC_CONTINUE;
+ */
}
void theory_str::init_model(model_generator & mg) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 1c2e2fbee..80e321729 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -144,6 +144,11 @@ namespace smt {
bool new_eq_check(expr * lhs, expr * rhs);
void group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts);
+ int ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr*, int> & freeVarMap,
+ std::map<expr*, std::set<expr*> > & unrollGroupMap);
+ void classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
+ std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap)
+
void dump_assignments();
public:
theory_str(ast_manager & m);
From 1f3c5cebbf660a52aebae291846a65a021c30520 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 26 Oct 2015 15:43:31 -0400
Subject: [PATCH 053/401] variable classification (WIP)
---
src/smt/theory_str.cpp | 82 ++++++++++++++++++++++++++++++------------
src/smt/theory_str.h | 6 +++-
2 files changed, 64 insertions(+), 24 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3e6b637d1..86aaaaf44 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2525,6 +2525,57 @@ void theory_str::dump_assignments() {
);
}
+void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap,
+ std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap) {
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ // check whether the node is a non-internal string variable;
+ // testing set membership here bypasses several expensive checks
+ if (variable_set.find(node) != variable_set.end()
+ && internal_variable_set.find(node) == internal_variable_set.end()) {
+ varMap[node] = 1;
+ }
+ // check whether the node is a function that we want to inspect
+ else if (is_app(node)) { // TODO
+ app * aNode = to_app(node);
+ if (is_strlen(aNode)) {
+ // Length
+ return;
+ } else if (is_concat(aNode)) {
+ expr * arg0 = aNode->get_arg(0);
+ expr * arg1 = aNode->get_arg(1);
+ bool arg0HasEq = false;
+ bool arg1HasEq = false;
+ expr * arg0Val = get_eqc_value(arg0, arg0HasEq);
+ expr * arg1Val = get_eqc_value(arg1, arg1HasEq);
+
+ int canskip = 0;
+ if (arg0HasEq && arg0Val == m_strutil.mk_string("")) {
+ canskip = 1;
+ }
+ if (canskip == 0 && arg1HasEq && arg1Val == m_strutil.mk_string("")) {
+ canskip = 1;
+ }
+ if (canskip == 0 && concatMap.find(node) == concatMap.end()) {
+ concatMap[node] = 1;
+ }
+ } else if (false) { // TODO is_unroll()
+ // Unroll
+ if (unrollMap.find(node) == unrollMap.end()) {
+ unrollMap[node] = 1;
+ }
+ }
+ // recursively visit all arguments
+ app * aNode = to_app(node);
+ for (unsigned i = 0; i < aNode->get_num_args(); ++i) {
+ expr * arg = aNode->get_arg(i);
+ classify_ast_by_type(arg, varMap, concatMap, unrollMap);
+ }
+ }
+}
+
// NOTE: this function used to take an argument `Z3_ast node`;
// it was not used and so was removed from the signature
void theory_str::classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
@@ -2537,29 +2588,14 @@ void theory_str::classify_ast_by_type_in_positive_context(std::map<expr*, int> &
for (expr_ref_vector::iterator it = assignments.begin(); it != assignments.end(); ++it) {
expr * argAst = *it;
- // TODO
- NOT_IMPLEMENTED_YET();
- /*
- * according to getNodeType(), the following things are considered "functions":
- * Contains, StartsWith, EndsWith, RegexIn
- * Length, Indexof, Indexof2, LastIndexof
- * Concat, SubString, Replace, Unroll, CharAt
- * RegexConcat, RegexStar, RegexPlus, RegexCharRange, RegexUnion, Str2Reg
- * something about Z3_ARRAY_SORT?
- * Z3 native functions that aren't considered "uninterpreted"
- * "real" uninterpreted functions declared in the input (domainSize != 0)
- */
+ // the original code jumped through some hoops to check whether the AST node
+ // is a function, then checked whether that function is "interesting".
+ // however, the only thing that's considered "interesting" is an equality predicate.
+ // so we bypass a huge amount of work by doing the following...
- /*
- if (getNodeType(t, argAst) == my_Z3_Func) {
- Z3_app func_app = Z3_to_app(ctx, argAst);
- Z3_decl_kind func_decl = Z3_get_decl_kind(ctx, Z3_get_app_decl(ctx, func_app));
-
- if (isInterestingFuncKind(func_decl)) {
- classifyAstByType(t, argAst, varMap, concatMap, unrollMap);
- }
+ if (m.is_eq(argAst)) {
+ classify_ast_by_type(argAst, varMap, concatMap, unrollMap);
}
- */
}
}
@@ -2598,10 +2634,10 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
// Step 1: get variables / concat AST appearing in the context
// TODO build this map; see strTheory::checkInputVar()
// it should just be variable_set - internal_variable_set?
- for(std::map<expr*, int>::iterator it = inputVarMap.begin(); it != inputVarMap.end(); ++it) {
+ for(std::map<expr*, int>::iterator it = input_var_map.begin(); it != input_var_map.end(); ++it) {
strVarMap[it->first] = 1;
}
- classify_ast_by_type_in_positive_context(assignments, strVarMap, concatMap, unrollMap);
+ classify_ast_by_type_in_positive_context(strVarMap, concatMap, unrollMap);
// TODO the rest
NOT_IMPLEMENTED_YET();
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 80e321729..684526602 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -104,6 +104,8 @@ namespace smt {
bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
bool is_string(app const * a) const { return a->is_app_of(get_id(), OP_STR); }
bool is_string(enode const * n) const { return is_string(n->get_owner()); }
+ bool is_strlen(app const * a) const { return a->is_app_of(get_id(), OP_STRLEN); }
+ bool is_strlen(enode const * n) const { return is_strlen(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
void instantiate_str_eq_length_axiom(enode * lhs, enode * rhs);
@@ -146,8 +148,10 @@ namespace smt {
int ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr*, int> & freeVarMap,
std::map<expr*, std::set<expr*> > & unrollGroupMap);
+ void classify_ast_by_type(expr * node, std::map<expr*, int> & varMap,
+ std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
void classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
- std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap)
+ std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
void dump_assignments();
public:
From 9f01b9dc92203f8cdefa7cd9befe43da6c6565f6 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 4 Nov 2015 16:22:06 -0500
Subject: [PATCH 054/401] more progress on model gen (WIP)
---
src/smt/theory_str.cpp | 203 ++++++++++++++++++++++++++++++++++++++++-
1 file changed, 199 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 86aaaaf44..c5ca630f9 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2632,13 +2632,208 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
ctx.get_assignments(assignments);
// Step 1: get variables / concat AST appearing in the context
- // TODO build this map; see strTheory::checkInputVar()
- // it should just be variable_set - internal_variable_set?
- for(std::map<expr*, int>::iterator it = input_var_map.begin(); it != input_var_map.end(); ++it) {
- strVarMap[it->first] = 1;
+ // the thing we iterate over should just be variable_set - internal_variable_set
+ // so we avoid computing the set difference (but this might be slower)
+ for(std::set<expr*>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
+ expr* var = *it;
+ if (internal_variable_set.find(var) == internal_variable_set.end()) {
+ strVarMap[*it] = 1;
+ }
}
classify_ast_by_type_in_positive_context(strVarMap, concatMap, unrollMap);
+ // TODO unroll()
+ /*
+ std::map<Z3_ast, Z3_ast> aliasUnrollSet;
+ std::map<Z3_ast, int>::iterator unrollItor = unrollMap.begin();
+ for (; unrollItor != unrollMap.end(); unrollItor++) {
+ if (aliasUnrollSet.find(unrollItor->first) != aliasUnrollSet.end())
+ continue;
+ Z3_ast aRoot = NULL;
+ Z3_ast curr = unrollItor->first;
+ do {
+ if (isUnrollFunc(t, curr)) {
+ if (aRoot == NULL) {
+ aRoot = curr;
+ }
+ aliasUnrollSet[curr] = aRoot;
+ }
+ curr = Z3_theory_get_eqc_next(t, curr);
+ } while (curr != unrollItor->first);
+ }
+
+ for (unrollItor = unrollMap.begin(); unrollItor != unrollMap.end(); unrollItor++) {
+ Z3_ast unrFunc = unrollItor->first;
+ Z3_ast urKey = aliasUnrollSet[unrFunc];
+ unrollGroupMap[urKey].insert(unrFunc);
+ }
+ */
+
+ // Step 2: collect alias relation
+ // e.g. suppose we have the equivalence class {x, y, z};
+ // then we set aliasIndexMap[y] = x
+ // and aliasIndexMap[z] = x
+
+ std::map<expr*, int>::iterator varItor = strVarMap.begin();
+ for (; varItor != strVarMap.end(); ++varItor) {
+ if (aliasIndexMap.find(varItor->first) != aliasIndexMap.end()) {
+ continue;
+ }
+ expr * aRoot = NULL;
+ expr * curr = varItor->first;
+ do {
+ if (variable_set.find(curr) != variable_set.end()) { // TODO internal_variable_set?
+ if (aRoot == NULL) {
+ aRoot = curr;
+ } else {
+ aliasIndexMap[curr] = aRoot;
+ }
+ }
+ // curr = get_eqc_next(curr);
+ enode * eqcNode = ctx.get_enode(curr);
+ eqcNode = eqcNode->get_next();
+ curr = eqcNode->get_owner();
+ } while (curr != varItor->first);
+ }
+
+ // Step 3: Collect interested cases
+
+ varItor = strVarMap.begin();
+ for (; varItor != strVarMap.end(); ++varItor) {
+ expr * deAliasNode = get_alias_index_ast(aliasIndexMap, varItor->first);
+ // Case 1: variable = string constant
+ // e.g. z = "str1" ::= var_eq_constStr_map[z] = "str1"
+
+ if (var_eq_constStr_map.find(deAliasNode) == var_eq_constStr_map.end()) {
+ bool nodeHasEqcValue = false;
+ expr * nodeValue = get_eqc_value(deAliasNode, nodeHasEqcValue);
+ if (nodeHasEqcValue) {
+ var_eq_constStr_map[deAliasNode] = nodeValue;
+ }
+ }
+
+ // Case 2: var_eq_concat
+ // e.g. z = concat("str1", b) ::= var_eq_concat[z][concat(c, "str2")] = 1
+ // var_eq_unroll
+ // e.g. z = unroll(...) ::= var_eq_unroll[z][unroll(...)] = 1
+
+ if (var_eq_concat_map.find(deAliasNode) == var_eq_concat_map.end()) {
+ enode * e_curr = ctx.get_enode(deAliasNode);
+ expr * curr = e_curr->get_next()->get_owner();
+ while (curr != deAliasNode) {
+ app * aCurr = to_app(curr);
+ // collect concat
+ if (is_concat(aCurr)) {
+ expr * arg0 = aCurr->get_arg(0);
+ expr * arg1 = aCurr->get_arg(1);
+ bool arg0HasEqcValue = false;
+ bool arg1HasEqcValue = false;
+ expr * arg0_value = get_eqc_value(arg0, arg0HasEqcValue);
+ expr * arg1_value = get_eqc_value(arg1, arg1HasEqcValue);
+
+ bool is_arg0_emptyStr = false;
+ if (arg0HasEqcValue) {
+ const char * strval = 0;
+ m_strutil.is_string(arg0_value, &strval);
+ if (strcmp(strval, "") == 0) {
+ is_arg0_emptyStr = true;
+ }
+ }
+
+ bool is_arg1_emptyStr = false;
+ if (arg1HasEqcValue) {
+ const char * strval = 0;
+ m_strutil.is_string(arg1_value, &strval);
+ if (strcmp(strval, "") == 0) {
+ is_arg1_emptyStr = true;
+ }
+ }
+
+ if (!is_arg0_emptyStr && !is_arg1_emptyStr) {
+ var_eq_concat_map[deAliasNode][curr] = 1;
+ }
+ }
+ // TODO: collect unroll functions
+ /*
+ else if (isUnrollFunc(t, curr)) {
+ var_eq_unroll_map[deAliasNode][curr] = 1;
+ }
+ */
+
+ // curr = get_eqc_next(curr)
+ e_curr = ctx.get_enode(curr);
+ curr = e_curr->get_next()->get_owner();
+ }
+ }
+
+ } // for(varItor in strVarMap)
+
+ // --------------------------------------------------
+ // * collect aliasing relation among eq concats
+ // e.g EQC={concat1, concat2, concat3}
+ // concats_eq_Index_map[concat2] = concat1
+ // concats_eq_Index_map[concat3] = concat1
+ // --------------------------------------------------
+
+ /*
+ std::map<Z3_ast, Z3_ast> concats_eq_Index_map;
+ std::map<Z3_ast, int>::iterator concatItor = concatMap.begin();
+ for (; concatItor != concatMap.end(); concatItor++) {
+ // simplifyConcatToConst(t, concatItor->first);
+
+ if (concats_eq_Index_map.find(concatItor->first) != concats_eq_Index_map.end())
+ continue;
+
+ Z3_ast aRoot = NULL;
+ Z3_ast curr = concatItor->first;
+ do {
+ if (isConcatFunc(t, curr)) {
+ if (aRoot == NULL)
+ aRoot = curr;
+ else
+ concats_eq_Index_map[curr] = aRoot;
+ }
+ curr = Z3_theory_get_eqc_next(t, curr);
+ } while (curr != concatItor->first);
+ }
+
+ concatItor = concatMap.begin();
+ for (; concatItor != concatMap.end(); concatItor++) {
+ Z3_ast deAliasConcat = NULL;
+ if (concats_eq_Index_map.find(concatItor->first) != concats_eq_Index_map.end())
+ deAliasConcat = concats_eq_Index_map[concatItor->first];
+ else
+ deAliasConcat = concatItor->first;
+
+ // --------------------------------------------------
+ // (3) concat_eq_constStr:
+ // e.g, concat(a,b) = "str1"
+ // --------------------------------------------------
+ if (concat_eq_constStr_map.find(deAliasConcat) == concat_eq_constStr_map.end()) {
+ bool nodeHasEqcValue = false;
+ Z3_ast nodeValue = get_eqc_value(t, deAliasConcat, nodeHasEqcValue);
+ if (nodeHasEqcValue)
+ concat_eq_constStr_map[deAliasConcat] = nodeValue;
+ }
+ // --------------------------------------------------
+ // (4) concat_eq_concat:
+ // e.g, concat(a,b) = concat("str1", c) /\ z = concat(a, b) /\ z = concat(e, f)
+ // --------------------------------------------------
+ if (concat_eq_concat_map.find(deAliasConcat) == concat_eq_concat_map.end()) {
+ Z3_ast curr = deAliasConcat;
+ do {
+ if (isConcatFunc(t, curr)) {
+ // curr is not a concat that can be reduced
+ if (concatMap.find(curr) != concatMap.end()) {
+ concat_eq_concat_map[deAliasConcat][curr] = 1;
+ }
+ }
+ curr = Z3_theory_get_eqc_next(t, curr);
+ } while (curr != deAliasConcat);
+ }
+ }
+ */
+
// TODO the rest
NOT_IMPLEMENTED_YET();
}
From 4a8ee88461ab27233c15a9af389bdea3743fc5bd Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 6 Nov 2015 13:43:54 -0500
Subject: [PATCH 055/401] ctx_dep_analysis() done, final_check() WIP
---
src/smt/theory_str.cpp | 517 +++++++++++++++++++++++++++++++++++------
src/smt/theory_str.h | 4 +
2 files changed, 451 insertions(+), 70 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index c5ca630f9..7d9aaad7d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2599,6 +2599,33 @@ void theory_str::classify_ast_by_type_in_positive_context(std::map<expr*, int> &
}
}
+inline expr * theory_str::get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node) {
+ if (aliasIndexMap.find(node) != aliasIndexMap.end())
+ return aliasIndexMap[node];
+ else
+ return node;
+}
+
+inline expr * theory_str::getMostLeftNodeInConcat(expr * node) {
+ app * aNode = to_app(node);
+ if (!is_concat(aNode)) {
+ return node;
+ } else {
+ expr * concatArgL = aNode->get_arg(0);
+ return getMostLeftNodeInConcat(concatArgL);
+ }
+}
+
+inline expr * theory_str::getMostRightNodeInConcat(expr * node) {
+ app * aNode = to_app(node);
+ if (!is_concat(aNode)) {
+ return node;
+ } else {
+ expr * concatArgR = aNode->get_arg(1);
+ return getMostRightNodeInConcat(concatArgR);
+ }
+}
+
/*
* Dependence analysis from current context assignment
* - "freeVarMap" contains a set of variables that doesn't constrained by Concats.
@@ -2775,67 +2802,429 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
// concats_eq_Index_map[concat3] = concat1
// --------------------------------------------------
- /*
- std::map<Z3_ast, Z3_ast> concats_eq_Index_map;
- std::map<Z3_ast, int>::iterator concatItor = concatMap.begin();
- for (; concatItor != concatMap.end(); concatItor++) {
- // simplifyConcatToConst(t, concatItor->first);
-
- if (concats_eq_Index_map.find(concatItor->first) != concats_eq_Index_map.end())
- continue;
-
- Z3_ast aRoot = NULL;
- Z3_ast curr = concatItor->first;
- do {
- if (isConcatFunc(t, curr)) {
- if (aRoot == NULL)
- aRoot = curr;
- else
- concats_eq_Index_map[curr] = aRoot;
- }
- curr = Z3_theory_get_eqc_next(t, curr);
- } while (curr != concatItor->first);
+ std::map<expr*, expr*> concats_eq_index_map;
+ std::map<expr*, int>::iterator concatItor = concatMap.begin();
+ for(; concatItor != concatMap.end(); ++concatItor) {
+ if (concats_eq_index_map.find(concatItor->first) != concats_eq_index_map.end()) {
+ continue;
+ }
+ expr * aRoot = NULL;
+ expr * curr = concatItor->first;
+ do {
+ if (is_concat(to_app(curr))) {
+ if (aRoot == NULL) {
+ aRoot = curr;
+ } else {
+ concats_eq_index_map[curr] = aRoot;
+ }
+ }
+ // curr = get_eqc_next(curr);
+ enode * e_curr = ctx.get_enode(curr);
+ curr = e_curr->get_next()->get_owner();
+ } while (curr != concatItor->first);
}
concatItor = concatMap.begin();
- for (; concatItor != concatMap.end(); concatItor++) {
- Z3_ast deAliasConcat = NULL;
- if (concats_eq_Index_map.find(concatItor->first) != concats_eq_Index_map.end())
- deAliasConcat = concats_eq_Index_map[concatItor->first];
- else
- deAliasConcat = concatItor->first;
+ for(; concatItor != concatMap.end(); ++concatItor) {
+ expr * deAliasConcat = NULL;
+ if (concats_eq_index_map.find(concatItor->first) != concats_eq_index_map.end()) {
+ deAliasConcat = concats_eq_index_map[concatItor->first];
+ } else {
+ deAliasConcat = concatItor->first;
+ }
- // --------------------------------------------------
- // (3) concat_eq_constStr:
- // e.g, concat(a,b) = "str1"
- // --------------------------------------------------
- if (concat_eq_constStr_map.find(deAliasConcat) == concat_eq_constStr_map.end()) {
- bool nodeHasEqcValue = false;
- Z3_ast nodeValue = get_eqc_value(t, deAliasConcat, nodeHasEqcValue);
- if (nodeHasEqcValue)
- concat_eq_constStr_map[deAliasConcat] = nodeValue;
- }
- // --------------------------------------------------
- // (4) concat_eq_concat:
- // e.g, concat(a,b) = concat("str1", c) /\ z = concat(a, b) /\ z = concat(e, f)
- // --------------------------------------------------
- if (concat_eq_concat_map.find(deAliasConcat) == concat_eq_concat_map.end()) {
- Z3_ast curr = deAliasConcat;
- do {
- if (isConcatFunc(t, curr)) {
- // curr is not a concat that can be reduced
- if (concatMap.find(curr) != concatMap.end()) {
- concat_eq_concat_map[deAliasConcat][curr] = 1;
- }
- }
- curr = Z3_theory_get_eqc_next(t, curr);
- } while (curr != deAliasConcat);
- }
+ // (3) concat_eq_conststr, e.g. concat(a,b) = "str1"
+ if (concat_eq_constStr_map.find(deAliasConcat) == concat_eq_constStr_map.end()) {
+ bool nodeHasEqcValue = false;
+ expr * nodeValue = get_eqc_value(deAliasConcat, nodeHasEqcValue);
+ if (nodeHasEqcValue) {
+ concat_eq_constStr_map[deAliasConcat] = nodeValue;
+ }
+ }
+
+ // (4) concat_eq_concat, e.g.
+ // concat(a,b) = concat("str1", c) AND z = concat(a,b) AND z = concat(e,f)
+ if (concat_eq_concat_map.find(deAliasConcat) == concat_eq_concat_map.end()) {
+ expr * curr = deAliasConcat;
+ do {
+ if (is_concat(to_app(curr))) {
+ // curr cannot be reduced
+ if (concatMap.find(curr) != concatMap.end()) {
+ concat_eq_concat_map[deAliasConcat][curr] = 1;
+ }
+ }
+ // curr = get_eqc_next(curr);
+ enode * e_curr = ctx.get_enode(curr);
+ curr = e_curr->get_next()->get_owner();
+ } while (curr != deAliasConcat);
+ }
+ }
+
+ // TODO this would be a great place to print some debugging information
+
+ // TODO compute Contains
+ /*
+ if (containPairBoolMap.size() > 0) {
+ computeContains(t, aliasIndexMap, concats_eq_Index_map, var_eq_constStr_map, concat_eq_constStr_map, var_eq_concat_map);
}
*/
- // TODO the rest
- NOT_IMPLEMENTED_YET();
+ // step 4: dependence analysis
+
+ // (1) var = string constant
+ for (std::map<expr*, expr*>::iterator itor = var_eq_constStr_map.begin();
+ itor != var_eq_constStr_map.end(); ++itor) {
+ expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
+ expr * strAst = itor->second;
+ depMap[var][strAst] = 1;
+ }
+
+ // (2) var = concat
+ for (std::map<expr*, std::map<expr*, int> >::iterator itor = var_eq_concat_map.begin();
+ itor != var_eq_concat_map.end(); ++itor) {
+ expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
+ for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); ++itor1) {
+ expr * concat = itor1->first;
+ std::map<expr*, int> inVarMap;
+ std::map<expr*, int> inConcatMap;
+ std::map<expr*, int> inUnrollMap;
+ classify_ast_by_type(concat, inVarMap, inConcatMap, inUnrollMap);
+ for (std::map<expr*, int>::iterator itor2 = inVarMap.begin(); itor2 != inVarMap.end(); ++itor2) {
+ expr * varInConcat = get_alias_index_ast(aliasIndexMap, itor2->first);
+ if (!(depMap[var].find(varInConcat) != depMap[var].end() && depMap[var][varInConcat] == 1)) {
+ depMap[var][varInConcat] = 2;
+ }
+ }
+ }
+ }
+
+ for (std::map<expr*, std::map<expr*, int> >::iterator itor = var_eq_unroll_map.begin();
+ itor != var_eq_unroll_map.end(); itor++) {
+ expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
+ for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
+ expr * unrollFunc = itor1->first;
+ std::map<expr*, int> inVarMap;
+ std::map<expr*, int> inConcatMap;
+ std::map<expr*, int> inUnrollMap;
+ classify_ast_by_type(unrollFunc, inVarMap, inConcatMap, inUnrollMap);
+ for (std::map<expr*, int>::iterator itor2 = inVarMap.begin(); itor2 != inVarMap.end(); itor2++) {
+ expr * varInFunc = get_alias_index_ast(aliasIndexMap, itor2->first);
+
+ STRACE("t_str_detail", tout << "var in unroll = " <<
+ mk_ismt2_pp(itor2->first, m) << std::endl
+ << "dealiased var = " << mk_ismt2_pp(varInFunc) << std::endl;);
+
+ // it's possible that we have both (Unroll $$_regVar_0 $$_unr_0) /\ (Unroll abcd $$_unr_0),
+ // while $$_regVar_0 = "abcd"
+ // have to exclude such cases
+ bool varHasValue = false;
+ get_eqc_value(varInFunc, varHasValue);
+ if (varHasValue)
+ continue;
+
+ if (depMap[var].find(varInFunc) == depMap[var].end()) {
+ depMap[var][varInFunc] = 6;
+ }
+ }
+ }
+ }
+
+ // (3) concat = string constant
+ for (std::map<expr*, expr*>::iterator itor = concat_eq_constStr_map.begin();
+ itor != concat_eq_constStr_map.end(); itor++) {
+ expr * concatAst = itor->first;
+ expr * constStr = itor->second;
+ std::map<expr*, int> inVarMap;
+ std::map<expr*, int> inConcatMap;
+ std::map<expr*, int> inUnrollMap;
+ classify_ast_by_type(concatAst, inVarMap, inConcatMap, inUnrollMap);
+ for (std::map<expr*, int>::iterator itor2 = inVarMap.begin(); itor2 != inVarMap.end(); itor2++) {
+ expr * varInConcat = get_alias_index_ast(aliasIndexMap, itor2->first);
+ if (!(depMap[varInConcat].find(constStr) != depMap[varInConcat].end() && depMap[varInConcat][constStr] == 1))
+ depMap[varInConcat][constStr] = 3;
+ }
+ }
+
+ // (4) equivalent concats
+ // - possibility 1 : concat("str", v1) = concat(concat(v2, v3), v4) = concat(v5, v6)
+ // ==> v2, v5 are constrained by "str"
+ // - possibliity 2 : concat(v1, "str") = concat(v2, v3) = concat(v4, v5)
+ // ==> v2, v4 are constrained by "str"
+ //--------------------------------------------------------------
+
+ std::map<expr*, expr*> mostLeftNodes;
+ std::map<expr*, expr*> mostRightNodes;
+
+ std::map<expr*, int> mLIdxMap;
+ std::map<int, std::set<expr*> > mLMap;
+ std::map<expr*, int> mRIdxMap;
+ std::map<int, std::set<expr*> > mRMap;
+ std::set<expr*> nSet;
+
+ for (std::map<expr*, std::map<expr*, int> >::iterator itor = concat_eq_concat_map.begin();
+ itor != concat_eq_concat_map.end(); itor++) {
+ mostLeftNodes.clear();
+ mostRightNodes.clear();
+
+ expr * mLConst = NULL;
+ expr * mRConst = NULL;
+
+ for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
+ expr * concatNode = itor1->first;
+ expr * mLNode = getMostLeftNodeInConcat(concatNode);
+ const char * strval;
+ if (m_strutil.is_string(to_app(mLNode), & strval)) {
+ if (mLConst == NULL && strcmp(strval, "") != 0) {
+ mLConst = mLNode;
+ }
+ } else {
+ mostLeftNodes[mLNode] = concatNode;
+ }
+
+ expr * mRNode = getMostRightNodeInConcat(concatNode);
+ if (m_strutil.is_string(to_app(mRNode), & strval)) {
+ if (mRConst == NULL && strcmp(strval, "") != 0) {
+ mRConst = mRNode;
+ }
+ } else {
+ mostRightNodes[mRNode] = concatNode;
+ }
+ }
+
+ if (mLConst != NULL) {
+ // -------------------------------------------------------------------------------------
+ // The left most variable in a concat is constrained by a constant string in eqc concat
+ // -------------------------------------------------------------------------------------
+ // e.g. Concat(x, ...) = Concat("abc", ...)
+ // -------------------------------------------------------------------------------------
+ for (std::map<expr*, expr*>::iterator itor1 = mostLeftNodes.begin();
+ itor1 != mostLeftNodes.end(); itor1++) {
+ expr * deVar = get_alias_index_ast(aliasIndexMap, itor1->first);
+ if (depMap[deVar].find(mLConst) == depMap[deVar].end() || depMap[deVar][mLConst] != 1) {
+ depMap[deVar][mLConst] = 4;
+ }
+ }
+ }
+
+ {
+ // -------------------------------------------------------------------------------------
+ // The left most variables in eqc concats are constrained by each other
+ // -------------------------------------------------------------------------------------
+ // e.g. concat(x, ...) = concat(u, ...) = ...
+ // x and u are constrained by each other
+ // -------------------------------------------------------------------------------------
+ nSet.clear();
+ std::map<expr*, expr*>::iterator itl = mostLeftNodes.begin();
+ for (; itl != mostLeftNodes.end(); itl++) {
+ bool lfHasEqcValue = false;
+ get_eqc_value(itl->first, lfHasEqcValue);
+ if (lfHasEqcValue)
+ continue;
+ expr * deVar = get_alias_index_ast(aliasIndexMap, itl->first);
+ nSet.insert(deVar);
+ }
+
+ if (nSet.size() > 1) {
+ int lId = -1;
+ for (std::set<expr*>::iterator itor2 = nSet.begin(); itor2 != nSet.end(); itor2++) {
+ if (mLIdxMap.find(*itor2) != mLIdxMap.end()) {
+ lId = mLIdxMap[*itor2];
+ break;
+ }
+ }
+ if (lId == -1)
+ lId = mLMap.size();
+ for (std::set<expr*>::iterator itor2 = nSet.begin(); itor2 != nSet.end(); itor2++) {
+ bool itorHasEqcValue = false;
+ get_eqc_value(*itor2, itorHasEqcValue);
+ if (itorHasEqcValue)
+ continue;
+ mLIdxMap[*itor2] = lId;
+ mLMap[lId].insert(*itor2);
+ }
+ }
+ }
+
+ if (mRConst != NULL) {
+ for (std::map<expr*, expr*>::iterator itor1 = mostRightNodes.begin();
+ itor1 != mostRightNodes.end(); itor1++) {
+ expr * deVar = get_alias_index_ast(aliasIndexMap, itor1->first);
+ if (depMap[deVar].find(mRConst) == depMap[deVar].end() || depMap[deVar][mRConst] != 1) {
+ depMap[deVar][mRConst] = 5;
+ }
+ }
+ }
+
+ {
+ nSet.clear();
+ std::map<expr*, expr*>::iterator itr = mostRightNodes.begin();
+ for (; itr != mostRightNodes.end(); itr++) {
+ expr * deVar = get_alias_index_ast(aliasIndexMap, itr->first);
+ nSet.insert(deVar);
+ }
+ if (nSet.size() > 1) {
+ int rId = -1;
+ std::set<expr*>::iterator itor2 = nSet.begin();
+ for (; itor2 != nSet.end(); itor2++) {
+ if (mRIdxMap.find(*itor2) != mRIdxMap.end()) {
+ rId = mRIdxMap[*itor2];
+ break;
+ }
+ }
+ if (rId == -1)
+ rId = mRMap.size();
+ for (itor2 = nSet.begin(); itor2 != nSet.end(); itor2++) {
+ bool rHasEqcValue = false;
+ get_eqc_value(*itor2, rHasEqcValue);
+ if (rHasEqcValue)
+ continue;
+ mRIdxMap[*itor2] = rId;
+ mRMap[rId].insert(*itor2);
+ }
+ }
+ }
+ }
+
+ // TODO this would be a great place to print the dependence map
+
+ // step, errr, 5: compute free variables based on the dependence map
+
+ // the case dependence map is empty, every var in VarMap is free
+ //---------------------------------------------------------------
+ // remove L/R most var in eq concat since they are constrained with each other
+ std::map<expr*, std::map<expr*, int> > lrConstrainedMap;
+ for (std::map<int, std::set<expr*> >::iterator itor = mLMap.begin(); itor != mLMap.end(); itor++) {
+ for (std::set<expr*>::iterator it1 = itor->second.begin(); it1 != itor->second.end(); it1++) {
+ std::set<expr*>::iterator it2 = it1;
+ it2++;
+ for (; it2 != itor->second.end(); it2++) {
+ expr * n1 = *it1;
+ expr * n2 = *it2;
+ lrConstrainedMap[n1][n2] = 1;
+ lrConstrainedMap[n2][n1] = 1;
+ }
+ }
+ }
+ for (std::map<int, std::set<expr*> >::iterator itor = mRMap.begin(); itor != mRMap.end(); itor++) {
+ for (std::set<expr*>::iterator it1 = itor->second.begin(); it1 != itor->second.end(); it1++) {
+ std::set<expr*>::iterator it2 = it1;
+ it2++;
+ for (; it2 != itor->second.end(); it2++) {
+ expr * n1 = *it1;
+ expr * n2 = *it2;
+ lrConstrainedMap[n1][n2] = 1;
+ lrConstrainedMap[n2][n1] = 1;
+ }
+ }
+ }
+
+ if (depMap.size() == 0) {
+ std::map<expr*, int>::iterator itor = strVarMap.begin();
+ for (; itor != strVarMap.end(); itor++) {
+ expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
+ if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
+ freeVarMap[var] = 1;
+ } else {
+ int lrConstainted = 0;
+ std::map<expr*, int>::iterator lrit = freeVarMap.begin();
+ for (; lrit != freeVarMap.end(); lrit++) {
+ if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
+ lrConstainted = 1;
+ break;
+ }
+ }
+ if (lrConstainted == 0) {
+ freeVarMap[var] = 1;
+ }
+ }
+ }
+ } else {
+ // if the keys in aliasIndexMap are not contained in keys in depMap, they are free
+ // e.g., x= y /\ x = z /\ t = "abc"
+ // aliasIndexMap[y]= x, aliasIndexMap[z] = x
+ // depMap t ~ "abc"(1)
+ // x should be free
+ std::map<expr*, int>::iterator itor2 = strVarMap.begin();
+ for (; itor2 != strVarMap.end(); itor2++) {
+ if (aliasIndexMap.find(itor2->first) != aliasIndexMap.end()) {
+ expr * var = aliasIndexMap[itor2->first];
+ if (depMap.find(var) == depMap.end()) {
+ if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
+ freeVarMap[var] = 1;
+ } else {
+ int lrConstainted = 0;
+ std::map<expr*, int>::iterator lrit = freeVarMap.begin();
+ for (; lrit != freeVarMap.end(); lrit++) {
+ if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
+ lrConstainted = 1;
+ break;
+ }
+ }
+ if (lrConstainted == 0) {
+ freeVarMap[var] = 1;
+ }
+ }
+ }
+ } else if (aliasIndexMap.find(itor2->first) == aliasIndexMap.end()) {
+ // if a variable is not in aliasIndexMap and not in depMap, it's free
+ if (depMap.find(itor2->first) == depMap.end()) {
+ expr * var = itor2->first;
+ if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
+ freeVarMap[var] = 1;
+ } else {
+ int lrConstainted = 0;
+ std::map<expr*, int>::iterator lrit = freeVarMap.begin();
+ for (; lrit != freeVarMap.end(); lrit++) {
+ if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
+ lrConstainted = 1;
+ break;
+ }
+ }
+ if (lrConstainted == 0) {
+ freeVarMap[var] = 1;
+ }
+ }
+ }
+ }
+ }
+
+ std::map<expr*, std::map<expr*, int> >::iterator itor = depMap.begin();
+ for (; itor != depMap.end(); itor++) {
+ for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
+ if (variable_set.find(itor1->first) != variable_set.end()) { // expr type = var
+ expr * var = get_alias_index_ast(aliasIndexMap, itor1->first);
+ // if a var is dep on itself and all dependence are type 2, it's a free variable
+ // e.g {y --> x(2), y(2), m --> m(2), n(2)} y,m are free
+ {
+ if (depMap.find(var) == depMap.end()) {
+ if (freeVarMap.find(var) == freeVarMap.end()) {
+ if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
+ freeVarMap[var] = 1;
+ } else {
+ int lrConstainted = 0;
+ std::map<expr*, int>::iterator lrit = freeVarMap.begin();
+ for (; lrit != freeVarMap.end(); lrit++) {
+ if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
+ lrConstainted = 1;
+ break;
+ }
+ }
+ if (lrConstainted == 0) {
+ freeVarMap[var] = 1;
+ }
+ }
+
+ } else {
+ freeVarMap[var] = freeVarMap[var] + 1;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return 0;
}
final_check_status theory_str::final_check_eh() {
@@ -2855,10 +3244,6 @@ final_check_status theory_str::final_check_eh() {
return FC_DONE;
}
- // TODO the rest...
- NOT_IMPLEMENTED_YET();
-
- /*
// Check every variable to see if it's eq. to some string constant.
// If not, mark it as free.
bool needToAssignFreeVars = false;
@@ -2877,18 +3262,10 @@ final_check_status theory_str::final_check_eh() {
return FC_DONE;
}
- for (std::set<expr*>::iterator it = free_variables.begin(); it != free_variables.end(); ++it) {
- expr * var = *it;
- if (internal_variable_set.find(var) != internal_variable_set.end()) {
- TRACE("t_str", tout << "assigning arbitrary string to internal variable " << mk_ismt2_pp(var, m) << std::endl;);
- app * val = m_strutil.mk_string("**unused**");
- assert_axiom(ctx.mk_eq_atom(var, val));
- } else {
- NOT_IMPLEMENTED_YET(); // TODO free variable assignment from strTheory::cb_final_check()
- }
- }
- return FC_CONTINUE;
- */
+
+
+ // TODO the rest...
+ NOT_IMPLEMENTED_YET();
}
void theory_str::init_model(model_generator & mg) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 684526602..3d0f14ca7 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -153,6 +153,10 @@ namespace smt {
void classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
+ expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
+ expr * getMostLeftNodeInConcat(expr * node);
+ expr * getMostRightNodeInConcat(expr * node);
+
void dump_assignments();
public:
theory_str(ast_manager & m);
From ac8b5e6eae5cf97146fafd4f1cc450cda7dc4a27 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 6 Nov 2015 14:10:18 -0500
Subject: [PATCH 056/401] free variable WIP
---
src/smt/theory_str.cpp | 160 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 3 +
2 files changed, 161 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 7d9aaad7d..cb31aedde 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3262,10 +3262,166 @@ final_check_status theory_str::final_check_eh() {
return FC_DONE;
}
+ // -----------------------------------------------------------
+ // variables in freeVar are those not bouned by Concats
+ // classify variables in freeVarMap:
+ // (1) freeVar = unroll(r1, t1)
+ // (2) vars are not bounded by either concat or unroll
+ // -----------------------------------------------------------
+ std::map<expr*, std::set<expr*> > fv_unrolls_map;
+ std::set<expr*> tmpSet;
+ expr * constValue = NULL;
+ for (std::map<expr*, int>::iterator fvIt2 = freeVar_map.begin(); fvIt2 != freeVar_map.end(); fvIt2++) {
+ expr * var = fvIt2->first;
+ tmpSet.clear();
+ get_eqc_allUnroll(var, constValue, tmpSet);
+ if (tmpSet.size() > 0) {
+ fv_unrolls_map[var] = tmpSet;
+ }
+ }
+ // erase var bounded by an unroll function from freeVar_map
+ for (std::map<expr*, std::set<expr*> >::iterator fvIt3 = fv_unrolls_map.begin();
+ fvIt3 != fv_unrolls_map.end(); fvIt3++) {
+ expr * var = fvIt3->first;
+ freeVar_map.erase(var);
+ }
+ // collect the case:
+ // * Concat(X, Y) = unroll(r1, t1) /\ Concat(X, Y) = unroll(r2, t2)
+ // concatEqUnrollsMap[Concat(X, Y)] = {unroll(r1, t1), unroll(r2, t2)}
- // TODO the rest...
- NOT_IMPLEMENTED_YET();
+ std::map<expr*, std::set<expr*> > concatEqUnrollsMap;
+ for (std::map<expr*, std::set<expr*> >::iterator urItor = unrollGroup_map.begin();
+ urItor != unrollGroup_map.end(); urItor++) {
+ expr * unroll = urItor->first;
+ expr * curr = unroll;
+ do {
+ if (is_concat(to_app(curr))) {
+ concatEqUnrollsMap[curr].insert(unroll);
+ concatEqUnrollsMap[curr].insert(unrollGroup_map[unroll].begin(), unrollGroup_map[unroll].end());
+ }
+ enode * e_curr = ctx.get_enode(curr);
+ curr = e_curr->get_next()->get_owner();
+ // curr = get_eqc_next(curr);
+ } while (curr != unroll);
+ }
+
+ std::map<expr*, std::set<expr*> > concatFreeArgsEqUnrollsMap;
+ std::set<expr*> fvUnrollSet;
+ for (std::map<expr*, std::set<expr*> >::iterator concatItor = concatEqUnrollsMap.begin();
+ concatItor != concatEqUnrollsMap.end(); concatItor++) {
+ expr * concat = concatItor->first;
+ expr * concatArg1 = to_app(concat)->get_arg(0);
+ expr * concatArg2 = to_app(concat)->get_arg(1);
+ bool arg1Bounded = false;
+ bool arg2Bounded = false;
+ // arg1
+ if (variable_set.find(concatArg1) != variable_set.end()) {
+ if (freeVar_map.find(concatArg1) == freeVar_map.end()) {
+ arg1Bounded = true;
+ } else {
+ fvUnrollSet.insert(concatArg1);
+ }
+ } else if (is_concat(to_app(concatArg1))) {
+ if (concatEqUnrollsMap.find(concatArg1) == concatEqUnrollsMap.end()) {
+ arg1Bounded = true;
+ }
+ }
+ // arg2
+ if (variable_set.find(concatArg2) != variable_set.end()) {
+ if (freeVar_map.find(concatArg2) == freeVar_map.end()) {
+ arg2Bounded = true;
+ } else {
+ fvUnrollSet.insert(concatArg2);
+ }
+ } else if (is_concat(to_app(concatArg2))) {
+ if (concatEqUnrollsMap.find(concatArg2) == concatEqUnrollsMap.end()) {
+ arg2Bounded = true;
+ }
+ }
+ if (!arg1Bounded && !arg2Bounded) {
+ concatFreeArgsEqUnrollsMap[concat].insert(
+ concatEqUnrollsMap[concat].begin(),
+ concatEqUnrollsMap[concat].end());
+ }
+ }
+ for (std::set<expr*>::iterator vItor = fvUnrollSet.begin(); vItor != fvUnrollSet.end(); vItor++) {
+ freeVar_map.erase(*vItor);
+ }
+
+ // Assign free variables
+ std::set<expr*> fSimpUnroll;
+
+ constValue = NULL;
+
+ // TODO this would be a great place to print debugging information
+
+ // TODO process_concat_eq_unroll()
+ /*
+ for (std::map<expr*, std::set<expr*> >::iterator fvIt2 = concatFreeArgsEqUnrollsMap.begin();
+ fvIt2 != concatFreeArgsEqUnrollsMap.end(); fvIt2++) {
+ expr * concat = fvIt2->first;
+ for (std::set<expr*>::iterator urItor = fvIt2->second.begin(); urItor != fvIt2->second.end(); urItor++) {
+ Z3_ast unroll = *urItor;
+ processConcatEqUnroll(concat, unroll);
+ }
+ }
+ */
+
+ // --------
+ // experimental free variable assignment - begin
+ // * special handling for variables that are not used in concat
+ // --------
+ bool testAssign = true;
+ if (!testAssign) {
+ for (std::map<expr*, int>::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) {
+ expr * freeVar = fvIt->first;
+ /*
+ std::string vName = std::string(Z3_ast_to_string(ctx, freeVar));
+ if (vName.length() >= 9 && vName.substr(0, 9) == "$$_regVar") {
+ continue;
+ }
+ */
+ // TODO if this variable represents a regular expression, continue
+ expr * toAssert = gen_len_val_options_for_free_var(freeVar, NULL, "");
+ if (toAssert != NULL) {
+ assert_axiom(toAssert);
+ }
+ }
+ } else {
+ process_free_var(freeVar_map);
+ }
+ // experimental free variable assignment - end
+
+ // TODO more unroll stuff
+ /*
+ for (std::map<expr*, std::set<expr*> >::iterator fvIt1 = fv_unrolls_map.begin();
+ fvIt1 != fv_unrolls_map.end(); fvIt1++) {
+ Z3_ast var = fvIt1->first;
+ fSimpUnroll.clear();
+ get_eqc_simpleUnroll(t, var, constValue, fSimpUnroll);
+ if (fSimpUnroll.size() == 0) {
+ genAssignUnrollReg(t, fv_unrolls_map[var]);
+ } else {
+ Z3_ast toAssert = genAssignUnrollStr2Reg(t, var, fSimpUnroll);
+ if (toAssert != NULL) {
+ addAxiom(t, toAssert, __LINE__);
+ }
+ }
+ }
+ */
+
+ return FC_CONTINUE; // since by this point we've added axioms
+}
+
+expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, std::string lenTesterValue) {
+ // TODO
+ NOT_IMPLEMENTED_YET();
+}
+
+void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
+ // TODO this one first
+ NOT_IMPLEMENTED_YET();
}
void theory_str::init_model(model_generator & mg) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 3d0f14ca7..60c2c3a8e 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -153,6 +153,9 @@ namespace smt {
void classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
+ expr * gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, std::string lenTesterValue);
+ void process_free_var(std::map<expr*, int> & freeVar_map);
+
expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
expr * getMostLeftNodeInConcat(expr * node);
expr * getMostRightNodeInConcat(expr * node);
From e9b31f29954ccc2252a5d122bcbe25b9f1601bc1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 6 Nov 2015 14:13:38 -0500
Subject: [PATCH 057/401] temporarily patched in a get_eqc_allUnroll()
implementation
---
src/smt/theory_str.cpp | 26 +++++++++++++++++++++++++-
src/smt/theory_str.h | 4 ++++
2 files changed, 29 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index cb31aedde..0965e7873 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3263,7 +3263,7 @@ final_check_status theory_str::final_check_eh() {
}
// -----------------------------------------------------------
- // variables in freeVar are those not bouned by Concats
+ // variables in freeVar are those not bounded by Concats
// classify variables in freeVarMap:
// (1) freeVar = unroll(r1, t1)
// (2) vars are not bounded by either concat or unroll
@@ -3424,6 +3424,30 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
NOT_IMPLEMENTED_YET();
}
+/*
+ * Collect all unroll functions
+ * and constant string in eqc of node n
+ */
+void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet) {
+ constStr = NULL;
+ unrollFuncSet.clear();
+ context & ctx = get_context();
+
+ expr * curr = n;
+ do {
+ if (is_string(to_app(curr))) {
+ constStr = curr;
+ } else if (false) /*(td->Unroll == Z3_get_app_decl(ctx, Z3_to_app(ctx, curr)))*/ { // TODO
+ if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
+ unrollFuncSet.insert(curr);
+ }
+ }
+ enode * e_curr = ctx.get_enode(curr);
+ curr = e_curr->get_next()->get_owner();
+ // curr = get_eqc_next(t, curr);
+ } while (curr != n);
+}
+
void theory_str::init_model(model_generator & mg) {
TRACE("t_str", tout << "initializing model" << std::endl; display(tout););
m_factory = alloc(str_value_factory, get_manager(), get_family_id());
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 60c2c3a8e..86f45aea0 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -160,6 +160,10 @@ namespace smt {
expr * getMostLeftNodeInConcat(expr * node);
expr * getMostRightNodeInConcat(expr * node);
+ // strRegex
+
+ void get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet);
+
void dump_assignments();
public:
theory_str(ast_manager & m);
From a9b8707d48fb8b474a6b49ba68d1f7e9fdf7d250 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 9 Nov 2015 15:14:34 -0500
Subject: [PATCH 058/401] possibly found a way to do get_parents()
---
src/smt/theory_str.cpp | 76 +++++++++++++++++++++++++++++++++++++++++-
1 file changed, 75 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 0965e7873..da5c858b8 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3420,7 +3420,81 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
}
void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
- // TODO this one first
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ std::set<expr*> eqcRepSet;
+ std::set<expr*> leafVarSet;
+ std::map<int, std::set<expr*> > aloneVars;
+
+ for (std::map<expr*, int>::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) {
+ expr * freeVar = fvIt->first;
+ /*
+ std::string vName = std::string(Z3_ast_to_string(ctx, freeVar));
+ if (vName.length() >= 9 && vName.substr(0, 9) == "$$_regVar") {
+ continue;
+ }
+ */
+ // TODO skip all regular expression vars
+
+ // Iterate the EQC of freeVar, its eqc variable should not be in the eqcRepSet.
+ // If found, have to filter it out
+ std::set<expr*> eqVarSet;
+ get_var_in_eqc(freeVar, eqVarSet);
+ bool duplicated = false;
+ expr * dupVar = NULL;
+ for (std::set<expr*>::iterator itorEqv = eqVarSet.begin(); itorEqv != eqVarSet.end(); itorEqv++) {
+ if (eqcRepSet.find(*itorEqv) != eqcRepSet.end()) {
+ duplicated = true;
+ dupVar = *itorEqv;
+ break;
+ }
+ }
+ if (duplicated && dupVar != NULL) {
+ STRACE("t_str_detail", tout << "Duplicated free variable found:" << mk_ismt2_pp(freeVar, m)
+ << " = " << mk_ismt2_pp(dupVar, m) << " (SKIP)" << std::endl;);
+ continue;
+ } else {
+ eqcRepSet.insert(freeVar);
+ }
+ }
+
+ for (std::set<expr*>::iterator fvIt = eqcRepSet.begin(); fvIt != eqcRepSet.end(); fvIt++) {
+ bool standAlone = true;
+ expr * freeVar = *fvIt;
+ // has length constraint initially
+ if (input_var_in_len.find(freeVar) != input_var_in_len.end()) {
+ standAlone = false;
+ }
+ // iterate parents
+ if (standAlone) {
+ // I hope this works!
+ enode * e_freeVar = ctx.get_enode(freeVar);
+ enode_vector::iterator it = e_freeVar->begin_parents();
+ for (; it != e_freeVar->end_parents(); ++it) {
+ expr * parentAst = (*it)->get_owner();
+ if (is_concat(to_app(parentAst))) {
+ standAlone = false;
+ break;
+ }
+ }
+ }
+
+ if (standAlone) {
+ // TODO
+ // int lenValue = getLenValue(freeVar);
+ int lenValue = -1;
+ if (lenValue != -1) {
+ leafVarSet.insert(freeVar);
+ } else {
+ aloneVars[lenValue].insert(freeVar);
+ }
+ } else {
+ leafVarSet.insert(freeVar);
+ }
+ }
+
+ // TODO the rest
NOT_IMPLEMENTED_YET();
}
From 0178872a19c0ad0cec339c2b9ebbe99453aa2c74 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 9 Nov 2015 15:33:52 -0500
Subject: [PATCH 059/401] completed process_free_var(), still WIP working on
gen_len_val_options_for_free_var()
---
src/smt/theory_str.cpp | 40 ++++++++++++++++++++++++++++++++++++++--
src/smt/theory_str.h | 3 +++
2 files changed, 41 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index da5c858b8..a235936d6 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2385,6 +2385,14 @@ void theory_str::set_up_axioms(expr * ex) {
if (is_concat(ap)) {
// if ex is a concat, set up concat axioms later
m_concat_axiom_todo.push_back(n);
+ } else if (is_strlen(ap)) {
+ // if the argument is a variable,
+ // keep track of this for later, we'll need it during model gen
+ expr * var = ap->get_arg(0);
+ app * aVar = to_app(var);
+ if (aVar->get_num_args() == 0 && !is_string(aVar)) {
+ input_var_in_len.insert(var);
+ }
} else if (ap->get_num_args() == 0 && !is_string(ap)) {
// if ex is a variable, add it to our list of variables
TRACE("t_str_detail", tout << "tracking variable" << std::endl;);
@@ -3419,6 +3427,20 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
NOT_IMPLEMENTED_YET();
}
+void theory_str::get_var_in_eqc(expr * n, std::set<expr*> & varSet) {
+ context & ctx = get_context();
+
+ expr * eqcNode = n;
+ do {
+ if (variable_set.find(eqcNode) != variable_set.end()) {
+ varSet.insert(eqcNode);
+ }
+ enode * e_eqc = ctx.get_enode(eqcNode);
+ eqcNode = e_eqc->get_next()->get_owner();
+ // eqcNode = Z3_theory_get_eqc_next(t, eqcNode);
+ } while (eqcNode != n);
+}
+
void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -3494,8 +3516,22 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
}
}
- // TODO the rest
- NOT_IMPLEMENTED_YET();
+ // TODO here's a great place for debugging info
+
+ for(std::set<expr*>::iterator itor1 = leafVarSet.begin();
+ itor1 != leafVarSet.end(); ++itor1) {
+ expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
+ assert_axiom(toAssert);
+ }
+
+ for (std::map<int, std::set<expr*> >::iterator mItor = aloneVars.begin();
+ mItor != aloneVars.end(); ++mItor) {
+ std::set<expr*>::iterator itor2 = mItor->second.begin();
+ for(; itor2 != mItor->second.end(); ++itor2) {
+ expr * toAssert = gen_len_val_options_for_free_var(*itor2, NULL, "");
+ assert_axiom(toAssert);
+ }
+ }
}
/*
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 86f45aea0..a4a89f947 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -82,6 +82,8 @@ namespace smt {
std::set<expr*> variable_set;
std::set<expr*> internal_variable_set;
+
+ std::set<expr*> input_var_in_len;
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
@@ -159,6 +161,7 @@ namespace smt {
expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
expr * getMostLeftNodeInConcat(expr * node);
expr * getMostRightNodeInConcat(expr * node);
+ void get_var_in_eqc(expr * n, std::set<expr*> & varSet);
// strRegex
From 6374d6316017ff772b2930c104215a39142917bc Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 9 Nov 2015 16:11:00 -0500
Subject: [PATCH 060/401] gen_len_val_options_for_free_var() WIP
---
src/smt/theory_str.cpp | 224 ++++++++++++++++++++++++++++++++++++++---
src/smt/theory_str.h | 8 ++
2 files changed, 219 insertions(+), 13 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a235936d6..c485c40ff 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -221,6 +221,24 @@ app * theory_str::mk_int(int n) {
return m_autil.mk_numeral(rational(n), true);
}
+expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ std::stringstream ss;
+ ss << "$$_len_" << mk_ismt2_pp(node, m) << "_" << lTries;
+ std::string name = ss.str();
+ return mk_str_var(name);
+
+ /*
+ Z3_context ctx = Z3_theory_get_context(t);
+ std::stringstream ss;
+ ss << "$$_len_" << Z3_ast_to_string(ctx, node) << "_" << lTries;
+ std::string name = ss.str();
+ return my_mk_str_var(t, name.c_str());
+ */
+}
+
app * theory_str::mk_internal_xor_var() {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -239,17 +257,26 @@ app * theory_str::mk_internal_xor_var() {
return a;
}
-/*
- Z3_context ctx = Z3_theory_get_context(t);
- PATheoryData * td = (PATheoryData *) Z3_theory_get_ext_data(t);
- std::stringstream ss;
- ss << tmpStringVarCount;
- tmpStringVarCount++;
- std::string name = "$$_str" + ss.str();
- Z3_ast varAst = mk_var(ctx, name.c_str(), td->String);
- nonEmptyStrVarAxiom(t, varAst, __LINE__);
- return varAst;
-*/
+app * theory_str::mk_str_var(std::string name) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ sort * string_sort = m.mk_sort(m_strutil.get_family_id(), STRING_SORT);
+ char * new_buffer = alloc_svect(char, name.length() + 1);
+ strcpy(new_buffer, name.c_str());
+ symbol sym(new_buffer);
+
+ app * a = m.mk_const(m.mk_const_decl(sym, string_sort));
+
+ // I have a hunch that this may not get internalized for free...
+ SASSERT(ctx.get_enode(a) != NULL);
+ m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
+
+ variable_set.insert(a);
+ internal_variable_set.insert(a);
+
+ return a;
+}
app * theory_str::mk_nonempty_str_var() {
context & ctx = get_context();
@@ -3422,9 +3449,180 @@ final_check_status theory_str::final_check_eh() {
return FC_CONTINUE; // since by this point we've added axioms
}
+inline std::string int_to_string(int i) {
+ std::stringstream ss;
+ ss << i;
+ return ss.str();
+}
+
+expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tries) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr * freeVarLen = mk_strlen(freeVar);
+
+ ptr_vector<expr> orList;
+ ptr_vector<expr> andList;
+
+ int distance = 3;
+ int l = (tries - 1) * distance;
+ int h = tries * distance;
+
+ for (int i = l; i < h; ++i) {
+ orList.push_back(m.mk_eq(indicator, m_strutil.mk_string(int_to_string(i).c_str())));
+ andList.push_back(m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVarLen, mk_int(i))));
+ }
+
+ orList.push_back(m.mk_eq(indicator, m_strutil.mk_string("more")));
+ andList.push_back(m.mk_eq(orList[orList.size() - 1], m_autil.mk_ge(freeVarLen, mk_int(h))));
+
+ expr ** or_items = alloc_svect(expr*, orList.size());
+ expr ** and_items = alloc_svect(expr*, andList.size() + 1);
+
+ for (int i = 0; i < orList.size(); ++i) {
+ or_items[i] = orList[i];
+ }
+
+ and_items[0] = m.mk_or(orList.size(), or_items);
+ for(int i = 0; i < andList.size(); ++i) {
+ and_items[i+1] = andList[i];
+ }
+ expr * lenTestAssert = m.mk_and(andList.size() + 1, and_items);
+
+ expr * assertL = NULL;
+ int testerCount = tries - 1;
+ if (testerCount > 0) {
+ expr ** and_items_LHS = alloc_svect(expr*, testerCount);
+ expr * moreAst = m_strutil.mk_string("more");
+ for (int i = 0; i < testerCount; ++i) {
+ and_items_LHS[i] = m.mk_eq(fvar_lenTester_map[freeVar][i], moreAst);
+ }
+ if (testerCount == 1) {
+ assertL = and_items_LHS[0];
+ } else {
+ assertL = m.mk_and(testerCount, and_items_LHS);
+ }
+ }
+
+ if (assertL != NULL) {
+ // return the axiom (assertL -> lenTestAssert)
+ // would like to use mk_implies() here but...
+ expr_ref lenTestAssert(m.mk_or(m.mk_not(assertL), lenTestAssert), m);
+ }
+
+ return lenTestAssert;
+
+}
+
+// -----------------------------------------------------------------------------------------------------
+// True branch will be taken in final_check:
+// - When we discover a variable is "free" for the first time
+// lenTesterInCbEq = NULL
+// lenTesterValue = ""
+// False branch will be taken when invoked by new_eq_eh().
+// - After we set up length tester for a "free" var in final_check,
+// when the tester is assigned to some value (e.g. "more" or "4"),
+// lenTesterInCbEq != NULL, and its value will be passed by lenTesterValue
+// The difference is that in new_eq_eh(), lenTesterInCbEq and its value have NOT been put into a same eqc
+// -----------------------------------------------------------------------------------------------------
expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, std::string lenTesterValue) {
- // TODO
- NOT_IMPLEMENTED_YET();
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ STRACE("t_str_detail", tout << "gen for free var " << mk_ismt2_pp(freeVar, m) << std::endl;);
+ // no length assertions for this free variable have ever been added.
+ if (fvar_len_count_map.find(freeVar) == fvar_len_count_map.end()) {
+ fvar_len_count_map[freeVar] = 1;
+ unsigned int testNum = fvar_len_count_map[freeVar];
+ expr * indicator = mk_internal_lenTest_var(freeVar, testNum);
+ fvar_lenTester_map[freeVar].push_back(indicator);
+ lenTester_fvar_map[indicator] = freeVar;
+
+ expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
+ return lenTestAssert;
+ } else {
+ /*
+ Z3_ast effectiveLenInd = NULL;
+ std::string effectiveLenIndiStr = "";
+ int lenTesterCount = (int) fvarLenTesterMap[freeVar].size();
+
+ int i = 0;
+ for (; i < lenTesterCount; i++) {
+ Z3_ast len_indicator_pre = fvarLenTesterMap[freeVar][i];
+ bool indicatorHasEqcValue = false;
+ Z3_ast len_indicator_value = get_eqc_value(t, len_indicator_pre, indicatorHasEqcValue);
+#ifdef DEBUGLOG
+ __debugPrint(logFile, "* length indicator ");
+ printZ3Node(t, len_indicator_pre);
+ __debugPrint(logFile, " = ");
+ printZ3Node(t, len_indicator_value);
+ __debugPrint(logFile, "\n");
+#endif
+ if (indicatorHasEqcValue) {
+ std::string len_pIndiStr = getConstStrValue(t, len_indicator_value);
+ if (len_pIndiStr != "more") {
+ effectiveLenInd = len_indicator_pre;
+ effectiveLenIndiStr = len_pIndiStr;
+ break;
+ }
+ } else {
+ if (lenTesterInCbEq != len_indicator_pre) {
+#ifdef DEBUGLOG
+ __debugPrint(logFile, "\n>> *Warning*: length indicator: ");
+ printZ3Node(t, len_indicator_pre);
+ __debugPrint(logFile, " doesn't have an EQC value. i = %d, lenTesterCount = %d\n", i , lenTesterCount);
+#endif
+ if (i > 0) {
+ effectiveLenInd = fvarLenTesterMap[freeVar][i - 1];
+ if (effectiveLenInd == lenTesterInCbEq) {
+ effectiveLenIndiStr = lenTesterValue;
+ } else {
+ bool effectiveHasEqcValue = false;
+ effectiveLenIndiStr = getConstStrValue(t, get_eqc_value(t, effectiveLenInd, effectiveHasEqcValue));
+ }
+ }
+ break;
+ }
+ // lenTesterInCbEq == len_indicator_pre
+ else {
+ if (lenTesterValue != "more") {
+ effectiveLenInd = len_indicator_pre;
+ effectiveLenIndiStr = lenTesterValue;
+ break;
+ }
+ }
+ }
+ }
+
+ if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "") {
+ Z3_ast indicator = NULL;
+ unsigned int testNum = 0;
+
+ __debugPrint(logFile, "\n>> effectiveLenIndiStr = %s, i = %d, lenTesterCount = %d\n", effectiveLenIndiStr.c_str(), i, lenTesterCount);
+
+ if (i == lenTesterCount) {
+ fvarLenCountMap[freeVar] = fvarLenCountMap[freeVar] + 1;
+ testNum = fvarLenCountMap[freeVar];
+ indicator = my_mk_internal_lenTest_var(t, freeVar, testNum);
+ fvarLenTesterMap[freeVar].push_back(indicator);
+ lenTesterFvarMap[indicator] = freeVar;
+ } else {
+ indicator = fvarLenTesterMap[freeVar][i];
+ testNum = i + 1;
+ }
+ Z3_ast lenTestAssert = genLenTestOptions(t, freeVar, indicator, testNum);
+ return lenTestAssert;
+ } else {
+ // length is fixed
+ Z3_ast valueAssert = genFreeVarOptions(t, freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, "");
+ return valueAssert;
+ }
+ */
+
+ // TODO
+ NOT_IMPLEMENTED_YET();
+ } // fVarLenCountMap.find(...)
}
void theory_str::get_var_in_eqc(expr * n, std::set<expr*> & varSet) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index a4a89f947..b7d93ef54 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -84,6 +84,11 @@ namespace smt {
std::set<expr*> internal_variable_set;
std::set<expr*> input_var_in_len;
+
+ std::map<expr*, unsigned int> fvar_len_count_map;
+ std::map<expr*, ptr_vector<expr> > fvar_lenTester_map;
+ std::map<expr*, expr*> lenTester_fvar_map;
+
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
@@ -99,6 +104,7 @@ namespace smt {
void add_cut_info_merge(expr * destNode, int slevel, expr * srcNode);
bool has_self_cut(expr * n1, expr * n2);
+ app * mk_str_var(std::string name);
app * mk_nonempty_str_var();
app * mk_internal_xor_var();
@@ -155,8 +161,10 @@ namespace smt {
void classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
+ expr * mk_internal_lenTest_var(expr * node, int lTries);
expr * gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, std::string lenTesterValue);
void process_free_var(std::map<expr*, int> & freeVar_map);
+ expr * gen_len_test_options(expr * freeVar, expr * indicator, int tries);
expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
expr * getMostLeftNodeInConcat(expr * node);
From 3a404c248d49a700ff50ed09db42859f4c660763 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 10 Nov 2015 12:40:01 -0500
Subject: [PATCH 061/401] gen_free_var_options() WIP
---
src/smt/theory_str.cpp | 124 +++++++++++++++++++++++++++++------------
src/smt/theory_str.h | 2 +
2 files changed, 90 insertions(+), 36 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index c485c40ff..2101fe7a5 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3455,6 +3455,65 @@ inline std::string int_to_string(int i) {
return ss.str();
}
+expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
+ std::string len_valueStr, expr * valTesterInCbEq, std::string valTesterValueStr) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ int len = atoi(len_valueStr.c_str());
+
+ if (fvar_valueTester_map[freeVar].find(len) == fvar_valueTester_map[freeVar].end()) {
+ int tries = 0;
+ expr * val_indicator = mk_internal_valTest_var(freeVar, len, tries);
+ valueTester_fvar_map[val_indicator] = freeVar;
+ fvar_valueTester_map[freeVar][len].push_back(std::make_pair(sLevel, val_indicator));
+ print_value_tester_list(fvar_valueTester_map[freeVar][len]);
+ return gen_val_options(freeVar, len_indicator, val_indicator, len_valueStr, tries);
+ } else {
+ // go through all previous value testers
+ // If some doesn't have an eqc value, add its assertion again.
+ int testerTotal = fvar_valueTester_map[freeVar][len].size();
+ int i = 0;
+ for (; i < testerTotal; i++) {
+ expr * aTester = fvarValueTesterMap[freeVar][len][i].second;
+
+ if (aTester == valTesterInCbEq) {
+ break;
+ }
+
+ bool anEqcHasValue = false;
+ // Z3_ast anEqc = get_eqc_value(t, aTester, anEqcHasValue);
+ get_eqc_value(aTester, anEqcHasValue);
+ if (!anEqcHasValue) {
+ STRACE("t_str_detail", "value tester " << mk_ismt2_pp(aTester, m)
+ << "doesn't have an equivalence class value." << std::endl;);
+
+ expr_ref makeupAssert(gen_val_options(freeVar, len_indicator, aTester, len_valueStr, i), m);
+
+ STRACE("t_str_detail", "var: " << mk_ismt2_pp(freeVar, m) << std::endl
+ << mk_ismt2_pp(makeupAssert, m) << std::endl;);
+ assert_axiom(makeupAssert);
+ }
+ }
+
+ if (valTesterValueStr == "more") {
+ expr * valTester = NULL;
+ if (i + 1 < testerTotal) {
+ valTester = fvar_valueTester_map[freeVar][len][i + 1].second;
+ } else {
+ valTester = mk_internal_valTest_var(freeVar, len, i + 1);
+ valueTester_fvar_map[valTester] = freeVar;
+ fvar_valueTester_map[freeVar][len].push_back(std::make_pair(sLevel, valTester));
+ print_value_tester_list(fvar_valueTester_map[freeVar][len]);
+ }
+ expr_ref nextAssert(gen_val_options(freeVar, len_indicator, valTester, len_valueStr, i + 1), m);
+ return nextAssert;
+ }
+
+ return NULL;
+ }
+}
+
expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tries) {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -3542,25 +3601,22 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
return lenTestAssert;
} else {
- /*
- Z3_ast effectiveLenInd = NULL;
+
+ expr * effectiveLenInd = NULL;
std::string effectiveLenIndiStr = "";
- int lenTesterCount = (int) fvarLenTesterMap[freeVar].size();
+ int lenTesterCount = (int) fvar_lenTester_map[freeVar].size();
int i = 0;
- for (; i < lenTesterCount; i++) {
- Z3_ast len_indicator_pre = fvarLenTesterMap[freeVar][i];
+ for (; i < lenTesterCount; ++i) {
+ expr * len_indicator_pre = fvar_lenTester_map[freeVar][i];
bool indicatorHasEqcValue = false;
- Z3_ast len_indicator_value = get_eqc_value(t, len_indicator_pre, indicatorHasEqcValue);
-#ifdef DEBUGLOG
- __debugPrint(logFile, "* length indicator ");
- printZ3Node(t, len_indicator_pre);
- __debugPrint(logFile, " = ");
- printZ3Node(t, len_indicator_value);
- __debugPrint(logFile, "\n");
-#endif
+ expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
+ STRACE("t_str_detail", tout << "length indicator " << mk_ismt2_pp(len_indicator_pre, m) <<
+ " = " << mk_ismt2_pp(len_indicator_value, m) << std::endl;);
if (indicatorHasEqcValue) {
- std::string len_pIndiStr = getConstStrValue(t, len_indicator_value);
+ const char * val = 0;
+ m_strutil.is_string(len_indicator_value, & val);
+ std::string len_pIndiStr(val);
if (len_pIndiStr != "more") {
effectiveLenInd = len_indicator_pre;
effectiveLenIndiStr = len_pIndiStr;
@@ -3568,18 +3624,18 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
}
} else {
if (lenTesterInCbEq != len_indicator_pre) {
-#ifdef DEBUGLOG
- __debugPrint(logFile, "\n>> *Warning*: length indicator: ");
- printZ3Node(t, len_indicator_pre);
- __debugPrint(logFile, " doesn't have an EQC value. i = %d, lenTesterCount = %d\n", i , lenTesterCount);
-#endif
+ STRACE("t_str", tout << "WARNING: length indicator " << mk_ismt2_pp(len_indicator_pre, m)
+ << " does not have an equivalence class value."
+ << " i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
if (i > 0) {
effectiveLenInd = fvarLenTesterMap[freeVar][i - 1];
if (effectiveLenInd == lenTesterInCbEq) {
effectiveLenIndiStr = lenTesterValue;
} else {
bool effectiveHasEqcValue = false;
- effectiveLenIndiStr = getConstStrValue(t, get_eqc_value(t, effectiveLenInd, effectiveHasEqcValue));
+ const char * val = 0;
+ m_strutil.is_string(get_eqc_value(effectiveLenInd, effectiveHasEqcValue), & val);
+ effectiveLenIndiStr = val;
}
}
break;
@@ -3592,36 +3648,32 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
break;
}
}
- }
- }
-
+ } // !indicatorHasEqcValue
+ } // for (i : [0..lenTesterCount-1])
if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "") {
- Z3_ast indicator = NULL;
+ expr * indicator = NULL;
unsigned int testNum = 0;
- __debugPrint(logFile, "\n>> effectiveLenIndiStr = %s, i = %d, lenTesterCount = %d\n", effectiveLenIndiStr.c_str(), i, lenTesterCount);
+ STRACE("t_str", tout << "effectiveLenIndiStr = " << effectiveLenIndiStr
+ << ", i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
if (i == lenTesterCount) {
- fvarLenCountMap[freeVar] = fvarLenCountMap[freeVar] + 1;
- testNum = fvarLenCountMap[freeVar];
- indicator = my_mk_internal_lenTest_var(t, freeVar, testNum);
- fvarLenTesterMap[freeVar].push_back(indicator);
- lenTesterFvarMap[indicator] = freeVar;
+ fvar_len_count_map[freeVar] = fvar_len_count_map[freeVar] + 1;
+ testNum = fvar_len_count_map[freeVar];
+ indicator = mk_internal_lenTest_var(freeVar, testNum);
+ fvar_lenTester_map[freeVar].push_back(indicator);
+ lenTester_fvar_map[indicator] = freeVar;
} else {
indicator = fvarLenTesterMap[freeVar][i];
testNum = i + 1;
}
- Z3_ast lenTestAssert = genLenTestOptions(t, freeVar, indicator, testNum);
+ expr_ref lenTestAssert(gen_len_test_options(freeVar, indicator, testNum), m);
return lenTestAssert;
} else {
// length is fixed
- Z3_ast valueAssert = genFreeVarOptions(t, freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, "");
+ expr_ref valueAssert(gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, ""), m);
return valueAssert;
}
- */
-
- // TODO
- NOT_IMPLEMENTED_YET();
} // fVarLenCountMap.find(...)
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index b7d93ef54..bd26f2564 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -165,6 +165,8 @@ namespace smt {
expr * gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, std::string lenTesterValue);
void process_free_var(std::map<expr*, int> & freeVar_map);
expr * gen_len_test_options(expr * freeVar, expr * indicator, int tries);
+ expr * gen_free_var_options(expr * freeVar, expr * len_indicator,
+ std::string len_valueStr, expr * valTesterInCbEq, std::string valTesterValueStr);
expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
expr * getMostLeftNodeInConcat(expr * node);
From 8b538f584031907a2802551d36bcbfaf256b9c4a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 11 Nov 2015 15:34:11 -0500
Subject: [PATCH 062/401] started gen_val_options() WIP
---
src/smt/theory_str.cpp | 146 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 7 ++
2 files changed, 152 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 2101fe7a5..f86f921de 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -239,6 +239,23 @@ expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
*/
}
+expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ std::stringstream ss;
+ ss << "$$_val_" << mk_ismt2_pp(node, m) << "_" << len << "_" << vTries;
+ std::string name = ss.str();
+ return mk_str_var(name);
+
+ /*
+ Z3_context ctx = Z3_theory_get_context(t);
+ std::stringstream ss;
+ ss << "$$_val_" << Z3_ast_to_string(ctx, node) << "_" << len << "_" << vTries;
+ std::string name = ss.str();
+ return my_mk_str_var(t, name.c_str());
+ */
+}
+
app * theory_str::mk_internal_xor_var() {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -3455,6 +3472,133 @@ inline std::string int_to_string(int i) {
return ss.str();
}
+inline std::string longlong_to_string(long long i) {
+ std::stringstream ss;
+ ss << i;
+ return ss.str();
+}
+
+void theory_str::print_value_tester_list(std::vector<std::pair<int, expr*> > & testerList) {
+ ast_manager & m = get_manager();
+ STRACE("t_str_detail",
+ int ss = testerList.size();
+ tout << "valueTesterList = {";
+ for (int i = 0; i < ss; ++i) {
+ if (i % 4 == 0) {
+ tout << std::endl;
+ }
+ tout << "(" << testerList[i].first << ", ";
+ tout << mk_ismt2_pp(testerList[i].second, m);
+ tout << "), ";
+ }
+ tout << std::endl << "}" << std::endl;
+ );
+}
+
+expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
+ std::string lenStr, int tries) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ int distance = 32;
+
+ // ----------------------------------------------------------------------------------------
+ // generate value options encoding
+ // encoding is a vector of size (len + 1)
+ // e.g, len = 2,
+ // encoding {1, 2, 0} means the value option is "charSet[2]"."charSet[1]"
+ // the last item in the encoding indicates whether the whole space is covered
+ // for example, if the charSet = {a, b}. All valid encodings are
+ // {0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {1, 1, 0}
+ // if add 1 to the last one, we get
+ // {0, 0, 1}
+ // the last item "1" shows this is not a valid encoding, and we have covered all space
+ // ----------------------------------------------------------------------------------------
+ int len = atoi(lenStr.c_str());
+ bool coverAll = false;
+ std::vector<std::vector<int> > options;
+ std::vector<int> base;
+
+ if (tries == 0) {
+ base = std::vector<int>(len + 1, 0);
+ coverAll = false;
+ } else {
+ expr * lastestValIndi = fvar_valueTester_map[freeVar][len][tries - 1].second;
+ STRACE("t_str_detail", tout << "last value tester = " << mk_ismt2_pp(lastestValIndi, m) << std::endl;);
+ coverAll = get_next_val_encode(valRangeMap[lastestValIndi], base);
+ }
+
+ long long l = (tries) * distance;
+ long long h = l;
+ for (int i = 0; i < distance; i++) {
+ if (coverAll)
+ break;
+ options.push_back(base);
+ h++;
+ coverAll = getNextValEncode(options[options.size() - 1], base);
+ }
+ valRangeMap[val_indicator] = options[options.size() - 1];
+
+ STRACE("t_str_detail", tout << "value tester encoding " << printVectorInt(valRangeMap[val_indicator]) << std::endl;);
+
+ // ----------------------------------------------------------------------------------------
+
+ std::vector<expr*> orList;
+ std::vector<expr*> andList;
+
+ for (long long i = l; i < h; i++) {
+ orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string(longlong_to_string(i).c_str()) ));
+ std::string aStr = gen_val_string(len, options[i - l]);
+ expr_ref strAst(m_strutil.mk_string(aStr), m);
+ andList.push_back(m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVar, strAst)));
+ }
+ if (!coverAll) {
+ orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string("more")));
+ }
+
+ Z3_ast * or_items = new Z3_ast[orList.size()];
+ Z3_ast * and_items = new Z3_ast[andList.size() + 1];
+ for (int i = 0; i < (int) orList.size(); i++) {
+ or_items[i] = orList[i];
+ }
+ if (orList.size() > 1)
+ and_items[0] = Z3_mk_or(ctx, orList.size(), or_items);
+ else
+ and_items[0] = or_items[0];
+
+ for (int i = 0; i < (int) andList.size(); i++) {
+ and_items[i + 1] = andList[i];
+ }
+ Z3_ast valTestAssert = Z3_mk_and(ctx, andList.size() + 1, and_items);
+ delete[] or_items;
+ delete[] and_items;
+
+ // ---------------------------------------
+ // IF the new value tester is $$_val_x_16_i
+ // Should add ($$_len_x_j = 16) /\ ($$_val_x_16_i = "more")
+ // ---------------------------------------
+ andList.clear();
+ andList.push_back(Z3_mk_eq(ctx, len_indicator, my_mk_str_value(t, lenStr.c_str())));
+ for (int i = 0; i < tries; i++) {
+ Z3_ast vTester = fvarValueTesterMap[freeVar][len][i].second;
+ if (vTester != val_indicator)
+ andList.push_back(Z3_mk_eq(ctx, vTester, my_mk_str_value(t, "more")));
+ }
+ Z3_ast assertL = NULL;
+ if (andList.size() == 1) {
+ assertL = andList[0];
+ } else {
+ Z3_ast * and_items = new Z3_ast[andList.size()];
+ for (int i = 0; i < (int) andList.size(); i++) {
+ and_items[i] = andList[i];
+ }
+ assertL = Z3_mk_and(ctx, andList.size(), and_items);
+ }
+
+ valTestAssert = Z3_mk_implies(ctx, assertL, valTestAssert);
+ return valTestAssert;
+}
+
expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
std::string len_valueStr, expr * valTesterInCbEq, std::string valTesterValueStr) {
context & ctx = get_context();
@@ -3475,7 +3619,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
int testerTotal = fvar_valueTester_map[freeVar][len].size();
int i = 0;
for (; i < testerTotal; i++) {
- expr * aTester = fvarValueTesterMap[freeVar][len][i].second;
+ expr * aTester = fvar_valueTester_map[freeVar][len][i].second;
if (aTester == valTesterInCbEq) {
break;
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index bd26f2564..c9432921a 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -89,6 +89,9 @@ namespace smt {
std::map<expr*, ptr_vector<expr> > fvar_lenTester_map;
std::map<expr*, expr*> lenTester_fvar_map;
+ std::map<expr*, std::map<int, std::vector<std::pair<int, expr*> > > > fvar_valueTester_map;
+ std::map<expr*, expr*> valueTester_fvar_map;
+
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
@@ -107,6 +110,7 @@ namespace smt {
app * mk_str_var(std::string name);
app * mk_nonempty_str_var();
app * mk_internal_xor_var();
+ expr * mk_internal_valTest_var(expr * node, int len, int vTries);
bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
@@ -167,6 +171,9 @@ namespace smt {
expr * gen_len_test_options(expr * freeVar, expr * indicator, int tries);
expr * gen_free_var_options(expr * freeVar, expr * len_indicator,
std::string len_valueStr, expr * valTesterInCbEq, std::string valTesterValueStr);
+ expr * gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
+ std::string lenStr, int tries);
+ void print_value_tester_list(std::vector<std::pair<int, expr*> > & testerList);
expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
expr * getMostLeftNodeInConcat(expr * node);
From 9beeb09acf44b8a5d0dc442cf27a1132205f33e9 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 15 Nov 2015 15:18:14 -0500
Subject: [PATCH 063/401] model gen possibly done, but I doubt it works so WIP
---
src/smt/theory_str.cpp | 76 ++++++++++++++++++++++++++++++++----------
src/smt/theory_str.h | 6 ++++
2 files changed, 65 insertions(+), 17 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f86f921de..1961a3e36 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3495,6 +3495,48 @@ void theory_str::print_value_tester_list(std::vector<std::pair<int, expr*> > & t
);
}
+std::string theory_str::gen_val_string(int len, std::vector<int> & encoding) {
+ SASSERT(charSetSize > 0);
+
+ std::string re = std::string(len, charSet[0]);
+ for (int i = 0; i < (int) encoding.size() - 1; i++) {
+ int idx = encoding[i];
+ re[len - 1 - i] = charSet[idx];
+ }
+ return re;
+}
+
+/*
+ * The return value indicates whether we covered the search space.
+ * - If the next encoding is valid, return false
+ * - Otherwise, return true
+ */
+bool theory_str::get_next_val_encode(std::vector<int> & base, std::vector<int> & next) {
+ int s = 0;
+ int carry = 0;
+ next.clear();
+
+ for (int i = 0; i < (int) base.size(); i++) {
+ if (i == 0) {
+ s = base[i] + 1;
+ carry = s / charSetSize;
+ s = s % charSetSize;
+ next.push_back(s);
+ } else {
+ s = base[i] + carry;
+ carry = s / charSetSize;
+ s = s % charSetSize;
+ next.push_back(s);
+ }
+ }
+ if (next[next.size() - 1] > 0) {
+ next.clear();
+ return true;
+ } else {
+ return false;
+ }
+}
+
expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
std::string lenStr, int tries) {
context & ctx = get_context();
@@ -3525,7 +3567,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
} else {
expr * lastestValIndi = fvar_valueTester_map[freeVar][len][tries - 1].second;
STRACE("t_str_detail", tout << "last value tester = " << mk_ismt2_pp(lastestValIndi, m) << std::endl;);
- coverAll = get_next_val_encode(valRangeMap[lastestValIndi], base);
+ coverAll = get_next_val_encode(val_range_map[lastestValIndi], base);
}
long long l = (tries) * distance;
@@ -3535,9 +3577,9 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
break;
options.push_back(base);
h++;
- coverAll = getNextValEncode(options[options.size() - 1], base);
+ coverAll = get_next_val_encode(options[options.size() - 1], base);
}
- valRangeMap[val_indicator] = options[options.size() - 1];
+ val_range_map[val_indicator] = options[options.size() - 1];
STRACE("t_str_detail", tout << "value tester encoding " << printVectorInt(valRangeMap[val_indicator]) << std::endl;);
@@ -3556,46 +3598,46 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string("more")));
}
- Z3_ast * or_items = new Z3_ast[orList.size()];
- Z3_ast * and_items = new Z3_ast[andList.size() + 1];
+ expr ** or_items = alloc_svect(expr*, orList.size());
+ expr ** and_items = alloc_svect(expr*, andList.size() + 1);
+
for (int i = 0; i < (int) orList.size(); i++) {
or_items[i] = orList[i];
}
if (orList.size() > 1)
- and_items[0] = Z3_mk_or(ctx, orList.size(), or_items);
+ and_items[0] = m.mk_or(orList.size(), or_items);
else
and_items[0] = or_items[0];
for (int i = 0; i < (int) andList.size(); i++) {
and_items[i + 1] = andList[i];
}
- Z3_ast valTestAssert = Z3_mk_and(ctx, andList.size() + 1, and_items);
- delete[] or_items;
- delete[] and_items;
+ expr * valTestAssert = m.mk_and(andList.size() + 1, and_items);
// ---------------------------------------
- // IF the new value tester is $$_val_x_16_i
+ // If the new value tester is $$_val_x_16_i
// Should add ($$_len_x_j = 16) /\ ($$_val_x_16_i = "more")
// ---------------------------------------
andList.clear();
- andList.push_back(Z3_mk_eq(ctx, len_indicator, my_mk_str_value(t, lenStr.c_str())));
+ andList.push_back(m.mk_eq(len_indicator, m_strutil.mk_string(lenStr.c_str())));
for (int i = 0; i < tries; i++) {
- Z3_ast vTester = fvarValueTesterMap[freeVar][len][i].second;
+ expr * vTester = fvar_valueTester_map[freeVar][len][i].second;
if (vTester != val_indicator)
- andList.push_back(Z3_mk_eq(ctx, vTester, my_mk_str_value(t, "more")));
+ andList.push_back(m.mk_eq(vTester, m_strutil.mk_string("more")));
}
- Z3_ast assertL = NULL;
+ expr * assertL = NULL;
if (andList.size() == 1) {
assertL = andList[0];
} else {
- Z3_ast * and_items = new Z3_ast[andList.size()];
+ expr ** and_items = alloc_svect(expr*, andList.size());
for (int i = 0; i < (int) andList.size(); i++) {
and_items[i] = andList[i];
}
- assertL = Z3_mk_and(ctx, andList.size(), and_items);
+ assertL = m.mk_and(andList.size(), and_items);
}
- valTestAssert = Z3_mk_implies(ctx, assertL, valTestAssert);
+ // (assertL => valTestAssert) <=> (!assertL OR valTestAssert)
+ valTestAssert = m.mk_or(m.mk_not(assertL), valTestAssert);
return valTestAssert;
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index c9432921a..b7a63edb3 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -92,6 +92,10 @@ namespace smt {
std::map<expr*, std::map<int, std::vector<std::pair<int, expr*> > > > fvar_valueTester_map;
std::map<expr*, expr*> valueTester_fvar_map;
+ std::map<expr*, std::vector<int> > val_range_map;
+
+ int charSetSize = 0;
+
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
@@ -174,6 +178,8 @@ namespace smt {
expr * gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
std::string lenStr, int tries);
void print_value_tester_list(std::vector<std::pair<int, expr*> > & testerList);
+ bool get_next_val_encode(std::vector<int> & base, std::vector<int> & next);
+ std::string gen_val_string(int len, std::vector<int> & encoding);
expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
expr * getMostLeftNodeInConcat(expr * node);
From b34fc06fe95645db09b8b3eb1778c9607e0c1e94 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 20 Nov 2015 12:24:23 -0500
Subject: [PATCH 064/401] fix all compilation errors, now to test it
---
src/smt/theory_str.cpp | 71 +++++++++++++++++++++---------------------
src/smt/theory_str.h | 13 ++++----
2 files changed, 42 insertions(+), 42 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 1961a3e36..068745d94 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -32,7 +32,9 @@ theory_str::theory_str(ast_manager & m):
tmpStringVarCount(0),
tmpXorVarCount(0),
avoidLoopCut(true),
- loopDetected(false)
+ loopDetected(false),
+ char_set(NULL),
+ charSetSize(0)
{
}
@@ -222,7 +224,6 @@ app * theory_str::mk_int(int n) {
}
expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
- context & ctx = get_context();
ast_manager & m = get_manager();
std::stringstream ss;
@@ -240,7 +241,6 @@ expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
}
expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
- context & ctx = get_context();
ast_manager & m = get_manager();
std::stringstream ss;
ss << "$$_val_" << mk_ismt2_pp(node, m) << "_" << len << "_" << vTries;
@@ -257,7 +257,6 @@ expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
}
app * theory_str::mk_internal_xor_var() {
- context & ctx = get_context();
ast_manager & m = get_manager();
std::stringstream ss;
ss << tmpXorVarCount;
@@ -296,7 +295,6 @@ app * theory_str::mk_str_var(std::string name) {
}
app * theory_str::mk_nonempty_str_var() {
- context & ctx = get_context();
ast_manager & m = get_manager();
std::stringstream ss;
ss << tmpStringVarCount;
@@ -435,12 +433,10 @@ void theory_str::instantiate_concat_axiom(enode * cat) {
SASSERT(is_concat(cat));
app * a_cat = cat->get_owner();
- context & ctx = get_context();
ast_manager & m = get_manager();
// build LHS
expr_ref len_xy(m);
- // TODO re-use ASTs for length subexpressions, like in old Z3-str?
// TODO should we use str_util for these and other expressions?
len_xy = mk_strlen(a_cat);
SASSERT(len_xy);
@@ -2580,9 +2576,6 @@ void theory_str::dump_assignments() {
void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap,
std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
// check whether the node is a non-internal string variable;
// testing set membership here bypasses several expensive checks
if (variable_set.find(node) != variable_set.end()
@@ -2620,7 +2613,6 @@ void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap
}
}
// recursively visit all arguments
- app * aNode = to_app(node);
for (unsigned i = 0; i < aNode->get_num_args(); ++i) {
expr * arg = aNode->get_arg(i);
classify_ast_by_type(arg, varMap, concatMap, unrollMap);
@@ -2964,7 +2956,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
STRACE("t_str_detail", tout << "var in unroll = " <<
mk_ismt2_pp(itor2->first, m) << std::endl
- << "dealiased var = " << mk_ismt2_pp(varInFunc) << std::endl;);
+ << "dealiased var = " << mk_ismt2_pp(varInFunc, m) << std::endl;);
// it's possible that we have both (Unroll $$_regVar_0 $$_unr_0) /\ (Unroll abcd $$_unr_0),
// while $$_regVar_0 = "abcd"
@@ -3280,7 +3272,6 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
}
final_check_status theory_str::final_check_eh() {
- ast_manager & m = get_manager();
context & ctx = get_context();
TRACE("t_str", tout << "final check" << std::endl;);
@@ -3478,7 +3469,7 @@ inline std::string longlong_to_string(long long i) {
return ss.str();
}
-void theory_str::print_value_tester_list(std::vector<std::pair<int, expr*> > & testerList) {
+void theory_str::print_value_tester_list(svector<std::pair<int, expr*> > & testerList) {
ast_manager & m = get_manager();
STRACE("t_str_detail",
int ss = testerList.size();
@@ -3495,13 +3486,14 @@ void theory_str::print_value_tester_list(std::vector<std::pair<int, expr*> > & t
);
}
-std::string theory_str::gen_val_string(int len, std::vector<int> & encoding) {
+std::string theory_str::gen_val_string(int len, int_vector & encoding) {
SASSERT(charSetSize > 0);
+ SASSERT(char_set != NULL);
- std::string re = std::string(len, charSet[0]);
+ std::string re = std::string(len, char_set[0]);
for (int i = 0; i < (int) encoding.size() - 1; i++) {
int idx = encoding[i];
- re[len - 1 - i] = charSet[idx];
+ re[len - 1 - i] = char_set[idx];
}
return re;
}
@@ -3511,10 +3503,10 @@ std::string theory_str::gen_val_string(int len, std::vector<int> & encoding) {
* - If the next encoding is valid, return false
* - Otherwise, return true
*/
-bool theory_str::get_next_val_encode(std::vector<int> & base, std::vector<int> & next) {
+bool theory_str::get_next_val_encode(int_vector & base, int_vector & next) {
int s = 0;
int carry = 0;
- next.clear();
+ next.reset();
for (int i = 0; i < (int) base.size(); i++) {
if (i == 0) {
@@ -3530,7 +3522,7 @@ bool theory_str::get_next_val_encode(std::vector<int> & base, std::vector<int> &
}
}
if (next[next.size() - 1] > 0) {
- next.clear();
+ next.reset();
return true;
} else {
return false;
@@ -3539,7 +3531,6 @@ bool theory_str::get_next_val_encode(std::vector<int> & base, std::vector<int> &
expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
std::string lenStr, int tries) {
- context & ctx = get_context();
ast_manager & m = get_manager();
int distance = 32;
@@ -3558,11 +3549,11 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
// ----------------------------------------------------------------------------------------
int len = atoi(lenStr.c_str());
bool coverAll = false;
- std::vector<std::vector<int> > options;
- std::vector<int> base;
+ svector<int_vector> options;
+ int_vector base;
if (tries == 0) {
- base = std::vector<int>(len + 1, 0);
+ base = int_vector(len + 1, 0);
coverAll = false;
} else {
expr * lastestValIndi = fvar_valueTester_map[freeVar][len][tries - 1].second;
@@ -3581,12 +3572,20 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
}
val_range_map[val_indicator] = options[options.size() - 1];
- STRACE("t_str_detail", tout << "value tester encoding " << printVectorInt(valRangeMap[val_indicator]) << std::endl;);
+ STRACE("t_str_detail",
+ tout << "value tester encoding " << "{" << std::endl;
+ int_vector vec = val_range_map[val_indicator];
+
+ for (int_vector::iterator it = vec.begin(); it != vec.end(); ++it) {
+ tout << *it << std::endl;
+ }
+ tout << "}" << std::endl;
+ );
// ----------------------------------------------------------------------------------------
- std::vector<expr*> orList;
- std::vector<expr*> andList;
+ ptr_vector<expr> orList;
+ ptr_vector<expr> andList;
for (long long i = l; i < h; i++) {
orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string(longlong_to_string(i).c_str()) ));
@@ -3618,7 +3617,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
// If the new value tester is $$_val_x_16_i
// Should add ($$_len_x_j = 16) /\ ($$_val_x_16_i = "more")
// ---------------------------------------
- andList.clear();
+ andList.reset();
andList.push_back(m.mk_eq(len_indicator, m_strutil.mk_string(lenStr.c_str())));
for (int i = 0; i < tries; i++) {
expr * vTester = fvar_valueTester_map[freeVar][len][i].second;
@@ -3646,6 +3645,8 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
context & ctx = get_context();
ast_manager & m = get_manager();
+ int sLevel = ctx.get_scope_level();
+
int len = atoi(len_valueStr.c_str());
if (fvar_valueTester_map[freeVar].find(len) == fvar_valueTester_map[freeVar].end()) {
@@ -3671,12 +3672,12 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
// Z3_ast anEqc = get_eqc_value(t, aTester, anEqcHasValue);
get_eqc_value(aTester, anEqcHasValue);
if (!anEqcHasValue) {
- STRACE("t_str_detail", "value tester " << mk_ismt2_pp(aTester, m)
+ STRACE("t_str_detail", tout << "value tester " << mk_ismt2_pp(aTester, m)
<< "doesn't have an equivalence class value." << std::endl;);
expr_ref makeupAssert(gen_val_options(freeVar, len_indicator, aTester, len_valueStr, i), m);
- STRACE("t_str_detail", "var: " << mk_ismt2_pp(freeVar, m) << std::endl
+ STRACE("t_str_detail", tout << "var: " << mk_ismt2_pp(freeVar, m) << std::endl
<< mk_ismt2_pp(makeupAssert, m) << std::endl;);
assert_axiom(makeupAssert);
}
@@ -3701,7 +3702,6 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
}
expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tries) {
- context & ctx = get_context();
ast_manager & m = get_manager();
expr * freeVarLen = mk_strlen(freeVar);
@@ -3724,12 +3724,12 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
expr ** or_items = alloc_svect(expr*, orList.size());
expr ** and_items = alloc_svect(expr*, andList.size() + 1);
- for (int i = 0; i < orList.size(); ++i) {
+ for (unsigned i = 0; i < orList.size(); ++i) {
or_items[i] = orList[i];
}
and_items[0] = m.mk_or(orList.size(), or_items);
- for(int i = 0; i < andList.size(); ++i) {
+ for(unsigned i = 0; i < andList.size(); ++i) {
and_items[i+1] = andList[i];
}
expr * lenTestAssert = m.mk_and(andList.size() + 1, and_items);
@@ -3772,7 +3772,6 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
// -----------------------------------------------------------------------------------------------------
expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, std::string lenTesterValue) {
- context & ctx = get_context();
ast_manager & m = get_manager();
STRACE("t_str_detail", tout << "gen for free var " << mk_ismt2_pp(freeVar, m) << std::endl;);
@@ -3814,7 +3813,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
<< " does not have an equivalence class value."
<< " i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
if (i > 0) {
- effectiveLenInd = fvarLenTesterMap[freeVar][i - 1];
+ effectiveLenInd = fvar_lenTester_map[freeVar][i - 1];
if (effectiveLenInd == lenTesterInCbEq) {
effectiveLenIndiStr = lenTesterValue;
} else {
@@ -3850,7 +3849,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
fvar_lenTester_map[freeVar].push_back(indicator);
lenTester_fvar_map[indicator] = freeVar;
} else {
- indicator = fvarLenTesterMap[freeVar][i];
+ indicator = fvar_lenTester_map[freeVar][i];
testNum = i + 1;
}
expr_ref lenTestAssert(gen_len_test_options(freeVar, indicator, testNum), m);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index b7a63edb3..2f23ce43e 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -89,12 +89,13 @@ namespace smt {
std::map<expr*, ptr_vector<expr> > fvar_lenTester_map;
std::map<expr*, expr*> lenTester_fvar_map;
- std::map<expr*, std::map<int, std::vector<std::pair<int, expr*> > > > fvar_valueTester_map;
+ std::map<expr*, std::map<int, svector<std::pair<int, expr*> > > > fvar_valueTester_map;
std::map<expr*, expr*> valueTester_fvar_map;
- std::map<expr*, std::vector<int> > val_range_map;
+ std::map<expr*, int_vector> val_range_map;
- int charSetSize = 0;
+ char * char_set;
+ int charSetSize;
protected:
void assert_axiom(expr * e);
@@ -177,9 +178,9 @@ namespace smt {
std::string len_valueStr, expr * valTesterInCbEq, std::string valTesterValueStr);
expr * gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
std::string lenStr, int tries);
- void print_value_tester_list(std::vector<std::pair<int, expr*> > & testerList);
- bool get_next_val_encode(std::vector<int> & base, std::vector<int> & next);
- std::string gen_val_string(int len, std::vector<int> & encoding);
+ void print_value_tester_list(svector<std::pair<int, expr*> > & testerList);
+ bool get_next_val_encode(int_vector & base, int_vector & next);
+ std::string gen_val_string(int len, int_vector & encoding);
expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
expr * getMostLeftNodeInConcat(expr * node);
From bf27d41b0824cab5c80280278d6032c4e8c97c30 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 20 Nov 2015 12:27:29 -0500
Subject: [PATCH 065/401] use TRACE instead of STRACE...
---
src/smt/theory_str.cpp | 22 +++++++++++-----------
1 file changed, 11 insertions(+), 11 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 068745d94..429c87e62 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2954,7 +2954,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
for (std::map<expr*, int>::iterator itor2 = inVarMap.begin(); itor2 != inVarMap.end(); itor2++) {
expr * varInFunc = get_alias_index_ast(aliasIndexMap, itor2->first);
- STRACE("t_str_detail", tout << "var in unroll = " <<
+ TRACE("t_str_detail", tout << "var in unroll = " <<
mk_ismt2_pp(itor2->first, m) << std::endl
<< "dealiased var = " << mk_ismt2_pp(varInFunc, m) << std::endl;);
@@ -3471,7 +3471,7 @@ inline std::string longlong_to_string(long long i) {
void theory_str::print_value_tester_list(svector<std::pair<int, expr*> > & testerList) {
ast_manager & m = get_manager();
- STRACE("t_str_detail",
+ TRACE("t_str_detail",
int ss = testerList.size();
tout << "valueTesterList = {";
for (int i = 0; i < ss; ++i) {
@@ -3557,7 +3557,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
coverAll = false;
} else {
expr * lastestValIndi = fvar_valueTester_map[freeVar][len][tries - 1].second;
- STRACE("t_str_detail", tout << "last value tester = " << mk_ismt2_pp(lastestValIndi, m) << std::endl;);
+ TRACE("t_str_detail", tout << "last value tester = " << mk_ismt2_pp(lastestValIndi, m) << std::endl;);
coverAll = get_next_val_encode(val_range_map[lastestValIndi], base);
}
@@ -3572,7 +3572,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
}
val_range_map[val_indicator] = options[options.size() - 1];
- STRACE("t_str_detail",
+ TRACE("t_str_detail",
tout << "value tester encoding " << "{" << std::endl;
int_vector vec = val_range_map[val_indicator];
@@ -3672,12 +3672,12 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
// Z3_ast anEqc = get_eqc_value(t, aTester, anEqcHasValue);
get_eqc_value(aTester, anEqcHasValue);
if (!anEqcHasValue) {
- STRACE("t_str_detail", tout << "value tester " << mk_ismt2_pp(aTester, m)
+ TRACE("t_str_detail", tout << "value tester " << mk_ismt2_pp(aTester, m)
<< "doesn't have an equivalence class value." << std::endl;);
expr_ref makeupAssert(gen_val_options(freeVar, len_indicator, aTester, len_valueStr, i), m);
- STRACE("t_str_detail", tout << "var: " << mk_ismt2_pp(freeVar, m) << std::endl
+ TRACE("t_str_detail", tout << "var: " << mk_ismt2_pp(freeVar, m) << std::endl
<< mk_ismt2_pp(makeupAssert, m) << std::endl;);
assert_axiom(makeupAssert);
}
@@ -3774,7 +3774,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
ast_manager & m = get_manager();
- STRACE("t_str_detail", tout << "gen for free var " << mk_ismt2_pp(freeVar, m) << std::endl;);
+ TRACE("t_str_detail", tout << "gen for free var " << mk_ismt2_pp(freeVar, m) << std::endl;);
// no length assertions for this free variable have ever been added.
if (fvar_len_count_map.find(freeVar) == fvar_len_count_map.end()) {
fvar_len_count_map[freeVar] = 1;
@@ -3796,7 +3796,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
expr * len_indicator_pre = fvar_lenTester_map[freeVar][i];
bool indicatorHasEqcValue = false;
expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
- STRACE("t_str_detail", tout << "length indicator " << mk_ismt2_pp(len_indicator_pre, m) <<
+ TRACE("t_str_detail", tout << "length indicator " << mk_ismt2_pp(len_indicator_pre, m) <<
" = " << mk_ismt2_pp(len_indicator_value, m) << std::endl;);
if (indicatorHasEqcValue) {
const char * val = 0;
@@ -3809,7 +3809,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
}
} else {
if (lenTesterInCbEq != len_indicator_pre) {
- STRACE("t_str", tout << "WARNING: length indicator " << mk_ismt2_pp(len_indicator_pre, m)
+ TRACE("t_str", tout << "WARNING: length indicator " << mk_ismt2_pp(len_indicator_pre, m)
<< " does not have an equivalence class value."
<< " i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
if (i > 0) {
@@ -3839,7 +3839,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
expr * indicator = NULL;
unsigned int testNum = 0;
- STRACE("t_str", tout << "effectiveLenIndiStr = " << effectiveLenIndiStr
+ TRACE("t_str", tout << "effectiveLenIndiStr = " << effectiveLenIndiStr
<< ", i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
if (i == lenTesterCount) {
@@ -3908,7 +3908,7 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
}
}
if (duplicated && dupVar != NULL) {
- STRACE("t_str_detail", tout << "Duplicated free variable found:" << mk_ismt2_pp(freeVar, m)
+ TRACE("t_str_detail", tout << "Duplicated free variable found:" << mk_ismt2_pp(freeVar, m)
<< " = " << mk_ismt2_pp(dupVar, m) << " (SKIP)" << std::endl;);
continue;
} else {
From 24148bafa3df7df22afedda3a6aac1175f9fc155 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 20 Nov 2015 15:48:06 -0500
Subject: [PATCH 066/401] fixed several AST bugs; need to load charSet now
---
src/smt/theory_str.cpp | 55 +++++++++++++++++++++++++++++++++++++-----
1 file changed, 49 insertions(+), 6 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 429c87e62..b2f79b7bc 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -285,6 +285,7 @@ app * theory_str::mk_str_var(std::string name) {
app * a = m.mk_const(m.mk_const_decl(sym, string_sort));
// I have a hunch that this may not get internalized for free...
+ ctx.internalize(a, false);
SASSERT(ctx.get_enode(a) != NULL);
m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
@@ -3504,6 +3505,8 @@ std::string theory_str::gen_val_string(int len, int_vector & encoding) {
* - Otherwise, return true
*/
bool theory_str::get_next_val_encode(int_vector & base, int_vector & next) {
+ SASSERT(charSetSize > 0);
+
int s = 0;
int carry = 0;
next.reset();
@@ -3552,6 +3555,14 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
svector<int_vector> options;
int_vector base;
+ TRACE("t_str_detail", tout
+ << "freeVar = " << mk_ismt2_pp(freeVar, m) << std::endl
+ << "len_indicator = " << mk_ismt2_pp(len_indicator, m) << std::endl
+ << "val_indicator = " << mk_ismt2_pp(val_indicator, m) << std::endl
+ << "lenstr = " << lenStr << std::endl
+ << "tries = " << tries << std::endl
+ ;);
+
if (tries == 0) {
base = int_vector(len + 1, 0);
coverAll = false;
@@ -3650,6 +3661,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
int len = atoi(len_valueStr.c_str());
if (fvar_valueTester_map[freeVar].find(len) == fvar_valueTester_map[freeVar].end()) {
+ TRACE("t_str_detail", tout << "no previous value testers" << std::endl;);
int tries = 0;
expr * val_indicator = mk_internal_valTest_var(freeVar, len, tries);
valueTester_fvar_map[val_indicator] = freeVar;
@@ -3657,6 +3669,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
print_value_tester_list(fvar_valueTester_map[freeVar][len]);
return gen_val_options(freeVar, len_indicator, val_indicator, len_valueStr, tries);
} else {
+ TRACE("t_str_detail", tout << "checking previous value testers" << std::endl;);
// go through all previous value testers
// If some doesn't have an eqc value, add its assertion again.
int testerTotal = fvar_valueTester_map[freeVar][len].size();
@@ -3704,7 +3717,10 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tries) {
ast_manager & m = get_manager();
- expr * freeVarLen = mk_strlen(freeVar);
+ TRACE("t_str_detail", tout << "entry" << std::endl;);
+
+ expr_ref freeVarLen(mk_strlen(freeVar), m);
+ SASSERT(freeVarLen);
ptr_vector<expr> orList;
ptr_vector<expr> andList;
@@ -3713,9 +3729,16 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
int l = (tries - 1) * distance;
int h = tries * distance;
+ TRACE("t_str_detail", tout << "building andList and orList" << std::endl;);
+
for (int i = l; i < h; ++i) {
- orList.push_back(m.mk_eq(indicator, m_strutil.mk_string(int_to_string(i).c_str())));
- andList.push_back(m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVarLen, mk_int(i))));
+ expr * or_expr = m.mk_eq(indicator, m_strutil.mk_string(int_to_string(i).c_str()));
+ TRACE("t_str_detail", tout << "or_expr = " << mk_ismt2_pp(or_expr, m) << std::endl;);
+ orList.push_back(or_expr);
+
+ expr * and_expr = m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVarLen, mk_int(i)));
+ TRACE("t_str_detail", tout << "and_expr = " << mk_ismt2_pp(and_expr, m) << std::endl;);
+ andList.push_back(and_expr);
}
orList.push_back(m.mk_eq(indicator, m_strutil.mk_string("more")));
@@ -3725,14 +3748,20 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
expr ** and_items = alloc_svect(expr*, andList.size() + 1);
for (unsigned i = 0; i < orList.size(); ++i) {
+ SASSERT(orList[i] != NULL);
or_items[i] = orList[i];
}
and_items[0] = m.mk_or(orList.size(), or_items);
+ SASSERT(and_items[0] != NULL);
for(unsigned i = 0; i < andList.size(); ++i) {
+ SASSERT(andList[i] != NULL);
and_items[i+1] = andList[i];
}
expr * lenTestAssert = m.mk_and(andList.size() + 1, and_items);
+ SASSERT(lenTestAssert != NULL);
+
+ TRACE("t_str_detail", tout << "lenTestAssert = " << mk_ismt2_pp(lenTestAssert, m) << std::endl;);
expr * assertL = NULL;
int testerCount = tries - 1;
@@ -3750,11 +3779,14 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
}
if (assertL != NULL) {
+ TRACE("t_str_detail", tout << "assertL = " << mk_ismt2_pp(assertL, m) << std::endl;);
// return the axiom (assertL -> lenTestAssert)
// would like to use mk_implies() here but...
expr_ref lenTestAssert(m.mk_or(m.mk_not(assertL), lenTestAssert), m);
}
+ TRACE("t_str_detail", tout << "exit" << std::endl;);
+
return lenTestAssert;
}
@@ -3777,16 +3809,23 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
TRACE("t_str_detail", tout << "gen for free var " << mk_ismt2_pp(freeVar, m) << std::endl;);
// no length assertions for this free variable have ever been added.
if (fvar_len_count_map.find(freeVar) == fvar_len_count_map.end()) {
+
+ TRACE("t_str_detail", tout << "no length assertions yet" << std::endl;);
+
fvar_len_count_map[freeVar] = 1;
unsigned int testNum = fvar_len_count_map[freeVar];
+
expr * indicator = mk_internal_lenTest_var(freeVar, testNum);
+ SASSERT(indicator != NULL);
+
fvar_lenTester_map[freeVar].push_back(indicator);
lenTester_fvar_map[indicator] = freeVar;
expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
+ SASSERT(lenTestAssert != NULL);
return lenTestAssert;
} else {
-
+ TRACE("t_str_detail", tout << "found previous length assertions" << std::endl;);
expr * effectiveLenInd = NULL;
std::string effectiveLenIndiStr = "";
int lenTesterCount = (int) fvar_lenTester_map[freeVar].size();
@@ -3836,6 +3875,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
} // !indicatorHasEqcValue
} // for (i : [0..lenTesterCount-1])
if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "") {
+ TRACE("t_str", tout << "length is not fixed; generating length tester options for free var" << std::endl;);
expr * indicator = NULL;
unsigned int testNum = 0;
@@ -3852,11 +3892,12 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
indicator = fvar_lenTester_map[freeVar][i];
testNum = i + 1;
}
- expr_ref lenTestAssert(gen_len_test_options(freeVar, indicator, testNum), m);
+ expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
return lenTestAssert;
} else {
+ TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
// length is fixed
- expr_ref valueAssert(gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, ""), m);
+ expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, "");
return valueAssert;
}
} // fVarLenCountMap.find(...)
@@ -3956,6 +3997,7 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
for(std::set<expr*>::iterator itor1 = leafVarSet.begin();
itor1 != leafVarSet.end(); ++itor1) {
expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
+ SASSERT(toAssert != NULL);
assert_axiom(toAssert);
}
@@ -3964,6 +4006,7 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
std::set<expr*>::iterator itor2 = mItor->second.begin();
for(; itor2 != mItor->second.end(); ++itor2) {
expr * toAssert = gen_len_val_options_for_free_var(*itor2, NULL, "");
+ SASSERT(toAssert != NULL);
assert_axiom(toAssert);
}
}
From 9010a5c4cf08764988113b3cf221c47e73d5963a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 20 Nov 2015 16:05:43 -0500
Subject: [PATCH 067/401] honest-to-goodness working model gen, i.e. it didn't
crash. more testing needed
---
src/smt/theory_str.cpp | 79 ++++++++++++++++++++++++++++++++++++++++--
src/smt/theory_str.h | 2 ++
2 files changed, 78 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b2f79b7bc..61763b693 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -32,15 +32,88 @@ theory_str::theory_str(ast_manager & m):
tmpStringVarCount(0),
tmpXorVarCount(0),
avoidLoopCut(true),
- loopDetected(false),
- char_set(NULL),
- charSetSize(0)
+ loopDetected(false)
{
+ initialize_charset();
}
theory_str::~theory_str() {
}
+void theory_str::initialize_charset() {
+ bool defaultCharset = true;
+ if (defaultCharset) {
+ // valid C strings can't contain the null byte ('\0')
+ charSetSize = 255;
+ char_set = alloc_svect(char, charSetSize);
+ int idx = 0;
+ // small letters
+ for (int i = 97; i < 123; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // caps
+ for (int i = 65; i < 91; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // numbers
+ for (int i = 48; i < 58; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // printable marks - 1
+ for (int i = 32; i < 48; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // printable marks - 2
+ for (int i = 58; i < 65; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // printable marks - 3
+ for (int i = 91; i < 97; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // printable marks - 4
+ for (int i = 123; i < 127; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // non-printable - 1
+ for (int i = 1; i < 32; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // non-printable - 2
+ for (int i = 127; i < 256; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ } else {
+ const char setset[] = { 'a', 'b', 'c' };
+ int fSize = sizeof(setset) / sizeof(char);
+
+ char_set = alloc_svect(char, fSize);
+ charSetSize = fSize;
+ for (int i = 0; i < charSetSize; i++) {
+ char_set[i] = setset[i];
+ charSetLookupTable[setset[i]] = i;
+ }
+ }
+}
+
void theory_str::assert_axiom(expr * e) {
if (get_manager().is_true(e)) return;
TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 2f23ce43e..12898d458 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -95,6 +95,7 @@ namespace smt {
std::map<expr*, int_vector> val_range_map;
char * char_set;
+ std::map<char, int> charSetLookupTable;
int charSetSize;
protected:
@@ -192,6 +193,7 @@ namespace smt {
void get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet);
void dump_assignments();
+ void initialize_charset();
public:
theory_str(ast_manager & m);
virtual ~theory_str();
From 07626a1e030427c9a612c3778e67ee5fda6382d8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 28 Nov 2015 23:56:30 -0500
Subject: [PATCH 068/401] remove expr_ref stuff, start tracking variables more
closely
---
src/smt/theory_str.cpp | 31 +++++++++++++++++++++----------
1 file changed, 21 insertions(+), 10 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 61763b693..9cdc53329 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -350,6 +350,8 @@ app * theory_str::mk_str_var(std::string name) {
context & ctx = get_context();
ast_manager & m = get_manager();
+ TRACE("t_str_detail", tout << "creating string variable " << name << std::endl;);
+
sort * string_sort = m.mk_sort(m_strutil.get_family_id(), STRING_SORT);
char * new_buffer = alloc_svect(char, name.length() + 1);
strcpy(new_buffer, name.c_str());
@@ -360,6 +362,7 @@ app * theory_str::mk_str_var(std::string name) {
// I have a hunch that this may not get internalized for free...
ctx.internalize(a, false);
SASSERT(ctx.get_enode(a) != NULL);
+ SASSERT(ctx.e_internalized(a));
m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
variable_set.insert(a);
@@ -369,26 +372,31 @@ app * theory_str::mk_str_var(std::string name) {
}
app * theory_str::mk_nonempty_str_var() {
+ context & ctx = get_context();
ast_manager & m = get_manager();
+
std::stringstream ss;
ss << tmpStringVarCount;
tmpStringVarCount++;
std::string name = "$$_str" + ss.str();
+
+ TRACE("t_str_detail", tout << "creating nonempty string variable " << name << std::endl;);
+
sort * string_sort = m.mk_sort(m_strutil.get_family_id(), STRING_SORT);
char * new_buffer = alloc_svect(char, name.length() + 1);
strcpy(new_buffer, name.c_str());
symbol sym(new_buffer);
app* a = m.mk_const(m.mk_const_decl(sym, string_sort));
+ ctx.internalize(a, false);
+ SASSERT(ctx.get_enode(a) != NULL);
// assert a variation of the basic string axioms that ensures this string is nonempty
{
// build LHS
- expr_ref len_str(m);
- len_str = mk_strlen(a);
+ expr * len_str = mk_strlen(a);
SASSERT(len_str);
// build RHS
- expr_ref zero(m);
- zero = m_autil.mk_numeral(rational(0), true);
+ expr * zero = m_autil.mk_numeral(rational(0), true);
SASSERT(zero);
// build LHS > RHS and assert
// we have to build !(LHS <= RHS) instead
@@ -2509,7 +2517,7 @@ void theory_str::set_up_axioms(expr * ex) {
}
} else if (ap->get_num_args() == 0 && !is_string(ap)) {
// if ex is a variable, add it to our list of variables
- TRACE("t_str_detail", tout << "tracking variable" << std::endl;);
+ TRACE("t_str_detail", tout << "tracking variable " << mk_ismt2_pp(ap, get_manager()) << std::endl;);
variable_set.insert(ex);
}
}
@@ -3347,6 +3355,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
final_check_status theory_str::final_check_eh() {
context & ctx = get_context();
+ ast_manager & m = get_manager();
TRACE("t_str", tout << "final check" << std::endl;);
TRACE("t_str_detail", dump_assignments(););
@@ -3365,7 +3374,9 @@ final_check_status theory_str::final_check_eh() {
// If not, mark it as free.
bool needToAssignFreeVars = false;
std::set<expr*> free_variables;
+ TRACE("t_str_detail", tout << variable_set.size() << " variables in variable_set" << std::endl;);
for (std::set<expr*>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
+ TRACE("t_str_detail", tout << "checking eqc of variable " << mk_ismt2_pp(*it, m) << std::endl;);
bool has_eqc_value = false;
get_eqc_value(*it, has_eqc_value);
if (!has_eqc_value) {
@@ -3674,7 +3685,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
for (long long i = l; i < h; i++) {
orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string(longlong_to_string(i).c_str()) ));
std::string aStr = gen_val_string(len, options[i - l]);
- expr_ref strAst(m_strutil.mk_string(aStr), m);
+ expr * strAst = m_strutil.mk_string(aStr);
andList.push_back(m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVar, strAst)));
}
if (!coverAll) {
@@ -3761,7 +3772,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
TRACE("t_str_detail", tout << "value tester " << mk_ismt2_pp(aTester, m)
<< "doesn't have an equivalence class value." << std::endl;);
- expr_ref makeupAssert(gen_val_options(freeVar, len_indicator, aTester, len_valueStr, i), m);
+ expr * makeupAssert = gen_val_options(freeVar, len_indicator, aTester, len_valueStr, i);
TRACE("t_str_detail", tout << "var: " << mk_ismt2_pp(freeVar, m) << std::endl
<< mk_ismt2_pp(makeupAssert, m) << std::endl;);
@@ -3779,7 +3790,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
fvar_valueTester_map[freeVar][len].push_back(std::make_pair(sLevel, valTester));
print_value_tester_list(fvar_valueTester_map[freeVar][len]);
}
- expr_ref nextAssert(gen_val_options(freeVar, len_indicator, valTester, len_valueStr, i + 1), m);
+ expr * nextAssert = gen_val_options(freeVar, len_indicator, valTester, len_valueStr, i + 1);
return nextAssert;
}
@@ -3792,7 +3803,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
TRACE("t_str_detail", tout << "entry" << std::endl;);
- expr_ref freeVarLen(mk_strlen(freeVar), m);
+ expr * freeVarLen = mk_strlen(freeVar);
SASSERT(freeVarLen);
ptr_vector<expr> orList;
@@ -3855,7 +3866,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
TRACE("t_str_detail", tout << "assertL = " << mk_ismt2_pp(assertL, m) << std::endl;);
// return the axiom (assertL -> lenTestAssert)
// would like to use mk_implies() here but...
- expr_ref lenTestAssert(m.mk_or(m.mk_not(assertL), lenTestAssert), m);
+ lenTestAssert = m.mk_or(m.mk_not(assertL), lenTestAssert);
}
TRACE("t_str_detail", tout << "exit" << std::endl;);
From dd0bc13be720fbb3abf976d6d6c134900db74058 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 30 Nov 2015 19:22:01 -0500
Subject: [PATCH 069/401] attempt to track popped variables, still segfaults,
WIP
---
src/smt/theory_str.cpp | 45 ++++++++++++++++++++++++++++++++++++++----
src/smt/theory_str.h | 2 ++
2 files changed, 43 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 9cdc53329..8056864a4 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -329,8 +329,18 @@ expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
*/
}
+void theory_str::track_variable_scope(expr * var) {
+ context & ctx = get_context();
+ int sLevel = ctx.get_scope_level();
+ if (internal_variable_scope_levels.find(sLevel) == internal_variable_scope_levels.end()) {
+ internal_variable_scope_levels[sLevel] = std::set<expr*>();
+ }
+ internal_variable_scope_levels[sLevel].insert(var);
+}
+
app * theory_str::mk_internal_xor_var() {
ast_manager & m = get_manager();
+ context & ctx = get_context();
std::stringstream ss;
ss << tmpXorVarCount;
tmpXorVarCount++;
@@ -342,6 +352,7 @@ app * theory_str::mk_internal_xor_var() {
symbol sym(new_buffer);
app* a = m.mk_const(m.mk_const_decl(sym, int_sort));
+
// TODO ctx.save_ast_trail(a)?
return a;
}
@@ -350,7 +361,8 @@ app * theory_str::mk_str_var(std::string name) {
context & ctx = get_context();
ast_manager & m = get_manager();
- TRACE("t_str_detail", tout << "creating string variable " << name << std::endl;);
+ int sLevel = ctx.get_scope_level();
+ TRACE("t_str_detail", tout << "creating string variable " << name << " at scope level " << sLevel << std::endl;);
sort * string_sort = m.mk_sort(m_strutil.get_family_id(), STRING_SORT);
char * new_buffer = alloc_svect(char, name.length() + 1);
@@ -367,6 +379,7 @@ app * theory_str::mk_str_var(std::string name) {
variable_set.insert(a);
internal_variable_set.insert(a);
+ track_variable_scope(a);
return a;
}
@@ -380,7 +393,9 @@ app * theory_str::mk_nonempty_str_var() {
tmpStringVarCount++;
std::string name = "$$_str" + ss.str();
- TRACE("t_str_detail", tout << "creating nonempty string variable " << name << std::endl;);
+ int sLevel = ctx.get_scope_level();
+
+ TRACE("t_str_detail", tout << "creating nonempty string variable " << name << " at scope level " << sLevel << std::endl;);
sort * string_sort = m.mk_sort(m_strutil.get_family_id(), STRING_SORT);
char * new_buffer = alloc_svect(char, name.length() + 1);
@@ -408,6 +423,7 @@ app * theory_str::mk_nonempty_str_var() {
// add 'a' to variable sets, so we can keep track of it
variable_set.insert(a);
internal_variable_set.insert(a);
+ track_variable_scope(a);
return a;
}
@@ -2620,13 +2636,16 @@ void theory_str::assign_eh(bool_var v, bool is_true) {
}
void theory_str::push_scope_eh() {
- TRACE("t_str", tout << "push" << std::endl;);
+ context & ctx = get_context();
+ int sLevel = ctx.get_scope_level();
+ TRACE("t_str", tout << "push to " << sLevel << std::endl;);
}
void theory_str::pop_scope_eh(unsigned num_scopes) {
- TRACE("t_str", tout << "pop " << num_scopes << std::endl;);
context & ctx = get_context();
int sLevel = ctx.get_scope_level();
+ TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
+
std::map<expr*, std::stack<T_cut *> >::iterator varItor = cut_var_map.begin();
while (varItor != cut_var_map.end()) {
while ((varItor->second.size() > 0) && (varItor->second.top()->level != 0) && (varItor->second.top()->level >= sLevel)) {
@@ -2639,6 +2658,24 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
}
++varItor;
}
+
+ // see if any internal variables went out of scope
+ for (int check_level = sLevel + num_scopes ; check_level > sLevel; --check_level) {
+ TRACE("t_str_detail", tout << "cleaning up internal variables at scope level " << check_level << std::endl;);
+ std::map<int, std::set<expr*> >::iterator it = internal_variable_scope_levels.find(check_level);
+ if (it != internal_variable_scope_levels.end()) {
+ unsigned count = 0;
+ std::set<expr*> vars = it->second;
+ for (std::set<expr*>::iterator var_it = vars.begin(); var_it != vars.end(); ++var_it) {
+ variable_set.erase(*var_it);
+ internal_variable_set.erase(*var_it);
+ count += 1;
+ }
+ TRACE("t_str_detail", tout << "cleaned up " << count << " variables" << std::endl;);
+ vars.clear();
+ }
+ }
+
}
void theory_str::dump_assignments() {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 12898d458..fe2ff4625 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -82,6 +82,7 @@ namespace smt {
std::set<expr*> variable_set;
std::set<expr*> internal_variable_set;
+ std::map<int, std::set<expr*> > internal_variable_scope_levels;
std::set<expr*> input_var_in_len;
@@ -113,6 +114,7 @@ namespace smt {
void add_cut_info_merge(expr * destNode, int slevel, expr * srcNode);
bool has_self_cut(expr * n1, expr * n2);
+ void track_variable_scope(expr * var);
app * mk_str_var(std::string name);
app * mk_nonempty_str_var();
app * mk_internal_xor_var();
From c44d49b625661065d8bb3a6da1a0a6015100b3e4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 1 Dec 2015 14:41:11 -0500
Subject: [PATCH 070/401] keep track of search level ourselves
---
src/smt/theory_str.cpp | 11 +++--------
src/smt/theory_str.h | 1 +
2 files changed, 4 insertions(+), 8 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 8056864a4..b69bb4ac7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -29,6 +29,7 @@ theory_str::theory_str(ast_manager & m):
search_started(false),
m_autil(m),
m_strutil(m),
+ sLevel(0),
tmpStringVarCount(0),
tmpXorVarCount(0),
avoidLoopCut(true),
@@ -331,7 +332,6 @@ expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
void theory_str::track_variable_scope(expr * var) {
context & ctx = get_context();
- int sLevel = ctx.get_scope_level();
if (internal_variable_scope_levels.find(sLevel) == internal_variable_scope_levels.end()) {
internal_variable_scope_levels[sLevel] = std::set<expr*>();
}
@@ -361,7 +361,6 @@ app * theory_str::mk_str_var(std::string name) {
context & ctx = get_context();
ast_manager & m = get_manager();
- int sLevel = ctx.get_scope_level();
TRACE("t_str_detail", tout << "creating string variable " << name << " at scope level " << sLevel << std::endl;);
sort * string_sort = m.mk_sort(m_strutil.get_family_id(), STRING_SORT);
@@ -393,8 +392,6 @@ app * theory_str::mk_nonempty_str_var() {
tmpStringVarCount++;
std::string name = "$$_str" + ss.str();
- int sLevel = ctx.get_scope_level();
-
TRACE("t_str_detail", tout << "creating nonempty string variable " << name << " at scope level " << sLevel << std::endl;);
sort * string_sort = m.mk_sort(m_strutil.get_family_id(), STRING_SORT);
@@ -2637,13 +2634,13 @@ void theory_str::assign_eh(bool_var v, bool is_true) {
void theory_str::push_scope_eh() {
context & ctx = get_context();
- int sLevel = ctx.get_scope_level();
+ sLevel += 1;
TRACE("t_str", tout << "push to " << sLevel << std::endl;);
}
void theory_str::pop_scope_eh(unsigned num_scopes) {
context & ctx = get_context();
- int sLevel = ctx.get_scope_level();
+ sLevel -= num_scopes;
TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
std::map<expr*, std::stack<T_cut *> >::iterator varItor = cut_var_map.begin();
@@ -3777,8 +3774,6 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
context & ctx = get_context();
ast_manager & m = get_manager();
- int sLevel = ctx.get_scope_level();
-
int len = atoi(len_valueStr.c_str());
if (fvar_valueTester_map[freeVar].find(len) == fvar_valueTester_map[freeVar].end()) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index fe2ff4625..ce4a0cfc9 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -63,6 +63,7 @@ namespace smt {
};
protected:
bool search_started;
+ int sLevel;
arith_util m_autil;
str_util m_strutil;
From 52f0277c99439419336bbcfb46f08d82d32e7041 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 1 Dec 2015 19:19:00 -0500
Subject: [PATCH 071/401] attempt to clean up out-of-scope variables more,
still crashing
---
src/smt/theory_str.cpp | 50 +++++++++++++++++++++++++++++++++++++-----
src/smt/theory_str.h | 4 +++-
2 files changed, 48 insertions(+), 6 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b69bb4ac7..3c6261243 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -32,6 +32,8 @@ theory_str::theory_str(ast_manager & m):
sLevel(0),
tmpStringVarCount(0),
tmpXorVarCount(0),
+ tmpLenTestVarCount(0),
+ tmpValTestVarCount(0),
avoidLoopCut(true),
loopDetected(false)
{
@@ -297,11 +299,14 @@ app * theory_str::mk_int(int n) {
return m_autil.mk_numeral(rational(n), true);
}
+// We have to work a little bit harder to ensure that all variables we create here are always fresh.
+
expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
ast_manager & m = get_manager();
std::stringstream ss;
- ss << "$$_len_" << mk_ismt2_pp(node, m) << "_" << lTries;
+ ss << "$$_len_" << mk_ismt2_pp(node, m) << "_" << lTries << "_" << tmpLenTestVarCount;
+ tmpLenTestVarCount += 1;
std::string name = ss.str();
return mk_str_var(name);
@@ -317,7 +322,8 @@ expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
ast_manager & m = get_manager();
std::stringstream ss;
- ss << "$$_val_" << mk_ismt2_pp(node, m) << "_" << len << "_" << vTries;
+ ss << "$$_val_" << mk_ismt2_pp(node, m) << "_" << len << "_" << vTries << "_" << tmpValTestVarCount;
+ tmpValTestVarCount += 1;
std::string name = ss.str();
return mk_str_var(name);
@@ -3923,9 +3929,35 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
ast_manager & m = get_manager();
TRACE("t_str_detail", tout << "gen for free var " << mk_ismt2_pp(freeVar, m) << std::endl;);
- // no length assertions for this free variable have ever been added.
- if (fvar_len_count_map.find(freeVar) == fvar_len_count_map.end()) {
+ bool map_effectively_empty = false;
+ if (fvar_len_count_map.find(freeVar) == fvar_len_count_map.end()) {
+ TRACE("t_str_detail", tout << "fvar_len_count_map is empty" << std::endl;);
+ map_effectively_empty = true;
+ }
+
+ if (!map_effectively_empty) {
+ // check whether any entries correspond to variables that went out of scope;
+ // if every entry is out of scope then the map counts as being empty
+ // TODO: maybe remove them from the map instead? either here or in pop_scope_eh()
+
+ // assume empty and find a counterexample
+ map_effectively_empty = true;
+ ptr_vector<expr> indicator_set = fvar_lenTester_map[freeVar];
+ for (ptr_vector<expr>::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) {
+ expr * indicator = *it;
+ if (internal_variable_set.find(indicator) != internal_variable_set.end()) {
+ TRACE("t_str_detail", tout <<"found active internal variable " << mk_ismt2_pp(indicator, m)
+ << " in fvar_lenTester_map[freeVar]" << std::endl;);
+ map_effectively_empty = false;
+ break;
+ }
+ }
+ CTRACE("t_str_detail", map_effectively_empty, tout << "all variables in fvar_lenTester_map[freeVar] out of scope" << std::endl;);
+ }
+
+ if (map_effectively_empty) {
+ // no length assertions for this free variable have ever been added.
TRACE("t_str_detail", tout << "no length assertions yet" << std::endl;);
fvar_len_count_map[freeVar] = 1;
@@ -3934,6 +3966,8 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
expr * indicator = mk_internal_lenTest_var(freeVar, testNum);
SASSERT(indicator != NULL);
+ // since the map is "effectively empty", we can remove those variables that have left scope...
+ fvar_lenTester_map[freeVar].shrink(0);
fvar_lenTester_map[freeVar].push_back(indicator);
lenTester_fvar_map[indicator] = freeVar;
@@ -3941,7 +3975,8 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
SASSERT(lenTestAssert != NULL);
return lenTestAssert;
} else {
- TRACE("t_str_detail", tout << "found previous length assertions" << std::endl;);
+ TRACE("t_str_detail", tout << "found previous in-scope length assertions" << std::endl;);
+
expr * effectiveLenInd = NULL;
std::string effectiveLenIndiStr = "";
int lenTesterCount = (int) fvar_lenTester_map[freeVar].size();
@@ -3949,6 +3984,11 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
int i = 0;
for (; i < lenTesterCount; ++i) {
expr * len_indicator_pre = fvar_lenTester_map[freeVar][i];
+ // check whether this is in scope as well
+ if (internal_variable_set.find(len_indicator_pre) == internal_variable_set.end()) {
+ continue;
+ }
+
bool indicatorHasEqcValue = false;
expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
TRACE("t_str_detail", tout << "length indicator " << mk_ismt2_pp(len_indicator_pre, m) <<
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index ce4a0cfc9..f126ca019 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -63,9 +63,9 @@ namespace smt {
};
protected:
bool search_started;
- int sLevel;
arith_util m_autil;
str_util m_strutil;
+ int sLevel;
str_value_factory * m_factory;
@@ -75,6 +75,8 @@ namespace smt {
int tmpStringVarCount;
int tmpXorVarCount;
+ int tmpLenTestVarCount;
+ int tmpValTestVarCount;
std::map<std::pair<expr*, expr*>, std::map<int, expr*> > varForBreakConcat;
bool avoidLoopCut;
From 953a4c5437c5a5d1a2be60e68991f0f15a0b49a2 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 2 Dec 2015 20:48:15 -0500
Subject: [PATCH 072/401] add temporary variables to m_trail
---
src/smt/theory_str.cpp | 8 +++++---
src/smt/theory_str.h | 3 +++
2 files changed, 8 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3c6261243..9d0f9d689 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -30,6 +30,7 @@ theory_str::theory_str(ast_manager & m):
m_autil(m),
m_strutil(m),
sLevel(0),
+ m_trail(m),
tmpStringVarCount(0),
tmpXorVarCount(0),
tmpLenTestVarCount(0),
@@ -357,9 +358,8 @@ app * theory_str::mk_internal_xor_var() {
strcpy(new_buffer, name.c_str());
symbol sym(new_buffer);
- app* a = m.mk_const(m.mk_const_decl(sym, int_sort));
-
- // TODO ctx.save_ast_trail(a)?
+ app * a = m.mk_const(m.mk_const_decl(sym, int_sort));
+ m_trail.push_back(a);
return a;
}
@@ -382,6 +382,7 @@ app * theory_str::mk_str_var(std::string name) {
SASSERT(ctx.e_internalized(a));
m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
+ m_trail.push_back(a);
variable_set.insert(a);
internal_variable_set.insert(a);
track_variable_scope(a);
@@ -424,6 +425,7 @@ app * theory_str::mk_nonempty_str_var() {
}
// add 'a' to variable sets, so we can keep track of it
+ m_trail.push_back(a);
variable_set.insert(a);
internal_variable_set.insert(a);
track_variable_scope(a);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index f126ca019..ca985cb8f 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -67,6 +67,9 @@ namespace smt {
str_util m_strutil;
int sLevel;
+ // TODO make sure that all generated expressions are saved into the trail
+ expr_ref_vector m_trail; // trail for generated terms
+
str_value_factory * m_factory;
ptr_vector<enode> m_basicstr_axiom_todo;
From 23150d3b5e81064f7717835457ef2689b28aebe2 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 2 Dec 2015 22:03:12 -0500
Subject: [PATCH 073/401] never ever ever reuse constants in mk_string(). this
gets us MUCH farther
---
src/ast/str_decl_plugin.cpp | 3 ++-
src/smt/theory_str.cpp | 30 ++++++++++++++----------------
2 files changed, 16 insertions(+), 17 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 5589db56c..550789065 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -101,7 +101,8 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters,
app * str_decl_plugin::mk_string(std::string & val) {
std::map<std::string, app*>::iterator it = string_cache.find(val);
- if (it == string_cache.end()) {
+ //if (it == string_cache.end()) {
+ if (true) {
char * new_buffer = alloc_svect(char, (val.length() + 1));
strcpy(new_buffer, val.c_str());
parameter p[1] = {parameter(new_buffer)};
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 9d0f9d689..9b9cc8fd9 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -300,7 +300,8 @@ app * theory_str::mk_int(int n) {
return m_autil.mk_numeral(rational(n), true);
}
-// We have to work a little bit harder to ensure that all variables we create here are always fresh.
+
+// TODO refactor all of these so that they don't use variable counters, but use ast_manager::mk_fresh_const instead
expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
ast_manager & m = get_manager();
@@ -369,12 +370,8 @@ app * theory_str::mk_str_var(std::string name) {
TRACE("t_str_detail", tout << "creating string variable " << name << " at scope level " << sLevel << std::endl;);
- sort * string_sort = m.mk_sort(m_strutil.get_family_id(), STRING_SORT);
- char * new_buffer = alloc_svect(char, name.length() + 1);
- strcpy(new_buffer, name.c_str());
- symbol sym(new_buffer);
-
- app * a = m.mk_const(m.mk_const_decl(sym, string_sort));
+ sort * string_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ app * a = m.mk_fresh_const(name.c_str(), string_sort);
// I have a hunch that this may not get internalized for free...
ctx.internalize(a, false);
@@ -401,12 +398,9 @@ app * theory_str::mk_nonempty_str_var() {
TRACE("t_str_detail", tout << "creating nonempty string variable " << name << " at scope level " << sLevel << std::endl;);
- sort * string_sort = m.mk_sort(m_strutil.get_family_id(), STRING_SORT);
- char * new_buffer = alloc_svect(char, name.length() + 1);
- strcpy(new_buffer, name.c_str());
- symbol sym(new_buffer);
+ sort * string_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ app * a = m.mk_fresh_const(name.c_str(), string_sort);
- app* a = m.mk_const(m.mk_const_decl(sym, string_sort));
ctx.internalize(a, false);
SASSERT(ctx.get_enode(a) != NULL);
// assert a variation of the basic string axioms that ensures this string is nonempty
@@ -3843,7 +3837,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
TRACE("t_str_detail", tout << "entry" << std::endl;);
- expr * freeVarLen = mk_strlen(freeVar);
+ expr_ref freeVarLen(mk_strlen(freeVar), m);
SASSERT(freeVarLen);
ptr_vector<expr> orList;
@@ -3856,7 +3850,10 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
TRACE("t_str_detail", tout << "building andList and orList" << std::endl;);
for (int i = l; i < h; ++i) {
- expr * or_expr = m.mk_eq(indicator, m_strutil.mk_string(int_to_string(i).c_str()));
+ std::string i_str = int_to_string(i);
+ expr_ref str_indicator(m_strutil.mk_string(i_str), m);
+ TRACE("t_str_detail", tout << "just created a string term: " << mk_ismt2_pp(str_indicator, m) << std::endl;);
+ expr * or_expr = m.mk_eq(indicator, str_indicator); // ARGUMENT 2 IS BOGUS! WRONG SORT
TRACE("t_str_detail", tout << "or_expr = " << mk_ismt2_pp(or_expr, m) << std::endl;);
orList.push_back(or_expr);
@@ -3868,6 +3865,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
orList.push_back(m.mk_eq(indicator, m_strutil.mk_string("more")));
andList.push_back(m.mk_eq(orList[orList.size() - 1], m_autil.mk_ge(freeVarLen, mk_int(h))));
+ // TODO refactor this to use expr_ref_vector/svector/buffer instead
expr ** or_items = alloc_svect(expr*, orList.size());
expr ** and_items = alloc_svect(expr*, andList.size() + 1);
@@ -3965,8 +3963,8 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
fvar_len_count_map[freeVar] = 1;
unsigned int testNum = fvar_len_count_map[freeVar];
- expr * indicator = mk_internal_lenTest_var(freeVar, testNum);
- SASSERT(indicator != NULL);
+ expr_ref indicator(mk_internal_lenTest_var(freeVar, testNum), m);
+ SASSERT(indicator);
// since the map is "effectively empty", we can remove those variables that have left scope...
fvar_lenTester_map[freeVar].shrink(0);
From 1a15b3937deb367adac5c64dae48e9e1298a6b5d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 2 Dec 2015 22:09:30 -0500
Subject: [PATCH 074/401] in_same_eqc() now checks to ensure both terms are
internalized before doing anything else
---
src/smt/theory_str.cpp | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 9b9cc8fd9..62100cfcd 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1999,6 +1999,20 @@ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
bool theory_str::in_same_eqc(expr * n1, expr * n2) {
if (n1 == n2) return true;
context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ // similar to get_eqc_value(), make absolutely sure
+ // that we've set this up properly for the context
+
+ if (!ctx.e_internalized(n1)) {
+ TRACE("t_str_detail", tout << "WARNING: expression " << mk_ismt2_pp(n1, m) << " was not internalized" << std::endl;);
+ ctx.internalize(n1, false);
+ }
+ if (!ctx.e_internalized(n2)) {
+ TRACE("t_str_detail", tout << "WARNING: expression " << mk_ismt2_pp(n2, m) << " was not internalized" << std::endl;);
+ ctx.internalize(n2, false);
+ }
+
enode * n1Node = ctx.get_enode(n1);
enode * n2Node = ctx.get_enode(n2);
From f5e94af784b19e021e367c688d295298abf214b8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 2 Dec 2015 22:15:04 -0500
Subject: [PATCH 075/401] check that both simplified expressions are concats in
simplify_concat_equality() this seems to fix all the crashes but the solver
takes forever to solve a really simple instance with easy model generation,
so I think something is still wrong probably next I will go through and
change std::map to obj_map, etc.
---
src/smt/theory_str.cpp | 11 +++++++----
1 file changed, 7 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 62100cfcd..f6187c7c1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -922,10 +922,6 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
expr * new_nn2 = simplify_concat(nn2);
app * a_new_nn1 = to_app(new_nn1);
app * a_new_nn2 = to_app(new_nn2);
- expr * v1_arg0 = a_new_nn1->get_arg(0);
- expr * v1_arg1 = a_new_nn1->get_arg(1);
- expr * v2_arg0 = a_new_nn2->get_arg(0);
- expr * v2_arg1 = a_new_nn2->get_arg(1);
TRACE("t_str_detail", tout << "new_nn1 = " << mk_ismt2_pp(new_nn1, m) << std::endl
<< "new_nn2 = " << mk_ismt2_pp(new_nn2, m) << std::endl;);
@@ -960,6 +956,13 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
return;
}
+ // TODO what happens if BOTH of these are simplified into non-concat terms?
+
+ expr * v1_arg0 = a_new_nn1->get_arg(0);
+ expr * v1_arg1 = a_new_nn1->get_arg(1);
+ expr * v2_arg0 = a_new_nn2->get_arg(0);
+ expr * v2_arg1 = a_new_nn2->get_arg(1);
+
if (!in_same_eqc(new_nn1, new_nn2) && (nn1 != new_nn1 || nn2 != new_nn2)) {
int ii4 = 0;
expr* item[3];
From e010e7c0d606a4059bf8d4fd56777720679402f9 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 2 Dec 2015 23:35:26 -0500
Subject: [PATCH 076/401] add trace message to indicate which free variables
are giving us trouble I think I'm onto the issue though
---
src/smt/theory_str.cpp | 10 +++++++++-
1 file changed, 9 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f6187c7c1..a5584efd8 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -532,6 +532,8 @@ void theory_str::instantiate_concat_axiom(enode * cat) {
ast_manager & m = get_manager();
+ TRACE("t_str_detail", tout << "instantiating concat axiom for " << mk_ismt2_pp(a_cat, m) << std::endl;);
+
// build LHS
expr_ref len_xy(m);
// TODO should we use str_util for these and other expressions?
@@ -560,7 +562,6 @@ void theory_str::instantiate_concat_axiom(enode * cat) {
// finally assert equality between the two subexpressions
app * eq = m.mk_eq(len_xy, len_x_plus_len_y);
SASSERT(eq);
- TRACE("t_str", tout << mk_ismt2_pp(eq, m) << std::endl;);
assert_axiom(eq);
}
@@ -3443,6 +3444,13 @@ final_check_status theory_str::final_check_eh() {
return FC_DONE;
}
+ CTRACE("t_str", needToAssignFreeVars,
+ tout << "Need to assign values to the following free variables:" << std::endl;
+ for (std::set<expr*>::iterator itx = free_variables.begin(); itx != free_variables.end(); ++itx) {
+ tout << mk_ismt2_pp(*itx, m) << std::endl;
+ }
+ );
+
// -----------------------------------------------------------
// variables in freeVar are those not bounded by Concats
// classify variables in freeVarMap:
From cf5eacbf332d175bad5b46b9739016814a3991f3 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 3 Dec 2015 20:58:54 -0500
Subject: [PATCH 077/401] successful run of model generation test case, after
assigning all internal variables a bogus value if they are unused
---
src/smt/theory_str.cpp | 29 +++++++++++++++++++++++------
1 file changed, 23 insertions(+), 6 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a5584efd8..fb74f4c40 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3428,20 +3428,37 @@ final_check_status theory_str::final_check_eh() {
// If not, mark it as free.
bool needToAssignFreeVars = false;
std::set<expr*> free_variables;
+ std::set<expr*> unused_internal_variables;
TRACE("t_str_detail", tout << variable_set.size() << " variables in variable_set" << std::endl;);
for (std::set<expr*>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
TRACE("t_str_detail", tout << "checking eqc of variable " << mk_ismt2_pp(*it, m) << std::endl;);
bool has_eqc_value = false;
get_eqc_value(*it, has_eqc_value);
if (!has_eqc_value) {
- needToAssignFreeVars = true;
- free_variables.insert(*it);
+ // if this is an internal variable, it can be ignored...I think
+ if (internal_variable_set.find(*it) != internal_variable_set.end()) {
+ TRACE("t_str_detail", tout << "WARNING: free internal variable " << mk_ismt2_pp(*it, m) << std::endl;);
+ unused_internal_variables.insert(*it);
+ } else {
+ needToAssignFreeVars = true;
+ free_variables.insert(*it);
+ }
}
}
if (!needToAssignFreeVars) {
- TRACE("t_str", tout << "All variables are assigned. Done!" << std::endl;);
- return FC_DONE;
+ if (unused_internal_variables.empty()) {
+ TRACE("t_str", tout << "All variables are assigned. Done!" << std::endl;);
+ return FC_DONE;
+ } else {
+ TRACE("t_str", tout << "Assigning decoy values to free internal variables." << std::endl;);
+ for (std::set<expr*>::iterator it = unused_internal_variables.begin(); it != unused_internal_variables.end(); ++it) {
+ expr * var = *it;
+ expr_ref assignment(m.mk_eq(var, m_strutil.mk_string("**unused**")), m);
+ assert_axiom(assignment);
+ }
+ return FC_CONTINUE;
+ }
}
CTRACE("t_str", needToAssignFreeVars,
@@ -4218,7 +4235,7 @@ void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> &
}
void theory_str::init_model(model_generator & mg) {
- TRACE("t_str", tout << "initializing model" << std::endl; display(tout););
+ //TRACE("t_str", tout << "initializing model" << std::endl; display(tout););
m_factory = alloc(str_value_factory, get_manager(), get_family_id());
mg.register_factory(m_factory);
}
@@ -4287,7 +4304,7 @@ model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
TRACE("t_str", tout << "WARNING: failed to find a concrete value, falling back" << std::endl;);
// TODO make absolutely sure the reason we can't find a concrete value is because of an unassigned temporary
// e.g. for an expression like (Concat X $$_str0)
- //return alloc(expr_wrapper_proc, m_strutil.mk_string(""));
+ //return alloc(expr_wrapper_proc, m_strutil.mk_string("**UNUSED**"));
NOT_IMPLEMENTED_YET();
}
}
From a2d0299621c2c7856329ea32c26aa264ed8ff2c3 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 7 May 2016 14:19:12 -0400
Subject: [PATCH 078/401] call super in push and pop
---
src/smt/theory_str.cpp | 26 ++++----------------------
1 file changed, 4 insertions(+), 22 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index fb74f4c40..61488638c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -191,26 +191,6 @@ static void cut_vars_map_copy(std::map<expr*, int> & dest, std::map<expr*, int>
}
}
-/*
-bool hasSelfCut(Z3_ast n1, Z3_ast n2) {
- if (cut_VARMap.find(n1) == cut_VARMap.end())
- return false;
-
- if (cut_VARMap.find(n2) == cut_VARMap.end())
- return false;
-
- if (cut_VARMap[n1].empty() || cut_VARMap[n2].empty())
- return false;
-
- std::map<Z3_ast, int>::iterator itor = cut_VARMap[n1].top()->vars.begin();
- for (; itor != cut_VARMap[n1].top()->vars.end(); itor++) {
- if (cut_VARMap[n2].top()->vars.find(itor->first) != cut_VARMap[n2].top()->vars.end())
- return true;
- }
- return false;
-}
-*/
-
bool theory_str::has_self_cut(expr * n1, expr * n2) {
if (cut_var_map.find(n1) == cut_var_map.end()) {
return false;
@@ -2653,9 +2633,11 @@ void theory_str::assign_eh(bool_var v, bool is_true) {
}
void theory_str::push_scope_eh() {
+ theory::push_scope_eh();
context & ctx = get_context();
sLevel += 1;
TRACE("t_str", tout << "push to " << sLevel << std::endl;);
+ TRACE("t_str_dump_assign", dump_assignments(););
}
void theory_str::pop_scope_eh(unsigned num_scopes) {
@@ -2692,7 +2674,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
vars.clear();
}
}
-
+ theory::pop_scope_eh(num_scopes);
}
void theory_str::dump_assignments() {
@@ -3128,7 +3110,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
// (4) equivalent concats
// - possibility 1 : concat("str", v1) = concat(concat(v2, v3), v4) = concat(v5, v6)
// ==> v2, v5 are constrained by "str"
- // - possibliity 2 : concat(v1, "str") = concat(v2, v3) = concat(v4, v5)
+ // - possibility 2 : concat(v1, "str") = concat(v2, v3) = concat(v4, v5)
// ==> v2, v4 are constrained by "str"
//--------------------------------------------------------------
From 1d324877cdf16e6547ef0a909a491e9e99ff3cef Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 7 May 2016 15:40:39 -0400
Subject: [PATCH 079/401] use theory_seq's internalize_term
---
src/smt/theory_str.cpp | 67 +++++++++++++++++++++++++++++++++++++++---
src/smt/theory_str.h | 4 ++-
2 files changed, 66 insertions(+), 5 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 61488638c..fc9a7f3d5 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -139,6 +139,7 @@ void theory_str::assert_implication(expr * premise, expr * conclusion) {
}
bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
+ /*
TRACE("t_str", tout << "internalizing atom: " << mk_ismt2_pp(atom, get_manager()) << std::endl;);
SASSERT(atom->get_family_id() == get_family_id());
@@ -152,15 +153,21 @@ bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
ctx.internalize(atom->get_arg(i), false);
literal l(ctx.mk_bool_var(atom));
+
ctx.set_var_theory(l.var(), get_id());
return true;
+ */
+ return internalize_term(atom);
}
bool theory_str::internalize_term(app * term) {
context & ctx = get_context();
+ ast_manager & m = get_manager();
TRACE("t_str", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
SASSERT(term->get_family_id() == get_family_id());
+
+ /* // what I had before
SASSERT(!ctx.e_internalized(term));
unsigned num_args = term->get_num_args();
@@ -175,15 +182,67 @@ bool theory_str::internalize_term(app * term) {
attach_new_th_var(e);
- /*
- if (is_concat(term)) {
- instantiate_concat_axiom(e);
- }
+ //if (is_concat(term)) {
+ // instantiate_concat_axiom(e);
+ //}
*/
+ // from theory_seq::internalize_term()
+ if (ctx.e_internalized(term)) {
+ enode* e = ctx.get_enode(term);
+ mk_var(e);
+ return true;
+ }
+ unsigned num_args = term->get_num_args();
+ expr* arg;
+ for (unsigned i = 0; i < num_args; i++) {
+ arg = term->get_arg(i);
+ mk_var(ensure_enode(arg));
+ }
+ if (m.is_bool(term)) {
+ bool_var bv = ctx.mk_bool_var(term);
+ ctx.set_var_theory(bv, get_id());
+ ctx.mark_as_relevant(bv);
+ }
+
+ enode* e = 0;
+ if (ctx.e_internalized(term)) {
+ e = ctx.get_enode(term);
+ }
+ else {
+ e = ctx.mk_enode(term, false, m.is_bool(term), true);
+ }
+ mk_var(e);
+
return true;
}
+enode* theory_str::ensure_enode(expr* e) {
+ context& ctx = get_context();
+ if (!ctx.e_internalized(e)) {
+ ctx.internalize(e, false);
+ }
+ enode* n = ctx.get_enode(e);
+ ctx.mark_as_relevant(n);
+ return n;
+}
+
+theory_var theory_str::mk_var(enode* n) {
+ if (!m_strutil.is_string(n->get_owner())) {
+ return null_theory_var;
+ }
+ if (is_attached_to_var(n)) {
+ return n->get_th_var(get_id());
+ }
+ else {
+ theory_var v = theory::mk_var(n);
+ // m_find.mk_var();
+ get_context().attach_th_var(n, this, v);
+ get_context().mark_as_relevant(n);
+ return v;
+ }
+}
+
static void cut_vars_map_copy(std::map<expr*, int> & dest, std::map<expr*, int> & src) {
std::map<expr*, int>::iterator itor = src.begin();
for (; itor != src.end(); itor++) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index ca985cb8f..af2ea1db6 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -208,6 +208,8 @@ namespace smt {
protected:
virtual bool internalize_atom(app * atom, bool gate_ctx);
virtual bool internalize_term(app * term);
+ virtual enode* ensure_enode(expr* e);
+ virtual theory_var mk_var(enode * n);
virtual void new_eq_eh(theory_var, theory_var);
virtual void new_diseq_eh(theory_var, theory_var);
@@ -224,7 +226,7 @@ namespace smt {
virtual void propagate();
virtual final_check_status final_check_eh();
- void attach_new_th_var(enode * n);
+ virtual void attach_new_th_var(enode * n);
virtual void init_model(model_generator & m);
virtual model_value_proc * mk_value(enode * n, model_generator & mg);
From 6dfc2dd9100a39f705000c54f80930f19d65a08c Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 7 May 2016 17:16:31 -0400
Subject: [PATCH 080/401] variables of sort String should now correctly be
identified as Very Relevant to the string solver
---
src/smt/theory_str.cpp | 28 ++++++++++++++++++++++------
1 file changed, 22 insertions(+), 6 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index fc9a7f3d5..37b68e48c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -212,7 +212,8 @@ bool theory_str::internalize_term(app * term) {
else {
e = ctx.mk_enode(term, false, m.is_bool(term), true);
}
- mk_var(e);
+ theory_var v = mk_var(e);
+ TRACE("t_str_detail", tout << "term " << mk_ismt2_pp(term, get_manager()) << " = v#" << v << std::endl;);
return true;
}
@@ -228,9 +229,16 @@ enode* theory_str::ensure_enode(expr* e) {
}
theory_var theory_str::mk_var(enode* n) {
+ /*
if (!m_strutil.is_string(n->get_owner())) {
return null_theory_var;
}
+ */
+ // TODO this may require an overhaul of m_strutil.is_string() if things suddenly start working after the following change:
+ ast_manager & m = get_manager();
+ if (!(is_sort_of(m.get_sort(n->get_owner()), m_strutil.get_fid(), STRING_SORT))) {
+ return null_theory_var;
+ }
if (is_attached_to_var(n)) {
return n->get_th_var(get_id());
}
@@ -416,6 +424,8 @@ app * theory_str::mk_str_var(std::string name) {
ctx.internalize(a, false);
SASSERT(ctx.get_enode(a) != NULL);
SASSERT(ctx.e_internalized(a));
+ // this might help??
+ mk_var(ctx.get_enode(a));
m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
m_trail.push_back(a);
@@ -442,6 +452,9 @@ app * theory_str::mk_nonempty_str_var() {
ctx.internalize(a, false);
SASSERT(ctx.get_enode(a) != NULL);
+ // this might help??
+ mk_var(ctx.get_enode(a));
+
// assert a variation of the basic string axioms that ensures this string is nonempty
{
// build LHS
@@ -2496,11 +2509,11 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
);
// step 1: Concat == Concat
- // I'm disabling this entire code block for now. It may no longer be useful.
+ // This code block may no longer be useful.
// Z3 seems to be putting LHS and RHS into the same equivalence class extremely early.
// As a result, simplify_concat_equality() is never getting called,
// and if it were called, it would probably get called with the same element on both sides.
- /*
+
bool hasCommon = false;
if (eqc_lhs_concat.size() != 0 && eqc_rhs_concat.size() != 0) {
std::set<expr*>::iterator itor1 = eqc_lhs_concat.begin();
@@ -2521,7 +2534,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
simplify_concat_equality(*(eqc_lhs_concat.begin()), *(eqc_rhs_concat.begin()));
}
}
- */
+
if (eqc_lhs_concat.size() != 0 && eqc_rhs_concat.size() != 0) {
// let's pick the first concat in the LHS's eqc
// and find some concat in the RHS's eqc that is
@@ -2591,6 +2604,10 @@ void theory_str::set_up_axioms(expr * ex) {
// if ex is a variable, add it to our list of variables
TRACE("t_str_detail", tout << "tracking variable " << mk_ismt2_pp(ap, get_manager()) << std::endl;);
variable_set.insert(ex);
+ ctx.mark_as_relevant(ex);
+ // this might help??
+ theory_var v = mk_var(n);
+ TRACE("t_str_detail", tout << "variable " << mk_ismt2_pp(ap, get_manager()) << " is #" << v << std::endl;);
}
}
} else {
@@ -2637,7 +2654,7 @@ void theory_str::init_search_eh() {
* This is done to find equalities between terms, etc. that we otherwise
* might not get a chance to see.
*/
- /*
+
expr_ref_vector assignments(m);
ctx.get_assignments(assignments);
for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
@@ -2659,7 +2676,6 @@ void theory_str::init_search_eh() {
<< ": expr ignored" << std::endl;);
}
}
- */
TRACE("t_str", tout << "search started" << std::endl;);
search_started = true;
From bcaad06061b2981669c84770462192d0886791e3 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 7 May 2016 17:47:50 -0400
Subject: [PATCH 081/401] add theory name; add debug info for freeVar_map
---
src/smt/theory_str.cpp | 11 +++++++----
src/smt/theory_str.h | 2 ++
2 files changed, 9 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 37b68e48c..3903508ea 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2655,6 +2655,7 @@ void theory_str::init_search_eh() {
* might not get a chance to see.
*/
+ /*
expr_ref_vector assignments(m);
ctx.get_assignments(assignments);
for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
@@ -2676,6 +2677,7 @@ void theory_str::init_search_eh() {
<< ": expr ignored" << std::endl;);
}
}
+ */
TRACE("t_str", tout << "search started" << std::endl;);
search_started = true;
@@ -2686,16 +2688,12 @@ void theory_str::new_eq_eh(theory_var x, theory_var y) {
TRACE("t_str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
handle_equality(get_enode(x)->get_owner(), get_enode(y)->get_owner());
-
- TRACE("t_str_dump_assign", dump_assignments(););
}
void theory_str::new_diseq_eh(theory_var x, theory_var y) {
//TRACE("t_str_detail", tout << "new diseq: v#" << x << " != v#" << y << std::endl;);
TRACE("t_str", tout << "new diseq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
-
- TRACE("t_str_dump_assign", dump_assignments(););
}
void theory_str::relevant_eh(app * n) {
@@ -3523,6 +3521,11 @@ final_check_status theory_str::final_check_eh() {
for (std::set<expr*>::iterator itx = free_variables.begin(); itx != free_variables.end(); ++itx) {
tout << mk_ismt2_pp(*itx, m) << std::endl;
}
+ tout << "freeVar_map has the following entries:" << std::endl;
+ for (std::map<expr*, int>::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) {
+ expr * var = fvIt->first;
+ tout << mk_ismt2_pp(var, m) << std::endl;
+ }
);
// -----------------------------------------------------------
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index af2ea1db6..9d56c01fe 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -205,6 +205,8 @@ namespace smt {
public:
theory_str(ast_manager & m);
virtual ~theory_str();
+
+ virtual char const * get_name() const { return "strings"; }
protected:
virtual bool internalize_atom(app * atom, bool gate_ctx);
virtual bool internalize_term(app * term);
From f9e1ed4496a859a771bdb100a34dc2c0cf533f8a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 9 May 2016 18:12:21 -0400
Subject: [PATCH 082/401] add simplify_parent()
---
src/ast/str_decl_plugin.cpp | 8 +
src/ast/str_decl_plugin.h | 2 +
src/smt/theory_str.cpp | 359 +++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 1 +
4 files changed, 368 insertions(+), 2 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 550789065..cd9cae5a5 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -169,6 +169,14 @@ bool str_recognizers::is_string(expr const * n) const {
return is_string(n, & tmp);
}
+std::string str_recognizers::get_string_constant_value(expr const *n) const {
+ const char * cstr = 0;
+ bool isString = is_string(n, & cstr);
+ SASSERT(isString);
+ std::string strval(cstr);
+ return strval;
+}
+
str_util::str_util(ast_manager &m) :
str_recognizers(m.mk_family_id(symbol("str"))),
m_manager(m) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index f1978ab8b..4f46fa5ac 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -81,6 +81,8 @@ public:
bool is_string(expr const * n, const char ** val) const;
bool is_string(expr const * n) const;
+
+ std::string get_string_constant_value(expr const *n) const;
// TODO
};
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3903508ea..254d32141 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -797,6 +797,34 @@ void theory_str::get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList) {
}
}
+// previously Concat() in strTheory.cpp
+// Evaluates the concatenation (n1 . n2) with respect to
+// the current equivalence classes of n1 and n2.
+// Returns a constant string expression representing this concatenation
+// if one can be determined, or NULL if this is not possible.
+expr * theory_str::eval_concat(expr * n1, expr * n2) {
+ bool n1HasEqcValue = false;
+ bool n2HasEqcValue = false;
+ expr * v1 = get_eqc_value(n1, n1HasEqcValue);
+ expr * v2 = get_eqc_value(n2, n2HasEqcValue);
+ if (n1HasEqcValue && n2HasEqcValue) {
+ std::string n1_str = m_strutil.get_string_constant_value(v1);
+ std::string n2_str = m_strutil.get_string_constant_value(v2);
+ std::string result = n1_str + n2_str;
+ return m_strutil.mk_string(result);
+ } else if (n1HasEqcValue && !n2HasEqcValue) {
+ if (m_strutil.get_string_constant_value(v1) == "") {
+ return n2;
+ }
+ } else if (n2HasEqcValue && !n1HasEqcValue) {
+ if (m_strutil.get_string_constant_value(v2) == "") {
+ return n1;
+ }
+ }
+ // give up
+ return NULL;
+}
+
/*
* The inputs:
* ~ nn: non const node
@@ -806,8 +834,298 @@ void theory_str::get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList) {
* to see whether some concat nodes can be simplified.
*/
+// TODO NEXT complete this method!
void theory_str::simplify_parent(expr * nn, expr * eq_str) {
- // TODO strTheory::simplifyParent()
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ TRACE("t_str", tout << "simplifying parents of " << mk_ismt2_pp(nn, m)
+ << " with respect to " << mk_ismt2_pp(eq_str, m) << std::endl;);
+
+ ctx.internalize(nn, false);
+ enode * n_eq_enode = ctx.get_enode(nn);
+ enode * nn_enode = n_eq_enode;
+
+ const char * tmp = 0;
+ m_strutil.is_string(eq_str, & tmp);
+ std::string eq_strValue(tmp);
+
+ do {
+ app * n_eqNode = n_eq_enode->get_owner();
+ for (enode_vector::iterator parent_it = n_eq_enode->begin_parents(); parent_it != n_eq_enode->end_parents(); parent_it++) {
+ enode * e_parent = *parent_it;
+ app * a_parent = e_parent->get_owner();
+ TRACE("t_str_detail", tout << "considering parent " << mk_ismt2_pp(a_parent, m) << std::endl;);
+
+ if (is_concat(a_parent)) {
+ expr * arg0 = a_parent->get_arg(0);
+ expr * arg1 = a_parent->get_arg(1);
+
+ // TODO getLenValue()
+ // int parentLen = getLenValue(a_parent)
+ int parentLen = -1;
+ if (arg0 == n_eq_enode->get_owner()) {
+ // TODO getLenValue()
+ // int arg0Len = getLenValue(eq_str);
+ // int arg1Len = getLenValue(arg1);
+ int arg0Len = -1;
+ int arg1Len = -1;
+
+ TRACE("t_str_detail",
+ tout << "simplify_parent #1:" << std::endl
+ << "* parent = " << mk_ismt2_pp(a_parent, m) << std::endl
+ << "* |parent| = " << parentLen << std::endl
+ << "* |arg0| = " << arg0Len << std::endl
+ << "* |arg1| = " << arg1Len << std::endl;
+ );
+
+ if (parentLen != -1 && arg1Len == -1) {
+ // TODO after getLenValue() above
+ /*
+ Z3_ast implyL11 = mk_2_and(t, Z3_mk_eq(ctx, mk_length(t, parent), mk_int(ctx, parentLen)),
+ Z3_mk_eq(ctx, mk_length(t, arg0), mk_int(ctx, arg0Len)));
+ int makeUpLenArg1 = parentLen - arg0Len;
+ Z3_ast lenAss = NULL;
+ if (makeUpLenArg1 >= 0) {
+ Z3_ast implyR11 = Z3_mk_eq(ctx, mk_length(t, arg1), mk_int(ctx, makeUpLenArg1));
+ lenAss = Z3_mk_implies(ctx, implyL11, implyR11);
+ } else {
+ lenAss = Z3_mk_not(ctx, implyL11);
+ }
+ addAxiom(t, lenAss, __LINE__);
+ */
+ }
+
+ // (Concat n_eqNode arg1) /\ arg1 has eq const
+
+ expr * concatResult = eval_concat(eq_str, arg1);
+ if (concatResult != NULL) {
+ bool arg1HasEqcValue = false;
+ expr * arg1Value = get_eqc_value(arg1, arg1HasEqcValue);
+ expr_ref implyL(m);
+ if (arg1 != arg1Value) {
+ expr_ref eq_ast1(m);
+ eq_ast1 = ctx.mk_eq_atom(n_eqNode, eq_str);
+ SASSERT(eq_ast1);
+
+ expr_ref eq_ast2(m);
+ eq_ast2 = ctx.mk_eq_atom(arg1, arg1Value);
+ SASSERT(eq_ast2);
+
+ implyL = m.mk_and(eq_ast1, eq_ast2);
+ } else {
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ }
+
+
+ if (!in_same_eqc(a_parent, concatResult)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, concatResult);
+ SASSERT(implyR);
+
+ assert_implication(implyL, implyR);
+ }
+ } else if (is_concat(n_eqNode)) {
+ expr_ref simpleConcat(m);
+ simpleConcat = mk_concat(eq_str, arg1);
+ if (!in_same_eqc(a_parent, simpleConcat)) {
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ SASSERT(implyL);
+
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, simpleConcat);
+ SASSERT(implyR);
+ assert_implication(implyL, implyR);
+ }
+ }
+ } // if (arg0 == n_eq_enode->get_owner())
+
+ if (arg1 == n_eq_enode->get_owner()) {
+ // TODO getLenValue()
+ // int arg0Len = getLenValue(arg0);
+ // int arg1Len = getLenValue(eq_str);
+ int arg0Len = -1;
+ int arg1Len = -1;
+
+ TRACE("t_str_detail",
+ tout << "simplify_parent #2:" << std::endl
+ << "* parent = " << mk_ismt2_pp(a_parent, m) << std::endl
+ << "* |parent| = " << parentLen << std::endl
+ << "* |arg0| = " << arg0Len << std::endl
+ << "* |arg1| = " << arg1Len << std::endl;
+ );
+
+ if (parentLen != -1 && arg0Len == -1) {
+ // TODO after getLenValue() above
+ /*
+ Z3_ast implyL11 = mk_2_and(t, Z3_mk_eq(ctx, mk_length(t, parent), mk_int(ctx, parentLen)),
+ Z3_mk_eq(ctx, mk_length(t, arg1), mk_int(ctx, arg1Len)));
+ int makeUpLenArg0 = parentLen - arg1Len;
+ Z3_ast lenAss = NULL;
+ if (makeUpLenArg0 >= 0) {
+ Z3_ast implyR11 = Z3_mk_eq(ctx, mk_length(t, arg0), mk_int(ctx, makeUpLenArg0));
+ lenAss = Z3_mk_implies(ctx, implyL11, implyR11);
+ } else {
+ lenAss = Z3_mk_not(ctx, implyL11);
+ }
+ addAxiom(t, lenAss, __LINE__);
+ */
+ }
+
+ // (Concat arg0 n_eqNode) /\ arg0 has eq const
+
+ expr * concatResult = eval_concat(eq_str, arg1);
+ if (concatResult != NULL) {
+ bool arg0HasEqcValue = false;
+ expr * arg0Value = get_eqc_value(arg0, arg0HasEqcValue);
+ expr_ref implyL(m);
+ if (arg0 != arg0Value) {
+ expr_ref eq_ast1(m);
+ eq_ast1 = ctx.mk_eq_atom(n_eqNode, eq_str);
+ SASSERT(eq_ast1);
+
+ expr_ref eq_ast2(m);
+ eq_ast2 = ctx.mk_eq_atom(arg0, arg0Value);
+ SASSERT(eq_ast2);
+
+ implyL = m.mk_and(eq_ast1, eq_ast2);
+ } else {
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ }
+
+ if (!in_same_eqc(a_parent, concatResult)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, concatResult);
+ SASSERT(implyR);
+
+ assert_implication(implyL, implyR);
+ }
+ } else if (is_concat(n_eqNode)) {
+ expr_ref simpleConcat(m);
+ simpleConcat = mk_concat(arg0, eq_str);
+ if (!in_same_eqc(a_parent, simpleConcat)) {
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ SASSERT(implyL);
+
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, simpleConcat);
+ SASSERT(implyR);
+ assert_implication(implyL, implyR);
+ }
+ }
+ } // if (arg1 == n_eq_enode->get_owner
+
+
+ //---------------------------------------------------------
+ // Case (2-1) begin: (Concat n_eqNode (Concat str var))
+ if (arg0 == n_eqNode && is_concat(to_app(arg1))) {
+ app * a_arg1 = to_app(arg1);
+ TRACE("t_str_detail", tout << "simplify_parent #3" << std::endl;);
+ expr * r_concat_arg0 = a_arg1->get_arg(0);
+ if (m_strutil.is_string(r_concat_arg0)) {
+ expr * combined_str = eval_concat(eq_str, r_concat_arg0);
+ SASSERT(combined_str);
+ expr * r_concat_arg1 = a_arg1->get_arg(1);
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ expr * simplifiedAst = mk_concat(combined_str, r_concat_arg1);
+ if (!in_same_eqc(a_parent, simplifiedAst)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, simplifiedAst);
+ assert_implication(implyL, implyR);
+ }
+ }
+ }
+ // Case (2-1) end: (Concat n_eqNode (Concat str var))
+ //---------------------------------------------------------
+
+
+ //---------------------------------------------------------
+ // Case (2-2) begin: (Concat (Concat var str) n_eqNode)
+ if (is_concat(to_app(arg0)) && arg1 == n_eqNode) {
+ app * a_arg0 = to_app(arg0);
+ TRACE("t_str_detail", tout << "simplify_parent #4" << std::endl;);
+ expr * l_concat_arg1 = a_arg0->get_arg(1);
+ if (m_strutil.is_string(l_concat_arg1)) {
+ expr * combined_str = eval_concat(l_concat_arg1, eq_str);
+ SASSERT(combined_str);
+ expr * l_concat_arg0 = a_arg0->get_arg(0);
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ expr * simplifiedAst = mk_concat(l_concat_arg0, combined_str);
+ if (!in_same_eqc(a_parent, simplifiedAst)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, simplifiedAst);
+ assert_implication(implyL, implyR);
+ }
+ }
+ }
+ // Case (2-2) end: (Concat (Concat var str) n_eqNode)
+ //---------------------------------------------------------
+
+ // Have to look up one more layer: if the parent of the concat is another concat
+ //-------------------------------------------------
+ // Case (3-1) begin: (Concat (Concat var n_eqNode) str )
+ if (arg1 == n_eqNode) {
+ for (enode_vector::iterator concat_parent_it = e_parent->begin_parents();
+ concat_parent_it != e_parent->end_parents(); concat_parent_it++) {
+ enode * e_concat_parent = *concat_parent_it;
+ app * concat_parent = e_concat_parent->get_owner();
+ if (is_concat(concat_parent)) {
+ expr * concat_parent_arg0 = concat_parent->get_arg(0);
+ expr * concat_parent_arg1 = concat_parent->get_arg(1);
+ if (concat_parent_arg0 == a_parent && m_strutil.is_string(concat_parent_arg1)) {
+ TRACE("t_str_detail", tout << "simplify_parent #5" << std::endl;);
+ expr * combinedStr = eval_concat(eq_str, concat_parent_arg1);
+ SASSERT(combinedStr);
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ expr * simplifiedAst = mk_concat(arg0, combinedStr);
+ if (!in_same_eqc(concat_parent, simplifiedAst)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(concat_parent, simplifiedAst);
+ assert_implication(implyL, implyR);
+ }
+ }
+ }
+ }
+ }
+ // Case (3-1) end: (Concat (Concat var n_eqNode) str )
+ // Case (3-2) begin: (Concat str (Concat n_eqNode var) )
+ if (arg0 == n_eqNode) {
+ for (enode_vector::iterator concat_parent_it = e_parent->begin_parents();
+ concat_parent_it != e_parent->end_parents(); concat_parent_it++) {
+ enode * e_concat_parent = *concat_parent_it;
+ app * concat_parent = e_concat_parent->get_owner();
+ if (is_concat(concat_parent)) {
+ expr * concat_parent_arg0 = concat_parent->get_arg(0);
+ expr * concat_parent_arg1 = concat_parent->get_arg(1);
+ if (concat_parent_arg1 == a_parent && m_strutil.is_string(concat_parent_arg0)) {
+ TRACE("t_str_detail", tout << "simplify_parent #6" << std::endl;);
+ expr * combinedStr = eval_concat(concat_parent_arg0, eq_str);
+ SASSERT(combinedStr);
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ expr * simplifiedAst = mk_concat(combinedStr, arg1);
+ if (!in_same_eqc(concat_parent, simplifiedAst)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(concat_parent, simplifiedAst);
+ assert_implication(implyL, implyR);
+ }
+ }
+ }
+ }
+ }
+ // Case (3-2) end: (Concat str (Concat n_eqNode var) )
+ } // if is_concat(a_parent)
+ } // for parent_it : n_eq_enode->begin_parents()
+
+
+ // check next EQC member
+ n_eq_enode = n_eq_enode->get_next();
+ } while (n_eq_enode != nn_enode);
}
expr * theory_str::simplify_concat(expr * node) {
@@ -2565,7 +2883,44 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
}
}
- // TODO simplify_parent over eqc
+ // simplify parents wrt. the equivalence class of both sides
+ // TODO this is slightly broken, re-enable it once some semantics have been fixed
+ // Briefly, Z3str2 expects that as this function is entered,
+ // lhs and rhs are NOT in the same equivalence class yet.
+ // However, newer versions of Z3 appear to behave differently,
+ // putting lhs and rhs into the same equivalence class
+ // *before* this function is called.
+ // Instead we do something possibly more aggressive here.
+ /*
+ bool lhs_has_eqc_value = false;
+ bool rhs_has_eqc_value = false;
+ expr * lhs_value = get_eqc_value(lhs, lhs_has_eqc_value);
+ expr * rhs_value = get_eqc_value(rhs, rhs_has_eqc_value);
+ if (lhs_has_eqc_value && !rhs_has_eqc_value) {
+ simplify_parent(rhs, lhs_value);
+ }
+ if (!lhs_has_eqc_value && rhs_has_eqc_value) {
+ simplify_parent(lhs, rhs_value);
+ }
+ */
+
+ bool lhs_has_eqc_value = false;
+ bool rhs_has_eqc_value = false;
+ expr * lhs_value = get_eqc_value(lhs, lhs_has_eqc_value);
+ expr * rhs_value = get_eqc_value(rhs, rhs_has_eqc_value);
+
+ // TODO this depends on the old, possibly broken, semantics of is_string().
+ // we explicitly want to test whether lhs/rhs is actually a string constant.
+ bool lhs_is_string_constant = m_strutil.is_string(lhs);
+ bool rhs_is_string_constant = m_strutil.is_string(rhs);
+
+
+ if (lhs_has_eqc_value && !rhs_is_string_constant) {
+ simplify_parent(rhs, lhs_value);
+ }
+ if (rhs_has_eqc_value && !lhs_is_string_constant) {
+ simplify_parent(lhs, rhs_value);
+ }
// TODO regex unroll? (much later)
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 9d56c01fe..e167beb18 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -195,6 +195,7 @@ namespace smt {
expr * getMostLeftNodeInConcat(expr * node);
expr * getMostRightNodeInConcat(expr * node);
void get_var_in_eqc(expr * n, std::set<expr*> & varSet);
+ expr * eval_concat(expr * n1, expr * n2);
// strRegex
From 9fc1410495bb6184606d603ba2f2eda104e23a9e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 17 May 2016 14:53:17 -0400
Subject: [PATCH 083/401] remove incorrect not-null assertions for model gen
---
src/smt/theory_str.cpp | 54 +++++++++++++++++++++++++++++++++++-------
src/smt/theory_str.h | 2 ++
2 files changed, 48 insertions(+), 8 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 254d32141..eace51dcb 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2748,6 +2748,35 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
}
}
+bool theory_str::free_var_attempt(expr * nn1, expr * nn2) {
+ /*
+ Z3_context ctx = Z3_theory_get_context(t);
+ if (getNodeType(t, nn1) == my_Z3_Str_Var) {
+ std::string vName = std::string(Z3_ast_to_string(ctx, nn1));
+ if (vName.length() >= 6) {
+ std::string vPrefix = vName.substr(0, 6);
+ // length attempts
+ if (vPrefix == "$$_len") {
+ if (getNodeType(t, nn2) == my_Z3_ConstStr) {
+ moreLenTests(t, nn1, getConstStrValue(t, nn2));
+ }
+ return 1;
+ }
+ // value attempts
+ else if (vPrefix == "$$_val") {
+ if (getNodeType(t, nn2) == my_Z3_ConstStr && "more" == getConstStrValue(t, nn2)) {
+ moreValueTests(t, nn1, getConstStrValue(t, nn2));
+ }
+ return 1;
+ } else if (vPrefix == "$$_uRt") {
+ return 1;
+ }
+ }
+ }
+ return 0;
+ */
+}
+
void theory_str::handle_equality(expr * lhs, expr * rhs) {
ast_manager & m = get_manager();
context & ctx = get_context();
@@ -2761,8 +2790,6 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
return;
}
- // TODO freeVarAttempt()?
-
// TODO simplify concat?
// newEqCheck() -- check consistency wrt. existing equivalence classes
@@ -4245,6 +4272,8 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
return gen_val_options(freeVar, len_indicator, val_indicator, len_valueStr, tries);
} else {
TRACE("t_str_detail", tout << "checking previous value testers" << std::endl;);
+ print_value_tester_list(fvar_valueTester_map[freeVar][len]);
+
// go through all previous value testers
// If some doesn't have an eqc value, add its assertion again.
int testerTotal = fvar_valueTester_map[freeVar][len].size();
@@ -4258,16 +4287,19 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
bool anEqcHasValue = false;
// Z3_ast anEqc = get_eqc_value(t, aTester, anEqcHasValue);
- get_eqc_value(aTester, anEqcHasValue);
+ expr * aTester_eqc_value = get_eqc_value(aTester, anEqcHasValue);
if (!anEqcHasValue) {
TRACE("t_str_detail", tout << "value tester " << mk_ismt2_pp(aTester, m)
- << "doesn't have an equivalence class value." << std::endl;);
+ << " doesn't have an equivalence class value." << std::endl;);
expr * makeupAssert = gen_val_options(freeVar, len_indicator, aTester, len_valueStr, i);
TRACE("t_str_detail", tout << "var: " << mk_ismt2_pp(freeVar, m) << std::endl
<< mk_ismt2_pp(makeupAssert, m) << std::endl;);
assert_axiom(makeupAssert);
+ } else {
+ TRACE("t_str_detail", tout << "value tester " << mk_ismt2_pp(aTester, m)
+ << " == " << mk_ismt2_pp(aTester_eqc_value, m) << std::endl;);
}
}
@@ -4506,6 +4538,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
testNum = i + 1;
}
expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
+ SASSERT(lenTestAssert != NULL);
return lenTestAssert;
} else {
TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
@@ -4610,8 +4643,11 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
for(std::set<expr*>::iterator itor1 = leafVarSet.begin();
itor1 != leafVarSet.end(); ++itor1) {
expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
- SASSERT(toAssert != NULL);
- assert_axiom(toAssert);
+ // gen_len_val_options_for_free_var() can legally return NULL,
+ // as methods that it calls may assert their own axioms instead.
+ if (toAssert != NULL) {
+ assert_axiom(toAssert);
+ }
}
for (std::map<int, std::set<expr*> >::iterator mItor = aloneVars.begin();
@@ -4619,8 +4655,10 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
std::set<expr*>::iterator itor2 = mItor->second.begin();
for(; itor2 != mItor->second.end(); ++itor2) {
expr * toAssert = gen_len_val_options_for_free_var(*itor2, NULL, "");
- SASSERT(toAssert != NULL);
- assert_axiom(toAssert);
+ // same deal with returning a NULL axiom here
+ if(toAssert != NULL) {
+ assert_axiom(toAssert);
+ }
}
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index e167beb18..242b37747 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -191,6 +191,8 @@ namespace smt {
bool get_next_val_encode(int_vector & base, int_vector & next);
std::string gen_val_string(int len, int_vector & encoding);
+ bool free_var_attempt(expr * nn1, expr * nn2);
+
expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
expr * getMostLeftNodeInConcat(expr * node);
expr * getMostRightNodeInConcat(expr * node);
From 2f80a9d4aecd78e5c483c6f9410f2dd60d81398e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 17 May 2016 16:31:08 -0400
Subject: [PATCH 084/401] add more_len_tests, more_value_tests
---
src/smt/theory_str.cpp | 110 +++++++++++++++++++++++++----------------
src/smt/theory_str.h | 5 ++
2 files changed, 72 insertions(+), 43 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index eace51dcb..ff0aacfa1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -357,15 +357,9 @@ expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
ss << "$$_len_" << mk_ismt2_pp(node, m) << "_" << lTries << "_" << tmpLenTestVarCount;
tmpLenTestVarCount += 1;
std::string name = ss.str();
- return mk_str_var(name);
-
- /*
- Z3_context ctx = Z3_theory_get_context(t);
- std::stringstream ss;
- ss << "$$_len_" << Z3_ast_to_string(ctx, node) << "_" << lTries;
- std::string name = ss.str();
- return my_mk_str_var(t, name.c_str());
- */
+ app * var = mk_str_var(name);
+ internal_lenTest_vars.insert(var);
+ return var;
}
expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
@@ -374,15 +368,9 @@ expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
ss << "$$_val_" << mk_ismt2_pp(node, m) << "_" << len << "_" << vTries << "_" << tmpValTestVarCount;
tmpValTestVarCount += 1;
std::string name = ss.str();
- return mk_str_var(name);
-
- /*
- Z3_context ctx = Z3_theory_get_context(t);
- std::stringstream ss;
- ss << "$$_val_" << Z3_ast_to_string(ctx, node) << "_" << len << "_" << vTries;
- std::string name = ss.str();
- return my_mk_str_var(t, name.c_str());
- */
+ app * var = mk_str_var(name);
+ internal_valTest_vars.insert(var);
+ return var;
}
void theory_str::track_variable_scope(expr * var) {
@@ -2748,33 +2736,65 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
}
}
-bool theory_str::free_var_attempt(expr * nn1, expr * nn2) {
- /*
- Z3_context ctx = Z3_theory_get_context(t);
- if (getNodeType(t, nn1) == my_Z3_Str_Var) {
- std::string vName = std::string(Z3_ast_to_string(ctx, nn1));
- if (vName.length() >= 6) {
- std::string vPrefix = vName.substr(0, 6);
- // length attempts
- if (vPrefix == "$$_len") {
- if (getNodeType(t, nn2) == my_Z3_ConstStr) {
- moreLenTests(t, nn1, getConstStrValue(t, nn2));
- }
- return 1;
+void theory_str::more_len_tests(expr * lenTester, std::string lenTesterValue) {
+ ast_manager & m = get_manager();
+ if (lenTester_fvar_map.find(lenTester) != lenTester_fvar_map.end()) {
+ expr * fVar = lenTester_fvar_map[lenTester];
+ expr * toAssert = gen_len_val_options_for_free_var(fVar, lenTester, lenTesterValue);
+ TRACE("t_str_detail", tout << "asserting more length tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
+ if (toAssert != NULL) {
+ assert_axiom(toAssert);
}
- // value attempts
- else if (vPrefix == "$$_val") {
- if (getNodeType(t, nn2) == my_Z3_ConstStr && "more" == getConstStrValue(t, nn2)) {
- moreValueTests(t, nn1, getConstStrValue(t, nn2));
- }
- return 1;
- } else if (vPrefix == "$$_uRt") {
- return 1;
- }
- }
}
- return 0;
- */
+}
+
+void theory_str::more_value_tests(expr * valTester, std::string valTesterValue) {
+ ast_manager & m = get_manager();
+
+ expr * fVar = valueTester_fvar_map[valTester];
+ int lenTesterCount = fvar_lenTester_map[fVar].size();
+
+ expr * effectiveLenInd = NULL;
+ std::string effectiveLenIndiStr = "";
+ for (int i = 0; i < lenTesterCount; ++i) {
+ expr * len_indicator_pre = fvar_lenTester_map[fVar][i];
+ bool indicatorHasEqcValue = false;
+ expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
+ if (indicatorHasEqcValue) {
+ std::string len_pIndiStr = m_strutil.get_string_constant_value(len_indicator_value);
+ if (len_pIndiStr != "more") {
+ effectiveLenInd = len_indicator_pre;
+ effectiveLenIndiStr = len_pIndiStr;
+ break;
+ }
+ }
+ }
+ expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
+ TRACE("t_str_detail", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
+ if (valueAssert != NULL) {
+ assert_axiom(valueAssert);
+ }
+}
+
+bool theory_str::free_var_attempt(expr * nn1, expr * nn2) {
+ ast_manager & m = get_manager();
+
+ if (internal_lenTest_vars.contains(nn1) && m_strutil.is_string(nn2)) {
+ TRACE("t_str", tout << "acting on equivalence between length tester var " << mk_ismt2_pp(nn1, m)
+ << " and constant " << mk_ismt2_pp(nn2, m) << std::endl;);
+ more_len_tests(nn1, m_strutil.get_string_constant_value(nn2));
+ return true;
+ } else if (internal_valTest_vars.contains(nn1) && m_strutil.is_string(nn2)) {
+ std::string nn2_str = m_strutil.get_string_constant_value(nn2);
+ if (nn2_str == "more") {
+ TRACE("t_str", tout << "acting on equivalence between value var " << mk_ismt2_pp(nn1, m)
+ << " and constant " << mk_ismt2_pp(nn2, m) << std::endl;);
+ more_value_tests(nn1, nn2_str);
+ }
+ return true;
+ } else {
+ return false;
+ }
}
void theory_str::handle_equality(expr * lhs, expr * rhs) {
@@ -2790,6 +2810,10 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
return;
}
+ if (free_var_attempt(lhs, rhs) || free_var_attempt(rhs, lhs)) {
+ return;
+ }
+
// TODO simplify concat?
// newEqCheck() -- check consistency wrt. existing equivalence classes
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 242b37747..3bb3940b6 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -90,6 +90,9 @@ namespace smt {
std::set<expr*> internal_variable_set;
std::map<int, std::set<expr*> > internal_variable_scope_levels;
+ obj_hashtable<expr> internal_lenTest_vars;
+ obj_hashtable<expr> internal_valTest_vars;
+
std::set<expr*> input_var_in_len;
std::map<expr*, unsigned int> fvar_len_count_map;
@@ -192,6 +195,8 @@ namespace smt {
std::string gen_val_string(int len, int_vector & encoding);
bool free_var_attempt(expr * nn1, expr * nn2);
+ void more_len_tests(expr * lenTester, std::string lenTesterValue);
+ void more_value_tests(expr * valTester, std::string valTesterValue);
expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
expr * getMostLeftNodeInConcat(expr * node);
From 866d97f768b0ed0217e66b30762bf6e6aa4ff5ca Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 17 May 2016 16:45:53 -0400
Subject: [PATCH 085/401] fix eval_concat copy-and-paste error in
simplify_parent; concat-eq-concat-case3_sat now passing
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ff0aacfa1..4c936dea5 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -963,7 +963,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
// (Concat arg0 n_eqNode) /\ arg0 has eq const
- expr * concatResult = eval_concat(eq_str, arg1);
+ expr * concatResult = eval_concat(arg0, eq_str);
if (concatResult != NULL) {
bool arg0HasEqcValue = false;
expr * arg0Value = get_eqc_value(arg0, arg0HasEqcValue);
From c8522c5b78a51e537bb36bd5468073be9f588c6b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 19 May 2016 16:51:43 -0400
Subject: [PATCH 086/401] cleanup before attempting to fix the null enode
parent bug
---
src/smt/theory_str.cpp | 38 ++++++++++++++++++++++++++++++++------
1 file changed, 32 insertions(+), 6 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 4c936dea5..7581baf8d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -821,8 +821,6 @@ expr * theory_str::eval_concat(expr * n1, expr * n2) {
* ~ concat node
* to see whether some concat nodes can be simplified.
*/
-
-// TODO NEXT complete this method!
void theory_str::simplify_parent(expr * nn, expr * eq_str) {
ast_manager & m = get_manager();
context & ctx = get_context();
@@ -834,14 +832,17 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
enode * n_eq_enode = ctx.get_enode(nn);
enode * nn_enode = n_eq_enode;
- const char * tmp = 0;
- m_strutil.is_string(eq_str, & tmp);
- std::string eq_strValue(tmp);
+ std::string eq_strValue = m_strutil.get_string_constant_value(eq_str);
do {
app * n_eqNode = n_eq_enode->get_owner();
+ TRACE("t_str_detail", tout << "considering all parents of " << mk_ismt2_pp(n_eqNode, m) << std::endl
+ << "associated n_eq_enode has " << n_eq_enode->get_num_parents() << " parents" << std::endl;);
for (enode_vector::iterator parent_it = n_eq_enode->begin_parents(); parent_it != n_eq_enode->end_parents(); parent_it++) {
enode * e_parent = *parent_it;
+ // TODO deeper bug hiding here
+ SASSERT(e_parent != NULL);
+
app * a_parent = e_parent->get_owner();
TRACE("t_str_detail", tout << "considering parent " << mk_ismt2_pp(a_parent, m) << std::endl;);
@@ -2814,7 +2815,32 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
return;
}
- // TODO simplify concat?
+ if (is_concat(to_app(lhs)) && is_concat(to_app(rhs))) {
+ bool nn1HasEqcValue = false;
+ bool nn2HasEqcValue = false;
+ expr * nn1_value = get_eqc_value(lhs, nn1HasEqcValue);
+ expr * nn2_value = get_eqc_value(rhs, nn2HasEqcValue);
+ if (nn1HasEqcValue && !nn2HasEqcValue) {
+ simplify_parent(rhs, nn1_value);
+ }
+ if (!nn1HasEqcValue && nn2HasEqcValue) {
+ simplify_parent(lhs, nn2_value);
+ }
+
+ expr * nn1_arg0 = to_app(lhs)->get_arg(0);
+ expr * nn1_arg1 = to_app(lhs)->get_arg(1);
+ expr * nn2_arg0 = to_app(rhs)->get_arg(0);
+ expr * nn2_arg1 = to_app(rhs)->get_arg(1);
+ if (nn1_arg0 == nn2_arg0 && in_same_eqc(nn1_arg1, nn2_arg1)) {
+ TRACE("t_str_detail", tout << "skip: lhs arg0 == rhs arg0" << std::endl;);
+ return;
+ }
+
+ if (nn1_arg1 == nn2_arg1 && in_same_eqc(nn1_arg0, nn2_arg0)) {
+ TRACE("t_str_detail", tout << "skip: lhs arg1 == rhs arg1" << std::endl;);
+ return;
+ }
+ }
// newEqCheck() -- check consistency wrt. existing equivalence classes
if (!new_eq_check(lhs, rhs)) {
From 2f494a96119732443e4d41321a6f97508a16a4ce Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 19 May 2016 16:57:01 -0400
Subject: [PATCH 087/401] fix null parent bug by making a copy of
n_eq_enode->m_parents in simplify_parent
---
src/smt/theory_str.cpp | 13 +++++++++++--
1 file changed, 11 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 7581baf8d..bc32e14eb 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -838,9 +838,18 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
app * n_eqNode = n_eq_enode->get_owner();
TRACE("t_str_detail", tout << "considering all parents of " << mk_ismt2_pp(n_eqNode, m) << std::endl
<< "associated n_eq_enode has " << n_eq_enode->get_num_parents() << " parents" << std::endl;);
- for (enode_vector::iterator parent_it = n_eq_enode->begin_parents(); parent_it != n_eq_enode->end_parents(); parent_it++) {
+
+ // the goal of this next bit is to avoid dereferencing a bogus e_parent in the following loop.
+ // what I image is causing this bug is that, for example, we examine some parent, we add an axiom that involves it,
+ // and the parent_it iterator becomes invalidated, because we indirectly modified the container that we're iterating over.
+
+ enode_vector current_parents;
+ for (enode_vector::const_iterator parent_it = n_eq_enode->begin_parents(); parent_it != n_eq_enode->end_parents(); parent_it++) {
+ current_parents.insert(*parent_it);
+ }
+
+ for (enode_vector::iterator parent_it = current_parents.begin(); parent_it != current_parents.end(); ++parent_it) {
enode * e_parent = *parent_it;
- // TODO deeper bug hiding here
SASSERT(e_parent != NULL);
app * a_parent = e_parent->get_owner();
From 2522e35c5e90d2a47f5bf4b2a4ad16f300678c6d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 20 May 2016 10:22:19 -0400
Subject: [PATCH 088/401] start work on string-integer integration
---
src/smt/theory_str.cpp | 33 +++++++++++++++++++++++++++++++++
src/smt/theory_str.h | 2 ++
2 files changed, 35 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index bc32e14eb..05425c61b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2363,6 +2363,39 @@ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
return n;
}
+/*
+ * Look through the equivalence class of n to find an integer constant.
+ * Return that constant if it is found. Otherwise, return -1.
+ * Note that a return value of -1 should not normally be possible, as
+ * string length cannot be negative.
+ */
+
+rational theory_str::get_len_value(expr * n) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ ctx.internalize(n, false);
+
+ TRACE("t_str_detail", tout << "checking eqc of " << mk_ismt2_pp(n, m) << " for an integer constant" << std::endl;);
+
+ enode * nNode = ctx.get_enode(n);
+ enode * eqcNode = nNode;
+ do {
+ app * ast = eqcNode->get_owner();
+ rational val;
+ bool is_int;
+ if (m_autil.is_numeral(n, val, is_int)) {
+ if (is_int) {
+ TRACE("t_str_detail", tout << "eqc contains integer constant " << val << std::endl;);
+ SASSERT(!val.is_neg());
+ return val;
+ }
+ }
+ } while (eqcNode != nNode);
+ // not found
+ TRACE("t_str_detail", tout << "eqc contains no integer constants" << std::endl;);
+ return rational(-1);
+}
+
/*
* Decide whether n1 and n2 are already in the same equivalence class.
* This only checks whether the core considers them to be equal;
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 3bb3940b6..cf7ef0060 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -146,6 +146,8 @@ namespace smt {
expr * get_eqc_value(expr * n, bool & hasEqcValue);
bool in_same_eqc(expr * n1, expr * n2);
+ rational get_len_value(expr * n);
+
bool can_two_nodes_eq(expr * n1, expr * n2);
bool can_concat_eq_str(expr * concat, std::string str);
bool can_concat_eq_concat(expr * concat1, expr * concat2);
From ecb069b7018f52b7621a8ac7445d4ce7968db770 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 20 May 2016 16:34:11 -0400
Subject: [PATCH 089/401] non-fixes to string length code, plus the
get_length() code from new Z3
---
src/smt/theory_str.cpp | 135 ++++++++++++++++++++++++++++++++++-------
src/smt/theory_str.h | 2 +-
2 files changed, 115 insertions(+), 22 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 05425c61b..d3e842fed 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1440,37 +1440,39 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr * m = to_app(concatAst2)->get_arg(0);
expr * n = to_app(concatAst2)->get_arg(1);
- /* TODO query the integer theory:
- int x_len = getLenValue(t, x);
- int y_len = getLenValue(t, y);
- int m_len = getLenValue(t, m);
- int n_len = getLenValue(t, n);
- */
- int x_len = -1;
- int y_len = -1;
- int m_len = -1;
- int n_len = -1;
+ rational x_len = get_len_value(x);
+ rational y_len = get_len_value(y);
+ rational m_len = get_len_value(m);
+ rational n_len = get_len_value(n);
int splitType = -1;
- if (x_len != -1 && m_len != -1) {
- if (x_len < m_len)
+ if (x_len != rational(-1) && m_len != rational(-1)) {
+ if (x_len < m_len) {
splitType = 0;
- else if (x_len == m_len)
+ } else if (x_len == m_len) {
splitType = 1;
- else
+ } else {
splitType = 2;
+ }
}
- if (splitType == -1 && y_len != -1 && n_len != -1) {
- if (y_len > n_len)
+ if (splitType == -1 && y_len != rational(-1) && n_len != rational(-1)) {
+ if (y_len > n_len) {
splitType = 0;
- else if (y_len == n_len)
+ } else if (y_len == n_len) {
splitType = 1;
- else
+ } else {
splitType = 2;
+ }
}
- TRACE("t_str_detail", tout << "split type " << splitType << std::endl;);
+ TRACE("t_str_detail", tout
+ << "len(x) = " << x_len << std::endl
+ << "len(y) = " << y_len << std::endl
+ << "len(m) = " << m_len << std::endl
+ << "len(n) = " << n_len << std::endl
+ << "split type " << splitType << std::endl;
+ );
expr * t1 = NULL;
expr * t2 = NULL;
@@ -2363,6 +2365,93 @@ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
return n;
}
+// from Z3: theory_seq.cpp
+
+/*
+static theory_mi_arith* get_th_arith(context& ctx, theory_id afid, expr* e) {
+ theory* th = ctx.get_theory(afid);
+ if (th && ctx.e_internalized(e)) {
+ return dynamic_cast<theory_mi_arith*>(th);
+ }
+ else {
+ return 0;
+ }
+}
+
+bool theory_seq::get_value(expr* e, rational& val) const {
+ context& ctx = get_context();
+ theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
+ expr_ref _val(m);
+ if (!tha || !tha->get_value(ctx.get_enode(e), _val)) return false;
+ return m_autil.is_numeral(_val, val) && val.is_int();
+}
+
+bool theory_seq::lower_bound(expr* _e, rational& lo) const {
+ context& ctx = get_context();
+ expr_ref e(m_util.str.mk_length(_e), m);
+ theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
+ expr_ref _lo(m);
+ if (!tha || !tha->get_lower(ctx.get_enode(e), _lo)) return false;
+ return m_autil.is_numeral(_lo, lo) && lo.is_int();
+}
+
+bool theory_seq::upper_bound(expr* _e, rational& hi) const {
+ context& ctx = get_context();
+ expr_ref e(m_util.str.mk_length(_e), m);
+ theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
+ expr_ref _hi(m);
+ if (!tha || !tha->get_upper(ctx.get_enode(e), _hi)) return false;
+ return m_autil.is_numeral(_hi, hi) && hi.is_int();
+}
+
+bool theory_seq::get_length(expr* e, rational& val) const {
+ context& ctx = get_context();
+ theory* th = ctx.get_theory(m_autil.get_family_id());
+ if (!th) return false;
+ theory_mi_arith* tha = dynamic_cast<theory_mi_arith*>(th);
+ if (!tha) return false;
+ rational val1;
+ expr_ref len(m), len_val(m);
+ expr* e1, *e2;
+ ptr_vector<expr> todo;
+ todo.push_back(e);
+ val.reset();
+ zstring s;
+ while (!todo.empty()) {
+ expr* c = todo.back();
+ todo.pop_back();
+ if (m_util.str.is_concat(c, e1, e2)) {
+ todo.push_back(e1);
+ todo.push_back(e2);
+ }
+ else if (m_util.str.is_unit(c)) {
+ val += rational(1);
+ }
+ else if (m_util.str.is_empty(c)) {
+ continue;
+ }
+ else if (m_util.str.is_string(c, s)) {
+ val += rational(s.length());
+ }
+ else if (!has_length(c)) {
+ return false;
+ }
+ else {
+ len = m_util.str.mk_length(c);
+ if (ctx.e_internalized(len) &&
+ tha->get_value(ctx.get_enode(len), len_val) &&
+ m_autil.is_numeral(len_val, val1)) {
+ val += val1;
+ }
+ else {
+ return false;
+ }
+ }
+ }
+ return val.is_int();
+}
+*/
+
/*
* Look through the equivalence class of n to find an integer constant.
* Return that constant if it is found. Otherwise, return -1.
@@ -2370,9 +2459,11 @@ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
* string length cannot be negative.
*/
-rational theory_str::get_len_value(expr * n) {
+rational theory_str::get_len_value(expr * x) {
ast_manager & m = get_manager();
context & ctx = get_context();
+ ctx.internalize(x, false);
+ expr * n = mk_strlen(x);
ctx.internalize(n, false);
TRACE("t_str_detail", tout << "checking eqc of " << mk_ismt2_pp(n, m) << " for an integer constant" << std::endl;);
@@ -2383,13 +2474,15 @@ rational theory_str::get_len_value(expr * n) {
app * ast = eqcNode->get_owner();
rational val;
bool is_int;
- if (m_autil.is_numeral(n, val, is_int)) {
+ TRACE("t_str_detail", tout << "eqc member: " << mk_ismt2_pp(ast, m) << std::endl;);
+ if (m_autil.is_numeral(ast, val, is_int)) {
if (is_int) {
TRACE("t_str_detail", tout << "eqc contains integer constant " << val << std::endl;);
SASSERT(!val.is_neg());
return val;
}
}
+ eqcNode = eqcNode->get_next();
} while (eqcNode != nNode);
// not found
TRACE("t_str_detail", tout << "eqc contains no integer constants" << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index cf7ef0060..946340366 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -146,7 +146,7 @@ namespace smt {
expr * get_eqc_value(expr * n, bool & hasEqcValue);
bool in_same_eqc(expr * n1, expr * n2);
- rational get_len_value(expr * n);
+ rational get_len_value(expr * x);
bool can_two_nodes_eq(expr * n1, expr * n2);
bool can_concat_eq_str(expr * concat, std::string str);
From f8f7014a1855d40931a3b2b9202f8c23ca617bc3 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 1 Jun 2016 16:34:48 -0400
Subject: [PATCH 090/401] use LRA instead of LIA in strings setup, so that the
theory_seq integer value code works
---
src/smt/smt_setup.cpp | 2 +-
src/smt/theory_str.cpp | 68 +++++++++++++++++++++++++-----------------
src/smt/theory_str.h | 3 +-
3 files changed, 43 insertions(+), 30 deletions(-)
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index 5e4af91fd..acb03a954 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -700,7 +700,7 @@ namespace smt {
}
void setup::setup_QF_S() {
- setup_QF_LIA();
+ setup_QF_LRA();
m_context.register_plugin(alloc(smt::theory_str, m_manager));
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index d3e842fed..e2e2f55d1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -21,6 +21,7 @@ Revision History:
#include"ast_pp.h"
#include"ast_ll_pp.h"
#include<list>
+#include"theory_arith.h"
namespace smt {
@@ -1440,13 +1441,14 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr * m = to_app(concatAst2)->get_arg(0);
expr * n = to_app(concatAst2)->get_arg(1);
- rational x_len = get_len_value(x);
- rational y_len = get_len_value(y);
- rational m_len = get_len_value(m);
- rational n_len = get_len_value(n);
+ rational x_len, y_len, m_len, n_len;
+ bool x_len_exists = get_len_value(x, x_len);
+ bool y_len_exists = get_len_value(y, y_len);
+ bool m_len_exists = get_len_value(m, m_len);
+ bool n_len_exists = get_len_value(n, n_len);
int splitType = -1;
- if (x_len != rational(-1) && m_len != rational(-1)) {
+ if (x_len_exists && m_len_exists) {
if (x_len < m_len) {
splitType = 0;
} else if (x_len == m_len) {
@@ -1456,7 +1458,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
}
- if (splitType == -1 && y_len != rational(-1) && n_len != rational(-1)) {
+ if (splitType == -1 && y_len_exists && n_len_exists) {
if (y_len > n_len) {
splitType = 0;
} else if (y_len == n_len) {
@@ -2367,7 +2369,6 @@ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
// from Z3: theory_seq.cpp
-/*
static theory_mi_arith* get_th_arith(context& ctx, theory_id afid, expr* e) {
theory* th = ctx.get_theory(afid);
if (th && ctx.e_internalized(e)) {
@@ -2378,15 +2379,18 @@ static theory_mi_arith* get_th_arith(context& ctx, theory_id afid, expr* e) {
}
}
-bool theory_seq::get_value(expr* e, rational& val) const {
+bool theory_str::get_value(expr* e, rational& val) const {
context& ctx = get_context();
+ ast_manager & m = get_manager();
theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
expr_ref _val(m);
if (!tha || !tha->get_value(ctx.get_enode(e), _val)) return false;
return m_autil.is_numeral(_val, val) && val.is_int();
}
-bool theory_seq::lower_bound(expr* _e, rational& lo) const {
+// TODO bring these in as well
+/*
+bool theory_str::lower_bound(expr* _e, rational& lo) const {
context& ctx = get_context();
expr_ref e(m_util.str.mk_length(_e), m);
theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
@@ -2395,7 +2399,7 @@ bool theory_seq::lower_bound(expr* _e, rational& lo) const {
return m_autil.is_numeral(_lo, lo) && lo.is_int();
}
-bool theory_seq::upper_bound(expr* _e, rational& hi) const {
+bool theory_str::upper_bound(expr* _e, rational& hi) const {
context& ctx = get_context();
expr_ref e(m_util.str.mk_length(_e), m);
theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
@@ -2403,54 +2407,60 @@ bool theory_seq::upper_bound(expr* _e, rational& hi) const {
if (!tha || !tha->get_upper(ctx.get_enode(e), _hi)) return false;
return m_autil.is_numeral(_hi, hi) && hi.is_int();
}
+*/
-bool theory_seq::get_length(expr* e, rational& val) const {
+bool theory_str::get_len_value(expr* e, rational& val) {
context& ctx = get_context();
+ ast_manager & m = get_manager();
theory* th = ctx.get_theory(m_autil.get_family_id());
- if (!th) return false;
+ if (!th) {
+ TRACE("t_str_int", tout << "oops, can't get m_autil's theory" << std::endl;);
+ return false;
+ }
theory_mi_arith* tha = dynamic_cast<theory_mi_arith*>(th);
- if (!tha) return false;
+ if (!tha) {
+ TRACE("t_str_int", tout << "oops, can't cast to theory_mi_arith" << std::endl;);
+ return false;
+ }
+
+ TRACE("t_str_int", tout << "checking len value of " << mk_ismt2_pp(e, m) << std::endl;);
+
rational val1;
expr_ref len(m), len_val(m);
expr* e1, *e2;
ptr_vector<expr> todo;
todo.push_back(e);
val.reset();
- zstring s;
while (!todo.empty()) {
expr* c = todo.back();
todo.pop_back();
- if (m_util.str.is_concat(c, e1, e2)) {
+ if (is_concat(to_app(c))) {
+ e1 = to_app(c)->get_arg(0);
+ e2 = to_app(c)->get_arg(1);
todo.push_back(e1);
todo.push_back(e2);
}
- else if (m_util.str.is_unit(c)) {
- val += rational(1);
- }
- else if (m_util.str.is_empty(c)) {
- continue;
- }
- else if (m_util.str.is_string(c, s)) {
- val += rational(s.length());
- }
- else if (!has_length(c)) {
- return false;
+ else if (is_string(to_app(c))) {
+ int sl = m_strutil.get_string_constant_value(c).length();
+ val += rational(sl);
}
else {
- len = m_util.str.mk_length(c);
+ len = mk_strlen(c);
if (ctx.e_internalized(len) &&
tha->get_value(ctx.get_enode(len), len_val) &&
m_autil.is_numeral(len_val, val1)) {
val += val1;
+ TRACE("t_str_int", tout << "subexpression " << mk_ismt2_pp(len, m) << " has length " << val1 << std::endl;);
}
else {
+ TRACE("t_str_int", tout << "subexpression " << mk_ismt2_pp(len, m) << " has no length assignment; bailing out" << std::endl;);
return false;
}
}
}
+ TRACE("t_str_int", tout << "length of " << mk_ismt2_pp(e, m) << " is " << val << std::endl;);
return val.is_int();
}
-*/
/*
* Look through the equivalence class of n to find an integer constant.
@@ -2459,6 +2469,7 @@ bool theory_seq::get_length(expr* e, rational& val) const {
* string length cannot be negative.
*/
+/*
rational theory_str::get_len_value(expr * x) {
ast_manager & m = get_manager();
context & ctx = get_context();
@@ -2488,6 +2499,7 @@ rational theory_str::get_len_value(expr * x) {
TRACE("t_str_detail", tout << "eqc contains no integer constants" << std::endl;);
return rational(-1);
}
+*/
/*
* Decide whether n1 and n2 are already in the same equivalence class.
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 946340366..da950713f 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -146,7 +146,8 @@ namespace smt {
expr * get_eqc_value(expr * n, bool & hasEqcValue);
bool in_same_eqc(expr * n1, expr * n2);
- rational get_len_value(expr * x);
+ bool get_value(expr* e, rational& val) const;
+ bool get_len_value(expr* e, rational& val);
bool can_two_nodes_eq(expr * n1, expr * n2);
bool can_concat_eq_str(expr * concat, std::string str);
From bc79a73779f0b28e10bb98ca22e266362c0c2687 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 1 Jun 2016 17:23:47 -0400
Subject: [PATCH 091/401] lower/upper bound WIP
---
src/smt/theory_str.cpp | 21 +++++++++++----------
src/smt/theory_str.h | 2 ++
2 files changed, 13 insertions(+), 10 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index e2e2f55d1..f7d31a80b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -165,7 +165,6 @@ bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
bool theory_str::internalize_term(app * term) {
context & ctx = get_context();
ast_manager & m = get_manager();
- TRACE("t_str", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
SASSERT(term->get_family_id() == get_family_id());
/* // what I had before
@@ -194,6 +193,7 @@ bool theory_str::internalize_term(app * term) {
mk_var(e);
return true;
}
+ TRACE("t_str", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
unsigned num_args = term->get_num_args();
expr* arg;
for (unsigned i = 0; i < num_args; i++) {
@@ -1447,6 +1447,8 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
bool m_len_exists = get_len_value(m, m_len);
bool n_len_exists = get_len_value(n, n_len);
+ // debugging
+
int splitType = -1;
if (x_len_exists && m_len_exists) {
if (x_len < m_len) {
@@ -2388,26 +2390,25 @@ bool theory_str::get_value(expr* e, rational& val) const {
return m_autil.is_numeral(_val, val) && val.is_int();
}
-// TODO bring these in as well
-/*
-bool theory_str::lower_bound(expr* _e, rational& lo) const {
+bool theory_str::lower_bound(expr* _e, rational& lo) {
context& ctx = get_context();
- expr_ref e(m_util.str.mk_length(_e), m);
+ ast_manager & m = get_manager();
+ expr_ref e(mk_strlen(_e), m);
theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
expr_ref _lo(m);
if (!tha || !tha->get_lower(ctx.get_enode(e), _lo)) return false;
return m_autil.is_numeral(_lo, lo) && lo.is_int();
}
-bool theory_str::upper_bound(expr* _e, rational& hi) const {
+bool theory_str::upper_bound(expr* _e, rational& hi) {
context& ctx = get_context();
- expr_ref e(m_util.str.mk_length(_e), m);
+ ast_manager & m = get_manager();
+ expr_ref e(mk_strlen(_e), m);
theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
expr_ref _hi(m);
if (!tha || !tha->get_upper(ctx.get_enode(e), _hi)) return false;
return m_autil.is_numeral(_hi, hi) && hi.is_int();
}
-*/
bool theory_str::get_len_value(expr* e, rational& val) {
context& ctx = get_context();
@@ -2450,10 +2451,10 @@ bool theory_str::get_len_value(expr* e, rational& val) {
tha->get_value(ctx.get_enode(len), len_val) &&
m_autil.is_numeral(len_val, val1)) {
val += val1;
- TRACE("t_str_int", tout << "subexpression " << mk_ismt2_pp(len, m) << " has length " << val1 << std::endl;);
+ TRACE("t_str_int", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has length " << val1 << std::endl;);
}
else {
- TRACE("t_str_int", tout << "subexpression " << mk_ismt2_pp(len, m) << " has no length assignment; bailing out" << std::endl;);
+ TRACE("t_str_int", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has no length assignment; bailing out" << std::endl;);
return false;
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index da950713f..45c5f3e06 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -148,6 +148,8 @@ namespace smt {
bool get_value(expr* e, rational& val) const;
bool get_len_value(expr* e, rational& val);
+ bool lower_bound(expr* _e, rational& lo);
+ bool upper_bound(expr* _e, rational& hi);
bool can_two_nodes_eq(expr * n1, expr * n2);
bool can_concat_eq_str(expr * concat, std::string str);
From b5fe473c3ac99b012d6cc945bd5ca0109e9f7f3b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 1 Jun 2016 17:50:45 -0400
Subject: [PATCH 092/401] fix compilation errors after merge
---
src/parsers/smt2/smt2parser.cpp | 3 ---
src/smt/theory_str.cpp | 4 ++++
src/smt/theory_str.h | 1 +
3 files changed, 5 insertions(+), 3 deletions(-)
diff --git a/src/parsers/smt2/smt2parser.cpp b/src/parsers/smt2/smt2parser.cpp
index c203b2faa..c8e9a78b6 100644
--- a/src/parsers/smt2/smt2parser.cpp
+++ b/src/parsers/smt2/smt2parser.cpp
@@ -1767,9 +1767,6 @@ namespace smt2 {
case scanner::BV_TOKEN:
parse_bv_numeral();
break;
- case scanner::STRING_TOKEN:
- parse_string();
- break;
case scanner::LEFT_PAREN:
push_expr_frame(m_num_expr_frames == 0 ? 0 : static_cast<expr_frame*>(m_stack.top()));
break;
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f7d31a80b..b65b799b1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4962,4 +4962,8 @@ model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
void theory_str::finalize_model(model_generator & mg) {}
+void theory_str::display(std::ostream & out) const {
+ out << "TODO: theory_str display" << std::endl;
+}
+
}; /* namespace smt */
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 45c5f3e06..ecd7e443f 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -220,6 +220,7 @@ namespace smt {
virtual ~theory_str();
virtual char const * get_name() const { return "strings"; }
+ virtual void display(std::ostream & out) const;
protected:
virtual bool internalize_atom(app * atom, bool gate_ctx);
virtual bool internalize_term(app * term);
From 33205cea712041ce5ba6cc3c6bc465e4c3e84d54 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 1 Jun 2016 17:57:00 -0400
Subject: [PATCH 093/401] completely bypass theory_seq; sorry! I'll put it back
when I'm done
---
src/ast/seq_decl_plugin.cpp | 6 +++---
src/cmd_context/check_logic.cpp | 7 ++++++-
2 files changed, 9 insertions(+), 4 deletions(-)
diff --git a/src/ast/seq_decl_plugin.cpp b/src/ast/seq_decl_plugin.cpp
index 21af0773a..787648e19 100644
--- a/src/ast/seq_decl_plugin.cpp
+++ b/src/ast/seq_decl_plugin.cpp
@@ -256,7 +256,7 @@ std::ostream& zstring::operator<<(std::ostream& out) const {
seq_decl_plugin::seq_decl_plugin(): m_init(false),
- m_stringc_sym("String"),
+ m_stringc_sym("StringSequence"),
m_charc_sym("Char"),
m_string(0),
m_char(0),
@@ -490,7 +490,7 @@ void seq_decl_plugin::set_manager(ast_manager* m, family_id id) {
m_char = bv.mk_sort(8);
m->inc_ref(m_char);
parameter param(m_char);
- m_string = m->mk_sort(symbol("String"), sort_info(m_family_id, SEQ_SORT, 1, ¶m));
+ m_string = m->mk_sort(symbol("StringSequence"), sort_info(m_family_id, SEQ_SORT, 1, ¶m));
m->inc_ref(m_string);
parameter paramS(m_string);
m_re = m->mk_sort(m_family_id, RE_SORT, 1, ¶mS);
@@ -745,7 +745,7 @@ void seq_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol
init();
sort_names.push_back(builtin_name("Seq", SEQ_SORT));
sort_names.push_back(builtin_name("RegEx", RE_SORT));
- sort_names.push_back(builtin_name("String", _STRING_SORT));
+ sort_names.push_back(builtin_name("StringSequence", _STRING_SORT));
}
app* seq_decl_plugin::mk_string(symbol const& s) {
diff --git a/src/cmd_context/check_logic.cpp b/src/cmd_context/check_logic.cpp
index 733689ac9..a547ab616 100644
--- a/src/cmd_context/check_logic.cpp
+++ b/src/cmd_context/check_logic.cpp
@@ -21,6 +21,7 @@ Revision History:
#include"array_decl_plugin.h"
#include"bv_decl_plugin.h"
#include"seq_decl_plugin.h"
+#include"str_decl_plugin.h"
#include"ast_pp.h"
#include"for_each_expr.h"
@@ -31,6 +32,7 @@ struct check_logic::imp {
bv_util m_bv_util;
array_util m_ar_util;
seq_util m_seq_util;
+ str_util m_str_util;
bool m_uf; // true if the logic supports uninterpreted functions
bool m_arrays; // true if the logic supports arbitrary arrays
bool m_bv_arrays; // true if the logic supports only bv arrays
@@ -42,7 +44,7 @@ struct check_logic::imp {
bool m_quantifiers; // true if the logic supports quantifiers
bool m_unknown_logic;
- imp(ast_manager & _m):m(_m), m_a_util(m), m_bv_util(m), m_ar_util(m), m_seq_util(m) {
+ imp(ast_manager & _m):m(_m), m_a_util(m), m_bv_util(m), m_ar_util(m), m_seq_util(m), m_str_util(m) {
reset();
}
@@ -432,6 +434,9 @@ struct check_logic::imp {
else if (fid == m_seq_util.get_family_id()) {
// nothing to check
}
+ else if (fid == m_str_util.get_family_id()) {
+ // nothing to check
+ }
else {
fail("logic does not support theory");
}
From e0df5bc2edf3b68f2d8c6403332c93d0664afe48 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 4 Jun 2016 16:29:10 -0400
Subject: [PATCH 094/401] fixups for string-integer
---
src/smt/theory_str.cpp | 33 ++++++++++++++++++++++-----------
1 file changed, 22 insertions(+), 11 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b65b799b1..eb64aae5d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1447,10 +1447,9 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
bool m_len_exists = get_len_value(m, m_len);
bool n_len_exists = get_len_value(n, n_len);
- // debugging
-
int splitType = -1;
if (x_len_exists && m_len_exists) {
+ TRACE("t_str_int", tout << "length values found: x/m" << std::endl;);
if (x_len < m_len) {
splitType = 0;
} else if (x_len == m_len) {
@@ -1461,6 +1460,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
if (splitType == -1 && y_len_exists && n_len_exists) {
+ TRACE("t_str_int", tout << "length values found: y/n" << std::endl;);
if (y_len > n_len) {
splitType = 0;
} else if (y_len == n_len) {
@@ -1471,10 +1471,10 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
TRACE("t_str_detail", tout
- << "len(x) = " << x_len << std::endl
- << "len(y) = " << y_len << std::endl
- << "len(m) = " << m_len << std::endl
- << "len(n) = " << n_len << std::endl
+ << "len(x) = " << (x_len_exists ? x_len.to_string() : "?") << std::endl
+ << "len(y) = " << (y_len_exists ? y_len.to_string() : "?") << std::endl
+ << "len(m) = " << (m_len_exists ? m_len.to_string() : "?") << std::endl
+ << "len(n) = " << (n_len_exists ? n_len.to_string() : "?") << std::endl
<< "split type " << splitType << std::endl;
);
@@ -2385,11 +2385,24 @@ bool theory_str::get_value(expr* e, rational& val) const {
context& ctx = get_context();
ast_manager & m = get_manager();
theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
+ if (!tha) {
+ return false;
+ }
expr_ref _val(m);
- if (!tha || !tha->get_value(ctx.get_enode(e), _val)) return false;
- return m_autil.is_numeral(_val, val) && val.is_int();
+ enode * en_e = ctx.get_enode(e);
+ enode * it = en_e;
+ do {
+ if (tha->get_value(it, _val)) {
+ // found an arithmetic term
+ return m_autil.is_numeral(_val, val) && val.is_int();
+ }
+ it = it->get_next();
+ } while (it != en_e);
+ return false;
}
+// TODO these methods currently crash the solver, find out why
+
bool theory_str::lower_bound(expr* _e, rational& lo) {
context& ctx = get_context();
ast_manager & m = get_manager();
@@ -2447,9 +2460,7 @@ bool theory_str::get_len_value(expr* e, rational& val) {
}
else {
len = mk_strlen(c);
- if (ctx.e_internalized(len) &&
- tha->get_value(ctx.get_enode(len), len_val) &&
- m_autil.is_numeral(len_val, val1)) {
+ if (ctx.e_internalized(len) && get_value(len, val1)) {
val += val1;
TRACE("t_str_int", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has length " << val1 << std::endl;);
}
From 62aeff90c53ae03962b907a46ae2de07ca4ae511 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 7 Jun 2016 17:38:57 -0400
Subject: [PATCH 095/401] fix string theory setup so that string-integer
integration actually works
---
src/smt/smt_setup.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index 5a7547609..117b606fd 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -706,7 +706,7 @@ namespace smt {
}
void setup::setup_QF_S() {
- setup_QF_LRA();
+ m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params));
m_context.register_plugin(alloc(smt::theory_str, m_manager));
}
From 513b4922eee8ac4b576d8588e31606c99645524e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 7 Jun 2016 17:40:59 -0400
Subject: [PATCH 096/401] tracing code for string-integer integration
---
src/smt/theory_arith.h | 14 ++++++++++++-
src/smt/theory_arith_core.h | 41 +++++++++++++++++++++++++++++++++++--
src/smt/theory_str.cpp | 31 +++++++++++++++++++++++++---
3 files changed, 80 insertions(+), 6 deletions(-)
diff --git a/src/smt/theory_arith.h b/src/smt/theory_arith.h
index 39f991c72..7e594abe5 100644
--- a/src/smt/theory_arith.h
+++ b/src/smt/theory_arith.h
@@ -576,7 +576,19 @@ namespace smt {
return is_free(get_context().get_enode(n)->get_th_var(get_id()));
}
bool is_fixed(theory_var v) const;
- void set_bound_core(theory_var v, bound * new_bound, bool upper) { m_bounds[static_cast<unsigned>(upper)][v] = new_bound; }
+ void set_bound_core(theory_var v, bound * new_bound, bool upper) {
+ TRACE("t_str_int",
+ tout << "setting " << (upper ? "upper" : "lower") << " bound ";
+ if (new_bound) {
+ tout << new_bound->get_value();
+ } else {
+ tout << "(NULL)";
+ }
+ tout << " for theory var v#" << v;
+ tout << std::endl;
+ );
+ m_bounds[static_cast<unsigned>(upper)][v] = new_bound;
+ }
void restore_bound(theory_var v, bound * new_bound, bool upper) { set_bound_core(v, new_bound, upper); }
void restore_nl_propagated_flag(unsigned old_trail_size);
void set_bound(bound * new_bound, bool upper);
diff --git a/src/smt/theory_arith_core.h b/src/smt/theory_arith_core.h
index 95c7fdfad..1ce56ffe8 100644
--- a/src/smt/theory_arith_core.h
+++ b/src/smt/theory_arith_core.h
@@ -3223,13 +3223,50 @@ namespace smt {
bool theory_arith<Ext>::get_value(enode * n, expr_ref & r) {
theory_var v = n->get_th_var(get_id());
inf_numeral val;
- return v != null_theory_var && (val = get_value(v), (!is_int(v) || val.is_int())) && to_expr(val, is_int(v), r);
+ // rewrites for tracing purposes
+ if (v == null_theory_var) {
+ TRACE("t_str_int", tout << "WARNING: enode " << mk_pp(n->get_owner(), get_manager())
+ << " attached to null theory var" << std::endl;
+ );
+ return false;
+ } else {
+ val = get_value(v);
+ TRACE("t_str_int", tout << "enode " << mk_pp(n->get_owner(), get_manager())
+ << " attached to theory var v#" << v
+ << ", has val = " << val
+ << std::endl;
+ );
+ if (!is_int(v) || val.is_int()) {
+ return to_expr(val, is_int(v), r);
+ } else {
+ return false;
+ }
+ }
+ // return v != null_theory_var && (val = get_value(v), (!is_int(v) || val.is_int())) && to_expr(val, is_int(v), r);
}
template<typename Ext>
bool theory_arith<Ext>::get_lower(enode * n, expr_ref & r) {
theory_var v = n->get_th_var(get_id());
- bound* b = (v == null_theory_var) ? 0 : lower(v);
+ bound * b;
+ if (v == null_theory_var) {
+ TRACE("t_str_int", tout << "WARNING: enode " << mk_pp(n->get_owner(), get_manager())
+ << " attached to null theory var" << std::endl;
+ );
+ b = 0;
+ } else {
+ b = lower(v);
+ TRACE("t_str_int",
+ tout << "enode " << mk_pp(n->get_owner(), get_manager())
+ << " attached to theory var v#" << v
+ << std::endl;
+ if (b) {
+ tout << "lower bound = " << b->get_value() << std::endl;
+ } else {
+ tout << "WARNING: b = NULL" << std::endl;
+ }
+ );
+ }
return b && to_expr(b->get_value(), is_int(v), r);
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index eb64aae5d..3b59961a3 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1470,6 +1470,14 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
}
+ {
+ rational x_lb, x_ub;
+ bool x_lb_p = lower_bound(x, x_lb);
+ bool x_ub_p = upper_bound(x, x_ub);
+ TRACE("t_str_detail", tout << "X [" << x_lb << ":" << x_ub << "]" << std::endl
+ << "lb? " << (x_lb_p?"yes":"no") << " ub? " << (x_ub_p?"yes":"no") << std::endl;);
+ }
+
TRACE("t_str_detail", tout
<< "len(x) = " << (x_len_exists ? x_len.to_string() : "?") << std::endl
<< "len(y) = " << (y_len_exists ? y_len.to_string() : "?") << std::endl
@@ -2388,21 +2396,25 @@ bool theory_str::get_value(expr* e, rational& val) const {
if (!tha) {
return false;
}
+ TRACE("t_str_int", tout << "checking eqc of " << mk_pp(e, m) << " for arithmetic value" << std::endl;);
expr_ref _val(m);
enode * en_e = ctx.get_enode(e);
enode * it = en_e;
do {
if (tha->get_value(it, _val)) {
// found an arithmetic term
+ TRACE("t_str_int", tout << "get_value[" << mk_pp(it->get_owner(), m) << "] = " << mk_pp(_val, m)
+ << std::endl;);
return m_autil.is_numeral(_val, val) && val.is_int();
+ } else {
+ TRACE("t_str_int", tout << "get_value[" << mk_pp(it->get_owner(), m) << "] not found" << std::endl;);
}
it = it->get_next();
} while (it != en_e);
+ TRACE("t_str_int", tout << "no arithmetic values found in eqc" << std::endl;);
return false;
}
-// TODO these methods currently crash the solver, find out why
-
bool theory_str::lower_bound(expr* _e, rational& lo) {
context& ctx = get_context();
ast_manager & m = get_manager();
@@ -2460,6 +2472,19 @@ bool theory_str::get_len_value(expr* e, rational& val) {
}
else {
len = mk_strlen(c);
+
+ // debugging
+ TRACE("t_str_int", {
+ tout << mk_pp(len, m) << ":" << std::endl
+ << (ctx.is_relevant(len.get()) ? "relevant" : "not relevant") << std::endl
+ << (ctx.e_internalized(len) ? "internalized" : "not internalized") << std::endl
+ ;
+ if (ctx.e_internalized(len)) {
+ enode * e_len = ctx.get_enode(len);
+ tout << "has " << e_len->get_num_th_vars() << " theory vars" << std::endl;
+ }
+ });
+
if (ctx.e_internalized(len) && get_value(len, val1)) {
val += val1;
TRACE("t_str_int", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has length " << val1 << std::endl;);
@@ -3225,7 +3250,7 @@ void theory_str::init_search_eh() {
unsigned nFormulas = ctx.get_num_asserted_formulas();
for (unsigned i = 0; i < nFormulas; ++i) {
expr * ex = ctx.get_asserted_formula(i);
- tout << mk_ismt2_pp(ex, m) << std::endl;
+ tout << mk_ismt2_pp(ex, m) << (ctx.is_relevant(ex) ? " (rel)" : " (NOT REL)") << std::endl;
}
);
/*
From 04fe8f66df6fc10722dade93db0d5f103982dd0e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 8 Jun 2016 16:22:31 -0400
Subject: [PATCH 097/401] concat-eq-concat type 1 split 0
---
src/smt/theory_str.cpp | 54 +++++++++++++++++++++++++++++++++++-------
src/smt/theory_str.h | 1 +
2 files changed, 46 insertions(+), 9 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3b59961a3..cc164ec3b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -348,6 +348,10 @@ app * theory_str::mk_int(int n) {
return m_autil.mk_numeral(rational(n), true);
}
+app * theory_str::mk_int(rational & q) {
+ return m_autil.mk_numeral(q, true);
+}
+
// TODO refactor all of these so that they don't use variable counters, but use ast_manager::mk_fresh_const instead
@@ -1470,14 +1474,6 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
}
- {
- rational x_lb, x_ub;
- bool x_lb_p = lower_bound(x, x_lb);
- bool x_ub_p = upper_bound(x, x_ub);
- TRACE("t_str_detail", tout << "X [" << x_lb << ":" << x_ub << "]" << std::endl
- << "lb? " << (x_lb_p?"yes":"no") << " ub? " << (x_ub_p?"yes":"no") << std::endl;);
- }
-
TRACE("t_str_detail", tout
<< "len(x) = " << (x_len_exists ? x_len.to_string() : "?") << std::endl
<< "len(y) = " << (y_len_exists ? y_len.to_string() : "?") << std::endl
@@ -1518,7 +1514,47 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
// For split types 0 through 2, we can get away with providing
// fewer split options since more length information is available.
if (splitType == 0) {
- NOT_IMPLEMENTED_YET(); // TODO
+ //--------------------------------------
+ // Type 0: M cuts Y.
+ // len(x) < len(m) || len(y) > len(n)
+ //--------------------------------------
+ if (!has_self_cut(m, y)) {
+ expr ** ax_l_items = alloc_svect(expr*, 3);
+ expr ** ax_r_items = alloc_svect(expr*, 3);
+
+ ax_l_items[0] = ctx.mk_eq_atom(concatAst1, concatAst2);
+
+ expr_ref x_t1(mk_concat(x, t1), mgr);
+ expr_ref t1_n(mk_concat(t1, n), mgr);
+
+ ax_r_items[0] = ctx.mk_eq_atom(m, x_t1);
+ ax_r_items[1] = ctx.mk_eq_atom(y, t1_n);
+
+ if (m_len_exists && x_len_exists) {
+ ax_l_items[1] = ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len));
+ ax_l_items[2] = ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len));
+ rational m_sub_x = m_len - x_len;
+ ax_r_items[2] = ctx.mk_eq_atom(mk_strlen(t1), mk_int(m_sub_x));
+ } else {
+ ax_l_items[1] = ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len));
+ ax_l_items[2] = ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len));
+ rational y_sub_n = y_len - n_len;
+ ax_r_items[2] = ctx.mk_eq_atom(mk_strlen(t1), mk_int(y_sub_n));
+ }
+
+ expr_ref ax_l(mgr.mk_and(3, ax_l_items), mgr);
+ expr_ref ax_r(mgr.mk_and(3, ax_r_items), mgr);
+
+ // Cut Info
+ add_cut_info_merge(t1, sLevel, m);
+ add_cut_info_merge(t1, sLevel, y);
+
+ assert_implication(ax_l, ax_r);
+ } else {
+ loopDetected = true;
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ // TODO printCutVar(m, y);
+ }
} else if (splitType == 1) {
NOT_IMPLEMENTED_YET(); // TODO
} else if (splitType == 2) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index ecd7e443f..e8dc6909e 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -117,6 +117,7 @@ namespace smt {
expr * mk_concat_const_str(expr * n1, expr * n2);
app * mk_int(int n);
+ app * mk_int(rational & q);
void check_and_init_cut_var(expr * node);
void add_cut_info_one_node(expr * baseNode, int slevel, expr * node);
From bd2b014008483ac42c53338007d5dab59b704880 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 8 Jun 2016 19:32:25 -0400
Subject: [PATCH 098/401] debugging information for dependence analysis
---
src/smt/theory_str.cpp | 209 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 22 +++++
2 files changed, 227 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index cc164ec3b..4918c999b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -27,6 +27,10 @@ namespace smt {
theory_str::theory_str(ast_manager & m):
theory(m.mk_family_id("str")),
+ /* Options */
+ opt_AggressiveLengthTesting(true),
+ opt_AggressiveValueTesting(true),
+ /* Internal setup */
search_started(false),
m_autil(m),
m_strutil(m),
@@ -344,6 +348,14 @@ void theory_str::check_and_init_cut_var(expr * node) {
}
}
+literal theory_str::mk_literal(expr* _e) {
+ ast_manager & m = get_manager();
+ expr_ref e(_e, m);
+ context& ctx = get_context();
+ ensure_enode(e);
+ return ctx.get_literal(e);
+}
+
app * theory_str::mk_int(int n) {
return m_autil.mk_numeral(rational(n), true);
}
@@ -3513,6 +3525,160 @@ inline expr * theory_str::getMostRightNodeInConcat(expr * node) {
}
}
+void theory_str::trace_ctx_dep(std::ofstream & tout,
+ std::map<expr*, expr*> & aliasIndexMap,
+ std::map<expr*, expr*> & var_eq_constStr_map,
+ std::map<expr*, std::map<expr*, int> > & var_eq_concat_map,
+ std::map<expr*, expr*> & concat_eq_constStr_map,
+ std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map) {
+#ifdef _TRACE
+ ast_manager & mgr = get_manager();
+ {
+ tout << "(0) alias: variables" << std::endl;
+ std::map<expr*, std::map<expr*, int> > aliasSumMap;
+ std::map<expr*, expr*>::iterator itor0 = aliasIndexMap.begin();
+ for (; itor0 != aliasIndexMap.end(); itor0++) {
+ aliasSumMap[itor0->second][itor0->first] = 1;
+ }
+ std::map<expr*, std::map<expr*, int> >::iterator keyItor = aliasSumMap.begin();
+ for (; keyItor != aliasSumMap.end(); keyItor++) {
+ tout << " * ";
+ tout << mk_pp(keyItor->first, mgr);
+ tout << " : ";
+ std::map<expr*, int>::iterator innerItor = keyItor->second.begin();
+ for (; innerItor != keyItor->second.end(); innerItor++) {
+ tout << mk_pp(innerItor->first, mgr);
+ tout << ", ";
+ }
+ tout << std::endl;
+ }
+ tout << std::endl;
+ }
+
+ {
+ tout << "(1) var = constStr:" << std::endl;
+ std::map<expr*, expr*>::iterator itor1 = var_eq_constStr_map.begin();
+ for (; itor1 != var_eq_constStr_map.end(); itor1++) {
+ tout << " * ";
+ tout << mk_pp(itor1->first, mgr);
+ tout << " = ";
+ tout << mk_pp(itor1->second, mgr);
+ if (!in_same_eqc(itor1->first, itor1->second)) {
+ tout << " (not true in ctx)";
+ }
+ tout << std::endl;
+ }
+ tout << std::endl;
+ }
+
+ {
+ tout << "(2) var = concat:" << std::endl;
+ std::map<expr*, std::map<expr*, int> >::iterator itor2 = var_eq_concat_map.begin();
+ for (; itor2 != var_eq_concat_map.end(); itor2++) {
+ tout << " * ";
+ tout << mk_pp(itor2->first, mgr);
+ tout << " = { ";
+ std::map<expr*, int>::iterator i_itor = itor2->second.begin();
+ for (; i_itor != itor2->second.end(); i_itor++) {
+ tout << mk_pp(i_itor->first, mgr);
+ tout << ", ";
+ }
+ tout << std::endl;
+ }
+ tout << std::endl;
+ }
+/*// TODO
+ {
+ __debugPrint(logFile, "(3) var = unrollFunc:\n");
+ std::map<Z3_ast, std::map<Z3_ast, int> >::iterator itor2 = var_eq_unroll_map.begin();
+ for (; itor2 != var_eq_unroll_map.end(); itor2++) {
+ __debugPrint(logFile, " * ");
+ printZ3Node(t, itor2->first);
+ __debugPrint(logFile, " = { ");
+ std::map<Z3_ast, int>::iterator i_itor = itor2->second.begin();
+ for (; i_itor != itor2->second.end(); i_itor++) {
+ printZ3Node(t, i_itor->first);
+ __debugPrint(logFile, ", ");
+ }
+ __debugPrint(logFile, " }\n");
+ }
+ __debugPrint(logFile, "\n");
+ }
+*/
+ {
+ tout << "(4) concat = constStr:" << std::endl;
+ std::map<expr*, expr*>::iterator itor3 = concat_eq_constStr_map.begin();
+ for (; itor3 != concat_eq_constStr_map.end(); itor3++) {
+ tout << " * ";
+ tout << mk_pp(itor3->first, mgr);
+ tout << " = ";
+ tout << mk_pp(itor3->second, mgr);
+ tout << std::endl;
+
+ }
+ tout << std::endl;
+ }
+
+ {
+ tout << "(5) eq concats:" << std::endl;
+ std::map<expr*, std::map<expr*, int> >::iterator itor4 = concat_eq_concat_map.begin();
+ for (; itor4 != concat_eq_concat_map.end(); itor4++) {
+ if (itor4->second.size() > 1) {
+ std::map<expr*, int>::iterator i_itor = itor4->second.begin();
+ tout << " * ";
+ for (; i_itor != itor4->second.end(); i_itor++) {
+ tout << mk_pp(i_itor->first, mgr);
+ tout << " , ";
+ }
+ tout << std::endl;
+ }
+ }
+ tout << std::endl;
+ }
+/*// TODO
+ {
+ __debugPrint(logFile, "(6) eq unrolls:\n");
+ std::map<Z3_ast, std::set<Z3_ast> >::iterator itor5 = unrollGroupMap.begin();
+ for (; itor5 != unrollGroupMap.end(); itor5++) {
+ __debugPrint(logFile, " * ");
+ std::set<Z3_ast>::iterator i_itor = itor5->second.begin();
+ for (; i_itor != itor5->second.end(); i_itor++) {
+ printZ3Node(t, *i_itor);
+ __debugPrint(logFile, ", ");
+ }
+ __debugPrint(logFile, "\n");
+ }
+ __debugPrint(logFile, "\n");
+ }
+
+ {
+ __debugPrint(logFile, "(7) unroll = concats:\n");
+ std::map<Z3_ast, std::set<Z3_ast> >::iterator itor5 = unrollGroupMap.begin();
+ for (; itor5 != unrollGroupMap.end(); itor5++) {
+ __debugPrint(logFile, " * ");
+ Z3_ast unroll = itor5->first;
+ printZ3Node(t, unroll);
+ __debugPrint(logFile, "\n");
+ Z3_ast curr = unroll;
+ do {
+ if (isConcatFunc(t, curr)) {
+ __debugPrint(logFile, " >>> ");
+ printZ3Node(t, curr);
+ __debugPrint(logFile, "\n");
+ }
+ curr = Z3_theory_get_eqc_next(t, curr);
+ }while (curr != unroll);
+ __debugPrint(logFile, "\n");
+ }
+ __debugPrint(logFile, "\n");
+ }
+ */
+#else
+ return;
+#endif // _TRACE
+}
+
+
/*
* Dependence analysis from current context assignment
* - "freeVarMap" contains a set of variables that doesn't constrained by Concats.
@@ -3747,7 +3913,9 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
}
}
- // TODO this would be a great place to print some debugging information
+ // print some debugging info
+ TRACE("t_str_detail", trace_ctx_dep(tout, aliasIndexMap, var_eq_constStr_map,
+ var_eq_concat_map, concat_eq_constStr_map, concat_eq_concat_map););
// TODO compute Contains
/*
@@ -4409,6 +4577,7 @@ bool theory_str::get_next_val_encode(int_vector & base, int_vector & next) {
expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
std::string lenStr, int tries) {
ast_manager & m = get_manager();
+ context & ctx = get_context();
int distance = 32;
@@ -4434,8 +4603,11 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
<< "len_indicator = " << mk_ismt2_pp(len_indicator, m) << std::endl
<< "val_indicator = " << mk_ismt2_pp(val_indicator, m) << std::endl
<< "lenstr = " << lenStr << std::endl
- << "tries = " << tries << std::endl
- ;);
+ << "tries = " << tries << std::endl;
+ if (opt_AggressiveValueTesting) {
+ tout << "note: aggressive value testing is enabled" << std::endl;
+ }
+ );
if (tries == 0) {
base = int_vector(len + 1, 0);
@@ -4474,12 +4646,23 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
for (long long i = l; i < h; i++) {
orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string(longlong_to_string(i).c_str()) ));
+ if (opt_AggressiveValueTesting) {
+ literal l = mk_eq(val_indicator, m_strutil.mk_string(longlong_to_string(i).c_str()), false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(l);
+ }
+
std::string aStr = gen_val_string(len, options[i - l]);
expr * strAst = m_strutil.mk_string(aStr);
andList.push_back(m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVar, strAst)));
}
if (!coverAll) {
orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string("more")));
+ if (opt_AggressiveValueTesting) {
+ literal l = mk_eq(val_indicator, m_strutil.mk_string("more"), false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(~l);
+ }
}
expr ** or_items = alloc_svect(expr*, orList.size());
@@ -4593,6 +4776,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tries) {
ast_manager & m = get_manager();
+ context & ctx = get_context();
TRACE("t_str_detail", tout << "entry" << std::endl;);
@@ -4606,7 +4790,12 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
int l = (tries - 1) * distance;
int h = tries * distance;
- TRACE("t_str_detail", tout << "building andList and orList" << std::endl;);
+ TRACE("t_str_detail",
+ tout << "building andList and orList" << std::endl;
+ if (opt_AggressiveLengthTesting) {
+ tout << "note: aggressive length testing is active" << std::endl;
+ }
+ );
for (int i = l; i < h; ++i) {
std::string i_str = int_to_string(i);
@@ -4616,12 +4805,24 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
TRACE("t_str_detail", tout << "or_expr = " << mk_ismt2_pp(or_expr, m) << std::endl;);
orList.push_back(or_expr);
+ if (opt_AggressiveLengthTesting) {
+ literal l = mk_eq(indicator, str_indicator, false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(l);
+ }
+
expr * and_expr = m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVarLen, mk_int(i)));
TRACE("t_str_detail", tout << "and_expr = " << mk_ismt2_pp(and_expr, m) << std::endl;);
andList.push_back(and_expr);
}
orList.push_back(m.mk_eq(indicator, m_strutil.mk_string("more")));
+ if (opt_AggressiveLengthTesting) {
+ literal l = mk_eq(indicator, m_strutil.mk_string("more"), false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(~l);
+ }
+
andList.push_back(m.mk_eq(orList[orList.size() - 1], m_autil.mk_ge(freeVarLen, mk_int(h))));
// TODO refactor this to use expr_ref_vector/svector/buffer instead
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index e8dc6909e..6616e9ffa 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -62,6 +62,20 @@ namespace smt {
}
};
protected:
+ // Some options that control how the solver operates.
+
+ /*
+ * If AggressiveLengthTesting is true, we manipulate the phase of length tester equalities
+ * to prioritize trying concrete length options over choosing the "more" option.
+ */
+ bool opt_AggressiveLengthTesting;
+
+ /*
+ * Similarly, if AggressiveValueTesting is true, we manipulate the phase of value tester equalities
+ * to prioritize trying concrete value options over choosing the "more" option.
+ */
+ bool opt_AggressiveValueTesting;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -116,6 +130,7 @@ namespace smt {
expr * mk_concat(expr * n1, expr * n2);
expr * mk_concat_const_str(expr * n1, expr * n2);
+ literal mk_literal(expr* _e);
app * mk_int(int n);
app * mk_int(rational & q);
@@ -183,6 +198,13 @@ namespace smt {
int ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr*, int> & freeVarMap,
std::map<expr*, std::set<expr*> > & unrollGroupMap);
+ void trace_ctx_dep(std::ofstream & tout,
+ std::map<expr*, expr*> & aliasIndexMap,
+ std::map<expr*, expr*> & var_eq_constStr_map,
+ std::map<expr*, std::map<expr*, int> > & var_eq_concat_map,
+ std::map<expr*, expr*> & concat_eq_constStr_map,
+ std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map);
+
void classify_ast_by_type(expr * node, std::map<expr*, int> & varMap,
std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
void classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
From 633237257390ce0e4aa4ebc490a318953adce856 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 8 Jun 2016 20:01:56 -0400
Subject: [PATCH 099/401] more debugging info in theory_str final check; fix
variable classification bug
---
src/smt/theory_str.cpp | 23 +++++++++++++++++++----
1 file changed, 19 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 4918c999b..8523fa29c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3431,10 +3431,12 @@ void theory_str::dump_assignments() {
void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap,
std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap) {
- // check whether the node is a non-internal string variable;
- // testing set membership here bypasses several expensive checks
+ // check whether the node is a string variable;
+ // testing set membership here bypasses several expensive checks.
+ // note that internal variables don't count if they're only length tester / value tester vars.
if (variable_set.find(node) != variable_set.end()
- && internal_variable_set.find(node) == internal_variable_set.end()) {
+ && internal_lenTest_vars.find(node) == internal_lenTest_vars.end()
+ && internal_valTest_vars.find(node) == internal_valTest_vars.end()) {
varMap[node] = 1;
}
// check whether the node is a function that we want to inspect
@@ -4140,7 +4142,20 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
}
}
- // TODO this would be a great place to print the dependence map
+ // print the dependence map
+ TRACE("t_str_detail",
+ tout << "Dependence Map" << std::endl;
+ for(std::map<expr*, std::map<expr*, int> >::iterator itor = depMap.begin(); itor != depMap.end(); itor++) {
+ tout << mk_pp(itor->first, m);
+ rational nnLen;
+ bool nnLen_exists = get_len_value(itor->first, nnLen);
+ tout << " [len = " << (nnLen_exists ? nnLen.to_string() : "?") << "] \t-->\t";
+ for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
+ tout << mk_pp(itor1->first, m) << "(" << itor1->second << "), ";
+ }
+ tout << std::endl;
+ }
+ );
// step, errr, 5: compute free variables based on the dependence map
From ae74b47924984a7778b77152fc00c96c918e178c Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 9 Jun 2016 15:41:31 -0400
Subject: [PATCH 100/401] string concat-eq type 1 integer integration
---
src/smt/theory_str.cpp | 49 +++++++++++++++++++++++++++++++++++++++---
1 file changed, 46 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 8523fa29c..6de5a10b7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1568,9 +1568,52 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
// TODO printCutVar(m, y);
}
} else if (splitType == 1) {
- NOT_IMPLEMENTED_YET(); // TODO
+ // Type 1:
+ // len(x) = len(m) || len(y) = len(n)
+ expr_ref ax_l1(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref ax_l2(mgr.mk_or(ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)), ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n))), mgr);
+ expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
+ expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x,m), ctx.mk_eq_atom(y,n)), mgr);
+ assert_implication(ax_l, ax_r);
} else if (splitType == 2) {
- NOT_IMPLEMENTED_YET(); // TODO
+ // Type 2: X cuts N.
+ // len(x) > len(m) || len(y) < len(n)
+ if (!has_self_cut(x, n)) {
+ expr_ref m_t2(mk_concat(m, t2), mgr);
+ expr_ref t2_y(mk_concat(t2, y), mgr);
+
+ expr ** ax_l_items = alloc_svect(expr*, 3);
+ ax_l_items[0] = ctx.mk_eq_atom(concatAst1, concatAst2);
+
+ expr ** ax_r_items = alloc_svect(expr*, 3);
+ ax_r_items[0] = ctx.mk_eq_atom(x, m_t2);
+ ax_r_items[1] = ctx.mk_eq_atom(t2_y, n);
+
+ if (m_len_exists && x_len_exists) {
+ ax_l_items[1] = ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len));
+ ax_l_items[2] = ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len));
+ rational x_sub_m = x_len - m_len;
+ ax_r_items[2] = ctx.mk_eq_atom(mk_strlen(t2), mk_int(x_sub_m));
+ } else {
+ ax_l_items[1] = ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len));
+ ax_l_items[2] = ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len));
+ rational n_sub_y = n_len - y_len;
+ ax_r_items[2] = ctx.mk_eq_atom(mk_strlen(t2), mk_int(n_sub_y));
+ }
+
+ expr_ref ax_l(mgr.mk_and(3, ax_l_items), mgr);
+ expr_ref ax_r(mgr.mk_and(3, ax_r_items), mgr);
+
+ // Cut Info
+ add_cut_info_merge(t2, sLevel, x);
+ add_cut_info_merge(t2, sLevel, n);
+
+ assert_implication(ax_l, ax_r);
+ } else {
+ loopDetected = true;
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ // TODO printCutVar(m, y);
+ }
} else if (splitType == -1) {
// Here we don't really have a choice. We have no length information at all...
expr ** or_item = alloc_svect(expr*, 3);
@@ -1590,7 +1633,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr_ref x_plus_t1(m_autil.mk_add(mk_strlen(x), mk_strlen(t1)), mgr);
and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(m), x_plus_t1));
- // TODO these are crashing the solvers because the integer theory
+ // These were crashing the solver because the integer theory
// expects a constant on the right-hand side.
// The things we want to assert here are len(m) > len(x) and len(y) > len(n).
// We rewrite A > B as A-B > 0 and then as not(A-B <= 0),
From 6f5ee2c3ce50ebe3dfe18a4c391aa5765142a4a5 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 9 Jun 2016 16:04:13 -0400
Subject: [PATCH 101/401] string concat-eq type 2 integer integration
---
src/smt/theory_str.cpp | 115 ++++++++++++++++++++++++++++++++++-------
1 file changed, 96 insertions(+), 19 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 6de5a10b7..0418fefd7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1776,21 +1776,14 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
y = v1_arg1;
}
- const char * strValue_tmp = 0;
- m_strutil.is_string(strAst, &strValue_tmp);
- std::string strValue(strValue_tmp);
- // TODO integer theory interaction
- /*
- int x_len = getLenValue(t, x);
- int y_len = getLenValue(t, y);
- int m_len = getLenValue(t, m);
- int str_len = getLenValue(t, strAst);
- */
+ std::string strValue = m_strutil.get_string_constant_value(strAst);
- int x_len = -1;
- int y_len = -1;
- int m_len = -1;
- int str_len = -1;
+ rational x_len, y_len, m_len, str_len;
+ bool x_len_exists = get_len_value(x, x_len);
+ bool y_len_exists = get_len_value(y, y_len);
+ bool m_len_exists = get_len_value(m, m_len);
+ bool str_len_exists = true;
+ str_len = rational((unsigned)(strValue.length()));
// setup
@@ -1816,7 +1809,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
}
int splitType = -1;
- if (x_len != -1 && m_len != -1) {
+ if (x_len_exists && m_len_exists) {
if (x_len < m_len)
splitType = 0;
else if (x_len == m_len)
@@ -1824,7 +1817,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
else
splitType = 2;
}
- if (splitType == -1 && y_len != -1 && str_len != -1) {
+ if (splitType == -1 && y_len_exists && str_len_exists) {
if (y_len > str_len)
splitType = 0;
else if (y_len == str_len)
@@ -1838,11 +1831,95 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
// Provide fewer split options when length information is available.
if (splitType == 0) {
- NOT_IMPLEMENTED_YET(); // TODO
+ // M cuts Y
+ // | x | y |
+ // | m | str |
+ expr_ref temp1_strAst(mk_concat(temp1, strAst), mgr);
+ if (can_two_nodes_eq(y, temp1_strAst)) {
+ if (!avoidLoopCut || !(has_self_cut(m, y))) {
+ // break down option 2-1
+ expr ** l_items = alloc_svect(expr*, 3);
+ l_items[0] = ctx.mk_eq_atom(concatAst1, concatAst2);
+
+ expr ** r_items = alloc_svect(expr*, 3);
+ expr_ref x_temp1(mk_concat(x, temp1), mgr);
+ r_items[0] = ctx.mk_eq_atom(m, x_temp1);
+ r_items[1] = ctx.mk_eq_atom(y, temp1_strAst);
+
+ if (x_len_exists && m_len_exists) {
+ l_items[1] = ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len));
+ l_items[2] = ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len));
+ rational m_sub_x = (m_len - x_len);
+ r_items[2] = ctx.mk_eq_atom(mk_strlen(temp1), mk_int(m_sub_x));
+ } else {
+ l_items[1] = ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len));
+ l_items[2] = ctx.mk_eq_atom(mk_strlen(strAst), mk_int(str_len));
+ rational y_sub_str = (y_len - str_len);
+ r_items[2] = ctx.mk_eq_atom(mk_strlen(temp1), mk_int(y_sub_str));
+ }
+
+ expr_ref ax_l(mgr.mk_and(3, l_items), mgr);
+ expr_ref ax_r(mgr.mk_and(3, r_items), mgr);
+
+ add_cut_info_merge(temp1, sLevel, y);
+ add_cut_info_merge(temp1, sLevel, m);
+
+ assert_implication(ax_l, ax_r);
+ } else {
+ loopDetected = true;
+ TRACE("t_str", tout << "AVOID LOOP: SKIP" << std::endl;);
+ // TODO printCutVar(m, y);
+ }
+ }
} else if (splitType == 1) {
- NOT_IMPLEMENTED_YET(); // TODO
+ // | x | y |
+ // | m | str |
+ expr_ref ax_l1(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref ax_l2(mgr.mk_or(
+ ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)),
+ ctx.mk_eq_atom(mk_strlen(y), mk_strlen(strAst))), mgr);
+ expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
+ expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x, m), ctx.mk_eq_atom(y, strAst)), mgr);
+ assert_implication(ax_l, ax_r);
} else if (splitType == 2) {
- NOT_IMPLEMENTED_YET(); // TODO
+ // m cut y,
+ // | x | y |
+ // | m | str |
+ rational lenDelta;
+ expr ** l_items = alloc_svect(expr*, 3);
+ int l_count = 0;
+ l_items[0] = ctx.mk_eq_atom(concatAst1, concatAst2);
+ if (x_len_exists && m_len_exists) {
+ l_items[1] = ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len));
+ l_items[2] = ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len));
+ l_count = 3;
+ lenDelta = x_len - m_len;
+ } else {
+ l_items[1] = ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len));
+ l_count = 2;
+ lenDelta = str_len - y_len;
+ }
+ std::string part1Str = strValue.substr(0, lenDelta.get_unsigned());
+ std::string part2Str = strValue.substr(lenDelta.get_unsigned(), strValue.length() - lenDelta.get_unsigned());
+
+ expr_ref prefixStr(m_strutil.mk_string(part1Str), mgr);
+ expr_ref x_concat(mk_concat(m, prefixStr), mgr);
+ expr_ref cropStr(m_strutil.mk_string(part2Str), mgr);
+
+ if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
+ expr ** r_items = alloc_svect(expr*, 2);
+ r_items[0] = ctx.mk_eq_atom(x, x_concat);
+ r_items[1] = ctx.mk_eq_atom(y, cropStr);
+ expr_ref ax_l(mgr.mk_and(l_count, l_items), mgr);
+ expr_ref ax_r(mgr.mk_and(2, r_items), mgr);
+
+ assert_implication(ax_l, ax_r);
+ } else {
+ // negate! It's impossible to split str with these lengths
+ TRACE("t_str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
+ expr_ref ax_l(mgr.mk_and(l_count, l_items), mgr);
+ assert_axiom(mgr.mk_not(ax_l));
+ }
} else {
// Split type -1: no idea about the length...
int optionTotal = 2 + strValue.length();
From 91d82956b29a91c744390981a1acfd4f5653eadb Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 9 Jun 2016 16:25:19 -0400
Subject: [PATCH 102/401] string concat-eq type 3 integer integration
---
src/smt/theory_str.cpp | 107 ++++++++++++++++++++++++++++++++++-------
1 file changed, 89 insertions(+), 18 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 0418fefd7..ba9b503be 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2042,20 +2042,14 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
y = v1_arg1;
}
- const char * strValue_tmp = 0;
- m_strutil.is_string(strAst, &strValue_tmp);
- std::string strValue(strValue_tmp);
+ std::string strValue = m_strutil.get_string_constant_value(strAst);
+
// TODO integer theory interaction
- /*
- int x_len = getLenValue(t, x);
- int y_len = getLenValue(t, y);
- int str_len = getLenValue(t, strAst);
- int n_len = getLenValue(t, n);
- */
- int x_len = -1;
- int y_len = -1;
- int str_len = -1;
- int n_len = -1;
+ rational x_len, y_len, str_len, n_len;
+ bool x_len_exists = get_len_value(x, x_len);
+ bool y_len_exists = get_len_value(y, y_len);
+ str_len = rational((unsigned)(strValue.length()));
+ bool n_len_exists = get_len_value(n, n_len);
expr_ref xorFlag(mgr);
expr_ref temp1(mgr);
@@ -2080,7 +2074,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
int splitType = -1;
- if (x_len != -1) {
+ if (x_len_exists) {
if (x_len < str_len)
splitType = 0;
else if (x_len == str_len)
@@ -2088,7 +2082,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
else
splitType = 2;
}
- if (splitType == -1 && y_len != -1 && n_len != -1) {
+ if (splitType == -1 && y_len_exists && n_len_exists) {
if (y_len > n_len)
splitType = 0;
else if (y_len == n_len)
@@ -2101,13 +2095,90 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
// Provide fewer split options when length information is available.
if (splitType == 0) {
- NOT_IMPLEMENTED_YET(); // TODO
+ // | x | y |
+ // | str | n |
+ expr_ref_vector litems(mgr);
+ litems.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
+ rational prefixLen;
+ if (!x_len_exists) {
+ prefixLen = str_len - (y_len - n_len);
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
+ } else {
+ prefixLen = x_len;
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ }
+ std::string prefixStr = strValue.substr(0, prefixLen.get_unsigned());
+ rational str_sub_prefix = str_len - prefixLen;
+ std::string suffixStr = strValue.substr(prefixLen.get_unsigned(), str_sub_prefix.get_unsigned());
+ expr_ref prefixAst(m_strutil.mk_string(prefixStr), mgr);
+ expr_ref suffixAst(m_strutil.mk_string(suffixStr), mgr);
+ expr_ref ax_l(mgr.mk_and(litems.size(), litems.c_ptr()), mgr);
+
+ expr_ref suf_n_concat(mk_concat(suffixAst, n), mgr);
+ if (can_two_nodes_eq(x, prefixAst) && can_two_nodes_eq(y, suf_n_concat)) {
+ expr ** r_items = alloc_svect(expr*, 2);
+ r_items[0] = ctx.mk_eq_atom(x, prefixAst);
+ r_items[1] = ctx.mk_eq_atom(y, suf_n_concat);
+ assert_implication(ax_l, mgr.mk_and(2, r_items));
+ } else {
+ // negate! It's impossible to split str with these lengths
+ TRACE("t_str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
+ assert_axiom(mgr.mk_not(ax_l));
+ }
}
else if (splitType == 1) {
- NOT_IMPLEMENTED_YET(); // TODO
+ expr_ref ax_l1(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref ax_l2(mgr.mk_or(
+ ctx.mk_eq_atom(mk_strlen(x), mk_strlen(strAst)),
+ ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n))), mgr);
+ expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
+ expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x, strAst), ctx.mk_eq_atom(y, n)), mgr);
+ assert_implication(ax_l, ax_r);
}
else if (splitType == 2) {
- NOT_IMPLEMENTED_YET(); // TODO
+ // | x | y |
+ // | str | n |
+ expr_ref_vector litems(mgr);
+ litems.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
+ rational tmpLen;
+ if (!x_len_exists) {
+ tmpLen = n_len - y_len;
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
+ } else {
+ tmpLen = x_len - str_len;
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ }
+ expr_ref ax_l(mgr.mk_and(litems.size(), litems.c_ptr()), mgr);
+
+ expr_ref str_temp1(mk_concat(strAst, temp1), mgr);
+ expr_ref temp1_y(mk_concat(temp1, y), mgr);
+
+ if (can_two_nodes_eq(x, str_temp1)) {
+ if (!avoidLoopCut || !(has_self_cut(x, n))) {
+ expr ** r_items = alloc_svect(expr*, 3);
+ r_items[0] = ctx.mk_eq_atom(x, str_temp1);
+ r_items[1] = ctx.mk_eq_atom(n, temp1_y);
+ r_items[2] = ctx.mk_eq_atom(mk_strlen(temp1), mk_int(tmpLen));
+ expr_ref ax_r(mgr.mk_and(3, r_items), mgr);
+
+ //Cut Info
+ add_cut_info_merge(temp1, sLevel, x);
+ add_cut_info_merge(temp1, sLevel, n);
+
+ assert_implication(ax_l, ax_r);
+ } else {
+ loopDetected = true;
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ // TODO printCutVar(x, n);
+ }
+ }
+ // else {
+ // // negate! It's impossible to split str with these lengths
+ // __debugPrint(logFile, "[Conflict] Negate! It's impossible to split str with these lengths @ %d.\n", __LINE__);
+ // addAxiom(t, Z3_mk_not(ctx, ax_l), __LINE__);
+ // }
}
else {
// Split type -1. We know nothing about the length...
From 1520760a04de41827bb177d2d67427033c9d2286 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 9 Jun 2016 20:31:21 -0400
Subject: [PATCH 103/401] string-integer integration in free var gen
---
src/smt/theory_str.cpp | 9 ++++-----
1 file changed, 4 insertions(+), 5 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ba9b503be..f8366ed07 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -5302,13 +5302,12 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
}
if (standAlone) {
- // TODO
- // int lenValue = getLenValue(freeVar);
- int lenValue = -1;
- if (lenValue != -1) {
+ rational len_value;
+ bool len_value_exists = get_len_value(freeVar, len_value);
+ if (len_value_exists) {
leafVarSet.insert(freeVar);
} else {
- aloneVars[lenValue].insert(freeVar);
+ aloneVars[-1].insert(freeVar);
}
} else {
leafVarSet.insert(freeVar);
From fd968783a599961a67ccc3afb2b90c4a776f9f38 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 9 Jun 2016 20:35:26 -0400
Subject: [PATCH 104/401] fix model generation for theory_str
---
src/smt/theory_str.h | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 6616e9ffa..99899b365 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -44,9 +44,7 @@ namespace smt {
return true;
}
virtual expr * get_fresh_value(sort * s) {
- // TODO this may be causing crashes in model gen? investigate
- //return m_util.mk_fresh_string();
- NOT_IMPLEMENTED_YET();
+ return m_util.mk_fresh_string();
}
virtual void register_value(expr * n) { /* Ignore */ }
};
From 08328c5614f26712946d57bd0d5594831608c292 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 12 Jun 2016 17:16:14 -0400
Subject: [PATCH 105/401] add option in theory_str to assert string constant
lengths more eagerly now passes z3str/concat-025
---
src/smt/theory_str.cpp | 11 ++++++++++-
src/smt/theory_str.h | 10 ++++++++++
2 files changed, 20 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f8366ed07..02db2132a 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -30,6 +30,7 @@ theory_str::theory_str(ast_manager & m):
/* Options */
opt_AggressiveLengthTesting(true),
opt_AggressiveValueTesting(true),
+ opt_EagerStringConstantLengthAssertions(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -191,7 +192,9 @@ bool theory_str::internalize_term(app * term) {
//}
*/
- // from theory_seq::internalize_term()
+ // TODO do we still need to do instantiate_concat_axiom()?
+
+ // partially from theory_seq::internalize_term()
if (ctx.e_internalized(term)) {
enode* e = ctx.get_enode(term);
mk_var(e);
@@ -217,6 +220,12 @@ bool theory_str::internalize_term(app * term) {
else {
e = ctx.mk_enode(term, false, m.is_bool(term), true);
}
+
+ if (opt_EagerStringConstantLengthAssertions && m_strutil.is_string(term)) {
+ TRACE("t_str", tout << "eagerly asserting length of string term " << mk_pp(term, m) << std::endl;);
+ m_basicstr_axiom_todo.insert(e);
+ }
+
theory_var v = mk_var(e);
TRACE("t_str_detail", tout << "term " << mk_ismt2_pp(term, get_manager()) << " = v#" << v << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 99899b365..2b8077a13 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -74,6 +74,15 @@ namespace smt {
*/
bool opt_AggressiveValueTesting;
+ /*
+ * Setting EagerStringConstantLengthAssertions to true allows some methods,
+ * in particular internalize_term(), to add
+ * length assertions about relevant string constants.
+ * Note that currently this should always be set to 'true', or else *no* length assertions
+ * will be made about string constants.
+ */
+ bool opt_EagerStringConstantLengthAssertions;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -87,6 +96,7 @@ namespace smt {
ptr_vector<enode> m_basicstr_axiom_todo;
svector<std::pair<enode*,enode*> > m_str_eq_todo;
ptr_vector<enode> m_concat_axiom_todo;
+ ptr_vector<enode> m_string_constant_length_todo;
int tmpStringVarCount;
int tmpXorVarCount;
From 18cd47dcd02c92a5805b1ccb04b4879d06273aa1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 12 Jun 2016 20:14:57 -0400
Subject: [PATCH 106/401] add flag for bailing out during a final check
infinite loop in theory_str also adds more debugging to free variable gen
---
src/smt/theory_str.cpp | 28 +++++++++++++++++++++++++++-
src/smt/theory_str.h | 8 ++++++++
2 files changed, 35 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 02db2132a..aaeb9ccce 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -31,11 +31,13 @@ theory_str::theory_str(ast_manager & m):
opt_AggressiveLengthTesting(true),
opt_AggressiveValueTesting(true),
opt_EagerStringConstantLengthAssertions(true),
+ opt_VerifyFinalCheckProgress(true),
/* Internal setup */
search_started(false),
m_autil(m),
m_strutil(m),
sLevel(0),
+ finalCheckProgressIndicator(false),
m_trail(m),
tmpStringVarCount(0),
tmpXorVarCount(0),
@@ -125,6 +127,9 @@ void theory_str::initialize_charset() {
}
void theory_str::assert_axiom(expr * e) {
+ if (opt_VerifyFinalCheckProgress) {
+ finalCheckProgressIndicator = true;
+ }
if (get_manager().is_true(e)) return;
TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
context & ctx = get_context();
@@ -4501,6 +4506,10 @@ final_check_status theory_str::final_check_eh() {
context & ctx = get_context();
ast_manager & m = get_manager();
+ if (opt_VerifyFinalCheckProgress) {
+ finalCheckProgressIndicator = false;
+ }
+
TRACE("t_str", tout << "final check" << std::endl;);
TRACE("t_str_detail", dump_assignments(););
@@ -4655,7 +4664,19 @@ final_check_status theory_str::final_check_eh() {
constValue = NULL;
- // TODO this would be a great place to print debugging information
+ {
+ TRACE("t_str_detail", tout << "free var map (# " << freeVar_map.size() << "):" << std::endl;
+ for (std::map<expr*, int>::iterator freeVarItor1 = freeVar_map.begin(); freeVarItor1 != freeVar_map.end(); freeVarItor1++) {
+ expr * freeVar = freeVarItor1->first;
+ rational lenValue;
+ bool lenValue_exists = get_len_value(freeVar, lenValue);
+ // TODO get_bound_strlen()
+ tout << mk_pp(freeVar, m) << " [depCnt = " << freeVarItor1->second << ", length = "
+ << (lenValue_exists ? lenValue.to_string() : "?")
+ << "]" << std::endl;
+ }
+ );
+ }
// TODO process_concat_eq_unroll()
/*
@@ -4712,6 +4733,11 @@ final_check_status theory_str::final_check_eh() {
}
*/
+ if (opt_VerifyFinalCheckProgress && !finalCheckProgressIndicator) {
+ TRACE("t_str", tout << "BUG: no progress in final check, giving up!!" << std::endl;);
+ m.raise_exception("no progress in theory_str final check");
+ }
+
return FC_CONTINUE; // since by this point we've added axioms
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 2b8077a13..562f49004 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -83,11 +83,19 @@ namespace smt {
*/
bool opt_EagerStringConstantLengthAssertions;
+ /*
+ * If VerifyFinalCheckProgress is set to true, continuing after final check is invoked
+ * without asserting any new axioms is considered a bug and will throw an exception.
+ */
+ bool opt_VerifyFinalCheckProgress;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
int sLevel;
+ bool finalCheckProgressIndicator;
+
// TODO make sure that all generated expressions are saved into the trail
expr_ref_vector m_trail; // trail for generated terms
From 7d09dbb8ec8685a0cb9b75bdf87733839fc179e1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 12 Jun 2016 20:46:52 -0400
Subject: [PATCH 107/401] basic infrastructure for string rewriting
---
src/ast/rewriter/rewriter.txt | 2 +
src/ast/rewriter/str_rewriter.cpp | 66 +++++++++++++++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 46 +++++++++++++++++++++
src/ast/rewriter/th_rewriter.cpp | 8 ++++
4 files changed, 122 insertions(+)
create mode 100644 src/ast/rewriter/str_rewriter.cpp
create mode 100644 src/ast/rewriter/str_rewriter.h
diff --git a/src/ast/rewriter/rewriter.txt b/src/ast/rewriter/rewriter.txt
index cdfba9f0f..a7a9e5eff 100644
--- a/src/ast/rewriter/rewriter.txt
+++ b/src/ast/rewriter/rewriter.txt
@@ -7,6 +7,8 @@ The following classes implement theory specific rewriting rules:
- array_rewriter
- datatype_rewriter
- fpa_rewriter
+ - seq_rewriter
+ - str_rewriter
Each of them provide the method
br_status mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
new file mode 100644
index 000000000..35a255871
--- /dev/null
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -0,0 +1,66 @@
+/*++
+Copyright (c) 2016 Microsoft Corporation
+
+Module Name:
+
+ str_rewriter.cpp
+
+Abstract:
+
+ AST rewriting rules for string terms.
+
+Author:
+
+ Murphy Berzish
+
+Notes:
+
+--*/
+
+#include"str_rewriter.h"
+#include"arith_decl_plugin.h"
+#include"ast_pp.h"
+#include"ast_util.h"
+#include"well_sorted.h"
+
+br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
+ SASSERT(f->get_family_id() == get_fid());
+
+ TRACE("t_str_rw", tout << "rewrite app: " << f->get_name() << std::endl;);
+
+ switch(f->get_decl_kind()) {
+ default:
+ return BR_FAILED;
+ }
+}
+
+br_status str_rewriter::mk_eq_core(expr * l, expr * r, expr_ref & result) {
+ // from seq_rewriter
+ expr_ref_vector lhs(m()), rhs(m()), res(m());
+ bool changed = false;
+ if (!reduce_eq(l, r, lhs, rhs, changed)) {
+ result = m().mk_false();
+ return BR_DONE;
+ }
+ if (!changed) {
+ return BR_FAILED;
+ }
+ for (unsigned i = 0; i < lhs.size(); ++i) {
+ res.push_back(m().mk_eq(lhs[i].get(), rhs[i].get()));
+ }
+ result = mk_and(res);
+ return BR_REWRITE3;
+}
+
+bool str_rewriter::reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change) {
+ // TODO inspect seq_rewriter::reduce_eq()
+ change = false;
+ return true;
+}
+
+bool str_rewriter::reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change) {
+ // TODO inspect seq_rewriter::reduce_eq()
+ change = false;
+ return true;
+}
+
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
new file mode 100644
index 000000000..fde36e92e
--- /dev/null
+++ b/src/ast/rewriter/str_rewriter.h
@@ -0,0 +1,46 @@
+/*++
+Copyright (c) 2016 Microsoft Corporation
+
+Module Name:
+
+ str_rewriter.h
+
+Abstract:
+
+ AST rewriting rules for string terms.
+
+Author:
+
+ Murphy Berzish
+
+Notes:
+
+--*/
+
+#include"str_decl_plugin.h"
+#include"arith_decl_plugin.h"
+#include"rewriter_types.h"
+#include"params.h"
+
+class str_rewriter {
+ str_util m_strutil;
+ arith_util m_autil;
+
+public:
+ str_rewriter(ast_manager & m, params_ref const & p = params_ref()) :
+ m_strutil(m), m_autil(m) {
+ }
+
+ ast_manager & m() const { return m_strutil.get_manager(); }
+ family_id get_fid() const { return m_strutil.get_family_id(); }
+
+ void updt_params(params_ref const & p) {}
+ static void get_param_descrs(param_descrs & r) {}
+
+ br_status mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result);
+ br_status mk_eq_core(expr * lhs, expr * rhs, expr_ref & result);
+
+ bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
+ bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
+
+};
diff --git a/src/ast/rewriter/th_rewriter.cpp b/src/ast/rewriter/th_rewriter.cpp
index 6f6daf8df..a56ca91d8 100644
--- a/src/ast/rewriter/th_rewriter.cpp
+++ b/src/ast/rewriter/th_rewriter.cpp
@@ -27,6 +27,7 @@ Notes:
#include"dl_rewriter.h"
#include"pb_rewriter.h"
#include"seq_rewriter.h"
+#include"str_rewriter.h"
#include"rewriter_def.h"
#include"expr_substitution.h"
#include"ast_smt2_pp.h"
@@ -45,6 +46,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
dl_rewriter m_dl_rw;
pb_rewriter m_pb_rw;
seq_rewriter m_seq_rw;
+ str_rewriter m_str_rw;
arith_util m_a_util;
bv_util m_bv_util;
unsigned long long m_max_memory; // in bytes
@@ -79,6 +81,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
m_ar_rw.updt_params(p);
m_f_rw.updt_params(p);
m_seq_rw.updt_params(p);
+ m_str_rw.updt_params(p);
updt_local_params(p);
}
@@ -179,6 +182,8 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
st = m_ar_rw.mk_eq_core(args[0], args[1], result);
else if (s_fid == m_seq_rw.get_fid())
st = m_seq_rw.mk_eq_core(args[0], args[1], result);
+ else if (s_fid == m_str_rw.get_fid())
+ st = m_str_rw.mk_eq_core(args[0], args[1], result);
if (st != BR_FAILED)
return st;
@@ -207,6 +212,8 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
return m_pb_rw.mk_app_core(f, num, args, result);
if (fid == m_seq_rw.get_fid())
return m_seq_rw.mk_app_core(f, num, args, result);
+ if (fid == m_str_rw.get_fid())
+ return m_str_rw.mk_app_core(f, num, args, result);
return BR_FAILED;
}
@@ -665,6 +672,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
m_dl_rw(m),
m_pb_rw(m),
m_seq_rw(m),
+ m_str_rw(m),
m_a_util(m),
m_bv_util(m),
m_used_dependencies(m),
From 389845180c0f03cc0f808ac7cd1cab3bac691e1d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 13 Jun 2016 16:34:24 -0400
Subject: [PATCH 108/401] add CharAt to theory_str and basic rewrite rule for
constant CharAt exprs
---
src/ast/rewriter/str_rewriter.cpp | 44 +++++++++++++++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 2 ++
src/ast/str_decl_plugin.cpp | 10 ++++++-
src/ast/str_decl_plugin.h | 6 ++++-
4 files changed, 60 insertions(+), 2 deletions(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 35a255871..3967453d4 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -23,12 +23,56 @@ Notes:
#include"ast_util.h"
#include"well_sorted.h"
+br_status str_rewriter::mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (CharAt " << mk_pp(arg0, m()) << " " << mk_pp(arg1, m()) << ")" << std::endl;);
+ // if arg0 is a string constant and arg1 is an integer constant,
+ // we can rewrite this by evaluating the expression
+ rational arg1Int;
+ if (m_strutil.is_string(arg0) && m_autil.is_numeral(arg1, arg1Int)) {
+ TRACE("t_str_rw", tout << "evaluating constant CharAt expression" << std::endl;);
+ std::string arg0Str = m_strutil.get_string_constant_value(arg0);
+ std::string resultStr;
+ if (arg1Int >= rational(0) && arg1Int <= rational((unsigned)arg0Str.length())) {
+ resultStr = arg0Str.at(arg1Int.get_unsigned());
+ TRACE("t_str_rw", tout << "result is '" << resultStr << "'" << std::endl;);
+ } else {
+ resultStr = "";
+ TRACE("t_str_rw", tout << "bogus length argument, result is empty string" << std::endl;);
+ }
+ result = m_strutil.mk_string(resultStr);
+ return BR_DONE;
+ } else {
+ // TODO NEXT
+ NOT_IMPLEMENTED_YET();
+ /*
+ Z3_ast ts0 = my_mk_internal_string_var(t);
+ Z3_ast ts1 = my_mk_internal_string_var(t);
+ Z3_ast ts2 = my_mk_internal_string_var(t);
+
+ Z3_ast cond = mk_2_and(t, Z3_mk_ge(ctx, args[1], mk_int(ctx, 0)), Z3_mk_lt(ctx, args[1], mk_length(t, args[0])));
+
+ Z3_ast and_item[3];
+ and_item[0] = Z3_mk_eq(ctx, args[0], mk_concat(t, ts0, mk_concat(t, ts1, ts2)));
+ and_item[1] = Z3_mk_eq(ctx, args[1], mk_length(t, ts0));
+ and_item[2] = Z3_mk_eq(ctx, mk_length(t, ts1), mk_int(ctx, 1));
+ Z3_ast thenBranch = Z3_mk_and(ctx, 3, and_item);
+ Z3_ast elseBranch = Z3_mk_eq(ctx, ts1, my_mk_str_value(t, ""));
+ breakdownAssert = Z3_mk_ite(ctx, cond, thenBranch, elseBranch);
+ return ts1;
+ */
+ }
+}
+
br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
SASSERT(f->get_family_id() == get_fid());
TRACE("t_str_rw", tout << "rewrite app: " << f->get_name() << std::endl;);
+ // TODO more rewrites for really easy cases, e.g. (Concat "abc" "def")...
switch(f->get_decl_kind()) {
+ case OP_STR_CHARAT:
+ SASSERT(num_args == 2);
+ return mk_str_CharAt(args[0], args[1], result);
default:
return BR_FAILED;
}
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index fde36e92e..01ccde242 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -40,6 +40,8 @@ public:
br_status mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result);
br_status mk_eq_core(expr * lhs, expr * rhs, expr_ref & result);
+ br_status mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & result);
+
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index cd9cae5a5..03fde5aeb 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -26,6 +26,7 @@ str_decl_plugin::str_decl_plugin():
m_str_decl(0),
m_concat_decl(0),
m_length_decl(0),
+ m_charat_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -39,6 +40,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_str_decl);
DEC_REF(m_concat_decl);
DEC_REF(m_length_decl);
+ DEC_REF(m_charat_decl);
DEC_REF(m_int_sort);
}
@@ -64,7 +66,11 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
MK_OP(m_concat_decl, "Concat", OP_STRCAT, s);
- m_length_decl = m->mk_func_decl(symbol("Length"), s, i, func_decl_info(id, OP_STRLEN)); m_manager->inc_ref(m_length_decl);
+ m_length_decl = m->mk_func_decl(symbol("Length"), s, i, func_decl_info(id, OP_STRLEN));
+ m_manager->inc_ref(m_length_decl);
+
+ m_charat_decl = m->mk_func_decl(symbol("CharAt"), s, i, s, func_decl_info(id, OP_STR_CHARAT));
+ m_manager->inc_ref(m_charat_decl);
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -82,6 +88,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
switch(k) {
case OP_STRCAT: return m_concat_decl;
case OP_STRLEN: return m_length_decl;
+ case OP_STR_CHARAT: return m_charat_decl;
default: return 0;
}
}
@@ -138,6 +145,7 @@ app * str_decl_plugin::mk_fresh_string() {
void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol const & logic) {
op_names.push_back(builtin_name("Concat", OP_STRCAT));
op_names.push_back(builtin_name("Length", OP_STRLEN));
+ op_names.push_back(builtin_name("CharAt", OP_STR_CHARAT));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 4f46fa5ac..049ef08ba 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -27,9 +27,12 @@ enum str_sort_kind {
enum str_op_kind {
OP_STR, /* string constants */
- //
+ // basic string operators
OP_STRCAT,
OP_STRLEN,
+ // higher-level string functions -- these are reduced to basic operations
+ OP_STR_CHARAT,
+ // end
LAST_STR_OP
};
@@ -40,6 +43,7 @@ protected:
func_decl * m_concat_decl;
func_decl * m_length_decl;
+ func_decl * m_charat_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
From be5cc02a4594c33b76fc1ca01586486071e0f272 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 13 Jun 2016 21:57:08 -0400
Subject: [PATCH 109/401] working axiomatization for CharAt
---
src/ast/rewriter/str_rewriter.cpp | 4 +--
src/smt/theory_str.cpp | 49 ++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 7 +++++
3 files changed, 57 insertions(+), 3 deletions(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 3967453d4..76c0d25ae 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -42,8 +42,8 @@ br_status str_rewriter::mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & resul
result = m_strutil.mk_string(resultStr);
return BR_DONE;
} else {
- // TODO NEXT
- NOT_IMPLEMENTED_YET();
+ // TODO if we ever figure out how to assert axioms in here, add this code
+ return BR_FAILED;
/*
Z3_ast ts0 = my_mk_internal_string_var(t);
Z3_ast ts1 = my_mk_internal_string_var(t);
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index aaeb9ccce..fe8f12e81 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -567,7 +567,9 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
}
bool theory_str::can_propagate() {
- return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty();
+ return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty()
+ || !m_axiom_CharAt_todo.empty()
+ ;
}
void theory_str::propagate() {
@@ -590,6 +592,11 @@ void theory_str::propagate() {
instantiate_concat_axiom(m_concat_axiom_todo[i]);
}
m_concat_axiom_todo.reset();
+
+ for (unsigned i = 0; i < m_axiom_CharAt_todo.size(); ++i) {
+ instantiate_axiom_CharAt(m_axiom_CharAt_todo[i]);
+ }
+ m_axiom_CharAt_todo.reset();
}
}
@@ -738,6 +745,44 @@ void theory_str::instantiate_str_eq_length_axiom(enode * lhs, enode * rhs) {
assert_implication(premise, conclusion);
}
+void theory_str::instantiate_axiom_CharAt(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+
+ TRACE("t_str_detail", tout << "instantiate CharAt axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref ts0(mk_str_var("ts0"), m);
+ expr_ref ts1(mk_str_var("ts1"), m);
+ expr_ref ts2(mk_str_var("ts2"), m);
+
+ expr_ref cond(m.mk_and(
+ m_autil.mk_ge(expr->get_arg(1), mk_int(0)),
+ // REWRITE for arithmetic theory:
+ // m_autil.mk_lt(expr->get_arg(1), mk_strlen(expr->get_arg(0)))
+ m.mk_not(m_autil.mk_ge(m_autil.mk_add(expr->get_arg(1), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))), mk_int(0)))
+ ), m);
+
+ expr_ref_vector and_item(m);
+ and_item.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, mk_concat(ts1, ts2))));
+ and_item.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_strlen(ts0)));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(ts1), mk_int(1)));
+
+ expr_ref thenBranch(m.mk_and(and_item.size(), and_item.c_ptr()), m);
+ expr_ref elseBranch(ctx.mk_eq_atom(ts1, m_strutil.mk_string("")), m);
+
+ expr_ref axiom(m.mk_ite(cond, thenBranch, elseBranch), m);
+ expr_ref reductionVar(ctx.mk_eq_atom(expr, ts1), m);
+
+ SASSERT(axiom);
+ SASSERT(reductionVar);
+
+ expr_ref finalAxiom(m.mk_and(axiom, reductionVar), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
@@ -3469,6 +3514,8 @@ void theory_str::set_up_axioms(expr * ex) {
if (aVar->get_num_args() == 0 && !is_string(aVar)) {
input_var_in_len.insert(var);
}
+ } else if (is_CharAt(ap)) {
+ m_axiom_CharAt_todo.push_back(n);
} else if (ap->get_num_args() == 0 && !is_string(ap)) {
// if ex is a variable, add it to our list of variables
TRACE("t_str_detail", tout << "tracking variable " << mk_ismt2_pp(ap, get_manager()) << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 562f49004..c86328d30 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -106,6 +106,9 @@ namespace smt {
ptr_vector<enode> m_concat_axiom_todo;
ptr_vector<enode> m_string_constant_length_todo;
+ // enode lists for term-specific axioms
+ ptr_vector<enode> m_axiom_CharAt_todo;
+
int tmpStringVarCount;
int tmpXorVarCount;
int tmpLenTestVarCount;
@@ -167,10 +170,14 @@ namespace smt {
bool is_string(enode const * n) const { return is_string(n->get_owner()); }
bool is_strlen(app const * a) const { return a->is_app_of(get_id(), OP_STRLEN); }
bool is_strlen(enode const * n) const { return is_strlen(n->get_owner()); }
+ bool is_CharAt(app const * a) const { return a->is_app_of(get_id(), OP_STR_CHARAT); }
+ bool is_CharAt(enode const * n) const { return is_CharAt(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
void instantiate_str_eq_length_axiom(enode * lhs, enode * rhs);
+ void instantiate_axiom_CharAt(enode * e);
+
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From 7d8e54c50f2de8655c737a64853d86eaa7633a12 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 13 Jun 2016 22:27:46 -0400
Subject: [PATCH 110/401] decl and rewriter for string StartsWith
---
src/ast/rewriter/str_rewriter.cpp | 41 +++++++++++++++++++------------
src/ast/rewriter/str_rewriter.h | 1 +
src/ast/str_decl_plugin.cpp | 9 +++++++
src/ast/str_decl_plugin.h | 3 +++
4 files changed, 38 insertions(+), 16 deletions(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 76c0d25ae..4b7ff9057 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -42,24 +42,30 @@ br_status str_rewriter::mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & resul
result = m_strutil.mk_string(resultStr);
return BR_DONE;
} else {
- // TODO if we ever figure out how to assert axioms in here, add this code
+ // TODO if we ever figure out how to assert axioms in here, add the axiom code from Z3str2's strAstReduce.cpp
return BR_FAILED;
- /*
- Z3_ast ts0 = my_mk_internal_string_var(t);
- Z3_ast ts1 = my_mk_internal_string_var(t);
- Z3_ast ts2 = my_mk_internal_string_var(t);
+ }
+}
- Z3_ast cond = mk_2_and(t, Z3_mk_ge(ctx, args[1], mk_int(ctx, 0)), Z3_mk_lt(ctx, args[1], mk_length(t, args[0])));
-
- Z3_ast and_item[3];
- and_item[0] = Z3_mk_eq(ctx, args[0], mk_concat(t, ts0, mk_concat(t, ts1, ts2)));
- and_item[1] = Z3_mk_eq(ctx, args[1], mk_length(t, ts0));
- and_item[2] = Z3_mk_eq(ctx, mk_length(t, ts1), mk_int(ctx, 1));
- Z3_ast thenBranch = Z3_mk_and(ctx, 3, and_item);
- Z3_ast elseBranch = Z3_mk_eq(ctx, ts1, my_mk_str_value(t, ""));
- breakdownAssert = Z3_mk_ite(ctx, cond, thenBranch, elseBranch);
- return ts1;
- */
+br_status str_rewriter::mk_str_StartsWith(expr * haystack, expr * needle, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (StartsWith " << mk_pp(haystack, m()) << " " << mk_pp(needle, m()) << ")" << std::endl;);
+ if (m_strutil.is_string(haystack) && m_strutil.is_string(needle)) {
+ TRACE("t_str_rw", tout << "evaluating constant StartsWith predicate" << std::endl;);
+ std::string haystackStr = m_strutil.get_string_constant_value(haystack);
+ std::string needleStr = m_strutil.get_string_constant_value(needle);
+ if (haystackStr.length() < needleStr.length()) {
+ result = m().mk_false();
+ return BR_DONE;
+ } else {
+ if (haystackStr.substr(0, needleStr.length()) == needleStr) {
+ result = m().mk_true();
+ } else {
+ result = m().mk_false();
+ }
+ return BR_DONE;
+ }
+ } else {
+ return BR_FAILED;
}
}
@@ -73,6 +79,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_CHARAT:
SASSERT(num_args == 2);
return mk_str_CharAt(args[0], args[1], result);
+ case OP_STR_STARTSWITH:
+ SASSERT(num_args == 2);
+ return mk_str_StartsWith(args[0], args[1], result);
default:
return BR_FAILED;
}
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index 01ccde242..8f12a75db 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -41,6 +41,7 @@ public:
br_status mk_eq_core(expr * lhs, expr * rhs, expr_ref & result);
br_status mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & result);
+ br_status mk_str_StartsWith(expr * haystack, expr * needle, expr_ref & result);
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 03fde5aeb..c6328d592 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -27,6 +27,7 @@ str_decl_plugin::str_decl_plugin():
m_concat_decl(0),
m_length_decl(0),
m_charat_decl(0),
+ m_startswith_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -41,6 +42,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_concat_decl);
DEC_REF(m_length_decl);
DEC_REF(m_charat_decl);
+ DEC_REF(m_startswith_decl);
DEC_REF(m_int_sort);
}
@@ -60,6 +62,8 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_manager->inc_ref(m_int_sort);
sort * i = m_int_sort;
+ sort* boolT = m_manager->mk_bool_sort();
+
#define MK_OP(FIELD, NAME, KIND, SORT) \
FIELD = m->mk_func_decl(symbol(NAME), SORT, SORT, SORT, func_decl_info(id, KIND)); \
m->inc_ref(FIELD)
@@ -71,6 +75,9 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_charat_decl = m->mk_func_decl(symbol("CharAt"), s, i, s, func_decl_info(id, OP_STR_CHARAT));
m_manager->inc_ref(m_charat_decl);
+
+ m_startswith_decl = m->mk_func_decl(symbol("StartsWith"), s, s, boolT, func_decl_info(id, OP_STR_STARTSWITH));
+ m_manager->inc_ref(m_startswith_decl);
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -89,6 +96,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STRCAT: return m_concat_decl;
case OP_STRLEN: return m_length_decl;
case OP_STR_CHARAT: return m_charat_decl;
+ case OP_STR_STARTSWITH: return m_startswith_decl;
default: return 0;
}
}
@@ -146,6 +154,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("Concat", OP_STRCAT));
op_names.push_back(builtin_name("Length", OP_STRLEN));
op_names.push_back(builtin_name("CharAt", OP_STR_CHARAT));
+ op_names.push_back(builtin_name("StartsWith", OP_STR_STARTSWITH));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 049ef08ba..d7bfcf172 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -32,6 +32,7 @@ enum str_op_kind {
OP_STRLEN,
// higher-level string functions -- these are reduced to basic operations
OP_STR_CHARAT,
+ OP_STR_STARTSWITH,
// end
LAST_STR_OP
};
@@ -43,7 +44,9 @@ protected:
func_decl * m_concat_decl;
func_decl * m_length_decl;
+
func_decl * m_charat_decl;
+ func_decl * m_startswith_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
From c5ffb012dd3d69c768133221fb391855a9773581 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Jun 2016 16:16:39 -0400
Subject: [PATCH 111/401] axioms for StartsWith; WIP as I need to fix an
infinite recursion bug
---
src/smt/theory_str.cpp | 53 +++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 4 ++++
2 files changed, 56 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index fe8f12e81..b87881ea6 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -568,7 +568,7 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
bool theory_str::can_propagate() {
return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty()
- || !m_axiom_CharAt_todo.empty()
+ || !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty()
;
}
@@ -597,6 +597,10 @@ void theory_str::propagate() {
instantiate_axiom_CharAt(m_axiom_CharAt_todo[i]);
}
m_axiom_CharAt_todo.reset();
+
+ for (unsigned i = 0; i < m_axiom_StartsWith_todo.size(); ++i) {
+ instantiate_axiom_StartsWith(m_axiom_StartsWith_todo[i]);
+ }
}
}
@@ -783,6 +787,39 @@ void theory_str::instantiate_axiom_CharAt(enode * e) {
assert_axiom(finalAxiom);
}
+void theory_str::instantiate_axiom_StartsWith(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ app * expr = e->get_owner();
+
+ TRACE("t_str_detail", tout << "instantiate StartsWith axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref ts0(mk_str_var("ts0"), m);
+ expr_ref ts1(mk_str_var("ts1"), m);
+
+ expr_ref_vector innerItems(m);
+ innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, ts1)));
+ innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts0), mk_strlen(expr->get_arg(1))));
+ innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts0, expr->get_arg(1)), expr, m.mk_not(expr)));
+ expr_ref then1(m.mk_and(innerItems.size(), innerItems.c_ptr()), m);
+ SASSERT(then1);
+
+ // the top-level condition is Length(arg0) >= Length(arg1).
+ // of course, the integer theory is not so accommodating
+ expr_ref topLevelCond(
+ m_autil.mk_ge(
+ m_autil.mk_add(
+ mk_strlen(expr->get_arg(0)), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(1)))),
+ mk_int(0))
+ , m);
+ SASSERT(topLevelCond);
+
+ expr_ref finalAxiom(m.mk_ite(topLevelCond, then1, m.mk_not(expr)), m);
+
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
@@ -3491,6 +3528,7 @@ void theory_str::set_up_axioms(expr * ex) {
sort * ex_sort = m.get_sort(ex);
sort * str_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ sort * bool_sort = m.mk_bool_sort();
if (ex_sort == str_sort) {
TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
@@ -3526,6 +3564,19 @@ void theory_str::set_up_axioms(expr * ex) {
TRACE("t_str_detail", tout << "variable " << mk_ismt2_pp(ap, get_manager()) << " is #" << v << std::endl;);
}
}
+ } else if (ex_sort == bool_sort) {
+ TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ ": expr is of sort Bool" << std::endl;);
+ // set up axioms for boolean terms
+ enode * n = ctx.get_enode(ex);
+ SASSERT(n);
+
+ if (is_app(ex)) {
+ app * ap = to_app(ex);
+ if (is_StartsWith(ap)) {
+ m_axiom_StartsWith_todo.push_back(n);
+ }
+ }
} else {
TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
": expr is of wrong sort, ignoring" << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index c86328d30..6c332dbd4 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -108,6 +108,7 @@ namespace smt {
// enode lists for term-specific axioms
ptr_vector<enode> m_axiom_CharAt_todo;
+ ptr_vector<enode> m_axiom_StartsWith_todo;
int tmpStringVarCount;
int tmpXorVarCount;
@@ -172,11 +173,14 @@ namespace smt {
bool is_strlen(enode const * n) const { return is_strlen(n->get_owner()); }
bool is_CharAt(app const * a) const { return a->is_app_of(get_id(), OP_STR_CHARAT); }
bool is_CharAt(enode const * n) const { return is_CharAt(n->get_owner()); }
+ bool is_StartsWith(app const * a) const { return a->is_app_of(get_id(), OP_STR_STARTSWITH); }
+ bool is_StartsWith(enode const * n) const { return is_StartsWith(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
void instantiate_str_eq_length_axiom(enode * lhs, enode * rhs);
void instantiate_axiom_CharAt(enode * e);
+ void instantiate_axiom_StartsWith(enode * e);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From 4f131ebba7f3dbd48abbe4c90d9e908aee3e728e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Jun 2016 16:42:46 -0400
Subject: [PATCH 112/401] prevent infinite loop of axiom generation. working
StartsWith
---
src/smt/theory_str.cpp | 12 ++++++++++++
src/smt/theory_str.h | 5 +++++
2 files changed, 17 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b87881ea6..7bdc9f197 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -601,6 +601,7 @@ void theory_str::propagate() {
for (unsigned i = 0; i < m_axiom_StartsWith_todo.size(); ++i) {
instantiate_axiom_StartsWith(m_axiom_StartsWith_todo[i]);
}
+ m_axiom_StartsWith_todo.reset();
}
}
@@ -754,6 +755,11 @@ void theory_str::instantiate_axiom_CharAt(enode * e) {
ast_manager & m = get_manager();
app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("t_str_detail", tout << "already set up CharAt axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
TRACE("t_str_detail", tout << "instantiate CharAt axiom for " << mk_pp(expr, m) << std::endl;);
@@ -790,7 +796,13 @@ void theory_str::instantiate_axiom_CharAt(enode * e) {
void theory_str::instantiate_axiom_StartsWith(enode * e) {
context & ctx = get_context();
ast_manager & m = get_manager();
+
app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("t_str_detail", tout << "already set up StartsWith axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
TRACE("t_str_detail", tout << "instantiate StartsWith axiom for " << mk_pp(expr, m) << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 6c332dbd4..6debaad71 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -110,6 +110,11 @@ namespace smt {
ptr_vector<enode> m_axiom_CharAt_todo;
ptr_vector<enode> m_axiom_StartsWith_todo;
+ // hashtable of all exprs for which we've already set up term-specific axioms --
+ // this prevents infinite recursive descent with respect to axioms that
+ // include an occurrence of the term for which axioms are being generated
+ obj_hashtable<expr> axiomatized_terms;
+
int tmpStringVarCount;
int tmpXorVarCount;
int tmpLenTestVarCount;
From fd38b4c729c8f03acfb7362c4c5edd89f7f4a7a7 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Jun 2016 17:55:46 -0400
Subject: [PATCH 113/401] EndsWith decl and rewriter, WIP
---
src/ast/rewriter/str_rewriter.cpp | 25 +++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
src/ast/str_decl_plugin.cpp | 7 ++++++
src/ast/str_decl_plugin.h | 2 ++
src/smt/theory_str.cpp | 40 ++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 5 ++++
6 files changed, 79 insertions(+), 1 deletion(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 4b7ff9057..d6419ba4f 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -69,6 +69,28 @@ br_status str_rewriter::mk_str_StartsWith(expr * haystack, expr * needle, expr_r
}
}
+br_status str_rewriter::mk_str_EndsWith(expr * haystack, expr * needle, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (EndsWith " << mk_pp(haystack, m()) << " " << mk_pp(needle, m()) << ")" << std::endl;);
+ if (m_strutil.is_string(haystack) && m_strutil.is_string(needle)) {
+ TRACE("t_str_rw", tout << "evaluating constant EndsWith predicate" << std::endl;);
+ std::string haystackStr = m_strutil.get_string_constant_value(haystack);
+ std::string needleStr = m_strutil.get_string_constant_value(needle);
+ if (haystackStr.length() < needleStr.length()) {
+ result = m().mk_false();
+ return BR_DONE;
+ } else {
+ if (haystackStr.substr(haystackStr.length() - needleStr.length(), needleStr.length()) == needleStr) {
+ result = m().mk_true();
+ } else {
+ result = m().mk_false();
+ }
+ return BR_DONE;
+ }
+ } else {
+ return BR_FAILED;
+ }
+}
+
br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
SASSERT(f->get_family_id() == get_fid());
@@ -82,6 +104,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_STARTSWITH:
SASSERT(num_args == 2);
return mk_str_StartsWith(args[0], args[1], result);
+ case OP_STR_ENDSWITH:
+ SASSERT(num_args == 2);
+ return mk_str_EndsWith(args[0], args[1], result);
default:
return BR_FAILED;
}
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index 8f12a75db..b179934c7 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -42,6 +42,7 @@ public:
br_status mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & result);
br_status mk_str_StartsWith(expr * haystack, expr * needle, expr_ref & result);
+ br_status mk_str_EndsWith(expr * haystack, expr * needle, expr_ref & result);
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index c6328d592..6453cb244 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -28,6 +28,7 @@ str_decl_plugin::str_decl_plugin():
m_length_decl(0),
m_charat_decl(0),
m_startswith_decl(0),
+ m_endswith_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -43,6 +44,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_length_decl);
DEC_REF(m_charat_decl);
DEC_REF(m_startswith_decl);
+ DEC_REF(m_endswith_decl);
DEC_REF(m_int_sort);
}
@@ -78,6 +80,9 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_startswith_decl = m->mk_func_decl(symbol("StartsWith"), s, s, boolT, func_decl_info(id, OP_STR_STARTSWITH));
m_manager->inc_ref(m_startswith_decl);
+
+ m_endswith_decl = m->mk_func_decl(symbol("EndsWith"), s, s, boolT, func_decl_info(id, OP_STR_ENDSWITH));
+ m_manager->inc_ref(m_endswith_decl);
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -97,6 +102,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STRLEN: return m_length_decl;
case OP_STR_CHARAT: return m_charat_decl;
case OP_STR_STARTSWITH: return m_startswith_decl;
+ case OP_STR_ENDSWITH: return m_endswith_decl;
default: return 0;
}
}
@@ -155,6 +161,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("Length", OP_STRLEN));
op_names.push_back(builtin_name("CharAt", OP_STR_CHARAT));
op_names.push_back(builtin_name("StartsWith", OP_STR_STARTSWITH));
+ op_names.push_back(builtin_name("EndsWith", OP_STR_ENDSWITH));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index d7bfcf172..4ce258c60 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -33,6 +33,7 @@ enum str_op_kind {
// higher-level string functions -- these are reduced to basic operations
OP_STR_CHARAT,
OP_STR_STARTSWITH,
+ OP_STR_ENDSWITH,
// end
LAST_STR_OP
};
@@ -47,6 +48,7 @@ protected:
func_decl * m_charat_decl;
func_decl * m_startswith_decl;
+ func_decl * m_endswith_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 7bdc9f197..76835c560 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -568,7 +568,7 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
bool theory_str::can_propagate() {
return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty()
- || !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty()
+ || !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty() || !m_axiom_EndsWith_todo.empty()
;
}
@@ -602,6 +602,11 @@ void theory_str::propagate() {
instantiate_axiom_StartsWith(m_axiom_StartsWith_todo[i]);
}
m_axiom_StartsWith_todo.reset();
+
+ for (unsigned i = 0; i < m_axiom_EndsWith_todo.size(); ++i) {
+ instantiate_axiom_EndsWith(m_axiom_EndsWith_todo[i]);
+ }
+ m_axiom_EndsWith_todo.reset();
}
}
@@ -832,6 +837,37 @@ void theory_str::instantiate_axiom_StartsWith(enode * e) {
assert_axiom(finalAxiom);
}
+void theory_str::instantiate_axiom_EndsWith(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("t_str_detail", tout << "already set up EndsWith axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("t_str_detail", tout << "instantiate EndsWith axiom for " << mk_pp(expr, m) << std::endl;);
+
+ // TODO NEXT
+ NOT_IMPLEMENTED_YET();
+ /*
+ Z3_ast resBoolVar = my_mk_internal_bool_var(t);
+ Z3_ast ts0 = my_mk_internal_string_var(t);
+ Z3_ast ts1 = my_mk_internal_string_var(t);
+ // boolVar = endswith(arg[0], arg[1])
+ // --------------------------------------------
+ std::vector<Z3_ast> innerItems;
+ innerItems.push_back( Z3_mk_eq(ctx, args[0], mk_concat(t, ts0, ts1)) );
+ innerItems.push_back( Z3_mk_eq(ctx, mk_length(t, ts1), mk_length(t, args[1])) );
+ innerItems.push_back( Z3_mk_ite(ctx, Z3_mk_eq(ctx, ts1, args[1]), Z3_mk_eq(ctx, resBoolVar, Z3_mk_true(ctx)), Z3_mk_eq(ctx, resBoolVar, Z3_mk_false(ctx) ) ) );
+ Z3_ast then1 = mk_and_fromVector(t, innerItems);
+ breakdownAssert = Z3_mk_ite(ctx, Z3_mk_ge(ctx, mk_length(t, args[0]), mk_length(t, args[1])), then1, Z3_mk_eq(ctx, resBoolVar, Z3_mk_false(ctx) ) );
+ reduceAst = resBoolVar;
+ */
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
@@ -3587,6 +3623,8 @@ void theory_str::set_up_axioms(expr * ex) {
app * ap = to_app(ex);
if (is_StartsWith(ap)) {
m_axiom_StartsWith_todo.push_back(n);
+ } else if (is_EndsWith(ap)) {
+ m_axiom_EndsWith_todo.push_back(n);
}
}
} else {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 6debaad71..ae3cc5d52 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -109,6 +109,7 @@ namespace smt {
// enode lists for term-specific axioms
ptr_vector<enode> m_axiom_CharAt_todo;
ptr_vector<enode> m_axiom_StartsWith_todo;
+ ptr_vector<enode> m_axiom_EndsWith_todo;
// hashtable of all exprs for which we've already set up term-specific axioms --
// this prevents infinite recursive descent with respect to axioms that
@@ -180,12 +181,16 @@ namespace smt {
bool is_CharAt(enode const * n) const { return is_CharAt(n->get_owner()); }
bool is_StartsWith(app const * a) const { return a->is_app_of(get_id(), OP_STR_STARTSWITH); }
bool is_StartsWith(enode const * n) const { return is_StartsWith(n->get_owner()); }
+ bool is_EndsWith(app const * a) const { return a->is_app_of(get_id(), OP_STR_ENDSWITH); }
+ bool is_EndsWith(enode const * n) const { return is_EndsWith(n->get_owner()); }
+
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
void instantiate_str_eq_length_axiom(enode * lhs, enode * rhs);
void instantiate_axiom_CharAt(enode * e);
void instantiate_axiom_StartsWith(enode * e);
+ void instantiate_axiom_EndsWith(enode * e);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From 989d6b577b457931574a0a9e376523f5869f2b88 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Jun 2016 18:05:24 -0400
Subject: [PATCH 114/401] EndsWith axiomatization in theory_str
---
src/smt/theory_str.cpp | 39 ++++++++++++++++++++++-----------------
1 file changed, 22 insertions(+), 17 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 76835c560..508f451a3 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -832,7 +832,6 @@ void theory_str::instantiate_axiom_StartsWith(enode * e) {
SASSERT(topLevelCond);
expr_ref finalAxiom(m.mk_ite(topLevelCond, then1, m.mk_not(expr)), m);
-
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
}
@@ -850,22 +849,28 @@ void theory_str::instantiate_axiom_EndsWith(enode * e) {
TRACE("t_str_detail", tout << "instantiate EndsWith axiom for " << mk_pp(expr, m) << std::endl;);
- // TODO NEXT
- NOT_IMPLEMENTED_YET();
- /*
- Z3_ast resBoolVar = my_mk_internal_bool_var(t);
- Z3_ast ts0 = my_mk_internal_string_var(t);
- Z3_ast ts1 = my_mk_internal_string_var(t);
- // boolVar = endswith(arg[0], arg[1])
- // --------------------------------------------
- std::vector<Z3_ast> innerItems;
- innerItems.push_back( Z3_mk_eq(ctx, args[0], mk_concat(t, ts0, ts1)) );
- innerItems.push_back( Z3_mk_eq(ctx, mk_length(t, ts1), mk_length(t, args[1])) );
- innerItems.push_back( Z3_mk_ite(ctx, Z3_mk_eq(ctx, ts1, args[1]), Z3_mk_eq(ctx, resBoolVar, Z3_mk_true(ctx)), Z3_mk_eq(ctx, resBoolVar, Z3_mk_false(ctx) ) ) );
- Z3_ast then1 = mk_and_fromVector(t, innerItems);
- breakdownAssert = Z3_mk_ite(ctx, Z3_mk_ge(ctx, mk_length(t, args[0]), mk_length(t, args[1])), then1, Z3_mk_eq(ctx, resBoolVar, Z3_mk_false(ctx) ) );
- reduceAst = resBoolVar;
- */
+ expr_ref ts0(mk_str_var("ts0"), m);
+ expr_ref ts1(mk_str_var("ts1"), m);
+
+ expr_ref_vector innerItems(m);
+ innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, ts1)));
+ innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts1), mk_strlen(expr->get_arg(1))));
+ innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts1, expr->get_arg(1)), expr, m.mk_not(expr)));
+ expr_ref then1(m.mk_and(innerItems.size(), innerItems.c_ptr()), m);
+ SASSERT(then1);
+
+ // the top-level condition is Length(arg0) >= Length(arg1)
+ expr_ref topLevelCond(
+ m_autil.mk_ge(
+ m_autil.mk_add(
+ mk_strlen(expr->get_arg(0)), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(1)))),
+ mk_int(0))
+ , m);
+ SASSERT(topLevelCond);
+
+ expr_ref finalAxiom(m.mk_ite(topLevelCond, then1, m.mk_not(expr)), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
}
void theory_str::attach_new_th_var(enode * n) {
From a3986d6d0e0ad90a62652b92f131dddb30115999 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Jun 2016 18:36:43 -0400
Subject: [PATCH 115/401] decl and rewriter support for Contains (WIP)
---
src/ast/rewriter/str_rewriter.cpp | 24 ++++++++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
src/ast/str_decl_plugin.cpp | 7 +++++++
src/ast/str_decl_plugin.h | 2 ++
4 files changed, 34 insertions(+)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index d6419ba4f..d33194748 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -91,6 +91,27 @@ br_status str_rewriter::mk_str_EndsWith(expr * haystack, expr * needle, expr_ref
}
}
+br_status str_rewriter::mk_str_Contains(expr * haystack, expr * needle, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (Contains " << mk_pp(haystack, m()) << " " << mk_pp(needle, m()) << ")" << std::endl;);
+ if (haystack == needle) {
+ TRACE("t_str_rw", tout << "eliminate (Contains) over identical terms" << std::endl;);
+ result = m().mk_true();
+ return BR_DONE;
+ } else if (m_strutil.is_string(haystack) && m_strutil.is_string(needle)) {
+ TRACE("t_str_rw", tout << "evaluating constant Contains predicate" << std::endl;);
+ std::string haystackStr = m_strutil.get_string_constant_value(haystack);
+ std::string needleStr = m_strutil.get_string_constant_value(needle);
+ if (haystackStr.find(needleStr) != std::string::npos) {
+ result = m().mk_true();
+ } else {
+ result = m().mk_false();
+ }
+ return BR_DONE;
+ } else {
+ return BR_FAILED;
+ }
+}
+
br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
SASSERT(f->get_family_id() == get_fid());
@@ -107,6 +128,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_ENDSWITH:
SASSERT(num_args == 2);
return mk_str_EndsWith(args[0], args[1], result);
+ case OP_STR_CONTAINS:
+ SASSERT(num_args == 2);
+ return mk_str_Contains(args[0], args[1], result);
default:
return BR_FAILED;
}
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index b179934c7..f98f64cc4 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -43,6 +43,7 @@ public:
br_status mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & result);
br_status mk_str_StartsWith(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_EndsWith(expr * haystack, expr * needle, expr_ref & result);
+ br_status mk_str_Contains(expr * haystack, expr * needle, expr_ref & result);
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 6453cb244..07e0d07a2 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -29,6 +29,7 @@ str_decl_plugin::str_decl_plugin():
m_charat_decl(0),
m_startswith_decl(0),
m_endswith_decl(0),
+ m_contains_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -45,6 +46,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_charat_decl);
DEC_REF(m_startswith_decl);
DEC_REF(m_endswith_decl);
+ DEC_REF(m_contains_decl);
DEC_REF(m_int_sort);
}
@@ -83,6 +85,9 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_endswith_decl = m->mk_func_decl(symbol("EndsWith"), s, s, boolT, func_decl_info(id, OP_STR_ENDSWITH));
m_manager->inc_ref(m_endswith_decl);
+
+ m_contains_decl = m->mk_func_decl(symbol("Contains"), s, s, boolT, func_decl_info(id, OP_STR_CONTAINS));
+ m_manager->inc_ref(m_contains_decl);
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -103,6 +108,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STR_CHARAT: return m_charat_decl;
case OP_STR_STARTSWITH: return m_startswith_decl;
case OP_STR_ENDSWITH: return m_endswith_decl;
+ case OP_STR_CONTAINS: return m_contains_decl;
default: return 0;
}
}
@@ -162,6 +168,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("CharAt", OP_STR_CHARAT));
op_names.push_back(builtin_name("StartsWith", OP_STR_STARTSWITH));
op_names.push_back(builtin_name("EndsWith", OP_STR_ENDSWITH));
+ op_names.push_back(builtin_name("Contains", OP_STR_CONTAINS));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 4ce258c60..c4605003d 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -34,6 +34,7 @@ enum str_op_kind {
OP_STR_CHARAT,
OP_STR_STARTSWITH,
OP_STR_ENDSWITH,
+ OP_STR_CONTAINS,
// end
LAST_STR_OP
};
@@ -49,6 +50,7 @@ protected:
func_decl * m_charat_decl;
func_decl * m_startswith_decl;
func_decl * m_endswith_decl;
+ func_decl * m_contains_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
From 7aeeb599ef6ed05ab8eb0f06fc4fb279585c981e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Jun 2016 18:43:51 -0400
Subject: [PATCH 116/401] very very basic Contains support in theory_str not
included: the 1200 lines of code that make it very fast
---
src/smt/theory_str.cpp | 29 +++++++++++++++++++++++++++++
src/smt/theory_str.h | 4 ++++
2 files changed, 33 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 508f451a3..faaba596f 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -569,6 +569,7 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
bool theory_str::can_propagate() {
return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty()
|| !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty() || !m_axiom_EndsWith_todo.empty()
+ || !m_axiom_Contains_todo.empty()
;
}
@@ -607,6 +608,11 @@ void theory_str::propagate() {
instantiate_axiom_EndsWith(m_axiom_EndsWith_todo[i]);
}
m_axiom_EndsWith_todo.reset();
+
+ for (unsigned i = 0; i < m_axiom_Contains_todo.size(); ++i) {
+ instantiate_axiom_Contains(m_axiom_Contains_todo[i]);
+ }
+ m_axiom_Contains_todo.reset();
}
}
@@ -873,6 +879,27 @@ void theory_str::instantiate_axiom_EndsWith(enode * e) {
assert_axiom(finalAxiom);
}
+void theory_str::instantiate_axiom_Contains(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("t_str_detail", tout << "already set up Contains axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("t_str_detail", tout << "instantiate Contains axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref ts0(mk_str_var("ts0"), m);
+ expr_ref ts1(mk_str_var("ts1"), m);
+ // TODO NEXT registerContain(expr);
+ expr_ref breakdownAssert(ctx.mk_eq_atom(expr, ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, mk_concat(expr->get_arg(1), ts1)))), m);
+ SASSERT(breakdownAssert);
+ assert_axiom(breakdownAssert);
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
@@ -3630,6 +3657,8 @@ void theory_str::set_up_axioms(expr * ex) {
m_axiom_StartsWith_todo.push_back(n);
} else if (is_EndsWith(ap)) {
m_axiom_EndsWith_todo.push_back(n);
+ } else if (is_Contains(ap)) {
+ m_axiom_Contains_todo.push_back(n);
}
}
} else {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index ae3cc5d52..6d1bd597f 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -110,6 +110,7 @@ namespace smt {
ptr_vector<enode> m_axiom_CharAt_todo;
ptr_vector<enode> m_axiom_StartsWith_todo;
ptr_vector<enode> m_axiom_EndsWith_todo;
+ ptr_vector<enode> m_axiom_Contains_todo;
// hashtable of all exprs for which we've already set up term-specific axioms --
// this prevents infinite recursive descent with respect to axioms that
@@ -183,6 +184,8 @@ namespace smt {
bool is_StartsWith(enode const * n) const { return is_StartsWith(n->get_owner()); }
bool is_EndsWith(app const * a) const { return a->is_app_of(get_id(), OP_STR_ENDSWITH); }
bool is_EndsWith(enode const * n) const { return is_EndsWith(n->get_owner()); }
+ bool is_Contains(app const * a) const { return a->is_app_of(get_id(), OP_STR_CONTAINS); }
+ bool is_Contains(enode const * n) const { return is_Contains(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
@@ -191,6 +194,7 @@ namespace smt {
void instantiate_axiom_CharAt(enode * e);
void instantiate_axiom_StartsWith(enode * e);
void instantiate_axiom_EndsWith(enode * e);
+ void instantiate_axiom_Contains(enode * e);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From db2a5854e9e21dffe51477a2d27f9711a2a85380 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Jun 2016 20:10:06 -0400
Subject: [PATCH 117/401] decl and rewriter for Indexof (WIP)
---
src/ast/rewriter/str_rewriter.cpp | 21 +++++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
src/ast/str_decl_plugin.cpp | 7 +++++++
src/ast/str_decl_plugin.h | 2 ++
4 files changed, 31 insertions(+)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index d33194748..5e61ee3a2 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -112,6 +112,24 @@ br_status str_rewriter::mk_str_Contains(expr * haystack, expr * needle, expr_ref
}
}
+br_status str_rewriter::mk_str_Indexof(expr * haystack, expr * needle, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (Indexof " << mk_pp(haystack, m()) << " " << mk_pp(needle, m()) << ")" << std::endl;);
+ if (m_strutil.is_string(haystack) && m_strutil.is_string(needle)) {
+ TRACE("t_str_rw", tout << "evaluating constant Indexof expression" << std::endl;);
+ std::string haystackStr = m_strutil.get_string_constant_value(haystack);
+ std::string needleStr = m_strutil.get_string_constant_value(needle);
+ if (haystackStr.find(needleStr) != std::string::npos) {
+ int index = haystackStr.find(needleStr);
+ result = m_autil.mk_numeral(rational(index), true);
+ } else {
+ result = m_autil.mk_numeral(rational(-1), true);
+ }
+ return BR_DONE;
+ } else {
+ return BR_FAILED;
+ }
+}
+
br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
SASSERT(f->get_family_id() == get_fid());
@@ -131,6 +149,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_CONTAINS:
SASSERT(num_args == 2);
return mk_str_Contains(args[0], args[1], result);
+ case OP_STR_INDEXOF:
+ SASSERT(num_args == 2);
+ return mk_str_Indexof(args[0], args[1], result);
default:
return BR_FAILED;
}
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index f98f64cc4..f22ac31a7 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -44,6 +44,7 @@ public:
br_status mk_str_StartsWith(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_EndsWith(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_Contains(expr * haystack, expr * needle, expr_ref & result);
+ br_status mk_str_Indexof(expr * haystack, expr * needle, expr_ref & result);
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 07e0d07a2..ea4b0c6d0 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -30,6 +30,7 @@ str_decl_plugin::str_decl_plugin():
m_startswith_decl(0),
m_endswith_decl(0),
m_contains_decl(0),
+ m_indexof_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -47,6 +48,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_startswith_decl);
DEC_REF(m_endswith_decl);
DEC_REF(m_contains_decl);
+ DEC_REF(m_indexof_decl);
DEC_REF(m_int_sort);
}
@@ -88,6 +90,9 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_contains_decl = m->mk_func_decl(symbol("Contains"), s, s, boolT, func_decl_info(id, OP_STR_CONTAINS));
m_manager->inc_ref(m_contains_decl);
+
+ m_indexof_decl = m->mk_func_decl(symbol("Indexof"), s, s, i, func_decl_info(id, OP_STR_INDEXOF));
+ m_manager->inc_ref(m_indexof_decl);
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -109,6 +114,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STR_STARTSWITH: return m_startswith_decl;
case OP_STR_ENDSWITH: return m_endswith_decl;
case OP_STR_CONTAINS: return m_contains_decl;
+ case OP_STR_INDEXOF: return m_indexof_decl;
default: return 0;
}
}
@@ -169,6 +175,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("StartsWith", OP_STR_STARTSWITH));
op_names.push_back(builtin_name("EndsWith", OP_STR_ENDSWITH));
op_names.push_back(builtin_name("Contains", OP_STR_CONTAINS));
+ op_names.push_back(builtin_name("Indexof", OP_STR_INDEXOF));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index c4605003d..a2a355ba2 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -35,6 +35,7 @@ enum str_op_kind {
OP_STR_STARTSWITH,
OP_STR_ENDSWITH,
OP_STR_CONTAINS,
+ OP_STR_INDEXOF,
// end
LAST_STR_OP
};
@@ -51,6 +52,7 @@ protected:
func_decl * m_startswith_decl;
func_decl * m_endswith_decl;
func_decl * m_contains_decl;
+ func_decl * m_indexof_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
From 881e3056f3a039ec0551b29ed4065c607de54fdc Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Jun 2016 21:28:31 -0400
Subject: [PATCH 118/401] support for IndexOf in theory_str
---
src/smt/theory_str.cpp | 113 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 6 +++
2 files changed, 117 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index faaba596f..df77018e9 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -430,6 +430,30 @@ app * theory_str::mk_internal_xor_var() {
return a;
}
+app * theory_str::mk_int_var(std::string name) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ TRACE("t_str_detail", tout << "creating integer variable " << name << " at scope level " << sLevel << std::endl;);
+
+ sort * int_sort = m.mk_sort(m_autil.get_family_id(), INT_SORT);
+ app * a = m.mk_fresh_const(name.c_str(), int_sort);
+
+ ctx.internalize(a, false);
+ SASSERT(ctx.get_enode(a) != NULL);
+ SASSERT(ctx.e_internalized(a));
+ ctx.mark_as_relevant(a);
+ // I'm assuming that this combination will do the correct thing in the integer theory.
+
+ //mk_var(ctx.get_enode(a));
+ m_trail.push_back(a);
+ //variable_set.insert(a);
+ //internal_variable_set.insert(a);
+ //track_variable_scope(a);
+
+ return a;
+}
+
app * theory_str::mk_str_var(std::string name) {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -498,6 +522,15 @@ app * theory_str::mk_nonempty_str_var() {
return a;
}
+app * theory_str::mk_contains(expr * haystack, expr * needle) {
+ expr * args[2] = {haystack, needle};
+ app * contains = get_manager().mk_app(get_id(), OP_STR_CONTAINS, 0, 0, 2, args);
+ // immediately force internalization so that axiom setup does not fail
+ get_context().internalize(contains, false);
+ set_up_axioms(contains);
+ return contains;
+}
+
app * theory_str::mk_strlen(expr * e) {
/*if (m_strutil.is_string(e)) {*/ if (false) {
const char * strval = 0;
@@ -569,7 +602,7 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
bool theory_str::can_propagate() {
return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty()
|| !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty() || !m_axiom_EndsWith_todo.empty()
- || !m_axiom_Contains_todo.empty()
+ || !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty()
;
}
@@ -613,6 +646,11 @@ void theory_str::propagate() {
instantiate_axiom_Contains(m_axiom_Contains_todo[i]);
}
m_axiom_Contains_todo.reset();
+
+ for (unsigned i = 0; i < m_axiom_Indexof_todo.size(); ++i) {
+ instantiate_axiom_Indexof(m_axiom_Indexof_todo[i]);
+ }
+ m_axiom_Indexof_todo.reset();
}
}
@@ -900,6 +938,62 @@ void theory_str::instantiate_axiom_Contains(enode * e) {
assert_axiom(breakdownAssert);
}
+void theory_str::instantiate_axiom_Indexof(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("t_str_detail", tout << "already set up Indexof axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("t_str_detail", tout << "instantiate Indexof axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref x1(mk_str_var("x1"), m);
+ expr_ref x2(mk_str_var("x2"), m);
+ expr_ref indexAst(mk_int_var("index"), m);
+
+ expr_ref condAst(mk_contains(expr->get_arg(0), expr->get_arg(1)), m);
+ SASSERT(condAst);
+
+ // -----------------------
+ // true branch
+ expr_ref_vector thenItems(m);
+ // args[0] = x1 . args[1] . x2
+ thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x1, mk_concat(expr->get_arg(1), x2))));
+ // indexAst = |x1|
+ thenItems.push_back(ctx.mk_eq_atom(indexAst, mk_strlen(x1)));
+ // args[0] = x3 . x4
+ // /\ |x3| = |x1| + |args[1]| - 1
+ // /\ ! contains(x3, args[1])
+ expr_ref x3(mk_str_var("x3"), m);
+ expr_ref x4(mk_str_var("x4"), m);
+ expr_ref tmpLen(m_autil.mk_add(indexAst, mk_strlen(expr->get_arg(1)), mk_int(-1)), m);
+ SASSERT(tmpLen);
+ thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x3, x4)));
+ thenItems.push_back(ctx.mk_eq_atom(mk_strlen(x3), tmpLen));
+ thenItems.push_back(m.mk_not(mk_contains(x3, expr->get_arg(1))));
+ expr_ref thenBranch(m.mk_and(thenItems.size(), thenItems.c_ptr()), m);
+ SASSERT(thenBranch);
+
+ // -----------------------
+ // false branch
+ expr_ref elseBranch(ctx.mk_eq_atom(indexAst, mk_int(-1)), m);
+ SASSERT(elseBranch);
+
+ expr_ref breakdownAssert(m.mk_ite(condAst, thenBranch, elseBranch), m);
+ SASSERT(breakdownAssert);
+
+ expr_ref reduceToIndex(ctx.mk_eq_atom(expr, indexAst), m);
+ SASSERT(reduceToIndex);
+
+ expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToIndex), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
@@ -3602,7 +3696,6 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
}
void theory_str::set_up_axioms(expr * ex) {
- // TODO check to make sure we don't set up axioms on the same term twice
ast_manager & m = get_manager();
context & ctx = get_context();
@@ -3610,6 +3703,9 @@ void theory_str::set_up_axioms(expr * ex) {
sort * str_sort = m.mk_sort(get_family_id(), STRING_SORT);
sort * bool_sort = m.mk_bool_sort();
+ family_id m_arith_fid = m.mk_family_id("arith");
+ sort * int_sort = m.mk_sort(m_arith_fid, INT_SORT);
+
if (ex_sort == str_sort) {
TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
": expr is of sort String" << std::endl;);
@@ -3661,6 +3757,19 @@ void theory_str::set_up_axioms(expr * ex) {
m_axiom_Contains_todo.push_back(n);
}
}
+ } else if (ex_sort == int_sort) {
+ TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ ": expr is of sort Int" << std::endl;);
+ // set up axioms for boolean terms
+ enode * n = ctx.get_enode(ex);
+ SASSERT(n);
+
+ if (is_app(ex)) {
+ app * ap = to_app(ex);
+ if (is_Indexof(ap)) {
+ m_axiom_Indexof_todo.push_back(n);
+ }
+ }
} else {
TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
": expr is of wrong sort, ignoring" << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 6d1bd597f..bf0fef38b 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -111,6 +111,7 @@ namespace smt {
ptr_vector<enode> m_axiom_StartsWith_todo;
ptr_vector<enode> m_axiom_EndsWith_todo;
ptr_vector<enode> m_axiom_Contains_todo;
+ ptr_vector<enode> m_axiom_Indexof_todo;
// hashtable of all exprs for which we've already set up term-specific axioms --
// this prevents infinite recursive descent with respect to axioms that
@@ -156,6 +157,7 @@ namespace smt {
app * mk_strlen(expr * e);
expr * mk_concat(expr * n1, expr * n2);
expr * mk_concat_const_str(expr * n1, expr * n2);
+ app * mk_contains(expr * haystack, expr * needle);
literal mk_literal(expr* _e);
app * mk_int(int n);
@@ -168,6 +170,7 @@ namespace smt {
void track_variable_scope(expr * var);
app * mk_str_var(std::string name);
+ app * mk_int_var(std::string name);
app * mk_nonempty_str_var();
app * mk_internal_xor_var();
expr * mk_internal_valTest_var(expr * node, int len, int vTries);
@@ -186,6 +189,8 @@ namespace smt {
bool is_EndsWith(enode const * n) const { return is_EndsWith(n->get_owner()); }
bool is_Contains(app const * a) const { return a->is_app_of(get_id(), OP_STR_CONTAINS); }
bool is_Contains(enode const * n) const { return is_Contains(n->get_owner()); }
+ bool is_Indexof(app const * a) const { return a->is_app_of(get_id(), OP_STR_INDEXOF); }
+ bool is_Indexof(enode const * n) const { return is_Indexof(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
@@ -195,6 +200,7 @@ namespace smt {
void instantiate_axiom_StartsWith(enode * e);
void instantiate_axiom_EndsWith(enode * e);
void instantiate_axiom_Contains(enode * e);
+ void instantiate_axiom_Indexof(enode * e);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From dc5a334d429e1e2c16ac00a9cdc11c2f1e60a236 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 15 Jun 2016 17:37:17 -0400
Subject: [PATCH 119/401] support for Indexof2 in theory_str
---
src/ast/rewriter/str_rewriter.cpp | 31 ++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
src/ast/str_decl_plugin.cpp | 10 ++++
src/ast/str_decl_plugin.h | 2 +
src/smt/theory_str.cpp | 84 ++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 6 +++
6 files changed, 133 insertions(+), 1 deletion(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 5e61ee3a2..30dcb1d95 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -130,6 +130,34 @@ br_status str_rewriter::mk_str_Indexof(expr * haystack, expr * needle, expr_ref
}
}
+br_status str_rewriter::mk_str_Indexof2(expr * arg0, expr * arg1, expr * arg2, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (Indexof2 " << mk_pp(arg0, m()) << " " << mk_pp(arg1, m()) << " " << mk_pp(arg2, m()) << ")" << std::endl;);
+ //if (getNodeType(t, args[0]) == my_Z3_ConstStr && getNodeType(t, args[1]) == my_Z3_ConstStr && getNodeType(t, args[2]) == my_Z3_Num) {
+ rational arg2Int;
+ if (m_strutil.is_string(arg0) && m_strutil.is_string(arg1) && m_autil.is_numeral(arg2, arg2Int)) {
+ TRACE("t_str_rw", tout << "evaluating constant Indexof2 expression" << std::endl;);
+ std::string arg0str = m_strutil.get_string_constant_value(arg0);
+ std::string arg1str = m_strutil.get_string_constant_value(arg1);
+ if (arg2Int >= rational((unsigned)arg0str.length())) {
+ result = m_autil.mk_numeral(rational(-1), true);
+ } else if (arg2Int < rational(0)) {
+ int index = arg0str.find(arg1str);
+ result = m_autil.mk_numeral(rational(index), true);
+ } else {
+ std::string suffixStr = arg0str.substr(arg2Int.get_unsigned(), arg0str.length() - arg2Int.get_unsigned());
+ if (suffixStr.find(arg1str) != std::string::npos) {
+ int index = suffixStr.find(arg1str) + arg2Int.get_unsigned();
+ result = m_autil.mk_numeral(rational(index), true);
+ } else {
+ result = m_autil.mk_numeral(rational(-1), true);
+ }
+ }
+ return BR_DONE;
+ } else {
+ return BR_FAILED;
+ }
+}
+
br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
SASSERT(f->get_family_id() == get_fid());
@@ -152,6 +180,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_INDEXOF:
SASSERT(num_args == 2);
return mk_str_Indexof(args[0], args[1], result);
+ case OP_STR_INDEXOF2:
+ SASSERT(num_args == 3);
+ return mk_str_Indexof2(args[0], args[1], args[2], result);
default:
return BR_FAILED;
}
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index f22ac31a7..c0bae2881 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -45,6 +45,7 @@ public:
br_status mk_str_EndsWith(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_Contains(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_Indexof(expr * haystack, expr * needle, expr_ref & result);
+ br_status mk_str_Indexof2(expr * arg0, expr * arg1, expr * arg2, expr_ref & result);
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index ea4b0c6d0..f6e458fbd 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -31,6 +31,7 @@ str_decl_plugin::str_decl_plugin():
m_endswith_decl(0),
m_contains_decl(0),
m_indexof_decl(0),
+ m_indexof2_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -49,6 +50,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_endswith_decl);
DEC_REF(m_contains_decl);
DEC_REF(m_indexof_decl);
+ DEC_REF(m_indexof2_decl);
DEC_REF(m_int_sort);
}
@@ -93,6 +95,12 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_indexof_decl = m->mk_func_decl(symbol("Indexof"), s, s, i, func_decl_info(id, OP_STR_INDEXOF));
m_manager->inc_ref(m_indexof_decl);
+
+ {
+ sort * d[3] = { s, s, i };
+ m_indexof2_decl = m->mk_func_decl(symbol("Indexof2"), 3, d, i, func_decl_info(id, OP_STR_INDEXOF2));
+ m_manager->inc_ref(m_indexof2_decl);
+ }
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -115,6 +123,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STR_ENDSWITH: return m_endswith_decl;
case OP_STR_CONTAINS: return m_contains_decl;
case OP_STR_INDEXOF: return m_indexof_decl;
+ case OP_STR_INDEXOF2: return m_indexof2_decl;
default: return 0;
}
}
@@ -176,6 +185,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("EndsWith", OP_STR_ENDSWITH));
op_names.push_back(builtin_name("Contains", OP_STR_CONTAINS));
op_names.push_back(builtin_name("Indexof", OP_STR_INDEXOF));
+ op_names.push_back(builtin_name("Indexof2", OP_STR_INDEXOF2));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index a2a355ba2..54762f6b9 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -36,6 +36,7 @@ enum str_op_kind {
OP_STR_ENDSWITH,
OP_STR_CONTAINS,
OP_STR_INDEXOF,
+ OP_STR_INDEXOF2,
// end
LAST_STR_OP
};
@@ -53,6 +54,7 @@ protected:
func_decl * m_endswith_decl;
func_decl * m_contains_decl;
func_decl * m_indexof_decl;
+ func_decl * m_indexof2_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index df77018e9..a5244f7bb 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -531,6 +531,15 @@ app * theory_str::mk_contains(expr * haystack, expr * needle) {
return contains;
}
+app * theory_str::mk_indexof(expr * haystack, expr * needle) {
+ expr * args[2] = {haystack, needle};
+ app * indexof = get_manager().mk_app(get_id(), OP_STR_INDEXOF, 0, 0, 2, args);
+ // immediately force internalization so that axiom setup does not fail
+ get_context().internalize(indexof, false);
+ set_up_axioms(indexof);
+ return indexof;
+}
+
app * theory_str::mk_strlen(expr * e) {
/*if (m_strutil.is_string(e)) {*/ if (false) {
const char * strval = 0;
@@ -602,7 +611,7 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
bool theory_str::can_propagate() {
return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty()
|| !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty() || !m_axiom_EndsWith_todo.empty()
- || !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty()
+ || !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty()
;
}
@@ -651,6 +660,11 @@ void theory_str::propagate() {
instantiate_axiom_Indexof(m_axiom_Indexof_todo[i]);
}
m_axiom_Indexof_todo.reset();
+
+ for (unsigned i = 0; i < m_axiom_Indexof2_todo.size(); ++i) {
+ instantiate_axiom_Indexof2(m_axiom_Indexof2_todo[i]);
+ }
+ m_axiom_Indexof2_todo.reset();
}
}
@@ -994,6 +1008,74 @@ void theory_str::instantiate_axiom_Indexof(enode * e) {
assert_axiom(finalAxiom);
}
+void theory_str::instantiate_axiom_Indexof2(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("t_str_detail", tout << "already set up Indexof2 axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("t_str_detail", tout << "instantiate Indexof2 axiom for " << mk_pp(expr, m) << std::endl;);
+
+ // -------------------------------------------------------------------------------
+ // if (arg[2] >= length(arg[0])) // ite2
+ // resAst = -1
+ // else
+ // args[0] = prefix . suffix
+ // /\ indexAst = indexof(suffix, arg[1])
+ // /\ args[2] = len(prefix)
+ // /\ if (indexAst == -1) resAst = indexAst // ite3
+ // else resAst = args[2] + indexAst
+ // -------------------------------------------------------------------------------
+
+ expr_ref resAst(mk_int_var("res"), m);
+ expr_ref indexAst(mk_int_var("index"), m);
+ expr_ref prefix(mk_str_var("prefix"), m);
+ expr_ref suffix(mk_str_var("suffix"), m);
+ expr_ref prefixLen(mk_strlen(prefix), m);
+ expr_ref zeroAst(mk_int(0), m);
+ expr_ref negOneAst(mk_int(-1), m);
+
+ expr_ref ite3(m.mk_ite(
+ ctx.mk_eq_atom(indexAst, negOneAst),
+ ctx.mk_eq_atom(resAst, negOneAst),
+ ctx.mk_eq_atom(resAst, m_autil.mk_add(expr->get_arg(2), indexAst))
+ ),m);
+
+ expr_ref_vector ite2ElseItems(m);
+ ite2ElseItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(prefix, suffix)));
+ ite2ElseItems.push_back(ctx.mk_eq_atom(indexAst, mk_indexof(suffix, expr->get_arg(1))));
+ ite2ElseItems.push_back(ctx.mk_eq_atom(expr->get_arg(2), prefixLen));
+ ite2ElseItems.push_back(ite3);
+ expr_ref ite2Else(m.mk_and(ite2ElseItems.size(), ite2ElseItems.c_ptr()), m);
+ SASSERT(ite2Else);
+
+ expr_ref ite2(m.mk_ite(
+ //m_autil.mk_ge(expr->get_arg(2), mk_strlen(expr->get_arg(0))),
+ m_autil.mk_ge(m_autil.mk_add(expr->get_arg(2), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))), zeroAst),
+ ctx.mk_eq_atom(resAst, negOneAst),
+ ite2Else
+ ), m);
+ SASSERT(ite2);
+
+ expr_ref ite1(m.mk_ite(
+ //m_autil.mk_lt(expr->get_arg(2), zeroAst),
+ m.mk_not(m_autil.mk_ge(expr->get_arg(2), zeroAst)),
+ ctx.mk_eq_atom(resAst, mk_indexof(expr->get_arg(0), expr->get_arg(1))),
+ ite2
+ ), m);
+ SASSERT(ite1);
+ assert_axiom(ite1);
+
+ expr_ref reduceTerm(ctx.mk_eq_atom(expr, resAst), m);
+ SASSERT(reduceTerm);
+ assert_axiom(reduceTerm);
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index bf0fef38b..c652a3faf 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -107,11 +107,13 @@ namespace smt {
ptr_vector<enode> m_string_constant_length_todo;
// enode lists for term-specific axioms
+ // TODO maybe refactor this into a generic "library_aware_axiom_todo" list
ptr_vector<enode> m_axiom_CharAt_todo;
ptr_vector<enode> m_axiom_StartsWith_todo;
ptr_vector<enode> m_axiom_EndsWith_todo;
ptr_vector<enode> m_axiom_Contains_todo;
ptr_vector<enode> m_axiom_Indexof_todo;
+ ptr_vector<enode> m_axiom_Indexof2_todo;
// hashtable of all exprs for which we've already set up term-specific axioms --
// this prevents infinite recursive descent with respect to axioms that
@@ -158,6 +160,7 @@ namespace smt {
expr * mk_concat(expr * n1, expr * n2);
expr * mk_concat_const_str(expr * n1, expr * n2);
app * mk_contains(expr * haystack, expr * needle);
+ app * mk_indexof(expr * haystack, expr * needle);
literal mk_literal(expr* _e);
app * mk_int(int n);
@@ -191,6 +194,8 @@ namespace smt {
bool is_Contains(enode const * n) const { return is_Contains(n->get_owner()); }
bool is_Indexof(app const * a) const { return a->is_app_of(get_id(), OP_STR_INDEXOF); }
bool is_Indexof(enode const * n) const { return is_Indexof(n->get_owner()); }
+ bool is_Indexof2(app const * a) const { return a->is_app_of(get_id(), OP_STR_INDEXOF2); }
+ bool is_Indexof2(enode const * n) const { return is_Indexof2(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
@@ -201,6 +206,7 @@ namespace smt {
void instantiate_axiom_EndsWith(enode * e);
void instantiate_axiom_Contains(enode * e);
void instantiate_axiom_Indexof(enode * e);
+ void instantiate_axiom_Indexof2(enode * e);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From 7c8b882ae6603b5908d6aa6d3ce5b48422c73cb4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 15 Jun 2016 18:04:33 -0400
Subject: [PATCH 120/401] decl and rewriter support for LastIndexof in
theory_str (WIP)
---
src/ast/rewriter/str_rewriter.cpp | 21 +++++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
src/ast/str_decl_plugin.cpp | 7 +++++++
src/ast/str_decl_plugin.h | 2 ++
4 files changed, 31 insertions(+)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 30dcb1d95..c4f2e634e 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -158,6 +158,24 @@ br_status str_rewriter::mk_str_Indexof2(expr * arg0, expr * arg1, expr * arg2, e
}
}
+br_status str_rewriter::mk_str_LastIndexof(expr * haystack, expr * needle, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (LastIndexof " << mk_pp(haystack, m()) << " " << mk_pp(needle, m()) << ")" << std::endl;);
+ if (m_strutil.is_string(haystack) && m_strutil.is_string(needle)) {
+ TRACE("t_str_rw", tout << "evaluating constant LastIndexof expression" << std::endl;);
+ std::string arg0Str = m_strutil.get_string_constant_value(haystack);
+ std::string arg1Str = m_strutil.get_string_constant_value(needle);
+ if (arg0Str.rfind(arg1Str) != std::string::npos) {
+ int index = arg0Str.rfind(arg1Str);
+ result = m_autil.mk_numeral(rational(index), true);
+ } else {
+ result = m_autil.mk_numeral(rational(-1), true);
+ }
+ return BR_DONE;
+ } else {
+ return BR_FAILED;
+ }
+}
+
br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
SASSERT(f->get_family_id() == get_fid());
@@ -183,6 +201,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_INDEXOF2:
SASSERT(num_args == 3);
return mk_str_Indexof2(args[0], args[1], args[2], result);
+ case OP_STR_LASTINDEXOF:
+ SASSERT(num_args == 2);
+ return mk_str_LastIndexof(args[0], args[1], result);
default:
return BR_FAILED;
}
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index c0bae2881..de399acba 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -46,6 +46,7 @@ public:
br_status mk_str_Contains(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_Indexof(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_Indexof2(expr * arg0, expr * arg1, expr * arg2, expr_ref & result);
+ br_status mk_str_LastIndexof(expr * haystack, expr * needle, expr_ref & result);
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index f6e458fbd..fbdb10263 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -32,6 +32,7 @@ str_decl_plugin::str_decl_plugin():
m_contains_decl(0),
m_indexof_decl(0),
m_indexof2_decl(0),
+ m_lastindexof_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -51,6 +52,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_contains_decl);
DEC_REF(m_indexof_decl);
DEC_REF(m_indexof2_decl);
+ DEC_REF(m_lastindexof_decl);
DEC_REF(m_int_sort);
}
@@ -101,6 +103,9 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_indexof2_decl = m->mk_func_decl(symbol("Indexof2"), 3, d, i, func_decl_info(id, OP_STR_INDEXOF2));
m_manager->inc_ref(m_indexof2_decl);
}
+
+ m_lastindexof_decl = m->mk_func_decl(symbol("LastIndexof"), s, s, i, func_decl_info(id, OP_STR_LASTINDEXOF));
+ m_manager->inc_ref(m_lastindexof_decl);
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -124,6 +129,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STR_CONTAINS: return m_contains_decl;
case OP_STR_INDEXOF: return m_indexof_decl;
case OP_STR_INDEXOF2: return m_indexof2_decl;
+ case OP_STR_LASTINDEXOF: return m_lastindexof_decl;
default: return 0;
}
}
@@ -186,6 +192,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("Contains", OP_STR_CONTAINS));
op_names.push_back(builtin_name("Indexof", OP_STR_INDEXOF));
op_names.push_back(builtin_name("Indexof2", OP_STR_INDEXOF2));
+ op_names.push_back(builtin_name("LastIndexof", OP_STR_LASTINDEXOF));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 54762f6b9..3e9a1d8f5 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -37,6 +37,7 @@ enum str_op_kind {
OP_STR_CONTAINS,
OP_STR_INDEXOF,
OP_STR_INDEXOF2,
+ OP_STR_LASTINDEXOF,
// end
LAST_STR_OP
};
@@ -55,6 +56,7 @@ protected:
func_decl * m_contains_decl;
func_decl * m_indexof_decl;
func_decl * m_indexof2_decl;
+ func_decl * m_lastindexof_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
From be5bf7fb803a036a3b129b90d1cc88c4240493db Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 15 Jun 2016 18:45:01 -0400
Subject: [PATCH 121/401] LastIndexof support
---
src/smt/theory_str.cpp | 80 +++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 4 +++
2 files changed, 83 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a5244f7bb..727048c11 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -611,7 +611,7 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
bool theory_str::can_propagate() {
return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty()
|| !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty() || !m_axiom_EndsWith_todo.empty()
- || !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty()
+ || !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty() || !m_axiom_LastIndexof_todo.empty()
;
}
@@ -665,6 +665,11 @@ void theory_str::propagate() {
instantiate_axiom_Indexof2(m_axiom_Indexof2_todo[i]);
}
m_axiom_Indexof2_todo.reset();
+
+ for (unsigned i = 0; i < m_axiom_LastIndexof_todo.size(); ++i) {
+ instantiate_axiom_LastIndexof(m_axiom_LastIndexof_todo[i]);
+ }
+ m_axiom_LastIndexof_todo.reset();
}
}
@@ -1076,6 +1081,75 @@ void theory_str::instantiate_axiom_Indexof2(enode * e) {
assert_axiom(reduceTerm);
}
+void theory_str::instantiate_axiom_LastIndexof(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("t_str_detail", tout << "already set up LastIndexof axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("t_str_detail", tout << "instantiate LastIndexof axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref x1(mk_str_var("x1"), m);
+ expr_ref x2(mk_str_var("x2"), m);
+ expr_ref indexAst(mk_int_var("index"), m);
+ expr_ref_vector items(m);
+
+ // args[0] = x1 . args[1] . x2
+ expr_ref eq1(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x1, mk_concat(expr->get_arg(1), x2))), m);
+ expr_ref arg0HasArg1(mk_contains(expr->get_arg(0), expr->get_arg(1)), m); // arg0HasArg1 = Contains(args[0], args[1])
+ items.push_back(ctx.mk_eq_atom(arg0HasArg1, eq1));
+
+
+ expr_ref condAst(arg0HasArg1, m);
+ //----------------------------
+ // true branch
+ expr_ref_vector thenItems(m);
+ thenItems.push_back(m_autil.mk_ge(indexAst, mk_int(0)));
+ // args[0] = x1 . args[1] . x2
+ // x1 doesn't contain args[1]
+ thenItems.push_back(m.mk_not(mk_contains(x2, expr->get_arg(1))));
+ thenItems.push_back(ctx.mk_eq_atom(indexAst, mk_strlen(x1)));
+
+ bool canSkip = false;
+ if (m_strutil.is_string(expr->get_arg(1))) {
+ std::string arg1Str = m_strutil.get_string_constant_value(expr->get_arg(1));
+ if (arg1Str.length() == 1) {
+ canSkip = true;
+ }
+ }
+
+ if (!canSkip) {
+ // args[0] = x3 . x4 /\ |x3| = |x1| + 1 /\ ! contains(x4, args[1])
+ expr_ref x3(mk_str_var("x3"), m);
+ expr_ref x4(mk_str_var("x4"), m);
+ expr_ref tmpLen(m_autil.mk_add(indexAst, mk_int(1)), m);
+ thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x3, x4)));
+ thenItems.push_back(ctx.mk_eq_atom(mk_strlen(x3), tmpLen));
+ thenItems.push_back(m.mk_not(mk_contains(x4, expr->get_arg(1))));
+ }
+ //----------------------------
+ // else branch
+ expr_ref_vector elseItems(m);
+ elseItems.push_back(ctx.mk_eq_atom(indexAst, mk_int(-1)));
+
+ items.push_back(m.mk_ite(condAst, m.mk_and(thenItems.size(), thenItems.c_ptr()), m.mk_and(elseItems.size(), elseItems.c_ptr())));
+
+ expr_ref breakdownAssert(m.mk_and(items.size(), items.c_ptr()), m);
+ SASSERT(breakdownAssert);
+
+ expr_ref reduceToIndex(ctx.mk_eq_atom(expr, indexAst), m);
+ SASSERT(reduceToIndex);
+
+ expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToIndex), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
@@ -3850,6 +3924,10 @@ void theory_str::set_up_axioms(expr * ex) {
app * ap = to_app(ex);
if (is_Indexof(ap)) {
m_axiom_Indexof_todo.push_back(n);
+ } else if (is_Indexof2(ap)) {
+ m_axiom_Indexof2_todo.push_back(n);
+ } else if (is_LastIndexof(ap)) {
+ m_axiom_LastIndexof_todo.push_back(n);
}
}
} else {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index c652a3faf..70878b45f 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -114,6 +114,7 @@ namespace smt {
ptr_vector<enode> m_axiom_Contains_todo;
ptr_vector<enode> m_axiom_Indexof_todo;
ptr_vector<enode> m_axiom_Indexof2_todo;
+ ptr_vector<enode> m_axiom_LastIndexof_todo;
// hashtable of all exprs for which we've already set up term-specific axioms --
// this prevents infinite recursive descent with respect to axioms that
@@ -196,6 +197,8 @@ namespace smt {
bool is_Indexof(enode const * n) const { return is_Indexof(n->get_owner()); }
bool is_Indexof2(app const * a) const { return a->is_app_of(get_id(), OP_STR_INDEXOF2); }
bool is_Indexof2(enode const * n) const { return is_Indexof2(n->get_owner()); }
+ bool is_LastIndexof(app const * a) const { return a->is_app_of(get_id(), OP_STR_LASTINDEXOF); }
+ bool is_LastIndexof(enode const * n) const { return is_LastIndexof(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
@@ -207,6 +210,7 @@ namespace smt {
void instantiate_axiom_Contains(enode * e);
void instantiate_axiom_Indexof(enode * e);
void instantiate_axiom_Indexof2(enode * e);
+ void instantiate_axiom_LastIndexof(enode * e);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From fb20951064f2b67567598b987d681d1c68b92b8a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 15 Jun 2016 20:26:07 -0400
Subject: [PATCH 122/401] theory_str Substr support WIP
---
src/ast/str_decl_plugin.cpp | 10 +++++++++
src/ast/str_decl_plugin.h | 2 ++
src/smt/theory_str.cpp | 42 +++++++++++++++++++++++++++++++++++++
src/smt/theory_str.h | 4 ++++
4 files changed, 58 insertions(+)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index fbdb10263..7bd4ec154 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -33,6 +33,7 @@ str_decl_plugin::str_decl_plugin():
m_indexof_decl(0),
m_indexof2_decl(0),
m_lastindexof_decl(0),
+ m_substr_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -53,6 +54,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_indexof_decl);
DEC_REF(m_indexof2_decl);
DEC_REF(m_lastindexof_decl);
+ DEC_REF(m_substr_decl);
DEC_REF(m_int_sort);
}
@@ -106,6 +108,12 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_lastindexof_decl = m->mk_func_decl(symbol("LastIndexof"), s, s, i, func_decl_info(id, OP_STR_LASTINDEXOF));
m_manager->inc_ref(m_lastindexof_decl);
+
+ {
+ sort * d[3] = {s, i, i };
+ m_substr_decl = m->mk_func_decl(symbol("Substring"), 3, d, s, func_decl_info(id, OP_STR_SUBSTR));
+ m_manager->inc_ref(m_substr_decl);
+ }
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -130,6 +138,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STR_INDEXOF: return m_indexof_decl;
case OP_STR_INDEXOF2: return m_indexof2_decl;
case OP_STR_LASTINDEXOF: return m_lastindexof_decl;
+ case OP_STR_SUBSTR: return m_substr_decl;
default: return 0;
}
}
@@ -193,6 +202,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("Indexof", OP_STR_INDEXOF));
op_names.push_back(builtin_name("Indexof2", OP_STR_INDEXOF2));
op_names.push_back(builtin_name("LastIndexof", OP_STR_LASTINDEXOF));
+ op_names.push_back(builtin_name("Substring", OP_STR_SUBSTR));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 3e9a1d8f5..bd2a70a1e 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -38,6 +38,7 @@ enum str_op_kind {
OP_STR_INDEXOF,
OP_STR_INDEXOF2,
OP_STR_LASTINDEXOF,
+ OP_STR_SUBSTR,
// end
LAST_STR_OP
};
@@ -57,6 +58,7 @@ protected:
func_decl * m_indexof_decl;
func_decl * m_indexof2_decl;
func_decl * m_lastindexof_decl;
+ func_decl * m_substr_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 727048c11..4f04ede23 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -612,6 +612,7 @@ bool theory_str::can_propagate() {
return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty()
|| !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty() || !m_axiom_EndsWith_todo.empty()
|| !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty() || !m_axiom_LastIndexof_todo.empty()
+ || !m_axiom_Substr_todo.empty()
;
}
@@ -670,6 +671,11 @@ void theory_str::propagate() {
instantiate_axiom_LastIndexof(m_axiom_LastIndexof_todo[i]);
}
m_axiom_LastIndexof_todo.reset();
+
+ for (unsigned i = 0; i < m_axiom_Substr_todo.size(); ++i) {
+ instantiate_axiom_Substr(m_axiom_Substr_todo[i]);
+ }
+ m_axiom_Substr_todo.reset();
}
}
@@ -1150,6 +1156,42 @@ void theory_str::instantiate_axiom_LastIndexof(enode * e) {
assert_axiom(finalAxiom);
}
+void theory_str::instantiate_axiom_Substr(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("t_str_detail", tout << "already set up Substr axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("t_str_detail", tout << "instantiate Substr axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref ts0(mk_str_var("ts0"), m);
+ expr_ref ts1(mk_str_var("ts1"), m);
+ expr_ref ts2(mk_str_var("ts2"), m);
+
+ expr_ref ts0_contains_ts1(mk_contains(expr->get_arg(0), ts1), m);
+
+ expr_ref_vector and_item(m);
+ and_item.push_back(ts0_contains_ts1);
+ and_item.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, mk_concat(ts1, ts2))));
+ and_item.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_strlen(ts0)));
+ and_item.push_back(ctx.mk_eq_atom(expr->get_arg(2), mk_strlen(ts1)));
+
+ expr_ref breakdownAssert(m.mk_and(and_item.size(), and_item.c_ptr()), m);
+ SASSERT(breakdownAssert);
+
+ expr_ref reduceToVar(ctx.mk_eq_atom(expr, ts1), m);
+ SASSERT(reduceToVar);
+
+ expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToVar), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 70878b45f..35a6fe91b 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -115,6 +115,7 @@ namespace smt {
ptr_vector<enode> m_axiom_Indexof_todo;
ptr_vector<enode> m_axiom_Indexof2_todo;
ptr_vector<enode> m_axiom_LastIndexof_todo;
+ ptr_vector<enode> m_axiom_Substr_todo;
// hashtable of all exprs for which we've already set up term-specific axioms --
// this prevents infinite recursive descent with respect to axioms that
@@ -199,6 +200,8 @@ namespace smt {
bool is_Indexof2(enode const * n) const { return is_Indexof2(n->get_owner()); }
bool is_LastIndexof(app const * a) const { return a->is_app_of(get_id(), OP_STR_LASTINDEXOF); }
bool is_LastIndexof(enode const * n) const { return is_LastIndexof(n->get_owner()); }
+ bool is_Substr(app const * a) const { return a->is_app_of(get_id(), OP_STR_SUBSTR); }
+ bool is_Substr(enode const * n) const { return is_Substr(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
@@ -211,6 +214,7 @@ namespace smt {
void instantiate_axiom_Indexof(enode * e);
void instantiate_axiom_Indexof2(enode * e);
void instantiate_axiom_LastIndexof(enode * e);
+ void instantiate_axiom_Substr(enode * e);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From 5b3c868c904065a84f00eb3042c20e0e851c2064 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 15 Jun 2016 21:14:54 -0400
Subject: [PATCH 123/401] theory_str Replace method
---
src/ast/rewriter/str_rewriter.cpp | 25 +++++++++
src/ast/rewriter/str_rewriter.h | 1 +
src/ast/str_decl_plugin.cpp | 10 ++++
src/ast/str_decl_plugin.h | 2 +
src/smt/theory_str.cpp | 87 +++++++++++++++++++++++++++----
src/smt/theory_str.h | 4 ++
6 files changed, 118 insertions(+), 11 deletions(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index c4f2e634e..8dc02cc09 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -176,6 +176,28 @@ br_status str_rewriter::mk_str_LastIndexof(expr * haystack, expr * needle, expr_
}
}
+br_status str_rewriter::mk_str_Replace(expr * base, expr * source, expr * target, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (Replace " << mk_pp(base, m()) << " " << mk_pp(source, m()) << " " << mk_pp(target, m()) << ")" << std::endl;);
+ if (m_strutil.is_string(base) && m_strutil.is_string(source) && m_strutil.is_string(target)) {
+ std::string arg0Str = m_strutil.get_string_constant_value(base);
+ std::string arg1Str = m_strutil.get_string_constant_value(source);
+ std::string arg2Str = m_strutil.get_string_constant_value(target);
+ if (arg0Str.find(arg1Str) != std::string::npos) {
+ int index1 = arg0Str.find(arg1Str);
+ int index2 = index1 + arg1Str.length();
+ std::string substr0 = arg0Str.substr(0, index1);
+ std::string substr2 = arg0Str.substr(index2);
+ std::string replaced = substr0 + arg2Str + substr2;
+ result = m_strutil.mk_string(replaced);
+ } else {
+ result = base;
+ }
+ return BR_DONE;
+ } else {
+ return BR_FAILED;
+ }
+}
+
br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
SASSERT(f->get_family_id() == get_fid());
@@ -204,6 +226,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_LASTINDEXOF:
SASSERT(num_args == 2);
return mk_str_LastIndexof(args[0], args[1], result);
+ case OP_STR_REPLACE:
+ SASSERT(num_args == 3);
+ return mk_str_Replace(args[0], args[1], args[2], result);
default:
return BR_FAILED;
}
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index de399acba..69a7c9579 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -47,6 +47,7 @@ public:
br_status mk_str_Indexof(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_Indexof2(expr * arg0, expr * arg1, expr * arg2, expr_ref & result);
br_status mk_str_LastIndexof(expr * haystack, expr * needle, expr_ref & result);
+ br_status mk_str_Replace(expr * base, expr * source, expr * target, expr_ref & result);
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 7bd4ec154..526b02f64 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -34,6 +34,7 @@ str_decl_plugin::str_decl_plugin():
m_indexof2_decl(0),
m_lastindexof_decl(0),
m_substr_decl(0),
+ m_replace_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -55,6 +56,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_indexof2_decl);
DEC_REF(m_lastindexof_decl);
DEC_REF(m_substr_decl);
+ DEC_REF(m_replace_decl);
DEC_REF(m_int_sort);
}
@@ -114,6 +116,12 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_substr_decl = m->mk_func_decl(symbol("Substring"), 3, d, s, func_decl_info(id, OP_STR_SUBSTR));
m_manager->inc_ref(m_substr_decl);
}
+
+ {
+ sort * d[3] = {s, s, s};
+ m_replace_decl = m->mk_func_decl(symbol("Replace"), 3, d, s, func_decl_info(id, OP_STR_REPLACE));
+ m_manager->inc_ref(m_replace_decl);
+ }
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -139,6 +147,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STR_INDEXOF2: return m_indexof2_decl;
case OP_STR_LASTINDEXOF: return m_lastindexof_decl;
case OP_STR_SUBSTR: return m_substr_decl;
+ case OP_STR_REPLACE: return m_replace_decl;
default: return 0;
}
}
@@ -203,6 +212,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("Indexof2", OP_STR_INDEXOF2));
op_names.push_back(builtin_name("LastIndexof", OP_STR_LASTINDEXOF));
op_names.push_back(builtin_name("Substring", OP_STR_SUBSTR));
+ op_names.push_back(builtin_name("Replace", OP_STR_REPLACE));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index bd2a70a1e..ee2432c50 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -39,6 +39,7 @@ enum str_op_kind {
OP_STR_INDEXOF2,
OP_STR_LASTINDEXOF,
OP_STR_SUBSTR,
+ OP_STR_REPLACE,
// end
LAST_STR_OP
};
@@ -59,6 +60,7 @@ protected:
func_decl * m_indexof2_decl;
func_decl * m_lastindexof_decl;
func_decl * m_substr_decl;
+ func_decl * m_replace_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 4f04ede23..1e2107f11 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -612,7 +612,7 @@ bool theory_str::can_propagate() {
return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty()
|| !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty() || !m_axiom_EndsWith_todo.empty()
|| !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty() || !m_axiom_LastIndexof_todo.empty()
- || !m_axiom_Substr_todo.empty()
+ || !m_axiom_Substr_todo.empty() || !m_axiom_Replace_todo.empty()
;
}
@@ -676,6 +676,11 @@ void theory_str::propagate() {
instantiate_axiom_Substr(m_axiom_Substr_todo[i]);
}
m_axiom_Substr_todo.reset();
+
+ for (unsigned i = 0; i < m_axiom_Replace_todo.size(); ++i) {
+ instantiate_axiom_Replace(m_axiom_Replace_todo[i]);
+ }
+ m_axiom_Replace_todo.reset();
}
}
@@ -1192,6 +1197,56 @@ void theory_str::instantiate_axiom_Substr(enode * e) {
assert_axiom(finalAxiom);
}
+void theory_str::instantiate_axiom_Replace(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("t_str_detail", tout << "already set up Replace axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("t_str_detail", tout << "instantiate Replace axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref x1(mk_str_var("x1"), m);
+ expr_ref x2(mk_str_var("x2"), m);
+ expr_ref i1(mk_int_var("i1"), m);
+ expr_ref result(mk_str_var("result"), m);
+
+ // condAst = Contains(args[0], args[1])
+ expr_ref condAst(mk_contains(expr->get_arg(0), expr->get_arg(1)), m);
+ // -----------------------
+ // true branch
+ expr_ref_vector thenItems(m);
+ // args[0] = x1 . args[1] . x2
+ thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x1, mk_concat(expr->get_arg(1), x2))));
+ // i1 = |x1|
+ thenItems.push_back(ctx.mk_eq_atom(i1, mk_strlen(x1)));
+ // args[0] = x3 . x4 /\ |x3| = |x1| + |args[1]| - 1 /\ ! contains(x3, args[1])
+ expr_ref x3(mk_str_var("x3"), m);
+ expr_ref x4(mk_str_var("x4"), m);
+ expr_ref tmpLen(m_autil.mk_add(i1, mk_strlen(expr->get_arg(1)), mk_int(-1)), m);
+ thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x3, x4)));
+ thenItems.push_back(ctx.mk_eq_atom(mk_strlen(x3), tmpLen));
+ thenItems.push_back(m.mk_not(mk_contains(x3, expr->get_arg(1))));
+ thenItems.push_back(ctx.mk_eq_atom(result, mk_concat(x1, mk_concat(expr->get_arg(2), x2))));
+ // -----------------------
+ // false branch
+ expr_ref elseBranch(ctx.mk_eq_atom(result, expr->get_arg(0)), m);
+
+ expr_ref breakdownAssert(m.mk_ite(condAst, m.mk_and(thenItems.size(), thenItems.c_ptr()), elseBranch), m);
+ SASSERT(breakdownAssert);
+
+ expr_ref reduceToResult(ctx.mk_eq_atom(expr, result), m);
+ SASSERT(reduceToResult);
+
+ expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToResult), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
@@ -3928,6 +3983,10 @@ void theory_str::set_up_axioms(expr * ex) {
}
} else if (is_CharAt(ap)) {
m_axiom_CharAt_todo.push_back(n);
+ } else if (is_Substr(ap)) {
+ m_axiom_Substr_todo.push_back(n);
+ } else if (is_Replace(ap)) {
+ m_axiom_Replace_todo.push_back(n);
} else if (ap->get_num_args() == 0 && !is_string(ap)) {
// if ex is a variable, add it to our list of variables
TRACE("t_str_detail", tout << "tracking variable " << mk_ismt2_pp(ap, get_manager()) << std::endl;);
@@ -3942,18 +4001,24 @@ void theory_str::set_up_axioms(expr * ex) {
TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
": expr is of sort Bool" << std::endl;);
// set up axioms for boolean terms
- enode * n = ctx.get_enode(ex);
- SASSERT(n);
- if (is_app(ex)) {
- app * ap = to_app(ex);
- if (is_StartsWith(ap)) {
- m_axiom_StartsWith_todo.push_back(n);
- } else if (is_EndsWith(ap)) {
- m_axiom_EndsWith_todo.push_back(n);
- } else if (is_Contains(ap)) {
- m_axiom_Contains_todo.push_back(n);
+ if (ctx.e_internalized(ex)) {
+ enode * n = ctx.get_enode(ex);
+ SASSERT(n);
+
+ if (is_app(ex)) {
+ app * ap = to_app(ex);
+ if (is_StartsWith(ap)) {
+ m_axiom_StartsWith_todo.push_back(n);
+ } else if (is_EndsWith(ap)) {
+ m_axiom_EndsWith_todo.push_back(n);
+ } else if (is_Contains(ap)) {
+ m_axiom_Contains_todo.push_back(n);
+ }
}
+ } else {
+ TRACE("t_str_detail", tout << "WARNING: Bool term " << mk_ismt2_pp(ex, get_manager()) << " not internalized. Skipping to prevent a crash." << std::endl;);
+ return;
}
} else if (ex_sort == int_sort) {
TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 35a6fe91b..7ee1d4281 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -116,6 +116,7 @@ namespace smt {
ptr_vector<enode> m_axiom_Indexof2_todo;
ptr_vector<enode> m_axiom_LastIndexof_todo;
ptr_vector<enode> m_axiom_Substr_todo;
+ ptr_vector<enode> m_axiom_Replace_todo;
// hashtable of all exprs for which we've already set up term-specific axioms --
// this prevents infinite recursive descent with respect to axioms that
@@ -202,6 +203,8 @@ namespace smt {
bool is_LastIndexof(enode const * n) const { return is_LastIndexof(n->get_owner()); }
bool is_Substr(app const * a) const { return a->is_app_of(get_id(), OP_STR_SUBSTR); }
bool is_Substr(enode const * n) const { return is_Substr(n->get_owner()); }
+ bool is_Replace(app const * a) const { return a->is_app_of(get_id(), OP_STR_REPLACE); }
+ bool is_Replace(enode const * n) const { return is_Replace(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
@@ -215,6 +218,7 @@ namespace smt {
void instantiate_axiom_Indexof2(enode * e);
void instantiate_axiom_LastIndexof(enode * e);
void instantiate_axiom_Substr(enode * e);
+ void instantiate_axiom_Replace(enode * e);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From 89a337ba7eac310745fc1e475ba3e7b59e2274ac Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 19 Jun 2016 18:25:31 -0400
Subject: [PATCH 124/401] quick path with string-integer integration in
theory_str::simplify_concat_equality
---
src/smt/theory_str.cpp | 74 ++++++++++++++++++++----------------------
1 file changed, 36 insertions(+), 38 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 1e2107f11..56b86885b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1733,17 +1733,12 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
expr * a2_arg0 = a_nn2->get_arg(0);
expr * a2_arg1 = a_nn2->get_arg(1);
- // TODO
- /*
- int a1_arg0_len = getLenValue(t, a1_arg0);
- int a1_arg1_len = getLenValue(t, a1_arg1);
- int a2_arg0_len = getLenValue(t, a2_arg0);
- int a2_arg1_len = getLenValue(t, a2_arg1);
- */
- int a1_arg0_len = -1;
- int a1_arg1_len = -1;
- int a2_arg0_len = -1;
- int a2_arg1_len = -1;
+ rational a1_arg0_len, a1_arg1_len, a2_arg0_len, a2_arg1_len;
+
+ bool a1_arg0_len_exists = get_len_value(a1_arg0, a1_arg0_len);
+ bool a1_arg1_len_exists = get_len_value(a1_arg1, a1_arg1_len);
+ bool a2_arg0_len_exists = get_len_value(a2_arg0, a2_arg0_len);
+ bool a2_arg1_len_exists = get_len_value(a2_arg1, a2_arg1_len);
TRACE("t_str", tout << "nn1 = " << mk_ismt2_pp(nn1, m) << std::endl
<< "nn2 = " << mk_ismt2_pp(nn2, m) << std::endl;);
@@ -1797,35 +1792,38 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
}
}
- // TODO quick path 1-2
- /*
- if(a1_arg0_len != -1 && a2_arg0_len != -1 && a1_arg0_len == a2_arg0_len){
- if (! inSameEqc(t, a1_arg0, a2_arg0)) {
- __debugPrint(logFile, ">> [simplifyConcatEq] Quick Path 2-1: len(nn1.arg0) == len(nn2.arg0)\n");
- Z3_ast ax_l1 = Z3_mk_eq(ctx, nn1, nn2);
- Z3_ast ax_l2 = Z3_mk_eq(ctx, mk_length(t, a1_arg0), mk_length(t, a2_arg0));
- Z3_ast ax_r1 = Z3_mk_eq(ctx, a1_arg0, a2_arg0);
- Z3_ast ax_r2 = Z3_mk_eq(ctx, a1_arg1, a2_arg1);
- Z3_ast toAdd = Z3_mk_implies(ctx, mk_2_and(t, ax_l1, ax_l2), mk_2_and(t, ax_r1, ax_r2));
- addAxiom(t, toAdd, __LINE__);
- return;
- }
- }
+ // quick path 2-1
+ if (a1_arg0_len_exists && a2_arg0_len_exists && a1_arg0_len == a2_arg0_len) {
+ if (!in_same_eqc(a1_arg0, a2_arg0)) {
+ TRACE("t_str_detail", tout << "quick path 2-1: len(nn1.arg0) == len(nn2.arg0)" << std::endl;);
+ expr_ref ax_l1(ctx.mk_eq_atom(nn1, nn2), m);
+ expr_ref ax_l2(ctx.mk_eq_atom(mk_strlen(a1_arg0), mk_strlen(a2_arg0)), m);
+ expr_ref ax_r1(ctx.mk_eq_atom(a1_arg0, a2_arg0), m);
+ expr_ref ax_r2(ctx.mk_eq_atom(a1_arg1, a2_arg1), m);
- if (a1_arg1_len != -1 && a2_arg1_len != -1 && a1_arg1_len == a2_arg1_len)
- {
- if (!inSameEqc(t, a1_arg1, a2_arg1)) {
- __debugPrint(logFile, ">> [simplifyConcatEq] Quick Path 2-2: len(nn1.arg1) == len(nn2.arg1)\n");
- Z3_ast ax_l1 = Z3_mk_eq(ctx, nn1, nn2);
- Z3_ast ax_l2 = Z3_mk_eq(ctx, mk_length(t, a1_arg1), mk_length(t, a2_arg1));
- Z3_ast ax_r1 = Z3_mk_eq(ctx, a1_arg0, a2_arg0);
- Z3_ast ax_r2 = Z3_mk_eq(ctx, a1_arg1, a2_arg1);
- Z3_ast toAdd = Z3_mk_implies(ctx, mk_2_and(t, ax_l1, ax_l2), mk_2_and(t, ax_r1, ax_r2));
- addAxiom(t, toAdd, __LINE__);
- return;
+ expr_ref premise(m.mk_and(ax_l1, ax_l2), m);
+ expr_ref conclusion(m.mk_and(ax_r1, ax_r2), m);
+
+ assert_implication(premise, conclusion);
+ return;
+ }
+ }
+
+ if (a1_arg1_len_exists && a2_arg1_len_exists && a1_arg1_len == a2_arg1_len) {
+ if (!in_same_eqc(a1_arg1, a2_arg1)) {
+ TRACE("t_str_detail", tout << "quick path 2-2: len(nn1.arg1) == len(nn2.arg1)" << std::endl;);
+ expr_ref ax_l1(ctx.mk_eq_atom(nn1, nn2), m);
+ expr_ref ax_l2(ctx.mk_eq_atom(mk_strlen(a1_arg1), mk_strlen(a2_arg1)), m);
+ expr_ref ax_r1(ctx.mk_eq_atom(a1_arg0, a2_arg0), m);
+ expr_ref ax_r2(ctx.mk_eq_atom(a1_arg1, a2_arg1), m);
+
+ expr_ref premise(m.mk_and(ax_l1, ax_l2), m);
+ expr_ref conclusion(m.mk_and(ax_r1, ax_r2), m);
+
+ assert_implication(premise, conclusion);
+ return;
+ }
}
- }
- */
expr * new_nn1 = simplify_concat(nn1);
expr * new_nn2 = simplify_concat(nn2);
From ba42478f9b229154f883abb85c8e59aff13e9c2d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 20 Jun 2016 20:02:22 -0400
Subject: [PATCH 125/401] string-integer wip
---
src/smt/theory_str.cpp | 60 +++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 2 ++
2 files changed, 61 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 56b86885b..15e202409 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1716,6 +1716,64 @@ expr * theory_str::simplify_concat(expr * node) {
}
+void theory_str::infer_len_concat_equality(expr * nn1, expr * nn2) {
+ rational nnLen;
+ bool nnLen_exists = get_len_value(nn1, nnLen);
+ if (!nnLen_exists) {
+ nnLen_exists = get_len_value(nn2, nnLen);
+ }
+
+ // case 1:
+ // Known: a1_arg0 and a1_arg1
+ // Unknown: nn1
+
+ if (is_concat(to_app(nn1))) {
+ rational nn1ConcatLen;
+ bool nn1ConcatLen_exists = infer_len_concat(nn1, nn1ConcatLen);
+ if (nnLen_exists && nn1ConcatLen_exists) {
+ nnLen = nn1ConcatLen;
+ }
+ }
+
+ // case 2:
+ // Known: a1_arg0 and a1_arg1
+ // Unknown: nn1
+
+ if (is_concat(to_app(nn2))) {
+ rational nn2ConcatLen;
+ bool nn2ConcatLen_exists = infer_len_concat(nn2, nn2ConcatLen);
+ if (nnLen_exists && nn2ConcatLen_exists) {
+ nnLen = nn2ConcatLen;
+ }
+ }
+
+ if (nnLen_exists) {
+ if (is_concat(to_app(nn1))) {
+ infer_len_concat_arg(nn1, nnLen);
+ }
+ if (is_concat(to_app(nn2))) {
+ infer_len_concat_arg(nn2, nnLen);
+ }
+ }
+
+ /*
+ if (isConcatFunc(t, nn2)) {
+ int nn2ConcatLen = inferLenConcat(t, nn2);
+ if (nnLen == -1 && nn2ConcatLen != -1)
+ nnLen = nn2ConcatLen;
+ }
+
+ if (nnLen != -1) {
+ if (isConcatFunc(t, nn1)) {
+ inferLenConcatArg(t, nn1, nnLen);
+ }
+ if (isConcatFunc(t, nn2)) {
+ inferLenConcatArg(t, nn2, nnLen);
+ }
+ }
+ */
+}
+
/*
* Handle two equivalent Concats.
*/
@@ -1743,7 +1801,7 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
TRACE("t_str", tout << "nn1 = " << mk_ismt2_pp(nn1, m) << std::endl
<< "nn2 = " << mk_ismt2_pp(nn2, m) << std::endl;);
- // TODO inferLenConcatEq(nn1, nn2);
+ infer_len_concat_equality(nn1, nn2);
if (a1_arg0 == a2_arg0) {
if (!in_same_eqc(a1_arg1, a2_arg1)) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 7ee1d4281..41091f64b 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -244,6 +244,8 @@ namespace smt {
void simplify_concat_equality(expr * lhs, expr * rhs);
void solve_concat_eq_str(expr * concat, expr * str);
+ void infer_len_concat_equality(expr * nn1, expr * nn2);
+
bool is_concat_eq_type1(expr * concatAst1, expr * concatAst2);
bool is_concat_eq_type2(expr * concatAst1, expr * concatAst2);
bool is_concat_eq_type3(expr * concatAst1, expr * concatAst2);
From 1e46782392cc67428e334548f2827aa731b07fbd Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 21 Jun 2016 17:25:28 -0400
Subject: [PATCH 126/401] theory_str infer_len_concat
---
src/smt/theory_str.cpp | 40 ++++++++++++++++++++++++++++++++++++++++
src/smt/theory_str.h | 1 +
2 files changed, 41 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 15e202409..a747ce12d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1716,6 +1716,46 @@ expr * theory_str::simplify_concat(expr * node) {
}
+// Modified signature of Z3str2's inferLenConcat().
+// Returns true iff nLen can be inferred by this method
+// (i.e. the equivalent of a len_exists flag in get_len_value()).
+
+bool theory_str::infer_len_concat(expr * n, rational & nLen) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ expr * arg0 = to_app(n)->get_arg(0);
+ expr * arg1 = to_app(n)->get_arg(1);
+
+ rational arg0_len, arg1_len;
+ bool arg0_len_exists = get_len_value(arg0, arg0_len);
+ bool arg1_len_exists = get_len_value(arg1, arg1_len);
+ rational tmp_len;
+ bool nLen_exists = get_len_value(n, tmp_len);
+
+ if (arg0_len_exists && arg1_len_exists && !nLen_exists) {
+ expr_ref_vector l_items(m);
+ // if (mk_strlen(arg0) != mk_int(arg0_len)) {
+ {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0_len)));
+ }
+
+ // if (mk_strlen(arg1) != mk_int(arg1_len)) {
+ {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1_len)));
+ }
+
+ expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
+ rational nnLen = arg0_len + arg1_len;
+ expr_ref axr(ctx.mk_eq_atom(mk_strlen(n), mk_int(nnLen)), m);
+ TRACE("t_str_detail", tout << "inferred (Length " << mk_pp(n, m) << ") = " << nnLen << std::endl;);
+ assert_implication(axl, axr);
+ nLen = nnLen;
+ return true;
+ } else {
+ return false;
+ }
+}
+
void theory_str::infer_len_concat_equality(expr * nn1, expr * nn2) {
rational nnLen;
bool nnLen_exists = get_len_value(nn1, nnLen);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 41091f64b..e3589d68d 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -245,6 +245,7 @@ namespace smt {
void solve_concat_eq_str(expr * concat, expr * str);
void infer_len_concat_equality(expr * nn1, expr * nn2);
+ bool infer_len_concat(expr * n, rational & nLen);
bool is_concat_eq_type1(expr * concatAst1, expr * concatAst2);
bool is_concat_eq_type2(expr * concatAst1, expr * concatAst2);
From a808a8c587d20fae4b130084b6779d6bdd589cb0 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 21 Jun 2016 17:38:49 -0400
Subject: [PATCH 127/401] theory_str infer_len_concat_arg
---
src/smt/theory_str.cpp | 55 ++++++++++++++++++++++++++++++++++++++++++
src/smt/theory_str.h | 1 +
2 files changed, 56 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a747ce12d..e8df17c58 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1756,6 +1756,61 @@ bool theory_str::infer_len_concat(expr * n, rational & nLen) {
}
}
+void theory_str::infer_len_concat_arg(expr * n, rational len) {
+ if (len.is_neg()) {
+ return;
+ }
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr * arg0 = to_app(n)->get_arg(0);
+ expr * arg1 = to_app(n)->get_arg(1);
+ rational arg0_len, arg1_len;
+ bool arg0_len_exists = get_len_value(arg0, arg0_len);
+ bool arg1_len_exists = get_len_value(arg1, arg1_len);
+
+ expr_ref_vector l_items(m);
+ expr_ref axr(m);
+ axr.reset();
+
+ // if (mk_length(t, n) != mk_int(ctx, len)) {
+ {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(len)));
+ }
+
+ if (!arg0_len_exists && arg1_len_exists) {
+ //if (mk_length(t, arg1) != mk_int(ctx, arg1_len)) {
+ {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1_len)));
+ }
+ rational arg0Len = len - arg1_len;
+ if (arg0Len.is_nonneg()) {
+ axr = ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0Len));
+ } else {
+ // TODO negate?
+ }
+ } else if (arg0_len_exists && !arg1_len_exists) {
+ //if (mk_length(t, arg0) != mk_int(ctx, arg0_len)) {
+ {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0_len)));
+ }
+ rational arg1Len = len - arg0_len;
+ if (arg1Len.is_nonneg()) {
+ axr = ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len));
+ } else {
+ // TODO negate?
+ }
+ } else {
+
+ }
+
+ if (axr) {
+ expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
+ assert_implication(axl, axr);
+ }
+}
+
void theory_str::infer_len_concat_equality(expr * nn1, expr * nn2) {
rational nnLen;
bool nnLen_exists = get_len_value(nn1, nnLen);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index e3589d68d..151dbc53f 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -246,6 +246,7 @@ namespace smt {
void infer_len_concat_equality(expr * nn1, expr * nn2);
bool infer_len_concat(expr * n, rational & nLen);
+ void infer_len_concat_arg(expr * n, rational len);
bool is_concat_eq_type1(expr * concatAst1, expr * concatAst2);
bool is_concat_eq_type2(expr * concatAst1, expr * concatAst2);
From 4c346298064c06fb10554477d14393e2d627ba2e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 21 Jun 2016 21:13:16 -0400
Subject: [PATCH 128/401] starting regex support, rewriter
---
src/ast/rewriter/str_rewriter.cpp | 27 +++++++++++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 3 +++
src/ast/str_decl_plugin.cpp | 23 +++++++++++++++++++++++
src/ast/str_decl_plugin.h | 10 ++++++++++
4 files changed, 63 insertions(+)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 8dc02cc09..3a0300ae4 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -198,6 +198,27 @@ br_status str_rewriter::mk_str_Replace(expr * base, expr * source, expr * target
}
}
+br_status str_rewriter::mk_re_Str2Reg(expr * str, expr_ref & result) {
+ // the argument to Str2Reg *must* be a string constant
+ // TODO is an assertion error too strict here? this basically crashes the solver
+ VERIFY(m_strutil.is_string(str));
+ return BR_FAILED;
+}
+
+br_status str_rewriter::mk_re_RegexIn(expr * str, expr * re, expr_ref & result) {
+ // fast path:
+ // (RegexIn E (Str2Reg S)) --> (= E S)
+ if (m_strutil.is_re_Str2Reg(re)) {
+ TRACE("t_str_rw", tout << "RegexIn fast path: " << mk_pp(str, m()) << " in " << mk_pp(re, m()) << std::endl;);
+ expr * regexStr = to_app(re)->get_arg(0);
+ VERIFY(m_strutil.is_string(regexStr));
+ result = m().mk_eq(str, regexStr);
+ return BR_REWRITE_FULL;
+ }
+
+ return BR_FAILED;
+}
+
br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
SASSERT(f->get_family_id() == get_fid());
@@ -229,6 +250,12 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_REPLACE:
SASSERT(num_args == 3);
return mk_str_Replace(args[0], args[1], args[2], result);
+ case OP_RE_STR2REGEX:
+ SASSERT(num_args == 1);
+ return mk_re_Str2Reg(args[0], result);
+ case OP_RE_REGEXIN:
+ SASSERT(num_args == 2);
+ return mk_re_RegexIn(args[0], args[1], result);
default:
return BR_FAILED;
}
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index 69a7c9579..5c0e1167f 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -49,6 +49,9 @@ public:
br_status mk_str_LastIndexof(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_Replace(expr * base, expr * source, expr * target, expr_ref & result);
+ br_status mk_re_Str2Reg(expr * str, expr_ref & result);
+ br_status mk_re_RegexIn(expr * str, expr * re, expr_ref & result);
+
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 526b02f64..7cd03fa16 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -24,6 +24,7 @@ Revision History:
str_decl_plugin::str_decl_plugin():
m_strv_sym("String"),
m_str_decl(0),
+ m_regex_decl(0),
m_concat_decl(0),
m_length_decl(0),
m_charat_decl(0),
@@ -35,6 +36,8 @@ str_decl_plugin::str_decl_plugin():
m_lastindexof_decl(0),
m_substr_decl(0),
m_replace_decl(0),
+ m_re_str2regex_decl(0),
+ m_re_regexin_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -46,6 +49,7 @@ str_decl_plugin::~str_decl_plugin(){
void str_decl_plugin::finalize(void) {
#define DEC_REF(decl) if (decl) { m_manager->dec_ref(decl); } ((void) 0)
DEC_REF(m_str_decl);
+ DEC_REF(m_regex_decl);
DEC_REF(m_concat_decl);
DEC_REF(m_length_decl);
DEC_REF(m_charat_decl);
@@ -57,6 +61,8 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_lastindexof_decl);
DEC_REF(m_substr_decl);
DEC_REF(m_replace_decl);
+ DEC_REF(m_re_str2regex_decl);
+ DEC_REF(m_re_regexin_decl);
DEC_REF(m_int_sort);
}
@@ -66,6 +72,10 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m->inc_ref(m_str_decl);
sort * s = m_str_decl;
+ m_regex_decl = m->mk_sort(symbol("Regex"), sort_info(id, REGEX_SORT));
+ m->inc_ref(m_regex_decl);
+ sort * re = m_regex_decl;
+
SASSERT(m_manager->has_plugin(symbol("arith")));
m_arith_fid = m_manager->mk_family_id("arith");
m_arith_plugin = static_cast<arith_decl_plugin*>(m_manager->get_plugin(m_arith_fid));
@@ -122,6 +132,13 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_replace_decl = m->mk_func_decl(symbol("Replace"), 3, d, s, func_decl_info(id, OP_STR_REPLACE));
m_manager->inc_ref(m_replace_decl);
}
+
+ m_re_str2regex_decl = m->mk_func_decl(symbol("Str2Reg"), s, re, func_decl_info(id, OP_RE_STR2REGEX));
+ m_manager->inc_ref(m_re_str2regex_decl);
+
+ m_re_regexin_decl = m->mk_func_decl(symbol("RegexIn"), s, re, boolT, func_decl_info(id, OP_RE_REGEXIN));
+ m_manager->inc_ref(m_re_regexin_decl);
+
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -131,6 +148,7 @@ decl_plugin * str_decl_plugin::mk_fresh() {
sort * str_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) {
switch (k) {
case STRING_SORT: return m_str_decl;
+ case REGEX_SORT: return m_regex_decl;
default: return 0;
}
}
@@ -148,6 +166,8 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STR_LASTINDEXOF: return m_lastindexof_decl;
case OP_STR_SUBSTR: return m_substr_decl;
case OP_STR_REPLACE: return m_replace_decl;
+ case OP_RE_STR2REGEX: return m_re_str2regex_decl;
+ case OP_RE_REGEXIN: return m_re_regexin_decl;
default: return 0;
}
}
@@ -213,10 +233,13 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("LastIndexof", OP_STR_LASTINDEXOF));
op_names.push_back(builtin_name("Substring", OP_STR_SUBSTR));
op_names.push_back(builtin_name("Replace", OP_STR_REPLACE));
+ op_names.push_back(builtin_name("Str2Reg", OP_RE_STR2REGEX));
+ op_names.push_back(builtin_name("RegexIn", OP_RE_REGEXIN));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
sort_names.push_back(builtin_name("String", STRING_SORT));
+ sort_names.push_back(builtin_name("Regex", REGEX_SORT));
}
bool str_decl_plugin::is_value(app * e) const {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index ee2432c50..496468e5a 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -23,6 +23,7 @@ Revision History:
enum str_sort_kind {
STRING_SORT,
+ REGEX_SORT,
};
enum str_op_kind {
@@ -40,6 +41,9 @@ enum str_op_kind {
OP_STR_LASTINDEXOF,
OP_STR_SUBSTR,
OP_STR_REPLACE,
+ // regular expression operators
+ OP_RE_STR2REGEX,
+ OP_RE_REGEXIN,
// end
LAST_STR_OP
};
@@ -48,6 +52,7 @@ class str_decl_plugin : public decl_plugin {
protected:
symbol m_strv_sym;
sort * m_str_decl;
+ sort * m_regex_decl;
func_decl * m_concat_decl;
func_decl * m_length_decl;
@@ -62,6 +67,9 @@ protected:
func_decl * m_substr_decl;
func_decl * m_replace_decl;
+ func_decl * m_re_str2regex_decl;
+ func_decl * m_re_regexin_decl;
+
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
sort * m_int_sort;
@@ -103,6 +111,8 @@ public:
bool is_string(expr const * n, const char ** val) const;
bool is_string(expr const * n) const;
+ bool is_re_Str2Reg(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_STR2REGEX); }
+
std::string get_string_constant_value(expr const *n) const;
// TODO
};
From 04803d7a3b5ec9e1eef2945648271880b73983e7 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 23 Jun 2016 15:24:35 -0400
Subject: [PATCH 129/401] starting regex support
---
src/ast/str_decl_plugin.cpp | 21 +++++++
src/ast/str_decl_plugin.h | 6 ++
src/smt/theory_str.cpp | 117 ++++++++++++++++++++++++++++++++++--
src/smt/theory_str.h | 18 ++++++
4 files changed, 157 insertions(+), 5 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 7cd03fa16..b140e11c3 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -38,6 +38,9 @@ str_decl_plugin::str_decl_plugin():
m_replace_decl(0),
m_re_str2regex_decl(0),
m_re_regexin_decl(0),
+ m_re_regexconcat_decl(0),
+ m_re_regexstar_decl(0),
+ m_re_regexunion_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -63,6 +66,9 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_replace_decl);
DEC_REF(m_re_str2regex_decl);
DEC_REF(m_re_regexin_decl);
+ DEC_REF(m_re_regexconcat_decl);
+ DEC_REF(m_re_regexstar_decl);
+ DEC_REF(m_re_regexunion_decl);
DEC_REF(m_int_sort);
}
@@ -139,6 +145,15 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_re_regexin_decl = m->mk_func_decl(symbol("RegexIn"), s, re, boolT, func_decl_info(id, OP_RE_REGEXIN));
m_manager->inc_ref(m_re_regexin_decl);
+ m_re_regexconcat_decl = m->mk_func_decl(symbol("RegexConcat"), re, re, re, func_decl_info(id, OP_RE_REGEXCONCAT));
+ m_manager->inc_ref(m_re_regexconcat_decl);
+
+ m_re_regexstar_decl = m->mk_func_decl(symbol("RegexStar"), re, re, func_decl_info(id, OP_RE_REGEXSTAR));
+ m_manager->inc_ref(m_re_regexstar_decl);
+
+ m_re_regexunion_decl = m->mk_func_decl(symbol("RegexUnion"), re, re, re, func_decl_info(id, OP_RE_REGEXUNION));
+ m_manager->inc_ref(m_re_regexunion_decl);
+
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -168,6 +183,9 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STR_REPLACE: return m_replace_decl;
case OP_RE_STR2REGEX: return m_re_str2regex_decl;
case OP_RE_REGEXIN: return m_re_regexin_decl;
+ case OP_RE_REGEXCONCAT: return m_re_regexconcat_decl;
+ case OP_RE_REGEXSTAR: return m_re_regexstar_decl;
+ case OP_RE_REGEXUNION: return m_re_regexunion_decl;
default: return 0;
}
}
@@ -235,6 +253,9 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("Replace", OP_STR_REPLACE));
op_names.push_back(builtin_name("Str2Reg", OP_RE_STR2REGEX));
op_names.push_back(builtin_name("RegexIn", OP_RE_REGEXIN));
+ op_names.push_back(builtin_name("RegexConcat", OP_RE_REGEXCONCAT));
+ op_names.push_back(builtin_name("RegexStar", OP_RE_REGEXSTAR));
+ op_names.push_back(builtin_name("RegexUnion", OP_RE_REGEXUNION));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 496468e5a..ccd2915af 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -44,6 +44,9 @@ enum str_op_kind {
// regular expression operators
OP_RE_STR2REGEX,
OP_RE_REGEXIN,
+ OP_RE_REGEXCONCAT,
+ OP_RE_REGEXSTAR,
+ OP_RE_REGEXUNION,
// end
LAST_STR_OP
};
@@ -69,6 +72,9 @@ protected:
func_decl * m_re_str2regex_decl;
func_decl * m_re_regexin_decl;
+ func_decl * m_re_regexconcat_decl;
+ func_decl * m_re_regexstar_decl;
+ func_decl * m_re_regexunion_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index e8df17c58..ab7bb13ef 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -479,6 +479,29 @@ app * theory_str::mk_str_var(std::string name) {
return a;
}
+app * theory_str::mk_regex_rep_var() {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ sort * string_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ app * a = m.mk_fresh_const("regex", string_sort);
+
+ ctx.internalize(a, false);
+ SASSERT(ctx.get_enode(a) != NULL);
+ SASSERT(ctx.e_internalized(a));
+ mk_var(ctx.get_enode(a));
+ m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
+
+ m_trail.push_back(a);
+ // TODO cross-check which variable sets we need
+ variable_set.insert(a);
+ //internal_variable_set.insert(a);
+ regex_variable_set.insert(a);
+ track_variable_scope(a);
+
+ return a;
+}
+
app * theory_str::mk_nonempty_str_var() {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -613,6 +636,7 @@ bool theory_str::can_propagate() {
|| !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty() || !m_axiom_EndsWith_todo.empty()
|| !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty() || !m_axiom_LastIndexof_todo.empty()
|| !m_axiom_Substr_todo.empty() || !m_axiom_Replace_todo.empty()
+ || !m_axiom_RegexIn_todo.empty()
;
}
@@ -681,6 +705,11 @@ void theory_str::propagate() {
instantiate_axiom_Replace(m_axiom_Replace_todo[i]);
}
m_axiom_Replace_todo.reset();
+
+ for (unsigned i = 0; i < m_axiom_RegexIn_todo.size(); ++i) {
+ instantiate_axiom_RegexIn(m_axiom_RegexIn_todo[i]);
+ }
+ m_axiom_RegexIn_todo.reset();
}
}
@@ -1247,6 +1276,84 @@ void theory_str::instantiate_axiom_Replace(enode * e) {
assert_axiom(finalAxiom);
}
+expr * theory_str::mk_RegexIn(expr * str, expr * regexp) {
+ expr * args[2] = {str, regexp};
+ app * regexIn = get_manager().mk_app(get_id(), OP_RE_REGEXIN, 0, 0, 2, args);
+ // immediately force internalization so that axiom setup does not fail
+ get_context().internalize(regexIn, false);
+ set_up_axioms(regexIn);
+ return regexIn;
+}
+
+void theory_str::instantiate_axiom_RegexIn(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("t_str_detail", tout << "already set up RegexIn axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("t_str_detail", tout << "instantiate RegexIn axiom for " << mk_pp(expr, m) << std::endl;);
+
+ // I don't think we need to port regexInBoolMap and regexInVarStrMap,
+ // but they would go here from reduce_regexIn
+
+ expr_ref str(expr->get_arg(0), m);
+ app * regex = to_app(expr->get_arg(1));
+
+ if (is_Str2Reg(regex)) {
+ expr_ref rxStr(regex->get_arg(0), m);
+ // want to assert 'expr IFF (str == rxStr)'
+ expr_ref rhs(ctx.mk_eq_atom(str, rxStr), m);
+ expr_ref finalAxiom(m.mk_iff(expr, rhs), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+ } else if (is_RegexConcat(regex)) {
+ expr_ref var1(mk_regex_rep_var(), m);
+ expr_ref var2(mk_regex_rep_var(), m);
+ expr_ref rhs(mk_concat(var1, var2), m);
+ expr_ref rx1(regex->get_arg(0), m);
+ expr_ref rx2(regex->get_arg(1), m);
+ expr_ref var1InRegex1(mk_RegexIn(var1, rx1), m);
+ expr_ref var2InRegex2(mk_RegexIn(var2, rx2), m);
+
+ expr_ref_vector items(m);
+ items.push_back(var1InRegex1);
+ items.push_back(var2InRegex2);
+ items.push_back(ctx.mk_eq_atom(expr, ctx.mk_eq_atom(str, rhs)));
+
+ expr_ref finalAxiom(mk_and(items), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+ /*
+ Z3_ast var1 = mk_regexRepVar(t);
+ Z3_ast var2 = mk_regexRepVar(t);
+ rhs = mk_concat(t, var1, var2);
+
+ Z3_ast regex1 = Z3_get_app_arg(ctx, arg1_func_app, 0);
+ Z3_ast regex2 = Z3_get_app_arg(ctx, arg1_func_app, 1);
+ Z3_ast var1InRegex1 = mk_2_arg_app(ctx, td->RegexIn, var1, regex1);
+ Z3_ast var2InRegex2 = mk_2_arg_app(ctx, td->RegexIn, var2, regex2);
+ std::vector<Z3_ast> items;
+ items.push_back(var1InRegex1);
+ items.push_back(var2InRegex2);
+ items.push_back(Z3_mk_eq(ctx, resBoolVar, Z3_mk_eq(ctx, args[0], rhs)));
+ extraAssert = mk_and_fromVector(t, items);
+ return resBoolVar;
+ */
+ } else if (is_RegexUnion(regex)) {
+
+ } else if (is_RegexStar(regex)) {
+
+ } else {
+ TRACE("t_str_detail", tout << "ERROR: unknown regex expression " << mk_pp(regex, m) << "!" << std::endl;);
+ NOT_IMPLEMENTED_YET();
+ }
+}
+
void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
@@ -4165,6 +4272,8 @@ void theory_str::set_up_axioms(expr * ex) {
m_axiom_EndsWith_todo.push_back(n);
} else if (is_Contains(ap)) {
m_axiom_Contains_todo.push_back(n);
+ } else if (is_RegexIn(ap)) {
+ m_axiom_RegexIn_todo.push_back(n);
}
}
} else {
@@ -4319,6 +4428,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
for (std::set<expr*>::iterator var_it = vars.begin(); var_it != vars.end(); ++var_it) {
variable_set.erase(*var_it);
internal_variable_set.erase(*var_it);
+ regex_variable_set.erase(*var_it);
count += 1;
}
TRACE("t_str_detail", tout << "cleaned up " << count << " variables" << std::endl;);
@@ -5994,13 +6104,10 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
for (std::map<expr*, int>::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) {
expr * freeVar = fvIt->first;
- /*
- std::string vName = std::string(Z3_ast_to_string(ctx, freeVar));
- if (vName.length() >= 9 && vName.substr(0, 9) == "$$_regVar") {
+ // skip all regular expression vars
+ if (regex_variable_set.find(freeVar) != regex_variable_set.end()) {
continue;
}
- */
- // TODO skip all regular expression vars
// Iterate the EQC of freeVar, its eqc variable should not be in the eqcRepSet.
// If found, have to filter it out
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 151dbc53f..9aead1105 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -117,6 +117,7 @@ namespace smt {
ptr_vector<enode> m_axiom_LastIndexof_todo;
ptr_vector<enode> m_axiom_Substr_todo;
ptr_vector<enode> m_axiom_Replace_todo;
+ ptr_vector<enode> m_axiom_RegexIn_todo;
// hashtable of all exprs for which we've already set up term-specific axioms --
// this prevents infinite recursive descent with respect to axioms that
@@ -135,6 +136,7 @@ namespace smt {
std::set<expr*> variable_set;
std::set<expr*> internal_variable_set;
+ std::set<expr*> regex_variable_set;
std::map<int, std::set<expr*> > internal_variable_scope_levels;
obj_hashtable<expr> internal_lenTest_vars;
@@ -180,6 +182,7 @@ namespace smt {
app * mk_nonempty_str_var();
app * mk_internal_xor_var();
expr * mk_internal_valTest_var(expr * node, int len, int vTries);
+ app * mk_regex_rep_var();
bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
@@ -206,6 +209,18 @@ namespace smt {
bool is_Replace(app const * a) const { return a->is_app_of(get_id(), OP_STR_REPLACE); }
bool is_Replace(enode const * n) const { return is_Replace(n->get_owner()); }
+ bool is_RegexIn(app const * a) const { return a->is_app_of(get_id(), OP_RE_REGEXIN); }
+ bool is_RegexIn(enode const * n) const { return is_RegexIn(n->get_owner()); }
+ bool is_RegexConcat(app const * a) const { return a->is_app_of(get_id(), OP_RE_REGEXCONCAT); }
+ bool is_RegexConcat(enode const * n) const { return is_RegexConcat(n->get_owner()); }
+ bool is_RegexStar(app const * a) const { return a->is_app_of(get_id(), OP_RE_REGEXSTAR); }
+ bool is_RegexStar(enode const * n) const { return is_RegexStar(n->get_owner()); }
+ bool is_RegexUnion(app const * a) const { return a->is_app_of(get_id(), OP_RE_REGEXUNION); }
+ bool is_RegexUnion(enode const * n) const { return is_RegexUnion(n->get_owner()); }
+ bool is_Str2Reg(app const * a) const { return a->is_app_of(get_id(), OP_RE_STR2REGEX); }
+ bool is_Str2Reg(enode const * n) const { return is_Str2Reg(n->get_owner()); }
+
+
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
void instantiate_str_eq_length_axiom(enode * lhs, enode * rhs);
@@ -220,6 +235,9 @@ namespace smt {
void instantiate_axiom_Substr(enode * e);
void instantiate_axiom_Replace(enode * e);
+ expr * mk_RegexIn(expr * str, expr * regexp);
+ void instantiate_axiom_RegexIn(enode * e);
+
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From 020e8aef6df7cbec0a19175a99385111289bbb4d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 23 Jun 2016 17:14:03 -0400
Subject: [PATCH 130/401] regex union
---
src/smt/theory_str.cpp | 29 ++++++++++++-----------------
1 file changed, 12 insertions(+), 17 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ab7bb13ef..46248abd2 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1328,26 +1328,21 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
expr_ref finalAxiom(mk_and(items), m);
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
- /*
- Z3_ast var1 = mk_regexRepVar(t);
- Z3_ast var2 = mk_regexRepVar(t);
- rhs = mk_concat(t, var1, var2);
-
- Z3_ast regex1 = Z3_get_app_arg(ctx, arg1_func_app, 0);
- Z3_ast regex2 = Z3_get_app_arg(ctx, arg1_func_app, 1);
- Z3_ast var1InRegex1 = mk_2_arg_app(ctx, td->RegexIn, var1, regex1);
- Z3_ast var2InRegex2 = mk_2_arg_app(ctx, td->RegexIn, var2, regex2);
- std::vector<Z3_ast> items;
+ } else if (is_RegexUnion(regex)) {
+ expr_ref var1(mk_regex_rep_var(), m);
+ expr_ref var2(mk_regex_rep_var(), m);
+ expr_ref orVar(m.mk_or(ctx.mk_eq_atom(str, var1), ctx.mk_eq_atom(str, var2)), m);
+ expr_ref regex1(regex->get_arg(0), m);
+ expr_ref regex2(regex->get_arg(1), m);
+ expr_ref var1InRegex1(mk_RegexIn(var1, regex1), m);
+ expr_ref var2InRegex2(mk_RegexIn(var2, regex2), m);
+ expr_ref_vector items(m);
items.push_back(var1InRegex1);
items.push_back(var2InRegex2);
- items.push_back(Z3_mk_eq(ctx, resBoolVar, Z3_mk_eq(ctx, args[0], rhs)));
- extraAssert = mk_and_fromVector(t, items);
- return resBoolVar;
- */
- } else if (is_RegexUnion(regex)) {
-
+ items.push_back(ctx.mk_eq_atom(expr, orVar));
+ assert_axiom(mk_and(items));
} else if (is_RegexStar(regex)) {
-
+ NOT_IMPLEMENTED_YET();
} else {
TRACE("t_str_detail", tout << "ERROR: unknown regex expression " << mk_pp(regex, m) << "!" << std::endl;);
NOT_IMPLEMENTED_YET();
From b31d1a92aa1627c45cb8d3708db292dfce3333a1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 27 Jun 2016 14:41:57 -0400
Subject: [PATCH 131/401] add more support for unroll (WIP)
---
src/ast/str_decl_plugin.cpp | 7 ++
src/ast/str_decl_plugin.h | 2 +
src/smt/theory_str.cpp | 150 +++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 9 ++-
4 files changed, 165 insertions(+), 3 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index b140e11c3..ef94272c7 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -41,6 +41,7 @@ str_decl_plugin::str_decl_plugin():
m_re_regexconcat_decl(0),
m_re_regexstar_decl(0),
m_re_regexunion_decl(0),
+ m_re_unroll_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -69,6 +70,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_re_regexconcat_decl);
DEC_REF(m_re_regexstar_decl);
DEC_REF(m_re_regexunion_decl);
+ DEC_REF(m_re_unroll_decl);
DEC_REF(m_int_sort);
}
@@ -154,6 +156,9 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_re_regexunion_decl = m->mk_func_decl(symbol("RegexUnion"), re, re, re, func_decl_info(id, OP_RE_REGEXUNION));
m_manager->inc_ref(m_re_regexunion_decl);
+ m_re_unroll_decl = m->mk_func_decl(symbol("Unroll"), re, i, s, func_decl_info(id, OP_RE_UNROLL));
+ m_manager->inc_ref(m_re_unroll_decl);
+
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -186,6 +191,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_RE_REGEXCONCAT: return m_re_regexconcat_decl;
case OP_RE_REGEXSTAR: return m_re_regexstar_decl;
case OP_RE_REGEXUNION: return m_re_regexunion_decl;
+ case OP_RE_UNROLL: return m_re_unroll_decl;
default: return 0;
}
}
@@ -256,6 +262,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("RegexConcat", OP_RE_REGEXCONCAT));
op_names.push_back(builtin_name("RegexStar", OP_RE_REGEXSTAR));
op_names.push_back(builtin_name("RegexUnion", OP_RE_REGEXUNION));
+ op_names.push_back(builtin_name("Unroll", OP_RE_UNROLL));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index ccd2915af..c2ad088a4 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -47,6 +47,7 @@ enum str_op_kind {
OP_RE_REGEXCONCAT,
OP_RE_REGEXSTAR,
OP_RE_REGEXUNION,
+ OP_RE_UNROLL,
// end
LAST_STR_OP
};
@@ -75,6 +76,7 @@ protected:
func_decl * m_re_regexconcat_decl;
func_decl * m_re_regexstar_decl;
func_decl * m_re_regexunion_decl;
+ func_decl * m_re_unroll_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 46248abd2..947c35f98 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -454,6 +454,10 @@ app * theory_str::mk_int_var(std::string name) {
return a;
}
+app * theory_str::mk_unroll_bound_var() {
+ return mk_int_var("unroll");
+}
+
app * theory_str::mk_str_var(std::string name) {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -545,6 +549,24 @@ app * theory_str::mk_nonempty_str_var() {
return a;
}
+app * theory_str::mk_unroll(expr * n, expr * bound) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr * args[2] = {n, bound};
+ app * unrollFunc = get_manager().mk_app(get_id(), OP_RE_UNROLL, 0, 0, 2, args);
+
+ expr_ref_vector items(m);
+ items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(bound, mk_int(0)), ctx.mk_eq_atom(unrollFunc, m_strutil.mk_string(""))));
+ items.push_back(m_autil.mk_ge(bound, mk_int(0)));
+ items.push_back(m_autil.mk_ge(mk_strlen(unrollFunc), mk_int(0)));
+
+ expr_ref finalAxiom(mk_and(items), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+ return unrollFunc;
+}
+
app * theory_str::mk_contains(expr * haystack, expr * needle) {
expr * args[2] = {haystack, needle};
app * contains = get_manager().mk_app(get_id(), OP_STR_CONTAINS, 0, 0, 2, args);
@@ -1342,7 +1364,16 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
items.push_back(ctx.mk_eq_atom(expr, orVar));
assert_axiom(mk_and(items));
} else if (is_RegexStar(regex)) {
- NOT_IMPLEMENTED_YET();
+ // slightly more complex due to the unrolling step.
+ expr_ref regex1(regex->get_arg(0), m);
+ expr_ref unrollCount(mk_unroll_bound_var(), m);
+ expr_ref unrollFunc(mk_unroll(regex1, unrollCount), m);
+ expr_ref_vector items(m);
+ items.push_back(ctx.mk_eq_atom(expr, ctx.mk_eq_atom(str, unrollFunc)));
+ items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(unrollCount, mk_int(0)), ctx.mk_eq_atom(unrollFunc, m_strutil.mk_string(""))));
+ expr_ref finalAxiom(mk_and(items), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
} else {
TRACE("t_str_detail", tout << "ERROR: unknown regex expression " << mk_pp(regex, m) << "!" << std::endl;);
NOT_IMPLEMENTED_YET();
@@ -3368,6 +3399,63 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
}
+void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ if (!is_Unroll(to_app(unrollFunc))) {
+ return;
+ }
+ if (!m_strutil.is_string(constStr)) {
+ return;
+ }
+
+ expr * funcInUnroll = to_app(unrollFunc)->get_arg(0);
+ std::string strValue = m_strutil.get_string_constant_value(constStr);
+
+ TRACE("t_str_detail", tout << "unrollFunc: " << mk_pp(unrollFunc, m) << std::endl
+ << "constStr: " << mk_pp(constStr, m) << std::endl;);
+
+ if (strValue == "") {
+ return;
+ }
+
+ if (is_Str2Reg(to_app(funcInUnroll))) {
+ unroll_str2reg_constStr(unrollFunc, constStr);
+ return;
+ }
+}
+
+void theory_str::unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr) {
+ context & ctx = get_context();
+ expr * str2RegFunc = to_app(unrollFunc)->get_arg(0);
+ expr * strInStr2RegFunc = to_app(str2RegFunc)->get_arg(0);
+ expr * oriCnt = to_app(unrollFunc)->get_arg(1);
+
+ // TODO NEXT
+ NOT_IMPLEMENTED_YET();
+
+ /*
+ Z3_context ctx = Z3_theory_get_context(t);
+ Z3_ast str2RegFunc = Z3_get_app_arg(ctx, Z3_to_app(ctx, unrollFunc), 0);
+ Z3_ast strInStr2RegFunc = Z3_get_app_arg(ctx, Z3_to_app(ctx, str2RegFunc), 0);
+ Z3_ast oriCnt = Z3_get_app_arg(ctx, Z3_to_app(ctx, unrollFunc), 1);
+
+ std::string strValue = getConstStrValue(t, eqConstStr);
+ std::string regStrValue = getConstStrValue(t, strInStr2RegFunc);
+ int strLen = strValue.length();
+ int regStrLen = regStrValue.length();
+ int cnt = strLen / regStrLen;
+
+ Z3_ast implyL = Z3_mk_eq(ctx, unrollFunc, eqConstStr);
+ Z3_ast implyR1 = Z3_mk_eq(ctx, oriCnt, mk_int(ctx, cnt));
+ Z3_ast implyR2 = Z3_mk_eq(ctx, mk_length(t, unrollFunc), mk_int(ctx, strLen));
+ Z3_ast toAssert = Z3_mk_implies(ctx, implyL, mk_2_and(t, implyR1, implyR2));
+
+ addAxiom(t, toAssert, __LINE__);
+ */
+}
+
/*
* Look through the equivalence class of n to find a string constant.
* Return that constant if it is found, and set hasEqcValue to true.
@@ -3392,6 +3480,26 @@ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
return n;
}
+void theory_str::get_eqc_all_unroll(expr * n, expr * & constStr, std::set<expr*> & unrollFuncSet) {
+ context & ctx = get_context();
+
+ constStr = NULL;
+ unrollFuncSet.clear();
+
+ // iterate over the eqc of 'n'
+ enode * n_enode = ctx.get_enode(n);
+ enode * e_curr = n_enode;
+ do {
+ app * curr = e_curr->get_owner();
+ if (m_strutil.is_string(curr)) {
+ constStr = curr;
+ } else if (is_Unroll(curr)) {
+ unrollFuncSet.insert(curr);
+ }
+ e_curr = e_curr->get_next();
+ } while (e_curr != n_enode);
+}
+
// from Z3: theory_seq.cpp
static theory_mi_arith* get_th_arith(context& ctx, theory_id afid, expr* e) {
@@ -4198,7 +4306,45 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
simplify_parent(lhs, rhs_value);
}
- // TODO regex unroll? (much later)
+ // regex unroll
+ /*
+ Z3_ast nn1EqConst = NULL;
+ std::set<Z3_ast> nn1EqUnrollFuncs;
+ get_eqc_allUnroll(t, nn1, nn1EqConst, nn1EqUnrollFuncs);
+ Z3_ast nn2EqConst = NULL;
+ std::set<Z3_ast> nn2EqUnrollFuncs;
+ get_eqc_allUnroll(t, nn2, nn2EqConst, nn2EqUnrollFuncs);
+
+ if (nn2EqConst != NULL) {
+ for (std::set<Z3_ast>::iterator itor1 = nn1EqUnrollFuncs.begin(); itor1 != nn1EqUnrollFuncs.end(); itor1++) {
+ processUnrollEqConstStr(t, *itor1, nn2EqConst);
+ }
+ }
+
+ if (nn1EqConst != NULL) {
+ for (std::set<Z3_ast>::iterator itor2 = nn2EqUnrollFuncs.begin(); itor2 != nn2EqUnrollFuncs.end(); itor2++) {
+ processUnrollEqConstStr(t, *itor2, nn1EqConst);
+ }
+ }
+ */
+ expr * nn1EqConst = NULL;
+ std::set<expr*> nn1EqUnrollFuncs;
+ get_eqc_all_unroll(lhs, nn1EqConst, nn1EqUnrollFuncs);
+ expr * nn2EqConst = NULL;
+ std::set<expr*> nn2EqUnrollFuncs;
+ get_eqc_all_unroll(rhs, nn2EqConst, nn2EqUnrollFuncs);
+
+ if (nn2EqConst != NULL) {
+ for (std::set<expr*>::iterator itor1 = nn1EqUnrollFuncs.begin(); itor1 != nn1EqUnrollFuncs.end(); itor1++) {
+ process_unroll_eq_const_str(*itor1, nn2EqConst);
+ }
+ }
+
+ if (nn1EqConst != NULL) {
+ for (std::set<expr*>::iterator itor2 = nn2EqUnrollFuncs.begin(); itor2 != nn2EqUnrollFuncs.end(); itor2++) {
+ process_unroll_eq_const_str(*itor2, nn1EqConst);
+ }
+ }
}
void theory_str::set_up_axioms(expr * ex) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 9aead1105..5bf30a266 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -183,6 +183,7 @@ namespace smt {
app * mk_internal_xor_var();
expr * mk_internal_valTest_var(expr * node, int len, int vTries);
app * mk_regex_rep_var();
+ app * mk_unroll_bound_var();
bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
@@ -219,7 +220,8 @@ namespace smt {
bool is_RegexUnion(enode const * n) const { return is_RegexUnion(n->get_owner()); }
bool is_Str2Reg(app const * a) const { return a->is_app_of(get_id(), OP_RE_STR2REGEX); }
bool is_Str2Reg(enode const * n) const { return is_Str2Reg(n->get_owner()); }
-
+ bool is_Unroll(app const * a) const { return a->is_app_of(get_id(), OP_RE_UNROLL); }
+ bool is_Unroll(enode const * n) const { return is_Unroll(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
void instantiate_basic_string_axioms(enode * str);
@@ -237,6 +239,11 @@ namespace smt {
expr * mk_RegexIn(expr * str, expr * regexp);
void instantiate_axiom_RegexIn(enode * e);
+ app * mk_unroll(expr * n, expr * bound);
+
+ void get_eqc_all_unroll(expr * n, expr * & constStr, std::set<expr*> & unrollFuncSet);
+ void process_unroll_eq_const_str(expr * unrollFunc, expr * constStr);
+ void unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
From 03827cb487bc1e083c628c0d9997f4352b93edb5 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 30 Jun 2016 01:21:21 -0400
Subject: [PATCH 132/401] add more Unroll support to final_check,
ctx_dep_analysis
---
src/smt/theory_str.cpp | 256 +++++++++++++++++++++++++----------------
src/smt/theory_str.h | 5 +-
2 files changed, 163 insertions(+), 98 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 947c35f98..83ce88b36 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3426,34 +3426,104 @@ void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr)
}
}
+void theory_str::process_concat_eq_unroll(expr * concat, expr * unroll) {
+ // TODO NEXT
+ NOT_IMPLEMENTED_YET();
+ /*
+#ifdef DEBUGLOG
+ __debugPrint(logFile, ">> processConcatEqUnroll: \n");
+ __debugPrint(logFile, " * [concat] ");
+ printZ3Node(t, concat);
+ __debugPrint(logFile, "\n");
+ __debugPrint(logFile, " * [unroll] ");
+ printZ3Node(t, unroll);
+ __debugPrint(logFile, "\n\n");
+#endif
+
+ Z3_context ctx = Z3_theory_get_context(t);
+ std::pair<Z3_ast, Z3_ast> key = std::make_pair(concat, unroll);
+ Z3_ast toAssert = NULL;
+
+ if (concatEqUnroll_AstMap.find(key) == concatEqUnroll_AstMap.end()) {
+ Z3_ast arg1 = Z3_get_app_arg(ctx, Z3_to_app(ctx, concat), 0);
+ Z3_ast arg2 = Z3_get_app_arg(ctx, Z3_to_app(ctx, concat), 1);
+ Z3_ast r1 = Z3_get_app_arg(ctx, Z3_to_app(ctx, unroll), 0);
+ Z3_ast t1 = Z3_get_app_arg(ctx, Z3_to_app(ctx, unroll), 1);
+
+ Z3_ast v1 = mk_regexRepVar(t);
+ Z3_ast v2 = mk_regexRepVar(t);
+ Z3_ast v3 = mk_regexRepVar(t);
+ Z3_ast v4 = mk_regexRepVar(t);
+ Z3_ast v5 = mk_regexRepVar(t);
+
+ Z3_ast t2 = mk_unrollBoundVar(t);
+ Z3_ast t3 = mk_unrollBoundVar(t);
+ Z3_ast emptyStr = my_mk_str_value(t, "");
+
+ Z3_ast unroll1 = mk_unroll(t, r1, t2);
+ Z3_ast unroll2 = mk_unroll(t, r1, t3);
+
+ Z3_ast op0 = Z3_mk_eq(ctx, t1, mk_int(ctx, 0));
+ Z3_ast op1 = Z3_mk_ge(ctx, t1, mk_int(ctx, 1));
+
+ std::vector<Z3_ast> op1Items;
+ std::vector<Z3_ast> op2Items;
+
+ op1Items.push_back(Z3_mk_eq(ctx, arg1, emptyStr));
+ op1Items.push_back(Z3_mk_eq(ctx, arg2, emptyStr));
+ op1Items.push_back(Z3_mk_eq(ctx, mk_length(t, arg1), mk_int(ctx, 0)));
+ op1Items.push_back(Z3_mk_eq(ctx, mk_length(t, arg2), mk_int(ctx, 0)));
+ Z3_ast opAnd1 = Z3_mk_eq(ctx, op0, mk_and_fromVector(t, op1Items));
+
+ Z3_ast v1v2 = mk_concat(t, v1, v2);
+ op2Items.push_back(Z3_mk_eq(ctx, arg1, v1v2));
+ op2Items.push_back(Z3_mk_eq(ctx, mk_length(t, arg1), mk_2_add(t, mk_length(t, v1), mk_length(t, v2))));
+ Z3_ast v3v4 = mk_concat(t, v3, v4);
+ op2Items.push_back(Z3_mk_eq(ctx, arg2, v3v4));
+ op2Items.push_back(Z3_mk_eq(ctx, mk_length(t, arg2), mk_2_add(t, mk_length(t, v3), mk_length(t, v4))));
+
+ op2Items.push_back(Z3_mk_eq(ctx, v1, unroll1));
+ op2Items.push_back(Z3_mk_eq(ctx, mk_length(t, v1), mk_length(t, unroll1)));
+ op2Items.push_back(Z3_mk_eq(ctx, v4, unroll2));
+ op2Items.push_back(Z3_mk_eq(ctx, mk_length(t, v4), mk_length(t, unroll2)));
+ Z3_ast v2v3 = mk_concat(t, v2, v3);
+ op2Items.push_back(Z3_mk_eq(ctx, v5, v2v3));
+ reduceVirtualRegexIn(t, v5, r1, op2Items);
+ op2Items.push_back(Z3_mk_eq(ctx, mk_length(t, v5), mk_2_add(t, mk_length(t, v2), mk_length(t, v3))));
+ op2Items.push_back(Z3_mk_eq(ctx, mk_2_add(t, t2, t3), mk_2_sub(t, t1, mk_int(ctx, 1))));
+ Z3_ast opAnd2 = Z3_mk_eq(ctx, op1, mk_and_fromVector(t, op2Items));
+
+ toAssert = mk_2_and(t, opAnd1, opAnd2);
+ concatEqUnroll_AstMap[key] = toAssert;
+ } else {
+ toAssert = concatEqUnroll_AstMap[key];
+ }
+
+ addAxiom(t, toAssert, __LINE__);
+ */
+}
+
void theory_str::unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr) {
context & ctx = get_context();
+ ast_manager & m = get_manager();
+
expr * str2RegFunc = to_app(unrollFunc)->get_arg(0);
expr * strInStr2RegFunc = to_app(str2RegFunc)->get_arg(0);
expr * oriCnt = to_app(unrollFunc)->get_arg(1);
- // TODO NEXT
- NOT_IMPLEMENTED_YET();
-
- /*
- Z3_context ctx = Z3_theory_get_context(t);
- Z3_ast str2RegFunc = Z3_get_app_arg(ctx, Z3_to_app(ctx, unrollFunc), 0);
- Z3_ast strInStr2RegFunc = Z3_get_app_arg(ctx, Z3_to_app(ctx, str2RegFunc), 0);
- Z3_ast oriCnt = Z3_get_app_arg(ctx, Z3_to_app(ctx, unrollFunc), 1);
-
- std::string strValue = getConstStrValue(t, eqConstStr);
- std::string regStrValue = getConstStrValue(t, strInStr2RegFunc);
+ std::string strValue = m_strutil.get_string_constant_value(eqConstStr);
+ std::string regStrValue = m_strutil.get_string_constant_value(strInStr2RegFunc);
int strLen = strValue.length();
int regStrLen = regStrValue.length();
- int cnt = strLen / regStrLen;
+ int cnt = strLen / regStrLen; // TODO prevent DIV/0 on regStrLen
- Z3_ast implyL = Z3_mk_eq(ctx, unrollFunc, eqConstStr);
- Z3_ast implyR1 = Z3_mk_eq(ctx, oriCnt, mk_int(ctx, cnt));
- Z3_ast implyR2 = Z3_mk_eq(ctx, mk_length(t, unrollFunc), mk_int(ctx, strLen));
- Z3_ast toAssert = Z3_mk_implies(ctx, implyL, mk_2_and(t, implyR1, implyR2));
-
- addAxiom(t, toAssert, __LINE__);
- */
+ expr_ref implyL(ctx.mk_eq_atom(unrollFunc, eqConstStr), m);
+ expr_ref implyR1(ctx.mk_eq_atom(oriCnt, mk_int(cnt)), m);
+ expr_ref implyR2(ctx.mk_eq_atom(mk_strlen(unrollFunc), mk_int(strLen)), m);
+ expr_ref axiomRHS(m.mk_and(implyR1, implyR2), m);
+ SASSERT(implyL);
+ SASSERT(axiomRHS);
+ assert_implication(implyL, axiomRHS);
}
/*
@@ -4628,7 +4698,7 @@ void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap
if (canskip == 0 && concatMap.find(node) == concatMap.end()) {
concatMap[node] = 1;
}
- } else if (false) { // TODO is_unroll()
+ } else if (is_Unroll(aNode)) {
// Unroll
if (unrollMap.find(node) == unrollMap.end()) {
unrollMap[node] = 1;
@@ -4696,9 +4766,12 @@ void theory_str::trace_ctx_dep(std::ofstream & tout,
std::map<expr*, expr*> & aliasIndexMap,
std::map<expr*, expr*> & var_eq_constStr_map,
std::map<expr*, std::map<expr*, int> > & var_eq_concat_map,
+ std::map<expr*, std::map<expr*, int> > & var_eq_unroll_map,
std::map<expr*, expr*> & concat_eq_constStr_map,
- std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map) {
+ std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map,
+ std::map<expr*, std::set<expr*> > & unrollGroupMap) {
#ifdef _TRACE
+ context & ctx = get_context();
ast_manager & mgr = get_manager();
{
tout << "(0) alias: variables" << std::endl;
@@ -4754,24 +4827,21 @@ void theory_str::trace_ctx_dep(std::ofstream & tout,
}
tout << std::endl;
}
-/*// TODO
+
{
- __debugPrint(logFile, "(3) var = unrollFunc:\n");
- std::map<Z3_ast, std::map<Z3_ast, int> >::iterator itor2 = var_eq_unroll_map.begin();
+ tout << "(3) var = unrollFunc:" << std::endl;
+ std::map<expr*, std::map<expr*, int> >::iterator itor2 = var_eq_unroll_map.begin();
for (; itor2 != var_eq_unroll_map.end(); itor2++) {
- __debugPrint(logFile, " * ");
- printZ3Node(t, itor2->first);
- __debugPrint(logFile, " = { ");
- std::map<Z3_ast, int>::iterator i_itor = itor2->second.begin();
+ tout << " * " << mk_pp(itor2->first, mgr) << " = { ";
+ std::map<expr*, int>::iterator i_itor = itor2->second.begin();
for (; i_itor != itor2->second.end(); i_itor++) {
- printZ3Node(t, i_itor->first);
- __debugPrint(logFile, ", ");
+ tout << mk_pp(i_itor->first, mgr) << ", ";
}
- __debugPrint(logFile, " }\n");
+ tout << " }" << std::endl;
}
- __debugPrint(logFile, "\n");
+ tout << std::endl;
}
-*/
+
{
tout << "(4) concat = constStr:" << std::endl;
std::map<expr*, expr*>::iterator itor3 = concat_eq_constStr_map.begin();
@@ -4802,44 +4872,41 @@ void theory_str::trace_ctx_dep(std::ofstream & tout,
}
tout << std::endl;
}
-/*// TODO
+
{
- __debugPrint(logFile, "(6) eq unrolls:\n");
- std::map<Z3_ast, std::set<Z3_ast> >::iterator itor5 = unrollGroupMap.begin();
+ tout << "(6) eq unrolls:" << std::endl;
+ std::map<expr*, std::set<expr*> >::iterator itor5 = unrollGroupMap.begin();
for (; itor5 != unrollGroupMap.end(); itor5++) {
- __debugPrint(logFile, " * ");
- std::set<Z3_ast>::iterator i_itor = itor5->second.begin();
+ tout << " * ";
+ std::set<expr*>::iterator i_itor = itor5->second.begin();
for (; i_itor != itor5->second.end(); i_itor++) {
- printZ3Node(t, *i_itor);
- __debugPrint(logFile, ", ");
+ tout << mk_pp(*i_itor, mgr) << ", ";
}
- __debugPrint(logFile, "\n");
+ tout << std::endl;
}
- __debugPrint(logFile, "\n");
+ tout << std::endl;
}
{
- __debugPrint(logFile, "(7) unroll = concats:\n");
- std::map<Z3_ast, std::set<Z3_ast> >::iterator itor5 = unrollGroupMap.begin();
+ tout << "(7) unroll = concats:" << std::endl;
+ std::map<expr*, std::set<expr*> >::iterator itor5 = unrollGroupMap.begin();
for (; itor5 != unrollGroupMap.end(); itor5++) {
- __debugPrint(logFile, " * ");
- Z3_ast unroll = itor5->first;
- printZ3Node(t, unroll);
- __debugPrint(logFile, "\n");
- Z3_ast curr = unroll;
+ tout << " * ";
+ expr * unroll = itor5->first;
+ tout << mk_pp(unroll, mgr) << std::endl;
+ enode * e_curr = ctx.get_enode(unroll);
+ enode * e_curr_end = e_curr;
do {
- if (isConcatFunc(t, curr)) {
- __debugPrint(logFile, " >>> ");
- printZ3Node(t, curr);
- __debugPrint(logFile, "\n");
+ app * curr = e_curr->get_owner();
+ if (is_concat(curr)) {
+ tout << " >>> " << mk_pp(curr, mgr) << std::endl;
}
- curr = Z3_theory_get_eqc_next(t, curr);
- }while (curr != unroll);
- __debugPrint(logFile, "\n");
+ e_curr = e_curr->get_next();
+ } while (e_curr != e_curr_end);
+ tout << std::endl;
}
- __debugPrint(logFile, "\n");
+ tout << std::endl;
}
- */
#else
return;
#endif // _TRACE
@@ -4889,32 +4956,32 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
}
classify_ast_by_type_in_positive_context(strVarMap, concatMap, unrollMap);
- // TODO unroll()
- /*
- std::map<Z3_ast, Z3_ast> aliasUnrollSet;
- std::map<Z3_ast, int>::iterator unrollItor = unrollMap.begin();
- for (; unrollItor != unrollMap.end(); unrollItor++) {
- if (aliasUnrollSet.find(unrollItor->first) != aliasUnrollSet.end())
- continue;
- Z3_ast aRoot = NULL;
- Z3_ast curr = unrollItor->first;
- do {
- if (isUnrollFunc(t, curr)) {
- if (aRoot == NULL) {
- aRoot = curr;
- }
- aliasUnrollSet[curr] = aRoot;
- }
- curr = Z3_theory_get_eqc_next(t, curr);
- } while (curr != unrollItor->first);
+ std::map<expr*, expr*> aliasUnrollSet;
+ std::map<expr*, int>::iterator unrollItor = unrollMap.begin();
+ for (; unrollItor != unrollMap.end(); ++unrollItor) {
+ if (aliasUnrollSet.find(unrollItor->first) != aliasUnrollSet.end()) {
+ continue;
+ }
+ expr * aRoot = NULL;
+ enode * e_currEqc = ctx.get_enode(unrollItor->first);
+ enode * e_curr = e_currEqc;
+ do {
+ app * curr = e_currEqc->get_owner();
+ if (is_Unroll(curr)) {
+ if (aRoot == NULL) {
+ aRoot = curr;
+ }
+ aliasUnrollSet[curr] = aRoot;
+ }
+ e_currEqc = e_currEqc->get_next();
+ } while (e_currEqc != e_curr);
}
for (unrollItor = unrollMap.begin(); unrollItor != unrollMap.end(); unrollItor++) {
- Z3_ast unrFunc = unrollItor->first;
- Z3_ast urKey = aliasUnrollSet[unrFunc];
+ expr * unrFunc = unrollItor->first;
+ expr * urKey = aliasUnrollSet[unrFunc];
unrollGroupMap[urKey].insert(unrFunc);
}
- */
// Step 2: collect alias relation
// e.g. suppose we have the equivalence class {x, y, z};
@@ -4999,13 +5066,9 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
if (!is_arg0_emptyStr && !is_arg1_emptyStr) {
var_eq_concat_map[deAliasNode][curr] = 1;
}
- }
- // TODO: collect unroll functions
- /*
- else if (isUnrollFunc(t, curr)) {
+ } else if (is_Unroll(to_app(curr))) {
var_eq_unroll_map[deAliasNode][curr] = 1;
}
- */
// curr = get_eqc_next(curr)
e_curr = ctx.get_enode(curr);
@@ -5082,12 +5145,13 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
// print some debugging info
TRACE("t_str_detail", trace_ctx_dep(tout, aliasIndexMap, var_eq_constStr_map,
- var_eq_concat_map, concat_eq_constStr_map, concat_eq_concat_map););
+ var_eq_concat_map, var_eq_unroll_map,
+ concat_eq_constStr_map, concat_eq_concat_map, unrollGroupMap););
- // TODO compute Contains
- /*
+ /*// TODO computeContains()
if (containPairBoolMap.size() > 0) {
- computeContains(t, aliasIndexMap, concats_eq_Index_map, var_eq_constStr_map, concat_eq_constStr_map, var_eq_concat_map);
+ NOT_IMPLEMENTED_YET();
+ compute_contains(aliasIndexMap, concats_eq_Index_map, var_eq_constStr_map, concat_eq_constStr_map, var_eq_concat_map);
}
*/
@@ -5638,17 +5702,14 @@ final_check_status theory_str::final_check_eh() {
);
}
- // TODO process_concat_eq_unroll()
- /*
for (std::map<expr*, std::set<expr*> >::iterator fvIt2 = concatFreeArgsEqUnrollsMap.begin();
fvIt2 != concatFreeArgsEqUnrollsMap.end(); fvIt2++) {
expr * concat = fvIt2->first;
for (std::set<expr*>::iterator urItor = fvIt2->second.begin(); urItor != fvIt2->second.end(); urItor++) {
- Z3_ast unroll = *urItor;
- processConcatEqUnroll(concat, unroll);
+ expr * unroll = *urItor;
+ process_concat_eq_unroll(concat, unroll);
}
}
- */
// --------
// experimental free variable assignment - begin
@@ -5675,12 +5736,13 @@ final_check_status theory_str::final_check_eh() {
}
// experimental free variable assignment - end
- // TODO more unroll stuff
- /*
+ // more unroll stuff
for (std::map<expr*, std::set<expr*> >::iterator fvIt1 = fv_unrolls_map.begin();
fvIt1 != fv_unrolls_map.end(); fvIt1++) {
- Z3_ast var = fvIt1->first;
+ expr * var = fvIt1->first;
fSimpUnroll.clear();
+ NOT_IMPLEMENTED_YET(); // TODO complete this unroll block
+ /*
get_eqc_simpleUnroll(t, var, constValue, fSimpUnroll);
if (fSimpUnroll.size() == 0) {
genAssignUnrollReg(t, fv_unrolls_map[var]);
@@ -5690,8 +5752,8 @@ final_check_status theory_str::final_check_eh() {
addAxiom(t, toAssert, __LINE__);
}
}
+ */
}
- */
if (opt_VerifyFinalCheckProgress && !finalCheckProgressIndicator) {
TRACE("t_str", tout << "BUG: no progress in final check, giving up!!" << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 5bf30a266..467727179 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -244,6 +244,7 @@ namespace smt {
void get_eqc_all_unroll(expr * n, expr * & constStr, std::set<expr*> & unrollFuncSet);
void process_unroll_eq_const_str(expr * unrollFunc, expr * constStr);
void unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr);
+ void process_concat_eq_unroll(expr * concat, expr * unroll);
void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs);
@@ -296,8 +297,10 @@ namespace smt {
std::map<expr*, expr*> & aliasIndexMap,
std::map<expr*, expr*> & var_eq_constStr_map,
std::map<expr*, std::map<expr*, int> > & var_eq_concat_map,
+ std::map<expr*, std::map<expr*, int> > & var_eq_unroll_map,
std::map<expr*, expr*> & concat_eq_constStr_map,
- std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map);
+ std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map,
+ std::map<expr*, std::set<expr*> > & unrollGroupMap);
void classify_ast_by_type(expr * node, std::map<expr*, int> & varMap,
std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
From 21f0a50abaee4c6d365a910928c46bfe4bae8d58 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 30 Jun 2016 01:24:43 -0400
Subject: [PATCH 133/401] add Unroll check to get_eqc_allUnroll
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 83ce88b36..b3621f61e 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6406,7 +6406,7 @@ void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> &
do {
if (is_string(to_app(curr))) {
constStr = curr;
- } else if (false) /*(td->Unroll == Z3_get_app_decl(ctx, Z3_to_app(ctx, curr)))*/ { // TODO
+ } else if (is_Unroll(to_app(curr))) {
if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
unrollFuncSet.insert(curr);
}
From 427632ede398c354abd0141a07d905626699643f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 30 Jun 2016 01:42:00 -0400
Subject: [PATCH 134/401] let free variable assignment work a bit more towards
unrolls
---
src/smt/theory_str.cpp | 142 ++++++++++++++++++++++++++++++++---------
src/smt/theory_str.h | 5 +-
2 files changed, 117 insertions(+), 30 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b3621f61e..64f3d1fc8 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3550,26 +3550,6 @@ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
return n;
}
-void theory_str::get_eqc_all_unroll(expr * n, expr * & constStr, std::set<expr*> & unrollFuncSet) {
- context & ctx = get_context();
-
- constStr = NULL;
- unrollFuncSet.clear();
-
- // iterate over the eqc of 'n'
- enode * n_enode = ctx.get_enode(n);
- enode * e_curr = n_enode;
- do {
- app * curr = e_curr->get_owner();
- if (m_strutil.is_string(curr)) {
- constStr = curr;
- } else if (is_Unroll(curr)) {
- unrollFuncSet.insert(curr);
- }
- e_curr = e_curr->get_next();
- } while (e_curr != n_enode);
-}
-
// from Z3: theory_seq.cpp
static theory_mi_arith* get_th_arith(context& ctx, theory_id afid, expr* e) {
@@ -4399,10 +4379,10 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
*/
expr * nn1EqConst = NULL;
std::set<expr*> nn1EqUnrollFuncs;
- get_eqc_all_unroll(lhs, nn1EqConst, nn1EqUnrollFuncs);
+ get_eqc_allUnroll(lhs, nn1EqConst, nn1EqUnrollFuncs);
expr * nn2EqConst = NULL;
std::set<expr*> nn2EqUnrollFuncs;
- get_eqc_all_unroll(rhs, nn2EqConst, nn2EqUnrollFuncs);
+ get_eqc_allUnroll(rhs, nn2EqConst, nn2EqUnrollFuncs);
if (nn2EqConst != NULL) {
for (std::set<expr*>::iterator itor1 = nn1EqUnrollFuncs.begin(); itor1 != nn1EqUnrollFuncs.end(); itor1++) {
@@ -5741,18 +5721,15 @@ final_check_status theory_str::final_check_eh() {
fvIt1 != fv_unrolls_map.end(); fvIt1++) {
expr * var = fvIt1->first;
fSimpUnroll.clear();
- NOT_IMPLEMENTED_YET(); // TODO complete this unroll block
- /*
- get_eqc_simpleUnroll(t, var, constValue, fSimpUnroll);
+ get_eqc_simpleUnroll(var, constValue, fSimpUnroll);
if (fSimpUnroll.size() == 0) {
- genAssignUnrollReg(t, fv_unrolls_map[var]);
+ gen_assign_unroll_reg(fv_unrolls_map[var]);
} else {
- Z3_ast toAssert = genAssignUnrollStr2Reg(t, var, fSimpUnroll);
+ expr * toAssert = gen_assign_unroll_Str2Reg(var, fSimpUnroll);
if (toAssert != NULL) {
- addAxiom(t, toAssert, __LINE__);
+ assert_axiom(toAssert);
}
}
- */
}
if (opt_VerifyFinalCheckProgress && !finalCheckProgressIndicator) {
@@ -6037,6 +6014,89 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
}
}
+void theory_str::gen_assign_unroll_reg(std::set<expr*> & unrolls) {
+ // TODO
+ NOT_IMPLEMENTED_YET();
+}
+
+static int computeGCD(int x, int y) {
+ if (x == 0) {
+ return y;
+ }
+ while (y != 0) {
+ if (x > y) {
+ x = x - y;
+ } else {
+ y = y - x;
+ }
+ }
+ return x;
+}
+
+static int computeLCM(int a, int b) {
+ int temp = computeGCD(a, b);
+ return temp ? (a / temp * b) : 0;
+}
+
+static std::string get_unrolled_string(std::string core, int count) {
+ std::string res = "";
+ for (int i = 0; i < count; i++) {
+ res += core;
+ }
+ return res;
+}
+
+expr * theory_str::gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ int lcm = 1;
+ int coreValueCount = 0;
+ expr * oneUnroll = NULL;
+ std::string oneCoreStr = "";
+ for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
+ expr * str2RegFunc = to_app(*itor)->get_arg(0);
+ expr * coreVal = to_app(str2RegFunc)->get_arg(0);
+ std::string coreStr = m_strutil.get_string_constant_value(coreVal);
+ if (oneUnroll == NULL) {
+ oneUnroll = *itor;
+ oneCoreStr = coreStr;
+ }
+ coreValueCount++;
+ int core1Len = coreStr.length();
+ lcm = computeLCM(lcm, core1Len);
+ }
+ //
+ bool canHaveNonEmptyAssign = true;
+ expr_ref_vector litems(mgr);
+ std::string lcmStr = get_unrolled_string(oneCoreStr, (lcm / oneCoreStr.length()));
+ for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
+ expr * str2RegFunc = to_app(*itor)->get_arg(0);
+ expr * coreVal = to_app(str2RegFunc)->get_arg(0);
+ std::string coreStr = m_strutil.get_string_constant_value(coreVal);
+ int core1Len = coreStr.length();
+ std::string uStr = get_unrolled_string(coreStr, (lcm / core1Len));
+ if (uStr != lcmStr) {
+ canHaveNonEmptyAssign = false;
+ }
+ litems.push_back(ctx.mk_eq_atom(n, *itor));
+ }
+
+ if (canHaveNonEmptyAssign) {
+ return gen_unroll_conditional_options(n, unrolls, lcmStr);
+ } else {
+ expr * implyL = mk_and(litems);
+ expr * implyR = ctx.mk_eq_atom(n, m_strutil.mk_string(""));
+ // want to return (implyL -> implyR)
+ return mgr.mk_or(mgr.mk_not(implyL), implyR);
+ }
+}
+
+expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, std::string lcmStr) {
+ // TODO NEXT
+ NOT_IMPLEMENTED_YET();
+}
+
expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tries) {
ast_manager & m = get_manager();
context & ctx = get_context();
@@ -6417,6 +6477,30 @@ void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> &
} while (curr != n);
}
+// Collect simple Unroll functions (whose core is Str2Reg) and constant strings in the EQC of n.
+void theory_str::get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet) {
+ constStr = NULL;
+ unrollFuncSet.clear();
+ context & ctx = get_context();
+
+ expr * curr = n;
+ do {
+ if (is_string(to_app(curr))) {
+ constStr = curr;
+ } else if (is_Unroll(to_app(curr))) {
+ expr * core = to_app(curr)->get_arg(0);
+ if (is_Str2Reg(to_app(core))) {
+ if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
+ unrollFuncSet.insert(curr);
+ }
+ }
+ }
+ enode * e_curr = ctx.get_enode(curr);
+ curr = e_curr->get_next()->get_owner();
+ // curr = get_eqc_next(t, curr);
+ } while (curr != n);
+}
+
void theory_str::init_model(model_generator & mg) {
//TRACE("t_str", tout << "initializing model" << std::endl; display(tout););
m_factory = alloc(str_value_factory, get_manager(), get_family_id());
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 467727179..7ef4ef7d3 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -241,7 +241,6 @@ namespace smt {
void instantiate_axiom_RegexIn(enode * e);
app * mk_unroll(expr * n, expr * bound);
- void get_eqc_all_unroll(expr * n, expr * & constStr, std::set<expr*> & unrollFuncSet);
void process_unroll_eq_const_str(expr * unrollFunc, expr * constStr);
void unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr);
void process_concat_eq_unroll(expr * concat, expr * unroll);
@@ -332,6 +331,10 @@ namespace smt {
// strRegex
void get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet);
+ void get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet);
+ void gen_assign_unroll_reg(std::set<expr*> & unrolls);
+ expr * gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls);
+ expr * gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, std::string lcmStr);
void dump_assignments();
void initialize_charset();
From b4110c886f13111c8273c20f00f2e54fc96bda60 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 30 Jun 2016 02:46:16 -0400
Subject: [PATCH 135/401] successful unroll of simple unbounded Str2Reg
---
src/smt/theory_str.cpp | 117 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 11 ++++
2 files changed, 126 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 64f3d1fc8..c8170a16a 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -32,6 +32,7 @@ theory_str::theory_str(ast_manager & m):
opt_AggressiveValueTesting(true),
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
+ opt_LCMUnrollStep(2),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -458,6 +459,10 @@ app * theory_str::mk_unroll_bound_var() {
return mk_int_var("unroll");
}
+app * theory_str::mk_unroll_test_var() {
+ return mk_str_var("unrollTest"); // was uRt
+}
+
app * theory_str::mk_str_var(std::string name) {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -6093,8 +6098,116 @@ expr * theory_str::gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls
}
expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, std::string lcmStr) {
- // TODO NEXT
- NOT_IMPLEMENTED_YET();
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ int dist = opt_LCMUnrollStep;
+ expr_ref_vector litems(mgr);
+ expr_ref moreAst(m_strutil.mk_string("more"), mgr);
+ for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
+ expr_ref item(ctx.mk_eq_atom(var, *itor), mgr);
+ TRACE("t_str_detail", tout << "considering unroll " << mk_pp(item, mgr) << std::endl;);
+ litems.push_back(item);
+ }
+
+ if (unroll_tries_map[var][unrolls].size() == 0) {
+ unroll_tries_map[var][unrolls].push_back(mk_unroll_test_var());
+ }
+
+ int tries = unroll_tries_map[var][unrolls].size();
+ for (int i = 0; i < tries; i++) {
+ expr * tester = unroll_tries_map[var][unrolls][i];
+ bool testerHasValue = false;
+ expr * testerVal = get_eqc_value(tester, testerHasValue);
+ if (!testerHasValue) {
+ // generate make-up assertion
+ int l = i * dist;
+ int h = (i + 1) * dist;
+ expr_ref lImp(mk_and(litems), mgr);
+ expr_ref rImp(gen_unroll_assign(var, lcmStr, tester, l, h), mgr);
+
+ SASSERT(lImp);
+ TRACE("t_str_detail", tout << "lImp = " << mk_pp(lImp, mgr) << std::endl;);
+ SASSERT(rImp);
+ TRACE("t_str_detail", tout << "rImp = " << mk_pp(rImp, mgr) << std::endl;);
+
+ expr_ref toAssert(mgr.mk_or(mgr.mk_not(lImp), rImp), mgr);
+ SASSERT(toAssert);
+ TRACE("t_str_detail", tout << "Making up assignments for variable which is equal to unbounded Unroll" << std::endl;);
+ m_trail.push_back(toAssert);
+ return toAssert;
+
+ // insert [tester = "more"] to litems so that the implyL for next tester is correct
+ litems.push_back(ctx.mk_eq_atom(tester, moreAst));
+ } else {
+ std::string testerStr = m_strutil.get_string_constant_value(testerVal);
+ TRACE("t_str_detail", tout << "Tester [" << mk_pp(tester, mgr) << "] = " << testerStr << std::endl;);
+ if (testerStr == "more") {
+ litems.push_back(ctx.mk_eq_atom(tester, moreAst));
+ }
+ }
+ }
+ expr * tester = mk_unroll_test_var();
+ unroll_tries_map[var][unrolls].push_back(tester);
+ int l = tries * dist;
+ int h = (tries + 1) * dist;
+ expr_ref lImp(mk_and(litems), mgr);
+ expr_ref rImp(gen_unroll_assign(var, lcmStr, tester, l, h), mgr);
+ SASSERT(lImp);
+ SASSERT(rImp);
+ expr_ref toAssert(mgr.mk_or(mgr.mk_not(lImp), rImp), mgr);
+ SASSERT(toAssert);
+ TRACE("t_str_detail", tout << "Generating assignment for variable which is equal to unbounded Unroll" << std::endl;);
+ m_trail.push_back(toAssert);
+ return toAssert;
+}
+
+expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * testerVar, int l, int h) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ TRACE("t_str_detail", tout << "entry: var = " << mk_pp(var, mgr) << ", lcmStr = " << lcmStr
+ << ", l = " << l << ", h = " << h << std::endl;);
+
+ expr_ref_vector orItems(mgr);
+ expr_ref_vector andItems(mgr);
+
+ for (int i = l; i < h; i++) {
+ std::string iStr = int_to_string(i);
+ expr_ref testerEqAst(ctx.mk_eq_atom(testerVar, m_strutil.mk_string(iStr)), mgr);
+ TRACE("t_str_detail", tout << "testerEqAst = " << mk_pp(testerEqAst, mgr) << std::endl;);
+ orItems.push_back(testerEqAst);
+ std::string unrollStrInstance = get_unrolled_string(lcmStr, i);
+
+ expr_ref x1(ctx.mk_eq_atom(testerEqAst, ctx.mk_eq_atom(var, m_strutil.mk_string(unrollStrInstance))), mgr);
+ TRACE("t_str_detail", tout << "x1 = " << mk_pp(x1, mgr) << std::endl;);
+ andItems.push_back(x1);
+
+ expr_ref x2(ctx.mk_eq_atom(testerEqAst, ctx.mk_eq_atom(mk_strlen(var), mk_int(i * lcmStr.length()))), mgr);
+ TRACE("t_str_detail", tout << "x2 = " << mk_pp(x2, mgr) << std::endl;);
+ andItems.push_back(x2);
+ }
+ expr_ref testerEqMore(ctx.mk_eq_atom(testerVar, m_strutil.mk_string("more")), mgr);
+ TRACE("t_str_detail", tout << "testerEqMore = " << mk_pp(testerEqMore, mgr) << std::endl;);
+ orItems.push_back(testerEqMore);
+ int nextLowerLenBound = h * lcmStr.length();
+ expr_ref more2(ctx.mk_eq_atom(testerEqMore,
+ //Z3_mk_ge(mk_length(t, var), mk_int(ctx, nextLowerLenBound))
+ m_autil.mk_ge(m_autil.mk_add(mk_strlen(var), mk_int(-1 * nextLowerLenBound)), mk_int(0))
+ ), mgr);
+ TRACE("t_str_detail", tout << "more2 = " << mk_pp(more2, mgr) << std::endl;);
+ andItems.push_back(more2);
+
+ expr_ref finalOR(mgr.mk_or(orItems.size(), orItems.c_ptr()), mgr);
+ TRACE("t_str_detail", tout << "finalOR = " << mk_pp(finalOR, mgr) << std::endl;);
+ andItems.push_back(mk_or(orItems));
+
+ expr_ref finalAND(mgr.mk_and(andItems.size(), andItems.c_ptr()), mgr);
+ TRACE("t_str_detail", tout << "finalAND = " << mk_pp(finalAND, mgr) << std::endl;);
+
+ // doing the following avoids a segmentation fault
+ m_trail.push_back(finalAND);
+ return finalAND;
}
expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tries) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 7ef4ef7d3..736900ba7 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -89,6 +89,11 @@ namespace smt {
*/
bool opt_VerifyFinalCheckProgress;
+ /*
+ * This constant controls how eagerly we expand unrolls in unbounded regex membership tests.
+ */
+ int opt_LCMUnrollStep;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -153,6 +158,10 @@ namespace smt {
std::map<expr*, int_vector> val_range_map;
+ // This can't be an expr_ref_vector because the constructor is wrong,
+ // we would need to modify the allocator so we pass in ast_manager
+ std::map<expr*, std::map<std::set<expr*>, ptr_vector<expr> > > unroll_tries_map;
+
char * char_set;
std::map<char, int> charSetLookupTable;
int charSetSize;
@@ -184,6 +193,7 @@ namespace smt {
expr * mk_internal_valTest_var(expr * node, int len, int vTries);
app * mk_regex_rep_var();
app * mk_unroll_bound_var();
+ app * mk_unroll_test_var();
bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
@@ -335,6 +345,7 @@ namespace smt {
void gen_assign_unroll_reg(std::set<expr*> & unrolls);
expr * gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls);
expr * gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, std::string lcmStr);
+ expr * gen_unroll_assign(expr * var, std::string lcmStr, expr * testerVar, int l, int h);
void dump_assignments();
void initialize_charset();
From a2d6149df59703b90c9835ea41077624f5192c13 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 30 Jun 2016 04:00:42 -0400
Subject: [PATCH 136/401] add general-case regex unroll model generation WIP as
there is currently a SAT-as-UNSAT bug I'm trying to fix
This also changes the semantics of lower_bound and upper_bound,
no longer wrapping the expr that is passed in with mk_strlen().
This actually makes these methods useful for checking bounds
of things other than strings.
---
src/smt/theory_str.cpp | 181 +++++++++++++++++++++++++++++++++++++++--
src/smt/theory_str.h | 2 +
2 files changed, 174 insertions(+), 9 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index c8170a16a..27043315b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -131,6 +131,7 @@ void theory_str::assert_axiom(expr * e) {
if (opt_VerifyFinalCheckProgress) {
finalCheckProgressIndicator = true;
}
+ // TODO add to m_trail?
if (get_manager().is_true(e)) return;
TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
context & ctx = get_context();
@@ -3432,6 +3433,11 @@ void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr)
}
void theory_str::process_concat_eq_unroll(expr * concat, expr * unroll) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ TRACE("t_str_detail", tout << "concat = " << mk_pp(concat, mgr) << ", unroll = " << mk_pp(unroll, mgr) << std::endl;);
+
// TODO NEXT
NOT_IMPLEMENTED_YET();
/*
@@ -3596,20 +3602,18 @@ bool theory_str::get_value(expr* e, rational& val) const {
bool theory_str::lower_bound(expr* _e, rational& lo) {
context& ctx = get_context();
ast_manager & m = get_manager();
- expr_ref e(mk_strlen(_e), m);
- theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
+ theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), _e);
expr_ref _lo(m);
- if (!tha || !tha->get_lower(ctx.get_enode(e), _lo)) return false;
+ if (!tha || !tha->get_lower(ctx.get_enode(_e), _lo)) return false;
return m_autil.is_numeral(_lo, lo) && lo.is_int();
}
bool theory_str::upper_bound(expr* _e, rational& hi) {
context& ctx = get_context();
ast_manager & m = get_manager();
- expr_ref e(mk_strlen(_e), m);
- theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
+ theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), _e);
expr_ref _hi(m);
- if (!tha || !tha->get_upper(ctx.get_enode(e), _hi)) return false;
+ if (!tha || !tha->get_upper(ctx.get_enode(_e), _hi)) return false;
return m_autil.is_numeral(_hi, hi) && hi.is_int();
}
@@ -5602,6 +5606,7 @@ final_check_status theory_str::final_check_eh() {
for (std::map<expr*, std::set<expr*> >::iterator fvIt3 = fv_unrolls_map.begin();
fvIt3 != fv_unrolls_map.end(); fvIt3++) {
expr * var = fvIt3->first;
+ TRACE("t_str_detail", tout << "erase free variable " << mk_pp(var, m) << " from freeVar_map, it is bounded by an Unroll" << std::endl;);
freeVar_map.erase(var);
}
@@ -5665,6 +5670,7 @@ final_check_status theory_str::final_check_eh() {
}
}
for (std::set<expr*>::iterator vItor = fvUnrollSet.begin(); vItor != fvUnrollSet.end(); vItor++) {
+ TRACE("t_str_detail", tout << "remove " << mk_pp(*vItor, m) << " from freeVar_map" << std::endl;);
freeVar_map.erase(*vItor);
}
@@ -5721,7 +5727,8 @@ final_check_status theory_str::final_check_eh() {
}
// experimental free variable assignment - end
- // more unroll stuff
+ // now deal with removed free variables that are bounded by an unroll
+ TRACE("t_str", tout << "fv_unrolls_map (#" << fv_unrolls_map.size() << ")" << std::endl;);
for (std::map<expr*, std::set<expr*> >::iterator fvIt1 = fv_unrolls_map.begin();
fvIt1 != fv_unrolls_map.end(); fvIt1++) {
expr * var = fvIt1->first;
@@ -6019,9 +6026,165 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
}
}
+void theory_str::reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vector & items) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ TRACE("t_str_detail", tout << "reduce regex " << mk_pp(regex, mgr) << " with respect to variable " << mk_pp(var, mgr) << std::endl;);
+
+ app * regexFuncDecl = to_app(regex);
+ if (is_Str2Reg(regexFuncDecl)) {
+ // ---------------------------------------------------------
+ // var \in Str2Reg(s1)
+ // ==>
+ // var = s1 /\ length(var) = length(s1)
+ // ---------------------------------------------------------
+ expr * strInside = to_app(regex)->get_arg(0);
+ items.push_back(ctx.mk_eq_atom(var, strInside));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_strlen(strInside)));
+ return;
+ }
+ // RegexUnion
+ else if (is_RegexUnion(regexFuncDecl)) {
+ // ---------------------------------------------------------
+ // var \in RegexUnion(r1, r2)
+ // ==>
+ // (var = newVar1 \/ var = newVar2)
+ // (var = newVar1 --> length(var) = length(newVar1)) /\ (var = newVar2 --> length(var) = length(newVar2))
+ // /\ (newVar1 \in r1) /\ (newVar2 \in r2)
+ // ---------------------------------------------------------
+ expr_ref newVar1(mk_regex_rep_var(), mgr);
+ expr_ref newVar2(mk_regex_rep_var(), mgr);
+ items.push_back(mgr.mk_or(ctx.mk_eq_atom(var, newVar1), ctx.mk_eq_atom(var, newVar2)));
+ items.push_back(mgr.mk_or(
+ mgr.mk_not(ctx.mk_eq_atom(var, newVar1)),
+ ctx.mk_eq_atom(mk_strlen(var), mk_strlen(newVar1))));
+ items.push_back(mgr.mk_or(
+ mgr.mk_not(ctx.mk_eq_atom(var, newVar2)),
+ ctx.mk_eq_atom(mk_strlen(var), mk_strlen(newVar2))));
+
+ expr * regArg1 = to_app(regex)->get_arg(0);
+ reduce_virtual_regex_in(newVar1, regArg1, items);
+
+ expr * regArg2 = to_app(regex)->get_arg(1);
+ reduce_virtual_regex_in(newVar2, regArg2, items);
+
+ return;
+ }
+ // RegexConcat
+ else if (is_RegexConcat(regexFuncDecl)) {
+ // ---------------------------------------------------------
+ // var \in RegexConcat(r1, r2)
+ // ==>
+ // (var = newVar1 . newVar2) /\ (length(var) = length(vewVar1 . newVar2) )
+ // /\ (newVar1 \in r1) /\ (newVar2 \in r2)
+ // ---------------------------------------------------------
+ expr_ref newVar1(mk_regex_rep_var(), mgr);
+ expr_ref newVar2(mk_regex_rep_var(), mgr);
+ expr_ref concatAst(mk_concat(newVar1, newVar2), mgr);
+ items.push_back(ctx.mk_eq_atom(var, concatAst));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var),
+ m_autil.mk_add(mk_strlen(newVar1), mk_strlen(newVar2))));
+
+ expr * regArg1 = to_app(regex)->get_arg(0);
+ reduce_virtual_regex_in(newVar1, regArg1, items);
+ expr * regArg2 = to_app(regex)->get_arg(1);
+ reduce_virtual_regex_in(newVar2, regArg2, items);
+ return;
+ }
+ // Unroll
+ else if (is_RegexStar(regexFuncDecl)) {
+ // ---------------------------------------------------------
+ // var \in Star(r1)
+ // ==>
+ // var = unroll(r1, t1) /\ |var| = |unroll(r1, t1)|
+ // ---------------------------------------------------------
+ expr * regArg = to_app(regex)->get_arg(0);
+ expr_ref unrollCnt(mk_unroll_bound_var(), mgr);
+ expr_ref unrollFunc(mk_unroll(regArg, unrollCnt), mgr);
+ items.push_back(ctx.mk_eq_atom(var, unrollFunc));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_strlen(unrollFunc)));
+ return;
+ } else {
+ UNREACHABLE();
+ }
+}
+
void theory_str::gen_assign_unroll_reg(std::set<expr*> & unrolls) {
- // TODO
- NOT_IMPLEMENTED_YET();
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ expr_ref_vector items(mgr);
+ for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
+ expr * unrFunc = *itor;
+ TRACE("t_str_detail", tout << "generating assignment for unroll " << mk_pp(unrFunc, mgr) << std::endl;);
+
+ expr * regexInUnr = to_app(unrFunc)->get_arg(0);
+ expr * cntInUnr = to_app(unrFunc)->get_arg(1);
+ items.reset();
+
+ rational low, high;
+ bool low_exists = lower_bound(cntInUnr, low);
+ bool high_exists = upper_bound(cntInUnr, high);
+
+ TRACE("t_str_detail",
+ tout << "unroll " << mk_pp(unrFunc, mgr) << std::endl;
+ rational unrLenValue;
+ bool unrLenValue_exists = get_len_value(unrFunc, unrLenValue);
+ tout << "unroll length: " << (unrLenValue_exists ? unrLenValue.to_string() : "?") << std::endl;
+ rational cntInUnrValue;
+ bool cntHasValue = get_value(cntInUnr, cntInUnrValue);
+ tout << "unroll count: " << (cntHasValue ? cntInUnrValue.to_string() : "?")
+ << " low = "
+ << (low_exists ? low.to_string() : "?")
+ << " high = "
+ << (high_exists ? high.to_string() : "?")
+ << std::endl;
+ );
+
+ expr_ref toAssert(mgr);
+ if (low.is_neg()) {
+ toAssert = m_autil.mk_ge(cntInUnr, mk_int(0));
+ } else {
+ if (unroll_var_map.find(unrFunc) == unroll_var_map.end()) {
+
+ expr_ref newVar1(mk_regex_rep_var(), mgr);
+ expr_ref newVar2(mk_regex_rep_var(), mgr);
+ expr_ref concatAst(mk_concat(newVar1, newVar2), mgr);
+ expr_ref newCnt(mk_unroll_bound_var(), mgr);
+ expr_ref newUnrollFunc(mk_unroll(regexInUnr, newCnt), mgr);
+
+ // unroll(r1, t1) = newVar1 . newVar2
+ items.push_back(ctx.mk_eq_atom(unrFunc, concatAst));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(unrFunc), m_autil.mk_add(mk_strlen(newVar1), mk_strlen(newVar2))));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(unrFunc), mk_strlen(newVar1)));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(unrFunc), mk_strlen(newVar2)));
+ // newVar1 \in r1
+ reduce_virtual_regex_in(newVar1, regexInUnr, items);
+ items.push_back(ctx.mk_eq_atom(cntInUnr, m_autil.mk_add(newCnt, mk_int(1))));
+ items.push_back(ctx.mk_eq_atom(newVar2, newUnrollFunc));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(newVar2), mk_strlen(newUnrollFunc)));
+ toAssert = ctx.mk_eq_atom(
+ m_autil.mk_ge(cntInUnr, mk_int(1)),
+ mk_and(items));
+
+ // option 0
+ expr_ref op0(ctx.mk_eq_atom(cntInUnr, mk_int(0)), mgr);
+ expr_ref ast1(ctx.mk_eq_atom(unrFunc, m_strutil.mk_string("")), mgr);
+ expr_ref ast2(ctx.mk_eq_atom(mk_strlen(unrFunc), mk_int(0)), mgr);
+ expr_ref and1(mgr.mk_and(ast1, ast2), mgr);
+
+ // put together
+ toAssert = mgr.mk_and(ctx.mk_eq_atom(op0, and1), toAssert);
+
+ unroll_var_map[unrFunc] = toAssert;
+ } else {
+ toAssert = unroll_var_map[unrFunc];
+ }
+ }
+ m_trail.push_back(toAssert);
+ assert_axiom(toAssert);
+ }
}
static int computeGCD(int x, int y) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 736900ba7..c61b3783a 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -161,6 +161,7 @@ namespace smt {
// This can't be an expr_ref_vector because the constructor is wrong,
// we would need to modify the allocator so we pass in ast_manager
std::map<expr*, std::map<std::set<expr*>, ptr_vector<expr> > > unroll_tries_map;
+ std::map<expr*, expr*> unroll_var_map;
char * char_set;
std::map<char, int> charSetLookupTable;
@@ -346,6 +347,7 @@ namespace smt {
expr * gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls);
expr * gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, std::string lcmStr);
expr * gen_unroll_assign(expr * var, std::string lcmStr, expr * testerVar, int l, int h);
+ void reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vector & items);
void dump_assignments();
void initialize_charset();
From b53da182b647b9ca1187538a76884be4534fbda5 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 30 Jun 2016 04:39:09 -0400
Subject: [PATCH 137/401] fix gen_assign_unroll_reg so that it does not assert
a contradiction
---
src/smt/theory_str.cpp | 30 ++++++++----------------------
src/smt/theory_str.h | 1 +
2 files changed, 9 insertions(+), 22 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 27043315b..843e78e85 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -461,7 +461,9 @@ app * theory_str::mk_unroll_bound_var() {
}
app * theory_str::mk_unroll_test_var() {
- return mk_str_var("unrollTest"); // was uRt
+ app * v = mk_str_var("unrollTest"); // was uRt
+ internal_unrollTest_vars.insert(v);
+ return v;
}
app * theory_str::mk_str_var(std::string name) {
@@ -4159,6 +4161,8 @@ bool theory_str::free_var_attempt(expr * nn1, expr * nn2) {
more_value_tests(nn1, nn2_str);
}
return true;
+ } else if (internal_unrollTest_vars.contains(nn1)) {
+ return true;
} else {
return false;
}
@@ -4366,26 +4370,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
}
// regex unroll
- /*
- Z3_ast nn1EqConst = NULL;
- std::set<Z3_ast> nn1EqUnrollFuncs;
- get_eqc_allUnroll(t, nn1, nn1EqConst, nn1EqUnrollFuncs);
- Z3_ast nn2EqConst = NULL;
- std::set<Z3_ast> nn2EqUnrollFuncs;
- get_eqc_allUnroll(t, nn2, nn2EqConst, nn2EqUnrollFuncs);
- if (nn2EqConst != NULL) {
- for (std::set<Z3_ast>::iterator itor1 = nn1EqUnrollFuncs.begin(); itor1 != nn1EqUnrollFuncs.end(); itor1++) {
- processUnrollEqConstStr(t, *itor1, nn2EqConst);
- }
- }
-
- if (nn1EqConst != NULL) {
- for (std::set<Z3_ast>::iterator itor2 = nn2EqUnrollFuncs.begin(); itor2 != nn2EqUnrollFuncs.end(); itor2++) {
- processUnrollEqConstStr(t, *itor2, nn1EqConst);
- }
- }
- */
expr * nn1EqConst = NULL;
std::set<expr*> nn1EqUnrollFuncs;
get_eqc_allUnroll(lhs, nn1EqConst, nn1EqUnrollFuncs);
@@ -6157,8 +6142,9 @@ void theory_str::gen_assign_unroll_reg(std::set<expr*> & unrolls) {
// unroll(r1, t1) = newVar1 . newVar2
items.push_back(ctx.mk_eq_atom(unrFunc, concatAst));
items.push_back(ctx.mk_eq_atom(mk_strlen(unrFunc), m_autil.mk_add(mk_strlen(newVar1), mk_strlen(newVar2))));
- items.push_back(ctx.mk_eq_atom(mk_strlen(unrFunc), mk_strlen(newVar1)));
- items.push_back(ctx.mk_eq_atom(mk_strlen(unrFunc), mk_strlen(newVar2)));
+ // mk_strlen(unrFunc) >= mk_strlen(newVar{1,2})
+ items.push_back(m_autil.mk_ge(m_autil.mk_add(mk_strlen(unrFunc), m_autil.mk_mul(mk_int(-1), mk_strlen(newVar1))), mk_int(0)));
+ items.push_back(m_autil.mk_ge(m_autil.mk_add(mk_strlen(unrFunc), m_autil.mk_mul(mk_int(-1), mk_strlen(newVar2))), mk_int(0)));
// newVar1 \in r1
reduce_virtual_regex_in(newVar1, regexInUnr, items);
items.push_back(ctx.mk_eq_atom(cntInUnr, m_autil.mk_add(newCnt, mk_int(1))));
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index c61b3783a..daf534686 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -146,6 +146,7 @@ namespace smt {
obj_hashtable<expr> internal_lenTest_vars;
obj_hashtable<expr> internal_valTest_vars;
+ obj_hashtable<expr> internal_unrollTest_vars;
std::set<expr*> input_var_in_len;
From 7d903ff1fa0cf04277aee71558d2cc6c961fe7ac Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 30 Jun 2016 04:55:11 -0400
Subject: [PATCH 138/401] implement process_concat_eq_unroll, WIP
---
src/smt/theory_str.cpp | 112 ++++++++++++++++++-----------------------
src/smt/theory_str.h | 1 +
2 files changed, 50 insertions(+), 63 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 843e78e85..853924a94 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3440,80 +3440,66 @@ void theory_str::process_concat_eq_unroll(expr * concat, expr * unroll) {
TRACE("t_str_detail", tout << "concat = " << mk_pp(concat, mgr) << ", unroll = " << mk_pp(unroll, mgr) << std::endl;);
- // TODO NEXT
- NOT_IMPLEMENTED_YET();
- /*
-#ifdef DEBUGLOG
- __debugPrint(logFile, ">> processConcatEqUnroll: \n");
- __debugPrint(logFile, " * [concat] ");
- printZ3Node(t, concat);
- __debugPrint(logFile, "\n");
- __debugPrint(logFile, " * [unroll] ");
- printZ3Node(t, unroll);
- __debugPrint(logFile, "\n\n");
-#endif
+ std::pair<expr*, expr*> key = std::make_pair(concat, unroll);
+ expr_ref toAssert(mgr);
- Z3_context ctx = Z3_theory_get_context(t);
- std::pair<Z3_ast, Z3_ast> key = std::make_pair(concat, unroll);
- Z3_ast toAssert = NULL;
+ if (concat_eq_unroll_ast_map.find(key) == concat_eq_unroll_ast_map.end()) {
+ expr_ref arg1(to_app(concat)->get_arg(0), mgr);
+ expr_ref arg2(to_app(concat)->get_arg(1), mgr);
+ expr_ref r1(to_app(unroll)->get_arg(0), mgr);
+ expr_ref t1(to_app(unroll)->get_arg(1), mgr);
- if (concatEqUnroll_AstMap.find(key) == concatEqUnroll_AstMap.end()) {
- Z3_ast arg1 = Z3_get_app_arg(ctx, Z3_to_app(ctx, concat), 0);
- Z3_ast arg2 = Z3_get_app_arg(ctx, Z3_to_app(ctx, concat), 1);
- Z3_ast r1 = Z3_get_app_arg(ctx, Z3_to_app(ctx, unroll), 0);
- Z3_ast t1 = Z3_get_app_arg(ctx, Z3_to_app(ctx, unroll), 1);
+ expr_ref v1(mk_regex_rep_var(), mgr);
+ expr_ref v2(mk_regex_rep_var(), mgr);
+ expr_ref v3(mk_regex_rep_var(), mgr);
+ expr_ref v4(mk_regex_rep_var(), mgr);
+ expr_ref v5(mk_regex_rep_var(), mgr);
- Z3_ast v1 = mk_regexRepVar(t);
- Z3_ast v2 = mk_regexRepVar(t);
- Z3_ast v3 = mk_regexRepVar(t);
- Z3_ast v4 = mk_regexRepVar(t);
- Z3_ast v5 = mk_regexRepVar(t);
+ expr_ref t2(mk_unroll_bound_var(), mgr);
+ expr_ref t3(mk_unroll_bound_var(), mgr);
+ expr_ref emptyStr(m_strutil.mk_string(""), mgr);
- Z3_ast t2 = mk_unrollBoundVar(t);
- Z3_ast t3 = mk_unrollBoundVar(t);
- Z3_ast emptyStr = my_mk_str_value(t, "");
+ expr_ref unroll1(mk_unroll(r1, t2), mgr);
+ expr_ref unroll2(mk_unroll(r1, t3), mgr);
- Z3_ast unroll1 = mk_unroll(t, r1, t2);
- Z3_ast unroll2 = mk_unroll(t, r1, t3);
+ expr_ref op0(ctx.mk_eq_atom(t1, mk_int(0)), mgr);
+ expr_ref op1(m_autil.mk_ge(t1, mk_int(1)), mgr);
- Z3_ast op0 = Z3_mk_eq(ctx, t1, mk_int(ctx, 0));
- Z3_ast op1 = Z3_mk_ge(ctx, t1, mk_int(ctx, 1));
+ expr_ref_vector op1Items(mgr);
+ expr_ref_vector op2Items(mgr);
- std::vector<Z3_ast> op1Items;
- std::vector<Z3_ast> op2Items;
+ op1Items.push_back(ctx.mk_eq_atom(arg1, emptyStr));
+ op1Items.push_back(ctx.mk_eq_atom(arg2, emptyStr));
+ op1Items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(0)));
+ op1Items.push_back(ctx.mk_eq_atom(mk_strlen(arg2), mk_int(0)));
+ expr_ref opAnd1(ctx.mk_eq_atom(op0, mk_and(op1Items)), mgr);
- op1Items.push_back(Z3_mk_eq(ctx, arg1, emptyStr));
- op1Items.push_back(Z3_mk_eq(ctx, arg2, emptyStr));
- op1Items.push_back(Z3_mk_eq(ctx, mk_length(t, arg1), mk_int(ctx, 0)));
- op1Items.push_back(Z3_mk_eq(ctx, mk_length(t, arg2), mk_int(ctx, 0)));
- Z3_ast opAnd1 = Z3_mk_eq(ctx, op0, mk_and_fromVector(t, op1Items));
+ expr_ref v1v2(mk_concat(v1, v2), mgr);
+ op2Items.push_back(ctx.mk_eq_atom(arg1, v1v2));
+ op2Items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), m_autil.mk_add(mk_strlen(v1), mk_strlen(v2))));
+ expr_ref v3v4(mk_concat(v3, v4), mgr);
+ op2Items.push_back(ctx.mk_eq_atom(arg2, v3v4));
+ op2Items.push_back(ctx.mk_eq_atom(mk_strlen(arg2), m_autil.mk_add(mk_strlen(v3), mk_strlen(v4))));
- Z3_ast v1v2 = mk_concat(t, v1, v2);
- op2Items.push_back(Z3_mk_eq(ctx, arg1, v1v2));
- op2Items.push_back(Z3_mk_eq(ctx, mk_length(t, arg1), mk_2_add(t, mk_length(t, v1), mk_length(t, v2))));
- Z3_ast v3v4 = mk_concat(t, v3, v4);
- op2Items.push_back(Z3_mk_eq(ctx, arg2, v3v4));
- op2Items.push_back(Z3_mk_eq(ctx, mk_length(t, arg2), mk_2_add(t, mk_length(t, v3), mk_length(t, v4))));
+ op2Items.push_back(ctx.mk_eq_atom(v1, unroll1));
+ op2Items.push_back(ctx.mk_eq_atom(mk_strlen(v1), mk_strlen(unroll1)));
+ op2Items.push_back(ctx.mk_eq_atom(v4, unroll2));
+ op2Items.push_back(ctx.mk_eq_atom(mk_strlen(v4), mk_strlen(unroll2)));
+ expr_ref v2v3(mk_concat(v2, v3), mgr);
+ op2Items.push_back(ctx.mk_eq_atom(v5, v2v3));
+ reduce_virtual_regex_in(v5, r1, op2Items);
+ op2Items.push_back(ctx.mk_eq_atom(mk_strlen(v5), m_autil.mk_add(mk_strlen(v2), mk_strlen(v3))));
+ op2Items.push_back(ctx.mk_eq_atom(m_autil.mk_add(t2, t3), m_autil.mk_add(t1, mk_int(-1))));
+ expr_ref opAnd2(ctx.mk_eq_atom(op1, mk_and(op2Items)), mgr);
- op2Items.push_back(Z3_mk_eq(ctx, v1, unroll1));
- op2Items.push_back(Z3_mk_eq(ctx, mk_length(t, v1), mk_length(t, unroll1)));
- op2Items.push_back(Z3_mk_eq(ctx, v4, unroll2));
- op2Items.push_back(Z3_mk_eq(ctx, mk_length(t, v4), mk_length(t, unroll2)));
- Z3_ast v2v3 = mk_concat(t, v2, v3);
- op2Items.push_back(Z3_mk_eq(ctx, v5, v2v3));
- reduceVirtualRegexIn(t, v5, r1, op2Items);
- op2Items.push_back(Z3_mk_eq(ctx, mk_length(t, v5), mk_2_add(t, mk_length(t, v2), mk_length(t, v3))));
- op2Items.push_back(Z3_mk_eq(ctx, mk_2_add(t, t2, t3), mk_2_sub(t, t1, mk_int(ctx, 1))));
- Z3_ast opAnd2 = Z3_mk_eq(ctx, op1, mk_and_fromVector(t, op2Items));
+ toAssert = mgr.mk_and(opAnd1, opAnd2);
+ m_trail.push_back(toAssert);
+ concat_eq_unroll_ast_map[key] = toAssert;
+ } else {
+ toAssert = concat_eq_unroll_ast_map[key];
+ }
- toAssert = mk_2_and(t, opAnd1, opAnd2);
- concatEqUnroll_AstMap[key] = toAssert;
- } else {
- toAssert = concatEqUnroll_AstMap[key];
- }
-
- addAxiom(t, toAssert, __LINE__);
- */
+ assert_axiom(toAssert);
}
void theory_str::unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index daf534686..154a66c58 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -163,6 +163,7 @@ namespace smt {
// we would need to modify the allocator so we pass in ast_manager
std::map<expr*, std::map<std::set<expr*>, ptr_vector<expr> > > unroll_tries_map;
std::map<expr*, expr*> unroll_var_map;
+ std::map<std::pair<expr*, expr*>, expr*> concat_eq_unroll_ast_map;
char * char_set;
std::map<char, int> charSetLookupTable;
From 9eead64d03a3e9c58313d5116a2891a031edb567 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 6 Jul 2016 17:31:37 -0400
Subject: [PATCH 139/401] prevent assertion of basic string axioms on variables
that go out of scope (theory_str) this is testing a crash avoidance feature,
the regression is tests/z3str/regex-026.smt2
this also adds some debugging code for a substr() crash but that is WIP
---
src/smt/theory_str.cpp | 27 ++++++++++++++++++++++++++-
1 file changed, 26 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 853924a94..c28132feb 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -799,6 +799,13 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
context & ctx = get_context();
ast_manager & m = get_manager();
+ // TESTING: attempt to avoid a crash here when a variable goes out of scope
+ // TODO this seems to work so we probably need to do this for other propagate checks, etc.
+ if (str->get_iscope_lvl() > ctx.get_scope_level()) {
+ TRACE("t_str_detail", tout << "WARNING: skipping axiom setup on out-of-scope string term" << std::endl;);
+ return;
+ }
+
// generate a stronger axiom for constant strings
app * a_str = str->get_owner();
if (m_strutil.is_string(str->get_owner())) {
@@ -1400,6 +1407,7 @@ void theory_str::reset_eh() {
m_basicstr_axiom_todo.reset();
m_str_eq_todo.reset();
m_concat_axiom_todo.reset();
+ // TODO reset a loooooot more internal stuff
pop_scope_eh(get_context().get_scope_level());
}
@@ -2714,8 +2722,25 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
l_count = 2;
lenDelta = str_len - y_len;
}
+ TRACE("t_str",
+ tout
+ << "xLen? " << (x_len_exists ? "yes" : "no") << std::endl
+ << "mLen? " << (m_len_exists ? "yes" : "no") << std::endl
+ << "yLen? " << (y_len_exists ? "yes" : "no") << std::endl
+ << "xLen = " << x_len.to_string() << std::endl
+ << "yLen = " << y_len.to_string() << std::endl
+ << "mLen = " << m_len.to_string() << std::endl
+ << "strLen = " << str_len.to_string() << std::endl
+ << "lenDelta = " << lenDelta.to_string() << std::endl
+ << "strValue = \"" << strValue << "\" (len=" << strValue.length() << ")" << std::endl
+ ;
+ );
+
+ TRACE("t_str", tout << "*** MARKER 1 ***" << std::endl;);
std::string part1Str = strValue.substr(0, lenDelta.get_unsigned());
+ TRACE("t_str", tout << "*** MARKER 2 ***" << std::endl;);
std::string part2Str = strValue.substr(lenDelta.get_unsigned(), strValue.length() - lenDelta.get_unsigned());
+ TRACE("t_str", tout << "*** MARKER 3 ***" << std::endl;);
expr_ref prefixStr(m_strutil.mk_string(part1Str), mgr);
expr_ref x_concat(mk_concat(m, prefixStr), mgr);
@@ -5495,7 +5520,7 @@ final_check_status theory_str::final_check_eh() {
}
TRACE("t_str", tout << "final check" << std::endl;);
- TRACE("t_str_detail", dump_assignments(););
+ TRACE("t_str_dump_assign", dump_assignments(););
// run dependence analysis to find free string variables
std::map<expr*, int> varAppearInAssign;
From 847a5fc1f82b437b46db0d9cc8b813560141050f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 7 Jul 2016 16:13:48 -0400
Subject: [PATCH 140/401] replace old mk_value behaviour in theory_str that
creates placeholders for unused terms instead of crashing
---
src/smt/theory_str.cpp | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index c28132feb..0626c6ac5 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6844,8 +6844,7 @@ model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
TRACE("t_str", tout << "WARNING: failed to find a concrete value, falling back" << std::endl;);
// TODO make absolutely sure the reason we can't find a concrete value is because of an unassigned temporary
// e.g. for an expression like (Concat X $$_str0)
- //return alloc(expr_wrapper_proc, m_strutil.mk_string("**UNUSED**"));
- NOT_IMPLEMENTED_YET();
+ return alloc(expr_wrapper_proc, m_strutil.mk_string("**UNUSED**"));
}
}
From 8aa6fee0af66b6e2dd465dc52b4dbc23c1b719b0 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 8 Jul 2016 12:21:11 -0400
Subject: [PATCH 141/401] fixups wip
---
src/smt/theory_str.cpp | 5 +++++
1 file changed, 5 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 0626c6ac5..aaecdb011 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -141,6 +141,10 @@ void theory_str::assert_axiom(expr * e) {
literal lit(ctx.get_literal(e));
ctx.mark_as_relevant(lit);
ctx.mk_th_axiom(get_id(), 1, &lit);
+
+ // crash/error avoidance: add all axioms to the trail
+ m_trail.push_back(e);
+
TRACE("t_str_detail", tout << "done asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
}
@@ -4622,6 +4626,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
unsigned count = 0;
std::set<expr*> vars = it->second;
for (std::set<expr*>::iterator var_it = vars.begin(); var_it != vars.end(); ++var_it) {
+ TRACE("t_str_detail", tout << "clean up variable " << mk_pp(*var_it, get_manager()) << std::endl;);
variable_set.erase(*var_it);
internal_variable_set.erase(*var_it);
regex_variable_set.erase(*var_it);
From 8d47b082446cf4292643a3fc1e333db2e355e09d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 10 Jul 2016 13:05:41 -0400
Subject: [PATCH 142/401] fix out-of-scope value tester bug in
theory_str::gen_free_var_options() we now pass tests/z3str/charAt-003.smt2
with detailed debugging turned off!
---
src/smt/theory_str.cpp | 24 ++++++++++++++++++++++--
1 file changed, 22 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index aaecdb011..06b221acd 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -5968,8 +5968,28 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
int len = atoi(len_valueStr.c_str());
- if (fvar_valueTester_map[freeVar].find(len) == fvar_valueTester_map[freeVar].end()) {
- TRACE("t_str_detail", tout << "no previous value testers" << std::endl;);
+ // check whether any value tester is actually in scope
+ // TODO NEXT we need to do this check for other tester variables that could potentially go out of scope
+ TRACE("t_str_detail", tout << "checking scope of previous value testers" << std::endl;);
+ bool map_effectively_empty = true;
+ if (fvar_valueTester_map[freeVar].find(len) != fvar_valueTester_map[freeVar].end()) {
+ // there's *something* in the map, but check its scope
+ svector<std::pair<int, expr*> > entries = fvar_valueTester_map[freeVar][len];
+ for (svector<std::pair<int,expr*> >::iterator it = entries.begin(); it != entries.end(); ++it) {
+ std::pair<int,expr*> entry = *it;
+ expr * aTester = entry.second;
+ if (internal_variable_set.find(aTester) == internal_variable_set.end()) {
+ TRACE("t_str_detail", tout << mk_pp(aTester, m) << " out of scope" << std::endl;);
+ } else {
+ TRACE("t_str_detail", tout << mk_pp(aTester, m) << " in scope" << std::endl;);
+ map_effectively_empty = false;
+ break;
+ }
+ }
+ }
+
+ if (map_effectively_empty) {
+ TRACE("t_str_detail", tout << "no previous value testers, or none of them were in scope" << std::endl;);
int tries = 0;
expr * val_indicator = mk_internal_valTest_var(freeVar, len, tries);
valueTester_fvar_map[val_indicator] = freeVar;
From 9ffcd135d5d2217c1ddd0328228d352145ec71ec Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 19 Jul 2016 15:47:41 -0400
Subject: [PATCH 143/401] add RegexPlus to theory_str
---
src/ast/rewriter/str_rewriter.cpp | 24 ++++++++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
src/ast/str_decl_plugin.cpp | 7 +++++++
src/ast/str_decl_plugin.h | 17 ++++++++++++++++-
4 files changed, 48 insertions(+), 1 deletion(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 3a0300ae4..a40d52aa1 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -219,6 +219,27 @@ br_status str_rewriter::mk_re_RegexIn(expr * str, expr * re, expr_ref & result)
return BR_FAILED;
}
+br_status str_rewriter::mk_re_RegexPlus(expr * re, expr_ref & result) {
+ /*
+ * Two optimizations are possible if we inspect 're'.
+ * If 're' is (RegexPlus X), then reduce to 're'.
+ * If 're' is (RegexStar X), then reduce to 're'.
+ * Otherwise, reduce to (RegexConcat re (RegexStar re)).
+ */
+
+ if (m_strutil.is_re_RegexPlus(re)) {
+ result = re;
+ return BR_REWRITE_FULL;
+ } else if (m_strutil.is_re_RegexStar(re)) {
+ // Z3str2 re-created the AST under 're' here, but I don't think we need to do that
+ result = re;
+ return BR_REWRITE_FULL;
+ } else {
+ result = m_strutil.mk_re_RegexConcat(re, m_strutil.mk_re_RegexStar(re));
+ return BR_REWRITE_FULL;
+ }
+}
+
br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
SASSERT(f->get_family_id() == get_fid());
@@ -256,6 +277,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_RE_REGEXIN:
SASSERT(num_args == 2);
return mk_re_RegexIn(args[0], args[1], result);
+ case OP_RE_REGEXPLUS:
+ SASSERT(num_args == 1);
+ return mk_re_RegexPlus(args[0], result);
default:
return BR_FAILED;
}
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index 5c0e1167f..bd79ed7a1 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -51,6 +51,7 @@ public:
br_status mk_re_Str2Reg(expr * str, expr_ref & result);
br_status mk_re_RegexIn(expr * str, expr * re, expr_ref & result);
+ br_status mk_re_RegexPlus(expr * re, expr_ref & result);
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index ef94272c7..45ff37b0f 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -42,6 +42,7 @@ str_decl_plugin::str_decl_plugin():
m_re_regexstar_decl(0),
m_re_regexunion_decl(0),
m_re_unroll_decl(0),
+ m_re_regexplus_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -70,6 +71,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_re_regexconcat_decl);
DEC_REF(m_re_regexstar_decl);
DEC_REF(m_re_regexunion_decl);
+ DEC_REF(m_re_regexplus_decl);
DEC_REF(m_re_unroll_decl);
DEC_REF(m_int_sort);
}
@@ -153,6 +155,9 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_re_regexstar_decl = m->mk_func_decl(symbol("RegexStar"), re, re, func_decl_info(id, OP_RE_REGEXSTAR));
m_manager->inc_ref(m_re_regexstar_decl);
+ m_re_regexplus_decl = m->mk_func_decl(symbol("RegexPlus"), re, re, func_decl_info(id, OP_RE_REGEXPLUS));
+ m_manager->inc_ref(m_re_regexplus_decl);
+
m_re_regexunion_decl = m->mk_func_decl(symbol("RegexUnion"), re, re, re, func_decl_info(id, OP_RE_REGEXUNION));
m_manager->inc_ref(m_re_regexunion_decl);
@@ -190,6 +195,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_RE_REGEXIN: return m_re_regexin_decl;
case OP_RE_REGEXCONCAT: return m_re_regexconcat_decl;
case OP_RE_REGEXSTAR: return m_re_regexstar_decl;
+ case OP_RE_REGEXPLUS: return m_re_regexplus_decl;
case OP_RE_REGEXUNION: return m_re_regexunion_decl;
case OP_RE_UNROLL: return m_re_unroll_decl;
default: return 0;
@@ -262,6 +268,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("RegexConcat", OP_RE_REGEXCONCAT));
op_names.push_back(builtin_name("RegexStar", OP_RE_REGEXSTAR));
op_names.push_back(builtin_name("RegexUnion", OP_RE_REGEXUNION));
+ op_names.push_back(builtin_name("RegexPlus", OP_RE_REGEXPLUS));
op_names.push_back(builtin_name("Unroll", OP_RE_UNROLL));
}
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index c2ad088a4..902e2208f 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -48,6 +48,8 @@ enum str_op_kind {
OP_RE_REGEXSTAR,
OP_RE_REGEXUNION,
OP_RE_UNROLL,
+ // higher-level regex operators
+ OP_RE_REGEXPLUS,
// end
LAST_STR_OP
};
@@ -77,6 +79,7 @@ protected:
func_decl * m_re_regexstar_decl;
func_decl * m_re_regexunion_decl;
func_decl * m_re_unroll_decl;
+ func_decl * m_re_regexplus_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
@@ -120,6 +123,8 @@ public:
bool is_string(expr const * n) const;
bool is_re_Str2Reg(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_STR2REGEX); }
+ bool is_re_RegexStar(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_REGEXSTAR); }
+ bool is_re_RegexPlus(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_REGEXPLUS); }
std::string get_string_constant_value(expr const *n) const;
// TODO
@@ -142,7 +147,17 @@ public:
app * mk_fresh_string() {
return m_plugin->mk_fresh_string();
}
- // TODO
+
+ app * mk_re_RegexConcat(expr * e1, expr * e2) {
+ expr * es[2] = {e1, e2};
+ return m_manager.mk_app(get_fid(), OP_RE_REGEXCONCAT, 2, es);
+ }
+
+ app * mk_re_RegexStar(expr * r) {
+ expr * es[1] = {r};
+ return m_manager.mk_app(get_fid(), OP_RE_REGEXSTAR, 1, es);
+ }
+
};
#endif /* _STR_DECL_PLUGIN_H_ */
From 0f382037799c9ccab63ecb7cf5ea97c1a1aab3ac Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 19 Jul 2016 16:39:43 -0400
Subject: [PATCH 144/401] add RegexCharRange to theory_str
---
src/ast/rewriter/str_rewriter.cpp | 37 ++++++++++++++++++++++++++++---
src/ast/rewriter/str_rewriter.h | 1 +
src/ast/str_decl_plugin.cpp | 7 ++++++
src/ast/str_decl_plugin.h | 16 +++++++++++++
4 files changed, 58 insertions(+), 3 deletions(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index a40d52aa1..1449afcc3 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -200,8 +200,7 @@ br_status str_rewriter::mk_str_Replace(expr * base, expr * source, expr * target
br_status str_rewriter::mk_re_Str2Reg(expr * str, expr_ref & result) {
// the argument to Str2Reg *must* be a string constant
- // TODO is an assertion error too strict here? this basically crashes the solver
- VERIFY(m_strutil.is_string(str));
+ ENSURE(m_strutil.is_string(str));
return BR_FAILED;
}
@@ -211,7 +210,7 @@ br_status str_rewriter::mk_re_RegexIn(expr * str, expr * re, expr_ref & result)
if (m_strutil.is_re_Str2Reg(re)) {
TRACE("t_str_rw", tout << "RegexIn fast path: " << mk_pp(str, m()) << " in " << mk_pp(re, m()) << std::endl;);
expr * regexStr = to_app(re)->get_arg(0);
- VERIFY(m_strutil.is_string(regexStr));
+ ENSURE(m_strutil.is_string(regexStr));
result = m().mk_eq(str, regexStr);
return BR_REWRITE_FULL;
}
@@ -240,6 +239,35 @@ br_status str_rewriter::mk_re_RegexPlus(expr * re, expr_ref & result) {
}
}
+br_status str_rewriter::mk_re_RegexCharRange(expr * start, expr * end, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (RegexCharRange " << mk_pp(start, m()) << " " << mk_pp(end, m()) << ")" << std::endl;);
+ // both 'start' and 'end' must be string constants
+ ENSURE(m_strutil.is_string(start) && m_strutil.is_string(end));
+ std::string arg0Value = m_strutil.get_string_constant_value(start);
+ std::string arg1Value = m_strutil.get_string_constant_value(end);
+ ENSURE(arg0Value.length() == 1 && arg1Value.length() == 1);
+ char low = arg0Value[0];
+ char high = arg1Value[0];
+ if (low > high) {
+ char t = low;
+ low = high;
+ high = t;
+ }
+
+ char c = low;
+ std::string cStr;
+ cStr.push_back(c);
+ expr * res = m_strutil.mk_re_Str2Reg(cStr);
+ c++;
+ for (; c <= high; c++) {
+ cStr.clear();
+ cStr.push_back(c);
+ res = m_strutil.mk_re_RegexUnion(res, m_strutil.mk_re_Str2Reg(cStr));
+ }
+ result = res;
+ return BR_DONE;
+}
+
br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
SASSERT(f->get_family_id() == get_fid());
@@ -280,6 +308,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_RE_REGEXPLUS:
SASSERT(num_args == 1);
return mk_re_RegexPlus(args[0], result);
+ case OP_RE_REGEXCHARRANGE:
+ SASSERT(num_args == 2);
+ return mk_re_RegexCharRange(args[0], args[1], result);
default:
return BR_FAILED;
}
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index bd79ed7a1..dccf4a6bd 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -52,6 +52,7 @@ public:
br_status mk_re_Str2Reg(expr * str, expr_ref & result);
br_status mk_re_RegexIn(expr * str, expr * re, expr_ref & result);
br_status mk_re_RegexPlus(expr * re, expr_ref & result);
+ br_status mk_re_RegexCharRange(expr * start, expr * end, expr_ref & result);
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 45ff37b0f..08358d46b 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -43,6 +43,7 @@ str_decl_plugin::str_decl_plugin():
m_re_regexunion_decl(0),
m_re_unroll_decl(0),
m_re_regexplus_decl(0),
+ m_re_regexcharrange_decl(0),
m_arith_plugin(0),
m_arith_fid(0),
m_int_sort(0){
@@ -72,6 +73,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_re_regexstar_decl);
DEC_REF(m_re_regexunion_decl);
DEC_REF(m_re_regexplus_decl);
+ DEC_REF(m_re_regexcharrange_decl);
DEC_REF(m_re_unroll_decl);
DEC_REF(m_int_sort);
}
@@ -164,6 +166,9 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_re_unroll_decl = m->mk_func_decl(symbol("Unroll"), re, i, s, func_decl_info(id, OP_RE_UNROLL));
m_manager->inc_ref(m_re_unroll_decl);
+ m_re_regexcharrange_decl = m->mk_func_decl(symbol("RegexCharRange"), s, s, re, func_decl_info(id, OP_RE_REGEXCHARRANGE));
+ m_manager->inc_ref(m_re_regexcharrange_decl);
+
}
decl_plugin * str_decl_plugin::mk_fresh() {
@@ -198,6 +203,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_RE_REGEXPLUS: return m_re_regexplus_decl;
case OP_RE_REGEXUNION: return m_re_regexunion_decl;
case OP_RE_UNROLL: return m_re_unroll_decl;
+ case OP_RE_REGEXCHARRANGE: return m_re_regexcharrange_decl;
default: return 0;
}
}
@@ -270,6 +276,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("RegexUnion", OP_RE_REGEXUNION));
op_names.push_back(builtin_name("RegexPlus", OP_RE_REGEXPLUS));
op_names.push_back(builtin_name("Unroll", OP_RE_UNROLL));
+ op_names.push_back(builtin_name("RegexCharRange", OP_RE_REGEXCHARRANGE));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 902e2208f..4b7a8858e 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -50,6 +50,7 @@ enum str_op_kind {
OP_RE_UNROLL,
// higher-level regex operators
OP_RE_REGEXPLUS,
+ OP_RE_REGEXCHARRANGE,
// end
LAST_STR_OP
};
@@ -80,6 +81,7 @@ protected:
func_decl * m_re_regexunion_decl;
func_decl * m_re_unroll_decl;
func_decl * m_re_regexplus_decl;
+ func_decl * m_re_regexcharrange_decl;
arith_decl_plugin * m_arith_plugin;
family_id m_arith_fid;
@@ -148,6 +150,20 @@ public:
return m_plugin->mk_fresh_string();
}
+ app * mk_re_Str2Reg(expr * s) {
+ expr * es[1] = {s};
+ return m_manager.mk_app(get_fid(), OP_RE_STR2REGEX, 1, es);
+ }
+
+ app * mk_re_Str2Reg(std::string s) {
+ return mk_re_Str2Reg(mk_string(s));
+ }
+
+ app * mk_re_RegexUnion(expr * e1, expr * e2) {
+ expr * es[2] = {e1, e2};
+ return m_manager.mk_app(get_fid(), OP_RE_REGEXUNION, 2, es);
+ }
+
app * mk_re_RegexConcat(expr * e1, expr * e2) {
expr * es[2] = {e1, e2};
return m_manager.mk_app(get_fid(), OP_RE_REGEXCONCAT, 2, es);
From ac16aa7c818e5bd3ead0ab45c5d03cc0953d162b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 23 Jul 2016 16:02:11 -0400
Subject: [PATCH 145/401] fix out-of-scope variable bug in
theory_str::process_concat_eq_type6
this fix will have to be made to all functions that use varForBreakConcat
---
src/smt/theory_str.cpp | 47 ++++++++++++++++++++++++++++++++++++------
1 file changed, 41 insertions(+), 6 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 06b221acd..28f972164 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3363,18 +3363,53 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
expr * xorFlag = NULL;
std::pair<expr*, expr*> key1(concatAst1, concatAst2);
std::pair<expr*, expr*> key2(concatAst2, concatAst1);
- if (varForBreakConcat.find(key1) == varForBreakConcat.end() && varForBreakConcat.find(key2) == varForBreakConcat.end()) {
+
+ // check the entries in this map to make sure they're still in scope
+ // before we use them.
+ // TODO something very similar might have to be done elsewhere when we use this map, if this works.
+
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
+
+ bool entry1InScope;
+ if (entry1 == varForBreakConcat.end()) {
+ entry1InScope = false;
+ } else {
+ if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
+ || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()) {
+ entry1InScope = false;
+ } else {
+ entry1InScope = true;
+ }
+ }
+
+ bool entry2InScope;
+ if (entry2 == varForBreakConcat.end()) {
+ entry2InScope = false;
+ } else {
+ if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
+ || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()) {
+ entry2InScope = false;
+ } else {
+ entry2InScope = true;
+ }
+ }
+
+ TRACE("t_str_detail", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
+
+ if (!entry1InScope && !entry2InScope) {
commonVar = mk_nonempty_str_var();
xorFlag = mk_internal_xor_var();
varForBreakConcat[key1][0] = commonVar;
varForBreakConcat[key1][1] = xorFlag;
} else {
- if (varForBreakConcat.find(key1) != varForBreakConcat.end()) {
- commonVar = varForBreakConcat[key1][0];
- xorFlag = varForBreakConcat[key1][1];
+ if (entry1InScope) {
+ commonVar = (entry1->second)[0];
+ xorFlag = (entry1->second)[1];
} else {
- commonVar = varForBreakConcat[key2][0];
- xorFlag = varForBreakConcat[key2][1];
+ commonVar = (entry2->second)[0];
+ xorFlag = (entry2->second)[1];
}
}
From 02a66c425ee6603961802de8c1a64163f61b4fe4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 23 Jul 2016 22:43:46 -0400
Subject: [PATCH 146/401] add option to bypass quick returns in integer theory
integration in theory_str
this might not actually be that useful, if the problem is, as I suspect it to be,
that values we get from the integer theory need not correspond with
assertions in the core (that can get popped off the stack, etc.)
---
src/smt/theory_str.cpp | 212 ++++++++++++++++++++++++++++++++++++-----
src/smt/theory_str.h | 9 ++
2 files changed, 196 insertions(+), 25 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 28f972164..d77290b46 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -33,6 +33,7 @@ theory_str::theory_str(ast_manager & m):
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
+ opt_NoQuickReturn_Concat_IntegerTheory(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -145,7 +146,7 @@ void theory_str::assert_axiom(expr * e) {
// crash/error avoidance: add all axioms to the trail
m_trail.push_back(e);
- TRACE("t_str_detail", tout << "done asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
+ //TRACE("t_str_detail", tout << "done asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
}
void theory_str::assert_implication(expr * premise, expr * conclusion) {
@@ -2049,8 +2050,16 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
TRACE("t_str", tout << "nn1 = " << mk_ismt2_pp(nn1, m) << std::endl
<< "nn2 = " << mk_ismt2_pp(nn2, m) << std::endl;);
+ TRACE("t_str_detail", tout
+ << "len(" << mk_pp(a1_arg0, m) << ") = " << (a1_arg0_len_exists ? a1_arg0_len.to_string() : "?") << std::endl
+ << "len(" << mk_pp(a1_arg1, m) << ") = " << (a1_arg1_len_exists ? a1_arg1_len.to_string() : "?") << std::endl
+ << "len(" << mk_pp(a2_arg0, m) << ") = " << (a2_arg0_len_exists ? a2_arg0_len.to_string() : "?") << std::endl
+ << "len(" << mk_pp(a2_arg1, m) << ") = " << (a2_arg1_len_exists ? a2_arg1_len.to_string() : "?") << std::endl
+ << std::endl;);
+
infer_len_concat_equality(nn1, nn2);
+ // TODO we may want to add no-quick-return options for these as well
if (a1_arg0 == a2_arg0) {
if (!in_same_eqc(a1_arg1, a2_arg1)) {
expr_ref premise(ctx.mk_eq_atom(nn1, nn2), m);
@@ -2077,6 +2086,8 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
// quick path
+ // TODO we may want to add no-quick-return options for these as well
+
if (in_same_eqc(a1_arg0, a2_arg0)) {
if (in_same_eqc(a1_arg1, a2_arg1)) {
TRACE("t_str_detail", tout << "SKIP: a1_arg0 =~ a2_arg0 and a1_arg1 =~ a2_arg1" << std::endl;);
@@ -2111,7 +2122,12 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
expr_ref conclusion(m.mk_and(ax_r1, ax_r2), m);
assert_implication(premise, conclusion);
- return;
+
+ if (opt_NoQuickReturn_Concat_IntegerTheory) {
+ TRACE("t_str_detail", tout << "bypassing quick return from the end of this case" << std::endl;);
+ } else {
+ return;
+ }
}
}
@@ -2127,7 +2143,11 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
expr_ref conclusion(m.mk_and(ax_r1, ax_r2), m);
assert_implication(premise, conclusion);
- return;
+ if (opt_NoQuickReturn_Concat_IntegerTheory) {
+ TRACE("t_str_detail", tout << "bypassing quick return from the end of this case" << std::endl;);
+ } else {
+ return;
+ }
}
}
@@ -2328,7 +2348,42 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
std::pair<expr*, expr*> key1(concatAst1, concatAst2);
std::pair<expr*, expr*> key2(concatAst2, concatAst1);
- if (varForBreakConcat.find(key1) == varForBreakConcat.end() && varForBreakConcat.find(key2) == varForBreakConcat.end()) {
+ // check the entries in this map to make sure they're still in scope
+ // before we use them.
+
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
+
+ bool entry1InScope;
+ if (entry1 == varForBreakConcat.end()) {
+ entry1InScope = false;
+ } else {
+ if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
+ || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()
+ || internal_variable_set.find((entry1->second)[2]) == internal_variable_set.end()) {
+ entry1InScope = false;
+ } else {
+ entry1InScope = true;
+ }
+ }
+
+ bool entry2InScope;
+ if (entry2 == varForBreakConcat.end()) {
+ entry2InScope = false;
+ } else {
+ if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
+ || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()
+ || internal_variable_set.find((entry2->second)[2]) == internal_variable_set.end()) {
+ entry2InScope = false;
+ } else {
+ entry2InScope = true;
+ }
+ }
+
+ TRACE("t_str_detail", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
+
+ if (!entry1InScope && !entry2InScope) {
t1 = mk_nonempty_str_var();
t2 = mk_nonempty_str_var();
xorFlag = mk_internal_xor_var();
@@ -2339,7 +2394,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
varForBreakConcat[key1][2] = xorFlag;
} else {
// match found
- if (varForBreakConcat.find(key1) != varForBreakConcat.end()) {
+ if (entry1InScope) {
t1 = varForBreakConcat[key1][0];
t2 = varForBreakConcat[key1][1];
xorFlag = varForBreakConcat[key1][2];
@@ -2619,17 +2674,50 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
std::pair<expr*, expr*> key1(concatAst1, concatAst2);
std::pair<expr*, expr*> key2(concatAst2, concatAst1);
- if (varForBreakConcat.find(key1) == varForBreakConcat.end()
- && varForBreakConcat.find(key2) == varForBreakConcat.end()) {
+ // check the entries in this map to make sure they're still in scope
+ // before we use them.
+
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
+
+ bool entry1InScope;
+ if (entry1 == varForBreakConcat.end()) {
+ entry1InScope = false;
+ } else {
+ if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
+ || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()) {
+ entry1InScope = false;
+ } else {
+ entry1InScope = true;
+ }
+ }
+
+ bool entry2InScope;
+ if (entry2 == varForBreakConcat.end()) {
+ entry2InScope = false;
+ } else {
+ if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
+ || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()) {
+ entry2InScope = false;
+ } else {
+ entry2InScope = true;
+ }
+ }
+
+ TRACE("t_str_detail", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
+
+
+ if (!entry1InScope && !entry2InScope) {
temp1 = mk_nonempty_str_var();
xorFlag = mk_internal_xor_var();
varForBreakConcat[key1][0] = temp1;
varForBreakConcat[key1][1] = xorFlag;
} else {
- if (varForBreakConcat.find(key1) != varForBreakConcat.end()) {
+ if (entry1InScope) {
temp1 = varForBreakConcat[key1][0];
xorFlag = varForBreakConcat[key1][1];
- } else if (varForBreakConcat.find(key2) != varForBreakConcat.end()) {
+ } else if (entry2InScope) {
temp1 = varForBreakConcat[key2][0];
xorFlag = varForBreakConcat[key2][1];
}
@@ -2888,7 +2976,6 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
std::string strValue = m_strutil.get_string_constant_value(strAst);
- // TODO integer theory interaction
rational x_len, y_len, str_len, n_len;
bool x_len_exists = get_len_value(x, x_len);
bool y_len_exists = get_len_value(y, y_len);
@@ -2899,14 +2986,49 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
expr_ref temp1(mgr);
std::pair<expr*, expr*> key1(concatAst1, concatAst2);
std::pair<expr*, expr*> key2(concatAst2, concatAst1);
- if (varForBreakConcat.find(key1) == varForBreakConcat.end() && varForBreakConcat.find(key2) == varForBreakConcat.end()) {
+
+ // check the entries in this map to make sure they're still in scope
+ // before we use them.
+
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
+
+ bool entry1InScope;
+ if (entry1 == varForBreakConcat.end()) {
+ entry1InScope = false;
+ } else {
+ if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
+ || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()) {
+ entry1InScope = false;
+ } else {
+ entry1InScope = true;
+ }
+ }
+
+ bool entry2InScope;
+ if (entry2 == varForBreakConcat.end()) {
+ entry2InScope = false;
+ } else {
+ if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
+ || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()) {
+ entry2InScope = false;
+ } else {
+ entry2InScope = true;
+ }
+ }
+
+ TRACE("t_str_detail", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
+
+
+ if (!entry1InScope && !entry2InScope) {
temp1 = mk_nonempty_str_var();
xorFlag = mk_internal_xor_var();
varForBreakConcat[key1][0] = temp1;
varForBreakConcat[key1][1] = xorFlag;
} else {
- if (varForBreakConcat.find(key1) != varForBreakConcat.end()) {
+ if (entry1InScope) {
temp1 = varForBreakConcat[key1][0];
xorFlag = varForBreakConcat[key1][1];
} else if (varForBreakConcat.find(key2) != varForBreakConcat.end()) {
@@ -3366,7 +3488,6 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
// check the entries in this map to make sure they're still in scope
// before we use them.
- // TODO something very similar might have to be done elsewhere when we use this map, if this works.
std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
@@ -4084,16 +4205,44 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
expr_ref xorFlag(m);
std::pair<expr*, expr*> key1(arg1, arg2);
std::pair<expr*, expr*> key2(arg2, arg1);
- std::map<std::pair<expr*, expr*>, std::map<int, expr*> >::iterator varBreak_key1 =
- varForBreakConcat.find(key1);
- std::map<std::pair<expr*, expr*>, std::map<int, expr*> >::iterator varBreak_key2 =
- varForBreakConcat.find(key2);
- if (varBreak_key1 == varForBreakConcat.end() && varBreak_key2 == varForBreakConcat.end()) {
+
+ // check the entries in this map to make sure they're still in scope
+ // before we use them.
+
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
+
+ bool entry1InScope;
+ if (entry1 == varForBreakConcat.end()) {
+ entry1InScope = false;
+ } else {
+ if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()) {
+ entry1InScope = false;
+ } else {
+ entry1InScope = true;
+ }
+ }
+
+ bool entry2InScope;
+ if (entry2 == varForBreakConcat.end()) {
+ entry2InScope = false;
+ } else {
+ if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()) {
+ entry2InScope = false;
+ } else {
+ entry2InScope = true;
+ }
+ }
+
+ TRACE("t_str_detail", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
+
+ if (!entry1InScope && !entry2InScope) {
xorFlag = mk_internal_xor_var();
varForBreakConcat[key1][0] = xorFlag;
- } else if (varBreak_key1 != varForBreakConcat.end()) {
+ } else if (entry1InScope) {
xorFlag = varForBreakConcat[key1][0];
- } else { // varBreak_key2 != varForBreakConcat.end()
+ } else { // entry2InScope
xorFlag = varForBreakConcat[key2][0];
}
@@ -4632,7 +4781,7 @@ void theory_str::push_scope_eh() {
context & ctx = get_context();
sLevel += 1;
TRACE("t_str", tout << "push to " << sLevel << std::endl;);
- TRACE("t_str_dump_assign", dump_assignments(););
+ TRACE("t_str_dump_assign_on_scope_change", dump_assignments(););
}
void theory_str::pop_scope_eh(unsigned num_scopes) {
@@ -4683,7 +4832,7 @@ void theory_str::dump_assignments() {
ctx.get_assignments(assignments);
for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
expr * ex = *i;
- tout << mk_ismt2_pp(ex, m) << std::endl;
+ tout << mk_ismt2_pp(ex, m) << (ctx.is_relevant(ex) ? "" : " (NOT REL)") << std::endl;
}
);
}
@@ -4697,6 +4846,9 @@ void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap
if (variable_set.find(node) != variable_set.end()
&& internal_lenTest_vars.find(node) == internal_lenTest_vars.end()
&& internal_valTest_vars.find(node) == internal_valTest_vars.end()) {
+ if (varMap[node] != 1) {
+ TRACE("t_str_detail", tout << "new variable: " << mk_pp(node, get_manager()) << std::endl;);
+ }
varMap[node] = 1;
}
// check whether the node is a function that we want to inspect
@@ -4755,6 +4907,10 @@ void theory_str::classify_ast_by_type_in_positive_context(std::map<expr*, int> &
// so we bypass a huge amount of work by doing the following...
if (m.is_eq(argAst)) {
+ TRACE("t_str_detail", tout
+ << "eq ast " << mk_pp(argAst, m) << " is between args of sort "
+ << m.get_sort(to_app(argAst)->get_arg(0))->get_name()
+ << std::endl;);
classify_ast_by_type(argAst, varMap, concatMap, unrollMap);
}
}
@@ -4976,6 +5132,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
for(std::set<expr*>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
expr* var = *it;
if (internal_variable_set.find(var) == internal_variable_set.end()) {
+ TRACE("t_str_detail", tout << "new variable: " << mk_pp(var, m) << std::endl;);
strVarMap[*it] = 1;
}
}
@@ -5716,7 +5873,7 @@ final_check_status theory_str::final_check_eh() {
constValue = NULL;
{
- TRACE("t_str_detail", tout << "free var map (# " << freeVar_map.size() << "):" << std::endl;
+ TRACE("t_str_detail", tout << "free var map (#" << freeVar_map.size() << "):" << std::endl;
for (std::map<expr*, int>::iterator freeVarItor1 = freeVar_map.begin(); freeVarItor1 != freeVar_map.end(); freeVarItor1++) {
expr * freeVar = freeVarItor1->first;
rational lenValue;
@@ -5764,7 +5921,7 @@ final_check_status theory_str::final_check_eh() {
// experimental free variable assignment - end
// now deal with removed free variables that are bounded by an unroll
- TRACE("t_str", tout << "fv_unrolls_map (#" << fv_unrolls_map.size() << ")" << std::endl;);
+ TRACE("t_str", tout << "fv_unrolls_map (#" << fv_unrolls_map.size() << "):" << std::endl;);
for (std::map<expr*, std::set<expr*> >::iterator fvIt1 = fv_unrolls_map.begin();
fvIt1 != fv_unrolls_map.end(); fvIt1++) {
expr * var = fvIt1->first;
@@ -6004,7 +6161,6 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
int len = atoi(len_valueStr.c_str());
// check whether any value tester is actually in scope
- // TODO NEXT we need to do this check for other tester variables that could potentially go out of scope
TRACE("t_str_detail", tout << "checking scope of previous value testers" << std::endl;);
bool map_effectively_empty = true;
if (fvar_valueTester_map[freeVar].find(len) != fvar_valueTester_map[freeVar].end()) {
@@ -6042,6 +6198,12 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
for (; i < testerTotal; i++) {
expr * aTester = fvar_valueTester_map[freeVar][len][i].second;
+ // it's probably worth checking scope here, actually
+ if (internal_variable_set.find(aTester) == internal_variable_set.end()) {
+ TRACE("t_str_detail", tout << "value tester " << mk_pp(aTester, m) << " out of scope, skipping" << std::endl;);
+ continue;
+ }
+
if (aTester == valTesterInCbEq) {
break;
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 154a66c58..d2b51a712 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -94,6 +94,15 @@ namespace smt {
*/
int opt_LCMUnrollStep;
+ /*
+ * If NoQuickReturn_Concat_IntegerTheory is set to true,
+ * the integer theory integration conditionals in simplify_concat_equality()
+ * will not return from the function after asserting their axioms.
+ * This means that control will fall through to the type 1-6 axioms,
+ * causing those to be added as well.
+ */
+ bool opt_NoQuickReturn_Concat_IntegerTheory;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
From f555074e27c6b570546cd27bd5410cf88af3faf1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 23 Jul 2016 23:29:56 -0400
Subject: [PATCH 147/401] add option to disable integer theory integration in
theory_str; this is currently ENABLED
---
src/smt/theory_str.cpp | 21 +++++++++++++++++++++
src/smt/theory_str.h | 16 ++++++++++++++++
2 files changed, 37 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index d77290b46..35bc7ab20 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -34,6 +34,7 @@ theory_str::theory_str(ast_manager & m):
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
opt_NoQuickReturn_Concat_IntegerTheory(true),
+ opt_DisableIntegerTheoryIntegration(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -3747,6 +3748,11 @@ static theory_mi_arith* get_th_arith(context& ctx, theory_id afid, expr* e) {
}
bool theory_str::get_value(expr* e, rational& val) const {
+ if (opt_DisableIntegerTheoryIntegration) {
+ TRACE("t_str_detail", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ return false;
+ }
+
context& ctx = get_context();
ast_manager & m = get_manager();
theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
@@ -3773,6 +3779,11 @@ bool theory_str::get_value(expr* e, rational& val) const {
}
bool theory_str::lower_bound(expr* _e, rational& lo) {
+ if (opt_DisableIntegerTheoryIntegration) {
+ TRACE("t_str_detail", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ return false;
+ }
+
context& ctx = get_context();
ast_manager & m = get_manager();
theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), _e);
@@ -3782,6 +3793,11 @@ bool theory_str::lower_bound(expr* _e, rational& lo) {
}
bool theory_str::upper_bound(expr* _e, rational& hi) {
+ if (opt_DisableIntegerTheoryIntegration) {
+ TRACE("t_str_detail", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ return false;
+ }
+
context& ctx = get_context();
ast_manager & m = get_manager();
theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), _e);
@@ -3791,6 +3807,11 @@ bool theory_str::upper_bound(expr* _e, rational& hi) {
}
bool theory_str::get_len_value(expr* e, rational& val) {
+ if (opt_DisableIntegerTheoryIntegration) {
+ TRACE("t_str_detail", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ return false;
+ }
+
context& ctx = get_context();
ast_manager & m = get_manager();
theory* th = ctx.get_theory(m_autil.get_family_id());
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index d2b51a712..0ba4a1a4d 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -100,9 +100,25 @@ namespace smt {
* will not return from the function after asserting their axioms.
* This means that control will fall through to the type 1-6 axioms,
* causing those to be added as well.
+ * The default behaviour of Z3str2 is to set this to 'false'.
*/
bool opt_NoQuickReturn_Concat_IntegerTheory;
+ /*
+ * If DisableIntegerTheoryIntegration is set to true,
+ * ALL calls to the integer theory integration methods
+ * (get_value, get_len_value, lower_bound, upper_bound)
+ * will ignore what the arithmetic solver believes about length terms,
+ * and will return no information.
+ *
+ * This reduces performance significantly, but can be useful to enable
+ * if it is suspected that string-integer integration, or the arithmetic solver itself,
+ * might have a bug.
+ *
+ * The default behaviour of Z3str2 is to set this to 'false'.
+ */
+ bool opt_DisableIntegerTheoryIntegration;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
From 1c518be61d8d133e48e3cafdd2153dc30ff7e4d1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 27 Jul 2016 12:46:35 -0400
Subject: [PATCH 148/401] new_eq_handler improvements in theory_str, WIP
---
src/smt/theory_str.cpp | 173 +++++++++++++++++++++++++++++++----------
src/smt/theory_str.h | 2 +
2 files changed, 133 insertions(+), 42 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 35bc7ab20..a0daa021a 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -33,8 +33,8 @@ theory_str::theory_str(ast_manager & m):
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
- opt_NoQuickReturn_Concat_IntegerTheory(true),
- opt_DisableIntegerTheoryIntegration(true),
+ opt_NoQuickReturn_Concat_IntegerTheory(false),
+ opt_DisableIntegerTheoryIntegration(false),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -1428,7 +1428,57 @@ void theory_str::reset_eh() {
* Then add an assertion: (y2 == (Concat ce m2)) AND ("str3" == (Concat abc x2)) -> (y2 != "str3")
*/
bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
- // TODO this involves messing around with enodes and equivalence classes
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ // Previously we did the check between LHS and RHS equivalence classes.
+ // However these have since been merged.
+ // We start by asserting that the EQCs, in fact, really are merged.
+ if (!in_same_eqc(lhs, rhs)) {
+ TRACE("t_str", tout << "BUG: lhs and rhs not in same eqc in new_eq_eh(), loss of invariant!" << std::endl;);
+ UNREACHABLE();
+ }
+
+ check_concat_len_in_eqc(lhs);
+ check_concat_len_in_eqc(rhs);
+
+ // Now we iterate over all pairs of terms in the (shared) eqc
+ // and check whether we can show that any pair of distinct terms
+ // cannot possibly be equal.
+ // If that's the case, we assert an axiom to that effect and stop.
+
+ enode * eqc_root = ctx.get_enode(lhs)->get_root();
+ enode * eqc_iterator1 = eqc_root;
+ do {
+ enode * eqc_iterator2 = eqc_iterator1;
+ do {
+ if (eqc_iterator1 == eqc_iterator2) {
+ continue;
+ }
+ // pull terms out of the enodes
+ app * eqc_nn1 = eqc_iterator1->get_owner();
+ app * eqc_nn2 = eqc_iterator2->get_owner();
+ TRACE("t_str_detail", tout << "checking whether " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " can be equal" << std::endl;);
+ if (!can_two_nodes_eq(eqc_nn1, eqc_nn2)) {
+ TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " cannot be equal to " << mk_pp(eqc_nn2, m) << std::endl;);
+ expr_ref to_assert(m.mk_not(ctx.mk_eq_atom(eqc_nn1, eqc_nn2)), m);
+ assert_axiom(to_assert);
+ return false;
+ }
+ if (!check_length_consistency(eqc_nn1, eqc_nn2)) {
+ TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " have inconsistent lengths" << std::endl;);
+ return false;
+ }
+ eqc_iterator2 = eqc_iterator2->get_next();
+ } while (eqc_iterator2 != eqc_root);
+
+ eqc_iterator1 = eqc_iterator1->get_next();
+ } while (eqc_iterator1 != eqc_root);
+
+ // TODO containPairBoolMap
+ // TODO regexInBoolMap
+
+ // okay, all checks here passed
return true;
}
@@ -2681,12 +2731,17 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
+ // prevent checking scope for the XOR term, as it's always in the same scope as the split var
+ // TODO probably make this change everywhere else in process_concat_eq*,
+ // and also make sure this is correct.
+
bool entry1InScope;
if (entry1 == varForBreakConcat.end()) {
entry1InScope = false;
} else {
if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
- || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()) {
+ /*|| internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()*/
+ ) {
entry1InScope = false;
} else {
entry1InScope = true;
@@ -2698,7 +2753,8 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
entry2InScope = false;
} else {
if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
- || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()) {
+ /*|| internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()*/
+ ) {
entry2InScope = false;
} else {
entry2InScope = true;
@@ -3954,48 +4010,58 @@ bool theory_str::in_same_eqc(expr * n1, expr * n2) {
return n1Node->get_root() == n2Node->get_root();
}
-/*
-bool canTwoNodesEq(Z3_theory t, Z3_ast n1, Z3_ast n2) {
- Z3_ast n1_curr = n1;
- Z3_ast n2_curr = n2;
-
- // case 0: n1_curr is const string, n2_curr is const string
- if (isConstStr(t, n1_curr) && isConstStr(t, n2_curr)) {
- if (n1_curr != n2_curr) {
- return false;
- }
- }
- // case 1: n1_curr is concat, n2_curr is const string
- else if (isConcatFunc(t, n1_curr) && isConstStr(t, n2_curr)) {
- std::string n2_curr_str = getConstStrValue(t, n2_curr);
- if (canConcatEqStr(t, n1_curr, n2_curr_str) != 1) {
- return false;
- }
- }
- // case 2: n2_curr is concat, n1_curr is const string
- else if (isConcatFunc(t, n2_curr) && isConstStr(t, n1_curr)) {
- std::string n1_curr_str = getConstStrValue(t, n1_curr);
- if (canConcatEqStr(t, n2_curr, n1_curr_str) != 1) {
- return false;
- }
- } else if (isConcatFunc(t, n1_curr) && isConcatFunc(t, n2_curr)) {
- if (canConcatEqConcat(t, n1_curr, n2_curr) != 1) {
- return false;
- }
- }
-
- return true;
-}
-*/
-
bool theory_str::can_concat_eq_str(expr * concat, std::string str) {
- // TODO
- return true;
+ /*
+ int strLen = str.length();
+ if (isConcatFunc(t, concat)) {
+ std::vector<Z3_ast> args;
+ getNodesInConcat(t, concat, args);
+ Z3_ast ml_node = args[0];
+ Z3_ast mr_node = args[args.size() - 1];
+
+ if (isConstStr(t, ml_node)) {
+ std::string ml_str = getConstStrValue(t, ml_node);
+ int ml_len = ml_str.length();
+ if (ml_len > strLen)
+ return 0;
+ int cLen = ml_len;
+ if (ml_str != str.substr(0, cLen))
+ return 0;
+ }
+
+ if (isConstStr(t, mr_node)) {
+ std::string mr_str = getConstStrValue(t, mr_node);
+ int mr_len = mr_str.length();
+ if (mr_len > strLen)
+ return 0;
+ int cLen = mr_len;
+ if (mr_str != str.substr(strLen - cLen, cLen))
+ return 0;
+ }
+
+ int sumLen = 0;
+ for (unsigned int i = 0; i < args.size(); i++) {
+ Z3_ast oneArg = args[i];
+ if (isConstStr(t, oneArg)) {
+ std::string arg_str = getConstStrValue(t, oneArg);
+ if (str.find(arg_str) == std::string::npos) {
+ return 0;
+ }
+ sumLen += getConstStrValue(t, oneArg).length();
+ }
+ }
+ if (sumLen > strLen)
+ return 0;
+ }
+ return 1;
+ */
+ // TODO NEXT
+ NOT_IMPLEMENTED_YET(); return true;
}
bool theory_str::can_concat_eq_concat(expr * concat1, expr * concat2) {
// TODO
- return true;
+ NOT_IMPLEMENTED_YET(); return true;
}
/*
@@ -4041,6 +4107,27 @@ bool theory_str::can_two_nodes_eq(expr * n1, expr * n2) {
return true;
}
+bool theory_str::check_length_consistency(expr * n1, expr * n2) {
+ // TODO NEXT
+ NOT_IMPLEMENTED_YET(); return true;
+}
+
+void theory_str::check_concat_len_in_eqc(expr * concat) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ enode * eqc_base = ctx.get_enode(concat);
+ enode * eqc_it = eqc_base;
+ do {
+ app * eqc_n = eqc_it->get_owner();
+ if (is_concat(eqc_n)) {
+ rational unused;
+ infer_len_concat(eqc_n, unused);
+ }
+ eqc_it = eqc_it->get_next();
+ } while (eqc_it != eqc_base);
+}
+
/*
* strArgmt::solve_concat_eq_str()
* Solve concatenations of the form:
@@ -4499,6 +4586,8 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
// As a result, simplify_concat_equality() is never getting called,
// and if it were called, it would probably get called with the same element on both sides.
+
+ // TODO improve these checks with an all-pairs match over LHS and RHS wrt. other concats
bool hasCommon = false;
if (eqc_lhs_concat.size() != 0 && eqc_rhs_concat.size() != 0) {
std::set<expr*>::iterator itor1 = eqc_lhs_concat.begin();
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 0ba4a1a4d..d213f6271 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -298,6 +298,8 @@ namespace smt {
bool can_two_nodes_eq(expr * n1, expr * n2);
bool can_concat_eq_str(expr * concat, std::string str);
bool can_concat_eq_concat(expr * concat1, expr * concat2);
+ void check_concat_len_in_eqc(expr * concat);
+ bool check_length_consistency(expr * n1, expr * n2);
void get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList);
expr * simplify_concat(expr * node);
From ceed3f3ff0203b7ec0c5a793bc1a6530c6e0b609 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 27 Jul 2016 15:15:01 -0400
Subject: [PATCH 149/401] add theory_str::can_concat_eq_str
---
src/smt/theory_str.cpp | 89 ++++++++++++++++++++++--------------------
1 file changed, 46 insertions(+), 43 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a0daa021a..bb7c1c9be 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4011,52 +4011,55 @@ bool theory_str::in_same_eqc(expr * n1, expr * n2) {
}
bool theory_str::can_concat_eq_str(expr * concat, std::string str) {
- /*
- int strLen = str.length();
- if (isConcatFunc(t, concat)) {
- std::vector<Z3_ast> args;
- getNodesInConcat(t, concat, args);
- Z3_ast ml_node = args[0];
- Z3_ast mr_node = args[args.size() - 1];
+ // TODO this method could use some traces and debugging info
+ int strLen = str.length();
+ if (is_concat(to_app(concat))) {
+ ptr_vector<expr> args;
+ get_nodes_in_concat(concat, args);
+ expr * ml_node = args[0];
+ expr * mr_node = args[args.size() - 1];
- if (isConstStr(t, ml_node)) {
- std::string ml_str = getConstStrValue(t, ml_node);
- int ml_len = ml_str.length();
- if (ml_len > strLen)
- return 0;
- int cLen = ml_len;
- if (ml_str != str.substr(0, cLen))
- return 0;
- }
+ if (m_strutil.is_string(ml_node)) {
+ std::string ml_str = m_strutil.get_string_constant_value(ml_node);
+ int ml_len = ml_str.length();
+ if (ml_len > strLen) {
+ return false;
+ }
+ int cLen = ml_len;
+ if (ml_str != str.substr(0, cLen)) {
+ return false;
+ }
+ }
- if (isConstStr(t, mr_node)) {
- std::string mr_str = getConstStrValue(t, mr_node);
- int mr_len = mr_str.length();
- if (mr_len > strLen)
- return 0;
- int cLen = mr_len;
- if (mr_str != str.substr(strLen - cLen, cLen))
- return 0;
- }
+ if (m_strutil.is_string(mr_node)) {
+ std::string mr_str = m_strutil.get_string_constant_value(mr_node);
+ int mr_len = mr_str.length();
+ if (mr_len > strLen) {
+ return false;
+ }
+ int cLen = mr_len;
+ if (mr_str != str.substr(strLen - cLen, cLen)) {
+ return false;
+ }
+ }
- int sumLen = 0;
- for (unsigned int i = 0; i < args.size(); i++) {
- Z3_ast oneArg = args[i];
- if (isConstStr(t, oneArg)) {
- std::string arg_str = getConstStrValue(t, oneArg);
- if (str.find(arg_str) == std::string::npos) {
- return 0;
- }
- sumLen += getConstStrValue(t, oneArg).length();
- }
- }
- if (sumLen > strLen)
- return 0;
- }
- return 1;
- */
- // TODO NEXT
- NOT_IMPLEMENTED_YET(); return true;
+ int sumLen = 0;
+ for (unsigned int i = 0 ; i < args.size() ; i++) {
+ expr * oneArg = args[i];
+ if (m_strutil.is_string(oneArg)) {
+ std::string arg_str = m_strutil.get_string_constant_value(oneArg);
+ if (str.find(arg_str) == std::string::npos) {
+ return false;
+ }
+ sumLen += arg_str.length();
+ }
+ }
+
+ if (sumLen > strLen) {
+ return false;
+ }
+ }
+ return true;
}
bool theory_str::can_concat_eq_concat(expr * concat1, expr * concat2) {
From a31a948a5bf0f720fdebcd23eaa838e796eb06fe Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 27 Jul 2016 15:21:33 -0400
Subject: [PATCH 150/401] add theory_str::can_concat_eq_concat
---
src/smt/theory_str.cpp | 35 +++++++++++++++++++++++++++++++++--
1 file changed, 33 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index bb7c1c9be..3ff4ff2de 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4063,8 +4063,39 @@ bool theory_str::can_concat_eq_str(expr * concat, std::string str) {
}
bool theory_str::can_concat_eq_concat(expr * concat1, expr * concat2) {
- // TODO
- NOT_IMPLEMENTED_YET(); return true;
+ // TODO this method could use some traces and debugging info
+ if (is_concat(to_app(concat1)) && is_concat(to_app(concat2))) {
+ {
+ // Suppose concat1 = (Concat X Y) and concat2 = (Concat M N).
+ expr * concat1_mostL = getMostLeftNodeInConcat(concat1);
+ expr * concat2_mostL = getMostLeftNodeInConcat(concat2);
+ // if both X and M are constant strings, check whether they have the same prefix
+ if (m_strutil.is_string(concat1_mostL) && m_strutil.is_string(concat2_mostL)) {
+ std::string concat1_mostL_str = m_strutil.get_string_constant_value(concat1_mostL);
+ std::string concat2_mostL_str = m_strutil.get_string_constant_value(concat2_mostL);
+ int cLen = std::min(concat1_mostL_str.length(), concat2_mostL_str.length());
+ if (concat1_mostL_str.substr(0, cLen) != concat2_mostL_str.substr(0, cLen)) {
+ return false;
+ }
+ }
+ }
+
+ {
+ // Similarly, if both Y and N are constant strings, check whether they have the same suffix
+ expr * concat1_mostR = getMostRightNodeInConcat(concat1);
+ expr * concat2_mostR = getMostRightNodeInConcat(concat2);
+ if (m_strutil.is_string(concat1_mostR) && m_strutil.is_string(concat2_mostR)) {
+ std::string concat1_mostR_str = m_strutil.get_string_constant_value(concat1_mostR);
+ std::string concat2_mostR_str = m_strutil.get_string_constant_value(concat2_mostR);
+ int cLen = std::min(concat1_mostR_str.length(), concat2_mostR_str.length());
+ if (concat1_mostR_str.substr(concat1_mostR_str.length() - cLen, cLen) !=
+ concat2_mostR_str.substr(concat2_mostR_str.length() - cLen, cLen)) {
+ return false;
+ }
+ }
+ }
+ }
+ return true;
}
/*
From 95f1cfa5a6b7d13ff0ad927c3416450932f83b5b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 27 Jul 2016 16:18:05 -0400
Subject: [PATCH 151/401] add theory_str::check_length_consistency, WIP
---
src/smt/theory_str.cpp | 31 +++++++++++++++++++++++++++++--
src/smt/theory_str.h | 2 ++
2 files changed, 31 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3ff4ff2de..24aefe3a6 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4141,9 +4141,36 @@ bool theory_str::can_two_nodes_eq(expr * n1, expr * n2) {
return true;
}
+// was checkLength2ConstStr() in Z3str2
+// returns true if everything is OK, or false if inconsistency detected
+// - note that these are different from the semantics in Z3str2
+bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
+ // TODO NEXT
+ NOT_IMPLEMENTED_YET(); return true;
+}
+
+// returns true if everything is OK, or false if inconsistency detected
+// - note that these are different from the semantics in Z3str2
+bool theory_str::check_length_eq_var_concat(expr * n1, expr * n2) {
+ // TODO NEXT
+ NOT_IMPLEMENTED_YET(); return true;
+}
+
+// returns false if an inconsistency is detected, or true if no inconsistencies were found
+// - note that these are different from the semantics of checkLengConsistency() in Z3str2
bool theory_str::check_length_consistency(expr * n1, expr * n2) {
- // TODO NEXT
- NOT_IMPLEMENTED_YET(); return true;
+ if (m_strutil.is_string(n1) && m_strutil.is_string(n2)) {
+ // consistency has already been checked in can_two_nodes_eq().
+ return true;
+ } else if (m_strutil.is_string(n1) && (!m_strutil.is_string(n2))) {
+ return check_length_const_string(n2, n1);
+ } else if (m_strutil.is_string(n2) && (!m_strutil.is_string(n1))) {
+ return check_length_const_string(n1, n2);
+ } else {
+ // n1 and n2 are vars or concats
+ return check_length_eq_var_concat(n1, n2);
+ }
+ return 0;
}
void theory_str::check_concat_len_in_eqc(expr * concat) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index d213f6271..d4681856c 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -300,6 +300,8 @@ namespace smt {
bool can_concat_eq_concat(expr * concat1, expr * concat2);
void check_concat_len_in_eqc(expr * concat);
bool check_length_consistency(expr * n1, expr * n2);
+ bool check_length_const_string(expr * n1, expr * constStr);
+ bool check_length_eq_var_concat(expr * n1, expr * n2);
void get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList);
expr * simplify_concat(expr * node);
From 76ceac6664032e8daf8935ad51ac1d96f048f4a0 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 28 Jul 2016 16:31:40 -0400
Subject: [PATCH 152/401] add theory_str::check_length_const_string
---
src/smt/theory_str.cpp | 50 ++++++++++++++++++++++++++++++++++++++++--
1 file changed, 48 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 24aefe3a6..042ff5808 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4145,8 +4145,54 @@ bool theory_str::can_two_nodes_eq(expr * n1, expr * n2) {
// returns true if everything is OK, or false if inconsistency detected
// - note that these are different from the semantics in Z3str2
bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
- // TODO NEXT
- NOT_IMPLEMENTED_YET(); return true;
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+
+ rational strLen((unsigned) (m_strutil.get_string_constant_value(constStr).length()));
+
+ if (is_concat(to_app(n1))) {
+ ptr_vector<expr> args;
+ expr_ref_vector items(mgr);
+
+ get_nodes_in_concat(n1, args);
+
+ rational sumLen(0);
+ for (unsigned int i = 0; i < args.size(); ++i) {
+ rational argLen;
+ bool argLen_exists = get_len_value(args[i], argLen);
+ if (argLen_exists) {
+ if (!m_strutil.is_string(args[i])) {
+ items.push_back(ctx.mk_eq_atom(mk_strlen(args[i]), mk_int(argLen)));
+ }
+ TRACE("t_str_detail", tout << "concat arg: " << mk_pp(args[i], mgr) << " has len = " << argLen.to_string() << std::endl;);
+ sumLen += argLen;
+ if (sumLen > strLen) {
+ items.push_back(ctx.mk_eq_atom(n1, constStr));
+ expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
+ TRACE("t_str_detail", tout << "inconsistent length: concat (len = " << sumLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
+ assert_axiom(toAssert);
+ return false;
+ }
+ }
+ }
+ } else { // !is_concat(n1)
+ rational oLen;
+ bool oLen_exists = get_len_value(n1, oLen);
+ if (oLen_exists && oLen != strLen) {
+ TRACE("t_str_detail", tout << "inconsistent length: var (len = " << oLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
+ expr_ref l(ctx.mk_eq_atom(n1, constStr), mgr);
+ expr_ref r(ctx.mk_eq_atom(mk_strlen(n1), mk_strlen(constStr)), mgr);
+ assert_implication(l, r);
+ return false;
+ }
+ }
+ rational unused;
+ if (get_len_value(n1, unused) == false) {
+ expr_ref l(ctx.mk_eq_atom(n1, constStr), mgr);
+ expr_ref r(ctx.mk_eq_atom(mk_strlen(n1), mk_strlen(constStr)), mgr);
+ assert_implication(l, r);
+ }
+ return true;
}
// returns true if everything is OK, or false if inconsistency detected
From 999420485b2b5fb8e58cbe987aad2be855df91d7 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 28 Jul 2016 16:49:39 -0400
Subject: [PATCH 153/401] add theory_str::check_length_eq_var_concat and helper
methods
---
src/smt/theory_str.cpp | 149 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 3 +
2 files changed, 150 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 042ff5808..07fe3e6f6 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4195,11 +4195,156 @@ bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
return true;
}
+bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ ptr_vector<expr> concat1Args;
+ ptr_vector<expr> concat2Args;
+ get_nodes_in_concat(n1, concat1Args);
+ get_nodes_in_concat(n2, concat2Args);
+
+ bool concat1LenFixed = true;
+ bool concat2LenFixed = true;
+
+ expr_ref_vector items(mgr);
+
+ rational sum1(0), sum2(0);
+
+ for (unsigned int i = 0; i < concat1Args.size(); ++i) {
+ expr * oneArg = concat1Args[i];
+ rational argLen;
+ bool argLen_exists = get_len_value(oneArg, argLen);
+ if (argLen_exists) {
+ sum1 += argLen;
+ if (!m_strutil.is_string(oneArg)) {
+ items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
+ }
+ } else {
+ concat1LenFixed = false;
+ }
+ }
+
+ for (unsigned int i = 0; i < concat2Args.size(); ++i) {
+ expr * oneArg = concat2Args[i];
+ rational argLen;
+ bool argLen_exists = get_len_value(oneArg, argLen);
+ if (argLen_exists) {
+ sum2 += argLen;
+ if (!m_strutil.is_string(oneArg)) {
+ items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
+ }
+ } else {
+ concat2LenFixed = false;
+ }
+ }
+
+ items.push_back(ctx.mk_eq_atom(n1, n2));
+
+ expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
+
+ bool conflict = false;
+
+ if (concat1LenFixed && concat2LenFixed) {
+ if (sum1 != sum2) {
+ conflict = true;
+ }
+ } else if (!concat1LenFixed && concat2LenFixed) {
+ if (sum1 > sum2) {
+ conflict = true;
+ }
+ } else if (concat1LenFixed && !concat2LenFixed) {
+ if (sum1 < sum2) {
+ conflict = true;
+ }
+ }
+
+ if (conflict) {
+ TRACE("t_str_detail", tout << "inconsistent length detected in concat <==> concat" << std::endl;);
+ return false;
+ }
+ return true;
+}
+
+bool theory_str::check_length_concat_var(expr * concat, expr * var) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ rational varLen;
+ bool varLen_exists = get_len_value(var, varLen);
+ if (!varLen_exists) {
+ return true;
+ } else {
+ rational sumLen(0);
+ ptr_vector<expr> args;
+ expr_ref_vector items(mgr);
+ get_nodes_in_concat(concat, args);
+ for (unsigned int i = 0; i < args.size(); ++i) {
+ expr * oneArg = args[i];
+ rational argLen;
+ bool argLen_exists = get_len_value(oneArg, argLen);
+ if (argLen_exists) {
+ if (!m_strutil.is_string(oneArg) && !argLen.is_zero()) {
+ items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
+ }
+ sumLen += argLen;
+ if (sumLen > varLen) {
+ TRACE("t_str_detail", tout << "inconsistent length detected in concat <==> var" << std::endl;);
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_int(varLen)));
+ items.push_back(ctx.mk_eq_atom(concat, var));
+ expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
+ assert_axiom(toAssert);
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+}
+
+bool theory_str::check_length_var_var(expr * var1, expr * var2) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ rational var1Len, var2Len;
+ bool var1Len_exists = get_len_value(var1, var1Len);
+ bool var2Len_exists = get_len_value(var2, var2Len);
+
+ if (var1Len_exists && var2Len_exists && var1Len != var2Len) {
+ TRACE("t_str_detail", tout << "inconsistent length detected in var <==> var" << std::endl;);
+ expr_ref_vector items(mgr);
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var1), mk_int(var1Len)));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var2), mk_int(var2Len)));
+ items.push_back(ctx.mk_eq_atom(var1, var2));
+ expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
+ assert_axiom(toAssert);
+ return false;
+ }
+ return true;
+}
+
// returns true if everything is OK, or false if inconsistency detected
// - note that these are different from the semantics in Z3str2
bool theory_str::check_length_eq_var_concat(expr * n1, expr * n2) {
- // TODO NEXT
- NOT_IMPLEMENTED_YET(); return true;
+ // n1 and n2 are not const string: either variable or concat
+ bool n1Concat = is_concat(to_app(n1));
+ bool n2Concat = is_concat(to_app(n2));
+ if (n1Concat && n2Concat) {
+ return check_length_concat_concat(n1, n2);
+ }
+ // n1 is concat, n2 is variable
+ else if (n1Concat && (!n2Concat)) {
+ return check_length_concat_var(n1, n2);
+ }
+ // n1 is variable, n2 is concat
+ else if ((!n1Concat) && n2Concat) {
+ return check_length_concat_var(n2, n1);
+ }
+ // n1 and n2 are both variables
+ else {
+ return check_length_var_var(n1, n2);
+ }
+ return 0;
}
// returns false if an inconsistency is detected, or true if no inconsistencies were found
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index d4681856c..bd66e64d4 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -302,6 +302,9 @@ namespace smt {
bool check_length_consistency(expr * n1, expr * n2);
bool check_length_const_string(expr * n1, expr * constStr);
bool check_length_eq_var_concat(expr * n1, expr * n2);
+ bool check_length_concat_concat(expr * n1, expr * n2);
+ bool check_length_concat_var(expr * concat, expr * var);
+ bool check_length_var_var(expr * var1, expr * var2);
void get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList);
expr * simplify_concat(expr * node);
From 244b611f1ca2ebabb1338fbcf0cdb8eb960e0683 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 28 Jul 2016 17:10:41 -0400
Subject: [PATCH 154/401] fix infinite loop bug in theory_str::new_eq_check
---
src/smt/theory_str.cpp | 32 ++++++++++++++++----------------
1 file changed, 16 insertions(+), 16 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 07fe3e6f6..17246ccf8 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1452,24 +1452,24 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
do {
enode * eqc_iterator2 = eqc_iterator1;
do {
- if (eqc_iterator1 == eqc_iterator2) {
- continue;
- }
- // pull terms out of the enodes
- app * eqc_nn1 = eqc_iterator1->get_owner();
- app * eqc_nn2 = eqc_iterator2->get_owner();
- TRACE("t_str_detail", tout << "checking whether " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " can be equal" << std::endl;);
- if (!can_two_nodes_eq(eqc_nn1, eqc_nn2)) {
- TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " cannot be equal to " << mk_pp(eqc_nn2, m) << std::endl;);
- expr_ref to_assert(m.mk_not(ctx.mk_eq_atom(eqc_nn1, eqc_nn2)), m);
- assert_axiom(to_assert);
- return false;
- }
- if (!check_length_consistency(eqc_nn1, eqc_nn2)) {
- TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " have inconsistent lengths" << std::endl;);
- return false;
+ if (eqc_iterator1 != eqc_iterator2) {
+ // pull terms out of the enodes
+ app * eqc_nn1 = eqc_iterator1->get_owner();
+ app * eqc_nn2 = eqc_iterator2->get_owner();
+ TRACE("t_str_detail", tout << "checking whether " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " can be equal" << std::endl;);
+ if (!can_two_nodes_eq(eqc_nn1, eqc_nn2)) {
+ TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " cannot be equal to " << mk_pp(eqc_nn2, m) << std::endl;);
+ expr_ref to_assert(m.mk_not(ctx.mk_eq_atom(eqc_nn1, eqc_nn2)), m);
+ assert_axiom(to_assert);
+ return false;
+ }
+ if (!check_length_consistency(eqc_nn1, eqc_nn2)) {
+ TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " have inconsistent lengths" << std::endl;);
+ return false;
+ }
}
eqc_iterator2 = eqc_iterator2->get_next();
+
} while (eqc_iterator2 != eqc_root);
eqc_iterator1 = eqc_iterator1->get_next();
From 6f67e9cdda33df556b7026cb215a555b3db4170f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 28 Jul 2016 17:18:56 -0400
Subject: [PATCH 155/401] fix theory_str::check_length_concat_concat to
actually assert the conflict axiom
---
src/smt/theory_str.cpp | 1 +
1 file changed, 1 insertion(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 17246ccf8..6393d8154 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4261,6 +4261,7 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
if (conflict) {
TRACE("t_str_detail", tout << "inconsistent length detected in concat <==> concat" << std::endl;);
+ assert_axiom(toAssert);
return false;
}
return true;
From 7f3a260eda927dea298761f67aa138fb02f1f5f6 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 30 Jul 2016 16:58:59 -0400
Subject: [PATCH 156/401] more aggressive simplifications in theory_str::handle
equality, WIP, not tested yet
---
src/smt/theory_str.cpp | 141 +++++++++++++++++------------------------
1 file changed, 59 insertions(+), 82 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 6393d8154..fe68b02ad 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4779,117 +4779,94 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
// BEGIN new_eq_handler() in strTheory
- // TODO there's some setup with getLenValue() that I don't think is necessary
- // because we should already be generating the string length axioms for all string terms
+ {
+ rational nn1Len, nn2Len;
+ bool nn1Len_exists = get_len_value(lhs, nn1Len);
+ bool nn2Len_exists = get_len_value(rhs, nn2Len);
+ expr * emptyStr = m_strutil.mk_string("");
+
+ if (nn1Len_exists && nn1Len.is_zero()) {
+ if (!in_same_eqc(lhs, emptyStr) && rhs != emptyStr) {
+ expr_ref eql(ctx.mk_eq_atom(mk_strlen(lhs), mk_int(0)), m);
+ expr_ref eqr(ctx.mk_eq_atom(lhs, emptyStr), m);
+ expr_ref toAssert(ctx.mk_eq_atom(eql, eqr), m);
+ assert_axiom(toAssert);
+ }
+ }
+
+ if (nn2Len_exists && nn2Len.is_zero()) {
+ if (!in_same_eqc(rhs, emptyStr) && lhs != emptyStr) {
+ expr_ref eql(ctx.mk_eq_atom(mk_strlen(rhs), mk_int(0)), m);
+ expr_ref eqr(ctx.mk_eq_atom(rhs, emptyStr), m);
+ expr_ref toAssert(ctx.mk_eq_atom(eql, eqr), m);
+ assert_axiom(toAssert);
+ }
+ }
+ }
+
+ // TODO some setup with haveEQLength() which I skip for now, not sure if necessary
instantiate_str_eq_length_axiom(ctx.get_enode(lhs), ctx.get_enode(rhs));
// group terms by equivalence class (groupNodeInEqc())
- std::set<expr*> eqc_lhs_concat;
- std::set<expr*> eqc_lhs_var;
- std::set<expr*> eqc_lhs_const;
- group_terms_by_eqc(lhs, eqc_lhs_concat, eqc_lhs_var, eqc_lhs_const);
+ // Previously we did the check between LHS and RHS equivalence classes.
+ // However these have since been merged.
+ // We start by asserting that the EQCs, in fact, really are merged.
+ if (!in_same_eqc(lhs, rhs)) {
+ TRACE("t_str", tout << "BUG: lhs and rhs not in same eqc in new_eq_eh(), loss of invariant!" << std::endl;);
+ UNREACHABLE();
+ }
+
+ std::set<expr*> eqc_concat;
+ std::set<expr*> eqc_var;
+ std::set<expr*> eqc_const;
+ group_terms_by_eqc(lhs, eqc_concat, eqc_var, eqc_const);
TRACE("t_str_detail",
- tout << "eqc[lhs]:" << std::endl;
+ tout << "eqc:" << std::endl;
tout << "Concats:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_lhs_concat.begin(); it != eqc_lhs_concat.end(); ++it) {
+ for (std::set<expr*>::iterator it = eqc_concat.begin(); it != eqc_concat.end(); ++it) {
expr * ex = *it;
tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
}
tout << "Variables:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_lhs_var.begin(); it != eqc_lhs_var.end(); ++it) {
+ for (std::set<expr*>::iterator it = eqc_var.begin(); it != eqc_var.end(); ++it) {
expr * ex = *it;
tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
}
tout << "Constants:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_lhs_const.begin(); it != eqc_lhs_const.end(); ++it) {
- expr * ex = *it;
- tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
- }
- );
-
- std::set<expr*> eqc_rhs_concat;
- std::set<expr*> eqc_rhs_var;
- std::set<expr*> eqc_rhs_const;
- group_terms_by_eqc(rhs, eqc_rhs_concat, eqc_rhs_var, eqc_rhs_const);
-
- TRACE("t_str_detail",
- tout << "eqc[rhs]:" << std::endl;
- tout << "Concats:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_rhs_concat.begin(); it != eqc_rhs_concat.end(); ++it) {
- expr * ex = *it;
- tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
- }
- tout << "Variables:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_rhs_var.begin(); it != eqc_rhs_var.end(); ++it) {
- expr * ex = *it;
- tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
- }
- tout << "Constants:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_rhs_const.begin(); it != eqc_rhs_const.end(); ++it) {
+ for (std::set<expr*>::iterator it = eqc_const.begin(); it != eqc_const.end(); ++it) {
expr * ex = *it;
tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
}
);
// step 1: Concat == Concat
- // This code block may no longer be useful.
- // Z3 seems to be putting LHS and RHS into the same equivalence class extremely early.
- // As a result, simplify_concat_equality() is never getting called,
- // and if it were called, it would probably get called with the same element on both sides.
-
- // TODO improve these checks with an all-pairs match over LHS and RHS wrt. other concats
- bool hasCommon = false;
- if (eqc_lhs_concat.size() != 0 && eqc_rhs_concat.size() != 0) {
- std::set<expr*>::iterator itor1 = eqc_lhs_concat.begin();
- std::set<expr*>::iterator itor2 = eqc_rhs_concat.begin();
- for (; itor1 != eqc_lhs_concat.end(); ++itor1) {
- if (eqc_rhs_concat.find(*itor1) != eqc_rhs_concat.end()) {
- hasCommon = true;
- break;
- }
- }
- for (; !hasCommon && itor2 != eqc_rhs_concat.end(); ++itor2) {
- if (eqc_lhs_concat.find(*itor2) != eqc_lhs_concat.end()) {
- hasCommon = true;
- break;
- }
- }
- if (!hasCommon) {
- simplify_concat_equality(*(eqc_lhs_concat.begin()), *(eqc_rhs_concat.begin()));
- }
- }
-
- if (eqc_lhs_concat.size() != 0 && eqc_rhs_concat.size() != 0) {
- // let's pick the first concat in the LHS's eqc
- // and find some concat in the RHS's eqc that is
- // distinct from the first one we picked
- expr * lhs = *eqc_lhs_concat.begin();
- std::set<expr*>::iterator itor2 = eqc_rhs_concat.begin();
- for (; itor2 != eqc_rhs_concat.end(); ++itor2) {
- expr * rhs = *itor2;
- if (lhs != rhs) {
- simplify_concat_equality(lhs, rhs);
- break;
+ // enhancement from Z3str2: all-pairs match over LHS and RHS wrt. other concats
+ if (eqc_concat.size() != 0) {
+ std::set<expr*>::iterator itor1, itor2;
+ for (itor1 = eqc_concat.begin(); itor1 != eqc_concat.end(); ++itor1) {
+ for (itor2 = itor1; itor2 != eqc_concat.end(); ++itor2) {
+ if (itor1 == itor2) {
+ continue;
+ }
+ expr * e1 = *itor1;
+ expr * e2 = *itor2;
+ TRACE("t_str_detail", tout << "simplify concat-concat pair " << mk_pp(e1, m) << " and " << mk_pp(e2, m) << std::endl;);
+ simplify_concat_equality(e1, e2);
}
}
}
// step 2: Concat == Constant
- if (eqc_lhs_const.size() != 0) {
- expr * conStr = *(eqc_lhs_const.begin());
- std::set<expr*>::iterator itor2 = eqc_rhs_concat.begin();
- for (; itor2 != eqc_rhs_concat.end(); ++itor2) {
+ // same enhancement as above wrt. Z3str2's behaviour
+ if (eqc_const.size() != 0) {
+ expr * conStr = *(eqc_const.begin());
+ std::set<expr*>::iterator itor2;
+ for (itor2 = eqc_concat.begin(); itor2 != eqc_concat.end(); ++itor2) {
solve_concat_eq_str(*itor2, conStr);
}
- } else if (eqc_rhs_const.size() != 0) {
- expr * conStr = *(eqc_rhs_const.begin());
- std::set<expr*>::iterator itor1 = eqc_lhs_concat.begin();
- for (; itor1 != eqc_lhs_concat.end(); ++itor1) {
- solve_concat_eq_str(*itor1, conStr);
- }
}
// simplify parents wrt. the equivalence class of both sides
From 8958eea27cf282b86945d7fa86d03d6e60ef6273 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 31 Jul 2016 11:22:04 -0400
Subject: [PATCH 157/401] crash avoidance in theory_str cut_var_map writes
---
src/smt/theory_str.cpp | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index fe68b02ad..624892ee1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -306,6 +306,9 @@ bool theory_str::has_self_cut(expr * n1, expr * n2) {
}
void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node) {
+ // crash avoidance?
+ m_trail.push_back(baseNode);
+ m_trail.push_back(node);
if (cut_var_map.find(baseNode) == cut_var_map.end()) {
T_cut * varInfo = alloc(T_cut);
varInfo->level = slevel;
@@ -334,6 +337,9 @@ void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node)
}
void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode) {
+ // crash avoidance?
+ m_trail.push_back(destNode);
+ m_trail.push_back(srcNode);
if (cut_var_map.find(srcNode) == cut_var_map.end()) {
get_manager().raise_exception("illegal state in add_cut_info_merge(): cut_var_map doesn't contain srcNode");
}
From f5b82740c36da4279be9eb27f1a151bdc6a6fb6e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 31 Jul 2016 16:26:56 -0400
Subject: [PATCH 158/401] debugging length testers in
theory_str::gen_len_val_options_for_free_var
---
src/smt/theory_str.cpp | 34 ++++++++++++++++++++++++++++++----
1 file changed, 30 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 624892ee1..a2b3e731b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -7105,11 +7105,23 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
std::string effectiveLenIndiStr = "";
int lenTesterCount = (int) fvar_lenTester_map[freeVar].size();
+ TRACE("t_str_detail",
+ tout << lenTesterCount << " length testers in fvar_lenTester_map[" << mk_pp(freeVar, m) << "]:" << std::endl;
+ for (int i = 0; i < lenTesterCount; ++i) {
+ expr * len_indicator = fvar_lenTester_map[freeVar][i];
+ tout << mk_pp(len_indicator, m) << ": ";
+ bool effectiveInScope = (internal_variable_set.find(len_indicator) != internal_variable_set.end());
+ tout << (effectiveInScope ? "in scope" : "NOT in scope");
+ tout << std::endl;
+ }
+ );
+
int i = 0;
for (; i < lenTesterCount; ++i) {
expr * len_indicator_pre = fvar_lenTester_map[freeVar][i];
// check whether this is in scope as well
if (internal_variable_set.find(len_indicator_pre) == internal_variable_set.end()) {
+ TRACE("t_str_detail", tout << "length indicator " << mk_pp(len_indicator_pre, m) << " not in scope" << std::endl;);
continue;
}
@@ -7133,13 +7145,26 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
<< " i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
if (i > 0) {
effectiveLenInd = fvar_lenTester_map[freeVar][i - 1];
+ bool effectiveHasEqcValue;
+ expr * effective_eqc_value = get_eqc_value(effectiveLenInd, effectiveHasEqcValue);
+ bool effectiveInScope = (internal_variable_set.find(effectiveLenInd) != internal_variable_set.end());
+ TRACE("t_str_detail", tout << "checking effective length indicator " << mk_pp(effectiveLenInd, m) << ": "
+ << (effectiveInScope ? "in scope" : "NOT in scope") << ", ";
+ if (effectiveHasEqcValue) {
+ tout << "~= " << mk_pp(effective_eqc_value, m);
+ } else {
+ tout << "no eqc string constant";
+ }
+ tout << std::endl;);
if (effectiveLenInd == lenTesterInCbEq) {
effectiveLenIndiStr = lenTesterValue;
} else {
- bool effectiveHasEqcValue = false;
- const char * val = 0;
- m_strutil.is_string(get_eqc_value(effectiveLenInd, effectiveHasEqcValue), & val);
- effectiveLenIndiStr = val;
+ if (effectiveHasEqcValue) {
+ effectiveLenIndiStr = m_strutil.get_string_constant_value(effective_eqc_value);
+ } else {
+ // TODO this should be unreachable, but can we really do anything here?
+ NOT_IMPLEMENTED_YET();
+ }
}
}
break;
@@ -7169,6 +7194,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
fvar_lenTester_map[freeVar].push_back(indicator);
lenTester_fvar_map[indicator] = freeVar;
} else {
+ // TODO make absolutely sure this is safe to do if 'indicator' is technically out of scope
indicator = fvar_lenTester_map[freeVar][i];
testNum = i + 1;
}
From 41497f44c12236b74b6abda63bcf2d225c171873 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 31 Jul 2016 16:30:52 -0400
Subject: [PATCH 159/401] prevent checking scope of XOR variables in
theory_str::process_concat_eq
---
src/smt/theory_str.cpp | 14 ++++++--------
1 file changed, 6 insertions(+), 8 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a2b3e731b..a6db9112f 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2417,7 +2417,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
} else {
if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
|| internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()
- || internal_variable_set.find((entry1->second)[2]) == internal_variable_set.end()) {
+ /*|| internal_variable_set.find((entry1->second)[2]) == internal_variable_set.end() */) {
entry1InScope = false;
} else {
entry1InScope = true;
@@ -2430,7 +2430,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
} else {
if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
|| internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()
- || internal_variable_set.find((entry2->second)[2]) == internal_variable_set.end()) {
+ /* || internal_variable_set.find((entry2->second)[2]) == internal_variable_set.end() */) {
entry2InScope = false;
} else {
entry2InScope = true;
@@ -2738,8 +2738,6 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
// prevent checking scope for the XOR term, as it's always in the same scope as the split var
- // TODO probably make this change everywhere else in process_concat_eq*,
- // and also make sure this is correct.
bool entry1InScope;
if (entry1 == varForBreakConcat.end()) {
@@ -3061,7 +3059,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
entry1InScope = false;
} else {
if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
- || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()) {
+ /* || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end() */) {
entry1InScope = false;
} else {
entry1InScope = true;
@@ -3073,7 +3071,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
entry2InScope = false;
} else {
if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
- || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()) {
+ /* || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end() */) {
entry2InScope = false;
} else {
entry2InScope = true;
@@ -3560,7 +3558,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
entry1InScope = false;
} else {
if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
- || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()) {
+ /* || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end() */) {
entry1InScope = false;
} else {
entry1InScope = true;
@@ -3572,7 +3570,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
entry2InScope = false;
} else {
if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
- || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()) {
+ /* || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end() */) {
entry2InScope = false;
} else {
entry2InScope = true;
From 9ceb2df28f868e700c3ed5be33d69d7c02d84181 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 31 Jul 2016 16:51:35 -0400
Subject: [PATCH 160/401] add integer integration to
theory_str::simplify_parent
---
src/smt/theory_str.cpp | 88 +++++++++++++++++++++---------------------
1 file changed, 43 insertions(+), 45 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a6db9112f..4560de950 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1564,6 +1564,14 @@ expr * theory_str::eval_concat(expr * n1, expr * n2) {
return NULL;
}
+static inline std::string rational_to_string_if_exists(const rational & x, bool x_exists) {
+ if (x_exists) {
+ return x.to_string();
+ } else {
+ return "?";
+ }
+}
+
/*
* The inputs:
* ~ nn: non const node
@@ -1610,39 +1618,34 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
expr * arg0 = a_parent->get_arg(0);
expr * arg1 = a_parent->get_arg(1);
- // TODO getLenValue()
- // int parentLen = getLenValue(a_parent)
- int parentLen = -1;
+ rational parentLen;
+ bool parentLen_exists = get_len_value(a_parent, parentLen);
+
if (arg0 == n_eq_enode->get_owner()) {
- // TODO getLenValue()
- // int arg0Len = getLenValue(eq_str);
- // int arg1Len = getLenValue(arg1);
- int arg0Len = -1;
- int arg1Len = -1;
+ rational arg0Len, arg1Len;
+ bool arg0Len_exists = get_len_value(eq_str, arg0Len);
+ bool arg1Len_exists = get_len_value(arg1, arg1Len);
TRACE("t_str_detail",
tout << "simplify_parent #1:" << std::endl
<< "* parent = " << mk_ismt2_pp(a_parent, m) << std::endl
- << "* |parent| = " << parentLen << std::endl
- << "* |arg0| = " << arg0Len << std::endl
- << "* |arg1| = " << arg1Len << std::endl;
+ << "* |parent| = " << rational_to_string_if_exists(parentLen, parentLen_exists) << std::endl
+ << "* |arg0| = " << rational_to_string_if_exists(arg0Len, arg0Len_exists) << std::endl
+ << "* |arg1| = " << rational_to_string_if_exists(arg1Len, arg1Len_exists) << std::endl;
);
- if (parentLen != -1 && arg1Len == -1) {
- // TODO after getLenValue() above
- /*
- Z3_ast implyL11 = mk_2_and(t, Z3_mk_eq(ctx, mk_length(t, parent), mk_int(ctx, parentLen)),
- Z3_mk_eq(ctx, mk_length(t, arg0), mk_int(ctx, arg0Len)));
- int makeUpLenArg1 = parentLen - arg0Len;
- Z3_ast lenAss = NULL;
- if (makeUpLenArg1 >= 0) {
- Z3_ast implyR11 = Z3_mk_eq(ctx, mk_length(t, arg1), mk_int(ctx, makeUpLenArg1));
- lenAss = Z3_mk_implies(ctx, implyL11, implyR11);
+ if (parentLen_exists && !arg1Len_exists) {
+ TRACE("t_str_detail", tout << "make up len for arg1" << std::endl;);
+ expr_ref implyL11(m.mk_and(ctx.mk_eq_atom(mk_strlen(a_parent), mk_int(parentLen)),
+ ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0Len))), m);
+ rational makeUpLenArg1 = parentLen - arg0Len;
+ if (makeUpLenArg1.is_nonneg()) {
+ expr_ref implyR11(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(makeUpLenArg1)), m);
+ assert_implication(implyL11, implyR11);
} else {
- lenAss = Z3_mk_not(ctx, implyL11);
+ expr_ref neg(m.mk_not(implyL11), m);
+ assert_axiom(neg);
}
- addAxiom(t, lenAss, __LINE__);
- */
}
// (Concat n_eqNode arg1) /\ arg1 has eq const
@@ -1691,35 +1694,30 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
} // if (arg0 == n_eq_enode->get_owner())
if (arg1 == n_eq_enode->get_owner()) {
- // TODO getLenValue()
- // int arg0Len = getLenValue(arg0);
- // int arg1Len = getLenValue(eq_str);
- int arg0Len = -1;
- int arg1Len = -1;
+ rational arg0Len, arg1Len;
+ bool arg0Len_exists = get_len_value(arg0, arg0Len);
+ bool arg1Len_exists = get_len_value(eq_str, arg1Len);
TRACE("t_str_detail",
tout << "simplify_parent #2:" << std::endl
<< "* parent = " << mk_ismt2_pp(a_parent, m) << std::endl
- << "* |parent| = " << parentLen << std::endl
- << "* |arg0| = " << arg0Len << std::endl
- << "* |arg1| = " << arg1Len << std::endl;
+ << "* |parent| = " << rational_to_string_if_exists(parentLen, parentLen_exists) << std::endl
+ << "* |arg0| = " << rational_to_string_if_exists(arg0Len, arg0Len_exists) << std::endl
+ << "* |arg1| = " << rational_to_string_if_exists(arg1Len, arg1Len_exists) << std::endl;
);
- if (parentLen != -1 && arg0Len == -1) {
- // TODO after getLenValue() above
- /*
- Z3_ast implyL11 = mk_2_and(t, Z3_mk_eq(ctx, mk_length(t, parent), mk_int(ctx, parentLen)),
- Z3_mk_eq(ctx, mk_length(t, arg1), mk_int(ctx, arg1Len)));
- int makeUpLenArg0 = parentLen - arg1Len;
- Z3_ast lenAss = NULL;
- if (makeUpLenArg0 >= 0) {
- Z3_ast implyR11 = Z3_mk_eq(ctx, mk_length(t, arg0), mk_int(ctx, makeUpLenArg0));
- lenAss = Z3_mk_implies(ctx, implyL11, implyR11);
+ if (parentLen_exists && !arg0Len_exists) {
+ TRACE("t_str_detail", tout << "make up len for arg0" << std::endl;);
+ expr_ref implyL11(m.mk_and(ctx.mk_eq_atom(mk_strlen(a_parent), mk_int(parentLen)),
+ ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len))), m);
+ rational makeUpLenArg0 = parentLen - arg1Len;
+ if (makeUpLenArg0.is_nonneg()) {
+ expr_ref implyR11(ctx.mk_eq_atom(mk_strlen(arg0), mk_int(makeUpLenArg0)), m);
+ assert_implication(implyL11, implyR11);
} else {
- lenAss = Z3_mk_not(ctx, implyL11);
+ expr_ref neg(m.mk_not(implyL11), m);
+ assert_axiom(neg);
}
- addAxiom(t, lenAss, __LINE__);
- */
}
// (Concat arg0 n_eqNode) /\ arg0 has eq const
From 778c0a5563734d08f3e80a97ed18fc61a8b67ac9 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 31 Jul 2016 16:55:17 -0400
Subject: [PATCH 161/401] improve theory_str::group_terms_by_eqc now that we
have simplify_concat
---
src/smt/theory_str.cpp | 25 +++++++++++--------------
1 file changed, 11 insertions(+), 14 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 4560de950..0ad47f828 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1495,23 +1495,20 @@ void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::se
do {
app * ast = eqcNode->get_owner();
if (is_concat(eqcNode)) {
- // TODO simplify_concat
- /*
- Z3_ast simConcat = simplifyConcat(t, eqcNode);
- if (simConcat != eqcNode) {
- if (isConcatFunc(t, simConcat)) {
- concats.insert(simConcat);
+ expr * simConcat = simplify_concat(ast);
+ if (simConcat != ast) {
+ if (is_concat(to_app(simConcat))) {
+ concats.insert(simConcat);
} else {
- if (isConstStr(t, simConcat)) {
- constStrs.insert(simConcat);
- } else {
- vars.insert(simConcat);
- }
+ if (m_strutil.is_string(simConcat)) {
+ consts.insert(simConcat);
+ } else {
+ vars.insert(simConcat);
+ }
}
- } else {
+ } else {
concats.insert(simConcat);
- }
- */
+ }
concats.insert(ast);
} else if (is_string(eqcNode)) {
consts.insert(ast);
From 6e348720b1c9994bc117283ae456af7fbbf5a46a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 31 Jul 2016 18:12:57 -0400
Subject: [PATCH 162/401] add integer theory integration to
theory_str::solve_concat_eq_str case 4
---
src/smt/theory_str.cpp | 96 +++++++++++++++++++++++++++++++++---------
1 file changed, 77 insertions(+), 19 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 0ad47f828..2b94b0c40 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4555,12 +4555,74 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
} else {
// Case 4: Concat(var, var) == const
TRACE("t_str", tout << "Case 4: Concat(var, var) == const" << std::endl;);
- // TODO large additions required in this section
- if (true) { /* if (Concat(arg1, arg2) == NULL) { */
- int arg1Len = -1; /* = getLenValue(arg1); */
- int arg2Len = -1; /* = getLenValue(arg2); */
- if (arg1Len != -1 || arg2Len != -1) {
- NOT_IMPLEMENTED_YET(); // TODO
+ if (eval_concat(arg1, arg2) == NULL) {
+ rational arg1Len, arg2Len;
+ bool arg1Len_exists = get_len_value(arg1, arg1Len);
+ bool arg2Len_exists = get_len_value(arg2, arg2Len);
+ rational concatStrLen((unsigned)const_str.length());
+ if (arg1Len_exists || arg2Len_exists) {
+ expr_ref ax_l1(ctx.mk_eq_atom(concat, str), m);
+ expr_ref ax_l2(m);
+ std::string prefixStr, suffixStr;
+ if (arg1Len_exists) {
+ if (arg1Len.is_neg()) {
+ TRACE("t_str_detail", tout << "length conflict: arg1Len = " << arg1Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ expr_ref toAssert(m_autil.mk_ge(mk_strlen(arg1), mk_int(0)), m);
+ assert_axiom(toAssert);
+ return;
+ } else if (arg1Len > concatStrLen) {
+ TRACE("t_str_detail", tout << "length conflict: arg1Len = " << arg1Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ expr_ref ax_r1(m_autil.mk_le(mk_strlen(arg1), mk_int(concatStrLen)), m);
+ assert_implication(ax_l1, ax_r1);
+ return;
+ }
+
+ prefixStr = const_str.substr(0, arg1Len.get_unsigned());
+ rational concat_minus_arg1 = concatStrLen - arg1Len;
+ suffixStr = const_str.substr(arg1Len.get_unsigned(), concat_minus_arg1.get_unsigned());
+ ax_l2 = ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len));
+ } else {
+ // arg2's length is available
+ if (arg2Len.is_neg()) {
+ TRACE("t_str_detail", tout << "length conflict: arg2Len = " << arg2Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ expr_ref toAssert(m_autil.mk_ge(mk_strlen(arg2), mk_int(0)), m);
+ assert_axiom(toAssert);
+ return;
+ } else if (arg2Len > concatStrLen) {
+ TRACE("t_str_detail", tout << "length conflict: arg2Len = " << arg2Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ expr_ref ax_r1(m_autil.mk_le(mk_strlen(arg2), mk_int(concatStrLen)), m);
+ assert_implication(ax_l1, ax_r1);
+ return;
+ }
+
+ rational concat_minus_arg2 = concatStrLen - arg2Len;
+ prefixStr = const_str.substr(0, concat_minus_arg2.get_unsigned());
+ suffixStr = const_str.substr(concat_minus_arg2.get_unsigned(), arg2Len.get_unsigned());
+ ax_l2 = ctx.mk_eq_atom(mk_strlen(arg2), mk_int(arg2Len));
+ }
+ // consistency check
+ if (is_concat(to_app(arg1)) && !can_concat_eq_str(arg1, prefixStr)) {
+ expr_ref ax_r(m.mk_not(ax_l2), m);
+ assert_implication(ax_l1, ax_r);
+ return;
+ }
+ if (is_concat(to_app(arg2)) && !can_concat_eq_str(arg2, suffixStr)) {
+ expr_ref ax_r(m.mk_not(ax_l2), m);
+ assert_implication(ax_l1, ax_r);
+ return;
+ }
+ expr_ref_vector r_items(m);
+ r_items.push_back(ctx.mk_eq_atom(arg1, m_strutil.mk_string(prefixStr)));
+ r_items.push_back(ctx.mk_eq_atom(arg2, m_strutil.mk_string(suffixStr)));
+ if (!arg1Len_exists) {
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(prefixStr.size())));
+ }
+ if (!arg2Len_exists) {
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(arg2), mk_int(suffixStr.size())));
+ }
+ expr_ref lhs(m.mk_and(ax_l1, ax_l2), m);
+ expr_ref rhs(mk_and(r_items), m);
+ assert_implication(lhs, rhs);
} else { /* ! (arg1Len != 1 || arg2Len != 1) */
expr_ref xorFlag(m);
std::pair<expr*, expr*> key1(arg1, arg2);
@@ -4569,6 +4631,8 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
// check the entries in this map to make sure they're still in scope
// before we use them.
+ // TODO XOR variables will always show up as "not in scope" because of how we update internal_variable_set
+
std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
@@ -4609,10 +4673,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
int concatStrLen = const_str.length();
int xor_pos = 0;
int and_count = 1;
- /*
- expr ** xor_items = new expr*[concatStrLen + 1];
- expr ** and_items = new expr*[4 * (concatStrLen+1) + 1];
- */
+
expr ** xor_items = alloc_svect(expr*, (concatStrLen+1));
expr ** and_items = alloc_svect(expr*, (4 * (concatStrLen+1) + 1));
@@ -4620,15 +4681,12 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
std::string prefixStr = const_str.substr(0, i);
std::string suffixStr = const_str.substr(i, concatStrLen - i);
// skip invalid options
- // TODO canConcatEqStr() checks:
- /*
- if (isConcatFunc(t, arg1) && canConcatEqStr(t, arg1, prefixStr) == 0) {
- continue;
- }
- if (isConcatFunc(t, arg2) && canConcatEqStr(t, arg2, suffixStr) == 0) {
- continue;
- }
- */
+ if (is_concat(to_app(arg1)) && !can_concat_eq_str(arg1, prefixStr)) {
+ continue;
+ }
+ if (is_concat(to_app(arg2)) && !can_concat_eq_str(arg2, suffixStr)) {
+ continue;
+ }
expr_ref xorAst(ctx.mk_eq_atom(xorFlag, m_autil.mk_numeral(rational(xor_pos), true)), m);
xor_items[xor_pos++] = xorAst;
From ee1af96f1bf92d1546449dc30573b62f27c34fae Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 1 Aug 2016 17:05:02 -0400
Subject: [PATCH 163/401] add opt_NoQuickReturn_IntegerTheory check in
theory_str::new_eq_check()
This allows us to assert an "inconsistent length" axiom from the integer theory
while continuing in new_eq_handler(). Currently active when
opt_NoQuickReturn_IntegerTheory is 'true' but this may be necessary
here and in other places, in general, to fix integer theory integration.
---
src/smt/theory_str.cpp | 13 +++++++++----
src/smt/theory_str.h | 10 ++++------
2 files changed, 13 insertions(+), 10 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 2b94b0c40..a80fd2165 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -33,7 +33,7 @@ theory_str::theory_str(ast_manager & m):
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
- opt_NoQuickReturn_Concat_IntegerTheory(false),
+ opt_NoQuickReturn_IntegerTheory(true),
opt_DisableIntegerTheoryIntegration(false),
/* Internal setup */
search_started(false),
@@ -1467,11 +1467,16 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " cannot be equal to " << mk_pp(eqc_nn2, m) << std::endl;);
expr_ref to_assert(m.mk_not(ctx.mk_eq_atom(eqc_nn1, eqc_nn2)), m);
assert_axiom(to_assert);
+ // this shouldn't use the integer theory at all, so we don't allow the option of quick-return
return false;
}
if (!check_length_consistency(eqc_nn1, eqc_nn2)) {
TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " have inconsistent lengths" << std::endl;);
- return false;
+ if (opt_NoQuickReturn_IntegerTheory){
+ TRACE("t_str_detail", tout << "continuing in new_eq_check() due to opt_NoQuickReturn_IntegerTheory" << std::endl;);
+ } else {
+ return false;
+ }
}
}
eqc_iterator2 = eqc_iterator2->get_next();
@@ -2175,7 +2180,7 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
assert_implication(premise, conclusion);
- if (opt_NoQuickReturn_Concat_IntegerTheory) {
+ if (opt_NoQuickReturn_IntegerTheory) {
TRACE("t_str_detail", tout << "bypassing quick return from the end of this case" << std::endl;);
} else {
return;
@@ -2195,7 +2200,7 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
expr_ref conclusion(m.mk_and(ax_r1, ax_r2), m);
assert_implication(premise, conclusion);
- if (opt_NoQuickReturn_Concat_IntegerTheory) {
+ if (opt_NoQuickReturn_IntegerTheory) {
TRACE("t_str_detail", tout << "bypassing quick return from the end of this case" << std::endl;);
} else {
return;
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index bd66e64d4..74c1786df 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -95,14 +95,12 @@ namespace smt {
int opt_LCMUnrollStep;
/*
- * If NoQuickReturn_Concat_IntegerTheory is set to true,
- * the integer theory integration conditionals in simplify_concat_equality()
+ * If NoQuickReturn_IntegerTheory is set to true,
+ * integer theory integration checks that assert axioms
* will not return from the function after asserting their axioms.
- * This means that control will fall through to the type 1-6 axioms,
- * causing those to be added as well.
- * The default behaviour of Z3str2 is to set this to 'false'.
+ * The default behaviour of Z3str2 is to set this to 'false'. This may be incorrect.
*/
- bool opt_NoQuickReturn_Concat_IntegerTheory;
+ bool opt_NoQuickReturn_IntegerTheory;
/*
* If DisableIntegerTheoryIntegration is set to true,
From 97f07a8a7c6a8c1379da46abcf9bb7c58652c0e4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 1 Aug 2016 18:14:56 -0400
Subject: [PATCH 164/401] fix debugging statements in
theory_str::gen_len_test_options
this fixes charAt-007.smt2 and prevents two unique crashes
---
src/smt/theory_str.cpp | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a80fd2165..ee17edb9c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6998,7 +6998,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
ast_manager & m = get_manager();
context & ctx = get_context();
- TRACE("t_str_detail", tout << "entry" << std::endl;);
+ //TRACE("t_str_detail", tout << "entry" << std::endl;);
expr_ref freeVarLen(mk_strlen(freeVar), m);
SASSERT(freeVarLen);
@@ -7020,9 +7020,9 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
for (int i = l; i < h; ++i) {
std::string i_str = int_to_string(i);
expr_ref str_indicator(m_strutil.mk_string(i_str), m);
- TRACE("t_str_detail", tout << "just created a string term: " << mk_ismt2_pp(str_indicator, m) << std::endl;);
+ //TRACE("t_str_detail", tout << "just created a string term: " << mk_ismt2_pp(str_indicator, m) << std::endl;);
expr * or_expr = m.mk_eq(indicator, str_indicator); // ARGUMENT 2 IS BOGUS! WRONG SORT
- TRACE("t_str_detail", tout << "or_expr = " << mk_ismt2_pp(or_expr, m) << std::endl;);
+ //TRACE("t_str_detail", tout << "or_expr = " << mk_ismt2_pp(or_expr, m) << std::endl;);
orList.push_back(or_expr);
if (opt_AggressiveLengthTesting) {
@@ -7032,7 +7032,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
}
expr * and_expr = m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVarLen, mk_int(i)));
- TRACE("t_str_detail", tout << "and_expr = " << mk_ismt2_pp(and_expr, m) << std::endl;);
+ //TRACE("t_str_detail", tout << "and_expr = " << mk_ismt2_pp(and_expr, m) << std::endl;);
andList.push_back(and_expr);
}
@@ -7063,7 +7063,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
expr * lenTestAssert = m.mk_and(andList.size() + 1, and_items);
SASSERT(lenTestAssert != NULL);
- TRACE("t_str_detail", tout << "lenTestAssert = " << mk_ismt2_pp(lenTestAssert, m) << std::endl;);
+ //TRACE("t_str_detail", tout << "lenTestAssert = " << mk_ismt2_pp(lenTestAssert, m) << std::endl;);
expr * assertL = NULL;
int testerCount = tries - 1;
@@ -7081,13 +7081,13 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
}
if (assertL != NULL) {
- TRACE("t_str_detail", tout << "assertL = " << mk_ismt2_pp(assertL, m) << std::endl;);
+ m_trail.push_back(assertL);
// return the axiom (assertL -> lenTestAssert)
// would like to use mk_implies() here but...
lenTestAssert = m.mk_or(m.mk_not(assertL), lenTestAssert);
}
- TRACE("t_str_detail", tout << "exit" << std::endl;);
+ //TRACE("t_str_detail", tout << "exit" << std::endl;);
return lenTestAssert;
From a51ad07e3f59f2db46f7534283e68729d33863b0 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 1 Aug 2016 20:52:42 -0400
Subject: [PATCH 165/401] crash avoidance in propagation of basic string axioms
and gen_len_test_options
---
src/smt/theory_str.cpp | 99 +++++++++++++++++++++++-------------------
1 file changed, 55 insertions(+), 44 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ee17edb9c..b96e454eb 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -237,6 +237,7 @@ bool theory_str::internalize_term(app * term) {
if (opt_EagerStringConstantLengthAssertions && m_strutil.is_string(term)) {
TRACE("t_str", tout << "eagerly asserting length of string term " << mk_pp(term, m) << std::endl;);
m_basicstr_axiom_todo.insert(e);
+ TRACE("t_str_axiom_bug", tout << "add " << mk_pp(e->get_owner(), m) << " to m_basicstr_axiom_todo" << std::endl;);
}
theory_var v = mk_var(e);
@@ -404,6 +405,7 @@ expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
std::string name = ss.str();
app * var = mk_str_var(name);
internal_lenTest_vars.insert(var);
+ m_trail.push_back(var);
return var;
}
@@ -415,6 +417,7 @@ expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
std::string name = ss.str();
app * var = mk_str_var(name);
internal_valTest_vars.insert(var);
+ m_trail.push_back(var);
return var;
}
@@ -494,6 +497,7 @@ app * theory_str::mk_str_var(std::string name) {
// this might help??
mk_var(ctx.get_enode(a));
m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
+ TRACE("t_str_axiom_bug", tout << "add " << mk_pp(a, m) << " to m_basicstr_axiom_todo" << std::endl;);
m_trail.push_back(a);
variable_set.insert(a);
@@ -515,6 +519,7 @@ app * theory_str::mk_regex_rep_var() {
SASSERT(ctx.e_internalized(a));
mk_var(ctx.get_enode(a));
m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
+ TRACE("t_str_axiom_bug", tout << "add " << mk_pp(a, m) << " to m_basicstr_axiom_todo" << std::endl;);
m_trail.push_back(a);
// TODO cross-check which variable sets we need
@@ -689,6 +694,7 @@ void theory_str::propagate() {
instantiate_basic_string_axioms(m_basicstr_axiom_todo[i]);
}
m_basicstr_axiom_todo.reset();
+ TRACE("t_str_axiom_bug", tout << "reset m_basicstr_axiom_todo" << std::endl;);
for (unsigned i = 0; i < m_str_eq_todo.size(); ++i) {
std::pair<enode*,enode*> pair = m_str_eq_todo[i];
@@ -811,6 +817,8 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
context & ctx = get_context();
ast_manager & m = get_manager();
+ TRACE("t_str_axiom_bug", tout << "set up basic string axioms on " << mk_pp(str->get_owner(), m) << std::endl;);
+
// TESTING: attempt to avoid a crash here when a variable goes out of scope
// TODO this seems to work so we probably need to do this for other propagate checks, etc.
if (str->get_iscope_lvl() > ctx.get_scope_level()) {
@@ -5010,6 +5018,7 @@ void theory_str::set_up_axioms(expr * ex) {
enode * n = ctx.get_enode(ex);
SASSERT(n);
m_basicstr_axiom_todo.push_back(n);
+ TRACE("t_str_axiom_bug", tout << "add " << mk_pp(ex, m) << " to m_basicstr_axiom_todo" << std::endl;);
if (is_app(ex)) {
@@ -5222,6 +5231,22 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
vars.clear();
}
}
+
+ // TODO if this works, possibly remove axioms from other vectors as well
+ ptr_vector<enode> new_m_basicstr;
+ for (ptr_vector<enode>::iterator it = m_basicstr_axiom_todo.begin(); it != m_basicstr_axiom_todo.end(); ++it) {
+ enode * e = *it;
+ app * a = e->get_owner();
+ TRACE("t_str_axiom_bug", tout << "consider deleting " << mk_pp(a, get_manager())
+ << ", enode scope level is " << e->get_iscope_lvl()
+ << std::endl;);
+ if (e->get_iscope_lvl() <= (unsigned)sLevel) {
+ new_m_basicstr.push_back(e);
+ }
+ }
+ m_basicstr_axiom_todo.reset();
+ m_basicstr_axiom_todo = new_m_basicstr;
+
theory::pop_scope_eh(num_scopes);
}
@@ -6998,13 +7023,11 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
ast_manager & m = get_manager();
context & ctx = get_context();
- //TRACE("t_str_detail", tout << "entry" << std::endl;);
-
expr_ref freeVarLen(mk_strlen(freeVar), m);
SASSERT(freeVarLen);
- ptr_vector<expr> orList;
- ptr_vector<expr> andList;
+ expr_ref_vector orList(m);
+ expr_ref_vector andList(m);
int distance = 3;
int l = (tries - 1) * distance;
@@ -7020,9 +7043,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
for (int i = l; i < h; ++i) {
std::string i_str = int_to_string(i);
expr_ref str_indicator(m_strutil.mk_string(i_str), m);
- //TRACE("t_str_detail", tout << "just created a string term: " << mk_ismt2_pp(str_indicator, m) << std::endl;);
- expr * or_expr = m.mk_eq(indicator, str_indicator); // ARGUMENT 2 IS BOGUS! WRONG SORT
- //TRACE("t_str_detail", tout << "or_expr = " << mk_ismt2_pp(or_expr, m) << std::endl;);
+ expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m); // ARGUMENT 2 IS BOGUS! WRONG SORT
orList.push_back(or_expr);
if (opt_AggressiveLengthTesting) {
@@ -7031,8 +7052,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
ctx.force_phase(l);
}
- expr * and_expr = m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVarLen, mk_int(i)));
- //TRACE("t_str_detail", tout << "and_expr = " << mk_ismt2_pp(and_expr, m) << std::endl;);
+ expr_ref and_expr(ctx.mk_eq_atom(orList.get(orList.size() - 1), m.mk_eq(freeVarLen, mk_int(i))), m);
andList.push_back(and_expr);
}
@@ -7043,54 +7063,44 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
ctx.force_phase(~l);
}
- andList.push_back(m.mk_eq(orList[orList.size() - 1], m_autil.mk_ge(freeVarLen, mk_int(h))));
+ andList.push_back(ctx.mk_eq_atom(orList.get(orList.size() - 1), m_autil.mk_ge(freeVarLen, mk_int(h))));
- // TODO refactor this to use expr_ref_vector/svector/buffer instead
- expr ** or_items = alloc_svect(expr*, orList.size());
- expr ** and_items = alloc_svect(expr*, andList.size() + 1);
+ expr_ref_vector or_items(m);
+ expr_ref_vector and_items(m);
for (unsigned i = 0; i < orList.size(); ++i) {
- SASSERT(orList[i] != NULL);
- or_items[i] = orList[i];
+ or_items.push_back(orList.get(i));
}
- and_items[0] = m.mk_or(orList.size(), or_items);
- SASSERT(and_items[0] != NULL);
+ and_items.push_back(mk_or(or_items));
for(unsigned i = 0; i < andList.size(); ++i) {
- SASSERT(andList[i] != NULL);
- and_items[i+1] = andList[i];
+ and_items.push_back(andList.get(i));
}
- expr * lenTestAssert = m.mk_and(andList.size() + 1, and_items);
- SASSERT(lenTestAssert != NULL);
- //TRACE("t_str_detail", tout << "lenTestAssert = " << mk_ismt2_pp(lenTestAssert, m) << std::endl;);
+ TRACE("t_str_detail", tout << "check: " << mk_pp(mk_and(and_items), m) << std::endl;);
+
+ expr_ref lenTestAssert = mk_and(and_items);
+ SASSERT(lenTestAssert);
+ TRACE("t_str_detail", tout << "crash avoidance lenTestAssert: " << mk_pp(lenTestAssert, m) << std::endl;);
- expr * assertL = NULL;
int testerCount = tries - 1;
if (testerCount > 0) {
- expr ** and_items_LHS = alloc_svect(expr*, testerCount);
- expr * moreAst = m_strutil.mk_string("more");
+ expr_ref_vector and_items_LHS(m);
+ expr_ref moreAst(m_strutil.mk_string("more"), m);
for (int i = 0; i < testerCount; ++i) {
- and_items_LHS[i] = m.mk_eq(fvar_lenTester_map[freeVar][i], moreAst);
- }
- if (testerCount == 1) {
- assertL = and_items_LHS[0];
- } else {
- assertL = m.mk_and(testerCount, and_items_LHS);
+ and_items_LHS.push_back(ctx.mk_eq_atom(fvar_lenTester_map[freeVar][i], moreAst));
}
+ expr_ref assertL(mk_and(and_items_LHS), m);
+ SASSERT(assertL);
+ expr * finalAxiom = m.mk_or(m.mk_not(assertL), lenTestAssert.get());
+ SASSERT(finalAxiom != NULL);
+ TRACE("t_str_detail", tout << "crash avoidance finalAxiom: " << mk_pp(finalAxiom, m) << std::endl;);
+ return finalAxiom;
+ } else {
+ TRACE("t_str_detail", tout << "crash avoidance lenTestAssert.get(): " << mk_pp(lenTestAssert.get(), m) << std::endl;);
+ m_trail.push_back(lenTestAssert.get());
+ return lenTestAssert.get();
}
-
- if (assertL != NULL) {
- m_trail.push_back(assertL);
- // return the axiom (assertL -> lenTestAssert)
- // would like to use mk_implies() here but...
- lenTestAssert = m.mk_or(m.mk_not(assertL), lenTestAssert);
- }
-
- //TRACE("t_str_detail", tout << "exit" << std::endl;);
-
- return lenTestAssert;
-
}
// -----------------------------------------------------------------------------------------------------
@@ -7237,7 +7247,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
} // for (i : [0..lenTesterCount-1])
if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "") {
TRACE("t_str", tout << "length is not fixed; generating length tester options for free var" << std::endl;);
- expr * indicator = NULL;
+ expr_ref indicator(m);
unsigned int testNum = 0;
TRACE("t_str", tout << "effectiveLenIndiStr = " << effectiveLenIndiStr
@@ -7261,6 +7271,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
// length is fixed
expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, "");
+ SASSERT(valueAssert != NULL);
return valueAssert;
}
} // fVarLenCountMap.find(...)
From 45c495495975a9b88b2996b4c06e46627a87bd01 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 2 Aug 2016 14:52:44 -0400
Subject: [PATCH 166/401] add debugging to theory_str::get_len_value in
preparation for fixes
---
src/smt/theory_str.cpp | 16 +++++++++++++++-
1 file changed, 15 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b96e454eb..395e1dab6 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -33,7 +33,7 @@ theory_str::theory_str(ast_manager & m):
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
- opt_NoQuickReturn_IntegerTheory(true),
+ opt_NoQuickReturn_IntegerTheory(false),
opt_DisableIntegerTheoryIntegration(false),
/* Internal setup */
search_started(false),
@@ -3882,6 +3882,7 @@ bool theory_str::get_len_value(expr* e, rational& val) {
context& ctx = get_context();
ast_manager & m = get_manager();
+
theory* th = ctx.get_theory(m_autil.get_family_id());
if (!th) {
TRACE("t_str_int", tout << "oops, can't get m_autil's theory" << std::endl;);
@@ -3926,6 +3927,18 @@ bool theory_str::get_len_value(expr* e, rational& val) {
if (ctx.e_internalized(len)) {
enode * e_len = ctx.get_enode(len);
tout << "has " << e_len->get_num_th_vars() << " theory vars" << std::endl;
+
+ // eqc debugging
+ {
+ tout << "dump equivalence class of " << mk_pp(len, get_manager()) << std::endl;
+ enode * nNode = ctx.get_enode(len);
+ enode * eqcNode = nNode;
+ do {
+ app * ast = eqcNode->get_owner();
+ tout << mk_pp(ast, get_manager()) << std::endl;
+ eqcNode = eqcNode->get_next();
+ } while (eqcNode != nNode);
+ }
}
});
@@ -3939,6 +3952,7 @@ bool theory_str::get_len_value(expr* e, rational& val) {
}
}
}
+
TRACE("t_str_int", tout << "length of " << mk_ismt2_pp(e, m) << " is " << val << std::endl;);
return val.is_int();
}
From 3c2fe497de4fee845f36e7a7bfc9b4860a6d265f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 2 Aug 2016 16:44:54 -0400
Subject: [PATCH 167/401] modify theory_str::get_value() to check EQC for a
numeral
Instead of asking the arithmetic theory for the current assignment,
we return the (unique) numeral in the equivalence class of the term
whose length we want to know.
This is because the arithmetic theory may return a default / internal
value that doesn't correspond to anything actually asserted by the core solver.
---
src/smt/theory_str.cpp | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 395e1dab6..2ae5dcec5 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3832,13 +3832,13 @@ bool theory_str::get_value(expr* e, rational& val) const {
enode * en_e = ctx.get_enode(e);
enode * it = en_e;
do {
- if (tha->get_value(it, _val)) {
+ if (m_autil.is_numeral(it->get_owner(), val) && val.is_int()) {
// found an arithmetic term
- TRACE("t_str_int", tout << "get_value[" << mk_pp(it->get_owner(), m) << "] = " << mk_pp(_val, m)
+ TRACE("t_str_int", tout << mk_pp(it->get_owner(), m) << " is an integer ( ~= " << val << " )"
<< std::endl;);
- return m_autil.is_numeral(_val, val) && val.is_int();
+ return true;
} else {
- TRACE("t_str_int", tout << "get_value[" << mk_pp(it->get_owner(), m) << "] not found" << std::endl;);
+ TRACE("t_str_int", tout << mk_pp(it->get_owner(), m) << " not a numeral" << std::endl;);
}
it = it->get_next();
} while (it != en_e);
From bc91d182bf97c64649d2b75d22b0163db9c29598 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 3 Aug 2016 13:39:14 -0400
Subject: [PATCH 168/401] mk_concat fixes WIP
---
src/smt/theory_str.cpp | 79 ++++++++++++++++++++++++++++++++++++++----
1 file changed, 72 insertions(+), 7 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 2ae5dcec5..6ae9fbf66 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -661,21 +661,86 @@ expr * theory_str::mk_concat_const_str(expr * n1, expr * n2) {
expr * theory_str::mk_concat(expr * n1, expr * n2) {
ast_manager & m = get_manager();
- if (n1 == NULL || n2 == NULL) {
- m.raise_exception("strings to be concatenated cannot be NULL");
- }
+ ENSURE(n1 != NULL);
+ ENSURE(n2 != NULL);
bool n1HasEqcValue = false;
bool n2HasEqcValue = false;
n1 = get_eqc_value(n1, n1HasEqcValue);
n2 = get_eqc_value(n2, n2HasEqcValue);
if (n1HasEqcValue && n2HasEqcValue) {
return mk_concat_const_str(n1, n2);
+ } else if (n1HasEqcValue && !n2HasEqcValue) {
+ bool n2_isConcatFunc = is_concat(to_app(n2));
+ if (m_strutil.get_string_constant_value(n1) == "") {
+ return n2;
+ }
+ if (n2_isConcatFunc) {
+ expr * n2_arg0 = to_app(n2)->get_arg(0);
+ expr * n2_arg1 = to_app(n2)->get_arg(1);
+ if (m_strutil.is_string(n2_arg0)) {
+ n1 = mk_concat_const_str(n1, n2_arg0); // n1 will be a constant
+ n2 = n2_arg1;
+ }
+ }
+ } else if (!n1HasEqcValue && n2HasEqcValue) {
+ if (m_strutil.get_string_constant_value(n2) == "") {
+ return n1;
+ }
+
+ if (is_concat(to_app(n1))) {
+ expr * n1_arg0 = to_app(n1)->get_arg(0);
+ expr * n1_arg1 = to_app(n1)->get_arg(1);
+ if (m_strutil.is_string(n1_arg1)) {
+ n1 = n1_arg0;
+ n2 = mk_concat_const_str(n1_arg1, n2); // n2 will be a constant
+ }
+ }
} else {
- // TODO there's a *TON* of missing code here from strTheory::mk_concat()
- // if all else fails, just build the application AST
- expr * args[2] = {n1, n2};
- return get_manager().mk_app(get_id(), OP_STRCAT, 0, 0, 2, args);
+ if (is_concat(to_app(n1)) && is_concat(to_app(n2))) {
+ expr * n1_arg0 = to_app(n1)->get_arg(0);
+ expr * n1_arg1 = to_app(n1)->get_arg(1);
+ expr * n2_arg0 = to_app(n2)->get_arg(0);
+ expr * n2_arg1 = to_app(n2)->get_arg(1);
+ if (m_strutil.is_string(n1_arg1) && m_strutil.is_string(n2_arg0)) {
+ expr * tmpN1 = n1_arg0;
+ expr * tmpN2 = mk_concat_const_str(n1_arg1, n2_arg0);
+ n1 = mk_concat(tmpN1, tmpN2);
+ n2 = n2_arg1;
+ }
+ }
}
+
+ //------------------------------------------------------
+ // * expr * ast1 = mk_2_arg_app(ctx, td->Concat, n1, n2);
+ // * expr * ast2 = mk_2_arg_app(ctx, td->Concat, n1, n2);
+ // Z3 treats (ast1) and (ast2) as two different nodes.
+ //-------------------------------------------------------
+ std::pair<expr*, expr*> concatArgs(n1, n2);
+ expr * concatAst = NULL;
+ // TODO NEXT clarify semantics of this, I think we can get around this check.
+ NOT_IMPLEMENTED_YET();
+ /*
+ if (concat_astNode_map.find(concatArgs) == concat_astNode_map.end()) {
+ concatAst = mk_2_arg_app(ctx, td->Concat, n1, n2);
+ concat_astNode_map[concatArgs] = concatAst;
+
+ Z3_ast concat_length = mk_length(t, concatAst);
+
+ std::vector<Z3_ast> childrenVector;
+ getNodesInConcat(t, concatAst, childrenVector);
+ Z3_ast * items = new Z3_ast[childrenVector.size()];
+ for (unsigned int i = 0; i < childrenVector.size(); i++) {
+ items[i] = mk_length(t, childrenVector[i]);
+ }
+ Z3_ast lenAssert = Z3_mk_eq(ctx, concat_length, Z3_mk_add(ctx, childrenVector.size(), items));
+ addAxiom(t, lenAssert, __LINE__, false);
+ delete[] items;
+
+ } else {
+ concatAst = concat_astNode_map[concatArgs];
+ }
+ */
+ return concatAst;
}
bool theory_str::can_propagate() {
From 0c4e7259025207a9e88f221a70147513a371ea7f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 4 Aug 2016 16:40:05 -0400
Subject: [PATCH 169/401] finish theory_str::mk_concat, no caching of generated
terms yet
---
src/smt/theory_str.cpp | 41 +++++++++++++++++++++--------------------
1 file changed, 21 insertions(+), 20 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 6ae9fbf66..78ab30dd7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -660,6 +660,7 @@ expr * theory_str::mk_concat_const_str(expr * n1, expr * n2) {
}
expr * theory_str::mk_concat(expr * n1, expr * n2) {
+ context & ctx = get_context();
ast_manager & m = get_manager();
ENSURE(n1 != NULL);
ENSURE(n2 != NULL);
@@ -717,29 +718,29 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
//-------------------------------------------------------
std::pair<expr*, expr*> concatArgs(n1, n2);
expr * concatAst = NULL;
- // TODO NEXT clarify semantics of this, I think we can get around this check.
- NOT_IMPLEMENTED_YET();
+ // TODO NEXT add cache lookups. I think we need to be more careful than just using std:: data structures here
/*
if (concat_astNode_map.find(concatArgs) == concat_astNode_map.end()) {
- concatAst = mk_2_arg_app(ctx, td->Concat, n1, n2);
- concat_astNode_map[concatArgs] = concatAst;
-
- Z3_ast concat_length = mk_length(t, concatAst);
-
- std::vector<Z3_ast> childrenVector;
- getNodesInConcat(t, concatAst, childrenVector);
- Z3_ast * items = new Z3_ast[childrenVector.size()];
- for (unsigned int i = 0; i < childrenVector.size(); i++) {
- items[i] = mk_length(t, childrenVector[i]);
- }
- Z3_ast lenAssert = Z3_mk_eq(ctx, concat_length, Z3_mk_add(ctx, childrenVector.size(), items));
- addAxiom(t, lenAssert, __LINE__, false);
- delete[] items;
-
- } else {
- concatAst = concat_astNode_map[concatArgs];
- }
*/
+ if (true) {
+ expr * args[2] = {n1, n2};
+ concatAst = m.mk_app(get_id(), OP_STRCAT, 0, 0, 2, args);
+ // concat_astNode_map[concatArgs] = concatAst;
+
+ expr_ref concat_length(mk_strlen(concatAst), m);
+
+ ptr_vector<expr> childrenVector;
+ get_nodes_in_concat(concatAst, childrenVector);
+ expr_ref_vector items(m);
+ for (unsigned int i = 0; i < childrenVector.size(); i++) {
+ items.push_back(mk_strlen(childrenVector.get(i)));
+ }
+ expr_ref lenAssert(ctx.mk_eq_atom(concat_length, m_autil.mk_add(items.size(), items.c_ptr())), m);
+ assert_axiom(lenAssert);
+ } else {
+ // concatAst = concat_astNode_map[concatArgs];
+ NOT_IMPLEMENTED_YET();
+ }
return concatAst;
}
From 91c336d7eeea124836c908195b91d634f23cb476 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 6 Aug 2016 15:32:37 -0400
Subject: [PATCH 170/401] fix erroneous vector double-insert in
theory_str::group_terms_by_eqc()
---
src/smt/theory_str.cpp | 1 -
1 file changed, 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 78ab30dd7..296041a39 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1588,7 +1588,6 @@ void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::se
} else {
concats.insert(simConcat);
}
- concats.insert(ast);
} else if (is_string(eqcNode)) {
consts.insert(ast);
} else {
From 2c91f388dfa02fa74c933af9d7249a61a276942e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 6 Aug 2016 15:35:47 -0400
Subject: [PATCH 171/401] add defensive double-non-concat check in
theory_str::simplify_concat_equality()
---
src/smt/theory_str.cpp | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 296041a39..ac897ee7d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2317,10 +2317,13 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
simplify_parent(new_nn1, new_nn2);
}
return;
+ } else if (!n1IsConcat && !n2IsConcat) {
+ // normally this should never happen, because group_terms_by_eqc() should have pre-simplified
+ // as much as possible. however, we make a defensive check here just in case
+ TRACE("t_str_detail", tout << "WARNING: nn1_new and nn2_new both simplify to non-concat terms" << std::endl;);
+ return;
}
- // TODO what happens if BOTH of these are simplified into non-concat terms?
-
expr * v1_arg0 = a_new_nn1->get_arg(0);
expr * v1_arg1 = a_new_nn1->get_arg(1);
expr * v2_arg0 = a_new_nn2->get_arg(0);
From 43b0cd5010fe4ebb9060142d9dad127b630f4d76 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 6 Aug 2016 15:38:58 -0400
Subject: [PATCH 172/401] clean up unused variables in theory_str.cpp
---
src/smt/theory_str.cpp | 7 -------
1 file changed, 7 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ac897ee7d..7b96a57f7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -422,7 +422,6 @@ expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
}
void theory_str::track_variable_scope(expr * var) {
- context & ctx = get_context();
if (internal_variable_scope_levels.find(sLevel) == internal_variable_scope_levels.end()) {
internal_variable_scope_levels[sLevel] = std::set<expr*>();
}
@@ -431,7 +430,6 @@ void theory_str::track_variable_scope(expr * var) {
app * theory_str::mk_internal_xor_var() {
ast_manager & m = get_manager();
- context & ctx = get_context();
std::stringstream ss;
ss << tmpXorVarCount;
tmpXorVarCount++;
@@ -3730,7 +3728,6 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
}
void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr) {
- context & ctx = get_context();
ast_manager & m = get_manager();
if (!is_Unroll(to_app(unrollFunc))) {
@@ -4461,7 +4458,6 @@ bool theory_str::check_length_consistency(expr * n1, expr * n2) {
void theory_str::check_concat_len_in_eqc(expr * concat) {
context & ctx = get_context();
- ast_manager & m = get_manager();
enode * eqc_base = ctx.get_enode(concat);
enode * eqc_it = eqc_base;
@@ -5271,14 +5267,12 @@ void theory_str::assign_eh(bool_var v, bool is_true) {
void theory_str::push_scope_eh() {
theory::push_scope_eh();
- context & ctx = get_context();
sLevel += 1;
TRACE("t_str", tout << "push to " << sLevel << std::endl;);
TRACE("t_str_dump_assign_on_scope_change", dump_assignments(););
}
void theory_str::pop_scope_eh(unsigned num_scopes) {
- context & ctx = get_context();
sLevel -= num_scopes;
TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
@@ -6664,7 +6658,6 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
std::string len_valueStr, expr * valTesterInCbEq, std::string valTesterValueStr) {
- context & ctx = get_context();
ast_manager & m = get_manager();
int len = atoi(len_valueStr.c_str());
From 395ec4543c1332434733f78ff18f5d162e537120 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 6 Aug 2016 22:19:10 -0400
Subject: [PATCH 173/401] avoid crash in theory_str, this leaks memory
---
src/smt/theory_str.cpp | 14 +++++++++++---
1 file changed, 11 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 7b96a57f7..2e95020a7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -315,12 +315,14 @@ void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node)
varInfo->level = slevel;
varInfo->vars[node] = 1;
cut_var_map[baseNode].push(varInfo);
+ TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << std::endl;);
} else {
if (cut_var_map[baseNode].empty()) {
T_cut * varInfo = alloc(T_cut);
varInfo->level = slevel;
varInfo->vars[node] = 1;
cut_var_map[baseNode].push(varInfo);
+ TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << std::endl;);
} else {
if (cut_var_map[baseNode].top()->level < slevel) {
T_cut * varInfo = alloc(T_cut);
@@ -328,8 +330,10 @@ void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node)
cut_vars_map_copy(varInfo->vars, cut_var_map[baseNode].top()->vars);
varInfo->vars[node] = 1;
cut_var_map[baseNode].push(varInfo);
+ TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << std::endl;);
} else if (cut_var_map[baseNode].top()->level == slevel) {
cut_var_map[baseNode].top()->vars[node] = 1;
+ TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << std::endl;);
} else {
get_manager().raise_exception("entered illegal state during add_cut_info_one_node()");
}
@@ -354,6 +358,7 @@ void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode)
varInfo->level = slevel;
cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
cut_var_map[destNode].push(varInfo);
+ TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << std::endl;);
} else {
if (cut_var_map[destNode].empty() || cut_var_map[destNode].top()->level < slevel) {
T_cut * varInfo = alloc(T_cut);
@@ -361,8 +366,10 @@ void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode)
cut_vars_map_copy(varInfo->vars, cut_var_map[destNode].top()->vars);
cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
cut_var_map[destNode].push(varInfo);
+ TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << std::endl;);
} else if (cut_var_map[destNode].top()->level == slevel) {
cut_vars_map_copy(cut_var_map[destNode].top()->vars, cut_var_map[srcNode].top()->vars);
+ TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << std::endl;);
} else {
get_manager().raise_exception("illegal state in add_cut_info_merge(): inconsistent slevels");
}
@@ -5281,12 +5288,13 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
while ((varItor->second.size() > 0) && (varItor->second.top()->level != 0) && (varItor->second.top()->level >= sLevel)) {
T_cut * aCut = varItor->second.top();
varItor->second.pop();
- dealloc(aCut);
+ // dealloc(aCut); // TODO find a safer way to do this, it is causing a crash
}
if (varItor->second.size() == 0) {
- cut_var_map.erase(varItor);
+ cut_var_map.erase(varItor++);
+ } else {
+ varItor++;
}
- ++varItor;
}
// see if any internal variables went out of scope
From cb566ad5ced242cad991c8381322522bcddc98eb Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 7 Aug 2016 15:43:08 -0400
Subject: [PATCH 174/401] fix model validation for theory_str
---
src/ast/rewriter/str_rewriter.cpp | 17 +++++++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
src/model/model_evaluator.cpp | 7 +++++++
3 files changed, 25 insertions(+)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 1449afcc3..37b6b6cbf 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -23,6 +23,20 @@ Notes:
#include"ast_util.h"
#include"well_sorted.h"
+br_status str_rewriter::mk_str_Concat(expr * arg0, expr * arg1, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (Concat " << mk_pp(arg0, m()) << " " << mk_pp(arg1, m()) << ")" << std::endl;);
+ if(m_strutil.is_string(arg0) && m_strutil.is_string(arg1)) {
+ TRACE("t_str_rw", tout << "evaluating Concat of two constant strings" << std::endl;);
+ std::string arg0Str = m_strutil.get_string_constant_value(arg0);
+ std::string arg1Str = m_strutil.get_string_constant_value(arg1);
+ std::string resultStr = arg0Str + arg1Str;
+ result = m_strutil.mk_string(resultStr);
+ return BR_DONE;
+ } else {
+ return BR_FAILED;
+ }
+}
+
br_status str_rewriter::mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & result) {
TRACE("t_str_rw", tout << "rewrite (CharAt " << mk_pp(arg0, m()) << " " << mk_pp(arg1, m()) << ")" << std::endl;);
// if arg0 is a string constant and arg1 is an integer constant,
@@ -275,6 +289,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
// TODO more rewrites for really easy cases, e.g. (Concat "abc" "def")...
switch(f->get_decl_kind()) {
+ case OP_STRCAT:
+ SASSERT(num_args == 2);
+ return mk_str_Concat(args[0], args[1], result);
case OP_STR_CHARAT:
SASSERT(num_args == 2);
return mk_str_CharAt(args[0], args[1], result);
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index dccf4a6bd..58e88591b 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -40,6 +40,7 @@ public:
br_status mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result);
br_status mk_eq_core(expr * lhs, expr * rhs, expr_ref & result);
+ br_status mk_str_Concat(expr * arg0, expr * arg1, expr_ref & result);
br_status mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & result);
br_status mk_str_StartsWith(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_EndsWith(expr * haystack, expr * needle, expr_ref & result);
diff --git a/src/model/model_evaluator.cpp b/src/model/model_evaluator.cpp
index eb2259263..fd420bad6 100644
--- a/src/model/model_evaluator.cpp
+++ b/src/model/model_evaluator.cpp
@@ -28,6 +28,7 @@ Revision History:
#include"datatype_rewriter.h"
#include"array_rewriter.h"
#include"fpa_rewriter.h"
+#include"str_rewriter.h"
#include"rewriter_def.h"
#include"cooperate.h"
#include"ast_pp.h"
@@ -44,6 +45,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
pb_rewriter m_pb_rw;
fpa_rewriter m_f_rw;
seq_rewriter m_seq_rw;
+ str_rewriter m_str_rw;
array_util m_ar;
unsigned long long m_max_memory;
unsigned m_max_steps;
@@ -63,6 +65,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
m_pb_rw(m),
m_f_rw(m),
m_seq_rw(m),
+ m_str_rw(m),
m_ar(m) {
bool flat = true;
m_b_rw.set_flat(flat);
@@ -152,6 +155,8 @@ struct evaluator_cfg : public default_rewriter_cfg {
st = m_f_rw.mk_eq_core(args[0], args[1], result);
else if (s_fid == m_seq_rw.get_fid())
st = m_seq_rw.mk_eq_core(args[0], args[1], result);
+ else if (s_fid == m_str_rw.get_fid())
+ st = m_str_rw.mk_eq_core(args[0], args[1], result);
else if (s_fid == m_ar_rw.get_fid())
st = mk_array_eq(args[0], args[1], result);
if (st != BR_FAILED)
@@ -174,6 +179,8 @@ struct evaluator_cfg : public default_rewriter_cfg {
st = m_f_rw.mk_app_core(f, num, args, result);
else if (fid == m_seq_rw.get_fid())
st = m_seq_rw.mk_app_core(f, num, args, result);
+ else if (fid == m_str_rw.get_fid())
+ st = m_str_rw.mk_app_core(f, num, args, result);
else if (fid == m().get_label_family_id() && num == 1) {
result = args[0];
st = BR_DONE;
From 3dff240bb3c552a869a9ce3d7bbdf96a7db738de Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 7 Aug 2016 15:50:41 -0400
Subject: [PATCH 175/401] theory_str model validation for Length
---
src/ast/rewriter/str_rewriter.cpp | 20 ++++++++++++++++++--
src/ast/rewriter/str_rewriter.h | 1 +
2 files changed, 19 insertions(+), 2 deletions(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 37b6b6cbf..fdb67f89e 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -26,7 +26,7 @@ Notes:
br_status str_rewriter::mk_str_Concat(expr * arg0, expr * arg1, expr_ref & result) {
TRACE("t_str_rw", tout << "rewrite (Concat " << mk_pp(arg0, m()) << " " << mk_pp(arg1, m()) << ")" << std::endl;);
if(m_strutil.is_string(arg0) && m_strutil.is_string(arg1)) {
- TRACE("t_str_rw", tout << "evaluating Concat of two constant strings" << std::endl;);
+ TRACE("t_str_rw", tout << "evaluating concat of two constant strings" << std::endl;);
std::string arg0Str = m_strutil.get_string_constant_value(arg0);
std::string arg1Str = m_strutil.get_string_constant_value(arg1);
std::string resultStr = arg0Str + arg1Str;
@@ -37,6 +37,20 @@ br_status str_rewriter::mk_str_Concat(expr * arg0, expr * arg1, expr_ref & resul
}
}
+br_status str_rewriter::mk_str_Length(expr * arg0, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (Length " << mk_pp(arg0, m()) << ")" << std::endl;);
+ if (m_strutil.is_string(arg0)) {
+ TRACE("t_str_rw", tout << "evaluating length of constant string" << std::endl;);
+ std::string arg0Str = m_strutil.get_string_constant_value(arg0);
+ rational arg0Len((unsigned)arg0Str.length());
+ result = m_autil.mk_numeral(arg0Len, true);
+ TRACE("t_str_rw", tout << "result is " << mk_pp(result, m()) << std::endl;);
+ return BR_DONE;
+ } else {
+ return BR_FAILED;
+ }
+}
+
br_status str_rewriter::mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & result) {
TRACE("t_str_rw", tout << "rewrite (CharAt " << mk_pp(arg0, m()) << " " << mk_pp(arg1, m()) << ")" << std::endl;);
// if arg0 is a string constant and arg1 is an integer constant,
@@ -287,11 +301,13 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
TRACE("t_str_rw", tout << "rewrite app: " << f->get_name() << std::endl;);
- // TODO more rewrites for really easy cases, e.g. (Concat "abc" "def")...
switch(f->get_decl_kind()) {
case OP_STRCAT:
SASSERT(num_args == 2);
return mk_str_Concat(args[0], args[1], result);
+ case OP_STRLEN:
+ SASSERT(num_args == 1);
+ return mk_str_Length(args[0], result);
case OP_STR_CHARAT:
SASSERT(num_args == 2);
return mk_str_CharAt(args[0], args[1], result);
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index 58e88591b..2235425be 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -41,6 +41,7 @@ public:
br_status mk_eq_core(expr * lhs, expr * rhs, expr_ref & result);
br_status mk_str_Concat(expr * arg0, expr * arg1, expr_ref & result);
+ br_status mk_str_Length(expr * arg0, expr_ref & result);
br_status mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & result);
br_status mk_str_StartsWith(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_EndsWith(expr * haystack, expr * needle, expr_ref & result);
From f7ba3ff0843c8ebd9df440678266c7614abac344 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 9 Aug 2016 20:11:25 -0400
Subject: [PATCH 176/401] crash avoidance in theory_str search start, fixes
length-001.smt2 regression
---
src/smt/theory_str.cpp | 19 ++++++++++++++++---
src/smt/theory_str.h | 3 +++
2 files changed, 19 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 2e95020a7..fd0b15b19 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -42,6 +42,7 @@ theory_str::theory_str(ast_manager & m):
sLevel(0),
finalCheckProgressIndicator(false),
m_trail(m),
+ m_delayed_axiom_setup_terms(m),
tmpStringVarCount(0),
tmpXorVarCount(0),
tmpLenTestVarCount(0),
@@ -755,10 +756,12 @@ bool theory_str::can_propagate() {
|| !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty() || !m_axiom_LastIndexof_todo.empty()
|| !m_axiom_Substr_todo.empty() || !m_axiom_Replace_todo.empty()
|| !m_axiom_RegexIn_todo.empty()
+ || !m_delayed_axiom_setup_terms.empty();
;
}
void theory_str::propagate() {
+ context & ctx = get_context();
while (can_propagate()) {
TRACE("t_str_detail", tout << "propagating..." << std::endl;);
for (unsigned i = 0; i < m_basicstr_axiom_todo.size(); ++i) {
@@ -829,6 +832,13 @@ void theory_str::propagate() {
instantiate_axiom_RegexIn(m_axiom_RegexIn_todo[i]);
}
m_axiom_RegexIn_todo.reset();
+
+ for (unsigned i = 0; i < m_delayed_axiom_setup_terms.size(); ++i) {
+ // I think this is okay
+ ctx.internalize(m_delayed_axiom_setup_terms[i].get(), false);
+ set_up_axioms(m_delayed_axiom_setup_terms[i].get());
+ }
+ m_delayed_axiom_setup_terms.reset();
}
}
@@ -5140,6 +5150,7 @@ void theory_str::set_up_axioms(expr * ex) {
": expr is of sort Bool" << std::endl;);
// set up axioms for boolean terms
+ ensure_enode(ex);
if (ctx.e_internalized(ex)) {
enode * n = ctx.get_enode(ex);
SASSERT(n);
@@ -5157,14 +5168,16 @@ void theory_str::set_up_axioms(expr * ex) {
}
}
} else {
- TRACE("t_str_detail", tout << "WARNING: Bool term " << mk_ismt2_pp(ex, get_manager()) << " not internalized. Skipping to prevent a crash." << std::endl;);
+ TRACE("t_str_detail", tout << "WARNING: Bool term " << mk_ismt2_pp(ex, get_manager()) << " not internalized. Delaying axiom setup to prevent a crash." << std::endl;);
+ ENSURE(!search_started); // infinite loop prevention
+ m_delayed_axiom_setup_terms.push_back(ex);
return;
}
} else if (ex_sort == int_sort) {
TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
": expr is of sort Int" << std::endl;);
- // set up axioms for boolean terms
- enode * n = ctx.get_enode(ex);
+ // set up axioms for integer terms
+ enode * n = ensure_enode(ex);
SASSERT(n);
if (is_app(ex)) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 74c1786df..7b4ff8ce0 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -129,6 +129,9 @@ namespace smt {
str_value_factory * m_factory;
+ // terms we couldn't go through set_up_axioms() with because they weren't internalized
+ expr_ref_vector m_delayed_axiom_setup_terms;
+
ptr_vector<enode> m_basicstr_axiom_todo;
svector<std::pair<enode*,enode*> > m_str_eq_todo;
ptr_vector<enode> m_concat_axiom_todo;
From 66129710492304874508f7d4c76f236604da6e00 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 14 Aug 2016 14:15:29 -0400
Subject: [PATCH 177/401] start adding Contains checks to theory_str
---
src/smt/theory_str.cpp | 116 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 7 +++
2 files changed, 121 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index fd0b15b19..aed46e868 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1124,12 +1124,13 @@ void theory_str::instantiate_axiom_Contains(enode * e) {
return;
}
axiomatized_terms.insert(expr);
+ contains_map.push_back(expr); // replaces registerContain() in Z3str2
TRACE("t_str_detail", tout << "instantiate Contains axiom for " << mk_pp(expr, m) << std::endl;);
expr_ref ts0(mk_str_var("ts0"), m);
expr_ref ts1(mk_str_var("ts1"), m);
- // TODO NEXT registerContain(expr);
+
expr_ref breakdownAssert(ctx.mk_eq_atom(expr, ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, mk_concat(expr->get_arg(1), ts1)))), m);
SASSERT(breakdownAssert);
assert_axiom(breakdownAssert);
@@ -1575,7 +1576,11 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
eqc_iterator1 = eqc_iterator1->get_next();
} while (eqc_iterator1 != eqc_root);
- // TODO containPairBoolMap
+
+ if (!contains_map.empty()) {
+ check_contain_in_new_eq(lhs, rhs);
+ }
+
// TODO regexInBoolMap
// okay, all checks here passed
@@ -4118,6 +4123,113 @@ bool theory_str::in_same_eqc(expr * n1, expr * n2) {
return n1Node->get_root() == n2Node->get_root();
}
+expr * theory_str::collect_eq_nodes(expr * n, expr_ref_vector & eqcSet) {
+ context & ctx = get_context();
+ expr * constStrNode = NULL;
+
+ enode * e_base = ctx.get_enode(n);
+ enode * e_curr = e_base;
+ do {
+ app * ex = e_curr->get_owner();
+ if (m_strutil.is_string(ex)) {
+ constStrNode = ex;
+ }
+ eqcSet.push_back(ex);
+
+ e_curr = e_curr->get_next();
+ } while (e_curr != e_base);
+ return constStrNode;
+}
+
+void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
+ NOT_IMPLEMENTED_YET(); // TODO NEXT
+}
+
+void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass) {
+ NOT_IMPLEMENTED_YET(); // TODO NEXT
+}
+
+void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
+ NOT_IMPLEMENTED_YET(); // TODO NEXT
+}
+
+void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
+ if (contains_map.empty()) {
+ return;
+ }
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ TRACE("t_str_detail", tout << "consistency check for contains wrt. " << mk_pp(n1, m) << " and " << mk_pp(n2, m) << std::endl;);
+
+ // Modification from Z3str2: the EQC of n1 and n2 *are* now merged.
+ // So we don't have to do anything too special
+ // to prepare willEqClass any more, we just use the EQC from n1 / n2.
+ expr_ref_vector willEqClass(m);
+ expr * constStrAst = collect_eq_nodes(n1, willEqClass);
+
+ TRACE("t_str_detail", tout << "eqc of n1 is {";
+ for (ptr_vector<expr>::iterator it = willEqClass.begin(); it != willEqClass.end(); ++it) {
+ expr * el = *it;
+ tout << " " << mk_pp(el, m);
+ }
+ tout << std::endl;
+ if (constStrAst == NULL) {
+ tout << "constStrAst = NULL" << std::endl;
+ } else {
+ tout << "constStrAst = " << mk_pp(constStrAst, m) << std::endl;
+ }
+ );
+
+ // step 1: we may have constant values for Contains checks now
+ if (constStrAst != NULL) {
+ ptr_vector<expr>::iterator itAst = willEqClass.begin();
+ for (; itAst != willEqClass.end(); itAst++) {
+ if (*itAst == constStrAst) {
+ continue;
+ }
+ check_contain_by_eqc_val(*itAst, constStrAst);
+ }
+ } else {
+ // no concrete value to be put in eqc, solely based on context
+ // Check here is used to detected the facts as follows:
+ // * known: contains(Z, Y) /\ Z = "abcdefg" /\ Y = M
+ // * new fact: M = concat(..., "jio", ...)
+ // Note that in this branch, either M or concat(..., "jio", ...) has a constant value
+ // So, only need to check
+ // * "EQC(M) U EQC(concat(..., "jio", ...))" as substr and
+ // * If strAst registered has an eqc constant in the context
+ // -------------------------------------------------------------
+ ptr_vector<expr>::iterator itAst = willEqClass.begin();
+ for (; itAst != willEqClass.end(); ++itAst) {
+ check_contain_by_substr(*itAst, willEqClass);
+ }
+ }
+
+ // ------------------------------------------
+ // step 2: check for b1 = contains(x, m), b2 = contains(y, n)
+ // (1) x = y /\ m = n ==> b1 = b2
+ // (2) x = y /\ Contains(const(m), const(n)) ==> (b1 -> b2)
+ // (3) x = y /\ Contains(const(n), const(m)) ==> (b2 -> b1)
+ // (4) x = y /\ containPairBoolMap[<eqc(m), eqc(n)>] ==> (b1 -> b2)
+ // (5) x = y /\ containPairBoolMap[<eqc(n), eqc(m)>] ==> (b2 -> b1)
+ // (6) Contains(const(x), const(y)) /\ m = n ==> (b2 -> b1)
+ // (7) Contains(const(y), const(x)) /\ m = n ==> (b1 -> b2)
+ // (8) containPairBoolMap[<eqc(x), eqc(y)>] /\ m = n ==> (b2 -> b1)
+ // (9) containPairBoolMap[<eqc(y), eqc(x)>] /\ m = n ==> (b1 -> b2)
+ // ------------------------------------------
+
+ expr_ref_vector::iterator varItor1 = willEqClass.begin();
+ for (; varItor1 != willEqClass.end(); ++varItor1) {
+ expr * varAst1 = *varItor1;
+ expr_ref_vector::iterator varItor2 = varItor1;
+ for (; varItor2 != willEqClass.end(); ++varItor2) {
+ expr * varAst2 = *varItor2;
+ check_contain_by_eq_nodes(varAst1, varAst2);
+ }
+ }
+}
+
bool theory_str::can_concat_eq_str(expr * concat, std::string str) {
// TODO this method could use some traces and debugging info
int strLen = str.length();
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 7b4ff8ce0..61eefece8 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -191,6 +191,8 @@ namespace smt {
std::map<expr*, expr*> unroll_var_map;
std::map<std::pair<expr*, expr*>, expr*> concat_eq_unroll_ast_map;
+ expr_ref_vector contains_map; // was containPairBoolMap in Z3str2
+
char * char_set;
std::map<char, int> charSetLookupTable;
int charSetSize;
@@ -290,6 +292,7 @@ namespace smt {
app * mk_value_helper(app * n);
expr * get_eqc_value(expr * n, bool & hasEqcValue);
bool in_same_eqc(expr * n1, expr * n2);
+ expr * collect_eq_nodes(expr * n, expr_ref_vector & eqcSet);
bool get_value(expr* e, rational& val) const;
bool get_len_value(expr* e, rational& val);
@@ -306,6 +309,10 @@ namespace smt {
bool check_length_concat_concat(expr * n1, expr * n2);
bool check_length_concat_var(expr * concat, expr * var);
bool check_length_var_var(expr * var1, expr * var2);
+ void check_contain_in_new_eq(expr * n1, expr * n2);
+ void check_contain_by_eqc_val(expr * varNode, expr * constNode);
+ void check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass);
+ void check_contain_by_eq_nodes(expr * n1, expr * n2);
void get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList);
expr * simplify_concat(expr * node);
From 1f594b190a8a00a167dcb234c43caf3d684d9d1c Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 14 Aug 2016 14:55:29 -0400
Subject: [PATCH 178/401] add theory_str::check_contain_by_eqc_val
---
src/smt/theory_str.cpp | 169 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 2 +
2 files changed, 170 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index aed46e868..18157e4be 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4141,8 +4141,161 @@ expr * theory_str::collect_eq_nodes(expr * n, expr_ref_vector & eqcSet) {
return constStrNode;
}
+/*
+ * Collect constant strings (from left to right) in an AST node.
+ */
+void theory_str::get_const_str_asts_in_node(expr * node, expr_ref_vector & astList) {
+ ast_manager & m = get_manager();
+ if (m_strutil.is_string(node)) {
+ astList.push_back(node);
+ //} else if (getNodeType(t, node) == my_Z3_Func) {
+ } else if (is_app(node)) {
+ app * func_app = to_app(node);
+ unsigned int argCount = func_app->get_num_args();
+ for (unsigned int i = 0; i < argCount; i++) {
+ expr * argAst = func_app->get_arg(i);
+ get_const_str_asts_in_node(argAst, astList);
+ }
+ }
+}
+
void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
- NOT_IMPLEMENTED_YET(); // TODO NEXT
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ TRACE("t_str_detail", tout << "varNode = " << mk_pp(varNode, m) << ", constNode = " << mk_pp(constNode, m) << std::endl;);
+
+ expr_ref_vector litems(m);
+
+ // Modification from Z3str:
+ // since we don't track containPairIdxMap any more,
+ // we check each element of contains_map to see whether
+ // either of its arguments are equal to varNode.
+ // This could possibly be made faster if we had a map class that
+ // let us use an expr_ref as a key.
+
+ expr_ref_vector::iterator itor1 = contains_map.begin();
+ for (; itor1 != contains_map.end(); ++itor1) {
+ expr * boolVar = *itor1;
+ // boolVar is actually a Contains term
+ app * containsApp = to_app(boolVar);
+ expr * strAst = containsApp->get_arg(0);
+ expr * substrAst = containsApp->get_arg(1);
+
+ // we only want to inspect the Contains terms where either of strAst or substrAst
+ // are equal to varNode.
+
+ TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
+
+ if (varNode != strAst && varNode != substrAst) {
+ TRACE("t_str_detail", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
+ continue;
+ }
+ TRACE("t_str_detail", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
+
+ // varEqcNode is str
+ if (strAst == varNode) {
+ expr_ref implyR(m);
+ litems.reset();
+
+ if (strAst != constNode) {
+ litems.push_back(ctx.mk_eq_atom(strAst, constNode));
+ }
+ std::string strConst = m_strutil.get_string_constant_value(constNode);
+ bool subStrHasEqcValue = false;
+ expr * substrValue = get_eqc_value(substrAst, subStrHasEqcValue);
+ if (substrValue != substrAst) {
+ litems.push_back(ctx.mk_eq_atom(substrAst, substrValue));
+ }
+
+ if (subStrHasEqcValue) {
+ // subStr has an eqc constant value
+ std::string subStrConst = m_strutil.get_string_constant_value(substrValue);
+
+ TRACE("t_str_detail", tout << "strConst = " << strConst << ", subStrConst = " << subStrConst << std::endl;);
+
+ if (strConst.find(subStrConst) != std::string::npos) {
+ //implyR = ctx.mk_eq(ctx, boolVar, Z3_mk_true(ctx));
+ implyR = boolVar;
+ } else {
+ //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
+ implyR = m.mk_not(boolVar);
+ }
+ } else {
+ // ------------------------------------------------------------------------------------------------
+ // subStr doesn't have an eqc contant value
+ // however, subStr equals to some concat(arg_1, arg_2, ..., arg_n)
+ // if arg_j is a constant and is not a part of the strConst, it's sure that the contains is false
+ // ** This check is needed here because the "strConst" and "strAst" may not be in a same eqc yet
+ // ------------------------------------------------------------------------------------------------
+ // collect eqc concat
+ std::set<expr*> eqcConcats;
+ get_concats_in_eqc(substrAst, eqcConcats);
+ for (std::set<expr*>::iterator concatItor = eqcConcats.begin();
+ concatItor != eqcConcats.end(); concatItor++) {
+ expr_ref_vector constList(m);
+ bool counterEgFound = false;
+ // get constant strings in concat
+ expr * aConcat = *concatItor;
+ get_const_str_asts_in_node(aConcat, constList);
+ for (expr_ref_vector::iterator cstItor = constList.begin();
+ cstItor != constList.end(); cstItor++) {
+ std::string pieceStr = m_strutil.get_string_constant_value(*cstItor);
+ if (strConst.find(pieceStr) == std::string::npos) {
+ counterEgFound = true;
+ if (aConcat != substrAst) {
+ litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
+ }
+ //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
+ implyR = m.mk_not(boolVar);
+ break;
+ }
+ }
+ if (counterEgFound) {
+ TRACE("t_str_detail", tout << "Inconsistency found!" << std::endl;);
+ break;
+ }
+ }
+ }
+ // add assertion
+ if (implyR != NULL) {
+ expr_ref implyLHS(mk_and(litems), m);
+ assert_implication(implyLHS, implyR);
+ }
+ }
+ // varEqcNode is subStr
+ else if (substrAst == varNode) {
+ expr_ref implyR(m);
+ litems.reset();
+
+ if (substrAst != constNode) {
+ litems.push_back(ctx.mk_eq_atom(substrAst, constNode));
+ }
+ bool strHasEqcValue = false;
+ expr * strValue = get_eqc_value(strAst, strHasEqcValue);
+ if (strValue != strAst) {
+ litems.push_back(ctx.mk_eq_atom(strAst, strValue));
+ }
+
+ if (strHasEqcValue) {
+ std::string strConst = m_strutil.get_string_constant_value(strValue);
+ std::string subStrConst = m_strutil.get_string_constant_value(constNode);
+ if (strConst.find(subStrConst) != std::string::npos) {
+ //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_true(ctx));
+ implyR = boolVar;
+ } else {
+ // implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
+ implyR = m.mk_not(boolVar);
+ }
+ }
+
+ // add assertion
+ if (implyR != NULL) {
+ expr_ref implyLHS(mk_and(litems), m);
+ assert_implication(implyLHS, implyR);
+ }
+ }
+ } // for (itor1 : contains_map)
}
void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass) {
@@ -7485,6 +7638,20 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
} // fVarLenCountMap.find(...)
}
+void theory_str::get_concats_in_eqc(expr * n, std::set<expr*> & concats) {
+ context & ctx = get_context();
+
+ expr * eqcNode = n;
+ do {
+ if (is_concat(to_app(eqcNode))) {
+ concats.insert(eqcNode);
+ }
+ enode * e_eqc = ctx.get_enode(eqcNode);
+ eqcNode = e_eqc->get_next()->get_owner();
+ // eqcNode = Z3_theory_get_eqc_next(t, eqcNode);
+ } while (eqcNode != n);
+}
+
void theory_str::get_var_in_eqc(expr * n, std::set<expr*> & varSet) {
context & ctx = get_context();
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 61eefece8..476519e5c 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -379,6 +379,8 @@ namespace smt {
expr * getMostLeftNodeInConcat(expr * node);
expr * getMostRightNodeInConcat(expr * node);
void get_var_in_eqc(expr * n, std::set<expr*> & varSet);
+ void get_concats_in_eqc(expr * n, std::set<expr*> & concats);
+ void get_const_str_asts_in_node(expr * node, expr_ref_vector & constList);
expr * eval_concat(expr * n1, expr * n2);
// strRegex
From ee6f1eef6919b72640f4f12a33795cc54b4346de Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 14 Aug 2016 15:14:48 -0400
Subject: [PATCH 179/401] add theory_str::check_contain_by_substr
---
src/smt/theory_str.cpp | 67 +++++++++++++++++++++++++++++++++++++++++-
1 file changed, 66 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 18157e4be..2258646bb 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4299,7 +4299,72 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
}
void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass) {
- NOT_IMPLEMENTED_YET(); // TODO NEXT
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ expr_ref_vector litems(m);
+
+ // same deal as before, we do not track containPairIdxMap
+ // and so we check elements of contains_map instead
+
+ expr_ref_vector::iterator itor1 = contains_map.begin();
+ for (; itor1 != contains_map.end(); ++itor1) {
+ expr * boolVar = *itor1;
+ // boolVar is actually a Contains term
+ app * containsApp = to_app(boolVar);
+ expr * strAst = containsApp->get_arg(0);
+ expr * substrAst = containsApp->get_arg(1);
+
+ // we only want to inspect the Contains terms where either of strAst or substrAst
+ // are equal to varNode.
+
+ TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
+
+ if (varNode != strAst && varNode != substrAst) {
+ TRACE("t_str_detail", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
+ continue;
+ }
+ TRACE("t_str_detail", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
+
+ if (substrAst == varNode) {
+ bool strAstHasVal = false;
+ expr * strValue = get_eqc_value(strAst, strAstHasVal);
+ if (strAstHasVal) {
+ TRACE("t_str_detail", tout << mk_pp(strAst, m) << " has constant eqc value " << mk_pp(strValue) << std::endl;);
+ if (strValue != strAst) {
+ litems.push_back(ctx.mk_eq_atom(strAst, strValue));
+ }
+ std::string strConst = m_strutil.get_string_constant_value(strValue);
+ // iterate eqc (also eqc-to-be) of substr
+ for (expr_ref_vector::iterator itAst = willEqClass.begin(); itAst != willEqClass.end(); itAst++) {
+ bool counterEgFound = false;
+ if (is_concat(to_app(*itAst))) {
+ expr_ref_vector constList(m);
+ // get constant strings in concat
+ app * aConcat = to_app(*itAst);
+ get_const_str_asts_in_node(aConcat, constList);
+ for (expr_ref_vector::iterator cstItor = constList.begin();
+ cstItor != constList.end(); cstItor++) {
+ std::string pieceStr = m_strutil.get_string_constant_value(*cstItor);
+ if (strConst.find(pieceStr) == std::string::npos) {
+ TRACE("t_str_detail", tout << "Inconsistency found!" << std::endl;);
+ counterEgFound = true;
+ if (aConcat != substrAst) {
+ litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
+ }
+ expr_ref implyLHS(mk_and(litems), m);
+ expr_ref implyR(m.mk_not(boolVar), m);
+ assert_implication(implyLHS, implyR);
+ break;
+ }
+ }
+ }
+ if (counterEgFound) {
+ break;
+ }
+ }
+ }
+ }
+ }
}
void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
From f48377e78004f9c503b9bbba8e4dd588450ce107 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 14 Aug 2016 16:14:48 -0400
Subject: [PATCH 180/401] temporarily disable a third Contains check for
testing purposes
---
src/smt/theory_str.cpp | 19 +++++++++++--------
1 file changed, 11 insertions(+), 8 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 2258646bb..28b310196 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -48,7 +48,8 @@ theory_str::theory_str(ast_manager & m):
tmpLenTestVarCount(0),
tmpValTestVarCount(0),
avoidLoopCut(true),
- loopDetected(false)
+ loopDetected(false),
+ contains_map(m)
{
initialize_charset();
}
@@ -4258,7 +4259,7 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
}
}
// add assertion
- if (implyR != NULL) {
+ if (implyR) {
expr_ref implyLHS(mk_and(litems), m);
assert_implication(implyLHS, implyR);
}
@@ -4290,7 +4291,7 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
}
// add assertion
- if (implyR != NULL) {
+ if (implyR) {
expr_ref implyLHS(mk_and(litems), m);
assert_implication(implyLHS, implyR);
}
@@ -4329,7 +4330,7 @@ void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willE
bool strAstHasVal = false;
expr * strValue = get_eqc_value(strAst, strAstHasVal);
if (strAstHasVal) {
- TRACE("t_str_detail", tout << mk_pp(strAst, m) << " has constant eqc value " << mk_pp(strValue) << std::endl;);
+ TRACE("t_str_detail", tout << mk_pp(strAst, m) << " has constant eqc value " << mk_pp(strValue, m) << std::endl;);
if (strValue != strAst) {
litems.push_back(ctx.mk_eq_atom(strAst, strValue));
}
@@ -4387,7 +4388,7 @@ void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
expr * constStrAst = collect_eq_nodes(n1, willEqClass);
TRACE("t_str_detail", tout << "eqc of n1 is {";
- for (ptr_vector<expr>::iterator it = willEqClass.begin(); it != willEqClass.end(); ++it) {
+ for (expr_ref_vector::iterator it = willEqClass.begin(); it != willEqClass.end(); ++it) {
expr * el = *it;
tout << " " << mk_pp(el, m);
}
@@ -4401,7 +4402,7 @@ void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
// step 1: we may have constant values for Contains checks now
if (constStrAst != NULL) {
- ptr_vector<expr>::iterator itAst = willEqClass.begin();
+ expr_ref_vector::iterator itAst = willEqClass.begin();
for (; itAst != willEqClass.end(); itAst++) {
if (*itAst == constStrAst) {
continue;
@@ -4418,7 +4419,7 @@ void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
// * "EQC(M) U EQC(concat(..., "jio", ...))" as substr and
// * If strAst registered has an eqc constant in the context
// -------------------------------------------------------------
- ptr_vector<expr>::iterator itAst = willEqClass.begin();
+ expr_ref_vector::iterator itAst = willEqClass.begin();
for (; itAst != willEqClass.end(); ++itAst) {
check_contain_by_substr(*itAst, willEqClass);
}
@@ -4443,7 +4444,9 @@ void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
expr_ref_vector::iterator varItor2 = varItor1;
for (; varItor2 != willEqClass.end(); ++varItor2) {
expr * varAst2 = *varItor2;
- check_contain_by_eq_nodes(varAst1, varAst2);
+ // for testing purposes
+ TRACE("t_str", tout << "WARNING: some Contains checks disabled!" << std::endl;);
+ // check_contain_by_eq_nodes(varAst1, varAst2);
}
}
}
From d28ef1d47185d6d67a95e1cb3b6251ed9e72c6da Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 15 Aug 2016 17:38:24 -0400
Subject: [PATCH 181/401] add theory_str::check_contain_by_eq_nodes
---
src/smt/theory_str.cpp | 382 ++++++++++++++++++++++++++++++++++++++--
src/smt/theory_str.h | 27 ++-
src/util/obj_pair_set.h | 5 +
3 files changed, 394 insertions(+), 20 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 28b310196..93173402c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -152,6 +152,11 @@ void theory_str::assert_axiom(expr * e) {
//TRACE("t_str_detail", tout << "done asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
}
+expr * theory_str::rewrite_implication(expr * premise, expr * conclusion) {
+ ast_manager & m = get_manager();
+ return m.mk_or(m.mk_not(premise), conclusion);
+}
+
void theory_str::assert_implication(expr * premise, expr * conclusion) {
ast_manager & m = get_manager();
TRACE("t_str_detail", tout << "asserting implication " << mk_ismt2_pp(premise, m) << " -> " << mk_ismt2_pp(conclusion, m) << std::endl;);
@@ -1119,20 +1124,28 @@ void theory_str::instantiate_axiom_Contains(enode * e) {
context & ctx = get_context();
ast_manager & m = get_manager();
- app * expr = e->get_owner();
- if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up Contains axiom for " << mk_pp(expr, m) << std::endl;);
+ app * ex = e->get_owner();
+ if (axiomatized_terms.contains(ex)) {
+ TRACE("t_str_detail", tout << "already set up Contains axiom for " << mk_pp(ex, m) << std::endl;);
return;
}
- axiomatized_terms.insert(expr);
- contains_map.push_back(expr); // replaces registerContain() in Z3str2
+ axiomatized_terms.insert(ex);
+ { // register Contains()
+ expr * str = ex->get_arg(0);
+ expr * substr = ex->get_arg(1);
+ contains_map.push_back(ex);
+ std::pair<expr*, expr*> key = std::pair<expr*, expr*>(str, substr);
+ contain_pair_bool_map.insert(str, substr, ex);
+ contain_pair_idx_map[str].insert(key);
+ contain_pair_idx_map[substr].insert(key);
+ }
- TRACE("t_str_detail", tout << "instantiate Contains axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("t_str_detail", tout << "instantiate Contains axiom for " << mk_pp(ex, m) << std::endl;);
expr_ref ts0(mk_str_var("ts0"), m);
expr_ref ts1(mk_str_var("ts1"), m);
- expr_ref breakdownAssert(ctx.mk_eq_atom(expr, ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, mk_concat(expr->get_arg(1), ts1)))), m);
+ expr_ref breakdownAssert(ctx.mk_eq_atom(ex, ctx.mk_eq_atom(ex->get_arg(0), mk_concat(ts0, mk_concat(ex->get_arg(1), ts1)))), m);
SASSERT(breakdownAssert);
assert_axiom(breakdownAssert);
}
@@ -4168,12 +4181,7 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
expr_ref_vector litems(m);
- // Modification from Z3str:
- // since we don't track containPairIdxMap any more,
- // we check each element of contains_map to see whether
- // either of its arguments are equal to varNode.
- // This could possibly be made faster if we had a map class that
- // let us use an expr_ref as a key.
+ // TODO refactor to use the new contain_pair_idx_map
expr_ref_vector::iterator itor1 = contains_map.begin();
for (; itor1 != contains_map.end(); ++itor1) {
@@ -4304,8 +4312,7 @@ void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willE
ast_manager & m = get_manager();
expr_ref_vector litems(m);
- // same deal as before, we do not track containPairIdxMap
- // and so we check elements of contains_map instead
+ // TODO refactor to use the new contain_pair_idx_map
expr_ref_vector::iterator itor1 = contains_map.begin();
for (; itor1 != contains_map.end(); ++itor1) {
@@ -4368,8 +4375,347 @@ void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willE
}
}
+bool theory_str::in_contain_idx_map(expr * n) {
+ return contain_pair_idx_map.contains(n);
+}
+
void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
- NOT_IMPLEMENTED_YET(); // TODO NEXT
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ if (in_contain_idx_map(n1) && in_contain_idx_map(n2)) {
+ obj_pair_set<expr, expr>::iterator keysItor1 = contain_pair_idx_map[n1].begin();
+ obj_pair_set<expr, expr>::iterator keysItor2;
+
+ for (; keysItor1 != contain_pair_idx_map[n1].end(); keysItor1++) {
+ // keysItor1 is on set {<.., n1>, ..., <n1, ...>, ...}
+ std::pair<expr*, expr*> key1 = *keysItor1;
+ if (key1.first == n1 && key1.second == n2) {
+ expr_ref implyL(m);
+ expr_ref implyR(contain_pair_bool_map[key1], m);
+ if (n1 != n2) {
+ implyL = ctx.mk_eq_atom(n1, n2);
+ assert_implication(implyL, implyR);
+ } else {
+ assert_axiom(implyR);
+ }
+ }
+
+ for (keysItor2 = contain_pair_idx_map[n2].begin();
+ keysItor2 != contain_pair_idx_map[n2].end(); keysItor2++) {
+ // keysItor2 is on set {<.., n2>, ..., <n2, ...>, ...}
+ std::pair<expr*, expr*> key2 = *keysItor2;
+ // skip if the pair is eq
+ if (key1 == key2) {
+ continue;
+ }
+
+ // ***************************
+ // Case 1: Contains(m, ...) /\ Contains(n, ) /\ m = n
+ // ***************************
+ if (key1.first == n1 && key2.first == n2) {
+ expr * subAst1 = key1.second;
+ expr * subAst2 = key2.second;
+ bool subAst1HasValue = false;
+ bool subAst2HasValue = false;
+ expr * subValue1 = get_eqc_value(subAst1, subAst1HasValue);
+ expr * subValue2 = get_eqc_value(subAst2, subAst2HasValue);
+
+ TRACE("t_str_detail",
+ tout << "(Contains " << mk_pp(n1, m) << " " << mk_pp(subAst1, m) << ")" << std::endl;
+ tout << "(Contains " << mk_pp(n2, m) << " " << mk_pp(subAst2, m) << ")" << std::endl;
+ if (subAst1 != subValue1) {
+ tout << mk_pp(subAst1, m) << " = " << mk_pp(subValue1, m) << std::endl;
+ }
+ if (subAst2 != subValue2) {
+ tout << mk_pp(subAst2, m) << " = " << mk_pp(subValue2, m) << std::endl;
+ }
+ );
+
+ if (subAst1HasValue && subAst2HasValue) {
+ expr_ref_vector litems1(m);
+ if (n1 != n2) {
+ litems1.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ if (subValue1 != subAst1) {
+ litems1.push_back(ctx.mk_eq_atom(subAst1, subValue1));
+ }
+ if (subValue2 != subAst2) {
+ litems1.push_back(ctx.mk_eq_atom(subAst2, subValue2));
+ }
+
+ std::string subConst1 = m_strutil.get_string_constant_value(subValue1);
+ std::string subConst2 = m_strutil.get_string_constant_value(subValue2);
+ expr_ref implyR(m);
+ if (subConst1 == subConst2) {
+ // key1.first = key2.first /\ key1.second = key2.second
+ // ==> (containPairBoolMap[key1] = containPairBoolMap[key2])
+ implyR = ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
+ } else if (subConst1.find(subConst2) != std::string::npos) {
+ // key1.first = key2.first /\ Contains(key1.second, key2.second)
+ // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
+ implyR = rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
+ } else if (subConst2.find(subConst1) != std::string::npos) {
+ // key1.first = key2.first /\ Contains(key2.second, key1.second)
+ // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
+ implyR = rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]);
+ }
+
+ if (implyR) {
+ if (litems1.empty()) {
+ assert_axiom(implyR);
+ } else {
+ assert_implication(mk_and(litems1), implyR);
+ }
+ }
+ } else {
+ expr_ref_vector subAst1Eqc(m);
+ expr_ref_vector subAst2Eqc(m);
+ collect_eq_nodes(subAst1, subAst1Eqc);
+ collect_eq_nodes(subAst2, subAst2Eqc);
+
+ if (subAst1Eqc.contains(subAst2)) {
+ // -----------------------------------------------------------
+ // * key1.first = key2.first /\ key1.second = key2.second
+ // --> containPairBoolMap[key1] = containPairBoolMap[key2]
+ // -----------------------------------------------------------
+ expr_ref_vector litems2(m);
+ if (n1 != n2) {
+ litems2.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ if (subAst1 != subAst2) {
+ litems2.push_back(ctx.mk_eq_atom(subAst1, subAst2));
+ }
+ expr_ref implyR(ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
+ if (litems2.empty()) {
+ assert_axiom(implyR);
+ } else {
+ assert_implication(mk_and(litems2), implyR);
+ }
+ } else {
+ // -----------------------------------------------------------
+ // * key1.first = key2.first
+ // check eqc(key1.second) and eqc(key2.second)
+ // -----------------------------------------------------------
+ expr_ref_vector::iterator eqItorSub1 = subAst1Eqc.begin();
+ for (; eqItorSub1 != subAst1Eqc.end(); eqItorSub1++) {
+ expr_ref_vector::iterator eqItorSub2 = subAst2Eqc.begin();
+ for (; eqItorSub2 != subAst2Eqc.end(); eqItorSub2++) {
+ // ------------
+ // key1.first = key2.first /\ containPairBoolMap[<eqc(key1.second), eqc(key2.second)>]
+ // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
+ // ------------
+ {
+ expr_ref_vector litems3(m);
+ if (n1 != n2) {
+ litems3.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ expr * eqSubVar1 = *eqItorSub1;
+ if (eqSubVar1 != subAst1) {
+ litems3.push_back(ctx.mk_eq_atom(subAst1, eqSubVar1));
+ }
+ expr * eqSubVar2 = *eqItorSub2;
+ if (eqSubVar2 != subAst2) {
+ litems3.push_back(ctx.mk_eq_atom(subAst2, eqSubVar2));
+ }
+ std::pair<expr*, expr*> tryKey1 = std::make_pair(eqSubVar1, eqSubVar2);
+ if (contain_pair_bool_map.contains(tryKey1)) {
+ TRACE("t_str_detail", tout << "(Contains " << mk_pp(eqSubVar1, m) << " " << mk_pp(eqSubVar2, m) << ")" << std::endl;);
+ litems3.push_back(contain_pair_bool_map[tryKey1]);
+ expr_ref implR(rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
+ assert_implication(mk_and(litems3), implR);
+ }
+ }
+ // ------------
+ // key1.first = key2.first /\ containPairBoolMap[<eqc(key2.second), eqc(key1.second)>]
+ // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
+ // ------------
+ {
+ expr_ref_vector litems4(m);
+ if (n1 != n2) {
+ litems4.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ expr * eqSubVar1 = *eqItorSub1;
+ if (eqSubVar1 != subAst1) {
+ litems4.push_back(ctx.mk_eq_atom(subAst1, eqSubVar1));
+ }
+ expr * eqSubVar2 = *eqItorSub2;
+ if (eqSubVar2 != subAst2) {
+ litems4.push_back(ctx.mk_eq_atom(subAst2, eqSubVar2));
+ }
+ std::pair<expr*, expr*> tryKey2 = std::make_pair(eqSubVar2, eqSubVar1);
+ if (contain_pair_bool_map.contains(tryKey2)) {
+ TRACE("t_str_detail", tout << "(Contains " << mk_pp(eqSubVar2, m) << " " << mk_pp(eqSubVar1, m) << ")" << std::endl;);
+ litems4.push_back(contain_pair_bool_map[tryKey2]);
+ expr_ref implR(rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]), m);
+ assert_implication(mk_and(litems4), implR);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ // ***************************
+ // Case 2: Contains(..., m) /\ Contains(... , n) /\ m = n
+ // ***************************
+ else if (key1.second == n1 && key2.second == n2) {
+ expr * str1 = key1.first;
+ expr * str2 = key2.first;
+ bool str1HasValue = false;
+ bool str2HasValue = false;
+ expr * strVal1 = get_eqc_value(str1, str1HasValue);
+ expr * strVal2 = get_eqc_value(str2, str2HasValue);
+
+ TRACE("t_str_detail",
+ tout << "(Contains " << mk_pp(str1, m) << " " << mk_pp(n1, m) << ")" << std::endl;
+ tout << "(Contains " << mk_pp(str2, m) << " " << mk_pp(n2, m) << ")" << std::endl;
+ if (str1 != strVal1) {
+ tout << mk_pp(str1, m) << " = " << mk_pp(strVal1, m) << std::endl;
+ }
+ if (str2 != strVal2) {
+ tout << mk_pp(str2, m) << " = " << mk_pp(strVal2, m) << std::endl;
+ }
+ );
+
+ if (str1HasValue && str2HasValue) {
+ expr_ref_vector litems1(m);
+ if (n1 != n2) {
+ litems1.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ if (strVal1 != str1) {
+ litems1.push_back(ctx.mk_eq_atom(str1, strVal1));
+ }
+ if (strVal2 != str2) {
+ litems1.push_back(ctx.mk_eq_atom(str2, strVal2));
+ }
+
+ std::string const1 = m_strutil.get_string_constant_value(strVal1);
+ std::string const2 = m_strutil.get_string_constant_value(strVal2);
+ expr_ref implyR(m);
+
+ if (const1 == const2) {
+ // key1.second = key2.second /\ key1.first = key2.first
+ // ==> (containPairBoolMap[key1] = containPairBoolMap[key2])
+ implyR = ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
+ } else if (const1.find(const2) != std::string::npos) {
+ // key1.second = key2.second /\ Contains(key1.first, key2.first)
+ // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
+ implyR = rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]);
+ } else if (const2.find(const1) != std::string::npos) {
+ // key1.first = key2.first /\ Contains(key2.first, key1.first)
+ // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
+ implyR = rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
+ }
+
+ if (implyR) {
+ if (litems1.size() == 0) {
+ assert_axiom(implyR);
+ } else {
+ assert_implication(mk_and(litems1), implyR);
+ }
+ }
+ }
+
+ else {
+ expr_ref_vector str1Eqc(m);
+ expr_ref_vector str2Eqc(m);
+ collect_eq_nodes(str1, str1Eqc);
+ collect_eq_nodes(str2, str2Eqc);
+
+ if (str1Eqc.contains(str2)) {
+ // -----------------------------------------------------------
+ // * key1.first = key2.first /\ key1.second = key2.second
+ // --> containPairBoolMap[key1] = containPairBoolMap[key2]
+ // -----------------------------------------------------------
+ expr_ref_vector litems2(m);
+ if (n1 != n2) {
+ litems2.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ if (str1 != str2) {
+ litems2.push_back(ctx.mk_eq_atom(str1, str2));
+ }
+ expr_ref implyR(ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
+ if (litems2.empty()) {
+ assert_axiom(implyR);
+ } else {
+ assert_implication(mk_and(litems2), implyR);
+ }
+ } else {
+ // -----------------------------------------------------------
+ // * key1.second = key2.second
+ // check eqc(key1.first) and eqc(key2.first)
+ // -----------------------------------------------------------
+ expr_ref_vector::iterator eqItorStr1 = str1Eqc.begin();
+ for (; eqItorStr1 != str1Eqc.end(); eqItorStr1++) {
+ expr_ref_vector::iterator eqItorStr2 = str2Eqc.begin();
+ for (; eqItorStr2 != str2Eqc.end(); eqItorStr2++) {
+ {
+ expr_ref_vector litems3(m);
+ if (n1 != n2) {
+ litems3.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ expr * eqStrVar1 = *eqItorStr1;
+ if (eqStrVar1 != str1) {
+ litems3.push_back(ctx.mk_eq_atom(str1, eqStrVar1));
+ }
+ expr * eqStrVar2 = *eqItorStr2;
+ if (eqStrVar2 != str2) {
+ litems3.push_back(ctx.mk_eq_atom(str2, eqStrVar2));
+ }
+ std::pair<expr*, expr*> tryKey1 = std::make_pair(eqStrVar1, eqStrVar2);
+ if (contain_pair_bool_map.contains(tryKey1)) {
+ TRACE("t_str_detail", tout << "(Contains " << mk_pp(eqStrVar1, m) << " " << mk_pp(eqStrVar2, m) << ")" << std::endl;);
+ litems3.push_back(contain_pair_bool_map[tryKey1]);
+
+ // ------------
+ // key1.second = key2.second /\ containPairBoolMap[<eqc(key1.first), eqc(key2.first)>]
+ // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
+ // ------------
+ expr_ref implR(rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]), m);
+ assert_implication(mk_and(litems3), implR);
+ }
+ }
+
+ {
+ expr_ref_vector litems4(m);
+ if (n1 != n2) {
+ litems4.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ expr * eqStrVar1 = *eqItorStr1;
+ if (eqStrVar1 != str1) {
+ litems4.push_back(ctx.mk_eq_atom(str1, eqStrVar1));
+ }
+ expr *eqStrVar2 = *eqItorStr2;
+ if (eqStrVar2 != str2) {
+ litems4.push_back(ctx.mk_eq_atom(str2, eqStrVar2));
+ }
+ std::pair<expr*, expr*> tryKey2 = std::make_pair(eqStrVar2, eqStrVar1);
+
+ if (contain_pair_bool_map.contains(tryKey2)) {
+ TRACE("t_str_detail", tout << "(Contains " << mk_pp(eqStrVar2, m) << " " << mk_pp(eqStrVar1, m) << ")" << std::endl;);
+ litems4.push_back(contain_pair_bool_map[tryKey2]);
+ // ------------
+ // key1.first = key2.first /\ containPairBoolMap[<eqc(key2.second), eqc(key1.second)>]
+ // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
+ // ------------
+ expr_ref implR(ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
+ assert_implication(mk_and(litems4), implR);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ }
+ }
+
+ if (n1 == n2) {
+ break;
+ }
+ }
+ } // (in_contain_idx_map(n1) && in_contain_idx_map(n2))
}
void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
@@ -4444,9 +4790,7 @@ void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
expr_ref_vector::iterator varItor2 = varItor1;
for (; varItor2 != willEqClass.end(); ++varItor2) {
expr * varAst2 = *varItor2;
- // for testing purposes
- TRACE("t_str", tout << "WARNING: some Contains checks disabled!" << std::endl;);
- // check_contain_by_eq_nodes(varAst1, varAst2);
+ check_contain_by_eq_nodes(varAst1, varAst2);
}
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 476519e5c..e5fd25894 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -49,6 +49,26 @@ namespace smt {
virtual void register_value(expr * n) { /* Ignore */ }
};
+ // rather than modify obj_pair_map I inherit from it and add my own helper methods
+ class theory_str_contain_pair_bool_map_t : public obj_pair_map<expr, expr, expr*> {
+ public:
+ expr * operator[](std::pair<expr*, expr*> key) const {
+ expr * value;
+ bool found = this->find(key.first, key.second, value);
+ if (found) {
+ return value;
+ } else {
+ TRACE("t_str", tout << "WARNING: lookup miss in contain_pair_bool_map!" << std::endl;);
+ return NULL;
+ }
+ }
+
+ bool contains(std::pair<expr*, expr*> key) const {
+ expr * unused;
+ return this->find(key.first, key.second, unused);
+ }
+ };
+
class theory_str : public theory {
struct T_cut
{
@@ -191,7 +211,10 @@ namespace smt {
std::map<expr*, expr*> unroll_var_map;
std::map<std::pair<expr*, expr*>, expr*> concat_eq_unroll_ast_map;
- expr_ref_vector contains_map; // was containPairBoolMap in Z3str2
+ expr_ref_vector contains_map;
+
+ theory_str_contain_pair_bool_map_t contain_pair_bool_map;
+ obj_map<expr, obj_pair_set<expr, expr> > contain_pair_idx_map;
char * char_set;
std::map<char, int> charSetLookupTable;
@@ -200,6 +223,7 @@ namespace smt {
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
+ expr * rewrite_implication(expr * premise, expr * conclusion);
app * mk_strlen(expr * e);
expr * mk_concat(expr * n1, expr * n2);
@@ -313,6 +337,7 @@ namespace smt {
void check_contain_by_eqc_val(expr * varNode, expr * constNode);
void check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass);
void check_contain_by_eq_nodes(expr * n1, expr * n2);
+ bool in_contain_idx_map(expr * n);
void get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList);
expr * simplify_concat(expr * node);
diff --git a/src/util/obj_pair_set.h b/src/util/obj_pair_set.h
index 29139a51d..c4212977c 100644
--- a/src/util/obj_pair_set.h
+++ b/src/util/obj_pair_set.h
@@ -46,6 +46,11 @@ public:
bool contains(obj_pair const & p) const { return m_set.contains(p); }
void reset() { m_set.reset(); }
bool empty() const { return m_set.empty(); }
+
+ typedef typename chashtable<obj_pair, hash_proc, eq_proc>::iterator iterator;
+
+ iterator begin() { return m_set.begin(); }
+ iterator end() { return m_set.end(); }
};
#endif
From 685edbb268cb1034c580fda269c1e226118da17e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 15 Aug 2016 18:58:36 -0400
Subject: [PATCH 182/401] pull out incorrectly-used data structures in
theory_str for contains check, this will need to be revisited
---
src/smt/theory_str.cpp | 6 +++---
src/smt/theory_str.h | 4 +++-
2 files changed, 6 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 93173402c..40745b069 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4376,7 +4376,7 @@ void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willE
}
bool theory_str::in_contain_idx_map(expr * n) {
- return contain_pair_idx_map.contains(n);
+ return contain_pair_idx_map.find(n) != contain_pair_idx_map.end();
}
void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
@@ -4384,8 +4384,8 @@ void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
ast_manager & m = get_manager();
if (in_contain_idx_map(n1) && in_contain_idx_map(n2)) {
- obj_pair_set<expr, expr>::iterator keysItor1 = contain_pair_idx_map[n1].begin();
- obj_pair_set<expr, expr>::iterator keysItor2;
+ std::set<std::pair<expr*, expr*> >::iterator keysItor1 = contain_pair_idx_map[n1].begin();
+ std::set<std::pair<expr*, expr*> >::iterator keysItor2;
for (; keysItor1 != contain_pair_idx_map[n1].end(); keysItor1++) {
// keysItor1 is on set {<.., n1>, ..., <n1, ...>, ...}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index e5fd25894..fd93edfd4 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -214,7 +214,9 @@ namespace smt {
expr_ref_vector contains_map;
theory_str_contain_pair_bool_map_t contain_pair_bool_map;
- obj_map<expr, obj_pair_set<expr, expr> > contain_pair_idx_map;
+ //obj_map<expr, obj_pair_set<expr, expr> > contain_pair_idx_map;
+ // TODO Find a better data structure, this is 100% a hack right now
+ std::map<expr*, std::set<std::pair<expr*, expr*> > > contain_pair_idx_map;
char * char_set;
std::map<char, int> charSetLookupTable;
From 48081864b01904f096f219cd30d119b05c0b8961 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 16 Aug 2016 18:07:31 -0400
Subject: [PATCH 183/401] add regex validation in str_rewriter
---
src/ast/rewriter/str_rewriter.cpp | 200 ++++++++++++++++++++++++++++++
src/ast/str_decl_plugin.h | 4 +-
2 files changed, 202 insertions(+), 2 deletions(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index fdb67f89e..54e0dd443 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -22,6 +22,192 @@ Notes:
#include"ast_pp.h"
#include"ast_util.h"
#include"well_sorted.h"
+#include<map>
+#include<set>
+#include<deque>
+
+class nfa {
+protected:
+ str_util & m_strutil;
+
+ bool m_valid;
+ unsigned m_next_id;
+
+ unsigned next_id() {
+ unsigned retval = m_next_id;
+ ++m_next_id;
+ return retval;
+ }
+
+ unsigned m_start_state;
+ unsigned m_end_state;
+
+ std::map<unsigned, std::map<char, unsigned> > transition_map;
+ std::map<unsigned, std::set<unsigned> > epsilon_map;
+
+ void make_transition(unsigned start, char symbol, unsigned end) {
+ transition_map[start][symbol] = end;
+ }
+
+ void make_epsilon_move(unsigned start, unsigned end) {
+ epsilon_map[start].insert(end);
+ }
+
+ // Convert a regular expression to an e-NFA using Thompson's construction
+ void convert_re(expr * e, unsigned & start, unsigned & end) {
+ start = next_id();
+ end = next_id();
+ if (m_strutil.is_re_Str2Reg(e)) {
+ app * a = to_app(e);
+ expr * arg_str = a->get_arg(0);
+ if (m_strutil.is_string(arg_str)) {
+ std::string str = m_strutil.get_string_constant_value(arg_str);
+ TRACE("t_str_rw", tout << "build NFA for '" << str << "'" << std::endl;);
+
+ // TODO this assumes the string is not empty
+ /*
+ * For an n-character string, we make (n-1) intermediate states,
+ * labelled i_(0) through i_(n-2).
+ * Then we construct the following transitions:
+ * start --str[0]--> i_(0) --str[1]--> i_(1) --...--> i_(n-2) --str[n-1]--> final
+ */
+ unsigned last = start;
+ for (unsigned i = 0; i <= str.length() - 2; ++i) {
+ unsigned i_state = next_id();
+ make_transition(last, str.at(i), i_state);
+ TRACE("t_str_rw", tout << "string transition " << last << "--" << str.at(i) << "--> " << i_state << std::endl;);
+ last = i_state;
+ }
+ make_transition(last, str.at(str.length() - 1), end);
+ TRACE("t_str_rw", tout << "string transition " << last << "--" << str.at(str.length() - 1) << "--> " << end << std::endl;);
+ TRACE("t_str_rw", tout << "string NFA: start = " << start << ", end = " << end << std::endl;);
+ } else {
+ TRACE("t_str_rw", tout << "invalid string constant in Str2Reg" << std::endl;);
+ m_valid = false;
+ return;
+ }
+ } else if (m_strutil.is_re_RegexConcat(e)){
+ app * a = to_app(e);
+ expr * re1 = a->get_arg(0);
+ expr * re2 = a->get_arg(1);
+ unsigned start1, end1;
+ convert_re(re1, start1, end1);
+ unsigned start2, end2;
+ convert_re(re2, start2, end2);
+ // start --e--> start1 --...--> end1 --e--> start2 --...--> end2 --e--> end
+ make_epsilon_move(start, start1);
+ make_epsilon_move(end1, start2);
+ make_epsilon_move(end2, end);
+ TRACE("t_str_rw", tout << "concat NFA: start = " << start << ", end = " << end << std::endl;);
+ } else if (m_strutil.is_re_RegexUnion(e)) {
+ app * a = to_app(e);
+ expr * re1 = a->get_arg(0);
+ expr * re2 = a->get_arg(1);
+ unsigned start1, end1;
+ convert_re(re1, start1, end1);
+ unsigned start2, end2;
+ convert_re(re2, start2, end2);
+
+ // start --e--> start1 ; start --e--> start2
+ // end1 --e--> end ; end2 --e--> end
+ make_epsilon_move(start, start1);
+ make_epsilon_move(start, start2);
+ make_epsilon_move(end1, end);
+ make_epsilon_move(end2, end);
+ TRACE("t_str_rw", tout << "union NFA: start = " << start << ", end = " << end << std::endl;);
+ } else if (m_strutil.is_re_RegexStar(e)) {
+ app * a = to_app(e);
+ expr * subex = a->get_arg(0);
+ unsigned start_subex, end_subex;
+ convert_re(subex, start_subex, end_subex);
+ // start --e--> start_subex, start --e--> end
+ // end_subex --e--> start_subex, end_subex --e--> end
+ make_epsilon_move(start, start_subex);
+ make_epsilon_move(start, end);
+ make_epsilon_move(end_subex, start_subex);
+ make_epsilon_move(end_subex, end);
+ TRACE("t_str_rw", tout << "star NFA: start = " << start << ", end = " << end << std::endl;);
+ } else {
+ TRACE("t_str_rw", tout << "invalid regular expression" << std::endl;);
+ m_valid = false;
+ return;
+ }
+ }
+
+public:
+ nfa(str_util & m_strutil, expr * e)
+: m_strutil(m_strutil),
+ m_valid(true), m_next_id(0), m_start_state(0), m_end_state(0) {
+ convert_re(e, m_start_state, m_end_state);
+ }
+
+ bool is_valid() const {
+ return m_valid;
+ }
+
+ void epsilon_closure(unsigned start, std::set<unsigned> & closure) {
+ std::deque<unsigned> worklist;
+ closure.insert(start);
+ worklist.push_back(start);
+
+ while(!worklist.empty()) {
+ unsigned state = worklist.front();
+ worklist.pop_front();
+ if (epsilon_map.find(state) != epsilon_map.end()) {
+ for (std::set<unsigned>::iterator it = epsilon_map[state].begin();
+ it != epsilon_map[state].end(); ++it) {
+ unsigned new_state = *it;
+ if (closure.find(new_state) == closure.end()) {
+ closure.insert(new_state);
+ worklist.push_back(new_state);
+ }
+ }
+ }
+ }
+ }
+
+ bool matches(std::string input) {
+ /*
+ * Keep a set of all states the NFA can currently be in.
+ * Initially this is the e-closure of m_start_state
+ * For each character A in the input string,
+ * the set of next states contains
+ * all states in transition_map[S][A] for each S in current_states,
+ * and all states in epsilon_map[S] for each S in current_states.
+ * After consuming the entire input string,
+ * the match is successful iff current_states contains m_end_state.
+ */
+ std::set<unsigned> current_states;
+ epsilon_closure(m_start_state, current_states);
+ for (unsigned i = 0; i < input.length(); ++i) {
+ char A = input.at(i);
+ std::set<unsigned> next_states;
+ for (std::set<unsigned>::iterator it = current_states.begin();
+ it != current_states.end(); ++it) {
+ unsigned S = *it;
+ // check transition_map
+ if (transition_map[S].find(A) != transition_map[S].end()) {
+ next_states.insert(transition_map[S][A]);
+ }
+ }
+
+ // take e-closure over next_states to compute the actual next_states
+ std::set<unsigned> epsilon_next_states;
+ for (std::set<unsigned>::iterator it = next_states.begin(); it != next_states.end(); ++it) {
+ unsigned S = *it;
+ std::set<unsigned> closure;
+ epsilon_closure(S, closure);
+ epsilon_next_states.insert(closure.begin(), closure.end());
+ }
+ current_states = epsilon_next_states;
+ }
+ if (current_states.find(m_end_state) != current_states.end()) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+};
br_status str_rewriter::mk_str_Concat(expr * arg0, expr * arg1, expr_ref & result) {
TRACE("t_str_rw", tout << "rewrite (Concat " << mk_pp(arg0, m()) << " " << mk_pp(arg1, m()) << ")" << std::endl;);
@@ -243,6 +429,20 @@ br_status str_rewriter::mk_re_RegexIn(expr * str, expr * re, expr_ref & result)
return BR_REWRITE_FULL;
}
+ // necessary for model validation
+ if (m_strutil.is_string(str)) {
+ TRACE("t_str_rw", tout << "RegexIn with constant string argument" << std::endl;);
+ nfa regex_nfa(m_strutil, re);
+ ENSURE(regex_nfa.is_valid());
+ std::string input = m_strutil.get_string_constant_value(str);
+ if (regex_nfa.matches(input)) {
+ result = m().mk_true();
+ } else {
+ result = m().mk_false();
+ }
+ return BR_DONE;
+ }
+
return BR_FAILED;
}
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 4b7a8858e..5b0ca2a3a 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -111,7 +111,6 @@ public:
virtual bool is_value(app * e) const;
virtual bool is_unique_value(app * e) const { return is_value(e); }
- // TODO
};
class str_recognizers {
@@ -125,11 +124,12 @@ public:
bool is_string(expr const * n) const;
bool is_re_Str2Reg(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_STR2REGEX); }
+ bool is_re_RegexConcat(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_REGEXCONCAT); }
+ bool is_re_RegexUnion(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_REGEXUNION); }
bool is_re_RegexStar(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_REGEXSTAR); }
bool is_re_RegexPlus(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_REGEXPLUS); }
std::string get_string_constant_value(expr const *n) const;
- // TODO
};
class str_util : public str_recognizers {
From 0834229b394754ef6cec69f1d4de7206a669bcaf Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 17 Aug 2016 15:33:02 -0400
Subject: [PATCH 184/401] theory_str model validation for substr
---
src/ast/rewriter/str_rewriter.cpp | 20 ++++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
2 files changed, 21 insertions(+)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 54e0dd443..fe434575e 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -412,6 +412,23 @@ br_status str_rewriter::mk_str_Replace(expr * base, expr * source, expr * target
}
}
+br_status str_rewriter::mk_str_Substr(expr * base, expr * start, expr * len, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (Substr " << mk_pp(base, m()) << " " << mk_pp(start, m()) << " " << mk_pp(len, m()) << ")" << std::endl;);
+ rational startVal, lenVal;
+ if (m_strutil.is_string(base) && m_autil.is_numeral(start, startVal) && m_autil.is_numeral(len, lenVal)) {
+ std::string baseStr = m_strutil.get_string_constant_value(base);
+ // TODO handling for invalid start/len
+ if (startVal.is_nonneg() && lenVal.is_nonneg() && startVal.get_unsigned() <= baseStr.length()) {
+ TRACE("t_str_rw", tout << "rewriting constant Substr expression" << std::endl;);
+ std::string substr = baseStr.substr(startVal.get_unsigned(), lenVal.get_unsigned());
+ result = m_strutil.mk_string(substr);
+ return BR_DONE;
+ }
+ }
+
+ return BR_FAILED;
+}
+
br_status str_rewriter::mk_re_Str2Reg(expr * str, expr_ref & result) {
// the argument to Str2Reg *must* be a string constant
ENSURE(m_strutil.is_string(str));
@@ -532,6 +549,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_REPLACE:
SASSERT(num_args == 3);
return mk_str_Replace(args[0], args[1], args[2], result);
+ case OP_STR_SUBSTR:
+ SASSERT(num_args == 3);
+ return mk_str_Substr(args[0], args[1], args[2], result);
case OP_RE_STR2REGEX:
SASSERT(num_args == 1);
return mk_re_Str2Reg(args[0], result);
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index 2235425be..862fc3e7e 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -50,6 +50,7 @@ public:
br_status mk_str_Indexof2(expr * arg0, expr * arg1, expr * arg2, expr_ref & result);
br_status mk_str_LastIndexof(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_Replace(expr * base, expr * source, expr * target, expr_ref & result);
+ br_status mk_str_Substr(expr * base, expr * start, expr * len, expr_ref & result);
br_status mk_re_Str2Reg(expr * str, expr_ref & result);
br_status mk_re_RegexIn(expr * str, expr * re, expr_ref & result);
From 71ad4d3a4abc08f4e2638fa7e0b23b14ab8575d4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 17 Aug 2016 16:21:19 -0400
Subject: [PATCH 185/401] add regex_in_bool_map to theory_str
---
src/smt/theory_str.cpp | 74 ++++++++++++++++++++++++++++++++++--------
src/smt/theory_str.h | 4 +++
2 files changed, 65 insertions(+), 13 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 40745b069..087bf6ad0 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1438,30 +1438,78 @@ expr * theory_str::mk_RegexIn(expr * str, expr * regexp) {
return regexIn;
}
+static std::string str2RegexStr(std::string str) {
+ std::string res = "";
+ int len = str.size();
+ for (int i = 0; i < len; i++) {
+ char nc = str[i];
+ // 12 special chars
+ if (nc == '\\' || nc == '^' || nc == '$' || nc == '.' || nc == '|' || nc == '?'
+ || nc == '*' || nc == '+' || nc == '(' || nc == ')' || nc == '[' || nc == '{') {
+ res.append(1, '\\');
+ }
+ res.append(1, str[i]);
+ }
+ return res;
+}
+
+std::string theory_str::get_std_regex_str(expr * regex) {
+ app * a_regex = to_app(regex);
+ if (is_Str2Reg(a_regex)) {
+ expr * regAst = a_regex->get_arg(0);
+ std::string regStr = str2RegexStr(m_strutil.get_string_constant_value(regAst));
+ return regStr;
+ } else if (is_RegexConcat(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ expr * reg2Ast = a_regex->get_arg(1);
+ std::string reg1Str = get_std_regex_str(reg1Ast);
+ std::string reg2Str = get_std_regex_str(reg2Ast);
+ return "(" + reg1Str + ")(" + reg2Str + ")";
+ } else if (is_RegexUnion(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ expr * reg2Ast = a_regex->get_arg(1);
+ std::string reg1Str = get_std_regex_str(reg1Ast);
+ std::string reg2Str = get_std_regex_str(reg2Ast);
+ return "(" + reg1Str + ")|(" + reg2Str + ")";
+ } else if (is_RegexStar(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ std::string reg1Str = get_std_regex_str(reg1Ast);
+ return "(" + reg1Str + ")*";
+ } else {
+ TRACE("t_str", tout << "BUG: unrecognized regex term " << mk_pp(regex, get_manager()) << std::endl;);
+ UNREACHABLE(); return "";
+ }
+}
+
void theory_str::instantiate_axiom_RegexIn(enode * e) {
context & ctx = get_context();
ast_manager & m = get_manager();
- app * expr = e->get_owner();
- if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up RegexIn axiom for " << mk_pp(expr, m) << std::endl;);
+ app * ex = e->get_owner();
+ if (axiomatized_terms.contains(ex)) {
+ TRACE("t_str_detail", tout << "already set up RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
return;
}
- axiomatized_terms.insert(expr);
+ axiomatized_terms.insert(ex);
- TRACE("t_str_detail", tout << "instantiate RegexIn axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("t_str_detail", tout << "instantiate RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
- // I don't think we need to port regexInBoolMap and regexInVarStrMap,
- // but they would go here from reduce_regexIn
+ {
+ std::string regexStr = get_std_regex_str(ex->get_arg(1));
+ std::pair<expr*, std::string> key1(ex->get_arg(0), regexStr);
+ // skip Z3str's map check, because we already check if we set up axioms on this term
+ regex_in_bool_map[key1] = ex;
+ regex_in_var_reg_str_map[ex->get_arg(0)].insert(regexStr);
+ }
- expr_ref str(expr->get_arg(0), m);
- app * regex = to_app(expr->get_arg(1));
+ expr_ref str(ex->get_arg(0), m);
+ app * regex = to_app(ex->get_arg(1));
if (is_Str2Reg(regex)) {
expr_ref rxStr(regex->get_arg(0), m);
// want to assert 'expr IFF (str == rxStr)'
expr_ref rhs(ctx.mk_eq_atom(str, rxStr), m);
- expr_ref finalAxiom(m.mk_iff(expr, rhs), m);
+ expr_ref finalAxiom(m.mk_iff(ex, rhs), m);
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
} else if (is_RegexConcat(regex)) {
@@ -1476,7 +1524,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
expr_ref_vector items(m);
items.push_back(var1InRegex1);
items.push_back(var2InRegex2);
- items.push_back(ctx.mk_eq_atom(expr, ctx.mk_eq_atom(str, rhs)));
+ items.push_back(ctx.mk_eq_atom(ex, ctx.mk_eq_atom(str, rhs)));
expr_ref finalAxiom(mk_and(items), m);
SASSERT(finalAxiom);
@@ -1492,7 +1540,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
expr_ref_vector items(m);
items.push_back(var1InRegex1);
items.push_back(var2InRegex2);
- items.push_back(ctx.mk_eq_atom(expr, orVar));
+ items.push_back(ctx.mk_eq_atom(ex, orVar));
assert_axiom(mk_and(items));
} else if (is_RegexStar(regex)) {
// slightly more complex due to the unrolling step.
@@ -1500,7 +1548,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
expr_ref unrollCount(mk_unroll_bound_var(), m);
expr_ref unrollFunc(mk_unroll(regex1, unrollCount), m);
expr_ref_vector items(m);
- items.push_back(ctx.mk_eq_atom(expr, ctx.mk_eq_atom(str, unrollFunc)));
+ items.push_back(ctx.mk_eq_atom(ex, ctx.mk_eq_atom(str, unrollFunc)));
items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(unrollCount, mk_int(0)), ctx.mk_eq_atom(unrollFunc, m_strutil.mk_string(""))));
expr_ref finalAxiom(mk_and(items), m);
SASSERT(finalAxiom);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index fd93edfd4..06a72c3e2 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -218,6 +218,9 @@ namespace smt {
// TODO Find a better data structure, this is 100% a hack right now
std::map<expr*, std::set<std::pair<expr*, expr*> > > contain_pair_idx_map;
+ std::map<std::pair<expr*, std::string>, expr*> regex_in_bool_map;
+ std::map<expr*, std::set<std::string> > regex_in_var_reg_str_map;
+
char * char_set;
std::map<char, int> charSetLookupTable;
int charSetSize;
@@ -419,6 +422,7 @@ namespace smt {
expr * gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, std::string lcmStr);
expr * gen_unroll_assign(expr * var, std::string lcmStr, expr * testerVar, int l, int h);
void reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vector & items);
+ std::string get_std_regex_str(expr * regex);
void dump_assignments();
void initialize_charset();
From 6263391c11278ca6653d61f9cc059b9b9232b4e5 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 17 Aug 2016 20:58:57 -0400
Subject: [PATCH 186/401] fix out-of-range integer comparison bug in string NFA
---
src/ast/rewriter/str_rewriter.cpp | 290 +++++++++++++-----------------
src/ast/rewriter/str_rewriter.h | 47 +++++
src/smt/theory_str.cpp | 59 +++++-
src/smt/theory_str.h | 12 ++
4 files changed, 243 insertions(+), 165 deletions(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index fe434575e..c644ecd46 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -26,188 +26,150 @@ Notes:
#include<set>
#include<deque>
-class nfa {
-protected:
- str_util & m_strutil;
+// Convert a regular expression to an e-NFA using Thompson's construction
+void nfa::convert_re(expr * e, unsigned & start, unsigned & end, str_util & m_strutil) {
+ start = next_id();
+ end = next_id();
+ if (m_strutil.is_re_Str2Reg(e)) {
+ app * a = to_app(e);
+ expr * arg_str = a->get_arg(0);
+ if (m_strutil.is_string(arg_str)) {
+ std::string str = m_strutil.get_string_constant_value(arg_str);
+ TRACE("t_str_rw", tout << "build NFA for '" << str << "'" << std::endl;);
- bool m_valid;
- unsigned m_next_id;
-
- unsigned next_id() {
- unsigned retval = m_next_id;
- ++m_next_id;
- return retval;
- }
-
- unsigned m_start_state;
- unsigned m_end_state;
-
- std::map<unsigned, std::map<char, unsigned> > transition_map;
- std::map<unsigned, std::set<unsigned> > epsilon_map;
-
- void make_transition(unsigned start, char symbol, unsigned end) {
- transition_map[start][symbol] = end;
- }
-
- void make_epsilon_move(unsigned start, unsigned end) {
- epsilon_map[start].insert(end);
- }
-
- // Convert a regular expression to an e-NFA using Thompson's construction
- void convert_re(expr * e, unsigned & start, unsigned & end) {
- start = next_id();
- end = next_id();
- if (m_strutil.is_re_Str2Reg(e)) {
- app * a = to_app(e);
- expr * arg_str = a->get_arg(0);
- if (m_strutil.is_string(arg_str)) {
- std::string str = m_strutil.get_string_constant_value(arg_str);
- TRACE("t_str_rw", tout << "build NFA for '" << str << "'" << std::endl;);
-
- // TODO this assumes the string is not empty
- /*
- * For an n-character string, we make (n-1) intermediate states,
- * labelled i_(0) through i_(n-2).
- * Then we construct the following transitions:
- * start --str[0]--> i_(0) --str[1]--> i_(1) --...--> i_(n-2) --str[n-1]--> final
- */
- unsigned last = start;
- for (unsigned i = 0; i <= str.length() - 2; ++i) {
- unsigned i_state = next_id();
- make_transition(last, str.at(i), i_state);
- TRACE("t_str_rw", tout << "string transition " << last << "--" << str.at(i) << "--> " << i_state << std::endl;);
- last = i_state;
- }
- make_transition(last, str.at(str.length() - 1), end);
- TRACE("t_str_rw", tout << "string transition " << last << "--" << str.at(str.length() - 1) << "--> " << end << std::endl;);
- TRACE("t_str_rw", tout << "string NFA: start = " << start << ", end = " << end << std::endl;);
- } else {
- TRACE("t_str_rw", tout << "invalid string constant in Str2Reg" << std::endl;);
- m_valid = false;
- return;
+ // TODO this assumes the string is not empty
+ /*
+ * For an n-character string, we make (n-1) intermediate states,
+ * labelled i_(0) through i_(n-2).
+ * Then we construct the following transitions:
+ * start --str[0]--> i_(0) --str[1]--> i_(1) --...--> i_(n-2) --str[n-1]--> final
+ */
+ unsigned last = start;
+ for (int i = 0; i <= ((int)str.length()) - 2; ++i) {
+ unsigned i_state = next_id();
+ make_transition(last, str.at(i), i_state);
+ TRACE("t_str_rw", tout << "string transition " << last << "--" << str.at(i) << "--> " << i_state << std::endl;);
+ last = i_state;
}
- } else if (m_strutil.is_re_RegexConcat(e)){
- app * a = to_app(e);
- expr * re1 = a->get_arg(0);
- expr * re2 = a->get_arg(1);
- unsigned start1, end1;
- convert_re(re1, start1, end1);
- unsigned start2, end2;
- convert_re(re2, start2, end2);
- // start --e--> start1 --...--> end1 --e--> start2 --...--> end2 --e--> end
- make_epsilon_move(start, start1);
- make_epsilon_move(end1, start2);
- make_epsilon_move(end2, end);
- TRACE("t_str_rw", tout << "concat NFA: start = " << start << ", end = " << end << std::endl;);
- } else if (m_strutil.is_re_RegexUnion(e)) {
- app * a = to_app(e);
- expr * re1 = a->get_arg(0);
- expr * re2 = a->get_arg(1);
- unsigned start1, end1;
- convert_re(re1, start1, end1);
- unsigned start2, end2;
- convert_re(re2, start2, end2);
-
- // start --e--> start1 ; start --e--> start2
- // end1 --e--> end ; end2 --e--> end
- make_epsilon_move(start, start1);
- make_epsilon_move(start, start2);
- make_epsilon_move(end1, end);
- make_epsilon_move(end2, end);
- TRACE("t_str_rw", tout << "union NFA: start = " << start << ", end = " << end << std::endl;);
- } else if (m_strutil.is_re_RegexStar(e)) {
- app * a = to_app(e);
- expr * subex = a->get_arg(0);
- unsigned start_subex, end_subex;
- convert_re(subex, start_subex, end_subex);
- // start --e--> start_subex, start --e--> end
- // end_subex --e--> start_subex, end_subex --e--> end
- make_epsilon_move(start, start_subex);
- make_epsilon_move(start, end);
- make_epsilon_move(end_subex, start_subex);
- make_epsilon_move(end_subex, end);
- TRACE("t_str_rw", tout << "star NFA: start = " << start << ", end = " << end << std::endl;);
+ make_transition(last, str.at(str.length() - 1), end);
+ TRACE("t_str_rw", tout << "string transition " << last << "--" << str.at(str.length() - 1) << "--> " << end << std::endl;);
+ TRACE("t_str_rw", tout << "string NFA: start = " << start << ", end = " << end << std::endl;);
} else {
- TRACE("t_str_rw", tout << "invalid regular expression" << std::endl;);
+ TRACE("t_str_rw", tout << "invalid string constant in Str2Reg" << std::endl;);
m_valid = false;
return;
}
+ } else if (m_strutil.is_re_RegexConcat(e)){
+ app * a = to_app(e);
+ expr * re1 = a->get_arg(0);
+ expr * re2 = a->get_arg(1);
+ unsigned start1, end1;
+ convert_re(re1, start1, end1, m_strutil);
+ unsigned start2, end2;
+ convert_re(re2, start2, end2, m_strutil);
+ // start --e--> start1 --...--> end1 --e--> start2 --...--> end2 --e--> end
+ make_epsilon_move(start, start1);
+ make_epsilon_move(end1, start2);
+ make_epsilon_move(end2, end);
+ TRACE("t_str_rw", tout << "concat NFA: start = " << start << ", end = " << end << std::endl;);
+ } else if (m_strutil.is_re_RegexUnion(e)) {
+ app * a = to_app(e);
+ expr * re1 = a->get_arg(0);
+ expr * re2 = a->get_arg(1);
+ unsigned start1, end1;
+ convert_re(re1, start1, end1, m_strutil);
+ unsigned start2, end2;
+ convert_re(re2, start2, end2, m_strutil);
+
+ // start --e--> start1 ; start --e--> start2
+ // end1 --e--> end ; end2 --e--> end
+ make_epsilon_move(start, start1);
+ make_epsilon_move(start, start2);
+ make_epsilon_move(end1, end);
+ make_epsilon_move(end2, end);
+ TRACE("t_str_rw", tout << "union NFA: start = " << start << ", end = " << end << std::endl;);
+ } else if (m_strutil.is_re_RegexStar(e)) {
+ app * a = to_app(e);
+ expr * subex = a->get_arg(0);
+ unsigned start_subex, end_subex;
+ convert_re(subex, start_subex, end_subex, m_strutil);
+ // start --e--> start_subex, start --e--> end
+ // end_subex --e--> start_subex, end_subex --e--> end
+ make_epsilon_move(start, start_subex);
+ make_epsilon_move(start, end);
+ make_epsilon_move(end_subex, start_subex);
+ make_epsilon_move(end_subex, end);
+ TRACE("t_str_rw", tout << "star NFA: start = " << start << ", end = " << end << std::endl;);
+ } else {
+ TRACE("t_str_rw", tout << "invalid regular expression" << std::endl;);
+ m_valid = false;
+ return;
}
+}
-public:
- nfa(str_util & m_strutil, expr * e)
-: m_strutil(m_strutil),
- m_valid(true), m_next_id(0), m_start_state(0), m_end_state(0) {
- convert_re(e, m_start_state, m_end_state);
- }
+void nfa::epsilon_closure(unsigned start, std::set<unsigned> & closure) {
+ std::deque<unsigned> worklist;
+ closure.insert(start);
+ worklist.push_back(start);
- bool is_valid() const {
- return m_valid;
- }
-
- void epsilon_closure(unsigned start, std::set<unsigned> & closure) {
- std::deque<unsigned> worklist;
- closure.insert(start);
- worklist.push_back(start);
-
- while(!worklist.empty()) {
- unsigned state = worklist.front();
- worklist.pop_front();
- if (epsilon_map.find(state) != epsilon_map.end()) {
- for (std::set<unsigned>::iterator it = epsilon_map[state].begin();
- it != epsilon_map[state].end(); ++it) {
- unsigned new_state = *it;
- if (closure.find(new_state) == closure.end()) {
- closure.insert(new_state);
- worklist.push_back(new_state);
- }
+ while(!worklist.empty()) {
+ unsigned state = worklist.front();
+ worklist.pop_front();
+ if (epsilon_map.find(state) != epsilon_map.end()) {
+ for (std::set<unsigned>::iterator it = epsilon_map[state].begin();
+ it != epsilon_map[state].end(); ++it) {
+ unsigned new_state = *it;
+ if (closure.find(new_state) == closure.end()) {
+ closure.insert(new_state);
+ worklist.push_back(new_state);
}
}
}
}
+}
- bool matches(std::string input) {
- /*
- * Keep a set of all states the NFA can currently be in.
- * Initially this is the e-closure of m_start_state
- * For each character A in the input string,
- * the set of next states contains
- * all states in transition_map[S][A] for each S in current_states,
- * and all states in epsilon_map[S] for each S in current_states.
- * After consuming the entire input string,
- * the match is successful iff current_states contains m_end_state.
- */
- std::set<unsigned> current_states;
- epsilon_closure(m_start_state, current_states);
- for (unsigned i = 0; i < input.length(); ++i) {
- char A = input.at(i);
- std::set<unsigned> next_states;
- for (std::set<unsigned>::iterator it = current_states.begin();
- it != current_states.end(); ++it) {
- unsigned S = *it;
- // check transition_map
- if (transition_map[S].find(A) != transition_map[S].end()) {
- next_states.insert(transition_map[S][A]);
- }
+bool nfa::matches(std::string input) {
+ /*
+ * Keep a set of all states the NFA can currently be in.
+ * Initially this is the e-closure of m_start_state
+ * For each character A in the input string,
+ * the set of next states contains
+ * all states in transition_map[S][A] for each S in current_states,
+ * and all states in epsilon_map[S] for each S in current_states.
+ * After consuming the entire input string,
+ * the match is successful iff current_states contains m_end_state.
+ */
+ std::set<unsigned> current_states;
+ epsilon_closure(m_start_state, current_states);
+ for (unsigned i = 0; i < input.length(); ++i) {
+ char A = input.at(i);
+ std::set<unsigned> next_states;
+ for (std::set<unsigned>::iterator it = current_states.begin();
+ it != current_states.end(); ++it) {
+ unsigned S = *it;
+ // check transition_map
+ if (transition_map[S].find(A) != transition_map[S].end()) {
+ next_states.insert(transition_map[S][A]);
}
+ }
- // take e-closure over next_states to compute the actual next_states
- std::set<unsigned> epsilon_next_states;
- for (std::set<unsigned>::iterator it = next_states.begin(); it != next_states.end(); ++it) {
- unsigned S = *it;
- std::set<unsigned> closure;
- epsilon_closure(S, closure);
- epsilon_next_states.insert(closure.begin(), closure.end());
- }
- current_states = epsilon_next_states;
- }
- if (current_states.find(m_end_state) != current_states.end()) {
- return true;
- } else {
- return false;
+ // take e-closure over next_states to compute the actual next_states
+ std::set<unsigned> epsilon_next_states;
+ for (std::set<unsigned>::iterator it = next_states.begin(); it != next_states.end(); ++it) {
+ unsigned S = *it;
+ std::set<unsigned> closure;
+ epsilon_closure(S, closure);
+ epsilon_next_states.insert(closure.begin(), closure.end());
}
+ current_states = epsilon_next_states;
}
-};
+ if (current_states.find(m_end_state) != current_states.end()) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
br_status str_rewriter::mk_str_Concat(expr * arg0, expr * arg1, expr_ref & result) {
TRACE("t_str_rw", tout << "rewrite (Concat " << mk_pp(arg0, m()) << " " << mk_pp(arg1, m()) << ")" << std::endl;);
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index 862fc3e7e..c64d086f9 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -21,6 +21,8 @@ Notes:
#include"arith_decl_plugin.h"
#include"rewriter_types.h"
#include"params.h"
+#include<set>
+#include<map>
class str_rewriter {
str_util m_strutil;
@@ -61,3 +63,48 @@ public:
bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
};
+
+class nfa {
+protected:
+ bool m_valid;
+ unsigned m_next_id;
+
+ unsigned next_id() {
+ unsigned retval = m_next_id;
+ ++m_next_id;
+ return retval;
+ }
+
+ unsigned m_start_state;
+ unsigned m_end_state;
+
+ std::map<unsigned, std::map<char, unsigned> > transition_map;
+ std::map<unsigned, std::set<unsigned> > epsilon_map;
+
+ void make_transition(unsigned start, char symbol, unsigned end) {
+ transition_map[start][symbol] = end;
+ }
+
+ void make_epsilon_move(unsigned start, unsigned end) {
+ epsilon_map[start].insert(end);
+ }
+
+ // Convert a regular expression to an e-NFA using Thompson's construction
+ void convert_re(expr * e, unsigned & start, unsigned & end, str_util & m_strutil);
+
+public:
+ nfa(str_util & m_strutil, expr * e)
+: m_valid(true), m_next_id(0), m_start_state(0), m_end_state(0) {
+ convert_re(e, m_start_state, m_end_state, m_strutil);
+ }
+
+ nfa() : m_valid(false), m_next_id(0), m_start_state(0), m_end_state(0) {}
+
+ bool is_valid() const {
+ return m_valid;
+ }
+
+ void epsilon_closure(unsigned start, std::set<unsigned> & closure);
+
+ bool matches(std::string input);
+};
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 087bf6ad0..d249649c7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -35,6 +35,7 @@ theory_str::theory_str(ast_manager & m):
opt_LCMUnrollStep(2),
opt_NoQuickReturn_IntegerTheory(false),
opt_DisableIntegerTheoryIntegration(false),
+ opt_NoCheckRegexIn(false),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -1643,7 +1644,14 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
check_contain_in_new_eq(lhs, rhs);
}
- // TODO regexInBoolMap
+ if (!regex_in_bool_map.empty()) {
+ if (opt_NoCheckRegexIn) {
+ TRACE("t_str", tout << "WARNING: skipping check_regex_in()" << std::endl;);
+ } else {
+ TRACE("t_str", tout << "checking regex consistency" << std::endl;);
+ check_regex_in(lhs, rhs);
+ }
+ }
// okay, all checks here passed
return true;
@@ -5213,6 +5221,55 @@ void theory_str::check_concat_len_in_eqc(expr * concat) {
} while (eqc_it != eqc_base);
}
+void theory_str::check_regex_in(expr * nn1, expr * nn2) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr_ref_vector eqNodeSet(m);
+ expr * constStr = collect_eq_nodes(nn1, eqNodeSet);
+
+ if (constStr == NULL) {
+ return;
+ } else {
+ expr_ref_vector::iterator itor = eqNodeSet.begin();
+ for (; itor != eqNodeSet.end(); itor++) {
+ if (regex_in_var_reg_str_map.find(*itor) != regex_in_var_reg_str_map.end()) {
+ std::set<std::string>::iterator strItor = regex_in_var_reg_str_map[*itor].begin();
+ for (; strItor != regex_in_var_reg_str_map[*itor].end(); strItor++) {
+ std::string regStr = *strItor;
+ std::string constStrValue = m_strutil.get_string_constant_value(constStr);
+ std::pair<expr*, std::string> key1 = std::make_pair(*itor, regStr);
+ if (regex_in_bool_map.find(key1) != regex_in_bool_map.end()) {
+ expr * boolVar = regex_in_bool_map[key1]; // actually the RegexIn term
+ app * a_regexIn = to_app(boolVar);
+ expr * regexTerm = a_regexIn->get_arg(1);
+
+ if (regex_nfa_cache.find(regexTerm) == regex_nfa_cache.end()) {
+ TRACE("t_str_detail", tout << "regex_nfa_cache: cache miss" << std::endl;);
+ regex_nfa_cache[regexTerm] = nfa(m_strutil, regexTerm);
+ } else {
+ TRACE("t_str_detail", tout << "regex_nfa_cache: cache hit" << std::endl;);
+ }
+
+ nfa regexNFA = regex_nfa_cache[regexTerm];
+ ENSURE(regexNFA.is_valid());
+ bool matchRes = regexNFA.matches(constStrValue);
+
+ TRACE("t_str_detail", tout << mk_pp(*itor, m) << " in " << regStr << " : " << (matchRes ? "yes" : "no") << std::endl;);
+
+ expr_ref implyL(ctx.mk_eq_atom(*itor, constStr), m);
+ if (matchRes) {
+ assert_implication(implyL, boolVar);
+ } else {
+ assert_implication(implyL, m.mk_not(boolVar));
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
/*
* strArgmt::solve_concat_eq_str()
* Solve concatenations of the form:
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 06a72c3e2..8acdb4f02 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -25,6 +25,7 @@ Revision History:
#include"arith_decl_plugin.h"
#include<set>
#include<stack>
+#include"str_rewriter.h"
namespace smt {
@@ -137,6 +138,14 @@ namespace smt {
*/
bool opt_DisableIntegerTheoryIntegration;
+ /*
+ * If NoCheckRegexIn is set to true,
+ * an expensive regular expression membership test is skipped.
+ * This option is for experiment purposes only and should be set to 'false'
+ * as skipping this check impacts the correctness of the solver.
+ */
+ bool opt_NoCheckRegexIn;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -221,6 +230,8 @@ namespace smt {
std::map<std::pair<expr*, std::string>, expr*> regex_in_bool_map;
std::map<expr*, std::set<std::string> > regex_in_var_reg_str_map;
+ std::map<expr*, nfa> regex_nfa_cache; // Regex term --> NFA
+
char * char_set;
std::map<char, int> charSetLookupTable;
int charSetSize;
@@ -423,6 +434,7 @@ namespace smt {
expr * gen_unroll_assign(expr * var, std::string lcmStr, expr * testerVar, int l, int h);
void reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vector & items);
std::string get_std_regex_str(expr * regex);
+ void check_regex_in(expr * nn1, expr * nn2);
void dump_assignments();
void initialize_charset();
From 54d7e4bbb59f7b255bc70c11dce9acdef6daf30b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 17 Aug 2016 21:12:19 -0400
Subject: [PATCH 187/401] remove the option to bypass check_regex_in in
theory_str
---
src/smt/theory_str.cpp | 9 ++-------
src/smt/theory_str.h | 8 --------
2 files changed, 2 insertions(+), 15 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index d249649c7..ae002f979 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -35,7 +35,6 @@ theory_str::theory_str(ast_manager & m):
opt_LCMUnrollStep(2),
opt_NoQuickReturn_IntegerTheory(false),
opt_DisableIntegerTheoryIntegration(false),
- opt_NoCheckRegexIn(false),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -1645,12 +1644,8 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
}
if (!regex_in_bool_map.empty()) {
- if (opt_NoCheckRegexIn) {
- TRACE("t_str", tout << "WARNING: skipping check_regex_in()" << std::endl;);
- } else {
- TRACE("t_str", tout << "checking regex consistency" << std::endl;);
- check_regex_in(lhs, rhs);
- }
+ TRACE("t_str", tout << "checking regex consistency" << std::endl;);
+ check_regex_in(lhs, rhs);
}
// okay, all checks here passed
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 8acdb4f02..527753b73 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -138,14 +138,6 @@ namespace smt {
*/
bool opt_DisableIntegerTheoryIntegration;
- /*
- * If NoCheckRegexIn is set to true,
- * an expensive regular expression membership test is skipped.
- * This option is for experiment purposes only and should be set to 'false'
- * as skipping this check impacts the correctness of the solver.
- */
- bool opt_NoCheckRegexIn;
-
bool search_started;
arith_util m_autil;
str_util m_strutil;
From 3c8b833eebd7ac8c946958720d3f95c14840355a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 18 Aug 2016 17:03:32 -0400
Subject: [PATCH 188/401] fix expression dereference error in
theory_str::gen_assign_unroll_Str2Reg
---
src/smt/theory_str.cpp | 7 ++++---
1 file changed, 4 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ae002f979..05cbe8803 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -7772,10 +7772,11 @@ expr * theory_str::gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls
if (canHaveNonEmptyAssign) {
return gen_unroll_conditional_options(n, unrolls, lcmStr);
} else {
- expr * implyL = mk_and(litems);
- expr * implyR = ctx.mk_eq_atom(n, m_strutil.mk_string(""));
+ expr_ref implyL(mk_and(litems), mgr);
+ expr_ref implyR(ctx.mk_eq_atom(n, m_strutil.mk_string("")), mgr);
// want to return (implyL -> implyR)
- return mgr.mk_or(mgr.mk_not(implyL), implyR);
+ expr * final_axiom = rewrite_implication(implyL, implyR);
+ return final_axiom;
}
}
From 8598a48e3b459c0b4e2ce491b40f8438211a0e07 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 18 Aug 2016 19:14:50 -0400
Subject: [PATCH 189/401] fix weird Contains rewriter behaviour in theory_str
---
src/smt/theory_str.cpp | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 05cbe8803..360bfa26a 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1130,6 +1130,22 @@ void theory_str::instantiate_axiom_Contains(enode * e) {
return;
}
axiomatized_terms.insert(ex);
+
+ // quick path, because this is necessary due to rewriter behaviour
+ // (at minimum it should fix z3str/concat-006.smt2
+ // TODO: see if it's necessary for other such terms
+ if (m_strutil.is_string(ex->get_arg(0)) && m_strutil.is_string(ex->get_arg(1))) {
+ TRACE("t_str_detail", tout << "eval constant Contains term " << mk_pp(ex, m) << std::endl;);
+ std::string haystackStr = m_strutil.get_string_constant_value(ex->get_arg(0));
+ std::string needleStr = m_strutil.get_string_constant_value(ex->get_arg(1));
+ if (haystackStr.find(needleStr) != std::string::npos) {
+ assert_axiom(ex);
+ } else {
+ assert_axiom(m.mk_not(ex));
+ }
+ return;
+ }
+
{ // register Contains()
expr * str = ex->get_arg(0);
expr * substr = ex->get_arg(1);
From 481e97a274c994d66f9c34bd615c8b4af214439d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 19 Aug 2016 22:53:36 -0400
Subject: [PATCH 190/401] propagate early in theory_str to set up
contains/regex maps this fixes an unsat-as-sat error in a regex test and
flips around some timeouts so more work will be required to track this down
---
src/smt/theory_str.cpp | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 360bfa26a..c781cae04 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6052,6 +6052,10 @@ void theory_str::init_search_eh() {
}
*/
+ // this might be cheating but we need to make sure that certain maps are populated
+ // before the first call to new_eq_eh()
+ propagate();
+
TRACE("t_str", tout << "search started" << std::endl;);
search_started = true;
}
From 1a75781a3ceb28f7dad6be75140c5b9685c935a7 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 20 Aug 2016 23:09:08 -0400
Subject: [PATCH 191/401] add experimental option to defer new_eq_check to
final_check in theory_str
---
src/smt/theory_str.cpp | 87 +++++++++++++++++++++++++++++++++++++-----
src/smt/theory_str.h | 9 ++++-
2 files changed, 86 insertions(+), 10 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index c781cae04..f53eefb6d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -35,6 +35,7 @@ theory_str::theory_str(ast_manager & m):
opt_LCMUnrollStep(2),
opt_NoQuickReturn_IntegerTheory(false),
opt_DisableIntegerTheoryIntegration(false),
+ opt_DeferEQCConsistencyCheck(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -1613,8 +1614,11 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
UNREACHABLE();
}
- check_concat_len_in_eqc(lhs);
- check_concat_len_in_eqc(rhs);
+ // skip this check if we defer consistency checking, as we can do it for every EQC in final check
+ if (!opt_DeferEQCConsistencyCheck) {
+ check_concat_len_in_eqc(lhs);
+ check_concat_len_in_eqc(rhs);
+ }
// Now we iterate over all pairs of terms in the (shared) eqc
// and check whether we can show that any pair of distinct terms
@@ -5197,7 +5201,7 @@ bool theory_str::check_length_eq_var_concat(expr * n1, expr * n2) {
else {
return check_length_var_var(n1, n2);
}
- return 0;
+ return true;
}
// returns false if an inconsistency is detected, or true if no inconsistencies were found
@@ -5214,22 +5218,31 @@ bool theory_str::check_length_consistency(expr * n1, expr * n2) {
// n1 and n2 are vars or concats
return check_length_eq_var_concat(n1, n2);
}
- return 0;
+ return true;
}
-void theory_str::check_concat_len_in_eqc(expr * concat) {
+// Modified signature: returns true if nothing was learned, or false if at least one axiom was asserted.
+// (This is used for deferred consistency checking)
+bool theory_str::check_concat_len_in_eqc(expr * concat) {
context & ctx = get_context();
+ bool no_assertions = true;
+
enode * eqc_base = ctx.get_enode(concat);
enode * eqc_it = eqc_base;
do {
app * eqc_n = eqc_it->get_owner();
if (is_concat(eqc_n)) {
rational unused;
- infer_len_concat(eqc_n, unused);
+ bool status = infer_len_concat(eqc_n, unused);
+ if (status) {
+ no_assertions = false;
+ }
}
eqc_it = eqc_it->get_next();
} while (eqc_it != eqc_base);
+
+ return no_assertions;
}
void theory_str::check_regex_in(expr * nn1, expr * nn2) {
@@ -5730,9 +5743,13 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
}
}
- // newEqCheck() -- check consistency wrt. existing equivalence classes
- if (!new_eq_check(lhs, rhs)) {
- return;
+ if (opt_DeferEQCConsistencyCheck) {
+ TRACE("t_str_detail", tout << "opt_DeferEQCConsistencyCheck is set; deferring new_eq_check call" << std::endl;);
+ } else {
+ // newEqCheck() -- check consistency wrt. existing equivalence classes
+ if (!new_eq_check(lhs, rhs)) {
+ return;
+ }
}
// BEGIN new_eq_handler() in strTheory
@@ -7040,6 +7057,58 @@ final_check_status theory_str::final_check_eh() {
TRACE("t_str", tout << "final check" << std::endl;);
TRACE("t_str_dump_assign", dump_assignments(););
+ if (opt_DeferEQCConsistencyCheck) {
+ TRACE("t_str_detail", tout << "performing deferred EQC consistency check" << std::endl;);
+ std::set<enode*> eqc_roots;
+ for (ptr_vector<enode>::const_iterator it = ctx.begin_enodes(); it != ctx.end_enodes(); ++it) {
+ enode * e = *it;
+ enode * root = e->get_root();
+ eqc_roots.insert(root);
+ }
+
+ bool found_inconsistency = false;
+
+ for (std::set<enode*>::iterator it = eqc_roots.begin(); it != eqc_roots.end(); ++it) {
+ enode * e = *it;
+ app * a = e->get_owner();
+ if (!(is_sort_of(m.get_sort(a), m_strutil.get_fid(), STRING_SORT))) {
+ TRACE("t_str_detail", tout << "EQC root " << mk_pp(a, m) << " not a string term; skipping" << std::endl;);
+ } else {
+ TRACE("t_str_detail", tout << "EQC root " << mk_pp(a, m) << " is a string term. Checking this EQC" << std::endl;);
+ // first call check_concat_len_in_eqc() on each member of the eqc
+ enode * e_it = e;
+ enode * e_root = e_it;
+ do {
+ bool status = check_concat_len_in_eqc(e_it->get_owner());
+ if (!status) {
+ TRACE("t_str_detail", tout << "concat-len check asserted an axiom on " << mk_pp(e_it->get_owner(), m) << std::endl;);
+ found_inconsistency = true;
+ }
+ e_it = e_it->get_next();
+ } while (e_it != e_root);
+
+ // now grab any two distinct elements from the EQC and call new_eq_check() on them
+ enode * e1 = e;
+ enode * e2 = e1->get_next();
+ if (e1 != e2) {
+ TRACE("t_str_detail", tout << "deferred new_eq_check() over EQC of " << mk_pp(e1->get_owner(), m) << " and " << mk_pp(e2->get_owner(), m) << std::endl;);
+ bool result = new_eq_check(e1->get_owner(), e2->get_owner());
+ if (!result) {
+ TRACE("t_str_detail", tout << "new_eq_check found inconsistencies" << std::endl;);
+ found_inconsistency = true;
+ }
+ }
+ }
+ }
+
+ if (found_inconsistency) {
+ TRACE("t_str", tout << "Found inconsistency in final check! Returning to search." << std::endl;);
+ return FC_CONTINUE;
+ } else {
+ TRACE("t_str", tout << "Deferred consistency check passed. Continuing in final check." << std::endl;);
+ }
+ }
+
// run dependence analysis to find free string variables
std::map<expr*, int> varAppearInAssign;
std::map<expr*, int> freeVar_map;
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 527753b73..60a1d70e2 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -138,6 +138,13 @@ namespace smt {
*/
bool opt_DisableIntegerTheoryIntegration;
+ /*
+ * If DeferEQCConsistencyCheck is set to true,
+ * expensive calls to new_eq_check() will be deferred until final check,
+ * at which time the consistency of *all* string equivalence classes will be validated.
+ */
+ bool opt_DeferEQCConsistencyCheck;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -334,7 +341,7 @@ namespace smt {
bool can_two_nodes_eq(expr * n1, expr * n2);
bool can_concat_eq_str(expr * concat, std::string str);
bool can_concat_eq_concat(expr * concat1, expr * concat2);
- void check_concat_len_in_eqc(expr * concat);
+ bool check_concat_len_in_eqc(expr * concat);
bool check_length_consistency(expr * n1, expr * n2);
bool check_length_const_string(expr * n1, expr * constStr);
bool check_length_eq_var_concat(expr * n1, expr * n2);
From 7b3203b48e2f53775e08921acb8f6792f4579623 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 21 Aug 2016 00:30:29 -0400
Subject: [PATCH 192/401] disable aggressive length/value testing in
theory_str, it seems to be detrimental
---
src/smt/theory_str.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f53eefb6d..a0b06bcbf 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -28,8 +28,8 @@ namespace smt {
theory_str::theory_str(ast_manager & m):
theory(m.mk_family_id("str")),
/* Options */
- opt_AggressiveLengthTesting(true),
- opt_AggressiveValueTesting(true),
+ opt_AggressiveLengthTesting(false),
+ opt_AggressiveValueTesting(false),
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
From 2a199294a1bfd8511caa0ee0b421c2d2f65de1da Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 21 Aug 2016 00:43:00 -0400
Subject: [PATCH 193/401] remove incorrect null pointer check from
theory_str::gen_len_val_options_for_free_var everything that calls this
method knows that it can legally return null
---
src/smt/theory_str.cpp | 1 -
1 file changed, 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a0b06bcbf..28420de26 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -8234,7 +8234,6 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
// length is fixed
expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, "");
- SASSERT(valueAssert != NULL);
return valueAssert;
}
} // fVarLenCountMap.find(...)
From 89d5f4ffb4a8d6e4b159c6c919964cffcb12754b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 21 Aug 2016 21:37:46 -0400
Subject: [PATCH 194/401] add compute_contains check to theory_str
this may cause a crash in indexof-002.smt2 but
I cannot reproduce it
---
src/smt/theory_str.cpp | 341 +++++++++++++++++++++++++++++++++++++++--
src/smt/theory_str.h | 14 ++
2 files changed, 346 insertions(+), 9 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 28420de26..90b0992d6 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -21,6 +21,7 @@ Revision History:
#include"ast_pp.h"
#include"ast_ll_pp.h"
#include<list>
+#include<vector>
#include"theory_arith.h"
namespace smt {
@@ -3102,15 +3103,14 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
int option = 0;
int pos = 1;
- expr_ref temp1_strAst(mk_concat(temp1, strAst), mgr); // TODO assert concat axioms?
+ expr_ref temp1_strAst(mk_concat(temp1, strAst), mgr);
// m cuts y
if (can_two_nodes_eq(y, temp1_strAst)) {
if (!avoidLoopCut || !has_self_cut(m, y)) {
// break down option 2-1
- // TODO
or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
- expr_ref x_temp1(mk_concat(x, temp1), mgr); // TODO assert concat axioms?
+ expr_ref x_temp1(mk_concat(x, temp1), mgr);
and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(m, x_temp1));
and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, temp1_strAst));
@@ -3131,7 +3131,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
std::string part1Str = strValue.substr(0, i);
std::string part2Str = strValue.substr(i, strValue.size() - i);
expr_ref prefixStr(m_strutil.mk_string(part1Str), mgr);
- expr_ref x_concat(mk_concat(m, prefixStr), mgr); // TODO concat axioms?
+ expr_ref x_concat(mk_concat(m, prefixStr), mgr);
expr_ref cropStr(m_strutil.mk_string(part2Str), mgr);
if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
// break down option 2-2
@@ -4866,6 +4866,332 @@ void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
}
}
+expr * theory_str::dealias_node(expr * node, std::map<expr*, expr*> & varAliasMap, std::map<expr*, expr*> & concatAliasMap) {
+ if (variable_set.find(node) != variable_set.end()) {
+ return get_alias_index_ast(varAliasMap, node);
+ } else if (is_concat(to_app(node))) {
+ return get_alias_index_ast(concatAliasMap, node);
+ }
+ return node;
+}
+
+void theory_str::get_grounded_concats(expr* node, std::map<expr*, expr*> & varAliasMap,
+ std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr*> & varConstMap,
+ std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap,
+ std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap) {
+ if (is_Unroll(to_app(node))) {
+ return;
+ }
+ // **************************************************
+ // first deAlias the node if it is a var or concat
+ // **************************************************
+ node = dealias_node(node, varAliasMap, concatAliasMap);
+
+ if (groundedMap.find(node) != groundedMap.end()) {
+ return;
+ }
+
+ // haven't computed grounded concats for "node" (de-aliased)
+ // ---------------------------------------------------------
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ // const strings: node is de-aliased
+ if (m_strutil.is_string(node)) {
+ std::vector<expr*> concatNodes;
+ concatNodes.push_back(node);
+ groundedMap[node][concatNodes].clear(); // no condition
+ }
+ // Concat functions
+ else if (is_concat(to_app(node))) {
+ // if "node" equals to a constant string, thenjust push the constant into the concat vector
+ // Again "node" has been de-aliased at the very beginning
+ if (concatConstMap.find(node) != concatConstMap.end()) {
+ std::vector<expr*> concatNodes;
+ concatNodes.push_back(concatConstMap[node]);
+ groundedMap[node][concatNodes].clear();
+ groundedMap[node][concatNodes].insert(ctx.mk_eq_atom(node, concatConstMap[node]));
+ }
+ // node doesn't have eq constant value. Process its children.
+ else {
+ // merge arg0 and arg1
+ expr * arg0 = to_app(node)->get_arg(0);
+ expr * arg1 = to_app(node)->get_arg(1);
+ expr * arg0DeAlias = dealias_node(arg0, varAliasMap, concatAliasMap);
+ expr * arg1DeAlias = dealias_node(arg1, varAliasMap, concatAliasMap);
+ get_grounded_concats(arg0DeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
+ get_grounded_concats(arg1DeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
+
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator arg0_grdItor = groundedMap[arg0DeAlias].begin();
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator arg1_grdItor;
+ for (; arg0_grdItor != groundedMap[arg0DeAlias].end(); arg0_grdItor++) {
+ arg1_grdItor = groundedMap[arg1DeAlias].begin();
+ for (; arg1_grdItor != groundedMap[arg1DeAlias].end(); arg1_grdItor++) {
+ std::vector<expr*> ndVec;
+ ndVec.insert(ndVec.end(), arg0_grdItor->first.begin(), arg0_grdItor->first.end());
+ int arg0VecSize = arg0_grdItor->first.size();
+ int arg1VecSize = arg1_grdItor->first.size();
+ if (arg0VecSize > 0 && arg1VecSize > 0 && m_strutil.is_string(arg0_grdItor->first[arg0VecSize - 1]) && m_strutil.is_string(arg1_grdItor->first[0])) {
+ ndVec.pop_back();
+ ndVec.push_back(mk_concat(arg0_grdItor->first[arg0VecSize - 1], arg1_grdItor->first[0]));
+ for (int i = 1; i < arg1VecSize; i++) {
+ ndVec.push_back(arg1_grdItor->first[i]);
+ }
+ } else {
+ ndVec.insert(ndVec.end(), arg1_grdItor->first.begin(), arg1_grdItor->first.end());
+ }
+ // only insert if we don't know "node = concat(ndVec)" since one set of condition leads to this is enough
+ if (groundedMap[node].find(ndVec) == groundedMap[node].end()) {
+ groundedMap[node][ndVec];
+ if (arg0 != arg0DeAlias) {
+ groundedMap[node][ndVec].insert(ctx.mk_eq_atom(arg0, arg0DeAlias));
+ }
+ groundedMap[node][ndVec].insert(arg0_grdItor->second.begin(), arg0_grdItor->second.end());
+
+ if (arg1 != arg1DeAlias) {
+ groundedMap[node][ndVec].insert(ctx.mk_eq_atom(arg1, arg1DeAlias));
+ }
+ groundedMap[node][ndVec].insert(arg1_grdItor->second.begin(), arg1_grdItor->second.end());
+ }
+ }
+ }
+ }
+ }
+ // string variables
+ else if (variable_set.find(node) != variable_set.end()) {
+ // deAliasedVar = Constant
+ if (varConstMap.find(node) != varConstMap.end()) {
+ std::vector<expr*> concatNodes;
+ concatNodes.push_back(varConstMap[node]);
+ groundedMap[node][concatNodes].clear();
+ groundedMap[node][concatNodes].insert(ctx.mk_eq_atom(node, varConstMap[node]));
+ }
+ // deAliasedVar = someConcat
+ else if (varEqConcatMap.find(node) != varEqConcatMap.end()) {
+ expr * eqConcat = varEqConcatMap[node].begin()->first;
+ expr * deAliasedEqConcat = dealias_node(eqConcat, varAliasMap, concatAliasMap);
+ get_grounded_concats(deAliasedEqConcat, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
+
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator grdItor = groundedMap[deAliasedEqConcat].begin();
+ for (; grdItor != groundedMap[deAliasedEqConcat].end(); grdItor++) {
+ std::vector<expr*> ndVec;
+ ndVec.insert(ndVec.end(), grdItor->first.begin(), grdItor->first.end());
+ // only insert if we don't know "node = concat(ndVec)" since one set of condition leads to this is enough
+ if (groundedMap[node].find(ndVec) == groundedMap[node].end()) {
+ // condition: node = deAliasedEqConcat
+ groundedMap[node][ndVec].insert(ctx.mk_eq_atom(node, deAliasedEqConcat));
+ // appending conditions for "deAliasedEqConcat = CONCAT(ndVec)"
+ groundedMap[node][ndVec].insert(grdItor->second.begin(), grdItor->second.end());
+ }
+ }
+ }
+ // node (has been de-aliased) != constant && node (has been de-aliased) != any concat
+ // just push in the deAliasedVar
+ else {
+ std::vector<expr*> concatNodes;
+ concatNodes.push_back(node);
+ groundedMap[node][concatNodes]; // TODO ???
+ }
+ }
+}
+
+void theory_str::print_grounded_concat(expr * node, std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap) {
+ ast_manager & m = get_manager();
+ TRACE("t_str_detail", tout << mk_pp(node, m) << std::endl;);
+ if (groundedMap.find(node) != groundedMap.end()) {
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator itor = groundedMap[node].begin();
+ for (; itor != groundedMap[node].end(); ++itor) {
+ TRACE("t_str_detail",
+ tout << "\t[grounded] ";
+ std::vector<expr*>::const_iterator vIt = itor->first.begin();
+ for (; vIt != itor->first.end(); ++vIt) {
+ tout << mk_pp(*vIt, m) << ", ";
+ }
+ tout << std::endl;
+ tout << "\t[condition] ";
+ std::set<expr*>::iterator sIt = itor->second.begin();
+ for (; sIt != itor->second.end(); sIt++) {
+ tout << mk_pp(*sIt, m) << ", ";
+ }
+ tout << std::endl;
+ );
+ }
+ } else {
+ TRACE("t_str_detail", tout << "not found" << std::endl;);
+ }
+}
+
+bool theory_str::is_partial_in_grounded_concat(const std::vector<expr*> & strVec, const std::vector<expr*> & subStrVec) {
+ int strCnt = strVec.size();
+ int subStrCnt = subStrVec.size();
+
+ if (strCnt == 0 || subStrCnt == 0) {
+ return false;
+ }
+
+ // The assumption is that all consecutive constant strings are merged into one node
+ if (strCnt < subStrCnt) {
+ return false;
+ }
+
+ if (subStrCnt == 1) {
+ if (m_strutil.is_string(subStrVec[0])) {
+ std::string subStrVal = m_strutil.get_string_constant_value(subStrVec[0]);
+ for (int i = 0; i < strCnt; i++) {
+ if (m_strutil.is_string(strVec[i])) {
+ std::string strVal = m_strutil.get_string_constant_value(strVec[i]);
+ if (strVal.find(subStrVal) != std::string::npos) {
+ return true;
+ }
+ }
+ }
+ } else {
+ for (int i = 0; i < strCnt; i++) {
+ if (strVec[i] == subStrVec[0]) {
+ return true;
+ }
+ }
+ }
+ return false;
+ } else {
+ for (int i = 0; i <= (strCnt - subStrCnt); i++) {
+ // The first node in subStrVect should be
+ // * constant: a suffix of a note in strVec[i]
+ // * variable:
+ bool firstNodesOK = true;
+ if (m_strutil.is_string(subStrVec[0])) {
+ std::string subStrHeadVal = m_strutil.get_string_constant_value(subStrVec[0]);
+ if (m_strutil.is_string(strVec[i])) {
+ std::string strHeadVal = m_strutil.get_string_constant_value(strVec[i]);
+ if (strHeadVal.size() >= subStrHeadVal.size()) {
+ std::string suffix = strHeadVal.substr(strHeadVal.size() - subStrHeadVal.size(), subStrHeadVal.size());
+ if (suffix != subStrHeadVal) {
+ firstNodesOK = false;
+ }
+ } else {
+ firstNodesOK = false;
+ }
+ } else {
+ if (subStrVec[0] != strVec[i]) {
+ firstNodesOK = false;
+ }
+ }
+ }
+ if (!firstNodesOK) {
+ continue;
+ }
+
+ // middle nodes
+ bool midNodesOK = true;
+ for (int j = 1; j < subStrCnt - 1; j++) {
+ if (subStrVec[j] != strVec[i + j]) {
+ midNodesOK = false;
+ break;
+ }
+ }
+ if (!midNodesOK) {
+ continue;
+ }
+
+ // tail nodes
+ int tailIdx = i + subStrCnt - 1;
+ if (m_strutil.is_string(subStrVec[subStrCnt - 1])) {
+ std::string subStrTailVal = m_strutil.get_string_constant_value(subStrVec[subStrCnt - 1]);
+ if (m_strutil.is_string(strVec[tailIdx])) {
+ std::string strTailVal = m_strutil.get_string_constant_value(strVec[tailIdx]);
+ if (strTailVal.size() >= subStrTailVal.size()) {
+ std::string prefix = strTailVal.substr(0, subStrTailVal.size());
+ if (prefix == subStrTailVal) {
+ return true;
+ } else {
+ continue;
+ }
+ } else {
+ continue;
+ }
+ }
+ } else {
+ if (subStrVec[subStrCnt - 1] == strVec[tailIdx]) {
+ return true;
+ } else {
+ continue;
+ }
+ }
+ }
+ return false;
+ }
+}
+
+void theory_str::check_subsequence(expr* str, expr* strDeAlias, expr* subStr, expr* subStrDeAlias, expr* boolVar,
+ std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap) {
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator itorStr = groundedMap[strDeAlias].begin();
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator itorSubStr;
+ for (; itorStr != groundedMap[strDeAlias].end(); itorStr++) {
+ itorSubStr = groundedMap[subStrDeAlias].begin();
+ for (; itorSubStr != groundedMap[subStrDeAlias].end(); itorSubStr++) {
+ bool contain = is_partial_in_grounded_concat(itorStr->first, itorSubStr->first);
+ if (contain) {
+ expr_ref_vector litems(m);
+ if (str != strDeAlias) {
+ litems.push_back(ctx.mk_eq_atom(str, strDeAlias));
+ }
+ if (subStr != subStrDeAlias) {
+ litems.push_back(ctx.mk_eq_atom(subStr, subStrDeAlias));
+ }
+
+ //litems.insert(itorStr->second.begin(), itorStr->second.end());
+ //litems.insert(itorSubStr->second.begin(), itorSubStr->second.end());
+ for (std::set<expr*>::const_iterator i1 = itorStr->second.begin();
+ i1 != itorStr->second.end(); ++i1) {
+ litems.push_back(*i1);
+ }
+ for (std::set<expr*>::const_iterator i1 = itorSubStr->second.begin();
+ i1 != itorSubStr->second.end(); ++i1) {
+ litems.push_back(*i1);
+ }
+
+ expr_ref implyR(boolVar, m);
+
+ if (litems.empty()) {
+ assert_axiom(implyR);
+ } else {
+ expr_ref implyL(mk_and(litems), m);
+ assert_implication(implyL, implyR);
+ }
+
+ }
+ }
+ }
+}
+
+void theory_str::compute_contains(std::map<expr*, expr*> & varAliasMap,
+ std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr*> & varConstMap,
+ std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap) {
+ std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > groundedMap;
+ theory_str_contain_pair_bool_map_t::iterator containItor = contain_pair_bool_map.begin();
+ for (; containItor != contain_pair_bool_map.end(); containItor++) {
+ expr* containBoolVar = containItor->get_value();
+ expr* str = containItor->get_key1();
+ expr* subStr = containItor->get_key2();
+
+ expr* strDeAlias = dealias_node(str, varAliasMap, concatAliasMap);
+ expr* subStrDeAlias = dealias_node(subStr, varAliasMap, concatAliasMap);
+
+ get_grounded_concats(strDeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
+ get_grounded_concats(subStrDeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
+
+ // debugging
+ print_grounded_concat(strDeAlias, groundedMap);
+ print_grounded_concat(subStrDeAlias, groundedMap);
+
+ check_subsequence(str, strDeAlias, subStr, subStrDeAlias, containBoolVar, groundedMap);
+ }
+}
+
bool theory_str::can_concat_eq_str(expr * concat, std::string str) {
// TODO this method could use some traces and debugging info
int strLen = str.length();
@@ -6668,12 +6994,9 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
var_eq_concat_map, var_eq_unroll_map,
concat_eq_constStr_map, concat_eq_concat_map, unrollGroupMap););
- /*// TODO computeContains()
- if (containPairBoolMap.size() > 0) {
- NOT_IMPLEMENTED_YET();
- compute_contains(aliasIndexMap, concats_eq_Index_map, var_eq_constStr_map, concat_eq_constStr_map, var_eq_concat_map);
+ if (!contain_pair_bool_map.empty()) {
+ compute_contains(aliasIndexMap, concats_eq_index_map, var_eq_constStr_map, concat_eq_constStr_map, var_eq_concat_map);
}
- */
// step 4: dependence analysis
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 60a1d70e2..ba132a579 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -25,6 +25,7 @@ Revision History:
#include"arith_decl_plugin.h"
#include<set>
#include<stack>
+#include<vector>
#include"str_rewriter.h"
namespace smt {
@@ -353,6 +354,19 @@ namespace smt {
void check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass);
void check_contain_by_eq_nodes(expr * n1, expr * n2);
bool in_contain_idx_map(expr * n);
+ // TODO refactor these methods to use expr_ref_vector instead of std::vector
+ void compute_contains(std::map<expr*, expr*> & varAliasMap,
+ std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr *> & varConstMap,
+ std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap);
+ expr * dealias_node(expr * node, std::map<expr*, expr*> & varAliasMap, std::map<expr*, expr*> & concatAliasMap);
+ void get_grounded_concats(expr* node, std::map<expr*, expr*> & varAliasMap,
+ std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr*> & varConstMap,
+ std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap,
+ std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap);
+ void print_grounded_concat(expr * node, std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap);
+ void check_subsequence(expr* str, expr* strDeAlias, expr* subStr, expr* subStrDeAlias, expr* boolVar,
+ std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap);
+ bool is_partial_in_grounded_concat(const std::vector<expr*> & strVec, const std::vector<expr*> & subStrVec);
void get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList);
expr * simplify_concat(expr * node);
From 5e22bc57c8a484d0891340ab2b095bbc9648cc4a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 31 Aug 2016 19:19:23 -0400
Subject: [PATCH 195/401] theory_str cleanup
---
src/smt/theory_str.cpp | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 90b0992d6..9c69f9716 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3401,7 +3401,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
std::string part2Str = strValue.substr(i, strValue.size() - i);
expr_ref cropStr(m_strutil.mk_string(part1Str), mgr);
expr_ref suffixStr(m_strutil.mk_string(part2Str), mgr);
- expr_ref y_concat(mk_concat(suffixStr, n), mgr); // TODO concat axioms?
+ expr_ref y_concat(mk_concat(suffixStr, n), mgr);
if (can_two_nodes_eq(x, cropStr) && can_two_nodes_eq(y, y_concat)) {
// break down option 3-1
@@ -6435,6 +6435,7 @@ void theory_str::push_scope_eh() {
void theory_str::pop_scope_eh(unsigned num_scopes) {
sLevel -= num_scopes;
TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
+ TRACE("t_str_dump_assign_on_scope_change", dump_assignments(););
std::map<expr*, std::stack<T_cut *> >::iterator varItor = cut_var_map.begin();
while (varItor != cut_var_map.end()) {
From f9b4f21683c19cf629dbc7f6d49793788c87f696 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 31 Aug 2016 19:22:04 -0400
Subject: [PATCH 196/401] add rewrite for theory_str rewriter RegexPlus fixes
regex-013.smt2
---
src/ast/rewriter/str_rewriter.cpp | 12 ++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
2 files changed, 13 insertions(+)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index c644ecd46..015898a64 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -425,6 +425,15 @@ br_status str_rewriter::mk_re_RegexIn(expr * str, expr * re, expr_ref & result)
return BR_FAILED;
}
+br_status str_rewriter::mk_re_RegexStar(expr * re, expr_ref & result) {
+ if (m_strutil.is_re_RegexStar(re)) {
+ result = re;
+ return BR_REWRITE_FULL;
+ } else {
+ return BR_FAILED;
+ }
+}
+
br_status str_rewriter::mk_re_RegexPlus(expr * re, expr_ref & result) {
/*
* Two optimizations are possible if we inspect 're'.
@@ -523,6 +532,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_RE_REGEXPLUS:
SASSERT(num_args == 1);
return mk_re_RegexPlus(args[0], result);
+ case OP_RE_REGEXSTAR:
+ SASSERT(num_args == 1);
+ return mk_re_RegexStar(args[0], result);
case OP_RE_REGEXCHARRANGE:
SASSERT(num_args == 2);
return mk_re_RegexCharRange(args[0], args[1], result);
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index c64d086f9..d147e82e8 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -57,6 +57,7 @@ public:
br_status mk_re_Str2Reg(expr * str, expr_ref & result);
br_status mk_re_RegexIn(expr * str, expr * re, expr_ref & result);
br_status mk_re_RegexPlus(expr * re, expr_ref & result);
+ br_status mk_re_RegexStar(expr * re, expr_ref & result);
br_status mk_re_RegexCharRange(expr * start, expr * end, expr_ref & result);
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
From d3062a8eff28019af492691c6030235ffe18cff1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 2 Sep 2016 18:23:41 -0400
Subject: [PATCH 197/401] omit out-of-scope length testers from axiom premise
in theory_str::gen_len_test_options this fixes a regression in
charAt-007.smt2
---
src/smt/theory_str.cpp | 52 ++++++++++++++++++++++++++++++++++--------
1 file changed, 43 insertions(+), 9 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 9c69f9716..7faca9922 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -22,6 +22,7 @@ Revision History:
#include"ast_ll_pp.h"
#include<list>
#include<vector>
+#include<algorithm>
#include"theory_arith.h"
namespace smt {
@@ -8375,7 +8376,14 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
expr_ref_vector and_items_LHS(m);
expr_ref moreAst(m_strutil.mk_string("more"), m);
for (int i = 0; i < testerCount; ++i) {
- and_items_LHS.push_back(ctx.mk_eq_atom(fvar_lenTester_map[freeVar][i], moreAst));
+ expr * indicator = fvar_lenTester_map[freeVar][i];
+ if (internal_variable_set.find(indicator) == internal_variable_set.end()) {
+ TRACE("t_str_detail", tout << "indicator " << mk_pp(indicator, m) << " out of scope; continuing" << std::endl;);
+ continue;
+ } else {
+ TRACE("t_str_detail", tout << "indicator " << mk_pp(indicator, m) << " in scope" << std::endl;);
+ and_items_LHS.push_back(ctx.mk_eq_atom(indicator, moreAst));
+ }
}
expr_ref assertL(mk_and(and_items_LHS), m);
SASSERT(assertL);
@@ -8591,6 +8599,12 @@ void theory_str::get_var_in_eqc(expr * n, std::set<expr*> & varSet) {
} while (eqcNode != n);
}
+bool cmpvarnames(expr * lhs, expr * rhs) {
+ symbol lhs_name = to_app(lhs)->get_decl()->get_name();
+ symbol rhs_name = to_app(rhs)->get_decl()->get_name();
+ return lhs_name.str() < rhs_name.str();
+}
+
void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -8664,14 +8678,34 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
// TODO here's a great place for debugging info
- for(std::set<expr*>::iterator itor1 = leafVarSet.begin();
- itor1 != leafVarSet.end(); ++itor1) {
- expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
- // gen_len_val_options_for_free_var() can legally return NULL,
- // as methods that it calls may assert their own axioms instead.
- if (toAssert != NULL) {
- assert_axiom(toAssert);
- }
+ // testing: iterate over leafVarSet deterministically
+ if (false) {
+ // *** TESTING CODE
+ std::vector<expr*> sortedLeafVarSet;
+ for (std::set<expr*>::iterator itor1 = leafVarSet.begin(); itor1 != leafVarSet.end(); ++itor1) {
+ sortedLeafVarSet.push_back(*itor1);
+ }
+ std::sort(sortedLeafVarSet.begin(), sortedLeafVarSet.end(), cmpvarnames);
+ for(std::vector<expr*>::iterator itor1 = sortedLeafVarSet.begin();
+ itor1 != sortedLeafVarSet.end(); ++itor1) {
+ expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
+ // gen_len_val_options_for_free_var() can legally return NULL,
+ // as methods that it calls may assert their own axioms instead.
+ if (toAssert != NULL) {
+ assert_axiom(toAssert);
+ }
+ }
+ } else {
+ // *** CODE FROM BEFORE
+ for(std::set<expr*>::iterator itor1 = leafVarSet.begin();
+ itor1 != leafVarSet.end(); ++itor1) {
+ expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
+ // gen_len_val_options_for_free_var() can legally return NULL,
+ // as methods that it calls may assert their own axioms instead.
+ if (toAssert != NULL) {
+ assert_axiom(toAssert);
+ }
+ }
}
for (std::map<int, std::set<expr*> >::iterator mItor = aloneVars.begin();
From 2b8f165cc47e197dfc7a6aef0849c2af0c067018 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 2 Sep 2016 19:04:20 -0400
Subject: [PATCH 198/401] patch UNSAT to UNKNOWN in cmd_context for theory_str
---
src/smt/smt_context.cpp | 20 ++++++++++++++++++++
src/smt/theory_str.h | 2 ++
2 files changed, 22 insertions(+)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 046e2028e..251cf3b9b 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -37,6 +37,7 @@ Revision History:
#include"model_pp.h"
#include"ast_smt2_pp.h"
#include"ast_translation.h"
+#include"theory_str.h"
namespace smt {
@@ -3086,6 +3087,25 @@ namespace smt {
if (r == l_true && get_cancel_flag()) {
r = l_undef;
}
+
+ // PATCH for theory_str:
+ // UNSAT + overlapping variables => UNKNOWN
+ if (r == l_false) {
+ ptr_vector<theory>::iterator it = m_theory_set.begin();
+ ptr_vector<theory>::iterator end = m_theory_set.end();
+ for (; it != end; ++it) {
+ theory * th = *it;
+ if (strcmp(th->get_name(), "strings") == 0) {
+ theory_str * str = (theory_str*)th;
+ if (str->overlapping_variables_detected()) {
+ TRACE("t_str", tout << "WARNING: overlapping variables detected, UNSAT changed to UNKNOWN!" << std::endl;);
+ r = l_undef;
+ }
+ break;
+ }
+ }
+ }
+
return r;
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index ba132a579..1fad18293 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -457,6 +457,8 @@ namespace smt {
virtual char const * get_name() const { return "strings"; }
virtual void display(std::ostream & out) const;
+
+ bool overlapping_variables_detected() const { return loopDetected; }
protected:
virtual bool internalize_atom(app * atom, bool gate_ctx);
virtual bool internalize_term(app * term);
From 347f441517c2f6ca2d44eec295361d376b52baa8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 2 Sep 2016 20:44:14 -0400
Subject: [PATCH 199/401] add a check for variable scope to theory_str
---
src/smt/theory_str.cpp | 52 ++++++++++++++++++++++++++++++++++++++++++
src/smt/theory_str.h | 12 ++++++++++
2 files changed, 64 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 7faca9922..f19553864 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -38,6 +38,7 @@ theory_str::theory_str(ast_manager & m):
opt_NoQuickReturn_IntegerTheory(false),
opt_DisableIntegerTheoryIntegration(false),
opt_DeferEQCConsistencyCheck(true),
+ opt_CheckVariableScope(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -6433,6 +6434,54 @@ void theory_str::push_scope_eh() {
TRACE("t_str_dump_assign_on_scope_change", dump_assignments(););
}
+void theory_str::recursive_check_variable_scope(expr * ex) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ if (is_app(ex)) {
+ app * a = to_app(ex);
+ if (a->get_num_args() == 0) {
+ // we only care about string variables
+ sort * s = m.get_sort(ex);
+ sort * string_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ if (s != string_sort) {
+ return;
+ }
+ // base case: string constant / var
+ if (m_strutil.is_string(a)) {
+ return;
+ } else {
+ // assume var
+ if (variable_set.find(ex) == variable_set.end()
+ && internal_variable_set.find(ex) == internal_variable_set.end()) {
+ TRACE("t_str_detail", tout << "WARNING: possible reference to out-of-scope variable " << mk_pp(ex, m) << std::endl;);
+ }
+ }
+ } else {
+ for (unsigned i = 0; i < a->get_num_args(); ++i) {
+ recursive_check_variable_scope(a->get_arg(i));
+ }
+ }
+ }
+}
+
+void theory_str::check_variable_scope() {
+ if (!opt_CheckVariableScope) {
+ return;
+ }
+ TRACE("t_str_detail", tout << "checking scopes of variables in the current assignment" << std::endl;);
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+ for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
+ expr * ex = *i;
+ recursive_check_variable_scope(ex);
+ }
+}
+
void theory_str::pop_scope_eh(unsigned num_scopes) {
sLevel -= num_scopes;
TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
@@ -6487,6 +6536,8 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
m_basicstr_axiom_todo = new_m_basicstr;
theory::pop_scope_eh(num_scopes);
+
+ check_variable_scope();
}
void theory_str::dump_assignments() {
@@ -7381,6 +7432,7 @@ final_check_status theory_str::final_check_eh() {
TRACE("t_str", tout << "final check" << std::endl;);
TRACE("t_str_dump_assign", dump_assignments(););
+ check_variable_scope();
if (opt_DeferEQCConsistencyCheck) {
TRACE("t_str_detail", tout << "performing deferred EQC consistency check" << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 1fad18293..8a0a2ea81 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -146,6 +146,14 @@ namespace smt {
*/
bool opt_DeferEQCConsistencyCheck;
+ /*
+ * If CheckVariableScope is set to true,
+ * pop_scope_eh() and final_check_eh() will run extra checks
+ * to determine whether the current assignment
+ * contains references to any internal variables that are no longer in scope.
+ */
+ bool opt_CheckVariableScope;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -451,6 +459,10 @@ namespace smt {
void dump_assignments();
void initialize_charset();
+
+ void check_variable_scope();
+ void recursive_check_variable_scope(expr * ex);
+
public:
theory_str(ast_manager & m);
virtual ~theory_str();
From 7b34efada78d48d2d1d55896662092605d57e5d1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 4 Sep 2016 18:48:15 -0400
Subject: [PATCH 200/401] add aggressive unroll test option to theory_str
---
src/smt/theory_str.cpp | 18 ++++++++++++++++++
src/smt/theory_str.h | 6 ++++++
2 files changed, 24 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f19553864..749b9c036 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -32,6 +32,7 @@ theory_str::theory_str(ast_manager & m):
/* Options */
opt_AggressiveLengthTesting(false),
opt_AggressiveValueTesting(false),
+ opt_AggressiveUnrollTesting(true),
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
@@ -8265,6 +8266,7 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
int tries = unroll_tries_map[var][unrolls].size();
for (int i = 0; i < tries; i++) {
+ // TODO possibly missing a scope check here
expr * tester = unroll_tries_map[var][unrolls][i];
bool testerHasValue = false;
expr * testerVal = get_eqc_value(tester, testerHasValue);
@@ -8318,6 +8320,10 @@ expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * test
TRACE("t_str_detail", tout << "entry: var = " << mk_pp(var, mgr) << ", lcmStr = " << lcmStr
<< ", l = " << l << ", h = " << h << std::endl;);
+ if (opt_AggressiveUnrollTesting) {
+ TRACE("t_str_detail", tout << "note: aggressive unroll testing is active" << std::endl;);
+ }
+
expr_ref_vector orItems(mgr);
expr_ref_vector andItems(mgr);
@@ -8325,6 +8331,12 @@ expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * test
std::string iStr = int_to_string(i);
expr_ref testerEqAst(ctx.mk_eq_atom(testerVar, m_strutil.mk_string(iStr)), mgr);
TRACE("t_str_detail", tout << "testerEqAst = " << mk_pp(testerEqAst, mgr) << std::endl;);
+ if (opt_AggressiveUnrollTesting) {
+ literal l = mk_eq(testerVar, m_strutil.mk_string(iStr), false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(l);
+ }
+
orItems.push_back(testerEqAst);
std::string unrollStrInstance = get_unrolled_string(lcmStr, i);
@@ -8338,6 +8350,12 @@ expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * test
}
expr_ref testerEqMore(ctx.mk_eq_atom(testerVar, m_strutil.mk_string("more")), mgr);
TRACE("t_str_detail", tout << "testerEqMore = " << mk_pp(testerEqMore, mgr) << std::endl;);
+ if (opt_AggressiveUnrollTesting) {
+ literal l = mk_eq(testerVar, m_strutil.mk_string("more"), false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(~l);
+ }
+
orItems.push_back(testerEqMore);
int nextLowerLenBound = h * lcmStr.length();
expr_ref more2(ctx.mk_eq_atom(testerEqMore,
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 8a0a2ea81..6ce46abb4 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -96,6 +96,12 @@ namespace smt {
*/
bool opt_AggressiveValueTesting;
+ /*
+ * If AggressiveUnrollTesting is true, we manipulate the phase of regex unroll tester equalities
+ * to prioritize trying concrete unroll counts over choosing the "more" option.
+ */
+ bool opt_AggressiveUnrollTesting;
+
/*
* Setting EagerStringConstantLengthAssertions to true allows some methods,
* in particular internalize_term(), to add
From c83e39d3b8ab55ab0309bfc160ee951f244979e3 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 5 Sep 2016 17:45:10 -0400
Subject: [PATCH 201/401] fix incorrect axiom in theory_str for Contains check
this partially fixes a regression in contains-034.smt2, which now is at least
not a SAT-as-UNSAT
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 749b9c036..421a45e57 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4773,7 +4773,7 @@ void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
// key1.first = key2.first /\ containPairBoolMap[<eqc(key2.second), eqc(key1.second)>]
// ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
// ------------
- expr_ref implR(ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
+ expr_ref implR(rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
assert_implication(mk_and(litems4), implR);
}
}
From 82e07aae8c921eb6a0d552bf3e0604b38241b840 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 8 Sep 2016 19:55:08 -0400
Subject: [PATCH 202/401] disable deferred eqc check in theory_str
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 421a45e57..d393f1cdb 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -38,7 +38,7 @@ theory_str::theory_str(ast_manager & m):
opt_LCMUnrollStep(2),
opt_NoQuickReturn_IntegerTheory(false),
opt_DisableIntegerTheoryIntegration(false),
- opt_DeferEQCConsistencyCheck(true),
+ opt_DeferEQCConsistencyCheck(false),
opt_CheckVariableScope(true),
/* Internal setup */
search_started(false),
From 2c5569aa1f0f4881d6354af3ccc4b29284e6e949 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 12 Sep 2016 15:43:58 -0400
Subject: [PATCH 203/401] change cut_var_map to obj_map
---
src/smt/theory_str.cpp | 41 +++++++++++++++++++++++++++--------------
src/smt/theory_str.h | 2 +-
2 files changed, 28 insertions(+), 15 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index d393f1cdb..511585fa8 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -299,10 +299,10 @@ static void cut_vars_map_copy(std::map<expr*, int> & dest, std::map<expr*, int>
}
bool theory_str::has_self_cut(expr * n1, expr * n2) {
- if (cut_var_map.find(n1) == cut_var_map.end()) {
+ if (!cut_var_map.contains(n1)) {
return false;
}
- if (cut_var_map.find(n2) == cut_var_map.end()) {
+ if (!cut_var_map.contains(n2)) {
return false;
}
if (cut_var_map[n1].empty() || cut_var_map[n2].empty()) {
@@ -322,10 +322,11 @@ void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node)
// crash avoidance?
m_trail.push_back(baseNode);
m_trail.push_back(node);
- if (cut_var_map.find(baseNode) == cut_var_map.end()) {
+ if (!cut_var_map.contains(baseNode)) {
T_cut * varInfo = alloc(T_cut);
varInfo->level = slevel;
varInfo->vars[node] = 1;
+ cut_var_map.insert(baseNode, std::stack<T_cut*>());
cut_var_map[baseNode].push(varInfo);
TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << std::endl;);
} else {
@@ -357,7 +358,7 @@ void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode)
// crash avoidance?
m_trail.push_back(destNode);
m_trail.push_back(srcNode);
- if (cut_var_map.find(srcNode) == cut_var_map.end()) {
+ if (!cut_var_map.contains(srcNode)) {
get_manager().raise_exception("illegal state in add_cut_info_merge(): cut_var_map doesn't contain srcNode");
}
@@ -365,10 +366,11 @@ void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode)
get_manager().raise_exception("illegal state in add_cut_info_merge(): cut_var_map[srcNode] is empty");
}
- if (cut_var_map.find(destNode) == cut_var_map.end()) {
+ if (!cut_var_map.contains(destNode)) {
T_cut * varInfo = alloc(T_cut);
varInfo->level = slevel;
cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
+ cut_var_map.insert(destNode, std::stack<T_cut*>());
cut_var_map[destNode].push(varInfo);
TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << std::endl;);
} else {
@@ -389,7 +391,7 @@ void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode)
}
void theory_str::check_and_init_cut_var(expr * node) {
- if (cut_var_map.find(node) != cut_var_map.end()) {
+ if (cut_var_map.contains(node)) {
return;
} else if (!m_strutil.is_string(node)) {
add_cut_info_one_node(node, -1, node);
@@ -6488,18 +6490,29 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
TRACE("t_str_dump_assign_on_scope_change", dump_assignments(););
- std::map<expr*, std::stack<T_cut *> >::iterator varItor = cut_var_map.begin();
+ // list of expr* to remove from cut_var_map
+ ptr_vector<expr> cutvarmap_removes;
+
+ obj_map<expr, std::stack<T_cut *> >::iterator varItor = cut_var_map.begin();
while (varItor != cut_var_map.end()) {
- while ((varItor->second.size() > 0) && (varItor->second.top()->level != 0) && (varItor->second.top()->level >= sLevel)) {
- T_cut * aCut = varItor->second.top();
- varItor->second.pop();
+ std::stack<T_cut*> & val = cut_var_map[varItor->m_key];
+ while ((val.size() > 0) && (val.top()->level != 0) && (val.top()->level >= sLevel)) {
+ T_cut * aCut = val.top();
+ val.pop();
// dealloc(aCut); // TODO find a safer way to do this, it is causing a crash
}
- if (varItor->second.size() == 0) {
- cut_var_map.erase(varItor++);
- } else {
- varItor++;
+ if (val.size() == 0) {
+ cutvarmap_removes.insert(varItor->m_key);
}
+ varItor++;
+ }
+
+ if (!cutvarmap_removes.empty()) {
+ ptr_vector<expr>::iterator it = cutvarmap_removes.begin();
+ for (; it != cutvarmap_removes.end(); ++it) {
+ expr * ex = *it;
+ cut_var_map.remove(ex);
+ }
}
// see if any internal variables went out of scope
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 6ce46abb4..bb2fc01d6 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -206,7 +206,7 @@ namespace smt {
bool avoidLoopCut;
bool loopDetected;
- std::map<expr*, std::stack<T_cut *> > cut_var_map;
+ obj_map<expr, std::stack<T_cut*> > cut_var_map;
std::set<expr*> variable_set;
std::set<expr*> internal_variable_set;
From b3fddf47076faa65964735c5c64963dfe202af11 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 12 Sep 2016 16:41:35 -0400
Subject: [PATCH 204/401] performance optimization in
theory_str::classify_ast_by_type
---
src/smt/theory_str.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 511585fa8..ecc3b7247 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6597,10 +6597,10 @@ void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap
expr * arg1Val = get_eqc_value(arg1, arg1HasEq);
int canskip = 0;
- if (arg0HasEq && arg0Val == m_strutil.mk_string("")) {
+ if (arg0HasEq && m_strutil.get_string_constant_value(arg0Val).empty()) {
canskip = 1;
}
- if (canskip == 0 && arg1HasEq && arg1Val == m_strutil.mk_string("")) {
+ if (canskip == 0 && arg1HasEq && m_strutil.get_string_constant_value(arg1Val).empty()) {
canskip = 1;
}
if (canskip == 0 && concatMap.find(node) == concatMap.end()) {
From 015016c92b43e4b01eadd00e00e151d59952362a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 12 Sep 2016 16:57:05 -0400
Subject: [PATCH 205/401] disable variable scope check if not tracing in
theory_str
---
src/smt/theory_str.cpp | 5 +++++
1 file changed, 5 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ecc3b7247..29bedbe86 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6472,6 +6472,11 @@ void theory_str::check_variable_scope() {
if (!opt_CheckVariableScope) {
return;
}
+
+ if (!is_trace_enabled("t_str_detail")) {
+ return;
+ }
+
TRACE("t_str_detail", tout << "checking scopes of variables in the current assignment" << std::endl;);
context & ctx = get_context();
From ca71a20ab75e8d868bfafb28115a7597717ea7f2 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 12 Sep 2016 17:17:17 -0400
Subject: [PATCH 206/401] add caching to theory_str::mk_concat, WIP
---
src/smt/theory_str.cpp | 15 +++++----------
src/smt/theory_str.h | 2 ++
2 files changed, 7 insertions(+), 10 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 29bedbe86..f44cb8322 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -735,16 +735,14 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
// * expr * ast2 = mk_2_arg_app(ctx, td->Concat, n1, n2);
// Z3 treats (ast1) and (ast2) as two different nodes.
//-------------------------------------------------------
- std::pair<expr*, expr*> concatArgs(n1, n2);
+
expr * concatAst = NULL;
- // TODO NEXT add cache lookups. I think we need to be more careful than just using std:: data structures here
- /*
- if (concat_astNode_map.find(concatArgs) == concat_astNode_map.end()) {
- */
- if (true) {
+
+ if (!concat_astNode_map.find(n1, n2, concatAst)) {
expr * args[2] = {n1, n2};
concatAst = m.mk_app(get_id(), OP_STRCAT, 0, 0, 2, args);
- // concat_astNode_map[concatArgs] = concatAst;
+ m_trail.push_back(concatAst);
+ concat_astNode_map.insert(n1, n2, concatAst);
expr_ref concat_length(mk_strlen(concatAst), m);
@@ -756,9 +754,6 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
}
expr_ref lenAssert(ctx.mk_eq_atom(concat_length, m_autil.mk_add(items.size(), items.c_ptr())), m);
assert_axiom(lenAssert);
- } else {
- // concatAst = concat_astNode_map[concatArgs];
- NOT_IMPLEMENTED_YET();
}
return concatAst;
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index bb2fc01d6..9f7d51a8f 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -250,6 +250,8 @@ namespace smt {
std::map<char, int> charSetLookupTable;
int charSetSize;
+ obj_pair_map<expr, expr, expr*> concat_astNode_map;
+
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
From aea0032aa7d5c2ed5022517217383becf861db24 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 13 Sep 2016 18:01:45 -0400
Subject: [PATCH 207/401] manage our own union-find structure in theory_str
concat-086.smt2 passes with this, for the first time ever
---
src/smt/theory_str.cpp | 213 ++++++++++++++++++++++++++---------------
src/smt/theory_str.h | 17 ++++
2 files changed, 154 insertions(+), 76 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f44cb8322..939a63160 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -54,12 +54,15 @@ theory_str::theory_str(ast_manager & m):
tmpValTestVarCount(0),
avoidLoopCut(true),
loopDetected(false),
- contains_map(m)
+ contains_map(m),
+ m_find(*this),
+ m_trail_stack(*this)
{
initialize_charset();
}
theory_str::~theory_str() {
+ m_trail_stack.reset();
}
void theory_str::initialize_charset() {
@@ -284,7 +287,7 @@ theory_var theory_str::mk_var(enode* n) {
}
else {
theory_var v = theory::mk_var(n);
- // m_find.mk_var();
+ m_find.mk_var();
get_context().attach_th_var(n, this, v);
get_context().mark_as_relevant(n);
return v;
@@ -1586,6 +1589,8 @@ void theory_str::attach_new_th_var(enode * n) {
void theory_str::reset_eh() {
TRACE("t_str", tout << "resetting" << std::endl;);
+ m_trail_stack.reset();
+
m_basicstr_axiom_todo.reset();
m_str_eq_todo.reset();
m_concat_axiom_todo.reset();
@@ -1673,13 +1678,40 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
return true;
}
+// support for user_smt_theory-style EQC handling
+
+app * theory_str::get_ast(theory_var i) {
+ return get_enode(i)->get_owner();
+}
+
+theory_var theory_str::get_var(expr * n) const {
+ if (!is_app(n)) {
+ return null_theory_var;
+ }
+ context & ctx = get_context();
+ if (ctx.e_internalized(to_app(n))) {
+ enode * e = ctx.get_enode(to_app(n));
+ return e->get_th_var(get_id());
+ }
+ return null_theory_var;
+}
+
+// simulate Z3_theory_get_eqc_next()
+expr * theory_str::get_eqc_next(expr * n) {
+ theory_var v = get_var(n);
+ if (v != null_theory_var) {
+ theory_var r = m_find.next(v);
+ return get_ast(r);
+ }
+ return n;
+}
+
void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts) {
context & ctx = get_context();
- enode * nNode = ctx.get_enode(n);
- enode * eqcNode = nNode;
+ expr * eqcNode = n;
do {
- app * ast = eqcNode->get_owner();
- if (is_concat(eqcNode)) {
+ app * ast = to_app(eqcNode);
+ if (is_concat(ast)) {
expr * simConcat = simplify_concat(ast);
if (simConcat != ast) {
if (is_concat(to_app(simConcat))) {
@@ -1694,13 +1726,13 @@ void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::se
} else {
concats.insert(simConcat);
}
- } else if (is_string(eqcNode)) {
+ } else if (is_string(ast)) {
consts.insert(ast);
} else {
vars.insert(ast);
}
- eqcNode = eqcNode->get_next();
- } while (eqcNode != nNode);
+ eqcNode = get_eqc_next(eqcNode);
+ } while (eqcNode != n);
}
void theory_str::get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList) {
@@ -3975,6 +4007,22 @@ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
return n;
}
+// Simulate the behaviour of get_eqc_value() from Z3str2.
+// We only check m_find for a string constant.
+
+expr * theory_str::z3str2_get_eqc_value(expr * n , bool & hasEqcValue) {
+ expr * curr = n;
+ do {
+ if (m_strutil.is_string(curr)) {
+ hasEqcValue = true;
+ return curr;
+ }
+ curr = get_eqc_next(curr);
+ } while (curr != n);
+ hasEqcValue = false;
+ return n;
+}
+
// from Z3: theory_seq.cpp
static theory_mi_arith* get_th_arith(context& ctx, theory_id afid, expr* e) {
@@ -6110,106 +6158,107 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
instantiate_str_eq_length_axiom(ctx.get_enode(lhs), ctx.get_enode(rhs));
// group terms by equivalence class (groupNodeInEqc())
- // Previously we did the check between LHS and RHS equivalence classes.
- // However these have since been merged.
- // We start by asserting that the EQCs, in fact, really are merged.
- if (!in_same_eqc(lhs, rhs)) {
- TRACE("t_str", tout << "BUG: lhs and rhs not in same eqc in new_eq_eh(), loss of invariant!" << std::endl;);
- UNREACHABLE();
- }
- std::set<expr*> eqc_concat;
- std::set<expr*> eqc_var;
- std::set<expr*> eqc_const;
- group_terms_by_eqc(lhs, eqc_concat, eqc_var, eqc_const);
+ std::set<expr*> eqc_concat_lhs;
+ std::set<expr*> eqc_var_lhs;
+ std::set<expr*> eqc_const_lhs;
+ group_terms_by_eqc(lhs, eqc_concat_lhs, eqc_var_lhs, eqc_const_lhs);
+
+ std::set<expr*> eqc_concat_rhs;
+ std::set<expr*> eqc_var_rhs;
+ std::set<expr*> eqc_const_rhs;
+ group_terms_by_eqc(rhs, eqc_concat_rhs, eqc_var_rhs, eqc_const_rhs);
TRACE("t_str_detail",
- tout << "eqc:" << std::endl;
+ tout << "lhs eqc:" << std::endl;
tout << "Concats:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_concat.begin(); it != eqc_concat.end(); ++it) {
+ for (std::set<expr*>::iterator it = eqc_concat_lhs.begin(); it != eqc_concat_lhs.end(); ++it) {
expr * ex = *it;
tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
}
tout << "Variables:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_var.begin(); it != eqc_var.end(); ++it) {
+ for (std::set<expr*>::iterator it = eqc_var_lhs.begin(); it != eqc_var_lhs.end(); ++it) {
expr * ex = *it;
tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
}
tout << "Constants:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_const.begin(); it != eqc_const.end(); ++it) {
+ for (std::set<expr*>::iterator it = eqc_const_lhs.begin(); it != eqc_const_lhs.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+
+ tout << "rhs eqc:" << std::endl;
+ tout << "Concats:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_concat_rhs.begin(); it != eqc_concat_rhs.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ tout << "Variables:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_var_rhs.begin(); it != eqc_var_rhs.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ tout << "Constants:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_const_rhs.begin(); it != eqc_const_rhs.end(); ++it) {
expr * ex = *it;
tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
}
);
// step 1: Concat == Concat
-
- // enhancement from Z3str2: all-pairs match over LHS and RHS wrt. other concats
- if (eqc_concat.size() != 0) {
- std::set<expr*>::iterator itor1, itor2;
- for (itor1 = eqc_concat.begin(); itor1 != eqc_concat.end(); ++itor1) {
- for (itor2 = itor1; itor2 != eqc_concat.end(); ++itor2) {
- if (itor1 == itor2) {
- continue;
- }
- expr * e1 = *itor1;
- expr * e2 = *itor2;
- TRACE("t_str_detail", tout << "simplify concat-concat pair " << mk_pp(e1, m) << " and " << mk_pp(e2, m) << std::endl;);
- simplify_concat_equality(e1, e2);
+ int hasCommon = 0;
+ if (eqc_concat_lhs.size() != 0 && eqc_concat_rhs.size() != 0) {
+ std::set<expr*>::iterator itor1 = eqc_concat_lhs.begin();
+ std::set<expr*>::iterator itor2 = eqc_concat_rhs.begin();
+ for (; itor1 != eqc_concat_lhs.end(); itor1++) {
+ if (eqc_concat_rhs.find(*itor1) != eqc_concat_rhs.end()) {
+ hasCommon = 1;
+ break;
}
}
+ for (; itor2 != eqc_concat_rhs.end(); itor2++) {
+ if (eqc_concat_lhs.find(*itor2) != eqc_concat_lhs.end()) {
+ hasCommon = 1;
+ break;
+ }
+ }
+ if (hasCommon == 0) {
+ simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin()));
+ }
}
// step 2: Concat == Constant
- // same enhancement as above wrt. Z3str2's behaviour
- if (eqc_const.size() != 0) {
- expr * conStr = *(eqc_const.begin());
- std::set<expr*>::iterator itor2;
- for (itor2 = eqc_concat.begin(); itor2 != eqc_concat.end(); ++itor2) {
+
+ if (eqc_const_lhs.size() != 0) {
+ expr * conStr = *(eqc_const_lhs.begin());
+ std::set<expr*>::iterator itor2 = eqc_const_rhs.begin();
+ for (; itor2 != eqc_const_rhs.end(); itor2++) {
solve_concat_eq_str(*itor2, conStr);
}
+ } else if (eqc_const_rhs.size() != 0) {
+ expr* conStr = *(eqc_const_rhs.begin());
+ std::set<expr*>::iterator itor1 = eqc_const_lhs.begin();
+ for (; itor1 != eqc_const_lhs.end(); itor1++) {
+ solve_concat_eq_str(*itor1, conStr);
+ }
}
// simplify parents wrt. the equivalence class of both sides
- // TODO this is slightly broken, re-enable it once some semantics have been fixed
- // Briefly, Z3str2 expects that as this function is entered,
- // lhs and rhs are NOT in the same equivalence class yet.
- // However, newer versions of Z3 appear to behave differently,
- // putting lhs and rhs into the same equivalence class
- // *before* this function is called.
- // Instead we do something possibly more aggressive here.
- /*
- bool lhs_has_eqc_value = false;
- bool rhs_has_eqc_value = false;
- expr * lhs_value = get_eqc_value(lhs, lhs_has_eqc_value);
- expr * rhs_value = get_eqc_value(rhs, rhs_has_eqc_value);
- if (lhs_has_eqc_value && !rhs_has_eqc_value) {
- simplify_parent(rhs, lhs_value);
+ bool nn1HasEqcValue = false;
+ bool nn2HasEqcValue = false;
+ // we want the Z3str2 eqc check here...
+ expr * nn1_value = z3str2_get_eqc_value(lhs, nn1HasEqcValue);
+ expr * nn2_value = z3str2_get_eqc_value(rhs, nn2HasEqcValue);
+ if (nn1HasEqcValue && !nn2HasEqcValue) {
+ simplify_parent(rhs, nn1_value);
}
- if (!lhs_has_eqc_value && rhs_has_eqc_value) {
- simplify_parent(lhs, rhs_value);
- }
- */
- bool lhs_has_eqc_value = false;
- bool rhs_has_eqc_value = false;
- expr * lhs_value = get_eqc_value(lhs, lhs_has_eqc_value);
- expr * rhs_value = get_eqc_value(rhs, rhs_has_eqc_value);
-
- // TODO this depends on the old, possibly broken, semantics of is_string().
- // we explicitly want to test whether lhs/rhs is actually a string constant.
- bool lhs_is_string_constant = m_strutil.is_string(lhs);
- bool rhs_is_string_constant = m_strutil.is_string(rhs);
-
-
- if (lhs_has_eqc_value && !rhs_is_string_constant) {
- simplify_parent(rhs, lhs_value);
- }
- if (rhs_has_eqc_value && !lhs_is_string_constant) {
- simplify_parent(lhs, rhs_value);
+ if (!nn1HasEqcValue && nn2HasEqcValue) {
+ simplify_parent(lhs, nn2_value);
}
// regex unroll
+ // TODO NEXT check EQC semantics here too
expr * nn1EqConst = NULL;
std::set<expr*> nn1EqUnrollFuncs;
@@ -6229,6 +6278,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
process_unroll_eq_const_str(*itor2, nn1EqConst);
}
}
+
}
void theory_str::set_up_axioms(expr * ex) {
@@ -6407,7 +6457,15 @@ void theory_str::new_eq_eh(theory_var x, theory_var y) {
//TRACE("t_str_detail", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
TRACE("t_str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
+ /*
+ if (m_find.find(x) == m_find.find(y)) {
+ return;
+ }
+ */
handle_equality(get_enode(x)->get_owner(), get_enode(y)->get_owner());
+
+ // replicate Z3str2 behaviour: merge eqc **AFTER** handle_equality
+ m_find.merge(x, y);
}
void theory_str::new_diseq_eh(theory_var x, theory_var y) {
@@ -6427,6 +6485,8 @@ void theory_str::assign_eh(bool_var v, bool is_true) {
void theory_str::push_scope_eh() {
theory::push_scope_eh();
+ m_trail_stack.push_scope();
+
sLevel += 1;
TRACE("t_str", tout << "push to " << sLevel << std::endl;);
TRACE("t_str_dump_assign_on_scope_change", dump_assignments(););
@@ -6549,6 +6609,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
m_basicstr_axiom_todo.reset();
m_basicstr_axiom_todo = new_m_basicstr;
+ m_trail_stack.pop_scope(num_scopes);
theory::pop_scope_eh(num_scopes);
check_variable_scope();
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 9f7d51a8f..58b104209 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -27,6 +27,7 @@ Revision History:
#include<stack>
#include<vector>
#include"str_rewriter.h"
+#include"union_find.h"
namespace smt {
@@ -81,6 +82,10 @@ namespace smt {
level = -100;
}
};
+
+ typedef trail_stack<theory_str> th_trail_stack;
+ typedef union_find<theory_str> th_union_find;
+
protected:
// Some options that control how the solver operates.
@@ -252,6 +257,12 @@ namespace smt {
obj_pair_map<expr, expr, expr*> concat_astNode_map;
+ th_union_find m_find;
+ th_trail_stack m_trail_stack;
+ theory_var get_var(expr * n) const;
+ expr * get_eqc_next(expr * n);
+ app * get_ast(theory_var i);
+
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
@@ -347,6 +358,7 @@ namespace smt {
app * mk_value_helper(app * n);
expr * get_eqc_value(expr * n, bool & hasEqcValue);
+ expr * z3str2_get_eqc_value(expr * n , bool & hasEqcValue);
bool in_same_eqc(expr * n1, expr * n2);
expr * collect_eq_nodes(expr * n, expr_ref_vector & eqcSet);
@@ -479,6 +491,11 @@ namespace smt {
virtual void display(std::ostream & out) const;
bool overlapping_variables_detected() const { return loopDetected; }
+
+ th_trail_stack& get_trail_stack() { return m_trail_stack; }
+ void merge_eh(theory_var, theory_var, theory_var v1, theory_var v2) {}
+ void after_merge_eh(theory_var r1, theory_var r2, theory_var v1, theory_var v2) { }
+ void unmerge_eh(theory_var v1, theory_var v2) {}
protected:
virtual bool internalize_atom(app * atom, bool gate_ctx);
virtual bool internalize_term(app * term);
From 8f636e1f57be63f2cdb071b44fc7baae0d05e924 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 13 Sep 2016 18:16:21 -0400
Subject: [PATCH 208/401] fix typo'ed set reference in handle_equality
---
src/smt/theory_str.cpp | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 939a63160..c3ae176b7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6231,14 +6231,14 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
if (eqc_const_lhs.size() != 0) {
expr * conStr = *(eqc_const_lhs.begin());
- std::set<expr*>::iterator itor2 = eqc_const_rhs.begin();
- for (; itor2 != eqc_const_rhs.end(); itor2++) {
+ std::set<expr*>::iterator itor2 = eqc_concat_rhs.begin();
+ for (; itor2 != eqc_concat_rhs.end(); itor2++) {
solve_concat_eq_str(*itor2, conStr);
}
} else if (eqc_const_rhs.size() != 0) {
expr* conStr = *(eqc_const_rhs.begin());
- std::set<expr*>::iterator itor1 = eqc_const_lhs.begin();
- for (; itor1 != eqc_const_lhs.end(); itor1++) {
+ std::set<expr*>::iterator itor1 = eqc_concat_lhs.begin();
+ for (; itor1 != eqc_concat_lhs.end(); itor1++) {
solve_concat_eq_str(*itor1, conStr);
}
}
From 34dc65515041928c4ef5116871c959a55f42fc08 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 13 Sep 2016 18:24:59 -0400
Subject: [PATCH 209/401] z3str2 eqc semantics for theory_str unroll checks
---
src/smt/theory_str.cpp | 8 ++------
1 file changed, 2 insertions(+), 6 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index c3ae176b7..6d4fb1aab 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -8883,9 +8883,7 @@ void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> &
unrollFuncSet.insert(curr);
}
}
- enode * e_curr = ctx.get_enode(curr);
- curr = e_curr->get_next()->get_owner();
- // curr = get_eqc_next(t, curr);
+ curr = get_eqc_next(curr);
} while (curr != n);
}
@@ -8907,9 +8905,7 @@ void theory_str::get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*
}
}
}
- enode * e_curr = ctx.get_enode(curr);
- curr = e_curr->get_next()->get_owner();
- // curr = get_eqc_next(t, curr);
+ curr = get_eqc_next(curr);
} while (curr != n);
}
From 9481601b4b315ada3abf46dd90b85b99136d2c94 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 15:15:47 -0400
Subject: [PATCH 210/401] restore z3str2 eqc semantics in
theory_str::new_eq_check
---
src/smt/theory_str.cpp | 73 +++++++++++++++---------------------------
1 file changed, 25 insertions(+), 48 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 6d4fb1aab..1238eb069 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -32,7 +32,7 @@ theory_str::theory_str(ast_manager & m):
/* Options */
opt_AggressiveLengthTesting(false),
opt_AggressiveValueTesting(false),
- opt_AggressiveUnrollTesting(true),
+ opt_AggressiveUnrollTesting(false),
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
@@ -143,7 +143,7 @@ void theory_str::assert_axiom(expr * e) {
if (opt_VerifyFinalCheckProgress) {
finalCheckProgressIndicator = true;
}
- // TODO add to m_trail?
+
if (get_manager().is_true(e)) return;
TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
context & ctx = get_context();
@@ -1612,58 +1612,42 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
context & ctx = get_context();
ast_manager & m = get_manager();
- // Previously we did the check between LHS and RHS equivalence classes.
- // However these have since been merged.
- // We start by asserting that the EQCs, in fact, really are merged.
- if (!in_same_eqc(lhs, rhs)) {
- TRACE("t_str", tout << "BUG: lhs and rhs not in same eqc in new_eq_eh(), loss of invariant!" << std::endl;);
- UNREACHABLE();
- }
-
// skip this check if we defer consistency checking, as we can do it for every EQC in final check
if (!opt_DeferEQCConsistencyCheck) {
check_concat_len_in_eqc(lhs);
check_concat_len_in_eqc(rhs);
}
- // Now we iterate over all pairs of terms in the (shared) eqc
+ // Now we iterate over all pairs of terms across both EQCs
// and check whether we can show that any pair of distinct terms
// cannot possibly be equal.
// If that's the case, we assert an axiom to that effect and stop.
- enode * eqc_root = ctx.get_enode(lhs)->get_root();
- enode * eqc_iterator1 = eqc_root;
+ expr * eqc_nn1 = lhs;
do {
- enode * eqc_iterator2 = eqc_iterator1;
+ expr * eqc_nn2 = rhs;
do {
- if (eqc_iterator1 != eqc_iterator2) {
- // pull terms out of the enodes
- app * eqc_nn1 = eqc_iterator1->get_owner();
- app * eqc_nn2 = eqc_iterator2->get_owner();
- TRACE("t_str_detail", tout << "checking whether " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " can be equal" << std::endl;);
- if (!can_two_nodes_eq(eqc_nn1, eqc_nn2)) {
- TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " cannot be equal to " << mk_pp(eqc_nn2, m) << std::endl;);
- expr_ref to_assert(m.mk_not(ctx.mk_eq_atom(eqc_nn1, eqc_nn2)), m);
- assert_axiom(to_assert);
- // this shouldn't use the integer theory at all, so we don't allow the option of quick-return
+ TRACE("t_str_detail", tout << "checking whether " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " can be equal" << std::endl;);
+ // inconsistency check: value
+ if (!can_two_nodes_eq(eqc_nn1, eqc_nn2)) {
+ TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " cannot be equal to " << mk_pp(eqc_nn2, m) << std::endl;);
+ expr_ref to_assert(m.mk_not(ctx.mk_eq_atom(eqc_nn1, eqc_nn2)), m);
+ assert_axiom(to_assert);
+ // this shouldn't use the integer theory at all, so we don't allow the option of quick-return
+ return false;
+ }
+ if (!check_length_consistency(eqc_nn1, eqc_nn2)) {
+ TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " have inconsistent lengths" << std::endl;);
+ if (opt_NoQuickReturn_IntegerTheory){
+ TRACE("t_str_detail", tout << "continuing in new_eq_check() due to opt_NoQuickReturn_IntegerTheory" << std::endl;);
+ } else {
return false;
}
- if (!check_length_consistency(eqc_nn1, eqc_nn2)) {
- TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " have inconsistent lengths" << std::endl;);
- if (opt_NoQuickReturn_IntegerTheory){
- TRACE("t_str_detail", tout << "continuing in new_eq_check() due to opt_NoQuickReturn_IntegerTheory" << std::endl;);
- } else {
- return false;
- }
- }
}
- eqc_iterator2 = eqc_iterator2->get_next();
-
- } while (eqc_iterator2 != eqc_root);
-
- eqc_iterator1 = eqc_iterator1->get_next();
- } while (eqc_iterator1 != eqc_root);
-
+ eqc_nn2 = get_eqc_next(eqc_nn2);
+ } while (eqc_nn2 != rhs);
+ eqc_nn1 = get_eqc_next(eqc_nn1);
+ } while (eqc_nn1 != lhs);
if (!contains_map.empty()) {
check_contain_in_new_eq(lhs, rhs);
@@ -2327,7 +2311,6 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
infer_len_concat_equality(nn1, nn2);
- // TODO we may want to add no-quick-return options for these as well
if (a1_arg0 == a2_arg0) {
if (!in_same_eqc(a1_arg1, a2_arg1)) {
expr_ref premise(ctx.mk_eq_atom(nn1, nn2), m);
@@ -2354,8 +2337,6 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
// quick path
- // TODO we may want to add no-quick-return options for these as well
-
if (in_same_eqc(a1_arg0, a2_arg0)) {
if (in_same_eqc(a1_arg1, a2_arg1)) {
TRACE("t_str_detail", tout << "SKIP: a1_arg0 =~ a2_arg0 and a1_arg1 =~ a2_arg1" << std::endl;);
@@ -4846,9 +4827,8 @@ void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
ast_manager & m = get_manager();
TRACE("t_str_detail", tout << "consistency check for contains wrt. " << mk_pp(n1, m) << " and " << mk_pp(n2, m) << std::endl;);
- // Modification from Z3str2: the EQC of n1 and n2 *are* now merged.
- // So we don't have to do anything too special
- // to prepare willEqClass any more, we just use the EQC from n1 / n2.
+ // Modification from Z3str2: if we use the merged EQC directly from the context,
+ // we don't have to do anything special to merge n1/n2's EQCs.
expr_ref_vector willEqClass(m);
expr * constStrAst = collect_eq_nodes(n1, willEqClass);
@@ -6257,9 +6237,6 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
simplify_parent(lhs, nn2_value);
}
- // regex unroll
- // TODO NEXT check EQC semantics here too
-
expr * nn1EqConst = NULL;
std::set<expr*> nn1EqUnrollFuncs;
get_eqc_allUnroll(lhs, nn1EqConst, nn1EqUnrollFuncs);
From ec9e1686f75d5171983f821c1a3e44312c7a9f19 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 15:32:49 -0400
Subject: [PATCH 211/401] fix semantics of collect_eq_nodes and simplify_parent
---
src/smt/theory_str.cpp | 78 ++++++++++--------------------------------
1 file changed, 18 insertions(+), 60 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 1238eb069..3727e15e1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1785,18 +1785,16 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
<< " with respect to " << mk_ismt2_pp(eq_str, m) << std::endl;);
ctx.internalize(nn, false);
- enode * n_eq_enode = ctx.get_enode(nn);
- enode * nn_enode = n_eq_enode;
std::string eq_strValue = m_strutil.get_string_constant_value(eq_str);
-
+ app * n_eqNode = nn;
do {
- app * n_eqNode = n_eq_enode->get_owner();
+ enode * n_eq_enode = ctx.get_enode(n_eqNode);
TRACE("t_str_detail", tout << "considering all parents of " << mk_ismt2_pp(n_eqNode, m) << std::endl
<< "associated n_eq_enode has " << n_eq_enode->get_num_parents() << " parents" << std::endl;);
// the goal of this next bit is to avoid dereferencing a bogus e_parent in the following loop.
- // what I image is causing this bug is that, for example, we examine some parent, we add an axiom that involves it,
+ // what I imagine is causing this bug is that, for example, we examine some parent, we add an axiom that involves it,
// and the parent_it iterator becomes invalidated, because we indirectly modified the container that we're iterating over.
enode_vector current_parents;
@@ -2068,8 +2066,8 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
// check next EQC member
- n_eq_enode = n_eq_enode->get_next();
- } while (n_eq_enode != nn_enode);
+ n_eqNode = get_eqc_next(n_eqNode);
+ } while (n_eqNode != nn);
}
expr * theory_str::simplify_concat(expr * node) {
@@ -4158,45 +4156,6 @@ bool theory_str::get_len_value(expr* e, rational& val) {
return val.is_int();
}
-/*
- * Look through the equivalence class of n to find an integer constant.
- * Return that constant if it is found. Otherwise, return -1.
- * Note that a return value of -1 should not normally be possible, as
- * string length cannot be negative.
- */
-
-/*
-rational theory_str::get_len_value(expr * x) {
- ast_manager & m = get_manager();
- context & ctx = get_context();
- ctx.internalize(x, false);
- expr * n = mk_strlen(x);
- ctx.internalize(n, false);
-
- TRACE("t_str_detail", tout << "checking eqc of " << mk_ismt2_pp(n, m) << " for an integer constant" << std::endl;);
-
- enode * nNode = ctx.get_enode(n);
- enode * eqcNode = nNode;
- do {
- app * ast = eqcNode->get_owner();
- rational val;
- bool is_int;
- TRACE("t_str_detail", tout << "eqc member: " << mk_ismt2_pp(ast, m) << std::endl;);
- if (m_autil.is_numeral(ast, val, is_int)) {
- if (is_int) {
- TRACE("t_str_detail", tout << "eqc contains integer constant " << val << std::endl;);
- SASSERT(!val.is_neg());
- return val;
- }
- }
- eqcNode = eqcNode->get_next();
- } while (eqcNode != nNode);
- // not found
- TRACE("t_str_detail", tout << "eqc contains no integer constants" << std::endl;);
- return rational(-1);
-}
-*/
-
/*
* Decide whether n1 and n2 are already in the same equivalence class.
* This only checks whether the core considers them to be equal;
@@ -4241,17 +4200,15 @@ expr * theory_str::collect_eq_nodes(expr * n, expr_ref_vector & eqcSet) {
context & ctx = get_context();
expr * constStrNode = NULL;
- enode * e_base = ctx.get_enode(n);
- enode * e_curr = e_base;
+ app * ex = n;
do {
- app * ex = e_curr->get_owner();
if (m_strutil.is_string(ex)) {
constStrNode = ex;
}
eqcSet.push_back(ex);
- e_curr = e_curr->get_next();
- } while (e_curr != e_base);
+ ex = get_eqc_next(ex);
+ } while (ex != n);
return constStrNode;
}
@@ -4827,10 +4784,10 @@ void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
ast_manager & m = get_manager();
TRACE("t_str_detail", tout << "consistency check for contains wrt. " << mk_pp(n1, m) << " and " << mk_pp(n2, m) << std::endl;);
- // Modification from Z3str2: if we use the merged EQC directly from the context,
- // we don't have to do anything special to merge n1/n2's EQCs.
expr_ref_vector willEqClass(m);
- expr * constStrAst = collect_eq_nodes(n1, willEqClass);
+ expr * constStrAst_1 = collect_eq_nodes(n1, willEqClass);
+ expr * constStrAst_2 = collect_eq_nodes(n2, willEqClass);
+ expr * constStrAst = (constStrAst_1 != NULL) ? constStrAst_1 : constStrAst_2;
TRACE("t_str_detail", tout << "eqc of n1 is {";
for (expr_ref_vector::iterator it = willEqClass.begin(); it != willEqClass.end(); ++it) {
@@ -5582,10 +5539,8 @@ bool theory_str::check_concat_len_in_eqc(expr * concat) {
bool no_assertions = true;
- enode * eqc_base = ctx.get_enode(concat);
- enode * eqc_it = eqc_base;
+ app * eqc_n = concat;
do {
- app * eqc_n = eqc_it->get_owner();
if (is_concat(eqc_n)) {
rational unused;
bool status = infer_len_concat(eqc_n, unused);
@@ -5593,8 +5548,8 @@ bool theory_str::check_concat_len_in_eqc(expr * concat) {
no_assertions = false;
}
}
- eqc_it = eqc_it->get_next();
- } while (eqc_it != eqc_base);
+ eqc_n = get_eqc_next(eqc_n);
+ } while (eqc_n != concat);
return no_assertions;
}
@@ -5604,7 +5559,10 @@ void theory_str::check_regex_in(expr * nn1, expr * nn2) {
ast_manager & m = get_manager();
expr_ref_vector eqNodeSet(m);
- expr * constStr = collect_eq_nodes(nn1, eqNodeSet);
+
+ expr * constStr_1 = collect_eq_nodes(nn1, eqNodeSet);
+ expr * constStr_2 = collect_eq_nodes(nn2, eqNodeSet);
+ expr * constStr = (constStr_1 != NULL) ? constStr_1 : constStr_2;
if (constStr == NULL) {
return;
From 87d61d6d6ed4a685df7d0364e5f37f1297d54175 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 15:35:37 -0400
Subject: [PATCH 212/401] fix semantics of in_same_eqc
---
src/smt/theory_str.cpp | 17 ++++-------------
1 file changed, 4 insertions(+), 13 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3727e15e1..ce5aabb6c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4178,22 +4178,13 @@ bool theory_str::in_same_eqc(expr * n1, expr * n2) {
ctx.internalize(n2, false);
}
- enode * n1Node = ctx.get_enode(n1);
- enode * n2Node = ctx.get_enode(n2);
-
- // here's what the old Z3str2 would have done; we can do something much better
- /*
- n1Node->get_root();
- enode * curr = n1Node->get_next();
- while (curr != n1Node) {
- if (curr == n2Node) {
+ expr * curr = get_eqc_next(n1);
+ while (curr != n1) {
+ if (curr == n2)
return true;
- }
- curr = curr->get_next();
+ curr = get_eqc_next(curr);
}
return false;
- */
- return n1Node->get_root() == n2Node->get_root();
}
expr * theory_str::collect_eq_nodes(expr * n, expr_ref_vector & eqcSet) {
From 50353168ef008a87bc38d37de305bfdfe43627e1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 15:36:36 -0400
Subject: [PATCH 213/401] fix semantics of get_concats_in_eqc and
get_var_in_eqc
---
src/smt/theory_str.cpp | 8 ++------
1 file changed, 2 insertions(+), 6 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ce5aabb6c..a773e0d6d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -8649,9 +8649,7 @@ void theory_str::get_concats_in_eqc(expr * n, std::set<expr*> & concats) {
if (is_concat(to_app(eqcNode))) {
concats.insert(eqcNode);
}
- enode * e_eqc = ctx.get_enode(eqcNode);
- eqcNode = e_eqc->get_next()->get_owner();
- // eqcNode = Z3_theory_get_eqc_next(t, eqcNode);
+ eqcNode = get_eqc_next(eqcNode);
} while (eqcNode != n);
}
@@ -8663,9 +8661,7 @@ void theory_str::get_var_in_eqc(expr * n, std::set<expr*> & varSet) {
if (variable_set.find(eqcNode) != variable_set.end()) {
varSet.insert(eqcNode);
}
- enode * e_eqc = ctx.get_enode(eqcNode);
- eqcNode = e_eqc->get_next()->get_owner();
- // eqcNode = Z3_theory_get_eqc_next(t, eqcNode);
+ eqcNode = get_eqc_next(eqcNode);
} while (eqcNode != n);
}
From 804009a75754864c26e19adffdefc0d31c4016cd Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 15:37:48 -0400
Subject: [PATCH 214/401] use z3str2 eqc semantics for get_eqc_value
---
src/smt/theory_str.cpp | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a773e0d6d..c3c8a50cf 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3967,6 +3967,7 @@ void theory_str::unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr) {
* Return that constant if it is found, and set hasEqcValue to true.
* Otherwise, return n, and set hasEqcValue to false.
*/
+/*
expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
context & ctx = get_context();
// I hope this works
@@ -3985,6 +3986,12 @@ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
hasEqcValue = false;
return n;
}
+*/
+
+expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
+ return z3str2_get_eqc_value(n, hasEqcValue);
+}
+
// Simulate the behaviour of get_eqc_value() from Z3str2.
// We only check m_find for a string constant.
From e46fc7b0b68b30f952ab3681a841e7a53e55cc92 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 15:51:33 -0400
Subject: [PATCH 215/401] fix expr-app conversion
---
src/smt/theory_str.cpp | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index c3c8a50cf..14d30d4a6 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1787,7 +1787,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
ctx.internalize(nn, false);
std::string eq_strValue = m_strutil.get_string_constant_value(eq_str);
- app * n_eqNode = nn;
+ expr * n_eqNode = nn;
do {
enode * n_eq_enode = ctx.get_enode(n_eqNode);
TRACE("t_str_detail", tout << "considering all parents of " << mk_ismt2_pp(n_eqNode, m) << std::endl
@@ -1872,7 +1872,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
assert_implication(implyL, implyR);
}
- } else if (is_concat(n_eqNode)) {
+ } else if (is_concat(to_app(n_eqNode))) {
expr_ref simpleConcat(m);
simpleConcat = mk_concat(eq_str, arg1);
if (!in_same_eqc(a_parent, simpleConcat)) {
@@ -1943,7 +1943,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
assert_implication(implyL, implyR);
}
- } else if (is_concat(n_eqNode)) {
+ } else if (is_concat(to_app(n_eqNode))) {
expr_ref simpleConcat(m);
simpleConcat = mk_concat(arg0, eq_str);
if (!in_same_eqc(a_parent, simpleConcat)) {
@@ -4198,9 +4198,9 @@ expr * theory_str::collect_eq_nodes(expr * n, expr_ref_vector & eqcSet) {
context & ctx = get_context();
expr * constStrNode = NULL;
- app * ex = n;
+ expr * ex = n;
do {
- if (m_strutil.is_string(ex)) {
+ if (m_strutil.is_string(to_app(ex))) {
constStrNode = ex;
}
eqcSet.push_back(ex);
@@ -5537,9 +5537,9 @@ bool theory_str::check_concat_len_in_eqc(expr * concat) {
bool no_assertions = true;
- app * eqc_n = concat;
+ expr * eqc_n = concat;
do {
- if (is_concat(eqc_n)) {
+ if (is_concat(to_app(eqc_n))) {
rational unused;
bool status = infer_len_concat(eqc_n, unused);
if (status) {
From a294c145dc0a4c55e5c89a6b5573ca8c1f84795a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 16:18:03 -0400
Subject: [PATCH 216/401] add theory_str::try_eval_concat to work around
rewriter behaviour this fixes a regression in concat-013.smt2
---
src/smt/theory_str.cpp | 62 +++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 2 ++
2 files changed, 63 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 14d30d4a6..3687dc9b7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -762,7 +762,7 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
}
bool theory_str::can_propagate() {
- return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty()
+ return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty() || !m_concat_eval_todo.empty()
|| !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty() || !m_axiom_EndsWith_todo.empty()
|| !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty() || !m_axiom_LastIndexof_todo.empty()
|| !m_axiom_Substr_todo.empty() || !m_axiom_Replace_todo.empty()
@@ -794,6 +794,11 @@ void theory_str::propagate() {
}
m_concat_axiom_todo.reset();
+ for (unsigned i = 0; i < m_concat_eval_todo.size(); ++i) {
+ try_eval_concat(m_concat_eval_todo[i]);
+ }
+ m_concat_eval_todo.reset();
+
for (unsigned i = 0; i < m_axiom_CharAt_todo.size(); ++i) {
instantiate_axiom_CharAt(m_axiom_CharAt_todo[i]);
}
@@ -853,6 +858,58 @@ void theory_str::propagate() {
}
}
+/*
+ * Attempt to evaluate a concat over constant strings,
+ * and if this is possible, assert equality between the
+ * flattened string and the original term.
+ */
+
+void theory_str::try_eval_concat(enode * cat) {
+ SASSERT(is_concat(cat));
+ app * a_cat = cat->get_owner();
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ TRACE("t_str_detail", tout << "attempting to flatten " << mk_pp(a_cat, m) << std::endl;);
+
+ std::stack<app*> worklist;
+ std::string flattenedString("");
+ bool constOK = true;
+
+ {
+ app * arg0 = to_app(a_cat->get_arg(0));
+ app * arg1 = to_app(a_cat->get_arg(1));
+
+ worklist.push(arg1);
+ worklist.push(arg0);
+ }
+
+ while (constOK && !worklist.empty()) {
+ app * evalArg = worklist.top(); worklist.pop();
+ if (m_strutil.is_string(evalArg)) {
+ std::string nextStr = m_strutil.get_string_constant_value(evalArg);
+ flattenedString.append(nextStr);
+ } else if (is_concat(evalArg)) {
+ app * arg0 = to_app(evalArg->get_arg(0));
+ app * arg1 = to_app(evalArg->get_arg(1));
+
+ worklist.push(arg1);
+ worklist.push(arg0);
+ } else {
+ TRACE("t_str_detail", tout << "non-constant term in concat -- giving up." << std::endl;);
+ constOK = false;
+ break;
+ }
+ }
+ if (constOK) {
+ TRACE("t_str_detail", tout << "flattened to \"" << flattenedString << "\"" << std::endl;);
+ expr_ref constStr(m_strutil.mk_string(flattenedString), m);
+ expr_ref axiom(ctx.mk_eq_atom(a_cat, constStr), m);
+ assert_axiom(axiom);
+ }
+}
+
/*
* Instantiate an axiom of the following form:
* Length(Concat(x, y)) = Length(x) + Length(y)
@@ -6240,6 +6297,9 @@ void theory_str::set_up_axioms(expr * ex) {
if (is_concat(ap)) {
// if ex is a concat, set up concat axioms later
m_concat_axiom_todo.push_back(n);
+ // we also want to check whether we can eval this concat,
+ // in case the rewriter did not totally finish with this term
+ m_concat_eval_todo.push_back(n);
} else if (is_strlen(ap)) {
// if the argument is a variable,
// keep track of this for later, we'll need it during model gen
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 58b104209..745d22ac2 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -184,6 +184,7 @@ namespace smt {
svector<std::pair<enode*,enode*> > m_str_eq_todo;
ptr_vector<enode> m_concat_axiom_todo;
ptr_vector<enode> m_string_constant_length_todo;
+ ptr_vector<enode> m_concat_eval_todo;
// enode lists for term-specific axioms
// TODO maybe refactor this into a generic "library_aware_axiom_todo" list
@@ -332,6 +333,7 @@ namespace smt {
bool is_Unroll(enode const * n) const { return is_Unroll(n->get_owner()); }
void instantiate_concat_axiom(enode * cat);
+ void try_eval_concat(enode * cat);
void instantiate_basic_string_axioms(enode * str);
void instantiate_str_eq_length_axiom(enode * lhs, enode * rhs);
From 9ee7326a19fd46cb0aa61719558c941c5e560051 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 17:26:52 -0400
Subject: [PATCH 217/401] tweaks to process_concat_eq_type_3
---
src/smt/theory_str.cpp | 63 +++++++++++++++++++++---------------------
1 file changed, 32 insertions(+), 31 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3687dc9b7..27c12b267 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3393,10 +3393,10 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
expr_ref suf_n_concat(mk_concat(suffixAst, n), mgr);
if (can_two_nodes_eq(x, prefixAst) && can_two_nodes_eq(y, suf_n_concat)) {
- expr ** r_items = alloc_svect(expr*, 2);
- r_items[0] = ctx.mk_eq_atom(x, prefixAst);
- r_items[1] = ctx.mk_eq_atom(y, suf_n_concat);
- assert_implication(ax_l, mgr.mk_and(2, r_items));
+ expr_ref_vector r_items(mgr);
+ r_items.push_back(ctx.mk_eq_atom(x, prefixAst));
+ r_items.push_back(ctx.mk_eq_atom(y, suf_n_concat));
+ assert_implication(ax_l, mk_and(r_items));
} else {
// negate! It's impossible to split str with these lengths
TRACE("t_str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
@@ -3433,11 +3433,11 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
if (can_two_nodes_eq(x, str_temp1)) {
if (!avoidLoopCut || !(has_self_cut(x, n))) {
- expr ** r_items = alloc_svect(expr*, 3);
- r_items[0] = ctx.mk_eq_atom(x, str_temp1);
- r_items[1] = ctx.mk_eq_atom(n, temp1_y);
- r_items[2] = ctx.mk_eq_atom(mk_strlen(temp1), mk_int(tmpLen));
- expr_ref ax_r(mgr.mk_and(3, r_items), mgr);
+ expr_ref_vector r_items(mgr);
+ r_items.push_back(ctx.mk_eq_atom(x, str_temp1));
+ r_items.push_back(ctx.mk_eq_atom(n, temp1_y));
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(tmpLen)));
+ expr_ref ax_r(mk_and(r_items), mgr);
//Cut Info
add_cut_info_merge(temp1, sLevel, x);
@@ -3460,9 +3460,9 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
// Split type -1. We know nothing about the length...
int optionTotal = 2 + strValue.length();
- expr ** or_item = alloc_svect(expr*, optionTotal);
- int option = 0;
- expr ** and_item = alloc_svect(expr*, (2 + 4 * optionTotal));
+ expr_ref_vector or_item(mgr);
+ unsigned option = 0;
+ expr_ref_vector and_item(mgr);
int pos = 1;
for (int i = 0; i <= (int) strValue.size(); i++) {
std::string part1Str = strValue.substr(0, i);
@@ -3474,11 +3474,11 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
if (can_two_nodes_eq(x, cropStr) && can_two_nodes_eq(y, y_concat)) {
// break down option 3-1
expr_ref x_eq_str(ctx.mk_eq_atom(x, cropStr), mgr);
- or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], x_eq_str);
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, y_concat));
+ or_item.push_back(ctx.mk_eq_atom(xorFlag, mk_int(option)));
+ and_item.push_back(ctx.mk_eq_atom(or_item.get(option), x_eq_str)); ++pos;
+ and_item.push_back(ctx.mk_eq_atom(or_item.get(option), ctx.mk_eq_atom(y, y_concat)));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x), mk_strlen(cropStr)));
+ and_item.push_back(ctx.mk_eq_atom(or_item.get(option), ctx.mk_eq_atom(mk_strlen(x), mk_strlen(cropStr)))); ++pos;
// and_item[pos++] = Z3_mk_eq(ctx, or_item[option], Z3_mk_eq(ctx, mk_length(t, y), mk_length(t, y_concat)));
// adding length constraint for _ = constStr seems slowing things down.
@@ -3495,18 +3495,18 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
if (can_two_nodes_eq(x, strAst_temp1)) {
if (!avoidLoopCut || !(has_self_cut(x, n))) {
// break down option 3-2
- or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+ or_item.push_back(ctx.mk_eq_atom(xorFlag, mk_int(option)));
expr_ref temp1_y(mk_concat(temp1, y), mgr);
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(x, strAst_temp1));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(n, temp1_y));
+ and_item.push_back(ctx.mk_eq_atom(or_item.get(option), ctx.mk_eq_atom(x, strAst_temp1))); ++pos;
+ and_item.push_back(ctx.mk_eq_atom(or_item.get(option), ctx.mk_eq_atom(n, temp1_y))); ++pos;
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x),
- m_autil.mk_add(mk_strlen(strAst), mk_strlen(temp1)) ));
+ and_item.push_back(ctx.mk_eq_atom(or_item.get(option), ctx.mk_eq_atom(mk_strlen(x),
+ m_autil.mk_add(mk_strlen(strAst), mk_strlen(temp1)) )) ); ++pos;
option++;
- add_cut_info_merge(temp1, ctx.get_scope_level(), x);
- add_cut_info_merge(temp1, ctx.get_scope_level(), n);
+ add_cut_info_merge(temp1, sLevel, x);
+ add_cut_info_merge(temp1, sLevel, n);
} else {
loopDetected = true;
TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
@@ -3517,11 +3517,11 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
if (option > 0) {
if (option == 1) {
- and_item[0] = or_item[0];
+ and_item.push_back(or_item.get(0));
} else {
- and_item[0] = mgr.mk_or(option, or_item);
+ and_item.push_back(mk_or(or_item));
}
- expr_ref implyR(mgr.mk_and(pos, and_item), mgr);
+ expr_ref implyR(mk_and(and_item), mgr);
assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
} else {
TRACE("t_str", tout << "STOP: should not split two eq. concats" << std::endl;);
@@ -6531,11 +6531,11 @@ void theory_str::check_variable_scope() {
ast_manager & m = get_manager();
expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
- for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
- expr * ex = *i;
- recursive_check_variable_scope(ex);
- }
+ ctx.get_assignments(assignments);
+ for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
+ expr * ex = *i;
+ recursive_check_variable_scope(ex);
+ }
}
void theory_str::pop_scope_eh(unsigned num_scopes) {
@@ -6587,6 +6587,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
}
}
+ // TODO use the trail stack to do this for us! requires lots of refactoring
// TODO if this works, possibly remove axioms from other vectors as well
ptr_vector<enode> new_m_basicstr;
for (ptr_vector<enode>::iterator it = m_basicstr_axiom_todo.begin(); it != m_basicstr_axiom_todo.end(); ++it) {
From f22f4da023fae6347d96167211ad5244c00f8714 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 17:33:47 -0400
Subject: [PATCH 218/401] remove unused variable
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 27c12b267..5ef3518d7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -151,6 +151,7 @@ void theory_str::assert_axiom(expr * e) {
ctx.internalize(e, true);
}
literal lit(ctx.get_literal(e));
+ // TESTING!
ctx.mark_as_relevant(lit);
ctx.mk_th_axiom(get_id(), 1, &lit);
@@ -3459,7 +3460,6 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
else {
// Split type -1. We know nothing about the length...
- int optionTotal = 2 + strValue.length();
expr_ref_vector or_item(mgr);
unsigned option = 0;
expr_ref_vector and_item(mgr);
From d334403720f1da03219307edf2d976e5fdd90121 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 17:42:40 -0400
Subject: [PATCH 219/401] remove relevancy testing experiment
---
src/smt/theory_str.cpp | 1 -
1 file changed, 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 5ef3518d7..6034395fc 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -151,7 +151,6 @@ void theory_str::assert_axiom(expr * e) {
ctx.internalize(e, true);
}
literal lit(ctx.get_literal(e));
- // TESTING!
ctx.mark_as_relevant(lit);
ctx.mk_th_axiom(get_id(), 1, &lit);
From 15055c8041d3244a303f017692d4e86ba383baeb Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 19:01:14 -0400
Subject: [PATCH 220/401] use mk_int_var to make xor terms
---
src/smt/theory_str.cpp | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 6034395fc..34ac58d18 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -32,7 +32,7 @@ theory_str::theory_str(ast_manager & m):
/* Options */
opt_AggressiveLengthTesting(false),
opt_AggressiveValueTesting(false),
- opt_AggressiveUnrollTesting(false),
+ opt_AggressiveUnrollTesting(true),
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
@@ -453,6 +453,7 @@ void theory_str::track_variable_scope(expr * var) {
}
app * theory_str::mk_internal_xor_var() {
+ /*
ast_manager & m = get_manager();
std::stringstream ss;
ss << tmpXorVarCount;
@@ -460,6 +461,7 @@ app * theory_str::mk_internal_xor_var() {
std::string name = "$$_xor_" + ss.str();
// Z3_sort r = of_sort(mk_c(c)->m().mk_sort(mk_c(c)->get_arith_fid(), INT_SORT));
sort * int_sort = m.mk_sort(m_autil.get_family_id(), INT_SORT);
+
char * new_buffer = alloc_svect(char, name.length() + 1);
strcpy(new_buffer, name.c_str());
symbol sym(new_buffer);
@@ -467,6 +469,8 @@ app * theory_str::mk_internal_xor_var() {
app * a = m.mk_const(m.mk_const_decl(sym, int_sort));
m_trail.push_back(a);
return a;
+ */
+ return mk_int_var("$$_xor");
}
app * theory_str::mk_int_var(std::string name) {
From ad7247df51042eba8d509e8d9cd801ae21720e15 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 19:32:14 -0400
Subject: [PATCH 221/401] make calls to theory_str::dump_assignments depend on
the correct trace flags
---
src/smt/theory_str.cpp | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 34ac58d18..dbf5d2f38 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6485,7 +6485,7 @@ void theory_str::push_scope_eh() {
sLevel += 1;
TRACE("t_str", tout << "push to " << sLevel << std::endl;);
- TRACE("t_str_dump_assign_on_scope_change", dump_assignments(););
+ TRACE_CODE(dump_assignments(););
}
void theory_str::recursive_check_variable_scope(expr * ex) {
@@ -6544,7 +6544,7 @@ void theory_str::check_variable_scope() {
void theory_str::pop_scope_eh(unsigned num_scopes) {
sLevel -= num_scopes;
TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
- TRACE("t_str_dump_assign_on_scope_change", dump_assignments(););
+ TRACE_CODE(dump_assignments(););
// list of expr* to remove from cut_var_map
ptr_vector<expr> cutvarmap_removes;
@@ -6615,7 +6615,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
void theory_str::dump_assignments() {
ast_manager & m = get_manager();
context & ctx = get_context();
- TRACE("t_str_detail",
+ TRACE("t_str_dump_assign_on_scope_change",
tout << "dumping all assignments:" << std::endl;
expr_ref_vector assignments(m);
ctx.get_assignments(assignments);
@@ -7503,7 +7503,7 @@ final_check_status theory_str::final_check_eh() {
}
TRACE("t_str", tout << "final check" << std::endl;);
- TRACE("t_str_dump_assign", dump_assignments(););
+ TRACE_CODE(dump_assignments(););
check_variable_scope();
if (opt_DeferEQCConsistencyCheck) {
From bed40c45b80d83ed7ad82ef14ec92f3b8352854b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 21:48:27 -0400
Subject: [PATCH 222/401] cleanup
---
src/smt/theory_str.cpp | 10 ++++++----
src/smt/theory_str.h | 2 ++
2 files changed, 8 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index dbf5d2f38..1dcfb0b29 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2161,6 +2161,7 @@ expr * theory_str::simplify_concat(expr * node) {
if (in_same_eqc(node, resultAst)) {
TRACE("t_str_detail", tout << "SKIP: both concats are already in the same equivalence class" << std::endl;);
} else {
+ // TODO refactor
expr ** items = alloc_svect(expr*, resolvedMap.size());
int pos = 0;
std::map<expr*, expr*>::iterator itor = resolvedMap.begin();
@@ -2459,8 +2460,8 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
}
}
- expr * new_nn1 = simplify_concat(nn1);
- expr * new_nn2 = simplify_concat(nn2);
+ expr_ref new_nn1(simplify_concat(nn1), m);
+ expr_ref new_nn2(simplify_concat(nn2), m);
app * a_new_nn1 = to_app(new_nn1);
app * a_new_nn2 = to_app(new_nn2);
@@ -5466,8 +5467,6 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
items.push_back(ctx.mk_eq_atom(n1, n2));
- expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
-
bool conflict = false;
if (concat1LenFixed && concat2LenFixed) {
@@ -5486,6 +5485,7 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
if (conflict) {
TRACE("t_str_detail", tout << "inconsistent length detected in concat <==> concat" << std::endl;);
+ expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
assert_axiom(toAssert);
return false;
}
@@ -6619,10 +6619,12 @@ void theory_str::dump_assignments() {
tout << "dumping all assignments:" << std::endl;
expr_ref_vector assignments(m);
ctx.get_assignments(assignments);
+ /*
for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
expr * ex = *i;
tout << mk_ismt2_pp(ex, m) << (ctx.is_relevant(ex) ? "" : " (NOT REL)") << std::endl;
}
+ */
);
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 745d22ac2..7af6ab1ca 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -29,6 +29,8 @@ Revision History:
#include"str_rewriter.h"
#include"union_find.h"
+// TODO refactor: anything that returns an expr* instead returns an expr_ref
+
namespace smt {
class str_value_factory : public value_factory {
From 8776b97841c80e476bf18dc32304c6efb5146050 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Sep 2016 22:08:40 -0400
Subject: [PATCH 223/401] variable scope correctness hack in theory_str
---
src/smt/theory_str.cpp | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 1dcfb0b29..d73d55dc3 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6483,6 +6483,12 @@ void theory_str::push_scope_eh() {
theory::push_scope_eh();
m_trail_stack.push_scope();
+ // TODO out-of-scope term debugging, see comment in pop_scope_eh()
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+
sLevel += 1;
TRACE("t_str", tout << "push to " << sLevel << std::endl;);
TRACE_CODE(dump_assignments(););
@@ -6544,6 +6550,12 @@ void theory_str::check_variable_scope() {
void theory_str::pop_scope_eh(unsigned num_scopes) {
sLevel -= num_scopes;
TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
+ // TODO: figure out what's going out of scope and why
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+
TRACE_CODE(dump_assignments(););
// list of expr* to remove from cut_var_map
@@ -7500,6 +7512,10 @@ final_check_status theory_str::final_check_eh() {
context & ctx = get_context();
ast_manager & m = get_manager();
+ // TODO out-of-scope term debugging, see comment in pop_scope_eh()
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+
if (opt_VerifyFinalCheckProgress) {
finalCheckProgressIndicator = false;
}
From e7c0c29ae5675afbac72b38ceab0f6e28b7ef525 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 15 Sep 2016 15:59:56 -0400
Subject: [PATCH 224/401] potentially fix out-of-scope infinite loop bug in
theory_str gen_unroll_conditional_options
---
src/smt/theory_str.cpp | 57 +++++++++++++++++++++++++++++++-----------
1 file changed, 42 insertions(+), 15 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index d73d55dc3..43d14ccf1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -504,6 +504,7 @@ app * theory_str::mk_unroll_bound_var() {
app * theory_str::mk_unroll_test_var() {
app * v = mk_str_var("unrollTest"); // was uRt
internal_unrollTest_vars.insert(v);
+ track_variable_scope(v);
return v;
}
@@ -6595,6 +6596,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
variable_set.erase(*var_it);
internal_variable_set.erase(*var_it);
regex_variable_set.erase(*var_it);
+ internal_unrollTest_vars.erase(*var_it);
count += 1;
}
TRACE("t_str_detail", tout << "cleaned up " << count << " variables" << std::endl;);
@@ -8349,13 +8351,35 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
litems.push_back(item);
}
+ // handle out-of-scope entries in unroll_tries_map
+
+ ptr_vector<expr> outOfScopeTesters;
+ // TODO refactor unroll_tries_map and internal_unrollTest_vars to use m_trail_stack
+
+ for (ptr_vector<expr>::iterator it = unroll_tries_map[var][unrolls].begin();
+ it != unroll_tries_map[var][unrolls].end(); ++it) {
+ expr * tester = *it;
+ bool inScope = (internal_unrollTest_vars.find(tester) != internal_unrollTest_vars.end());
+ TRACE("t_str_detail", tout << "unroll test var " << mk_pp(tester, mgr)
+ << (inScope ? " in scope" : " out of scope")
+ << std::endl;);
+ if (!inScope) {
+ outOfScopeTesters.push_back(tester);
+ }
+ }
+
+ for (ptr_vector<expr>::iterator it = outOfScopeTesters.begin();
+ it != outOfScopeTesters.end(); ++it) {
+ unroll_tries_map[var][unrolls].erase(*it);
+ }
+
+
if (unroll_tries_map[var][unrolls].size() == 0) {
unroll_tries_map[var][unrolls].push_back(mk_unroll_test_var());
}
int tries = unroll_tries_map[var][unrolls].size();
for (int i = 0; i < tries; i++) {
- // TODO possibly missing a scope check here
expr * tester = unroll_tries_map[var][unrolls][i];
bool testerHasValue = false;
expr * testerVal = get_eqc_value(tester, testerHasValue);
@@ -8377,6 +8401,9 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
m_trail.push_back(toAssert);
return toAssert;
+ // note: this is how the code looks in Z3str2's strRegex.cpp:genUnrollConditionalOptions.
+ // the return is in the same place
+
// insert [tester = "more"] to litems so that the implyL for next tester is correct
litems.push_back(ctx.mk_eq_atom(tester, moreAst));
} else {
@@ -8881,21 +8908,21 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
* and constant string in eqc of node n
*/
void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet) {
- constStr = NULL;
- unrollFuncSet.clear();
- context & ctx = get_context();
+ constStr = NULL;
+ unrollFuncSet.clear();
+ context & ctx = get_context();
- expr * curr = n;
- do {
- if (is_string(to_app(curr))) {
- constStr = curr;
- } else if (is_Unroll(to_app(curr))) {
- if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
- unrollFuncSet.insert(curr);
- }
- }
- curr = get_eqc_next(curr);
- } while (curr != n);
+ expr * curr = n;
+ do {
+ if (is_string(to_app(curr))) {
+ constStr = curr;
+ } else if (is_Unroll(to_app(curr))) {
+ if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
+ unrollFuncSet.insert(curr);
+ }
+ }
+ curr = get_eqc_next(curr);
+ } while (curr != n);
}
// Collect simple Unroll functions (whose core is Str2Reg) and constant strings in the EQC of n.
From 91b625768c4ef1c202817e9c1cff66f6c34b2f15 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 15 Sep 2016 17:01:59 -0400
Subject: [PATCH 225/401] fix tracing in theory_str
---
src/smt/theory_str.cpp | 30 ++++++++++++++----------------
1 file changed, 14 insertions(+), 16 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 43d14ccf1..22df46980 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -148,7 +148,7 @@ void theory_str::assert_axiom(expr * e) {
TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
context & ctx = get_context();
if (!ctx.b_internalized(e)) {
- ctx.internalize(e, true);
+ ctx.internalize(e, false);
}
literal lit(ctx.get_literal(e));
ctx.mark_as_relevant(lit);
@@ -6492,7 +6492,7 @@ void theory_str::push_scope_eh() {
sLevel += 1;
TRACE("t_str", tout << "push to " << sLevel << std::endl;);
- TRACE_CODE(dump_assignments(););
+ TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
}
void theory_str::recursive_check_variable_scope(expr * ex) {
@@ -6557,7 +6557,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
expr_ref_vector assignments(m);
ctx.get_assignments(assignments);
- TRACE_CODE(dump_assignments(););
+ TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
// list of expr* to remove from cut_var_map
ptr_vector<expr> cutvarmap_removes;
@@ -6627,18 +6627,16 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
}
void theory_str::dump_assignments() {
- ast_manager & m = get_manager();
- context & ctx = get_context();
- TRACE("t_str_dump_assign_on_scope_change",
- tout << "dumping all assignments:" << std::endl;
- expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
- /*
- for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
- expr * ex = *i;
- tout << mk_ismt2_pp(ex, m) << (ctx.is_relevant(ex) ? "" : " (NOT REL)") << std::endl;
- }
- */
+ TRACE_CODE(
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ tout << "dumping all assignments:" << std::endl;
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+ for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
+ expr * ex = *i;
+ tout << mk_ismt2_pp(ex, m) << (ctx.is_relevant(ex) ? "" : " (NOT REL)") << std::endl;
+ }
);
}
@@ -7523,7 +7521,7 @@ final_check_status theory_str::final_check_eh() {
}
TRACE("t_str", tout << "final check" << std::endl;);
- TRACE_CODE(dump_assignments(););
+ TRACE_CODE(if (is_trace_enabled("t_str_dump_assign")) { dump_assignments(); });
check_variable_scope();
if (opt_DeferEQCConsistencyCheck) {
From c38f63dd2a6ddd2b19e2cd5bb75837ba08128728 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 19 Sep 2016 19:42:16 -0400
Subject: [PATCH 226/401] fix eqc management and unroll test var gen in
theory_str::final_check
---
src/smt/theory_str.cpp | 32 ++++++++++++++------------------
1 file changed, 14 insertions(+), 18 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 22df46980..4ba9aa0ff 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -228,7 +228,7 @@ bool theory_str::internalize_term(app * term) {
mk_var(e);
return true;
}
- TRACE("t_str", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
+ TRACE("t_str_detail", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
unsigned num_args = term->get_num_args();
expr* arg;
for (unsigned i = 0; i < num_args; i++) {
@@ -517,6 +517,9 @@ app * theory_str::mk_str_var(std::string name) {
sort * string_sort = m.mk_sort(get_family_id(), STRING_SORT);
app * a = m.mk_fresh_const(name.c_str(), string_sort);
+ TRACE("t_str_detail", tout << "a->get_family_id() = " << a->get_family_id() << std::endl
+ << "this->get_family_id() = " << this->get_family_id() << std::endl;);
+
// I have a hunch that this may not get internalized for free...
ctx.internalize(a, false);
SASSERT(ctx.get_enode(a) != NULL);
@@ -6584,6 +6587,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
}
}
+ /*
// see if any internal variables went out of scope
for (int check_level = sLevel + num_scopes ; check_level > sLevel; --check_level) {
TRACE("t_str_detail", tout << "cleaning up internal variables at scope level " << check_level << std::endl;);
@@ -6603,6 +6607,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
vars.clear();
}
}
+ */
// TODO use the trail stack to do this for us! requires lots of refactoring
// TODO if this works, possibly remove axioms from other vectors as well
@@ -6623,7 +6628,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
m_trail_stack.pop_scope(num_scopes);
theory::pop_scope_eh(num_scopes);
- check_variable_scope();
+ //check_variable_scope();
}
void theory_str::dump_assignments() {
@@ -6648,7 +6653,8 @@ void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap
// note that internal variables don't count if they're only length tester / value tester vars.
if (variable_set.find(node) != variable_set.end()
&& internal_lenTest_vars.find(node) == internal_lenTest_vars.end()
- && internal_valTest_vars.find(node) == internal_valTest_vars.end()) {
+ && internal_valTest_vars.find(node) == internal_valTest_vars.end()
+ && internal_unrollTest_vars.find(node) == internal_unrollTest_vars.end()) {
if (varMap[node] != 1) {
TRACE("t_str_detail", tout << "new variable: " << mk_pp(node, get_manager()) << std::endl;);
}
@@ -6988,10 +6994,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
aliasIndexMap[curr] = aRoot;
}
}
- // curr = get_eqc_next(curr);
- enode * eqcNode = ctx.get_enode(curr);
- eqcNode = eqcNode->get_next();
- curr = eqcNode->get_owner();
+ curr = get_eqc_next(curr);
} while (curr != varItor->first);
}
@@ -7017,8 +7020,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
// e.g. z = unroll(...) ::= var_eq_unroll[z][unroll(...)] = 1
if (var_eq_concat_map.find(deAliasNode) == var_eq_concat_map.end()) {
- enode * e_curr = ctx.get_enode(deAliasNode);
- expr * curr = e_curr->get_next()->get_owner();
+ expr * curr = get_eqc_next(deAliasNode);
while (curr != deAliasNode) {
app * aCurr = to_app(curr);
// collect concat
@@ -7055,9 +7057,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
var_eq_unroll_map[deAliasNode][curr] = 1;
}
- // curr = get_eqc_next(curr)
- e_curr = ctx.get_enode(curr);
- curr = e_curr->get_next()->get_owner();
+ curr = get_eqc_next(curr);
}
}
@@ -7086,9 +7086,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
concats_eq_index_map[curr] = aRoot;
}
}
- // curr = get_eqc_next(curr);
- enode * e_curr = ctx.get_enode(curr);
- curr = e_curr->get_next()->get_owner();
+ curr = get_eqc_next(curr);
} while (curr != concatItor->first);
}
@@ -7121,9 +7119,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
concat_eq_concat_map[deAliasConcat][curr] = 1;
}
}
- // curr = get_eqc_next(curr);
- enode * e_curr = ctx.get_enode(curr);
- curr = e_curr->get_next()->get_owner();
+ curr = get_eqc_next(curr);
} while (curr != deAliasConcat);
}
}
From 9615b191dedc90f2ca939ff21e23a5e07333620b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 19 Sep 2016 23:40:17 -0400
Subject: [PATCH 227/401] theory_str hacking for theory var stuff WIP
---
src/smt/smt_context.cpp | 6 +++++
src/smt/theory_str.cpp | 53 +++++++++++++++++++++++++++++++++++++++--
src/smt/theory_str.h | 3 +++
3 files changed, 60 insertions(+), 2 deletions(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 251cf3b9b..c712135d3 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -1691,6 +1691,12 @@ namespace smt {
for (unsigned i = 0; i < m_th_eq_propagation_queue.size() && !inconsistent(); i++) {
new_th_eq curr = m_th_eq_propagation_queue[i];
theory * th = get_theory(curr.m_th_id);
+ TRACE("t_str_eq_bug", tout
+ << "th->name = " << th->get_name() << std::endl
+ << "m_th_id = " << curr.m_th_id << std::endl
+ << "m_lhs = " << curr.m_lhs << std::endl
+ << "m_rhs = " << curr.m_rhs << std::endl
+ << std::endl;);
SASSERT(th);
th->new_eq_eh(curr.m_lhs, curr.m_rhs);
#ifdef Z3DEBUG
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 4ba9aa0ff..8cd7c227c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -200,6 +200,43 @@ bool theory_str::internalize_term(app * term) {
ast_manager & m = get_manager();
SASSERT(term->get_family_id() == get_family_id());
+ TRACE("t_str_detail", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
+
+ // emulation of user_smt_theory::internalize_term()
+
+ unsigned num_args = term->get_num_args();
+ for (unsigned i = 0; i < num_args; ++i) {
+ ctx.internalize(term->get_arg(i), false);
+ }
+ if (ctx.e_internalized(term)) {
+ enode * e = ctx.get_enode(term);
+ mk_var(e);
+ return true;
+ }
+ // m_parents.push_back(term);
+ enode * e = ctx.mk_enode(term, false, m.is_bool(term), true);
+ if (m.is_bool(term)) {
+ bool_var bv = ctx.mk_bool_var(term);
+ ctx.set_var_theory(bv, get_id());
+ ctx.set_enode_flag(bv, true);
+ }
+ // make sure every argument is attached to a theory variable
+ for (unsigned i = 0; i < num_args; ++i) {
+ enode * arg = e->get_arg(i);
+ theory_var v_arg = mk_var(arg);
+ TRACE("t_str_detail", tout << "arg has theory var #" << v_arg << std::endl;);
+ }
+
+ theory_var v = mk_var(e);
+ TRACE("t_str_detail", tout << "term has theory var #" << v << std::endl;);
+
+ if (opt_EagerStringConstantLengthAssertions && m_strutil.is_string(term)) {
+ TRACE("t_str", tout << "eagerly asserting length of string term " << mk_pp(term, m) << std::endl;);
+ m_basicstr_axiom_todo.insert(e);
+ TRACE("t_str_axiom_bug", tout << "add " << mk_pp(e->get_owner(), m) << " to m_basicstr_axiom_todo" << std::endl;);
+ }
+ return true;
+
/* // what I had before
SASSERT(!ctx.e_internalized(term));
@@ -223,6 +260,7 @@ bool theory_str::internalize_term(app * term) {
// TODO do we still need to do instantiate_concat_axiom()?
// partially from theory_seq::internalize_term()
+ /*
if (ctx.e_internalized(term)) {
enode* e = ctx.get_enode(term);
mk_var(e);
@@ -259,6 +297,7 @@ bool theory_str::internalize_term(app * term) {
TRACE("t_str_detail", tout << "term " << mk_ismt2_pp(term, get_manager()) << " = v#" << v << std::endl;);
return true;
+ */
}
enode* theory_str::ensure_enode(expr* e) {
@@ -271,7 +310,14 @@ enode* theory_str::ensure_enode(expr* e) {
return n;
}
+void theory_str::refresh_theory_var(expr * e) {
+ enode * en = ensure_enode(e);
+ theory_var v = mk_var(en);
+ TRACE("t_str_detail", tout << "refresh " << mk_pp(e, get_manager()) << ": v#" << v << std::endl;);
+}
+
theory_var theory_str::mk_var(enode* n) {
+ TRACE("t_str_detail", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;);
/*
if (!m_strutil.is_string(n->get_owner())) {
return null_theory_var;
@@ -283,11 +329,12 @@ theory_var theory_str::mk_var(enode* n) {
return null_theory_var;
}
if (is_attached_to_var(n)) {
+ TRACE("t_str_detail", tout << "already attached to theory var" << std::endl;);
return n->get_th_var(get_id());
- }
- else {
+ } else {
theory_var v = theory::mk_var(n);
m_find.mk_var();
+ TRACE("t_str_detail", tout << "new theory var v#" << v << std::endl;);
get_context().attach_th_var(n, this, v);
get_context().mark_as_relevant(n);
return v;
@@ -8375,6 +8422,8 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
int tries = unroll_tries_map[var][unrolls].size();
for (int i = 0; i < tries; i++) {
expr * tester = unroll_tries_map[var][unrolls][i];
+ // TESTING
+ refresh_theory_var(tester);
bool testerHasValue = false;
expr * testerVal = get_eqc_value(tester, testerHasValue);
if (!testerHasValue) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 7af6ab1ca..85209c631 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -487,6 +487,9 @@ namespace smt {
void check_variable_scope();
void recursive_check_variable_scope(expr * ex);
+ // TESTING
+ void refresh_theory_var(expr * e);
+
public:
theory_str(ast_manager & m);
virtual ~theory_str();
From f1d7ffcdced6635717911f18c57d46b2af0c69bf Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 20 Sep 2016 00:14:38 -0400
Subject: [PATCH 228/401] fix regression regex-020
---
src/smt/theory_str.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 8cd7c227c..44a4b0d7c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -7641,9 +7641,9 @@ final_check_status theory_str::final_check_eh() {
get_eqc_value(*it, has_eqc_value);
if (!has_eqc_value) {
// if this is an internal variable, it can be ignored...I think
- if (internal_variable_set.find(*it) != internal_variable_set.end()) {
+ if (internal_variable_set.find(*it) != internal_variable_set.end() || regex_variable_set.find(*it) != regex_variable_set.end()) {
TRACE("t_str_detail", tout << "WARNING: free internal variable " << mk_ismt2_pp(*it, m) << std::endl;);
- unused_internal_variables.insert(*it);
+ //unused_internal_variables.insert(*it);
} else {
needToAssignFreeVars = true;
free_variables.insert(*it);
From 447c6e4ce362a71f2c2b31f1a1eff7a2a4b91213 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 20 Sep 2016 00:28:29 -0400
Subject: [PATCH 229/401] refresh length tester in
theory_str::gen_len_val_options_for_free_var fixes charAt-007.smt2
---
src/smt/theory_str.cpp | 1 +
1 file changed, 1 insertion(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 44a4b0d7c..9f0975609 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -8786,6 +8786,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
} else {
// TODO make absolutely sure this is safe to do if 'indicator' is technically out of scope
indicator = fvar_lenTester_map[freeVar][i];
+ refresh_theory_var(indicator);
testNum = i + 1;
}
expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
From 48eaa6159cc06f0935d78fe16916c9b147ee79d9 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 20 Sep 2016 01:10:27 -0400
Subject: [PATCH 230/401] disable aggressive unroll testing in theory_str, it
may be doing more harm than good
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 9f0975609..b2e0e70ba 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -32,7 +32,7 @@ theory_str::theory_str(ast_manager & m):
/* Options */
opt_AggressiveLengthTesting(false),
opt_AggressiveValueTesting(false),
- opt_AggressiveUnrollTesting(true),
+ opt_AggressiveUnrollTesting(false),
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
From feef85c129aca77b1f160851681a61042c9f5a66 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 20 Sep 2016 15:37:29 -0400
Subject: [PATCH 231/401] override scope check in
theory_str::solve_concat_eq_str
fixes indexof2-009.smt2
---
src/smt/theory_str.cpp | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b2e0e70ba..798e16e7c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -5973,24 +5973,40 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
bool entry1InScope;
if (entry1 == varForBreakConcat.end()) {
+ TRACE("t_str_detail", tout << "key1 no entry" << std::endl;);
entry1InScope = false;
} else {
+ // OVERRIDE.
+ entry1InScope = true;
+ TRACE("t_str_detail", tout << "key1 entry" << std::endl;);
+ /*
if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()) {
+ TRACE("t_str_detail", tout << "key1 entry not in scope" << std::endl;);
entry1InScope = false;
} else {
+ TRACE("t_str_detail", tout << "key1 entry in scope" << std::endl;);
entry1InScope = true;
}
+ */
}
bool entry2InScope;
if (entry2 == varForBreakConcat.end()) {
+ TRACE("t_str_detail", tout << "key2 no entry" << std::endl;);
entry2InScope = false;
} else {
+ // OVERRIDE.
+ entry2InScope = true;
+ TRACE("t_str_detail", tout << "key2 entry" << std::endl;);
+ /*
if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()) {
+ TRACE("t_str_detail", tout << "key2 entry not in scope" << std::endl;);
entry2InScope = false;
} else {
+ TRACE("t_str_detail", tout << "key2 entry in scope" << std::endl;);
entry2InScope = true;
}
+ */
}
TRACE("t_str_detail", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
From 4433417b6ebdf34384e46462fbe5c2f647437200 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 20 Sep 2016 16:25:28 -0400
Subject: [PATCH 232/401] faster push_scope in theory_str
---
src/smt/theory_str.cpp | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 798e16e7c..59db86212 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -32,7 +32,7 @@ theory_str::theory_str(ast_manager & m):
/* Options */
opt_AggressiveLengthTesting(false),
opt_AggressiveValueTesting(false),
- opt_AggressiveUnrollTesting(false),
+ opt_AggressiveUnrollTesting(true),
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
@@ -6551,10 +6551,12 @@ void theory_str::push_scope_eh() {
m_trail_stack.push_scope();
// TODO out-of-scope term debugging, see comment in pop_scope_eh()
+ /*
context & ctx = get_context();
ast_manager & m = get_manager();
expr_ref_vector assignments(m);
ctx.get_assignments(assignments);
+ */
sLevel += 1;
TRACE("t_str", tout << "push to " << sLevel << std::endl;);
From 1061cdf58ab4f3a95675fc13530df3b1aa259136 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 22 Sep 2016 15:40:43 -0400
Subject: [PATCH 233/401] fix value tester theory var reuse in theory_str fixes
release regression in charAt-007
---
src/smt/theory_str.cpp | 2 ++
1 file changed, 2 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 59db86212..ab6a9f229 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -8131,6 +8131,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
if (!anEqcHasValue) {
TRACE("t_str_detail", tout << "value tester " << mk_ismt2_pp(aTester, m)
<< " doesn't have an equivalence class value." << std::endl;);
+ refresh_theory_var(aTester);
expr * makeupAssert = gen_val_options(freeVar, len_indicator, aTester, len_valueStr, i);
@@ -8147,6 +8148,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
expr * valTester = NULL;
if (i + 1 < testerTotal) {
valTester = fvar_valueTester_map[freeVar][len][i + 1].second;
+ refresh_theory_var(valTester);
} else {
valTester = mk_internal_valTest_var(freeVar, len, i + 1);
valueTester_fvar_map[valTester] = freeVar;
From dc8062ba6727e59dc789ba1a4e27c2fe48eecbb5 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 22 Sep 2016 20:14:42 -0400
Subject: [PATCH 234/401] patch out contains check for substr reduction fixes
all regressions in release build, we may want to revisit this later
---
src/smt/theory_str.cpp | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ab6a9f229..23b2af0fb 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1496,7 +1496,8 @@ void theory_str::instantiate_axiom_Substr(enode * e) {
expr_ref ts0_contains_ts1(mk_contains(expr->get_arg(0), ts1), m);
expr_ref_vector and_item(m);
- and_item.push_back(ts0_contains_ts1);
+ // TODO simulate this contains check; it causes problems with a few regressions but we might need it for performance
+ //and_item.push_back(ts0_contains_ts1);
and_item.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, mk_concat(ts1, ts2))));
and_item.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_strlen(ts0)));
and_item.push_back(ctx.mk_eq_atom(expr->get_arg(2), mk_strlen(ts1)));
From ce53b368647c27176d87aa20b97414b7cc7eddf4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 14 Oct 2016 12:34:11 -0400
Subject: [PATCH 235/401] theory_str API started
---
src/api/api_ast.cpp | 16 ++++++++
src/api/api_context.cpp | 2 +
src/api/api_context.h | 6 +++
src/api/api_str.cpp | 80 +++++++++++++++++++++++++++++++++++++
src/api/z3_api.h | 57 ++++++++++++++++++++++++++
src/ast/str_decl_plugin.cpp | 1 +
src/ast/str_decl_plugin.h | 5 +++
7 files changed, 167 insertions(+)
create mode 100644 src/api/api_str.cpp
diff --git a/src/api/api_ast.cpp b/src/api/api_ast.cpp
index 1f16b2d35..7774efcd9 100644
--- a/src/api/api_ast.cpp
+++ b/src/api/api_ast.cpp
@@ -647,6 +647,12 @@ extern "C" {
else if (fid == mk_c(c)->get_seq_fid() && k == RE_SORT) {
return Z3_RE_SORT;
}
+ else if (fid == mk_c(c)->get_str_fid() && k == STRING_SORT) {
+ return Z3_STRING_SORT;
+ }
+ else if (fid == mk_c(c)->get_str_fid() && k == REGEX_SORT) {
+ return Z3_REGEX_SORT;
+ }
else {
return Z3_UNKNOWN_SORT;
}
@@ -1139,6 +1145,16 @@ extern "C" {
}
}
+ if (mk_c(c)->get_str_fid() == _d->get_family_id()) {
+ switch (_d->get_decl_kind()) {
+ // TODO(z3str2) add others
+ case OP_STRCAT: return Z3_OP_STR_CONCAT;
+ case OP_STRLEN: return Z3_OP_STR_LENGTH;
+ default:
+ return Z3_OP_UNINTERPRETED;
+ }
+ }
+
if (mk_c(c)->get_fpa_fid() == _d->get_family_id()) {
switch (_d->get_decl_kind()) {
case OP_FPA_RM_NEAREST_TIES_TO_EVEN: return Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN;
diff --git a/src/api/api_context.cpp b/src/api/api_context.cpp
index bc48874a7..8fbb02598 100644
--- a/src/api/api_context.cpp
+++ b/src/api/api_context.cpp
@@ -74,6 +74,7 @@ namespace api {
m_fpa_util(m()),
m_dtutil(m()),
m_sutil(m()),
+ m_strutil(m()),
m_last_result(m()),
m_ast_trail(m()),
m_pmanager(m_limit) {
@@ -98,6 +99,7 @@ namespace api {
m_datalog_fid = m().mk_family_id("datalog_relation");
m_fpa_fid = m().mk_family_id("fpa");
m_seq_fid = m().mk_family_id("seq");
+ m_str_fid = m().mk_family_id("str");
m_dt_plugin = static_cast<datatype_decl_plugin*>(m().get_plugin(m_dt_fid));
install_tactics(*this);
diff --git a/src/api/api_context.h b/src/api/api_context.h
index fa6754120..0f2104a2b 100644
--- a/src/api/api_context.h
+++ b/src/api/api_context.h
@@ -26,6 +26,7 @@ Revision History:
#include"arith_decl_plugin.h"
#include"bv_decl_plugin.h"
#include"seq_decl_plugin.h"
+#include"str_decl_plugin.h"
#include"datatype_decl_plugin.h"
#include"dl_decl_plugin.h"
#include"fpa_decl_plugin.h"
@@ -61,6 +62,8 @@ namespace api {
datatype_util m_dtutil;
seq_util m_sutil;
+ str_util m_strutil;
+
// Support for old solver API
smt_params m_fparams;
// -------------------------------
@@ -79,6 +82,7 @@ namespace api {
family_id m_pb_fid;
family_id m_fpa_fid;
family_id m_seq_fid;
+ family_id m_str_fid;
datatype_decl_plugin * m_dt_plugin;
std::string m_string_buffer; // temporary buffer used to cache strings sent to the "external" world.
@@ -123,6 +127,7 @@ namespace api {
fpa_util & fpautil() { return m_fpa_util; }
datatype_util& dtutil() { return m_dtutil; }
seq_util& sutil() { return m_sutil; }
+ str_util& strutil() { return m_strutil; }
family_id get_basic_fid() const { return m_basic_fid; }
family_id get_array_fid() const { return m_array_fid; }
family_id get_arith_fid() const { return m_arith_fid; }
@@ -132,6 +137,7 @@ namespace api {
family_id get_pb_fid() const { return m_pb_fid; }
family_id get_fpa_fid() const { return m_fpa_fid; }
family_id get_seq_fid() const { return m_seq_fid; }
+ family_id get_str_fid() const { return m_str_fid; }
datatype_decl_plugin * get_dt_plugin() const { return m_dt_plugin; }
Z3_error_code get_error_code() const { return m_error_code; }
diff --git a/src/api/api_str.cpp b/src/api/api_str.cpp
new file mode 100644
index 000000000..a42600f2f
--- /dev/null
+++ b/src/api/api_str.cpp
@@ -0,0 +1,80 @@
+/*++
+Copyright (c) 2016 Microsoft Corporation
+
+Module Name:
+
+ api_str.cpp
+
+Abstract:
+
+ API for strings and regular expressions (Z3str2 implementation).
+
+Author:
+
+ Murphy Berzish (mtrberzi) 2016-10-03.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_util.h"
+#include"ast_pp.h"
+
+extern "C" {
+
+ Z3_sort Z3_API Z3_mk_str_sort(Z3_context c) {
+ Z3_TRY;
+ LOG_Z3_mk_str_sort(c);
+ RESET_ERROR_CODE();
+ sort * ty = mk_c(c)->strutil().mk_string_sort();
+ mk_c(c)->save_ast_trail(ty);
+ RETURN_Z3(of_sort(ty));
+ Z3_CATCH_RETURN(0);
+ }
+
+ Z3_bool Z3_API Z3_is_str_sort(Z3_context c, Z3_sort s) {
+ Z3_TRY;
+ LOG_Z3_is_str_sort(c, s);
+ RESET_ERROR_CODE();
+ bool result = mk_c(c)->strutil().is_str_sort(to_sort(s));
+ return result?Z3_TRUE:Z3_FALSE;
+ Z3_CATCH_RETURN(Z3_FALSE);
+ }
+
+ Z3_bool Z3_API Z3_is_str(Z3_context c, Z3_ast s) {
+ Z3_TRY;
+ LOG_Z3_is_str(c, s);
+ RESET_ERROR_CODE();
+ bool result = mk_c(c)->strutil().is_string(to_expr(s));
+ return result ? Z3_TRUE : Z3_FALSE;
+ Z3_CATCH_RETURN(Z3_FALSE);
+ }
+
+ Z3_string Z3_API Z3_get_str(Z3_context c, Z3_ast s) {
+ Z3_TRY;
+ LOG_Z3_get_str(c, s);
+ RESET_ERROR_CODE();
+ if (!mk_c(c)->strutil().is_string(to_expr(s))) {
+ SET_ERROR_CODE(Z3_INVALID_ARG);
+ return "";
+ }
+ std::string result = mk_c(c)->strutil().get_string_constant_value(to_expr(s));
+ return mk_c(c)->mk_external_string(result);
+ Z3_CATCH_RETURN("");
+ }
+
+ Z3_ast Z3_API Z3_mk_str(Z3_context c, Z3_string str) {
+ Z3_TRY;
+ LOG_Z3_mk_str(c, str);
+ RESET_ERROR_CODE();
+ std::string s(str);
+ app * a = mk_c(c)->strutil().mk_string(str);
+ mk_c(c)->save_ast_trail(a);
+ RETURN_Z3(of_ast(a));
+ Z3_CATCH_RETURN(0);
+ }
+
+};
diff --git a/src/api/z3_api.h b/src/api/z3_api.h
index 114490015..7afba979e 100644
--- a/src/api/z3_api.h
+++ b/src/api/z3_api.h
@@ -165,6 +165,8 @@ typedef enum
Z3_ROUNDING_MODE_SORT,
Z3_SEQ_SORT,
Z3_RE_SORT,
+ Z3_STRING_SORT,
+ Z3_REGEX_SORT,
Z3_UNKNOWN_SORT = 1000
} Z3_sort_kind;
@@ -1150,6 +1152,10 @@ typedef enum {
Z3_OP_RE_CONCAT,
Z3_OP_RE_UNION,
+ // theory_str
+ Z3_OP_STR_CONCAT,
+ Z3_OP_STR_LENGTH,
+
// Auxiliary
Z3_OP_LABEL = 0x700,
Z3_OP_LABEL_LIT,
@@ -3145,6 +3151,57 @@ extern "C" {
/*@}*/
+ /** @name Strings and regular expressions (Z3str2 implementation) */
+ /*@{*/
+
+ /**
+ \brief Create a string sort for 8-bit ASCII strings.
+
+ This function creates a sort for ASCII strings.
+ Each character is 8 bits.
+
+ def_API('Z3_mk_str_sort', SORT, (_in(CONTEXT), ))
+ */
+ Z3_sort Z3_API Z3_mk_str_sort(Z3_context c);
+
+ /**
+ \brief Check if \c s is a string sort.
+
+ def_API('Z3_is_str_sort', BOOL, (_in(CONTEXT), _in(SORT)))
+ */
+
+ Z3_bool Z3_API Z3_is_str_sort(Z3_context c, Z3_sort s);
+
+ /**
+ \brief Determine if \c s is a string constant.
+
+ def_API('Z3_is_str', BOOL, (_in(CONTEXT), _in(AST)))
+ */
+
+ Z3_bool Z3_API Z3_is_str(Z3_context c, Z3_ast s);
+
+ /**
+ \brief Retrieve the string constant stored in \c s.
+
+ \pre Z3_is_str(c, s)
+
+ def_API('Z3_get_str', STRING, (_in(CONTEXT), _in(AST)))
+ */
+
+ Z3_string Z3_API Z3_get_str(Z3_context c, Z3_ast s);
+
+ /**
+ \brief Create a string constant.
+
+ \param c logical context.
+ \param str The ASCII representation of the string constant.
+
+ def_API('Z3_mk_str', AST, (_in(CONTEXT), _in(STRING)))
+ */
+ Z3_ast Z3_API Z3_mk_str(Z3_context c, Z3_string str);
+
+ /*@}*/
+
/** @name Sequences and regular expressions */
/*@{*/
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 08358d46b..aa12e5946 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -322,4 +322,5 @@ str_util::str_util(ast_manager &m) :
m_manager(m) {
SASSERT(m.has_plugin(symbol("str")));
m_plugin = static_cast<str_decl_plugin*>(m.get_plugin(m.mk_family_id(symbol("str"))));
+ m_fid = m_plugin->get_family_id();
}
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 5b0ca2a3a..aa8204459 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -120,6 +120,8 @@ public:
family_id get_fid() const { return m_afid; }
family_id get_family_id() const { return get_fid(); }
+ bool is_str_sort(sort* s) const { return is_sort_of(s, m_afid, STRING_SORT); }
+
bool is_string(expr const * n, const char ** val) const;
bool is_string(expr const * n) const;
@@ -135,11 +137,14 @@ public:
class str_util : public str_recognizers {
ast_manager & m_manager;
str_decl_plugin * m_plugin;
+ family_id m_fid;
public:
str_util(ast_manager & m);
ast_manager & get_manager() const { return m_manager; }
str_decl_plugin & plugin() { return *m_plugin; }
+ sort* mk_string_sort() const { return get_manager().mk_sort(m_fid, STRING_SORT, 0, 0); }
+
app * mk_string(const char * val) {
return m_plugin->mk_string(val);
}
From d57c92f69e14db91d460e32b1430acf8c428adc2 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 20 Oct 2016 12:25:52 -0400
Subject: [PATCH 236/401] theory_str api: concat, length
---
src/api/api_str.cpp | 3 +++
src/api/z3_api.h | 13 +++++++++++++
2 files changed, 16 insertions(+)
diff --git a/src/api/api_str.cpp b/src/api/api_str.cpp
index a42600f2f..e28c6a501 100644
--- a/src/api/api_str.cpp
+++ b/src/api/api_str.cpp
@@ -77,4 +77,7 @@ extern "C" {
Z3_CATCH_RETURN(0);
}
+ MK_BINARY(Z3_mk_str_concat, mk_c(c)->get_str_fid(), OP_STRCAT, SKIP);
+ MK_UNARY(Z3_mk_str_length, mk_c(c)->get_str_fid(), OP_STRLEN, SKIP);
+
};
diff --git a/src/api/z3_api.h b/src/api/z3_api.h
index 7afba979e..c938678d6 100644
--- a/src/api/z3_api.h
+++ b/src/api/z3_api.h
@@ -3200,6 +3200,19 @@ extern "C" {
*/
Z3_ast Z3_API Z3_mk_str(Z3_context c, Z3_string str);
+ /**
+ \brief Create a string concatenation term.
+ def_API('Z3_mk_str_concat', AST, (_in(CONTEXT), _in(AST), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_str_concat(Z3_context c, Z3_ast s1, Z3_ast s2);
+
+ /**
+ \brief Create a string length term. (Integer representation)
+ def_API('Z3_mk_str_length', AST, (_in(CONTEXT), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_str_length(Z3_context c, Z3_ast s);
+
+
/*@}*/
/** @name Sequences and regular expressions */
From 05dfa5509a0263f48a29e33bf2ebc24a9590b472 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 20 Oct 2016 15:36:54 -0400
Subject: [PATCH 237/401] theory_str high-level and regex API
---
src/api/api_str.cpp | 78 +++++++++++++++++++++++++++++++++++++++++
src/api/z3_api.h | 84 +++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 162 insertions(+)
diff --git a/src/api/api_str.cpp b/src/api/api_str.cpp
index e28c6a501..1a1debb5b 100644
--- a/src/api/api_str.cpp
+++ b/src/api/api_str.cpp
@@ -79,5 +79,83 @@ extern "C" {
MK_BINARY(Z3_mk_str_concat, mk_c(c)->get_str_fid(), OP_STRCAT, SKIP);
MK_UNARY(Z3_mk_str_length, mk_c(c)->get_str_fid(), OP_STRLEN, SKIP);
+ MK_BINARY(Z3_mk_str_at, mk_c(c)->get_str_fid(), OP_STR_CHARAT, SKIP);
+ // translate prefixof/suffixof to StartsWith/EndsWith
+ // TODO string standardization might just remove StartsWith/EndsWith in future
+ Z3_ast Z3_API Z3_mk_str_prefixof(Z3_context c, Z3_ast pre, Z3_ast full) {
+ LOG_Z3_mk_str_prefixof(c, pre, full);
+ Z3_TRY;
+ RESET_ERROR_CODE();
+ expr * args[2] = { to_expr(full), to_expr(pre) }; // reverse args
+ ast * a = mk_c(c)->m().mk_app(mk_c(c)->get_str_fid(), OP_STR_STARTSWITH, 0, 0, 2, args);
+ mk_c(c)->save_ast_trail(a);
+ check_sorts(c, a);
+ RETURN_Z3(of_ast(a));
+ Z3_CATCH_RETURN(0);
+ }
+ Z3_ast Z3_API Z3_mk_str_suffixof(Z3_context c, Z3_ast suf, Z3_ast full) {
+ LOG_Z3_mk_str_suffixof(c, suf, full);
+ Z3_TRY;
+ RESET_ERROR_CODE();
+ expr * args[2] = { to_expr(full), to_expr(suf) }; // reverse args
+ ast * a = mk_c(c)->m().mk_app(mk_c(c)->get_str_fid(), OP_STR_ENDSWITH, 0, 0, 2, args);
+ mk_c(c)->save_ast_trail(a);
+ check_sorts(c, a);
+ RETURN_Z3(of_ast(a));
+ Z3_CATCH_RETURN(0);
+ }
+
+ MK_BINARY(Z3_mk_str_contains, mk_c(c)->get_str_fid(), OP_STR_CONTAINS, SKIP);
+ MK_TERNARY(Z3_mk_str_indexof, mk_c(c)->get_str_fid(), OP_STR_INDEXOF, SKIP);
+ MK_TERNARY(Z3_mk_str_substr, mk_c(c)->get_str_fid(), OP_STR_SUBSTR, SKIP);
+ MK_TERNARY(Z3_mk_str_replace, mk_c(c)->get_str_fid(), OP_STR_REPLACE, SKIP);
+
+ Z3_ast Z3_API Z3_mk_str_to_regex(Z3_context c, Z3_string str) {
+ LOG_Z3_mk_str_to_regex(c, str);
+ Z3_TRY;
+ RESET_ERROR_CODE();
+ std::string s(str);
+ app * a = mk_c(c)->strutil().mk_string(str);
+ mk_c(c)->save_ast_trail(a);
+
+ expr * args[1] = { to_expr(a) };
+ ast * re = mk_c(c)->m().mk_app(mk_c(c)->get_str_fid(), OP_RE_STR2REGEX, 0, 0, 1, args);
+ mk_c(c)->save_ast_trail(re);
+ check_sorts(c, re);
+ RETURN_Z3(of_ast(re));
+ Z3_CATCH_RETURN(0);
+ }
+
+ MK_BINARY(Z3_mk_str_in_regex, mk_c(c)->get_str_fid(), OP_RE_REGEXIN, SKIP);
+ MK_BINARY(Z3_mk_regex_concat, mk_c(c)->get_str_fid(), OP_RE_REGEXCONCAT, SKIP);
+ MK_BINARY(Z3_mk_regex_union, mk_c(c)->get_str_fid(), OP_RE_REGEXUNION, SKIP);
+ MK_UNARY(Z3_mk_regex_star, mk_c(c)->get_str_fid(), OP_RE_REGEXSTAR, SKIP);
+ MK_UNARY(Z3_mk_regex_plus, mk_c(c)->get_str_fid(), OP_RE_REGEXPLUS, SKIP);
+
+ Z3_ast Z3_API Z3_mk_regex_range(Z3_context c, Z3_string start, Z3_string end) {
+ LOG_Z3_mk_regex_range(c, start, end);
+ Z3_TRY;
+ RESET_ERROR_CODE();
+
+ std::string cStart(start);
+ std::string cEnd(end);
+ if(cStart.length() != 1 || cEnd.length() != 1) {
+ SET_ERROR_CODE(Z3_INVALID_ARG);
+ return 0;
+ }
+
+ app * a1 = mk_c(c)->strutil().mk_string(cStart);
+ mk_c(c)->save_ast_trail(a1);
+ app * a2 = mk_c(c)->strutil().mk_string(cEnd);
+ mk_c(c)->save_ast_trail(a2);
+
+ expr * args[2] = { to_expr(a1), to_expr(a2) };
+ ast * range = mk_c(c)->m().mk_app(mk_c(c)->get_str_fid(), OP_RE_REGEXCHARRANGE, 0, 0, 2, args);
+ mk_c(c)->save_ast_trail(range);
+ check_sorts(c, range);
+ RETURN_Z3(of_ast(range));
+
+ Z3_CATCH_RETURN(0);
+ }
};
diff --git a/src/api/z3_api.h b/src/api/z3_api.h
index c938678d6..7494bcb17 100644
--- a/src/api/z3_api.h
+++ b/src/api/z3_api.h
@@ -3212,6 +3212,90 @@ extern "C" {
*/
Z3_ast Z3_API Z3_mk_str_length(Z3_context c, Z3_ast s);
+ /**
+ \brief Create 'character at index' term.
+ def_API('Z3_mk_str_at', AST, (_in(CONTEXT), _in(AST), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_str_at(Z3_context c, Z3_ast s, Z3_ast idx);
+
+ /**
+ \brief Create 'str.prefixof' term.
+ def_API('Z3_mk_str_prefixof', AST, (_in(CONTEXT), _in(AST), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_str_prefixof(Z3_context c, Z3_ast pre, Z3_ast full);
+
+ /**
+ \brief Create 'str.suffixof' term.
+ def_API('Z3_mk_str_suffixof', AST, (_in(CONTEXT), _in(AST), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_str_suffixof(Z3_context c, Z3_ast suf, Z3_ast full);
+
+ /**
+ \brief Create 'str.contains' term.
+ def_API('Z3_mk_str_contains', AST, (_in(CONTEXT), _in(AST), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_str_contains(Z3_context c, Z3_ast needle, Z3_ast haystack);
+
+ /**
+ \brief Create 'str.indexof' term.
+ def_API('Z3_mk_str_indexof', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_str_indexof(Z3_context c, Z3_ast haystack, Z3_ast needle, Z3_ast start);
+
+ /**
+ \brief Create 'str.substr' term.
+ def_API('Z3_mk_str_substr', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_str_substr(Z3_context c, Z3_ast s, Z3_ast start, Z3_ast count);
+
+ /**
+ \brief Create 'str.replace' term.
+ def_API('Z3_mk_str_replace', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_str_replace(Z3_context c, Z3_ast base, Z3_ast target, Z3_ast replacement);
+
+
+ /**
+ \brief Create a regular expression that matches the given string constant.
+ def_API('Z3_mk_str_to_regex', AST, (_in(CONTEXT), _in(STRING)))
+ */
+ Z3_ast Z3_API Z3_mk_str_to_regex(Z3_context c, Z3_string str);
+
+ /**
+ \brief Create a regular expression membership predicate.
+ def_API('Z3_mk_str_in_regex', AST, (_in(CONTEXT), _in(AST), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_str_in_regex(Z3_context c, Z3_ast str, Z3_ast regex);
+
+ /**
+ \brief Create a regex concatenation term.
+ def_API('Z3_mk_regex_concat', AST, (_in(CONTEXT), _in(AST), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_regex_concat(Z3_context c, Z3_ast r1, Z3_ast r2);
+
+ /**
+ \brief Create a regex union term.
+ def_API('Z3_mk_regex_union', AST, (_in(CONTEXT), _in(AST), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_regex_union(Z3_context c, Z3_ast r1, Z3_ast r2);
+
+ /**
+ \brief Create a regex Kleene star term.
+ def_API('Z3_mk_regex_star', AST, (_in(CONTEXT), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_regex_star(Z3_context c, Z3_ast r);
+
+ /**
+ \brief Create a regex plus term.
+ def_API('Z3_mk_regex_plus', AST, (_in(CONTEXT), _in(AST)))
+ */
+ Z3_ast Z3_API Z3_mk_regex_plus(Z3_context c, Z3_ast r);
+
+ /**
+ \brief Create a regex character range term.
+ def_API('Z3_mk_regex_range', AST, (_in(CONTEXT), _in(STRING), _in(STRING)))
+ */
+ Z3_ast Z3_API Z3_mk_regex_range(Z3_context c, Z3_string start, Z3_string end);
/*@}*/
From ef0f6f1de346ddac51a5ff1bb114120312bde0f1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 20 Oct 2016 16:01:51 -0400
Subject: [PATCH 238/401] add str.to-int in theory_str WIP
---
src/ast/rewriter/str_rewriter.cpp | 39 +++++++++++++++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
src/ast/str_decl_plugin.cpp | 7 ++++++
src/ast/str_decl_plugin.h | 3 +++
4 files changed, 50 insertions(+)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 015898a64..db3885f28 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -25,6 +25,7 @@ Notes:
#include<map>
#include<set>
#include<deque>
+#include<cctype>
// Convert a regular expression to an e-NFA using Thompson's construction
void nfa::convert_re(expr * e, unsigned & start, unsigned & end, str_util & m_strutil) {
@@ -374,6 +375,41 @@ br_status str_rewriter::mk_str_Replace(expr * base, expr * source, expr * target
}
}
+br_status str_rewriter::mk_str_to_int(expr * arg0, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (str.to-int " << mk_pp(arg0, m()) << ")" << std::endl;);
+
+ if (m_strutil.is_string(arg0)) {
+ std::string str = m_strutil.get_string_constant_value(arg0);
+ if (str.length() == 0) {
+ result = m_autil.mk_numeral(rational::zero(), true);
+ return BR_DONE;
+ }
+
+ // interpret str as a natural number and rewrite to the corresponding integer.
+ // if this is not valid, rewrite to -1
+ // TODO leading zeroes?
+ rational convertedRepresentation(0);
+ rational ten(10);
+ for (unsigned i = 0; i < str.length(); ++i) {
+ char digit = str.at(i);
+ if (isdigit((int)digit)) {
+ std::string sDigit(1, digit);
+ int val = atoi(sDigit.c_str());
+ convertedRepresentation = (ten * convertedRepresentation) + rational(val);
+ } else {
+ // not a digit, invalid
+ TRACE("t_str_rw", tout << "str.to-int argument contains non-digit character '" << digit << "'" << std::endl;);
+ convertedRepresentation = rational::minus_one();
+ break;
+ }
+ }
+ result = m_autil.mk_numeral(convertedRepresentation, true);
+ return BR_DONE;
+ }
+ return BR_FAILED;
+
+}
+
br_status str_rewriter::mk_str_Substr(expr * base, expr * start, expr * len, expr_ref & result) {
TRACE("t_str_rw", tout << "rewrite (Substr " << mk_pp(base, m()) << " " << mk_pp(start, m()) << " " << mk_pp(len, m()) << ")" << std::endl;);
rational startVal, lenVal;
@@ -520,6 +556,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_REPLACE:
SASSERT(num_args == 3);
return mk_str_Replace(args[0], args[1], args[2], result);
+ case OP_STR_STR2INT:
+ SASSERT(num_args == 1);
+ return mk_str_to_int(args[0], result);
case OP_STR_SUBSTR:
SASSERT(num_args == 3);
return mk_str_Substr(args[0], args[1], args[2], result);
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index d147e82e8..10898eae7 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -53,6 +53,7 @@ public:
br_status mk_str_LastIndexof(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_Replace(expr * base, expr * source, expr * target, expr_ref & result);
br_status mk_str_Substr(expr * base, expr * start, expr * len, expr_ref & result);
+ br_status mk_str_to_int(expr * arg0, expr_ref & result);
br_status mk_re_Str2Reg(expr * str, expr_ref & result);
br_status mk_re_RegexIn(expr * str, expr * re, expr_ref & result);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index aa12e5946..e8455ffbd 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -36,6 +36,7 @@ str_decl_plugin::str_decl_plugin():
m_lastindexof_decl(0),
m_substr_decl(0),
m_replace_decl(0),
+ m_str2int_decl(0),
m_re_str2regex_decl(0),
m_re_regexin_decl(0),
m_re_regexconcat_decl(0),
@@ -67,6 +68,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_lastindexof_decl);
DEC_REF(m_substr_decl);
DEC_REF(m_replace_decl);
+ DEC_REF(m_str2int_decl);
DEC_REF(m_re_str2regex_decl);
DEC_REF(m_re_regexin_decl);
DEC_REF(m_re_regexconcat_decl);
@@ -145,6 +147,9 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_manager->inc_ref(m_replace_decl);
}
+ m_str2int_decl = m->mk_func_decl(symbol("str.to-int"), s, i, func_decl_info(id, OP_STR_STR2INT));
+ m_manager->inc_ref(m_str2int_decl);
+
m_re_str2regex_decl = m->mk_func_decl(symbol("Str2Reg"), s, re, func_decl_info(id, OP_RE_STR2REGEX));
m_manager->inc_ref(m_re_str2regex_decl);
@@ -196,6 +201,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STR_LASTINDEXOF: return m_lastindexof_decl;
case OP_STR_SUBSTR: return m_substr_decl;
case OP_STR_REPLACE: return m_replace_decl;
+ case OP_STR_STR2INT: return m_str2int_decl;
case OP_RE_STR2REGEX: return m_re_str2regex_decl;
case OP_RE_REGEXIN: return m_re_regexin_decl;
case OP_RE_REGEXCONCAT: return m_re_regexconcat_decl;
@@ -269,6 +275,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("LastIndexof", OP_STR_LASTINDEXOF));
op_names.push_back(builtin_name("Substring", OP_STR_SUBSTR));
op_names.push_back(builtin_name("Replace", OP_STR_REPLACE));
+ op_names.push_back(builtin_name("str.to-int", OP_STR_STR2INT));
op_names.push_back(builtin_name("Str2Reg", OP_RE_STR2REGEX));
op_names.push_back(builtin_name("RegexIn", OP_RE_REGEXIN));
op_names.push_back(builtin_name("RegexConcat", OP_RE_REGEXCONCAT));
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index aa8204459..ba2b4f751 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -41,6 +41,8 @@ enum str_op_kind {
OP_STR_LASTINDEXOF,
OP_STR_SUBSTR,
OP_STR_REPLACE,
+ // string-integer conversion
+ OP_STR_STR2INT,
// regular expression operators
OP_RE_STR2REGEX,
OP_RE_REGEXIN,
@@ -73,6 +75,7 @@ protected:
func_decl * m_lastindexof_decl;
func_decl * m_substr_decl;
func_decl * m_replace_decl;
+ func_decl * m_str2int_decl;
func_decl * m_re_str2regex_decl;
func_decl * m_re_regexin_decl;
From b06b9f9264ec75c3dcbe324d666e0dc3e61193fd Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 21 Oct 2016 13:35:35 -0400
Subject: [PATCH 239/401] str.to-int WIP
---
src/smt/theory_str.cpp | 120 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 12 +++++
2 files changed, 131 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 23b2af0fb..ffaf098f7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -55,6 +55,7 @@ theory_str::theory_str(ast_manager & m):
avoidLoopCut(true),
loopDetected(false),
contains_map(m),
+ string_int_conversion_terms(m),
m_find(*this),
m_trail_stack(*this)
{
@@ -821,7 +822,7 @@ bool theory_str::can_propagate() {
|| !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty() || !m_axiom_EndsWith_todo.empty()
|| !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty() || !m_axiom_LastIndexof_todo.empty()
|| !m_axiom_Substr_todo.empty() || !m_axiom_Replace_todo.empty()
- || !m_axiom_RegexIn_todo.empty()
+ || !m_axiom_RegexIn_todo.empty() || !m_library_aware_axiom_todo.empty()
|| !m_delayed_axiom_setup_terms.empty();
;
}
@@ -904,6 +905,17 @@ void theory_str::propagate() {
}
m_axiom_RegexIn_todo.reset();
+ for (unsigned i = 0; i < m_library_aware_axiom_todo.size(); ++i) {
+ enode * e = m_library_aware_axiom_todo[i];
+ if (is_str_to_int(e)) {
+ instantiate_axiom_str_to_int(e);
+ } else {
+ TRACE("t_str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_owner(), get_manager()) << std::endl;);
+ NOT_IMPLEMENTED_YET();
+ }
+ }
+ m_library_aware_axiom_todo.reset();
+
for (unsigned i = 0; i < m_delayed_axiom_setup_terms.size(); ++i) {
// I think this is okay
ctx.internalize(m_delayed_axiom_setup_terms[i].get(), false);
@@ -1563,6 +1575,53 @@ void theory_str::instantiate_axiom_Replace(enode * e) {
assert_axiom(finalAxiom);
}
+void theory_str::instantiate_axiom_str_to_int(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * ex = e->get_owner();
+ if (axiomatized_terms.contains(ex)) {
+ TRACE("t_str_detail", tout << "already set up str.to-int axiom for " << mk_pp(ex, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(ex);
+
+ TRACE("t_str_detail", tout << "instantiate str.to-int axiom for " << mk_pp(ex, m) << std::endl;);
+
+ // let expr = (str.to-int S)
+ // axiom 1: expr >= -1
+ // axiom 2: expr = 0 <==> S = "0"
+ // axiom 3: expr >= 1 ==> len(S) > 0 AND S[0] != "0"
+
+ expr * S = ex->get_arg(0);
+ {
+ expr_ref axiom1(m_autil.mk_ge(ex, m_autil.mk_numeral(rational::minus_one(), true)), m);
+ SASSERT(axiom1);
+ assert_axiom(axiom1);
+ }
+
+ {
+ expr_ref lhs(ctx.mk_eq_atom(ex, m_autil.mk_numeral(rational::zero(), true)), m);
+ expr_ref rhs(ctx.mk_eq_atom(S, m_strutil.mk_string("0")), m);
+ expr_ref axiom2(ctx.mk_eq_atom(lhs, rhs), m);
+ SASSERT(axiom2);
+ assert_axiom(axiom2);
+ }
+
+ {
+ expr_ref premise(m_autil.mk_ge(ex, m_autil.mk_numeral(rational::one(), true)), m);
+ expr_ref hd(mk_str_var("hd"), m);
+ expr_ref tl(mk_str_var("tl"), m);
+ expr_ref conclusion1(ctx.mk_eq_atom(S, mk_concat(hd, tl)), m);
+ expr_ref conclusion2(ctx.mk_eq_atom(mk_strlen(hd), m_autil.mk_numeral(rational::one(), true)), m);
+ expr_ref conclusion3(m.mk_not(ctx.mk_eq_atom(hd, m_strutil.mk_string("0"))), m);
+ expr_ref conclusion(m.mk_and(conclusion1, conclusion2, conclusion3), m);
+ SASSERT(premise);
+ SASSERT(conclusion);
+ assert_implication(premise, conclusion);
+ }
+}
+
expr * theory_str::mk_RegexIn(expr * str, expr * regexp) {
expr * args[2] = {str, regexp};
app * regexIn = get_manager().mk_app(get_id(), OP_RE_REGEXIN, 0, 0, 2, args);
@@ -6438,6 +6497,9 @@ void theory_str::set_up_axioms(expr * ex) {
m_axiom_Indexof2_todo.push_back(n);
} else if (is_LastIndexof(ap)) {
m_axiom_LastIndexof_todo.push_back(n);
+ } else if (is_str_to_int(ap)) {
+ string_int_conversion_terms.push_back(ap);
+ m_library_aware_axiom_todo.push_back(n);
}
}
} else {
@@ -7570,6 +7632,42 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
return 0;
}
+// Check agreement between integer and string theories for the term a = (str.to-int S).
+// Returns true if axioms were added, and false otherwise.
+bool theory_str::finalcheck_str2int(app * a) {
+ bool axiomAdd = false;
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr * S = a->get_arg(0);
+
+ // check integer theory
+ rational Ival;
+ bool Ival_exists = get_value(a, Ival);
+ if (Ival_exists) {
+ TRACE("t_str_detail", tout << "integer theory assigns " << mk_pp(a, m) << " = " << Ival.to_string() << std::endl;);
+ // if that value is not -1, we can assert (str.to-int S) = Ival --> S = "Ival"
+ if (!Ival.is_minus_one()) {
+ std::string Ival_str = Ival.to_string();
+ expr_ref premise(ctx.mk_eq_atom(a, m_autil.mk_numeral(Ival, true)), m);
+ expr_ref conclusion(ctx.mk_eq_atom(S, m_strutil.mk_string(Ival_str)), m);
+ expr_ref axiom(m.mk_or(m.mk_not(premise), conclusion), m);
+ if (!string_int_axioms.contains(axiom)) {
+ string_int_axioms.insert(axiom);
+ assert_axiom(axiom);
+ m_trail_stack.push(insert_obj_trail<theory_str, expr>(string_int_axioms, axiom));
+ axiomAdd = true;
+ }
+ }
+ } else {
+ TRACE("t_str_detail", tout << "integer theory has no assignment for " << mk_pp(a, m) << std::endl;);
+ NOT_IMPLEMENTED_YET();
+ }
+ // TODO also check assignment in string theory
+
+ return axiomAdd;
+}
+
final_check_status theory_str::final_check_eh() {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -7671,6 +7769,26 @@ final_check_status theory_str::final_check_eh() {
}
if (!needToAssignFreeVars) {
+
+ // check string-int terms
+ bool addedStrIntAxioms = false;
+ for (unsigned i = 0; i < string_int_conversion_terms.size(); ++i) {
+ app * ex = to_app(string_int_conversion_terms[i].get());
+ if (is_str_to_int(ex)) {
+ bool axiomAdd = finalcheck_str2int(ex);
+ if (axiomAdd) {
+ addedStrIntAxioms = true;
+ }
+ } else {
+ // TODO int.to-str
+ NOT_IMPLEMENTED_YET();
+ }
+ }
+ if (addedStrIntAxioms) {
+ TRACE("t_str", tout << "Resuming search due to addition of string-integer conversion axioms." << std::endl;);
+ return FC_CONTINUE;
+ }
+
if (unused_internal_variables.empty()) {
TRACE("t_str", tout << "All variables are assigned. Done!" << std::endl;);
return FC_DONE;
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 85209c631..5fd2e980b 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -201,6 +201,9 @@ namespace smt {
ptr_vector<enode> m_axiom_Replace_todo;
ptr_vector<enode> m_axiom_RegexIn_todo;
+ // TODO refactor everything to use this worklist
+ ptr_vector<enode> m_library_aware_axiom_todo;
+
// hashtable of all exprs for which we've already set up term-specific axioms --
// this prevents infinite recursive descent with respect to axioms that
// include an occurrence of the term for which axioms are being generated
@@ -260,6 +263,10 @@ namespace smt {
obj_pair_map<expr, expr, expr*> concat_astNode_map;
+ // all (str.to-int) and (int.to-str) terms
+ expr_ref_vector string_int_conversion_terms;
+ obj_hashtable<expr> string_int_axioms;
+
th_union_find m_find;
th_trail_stack m_trail_stack;
theory_var get_var(expr * n) const;
@@ -320,6 +327,8 @@ namespace smt {
bool is_Substr(enode const * n) const { return is_Substr(n->get_owner()); }
bool is_Replace(app const * a) const { return a->is_app_of(get_id(), OP_STR_REPLACE); }
bool is_Replace(enode const * n) const { return is_Replace(n->get_owner()); }
+ bool is_str_to_int(app const * a) const { return a->is_app_of(get_id(), OP_STR_STR2INT); }
+ bool is_str_to_int(enode const * n) const { return is_str_to_int(n->get_owner()); }
bool is_RegexIn(app const * a) const { return a->is_app_of(get_id(), OP_RE_REGEXIN); }
bool is_RegexIn(enode const * n) const { return is_RegexIn(n->get_owner()); }
@@ -348,6 +357,7 @@ namespace smt {
void instantiate_axiom_LastIndexof(enode * e);
void instantiate_axiom_Substr(enode * e);
void instantiate_axiom_Replace(enode * e);
+ void instantiate_axiom_str_to_int(enode * e);
expr * mk_RegexIn(expr * str, expr * regexp);
void instantiate_axiom_RegexIn(enode * e);
@@ -469,6 +479,8 @@ namespace smt {
void get_const_str_asts_in_node(expr * node, expr_ref_vector & constList);
expr * eval_concat(expr * n1, expr * n2);
+ bool finalcheck_str2int(app * a);
+
// strRegex
void get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet);
From 452eed662603e658372712f37250fd3a1bde2832 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 29 Oct 2016 12:19:24 -0400
Subject: [PATCH 240/401] move get_std_regex_str to str_util
---
src/ast/str_decl_plugin.cpp | 43 +++++++++++++++++++++++++++++++++++
src/ast/str_decl_plugin.h | 2 ++
src/smt/theory_str.cpp | 45 +------------------------------------
src/smt/theory_str.h | 1 -
4 files changed, 46 insertions(+), 45 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index e8455ffbd..333ae2a02 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -331,3 +331,46 @@ str_util::str_util(ast_manager &m) :
m_plugin = static_cast<str_decl_plugin*>(m.get_plugin(m.mk_family_id(symbol("str"))));
m_fid = m_plugin->get_family_id();
}
+
+static std::string str2RegexStr(std::string str) {
+ std::string res = "";
+ int len = str.size();
+ for (int i = 0; i < len; i++) {
+ char nc = str[i];
+ // 12 special chars
+ if (nc == '\\' || nc == '^' || nc == '$' || nc == '.' || nc == '|' || nc == '?'
+ || nc == '*' || nc == '+' || nc == '(' || nc == ')' || nc == '[' || nc == '{') {
+ res.append(1, '\\');
+ }
+ res.append(1, str[i]);
+ }
+ return res;
+}
+
+std::string str_util::get_std_regex_str(expr * regex) {
+ app * a_regex = to_app(regex);
+ if (is_re_Str2Reg(a_regex)) {
+ expr * regAst = a_regex->get_arg(0);
+ std::string regStr = str2RegexStr(get_string_constant_value(regAst));
+ return regStr;
+ } else if (is_re_RegexConcat(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ expr * reg2Ast = a_regex->get_arg(1);
+ std::string reg1Str = get_std_regex_str(reg1Ast);
+ std::string reg2Str = get_std_regex_str(reg2Ast);
+ return "(" + reg1Str + ")(" + reg2Str + ")";
+ } else if (is_re_RegexUnion(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ expr * reg2Ast = a_regex->get_arg(1);
+ std::string reg1Str = get_std_regex_str(reg1Ast);
+ std::string reg2Str = get_std_regex_str(reg2Ast);
+ return "(" + reg1Str + ")|(" + reg2Str + ")";
+ } else if (is_re_RegexStar(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ std::string reg1Str = get_std_regex_str(reg1Ast);
+ return "(" + reg1Str + ")*";
+ } else {
+ TRACE("t_str", tout << "BUG: unrecognized regex term " << mk_pp(regex, get_manager()) << std::endl;);
+ UNREACHABLE(); return "";
+ }
+}
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index ba2b4f751..e9ab43865 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -182,6 +182,8 @@ public:
return m_manager.mk_app(get_fid(), OP_RE_REGEXSTAR, 1, es);
}
+ std::string get_std_regex_str(expr * regex);
+
};
#endif /* _STR_DECL_PLUGIN_H_ */
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 23b2af0fb..1050e4a66 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1572,49 +1572,6 @@ expr * theory_str::mk_RegexIn(expr * str, expr * regexp) {
return regexIn;
}
-static std::string str2RegexStr(std::string str) {
- std::string res = "";
- int len = str.size();
- for (int i = 0; i < len; i++) {
- char nc = str[i];
- // 12 special chars
- if (nc == '\\' || nc == '^' || nc == '$' || nc == '.' || nc == '|' || nc == '?'
- || nc == '*' || nc == '+' || nc == '(' || nc == ')' || nc == '[' || nc == '{') {
- res.append(1, '\\');
- }
- res.append(1, str[i]);
- }
- return res;
-}
-
-std::string theory_str::get_std_regex_str(expr * regex) {
- app * a_regex = to_app(regex);
- if (is_Str2Reg(a_regex)) {
- expr * regAst = a_regex->get_arg(0);
- std::string regStr = str2RegexStr(m_strutil.get_string_constant_value(regAst));
- return regStr;
- } else if (is_RegexConcat(a_regex)) {
- expr * reg1Ast = a_regex->get_arg(0);
- expr * reg2Ast = a_regex->get_arg(1);
- std::string reg1Str = get_std_regex_str(reg1Ast);
- std::string reg2Str = get_std_regex_str(reg2Ast);
- return "(" + reg1Str + ")(" + reg2Str + ")";
- } else if (is_RegexUnion(a_regex)) {
- expr * reg1Ast = a_regex->get_arg(0);
- expr * reg2Ast = a_regex->get_arg(1);
- std::string reg1Str = get_std_regex_str(reg1Ast);
- std::string reg2Str = get_std_regex_str(reg2Ast);
- return "(" + reg1Str + ")|(" + reg2Str + ")";
- } else if (is_RegexStar(a_regex)) {
- expr * reg1Ast = a_regex->get_arg(0);
- std::string reg1Str = get_std_regex_str(reg1Ast);
- return "(" + reg1Str + ")*";
- } else {
- TRACE("t_str", tout << "BUG: unrecognized regex term " << mk_pp(regex, get_manager()) << std::endl;);
- UNREACHABLE(); return "";
- }
-}
-
void theory_str::instantiate_axiom_RegexIn(enode * e) {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -1629,7 +1586,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
TRACE("t_str_detail", tout << "instantiate RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
{
- std::string regexStr = get_std_regex_str(ex->get_arg(1));
+ std::string regexStr = m_strutil.get_std_regex_str(ex->get_arg(1));
std::pair<expr*, std::string> key1(ex->get_arg(0), regexStr);
// skip Z3str's map check, because we already check if we set up axioms on this term
regex_in_bool_map[key1] = ex;
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 85209c631..43552f31a 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -478,7 +478,6 @@ namespace smt {
expr * gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, std::string lcmStr);
expr * gen_unroll_assign(expr * var, std::string lcmStr, expr * testerVar, int l, int h);
void reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vector & items);
- std::string get_std_regex_str(expr * regex);
void check_regex_in(expr * nn1, expr * nn2);
void dump_assignments();
From 3da78f9d8015676b36e3869a3f9a665aa29f1d10 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 1 Nov 2016 20:35:01 -0400
Subject: [PATCH 241/401] experimental cached length testers in theory_str
---
src/smt/theory_str.cpp | 24 +++++++++++++++++++++---
src/smt/theory_str.h | 12 ++++++++++++
2 files changed, 33 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 1050e4a66..45b715247 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -40,6 +40,7 @@ theory_str::theory_str(ast_manager & m):
opt_DisableIntegerTheoryIntegration(false),
opt_DeferEQCConsistencyCheck(false),
opt_CheckVariableScope(true),
+ opt_UseFastLengthTesterCache(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -8536,9 +8537,25 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
);
for (int i = l; i < h; ++i) {
- std::string i_str = int_to_string(i);
- expr_ref str_indicator(m_strutil.mk_string(i_str), m);
- expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m); // ARGUMENT 2 IS BOGUS! WRONG SORT
+ expr_ref str_indicator(m);
+ if (opt_UseFastLengthTesterCache) {
+ rational ri(i);
+ expr * lookup_val;
+ if(lengthTesterCache.find(ri, lookup_val)) {
+ str_indicator = expr_ref(lookup_val, m);
+ } else {
+ // no match; create and insert
+ std::string i_str = int_to_string(i);
+ expr_ref new_val(m_strutil.mk_string(i_str), m);
+ lengthTesterCache.insert(ri, new_val);
+ m_trail.push_back(new_val);
+ str_indicator = expr_ref(new_val, m);
+ }
+ } else {
+ std::string i_str = int_to_string(i);
+ expr_ref str_indicator(m_strutil.mk_string(i_str), m);
+ }
+ expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
orList.push_back(or_expr);
if (opt_AggressiveLengthTesting) {
@@ -8551,6 +8568,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
andList.push_back(and_expr);
}
+ // TODO cache mk_string("more")
orList.push_back(m.mk_eq(indicator, m_strutil.mk_string("more")));
if (opt_AggressiveLengthTesting) {
literal l = mk_eq(indicator, m_strutil.mk_string("more"), false);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 43552f31a..9b41c583b 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -88,6 +88,8 @@ namespace smt {
typedef trail_stack<theory_str> th_trail_stack;
typedef union_find<theory_str> th_union_find;
+ typedef map<rational, expr*, obj_hash<rational>, default_eq<rational> > rational_map;
+
protected:
// Some options that control how the solver operates.
@@ -167,6 +169,13 @@ namespace smt {
*/
bool opt_CheckVariableScope;
+ /*
+ * If UseFastLengthTesterCache is set to true,
+ * length tester terms will not be generated from scratch each time they are needed,
+ * but will be saved in a map and looked up.
+ */
+ bool opt_UseFastLengthTesterCache;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -260,6 +269,9 @@ namespace smt {
obj_pair_map<expr, expr, expr*> concat_astNode_map;
+ // used when opt_FastLengthTesterCache is true
+ rational_map lengthTesterCache;
+
th_union_find m_find;
th_trail_stack m_trail_stack;
theory_var get_var(expr * n) const;
From a61e1f17e872075cc784e06de4061a5b24941d5e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 2 Nov 2016 12:35:14 -0400
Subject: [PATCH 242/401] fix crash in gen_len_test_options when fast length
testers are disabled
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 45b715247..5f024dead 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -8553,7 +8553,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
}
} else {
std::string i_str = int_to_string(i);
- expr_ref str_indicator(m_strutil.mk_string(i_str), m);
+ str_indicator = expr_ref(m_strutil.mk_string(i_str), m);
}
expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
orList.push_back(or_expr);
From 3ae336fa6f178aa41403140c98d061a2ea560411 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 2 Nov 2016 13:05:16 -0400
Subject: [PATCH 243/401] add experimental value tester caching to theory_str
---
src/smt/theory_str.cpp | 13 ++++++++++++-
src/smt/theory_str.h | 15 +++++++++++++++
2 files changed, 27 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 5f024dead..c7cbff04e 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -41,6 +41,7 @@ theory_str::theory_str(ast_manager & m):
opt_DeferEQCConsistencyCheck(false),
opt_CheckVariableScope(true),
opt_UseFastLengthTesterCache(true),
+ opt_UseFastValueTesterCache(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -7967,6 +7968,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
ptr_vector<expr> andList;
for (long long i = l; i < h; i++) {
+ // TODO can we share the val_indicator constants with the length tester cache?
orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string(longlong_to_string(i).c_str()) ));
if (opt_AggressiveValueTesting) {
literal l = mk_eq(val_indicator, m_strutil.mk_string(longlong_to_string(i).c_str()), false);
@@ -7975,7 +7977,16 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
}
std::string aStr = gen_val_string(len, options[i - l]);
- expr * strAst = m_strutil.mk_string(aStr);
+ expr * strAst;
+ if (opt_UseFastValueTesterCache) {
+ if (!valueTesterCache.find(aStr, strAst)) {
+ strAst = m_strutil.mk_string(aStr);
+ valueTesterCache.insert(aStr, strAst);
+ m_trail.push_back(strAst);
+ }
+ } else {
+ strAst = m_strutil.mk_string(aStr);
+ }
andList.push_back(m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVar, strAst)));
}
if (!coverAll) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 9b41c583b..b04e21fca 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -89,6 +89,12 @@ namespace smt {
typedef union_find<theory_str> th_union_find;
typedef map<rational, expr*, obj_hash<rational>, default_eq<rational> > rational_map;
+ struct str_hash_proc {
+ unsigned operator()(std::string const & s) const {
+ return string_hash(s.c_str(), static_cast<unsigned>(s.length()), 17);
+ }
+ };
+ typedef map<std::string, expr*, str_hash_proc, default_eq<std::string> > string_map;
protected:
// Some options that control how the solver operates.
@@ -176,6 +182,13 @@ namespace smt {
*/
bool opt_UseFastLengthTesterCache;
+ /*
+ * If UseFastValueTesterCache is set to true,
+ * value tester terms will not be generated from scratch each time they are needed,
+ * but will be saved in a map and looked up.
+ */
+ bool opt_UseFastValueTesterCache;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -271,6 +284,8 @@ namespace smt {
// used when opt_FastLengthTesterCache is true
rational_map lengthTesterCache;
+ // used when opt_FastValueTesterCache is true
+ string_map valueTesterCache;
th_union_find m_find;
th_trail_stack m_trail_stack;
From 521e0e175be66fcb5140ff3ac766ebb35ef3cd56 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 8 Nov 2016 14:23:10 -0500
Subject: [PATCH 244/401] refresh reused split vars in theory_str this fixes
kaluza/unsat/big/7907, now SAT in ~30s
---
src/smt/theory_str.cpp | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index c7cbff04e..a9a290ab1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2726,6 +2726,9 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
t2 = varForBreakConcat[key2][1];
xorFlag = varForBreakConcat[key2][2];
}
+ // TODO do I need to refresh the xorFlag, which is an integer var, and if so, how?
+ refresh_theory_var(t1);
+ refresh_theory_var(t2);
}
// For split types 0 through 2, we can get away with providing
@@ -3048,6 +3051,8 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
temp1 = varForBreakConcat[key2][0];
xorFlag = varForBreakConcat[key2][1];
}
+ // TODO refresh xorFlag?
+ refresh_theory_var(temp1);
}
int splitType = -1;
@@ -3361,6 +3366,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
temp1 = varForBreakConcat[key2][0];
xorFlag = varForBreakConcat[key2][1];
}
+ refresh_theory_var(temp1);
}
@@ -3857,6 +3863,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
commonVar = (entry2->second)[0];
xorFlag = (entry2->second)[1];
}
+ refresh_theory_var(commonVar);
}
expr ** or_item = alloc_svect(expr*, (overlapLen.size() + 1));
From 61d1d5e8b0a87381ac429a06786c3db28c4e9aa2 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 8 Nov 2016 15:20:47 -0500
Subject: [PATCH 245/401] add cache for length terms to theory_str, but it
seems to slow things down so I disabled it
---
src/smt/theory_str.cpp | 17 +++++++++++++++--
src/smt/theory_str.h | 3 +++
2 files changed, 18 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a9a290ab1..4e5e45ce7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -696,8 +696,21 @@ app * theory_str::mk_strlen(expr * e) {
int len = strlen(strval);
return m_autil.mk_numeral(rational(len), true);
} else {
- expr * args[1] = {e};
- return get_manager().mk_app(get_id(), OP_STRLEN, 0, 0, 1, args);
+ if (false) {
+ // use cache
+ app * lenTerm = NULL;
+ if (!length_ast_map.find(e, lenTerm)) {
+ expr * args[1] = {e};
+ lenTerm = get_manager().mk_app(get_id(), OP_STRLEN, 0, 0, 1, args);
+ length_ast_map.insert(e, lenTerm);
+ m_trail.push_back(lenTerm);
+ }
+ return lenTerm;
+ } else {
+ // always regen
+ expr * args[1] = {e};
+ return get_manager().mk_app(get_id(), OP_STRLEN, 0, 0, 1, args);
+ }
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index b04e21fca..48ebf049b 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -287,6 +287,9 @@ namespace smt {
// used when opt_FastValueTesterCache is true
string_map valueTesterCache;
+ // cache mapping each string S to Length(S)
+ obj_map<expr, app*> length_ast_map;
+
th_union_find m_find;
th_trail_stack m_trail_stack;
theory_var get_var(expr * n) const;
From fff1fadf3b4d4b84c8bf925fab82762182d0366f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 9 Nov 2016 15:54:22 -0500
Subject: [PATCH 246/401] add str.from-int in theory_str rewriter
---
src/ast/rewriter/str_rewriter.cpp | 22 ++++++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
src/ast/str_decl_plugin.cpp | 7 +++++++
src/ast/str_decl_plugin.h | 2 ++
4 files changed, 32 insertions(+)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index db3885f28..875343655 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -410,6 +410,25 @@ br_status str_rewriter::mk_str_to_int(expr * arg0, expr_ref & result) {
}
+br_status str_rewriter::mk_str_from_int(expr * arg0, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (str.from-int " << mk_pp(arg0, m()) << ")" << std::endl;);
+ rational arg0Int;
+ if (m_autil.is_numeral(arg0, arg0Int)) {
+ // (str.from-int N) with N non-negative is the corresponding string in decimal notation.
+ // otherwise it is the empty string
+ if (arg0Int.is_nonneg()) {
+ std::string str = arg0Int.to_string();
+ result = m_strutil.mk_string(str);
+ TRACE("t_str_rw", tout << "convert non-negative integer constant to " << str << std::endl;);
+ } else {
+ result = m_strutil.mk_string("");
+ TRACE("t_str_rw", tout << "convert invalid integer constant to empty string" << std::endl;);
+ }
+ return BR_DONE;
+ }
+ return BR_FAILED;
+}
+
br_status str_rewriter::mk_str_Substr(expr * base, expr * start, expr * len, expr_ref & result) {
TRACE("t_str_rw", tout << "rewrite (Substr " << mk_pp(base, m()) << " " << mk_pp(start, m()) << " " << mk_pp(len, m()) << ")" << std::endl;);
rational startVal, lenVal;
@@ -559,6 +578,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_STR2INT:
SASSERT(num_args == 1);
return mk_str_to_int(args[0], result);
+ case OP_STR_INT2STR:
+ SASSERT(num_args == 1);
+ return mk_str_from_int(args[0], result);
case OP_STR_SUBSTR:
SASSERT(num_args == 3);
return mk_str_Substr(args[0], args[1], args[2], result);
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index 10898eae7..822fb1ea8 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -54,6 +54,7 @@ public:
br_status mk_str_Replace(expr * base, expr * source, expr * target, expr_ref & result);
br_status mk_str_Substr(expr * base, expr * start, expr * len, expr_ref & result);
br_status mk_str_to_int(expr * arg0, expr_ref & result);
+ br_status mk_str_from_int(expr * arg0, expr_ref & result);
br_status mk_re_Str2Reg(expr * str, expr_ref & result);
br_status mk_re_RegexIn(expr * str, expr * re, expr_ref & result);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 333ae2a02..4f9dcb7aa 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -37,6 +37,7 @@ str_decl_plugin::str_decl_plugin():
m_substr_decl(0),
m_replace_decl(0),
m_str2int_decl(0),
+ m_int2str_decl(0),
m_re_str2regex_decl(0),
m_re_regexin_decl(0),
m_re_regexconcat_decl(0),
@@ -69,6 +70,7 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_substr_decl);
DEC_REF(m_replace_decl);
DEC_REF(m_str2int_decl);
+ DEC_REF(m_int2str_decl);
DEC_REF(m_re_str2regex_decl);
DEC_REF(m_re_regexin_decl);
DEC_REF(m_re_regexconcat_decl);
@@ -150,6 +152,9 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_str2int_decl = m->mk_func_decl(symbol("str.to-int"), s, i, func_decl_info(id, OP_STR_STR2INT));
m_manager->inc_ref(m_str2int_decl);
+ m_int2str_decl = m->mk_func_decl(symbol("str.from-int"), i, s, func_decl_info(id, OP_STR_INT2STR));
+ m_manager->inc_ref(m_int2str_decl);
+
m_re_str2regex_decl = m->mk_func_decl(symbol("Str2Reg"), s, re, func_decl_info(id, OP_RE_STR2REGEX));
m_manager->inc_ref(m_re_str2regex_decl);
@@ -202,6 +207,7 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STR_SUBSTR: return m_substr_decl;
case OP_STR_REPLACE: return m_replace_decl;
case OP_STR_STR2INT: return m_str2int_decl;
+ case OP_STR_INT2STR: return m_int2str_decl;
case OP_RE_STR2REGEX: return m_re_str2regex_decl;
case OP_RE_REGEXIN: return m_re_regexin_decl;
case OP_RE_REGEXCONCAT: return m_re_regexconcat_decl;
@@ -276,6 +282,7 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("Substring", OP_STR_SUBSTR));
op_names.push_back(builtin_name("Replace", OP_STR_REPLACE));
op_names.push_back(builtin_name("str.to-int", OP_STR_STR2INT));
+ op_names.push_back(builtin_name("str.from-int", OP_STR_INT2STR));
op_names.push_back(builtin_name("Str2Reg", OP_RE_STR2REGEX));
op_names.push_back(builtin_name("RegexIn", OP_RE_REGEXIN));
op_names.push_back(builtin_name("RegexConcat", OP_RE_REGEXCONCAT));
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index e9ab43865..29b2ce9c3 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -43,6 +43,7 @@ enum str_op_kind {
OP_STR_REPLACE,
// string-integer conversion
OP_STR_STR2INT,
+ OP_STR_INT2STR,
// regular expression operators
OP_RE_STR2REGEX,
OP_RE_REGEXIN,
@@ -76,6 +77,7 @@ protected:
func_decl * m_substr_decl;
func_decl * m_replace_decl;
func_decl * m_str2int_decl;
+ func_decl * m_int2str_decl;
func_decl * m_re_str2regex_decl;
func_decl * m_re_regexin_decl;
From 5635016205279623e2c00420934525c9fe22d801 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 9 Nov 2016 18:06:02 -0500
Subject: [PATCH 247/401] theory_str str.from-int very WIP
---
src/smt/theory_str.cpp | 98 ++++++++++++++++++++++++++++++++++++++++--
src/smt/theory_str.h | 4 ++
2 files changed, 98 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 40dc3f42f..881045815 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -924,6 +924,8 @@ void theory_str::propagate() {
enode * e = m_library_aware_axiom_todo[i];
if (is_str_to_int(e)) {
instantiate_axiom_str_to_int(e);
+ } else if (is_int_to_str(e)) {
+ instantiate_axiom_int_to_str(e);
} else {
TRACE("t_str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_owner(), get_manager()) << std::endl;);
NOT_IMPLEMENTED_YET();
@@ -1637,6 +1639,30 @@ void theory_str::instantiate_axiom_str_to_int(enode * e) {
}
}
+void theory_str::instantiate_axiom_int_to_str(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * ex = e->get_owner();
+ if (axiomatized_terms.contains(ex)) {
+ TRACE("t_str_detail", tout << "already set up str.from-int axiom for " << mk_pp(ex, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(ex);
+
+ TRACE("t_str_detail", tout << "instantiate str.from-int axiom for " << mk_pp(ex, m) << std::endl;);
+
+ // axiom 1: N < 0 <==> (str.from-int N) = ""
+ expr * N = ex->get_arg(0);
+ {
+ expr_ref axiom1_lhs(m.mk_not(m_autil.mk_ge(N, m_autil.mk_numeral(rational::zero(), true))), m);
+ expr_ref axiom1_rhs(ctx.mk_eq_atom(ex, m_strutil.mk_string("")), m);
+ expr_ref axiom1(ctx.mk_eq_atom(axiom1_lhs, axiom1_rhs), m);
+ SASSERT(axiom1);
+ assert_axiom(axiom1);
+ }
+}
+
expr * theory_str::mk_RegexIn(expr * str, expr * regexp) {
expr * args[2] = {str, regexp};
app * regexIn = get_manager().mk_app(get_id(), OP_RE_REGEXIN, 0, 0, 2, args);
@@ -6476,7 +6502,7 @@ void theory_str::set_up_axioms(expr * ex) {
m_axiom_Indexof2_todo.push_back(n);
} else if (is_LastIndexof(ap)) {
m_axiom_LastIndexof_todo.push_back(n);
- } else if (is_str_to_int(ap)) {
+ } else if (is_str_to_int(ap) || is_int_to_str(ap)) {
string_int_conversion_terms.push_back(ap);
m_library_aware_axiom_todo.push_back(n);
}
@@ -7630,7 +7656,7 @@ bool theory_str::finalcheck_str2int(app * a) {
std::string Ival_str = Ival.to_string();
expr_ref premise(ctx.mk_eq_atom(a, m_autil.mk_numeral(Ival, true)), m);
expr_ref conclusion(ctx.mk_eq_atom(S, m_strutil.mk_string(Ival_str)), m);
- expr_ref axiom(m.mk_or(m.mk_not(premise), conclusion), m);
+ expr_ref axiom(rewrite_implication(premise, conclusion), m);
if (!string_int_axioms.contains(axiom)) {
string_int_axioms.insert(axiom);
assert_axiom(axiom);
@@ -7647,6 +7673,66 @@ bool theory_str::finalcheck_str2int(app * a) {
return axiomAdd;
}
+bool theory_str::finalcheck_int2str(app * a) {
+ bool axiomAdd = false;
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr * N = a->get_arg(0);
+
+ // check string theory
+ bool Sval_expr_exists;
+ expr * Sval_expr = get_eqc_value(a, Sval_expr_exists);
+ if (Sval_expr_exists) {
+ std::string Sval = m_strutil.get_string_constant_value(Sval_expr);
+ TRACE("t_str_detail", tout << "string theory assigns \"" << mk_pp(a, m) << " = " << Sval << std::endl;);
+ // empty string --> integer value < 0
+ if (Sval.empty()) {
+ // ignore this. we should already assert the axiom for what happens when the string is ""
+ } else {
+ // nonempty string --> convert to correct integer value, or disallow it
+ // TODO think about whether we need to persist the axiom in this case?
+ rational convertedRepresentation(0);
+ rational ten(10);
+ bool conversionOK = true;
+ for (unsigned i = 0; i < Sval.length(); ++i) {
+ char digit = Sval.at(i);
+ if (isdigit((int)digit)) {
+ std::string sDigit(1, digit);
+ int val = atoi(sDigit.c_str());
+ convertedRepresentation = (ten * convertedRepresentation) + rational(val);
+ } else {
+ // not a digit, invalid
+ TRACE("t_str_rw", tout << "str.to-int argument contains non-digit character '" << digit << "'" << std::endl;);
+ conversionOK = false;
+ break;
+ }
+ }
+ if (conversionOK) {
+ expr_ref premise(ctx.mk_eq_atom(a, m_strutil.mk_string(Sval)), m);
+ expr_ref conclusion(ctx.mk_eq_atom(N, m_autil.mk_numeral(convertedRepresentation, true)), m);
+ expr_ref axiom(rewrite_implication(premise, conclusion), m);
+ if (!string_int_axioms.contains(axiom)) {
+ string_int_axioms.insert(axiom);
+ assert_axiom(axiom);
+ m_trail_stack.push(insert_obj_trail<theory_str, expr>(string_int_axioms, axiom));
+ axiomAdd = true;
+ }
+ } else {
+ expr_ref axiom(m.mk_not(ctx.mk_eq_atom(a, m_strutil.mk_string(Sval))), m);
+ // always assert this axiom because this is a conflict clause
+ assert_axiom(axiom);
+ axiomAdd = true;
+ }
+ }
+ } else {
+ TRACE("t_str_detail", tout << "string theory has no assignment for " << mk_pp(a, m) << std::endl;);
+ NOT_IMPLEMENTED_YET();
+ }
+ // TODO also check assignment in integer theory
+ return axiomAdd;
+}
+
final_check_status theory_str::final_check_eh() {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -7758,9 +7844,13 @@ final_check_status theory_str::final_check_eh() {
if (axiomAdd) {
addedStrIntAxioms = true;
}
+ } else if (is_int_to_str(ex)) {
+ bool axiomAdd = finalcheck_int2str(ex);
+ if (axiomAdd) {
+ addedStrIntAxioms = true;
+ }
} else {
- // TODO int.to-str
- NOT_IMPLEMENTED_YET();
+ UNREACHABLE();
}
}
if (addedStrIntAxioms) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index e99774034..c7d931d1e 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -359,6 +359,8 @@ namespace smt {
bool is_Replace(enode const * n) const { return is_Replace(n->get_owner()); }
bool is_str_to_int(app const * a) const { return a->is_app_of(get_id(), OP_STR_STR2INT); }
bool is_str_to_int(enode const * n) const { return is_str_to_int(n->get_owner()); }
+ bool is_int_to_str(app const * a) const { return a->is_app_of(get_id(), OP_STR_INT2STR); }
+ bool is_int_to_str(enode const * n) const { return is_int_to_str(n->get_owner()); }
bool is_RegexIn(app const * a) const { return a->is_app_of(get_id(), OP_RE_REGEXIN); }
bool is_RegexIn(enode const * n) const { return is_RegexIn(n->get_owner()); }
@@ -388,6 +390,7 @@ namespace smt {
void instantiate_axiom_Substr(enode * e);
void instantiate_axiom_Replace(enode * e);
void instantiate_axiom_str_to_int(enode * e);
+ void instantiate_axiom_int_to_str(enode * e);
expr * mk_RegexIn(expr * str, expr * regexp);
void instantiate_axiom_RegexIn(enode * e);
@@ -510,6 +513,7 @@ namespace smt {
expr * eval_concat(expr * n1, expr * n2);
bool finalcheck_str2int(app * a);
+ bool finalcheck_int2str(app * a);
// strRegex
From fbaee080b202380b65a5df39c5c038ca68ed0442 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 11 Nov 2016 00:32:50 -0500
Subject: [PATCH 248/401] fix performance regression introduced with theory_str
str.from-int more investigation is required to understand why this works.
---
src/ast/str_decl_plugin.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 29b2ce9c3..8905d66bc 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -43,7 +43,7 @@ enum str_op_kind {
OP_STR_REPLACE,
// string-integer conversion
OP_STR_STR2INT,
- OP_STR_INT2STR,
+ OP_STR_INT2STR, OP_STR_PLACEHOLDER1, OP_STR_PLACEHOLDER2,
// regular expression operators
OP_RE_STR2REGEX,
OP_RE_REGEXIN,
From 02aacab04e58d5fd8e6f1c79beb8259a1e294b24 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 11 Nov 2016 17:52:18 -0500
Subject: [PATCH 249/401] add z3str2-style free variable check to theory_str
---
src/smt/theory_str.cpp | 62 ++++++++++++++++++++++++++++++------------
1 file changed, 45 insertions(+), 17 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 881045815..fa205ac32 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -7811,26 +7811,54 @@ final_check_status theory_str::final_check_eh() {
return FC_DONE;
}
- // Check every variable to see if it's eq. to some string constant.
- // If not, mark it as free.
bool needToAssignFreeVars = false;
std::set<expr*> free_variables;
std::set<expr*> unused_internal_variables;
- TRACE("t_str_detail", tout << variable_set.size() << " variables in variable_set" << std::endl;);
- for (std::set<expr*>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
- TRACE("t_str_detail", tout << "checking eqc of variable " << mk_ismt2_pp(*it, m) << std::endl;);
- bool has_eqc_value = false;
- get_eqc_value(*it, has_eqc_value);
- if (!has_eqc_value) {
- // if this is an internal variable, it can be ignored...I think
- if (internal_variable_set.find(*it) != internal_variable_set.end() || regex_variable_set.find(*it) != regex_variable_set.end()) {
- TRACE("t_str_detail", tout << "WARNING: free internal variable " << mk_ismt2_pp(*it, m) << std::endl;);
- //unused_internal_variables.insert(*it);
- } else {
- needToAssignFreeVars = true;
- free_variables.insert(*it);
- }
- }
+ if (true) { // Z3str2 free variables check
+ std::map<expr*, int>::iterator itor = varAppearInAssign.begin();
+ for (; itor != varAppearInAssign.end(); ++itor) {
+ /*
+ std::string vName = std::string(Z3_ast_to_string(ctx, itor->first));
+ if (vName.length() >= 3 && vName.substr(0, 3) == "$$_")
+ continue;
+ */
+ if (internal_variable_set.find(itor->first) != internal_variable_set.end()
+ || regex_variable_set.find(itor->first) != regex_variable_set.end()) {
+ // this can be ignored, I think
+ TRACE("t_str_detail", tout << "free internal variable " << mk_pp(itor->first, m) << " ignored" << std::endl;);
+ continue;
+ }
+ bool hasEqcValue = false;
+ expr * eqcString = get_eqc_value(itor->first, hasEqcValue);
+ if (!hasEqcValue) {
+ TRACE("t_str_detail", tout << "found free variable " << mk_pp(itor->first, m) << std::endl;);
+ needToAssignFreeVars = true;
+ free_variables.insert(itor->first);
+ // break;
+ } else {
+ // debug
+ TRACE("t_str_detail", tout << "variable " << mk_pp(itor->first, m) << " = " << mk_pp(eqcString, m) << std::endl;);
+ }
+ }
+ } else { // new, possibly incorrect free variables check
+ // Check every variable to see if it's eq. to some string constant.
+ // If not, mark it as free.
+ TRACE("t_str_detail", tout << variable_set.size() << " variables in variable_set" << std::endl;);
+ for (std::set<expr*>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
+ TRACE("t_str_detail", tout << "checking eqc of variable " << mk_ismt2_pp(*it, m) << std::endl;);
+ bool has_eqc_value = false;
+ get_eqc_value(*it, has_eqc_value);
+ if (!has_eqc_value) {
+ // if this is an internal variable, it can be ignored...I think
+ if (internal_variable_set.find(*it) != internal_variable_set.end() || regex_variable_set.find(*it) != regex_variable_set.end()) {
+ TRACE("t_str_detail", tout << "WARNING: free internal variable " << mk_ismt2_pp(*it, m) << std::endl;);
+ //unused_internal_variables.insert(*it);
+ } else {
+ needToAssignFreeVars = true;
+ free_variables.insert(*it);
+ }
+ }
+ }
}
if (!needToAssignFreeVars) {
From df6b4611174ad4159ca816bd9f791d9c6448f15a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 14 Nov 2016 12:33:23 -0500
Subject: [PATCH 250/401] enhanced backpropagation in theory_str final_check
for var=concat terms fixes kaluza sat/big/709.smt2
---
src/smt/theory_str.cpp | 47 ++++++++++++++++++++++++++++++++++++------
src/smt/theory_str.h | 2 +-
2 files changed, 42 insertions(+), 7 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index fa205ac32..21a9ace97 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2028,7 +2028,6 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
expr_ref eq_ast2(m);
eq_ast2 = ctx.mk_eq_atom(arg1, arg1Value);
SASSERT(eq_ast2);
-
implyL = m.mk_and(eq_ast1, eq_ast2);
} else {
implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
@@ -2070,7 +2069,6 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
<< "* |arg0| = " << rational_to_string_if_exists(arg0Len, arg0Len_exists) << std::endl
<< "* |arg1| = " << rational_to_string_if_exists(arg1Len, arg1Len_exists) << std::endl;
);
-
if (parentLen_exists && !arg0Len_exists) {
TRACE("t_str_detail", tout << "make up len for arg0" << std::endl;);
expr_ref implyL11(m.mk_and(ctx.mk_eq_atom(mk_strlen(a_parent), mk_int(parentLen)),
@@ -2096,7 +2094,6 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
expr_ref eq_ast1(m);
eq_ast1 = ctx.mk_eq_atom(n_eqNode, eq_str);
SASSERT(eq_ast1);
-
expr_ref eq_ast2(m);
eq_ast2 = ctx.mk_eq_atom(arg0, arg0Value);
SASSERT(eq_ast2);
@@ -7049,13 +7046,12 @@ void theory_str::trace_ctx_dep(std::ofstream & tout,
* > should split the unroll function so that var2 and var3 are bounded by new unrolls
*/
int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr*, int> & freeVarMap,
- std::map<expr*, std::set<expr*> > & unrollGroupMap) {
+ std::map<expr*, std::set<expr*> > & unrollGroupMap, std::map<expr*, std::map<expr*, int> > & var_eq_concat_map) {
std::map<expr*, int> concatMap;
std::map<expr*, int> unrollMap;
std::map<expr*, expr*> aliasIndexMap;
std::map<expr*, expr*> var_eq_constStr_map;
std::map<expr*, expr*> concat_eq_constStr_map;
- std::map<expr*, std::map<expr*, int> > var_eq_concat_map;
std::map<expr*, std::map<expr*, int> > var_eq_unroll_map;
std::map<expr*, std::map<expr*, int> > concat_eq_concat_map;
std::map<expr*, std::map<expr*, int> > depMap;
@@ -7805,12 +7801,51 @@ final_check_status theory_str::final_check_eh() {
std::map<expr*, int> varAppearInAssign;
std::map<expr*, int> freeVar_map;
std::map<expr*, std::set<expr*> > unrollGroup_map;
- int conflictInDep = ctx_dep_analysis(varAppearInAssign, freeVar_map, unrollGroup_map);
+ std::map<expr*, std::map<expr*, int> > var_eq_concat_map;
+ int conflictInDep = ctx_dep_analysis(varAppearInAssign, freeVar_map, unrollGroup_map, var_eq_concat_map);
if (conflictInDep == -1) {
// return Z3_TRUE;
return FC_DONE;
}
+ // enhancement: improved backpropagation of string constants into var=concat terms
+ bool backpropagation_occurred = false;
+ for (std::map<expr*, std::map<expr*, int> >::iterator veqc_map_it = var_eq_concat_map.begin();
+ veqc_map_it != var_eq_concat_map.end(); ++veqc_map_it) {
+ expr * var = veqc_map_it->first;
+ for (std::map<expr*, int>::iterator concat_map_it = veqc_map_it->second.begin();
+ concat_map_it != veqc_map_it->second.end(); ++concat_map_it) {
+ app * concat = to_app(concat_map_it->first);
+ expr * concat_lhs = concat->get_arg(0);
+ expr * concat_rhs = concat->get_arg(1);
+ // If the concat LHS and RHS both have a string constant in their EQC,
+ // but the var does not, then we assert an axiom of the form
+ // (lhs = "lhs" AND rhs = "rhs") --> (Concat lhs rhs) = "lhsrhs"
+ bool concat_lhs_haseqc, concat_rhs_haseqc, var_haseqc;
+ expr * concat_lhs_str = get_eqc_value(concat_lhs, concat_lhs_haseqc);
+ expr * concat_rhs_str = get_eqc_value(concat_rhs, concat_rhs_haseqc);
+ expr * var_str = get_eqc_value(var, var_haseqc);
+ if (concat_lhs_haseqc && concat_rhs_haseqc && !var_haseqc) {
+ TRACE("t_str_detail", tout << "backpropagate into " << mk_pp(var, m) << " = " << mk_pp(concat, m) << std::endl
+ << "LHS ~= " << mk_pp(concat_lhs_str, m) << " RHS ~= " << mk_pp(concat_rhs_str, m) << std::endl;);
+ std::string lhsString = m_strutil.get_string_constant_value(concat_lhs_str);
+ std::string rhsString = m_strutil.get_string_constant_value(concat_rhs_str);
+ std::string concatString = lhsString + rhsString;
+ expr_ref lhs1(ctx.mk_eq_atom(concat_lhs, concat_lhs_str), m);
+ expr_ref lhs2(ctx.mk_eq_atom(concat_rhs, concat_rhs_str), m);
+ expr_ref lhs(m.mk_and(lhs1, lhs2), m);
+ expr_ref rhs(ctx.mk_eq_atom(concat, m_strutil.mk_string(concatString)), m);
+ assert_implication(lhs, rhs);
+ backpropagation_occurred = true;
+ }
+ }
+ }
+
+ if (backpropagation_occurred) {
+ TRACE("t_str", tout << "Resuming search due to axioms added by backpropagation." << std::endl;);
+ return FC_CONTINUE;
+ }
+
bool needToAssignFreeVars = false;
std::set<expr*> free_variables;
std::set<expr*> unused_internal_variables;
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index c7d931d1e..5b8f644eb 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -473,7 +473,7 @@ namespace smt {
void group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts);
int ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr*, int> & freeVarMap,
- std::map<expr*, std::set<expr*> > & unrollGroupMap);
+ std::map<expr*, std::set<expr*> > & unrollGroupMap, std::map<expr*, std::map<expr*, int> > & var_eq_concat_map);
void trace_ctx_dep(std::ofstream & tout,
std::map<expr*, expr*> & aliasIndexMap,
std::map<expr*, expr*> & var_eq_constStr_map,
From 977142860042aaad55c80deda252b50d054ae524 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 15 Nov 2016 15:18:07 -0500
Subject: [PATCH 251/401] experimental modification to simplify_parent call in
theory_str, WIP
---
src/smt/theory_str.cpp | 24 ++++++++++++------------
1 file changed, 12 insertions(+), 12 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 21a9ace97..3874f9f1d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2267,19 +2267,12 @@ expr * theory_str::simplify_concat(expr * node) {
if (in_same_eqc(node, resultAst)) {
TRACE("t_str_detail", tout << "SKIP: both concats are already in the same equivalence class" << std::endl;);
} else {
- // TODO refactor
- expr ** items = alloc_svect(expr*, resolvedMap.size());
- int pos = 0;
+ expr_ref_vector items(m);
std::map<expr*, expr*>::iterator itor = resolvedMap.begin();
for (; itor != resolvedMap.end(); ++itor) {
- items[pos++] = ctx.mk_eq_atom(itor->first, itor->second);
- }
- expr_ref premise(m);
- if (pos == 1) {
- premise = items[0];
- } else {
- premise = m.mk_and(pos, items);
+ items.push_back(ctx.mk_eq_atom(itor->first, itor->second));
}
+ expr_ref premise(mk_and(items), m);
expr_ref conclusion(ctx.mk_eq_atom(node, resultAst), m);
assert_implication(premise, conclusion);
}
@@ -6374,11 +6367,18 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
// we want the Z3str2 eqc check here...
expr * nn1_value = z3str2_get_eqc_value(lhs, nn1HasEqcValue);
expr * nn2_value = z3str2_get_eqc_value(rhs, nn2HasEqcValue);
- if (nn1HasEqcValue && !nn2HasEqcValue) {
+
+
+ // modification from z3str2: simplify whenever we see a string constant on either side,
+ // not only when it's on one side but not the other.
+ // this may work in cases where a concat is simplified to a string constant in group_terms_by_eqc()
+ // and we fail to simplify parents because we think a string constant is on both sides
+
+ if (nn1HasEqcValue /* && !nn2HasEqcValue */ ) {
simplify_parent(rhs, nn1_value);
}
- if (!nn1HasEqcValue && nn2HasEqcValue) {
+ if (/* !nn1HasEqcValue && */ nn2HasEqcValue) {
simplify_parent(lhs, nn2_value);
}
From 55ae83f47ebedd3fea1c04e4c39962fa80b97819 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 16 Nov 2016 13:00:05 -0500
Subject: [PATCH 252/401] Revert "experimental modification to simplify_parent
call in theory_str, WIP"
This reverts commit 977142860042aaad55c80deda252b50d054ae524.
---
src/smt/theory_str.cpp | 24 ++++++++++++------------
1 file changed, 12 insertions(+), 12 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3874f9f1d..21a9ace97 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2267,12 +2267,19 @@ expr * theory_str::simplify_concat(expr * node) {
if (in_same_eqc(node, resultAst)) {
TRACE("t_str_detail", tout << "SKIP: both concats are already in the same equivalence class" << std::endl;);
} else {
- expr_ref_vector items(m);
+ // TODO refactor
+ expr ** items = alloc_svect(expr*, resolvedMap.size());
+ int pos = 0;
std::map<expr*, expr*>::iterator itor = resolvedMap.begin();
for (; itor != resolvedMap.end(); ++itor) {
- items.push_back(ctx.mk_eq_atom(itor->first, itor->second));
+ items[pos++] = ctx.mk_eq_atom(itor->first, itor->second);
+ }
+ expr_ref premise(m);
+ if (pos == 1) {
+ premise = items[0];
+ } else {
+ premise = m.mk_and(pos, items);
}
- expr_ref premise(mk_and(items), m);
expr_ref conclusion(ctx.mk_eq_atom(node, resultAst), m);
assert_implication(premise, conclusion);
}
@@ -6367,18 +6374,11 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
// we want the Z3str2 eqc check here...
expr * nn1_value = z3str2_get_eqc_value(lhs, nn1HasEqcValue);
expr * nn2_value = z3str2_get_eqc_value(rhs, nn2HasEqcValue);
-
-
- // modification from z3str2: simplify whenever we see a string constant on either side,
- // not only when it's on one side but not the other.
- // this may work in cases where a concat is simplified to a string constant in group_terms_by_eqc()
- // and we fail to simplify parents because we think a string constant is on both sides
-
- if (nn1HasEqcValue /* && !nn2HasEqcValue */ ) {
+ if (nn1HasEqcValue && !nn2HasEqcValue) {
simplify_parent(rhs, nn1_value);
}
- if (/* !nn1HasEqcValue && */ nn2HasEqcValue) {
+ if (!nn1HasEqcValue && nn2HasEqcValue) {
simplify_parent(lhs, nn2_value);
}
From e2d05578d62251d9c7630ffa6c965f29a664d07a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 17 Nov 2016 15:25:39 -0500
Subject: [PATCH 253/401] add extra trace message in smt_context for theory_str
results change
---
src/smt/smt_context.cpp | 1 +
1 file changed, 1 insertion(+)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index c712135d3..8958eae5f 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -3105,6 +3105,7 @@ namespace smt {
theory_str * str = (theory_str*)th;
if (str->overlapping_variables_detected()) {
TRACE("t_str", tout << "WARNING: overlapping variables detected, UNSAT changed to UNKNOWN!" << std::endl;);
+ TRACE("context", tout << "WARNING: overlapping variables detected in theory_str. UNSAT changed to UNKNOWN!" << std::endl;);
r = l_undef;
}
break;
From d260218e2be6f1ece2140cfeaea9aa2e8cc177fe Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 17 Nov 2016 15:28:17 -0500
Subject: [PATCH 254/401] tabs to spaces test
---
src/smt/theory_str.cpp | 34 +++++++++++++++++-----------------
1 file changed, 17 insertions(+), 17 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 21a9ace97..39b221961 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -35,13 +35,13 @@ theory_str::theory_str(ast_manager & m):
opt_AggressiveUnrollTesting(true),
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
- opt_LCMUnrollStep(2),
- opt_NoQuickReturn_IntegerTheory(false),
- opt_DisableIntegerTheoryIntegration(false),
- opt_DeferEQCConsistencyCheck(false),
- opt_CheckVariableScope(true),
- opt_UseFastLengthTesterCache(true),
- opt_UseFastValueTesterCache(true),
+ opt_LCMUnrollStep(2),
+ opt_NoQuickReturn_IntegerTheory(false),
+ opt_DisableIntegerTheoryIntegration(false),
+ opt_DeferEQCConsistencyCheck(false),
+ opt_CheckVariableScope(true),
+ opt_UseFastLengthTesterCache(true),
+ opt_UseFastValueTesterCache(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -51,17 +51,17 @@ theory_str::theory_str(ast_manager & m):
m_trail(m),
m_delayed_axiom_setup_terms(m),
tmpStringVarCount(0),
- tmpXorVarCount(0),
- tmpLenTestVarCount(0),
- tmpValTestVarCount(0),
- avoidLoopCut(true),
- loopDetected(false),
- contains_map(m),
- string_int_conversion_terms(m),
- m_find(*this),
- m_trail_stack(*this)
+ tmpXorVarCount(0),
+ tmpLenTestVarCount(0),
+ tmpValTestVarCount(0),
+ avoidLoopCut(true),
+ loopDetected(false),
+ contains_map(m),
+ string_int_conversion_terms(m),
+ m_find(*this),
+ m_trail_stack(*this)
{
- initialize_charset();
+ initialize_charset();
}
theory_str::~theory_str() {
From 855037eed765cd4462011fa2562d471fc9cd4bc6 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 17 Nov 2016 16:25:53 -0500
Subject: [PATCH 255/401] refactor process_concat_eq_type2 in theory_str; fixes
unsat/big/8558
---
src/smt/theory_str.cpp | 83 ++++++++++++++++++++----------------------
1 file changed, 39 insertions(+), 44 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 39b221961..f92939ac7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3180,28 +3180,28 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
if (can_two_nodes_eq(y, temp1_strAst)) {
if (!avoidLoopCut || !(has_self_cut(m, y))) {
// break down option 2-1
- expr ** l_items = alloc_svect(expr*, 3);
- l_items[0] = ctx.mk_eq_atom(concatAst1, concatAst2);
+ expr_ref_vector l_items(mgr);
+ l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
- expr ** r_items = alloc_svect(expr*, 3);
+ expr_ref_vector r_items(mgr);
expr_ref x_temp1(mk_concat(x, temp1), mgr);
- r_items[0] = ctx.mk_eq_atom(m, x_temp1);
- r_items[1] = ctx.mk_eq_atom(y, temp1_strAst);
+ r_items.push_back(ctx.mk_eq_atom(m, x_temp1));
+ r_items.push_back(ctx.mk_eq_atom(y, temp1_strAst));
if (x_len_exists && m_len_exists) {
- l_items[1] = ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len));
- l_items[2] = ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
rational m_sub_x = (m_len - x_len);
- r_items[2] = ctx.mk_eq_atom(mk_strlen(temp1), mk_int(m_sub_x));
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(m_sub_x)));
} else {
- l_items[1] = ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len));
- l_items[2] = ctx.mk_eq_atom(mk_strlen(strAst), mk_int(str_len));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(strAst), mk_int(str_len)));
rational y_sub_str = (y_len - str_len);
- r_items[2] = ctx.mk_eq_atom(mk_strlen(temp1), mk_int(y_sub_str));
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(y_sub_str)));
}
- expr_ref ax_l(mgr.mk_and(3, l_items), mgr);
- expr_ref ax_r(mgr.mk_and(3, r_items), mgr);
+ expr_ref ax_l(mk_and(l_items), mgr);
+ expr_ref ax_r(mk_and(r_items), mgr);
add_cut_info_merge(temp1, sLevel, y);
add_cut_info_merge(temp1, sLevel, m);
@@ -3228,16 +3228,16 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
// | x | y |
// | m | str |
rational lenDelta;
- expr ** l_items = alloc_svect(expr*, 3);
+ expr_ref_vector l_items(mgr);
int l_count = 0;
- l_items[0] = ctx.mk_eq_atom(concatAst1, concatAst2);
+ l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
if (x_len_exists && m_len_exists) {
- l_items[1] = ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len));
- l_items[2] = ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
l_count = 3;
lenDelta = x_len - m_len;
} else {
- l_items[1] = ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
l_count = 2;
lenDelta = str_len - y_len;
}
@@ -3255,35 +3255,32 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
;
);
- TRACE("t_str", tout << "*** MARKER 1 ***" << std::endl;);
std::string part1Str = strValue.substr(0, lenDelta.get_unsigned());
- TRACE("t_str", tout << "*** MARKER 2 ***" << std::endl;);
std::string part2Str = strValue.substr(lenDelta.get_unsigned(), strValue.length() - lenDelta.get_unsigned());
- TRACE("t_str", tout << "*** MARKER 3 ***" << std::endl;);
expr_ref prefixStr(m_strutil.mk_string(part1Str), mgr);
expr_ref x_concat(mk_concat(m, prefixStr), mgr);
expr_ref cropStr(m_strutil.mk_string(part2Str), mgr);
if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
- expr ** r_items = alloc_svect(expr*, 2);
- r_items[0] = ctx.mk_eq_atom(x, x_concat);
- r_items[1] = ctx.mk_eq_atom(y, cropStr);
- expr_ref ax_l(mgr.mk_and(l_count, l_items), mgr);
- expr_ref ax_r(mgr.mk_and(2, r_items), mgr);
+ expr_ref_vector r_items(mgr);
+ r_items.push_back(ctx.mk_eq_atom(x, x_concat));
+ r_items.push_back(ctx.mk_eq_atom(y, cropStr));
+ expr_ref ax_l(mk_and(l_items), mgr);
+ expr_ref ax_r(mk_and(r_items), mgr);
assert_implication(ax_l, ax_r);
} else {
// negate! It's impossible to split str with these lengths
TRACE("t_str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
- expr_ref ax_l(mgr.mk_and(l_count, l_items), mgr);
+ expr_ref ax_l(mk_and(l_items), mgr);
assert_axiom(mgr.mk_not(ax_l));
}
} else {
// Split type -1: no idea about the length...
int optionTotal = 2 + strValue.length();
- expr ** or_item = alloc_svect(expr*, optionTotal);
- expr ** and_item = alloc_svect(expr*, (1 + 6 + 4 * (strValue.length() + 1)));
+ expr_ref_vector or_item(mgr);
+ expr_ref_vector and_item(mgr);
int option = 0;
int pos = 1;
@@ -3293,13 +3290,14 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
if (can_two_nodes_eq(y, temp1_strAst)) {
if (!avoidLoopCut || !has_self_cut(m, y)) {
// break down option 2-1
- or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+ expr_ref current_or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
+ or_item.push_back(current_or_item_option);
expr_ref x_temp1(mk_concat(x, temp1), mgr);
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(m, x_temp1));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, temp1_strAst));
+ and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(m, x_temp1)));
+ and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(y, temp1_strAst)));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(m),
- m_autil.mk_add(mk_strlen(x), mk_strlen(temp1))));
+ and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(mk_strlen(m),
+ m_autil.mk_add(mk_strlen(x), mk_strlen(temp1)))));
++option;
add_cut_info_merge(temp1, ctx.get_scope_level(), y);
@@ -3319,21 +3317,18 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
expr_ref cropStr(m_strutil.mk_string(part2Str), mgr);
if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
// break down option 2-2
- or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(x, x_concat));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, cropStr));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(y), mk_int(part2Str.length())));
+ expr_ref current_or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
+ or_item.push_back(current_or_item_option);
+ and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(x, x_concat)));
+ and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(y, cropStr)));
+ and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(mk_strlen(y), mk_int(part2Str.length()))));
++option;
}
}
if (option > 0) {
- if (option == 1) {
- and_item[0] = or_item[0];
- } else {
- and_item[0] = mgr.mk_or(option, or_item);
- }
- expr_ref implyR(mgr.mk_and(pos, and_item), mgr);
+ and_item.push_back(mk_or(or_item));
+ expr_ref implyR(mk_and(and_item), mgr);
assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
} else {
TRACE("t_str", tout << "STOP: Should not split two EQ concats." << std::endl;);
From 5e37a218025aa5ed1dd7cbf00fbdd47376931f81 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 18 Nov 2016 16:07:20 -0500
Subject: [PATCH 256/401] fix expr_ref in theory_str splits WIP
---
src/smt/theory_str.cpp | 120 +++++++++++++++++++++--------------------
1 file changed, 61 insertions(+), 59 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f92939ac7..a34a6b8c1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -23,6 +23,8 @@ Revision History:
#include<list>
#include<vector>
#include<algorithm>
+
+#include "../ast/ast.h"
#include"theory_arith.h"
namespace smt {
@@ -2834,31 +2836,31 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
// len(x) < len(m) || len(y) > len(n)
//--------------------------------------
if (!has_self_cut(m, y)) {
- expr ** ax_l_items = alloc_svect(expr*, 3);
- expr ** ax_r_items = alloc_svect(expr*, 3);
+ expr_ref_vector ax_l_items(mgr);
+ expr_ref_vector ax_r_items(mgr);
- ax_l_items[0] = ctx.mk_eq_atom(concatAst1, concatAst2);
+ ax_l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
expr_ref x_t1(mk_concat(x, t1), mgr);
expr_ref t1_n(mk_concat(t1, n), mgr);
- ax_r_items[0] = ctx.mk_eq_atom(m, x_t1);
- ax_r_items[1] = ctx.mk_eq_atom(y, t1_n);
+ ax_r_items.push_back(ctx.mk_eq_atom(m, x_t1));
+ ax_r_items.push_back(ctx.mk_eq_atom(y, t1_n));
if (m_len_exists && x_len_exists) {
- ax_l_items[1] = ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len));
- ax_l_items[2] = ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
rational m_sub_x = m_len - x_len;
- ax_r_items[2] = ctx.mk_eq_atom(mk_strlen(t1), mk_int(m_sub_x));
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t1), mk_int(m_sub_x)));
} else {
- ax_l_items[1] = ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len));
- ax_l_items[2] = ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
rational y_sub_n = y_len - n_len;
- ax_r_items[2] = ctx.mk_eq_atom(mk_strlen(t1), mk_int(y_sub_n));
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t1), mk_int(y_sub_n)));
}
- expr_ref ax_l(mgr.mk_and(3, ax_l_items), mgr);
- expr_ref ax_r(mgr.mk_and(3, ax_r_items), mgr);
+ expr_ref ax_l(mk_and(ax_l_items), mgr);
+ expr_ref ax_r(mk_and(ax_r_items), mgr);
// Cut Info
add_cut_info_merge(t1, sLevel, m);
@@ -2885,27 +2887,27 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr_ref m_t2(mk_concat(m, t2), mgr);
expr_ref t2_y(mk_concat(t2, y), mgr);
- expr ** ax_l_items = alloc_svect(expr*, 3);
- ax_l_items[0] = ctx.mk_eq_atom(concatAst1, concatAst2);
+ expr_ref_vector ax_l_items(mgr);
+ ax_l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
- expr ** ax_r_items = alloc_svect(expr*, 3);
- ax_r_items[0] = ctx.mk_eq_atom(x, m_t2);
- ax_r_items[1] = ctx.mk_eq_atom(t2_y, n);
+ expr_ref_vector ax_r_items(mgr);
+ ax_r_items.push_back(ctx.mk_eq_atom(x, m_t2));
+ ax_r_items.push_back(ctx.mk_eq_atom(t2_y, n));
if (m_len_exists && x_len_exists) {
- ax_l_items[1] = ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len));
- ax_l_items[2] = ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
rational x_sub_m = x_len - m_len;
- ax_r_items[2] = ctx.mk_eq_atom(mk_strlen(t2), mk_int(x_sub_m));
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t2), mk_int(x_sub_m)));
} else {
- ax_l_items[1] = ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len));
- ax_l_items[2] = ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
rational n_sub_y = n_len - y_len;
- ax_r_items[2] = ctx.mk_eq_atom(mk_strlen(t2), mk_int(n_sub_y));
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t2), mk_int(n_sub_y)));
}
- expr_ref ax_l(mgr.mk_and(3, ax_l_items), mgr);
- expr_ref ax_r(mgr.mk_and(3, ax_r_items), mgr);
+ expr_ref ax_l(mk_and(ax_l_items), mgr);
+ expr_ref ax_r(mk_and(ax_r_items), mgr);
// Cut Info
add_cut_info_merge(t2, sLevel, x);
@@ -2919,8 +2921,8 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
} else if (splitType == -1) {
// Here we don't really have a choice. We have no length information at all...
- expr ** or_item = alloc_svect(expr*, 3);
- expr ** and_item = alloc_svect(expr*, 20);
+ expr_ref_vector or_item(mgr);
+ expr_ref_vector and_item(mgr);
int option = 0;
int pos = 1;
@@ -2928,28 +2930,29 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
// len(x) < len(m) || len(y) > len(n)
if (!avoidLoopCut || !has_self_cut(m, y)) {
// break down option 1-1
- expr * x_t1 = mk_concat(x, t1);
- expr * t1_n = mk_concat(t1, n);
- or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(m, x_t1));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, t1_n));
+ expr_ref x_t1(mk_concat(x, t1), mgr);
+ expr_ref t1_n(mk_concat(t1, n), mgr);
+ expr_ref or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
+ or_item.push_back(or_item_option);
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(m, x_t1)));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(y, t1_n)));
expr_ref x_plus_t1(m_autil.mk_add(mk_strlen(x), mk_strlen(t1)), mgr);
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(m), x_plus_t1));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(m), x_plus_t1)));
// These were crashing the solver because the integer theory
// expects a constant on the right-hand side.
// The things we want to assert here are len(m) > len(x) and len(y) > len(n).
// We rewrite A > B as A-B > 0 and then as not(A-B <= 0),
// and then, *because we aren't allowed to use subtraction*,
// as not(A + -1*B <= 0)
- and_item[pos++] = ctx.mk_eq_atom(or_item[option],
+ and_item.push_back(ctx.mk_eq_atom(or_item_option,
mgr.mk_not(m_autil.mk_le(
m_autil.mk_add(mk_strlen(m), m_autil.mk_mul(mk_int(-1), mk_strlen(x))),
- mk_int(0))) );
- and_item[pos++] = ctx.mk_eq_atom(or_item[option],
+ mk_int(0))) ));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option,
mgr.mk_not(m_autil.mk_le(
m_autil.mk_add(mk_strlen(y),m_autil.mk_mul(mk_int(-1), mk_strlen(n))),
- mk_int(0))) );
+ mk_int(0))) ));
option++;
@@ -2965,25 +2968,26 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
// x = m || y = n
if (!avoidLoopCut || !has_self_cut(x, n)) {
// break down option 1-2
- expr * m_t2 = mk_concat(m, t2);
- expr * t2_y = mk_concat(t2, y);
- or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(x, m_t2));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(n, t2_y));
+ expr_ref m_t2(mk_concat(m, t2), mgr);
+ expr_ref t2_y(mk_concat(t2, y), mgr);
+ expr_ref or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
+ or_item.push_back(or_item_option);
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(x, m_t2)));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(n, t2_y)));
expr_ref m_plus_t2(m_autil.mk_add(mk_strlen(m), mk_strlen(t2)), mgr);
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x), m_plus_t2));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(x), m_plus_t2)));
// want len(x) > len(m) and len(n) > len(y)
- and_item[pos++] = ctx.mk_eq_atom(or_item[option],
+ and_item.push_back(ctx.mk_eq_atom(or_item_option,
mgr.mk_not(m_autil.mk_le(
m_autil.mk_add(mk_strlen(x), m_autil.mk_mul(mk_int(-1), mk_strlen(m))),
- mk_int(0))) );
- and_item[pos++] = ctx.mk_eq_atom(or_item[option],
+ mk_int(0))) ));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option,
mgr.mk_not(m_autil.mk_le(
m_autil.mk_add(mk_strlen(n), m_autil.mk_mul(mk_int(-1), mk_strlen(y))),
- mk_int(0))) );
+ mk_int(0))) ));
option++;
@@ -2997,22 +3001,20 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
if (can_two_nodes_eq(x, m) && can_two_nodes_eq(y, n)) {
- or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(x, m));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, n));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)));
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n)));
+ expr_ref or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
+ or_item.push_back(or_item_option);
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(x, m)));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(y, n)));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m))));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n))));
++option;
}
if (option > 0) {
- if (option == 1) {
- and_item[0] = or_item[0];
- } else {
- and_item[0] = mgr.mk_or(option, or_item);
- }
+ and_item.push_back(mk_or(or_item));
+
expr_ref premise(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
- expr_ref conclusion(mgr.mk_and(pos, and_item), mgr);
+ expr_ref conclusion(mk_and(and_item), mgr);
assert_implication(premise, conclusion);
} else {
TRACE("t_str", tout << "STOP: no split option found for two EQ concats." << std::endl;);
From 11d8ffc4d430a8bf553a2df84639455a416f7868 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 22 Nov 2016 18:21:40 -0500
Subject: [PATCH 257/401] escape characters in theory_str
---
src/ast/str_decl_plugin.cpp | 64 +++++++++++++++++++++++++++++++++
src/ast/str_decl_plugin.h | 7 ++++
src/parsers/smt2/smt2parser.cpp | 2 +-
3 files changed, 72 insertions(+), 1 deletion(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 4f9dcb7aa..f17551b94 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -339,6 +339,70 @@ str_util::str_util(ast_manager &m) :
m_fid = m_plugin->get_family_id();
}
+/*
+ * Scan through the string 'val' and interpret each instance of "backslash followed by a character"
+ * as a possible escape sequence. Emit all other characters as-is.
+ * This exists because the SMT-LIB 2.5 standard does not recognize escape sequences other than "" -> " .
+ * The escape sequences recognized are as follows:
+ * \a \b \e \f \n \r \t \v : as specified by the C++ standard
+ * \ooo : produces the ASCII character corresponding to the octal value "ooo", where each "o" is a
+ * single octal digit and between 1 and 3 valid digits are given
+ * \xhh : produces the ASCII character corresponding to the hexadecimal value "hh", where each "h" is a
+ * single case-insensitive hex digit (0-9A-F) and exactly 2 digits are given
+ * \C, for any character C that does not start a legal escape sequence : the backslash is ignored and "C" is produced.
+ */
+app * str_util::mk_string_with_escape_characters(std::string & val) {
+ std::string parsedStr;
+ parsedStr.reserve(val.length());
+ for (unsigned i = 0; i < val.length(); ++i) {
+ char nextChar = val.at(i);
+
+ if (nextChar == '\\') {
+ // check escape sequence
+ i++;
+ if (i >= val.length()) {
+ // TODO illegal escape sequence
+ NOT_IMPLEMENTED_YET();
+ }
+ char escapeChar1 = val.at(i);
+ if (escapeChar1 == 'a') {
+ parsedStr.push_back('\a');
+ } else if (escapeChar1 == 'b') {
+ parsedStr.push_back('\b');
+ } else if (escapeChar1 == 'e') {
+ parsedStr.push_back('\e');
+ } else if (escapeChar1 == 'f') {
+ parsedStr.push_back('\f');
+ } else if (escapeChar1 == 'n') {
+ parsedStr.push_back('\n');
+ } else if (escapeChar1 == 'r') {
+ parsedStr.push_back('\r');
+ } else if (escapeChar1 == 't') {
+ parsedStr.push_back('\t');
+ } else if (escapeChar1 == 'v') {
+ parsedStr.push_back('\v');
+ } else if (escapeChar1 == 'x') {
+ // TODO hex escape
+ NOT_IMPLEMENTED_YET();
+ } else if (escapeChar1 == '0' || escapeChar1 == '1' || escapeChar1 == '2' || escapeChar1 == '3' ||
+ escapeChar1 == '4' || escapeChar1 == '5' || escapeChar1 == '6' || escapeChar1 == '7') {
+ // TODO octal escape
+ NOT_IMPLEMENTED_YET();
+ } else {
+ // unrecognized escape sequence -- just emit that character
+ parsedStr.push_back(escapeChar1);
+ }
+ } else {
+ parsedStr.push_back(nextChar);
+ }
+
+ // i is incremented at the end of this loop.
+ // If it is modified, ensure that it points to the index before
+ // the next character.
+ }
+ return mk_string(parsedStr);
+}
+
static std::string str2RegexStr(std::string str) {
std::string res = "";
int len = str.size();
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 8905d66bc..ff531e942 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -156,10 +156,17 @@ public:
app * mk_string(std::string & val) {
return m_plugin->mk_string(val);
}
+
app * mk_fresh_string() {
return m_plugin->mk_fresh_string();
}
+ app * mk_string_with_escape_characters(const char * val) {
+ std::string str(val);
+ return mk_string_with_escape_characters(str);
+ }
+ app * mk_string_with_escape_characters(std::string & val);
+
app * mk_re_Str2Reg(expr * s) {
expr * es[1] = {s};
return m_manager.mk_app(get_fid(), OP_RE_STR2REGEX, 1, es);
diff --git a/src/parsers/smt2/smt2parser.cpp b/src/parsers/smt2/smt2parser.cpp
index c8e9a78b6..cdef41b72 100644
--- a/src/parsers/smt2/smt2parser.cpp
+++ b/src/parsers/smt2/smt2parser.cpp
@@ -1104,7 +1104,7 @@ namespace smt2 {
strncpy(buf, original_token, bufsize);
buf[bufsize] = '\0';
TRACE("parse_string", tout << "new string constant: " << buf << " length=" << bufsize << "\n";);
- expr_stack().push_back(strutil().mk_string(buf));
+ expr_stack().push_back(strutil().mk_string_with_escape_characters(buf));
next();
}
From 8e962aa427e7a10ee315b9b3868fac7a8920a497 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 22 Nov 2016 18:32:03 -0500
Subject: [PATCH 258/401] escape chars in smt2 printing of string constants
---
src/ast/ast_smt2_pp.cpp | 43 +++++++++++++++++++++++++++++++------
src/ast/str_decl_plugin.cpp | 4 +++-
2 files changed, 40 insertions(+), 7 deletions(-)
diff --git a/src/ast/ast_smt2_pp.cpp b/src/ast/ast_smt2_pp.cpp
index ce7177ec9..eece67a32 100644
--- a/src/ast/ast_smt2_pp.cpp
+++ b/src/ast/ast_smt2_pp.cpp
@@ -305,14 +305,45 @@ format * smt2_pp_environment::mk_float(rational const & val) const {
}
format * smt2_pp_environment::pp_str_literal(app * t) {
- TRACE("parse_string", tout << "pp_str_literal\n";);
- str_util & u = get_strutil();
- SASSERT(u.is_string(t));
- const char * val;
- u.is_string(t, &val);
ast_manager & m = get_manager();
+ str_util & u = get_strutil();
+ TRACE("parse_string", tout << "pp_str_literal\n";);
+
+ SASSERT(u.is_string(t));
+ std::string strVal = u.get_string_constant_value(t);
string_buffer<> buf;
- buf << "\"" << val << "\"";
+ buf << "\"";
+
+ // we want to scan strVal and escape every non-printable character
+ for (unsigned int i = 0; i < strVal.length(); ++i) {
+ char c = strVal.at(i);
+ if (isprint(c)) {
+ buf << c;
+ } else if (c == '\a') {
+ buf << "\\a";
+ } else if (c == '\b') {
+ buf << "\\b";
+ } else if (c == '\e') {
+ buf << "\\e";
+ } else if (c == '\f') {
+ buf << "\\f";
+ } else if (c == '\n') {
+ buf << "\\n";
+ } else if (c == '\r') {
+ buf << "\\r";
+ } else if (c == '\t') {
+ buf << "\\t";
+ } else if (c == '\v') {
+ buf << "\\v";
+ } else if (c == '\\') {
+ buf << "\\" << "\\";
+ } else {
+ // TODO general hex escape
+ NOT_IMPLEMENTED_YET();
+ }
+ }
+
+ buf << "\"";
return mk_string(m, buf.c_str());
}
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index f17551b94..8ac1f722f 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -344,7 +344,7 @@ str_util::str_util(ast_manager &m) :
* as a possible escape sequence. Emit all other characters as-is.
* This exists because the SMT-LIB 2.5 standard does not recognize escape sequences other than "" -> " .
* The escape sequences recognized are as follows:
- * \a \b \e \f \n \r \t \v : as specified by the C++ standard
+ * \a \b \e \f \n \r \t \v \\ : as specified by the C++ standard
* \ooo : produces the ASCII character corresponding to the octal value "ooo", where each "o" is a
* single octal digit and between 1 and 3 valid digits are given
* \xhh : produces the ASCII character corresponding to the hexadecimal value "hh", where each "h" is a
@@ -381,6 +381,8 @@ app * str_util::mk_string_with_escape_characters(std::string & val) {
parsedStr.push_back('\t');
} else if (escapeChar1 == 'v') {
parsedStr.push_back('\v');
+ } else if (escapeChar1 == '\\') {
+ parsedStr.push_back('\\');
} else if (escapeChar1 == 'x') {
// TODO hex escape
NOT_IMPLEMENTED_YET();
From 889b6be2c3eb5d78613ceb46df98e290c12c2fde Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 23 Nov 2016 19:03:53 -0500
Subject: [PATCH 259/401] fix smt-lib 2.5 double quotes in pp
---
src/ast/ast_smt2_pp.cpp | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/src/ast/ast_smt2_pp.cpp b/src/ast/ast_smt2_pp.cpp
index eece67a32..7e178b422 100644
--- a/src/ast/ast_smt2_pp.cpp
+++ b/src/ast/ast_smt2_pp.cpp
@@ -317,7 +317,10 @@ format * smt2_pp_environment::pp_str_literal(app * t) {
// we want to scan strVal and escape every non-printable character
for (unsigned int i = 0; i < strVal.length(); ++i) {
char c = strVal.at(i);
- if (isprint(c)) {
+ if (c == '"') {
+ // SMT-LIB 2.5 string escape
+ buf << "\"\"";
+ } else if (isprint(c)) {
buf << c;
} else if (c == '\a') {
buf << "\\a";
From 1fa8129c8f063a5508a63f2450c5c0184429e7ca Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 25 Nov 2016 18:02:24 -0500
Subject: [PATCH 260/401] pretty-printing of general escape sequences for
string literals
---
src/ast/ast_smt2_pp.cpp | 10 ++++++++--
1 file changed, 8 insertions(+), 2 deletions(-)
diff --git a/src/ast/ast_smt2_pp.cpp b/src/ast/ast_smt2_pp.cpp
index 7e178b422..ed634069c 100644
--- a/src/ast/ast_smt2_pp.cpp
+++ b/src/ast/ast_smt2_pp.cpp
@@ -341,8 +341,14 @@ format * smt2_pp_environment::pp_str_literal(app * t) {
} else if (c == '\\') {
buf << "\\" << "\\";
} else {
- // TODO general hex escape
- NOT_IMPLEMENTED_YET();
+ // general hex escape
+ buf << "\\x";
+ unsigned int cVal = (unsigned int)c;
+ const char convtable[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+ unsigned int highPart = cVal / 16;
+ unsigned int lowPart = cVal % 16;
+ SASSERT(highPart < 16); SASSERT(lowPart < 16);
+ buf << convtable[highPart] << convtable[lowPart];
}
}
From 8c33dfab39c380ab5162b712bbab024fecb61cf8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 27 Nov 2016 20:51:34 -0500
Subject: [PATCH 261/401] fix escape character overflow print
---
src/ast/ast_smt2_pp.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/ast/ast_smt2_pp.cpp b/src/ast/ast_smt2_pp.cpp
index ed634069c..db2043320 100644
--- a/src/ast/ast_smt2_pp.cpp
+++ b/src/ast/ast_smt2_pp.cpp
@@ -343,7 +343,7 @@ format * smt2_pp_environment::pp_str_literal(app * t) {
} else {
// general hex escape
buf << "\\x";
- unsigned int cVal = (unsigned int)c;
+ unsigned int cVal = ((unsigned int)c) & 0x000000FF;
const char convtable[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
unsigned int highPart = cVal / 16;
unsigned int lowPart = cVal % 16;
From 1e65511a3f86084c8fdcaf1e8e6445091dcef43b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Nov 2016 16:21:26 -0500
Subject: [PATCH 262/401] save a few functions to trail in theory_str
---
src/smt/theory_str.cpp | 3 +++
1 file changed, 3 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a34a6b8c1..ca27169ed 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -662,6 +662,7 @@ app * theory_str::mk_unroll(expr * n, expr * bound) {
expr * args[2] = {n, bound};
app * unrollFunc = get_manager().mk_app(get_id(), OP_RE_UNROLL, 0, 0, 2, args);
+ m_trail.push_back(unrollFunc);
expr_ref_vector items(m);
items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(bound, mk_int(0)), ctx.mk_eq_atom(unrollFunc, m_strutil.mk_string(""))));
@@ -677,6 +678,7 @@ app * theory_str::mk_unroll(expr * n, expr * bound) {
app * theory_str::mk_contains(expr * haystack, expr * needle) {
expr * args[2] = {haystack, needle};
app * contains = get_manager().mk_app(get_id(), OP_STR_CONTAINS, 0, 0, 2, args);
+ m_trail.push_back(contains);
// immediately force internalization so that axiom setup does not fail
get_context().internalize(contains, false);
set_up_axioms(contains);
@@ -686,6 +688,7 @@ app * theory_str::mk_contains(expr * haystack, expr * needle) {
app * theory_str::mk_indexof(expr * haystack, expr * needle) {
expr * args[2] = {haystack, needle};
app * indexof = get_manager().mk_app(get_id(), OP_STR_INDEXOF, 0, 0, 2, args);
+ m_trail.push_back(indexof);
// immediately force internalization so that axiom setup does not fail
get_context().internalize(indexof, false);
set_up_axioms(indexof);
From b77f6666dc82cd5976ef4f9916e4e0aba8865955 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Nov 2016 18:40:28 -0500
Subject: [PATCH 263/401] refactor process_concat_eq_type_6 to use
expr_ref_vector
---
src/smt/theory_str.cpp | 52 +++++++++++++++++++++++-------------------
1 file changed, 28 insertions(+), 24 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ca27169ed..6c584fa2e 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2272,19 +2272,14 @@ expr * theory_str::simplify_concat(expr * node) {
if (in_same_eqc(node, resultAst)) {
TRACE("t_str_detail", tout << "SKIP: both concats are already in the same equivalence class" << std::endl;);
} else {
- // TODO refactor
- expr ** items = alloc_svect(expr*, resolvedMap.size());
+ expr_ref_vector items(m);
int pos = 0;
std::map<expr*, expr*>::iterator itor = resolvedMap.begin();
for (; itor != resolvedMap.end(); ++itor) {
- items[pos++] = ctx.mk_eq_atom(itor->first, itor->second);
- }
- expr_ref premise(m);
- if (pos == 1) {
- premise = items[0];
- } else {
- premise = m.mk_and(pos, items);
+ items.push_back(ctx.mk_eq_atom(itor->first, itor->second));
+ pos += 1;
}
+ expr_ref premise(mk_and(items), m);
expr_ref conclusion(ctx.mk_eq_atom(node, resultAst), m);
assert_implication(premise, conclusion);
}
@@ -3961,22 +3956,26 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
refresh_theory_var(commonVar);
}
- expr ** or_item = alloc_svect(expr*, (overlapLen.size() + 1));
+ expr_ref_vector or_item(mgr);
int option = 0;
- expr ** and_item = alloc_svect(expr*, (1 + 4 * (overlapLen.size() + 1)));
+ expr_ref_vector and_item(mgr);
int pos = 1;
if (!avoidLoopCut || !has_self_cut(m, y)) {
- or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+ expr_ref or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
+ or_item.push_back(or_item_option);
expr_ref str1_commonVar(mk_concat(str1Ast, commonVar), mgr);
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(m, str1_commonVar));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(m, str1_commonVar)));
+ pos += 1;
expr_ref commonVar_str2(mk_concat(commonVar, str2Ast), mgr);
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(y, commonVar_str2));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(y, commonVar_str2)));
+ pos += 1;
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(m),
- m_autil.mk_add(mk_strlen(str1Ast), mk_strlen(commonVar)) ));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(m),
+ m_autil.mk_add(mk_strlen(str1Ast), mk_strlen(commonVar)) )));
+ pos += 1;
// addItems[0] = mk_length(t, commonVar);
// addItems[1] = mk_length(t, str2Ast);
@@ -3993,29 +3992,34 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
int overLen = *itor;
std::string prefix = str1Value.substr(0, str1Len - overLen);
std::string suffix = str2Value.substr(overLen, str2Len - overLen);
- or_item[option] = ctx.mk_eq_atom(xorFlag, mk_int(option));
+ expr_ref or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
+ or_item.push_back(or_item_option);
expr_ref prefixAst(m_strutil.mk_string(prefix), mgr);
expr_ref x_eq_prefix(ctx.mk_eq_atom(m, prefixAst), mgr);
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], x_eq_prefix);
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, x_eq_prefix));
+ pos += 1;
- and_item[pos++] = ctx.mk_eq_atom(or_item[option],
- ctx.mk_eq_atom(mk_strlen(m), mk_strlen(prefixAst)));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option,
+ ctx.mk_eq_atom(mk_strlen(m), mk_strlen(prefixAst))));
+ pos += 1;
// adding length constraint for _ = constStr seems slowing things down.
expr_ref suffixAst(m_strutil.mk_string(suffix), mgr);
expr_ref y_eq_suffix(ctx.mk_eq_atom(y, suffixAst), mgr);
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], y_eq_suffix);
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, y_eq_suffix));
+ pos += 1;
- and_item[pos++] = ctx.mk_eq_atom(or_item[option], ctx.mk_eq_atom(mk_strlen(y), mk_strlen(suffixAst)));
+ and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(y), mk_strlen(suffixAst))));
+ pos += 1;
option++;
}
// case 6: concat("str1", y) = concat(m, "str2")
- and_item[0] = mgr.mk_or(option, or_item);
- expr_ref implyR(mgr.mk_and(pos, and_item), mgr);
+ and_item.push_back(mk_or(or_item));
+ expr_ref implyR(mk_and(and_item), mgr);
assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
}
From f968f79d1c5e4f6bc696a62a77ce140dd61f5a5b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Nov 2016 18:47:42 -0500
Subject: [PATCH 264/401] refactor solve_concat_eq_str to use expr_ref_vector
---
src/smt/theory_str.cpp | 37 ++++++++++++++++---------------------
1 file changed, 16 insertions(+), 21 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 6c584fa2e..ea1ae8677 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -5824,19 +5824,16 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
if (arg1 != a1 || arg2 != a2) {
TRACE("t_str", tout << "resolved concat argument(s) to eqc string constants" << std::endl;);
int iPos = 0;
- app * item1[2];
+ expr_ref_vector item1(m);
if (a1 != arg1) {
- item1[iPos++] = ctx.mk_eq_atom(a1, arg1);
+ item1.push_back(ctx.mk_eq_atom(a1, arg1));
+ iPos += 1;
}
if (a2 != arg2) {
- item1[iPos++] = ctx.mk_eq_atom(a2, arg2);
- }
- expr_ref implyL1(m);
- if (iPos == 1) {
- implyL1 = item1[0];
- } else {
- implyL1 = m.mk_and(item1[0], item1[1]);
+ item1.push_back(ctx.mk_eq_atom(a2, arg2));
+ iPos += 1;
}
+ expr_ref implyL1(mk_and(item1), m);
newConcat = mk_concat(arg1, arg2);
if (newConcat != str) {
expr_ref implyR1(ctx.mk_eq_atom(concat, newConcat), m);
@@ -6091,8 +6088,8 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
int xor_pos = 0;
int and_count = 1;
- expr ** xor_items = alloc_svect(expr*, (concatStrLen+1));
- expr ** and_items = alloc_svect(expr*, (4 * (concatStrLen+1) + 1));
+ expr_ref_vector xor_items(m);
+ expr_ref_vector and_items(m);
for (int i = 0; i < concatStrLen + 1; ++i) {
std::string prefixStr = const_str.substr(0, i);
@@ -6105,15 +6102,18 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
continue;
}
expr_ref xorAst(ctx.mk_eq_atom(xorFlag, m_autil.mk_numeral(rational(xor_pos), true)), m);
- xor_items[xor_pos++] = xorAst;
+ xor_items.push_back(xorAst);
+ xor_pos += 1;
expr_ref prefixAst(m_strutil.mk_string(prefixStr), m);
expr_ref arg1_eq (ctx.mk_eq_atom(arg1, prefixAst), m);
- and_items[and_count++] = ctx.mk_eq_atom(xorAst, arg1_eq);
+ and_items.push_back(ctx.mk_eq_atom(xorAst, arg1_eq));
+ and_count += 1;
expr_ref suffixAst(m_strutil.mk_string(suffixStr), m);
expr_ref arg2_eq (ctx.mk_eq_atom(arg2, suffixAst), m);
- and_items[and_count++] = ctx.mk_eq_atom(xorAst, arg2_eq);
+ and_items.push_back(ctx.mk_eq_atom(xorAst, arg2_eq));
+ and_count += 1;
}
expr_ref implyL(ctx.mk_eq_atom(concat, str), m);
@@ -6124,13 +6124,8 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
expr_ref negate_ast(m.mk_not(concat_eq_str), m);
assert_axiom(negate_ast);
} else {
- if (xor_pos == 1) {
- and_items[0] = xor_items[0];
- implyR1 = m.mk_and(and_count, and_items);
- } else {
- and_items[0] = m.mk_or(xor_pos, xor_items);
- implyR1 = m.mk_and(and_count, and_items);
- }
+ and_items.push_back(mk_or(xor_items));
+ implyR1 = mk_and(and_items);
assert_implication(implyL, implyR1);
}
} /* (arg1Len != 1 || arg2Len != 1) */
From 361f02ef1dc8ea0c3eeb9c5d993cc4e15e0dbab6 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 28 Nov 2016 21:34:55 -0500
Subject: [PATCH 265/401] remove assignment refcount hack from
theory_str::pop_scope_eh
---
src/smt/theory_str.cpp | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ea1ae8677..37be73333 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6686,8 +6686,9 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
// TODO: figure out what's going out of scope and why
context & ctx = get_context();
ast_manager & m = get_manager();
- expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
+
+ // expr_ref_vector assignments(m);
+ // ctx.get_assignments(assignments);
TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
@@ -8254,6 +8255,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
// ----------------------------------------------------------------------------------------
+ // TODO refactor this and below to use expr_ref_vector instead of ptr_vector/svect
ptr_vector<expr> orList;
ptr_vector<expr> andList;
From 947d4437266ae05a397f024ae622406631ffc090 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 29 Nov 2016 19:46:37 -0500
Subject: [PATCH 266/401] improved regex concat rewrite
---
src/ast/rewriter/str_rewriter.cpp | 22 ++++++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 1 +
2 files changed, 23 insertions(+)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 875343655..e30e857b2 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -489,6 +489,25 @@ br_status str_rewriter::mk_re_RegexStar(expr * re, expr_ref & result) {
}
}
+br_status str_rewriter::mk_re_RegexConcat(expr * r0, expr * r1, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (RegexConcat " << mk_pp(r0, m()) << " " << mk_pp(r1, m()) << ")" << std::endl;);
+ // (RegexConcat (Str2Reg "A") (Str2Reg "B")) --> (Str2Reg "AB")
+ if (m_strutil.is_re_Str2Reg(r0) && m_strutil.is_re_Str2Reg(r1)) {
+ expr * r0str = to_app(r0)->get_arg(0);
+ expr * r1str = to_app(r1)->get_arg(0);
+ ENSURE(m_strutil.is_string(r0str));
+ ENSURE(m_strutil.is_string(r1str));
+ std::string r0val = m_strutil.get_string_constant_value(r0str);
+ std::string r1val = m_strutil.get_string_constant_value(r1str);
+ std::string simplifyVal = r0val + r1val;
+ TRACE("t_str_rw", tout << "RegexConcat fast path: both sides are Str2Reg, simplify to (Str2Reg \"" << simplifyVal << "\")" << std::endl;);
+ result = m_strutil.mk_re_Str2Reg(simplifyVal);
+ return BR_DONE;
+ }
+
+ return BR_FAILED;
+}
+
br_status str_rewriter::mk_re_RegexPlus(expr * re, expr_ref & result) {
/*
* Two optimizations are possible if we inspect 're'.
@@ -596,6 +615,9 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_RE_REGEXSTAR:
SASSERT(num_args == 1);
return mk_re_RegexStar(args[0], result);
+ case OP_RE_REGEXCONCAT:
+ SASSERT(num_args == 2);
+ return mk_re_RegexConcat(args[0], args[1], result);
case OP_RE_REGEXCHARRANGE:
SASSERT(num_args == 2);
return mk_re_RegexCharRange(args[0], args[1], result);
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index 822fb1ea8..145c0193e 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -60,6 +60,7 @@ public:
br_status mk_re_RegexIn(expr * str, expr * re, expr_ref & result);
br_status mk_re_RegexPlus(expr * re, expr_ref & result);
br_status mk_re_RegexStar(expr * re, expr_ref & result);
+ br_status mk_re_RegexConcat(expr * r0, expr * r1, expr_ref & result);
br_status mk_re_RegexCharRange(expr * start, expr * end, expr_ref & result);
bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
From edf151c9a0a3b0b69803f9944c6fc88bf1443a76 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 29 Nov 2016 21:46:00 -0500
Subject: [PATCH 267/401] testing term generation refactor in
theory_str::check_length_const_string
---
src/smt/theory_str.cpp | 23 +++++++++++++++++++++--
1 file changed, 21 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 37be73333..76b605ff9 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -5453,6 +5453,7 @@ bool theory_str::can_two_nodes_eq(expr * n1, expr * n2) {
// case 0: n1_curr is const string, n2_curr is const string
if (is_string(n1_curr) && is_string(n2_curr)) {
if (n1_curr != n2_curr) {
+ // TODO confirm whether it's okay to compare the pointers like this
return false;
}
}
@@ -5494,8 +5495,18 @@ bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
rational strLen((unsigned) (m_strutil.get_string_constant_value(constStr).length()));
if (is_concat(to_app(n1))) {
+ /*
+ * This has been refactored from Z3str2.
+ * We avoid creating new subexpressions until we actually detect a conflict.
+ * This may avoid a bit of overhead incurred by creating these terms.
+ */
+
ptr_vector<expr> args;
- expr_ref_vector items(mgr);
+
+ expr_ref_vector eq_args(mgr);
+ vector<rational> eq_lens;
+ // foreach (arg, len) in zip(eq_args, eq_lens):
+ // generate eq(mk_strlen(arg), mk_int(len))
get_nodes_in_concat(n1, args);
@@ -5505,12 +5516,20 @@ bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
bool argLen_exists = get_len_value(args[i], argLen);
if (argLen_exists) {
if (!m_strutil.is_string(args[i])) {
- items.push_back(ctx.mk_eq_atom(mk_strlen(args[i]), mk_int(argLen)));
+ // items.push_back(ctx.mk_eq_atom(mk_strlen(args[i]), mk_int(argLen)));
+ eq_args.push_back(args[i]);
+ eq_lens.push_back(rational(argLen));
}
TRACE("t_str_detail", tout << "concat arg: " << mk_pp(args[i], mgr) << " has len = " << argLen.to_string() << std::endl;);
sumLen += argLen;
if (sumLen > strLen) {
+ expr_ref_vector items(mgr);
items.push_back(ctx.mk_eq_atom(n1, constStr));
+ for (unsigned int z = 0; z < eq_args.size(); ++z) {
+ expr * arg = eq_args.get(z);
+ rational len = eq_lens.get(z);
+ items.push_back(ctx.mk_eq_atom(mk_strlen(arg), mk_int(len)));
+ }
expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
TRACE("t_str_detail", tout << "inconsistent length: concat (len = " << sumLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
assert_axiom(toAssert);
From 599cc1e75d616c4640c1813bf2d26076372e18eb Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 30 Nov 2016 13:08:42 -0500
Subject: [PATCH 268/401] ref_vector refactoring in
theory_str::check_length_concat_concat
---
src/smt/theory_str.cpp | 25 ++++++++++++++++++++-----
1 file changed, 20 insertions(+), 5 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 76b605ff9..84adf819d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -5569,7 +5569,13 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
bool concat1LenFixed = true;
bool concat2LenFixed = true;
- expr_ref_vector items(mgr);
+ /*
+ * Refactored from the Z3str2 version.
+ * We delay creation of new terms until a conflict
+ * is actually detected.
+ */
+ expr_ref_vector eq_args(mgr);
+ vector<rational> eq_lens;
rational sum1(0), sum2(0);
@@ -5580,7 +5586,9 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
if (argLen_exists) {
sum1 += argLen;
if (!m_strutil.is_string(oneArg)) {
- items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
+ // items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
+ eq_args.push_back(oneArg);
+ eq_lens.push_back(rational(argLen));
}
} else {
concat1LenFixed = false;
@@ -5594,15 +5602,15 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
if (argLen_exists) {
sum2 += argLen;
if (!m_strutil.is_string(oneArg)) {
- items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
+ // items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
+ eq_args.push_back(oneArg);
+ eq_lens.push_back(rational(argLen));
}
} else {
concat2LenFixed = false;
}
}
- items.push_back(ctx.mk_eq_atom(n1, n2));
-
bool conflict = false;
if (concat1LenFixed && concat2LenFixed) {
@@ -5621,6 +5629,13 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
if (conflict) {
TRACE("t_str_detail", tout << "inconsistent length detected in concat <==> concat" << std::endl;);
+ expr_ref_vector items(mgr);
+ for (unsigned int z = 0; z < eq_args.size(); ++z) {
+ expr * arg = eq_args.get(z);
+ rational len = eq_lens.get(z);
+ items.push_back(ctx.mk_eq_atom(mk_strlen(arg), mk_int(len)));
+ }
+ items.push_back(ctx.mk_eq_atom(n1, n2));
expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
assert_axiom(toAssert);
return false;
From fd1bf65b6472b883203ea3f0fecb33ee028c66df Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 30 Nov 2016 15:52:58 -0500
Subject: [PATCH 269/401] experimental non-reuse of XOR vars in theory_str
---
src/smt/theory_str.cpp | 22 ++++++++++------------
1 file changed, 10 insertions(+), 12 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 84adf819d..ec0a432d1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2815,13 +2815,12 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
if (entry1InScope) {
t1 = varForBreakConcat[key1][0];
t2 = varForBreakConcat[key1][1];
- xorFlag = varForBreakConcat[key1][2];
+ xorFlag = mk_internal_xor_var();
} else {
t1 = varForBreakConcat[key2][0];
t2 = varForBreakConcat[key2][1];
- xorFlag = varForBreakConcat[key2][2];
+ xorFlag = mk_internal_xor_var();
}
- // TODO do I need to refresh the xorFlag, which is an integer var, and if so, how?
refresh_theory_var(t1);
refresh_theory_var(t2);
}
@@ -3141,12 +3140,11 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
} else {
if (entry1InScope) {
temp1 = varForBreakConcat[key1][0];
- xorFlag = varForBreakConcat[key1][1];
+ xorFlag = mk_internal_xor_var();
} else if (entry2InScope) {
temp1 = varForBreakConcat[key2][0];
- xorFlag = varForBreakConcat[key2][1];
+ xorFlag = mk_internal_xor_var();
}
- // TODO refresh xorFlag?
refresh_theory_var(temp1);
}
@@ -3451,10 +3449,10 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
} else {
if (entry1InScope) {
temp1 = varForBreakConcat[key1][0];
- xorFlag = varForBreakConcat[key1][1];
+ xorFlag = mk_internal_xor_var();
} else if (varForBreakConcat.find(key2) != varForBreakConcat.end()) {
temp1 = varForBreakConcat[key2][0];
- xorFlag = varForBreakConcat[key2][1];
+ xorFlag = mk_internal_xor_var();
}
refresh_theory_var(temp1);
}
@@ -3948,10 +3946,10 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
} else {
if (entry1InScope) {
commonVar = (entry1->second)[0];
- xorFlag = (entry1->second)[1];
+ xorFlag = mk_internal_xor_var();
} else {
commonVar = (entry2->second)[0];
- xorFlag = (entry2->second)[1];
+ xorFlag = mk_internal_xor_var();
}
refresh_theory_var(commonVar);
}
@@ -6113,9 +6111,9 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
xorFlag = mk_internal_xor_var();
varForBreakConcat[key1][0] = xorFlag;
} else if (entry1InScope) {
- xorFlag = varForBreakConcat[key1][0];
+ xorFlag = mk_internal_xor_var();
} else { // entry2InScope
- xorFlag = varForBreakConcat[key2][0];
+ xorFlag = mk_internal_xor_var();
}
int concatStrLen = const_str.length();
From 170e2b4e2a56b1bbcafcf104ead8f16baa2fc054 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 30 Nov 2016 19:41:00 -0500
Subject: [PATCH 270/401] refactor theory_str::check_length_concat_var
---
src/smt/theory_str.cpp | 20 ++++++++++++++++++--
1 file changed, 18 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ec0a432d1..bc73db405 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -5652,7 +5652,15 @@ bool theory_str::check_length_concat_var(expr * concat, expr * var) {
} else {
rational sumLen(0);
ptr_vector<expr> args;
- expr_ref_vector items(mgr);
+
+ /*
+ * Refactor from the Z3str2 version.
+ * Only generate new terms if a conflict is actually detected.
+ */
+
+ expr_ref_vector eq_args(mgr);
+ vector<rational> eq_lens;
+
get_nodes_in_concat(concat, args);
for (unsigned int i = 0; i < args.size(); ++i) {
expr * oneArg = args[i];
@@ -5660,11 +5668,19 @@ bool theory_str::check_length_concat_var(expr * concat, expr * var) {
bool argLen_exists = get_len_value(oneArg, argLen);
if (argLen_exists) {
if (!m_strutil.is_string(oneArg) && !argLen.is_zero()) {
- items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
+ // items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
+ eq_args.push_back(oneArg);
+ eq_lens.push_back(rational(argLen));
}
sumLen += argLen;
if (sumLen > varLen) {
TRACE("t_str_detail", tout << "inconsistent length detected in concat <==> var" << std::endl;);
+ expr_ref_vector items(mgr);
+ for (unsigned int z = 0; z < eq_args.size(); ++z) {
+ expr * arg = eq_args.get(z);
+ rational len = eq_lens.get(z);
+ items.push_back(ctx.mk_eq_atom(mk_strlen(arg), mk_int(len)));
+ }
items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_int(varLen)));
items.push_back(ctx.mk_eq_atom(concat, var));
expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
From 10c0d94cf2a7834efed103d01f2c3d498045040e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 1 Dec 2016 15:19:50 -0500
Subject: [PATCH 271/401] Revert "refactor theory_str::check_length_concat_var"
This reverts commit 170e2b4e2a56b1bbcafcf104ead8f16baa2fc054.
---
src/smt/theory_str.cpp | 20 ++------------------
1 file changed, 2 insertions(+), 18 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index bc73db405..ec0a432d1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -5652,15 +5652,7 @@ bool theory_str::check_length_concat_var(expr * concat, expr * var) {
} else {
rational sumLen(0);
ptr_vector<expr> args;
-
- /*
- * Refactor from the Z3str2 version.
- * Only generate new terms if a conflict is actually detected.
- */
-
- expr_ref_vector eq_args(mgr);
- vector<rational> eq_lens;
-
+ expr_ref_vector items(mgr);
get_nodes_in_concat(concat, args);
for (unsigned int i = 0; i < args.size(); ++i) {
expr * oneArg = args[i];
@@ -5668,19 +5660,11 @@ bool theory_str::check_length_concat_var(expr * concat, expr * var) {
bool argLen_exists = get_len_value(oneArg, argLen);
if (argLen_exists) {
if (!m_strutil.is_string(oneArg) && !argLen.is_zero()) {
- // items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
- eq_args.push_back(oneArg);
- eq_lens.push_back(rational(argLen));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
}
sumLen += argLen;
if (sumLen > varLen) {
TRACE("t_str_detail", tout << "inconsistent length detected in concat <==> var" << std::endl;);
- expr_ref_vector items(mgr);
- for (unsigned int z = 0; z < eq_args.size(); ++z) {
- expr * arg = eq_args.get(z);
- rational len = eq_lens.get(z);
- items.push_back(ctx.mk_eq_atom(mk_strlen(arg), mk_int(len)));
- }
items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_int(varLen)));
items.push_back(ctx.mk_eq_atom(concat, var));
expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
From 548f635f7ed1094d8aa84ead6f6acd80951eb4d4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 1 Dec 2016 15:19:50 -0500
Subject: [PATCH 272/401] Revert "experimental non-reuse of XOR vars in
theory_str"
This reverts commit fd1bf65b6472b883203ea3f0fecb33ee028c66df.
---
src/smt/theory_str.cpp | 22 ++++++++++++----------
1 file changed, 12 insertions(+), 10 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ec0a432d1..84adf819d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2815,12 +2815,13 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
if (entry1InScope) {
t1 = varForBreakConcat[key1][0];
t2 = varForBreakConcat[key1][1];
- xorFlag = mk_internal_xor_var();
+ xorFlag = varForBreakConcat[key1][2];
} else {
t1 = varForBreakConcat[key2][0];
t2 = varForBreakConcat[key2][1];
- xorFlag = mk_internal_xor_var();
+ xorFlag = varForBreakConcat[key2][2];
}
+ // TODO do I need to refresh the xorFlag, which is an integer var, and if so, how?
refresh_theory_var(t1);
refresh_theory_var(t2);
}
@@ -3140,11 +3141,12 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
} else {
if (entry1InScope) {
temp1 = varForBreakConcat[key1][0];
- xorFlag = mk_internal_xor_var();
+ xorFlag = varForBreakConcat[key1][1];
} else if (entry2InScope) {
temp1 = varForBreakConcat[key2][0];
- xorFlag = mk_internal_xor_var();
+ xorFlag = varForBreakConcat[key2][1];
}
+ // TODO refresh xorFlag?
refresh_theory_var(temp1);
}
@@ -3449,10 +3451,10 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
} else {
if (entry1InScope) {
temp1 = varForBreakConcat[key1][0];
- xorFlag = mk_internal_xor_var();
+ xorFlag = varForBreakConcat[key1][1];
} else if (varForBreakConcat.find(key2) != varForBreakConcat.end()) {
temp1 = varForBreakConcat[key2][0];
- xorFlag = mk_internal_xor_var();
+ xorFlag = varForBreakConcat[key2][1];
}
refresh_theory_var(temp1);
}
@@ -3946,10 +3948,10 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
} else {
if (entry1InScope) {
commonVar = (entry1->second)[0];
- xorFlag = mk_internal_xor_var();
+ xorFlag = (entry1->second)[1];
} else {
commonVar = (entry2->second)[0];
- xorFlag = mk_internal_xor_var();
+ xorFlag = (entry2->second)[1];
}
refresh_theory_var(commonVar);
}
@@ -6111,9 +6113,9 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
xorFlag = mk_internal_xor_var();
varForBreakConcat[key1][0] = xorFlag;
} else if (entry1InScope) {
- xorFlag = mk_internal_xor_var();
+ xorFlag = varForBreakConcat[key1][0];
} else { // entry2InScope
- xorFlag = mk_internal_xor_var();
+ xorFlag = varForBreakConcat[key2][0];
}
int concatStrLen = const_str.length();
From b020c71f8a8ddbd01addb88269cb582459ecc204 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 1 Dec 2016 15:19:51 -0500
Subject: [PATCH 273/401] Revert "ref_vector refactoring in
theory_str::check_length_concat_concat"
This reverts commit 599cc1e75d616c4640c1813bf2d26076372e18eb.
---
src/smt/theory_str.cpp | 25 +++++--------------------
1 file changed, 5 insertions(+), 20 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 84adf819d..76b605ff9 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -5569,13 +5569,7 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
bool concat1LenFixed = true;
bool concat2LenFixed = true;
- /*
- * Refactored from the Z3str2 version.
- * We delay creation of new terms until a conflict
- * is actually detected.
- */
- expr_ref_vector eq_args(mgr);
- vector<rational> eq_lens;
+ expr_ref_vector items(mgr);
rational sum1(0), sum2(0);
@@ -5586,9 +5580,7 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
if (argLen_exists) {
sum1 += argLen;
if (!m_strutil.is_string(oneArg)) {
- // items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
- eq_args.push_back(oneArg);
- eq_lens.push_back(rational(argLen));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
}
} else {
concat1LenFixed = false;
@@ -5602,15 +5594,15 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
if (argLen_exists) {
sum2 += argLen;
if (!m_strutil.is_string(oneArg)) {
- // items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
- eq_args.push_back(oneArg);
- eq_lens.push_back(rational(argLen));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
}
} else {
concat2LenFixed = false;
}
}
+ items.push_back(ctx.mk_eq_atom(n1, n2));
+
bool conflict = false;
if (concat1LenFixed && concat2LenFixed) {
@@ -5629,13 +5621,6 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
if (conflict) {
TRACE("t_str_detail", tout << "inconsistent length detected in concat <==> concat" << std::endl;);
- expr_ref_vector items(mgr);
- for (unsigned int z = 0; z < eq_args.size(); ++z) {
- expr * arg = eq_args.get(z);
- rational len = eq_lens.get(z);
- items.push_back(ctx.mk_eq_atom(mk_strlen(arg), mk_int(len)));
- }
- items.push_back(ctx.mk_eq_atom(n1, n2));
expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
assert_axiom(toAssert);
return false;
From 406b622f59c92caa59f7e2713f4d6f8d67d32ae4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 1 Dec 2016 15:19:51 -0500
Subject: [PATCH 274/401] Revert "testing term generation refactor in
theory_str::check_length_const_string"
This reverts commit edf151c9a0a3b0b69803f9944c6fc88bf1443a76.
---
src/smt/theory_str.cpp | 23 ++---------------------
1 file changed, 2 insertions(+), 21 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 76b605ff9..37be73333 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -5453,7 +5453,6 @@ bool theory_str::can_two_nodes_eq(expr * n1, expr * n2) {
// case 0: n1_curr is const string, n2_curr is const string
if (is_string(n1_curr) && is_string(n2_curr)) {
if (n1_curr != n2_curr) {
- // TODO confirm whether it's okay to compare the pointers like this
return false;
}
}
@@ -5495,18 +5494,8 @@ bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
rational strLen((unsigned) (m_strutil.get_string_constant_value(constStr).length()));
if (is_concat(to_app(n1))) {
- /*
- * This has been refactored from Z3str2.
- * We avoid creating new subexpressions until we actually detect a conflict.
- * This may avoid a bit of overhead incurred by creating these terms.
- */
-
ptr_vector<expr> args;
-
- expr_ref_vector eq_args(mgr);
- vector<rational> eq_lens;
- // foreach (arg, len) in zip(eq_args, eq_lens):
- // generate eq(mk_strlen(arg), mk_int(len))
+ expr_ref_vector items(mgr);
get_nodes_in_concat(n1, args);
@@ -5516,20 +5505,12 @@ bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
bool argLen_exists = get_len_value(args[i], argLen);
if (argLen_exists) {
if (!m_strutil.is_string(args[i])) {
- // items.push_back(ctx.mk_eq_atom(mk_strlen(args[i]), mk_int(argLen)));
- eq_args.push_back(args[i]);
- eq_lens.push_back(rational(argLen));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(args[i]), mk_int(argLen)));
}
TRACE("t_str_detail", tout << "concat arg: " << mk_pp(args[i], mgr) << " has len = " << argLen.to_string() << std::endl;);
sumLen += argLen;
if (sumLen > strLen) {
- expr_ref_vector items(mgr);
items.push_back(ctx.mk_eq_atom(n1, constStr));
- for (unsigned int z = 0; z < eq_args.size(); ++z) {
- expr * arg = eq_args.get(z);
- rational len = eq_lens.get(z);
- items.push_back(ctx.mk_eq_atom(mk_strlen(arg), mk_int(len)));
- }
expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
TRACE("t_str_detail", tout << "inconsistent length: concat (len = " << sumLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
assert_axiom(toAssert);
From 35ad68d9b5726f60f75a790164ccd69786182277 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 5 Dec 2016 15:13:48 -0500
Subject: [PATCH 275/401] assert stronger arrangements theory_str
---
src/smt/theory_str.cpp | 128 +++++++++++++++++++++++++++++++++++------
src/smt/theory_str.h | 9 +++
2 files changed, 120 insertions(+), 17 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 37be73333..3c6ad60ca 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -44,6 +44,7 @@ theory_str::theory_str(ast_manager & m):
opt_CheckVariableScope(true),
opt_UseFastLengthTesterCache(true),
opt_UseFastValueTesterCache(true),
+ opt_AssertStrongerArrangements(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -2864,7 +2865,12 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(t1, sLevel, m);
add_cut_info_merge(t1, sLevel, y);
- assert_implication(ax_l, ax_r);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, ax_r);
+ }
} else {
loopDetected = true;
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
@@ -2911,7 +2917,12 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(t2, sLevel, x);
add_cut_info_merge(t2, sLevel, n);
- assert_implication(ax_l, ax_r);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, ax_r);
+ }
} else {
loopDetected = true;
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
@@ -3013,7 +3024,12 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr_ref premise(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
expr_ref conclusion(mk_and(and_item), mgr);
- assert_implication(premise, conclusion);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(premise, conclusion), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(premise, conclusion);
+ }
} else {
TRACE("t_str", tout << "STOP: no split option found for two EQ concats." << std::endl;);
}
@@ -3206,7 +3222,12 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(temp1, sLevel, y);
add_cut_info_merge(temp1, sLevel, m);
- assert_implication(ax_l, ax_r);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, ax_r);
+ }
} else {
loopDetected = true;
TRACE("t_str", tout << "AVOID LOOP: SKIP" << std::endl;);
@@ -3269,7 +3290,12 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
expr_ref ax_l(mk_and(l_items), mgr);
expr_ref ax_r(mk_and(r_items), mgr);
- assert_implication(ax_l, ax_r);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, ax_r);
+ }
} else {
// negate! It's impossible to split str with these lengths
TRACE("t_str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
@@ -3329,7 +3355,14 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
if (option > 0) {
and_item.push_back(mk_or(or_item));
expr_ref implyR(mk_and(and_item), mgr);
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+
+ if (opt_AssertStrongerArrangements) {
+ expr_ref implyLHS(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref ax_strong(ctx.mk_eq_atom(implyLHS, implyR), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
} else {
TRACE("t_str", tout << "STOP: Should not split two EQ concats." << std::endl;);
}
@@ -3508,7 +3541,13 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
expr_ref_vector r_items(mgr);
r_items.push_back(ctx.mk_eq_atom(x, prefixAst));
r_items.push_back(ctx.mk_eq_atom(y, suf_n_concat));
- assert_implication(ax_l, mk_and(r_items));
+
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, mk_and(r_items)), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, mk_and(r_items));
+ }
} else {
// negate! It's impossible to split str with these lengths
TRACE("t_str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
@@ -3522,7 +3561,13 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n))), mgr);
expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x, strAst), ctx.mk_eq_atom(y, n)), mgr);
- assert_implication(ax_l, ax_r);
+
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, ax_r);
+ }
}
else if (splitType == 2) {
// | x | y |
@@ -3555,7 +3600,12 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(temp1, sLevel, x);
add_cut_info_merge(temp1, sLevel, n);
- assert_implication(ax_l, ax_r);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, ax_r);
+ }
} else {
loopDetected = true;
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
@@ -3633,7 +3683,14 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
and_item.push_back(mk_or(or_item));
}
expr_ref implyR(mk_and(and_item), mgr);
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_lhs(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_lhs, implyR), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
} else {
TRACE("t_str", tout << "STOP: should not split two eq. concats" << std::endl;);
}
@@ -3708,13 +3765,24 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
if (!in_same_eqc(tmpAst, n)) {
// break down option 4-1
expr_ref implyR(ctx.mk_eq_atom(n, tmpAst), mgr);
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
}
} else if (str1Len == str2Len) {
if (!in_same_eqc(n, y)) {
//break down option 4-2
expr_ref implyR(ctx.mk_eq_atom(n, y), mgr);
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
}
} else {
std::string deltaStr = str2Value.substr(str1Len, str2Len - str1Len);
@@ -3722,7 +3790,12 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
if (!in_same_eqc(y, tmpAst)) {
//break down option 4-3
expr_ref implyR(ctx.mk_eq_atom(y, tmpAst), mgr);
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
}
}
}
@@ -3794,20 +3867,35 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
expr_ref x_deltaStr(mk_concat(x, m_strutil.mk_string(deltaStr)), mgr);
if (!in_same_eqc(m, x_deltaStr)) {
expr_ref implyR(ctx.mk_eq_atom(m, x_deltaStr), mgr);
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
}
} else if (str1Len == str2Len) {
// test
if (!in_same_eqc(x, m)) {
expr_ref implyR(ctx.mk_eq_atom(x, m), mgr);
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
}
} else {
std::string deltaStr = str2Value.substr(0, str2Len - str1Len);
expr_ref m_deltaStr(mk_concat(m, m_strutil.mk_string(deltaStr)), mgr);
if (!in_same_eqc(x, m_deltaStr)) {
expr_ref implyR(ctx.mk_eq_atom(x, m_deltaStr), mgr);
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
}
}
}
@@ -4020,7 +4108,13 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
// case 6: concat("str1", y) = concat(m, "str2")
and_item.push_back(mk_or(or_item));
expr_ref implyR(mk_and(and_item), mgr);
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
}
void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 5b8f644eb..8168d0632 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -189,6 +189,15 @@ namespace smt {
*/
bool opt_UseFastValueTesterCache;
+ /*
+ * If AssertStrongerArrangements is set to true,
+ * the implications that would normally be asserted during arrangement generation
+ * will instead be asserted as equivalences.
+ * This is a stronger version of the regular axiom.
+ * The default (Z3str2) behaviour is to set this to false.
+ */
+ bool opt_AssertStrongerArrangements;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
From be9cb8db82d56493401817ef5bac6a5ee4affd47 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 5 Dec 2016 20:17:43 -0500
Subject: [PATCH 276/401] regex tracing theory_str
---
src/ast/rewriter/str_rewriter.cpp | 2 +-
src/smt/theory_str.cpp | 1 +
2 files changed, 2 insertions(+), 1 deletion(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index e30e857b2..bc64e7218 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -456,10 +456,10 @@ br_status str_rewriter::mk_re_RegexIn(expr * str, expr * re, expr_ref & result)
// fast path:
// (RegexIn E (Str2Reg S)) --> (= E S)
if (m_strutil.is_re_Str2Reg(re)) {
- TRACE("t_str_rw", tout << "RegexIn fast path: " << mk_pp(str, m()) << " in " << mk_pp(re, m()) << std::endl;);
expr * regexStr = to_app(re)->get_arg(0);
ENSURE(m_strutil.is_string(regexStr));
result = m().mk_eq(str, regexStr);
+ TRACE("t_str_rw", tout << "RegexIn fast path: " << mk_pp(str, m()) << " in " << mk_pp(re, m()) << " ==> " << mk_pp(result, m()) << std::endl;);
return BR_REWRITE_FULL;
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 37be73333..543adcc03 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1708,6 +1708,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
expr_ref finalAxiom(m.mk_iff(ex, rhs), m);
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
+ TRACE("t_str", tout << "set up Str2Reg: (RegexIn " << mk_pp(str, m) << " " << mk_pp(regex, m) << ")" << std::endl;);
} else if (is_RegexConcat(regex)) {
expr_ref var1(mk_regex_rep_var(), m);
expr_ref var2(mk_regex_rep_var(), m);
From da61c99f9e880edf1e7b6540e4b3012c96f62ce5 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 6 Dec 2016 12:52:48 -0500
Subject: [PATCH 277/401] experimental boolean case split in theory_str
process_concat_eq_type1 WIP
---
src/smt/theory_str.cpp | 93 +++++++++++++++++++++++++++---------------
src/smt/theory_str.h | 2 +
2 files changed, 62 insertions(+), 33 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 84091e2da..3d22427d5 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2443,6 +2443,30 @@ void theory_str::infer_len_concat_equality(expr * nn1, expr * nn2) {
*/
}
+expr_ref theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr_ref_vector result(m);
+
+ // TODO this can probably be made more efficient
+
+ for (unsigned int majorIndex = 0; majorIndex < terms.size(); ++majorIndex) {
+ for (unsigned int minorIndex = 0; minorIndex < terms.size(); ++minorIndex) {
+ if (majorIndex == minorIndex) {
+ continue;
+ }
+ // generate an expression of the form
+ // terms[majorIndex] --> NOT(terms[minorIndex])
+ expr_ref ex(rewrite_implication(terms.get(majorIndex), m.mk_not(terms.get(minorIndex))), m);
+ result.push_back(ex);
+ }
+ }
+
+ expr_ref final_result(mk_and(result), m);
+ return final_result;
+}
+
/*
* Handle two equivalent Concats.
*/
@@ -2931,40 +2955,42 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
} else if (splitType == -1) {
// Here we don't really have a choice. We have no length information at all...
- expr_ref_vector or_item(mgr);
- expr_ref_vector and_item(mgr);
+
+ // This vector will eventually contain one term for each possible arrangement we explore.
+ expr_ref_vector arrangement_disjunction(mgr);
+
int option = 0;
int pos = 1;
// break option 1: m cuts y
// len(x) < len(m) || len(y) > len(n)
if (!avoidLoopCut || !has_self_cut(m, y)) {
+ expr_ref_vector and_item(mgr);
// break down option 1-1
expr_ref x_t1(mk_concat(x, t1), mgr);
expr_ref t1_n(mk_concat(t1, n), mgr);
- expr_ref or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
- or_item.push_back(or_item_option);
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(m, x_t1)));
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(y, t1_n)));
+
+ and_item.push_back(ctx.mk_eq_atom(m, x_t1));
+ and_item.push_back(ctx.mk_eq_atom(y, t1_n));
expr_ref x_plus_t1(m_autil.mk_add(mk_strlen(x), mk_strlen(t1)), mgr);
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(m), x_plus_t1)));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(m), x_plus_t1));
// These were crashing the solver because the integer theory
// expects a constant on the right-hand side.
// The things we want to assert here are len(m) > len(x) and len(y) > len(n).
// We rewrite A > B as A-B > 0 and then as not(A-B <= 0),
// and then, *because we aren't allowed to use subtraction*,
// as not(A + -1*B <= 0)
- and_item.push_back(ctx.mk_eq_atom(or_item_option,
+ and_item.push_back(
mgr.mk_not(m_autil.mk_le(
m_autil.mk_add(mk_strlen(m), m_autil.mk_mul(mk_int(-1), mk_strlen(x))),
- mk_int(0))) ));
- and_item.push_back(ctx.mk_eq_atom(or_item_option,
+ mk_int(0))) );
+ and_item.push_back(
mgr.mk_not(m_autil.mk_le(
m_autil.mk_add(mk_strlen(y),m_autil.mk_mul(mk_int(-1), mk_strlen(n))),
- mk_int(0))) ));
+ mk_int(0))) );
- option++;
+ arrangement_disjunction.push_back(mk_and(and_item));
add_cut_info_merge(t1, ctx.get_scope_level(), m);
add_cut_info_merge(t1, ctx.get_scope_level(), y);
@@ -2977,30 +3003,30 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
// break option 2:
// x = m || y = n
if (!avoidLoopCut || !has_self_cut(x, n)) {
+ expr_ref_vector and_item(mgr);
// break down option 1-2
expr_ref m_t2(mk_concat(m, t2), mgr);
expr_ref t2_y(mk_concat(t2, y), mgr);
- expr_ref or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
- or_item.push_back(or_item_option);
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(x, m_t2)));
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(n, t2_y)));
+
+ and_item.push_back(ctx.mk_eq_atom(x, m_t2));
+ and_item.push_back(ctx.mk_eq_atom(n, t2_y));
expr_ref m_plus_t2(m_autil.mk_add(mk_strlen(m), mk_strlen(t2)), mgr);
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(x), m_plus_t2)));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(x), m_plus_t2));
// want len(x) > len(m) and len(n) > len(y)
- and_item.push_back(ctx.mk_eq_atom(or_item_option,
+ and_item.push_back(
mgr.mk_not(m_autil.mk_le(
m_autil.mk_add(mk_strlen(x), m_autil.mk_mul(mk_int(-1), mk_strlen(m))),
- mk_int(0))) ));
- and_item.push_back(ctx.mk_eq_atom(or_item_option,
+ mk_int(0))) );
+ and_item.push_back(
mgr.mk_not(m_autil.mk_le(
m_autil.mk_add(mk_strlen(n), m_autil.mk_mul(mk_int(-1), mk_strlen(y))),
- mk_int(0))) ));
+ mk_int(0))) );
- option++;
+ arrangement_disjunction.push_back(mk_and(and_item));
add_cut_info_merge(t2, ctx.get_scope_level(), x);
add_cut_info_merge(t2, ctx.get_scope_level(), n);
@@ -3011,26 +3037,27 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
if (can_two_nodes_eq(x, m) && can_two_nodes_eq(y, n)) {
- expr_ref or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
- or_item.push_back(or_item_option);
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(x, m)));
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(y, n)));
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m))));
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n))));
- ++option;
+ expr_ref_vector and_item(mgr);
+
+ and_item.push_back(ctx.mk_eq_atom(x, m));
+ and_item.push_back(ctx.mk_eq_atom(y, n));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n)));
+
+ arrangement_disjunction.push_back(mk_and(and_item));
}
- if (option > 0) {
- and_item.push_back(mk_or(or_item));
-
+ if (!arrangement_disjunction.empty()) {
expr_ref premise(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
- expr_ref conclusion(mk_and(and_item), mgr);
+ expr_ref conclusion(mk_or(arrangement_disjunction), mgr);
if (opt_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(premise, conclusion), mgr);
assert_axiom(ax_strong);
} else {
assert_implication(premise, conclusion);
}
+ // assert mutual exclusion between each branch of the arrangement
+ assert_axiom(generate_mutual_exclusion(arrangement_disjunction));
} else {
TRACE("t_str", tout << "STOP: no split option found for two EQ concats." << std::endl;);
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 8168d0632..29f5c2336 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -478,6 +478,8 @@ namespace smt {
void process_concat_eq_type5(expr * concatAst1, expr * concatAst2);
void process_concat_eq_type6(expr * concatAst1, expr * concatAst2);
+ expr_ref generate_mutual_exclusion(expr_ref_vector & exprs);
+
bool new_eq_check(expr * lhs, expr * rhs);
void group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts);
From b57f04e2d2c74d124d72765964cae95475287f3b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 6 Dec 2016 12:59:40 -0500
Subject: [PATCH 278/401] optimize generate_mutual_exclusion in theory_str to
make only half as many subterms
---
src/smt/theory_str.cpp | 7 +------
1 file changed, 1 insertion(+), 6 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3d22427d5..4b38d02d3 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2449,13 +2449,8 @@ expr_ref theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
expr_ref_vector result(m);
- // TODO this can probably be made more efficient
-
for (unsigned int majorIndex = 0; majorIndex < terms.size(); ++majorIndex) {
- for (unsigned int minorIndex = 0; minorIndex < terms.size(); ++minorIndex) {
- if (majorIndex == minorIndex) {
- continue;
- }
+ for (unsigned int minorIndex = majorIndex + 1; minorIndex < terms.size(); ++minorIndex) {
// generate an expression of the form
// terms[majorIndex] --> NOT(terms[minorIndex])
expr_ref ex(rewrite_implication(terms.get(majorIndex), m.mk_not(terms.get(minorIndex))), m);
From 225b527d5832848bc80bc3406b3fafde36d581a8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 6 Dec 2016 16:09:38 -0500
Subject: [PATCH 279/401] boolean case split theory_str process_concat_eq_type2
---
src/smt/theory_str.cpp | 35 +++++++++++++++++------------------
1 file changed, 17 insertions(+), 18 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 4b38d02d3..ef86be313 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3328,8 +3328,8 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
} else {
// Split type -1: no idea about the length...
int optionTotal = 2 + strValue.length();
- expr_ref_vector or_item(mgr);
- expr_ref_vector and_item(mgr);
+ expr_ref_vector arrangement_disjunction(mgr);
+
int option = 0;
int pos = 1;
@@ -3339,16 +3339,16 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
if (can_two_nodes_eq(y, temp1_strAst)) {
if (!avoidLoopCut || !has_self_cut(m, y)) {
// break down option 2-1
- expr_ref current_or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
- or_item.push_back(current_or_item_option);
+ expr_ref_vector and_item(mgr);
+
expr_ref x_temp1(mk_concat(x, temp1), mgr);
- and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(m, x_temp1)));
- and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(y, temp1_strAst)));
+ and_item.push_back(ctx.mk_eq_atom(m, x_temp1));
+ and_item.push_back(ctx.mk_eq_atom(y, temp1_strAst));
- and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(mk_strlen(m),
- m_autil.mk_add(mk_strlen(x), mk_strlen(temp1)))));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(m),
+ m_autil.mk_add(mk_strlen(x), mk_strlen(temp1))));
- ++option;
+ arrangement_disjunction.push_back(mk_and(and_item));
add_cut_info_merge(temp1, ctx.get_scope_level(), y);
add_cut_info_merge(temp1, ctx.get_scope_level(), m);
} else {
@@ -3366,18 +3366,16 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
expr_ref cropStr(m_strutil.mk_string(part2Str), mgr);
if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
// break down option 2-2
- expr_ref current_or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
- or_item.push_back(current_or_item_option);
- and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(x, x_concat)));
- and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(y, cropStr)));
- and_item.push_back(ctx.mk_eq_atom(current_or_item_option, ctx.mk_eq_atom(mk_strlen(y), mk_int(part2Str.length()))));
- ++option;
+ expr_ref_vector and_item(mgr);
+ and_item.push_back(ctx.mk_eq_atom(x, x_concat));
+ and_item.push_back(ctx.mk_eq_atom(y, cropStr));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(part2Str.length())));
+ arrangement_disjunction.push_back(mk_and(and_item));
}
}
- if (option > 0) {
- and_item.push_back(mk_or(or_item));
- expr_ref implyR(mk_and(and_item), mgr);
+ if (!arrangement_disjunction.empty()) {
+ expr_ref implyR(mk_or(arrangement_disjunction), mgr);
if (opt_AssertStrongerArrangements) {
expr_ref implyLHS(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
@@ -3386,6 +3384,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
} else {
assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
}
+ assert_axiom(generate_mutual_exclusion(arrangement_disjunction));
} else {
TRACE("t_str", tout << "STOP: Should not split two EQ concats." << std::endl;);
}
From 7b0aaf874554704af8561810285c69c42a451d97 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 6 Dec 2016 16:22:42 -0500
Subject: [PATCH 280/401] boolean case split theory_str concat_eq remaining
cases
---
src/smt/theory_str.cpp | 77 ++++++++++++++++++++----------------------
1 file changed, 37 insertions(+), 40 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ef86be313..d524bffe7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3643,9 +3643,9 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
else {
// Split type -1. We know nothing about the length...
- expr_ref_vector or_item(mgr);
+ expr_ref_vector arrangement_disjunction(mgr);
unsigned option = 0;
- expr_ref_vector and_item(mgr);
+
int pos = 1;
for (int i = 0; i <= (int) strValue.size(); i++) {
std::string part1Str = strValue.substr(0, i);
@@ -3655,17 +3655,18 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
expr_ref y_concat(mk_concat(suffixStr, n), mgr);
if (can_two_nodes_eq(x, cropStr) && can_two_nodes_eq(y, y_concat)) {
+ expr_ref_vector and_item(mgr);
// break down option 3-1
expr_ref x_eq_str(ctx.mk_eq_atom(x, cropStr), mgr);
- or_item.push_back(ctx.mk_eq_atom(xorFlag, mk_int(option)));
- and_item.push_back(ctx.mk_eq_atom(or_item.get(option), x_eq_str)); ++pos;
- and_item.push_back(ctx.mk_eq_atom(or_item.get(option), ctx.mk_eq_atom(y, y_concat)));
- and_item.push_back(ctx.mk_eq_atom(or_item.get(option), ctx.mk_eq_atom(mk_strlen(x), mk_strlen(cropStr)))); ++pos;
+ and_item.push_back(x_eq_str); ++pos;
+ and_item.push_back(ctx.mk_eq_atom(y, y_concat));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_strlen(cropStr))); ++pos;
+
// and_item[pos++] = Z3_mk_eq(ctx, or_item[option], Z3_mk_eq(ctx, mk_length(t, y), mk_length(t, y_concat)));
-
// adding length constraint for _ = constStr seems slowing things down.
- option++;
+
+ arrangement_disjunction.push_back(mk_and(and_item));
}
}
@@ -3678,15 +3679,16 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
if (can_two_nodes_eq(x, strAst_temp1)) {
if (!avoidLoopCut || !(has_self_cut(x, n))) {
// break down option 3-2
- or_item.push_back(ctx.mk_eq_atom(xorFlag, mk_int(option)));
+ expr_ref_vector and_item(mgr);
expr_ref temp1_y(mk_concat(temp1, y), mgr);
- and_item.push_back(ctx.mk_eq_atom(or_item.get(option), ctx.mk_eq_atom(x, strAst_temp1))); ++pos;
- and_item.push_back(ctx.mk_eq_atom(or_item.get(option), ctx.mk_eq_atom(n, temp1_y))); ++pos;
+ and_item.push_back(ctx.mk_eq_atom(x, strAst_temp1)); ++pos;
+ and_item.push_back(ctx.mk_eq_atom(n, temp1_y)); ++pos;
- and_item.push_back(ctx.mk_eq_atom(or_item.get(option), ctx.mk_eq_atom(mk_strlen(x),
- m_autil.mk_add(mk_strlen(strAst), mk_strlen(temp1)) )) ); ++pos;
- option++;
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(x),
+ m_autil.mk_add(mk_strlen(strAst), mk_strlen(temp1)) ) ); ++pos;
+
+ arrangement_disjunction.push_back(mk_and(and_item));
add_cut_info_merge(temp1, sLevel, x);
add_cut_info_merge(temp1, sLevel, n);
@@ -3698,13 +3700,8 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
}
- if (option > 0) {
- if (option == 1) {
- and_item.push_back(or_item.get(0));
- } else {
- and_item.push_back(mk_or(or_item));
- }
- expr_ref implyR(mk_and(and_item), mgr);
+ if (!arrangement_disjunction.empty()) {
+ expr_ref implyR(mk_or(arrangement_disjunction), mgr);
if (opt_AssertStrongerArrangements) {
expr_ref ax_lhs(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
@@ -3713,6 +3710,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
} else {
assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
}
+ assert_axiom(generate_mutual_exclusion(arrangement_disjunction));
} else {
TRACE("t_str", tout << "STOP: should not split two eq. concats" << std::endl;);
}
@@ -4066,32 +4064,30 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
refresh_theory_var(commonVar);
}
- expr_ref_vector or_item(mgr);
+ expr_ref_vector arrangement_disjunction(mgr);
int option = 0;
- expr_ref_vector and_item(mgr);
int pos = 1;
if (!avoidLoopCut || !has_self_cut(m, y)) {
- expr_ref or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
- or_item.push_back(or_item_option);
+ expr_ref_vector and_item(mgr);
expr_ref str1_commonVar(mk_concat(str1Ast, commonVar), mgr);
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(m, str1_commonVar)));
+ and_item.push_back(ctx.mk_eq_atom(m, str1_commonVar));
pos += 1;
expr_ref commonVar_str2(mk_concat(commonVar, str2Ast), mgr);
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(y, commonVar_str2)));
+ and_item.push_back(ctx.mk_eq_atom(y, commonVar_str2));
pos += 1;
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(m),
- m_autil.mk_add(mk_strlen(str1Ast), mk_strlen(commonVar)) )));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(m),
+ m_autil.mk_add(mk_strlen(str1Ast), mk_strlen(commonVar)) ));
pos += 1;
// addItems[0] = mk_length(t, commonVar);
// addItems[1] = mk_length(t, str2Ast);
// and_item[pos++] = Z3_mk_eq(ctx, or_item[option], Z3_mk_eq(ctx, mk_length(t, y), Z3_mk_add(ctx, 2, addItems)));
- option++;
+ arrangement_disjunction.push_back(mk_and(and_item));
} else {
loopDetected = true;
TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
@@ -4102,34 +4098,34 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
int overLen = *itor;
std::string prefix = str1Value.substr(0, str1Len - overLen);
std::string suffix = str2Value.substr(overLen, str2Len - overLen);
- expr_ref or_item_option(ctx.mk_eq_atom(xorFlag, mk_int(option)), mgr);
- or_item.push_back(or_item_option);
+
+ expr_ref_vector and_item(mgr);
expr_ref prefixAst(m_strutil.mk_string(prefix), mgr);
expr_ref x_eq_prefix(ctx.mk_eq_atom(m, prefixAst), mgr);
- and_item.push_back(ctx.mk_eq_atom(or_item_option, x_eq_prefix));
+ and_item.push_back(x_eq_prefix);
pos += 1;
- and_item.push_back(ctx.mk_eq_atom(or_item_option,
- ctx.mk_eq_atom(mk_strlen(m), mk_strlen(prefixAst))));
+ and_item.push_back(
+ ctx.mk_eq_atom(mk_strlen(m), mk_strlen(prefixAst)));
pos += 1;
// adding length constraint for _ = constStr seems slowing things down.
expr_ref suffixAst(m_strutil.mk_string(suffix), mgr);
expr_ref y_eq_suffix(ctx.mk_eq_atom(y, suffixAst), mgr);
- and_item.push_back(ctx.mk_eq_atom(or_item_option, y_eq_suffix));
+ and_item.push_back(y_eq_suffix);
pos += 1;
- and_item.push_back(ctx.mk_eq_atom(or_item_option, ctx.mk_eq_atom(mk_strlen(y), mk_strlen(suffixAst))));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_strlen(suffixAst)));
pos += 1;
- option++;
+ arrangement_disjunction.push_back(mk_and(and_item));
}
// case 6: concat("str1", y) = concat(m, "str2")
- and_item.push_back(mk_or(or_item));
- expr_ref implyR(mk_and(and_item), mgr);
+
+ expr_ref implyR(mk_or(arrangement_disjunction), mgr);
if (opt_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
@@ -4137,6 +4133,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
} else {
assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
}
+ assert_axiom(generate_mutual_exclusion(arrangement_disjunction));
}
void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr) {
From 515cd4a3f33cf2e4509cce349dc6cabb8260ee5c Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 8 Dec 2016 14:49:38 -0500
Subject: [PATCH 281/401] add boolean case split in
theory_str::solve_concat_eq_str
---
src/smt/theory_str.cpp | 26 +++++++++++++++-----------
1 file changed, 15 insertions(+), 11 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index d524bffe7..0f434900e 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6201,10 +6201,10 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
int xor_pos = 0;
int and_count = 1;
- expr_ref_vector xor_items(m);
- expr_ref_vector and_items(m);
+ expr_ref_vector arrangement_disjunction(m);
for (int i = 0; i < concatStrLen + 1; ++i) {
+ expr_ref_vector and_items(m);
std::string prefixStr = const_str.substr(0, i);
std::string suffixStr = const_str.substr(i, concatStrLen - i);
// skip invalid options
@@ -6214,32 +6214,36 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
if (is_concat(to_app(arg2)) && !can_concat_eq_str(arg2, suffixStr)) {
continue;
}
- expr_ref xorAst(ctx.mk_eq_atom(xorFlag, m_autil.mk_numeral(rational(xor_pos), true)), m);
- xor_items.push_back(xorAst);
- xor_pos += 1;
expr_ref prefixAst(m_strutil.mk_string(prefixStr), m);
expr_ref arg1_eq (ctx.mk_eq_atom(arg1, prefixAst), m);
- and_items.push_back(ctx.mk_eq_atom(xorAst, arg1_eq));
+ and_items.push_back(arg1_eq);
and_count += 1;
expr_ref suffixAst(m_strutil.mk_string(suffixStr), m);
expr_ref arg2_eq (ctx.mk_eq_atom(arg2, suffixAst), m);
- and_items.push_back(ctx.mk_eq_atom(xorAst, arg2_eq));
+ and_items.push_back(arg2_eq);
and_count += 1;
+
+ arrangement_disjunction.push_back(mk_and(and_items));
}
expr_ref implyL(ctx.mk_eq_atom(concat, str), m);
expr_ref implyR1(m);
- if (xor_pos == 0) {
+ if (arrangement_disjunction.empty()) {
// negate
expr_ref concat_eq_str(ctx.mk_eq_atom(concat, str), m);
expr_ref negate_ast(m.mk_not(concat_eq_str), m);
assert_axiom(negate_ast);
} else {
- and_items.push_back(mk_or(xor_items));
- implyR1 = mk_and(and_items);
- assert_implication(implyL, implyR1);
+ implyR1 = mk_or(arrangement_disjunction);
+ if (opt_AssertStrongerArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(implyL, implyR1), m);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(implyL, implyR1);
+ }
+ assert_axiom(generate_mutual_exclusion(arrangement_disjunction));
}
} /* (arg1Len != 1 || arg2Len != 1) */
} /* if (Concat(arg1, arg2) == NULL) */
From 737565180fbe21c20e7395b32fe40b51d93aeba2 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 9 Dec 2016 16:55:34 -0500
Subject: [PATCH 282/401] disable stronger arrangements in theory_str for now
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 0f434900e..92920c220 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -44,7 +44,7 @@ theory_str::theory_str(ast_manager & m):
opt_CheckVariableScope(true),
opt_UseFastLengthTesterCache(true),
opt_UseFastValueTesterCache(true),
- opt_AssertStrongerArrangements(true),
+ opt_AssertStrongerArrangements(false),
/* Internal setup */
search_started(false),
m_autil(m),
From e9411e5b8c6d80de3f8866071ae89cc4f7df431c Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 9 Dec 2016 17:12:29 -0500
Subject: [PATCH 283/401] explicitly re-introduce string axioms on refreshed
string theory vars this fixes at least one case (kaluza/unsat/big/9650.smt2)
where a string could have a negative length value due to a constraint that
went out of scope
---
src/smt/theory_str.cpp | 3 +++
1 file changed, 3 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 92920c220..a6d93e70b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -320,6 +320,9 @@ void theory_str::refresh_theory_var(expr * e) {
enode * en = ensure_enode(e);
theory_var v = mk_var(en);
TRACE("t_str_detail", tout << "refresh " << mk_pp(e, get_manager()) << ": v#" << v << std::endl;);
+ // TODO this is probably sub-optimal
+ // TODO case where the refreshed var must be non-empty?
+ m_basicstr_axiom_todo.push_back(en);
}
theory_var theory_str::mk_var(enode* n) {
From 09053b831dd6bb4948045d6a43ed24b636e00382 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 9 Dec 2016 17:23:39 -0500
Subject: [PATCH 284/401] enforce nonempty string constraint on refreshed
nonempty string vars
---
src/smt/theory_str.cpp | 34 ++++++++++++++++++++++++++++++----
src/smt/theory_str.h | 1 +
2 files changed, 31 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a6d93e70b..b9e9e748f 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -321,7 +321,6 @@ void theory_str::refresh_theory_var(expr * e) {
theory_var v = mk_var(en);
TRACE("t_str_detail", tout << "refresh " << mk_pp(e, get_manager()) << ": v#" << v << std::endl;);
// TODO this is probably sub-optimal
- // TODO case where the refreshed var must be non-empty?
m_basicstr_axiom_todo.push_back(en);
}
@@ -617,6 +616,28 @@ app * theory_str::mk_regex_rep_var() {
return a;
}
+void theory_str::add_nonempty_constraint(expr * s) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr_ref ax1(m.mk_not(ctx.mk_eq_atom(s, m_strutil.mk_string(""))), m);
+ assert_axiom(ax1);
+
+ {
+ // build LHS
+ expr_ref len_str(mk_strlen(s), m);
+ SASSERT(len_str);
+ // build RHS
+ expr_ref zero(m_autil.mk_numeral(rational(0), true), m);
+ SASSERT(zero);
+ // build LHS > RHS and assert
+ // we have to build !(LHS <= RHS) instead
+ expr_ref lhs_gt_rhs(m.mk_not(m_autil.mk_le(len_str, zero)), m);
+ SASSERT(lhs_gt_rhs);
+ assert_axiom(lhs_gt_rhs);
+ }
+}
+
app * theory_str::mk_nonempty_str_var() {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -639,14 +660,14 @@ app * theory_str::mk_nonempty_str_var() {
// assert a variation of the basic string axioms that ensures this string is nonempty
{
// build LHS
- expr * len_str = mk_strlen(a);
+ expr_ref len_str(mk_strlen(a), m);
SASSERT(len_str);
// build RHS
- expr * zero = m_autil.mk_numeral(rational(0), true);
+ expr_ref zero(m_autil.mk_numeral(rational(0), true), m);
SASSERT(zero);
// build LHS > RHS and assert
// we have to build !(LHS <= RHS) instead
- app * lhs_gt_rhs = m.mk_not(m_autil.mk_le(len_str, zero));
+ expr_ref lhs_gt_rhs(m.mk_not(m_autil.mk_le(len_str, zero)), m);
SASSERT(lhs_gt_rhs);
assert_axiom(lhs_gt_rhs);
}
@@ -2847,7 +2868,9 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
// TODO do I need to refresh the xorFlag, which is an integer var, and if so, how?
refresh_theory_var(t1);
+ add_nonempty_constraint(t1);
refresh_theory_var(t2);
+ add_nonempty_constraint(t2);
}
// For split types 0 through 2, we can get away with providing
@@ -3190,6 +3213,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
}
// TODO refresh xorFlag?
refresh_theory_var(temp1);
+ add_nonempty_constraint(temp1);
}
int splitType = -1;
@@ -3515,6 +3539,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
xorFlag = varForBreakConcat[key2][1];
}
refresh_theory_var(temp1);
+ add_nonempty_constraint(temp1);
}
@@ -4065,6 +4090,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
xorFlag = (entry2->second)[1];
}
refresh_theory_var(commonVar);
+ add_nonempty_constraint(commonVar);
}
expr_ref_vector arrangement_disjunction(mgr);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 29f5c2336..b3667bdec 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -341,6 +341,7 @@ namespace smt {
app * mk_regex_rep_var();
app * mk_unroll_bound_var();
app * mk_unroll_test_var();
+ void add_nonempty_constraint(expr * s);
bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
From f5bc17b864a7989b339bbe921aae1bf18f3ecbf0 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 13 Dec 2016 16:12:57 -0500
Subject: [PATCH 285/401] theory_str params module, WIP
---
src/smt/params/smt_params.h | 2 ++
src/smt/params/smt_params_helper.pyg | 3 +-
src/smt/params/theory_str_params.cpp | 24 ++++++++++++++++
src/smt/params/theory_str_params.h | 42 ++++++++++++++++++++++++++++
src/smt/smt_setup.cpp | 4 +--
src/smt/theory_str.cpp | 40 +++++++++++++-------------
src/smt/theory_str.h | 16 +++--------
7 files changed, 96 insertions(+), 35 deletions(-)
create mode 100644 src/smt/params/theory_str_params.cpp
create mode 100644 src/smt/params/theory_str_params.h
diff --git a/src/smt/params/smt_params.h b/src/smt/params/smt_params.h
index 9c1eec649..27071bd9e 100644
--- a/src/smt/params/smt_params.h
+++ b/src/smt/params/smt_params.h
@@ -25,6 +25,7 @@ Revision History:
#include"theory_arith_params.h"
#include"theory_array_params.h"
#include"theory_bv_params.h"
+#include"theory_str_params.h"
#include"theory_pb_params.h"
#include"theory_datatype_params.h"
#include"preprocessor_params.h"
@@ -75,6 +76,7 @@ struct smt_params : public preprocessor_params,
public theory_arith_params,
public theory_array_params,
public theory_bv_params,
+ public theory_str_params,
public theory_pb_params,
public theory_datatype_params {
bool m_display_proof;
diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg
index a9f6ccc18..49a786e69 100644
--- a/src/smt/params/smt_params_helper.pyg
+++ b/src/smt/params/smt_params_helper.pyg
@@ -61,5 +61,6 @@ def_module_params(module_name='smt',
('dack.gc', UINT, 2000, 'Dynamic ackermannization garbage collection frequency (per conflict)'),
('dack.gc_inv_decay', DOUBLE, 0.8, 'Dynamic ackermannization garbage collection decay'),
('dack.threshold', UINT, 10, ' number of times the congruence rule must be used before Leibniz\'s axiom is expanded'),
- ('core.validate', BOOL, False, 'validate unsat core produced by SMT context')
+ ('core.validate', BOOL, False, 'validate unsat core produced by SMT context'),
+ ('str.strong_arrangements', BOOL, True, 'assert equivalences instead of implications when generating string arrangement axioms')
))
diff --git a/src/smt/params/theory_str_params.cpp b/src/smt/params/theory_str_params.cpp
new file mode 100644
index 000000000..c1fcb0412
--- /dev/null
+++ b/src/smt/params/theory_str_params.cpp
@@ -0,0 +1,24 @@
+/*++
+Module Name:
+
+ theory_str_params.cpp
+
+Abstract:
+
+ Parameters for string theory plugin
+
+Author:
+
+ Murphy Berzish (mtrberzi) 2016-12-13
+
+Revision History:
+
+--*/
+
+#include"theory_str_params.h"
+#include"smt_params_helper.hpp"
+
+void theory_str_params::updt_params(params_ref const & _p) {
+ smt_params_helper p(_p);
+ m_AssertStrongerArrangements = p.str_strong_arrangements();
+}
diff --git a/src/smt/params/theory_str_params.h b/src/smt/params/theory_str_params.h
new file mode 100644
index 000000000..480ad1479
--- /dev/null
+++ b/src/smt/params/theory_str_params.h
@@ -0,0 +1,42 @@
+/*++
+Module Name:
+
+ theory_str_params.h
+
+Abstract:
+
+ Parameters for string theory plugin
+
+Author:
+
+ Murphy Berzish (mtrberzi) 2016-12-13
+
+Revision History:
+
+--*/
+
+#ifndef THEORY_STR_PARAMS_H
+#define THEORY_STR_PARAMS_H
+
+#include"params.h"
+
+struct theory_str_params {
+ /*
+ * If AssertStrongerArrangements is set to true,
+ * the implications that would normally be asserted during arrangement generation
+ * will instead be asserted as equivalences.
+ * This is a stronger version of the standard axiom.
+ * The Z3str2 axioms can be simulated by setting this to false.
+ */
+ bool m_AssertStrongerArrangements;
+
+ theory_str_params(params_ref const & p = params_ref()):
+ m_AssertStrongerArrangements(true)
+ {
+ updt_params(p);
+ }
+
+ void updt_params(params_ref const & p);
+};
+
+#endif /* THEORY_STR_PARAMS_H */
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index 117b606fd..7cbfd0b2e 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -707,7 +707,7 @@ namespace smt {
void setup::setup_QF_S() {
m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params));
- m_context.register_plugin(alloc(smt::theory_str, m_manager));
+ m_context.register_plugin(alloc(smt::theory_str, m_manager, m_params));
}
bool is_arith(static_features const & st) {
@@ -839,7 +839,7 @@ namespace smt {
void setup::setup_str() {
setup_arith();
- m_context.register_plugin(alloc(theory_str, m_manager));
+ m_context.register_plugin(alloc(theory_str, m_manager, m_params));
}
void setup::setup_unknown() {
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b9e9e748f..4eb15d6ad 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -29,8 +29,9 @@ Revision History:
namespace smt {
-theory_str::theory_str(ast_manager & m):
+theory_str::theory_str(ast_manager & m, theory_str_params const & params):
theory(m.mk_family_id("str")),
+ m_params(params),
/* Options */
opt_AggressiveLengthTesting(false),
opt_AggressiveValueTesting(false),
@@ -44,7 +45,6 @@ theory_str::theory_str(ast_manager & m):
opt_CheckVariableScope(true),
opt_UseFastLengthTesterCache(true),
opt_UseFastValueTesterCache(true),
- opt_AssertStrongerArrangements(false),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -2911,7 +2911,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(t1, sLevel, m);
add_cut_info_merge(t1, sLevel, y);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -2963,7 +2963,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(t2, sLevel, x);
add_cut_info_merge(t2, sLevel, n);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -3071,7 +3071,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
if (!arrangement_disjunction.empty()) {
expr_ref premise(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
expr_ref conclusion(mk_or(arrangement_disjunction), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(premise, conclusion), mgr);
assert_axiom(ax_strong);
} else {
@@ -3272,7 +3272,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(temp1, sLevel, y);
add_cut_info_merge(temp1, sLevel, m);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -3340,7 +3340,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
expr_ref ax_l(mk_and(l_items), mgr);
expr_ref ax_r(mk_and(r_items), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -3404,7 +3404,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
if (!arrangement_disjunction.empty()) {
expr_ref implyR(mk_or(arrangement_disjunction), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref implyLHS(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
expr_ref ax_strong(ctx.mk_eq_atom(implyLHS, implyR), mgr);
assert_axiom(ax_strong);
@@ -3592,7 +3592,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
r_items.push_back(ctx.mk_eq_atom(x, prefixAst));
r_items.push_back(ctx.mk_eq_atom(y, suf_n_concat));
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, mk_and(r_items)), mgr);
assert_axiom(ax_strong);
} else {
@@ -3612,7 +3612,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x, strAst), ctx.mk_eq_atom(y, n)), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -3650,7 +3650,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(temp1, sLevel, x);
add_cut_info_merge(temp1, sLevel, n);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -3731,7 +3731,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
if (!arrangement_disjunction.empty()) {
expr_ref implyR(mk_or(arrangement_disjunction), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_lhs(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
expr_ref ax_strong(ctx.mk_eq_atom(ax_lhs, implyR), mgr);
assert_axiom(ax_strong);
@@ -3813,7 +3813,7 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
if (!in_same_eqc(tmpAst, n)) {
// break down option 4-1
expr_ref implyR(ctx.mk_eq_atom(n, tmpAst), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -3825,7 +3825,7 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
//break down option 4-2
expr_ref implyR(ctx.mk_eq_atom(n, y), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -3838,7 +3838,7 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
if (!in_same_eqc(y, tmpAst)) {
//break down option 4-3
expr_ref implyR(ctx.mk_eq_atom(y, tmpAst), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -3915,7 +3915,7 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
expr_ref x_deltaStr(mk_concat(x, m_strutil.mk_string(deltaStr)), mgr);
if (!in_same_eqc(m, x_deltaStr)) {
expr_ref implyR(ctx.mk_eq_atom(m, x_deltaStr), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -3926,7 +3926,7 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
// test
if (!in_same_eqc(x, m)) {
expr_ref implyR(ctx.mk_eq_atom(x, m), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -3938,7 +3938,7 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
expr_ref m_deltaStr(mk_concat(m, m_strutil.mk_string(deltaStr)), mgr);
if (!in_same_eqc(x, m_deltaStr)) {
expr_ref implyR(ctx.mk_eq_atom(x, m_deltaStr), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -4156,7 +4156,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
expr_ref implyR(mk_or(arrangement_disjunction), mgr);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -6266,7 +6266,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
assert_axiom(negate_ast);
} else {
implyR1 = mk_or(arrangement_disjunction);
- if (opt_AssertStrongerArrangements) {
+ if (m_params.m_AssertStrongerArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(implyL, implyR1), m);
assert_axiom(ax_strong);
} else {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index b3667bdec..30bf0b080 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -18,6 +18,7 @@ Revision History:
#define _THEORY_STR_H_
#include"smt_theory.h"
+#include"theory_str_params.h"
#include"trail.h"
#include"th_rewriter.h"
#include"value_factory.h"
@@ -97,7 +98,7 @@ namespace smt {
typedef map<std::string, expr*, str_hash_proc, default_eq<std::string> > string_map;
protected:
- // Some options that control how the solver operates.
+ theory_str_params const & m_params;
/*
* If AggressiveLengthTesting is true, we manipulate the phase of length tester equalities
@@ -189,15 +190,6 @@ namespace smt {
*/
bool opt_UseFastValueTesterCache;
- /*
- * If AssertStrongerArrangements is set to true,
- * the implications that would normally be asserted during arrangement generation
- * will instead be asserted as equivalences.
- * This is a stronger version of the regular axiom.
- * The default (Z3str2) behaviour is to set this to false.
- */
- bool opt_AssertStrongerArrangements;
-
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -548,7 +540,7 @@ namespace smt {
void refresh_theory_var(expr * e);
public:
- theory_str(ast_manager & m);
+ theory_str(ast_manager & m, theory_str_params const & params);
virtual ~theory_str();
virtual char const * get_name() const { return "strings"; }
@@ -569,7 +561,7 @@ namespace smt {
virtual void new_eq_eh(theory_var, theory_var);
virtual void new_diseq_eh(theory_var, theory_var);
- virtual theory* mk_fresh(context*) { return alloc(theory_str, get_manager()); }
+ virtual theory* mk_fresh(context*) { return alloc(theory_str, get_manager(), m_params); }
virtual void init_search_eh();
virtual void relevant_eh(app * n);
virtual void assign_eh(bool_var v, bool is_true);
From bced5828f7c1dbcab586709a2a6f067a97fab1f7 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 13 Dec 2016 17:20:58 -0500
Subject: [PATCH 286/401] theory_str parameters
---
src/smt/params/smt_params_helper.pyg | 4 +++-
src/smt/params/theory_str_params.cpp | 2 ++
src/smt/params/theory_str_params.h | 16 +++++++++++++++-
src/smt/theory_str.cpp | 14 ++++++--------
src/smt/theory_str.h | 12 ------------
5 files changed, 26 insertions(+), 22 deletions(-)
diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg
index 49a786e69..feec8b01c 100644
--- a/src/smt/params/smt_params_helper.pyg
+++ b/src/smt/params/smt_params_helper.pyg
@@ -62,5 +62,7 @@ def_module_params(module_name='smt',
('dack.gc_inv_decay', DOUBLE, 0.8, 'Dynamic ackermannization garbage collection decay'),
('dack.threshold', UINT, 10, ' number of times the congruence rule must be used before Leibniz\'s axiom is expanded'),
('core.validate', BOOL, False, 'validate unsat core produced by SMT context'),
- ('str.strong_arrangements', BOOL, True, 'assert equivalences instead of implications when generating string arrangement axioms')
+ ('str.strong_arrangements', BOOL, True, 'assert equivalences instead of implications when generating string arrangement axioms'),
+ ('str.aggressive_length_testing', BOOL, False, 'prioritize testing concrete length values over generating more options'),
+ ('str.aggressive_value_testing', BOOL, False, 'prioritize testing concrete string constant values over generating more options')
))
diff --git a/src/smt/params/theory_str_params.cpp b/src/smt/params/theory_str_params.cpp
index c1fcb0412..f7a562842 100644
--- a/src/smt/params/theory_str_params.cpp
+++ b/src/smt/params/theory_str_params.cpp
@@ -21,4 +21,6 @@ Revision History:
void theory_str_params::updt_params(params_ref const & _p) {
smt_params_helper p(_p);
m_AssertStrongerArrangements = p.str_strong_arrangements();
+ m_AggressiveLengthTesting = p.str_aggressive_length_testing();
+ m_AggressiveValueTesting = p.str_aggressive_value_testing();
}
diff --git a/src/smt/params/theory_str_params.h b/src/smt/params/theory_str_params.h
index 480ad1479..78c78089e 100644
--- a/src/smt/params/theory_str_params.h
+++ b/src/smt/params/theory_str_params.h
@@ -30,8 +30,22 @@ struct theory_str_params {
*/
bool m_AssertStrongerArrangements;
+ /*
+ * If AggressiveLengthTesting is true, we manipulate the phase of length tester equalities
+ * to prioritize trying concrete length options over choosing the "more" option.
+ */
+ bool m_AggressiveLengthTesting;
+
+ /*
+ * Similarly, if AggressiveValueTesting is true, we manipulate the phase of value tester equalities
+ * to prioritize trying concrete value options over choosing the "more" option.
+ */
+ bool m_AggressiveValueTesting;
+
theory_str_params(params_ref const & p = params_ref()):
- m_AssertStrongerArrangements(true)
+ m_AssertStrongerArrangements(true),
+ m_AggressiveLengthTesting(false),
+ m_AggressiveValueTesting(false)
{
updt_params(p);
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 4eb15d6ad..fe89b4662 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -33,8 +33,6 @@ theory_str::theory_str(ast_manager & m, theory_str_params const & params):
theory(m.mk_family_id("str")),
m_params(params),
/* Options */
- opt_AggressiveLengthTesting(false),
- opt_AggressiveValueTesting(false),
opt_AggressiveUnrollTesting(true),
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
@@ -8364,7 +8362,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
<< "val_indicator = " << mk_ismt2_pp(val_indicator, m) << std::endl
<< "lenstr = " << lenStr << std::endl
<< "tries = " << tries << std::endl;
- if (opt_AggressiveValueTesting) {
+ if (m_params.m_AggressiveValueTesting) {
tout << "note: aggressive value testing is enabled" << std::endl;
}
);
@@ -8408,7 +8406,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
for (long long i = l; i < h; i++) {
// TODO can we share the val_indicator constants with the length tester cache?
orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string(longlong_to_string(i).c_str()) ));
- if (opt_AggressiveValueTesting) {
+ if (m_params.m_AggressiveValueTesting) {
literal l = mk_eq(val_indicator, m_strutil.mk_string(longlong_to_string(i).c_str()), false);
ctx.mark_as_relevant(l);
ctx.force_phase(l);
@@ -8429,7 +8427,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
}
if (!coverAll) {
orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string("more")));
- if (opt_AggressiveValueTesting) {
+ if (m_params.m_AggressiveValueTesting) {
literal l = mk_eq(val_indicator, m_strutil.mk_string("more"), false);
ctx.mark_as_relevant(l);
ctx.force_phase(~l);
@@ -8980,7 +8978,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
TRACE("t_str_detail",
tout << "building andList and orList" << std::endl;
- if (opt_AggressiveLengthTesting) {
+ if (m_params.m_AggressiveLengthTesting) {
tout << "note: aggressive length testing is active" << std::endl;
}
);
@@ -9007,7 +9005,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
orList.push_back(or_expr);
- if (opt_AggressiveLengthTesting) {
+ if (m_params.m_AggressiveLengthTesting) {
literal l = mk_eq(indicator, str_indicator, false);
ctx.mark_as_relevant(l);
ctx.force_phase(l);
@@ -9019,7 +9017,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
// TODO cache mk_string("more")
orList.push_back(m.mk_eq(indicator, m_strutil.mk_string("more")));
- if (opt_AggressiveLengthTesting) {
+ if (m_params.m_AggressiveLengthTesting) {
literal l = mk_eq(indicator, m_strutil.mk_string("more"), false);
ctx.mark_as_relevant(l);
ctx.force_phase(~l);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 30bf0b080..02b351167 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -100,18 +100,6 @@ namespace smt {
protected:
theory_str_params const & m_params;
- /*
- * If AggressiveLengthTesting is true, we manipulate the phase of length tester equalities
- * to prioritize trying concrete length options over choosing the "more" option.
- */
- bool opt_AggressiveLengthTesting;
-
- /*
- * Similarly, if AggressiveValueTesting is true, we manipulate the phase of value tester equalities
- * to prioritize trying concrete value options over choosing the "more" option.
- */
- bool opt_AggressiveValueTesting;
-
/*
* If AggressiveUnrollTesting is true, we manipulate the phase of regex unroll tester equalities
* to prioritize trying concrete unroll counts over choosing the "more" option.
From 27a2c20c1cf38e55cc4995749de4475864b5ef39 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 13 Dec 2016 19:38:40 -0500
Subject: [PATCH 287/401] add more parameters for theory_str
---
src/smt/params/smt_params_helper.pyg | 6 +++++-
src/smt/params/theory_str_params.cpp | 3 +++
src/smt/params/theory_str_params.h | 25 ++++++++++++++++++++++++-
src/smt/theory_str.cpp | 13 +++++--------
src/smt/theory_str.h | 20 --------------------
5 files changed, 37 insertions(+), 30 deletions(-)
diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg
index feec8b01c..cf861a28a 100644
--- a/src/smt/params/smt_params_helper.pyg
+++ b/src/smt/params/smt_params_helper.pyg
@@ -64,5 +64,9 @@ def_module_params(module_name='smt',
('core.validate', BOOL, False, 'validate unsat core produced by SMT context'),
('str.strong_arrangements', BOOL, True, 'assert equivalences instead of implications when generating string arrangement axioms'),
('str.aggressive_length_testing', BOOL, False, 'prioritize testing concrete length values over generating more options'),
- ('str.aggressive_value_testing', BOOL, False, 'prioritize testing concrete string constant values over generating more options')
+ ('str.aggressive_value_testing', BOOL, False, 'prioritize testing concrete string constant values over generating more options'),
+ ('str.aggressive_unroll_testing', BOOL, True, 'prioritize testing concrete regex unroll counts over generating more options'),
+ ('str.fast_length_tester_cache', BOOL, False, 'cache length tester constants instead of regenerating them'),
+ ('str.fast_value_tester_cache', BOOL, True, 'cache value tester constants instead of regenerating them')
+
))
diff --git a/src/smt/params/theory_str_params.cpp b/src/smt/params/theory_str_params.cpp
index f7a562842..f952c6c87 100644
--- a/src/smt/params/theory_str_params.cpp
+++ b/src/smt/params/theory_str_params.cpp
@@ -23,4 +23,7 @@ void theory_str_params::updt_params(params_ref const & _p) {
m_AssertStrongerArrangements = p.str_strong_arrangements();
m_AggressiveLengthTesting = p.str_aggressive_length_testing();
m_AggressiveValueTesting = p.str_aggressive_value_testing();
+ m_AggressiveUnrollTesting = p.str_aggressive_unroll_testing();
+ m_UseFastLengthTesterCache = p.str_fast_length_tester_cache();
+ m_UseFastValueTesterCache = p.str_fast_value_tester_cache();
}
diff --git a/src/smt/params/theory_str_params.h b/src/smt/params/theory_str_params.h
index 78c78089e..f4e7ecf33 100644
--- a/src/smt/params/theory_str_params.h
+++ b/src/smt/params/theory_str_params.h
@@ -42,10 +42,33 @@ struct theory_str_params {
*/
bool m_AggressiveValueTesting;
+ /*
+ * If AggressiveUnrollTesting is true, we manipulate the phase of regex unroll tester equalities
+ * to prioritize trying concrete unroll counts over choosing the "more" option.
+ */
+ bool m_AggressiveUnrollTesting;
+
+ /*
+ * If UseFastLengthTesterCache is set to true,
+ * length tester terms will not be generated from scratch each time they are needed,
+ * but will be saved in a map and looked up.
+ */
+ bool m_UseFastLengthTesterCache;
+
+ /*
+ * If UseFastValueTesterCache is set to true,
+ * value tester terms will not be generated from scratch each time they are needed,
+ * but will be saved in a map and looked up.
+ */
+ bool m_UseFastValueTesterCache;
+
theory_str_params(params_ref const & p = params_ref()):
m_AssertStrongerArrangements(true),
m_AggressiveLengthTesting(false),
- m_AggressiveValueTesting(false)
+ m_AggressiveValueTesting(false),
+ m_AggressiveUnrollTesting(true),
+ m_UseFastLengthTesterCache(false),
+ m_UseFastValueTesterCache(true)
{
updt_params(p);
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index fe89b4662..b18d51a98 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -33,7 +33,6 @@ theory_str::theory_str(ast_manager & m, theory_str_params const & params):
theory(m.mk_family_id("str")),
m_params(params),
/* Options */
- opt_AggressiveUnrollTesting(true),
opt_EagerStringConstantLengthAssertions(true),
opt_VerifyFinalCheckProgress(true),
opt_LCMUnrollStep(2),
@@ -41,8 +40,6 @@ theory_str::theory_str(ast_manager & m, theory_str_params const & params):
opt_DisableIntegerTheoryIntegration(false),
opt_DeferEQCConsistencyCheck(false),
opt_CheckVariableScope(true),
- opt_UseFastLengthTesterCache(true),
- opt_UseFastValueTesterCache(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -8414,7 +8411,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
std::string aStr = gen_val_string(len, options[i - l]);
expr * strAst;
- if (opt_UseFastValueTesterCache) {
+ if (m_params.m_UseFastValueTesterCache) {
if (!valueTesterCache.find(aStr, strAst)) {
strAst = m_strutil.mk_string(aStr);
valueTesterCache.insert(aStr, strAst);
@@ -8905,7 +8902,7 @@ expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * test
TRACE("t_str_detail", tout << "entry: var = " << mk_pp(var, mgr) << ", lcmStr = " << lcmStr
<< ", l = " << l << ", h = " << h << std::endl;);
- if (opt_AggressiveUnrollTesting) {
+ if (m_params.m_AggressiveUnrollTesting) {
TRACE("t_str_detail", tout << "note: aggressive unroll testing is active" << std::endl;);
}
@@ -8916,7 +8913,7 @@ expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * test
std::string iStr = int_to_string(i);
expr_ref testerEqAst(ctx.mk_eq_atom(testerVar, m_strutil.mk_string(iStr)), mgr);
TRACE("t_str_detail", tout << "testerEqAst = " << mk_pp(testerEqAst, mgr) << std::endl;);
- if (opt_AggressiveUnrollTesting) {
+ if (m_params.m_AggressiveUnrollTesting) {
literal l = mk_eq(testerVar, m_strutil.mk_string(iStr), false);
ctx.mark_as_relevant(l);
ctx.force_phase(l);
@@ -8935,7 +8932,7 @@ expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * test
}
expr_ref testerEqMore(ctx.mk_eq_atom(testerVar, m_strutil.mk_string("more")), mgr);
TRACE("t_str_detail", tout << "testerEqMore = " << mk_pp(testerEqMore, mgr) << std::endl;);
- if (opt_AggressiveUnrollTesting) {
+ if (m_params.m_AggressiveUnrollTesting) {
literal l = mk_eq(testerVar, m_strutil.mk_string("more"), false);
ctx.mark_as_relevant(l);
ctx.force_phase(~l);
@@ -8985,7 +8982,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
for (int i = l; i < h; ++i) {
expr_ref str_indicator(m);
- if (opt_UseFastLengthTesterCache) {
+ if (m_params.m_UseFastLengthTesterCache) {
rational ri(i);
expr * lookup_val;
if(lengthTesterCache.find(ri, lookup_val)) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 02b351167..2a9997517 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -100,12 +100,6 @@ namespace smt {
protected:
theory_str_params const & m_params;
- /*
- * If AggressiveUnrollTesting is true, we manipulate the phase of regex unroll tester equalities
- * to prioritize trying concrete unroll counts over choosing the "more" option.
- */
- bool opt_AggressiveUnrollTesting;
-
/*
* Setting EagerStringConstantLengthAssertions to true allows some methods,
* in particular internalize_term(), to add
@@ -164,20 +158,6 @@ namespace smt {
*/
bool opt_CheckVariableScope;
- /*
- * If UseFastLengthTesterCache is set to true,
- * length tester terms will not be generated from scratch each time they are needed,
- * but will be saved in a map and looked up.
- */
- bool opt_UseFastLengthTesterCache;
-
- /*
- * If UseFastValueTesterCache is set to true,
- * value tester terms will not be generated from scratch each time they are needed,
- * but will be saved in a map and looked up.
- */
- bool opt_UseFastValueTesterCache;
-
bool search_started;
arith_util m_autil;
str_util m_strutil;
From 67e73077773b6fa136c8a4896f5f2e55cfd77e9b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 14 Dec 2016 15:00:17 -0500
Subject: [PATCH 288/401] add cut var debug info, wip
---
src/smt/theory_str.cpp | 39 ++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 2 ++
2 files changed, 40 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b18d51a98..503485293 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2481,6 +2481,43 @@ expr_ref theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
return final_result;
}
+void theory_str::print_cut_var(expr * node, std::ofstream & xout) {
+ ast_manager & m = get_manager();
+ /*
+#ifdef DEBUGLOG
+ __debugPrint(logFile, "\n>> CUT info of [");
+ printZ3Node(t, node);
+ __debugPrint(logFile, "]\n");
+
+ if (cut_VARMap.find(node) != cut_VARMap.end()) {
+ if (!cut_VARMap[node].empty()) {
+ __debugPrint(logFile, "[%2d] {", cut_VARMap[node].top()->level);
+ std::map<Z3_ast, int>::iterator itor = cut_VARMap[node].top()->vars.begin();
+ for (; itor != cut_VARMap[node].top()->vars.end(); itor++) {
+ printZ3Node(t, itor->first);
+ __debugPrint(logFile, ", ");
+ }
+ __debugPrint(logFile, "}\n");
+ } else {
+
+ }
+ }
+ __debugPrint(logFile, "------------------------\n\n");
+#endif
+*/
+ xout << "Cut info of " << mk_pp(node, m) << std::endl;
+ if (cut_var_map.contains(node)) {
+ if (!cut_var_map[node].empty()) {
+ xout << "[" << cut_var_map[node].top()->level << "] ";
+ std::map<expr*, int>::iterator itor = cut_var_map[node].top()->vars.begin();
+ for (; itor != cut_var_map[node].top()->vars.end(); ++itor) {
+ xout << mk_pp(itor->first, m) << ", ";
+ }
+ xout << std::endl;
+ }
+ }
+}
+
/*
* Handle two equivalent Concats.
*/
@@ -3013,7 +3050,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
} else {
loopDetected = true;
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- // TODO printCutVar(m, y);
+ TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
}
// break option 2:
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 2a9997517..73f8d9dcc 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -439,6 +439,8 @@ namespace smt {
void process_concat_eq_type5(expr * concatAst1, expr * concatAst2);
void process_concat_eq_type6(expr * concatAst1, expr * concatAst2);
+ void print_cut_var(expr * node, std::ofstream & xout);
+
expr_ref generate_mutual_exclusion(expr_ref_vector & exprs);
bool new_eq_check(expr * lhs, expr * rhs);
From dd8cd8199ba06db25e34b7539aff8dc212e28881 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 16 Dec 2016 14:37:34 -0500
Subject: [PATCH 289/401] theory_str refcount debug messages and beginning
theory case split
---
src/ast/ast.cpp | 1 +
src/smt/params/smt_params.cpp | 1 +
src/smt/params/smt_params.h | 2 ++
src/smt/params/smt_params_helper.pyg | 4 ++--
src/smt/smt_context.cpp | 11 ++++++++++-
src/smt/theory_str.cpp | 12 ++++++++++++
6 files changed, 28 insertions(+), 3 deletions(-)
diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp
index a9a91ab2a..a822be37a 100644
--- a/src/ast/ast.cpp
+++ b/src/ast/ast.cpp
@@ -1767,6 +1767,7 @@ void ast_manager::delete_node(ast * n) {
TRACE("ast", tout << "Deleting object " << n->m_id << " " << n << "\n";);
CTRACE("del_quantifier", is_quantifier(n), tout << "deleting quantifier " << n->m_id << " " << n << "\n";);
TRACE("mk_var_bug", tout << "del_ast: " << n->m_id << "\n";);
+ TRACE("t_str_refcount_hack", tout << "delete ast " << n->m_id << std::endl;);
TRACE("ast_delete_node", tout << mk_bounded_pp(n, *this) << "\n";);
SASSERT(m_ast_table.contains(n));
diff --git a/src/smt/params/smt_params.cpp b/src/smt/params/smt_params.cpp
index 8222c3d60..a5b3e4867 100644
--- a/src/smt/params/smt_params.cpp
+++ b/src/smt/params/smt_params.cpp
@@ -31,6 +31,7 @@ void smt_params::updt_local_params(params_ref const & _p) {
m_restart_strategy = static_cast<restart_strategy>(p.restart_strategy());
m_restart_factor = p.restart_factor();
m_case_split_strategy = static_cast<case_split_strategy>(p.case_split());
+ m_theory_case_split = p.theory_case_split();
m_delay_units = p.delay_units();
m_delay_units_threshold = p.delay_units_threshold();
m_preprocess = _p.get_bool("preprocess", true); // hidden parameter
diff --git a/src/smt/params/smt_params.h b/src/smt/params/smt_params.h
index 27071bd9e..55346d34f 100644
--- a/src/smt/params/smt_params.h
+++ b/src/smt/params/smt_params.h
@@ -111,6 +111,7 @@ struct smt_params : public preprocessor_params,
case_split_strategy m_case_split_strategy;
unsigned m_rel_case_split_order;
bool m_lookahead_diseq;
+ bool m_theory_case_split;
// -----------------------------------
//
@@ -241,6 +242,7 @@ struct smt_params : public preprocessor_params,
m_case_split_strategy(CS_ACTIVITY_DELAY_NEW),
m_rel_case_split_order(0),
m_lookahead_diseq(false),
+ m_theory_case_split(false),
m_delay_units(false),
m_delay_units_threshold(32),
m_theory_resolve(false),
diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg
index cf861a28a..3f2c6a54a 100644
--- a/src/smt/params/smt_params_helper.pyg
+++ b/src/smt/params/smt_params_helper.pyg
@@ -67,6 +67,6 @@ def_module_params(module_name='smt',
('str.aggressive_value_testing', BOOL, False, 'prioritize testing concrete string constant values over generating more options'),
('str.aggressive_unroll_testing', BOOL, True, 'prioritize testing concrete regex unroll counts over generating more options'),
('str.fast_length_tester_cache', BOOL, False, 'cache length tester constants instead of regenerating them'),
- ('str.fast_value_tester_cache', BOOL, True, 'cache value tester constants instead of regenerating them')
-
+ ('str.fast_value_tester_cache', BOOL, True, 'cache value tester constants instead of regenerating them'),
+ ('theory_case_split', BOOL, False, 'Allow the context to use heuristics involving theory case splits, which are a set of literals of which exactly one can be assigned True. If this option is false, the context will generate extra axioms to enforce this instead.')
))
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 8958eae5f..741525dd2 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -2377,6 +2377,9 @@ namespace smt {
*/
unsigned context::pop_scope_core(unsigned num_scopes) {
+ TRACE("t_str_refcount_hack", tout << "begin pop_scope_core in smt_context" << std::endl;);
+
+
if (m_manager.has_trace_stream())
m_manager.trace_stream() << "[pop] " << num_scopes << " " << m_scope_lvl << "\n";
@@ -2423,8 +2426,11 @@ namespace smt {
ptr_vector<theory>::iterator it = m_theory_set.begin();
ptr_vector<theory>::iterator end = m_theory_set.end();
- for (; it != end; ++it)
+ for (; it != end; ++it) {
+ TRACE("t_str_refcount_hack", tout << "begin theory pop_scope_eh" << std::endl;);
(*it)->pop_scope_eh(num_scopes);
+ TRACE("t_str_refcount_hack", tout << "end theory pop_scope_eh" << std::endl;);
+ }
del_justifications(m_justifications, s.m_justifications_lim);
@@ -2450,6 +2456,9 @@ namespace smt {
reassert_units(units_to_reassert_lim);
TRACE("pop_scope_detail", tout << "end of pop_scope: \n"; display(tout););
CASSERT("context", check_invariant());
+
+ TRACE("t_str_refcount_hack", tout << "end pop_scope_core in smt_context" << std::endl;);
+
return num_bool_vars;
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 503485293..25a045ee8 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1805,6 +1805,7 @@ void theory_str::reset_eh() {
* Then add an assertion: (y2 == (Concat ce m2)) AND ("str3" == (Concat abc x2)) -> (y2 != "str3")
*/
bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
+ TRACE("t_str_refcount_hack", tout << "begin new_eq_check in theory_str" << std::endl;);
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -1830,6 +1831,7 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
expr_ref to_assert(m.mk_not(ctx.mk_eq_atom(eqc_nn1, eqc_nn2)), m);
assert_axiom(to_assert);
// this shouldn't use the integer theory at all, so we don't allow the option of quick-return
+ TRACE("t_str_refcount_hack", tout << "end new_eq_check in theory_str" << std::endl;);
return false;
}
if (!check_length_consistency(eqc_nn1, eqc_nn2)) {
@@ -1837,6 +1839,7 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
if (opt_NoQuickReturn_IntegerTheory){
TRACE("t_str_detail", tout << "continuing in new_eq_check() due to opt_NoQuickReturn_IntegerTheory" << std::endl;);
} else {
+ TRACE("t_str_refcount_hack", tout << "end new_eq_check in theory_str" << std::endl;);
return false;
}
}
@@ -1855,6 +1858,7 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
}
// okay, all checks here passed
+ TRACE("t_str_refcount_hack", tout << "end new_eq_check in theory_str" << std::endl;);
return true;
}
@@ -6859,14 +6863,20 @@ void theory_str::check_variable_scope() {
}
void theory_str::pop_scope_eh(unsigned num_scopes) {
+ TRACE("t_str_refcount_hack", tout << "begin pop_scope_eh in theory_str" << std::endl;);
+
sLevel -= num_scopes;
TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
// TODO: figure out what's going out of scope and why
context & ctx = get_context();
ast_manager & m = get_manager();
+ // {
// expr_ref_vector assignments(m);
// ctx.get_assignments(assignments);
+ // TRACE("t_str_refcount_hack", tout << "assignment vector about to go out of scope" << std::endl;);
+ // }
+ // TRACE("t_str_refcount_hack", tout << "assignment vector has gone out of scope" << std::endl;);
TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
@@ -6937,6 +6947,8 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
theory::pop_scope_eh(num_scopes);
//check_variable_scope();
+
+ TRACE("t_str_refcount_hack", tout << "end pop_scope_eh in theory_str" << std::endl;);
}
void theory_str::dump_assignments() {
From e85f9d33c4dceccded5436955a84f125a1e712d8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 16 Dec 2016 15:50:03 -0500
Subject: [PATCH 290/401] add "legacy" support for theory case splits
this replicates what was done in theory_str to add axioms excluding each
pair of literals from being assigned True at the same time;
no new heuristics are being used in smt_context (yet)
---
src/smt/smt_context.cpp | 21 +++++++++++++++++++++
src/smt/smt_context.h | 8 ++++++++
src/smt/theory_str.cpp | 26 +++++++++++++++++++-------
src/smt/theory_str.h | 2 +-
4 files changed, 49 insertions(+), 8 deletions(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 741525dd2..907ea876b 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -2939,6 +2939,27 @@ namespace smt {
assert_expr_core(e, pr);
}
+ void context::mk_th_case_split(unsigned num_lits, literal * lits) {
+ TRACE("theory_case_split", display_literals_verbose(tout << "theory case split: ", num_lits, lits); tout << std::endl;);
+ // If we don't use the theory case split heuristic,
+ // for each pair of literals (l1, l2) we add the clause (~l1 OR ~l2)
+ // to enforce the condition that more than one literal can't be
+ // assigned 'true' simultaneously.
+ if (!m_fparams.m_theory_case_split) {
+ for (unsigned i = 0; i < num_lits; ++i) {
+ for (unsigned j = i+1; j < num_lits; ++j) {
+ literal l1 = lits[i];
+ literal l2 = lits[j];
+ literal excl[2] = {~l1, ~l2};
+ justification * j_excl = 0;
+ mk_clause(2, excl, j_excl);
+ }
+ }
+ } else {
+ NOT_IMPLEMENTED_YET();
+ }
+ }
+
bool context::reduce_assertions() {
if (!m_asserted_formulas.inconsistent()) {
SASSERT(at_base_level());
diff --git a/src/smt/smt_context.h b/src/smt/smt_context.h
index 8b2453e31..5c52adc73 100644
--- a/src/smt/smt_context.h
+++ b/src/smt/smt_context.h
@@ -805,6 +805,14 @@ namespace smt {
void mk_th_axiom(theory_id tid, literal l1, literal l2, literal l3, unsigned num_params = 0, parameter * params = 0);
+ /*
+ * Provide a hint to the core solver that the specified literals form a "theory case split".
+ * The core solver will enforce the condition that exactly one of these literals can be
+ * assigned 'true' at any time.
+ * We assume that the theory solver has already asserted the disjunction of these literals
+ * or some other axiom that means at least one of them must be assigned 'true'.
+ */
+ void mk_th_case_split(unsigned num_lits, literal * lits);
bool_var mk_bool_var(expr * n);
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 25a045ee8..89f31db5a 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2466,8 +2466,19 @@ void theory_str::infer_len_concat_equality(expr * nn1, expr * nn2) {
*/
}
-expr_ref theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
+void theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
context & ctx = get_context();
+ // pull each literal out of the arrangement disjunction
+ literal_vector ls;
+ for (unsigned i = 0; i < terms.size(); ++i) {
+ expr * e = terms.get(i);
+ literal l = ctx.get_literal(e);
+ ls.push_back(l);
+ }
+ ctx.mk_th_case_split(ls.size(), ls.c_ptr());
+
+ // old version, without special support in the context
+ /*
ast_manager & m = get_manager();
expr_ref_vector result(m);
@@ -2482,7 +2493,8 @@ expr_ref theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
}
expr_ref final_result(mk_and(result), m);
- return final_result;
+ assert_axiom(final_result);
+ */
}
void theory_str::print_cut_var(expr * node, std::ofstream & xout) {
@@ -3114,7 +3126,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
assert_implication(premise, conclusion);
}
// assert mutual exclusion between each branch of the arrangement
- assert_axiom(generate_mutual_exclusion(arrangement_disjunction));
+ generate_mutual_exclusion(arrangement_disjunction);
} else {
TRACE("t_str", tout << "STOP: no split option found for two EQ concats." << std::endl;);
}
@@ -3447,7 +3459,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
} else {
assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
}
- assert_axiom(generate_mutual_exclusion(arrangement_disjunction));
+ generate_mutual_exclusion(arrangement_disjunction);
} else {
TRACE("t_str", tout << "STOP: Should not split two EQ concats." << std::endl;);
}
@@ -3774,7 +3786,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
} else {
assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
}
- assert_axiom(generate_mutual_exclusion(arrangement_disjunction));
+ generate_mutual_exclusion(arrangement_disjunction);
} else {
TRACE("t_str", tout << "STOP: should not split two eq. concats" << std::endl;);
}
@@ -4198,7 +4210,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
} else {
assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
}
- assert_axiom(generate_mutual_exclusion(arrangement_disjunction));
+ generate_mutual_exclusion(arrangement_disjunction);
}
void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr) {
@@ -6308,7 +6320,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
} else {
assert_implication(implyL, implyR1);
}
- assert_axiom(generate_mutual_exclusion(arrangement_disjunction));
+ generate_mutual_exclusion(arrangement_disjunction);
}
} /* (arg1Len != 1 || arg2Len != 1) */
} /* if (Concat(arg1, arg2) == NULL) */
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 73f8d9dcc..ffeea34e8 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -441,7 +441,7 @@ namespace smt {
void print_cut_var(expr * node, std::ofstream & xout);
- expr_ref generate_mutual_exclusion(expr_ref_vector & exprs);
+ void generate_mutual_exclusion(expr_ref_vector & exprs);
bool new_eq_check(expr * lhs, expr * rhs);
void group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts);
From e5d3e425f10aba1380018d68711154c3588face8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 18 Dec 2016 15:23:05 -0500
Subject: [PATCH 291/401] theory_str caching of all string constants
---
src/smt/theory_str.cpp | 155 ++++++++++++++++++++++++-----------------
src/smt/theory_str.h | 8 +++
2 files changed, 101 insertions(+), 62 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 89f31db5a..19e677acb 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -56,6 +56,9 @@ theory_str::theory_str(ast_manager & m, theory_str_params const & params):
loopDetected(false),
contains_map(m),
string_int_conversion_terms(m),
+ totalCacheAccessCount(0),
+ cacheHitCount(0),
+ cacheMissCount(0),
m_find(*this),
m_trail_stack(*this)
{
@@ -66,6 +69,34 @@ theory_str::~theory_str() {
m_trail_stack.reset();
}
+expr * theory_str::mk_string(std::string str) {
+ ++totalCacheAccessCount;
+ expr * val;
+ if (stringConstantCache.find(str, val)) {
+ // cache hit
+ ++cacheHitCount;
+ TRACE("t_str_cache", tout << "cache hit: \"" << str << "\" ("
+ << cacheHitCount << " hits, " << cacheMissCount << " misses out of "
+ << totalCacheAccessCount << " accesses)" << std::endl;);
+ return val;
+ } else {
+ // cache miss
+ ++cacheMissCount;
+ TRACE("t_str_cache", tout << "cache miss: \"" << str << "\" ("
+ << cacheHitCount << " hits, " << cacheMissCount << " misses out of "
+ << totalCacheAccessCount << " accesses)" << std::endl;);
+ val = m_strutil.mk_string(str);
+ m_trail.push_back(val);
+ stringConstantCache.insert(str, val);
+ return val;
+ }
+}
+
+expr * theory_str::mk_string(const char * str) {
+ std::string valStr(str);
+ return mk_string(valStr);
+}
+
void theory_str::initialize_charset() {
bool defaultCharset = true;
if (defaultCharset) {
@@ -615,7 +646,7 @@ void theory_str::add_nonempty_constraint(expr * s) {
context & ctx = get_context();
ast_manager & m = get_manager();
- expr_ref ax1(m.mk_not(ctx.mk_eq_atom(s, m_strutil.mk_string(""))), m);
+ expr_ref ax1(m.mk_not(ctx.mk_eq_atom(s, mk_string(""))), m);
assert_axiom(ax1);
{
@@ -685,7 +716,7 @@ app * theory_str::mk_unroll(expr * n, expr * bound) {
m_trail.push_back(unrollFunc);
expr_ref_vector items(m);
- items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(bound, mk_int(0)), ctx.mk_eq_atom(unrollFunc, m_strutil.mk_string(""))));
+ items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(bound, mk_int(0)), ctx.mk_eq_atom(unrollFunc, mk_string(""))));
items.push_back(m_autil.mk_ge(bound, mk_int(0)));
items.push_back(m_autil.mk_ge(mk_strlen(unrollFunc), mk_int(0)));
@@ -760,7 +791,7 @@ expr * theory_str::mk_concat_const_str(expr * n1, expr * n2) {
m_strutil.is_string(v2, & n2_str_tmp);
std::string n2_str(n2_str_tmp);
std::string result = n1_str + n2_str;
- return m_strutil.mk_string(result);
+ return mk_string(result);
} else if (n1HasEqcValue && !n2HasEqcValue) {
const char * n1_str_tmp;
m_strutil.is_string(v1, & n1_str_tmp);
@@ -1013,7 +1044,7 @@ void theory_str::try_eval_concat(enode * cat) {
}
if (constOK) {
TRACE("t_str_detail", tout << "flattened to \"" << flattenedString << "\"" << std::endl;);
- expr_ref constStr(m_strutil.mk_string(flattenedString), m);
+ expr_ref constStr(mk_string(flattenedString), m);
expr_ref axiom(ctx.mk_eq_atom(a_cat, constStr), m);
assert_axiom(axiom);
}
@@ -1132,7 +1163,7 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
SASSERT(lhs);
// build RHS of iff
expr_ref empty_str(m);
- empty_str = m_strutil.mk_string("");
+ empty_str = mk_string("");
SASSERT(empty_str);
expr_ref rhs(m);
rhs = ctx.mk_eq_atom(a_str, empty_str);
@@ -1203,7 +1234,7 @@ void theory_str::instantiate_axiom_CharAt(enode * e) {
and_item.push_back(ctx.mk_eq_atom(mk_strlen(ts1), mk_int(1)));
expr_ref thenBranch(m.mk_and(and_item.size(), and_item.c_ptr()), m);
- expr_ref elseBranch(ctx.mk_eq_atom(ts1, m_strutil.mk_string("")), m);
+ expr_ref elseBranch(ctx.mk_eq_atom(ts1, mk_string("")), m);
expr_ref axiom(m.mk_ite(cond, thenBranch, elseBranch), m);
expr_ref reductionVar(ctx.mk_eq_atom(expr, ts1), m);
@@ -1644,7 +1675,7 @@ void theory_str::instantiate_axiom_str_to_int(enode * e) {
{
expr_ref lhs(ctx.mk_eq_atom(ex, m_autil.mk_numeral(rational::zero(), true)), m);
- expr_ref rhs(ctx.mk_eq_atom(S, m_strutil.mk_string("0")), m);
+ expr_ref rhs(ctx.mk_eq_atom(S, mk_string("0")), m);
expr_ref axiom2(ctx.mk_eq_atom(lhs, rhs), m);
SASSERT(axiom2);
assert_axiom(axiom2);
@@ -1656,7 +1687,7 @@ void theory_str::instantiate_axiom_str_to_int(enode * e) {
expr_ref tl(mk_str_var("tl"), m);
expr_ref conclusion1(ctx.mk_eq_atom(S, mk_concat(hd, tl)), m);
expr_ref conclusion2(ctx.mk_eq_atom(mk_strlen(hd), m_autil.mk_numeral(rational::one(), true)), m);
- expr_ref conclusion3(m.mk_not(ctx.mk_eq_atom(hd, m_strutil.mk_string("0"))), m);
+ expr_ref conclusion3(m.mk_not(ctx.mk_eq_atom(hd, mk_string("0"))), m);
expr_ref conclusion(m.mk_and(conclusion1, conclusion2, conclusion3), m);
SASSERT(premise);
SASSERT(conclusion);
@@ -1681,7 +1712,7 @@ void theory_str::instantiate_axiom_int_to_str(enode * e) {
expr * N = ex->get_arg(0);
{
expr_ref axiom1_lhs(m.mk_not(m_autil.mk_ge(N, m_autil.mk_numeral(rational::zero(), true))), m);
- expr_ref axiom1_rhs(ctx.mk_eq_atom(ex, m_strutil.mk_string("")), m);
+ expr_ref axiom1_rhs(ctx.mk_eq_atom(ex, mk_string("")), m);
expr_ref axiom1(ctx.mk_eq_atom(axiom1_lhs, axiom1_rhs), m);
SASSERT(axiom1);
assert_axiom(axiom1);
@@ -1766,7 +1797,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
expr_ref unrollFunc(mk_unroll(regex1, unrollCount), m);
expr_ref_vector items(m);
items.push_back(ctx.mk_eq_atom(ex, ctx.mk_eq_atom(str, unrollFunc)));
- items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(unrollCount, mk_int(0)), ctx.mk_eq_atom(unrollFunc, m_strutil.mk_string(""))));
+ items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(unrollCount, mk_int(0)), ctx.mk_eq_atom(unrollFunc, mk_string(""))));
expr_ref finalAxiom(mk_and(items), m);
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
@@ -1947,7 +1978,7 @@ expr * theory_str::eval_concat(expr * n1, expr * n2) {
std::string n1_str = m_strutil.get_string_constant_value(v1);
std::string n2_str = m_strutil.get_string_constant_value(v2);
std::string result = n1_str + n2_str;
- return m_strutil.mk_string(result);
+ return mk_string(result);
} else if (n1HasEqcValue && !n2HasEqcValue) {
if (m_strutil.get_string_constant_value(v1) == "") {
return n2;
@@ -2286,7 +2317,7 @@ expr * theory_str::simplify_concat(expr * node) {
// no simplification possible
return node;
} else {
- expr * resultAst = m_strutil.mk_string("");
+ expr * resultAst = mk_string("");
for (unsigned i = 0; i < argVec.size(); ++i) {
bool vArgHasEqcValue = false;
expr * vArg = get_eqc_value(argVec[i], vArgHasEqcValue);
@@ -3377,9 +3408,9 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
std::string part1Str = strValue.substr(0, lenDelta.get_unsigned());
std::string part2Str = strValue.substr(lenDelta.get_unsigned(), strValue.length() - lenDelta.get_unsigned());
- expr_ref prefixStr(m_strutil.mk_string(part1Str), mgr);
+ expr_ref prefixStr(mk_string(part1Str), mgr);
expr_ref x_concat(mk_concat(m, prefixStr), mgr);
- expr_ref cropStr(m_strutil.mk_string(part2Str), mgr);
+ expr_ref cropStr(mk_string(part2Str), mgr);
if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
expr_ref_vector r_items(mgr);
@@ -3436,9 +3467,9 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
for (int i = 0; i <= (int)strValue.size(); ++i) {
std::string part1Str = strValue.substr(0, i);
std::string part2Str = strValue.substr(i, strValue.size() - i);
- expr_ref prefixStr(m_strutil.mk_string(part1Str), mgr);
+ expr_ref prefixStr(mk_string(part1Str), mgr);
expr_ref x_concat(mk_concat(m, prefixStr), mgr);
- expr_ref cropStr(m_strutil.mk_string(part2Str), mgr);
+ expr_ref cropStr(mk_string(part2Str), mgr);
if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
// break down option 2-2
expr_ref_vector and_item(mgr);
@@ -3630,8 +3661,8 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
std::string prefixStr = strValue.substr(0, prefixLen.get_unsigned());
rational str_sub_prefix = str_len - prefixLen;
std::string suffixStr = strValue.substr(prefixLen.get_unsigned(), str_sub_prefix.get_unsigned());
- expr_ref prefixAst(m_strutil.mk_string(prefixStr), mgr);
- expr_ref suffixAst(m_strutil.mk_string(suffixStr), mgr);
+ expr_ref prefixAst(mk_string(prefixStr), mgr);
+ expr_ref suffixAst(mk_string(suffixStr), mgr);
expr_ref ax_l(mgr.mk_and(litems.size(), litems.c_ptr()), mgr);
expr_ref suf_n_concat(mk_concat(suffixAst, n), mgr);
@@ -3726,8 +3757,8 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
for (int i = 0; i <= (int) strValue.size(); i++) {
std::string part1Str = strValue.substr(0, i);
std::string part2Str = strValue.substr(i, strValue.size() - i);
- expr_ref cropStr(m_strutil.mk_string(part1Str), mgr);
- expr_ref suffixStr(m_strutil.mk_string(part2Str), mgr);
+ expr_ref cropStr(mk_string(part1Str), mgr);
+ expr_ref suffixStr(mk_string(part2Str), mgr);
expr_ref y_concat(mk_concat(suffixStr, n), mgr);
if (can_two_nodes_eq(x, cropStr) && can_two_nodes_eq(y, y_concat)) {
@@ -3857,7 +3888,7 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
} else {
if (str1Len > str2Len) {
std::string deltaStr = str1Value.substr(str2Len, str1Len - str2Len);
- expr_ref tmpAst(mk_concat(m_strutil.mk_string(deltaStr), y), mgr);
+ expr_ref tmpAst(mk_concat(mk_string(deltaStr), y), mgr);
if (!in_same_eqc(tmpAst, n)) {
// break down option 4-1
expr_ref implyR(ctx.mk_eq_atom(n, tmpAst), mgr);
@@ -3882,7 +3913,7 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
}
} else {
std::string deltaStr = str2Value.substr(str1Len, str2Len - str1Len);
- expr_ref tmpAst(mk_concat(m_strutil.mk_string(deltaStr), n), mgr);
+ expr_ref tmpAst(mk_concat(mk_string(deltaStr), n), mgr);
if (!in_same_eqc(y, tmpAst)) {
//break down option 4-3
expr_ref implyR(ctx.mk_eq_atom(y, tmpAst), mgr);
@@ -3960,7 +3991,7 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
} else {
if (str1Len > str2Len) {
std::string deltaStr = str1Value.substr(0, str1Len - str2Len);
- expr_ref x_deltaStr(mk_concat(x, m_strutil.mk_string(deltaStr)), mgr);
+ expr_ref x_deltaStr(mk_concat(x, mk_string(deltaStr)), mgr);
if (!in_same_eqc(m, x_deltaStr)) {
expr_ref implyR(ctx.mk_eq_atom(m, x_deltaStr), mgr);
if (m_params.m_AssertStrongerArrangements) {
@@ -3983,7 +4014,7 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
}
} else {
std::string deltaStr = str2Value.substr(0, str2Len - str1Len);
- expr_ref m_deltaStr(mk_concat(m, m_strutil.mk_string(deltaStr)), mgr);
+ expr_ref m_deltaStr(mk_concat(m, mk_string(deltaStr)), mgr);
if (!in_same_eqc(x, m_deltaStr)) {
expr_ref implyR(ctx.mk_eq_atom(x, m_deltaStr), mgr);
if (m_params.m_AssertStrongerArrangements) {
@@ -4178,7 +4209,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
expr_ref_vector and_item(mgr);
- expr_ref prefixAst(m_strutil.mk_string(prefix), mgr);
+ expr_ref prefixAst(mk_string(prefix), mgr);
expr_ref x_eq_prefix(ctx.mk_eq_atom(m, prefixAst), mgr);
and_item.push_back(x_eq_prefix);
pos += 1;
@@ -4189,7 +4220,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
// adding length constraint for _ = constStr seems slowing things down.
- expr_ref suffixAst(m_strutil.mk_string(suffix), mgr);
+ expr_ref suffixAst(mk_string(suffix), mgr);
expr_ref y_eq_suffix(ctx.mk_eq_atom(y, suffixAst), mgr);
and_item.push_back(y_eq_suffix);
pos += 1;
@@ -4262,7 +4293,7 @@ void theory_str::process_concat_eq_unroll(expr * concat, expr * unroll) {
expr_ref t2(mk_unroll_bound_var(), mgr);
expr_ref t3(mk_unroll_bound_var(), mgr);
- expr_ref emptyStr(m_strutil.mk_string(""), mgr);
+ expr_ref emptyStr(mk_string(""), mgr);
expr_ref unroll1(mk_unroll(r1, t2), mgr);
expr_ref unroll2(mk_unroll(r1, t3), mgr);
@@ -6093,7 +6124,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
assert_axiom(diseq);
return;
} else {
- expr_ref tmpStrConst(m_strutil.mk_string(firstPart), m);
+ expr_ref tmpStrConst(mk_string(firstPart), m);
expr_ref premise(ctx.mk_eq_atom(newConcat, str), m);
expr_ref conclusion(ctx.mk_eq_atom(arg1, tmpStrConst), m);
assert_implication(premise, conclusion);
@@ -6133,7 +6164,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
assert_axiom(diseq);
return;
} else {
- expr_ref tmpStrConst(m_strutil.mk_string(secondPart), m);
+ expr_ref tmpStrConst(mk_string(secondPart), m);
expr_ref premise(ctx.mk_eq_atom(newConcat, str), m);
expr_ref conclusion(ctx.mk_eq_atom(arg2, tmpStrConst), m);
assert_implication(premise, conclusion);
@@ -6200,8 +6231,8 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
return;
}
expr_ref_vector r_items(m);
- r_items.push_back(ctx.mk_eq_atom(arg1, m_strutil.mk_string(prefixStr)));
- r_items.push_back(ctx.mk_eq_atom(arg2, m_strutil.mk_string(suffixStr)));
+ r_items.push_back(ctx.mk_eq_atom(arg1, mk_string(prefixStr)));
+ r_items.push_back(ctx.mk_eq_atom(arg2, mk_string(suffixStr)));
if (!arg1Len_exists) {
r_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(prefixStr.size())));
}
@@ -6292,12 +6323,12 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
continue;
}
- expr_ref prefixAst(m_strutil.mk_string(prefixStr), m);
+ expr_ref prefixAst(mk_string(prefixStr), m);
expr_ref arg1_eq (ctx.mk_eq_atom(arg1, prefixAst), m);
and_items.push_back(arg1_eq);
and_count += 1;
- expr_ref suffixAst(m_strutil.mk_string(suffixStr), m);
+ expr_ref suffixAst(mk_string(suffixStr), m);
expr_ref arg2_eq (ctx.mk_eq_atom(arg2, suffixAst), m);
and_items.push_back(arg2_eq);
and_count += 1;
@@ -6450,7 +6481,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
rational nn1Len, nn2Len;
bool nn1Len_exists = get_len_value(lhs, nn1Len);
bool nn2Len_exists = get_len_value(rhs, nn2Len);
- expr * emptyStr = m_strutil.mk_string("");
+ expr * emptyStr = mk_string("");
if (nn1Len_exists && nn1Len.is_zero()) {
if (!in_same_eqc(lhs, emptyStr) && rhs != emptyStr) {
@@ -7853,7 +7884,7 @@ bool theory_str::finalcheck_str2int(app * a) {
if (!Ival.is_minus_one()) {
std::string Ival_str = Ival.to_string();
expr_ref premise(ctx.mk_eq_atom(a, m_autil.mk_numeral(Ival, true)), m);
- expr_ref conclusion(ctx.mk_eq_atom(S, m_strutil.mk_string(Ival_str)), m);
+ expr_ref conclusion(ctx.mk_eq_atom(S, mk_string(Ival_str)), m);
expr_ref axiom(rewrite_implication(premise, conclusion), m);
if (!string_int_axioms.contains(axiom)) {
string_int_axioms.insert(axiom);
@@ -7907,7 +7938,7 @@ bool theory_str::finalcheck_int2str(app * a) {
}
}
if (conversionOK) {
- expr_ref premise(ctx.mk_eq_atom(a, m_strutil.mk_string(Sval)), m);
+ expr_ref premise(ctx.mk_eq_atom(a, mk_string(Sval)), m);
expr_ref conclusion(ctx.mk_eq_atom(N, m_autil.mk_numeral(convertedRepresentation, true)), m);
expr_ref axiom(rewrite_implication(premise, conclusion), m);
if (!string_int_axioms.contains(axiom)) {
@@ -7917,7 +7948,7 @@ bool theory_str::finalcheck_int2str(app * a) {
axiomAdd = true;
}
} else {
- expr_ref axiom(m.mk_not(ctx.mk_eq_atom(a, m_strutil.mk_string(Sval))), m);
+ expr_ref axiom(m.mk_not(ctx.mk_eq_atom(a, mk_string(Sval))), m);
// always assert this axiom because this is a conflict clause
assert_axiom(axiom);
axiomAdd = true;
@@ -8036,7 +8067,7 @@ final_check_status theory_str::final_check_eh() {
expr_ref lhs1(ctx.mk_eq_atom(concat_lhs, concat_lhs_str), m);
expr_ref lhs2(ctx.mk_eq_atom(concat_rhs, concat_rhs_str), m);
expr_ref lhs(m.mk_and(lhs1, lhs2), m);
- expr_ref rhs(ctx.mk_eq_atom(concat, m_strutil.mk_string(concatString)), m);
+ expr_ref rhs(ctx.mk_eq_atom(concat, mk_string(concatString)), m);
assert_implication(lhs, rhs);
backpropagation_occurred = true;
}
@@ -8130,7 +8161,7 @@ final_check_status theory_str::final_check_eh() {
TRACE("t_str", tout << "Assigning decoy values to free internal variables." << std::endl;);
for (std::set<expr*>::iterator it = unused_internal_variables.begin(); it != unused_internal_variables.end(); ++it) {
expr * var = *it;
- expr_ref assignment(m.mk_eq(var, m_strutil.mk_string("**unused**")), m);
+ expr_ref assignment(m.mk_eq(var, mk_string("**unused**")), m);
assert_axiom(assignment);
}
return FC_CONTINUE;
@@ -8463,9 +8494,9 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
for (long long i = l; i < h; i++) {
// TODO can we share the val_indicator constants with the length tester cache?
- orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string(longlong_to_string(i).c_str()) ));
+ orList.push_back(m.mk_eq(val_indicator, mk_string(longlong_to_string(i).c_str()) ));
if (m_params.m_AggressiveValueTesting) {
- literal l = mk_eq(val_indicator, m_strutil.mk_string(longlong_to_string(i).c_str()), false);
+ literal l = mk_eq(val_indicator, mk_string(longlong_to_string(i).c_str()), false);
ctx.mark_as_relevant(l);
ctx.force_phase(l);
}
@@ -8474,19 +8505,19 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
expr * strAst;
if (m_params.m_UseFastValueTesterCache) {
if (!valueTesterCache.find(aStr, strAst)) {
- strAst = m_strutil.mk_string(aStr);
+ strAst = mk_string(aStr);
valueTesterCache.insert(aStr, strAst);
m_trail.push_back(strAst);
}
} else {
- strAst = m_strutil.mk_string(aStr);
+ strAst = mk_string(aStr);
}
andList.push_back(m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVar, strAst)));
}
if (!coverAll) {
- orList.push_back(m.mk_eq(val_indicator, m_strutil.mk_string("more")));
+ orList.push_back(m.mk_eq(val_indicator, mk_string("more")));
if (m_params.m_AggressiveValueTesting) {
- literal l = mk_eq(val_indicator, m_strutil.mk_string("more"), false);
+ literal l = mk_eq(val_indicator, mk_string("more"), false);
ctx.mark_as_relevant(l);
ctx.force_phase(~l);
}
@@ -8513,11 +8544,11 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
// Should add ($$_len_x_j = 16) /\ ($$_val_x_16_i = "more")
// ---------------------------------------
andList.reset();
- andList.push_back(m.mk_eq(len_indicator, m_strutil.mk_string(lenStr.c_str())));
+ andList.push_back(m.mk_eq(len_indicator, mk_string(lenStr.c_str())));
for (int i = 0; i < tries; i++) {
expr * vTester = fvar_valueTester_map[freeVar][len][i].second;
if (vTester != val_indicator)
- andList.push_back(m.mk_eq(vTester, m_strutil.mk_string("more")));
+ andList.push_back(m.mk_eq(vTester, mk_string("more")));
}
expr * assertL = NULL;
if (andList.size() == 1) {
@@ -8772,7 +8803,7 @@ void theory_str::gen_assign_unroll_reg(std::set<expr*> & unrolls) {
// option 0
expr_ref op0(ctx.mk_eq_atom(cntInUnr, mk_int(0)), mgr);
- expr_ref ast1(ctx.mk_eq_atom(unrFunc, m_strutil.mk_string("")), mgr);
+ expr_ref ast1(ctx.mk_eq_atom(unrFunc, mk_string("")), mgr);
expr_ref ast2(ctx.mk_eq_atom(mk_strlen(unrFunc), mk_int(0)), mgr);
expr_ref and1(mgr.mk_and(ast1, ast2), mgr);
@@ -8856,7 +8887,7 @@ expr * theory_str::gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls
return gen_unroll_conditional_options(n, unrolls, lcmStr);
} else {
expr_ref implyL(mk_and(litems), mgr);
- expr_ref implyR(ctx.mk_eq_atom(n, m_strutil.mk_string("")), mgr);
+ expr_ref implyR(ctx.mk_eq_atom(n, mk_string("")), mgr);
// want to return (implyL -> implyR)
expr * final_axiom = rewrite_implication(implyL, implyR);
return final_axiom;
@@ -8869,7 +8900,7 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
int dist = opt_LCMUnrollStep;
expr_ref_vector litems(mgr);
- expr_ref moreAst(m_strutil.mk_string("more"), mgr);
+ expr_ref moreAst(mk_string("more"), mgr);
for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
expr_ref item(ctx.mk_eq_atom(var, *itor), mgr);
TRACE("t_str_detail", tout << "considering unroll " << mk_pp(item, mgr) << std::endl;);
@@ -8972,10 +9003,10 @@ expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * test
for (int i = l; i < h; i++) {
std::string iStr = int_to_string(i);
- expr_ref testerEqAst(ctx.mk_eq_atom(testerVar, m_strutil.mk_string(iStr)), mgr);
+ expr_ref testerEqAst(ctx.mk_eq_atom(testerVar, mk_string(iStr)), mgr);
TRACE("t_str_detail", tout << "testerEqAst = " << mk_pp(testerEqAst, mgr) << std::endl;);
if (m_params.m_AggressiveUnrollTesting) {
- literal l = mk_eq(testerVar, m_strutil.mk_string(iStr), false);
+ literal l = mk_eq(testerVar, mk_string(iStr), false);
ctx.mark_as_relevant(l);
ctx.force_phase(l);
}
@@ -8983,7 +9014,7 @@ expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * test
orItems.push_back(testerEqAst);
std::string unrollStrInstance = get_unrolled_string(lcmStr, i);
- expr_ref x1(ctx.mk_eq_atom(testerEqAst, ctx.mk_eq_atom(var, m_strutil.mk_string(unrollStrInstance))), mgr);
+ expr_ref x1(ctx.mk_eq_atom(testerEqAst, ctx.mk_eq_atom(var, mk_string(unrollStrInstance))), mgr);
TRACE("t_str_detail", tout << "x1 = " << mk_pp(x1, mgr) << std::endl;);
andItems.push_back(x1);
@@ -8991,10 +9022,10 @@ expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * test
TRACE("t_str_detail", tout << "x2 = " << mk_pp(x2, mgr) << std::endl;);
andItems.push_back(x2);
}
- expr_ref testerEqMore(ctx.mk_eq_atom(testerVar, m_strutil.mk_string("more")), mgr);
+ expr_ref testerEqMore(ctx.mk_eq_atom(testerVar, mk_string("more")), mgr);
TRACE("t_str_detail", tout << "testerEqMore = " << mk_pp(testerEqMore, mgr) << std::endl;);
if (m_params.m_AggressiveUnrollTesting) {
- literal l = mk_eq(testerVar, m_strutil.mk_string("more"), false);
+ literal l = mk_eq(testerVar, mk_string("more"), false);
ctx.mark_as_relevant(l);
ctx.force_phase(~l);
}
@@ -9051,14 +9082,14 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
} else {
// no match; create and insert
std::string i_str = int_to_string(i);
- expr_ref new_val(m_strutil.mk_string(i_str), m);
+ expr_ref new_val(mk_string(i_str), m);
lengthTesterCache.insert(ri, new_val);
m_trail.push_back(new_val);
str_indicator = expr_ref(new_val, m);
}
} else {
std::string i_str = int_to_string(i);
- str_indicator = expr_ref(m_strutil.mk_string(i_str), m);
+ str_indicator = expr_ref(mk_string(i_str), m);
}
expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
orList.push_back(or_expr);
@@ -9074,9 +9105,9 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
}
// TODO cache mk_string("more")
- orList.push_back(m.mk_eq(indicator, m_strutil.mk_string("more")));
+ orList.push_back(m.mk_eq(indicator, mk_string("more")));
if (m_params.m_AggressiveLengthTesting) {
- literal l = mk_eq(indicator, m_strutil.mk_string("more"), false);
+ literal l = mk_eq(indicator, mk_string("more"), false);
ctx.mark_as_relevant(l);
ctx.force_phase(~l);
}
@@ -9104,7 +9135,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
int testerCount = tries - 1;
if (testerCount > 0) {
expr_ref_vector and_items_LHS(m);
- expr_ref moreAst(m_strutil.mk_string("more"), m);
+ expr_ref moreAst(mk_string("more"), m);
for (int i = 0; i < testerCount; ++i) {
expr * indicator = fvar_lenTester_map[freeVar][i];
if (internal_variable_set.find(indicator) == internal_variable_set.end()) {
@@ -9530,7 +9561,7 @@ app * theory_str::mk_value_helper(app * n) {
std::string a0_s(a0_str);
std::string a1_s(a1_str);
std::string result = a0_s + a1_s;
- return m_strutil.mk_string(result);
+ return to_app(mk_string(result));
}
}
// fallback path
@@ -9562,7 +9593,7 @@ model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
TRACE("t_str", tout << "WARNING: failed to find a concrete value, falling back" << std::endl;);
// TODO make absolutely sure the reason we can't find a concrete value is because of an unassigned temporary
// e.g. for an expression like (Concat X $$_str0)
- return alloc(expr_wrapper_proc, m_strutil.mk_string("**UNUSED**"));
+ return alloc(expr_wrapper_proc, to_app(mk_string("**UNUSED**")));
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index ffeea34e8..e77c955f2 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -263,6 +263,11 @@ namespace smt {
// used when opt_FastValueTesterCache is true
string_map valueTesterCache;
+ string_map stringConstantCache;
+ unsigned long totalCacheAccessCount;
+ unsigned long cacheHitCount;
+ unsigned long cacheMissCount;
+
// cache mapping each string S to Length(S)
obj_map<expr, app*> length_ast_map;
@@ -277,6 +282,9 @@ namespace smt {
void assert_implication(expr * premise, expr * conclusion);
expr * rewrite_implication(expr * premise, expr * conclusion);
+ expr * mk_string(std::string str);
+ expr * mk_string(const char * str);
+
app * mk_strlen(expr * e);
expr * mk_concat(expr * n1, expr * n2);
expr * mk_concat_const_str(expr * n1, expr * n2);
From 94762d276d7a6cac121e72fae0d39be046701ac9 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 18 Dec 2016 18:47:38 -0500
Subject: [PATCH 292/401] add string constant cache to theory_str and
associated param
---
src/smt/params/smt_params_helper.pyg | 1 +
src/smt/params/theory_str_params.cpp | 1 +
src/smt/params/theory_str_params.h | 9 ++++++-
src/smt/theory_str.cpp | 40 +++++++++++++++-------------
4 files changed, 32 insertions(+), 19 deletions(-)
diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg
index 3f2c6a54a..3bcb867b4 100644
--- a/src/smt/params/smt_params_helper.pyg
+++ b/src/smt/params/smt_params_helper.pyg
@@ -68,5 +68,6 @@ def_module_params(module_name='smt',
('str.aggressive_unroll_testing', BOOL, True, 'prioritize testing concrete regex unroll counts over generating more options'),
('str.fast_length_tester_cache', BOOL, False, 'cache length tester constants instead of regenerating them'),
('str.fast_value_tester_cache', BOOL, True, 'cache value tester constants instead of regenerating them'),
+ ('str.string_constant_cache', BOOL, True, 'cache all generated string constants generated from anywhere in theory_str'),
('theory_case_split', BOOL, False, 'Allow the context to use heuristics involving theory case splits, which are a set of literals of which exactly one can be assigned True. If this option is false, the context will generate extra axioms to enforce this instead.')
))
diff --git a/src/smt/params/theory_str_params.cpp b/src/smt/params/theory_str_params.cpp
index f952c6c87..dae7765cc 100644
--- a/src/smt/params/theory_str_params.cpp
+++ b/src/smt/params/theory_str_params.cpp
@@ -26,4 +26,5 @@ void theory_str_params::updt_params(params_ref const & _p) {
m_AggressiveUnrollTesting = p.str_aggressive_unroll_testing();
m_UseFastLengthTesterCache = p.str_fast_length_tester_cache();
m_UseFastValueTesterCache = p.str_fast_value_tester_cache();
+ m_StringConstantCache = p.str_string_constant_cache();
}
diff --git a/src/smt/params/theory_str_params.h b/src/smt/params/theory_str_params.h
index f4e7ecf33..dc4e1aa89 100644
--- a/src/smt/params/theory_str_params.h
+++ b/src/smt/params/theory_str_params.h
@@ -62,13 +62,20 @@ struct theory_str_params {
*/
bool m_UseFastValueTesterCache;
+ /*
+ * If StringConstantCache is set to true,
+ * all string constants in theory_str generated from anywhere will be cached and saved.
+ */
+ bool m_StringConstantCache;
+
theory_str_params(params_ref const & p = params_ref()):
m_AssertStrongerArrangements(true),
m_AggressiveLengthTesting(false),
m_AggressiveValueTesting(false),
m_AggressiveUnrollTesting(true),
m_UseFastLengthTesterCache(false),
- m_UseFastValueTesterCache(true)
+ m_UseFastValueTesterCache(true),
+ m_StringConstantCache(true)
{
updt_params(p);
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 19e677acb..3a3d36c36 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -70,25 +70,29 @@ theory_str::~theory_str() {
}
expr * theory_str::mk_string(std::string str) {
- ++totalCacheAccessCount;
- expr * val;
- if (stringConstantCache.find(str, val)) {
- // cache hit
- ++cacheHitCount;
- TRACE("t_str_cache", tout << "cache hit: \"" << str << "\" ("
- << cacheHitCount << " hits, " << cacheMissCount << " misses out of "
- << totalCacheAccessCount << " accesses)" << std::endl;);
- return val;
+ if (m_params.m_StringConstantCache) {
+ ++totalCacheAccessCount;
+ expr * val;
+ if (stringConstantCache.find(str, val)) {
+ // cache hit
+ ++cacheHitCount;
+ TRACE("t_str_cache", tout << "cache hit: \"" << str << "\" ("
+ << cacheHitCount << " hits, " << cacheMissCount << " misses out of "
+ << totalCacheAccessCount << " accesses)" << std::endl;);
+ return val;
+ } else {
+ // cache miss
+ ++cacheMissCount;
+ TRACE("t_str_cache", tout << "cache miss: \"" << str << "\" ("
+ << cacheHitCount << " hits, " << cacheMissCount << " misses out of "
+ << totalCacheAccessCount << " accesses)" << std::endl;);
+ val = m_strutil.mk_string(str);
+ m_trail.push_back(val);
+ stringConstantCache.insert(str, val);
+ return val;
+ }
} else {
- // cache miss
- ++cacheMissCount;
- TRACE("t_str_cache", tout << "cache miss: \"" << str << "\" ("
- << cacheHitCount << " hits, " << cacheMissCount << " misses out of "
- << totalCacheAccessCount << " accesses)" << std::endl;);
- val = m_strutil.mk_string(str);
- m_trail.push_back(val);
- stringConstantCache.insert(str, val);
- return val;
+ return m_strutil.mk_string(str);
}
}
From a04bc9974b2d2847505a37f3e9e640a082f4ed84 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 20 Dec 2016 11:14:42 -0500
Subject: [PATCH 293/401] theory case split WIP
---
src/smt/smt_context.cpp | 26 +++++++++++++++++++++++++-
src/smt/smt_context.h | 12 ++++++++++++
2 files changed, 37 insertions(+), 1 deletion(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 907ea876b..45beebc15 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -1750,6 +1750,8 @@ namespace smt {
if (inconsistent())
return false;
unsigned qhead = m_qhead;
+ if (!propagate_th_case_split())
+ return false;
if (!bcp())
return false;
if (get_cancel_flag())
@@ -2956,10 +2958,32 @@ namespace smt {
}
}
} else {
- NOT_IMPLEMENTED_YET();
+ int_set new_case_split; // TODO is it okay to allocate this on the stack?
+ for (unsigned i = 0; i < num_lits; ++i) {
+ literal l = lits[i];
+ // TODO do we need to enforce this invariant? can we make undo information work without it?
+ SASSERT(!m_all_th_case_split_literals.contains(l.index()));
+ m_all_th_case_split_literals.insert(l.index());
+ // TODO add undo information for this insert
+ new_case_split.insert(l.index());
+ }
+ m_th_case_split_sets.push_back(new_case_split);
+ push_trail(push_back_vector<context, vector<int_set> >(m_th_case_split_sets));
+ for (unsigned i = 0; i < num_lits; ++i) {
+ literal l = lits[i];
+ m_literal2casesplitsets[l.index()].push_back(new_case_split);
+ push_trail(push_back_vector<context, vector<int_set> >(m_literal2casesplitsets[l.index()]));
+ }
}
}
+ bool context::propagate_th_case_split() {
+ if (m_all_th_case_split_literals.empty())
+ return true;
+
+ NOT_IMPLEMENTED_YET(); return true;
+ }
+
bool context::reduce_assertions() {
if (!m_asserted_formulas.inconsistent()) {
SASSERT(at_base_level());
diff --git a/src/smt/smt_context.h b/src/smt/smt_context.h
index 5c52adc73..cdc52dc67 100644
--- a/src/smt/smt_context.h
+++ b/src/smt/smt_context.h
@@ -212,6 +212,16 @@ namespace smt {
literal2assumption m_literal2assumption; // maps an expression associated with a literal to the original assumption
expr_ref_vector m_unsat_core;
+ // -----------------------------------
+ //
+ // Theory case split
+ //
+ // -----------------------------------
+ typedef int_hashtable<int_hash, default_eq<int> > int_set;
+ int_set m_all_th_case_split_literals;
+ vector<int_set> m_th_case_split_sets;
+ u_map< vector<int_set> > m_literal2casesplitsets; // returns the case split literal sets that a literal participates in
+
// -----------------------------------
//
// Accessors
@@ -814,6 +824,8 @@ namespace smt {
*/
void mk_th_case_split(unsigned num_lits, literal * lits);
+ bool propagate_th_case_split();
+
bool_var mk_bool_var(expr * n);
enode * mk_enode(app * n, bool suppress_args, bool merge_tf, bool cgc_enabled);
From ab0fcc42f9107931a414fff39c1769dfd7be14d1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 20 Dec 2016 16:21:07 -0500
Subject: [PATCH 294/401] theory case split heuristic
---
src/smt/smt_context.cpp | 93 +++++++++++++++++++++++++++++++++++++----
src/smt/smt_context.h | 8 +++-
2 files changed, 91 insertions(+), 10 deletions(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 45beebc15..93461584f 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -63,6 +63,7 @@ namespace smt {
m_is_diseq_tmp(0),
m_units_to_reassert(m_manager),
m_qhead(0),
+ m_th_case_split_qhead(0),
m_simp_qhead(0),
m_simp_counter(0),
m_bvar_inc(1.0),
@@ -325,6 +326,7 @@ namespace smt {
bool context::bcp() {
SASSERT(!inconsistent());
+ m_th_case_split_qhead = m_qhead;
while (m_qhead < m_assigned_literals.size()) {
if (get_cancel_flag()) {
return true;
@@ -1750,10 +1752,10 @@ namespace smt {
if (inconsistent())
return false;
unsigned qhead = m_qhead;
- if (!propagate_th_case_split())
- return false;
if (!bcp())
return false;
+ if (!propagate_th_case_split())
+ return false;
if (get_cancel_flag())
return true;
SASSERT(!inconsistent());
@@ -2941,6 +2943,18 @@ namespace smt {
assert_expr_core(e, pr);
}
+ class case_split_insert_trail : public trail<context> {
+ literal l;
+ public:
+ case_split_insert_trail(literal l):
+ l(l) {
+
+ }
+ virtual void undo(context & ctx) {
+ ctx.undo_th_case_split(l);
+ }
+ };
+
void context::mk_th_case_split(unsigned num_lits, literal * lits) {
TRACE("theory_case_split", display_literals_verbose(tout << "theory case split: ", num_lits, lits); tout << std::endl;);
// If we don't use the theory case split heuristic,
@@ -2958,30 +2972,93 @@ namespace smt {
}
}
} else {
- int_set new_case_split; // TODO is it okay to allocate this on the stack?
+ literal_vector new_case_split; // TODO is it okay to allocate this on the stack?
for (unsigned i = 0; i < num_lits; ++i) {
literal l = lits[i];
// TODO do we need to enforce this invariant? can we make undo information work without it?
SASSERT(!m_all_th_case_split_literals.contains(l.index()));
m_all_th_case_split_literals.insert(l.index());
- // TODO add undo information for this insert
- new_case_split.insert(l.index());
+ push_trail(case_split_insert_trail(l));
+ new_case_split.push_back(l);
}
m_th_case_split_sets.push_back(new_case_split);
- push_trail(push_back_vector<context, vector<int_set> >(m_th_case_split_sets));
+ push_trail(push_back_vector<context, vector<literal_vector> >(m_th_case_split_sets));
for (unsigned i = 0; i < num_lits; ++i) {
literal l = lits[i];
+ if (!m_literal2casesplitsets.contains(l.index())) {
+ m_literal2casesplitsets.insert(l.index(), vector<literal_vector>());
+ }
m_literal2casesplitsets[l.index()].push_back(new_case_split);
- push_trail(push_back_vector<context, vector<int_set> >(m_literal2casesplitsets[l.index()]));
+ push_trail(push_back_vector<context, vector<literal_vector> >(m_literal2casesplitsets[l.index()]));
}
+ TRACE("theory_case_split", tout << "tracking case split literal set { ";
+ for (unsigned i = 0; i < num_lits; ++i) {
+ tout << lits[i].index() << " ";
+ }
+ tout << "}" << std::endl;
+ );
}
}
+ void context::undo_th_case_split(literal l) {
+ m_all_th_case_split_literals.remove(l.index());
+ }
+
bool context::propagate_th_case_split() {
if (m_all_th_case_split_literals.empty())
return true;
- NOT_IMPLEMENTED_YET(); return true;
+ // iterate over all literals assigned since the last time this method was called,
+ // not counting any literals that get assigned by this method
+ // this relies on bcp() to give us its old m_qhead and therefore
+ // bcp() should always be called before this method
+ unsigned assigned_literal_idx = m_th_case_split_qhead;
+ unsigned assigned_literal_end = m_assigned_literals.size();
+ while(assigned_literal_idx < assigned_literal_end) {
+ literal l = m_assigned_literals[assigned_literal_idx];
+ TRACE("theory_case_split", tout << "check literal " << l.index() << std::endl; display_literal_verbose(tout, l); tout << std::endl;);
+ ++assigned_literal_idx;
+ // check if this literal participates in any theory case split
+ if (m_all_th_case_split_literals.contains(l.index())) {
+ TRACE("theory_case_split", tout << "assigned literal " << l.index() << " is a theory case split literal" << std::endl;);
+ // now find the sets of literals which contain l
+ vector<literal_vector> case_split_sets = m_literal2casesplitsets.get(l.index(), vector<literal_vector>());
+ for (vector<literal_vector>::const_iterator it = case_split_sets.begin(); it != case_split_sets.end(); ++it) {
+ literal_vector case_split_set = *it;
+ TRACE("theory_case_split", tout << "found case split set { ";
+ for(literal_vector::iterator set_it = case_split_set.begin(); set_it != case_split_set.end(); ++set_it) {
+ tout << set_it->index() << " ";
+ }
+ tout << "}" << std::endl;);
+ for(literal_vector::iterator set_it = case_split_set.begin(); set_it != case_split_set.end(); ++set_it) {
+ literal l2 = *set_it;
+ if (l2 != l) {
+ b_justification js(l);
+ switch (get_assignment(l2)) {
+ case l_false:
+ TRACE("theory_case_split", tout << "case split literal " << l2.index() << " is already assigned False" << std::endl;);
+ break;
+ // TODO these next two cases can be combined. I'm doing this for debugging purposes
+ case l_undef:
+ TRACE("theory_case_split", tout << "case split literal " << l2.index() << " is not assigned" << std::endl;);
+ assign(~l2, js);
+ break;
+ case l_true:
+ TRACE("theory_case_split", tout << "case split literal " << l2.index() << " is already assigned True" << std::endl;);
+ assign(~l2, js);
+ break;
+ }
+ if (inconsistent()) {
+ TRACE("theory_case_split", tout << "conflict detected!" << std::endl;);
+ return false;
+ }
+ }
+ }
+ }
+ }
+ }
+ // if we get here without detecting a conflict, we're fine
+ return true;
}
bool context::reduce_assertions() {
diff --git a/src/smt/smt_context.h b/src/smt/smt_context.h
index cdc52dc67..8016eb587 100644
--- a/src/smt/smt_context.h
+++ b/src/smt/smt_context.h
@@ -219,8 +219,9 @@ namespace smt {
// -----------------------------------
typedef int_hashtable<int_hash, default_eq<int> > int_set;
int_set m_all_th_case_split_literals;
- vector<int_set> m_th_case_split_sets;
- u_map< vector<int_set> > m_literal2casesplitsets; // returns the case split literal sets that a literal participates in
+ vector<literal_vector> m_th_case_split_sets;
+ u_map< vector<literal_vector> > m_literal2casesplitsets; // returns the case split literal sets that a literal participates in
+ unsigned m_th_case_split_qhead;
// -----------------------------------
//
@@ -824,6 +825,9 @@ namespace smt {
*/
void mk_th_case_split(unsigned num_lits, literal * lits);
+ // helper function for trail
+ void undo_th_case_split(literal l);
+
bool propagate_th_case_split();
bool_var mk_bool_var(expr * n);
From df63b62763ef06c27fef3bc9c3d5d5fac17437ff Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 20 Dec 2016 17:32:51 -0500
Subject: [PATCH 295/401] fix vector manip bug in theory case split
---
src/smt/smt_context.cpp | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 93461584f..6c0a89d4f 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -2989,7 +2989,6 @@ namespace smt {
m_literal2casesplitsets.insert(l.index(), vector<literal_vector>());
}
m_literal2casesplitsets[l.index()].push_back(new_case_split);
- push_trail(push_back_vector<context, vector<literal_vector> >(m_literal2casesplitsets[l.index()]));
}
TRACE("theory_case_split", tout << "tracking case split literal set { ";
for (unsigned i = 0; i < num_lits; ++i) {
@@ -3002,6 +3001,11 @@ namespace smt {
void context::undo_th_case_split(literal l) {
m_all_th_case_split_literals.remove(l.index());
+ if (m_literal2casesplitsets.contains(l.index())) {
+ if (!m_literal2casesplitsets[l.index()].empty()) {
+ m_literal2casesplitsets[l.index()].pop_back();
+ }
+ }
}
bool context::propagate_th_case_split() {
From 2dc9b486d3d4962850e2899836b64cf2a07266f9 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 22 Dec 2016 19:17:42 -0500
Subject: [PATCH 296/401] theory_str binary search heuristic WIP
---
src/smt/params/smt_params_helper.pyg | 2 +
src/smt/params/theory_str_params.cpp | 2 +
src/smt/params/theory_str_params.h | 7 +-
src/smt/theory_str.cpp | 546 +++++++++++++++++++--------
src/smt/theory_str.h | 53 +++
5 files changed, 442 insertions(+), 168 deletions(-)
diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg
index 3bcb867b4..4e3bec57d 100644
--- a/src/smt/params/smt_params_helper.pyg
+++ b/src/smt/params/smt_params_helper.pyg
@@ -69,5 +69,7 @@ def_module_params(module_name='smt',
('str.fast_length_tester_cache', BOOL, False, 'cache length tester constants instead of regenerating them'),
('str.fast_value_tester_cache', BOOL, True, 'cache value tester constants instead of regenerating them'),
('str.string_constant_cache', BOOL, True, 'cache all generated string constants generated from anywhere in theory_str'),
+ ('str.use_binary_search', BOOL, False, 'use a binary search heuristic for finding concrete length values for free variables in theory_str (set to False to use linear search)'),
+ ('str.binary_search_start', UINT, 64, 'initial upper bound for theory_str binary search'),
('theory_case_split', BOOL, False, 'Allow the context to use heuristics involving theory case splits, which are a set of literals of which exactly one can be assigned True. If this option is false, the context will generate extra axioms to enforce this instead.')
))
diff --git a/src/smt/params/theory_str_params.cpp b/src/smt/params/theory_str_params.cpp
index dae7765cc..2e98a4394 100644
--- a/src/smt/params/theory_str_params.cpp
+++ b/src/smt/params/theory_str_params.cpp
@@ -27,4 +27,6 @@ void theory_str_params::updt_params(params_ref const & _p) {
m_UseFastLengthTesterCache = p.str_fast_length_tester_cache();
m_UseFastValueTesterCache = p.str_fast_value_tester_cache();
m_StringConstantCache = p.str_string_constant_cache();
+ m_UseBinarySearch = p.str_use_binary_search();
+ m_BinarySearchInitialUpperBound = p.str_binary_search_start();
}
diff --git a/src/smt/params/theory_str_params.h b/src/smt/params/theory_str_params.h
index dc4e1aa89..39c553780 100644
--- a/src/smt/params/theory_str_params.h
+++ b/src/smt/params/theory_str_params.h
@@ -68,6 +68,9 @@ struct theory_str_params {
*/
bool m_StringConstantCache;
+ bool m_UseBinarySearch;
+ unsigned m_BinarySearchInitialUpperBound;
+
theory_str_params(params_ref const & p = params_ref()):
m_AssertStrongerArrangements(true),
m_AggressiveLengthTesting(false),
@@ -75,7 +78,9 @@ struct theory_str_params {
m_AggressiveUnrollTesting(true),
m_UseFastLengthTesterCache(false),
m_UseFastValueTesterCache(true),
- m_StringConstantCache(true)
+ m_StringConstantCache(true),
+ m_UseBinarySearch(false),
+ m_BinarySearchInitialUpperBound(64)
{
updt_params(p);
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3a3d36c36..754d258bc 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6379,27 +6379,53 @@ void theory_str::more_value_tests(expr * valTester, std::string valTesterValue)
ast_manager & m = get_manager();
expr * fVar = valueTester_fvar_map[valTester];
- int lenTesterCount = fvar_lenTester_map[fVar].size();
-
- expr * effectiveLenInd = NULL;
- std::string effectiveLenIndiStr = "";
- for (int i = 0; i < lenTesterCount; ++i) {
- expr * len_indicator_pre = fvar_lenTester_map[fVar][i];
- bool indicatorHasEqcValue = false;
- expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
- if (indicatorHasEqcValue) {
- std::string len_pIndiStr = m_strutil.get_string_constant_value(len_indicator_value);
- if (len_pIndiStr != "more") {
- effectiveLenInd = len_indicator_pre;
- effectiveLenIndiStr = len_pIndiStr;
- break;
+ if (m_params.m_UseBinarySearch) {
+ if (!binary_search_len_tester_stack.contains(fVar) || binary_search_len_tester_stack[fVar].empty()) {
+ TRACE("t_str_binary_search", tout << "WARNING: no active length testers for " << mk_pp(fVar, m) << std::endl;);
+ // TODO handle this?
+ NOT_IMPLEMENTED_YET();
+ }
+ expr * effectiveLenInd = binary_search_len_tester_stack[fVar].back();
+ bool hasEqcValue;
+ expr * len_indicator_value = get_eqc_value(effectiveLenInd, hasEqcValue);
+ if (!hasEqcValue) {
+ TRACE("t_str_binary_search", tout << "WARNING: length tester " << mk_pp(effectiveLenInd, m) << " at top of stack for " << mk_pp(fVar, m) << " has no EQC value" << std::endl;);
+ } else {
+ // safety check
+ std::string effectiveLenIndiStr = m_strutil.get_string_constant_value(len_indicator_value);
+ if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "less") {
+ TRACE("t_str_binary_search", tout << "ERROR: illegal state -- requesting 'more value tests' but a length tester is not yet concrete!" << std::endl;);
+ UNREACHABLE();
+ }
+ expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
+ TRACE("t_str_detail", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
+ if (valueAssert != NULL) {
+ assert_axiom(valueAssert);
}
}
- }
- expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
- TRACE("t_str_detail", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
- if (valueAssert != NULL) {
- assert_axiom(valueAssert);
+ } else {
+ int lenTesterCount = fvar_lenTester_map[fVar].size();
+
+ expr * effectiveLenInd = NULL;
+ std::string effectiveLenIndiStr = "";
+ for (int i = 0; i < lenTesterCount; ++i) {
+ expr * len_indicator_pre = fvar_lenTester_map[fVar][i];
+ bool indicatorHasEqcValue = false;
+ expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
+ if (indicatorHasEqcValue) {
+ std::string len_pIndiStr = m_strutil.get_string_constant_value(len_indicator_value);
+ if (len_pIndiStr != "more") {
+ effectiveLenInd = len_indicator_pre;
+ effectiveLenIndiStr = len_pIndiStr;
+ break;
+ }
+ }
+ }
+ expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
+ TRACE("t_str_detail", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
+ if (valueAssert != NULL) {
+ assert_axiom(valueAssert);
+ }
}
}
@@ -9163,6 +9189,186 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
}
}
+// Return an expression of the form
+// (tester = "less" | tester = "N" | tester = "more") &
+// (tester = "less" iff len(freeVar) < N) & (tester = "more" iff len(freeVar) > N) & (tester = "N" iff len(freeVar) = N))
+expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ rational N = bounds.midPoint;
+ rational N_minus_one = N - rational::one();
+ rational N_plus_one = N + rational::one();
+ expr_ref lenFreeVar(mk_strlen(freeVar), m);
+
+ TRACE("t_str_binary_search", tout << "create case split for free var " << mk_pp(freeVar, m)
+ << " over " << mk_pp(tester, m) << " with midpoint " << N << std::endl;);
+
+ expr_ref_vector combinedCaseSplit(m);
+ expr_ref_vector testerCases(m);
+
+ expr_ref caseLess(ctx.mk_eq_atom(tester, mk_string("less")), m);
+ testerCases.push_back(caseLess);
+ combinedCaseSplit.push_back(ctx.mk_eq_atom(caseLess, m_autil.mk_le(lenFreeVar, m_autil.mk_numeral(N_minus_one, true) )));
+
+ expr_ref caseMore(ctx.mk_eq_atom(tester, mk_string("more")), m);
+ testerCases.push_back(caseMore);
+ combinedCaseSplit.push_back(ctx.mk_eq_atom(caseMore, m_autil.mk_ge(lenFreeVar, m_autil.mk_numeral(N_plus_one, true) )));
+
+ expr_ref caseEq(ctx.mk_eq_atom(tester, mk_string(N.to_string())), m);
+ testerCases.push_back(caseEq);
+ combinedCaseSplit.push_back(ctx.mk_eq_atom(caseEq, ctx.mk_eq_atom(lenFreeVar, m_autil.mk_numeral(N, true))));
+
+ combinedCaseSplit.push_back(mk_or(testerCases));
+
+ expr_ref final_term(mk_and(combinedCaseSplit), m);
+ SASSERT(final_term);
+ TRACE("t_str_binary_search", tout << "final term: " << mk_pp(final_term, m) << std::endl;);
+ return final_term;
+}
+
+expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenTester, std::string previousLenTesterValue) {
+ ast_manager & m = get_manager();
+
+ if (binary_search_len_tester_stack.contains(freeVar)) {
+ TRACE("t_str_binary_search", tout << "checking existing length testers for " << mk_pp(freeVar, m) << std::endl;
+ for (ptr_vector<expr>::const_iterator it = binary_search_len_tester_stack[freeVar].begin();
+ it != binary_search_len_tester_stack[freeVar].end(); ++it) {
+ expr * tester = *it;
+ tout << mk_pp(tester, m) << ": ";
+ if (binary_search_len_tester_info.contains(tester)) {
+ binary_search_info & bounds = binary_search_len_tester_info[tester];
+ tout << "[" << bounds.lowerBound << " | " << bounds.midPoint << " | " << bounds.upperBound << "]!" << bounds.windowSize;
+ } else {
+ tout << "[WARNING: no bounds info available]";
+ }
+ bool hasEqcValue;
+ expr * testerEqcValue = get_eqc_value(tester, hasEqcValue);
+ if (hasEqcValue) {
+ tout << " = " << mk_pp(testerEqcValue, m);
+ } else {
+ tout << " [no eqc value]";
+ }
+ tout << std::endl;
+ }
+ );
+ expr * lastTester = binary_search_len_tester_stack[freeVar].back();
+ bool lastTesterHasEqcValue;
+ expr * lastTesterValue = get_eqc_value(lastTester, lastTesterHasEqcValue);
+ std::string lastTesterConstant;
+ if (!lastTesterHasEqcValue) {
+ TRACE("t_str_binary_search", tout << "length tester " << mk_pp(lastTester, m) << " at top of stack doesn't have an EQC value yet" << std::endl;);
+ // check previousLenTester
+ if (previousLenTester == lastTester) {
+ lastTesterConstant = previousLenTesterValue;
+ TRACE("t_str_binary_search", tout << "invoked with previousLenTester info matching top of stack" << std::endl;);
+ } else {
+ // this is a bit unexpected
+ TRACE("t_str_binary_search", tout << "WARNING: unexpected reordering of length testers!" << std::endl;);
+ // TODO resolve this case
+ NOT_IMPLEMENTED_YET(); return NULL;
+ }
+ } else {
+ lastTesterConstant = m_strutil.get_string_constant_value(lastTesterValue);
+ }
+ TRACE("t_str_binary_search", tout << "last length tester is assigned \"" << lastTesterConstant << "\"" << std::endl;);
+ if (lastTesterConstant == "more" || lastTesterConstant == "less") {
+ // use the previous bounds info to generate a new midpoint
+ binary_search_info lastBounds;
+ if (!binary_search_len_tester_info.find(lastTester, lastBounds)) {
+ // unexpected
+ TRACE("t_str_binary_search", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
+ // TODO resolve this
+ NOT_IMPLEMENTED_YET();
+ }
+ TRACE("t_str_binary_search", tout << "last bounds are [" << lastBounds.lowerBound << " | " << lastBounds.midPoint << " | " << lastBounds.upperBound << "]!" << lastBounds.windowSize << std::endl;);
+ binary_search_info newBounds;
+ expr * newTester;
+ if (lastTesterConstant == "more") {
+ // special case: if the midpoint, upper bound, and window size are all equal,
+ // we double the window size and adjust the bounds
+ if (lastBounds.midPoint == lastBounds.upperBound && lastBounds.upperBound == lastBounds.windowSize) {
+ TRACE("t_str_binary_search", tout << "search hit window size; expanding" << std::endl;);
+ // TODO is this correct?
+ newBounds.lowerBound = lastBounds.windowSize + rational::one();
+ newBounds.windowSize = lastBounds.windowSize * rational(2);
+ newBounds.upperBound = newBounds.windowSize;
+ newBounds.calculate_midpoint();
+ } else if (false) {
+ // TODO handle the case where the midpoint can't be increased further
+ // (e.g. a window like [50 | 50 | 50]!64 and we don't answer "50")
+ } else {
+ // general case
+ newBounds.lowerBound = lastBounds.midPoint + rational::one();
+ newBounds.windowSize = lastBounds.windowSize;
+ newBounds.upperBound = lastBounds.upperBound;
+ newBounds.calculate_midpoint();
+ }
+ if (!binary_search_next_var_high.find(lastTester, newTester)) {
+ newTester = mk_internal_lenTest_var(freeVar, newBounds.midPoint.get_int32());
+ binary_search_next_var_high.insert(lastTester, newTester);
+ }
+ refresh_theory_var(newTester);
+ } else if (lastTesterConstant == "less") {
+ if (false) {
+ // TODO handle the case where the midpoint can't be decreased further
+ // (e.g. a window like [0 | 0 | 0]!64 and we don't answer "0"
+ } else {
+ // general case
+ newBounds.upperBound = lastBounds.midPoint - rational::one();
+ newBounds.windowSize = lastBounds.windowSize;
+ newBounds.lowerBound = lastBounds.lowerBound;
+ newBounds.calculate_midpoint();
+ }
+ if (!binary_search_next_var_low.find(lastTester, newTester)) {
+ newTester = mk_internal_lenTest_var(freeVar, newBounds.midPoint.get_int32());
+ binary_search_next_var_low.insert(lastTester, newTester);
+ }
+ refresh_theory_var(newTester);
+ }
+ TRACE("t_str_binary_search", tout << "new bounds are [" << newBounds.lowerBound << " | " << newBounds.midPoint << " | " << newBounds.upperBound << "]!" << newBounds.windowSize << std::endl;);
+ binary_search_len_tester_stack[freeVar].push_back(newTester);
+ m_trail_stack.push(binary_search_trail<theory_str>(binary_search_len_tester_stack, freeVar));
+ binary_search_len_tester_info.insert(newTester, newBounds);
+ m_trail_stack.push(insert_obj_map<theory_str, expr, binary_search_info>(binary_search_len_tester_info, newTester));
+
+ expr_ref next_case_split(binary_search_case_split(freeVar, newTester, newBounds));
+ m_trail.push_back(next_case_split);
+ // TODO assert a precondition about all previous length testers that got us here
+ return next_case_split;
+ } else { // lastTesterConstant is a concrete value
+ TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
+ // length is fixed
+ expr * valueAssert = gen_free_var_options(freeVar, lastTester, lastTesterConstant, NULL, "");
+ return valueAssert;
+ }
+ } else {
+ // no length testers yet
+ TRACE("t_str_binary_search", tout << "no length testers for " << mk_pp(freeVar, m) << std::endl;);
+ binary_search_len_tester_stack.insert(freeVar, ptr_vector<expr>());
+
+ expr * firstTester;
+ rational lowerBound(0);
+ rational upperBound(m_params.m_BinarySearchInitialUpperBound);
+ rational windowSize(upperBound);
+ rational midPoint(floor(upperBound / rational(2)));
+ if (!binary_search_starting_len_tester.find(freeVar, firstTester)) {
+ firstTester = mk_internal_lenTest_var(freeVar, midPoint.get_int32());
+ binary_search_starting_len_tester.insert(freeVar, firstTester);
+ }
+ refresh_theory_var(firstTester);
+
+ binary_search_len_tester_stack[freeVar].push_back(firstTester);
+ m_trail_stack.push(binary_search_trail<theory_str>(binary_search_len_tester_stack, freeVar));
+ binary_search_info new_info(lowerBound, midPoint, upperBound, windowSize);
+ binary_search_len_tester_info.insert(firstTester, new_info);
+ m_trail_stack.push(insert_obj_map<theory_str, expr, binary_search_info>(binary_search_len_tester_info, firstTester));
+
+ expr_ref initial_case_split(binary_search_case_split(freeVar, firstTester, new_info));
+ m_trail.push_back(initial_case_split);
+ return initial_case_split;
+ }
+}
+
// -----------------------------------------------------------------------------------------------------
// True branch will be taken in final_check:
// - When we discover a variable is "free" for the first time
@@ -9180,161 +9386,167 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
TRACE("t_str_detail", tout << "gen for free var " << mk_ismt2_pp(freeVar, m) << std::endl;);
- bool map_effectively_empty = false;
- if (fvar_len_count_map.find(freeVar) == fvar_len_count_map.end()) {
- TRACE("t_str_detail", tout << "fvar_len_count_map is empty" << std::endl;);
- map_effectively_empty = true;
- }
-
- if (!map_effectively_empty) {
- // check whether any entries correspond to variables that went out of scope;
- // if every entry is out of scope then the map counts as being empty
- // TODO: maybe remove them from the map instead? either here or in pop_scope_eh()
-
- // assume empty and find a counterexample
- map_effectively_empty = true;
- ptr_vector<expr> indicator_set = fvar_lenTester_map[freeVar];
- for (ptr_vector<expr>::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) {
- expr * indicator = *it;
- if (internal_variable_set.find(indicator) != internal_variable_set.end()) {
- TRACE("t_str_detail", tout <<"found active internal variable " << mk_ismt2_pp(indicator, m)
- << " in fvar_lenTester_map[freeVar]" << std::endl;);
- map_effectively_empty = false;
- break;
- }
- }
- CTRACE("t_str_detail", map_effectively_empty, tout << "all variables in fvar_lenTester_map[freeVar] out of scope" << std::endl;);
- }
-
- if (map_effectively_empty) {
- // no length assertions for this free variable have ever been added.
- TRACE("t_str_detail", tout << "no length assertions yet" << std::endl;);
-
- fvar_len_count_map[freeVar] = 1;
- unsigned int testNum = fvar_len_count_map[freeVar];
-
- expr_ref indicator(mk_internal_lenTest_var(freeVar, testNum), m);
- SASSERT(indicator);
-
- // since the map is "effectively empty", we can remove those variables that have left scope...
- fvar_lenTester_map[freeVar].shrink(0);
- fvar_lenTester_map[freeVar].push_back(indicator);
- lenTester_fvar_map[indicator] = freeVar;
-
- expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
- SASSERT(lenTestAssert != NULL);
- return lenTestAssert;
+ if (m_params.m_UseBinarySearch) {
+ TRACE("t_str_detail", tout << "using binary search heuristic" << std::endl;);
+ return binary_search_length_test(freeVar, lenTesterInCbEq, lenTesterValue);
} else {
- TRACE("t_str_detail", tout << "found previous in-scope length assertions" << std::endl;);
+ bool map_effectively_empty = false;
+ if (fvar_len_count_map.find(freeVar) == fvar_len_count_map.end()) {
+ TRACE("t_str_detail", tout << "fvar_len_count_map is empty" << std::endl;);
+ map_effectively_empty = true;
+ }
- expr * effectiveLenInd = NULL;
- std::string effectiveLenIndiStr = "";
- int lenTesterCount = (int) fvar_lenTester_map[freeVar].size();
+ if (!map_effectively_empty) {
+ // check whether any entries correspond to variables that went out of scope;
+ // if every entry is out of scope then the map counts as being empty
+ // TODO: maybe remove them from the map instead? either here or in pop_scope_eh()
- TRACE("t_str_detail",
- tout << lenTesterCount << " length testers in fvar_lenTester_map[" << mk_pp(freeVar, m) << "]:" << std::endl;
- for (int i = 0; i < lenTesterCount; ++i) {
- expr * len_indicator = fvar_lenTester_map[freeVar][i];
- tout << mk_pp(len_indicator, m) << ": ";
- bool effectiveInScope = (internal_variable_set.find(len_indicator) != internal_variable_set.end());
- tout << (effectiveInScope ? "in scope" : "NOT in scope");
- tout << std::endl;
- }
- );
+ // assume empty and find a counterexample
+ map_effectively_empty = true;
+ ptr_vector<expr> indicator_set = fvar_lenTester_map[freeVar];
+ for (ptr_vector<expr>::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) {
+ expr * indicator = *it;
+ if (internal_variable_set.find(indicator) != internal_variable_set.end()) {
+ TRACE("t_str_detail", tout <<"found active internal variable " << mk_ismt2_pp(indicator, m)
+ << " in fvar_lenTester_map[freeVar]" << std::endl;);
+ map_effectively_empty = false;
+ break;
+ }
+ }
+ CTRACE("t_str_detail", map_effectively_empty, tout << "all variables in fvar_lenTester_map[freeVar] out of scope" << std::endl;);
+ }
- int i = 0;
- for (; i < lenTesterCount; ++i) {
- expr * len_indicator_pre = fvar_lenTester_map[freeVar][i];
- // check whether this is in scope as well
- if (internal_variable_set.find(len_indicator_pre) == internal_variable_set.end()) {
- TRACE("t_str_detail", tout << "length indicator " << mk_pp(len_indicator_pre, m) << " not in scope" << std::endl;);
- continue;
- }
+ if (map_effectively_empty) {
+ // no length assertions for this free variable have ever been added.
+ TRACE("t_str_detail", tout << "no length assertions yet" << std::endl;);
- bool indicatorHasEqcValue = false;
- expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
- TRACE("t_str_detail", tout << "length indicator " << mk_ismt2_pp(len_indicator_pre, m) <<
- " = " << mk_ismt2_pp(len_indicator_value, m) << std::endl;);
- if (indicatorHasEqcValue) {
- const char * val = 0;
- m_strutil.is_string(len_indicator_value, & val);
- std::string len_pIndiStr(val);
- if (len_pIndiStr != "more") {
- effectiveLenInd = len_indicator_pre;
- effectiveLenIndiStr = len_pIndiStr;
- break;
- }
- } else {
- if (lenTesterInCbEq != len_indicator_pre) {
- TRACE("t_str", tout << "WARNING: length indicator " << mk_ismt2_pp(len_indicator_pre, m)
- << " does not have an equivalence class value."
- << " i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
- if (i > 0) {
- effectiveLenInd = fvar_lenTester_map[freeVar][i - 1];
- bool effectiveHasEqcValue;
- expr * effective_eqc_value = get_eqc_value(effectiveLenInd, effectiveHasEqcValue);
- bool effectiveInScope = (internal_variable_set.find(effectiveLenInd) != internal_variable_set.end());
- TRACE("t_str_detail", tout << "checking effective length indicator " << mk_pp(effectiveLenInd, m) << ": "
- << (effectiveInScope ? "in scope" : "NOT in scope") << ", ";
- if (effectiveHasEqcValue) {
- tout << "~= " << mk_pp(effective_eqc_value, m);
- } else {
- tout << "no eqc string constant";
- }
- tout << std::endl;);
- if (effectiveLenInd == lenTesterInCbEq) {
- effectiveLenIndiStr = lenTesterValue;
- } else {
- if (effectiveHasEqcValue) {
- effectiveLenIndiStr = m_strutil.get_string_constant_value(effective_eqc_value);
- } else {
- // TODO this should be unreachable, but can we really do anything here?
- NOT_IMPLEMENTED_YET();
- }
- }
- }
- break;
- }
- // lenTesterInCbEq == len_indicator_pre
- else {
- if (lenTesterValue != "more") {
- effectiveLenInd = len_indicator_pre;
- effectiveLenIndiStr = lenTesterValue;
- break;
- }
- }
- } // !indicatorHasEqcValue
- } // for (i : [0..lenTesterCount-1])
- if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "") {
- TRACE("t_str", tout << "length is not fixed; generating length tester options for free var" << std::endl;);
- expr_ref indicator(m);
- unsigned int testNum = 0;
+ fvar_len_count_map[freeVar] = 1;
+ unsigned int testNum = fvar_len_count_map[freeVar];
- TRACE("t_str", tout << "effectiveLenIndiStr = " << effectiveLenIndiStr
- << ", i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
+ expr_ref indicator(mk_internal_lenTest_var(freeVar, testNum), m);
+ SASSERT(indicator);
- if (i == lenTesterCount) {
- fvar_len_count_map[freeVar] = fvar_len_count_map[freeVar] + 1;
- testNum = fvar_len_count_map[freeVar];
- indicator = mk_internal_lenTest_var(freeVar, testNum);
- fvar_lenTester_map[freeVar].push_back(indicator);
- lenTester_fvar_map[indicator] = freeVar;
- } else {
- // TODO make absolutely sure this is safe to do if 'indicator' is technically out of scope
- indicator = fvar_lenTester_map[freeVar][i];
- refresh_theory_var(indicator);
- testNum = i + 1;
- }
- expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
- SASSERT(lenTestAssert != NULL);
- return lenTestAssert;
- } else {
- TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
- // length is fixed
- expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, "");
- return valueAssert;
- }
- } // fVarLenCountMap.find(...)
+ // since the map is "effectively empty", we can remove those variables that have left scope...
+ fvar_lenTester_map[freeVar].shrink(0);
+ fvar_lenTester_map[freeVar].push_back(indicator);
+ lenTester_fvar_map[indicator] = freeVar;
+
+ expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
+ SASSERT(lenTestAssert != NULL);
+ return lenTestAssert;
+ } else {
+ TRACE("t_str_detail", tout << "found previous in-scope length assertions" << std::endl;);
+
+ expr * effectiveLenInd = NULL;
+ std::string effectiveLenIndiStr = "";
+ int lenTesterCount = (int) fvar_lenTester_map[freeVar].size();
+
+ TRACE("t_str_detail",
+ tout << lenTesterCount << " length testers in fvar_lenTester_map[" << mk_pp(freeVar, m) << "]:" << std::endl;
+ for (int i = 0; i < lenTesterCount; ++i) {
+ expr * len_indicator = fvar_lenTester_map[freeVar][i];
+ tout << mk_pp(len_indicator, m) << ": ";
+ bool effectiveInScope = (internal_variable_set.find(len_indicator) != internal_variable_set.end());
+ tout << (effectiveInScope ? "in scope" : "NOT in scope");
+ tout << std::endl;
+ }
+ );
+
+ int i = 0;
+ for (; i < lenTesterCount; ++i) {
+ expr * len_indicator_pre = fvar_lenTester_map[freeVar][i];
+ // check whether this is in scope as well
+ if (internal_variable_set.find(len_indicator_pre) == internal_variable_set.end()) {
+ TRACE("t_str_detail", tout << "length indicator " << mk_pp(len_indicator_pre, m) << " not in scope" << std::endl;);
+ continue;
+ }
+
+ bool indicatorHasEqcValue = false;
+ expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
+ TRACE("t_str_detail", tout << "length indicator " << mk_ismt2_pp(len_indicator_pre, m) <<
+ " = " << mk_ismt2_pp(len_indicator_value, m) << std::endl;);
+ if (indicatorHasEqcValue) {
+ const char * val = 0;
+ m_strutil.is_string(len_indicator_value, & val);
+ std::string len_pIndiStr(val);
+ if (len_pIndiStr != "more") {
+ effectiveLenInd = len_indicator_pre;
+ effectiveLenIndiStr = len_pIndiStr;
+ break;
+ }
+ } else {
+ if (lenTesterInCbEq != len_indicator_pre) {
+ TRACE("t_str", tout << "WARNING: length indicator " << mk_ismt2_pp(len_indicator_pre, m)
+ << " does not have an equivalence class value."
+ << " i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
+ if (i > 0) {
+ effectiveLenInd = fvar_lenTester_map[freeVar][i - 1];
+ bool effectiveHasEqcValue;
+ expr * effective_eqc_value = get_eqc_value(effectiveLenInd, effectiveHasEqcValue);
+ bool effectiveInScope = (internal_variable_set.find(effectiveLenInd) != internal_variable_set.end());
+ TRACE("t_str_detail", tout << "checking effective length indicator " << mk_pp(effectiveLenInd, m) << ": "
+ << (effectiveInScope ? "in scope" : "NOT in scope") << ", ";
+ if (effectiveHasEqcValue) {
+ tout << "~= " << mk_pp(effective_eqc_value, m);
+ } else {
+ tout << "no eqc string constant";
+ }
+ tout << std::endl;);
+ if (effectiveLenInd == lenTesterInCbEq) {
+ effectiveLenIndiStr = lenTesterValue;
+ } else {
+ if (effectiveHasEqcValue) {
+ effectiveLenIndiStr = m_strutil.get_string_constant_value(effective_eqc_value);
+ } else {
+ // TODO this should be unreachable, but can we really do anything here?
+ NOT_IMPLEMENTED_YET();
+ }
+ }
+ }
+ break;
+ }
+ // lenTesterInCbEq == len_indicator_pre
+ else {
+ if (lenTesterValue != "more") {
+ effectiveLenInd = len_indicator_pre;
+ effectiveLenIndiStr = lenTesterValue;
+ break;
+ }
+ }
+ } // !indicatorHasEqcValue
+ } // for (i : [0..lenTesterCount-1])
+ if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "") {
+ TRACE("t_str", tout << "length is not fixed; generating length tester options for free var" << std::endl;);
+ expr_ref indicator(m);
+ unsigned int testNum = 0;
+
+ TRACE("t_str", tout << "effectiveLenIndiStr = " << effectiveLenIndiStr
+ << ", i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
+
+ if (i == lenTesterCount) {
+ fvar_len_count_map[freeVar] = fvar_len_count_map[freeVar] + 1;
+ testNum = fvar_len_count_map[freeVar];
+ indicator = mk_internal_lenTest_var(freeVar, testNum);
+ fvar_lenTester_map[freeVar].push_back(indicator);
+ lenTester_fvar_map[indicator] = freeVar;
+ } else {
+ // TODO make absolutely sure this is safe to do if 'indicator' is technically out of scope
+ indicator = fvar_lenTester_map[freeVar][i];
+ refresh_theory_var(indicator);
+ testNum = i + 1;
+ }
+ expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
+ SASSERT(lenTestAssert != NULL);
+ return lenTestAssert;
+ } else {
+ TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
+ // length is fixed
+ expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, "");
+ return valueAssert;
+ }
+ } // fVarLenCountMap.find(...)
+
+ } // !UseBinarySearch
}
void theory_str::get_concats_in_eqc(expr * n, std::set<expr*> & concats) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index e77c955f2..4ac054c52 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -75,6 +75,27 @@ namespace smt {
}
};
+ template<typename Ctx>
+ class binary_search_trail : public trail<Ctx> {
+ obj_map<expr, ptr_vector<expr> > & target;
+ expr * entry;
+ public:
+ binary_search_trail(obj_map<expr, ptr_vector<expr> > & target, expr * entry) :
+ target(target), entry(entry) {}
+ virtual ~binary_search_trail() {}
+ virtual void undo(Ctx & ctx) {
+ if (target.contains(entry)) {
+ if (!target[entry].empty()) {
+ target[entry].pop_back();
+ } else {
+ TRACE("t_str_binary_search", tout << "WARNING: attempt to remove length tester from an empty stack" << std::endl;);
+ }
+ } else {
+ TRACE("t_str_binary_search", tout << "WARNING: attempt to access length tester map via invalid key" << std::endl;);
+ }
+ }
+ };
+
class theory_str : public theory {
struct T_cut
{
@@ -277,6 +298,34 @@ namespace smt {
expr * get_eqc_next(expr * n);
app * get_ast(theory_var i);
+ // binary search heuristic data
+ struct binary_search_info {
+ rational lowerBound;
+ rational midPoint;
+ rational upperBound;
+ rational windowSize;
+
+ binary_search_info() : lowerBound(rational::zero()), midPoint(rational::zero()),
+ upperBound(rational::zero()), windowSize(rational::zero()) {}
+ binary_search_info(rational lower, rational mid, rational upper, rational windowSize) :
+ lowerBound(lower), midPoint(mid), upperBound(upper), windowSize(windowSize) {}
+
+ void calculate_midpoint() {
+ midPoint = floor(lowerBound + ((upperBound - lowerBound) / rational(2)) );
+ }
+ };
+ // maps a free string var to a stack of active length testers.
+ // can use binary_search_trail to record changes to this object
+ obj_map<expr, ptr_vector<expr> > binary_search_len_tester_stack;
+ // maps a length tester var to the *active* search window
+ obj_map<expr, binary_search_info> binary_search_len_tester_info;
+ // maps a free string var to the first length tester to be (re)used
+ obj_map<expr, expr*> binary_search_starting_len_tester;
+ // maps a length tester to the next length tester to be (re)used if the split is "low"
+ obj_map<expr, expr*> binary_search_next_var_low;
+ // maps a length tester to the next length tester to be (re)used if the split is "high"
+ obj_map<expr, expr*> binary_search_next_var_high;
+
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
@@ -482,6 +531,10 @@ namespace smt {
bool get_next_val_encode(int_vector & base, int_vector & next);
std::string gen_val_string(int len, int_vector & encoding);
+ // binary search heuristic
+ expr * binary_search_length_test(expr * freeVar, expr * previousLenTester, std::string previousLenTesterValue);
+ expr_ref binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds);
+
bool free_var_attempt(expr * nn1, expr * nn2);
void more_len_tests(expr * lenTester, std::string lenTesterValue);
void more_value_tests(expr * valTester, std::string valTesterValue);
From 0a6c23148fa1723d6582513b22acc9c632c97e97 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 22 Dec 2016 19:33:38 -0500
Subject: [PATCH 297/401] fix empty vector edge case in binary search
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 754d258bc..0edd2726d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -9229,7 +9229,7 @@ expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, bin
expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenTester, std::string previousLenTesterValue) {
ast_manager & m = get_manager();
- if (binary_search_len_tester_stack.contains(freeVar)) {
+ if (binary_search_len_tester_stack.contains(freeVar) && !binary_search_len_tester_stack[freeVar].empty()) {
TRACE("t_str_binary_search", tout << "checking existing length testers for " << mk_pp(freeVar, m) << std::endl;
for (ptr_vector<expr>::const_iterator it = binary_search_len_tester_stack[freeVar].begin();
it != binary_search_len_tester_stack[freeVar].end(); ++it) {
From f3e064cb077a417ba97f0198e18097ad3ec10caf Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 31 Dec 2016 13:28:32 -0500
Subject: [PATCH 298/401] theory_str binary search crash avoidance when a
negative length is reached
---
src/smt/theory_str.cpp | 21 +++++++++++++++++++++
1 file changed, 21 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 0edd2726d..d3d680717 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -8426,6 +8426,13 @@ std::string theory_str::gen_val_string(int len, int_vector & encoding) {
bool theory_str::get_next_val_encode(int_vector & base, int_vector & next) {
SASSERT(charSetSize > 0);
+ TRACE("t_str_value_test_bug", tout << "base vector: [ ";
+ for (unsigned i = 0; i < base.size(); ++i) {
+ tout << base[i] << " ";
+ }
+ tout << "]" << std::endl;
+ );
+
int s = 0;
int carry = 0;
next.reset();
@@ -9228,6 +9235,7 @@ expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, bin
expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenTester, std::string previousLenTesterValue) {
ast_manager & m = get_manager();
+ context & ctx = get_context();
if (binary_search_len_tester_stack.contains(freeVar) && !binary_search_len_tester_stack[freeVar].empty()) {
TRACE("t_str_binary_search", tout << "checking existing length testers for " << mk_pp(freeVar, m) << std::endl;
@@ -9337,6 +9345,19 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
return next_case_split;
} else { // lastTesterConstant is a concrete value
TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
+ // defensive check that this length did not converge on a negative value.
+ binary_search_info lastBounds;
+ if (!binary_search_len_tester_info.find(lastTester, lastBounds)) {
+ // unexpected
+ TRACE("t_str_binary_search", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
+ // TODO resolve this
+ NOT_IMPLEMENTED_YET();
+ }
+ if (lastBounds.midPoint.is_neg()) {
+ TRACE("t_str_binary_search", tout << "WARNING: length search converged on a negative value. Negating this constraint." << std::endl;);
+ expr_ref axiom(m.mk_not(ctx.mk_eq_atom(mk_strlen(freeVar), m_autil.mk_numeral(lastBounds.midPoint, true))), m);
+ return axiom;
+ }
// length is fixed
expr * valueAssert = gen_free_var_options(freeVar, lastTester, lastTesterConstant, NULL, "");
return valueAssert;
From f9d7981c1eb81aa7121c0ae5f637ca712864847a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 3 Jan 2017 15:45:04 -0500
Subject: [PATCH 299/401] add theory case split to theory_str binary search
---
src/smt/theory_str.cpp | 22 ++++++++++++++++++----
src/smt/theory_str.h | 3 ++-
2 files changed, 20 insertions(+), 5 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index d3d680717..278f692f8 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2507,6 +2507,7 @@ void theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
literal_vector ls;
for (unsigned i = 0; i < terms.size(); ++i) {
expr * e = terms.get(i);
+ // TODO make sure the terms are internalized, etc.?
literal l = ctx.get_literal(e);
ls.push_back(l);
}
@@ -9199,7 +9200,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
// Return an expression of the form
// (tester = "less" | tester = "N" | tester = "more") &
// (tester = "less" iff len(freeVar) < N) & (tester = "more" iff len(freeVar) > N) & (tester = "N" iff len(freeVar) = N))
-expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds) {
+expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds, literal_vector & case_split) {
context & ctx = get_context();
ast_manager & m = get_manager();
rational N = bounds.midPoint;
@@ -9227,6 +9228,16 @@ expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, bin
combinedCaseSplit.push_back(mk_or(testerCases));
+ // force internalization on all terms in testerCases so we can extract literals
+ for (unsigned i = 0; i < testerCases.size(); ++i) {
+ expr * testerCase = testerCases.get(i);
+ if (!ctx.b_internalized(testerCase)) {
+ ctx.internalize(testerCase, false);
+ }
+ literal l = ctx.get_literal(testerCase);
+ case_split.push_back(l);
+ }
+
expr_ref final_term(mk_and(combinedCaseSplit), m);
SASSERT(final_term);
TRACE("t_str_binary_search", tout << "final term: " << mk_pp(final_term, m) << std::endl;);
@@ -9339,9 +9350,10 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
binary_search_len_tester_info.insert(newTester, newBounds);
m_trail_stack.push(insert_obj_map<theory_str, expr, binary_search_info>(binary_search_len_tester_info, newTester));
- expr_ref next_case_split(binary_search_case_split(freeVar, newTester, newBounds));
+ literal_vector case_split_literals;
+ expr_ref next_case_split(binary_search_case_split(freeVar, newTester, newBounds, case_split_literals));
m_trail.push_back(next_case_split);
- // TODO assert a precondition about all previous length testers that got us here
+ ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
return next_case_split;
} else { // lastTesterConstant is a concrete value
TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
@@ -9384,8 +9396,10 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
binary_search_len_tester_info.insert(firstTester, new_info);
m_trail_stack.push(insert_obj_map<theory_str, expr, binary_search_info>(binary_search_len_tester_info, firstTester));
- expr_ref initial_case_split(binary_search_case_split(freeVar, firstTester, new_info));
+ literal_vector case_split_literals;
+ expr_ref initial_case_split(binary_search_case_split(freeVar, firstTester, new_info, case_split_literals));
m_trail.push_back(initial_case_split);
+ ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
return initial_case_split;
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 4ac054c52..fdd1a9c84 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -84,6 +84,7 @@ namespace smt {
target(target), entry(entry) {}
virtual ~binary_search_trail() {}
virtual void undo(Ctx & ctx) {
+ TRACE("t_str_binary_search", tout << "in binary_search_trail::undo()" << std::endl;);
if (target.contains(entry)) {
if (!target[entry].empty()) {
target[entry].pop_back();
@@ -533,7 +534,7 @@ namespace smt {
// binary search heuristic
expr * binary_search_length_test(expr * freeVar, expr * previousLenTester, std::string previousLenTesterValue);
- expr_ref binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds);
+ expr_ref binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds, literal_vector & case_split_lits);
bool free_var_attempt(expr * nn1, expr * nn2);
void more_len_tests(expr * lenTester, std::string lenTesterValue);
From c190d458596803fabc7db00d006c143e93b58e5d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 4 Jan 2017 15:56:16 -0500
Subject: [PATCH 300/401] fix binary search string length axiom
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 278f692f8..bfa439e03 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -9367,7 +9367,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
}
if (lastBounds.midPoint.is_neg()) {
TRACE("t_str_binary_search", tout << "WARNING: length search converged on a negative value. Negating this constraint." << std::endl;);
- expr_ref axiom(m.mk_not(ctx.mk_eq_atom(mk_strlen(freeVar), m_autil.mk_numeral(lastBounds.midPoint, true))), m);
+ expr_ref axiom(m_autil.mk_ge(mk_strlen(freeVar), m_autil.mk_numeral(rational::zero(), true)), m);
return axiom;
}
// length is fixed
From 6f5c1942f0529afe2a40193cfbff9a625696ef60 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 8 Jan 2017 20:15:45 -0500
Subject: [PATCH 301/401] theory_str length propagation
---
src/smt/theory_str.cpp | 169 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 7 +-
2 files changed, 174 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index bfa439e03..120bf426a 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -9,7 +9,7 @@ Abstract:
Author:
- Murphy Berzish (mtrberzi) 2015-09-03
+ Murphy Berzish and Yunhui Zheng
Revision History:
@@ -7993,6 +7993,160 @@ bool theory_str::finalcheck_int2str(app * a) {
return axiomAdd;
}
+void theory_str::collect_var_concat(expr * node, std::set<expr*> & varSet, std::set<expr*> & concatSet) {
+ if (variable_set.find(node) != variable_set.end()) {
+ if (internal_lenTest_vars.find(node) == internal_lenTest_vars.end()) {
+ varSet.insert(node);
+ }
+ }
+ else if (is_app(node)) {
+ app * aNode = to_app(node);
+ if (is_strlen(aNode)) {
+ // Length
+ return;
+ }
+ if (is_concat(aNode)) {
+ expr * arg0 = aNode->get_arg(0);
+ expr * arg1 = aNode->get_arg(1);
+ if (concatSet.find(node) == concatSet.end()) {
+ concatSet.insert(node);
+ }
+ }
+ // recursively visit all arguments
+ for (unsigned i = 0; i < aNode->get_num_args(); ++i) {
+ expr * arg = aNode->get_arg(i);
+ collect_var_concat(arg, varSet, concatSet);
+ }
+ }
+}
+
+bool theory_str::propagate_length_within_eqc(expr * var) {
+ bool res = false;
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ TRACE("t_str_length", tout << "propagate_length_within_eqc: " << mk_ismt2_pp(var, m) << std::endl ;);
+
+ enode * n_eq_enode = ctx.get_enode(var);
+ rational varLen;
+ if (! get_len_value(var, varLen)) {
+ bool hasLen = false;
+ expr * nodeWithLen= var;
+ do {
+ if (get_len_value(nodeWithLen, varLen)) {
+ hasLen = true;
+ break;
+ }
+ nodeWithLen = get_eqc_next(nodeWithLen);
+ } while (nodeWithLen != var);
+
+ if (hasLen) {
+ // var = nodeWithLen --> |var| = |nodeWithLen|
+ expr_ref_vector l_items(m);
+ expr_ref varEqNode(ctx.mk_eq_atom(var, nodeWithLen), m);
+ l_items.push_back(varEqNode);
+
+ expr_ref nodeWithLenExpr (mk_strlen(nodeWithLen), m);
+ expr_ref varLenExpr (mk_int(varLen), m);
+ expr_ref lenEqNum(ctx.mk_eq_atom(nodeWithLenExpr, varLenExpr), m);
+ l_items.push_back(lenEqNum);
+
+ expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
+ expr_ref varLen(mk_strlen(var), m);
+ expr_ref axr(ctx.mk_eq_atom(varLen, mk_int(varLen)), m);
+ assert_implication(axl, axr);
+ TRACE("t_str_length", tout << mk_ismt2_pp(axl, m) << std::endl << " ---> " << std::endl << mk_ismt2_pp(axr, m););
+ res = true;
+ }
+ }
+ return res;
+}
+
+bool theory_str::propagate_length(std::set<expr*> & varSet, std::set<expr*> & concatSet, std::map<expr*, int> & exprLenMap) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+ bool axiomAdded = false;
+ // collect all concats in context
+ for (expr_ref_vector::iterator it = assignments.begin(); it != assignments.end(); ++it) {
+ if (! ctx.is_relevant(*it)) {
+ continue;
+ }
+ if (m.is_eq(*it)) {
+ collect_var_concat(*it, varSet, concatSet);
+ }
+ }
+ // iterate each concat
+ // if a concat doesn't have length info, check if the length of all leaf nodes can be resolved
+ for (std::set<expr*>::iterator it = concatSet.begin(); it != concatSet.end(); it++) {
+ expr * concat = *it;
+ rational lenValue;
+ expr_ref concatlenExpr (mk_strlen(concat), m) ;
+ bool allLeafResolved = true;
+ if (! get_value(concatlenExpr, lenValue)) {
+ // the length fo concat is unresolved yet
+ if (get_len_value(concat, lenValue)) {
+ // but all leaf nodes have length information
+ TRACE("t_str_length", tout << "* length pop-up: " << mk_ismt2_pp(concat, m) << "| = " << lenValue << std::endl;);
+ std::set<expr*> leafNodes;
+ get_unique_non_concat_nodes(concat, leafNodes);
+ expr_ref_vector l_items(m);
+ for (std::set<expr*>::iterator leafIt = leafNodes.begin(); leafIt != leafNodes.end(); ++leafIt) {
+ rational leafLenValue;
+ if (get_len_value(*leafIt, leafLenValue)) {
+ expr_ref leafItLenExpr (mk_strlen(*leafIt), m);
+ expr_ref leafLenValueExpr (mk_int(leafLenValue), m);
+ expr_ref lcExpr (ctx.mk_eq_atom(leafItLenExpr, leafLenValueExpr), m);
+ l_items.push_back(lcExpr);
+ } else {
+ allLeafResolved = false;
+ break;
+ }
+ }
+ if (allLeafResolved) {
+ expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
+ expr_ref lenValueExpr (mk_int(lenValue), m);
+ expr_ref axr(ctx.mk_eq_atom(concatlenExpr, lenValueExpr), m);
+ assert_implication(axl, axr);
+ TRACE("t_str_length", tout << mk_ismt2_pp(axl, m) << std::endl << " ---> " << std::endl << mk_ismt2_pp(axr, m)<< std::endl;);
+ axiomAdded = true;
+ }
+ }
+ }
+ }
+ // if no concat length is propagated, check the length of variables.
+ if (! axiomAdded) {
+ for (std::set<expr*>::iterator it = varSet.begin(); it != varSet.end(); it++) {
+ expr * var = *it;
+ rational lenValue;
+ expr_ref varlen (mk_strlen(var), m) ;
+ bool allLeafResolved = true;
+ if (! get_value(varlen, lenValue)) {
+ if (propagate_length_within_eqc(var)) {
+ axiomAdded = true;
+ }
+ }
+ }
+
+ }
+ return axiomAdded;
+}
+
+void theory_str::get_unique_non_concat_nodes(expr * node, std::set<expr*> & argSet) {
+ app * a_node = to_app(node);
+ if (!is_concat(a_node)) {
+ argSet.insert(node);
+ return;
+ } else {
+ SASSERT(a_node->get_num_args() == 2);
+ expr * leftArg = a_node->get_arg(0);
+ expr * rightArg = a_node->get_arg(1);
+ get_unique_non_concat_nodes(leftArg, argSet);
+ get_unique_non_concat_nodes(rightArg, argSet);
+ }
+}
+
final_check_status theory_str::final_check_eh() {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -8110,6 +8264,19 @@ final_check_status theory_str::final_check_eh() {
return FC_CONTINUE;
}
+ // enhancement: improved backpropagation of length information
+ {
+ std::set<expr*> varSet;
+ std::set<expr*> concatSet;
+ std::map<expr*, int> exprLenMap;
+
+ bool length_propagation_occurred = propagate_length(varSet, concatSet, exprLenMap);
+ if (length_propagation_occurred) {
+ TRACE("t_str", tout << "Resuming search due to axioms added by length propagation." << std::endl;);
+ return FC_CONTINUE;
+ }
+ }
+
bool needToAssignFreeVars = false;
std::set<expr*> free_variables;
std::set<expr*> unused_internal_variables;
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index fdd1a9c84..b7229a72e 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -9,7 +9,7 @@ Abstract:
Author:
- Murphy Berzish (mtrberzi) 2015-09-03
+ Murphy Berzish and Yunhui Zheng
Revision History:
@@ -568,6 +568,11 @@ namespace smt {
void check_variable_scope();
void recursive_check_variable_scope(expr * ex);
+ void collect_var_concat(expr * node, std::set<expr*> & varSet, std::set<expr*> & concatSet);
+ bool propagate_length(std::set<expr*> & varSet, std::set<expr*> & concatSet, std::map<expr*, int> & exprLenMap);
+ void get_unique_non_concat_nodes(expr * node, std::set<expr*> & argSet);
+ bool propagate_length_within_eqc(expr * var);
+
// TESTING
void refresh_theory_var(expr * e);
From 5f854c6689b4aa6250a79f28822fdde6c6ea5d48 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 9 Jan 2017 15:11:56 -0500
Subject: [PATCH 302/401] experimental linear search theory case split in
theory_str
---
src/smt/theory_str.cpp | 12 ++++++++++++
1 file changed, 12 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 120bf426a..9a71c05a9 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -9277,6 +9277,9 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
}
);
+ // experimental theory-aware case split support
+ literal_vector case_split_literals;
+
for (int i = l; i < h; ++i) {
expr_ref str_indicator(m);
if (m_params.m_UseFastLengthTesterCache) {
@@ -9305,6 +9308,8 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
ctx.force_phase(l);
}
+ case_split_literals.insert(mk_eq(freeVarLen, mk_int(i), false));
+
expr_ref and_expr(ctx.mk_eq_atom(orList.get(orList.size() - 1), m.mk_eq(freeVarLen, mk_int(i))), m);
andList.push_back(and_expr);
}
@@ -9319,6 +9324,13 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
andList.push_back(ctx.mk_eq_atom(orList.get(orList.size() - 1), m_autil.mk_ge(freeVarLen, mk_int(h))));
+ { // more experimental theory case split support
+ expr_ref tmp(m_autil.mk_ge(freeVarLen, mk_int(h)), m);
+ ctx.internalize(m_autil.mk_ge(freeVarLen, mk_int(h)), false);
+ case_split_literals.push_back(ctx.get_literal(tmp));
+ ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
+ }
+
expr_ref_vector or_items(m);
expr_ref_vector and_items(m);
From 9004e1b23e9e662d6fde73e1db5cfeedc9399b1b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 10 Jan 2017 12:34:44 -0500
Subject: [PATCH 303/401] disable length test/theory case split integration
theory_str
---
src/smt/theory_str.cpp | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 9a71c05a9..5a27dcebb 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -9324,12 +9324,14 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
andList.push_back(ctx.mk_eq_atom(orList.get(orList.size() - 1), m_autil.mk_ge(freeVarLen, mk_int(h))));
+ /*
{ // more experimental theory case split support
expr_ref tmp(m_autil.mk_ge(freeVarLen, mk_int(h)), m);
ctx.internalize(m_autil.mk_ge(freeVarLen, mk_int(h)), false);
case_split_literals.push_back(ctx.get_literal(tmp));
ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
}
+ */
expr_ref_vector or_items(m);
expr_ref_vector and_items(m);
@@ -9532,7 +9534,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
literal_vector case_split_literals;
expr_ref next_case_split(binary_search_case_split(freeVar, newTester, newBounds, case_split_literals));
m_trail.push_back(next_case_split);
- ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
+ // ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
return next_case_split;
} else { // lastTesterConstant is a concrete value
TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
@@ -9578,7 +9580,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
literal_vector case_split_literals;
expr_ref initial_case_split(binary_search_case_split(freeVar, firstTester, new_info, case_split_literals));
m_trail.push_back(initial_case_split);
- ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
+ // ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
return initial_case_split;
}
}
From 3459c1993ebd8b21745e4b796cc4cbc2b45c4005 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 10 Jan 2017 15:38:33 -0500
Subject: [PATCH 304/401] experimental theory-aware branching code
---
src/smt/params/smt_params.cpp | 1 +
src/smt/params/smt_params.h | 2 +
src/smt/params/smt_params_helper.pyg | 3 +-
src/smt/smt_case_split_queue.cpp | 164 ++++++++++++++++++++++++++-
src/smt/smt_case_split_queue.h | 3 +
5 files changed, 166 insertions(+), 7 deletions(-)
diff --git a/src/smt/params/smt_params.cpp b/src/smt/params/smt_params.cpp
index a5b3e4867..f295e260b 100644
--- a/src/smt/params/smt_params.cpp
+++ b/src/smt/params/smt_params.cpp
@@ -32,6 +32,7 @@ void smt_params::updt_local_params(params_ref const & _p) {
m_restart_factor = p.restart_factor();
m_case_split_strategy = static_cast<case_split_strategy>(p.case_split());
m_theory_case_split = p.theory_case_split();
+ m_theory_aware_branching = p.theory_aware_branching();
m_delay_units = p.delay_units();
m_delay_units_threshold = p.delay_units_threshold();
m_preprocess = _p.get_bool("preprocess", true); // hidden parameter
diff --git a/src/smt/params/smt_params.h b/src/smt/params/smt_params.h
index 55346d34f..a0c90a525 100644
--- a/src/smt/params/smt_params.h
+++ b/src/smt/params/smt_params.h
@@ -112,6 +112,7 @@ struct smt_params : public preprocessor_params,
unsigned m_rel_case_split_order;
bool m_lookahead_diseq;
bool m_theory_case_split;
+ bool m_theory_aware_branching;
// -----------------------------------
//
@@ -243,6 +244,7 @@ struct smt_params : public preprocessor_params,
m_rel_case_split_order(0),
m_lookahead_diseq(false),
m_theory_case_split(false),
+ m_theory_aware_branching(false),
m_delay_units(false),
m_delay_units_threshold(32),
m_theory_resolve(false),
diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg
index 4e3bec57d..8e8e52987 100644
--- a/src/smt/params/smt_params_helper.pyg
+++ b/src/smt/params/smt_params_helper.pyg
@@ -71,5 +71,6 @@ def_module_params(module_name='smt',
('str.string_constant_cache', BOOL, True, 'cache all generated string constants generated from anywhere in theory_str'),
('str.use_binary_search', BOOL, False, 'use a binary search heuristic for finding concrete length values for free variables in theory_str (set to False to use linear search)'),
('str.binary_search_start', UINT, 64, 'initial upper bound for theory_str binary search'),
- ('theory_case_split', BOOL, False, 'Allow the context to use heuristics involving theory case splits, which are a set of literals of which exactly one can be assigned True. If this option is false, the context will generate extra axioms to enforce this instead.')
+ ('theory_case_split', BOOL, False, 'Allow the context to use heuristics involving theory case splits, which are a set of literals of which exactly one can be assigned True. If this option is false, the context will generate extra axioms to enforce this instead.'),
+ ('theory_aware_branching', BOOL, False, 'Allow the context to use extra information from theory solvers regarding literal branching prioritization.')
))
diff --git a/src/smt/smt_case_split_queue.cpp b/src/smt/smt_case_split_queue.cpp
index 06004e3b8..8b02dd6a9 100644
--- a/src/smt/smt_case_split_queue.cpp
+++ b/src/smt/smt_case_split_queue.cpp
@@ -22,9 +22,13 @@ Revision History:
#include"stopwatch.h"
#include"for_each_expr.h"
#include"ast_pp.h"
+#include"map.h"
+#include"hashtable.h"
namespace smt {
+ typedef map<bool_var, double, int_hash, default_eq<bool_var> > theory_var_priority_map;
+
struct bool_var_act_lt {
svector<double> const & m_activity;
bool_var_act_lt(svector<double> const & a):m_activity(a) {}
@@ -35,6 +39,25 @@ namespace smt {
typedef heap<bool_var_act_lt> bool_var_act_queue;
+ struct theory_aware_act_lt {
+ // only take into account theory var priority for now
+ theory_var_priority_map const & m_theory_var_priority;
+ theory_aware_act_lt(theory_var_priority_map const & a):m_theory_var_priority(a) {}
+ bool operator()(bool_var v1, bool_var v2) const {
+ double p_v1, p_v2;
+ // safety -- use a large negative number if some var isn't in the map
+ if (!m_theory_var_priority.find(v1, p_v1)) {
+ p_v1 = -1000.0;
+ }
+ if (!m_theory_var_priority.find(v2, p_v2)) {
+ p_v2 = -1000.0;
+ }
+ return p_v1 > p_v2;
+ }
+ };
+
+ typedef heap<theory_aware_act_lt> theory_aware_act_queue;
+
/**
\brief Case split queue based on activity and random splits.
*/
@@ -1087,6 +1110,118 @@ namespace smt {
}
};
+ class theory_aware_branching_queue : public case_split_queue {
+ protected:
+ context & m_context;
+ smt_params & m_params;
+
+ theory_var_priority_map m_theory_var_priority;
+ theory_aware_act_queue m_theory_queue;
+ case_split_queue * m_base_queue;
+ int_hashtable<int_hash, default_eq<bool_var> > m_theory_vars;
+ map<bool_var, lbool, int_hash, default_eq<bool_var> > m_theory_var_phase;
+ public:
+ theory_aware_branching_queue(context & ctx, smt_params & p, case_split_queue * base_queue) :
+ m_context(ctx),
+ m_params(p),
+ m_theory_var_priority(),
+ m_theory_queue(1024, theory_aware_act_lt(m_theory_var_priority)),
+ m_base_queue(base_queue) {
+ }
+
+ virtual void activity_increased_eh(bool_var v) {
+ if (m_theory_queue.contains(v)) {
+ m_theory_queue.decreased(v);
+ }
+ m_base_queue->activity_increased_eh(v);
+ }
+
+ virtual void mk_var_eh(bool_var v) {
+ // do nothing. we only "react" if/when we learn this is an important theory literal
+ m_base_queue->mk_var_eh(v);
+ }
+
+ virtual void del_var_eh(bool_var v) {
+ if (m_theory_queue.contains(v)) {
+ m_theory_queue.erase(v);
+ }
+ m_base_queue->del_var_eh(v);
+ }
+
+ virtual void assign_lit_eh(literal l) {
+ m_base_queue->assign_lit_eh(l);
+ }
+
+ virtual void unassign_var_eh(bool_var v) {
+ if (m_theory_vars.contains(v) && !m_theory_queue.contains(v)) {
+ m_theory_queue.insert(v);
+ }
+ m_base_queue->unassign_var_eh(v);
+ }
+
+ virtual void relevant_eh(expr * n) {
+ m_base_queue->relevant_eh(n);
+ }
+
+ virtual void init_search_eh() {
+ m_base_queue->init_search_eh();
+ }
+
+ virtual void end_search_eh() {
+ m_base_queue->end_search_eh();
+ }
+
+ virtual void internalize_instance_eh(expr * e, unsigned gen) {
+ m_base_queue->internalize_instance_eh(e, gen);
+ }
+
+ virtual void reset() {
+ m_theory_queue.reset();
+ m_theory_vars.reset();
+ m_theory_var_phase.reset();
+ m_theory_var_priority.reset();
+ m_base_queue->reset();
+ }
+
+ virtual void push_scope() {
+ m_base_queue->push_scope();
+ }
+
+ virtual void pop_scope(unsigned num_scopes) {
+ m_base_queue->pop_scope(num_scopes);
+ }
+
+ virtual void next_case_split(bool_var & next, lbool & phase) {
+ while (!m_theory_queue.empty()) {
+ next = m_theory_queue.erase_min();
+ // if this literal is unassigned, it is the theory literal with the highest priority,
+ // so case split on this
+ if (m_context.get_assignment(next) == l_undef) {
+ TRACE("theory_aware_branching", tout << "Theory-aware branch on l#" << next << std::endl;);
+ if (!m_theory_var_phase.find(next, phase)) {
+ phase = l_undef;
+ }
+ return;
+ }
+ }
+ // if we reach this point, the theory literal queue is empty,
+ // so fall back to the base queue
+ m_base_queue->next_case_split(next, phase);
+ }
+
+ virtual void add_theory_aware_branching_info(bool_var v, double priority, lbool phase) {
+ TRACE("theory_aware_branching", tout << "Add theory-aware branching information for l#" << v << ": priority=" << priority << std::endl;);
+ m_theory_vars.insert(v);
+ m_theory_var_phase.insert(v, phase);
+ m_theory_var_priority.insert(v, priority);
+ m_theory_queue.insert(v);
+ }
+
+ virtual void display(std::ostream & out) {
+ // TODO
+ m_base_queue->display(out);
+ }
+ };
case_split_queue * mk_case_split_queue(context & ctx, smt_params & p) {
if (p.m_relevancy_lvl < 2 && (p.m_case_split_strategy == CS_RELEVANCY || p.m_case_split_strategy == CS_RELEVANCY_ACTIVITY ||
@@ -1099,19 +1234,36 @@ namespace smt {
warning_msg("auto configuration (option AUTO_CONFIG) must be disabled to use option CASE_SPLIT=3, 4 or 5");
p.m_case_split_strategy = CS_ACTIVITY;
}
+
+ case_split_queue * baseQueue;
+
switch (p.m_case_split_strategy) {
case CS_ACTIVITY_DELAY_NEW:
- return alloc(dact_case_split_queue, ctx, p);
+ baseQueue = alloc(dact_case_split_queue, ctx, p);
+ break;
case CS_ACTIVITY_WITH_CACHE:
- return alloc(cact_case_split_queue, ctx, p);
+ baseQueue = alloc(cact_case_split_queue, ctx, p);
+ break;
case CS_RELEVANCY:
- return alloc(rel_case_split_queue, ctx, p);
+ baseQueue = alloc(rel_case_split_queue, ctx, p);
+ break;
case CS_RELEVANCY_ACTIVITY:
- return alloc(rel_act_case_split_queue, ctx, p);
+ baseQueue = alloc(rel_act_case_split_queue, ctx, p);
+ break;
case CS_RELEVANCY_GOAL:
- return alloc(rel_goal_case_split_queue, ctx, p);
+ baseQueue = alloc(rel_goal_case_split_queue, ctx, p);
+ break;
default:
- return alloc(act_case_split_queue, ctx, p);
+ baseQueue = alloc(act_case_split_queue, ctx, p);
+ break;
+ }
+
+ if (p.m_theory_aware_branching) {
+ TRACE("theory_aware_branching", tout << "Allocating and returning theory-aware branching queue." << std::endl;);
+ case_split_queue * theory_aware_queue = alloc(theory_aware_branching_queue, ctx, p, baseQueue);
+ return theory_aware_queue;
+ } else {
+ return baseQueue;
}
}
diff --git a/src/smt/smt_case_split_queue.h b/src/smt/smt_case_split_queue.h
index e6b217a22..9a3a93cc6 100644
--- a/src/smt/smt_case_split_queue.h
+++ b/src/smt/smt_case_split_queue.h
@@ -46,6 +46,9 @@ namespace smt {
virtual void next_case_split(bool_var & next, lbool & phase) = 0;
virtual void display(std::ostream & out) = 0;
virtual ~case_split_queue() {}
+
+ // theory-aware branching hint
+ virtual void add_theory_aware_branching_info(bool_var v, double priority, lbool phase) {}
};
case_split_queue * mk_case_split_queue(context & ctx, smt_params & p);
From 1363f50e4ffce014dc80a5e757529232c93f6154 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 10 Jan 2017 19:50:46 -0500
Subject: [PATCH 305/401] demonstration of theory-aware branching in
theory_str, WIP
---
src/smt/smt_context.cpp | 4 ++++
src/smt/smt_context.h | 7 +++++++
src/smt/theory_str.cpp | 40 +++++++++++++++++-----------------------
src/smt/theory_str.h | 1 +
4 files changed, 29 insertions(+), 23 deletions(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 6c0a89d4f..2de610772 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -2999,6 +2999,10 @@ namespace smt {
}
}
+ void context::add_theory_aware_branching_info(bool_var v, double priority, lbool phase) {
+ m_case_split_queue->add_theory_aware_branching_info(v, priority, phase);
+ }
+
void context::undo_th_case_split(literal l) {
m_all_th_case_split_literals.remove(l.index());
if (m_literal2casesplitsets.contains(l.index())) {
diff --git a/src/smt/smt_context.h b/src/smt/smt_context.h
index 8016eb587..2aae6c8a5 100644
--- a/src/smt/smt_context.h
+++ b/src/smt/smt_context.h
@@ -825,6 +825,13 @@ namespace smt {
*/
void mk_th_case_split(unsigned num_lits, literal * lits);
+ /*
+ * Provide a hint to the branching heuristic about the priority of a "theory-aware literal".
+ * Literals marked in this way will always be branched on before unmarked literals,
+ * starting with the literal having the highest priority.
+ */
+ void add_theory_aware_branching_info(bool_var v, double priority, lbool phase);
+
// helper function for trail
void undo_th_case_split(literal l);
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 5a27dcebb..f49b539dd 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2501,6 +2501,13 @@ void theory_str::infer_len_concat_equality(expr * nn1, expr * nn2) {
*/
}
+void theory_str::add_theory_aware_branching_info(expr * term, double priority, lbool phase) {
+ context & ctx = get_context();
+ ctx.internalize(term, false);
+ bool_var v = ctx.get_bool_var(term);
+ ctx.add_theory_aware_branching_info(v, priority, phase);
+}
+
void theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
context & ctx = get_context();
// pull each literal out of the arrangement disjunction
@@ -2512,25 +2519,6 @@ void theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
ls.push_back(l);
}
ctx.mk_th_case_split(ls.size(), ls.c_ptr());
-
- // old version, without special support in the context
- /*
- ast_manager & m = get_manager();
-
- expr_ref_vector result(m);
-
- for (unsigned int majorIndex = 0; majorIndex < terms.size(); ++majorIndex) {
- for (unsigned int minorIndex = majorIndex + 1; minorIndex < terms.size(); ++minorIndex) {
- // generate an expression of the form
- // terms[majorIndex] --> NOT(terms[minorIndex])
- expr_ref ex(rewrite_implication(terms.get(majorIndex), m.mk_not(terms.get(minorIndex))), m);
- result.push_back(ex);
- }
- }
-
- expr_ref final_result(mk_and(result), m);
- assert_axiom(final_result);
- */
}
void theory_str::print_cut_var(expr * node, std::ofstream & xout) {
@@ -3095,7 +3083,9 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
m_autil.mk_add(mk_strlen(y),m_autil.mk_mul(mk_int(-1), mk_strlen(n))),
mk_int(0))) );
- arrangement_disjunction.push_back(mk_and(and_item));
+ expr_ref option1(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option1);
+ add_theory_aware_branching_info(option1, 0.0, l_true);
add_cut_info_merge(t1, ctx.get_scope_level(), m);
add_cut_info_merge(t1, ctx.get_scope_level(), y);
@@ -3130,8 +3120,9 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
m_autil.mk_add(mk_strlen(n), m_autil.mk_mul(mk_int(-1), mk_strlen(y))),
mk_int(0))) );
-
- arrangement_disjunction.push_back(mk_and(and_item));
+ expr_ref option2(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option2);
+ add_theory_aware_branching_info(option2, 0.0, l_true);
add_cut_info_merge(t2, ctx.get_scope_level(), x);
add_cut_info_merge(t2, ctx.get_scope_level(), n);
@@ -3149,7 +3140,10 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
and_item.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)));
and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n)));
- arrangement_disjunction.push_back(mk_and(and_item));
+ expr_ref option3(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option3);
+ // prioritize this case, it is easier
+ add_theory_aware_branching_info(option3, 2.0, l_true);
}
if (!arrangement_disjunction.empty()) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index b7229a72e..1f615cfc5 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -500,6 +500,7 @@ namespace smt {
void print_cut_var(expr * node, std::ofstream & xout);
void generate_mutual_exclusion(expr_ref_vector & exprs);
+ void add_theory_aware_branching_info(expr * term, double priority, lbool phase);
bool new_eq_check(expr * lhs, expr * rhs);
void group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts);
From bc5af5873463f9648a093e8e9c21c8a2d0ce487c Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 10 Jan 2017 20:08:35 -0500
Subject: [PATCH 306/401] additional theory-aware branches in theory_str
---
src/smt/theory_str.cpp | 59 +++++++++++++++++++++++++++++++++++++-----
1 file changed, 52 insertions(+), 7 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index f49b539dd..0bc9e8dc8 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3453,7 +3453,9 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
and_item.push_back(ctx.mk_eq_atom(mk_strlen(m),
m_autil.mk_add(mk_strlen(x), mk_strlen(temp1))));
- arrangement_disjunction.push_back(mk_and(and_item));
+ expr_ref option1(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option1);
+ add_theory_aware_branching_info(option1, 0.0, l_true);
add_cut_info_merge(temp1, ctx.get_scope_level(), y);
add_cut_info_merge(temp1, ctx.get_scope_level(), m);
} else {
@@ -3475,7 +3477,16 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
and_item.push_back(ctx.mk_eq_atom(x, x_concat));
and_item.push_back(ctx.mk_eq_atom(y, cropStr));
and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(part2Str.length())));
- arrangement_disjunction.push_back(mk_and(and_item));
+ expr_ref option2(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option2);
+ double priority;
+ // prioritize the option where y is equal to the original string
+ if (i == 0) {
+ priority = 2.0;
+ } else {
+ priority = 0.0;
+ }
+ add_theory_aware_branching_info(option2, priority, l_true);
}
}
@@ -3772,7 +3783,15 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
// and_item[pos++] = Z3_mk_eq(ctx, or_item[option], Z3_mk_eq(ctx, mk_length(t, y), mk_length(t, y_concat)));
// adding length constraint for _ = constStr seems slowing things down.
- arrangement_disjunction.push_back(mk_and(and_item));
+ expr_ref option1(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option1);
+ double priority;
+ if (i == (int)strValue.size()) {
+ priority = 1.0;
+ } else {
+ priority = 0.0;
+ }
+ add_theory_aware_branching_info(option1, priority, l_true);
}
}
@@ -3794,7 +3813,9 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
and_item.push_back(ctx.mk_eq_atom(mk_strlen(x),
m_autil.mk_add(mk_strlen(strAst), mk_strlen(temp1)) ) ); ++pos;
- arrangement_disjunction.push_back(mk_and(and_item));
+ expr_ref option2(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option2);
+ add_theory_aware_branching_info(option2, 0.0, l_true);
add_cut_info_merge(temp1, sLevel, x);
add_cut_info_merge(temp1, sLevel, n);
@@ -4194,7 +4215,9 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
// addItems[1] = mk_length(t, str2Ast);
// and_item[pos++] = Z3_mk_eq(ctx, or_item[option], Z3_mk_eq(ctx, mk_length(t, y), Z3_mk_add(ctx, 2, addItems)));
- arrangement_disjunction.push_back(mk_and(and_item));
+ expr_ref option1(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option1);
+ add_theory_aware_branching_info(option1, 0.0, l_true);
} else {
loopDetected = true;
TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
@@ -4227,7 +4250,16 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_strlen(suffixAst)));
pos += 1;
- arrangement_disjunction.push_back(mk_and(and_item));
+ expr_ref option2(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option2);
+ double priority;
+ // prefer the option "str1" = x
+ if (prefix == str1Value) {
+ priority = 1.0;
+ } else {
+ priority = 0.0;
+ }
+ add_theory_aware_branching_info(option2, priority, l_true);
}
// case 6: concat("str1", y) = concat(m, "str2")
@@ -9296,6 +9328,16 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
orList.push_back(or_expr);
+ double priority;
+ // give high priority to small lengths if this is available
+ if (i <= 5) {
+ priority = 3.0;
+ } else {
+ // prioritize over "more"
+ priority = 0.5;
+ }
+ add_theory_aware_branching_info(or_expr, priority, l_true);
+
if (m_params.m_AggressiveLengthTesting) {
literal l = mk_eq(indicator, str_indicator, false);
ctx.mark_as_relevant(l);
@@ -9309,7 +9351,10 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
}
// TODO cache mk_string("more")
- orList.push_back(m.mk_eq(indicator, mk_string("more")));
+ expr_ref more_option(ctx.mk_eq_atom(indicator, mk_string("more")), m);
+ orList.push_back(more_option);
+ // decrease priority of this option
+ add_theory_aware_branching_info(more_option, -1.0, l_true);
if (m_params.m_AggressiveLengthTesting) {
literal l = mk_eq(indicator, mk_string("more"), false);
ctx.mark_as_relevant(l);
From 20a8ad9b2101b558191aa650353c421ad7c28ca0 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 10 Jan 2017 22:15:46 -0500
Subject: [PATCH 307/401] correctly reserve entries in theory aware branching
queue heap
---
src/smt/smt_case_split_queue.cpp | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/src/smt/smt_case_split_queue.cpp b/src/smt/smt_case_split_queue.cpp
index 8b02dd6a9..ebe9c2e4e 100644
--- a/src/smt/smt_case_split_queue.cpp
+++ b/src/smt/smt_case_split_queue.cpp
@@ -1130,9 +1130,6 @@ namespace smt {
}
virtual void activity_increased_eh(bool_var v) {
- if (m_theory_queue.contains(v)) {
- m_theory_queue.decreased(v);
- }
m_base_queue->activity_increased_eh(v);
}
@@ -1214,6 +1211,7 @@ namespace smt {
m_theory_vars.insert(v);
m_theory_var_phase.insert(v, phase);
m_theory_var_priority.insert(v, priority);
+ m_theory_queue.reserve(v+1);
m_theory_queue.insert(v);
}
From 6576dabd583c3d8789e519cec5b6aafbc5a5cac8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 12 Jan 2017 00:20:34 -0500
Subject: [PATCH 308/401] add tracing info to theory_str cut var map
---
src/smt/theory_str.cpp | 18 ++++++++++--------
1 file changed, 10 insertions(+), 8 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 0bc9e8dc8..44d13d666 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -416,14 +416,14 @@ void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node)
varInfo->vars[node] = 1;
cut_var_map.insert(baseNode, std::stack<T_cut*>());
cut_var_map[baseNode].push(varInfo);
- TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << std::endl;);
+ TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
if (cut_var_map[baseNode].empty()) {
T_cut * varInfo = alloc(T_cut);
varInfo->level = slevel;
varInfo->vars[node] = 1;
cut_var_map[baseNode].push(varInfo);
- TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << std::endl;);
+ TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
if (cut_var_map[baseNode].top()->level < slevel) {
T_cut * varInfo = alloc(T_cut);
@@ -431,10 +431,10 @@ void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node)
cut_vars_map_copy(varInfo->vars, cut_var_map[baseNode].top()->vars);
varInfo->vars[node] = 1;
cut_var_map[baseNode].push(varInfo);
- TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << std::endl;);
+ TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
} else if (cut_var_map[baseNode].top()->level == slevel) {
cut_var_map[baseNode].top()->vars[node] = 1;
- TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << std::endl;);
+ TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
get_manager().raise_exception("entered illegal state during add_cut_info_one_node()");
}
@@ -460,7 +460,7 @@ void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode)
cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
cut_var_map.insert(destNode, std::stack<T_cut*>());
cut_var_map[destNode].push(varInfo);
- TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << std::endl;);
+ TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
if (cut_var_map[destNode].empty() || cut_var_map[destNode].top()->level < slevel) {
T_cut * varInfo = alloc(T_cut);
@@ -468,10 +468,10 @@ void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode)
cut_vars_map_copy(varInfo->vars, cut_var_map[destNode].top()->vars);
cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
cut_var_map[destNode].push(varInfo);
- TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << std::endl;);
+ TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
} else if (cut_var_map[destNode].top()->level == slevel) {
cut_vars_map_copy(cut_var_map[destNode].top()->vars, cut_var_map[srcNode].top()->vars);
- TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << std::endl;);
+ TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
get_manager().raise_exception("illegal state in add_cut_info_merge(): inconsistent slevels");
}
@@ -4221,7 +4221,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
} else {
loopDetected = true;
TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
- // TODO printCutVAR(m, y)
+ TRACE("t_str", print_cut_var(m, tout); print_cut_var(y, tout););
}
for (std::list<int>::iterator itor = overlapLen.begin(); itor != overlapLen.end(); itor++) {
@@ -6985,8 +6985,10 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
obj_map<expr, std::stack<T_cut *> >::iterator varItor = cut_var_map.begin();
while (varItor != cut_var_map.end()) {
+ expr * e = varItor->m_key;
std::stack<T_cut*> & val = cut_var_map[varItor->m_key];
while ((val.size() > 0) && (val.top()->level != 0) && (val.top()->level >= sLevel)) {
+ TRACE("t_str_cut_var_map", tout << "remove cut info for " << mk_pp(e, m) << std::endl; print_cut_var(e, tout););
T_cut * aCut = val.top();
val.pop();
// dealloc(aCut); // TODO find a safer way to do this, it is causing a crash
From 677fcdcb41e93eb450774c97ba497d4368d55066 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 12 Jan 2017 18:41:30 -0500
Subject: [PATCH 309/401] concat overlap avoid in theory_str
---
src/smt/theory_str.cpp | 202 ++++++++++++++++++++++++++++++++++++++++-
src/smt/theory_str.h | 11 +++
2 files changed, 212 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 44d13d666..03b04d308 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -40,6 +40,7 @@ theory_str::theory_str(ast_manager & m, theory_str_params const & params):
opt_DisableIntegerTheoryIntegration(false),
opt_DeferEQCConsistencyCheck(false),
opt_CheckVariableScope(true),
+ opt_ConcatOverlapAvoid(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -2801,6 +2802,179 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
}
+/*
+ * Returns true if attempting to process a concat equality between lhs and rhs
+ * will result in overlapping variables (false otherwise).
+ */
+bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
+ ast_manager & m = get_manager();
+
+ expr_ref new_nn1(simplify_concat(lhs), m);
+ expr_ref new_nn2(simplify_concat(rhs), m);
+ app * a_new_nn1 = to_app(new_nn1);
+ app * a_new_nn2 = to_app(new_nn2);
+
+ bool n1IsConcat = is_concat(a_new_nn1);
+ bool n2IsConcat = is_concat(a_new_nn2);
+ if (!n1IsConcat && !n2IsConcat) {
+ // we simplified both sides to non-concat expressions...
+ return false;
+ }
+
+ expr * v1_arg0 = a_new_nn1->get_arg(0);
+ expr * v1_arg1 = a_new_nn1->get_arg(1);
+ expr * v2_arg0 = a_new_nn2->get_arg(0);
+ expr * v2_arg1 = a_new_nn2->get_arg(1);
+
+ TRACE("t_str_detail", tout << "checking whether " << mk_pp(new_nn1, m) << " and " << mk_pp(new_nn1, m) << " might overlap." << std::endl;);
+
+ check_and_init_cut_var(v1_arg0);
+ check_and_init_cut_var(v1_arg1);
+ check_and_init_cut_var(v2_arg0);
+ check_and_init_cut_var(v2_arg1);
+
+ //*************************************************************
+ // case 1: concat(x, y) = concat(m, n)
+ //*************************************************************
+ if (is_concat_eq_type1(new_nn1, new_nn2)) {
+ TRACE("t_str_detail", tout << "Type 1 check." << std::endl;);
+ expr * x = to_app(new_nn1)->get_arg(0);
+ expr * y = to_app(new_nn1)->get_arg(1);
+ expr * m = to_app(new_nn2)->get_arg(0);
+ expr * n = to_app(new_nn2)->get_arg(1);
+
+ // TODO is it too slow to perform length checks here to avoid false positives?
+
+ if (has_self_cut(m, y)) {
+ TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
+ return true;
+ } else if (has_self_cut(x, n)) {
+ TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(x, tout); print_cut_var(n, tout););
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ //*************************************************************
+ // case 2: concat(x, y) = concat(m, "str")
+ //*************************************************************
+ if (is_concat_eq_type2(new_nn1, new_nn2)) {
+ expr * x = NULL;
+ expr * y = NULL;
+ expr * strAst = NULL;
+ expr * m = NULL;
+
+ expr * v1_arg0 = to_app(new_nn1)->get_arg(0);
+ expr * v1_arg1 = to_app(new_nn1)->get_arg(1);
+ expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
+ expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
+
+ if (m_strutil.is_string(v1_arg1) && !m_strutil.is_string(v2_arg1)) {
+ m = v1_arg0;
+ strAst = v1_arg1;
+ x = v2_arg0;
+ y = v2_arg1;
+ } else {
+ m = v2_arg0;
+ strAst = v2_arg1;
+ x = v1_arg0;
+ y = v1_arg1;
+ }
+
+ if (has_self_cut(m, y)) {
+ TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ //*************************************************************
+ // case 3: concat(x, y) = concat("str", n)
+ //*************************************************************
+ if (is_concat_eq_type3(new_nn1, new_nn2)) {
+ expr * v1_arg0 = to_app(new_nn1)->get_arg(0);
+ expr * v1_arg1 = to_app(new_nn1)->get_arg(1);
+ expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
+ expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
+
+ expr * x = NULL;
+ expr * y = NULL;
+ expr * strAst = NULL;
+ expr * n = NULL;
+
+ if (m_strutil.is_string(v1_arg0) && !m_strutil.is_string(v2_arg0)) {
+ strAst = v1_arg0;
+ n = v1_arg1;
+ x = v2_arg0;
+ y = v2_arg1;
+ } else {
+ strAst = v2_arg0;
+ n = v2_arg1;
+ x = v1_arg0;
+ y = v1_arg1;
+ }
+ if (has_self_cut(x, n)) {
+ TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(x, tout); print_cut_var(n, tout););
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ //*************************************************************
+ // case 4: concat("str1", y) = concat("str2", n)
+ //*************************************************************
+ if (is_concat_eq_type4(new_nn1, new_nn2)) {
+ // This case can never result in an overlap.
+ return false;
+ }
+
+ //*************************************************************
+ // case 5: concat(x, "str1") = concat(m, "str2")
+ //*************************************************************
+ if (is_concat_eq_type5(new_nn1, new_nn2)) {
+ // This case can never result in an overlap.
+ return false;
+ }
+ //*************************************************************
+ // case 6: concat("str1", y) = concat(m, "str2")
+ //*************************************************************
+ if (is_concat_eq_type6(new_nn1, new_nn2)) {
+ expr * v1_arg0 = to_app(new_nn1)->get_arg(0);
+ expr * v1_arg1 = to_app(new_nn1)->get_arg(1);
+ expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
+ expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
+
+ expr * str1Ast = NULL;
+ expr * y = NULL;
+ expr * m = NULL;
+ expr * str2Ast = NULL;
+
+ if (m_strutil.is_string(v1_arg0)) {
+ str1Ast = v1_arg0;
+ y = v1_arg1;
+ m = v2_arg0;
+ str2Ast = v2_arg1;
+ } else {
+ str1Ast = v2_arg0;
+ y = v2_arg1;
+ m = v1_arg0;
+ str2Ast = v1_arg1;
+ }
+ if (has_self_cut(m, y)) {
+ TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ TRACE("t_str_detail", tout << "warning: unrecognized concat case" << std::endl;);
+ return false;
+}
+
/*************************************************************
* Type 1: concat(x, y) = concat(m, n)
* x, y, m and n all variables
@@ -6629,7 +6803,33 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
}
}
if (hasCommon == 0) {
- simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin()));
+ if (opt_ConcatOverlapAvoid) {
+ bool found = false;
+ // check each pair and take the first ones that won't immediately overlap
+ for (itor1 = eqc_concat_lhs.begin(); itor1 != eqc_concat_lhs.end() && !found; ++itor1) {
+ expr * concat_lhs = *itor1;
+ for (itor2 = eqc_concat_rhs.begin(); itor2 != eqc_concat_rhs.end() && !found; ++itor2) {
+ expr * concat_rhs = *itor2;
+ if (will_result_in_overlap(concat_lhs, concat_rhs)) {
+ TRACE("t_str_detail", tout << "Concats " << mk_pp(concat_lhs, m) << " and "
+ << mk_pp(concat_rhs, m) << " will result in overlap; skipping." << std::endl;);
+ } else {
+ TRACE("t_str_detail", tout << "Concats " << mk_pp(concat_lhs, m) << " and "
+ << mk_pp(concat_rhs, m) << " won't overlap. Simplifying here." << std::endl;);
+ simplify_concat_equality(concat_lhs, concat_rhs);
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found) {
+ TRACE("t_str_detail", tout << "All pairs of concats expected to overlap, falling back." << std::endl;);
+ simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin()));
+ }
+ } else {
+ // default behaviour
+ simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin()));
+ }
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 1f615cfc5..7f1e1dd9c 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -180,6 +180,14 @@ namespace smt {
*/
bool opt_CheckVariableScope;
+ /*
+ * If ConcatOverlapAvoid is set to true,
+ * the check to simplify Concat = Concat in handle_equality() will
+ * avoid simplifying wrt. pairs of Concat terms that will immediately
+ * result in an overlap. (false = Z3str2 behaviour)
+ */
+ bool opt_ConcatOverlapAvoid;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -350,6 +358,9 @@ namespace smt {
void add_cut_info_merge(expr * destNode, int slevel, expr * srcNode);
bool has_self_cut(expr * n1, expr * n2);
+ // for ConcatOverlapAvoid
+ bool will_result_in_overlap(expr * lhs, expr * rhs);
+
void track_variable_scope(expr * var);
app * mk_str_var(std::string name);
app * mk_int_var(std::string name);
From f033a77faed636ed932ed2b6a811e3255cbca189 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 13 Jan 2017 12:57:48 -0500
Subject: [PATCH 310/401] modify theory-aware branching to manipulate activity
instead of giving absolute priority
---
src/smt/smt_case_split_queue.cpp | 137 +++++++++++++++++++++++++++----
src/smt/theory_str.cpp | 30 +++----
2 files changed, 138 insertions(+), 29 deletions(-)
diff --git a/src/smt/smt_case_split_queue.cpp b/src/smt/smt_case_split_queue.cpp
index ebe9c2e4e..fa012525b 100644
--- a/src/smt/smt_case_split_queue.cpp
+++ b/src/smt/smt_case_split_queue.cpp
@@ -40,18 +40,20 @@ namespace smt {
typedef heap<bool_var_act_lt> bool_var_act_queue;
struct theory_aware_act_lt {
- // only take into account theory var priority for now
+ svector<double> const & m_activity;
theory_var_priority_map const & m_theory_var_priority;
- theory_aware_act_lt(theory_var_priority_map const & a):m_theory_var_priority(a) {}
+ theory_aware_act_lt(svector<double> const & act, theory_var_priority_map const & a):m_activity(act),m_theory_var_priority(a) {}
bool operator()(bool_var v1, bool_var v2) const {
double p_v1, p_v2;
- // safety -- use a large negative number if some var isn't in the map
if (!m_theory_var_priority.find(v1, p_v1)) {
- p_v1 = -1000.0;
- }
+ p_v1 = 0.0;
+ }
if (!m_theory_var_priority.find(v2, p_v2)) {
- p_v2 = -1000.0;
+ p_v2 = 0.0;
}
+ // add clause activity
+ p_v1 += m_activity[v1];
+ p_v2 += m_activity[v2];
return p_v1 > p_v2;
}
};
@@ -1109,7 +1111,8 @@ namespace smt {
m_params.m_qi_eager_threshold += start_gen;
}
};
-
+
+ /*
class theory_aware_branching_queue : public case_split_queue {
protected:
context & m_context;
@@ -1220,7 +1223,114 @@ namespace smt {
m_base_queue->display(out);
}
};
+ */
+ class theory_aware_branching_queue : public case_split_queue {
+ protected:
+ context & m_context;
+ smt_params & m_params;
+ theory_var_priority_map m_theory_var_priority;
+ theory_aware_act_queue m_queue;
+ public:
+ theory_aware_branching_queue(context & ctx, smt_params & p):
+ m_context(ctx),
+ m_params(p),
+ m_theory_var_priority(),
+ m_queue(1024, theory_aware_act_lt(ctx.get_activity_vector(), m_theory_var_priority)) {
+ }
+
+ virtual void activity_increased_eh(bool_var v) {
+ if (m_queue.contains(v))
+ m_queue.decreased(v);
+ }
+
+ virtual void mk_var_eh(bool_var v) {
+ m_queue.reserve(v+1);
+ m_queue.insert(v);
+ }
+
+ virtual void del_var_eh(bool_var v) {
+ if (m_queue.contains(v))
+ m_queue.erase(v);
+ }
+
+ virtual void unassign_var_eh(bool_var v) {
+ if (!m_queue.contains(v))
+ m_queue.insert(v);
+ }
+
+ virtual void relevant_eh(expr * n) {}
+
+ virtual void init_search_eh() {}
+
+ virtual void end_search_eh() {}
+
+ virtual void reset() {
+ m_queue.reset();
+ }
+
+ virtual void push_scope() {}
+
+ virtual void pop_scope(unsigned num_scopes) {}
+
+ virtual void next_case_split(bool_var & next, lbool & phase) {
+ phase = l_undef;
+
+ if (m_context.get_random_value() < static_cast<int>(m_params.m_random_var_freq * random_gen::max_value())) {
+ next = m_context.get_random_value() % m_context.get_num_b_internalized();
+ TRACE("random_split", tout << "next: " << next << " get_assignment(next): " << m_context.get_assignment(next) << "\n";);
+ if (m_context.get_assignment(next) == l_undef)
+ return;
+ }
+
+ while (!m_queue.empty()) {
+ next = m_queue.erase_min();
+ if (m_context.get_assignment(next) == l_undef)
+ return;
+ }
+
+ next = null_bool_var;
+ }
+
+ virtual void add_theory_aware_branching_info(bool_var v, double priority, lbool phase) {
+ TRACE("theory_aware_branching", tout << "Add theory-aware branching information for l#" << v << ": priority=" << priority << std::endl;);
+ // m_theory_vars.insert(v);
+ // m_theory_var_phase.insert(v, phase);
+ m_theory_var_priority.insert(v, priority);
+ if (m_queue.contains(v)) {
+ if (priority > 0.0) {
+ m_queue.decreased(v);
+ } else {
+ m_queue.increased(v);
+ }
+ }
+ // m_theory_queue.reserve(v+1);
+ // m_theory_queue.insert(v);
+ }
+
+ virtual void display(std::ostream & out) {
+ bool first = true;
+ bool_var_act_queue::const_iterator it = m_queue.begin();
+ bool_var_act_queue::const_iterator end = m_queue.end();
+ for (; it != end ; ++it) {
+ unsigned v = *it;
+ if (m_context.get_assignment(v) == l_undef) {
+ if (first) {
+ out << "remaining case-splits:\n";
+ first = false;
+ }
+ out << "#" << m_context.bool_var2expr(v)->get_id() << " ";
+ }
+ }
+ if (!first)
+ out << "\n";
+
+ }
+
+ virtual ~theory_aware_branching_queue() {};
+ };
+
+
case_split_queue * mk_case_split_queue(context & ctx, smt_params & p) {
if (p.m_relevancy_lvl < 2 && (p.m_case_split_strategy == CS_RELEVANCY || p.m_case_split_strategy == CS_RELEVANCY_ACTIVITY ||
p.m_case_split_strategy == CS_RELEVANCY_GOAL)) {
@@ -1235,6 +1345,10 @@ namespace smt {
case_split_queue * baseQueue;
+ if (p.m_theory_aware_branching) {
+ // override
+ baseQueue = alloc(theory_aware_branching_queue, ctx, p);
+ } else {
switch (p.m_case_split_strategy) {
case CS_ACTIVITY_DELAY_NEW:
baseQueue = alloc(dact_case_split_queue, ctx, p);
@@ -1255,14 +1369,9 @@ namespace smt {
baseQueue = alloc(act_case_split_queue, ctx, p);
break;
}
+ }
- if (p.m_theory_aware_branching) {
- TRACE("theory_aware_branching", tout << "Allocating and returning theory-aware branching queue." << std::endl;);
- case_split_queue * theory_aware_queue = alloc(theory_aware_branching_queue, ctx, p, baseQueue);
- return theory_aware_queue;
- } else {
- return baseQueue;
- }
+ return baseQueue;
}
};
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 44d13d666..2936baf13 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3085,7 +3085,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr_ref option1(mk_and(and_item), mgr);
arrangement_disjunction.push_back(option1);
- add_theory_aware_branching_info(option1, 0.0, l_true);
+ add_theory_aware_branching_info(option1, 0.1, l_true);
add_cut_info_merge(t1, ctx.get_scope_level(), m);
add_cut_info_merge(t1, ctx.get_scope_level(), y);
@@ -3122,7 +3122,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr_ref option2(mk_and(and_item), mgr);
arrangement_disjunction.push_back(option2);
- add_theory_aware_branching_info(option2, 0.0, l_true);
+ add_theory_aware_branching_info(option2, 0.1, l_true);
add_cut_info_merge(t2, ctx.get_scope_level(), x);
add_cut_info_merge(t2, ctx.get_scope_level(), n);
@@ -3143,7 +3143,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr_ref option3(mk_and(and_item), mgr);
arrangement_disjunction.push_back(option3);
// prioritize this case, it is easier
- add_theory_aware_branching_info(option3, 2.0, l_true);
+ add_theory_aware_branching_info(option3, 0.5, l_true);
}
if (!arrangement_disjunction.empty()) {
@@ -3455,7 +3455,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
expr_ref option1(mk_and(and_item), mgr);
arrangement_disjunction.push_back(option1);
- add_theory_aware_branching_info(option1, 0.0, l_true);
+ add_theory_aware_branching_info(option1, 0.1, l_true);
add_cut_info_merge(temp1, ctx.get_scope_level(), y);
add_cut_info_merge(temp1, ctx.get_scope_level(), m);
} else {
@@ -3482,9 +3482,9 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
double priority;
// prioritize the option where y is equal to the original string
if (i == 0) {
- priority = 2.0;
+ priority = 0.5;
} else {
- priority = 0.0;
+ priority = 0.1;
}
add_theory_aware_branching_info(option2, priority, l_true);
}
@@ -3787,9 +3787,9 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
arrangement_disjunction.push_back(option1);
double priority;
if (i == (int)strValue.size()) {
- priority = 1.0;
+ priority = 0.5;
} else {
- priority = 0.0;
+ priority = 0.1;
}
add_theory_aware_branching_info(option1, priority, l_true);
}
@@ -3815,7 +3815,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
expr_ref option2(mk_and(and_item), mgr);
arrangement_disjunction.push_back(option2);
- add_theory_aware_branching_info(option2, 0.0, l_true);
+ add_theory_aware_branching_info(option2, 0.1, l_true);
add_cut_info_merge(temp1, sLevel, x);
add_cut_info_merge(temp1, sLevel, n);
@@ -4217,7 +4217,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
expr_ref option1(mk_and(and_item), mgr);
arrangement_disjunction.push_back(option1);
- add_theory_aware_branching_info(option1, 0.0, l_true);
+ add_theory_aware_branching_info(option1, 0.1, l_true);
} else {
loopDetected = true;
TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
@@ -4255,9 +4255,9 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
double priority;
// prefer the option "str1" = x
if (prefix == str1Value) {
- priority = 1.0;
+ priority = 0.5;
} else {
- priority = 0.0;
+ priority = 0.1;
}
add_theory_aware_branching_info(option2, priority, l_true);
}
@@ -9333,10 +9333,10 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
double priority;
// give high priority to small lengths if this is available
if (i <= 5) {
- priority = 3.0;
+ priority = 0.3;
} else {
// prioritize over "more"
- priority = 0.5;
+ priority = 0.2;
}
add_theory_aware_branching_info(or_expr, priority, l_true);
@@ -9356,7 +9356,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
expr_ref more_option(ctx.mk_eq_atom(indicator, mk_string("more")), m);
orList.push_back(more_option);
// decrease priority of this option
- add_theory_aware_branching_info(more_option, -1.0, l_true);
+ add_theory_aware_branching_info(more_option, -0.1, l_true);
if (m_params.m_AggressiveLengthTesting) {
literal l = mk_eq(indicator, mk_string("more"), false);
ctx.mark_as_relevant(l);
From a9ec8666f0c2e310bfe581169538b59e9cb1748d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 14 Jan 2017 14:43:57 -0500
Subject: [PATCH 311/401] add phase selection to theory-aware branching queue
---
src/smt/smt_case_split_queue.cpp | 44 +++++++++++++++++++-------------
1 file changed, 26 insertions(+), 18 deletions(-)
diff --git a/src/smt/smt_case_split_queue.cpp b/src/smt/smt_case_split_queue.cpp
index fa012525b..c7ef655f2 100644
--- a/src/smt/smt_case_split_queue.cpp
+++ b/src/smt/smt_case_split_queue.cpp
@@ -1231,14 +1231,17 @@ namespace smt {
smt_params & m_params;
theory_var_priority_map m_theory_var_priority;
theory_aware_act_queue m_queue;
+
+ int_hashtable<int_hash, default_eq<bool_var> > m_theory_vars;
+ map<bool_var, lbool, int_hash, default_eq<bool_var> > m_theory_var_phase;
public:
theory_aware_branching_queue(context & ctx, smt_params & p):
m_context(ctx),
m_params(p),
- m_theory_var_priority(),
+ m_theory_var_priority(),
m_queue(1024, theory_aware_act_lt(ctx.get_activity_vector(), m_theory_var_priority)) {
}
-
+
virtual void activity_increased_eh(bool_var v) {
if (m_queue.contains(v))
m_queue.decreased(v);
@@ -1275,39 +1278,44 @@ namespace smt {
virtual void next_case_split(bool_var & next, lbool & phase) {
phase = l_undef;
-
+
if (m_context.get_random_value() < static_cast<int>(m_params.m_random_var_freq * random_gen::max_value())) {
next = m_context.get_random_value() % m_context.get_num_b_internalized();
TRACE("random_split", tout << "next: " << next << " get_assignment(next): " << m_context.get_assignment(next) << "\n";);
if (m_context.get_assignment(next) == l_undef)
return;
}
-
+
while (!m_queue.empty()) {
next = m_queue.erase_min();
if (m_context.get_assignment(next) == l_undef)
return;
}
-
+
next = null_bool_var;
+ if (m_theory_vars.contains(next)) {
+ if (!m_theory_var_phase.find(next, phase)) {
+ phase = l_undef;
+ }
+ }
}
virtual void add_theory_aware_branching_info(bool_var v, double priority, lbool phase) {
TRACE("theory_aware_branching", tout << "Add theory-aware branching information for l#" << v << ": priority=" << priority << std::endl;);
- // m_theory_vars.insert(v);
- // m_theory_var_phase.insert(v, phase);
+ m_theory_vars.insert(v);
+ m_theory_var_phase.insert(v, phase);
m_theory_var_priority.insert(v, priority);
- if (m_queue.contains(v)) {
- if (priority > 0.0) {
- m_queue.decreased(v);
- } else {
- m_queue.increased(v);
- }
- }
+ if (m_queue.contains(v)) {
+ if (priority > 0.0) {
+ m_queue.decreased(v);
+ } else {
+ m_queue.increased(v);
+ }
+ }
// m_theory_queue.reserve(v+1);
// m_theory_queue.insert(v);
}
-
+
virtual void display(std::ostream & out) {
bool first = true;
bool_var_act_queue::const_iterator it = m_queue.begin();
@@ -1330,15 +1338,15 @@ namespace smt {
virtual ~theory_aware_branching_queue() {};
};
-
+
case_split_queue * mk_case_split_queue(context & ctx, smt_params & p) {
if (p.m_relevancy_lvl < 2 && (p.m_case_split_strategy == CS_RELEVANCY || p.m_case_split_strategy == CS_RELEVANCY_ACTIVITY ||
- p.m_case_split_strategy == CS_RELEVANCY_GOAL)) {
+ p.m_case_split_strategy == CS_RELEVANCY_GOAL)) {
warning_msg("relevancy must be enabled to use option CASE_SPLIT=3, 4 or 5");
p.m_case_split_strategy = CS_ACTIVITY;
}
if (p.m_auto_config && (p.m_case_split_strategy == CS_RELEVANCY || p.m_case_split_strategy == CS_RELEVANCY_ACTIVITY ||
- p.m_case_split_strategy == CS_RELEVANCY_GOAL)) {
+ p.m_case_split_strategy == CS_RELEVANCY_GOAL)) {
warning_msg("auto configuration (option AUTO_CONFIG) must be disabled to use option CASE_SPLIT=3, 4 or 5");
p.m_case_split_strategy = CS_ACTIVITY;
}
From aa8bf2668f9942af6ef819e1a9f9af87a227c14e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 14 Jan 2017 15:28:58 -0500
Subject: [PATCH 312/401] scale theory-aware priority by bvar_inc
---
src/smt/smt_case_split_queue.cpp | 19 ++++++++++++-------
src/smt/smt_context.h | 1 +
2 files changed, 13 insertions(+), 7 deletions(-)
diff --git a/src/smt/smt_case_split_queue.cpp b/src/smt/smt_case_split_queue.cpp
index c7ef655f2..2bc3e32df 100644
--- a/src/smt/smt_case_split_queue.cpp
+++ b/src/smt/smt_case_split_queue.cpp
@@ -42,18 +42,23 @@ namespace smt {
struct theory_aware_act_lt {
svector<double> const & m_activity;
theory_var_priority_map const & m_theory_var_priority;
- theory_aware_act_lt(svector<double> const & act, theory_var_priority_map const & a):m_activity(act),m_theory_var_priority(a) {}
+ double const & m_bvar_inc;
+ theory_aware_act_lt(svector<double> const & act,
+ theory_var_priority_map const & a,
+ double const & bvar_inc):m_activity(act),m_theory_var_priority(a),m_bvar_inc(bvar_inc) {}
bool operator()(bool_var v1, bool_var v2) const {
double p_v1, p_v2;
if (!m_theory_var_priority.find(v1, p_v1)) {
- p_v1 = 0.0;
- }
+ p_v1 = 0.0;
+ }
+ p_v1 *= m_bvar_inc;
if (!m_theory_var_priority.find(v2, p_v2)) {
p_v2 = 0.0;
}
- // add clause activity
- p_v1 += m_activity[v1];
- p_v2 += m_activity[v2];
+ p_v2 *= m_bvar_inc;
+ // add clause activity
+ p_v1 += m_activity[v1];
+ p_v2 += m_activity[v2];
return p_v1 > p_v2;
}
};
@@ -1239,7 +1244,7 @@ namespace smt {
m_context(ctx),
m_params(p),
m_theory_var_priority(),
- m_queue(1024, theory_aware_act_lt(ctx.get_activity_vector(), m_theory_var_priority)) {
+ m_queue(1024, theory_aware_act_lt(ctx.get_activity_vector(), m_theory_var_priority, ctx.get_bvar_inc())) {
}
virtual void activity_increased_eh(bool_var v) {
diff --git a/src/smt/smt_context.h b/src/smt/smt_context.h
index 2aae6c8a5..9a8e01b93 100644
--- a/src/smt/smt_context.h
+++ b/src/smt/smt_context.h
@@ -824,6 +824,7 @@ namespace smt {
* or some other axiom that means at least one of them must be assigned 'true'.
*/
void mk_th_case_split(unsigned num_lits, literal * lits);
+ double get_bvar_inc() const { return m_bvar_inc; }
/*
* Provide a hint to the branching heuristic about the priority of a "theory-aware literal".
From 0dfaa30ae8f2b143bf90959dea1ba222e923d2ad Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 16 Jan 2017 14:46:04 -0500
Subject: [PATCH 313/401] experimental z3str2 search order
---
src/smt/theory_str.cpp | 22 ++++++++++++++++++++--
src/smt/theory_str.h | 16 +++++++++++++++-
2 files changed, 35 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index fd379fd2d..13f2732d8 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -41,6 +41,7 @@ theory_str::theory_str(ast_manager & m, theory_str_params const & params):
opt_DeferEQCConsistencyCheck(false),
opt_CheckVariableScope(true),
opt_ConcatOverlapAvoid(true),
+ opt_DeferredSearchOrder(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -899,7 +900,8 @@ bool theory_str::can_propagate() {
|| !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty() || !m_axiom_LastIndexof_todo.empty()
|| !m_axiom_Substr_todo.empty() || !m_axiom_Replace_todo.empty()
|| !m_axiom_RegexIn_todo.empty() || !m_library_aware_axiom_todo.empty()
- || !m_delayed_axiom_setup_terms.empty();
+ || !m_delayed_axiom_setup_terms.empty()
+ || (opt_DeferredSearchOrder && !m_new_eqs.empty())
;
}
@@ -1000,6 +1002,14 @@ void theory_str::propagate() {
set_up_axioms(m_delayed_axiom_setup_terms[i].get());
}
m_delayed_axiom_setup_terms.reset();
+
+ if (opt_DeferredSearchOrder) {
+ for (unsigned i = 0; i < m_new_eqs.size(); ++i) {
+ var_pair & p = m_new_eqs[i];
+ cb_new_eq(p.first, p.second);
+ }
+ m_new_eqs.reset();
+ }
}
}
@@ -7062,7 +7072,15 @@ void theory_str::init_search_eh() {
search_started = true;
}
-void theory_str::new_eq_eh(theory_var x, theory_var y) {
+void theory_str::new_eq_eh(theory_var v1, theory_var v2) {
+ if (opt_DeferredSearchOrder) {
+ m_new_eqs.push_back(var_pair(v1,v2));
+ } else {
+ cb_new_eq(v1, v2);
+ }
+}
+
+void theory_str::cb_new_eq(theory_var x, theory_var y) {
//TRACE("t_str_detail", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
TRACE("t_str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 7f1e1dd9c..598e9d8c9 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -97,6 +97,8 @@ namespace smt {
}
};
+ typedef std::pair<theory_var, theory_var> var_pair;
+
class theory_str : public theory {
struct T_cut
{
@@ -188,6 +190,16 @@ namespace smt {
*/
bool opt_ConcatOverlapAvoid;
+ /*
+ * If DeferredSearchOrder is set to true,
+ * certain behaviours from user_smt_theory will be emulated in order to
+ * reproduce more faithfully the search order used by Z3str2.
+ * In particular, new equalities will be saved and processed during propagate(),
+ * and asserted axioms will be deferred until the end of each propagate() step.
+ */
+ bool opt_DeferredSearchOrder;
+ svector<var_pair> m_new_eqs;
+
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -585,9 +597,11 @@ namespace smt {
void get_unique_non_concat_nodes(expr * node, std::set<expr*> & argSet);
bool propagate_length_within_eqc(expr * var);
- // TESTING
void refresh_theory_var(expr * e);
+ // user_smt_theory search order emulation
+ void cb_new_eq(theory_var v1, theory_var v2);
+
public:
theory_str(ast_manager & m, theory_str_params const & params);
virtual ~theory_str();
From 4b6582b8f35f5c5c650cd855d6774a1c0a4463c3 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 16 Jan 2017 15:46:17 -0500
Subject: [PATCH 314/401] Revert "experimental z3str2 search order"
This reverts commit 0dfaa30ae8f2b143bf90959dea1ba222e923d2ad.
---
src/smt/theory_str.cpp | 22 ++--------------------
src/smt/theory_str.h | 16 +---------------
2 files changed, 3 insertions(+), 35 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 13f2732d8..fd379fd2d 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -41,7 +41,6 @@ theory_str::theory_str(ast_manager & m, theory_str_params const & params):
opt_DeferEQCConsistencyCheck(false),
opt_CheckVariableScope(true),
opt_ConcatOverlapAvoid(true),
- opt_DeferredSearchOrder(true),
/* Internal setup */
search_started(false),
m_autil(m),
@@ -900,8 +899,7 @@ bool theory_str::can_propagate() {
|| !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty() || !m_axiom_LastIndexof_todo.empty()
|| !m_axiom_Substr_todo.empty() || !m_axiom_Replace_todo.empty()
|| !m_axiom_RegexIn_todo.empty() || !m_library_aware_axiom_todo.empty()
- || !m_delayed_axiom_setup_terms.empty()
- || (opt_DeferredSearchOrder && !m_new_eqs.empty())
+ || !m_delayed_axiom_setup_terms.empty();
;
}
@@ -1002,14 +1000,6 @@ void theory_str::propagate() {
set_up_axioms(m_delayed_axiom_setup_terms[i].get());
}
m_delayed_axiom_setup_terms.reset();
-
- if (opt_DeferredSearchOrder) {
- for (unsigned i = 0; i < m_new_eqs.size(); ++i) {
- var_pair & p = m_new_eqs[i];
- cb_new_eq(p.first, p.second);
- }
- m_new_eqs.reset();
- }
}
}
@@ -7072,15 +7062,7 @@ void theory_str::init_search_eh() {
search_started = true;
}
-void theory_str::new_eq_eh(theory_var v1, theory_var v2) {
- if (opt_DeferredSearchOrder) {
- m_new_eqs.push_back(var_pair(v1,v2));
- } else {
- cb_new_eq(v1, v2);
- }
-}
-
-void theory_str::cb_new_eq(theory_var x, theory_var y) {
+void theory_str::new_eq_eh(theory_var x, theory_var y) {
//TRACE("t_str_detail", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
TRACE("t_str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 598e9d8c9..7f1e1dd9c 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -97,8 +97,6 @@ namespace smt {
}
};
- typedef std::pair<theory_var, theory_var> var_pair;
-
class theory_str : public theory {
struct T_cut
{
@@ -190,16 +188,6 @@ namespace smt {
*/
bool opt_ConcatOverlapAvoid;
- /*
- * If DeferredSearchOrder is set to true,
- * certain behaviours from user_smt_theory will be emulated in order to
- * reproduce more faithfully the search order used by Z3str2.
- * In particular, new equalities will be saved and processed during propagate(),
- * and asserted axioms will be deferred until the end of each propagate() step.
- */
- bool opt_DeferredSearchOrder;
- svector<var_pair> m_new_eqs;
-
bool search_started;
arith_util m_autil;
str_util m_strutil;
@@ -597,11 +585,9 @@ namespace smt {
void get_unique_non_concat_nodes(expr * node, std::set<expr*> & argSet);
bool propagate_length_within_eqc(expr * var);
+ // TESTING
void refresh_theory_var(expr * e);
- // user_smt_theory search order emulation
- void cb_new_eq(theory_var v1, theory_var v2);
-
public:
theory_str(ast_manager & m, theory_str_params const & params);
virtual ~theory_str();
From 4e2847dea4e84f2ab4309b3de28309ca8eda41ce Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 16 Jan 2017 15:46:28 -0500
Subject: [PATCH 315/401] Revert "scale theory-aware priority by bvar_inc"
This reverts commit aa8bf2668f9942af6ef819e1a9f9af87a227c14e.
---
src/smt/smt_case_split_queue.cpp | 19 +++++++------------
src/smt/smt_context.h | 1 -
2 files changed, 7 insertions(+), 13 deletions(-)
diff --git a/src/smt/smt_case_split_queue.cpp b/src/smt/smt_case_split_queue.cpp
index 2bc3e32df..c7ef655f2 100644
--- a/src/smt/smt_case_split_queue.cpp
+++ b/src/smt/smt_case_split_queue.cpp
@@ -42,23 +42,18 @@ namespace smt {
struct theory_aware_act_lt {
svector<double> const & m_activity;
theory_var_priority_map const & m_theory_var_priority;
- double const & m_bvar_inc;
- theory_aware_act_lt(svector<double> const & act,
- theory_var_priority_map const & a,
- double const & bvar_inc):m_activity(act),m_theory_var_priority(a),m_bvar_inc(bvar_inc) {}
+ theory_aware_act_lt(svector<double> const & act, theory_var_priority_map const & a):m_activity(act),m_theory_var_priority(a) {}
bool operator()(bool_var v1, bool_var v2) const {
double p_v1, p_v2;
if (!m_theory_var_priority.find(v1, p_v1)) {
- p_v1 = 0.0;
- }
- p_v1 *= m_bvar_inc;
+ p_v1 = 0.0;
+ }
if (!m_theory_var_priority.find(v2, p_v2)) {
p_v2 = 0.0;
}
- p_v2 *= m_bvar_inc;
- // add clause activity
- p_v1 += m_activity[v1];
- p_v2 += m_activity[v2];
+ // add clause activity
+ p_v1 += m_activity[v1];
+ p_v2 += m_activity[v2];
return p_v1 > p_v2;
}
};
@@ -1244,7 +1239,7 @@ namespace smt {
m_context(ctx),
m_params(p),
m_theory_var_priority(),
- m_queue(1024, theory_aware_act_lt(ctx.get_activity_vector(), m_theory_var_priority, ctx.get_bvar_inc())) {
+ m_queue(1024, theory_aware_act_lt(ctx.get_activity_vector(), m_theory_var_priority)) {
}
virtual void activity_increased_eh(bool_var v) {
diff --git a/src/smt/smt_context.h b/src/smt/smt_context.h
index 9a8e01b93..2aae6c8a5 100644
--- a/src/smt/smt_context.h
+++ b/src/smt/smt_context.h
@@ -824,7 +824,6 @@ namespace smt {
* or some other axiom that means at least one of them must be assigned 'true'.
*/
void mk_th_case_split(unsigned num_lits, literal * lits);
- double get_bvar_inc() const { return m_bvar_inc; }
/*
* Provide a hint to the branching heuristic about the priority of a "theory-aware literal".
From e459617c39b8ef171586f50748126de49dc53f85 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 16 Jan 2017 18:04:03 -0500
Subject: [PATCH 316/401] experimental finite model finding WIP, first
successful run
---
src/smt/params/smt_params_helper.pyg | 3 +-
src/smt/params/theory_str_params.cpp | 1 +
src/smt/params/theory_str_params.h | 8 ++
src/smt/theory_str.cpp | 160 ++++++++++++++++++++++++++-
src/smt/theory_str.h | 6 +
5 files changed, 175 insertions(+), 3 deletions(-)
diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg
index 8e8e52987..e23915ab4 100644
--- a/src/smt/params/smt_params_helper.pyg
+++ b/src/smt/params/smt_params_helper.pyg
@@ -72,5 +72,6 @@ def_module_params(module_name='smt',
('str.use_binary_search', BOOL, False, 'use a binary search heuristic for finding concrete length values for free variables in theory_str (set to False to use linear search)'),
('str.binary_search_start', UINT, 64, 'initial upper bound for theory_str binary search'),
('theory_case_split', BOOL, False, 'Allow the context to use heuristics involving theory case splits, which are a set of literals of which exactly one can be assigned True. If this option is false, the context will generate extra axioms to enforce this instead.'),
- ('theory_aware_branching', BOOL, False, 'Allow the context to use extra information from theory solvers regarding literal branching prioritization.')
+ ('theory_aware_branching', BOOL, False, 'Allow the context to use extra information from theory solvers regarding literal branching prioritization.'),
+ ('str.finite_overlap_models', BOOL, False, 'attempt a finite model search for overlapping variables instead of completely giving up on the arrangement')
))
diff --git a/src/smt/params/theory_str_params.cpp b/src/smt/params/theory_str_params.cpp
index 2e98a4394..46302cf82 100644
--- a/src/smt/params/theory_str_params.cpp
+++ b/src/smt/params/theory_str_params.cpp
@@ -27,6 +27,7 @@ void theory_str_params::updt_params(params_ref const & _p) {
m_UseFastLengthTesterCache = p.str_fast_length_tester_cache();
m_UseFastValueTesterCache = p.str_fast_value_tester_cache();
m_StringConstantCache = p.str_string_constant_cache();
+ m_FiniteOverlapModels = p.str_finite_overlap_models();
m_UseBinarySearch = p.str_use_binary_search();
m_BinarySearchInitialUpperBound = p.str_binary_search_start();
}
diff --git a/src/smt/params/theory_str_params.h b/src/smt/params/theory_str_params.h
index 39c553780..4effb0897 100644
--- a/src/smt/params/theory_str_params.h
+++ b/src/smt/params/theory_str_params.h
@@ -68,6 +68,13 @@ struct theory_str_params {
*/
bool m_StringConstantCache;
+ /*
+ * If FiniteOverlapModels is set to true,
+ * arrangements that result in overlapping variables will generate a small number of models
+ * to test instead of completely giving up on the case.
+ */
+ bool m_FiniteOverlapModels;
+
bool m_UseBinarySearch;
unsigned m_BinarySearchInitialUpperBound;
@@ -79,6 +86,7 @@ struct theory_str_params {
m_UseFastLengthTesterCache(false),
m_UseFastValueTesterCache(true),
m_StringConstantCache(true),
+ m_FiniteOverlapModels(false),
m_UseBinarySearch(false),
m_BinarySearchInitialUpperBound(64)
{
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index fd379fd2d..4ff80a613 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4394,8 +4394,47 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
add_theory_aware_branching_info(option1, 0.1, l_true);
} else {
loopDetected = true;
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
- TRACE("t_str", print_cut_var(m, tout); print_cut_var(y, tout););
+
+ if (m_params.m_FiniteOverlapModels) {
+ // TODO refactor this entire segment into its own method. this is really just for experiment purposes
+ TRACE("t_str", tout << "activating finite model testing for overlapping concats "
+ << mk_pp(concatAst1, mgr) << " and " << mk_pp(concatAst2, mgr) << std::endl;);
+ std::map<expr*, int> concatMap;
+ std::map<expr*, int> unrollMap;
+ std::map<expr*, int> varMap;
+ classify_ast_by_type(concatAst1, varMap, concatMap, unrollMap);
+ classify_ast_by_type(concatAst2, varMap, concatMap, unrollMap);
+ TRACE("t_str_detail", tout << "found vars:";
+ for (std::map<expr*,int>::iterator it = varMap.begin(); it != varMap.end(); ++it) {
+ tout << " " << mk_pp(it->first, mgr);
+ }
+ tout << std::endl;
+ );
+
+ expr_ref testvar(mk_str_var("finiteModelTest"), mgr);
+ m_trail.push_back(testvar);
+ ptr_vector<expr> varlist;
+
+ for (std::map<expr*, int>::iterator it = varMap.begin(); it != varMap.end(); ++it) {
+ expr * v = it->first;
+ varlist.push_back(v);
+ }
+
+ // make things easy for the core wrt. testvar
+ expr_ref t1(ctx.mk_eq_atom(testvar, m_strutil.mk_string("")), mgr);
+ expr_ref t_yes(ctx.mk_eq_atom(testvar, m_strutil.mk_string("yes")), mgr);
+ expr_ref testvaraxiom(mgr.mk_or(t1, t_yes), mgr);
+ assert_axiom(testvaraxiom);
+
+ finite_model_test_varlists.insert(testvar, varlist);
+ m_trail_stack.push(insert_obj_map<theory_str, expr, ptr_vector<expr> >(finite_model_test_varlists, testvar) );
+
+ arrangement_disjunction.push_back(t_yes);
+ add_theory_aware_branching_info(t_yes, -0.1, l_true);
+ } else {
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
+ TRACE("t_str", print_cut_var(m, tout); print_cut_var(y, tout););
+ }
}
for (std::list<int>::iterator itor = overlapLen.begin(); itor != overlapLen.end(); itor++) {
@@ -6564,6 +6603,114 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
}
}
+void theory_str::finite_model_test(expr * testvar, expr * str) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ if (!m_strutil.is_string(str)) return;
+ std::string s = m_strutil.get_string_constant_value(str);
+ if (s == "yes") {
+ TRACE("t_str", tout << "start finite model test for " << mk_pp(testvar, m) << std::endl;);
+ ptr_vector<expr> & vars = finite_model_test_varlists[testvar];
+ for (ptr_vector<expr>::iterator it = vars.begin(); it != vars.end(); ++it) {
+ expr * v = *it;
+ // check for any sort of existing length tester we might interfere with
+ if (m_params.m_UseBinarySearch) {
+ NOT_IMPLEMENTED_YET();
+ } else {
+ bool map_effectively_empty = false;
+ if (fvar_len_count_map.find(v) == fvar_len_count_map.end()) {
+ map_effectively_empty = true;
+ }
+
+ if (!map_effectively_empty) {
+ map_effectively_empty = true;
+ ptr_vector<expr> indicator_set = fvar_lenTester_map[v];
+ for (ptr_vector<expr>::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) {
+ expr * indicator = *it;
+ if (internal_variable_set.find(indicator) != internal_variable_set.end()) {
+ map_effectively_empty = false;
+ break;
+ }
+ }
+ }
+
+ if (map_effectively_empty) {
+ TRACE("t_str_detail", tout << "no existing length testers for " << mk_pp(v, m) << std::endl;);
+ rational v_len;
+ if (get_len_value(v, v_len)) {
+ TRACE("t_str_detail", tout << "length = " << v_len.to_string() << std::endl;);
+ } else {
+ expr_ref vLengthExpr(mk_strlen(v), m);
+
+ rational v_lower_bound;
+ bool lower_bound_exists = lower_bound(vLengthExpr, v_lower_bound);
+ rational v_upper_bound;
+ bool upper_bound_exists = upper_bound(vLengthExpr, v_upper_bound);
+ TRACE("t_str_detail", tout << "bounds = [" << (lower_bound_exists?v_lower_bound.to_string():"?")
+ << ".." << (upper_bound_exists?v_upper_bound.to_string():"?") << "]" << std::endl;);
+
+ // make sure the bounds are non-negative
+ if (lower_bound_exists && v_lower_bound.is_neg()) {
+ v_lower_bound = rational::zero();
+ }
+ if (upper_bound_exists && v_upper_bound.is_neg()) {
+ v_upper_bound = rational::zero();
+ }
+
+ if (lower_bound_exists && upper_bound_exists) {
+ // easiest case. we will search within these bounds
+ } else if (upper_bound_exists && !lower_bound_exists) {
+ // search between 0 and the upper bound
+ v_lower_bound == rational::zero();
+ } else if (lower_bound_exists && !upper_bound_exists) {
+ // check some finite portion of the search space
+ // TODO here and below, factor out the increment to a param
+ v_upper_bound = v_lower_bound + rational(10);
+ } else {
+ // no bounds information
+ v_lower_bound = rational::zero();
+ v_upper_bound = v_lower_bound + rational(10);
+ }
+ // now create a fake length tester over this finite disjunction of lengths
+
+ fvar_len_count_map[v] = 1;
+ unsigned int testNum = fvar_len_count_map[v];
+
+ expr_ref indicator(mk_internal_lenTest_var(v, testNum), m);
+ SASSERT(indicator);
+ m_trail.push_back(indicator);
+
+ fvar_lenTester_map[v].shrink(0);
+ fvar_lenTester_map[v].push_back(indicator);
+ lenTester_fvar_map[indicator] = v;
+
+ expr_ref_vector orList(m);
+ expr_ref_vector andList(m);
+
+ for (rational l = v_lower_bound; l <= v_upper_bound; l += rational::one()) {
+ // TODO integrate with the enhancements in gen_len_test_options()
+ std::string lStr = l.to_string();
+ expr_ref str_indicator(m_strutil.mk_string(lStr), m);
+ expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
+ orList.push_back(or_expr);
+ expr_ref and_expr(ctx.mk_eq_atom(or_expr, ctx.mk_eq_atom(vLengthExpr, m_autil.mk_numeral(l, true))), m);
+ andList.push_back(and_expr);
+ }
+ andList.push_back(mk_or(orList));
+ expr_ref implLhs(ctx.mk_eq_atom(testvar, str), m);
+ expr_ref implRhs(mk_and(andList), m);
+ assert_implication(implLhs, implRhs);
+ }
+ } else {
+ // TODO figure out this case
+ NOT_IMPLEMENTED_YET();
+ }
+ }
+ } // foreach (v in vars)
+ } // (s == "yes")
+}
+
void theory_str::more_len_tests(expr * lenTester, std::string lenTesterValue) {
ast_manager & m = get_manager();
if (lenTester_fvar_map.find(lenTester) != lenTester_fvar_map.end()) {
@@ -6666,6 +6813,15 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
return;
}
+ if (m_params.m_FiniteOverlapModels && !finite_model_test_varlists.empty()) {
+ // TODO NEXT
+ if (finite_model_test_varlists.contains(lhs)) {
+ finite_model_test(lhs, rhs); return;
+ } else if (finite_model_test_varlists.contains(rhs)) {
+ finite_model_test(rhs, lhs); return;
+ }
+ }
+
if (free_var_attempt(lhs, rhs) || free_var_attempt(rhs, lhs)) {
return;
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 7f1e1dd9c..050593691 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -335,6 +335,10 @@ namespace smt {
// maps a length tester to the next length tester to be (re)used if the split is "high"
obj_map<expr, expr*> binary_search_next_var_high;
+ // finite model finding data
+ // maps a finite model tester var to a list of variables that will be tested
+ obj_map<expr, ptr_vector<expr> > finite_model_test_varlists;
+
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
@@ -588,6 +592,8 @@ namespace smt {
// TESTING
void refresh_theory_var(expr * e);
+ void finite_model_test(expr * v, expr * c);
+
public:
theory_str(ast_manager & m, theory_str_params const & params);
virtual ~theory_str();
From 0af834421faa801faa1010b20e085cde4fc4780e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 16 Jan 2017 18:24:47 -0500
Subject: [PATCH 317/401] finite model finding for other concat cases in
theory_str
---
src/smt/theory_str.cpp | 378 ++++++++++++++++++++++++-----------------
src/smt/theory_str.h | 1 +
2 files changed, 220 insertions(+), 159 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 4ff80a613..5313b08ce 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3126,33 +3126,33 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
// Type 0: M cuts Y.
// len(x) < len(m) || len(y) > len(n)
//--------------------------------------
+ expr_ref_vector ax_l_items(mgr);
+ expr_ref_vector ax_r_items(mgr);
+
+ ax_l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
+
+ expr_ref x_t1(mk_concat(x, t1), mgr);
+ expr_ref t1_n(mk_concat(t1, n), mgr);
+
+ ax_r_items.push_back(ctx.mk_eq_atom(m, x_t1));
+ ax_r_items.push_back(ctx.mk_eq_atom(y, t1_n));
+
+ if (m_len_exists && x_len_exists) {
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
+ rational m_sub_x = m_len - x_len;
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t1), mk_int(m_sub_x)));
+ } else {
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
+ rational y_sub_n = y_len - n_len;
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t1), mk_int(y_sub_n)));
+ }
+
+ expr_ref ax_l(mk_and(ax_l_items), mgr);
+ expr_ref ax_r(mk_and(ax_r_items), mgr);
+
if (!has_self_cut(m, y)) {
- expr_ref_vector ax_l_items(mgr);
- expr_ref_vector ax_r_items(mgr);
-
- ax_l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
-
- expr_ref x_t1(mk_concat(x, t1), mgr);
- expr_ref t1_n(mk_concat(t1, n), mgr);
-
- ax_r_items.push_back(ctx.mk_eq_atom(m, x_t1));
- ax_r_items.push_back(ctx.mk_eq_atom(y, t1_n));
-
- if (m_len_exists && x_len_exists) {
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
- rational m_sub_x = m_len - x_len;
- ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t1), mk_int(m_sub_x)));
- } else {
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
- rational y_sub_n = y_len - n_len;
- ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t1), mk_int(y_sub_n)));
- }
-
- expr_ref ax_l(mk_and(ax_l_items), mgr);
- expr_ref ax_r(mk_and(ax_r_items), mgr);
-
// Cut Info
add_cut_info_merge(t1, sLevel, m);
add_cut_info_merge(t1, sLevel, y);
@@ -3165,8 +3165,14 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
} else {
loopDetected = true;
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- // TODO printCutVar(m, y);
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ assert_implication(ax_l, tester);
+ add_theory_aware_branching_info(tester, -0.1, l_true);
+ } else {
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ // TODO printCutVar(m, y);
+ }
}
} else if (splitType == 1) {
// Type 1:
@@ -3179,32 +3185,32 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
} else if (splitType == 2) {
// Type 2: X cuts N.
// len(x) > len(m) || len(y) < len(n)
+ expr_ref m_t2(mk_concat(m, t2), mgr);
+ expr_ref t2_y(mk_concat(t2, y), mgr);
+
+ expr_ref_vector ax_l_items(mgr);
+ ax_l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
+
+ expr_ref_vector ax_r_items(mgr);
+ ax_r_items.push_back(ctx.mk_eq_atom(x, m_t2));
+ ax_r_items.push_back(ctx.mk_eq_atom(t2_y, n));
+
+ if (m_len_exists && x_len_exists) {
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
+ rational x_sub_m = x_len - m_len;
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t2), mk_int(x_sub_m)));
+ } else {
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
+ rational n_sub_y = n_len - y_len;
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t2), mk_int(n_sub_y)));
+ }
+
+ expr_ref ax_l(mk_and(ax_l_items), mgr);
+ expr_ref ax_r(mk_and(ax_r_items), mgr);
+
if (!has_self_cut(x, n)) {
- expr_ref m_t2(mk_concat(m, t2), mgr);
- expr_ref t2_y(mk_concat(t2, y), mgr);
-
- expr_ref_vector ax_l_items(mgr);
- ax_l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
-
- expr_ref_vector ax_r_items(mgr);
- ax_r_items.push_back(ctx.mk_eq_atom(x, m_t2));
- ax_r_items.push_back(ctx.mk_eq_atom(t2_y, n));
-
- if (m_len_exists && x_len_exists) {
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
- rational x_sub_m = x_len - m_len;
- ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t2), mk_int(x_sub_m)));
- } else {
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
- rational n_sub_y = n_len - y_len;
- ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t2), mk_int(n_sub_y)));
- }
-
- expr_ref ax_l(mk_and(ax_l_items), mgr);
- expr_ref ax_r(mk_and(ax_r_items), mgr);
-
// Cut Info
add_cut_info_merge(t2, sLevel, x);
add_cut_info_merge(t2, sLevel, n);
@@ -3217,8 +3223,14 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
} else {
loopDetected = true;
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- // TODO printCutVar(m, y);
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ assert_implication(ax_l, tester);
+ add_theory_aware_branching_info(tester, -0.1, l_true);
+ } else {
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ // TODO printCutVar(m, y);
+ }
}
} else if (splitType == -1) {
// Here we don't really have a choice. We have no length information at all...
@@ -3265,12 +3277,19 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(t1, ctx.get_scope_level(), y);
} else {
loopDetected = true;
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ arrangement_disjunction.push_back(tester);
+ add_theory_aware_branching_info(tester, -0.1, l_true);
+ } else {
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+ }
}
// break option 2:
- // x = m || y = n
+ // x = m . t2
+ // n = t2 . y
if (!avoidLoopCut || !has_self_cut(x, n)) {
expr_ref_vector and_item(mgr);
// break down option 1-2
@@ -3302,10 +3321,19 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(t2, ctx.get_scope_level(), n);
} else {
loopDetected = true;
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- // TODO printCutVar(x, n);
+ if (m_params.m_FiniteOverlapModels) {
+ // TODO this might repeat the case above, we may wish to avoid doing this twice
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ arrangement_disjunction.push_back(tester);
+ add_theory_aware_branching_info(tester, -0.1, l_true);
+ } else {
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ // TODO printCutVar(x, n);
+ }
}
+ // option 3:
+ // x = m, y = n
if (can_two_nodes_eq(x, m) && can_two_nodes_eq(y, n)) {
expr_ref_vector and_item(mgr);
@@ -3496,31 +3524,31 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
// | m | str |
expr_ref temp1_strAst(mk_concat(temp1, strAst), mgr);
if (can_two_nodes_eq(y, temp1_strAst)) {
+ expr_ref_vector l_items(mgr);
+ l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
+
+ expr_ref_vector r_items(mgr);
+ expr_ref x_temp1(mk_concat(x, temp1), mgr);
+ r_items.push_back(ctx.mk_eq_atom(m, x_temp1));
+ r_items.push_back(ctx.mk_eq_atom(y, temp1_strAst));
+
+ if (x_len_exists && m_len_exists) {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
+ rational m_sub_x = (m_len - x_len);
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(m_sub_x)));
+ } else {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(strAst), mk_int(str_len)));
+ rational y_sub_str = (y_len - str_len);
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(y_sub_str)));
+ }
+
+ expr_ref ax_l(mk_and(l_items), mgr);
+ expr_ref ax_r(mk_and(r_items), mgr);
+
if (!avoidLoopCut || !(has_self_cut(m, y))) {
// break down option 2-1
- expr_ref_vector l_items(mgr);
- l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
-
- expr_ref_vector r_items(mgr);
- expr_ref x_temp1(mk_concat(x, temp1), mgr);
- r_items.push_back(ctx.mk_eq_atom(m, x_temp1));
- r_items.push_back(ctx.mk_eq_atom(y, temp1_strAst));
-
- if (x_len_exists && m_len_exists) {
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
- rational m_sub_x = (m_len - x_len);
- r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(m_sub_x)));
- } else {
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(strAst), mk_int(str_len)));
- rational y_sub_str = (y_len - str_len);
- r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(y_sub_str)));
- }
-
- expr_ref ax_l(mk_and(l_items), mgr);
- expr_ref ax_r(mk_and(r_items), mgr);
-
add_cut_info_merge(temp1, sLevel, y);
add_cut_info_merge(temp1, sLevel, m);
@@ -3532,8 +3560,15 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
}
} else {
loopDetected = true;
- TRACE("t_str", tout << "AVOID LOOP: SKIP" << std::endl;);
- // TODO printCutVar(m, y);
+
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ assert_implication(ax_l, tester);
+ add_theory_aware_branching_info(tester, -0.1, l_true);
+ } else {
+ TRACE("t_str", tout << "AVOID LOOP: SKIP" << std::endl;);
+ // TODO printCutVar(m, y);
+ }
}
}
} else if (splitType == 1) {
@@ -3634,8 +3669,14 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(temp1, ctx.get_scope_level(), m);
} else {
loopDetected = true;
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- // TODO printCutVar(m, y)
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ arrangement_disjunction.push_back(tester);
+ add_theory_aware_branching_info(tester, -0.1, l_true);
+ } else {
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ // TODO printCutVar(m, y)
+ }
}
}
@@ -3921,8 +3962,14 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
}
} else {
loopDetected = true;
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- // TODO printCutVar(x, n);
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ assert_implication(ax_l, tester);
+ add_theory_aware_branching_info(tester, -0.1, l_true);
+ } else {
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ // TODO printCutVar(x, n);
+ }
}
}
// else {
@@ -3995,8 +4042,14 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(temp1, sLevel, n);
} else {
loopDetected = true;
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
- // TODO printCutVAR(x, n)
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ arrangement_disjunction.push_back(tester);
+ add_theory_aware_branching_info(tester, -0.1, l_true);
+ } else {
+ TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
+ // TODO printCutVAR(x, n)
+ }
}
}
@@ -4396,41 +4449,9 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
loopDetected = true;
if (m_params.m_FiniteOverlapModels) {
- // TODO refactor this entire segment into its own method. this is really just for experiment purposes
- TRACE("t_str", tout << "activating finite model testing for overlapping concats "
- << mk_pp(concatAst1, mgr) << " and " << mk_pp(concatAst2, mgr) << std::endl;);
- std::map<expr*, int> concatMap;
- std::map<expr*, int> unrollMap;
- std::map<expr*, int> varMap;
- classify_ast_by_type(concatAst1, varMap, concatMap, unrollMap);
- classify_ast_by_type(concatAst2, varMap, concatMap, unrollMap);
- TRACE("t_str_detail", tout << "found vars:";
- for (std::map<expr*,int>::iterator it = varMap.begin(); it != varMap.end(); ++it) {
- tout << " " << mk_pp(it->first, mgr);
- }
- tout << std::endl;
- );
-
- expr_ref testvar(mk_str_var("finiteModelTest"), mgr);
- m_trail.push_back(testvar);
- ptr_vector<expr> varlist;
-
- for (std::map<expr*, int>::iterator it = varMap.begin(); it != varMap.end(); ++it) {
- expr * v = it->first;
- varlist.push_back(v);
- }
-
- // make things easy for the core wrt. testvar
- expr_ref t1(ctx.mk_eq_atom(testvar, m_strutil.mk_string("")), mgr);
- expr_ref t_yes(ctx.mk_eq_atom(testvar, m_strutil.mk_string("yes")), mgr);
- expr_ref testvaraxiom(mgr.mk_or(t1, t_yes), mgr);
- assert_axiom(testvaraxiom);
-
- finite_model_test_varlists.insert(testvar, varlist);
- m_trail_stack.push(insert_obj_map<theory_str, expr, ptr_vector<expr> >(finite_model_test_varlists, testvar) );
-
- arrangement_disjunction.push_back(t_yes);
- add_theory_aware_branching_info(t_yes, -0.1, l_true);
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ arrangement_disjunction.push_back(tester);
+ add_theory_aware_branching_info(tester, -0.1, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
TRACE("t_str", print_cut_var(m, tout); print_cut_var(y, tout););
@@ -6603,6 +6624,44 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
}
}
+expr_ref theory_str::set_up_finite_model_test(expr * lhs, expr * rhs) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ TRACE("t_str", tout << "activating finite model testing for overlapping concats "
+ << mk_pp(lhs, m) << " and " << mk_pp(rhs, m) << std::endl;);
+ std::map<expr*, int> concatMap;
+ std::map<expr*, int> unrollMap;
+ std::map<expr*, int> varMap;
+ classify_ast_by_type(lhs, varMap, concatMap, unrollMap);
+ classify_ast_by_type(rhs, varMap, concatMap, unrollMap);
+ TRACE("t_str_detail", tout << "found vars:";
+ for (std::map<expr*,int>::iterator it = varMap.begin(); it != varMap.end(); ++it) {
+ tout << " " << mk_pp(it->first, m);
+ }
+ tout << std::endl;
+ );
+
+ expr_ref testvar(mk_str_var("finiteModelTest"), m);
+ m_trail.push_back(testvar);
+ ptr_vector<expr> varlist;
+
+ for (std::map<expr*, int>::iterator it = varMap.begin(); it != varMap.end(); ++it) {
+ expr * v = it->first;
+ varlist.push_back(v);
+ }
+
+ // make things easy for the core wrt. testvar
+ expr_ref t1(ctx.mk_eq_atom(testvar, m_strutil.mk_string("")), m);
+ expr_ref t_yes(ctx.mk_eq_atom(testvar, m_strutil.mk_string("yes")), m);
+ expr_ref testvaraxiom(m.mk_or(t1, t_yes), m);
+ assert_axiom(testvaraxiom);
+
+ finite_model_test_varlists.insert(testvar, varlist);
+ m_trail_stack.push(insert_obj_map<theory_str, expr, ptr_vector<expr> >(finite_model_test_varlists, testvar) );
+ return t_yes;
+}
+
void theory_str::finite_model_test(expr * testvar, expr * str) {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -6638,14 +6697,15 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
if (map_effectively_empty) {
TRACE("t_str_detail", tout << "no existing length testers for " << mk_pp(v, m) << std::endl;);
rational v_len;
+ rational v_lower_bound;
+ rational v_upper_bound;
+ expr_ref vLengthExpr(mk_strlen(v), m);
if (get_len_value(v, v_len)) {
TRACE("t_str_detail", tout << "length = " << v_len.to_string() << std::endl;);
+ v_lower_bound = v_len;
+ v_upper_bound = v_len;
} else {
- expr_ref vLengthExpr(mk_strlen(v), m);
-
- rational v_lower_bound;
bool lower_bound_exists = lower_bound(vLengthExpr, v_lower_bound);
- rational v_upper_bound;
bool upper_bound_exists = upper_bound(vLengthExpr, v_upper_bound);
TRACE("t_str_detail", tout << "bounds = [" << (lower_bound_exists?v_lower_bound.to_string():"?")
<< ".." << (upper_bound_exists?v_upper_bound.to_string():"?") << "]" << std::endl;);
@@ -6672,36 +6732,36 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
v_lower_bound = rational::zero();
v_upper_bound = v_lower_bound + rational(10);
}
- // now create a fake length tester over this finite disjunction of lengths
-
- fvar_len_count_map[v] = 1;
- unsigned int testNum = fvar_len_count_map[v];
-
- expr_ref indicator(mk_internal_lenTest_var(v, testNum), m);
- SASSERT(indicator);
- m_trail.push_back(indicator);
-
- fvar_lenTester_map[v].shrink(0);
- fvar_lenTester_map[v].push_back(indicator);
- lenTester_fvar_map[indicator] = v;
-
- expr_ref_vector orList(m);
- expr_ref_vector andList(m);
-
- for (rational l = v_lower_bound; l <= v_upper_bound; l += rational::one()) {
- // TODO integrate with the enhancements in gen_len_test_options()
- std::string lStr = l.to_string();
- expr_ref str_indicator(m_strutil.mk_string(lStr), m);
- expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
- orList.push_back(or_expr);
- expr_ref and_expr(ctx.mk_eq_atom(or_expr, ctx.mk_eq_atom(vLengthExpr, m_autil.mk_numeral(l, true))), m);
- andList.push_back(and_expr);
- }
- andList.push_back(mk_or(orList));
- expr_ref implLhs(ctx.mk_eq_atom(testvar, str), m);
- expr_ref implRhs(mk_and(andList), m);
- assert_implication(implLhs, implRhs);
}
+ // now create a fake length tester over this finite disjunction of lengths
+
+ fvar_len_count_map[v] = 1;
+ unsigned int testNum = fvar_len_count_map[v];
+
+ expr_ref indicator(mk_internal_lenTest_var(v, testNum), m);
+ SASSERT(indicator);
+ m_trail.push_back(indicator);
+
+ fvar_lenTester_map[v].shrink(0);
+ fvar_lenTester_map[v].push_back(indicator);
+ lenTester_fvar_map[indicator] = v;
+
+ expr_ref_vector orList(m);
+ expr_ref_vector andList(m);
+
+ for (rational l = v_lower_bound; l <= v_upper_bound; l += rational::one()) {
+ // TODO integrate with the enhancements in gen_len_test_options()
+ std::string lStr = l.to_string();
+ expr_ref str_indicator(m_strutil.mk_string(lStr), m);
+ expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
+ orList.push_back(or_expr);
+ expr_ref and_expr(ctx.mk_eq_atom(or_expr, ctx.mk_eq_atom(vLengthExpr, m_autil.mk_numeral(l, true))), m);
+ andList.push_back(and_expr);
+ }
+ andList.push_back(mk_or(orList));
+ expr_ref implLhs(ctx.mk_eq_atom(testvar, str), m);
+ expr_ref implRhs(mk_and(andList), m);
+ assert_implication(implLhs, implRhs);
} else {
// TODO figure out this case
NOT_IMPLEMENTED_YET();
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 050593691..3bb093dcd 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -592,6 +592,7 @@ namespace smt {
// TESTING
void refresh_theory_var(expr * e);
+ expr_ref set_up_finite_model_test(expr * lhs, expr * rhs);
void finite_model_test(expr * v, expr * c);
public:
From 794e210958df94b313fae287cbfa8951d1c712d7 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 16 Jan 2017 21:42:11 -0500
Subject: [PATCH 318/401] finite model fix
---
src/smt/theory_str.cpp | 10 ++++++++--
1 file changed, 8 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 5313b08ce..e91709962 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6673,6 +6673,12 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
ptr_vector<expr> & vars = finite_model_test_varlists[testvar];
for (ptr_vector<expr>::iterator it = vars.begin(); it != vars.end(); ++it) {
expr * v = *it;
+ bool v_has_eqc = false;
+ get_eqc_value(v, v_has_eqc);
+ if (v_has_eqc) {
+ TRACE("t_str_detail", tout << "variable " << mk_pp(v,m) << " already equivalent to a string constant" << std::endl;);
+ continue;
+ }
// check for any sort of existing length tester we might interfere with
if (m_params.m_UseBinarySearch) {
NOT_IMPLEMENTED_YET();
@@ -6763,8 +6769,8 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
expr_ref implRhs(mk_and(andList), m);
assert_implication(implLhs, implRhs);
} else {
- // TODO figure out this case
- NOT_IMPLEMENTED_YET();
+ TRACE("t_str_detail", tout << "already found existing length testers for " << mk_pp(v, m) << std::endl;);
+ continue;
}
}
} // foreach (v in vars)
From a570149b57e30137d27f647ef59c83ca9fd793fa Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 17 Jan 2017 14:49:57 -0500
Subject: [PATCH 319/401] finite overlap models with binary search
---
src/smt/theory_str.cpp | 10 +++++++++-
1 file changed, 9 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index e91709962..3153fa337 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6681,7 +6681,15 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
}
// check for any sort of existing length tester we might interfere with
if (m_params.m_UseBinarySearch) {
- NOT_IMPLEMENTED_YET();
+ if (binary_search_len_tester_stack.contains(v) && !binary_search_len_tester_stack[v].empty()) {
+ TRACE("t_str_detail", tout << "already found existing length testers for " << mk_pp(v, m) << std::endl;);
+ continue;
+ } else {
+ // start binary search as normal
+ expr_ref implLhs(ctx.mk_eq_atom(testvar, str), m);
+ expr_ref implRhs(binary_search_length_test(v, NULL, ""), m);
+ assert_implication(implLhs, implRhs);
+ }
} else {
bool map_effectively_empty = false;
if (fvar_len_count_map.find(v) == fvar_len_count_map.end()) {
From 50e2273dbdd67b8d7fa8940f3411d3b0a9d93d57 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 20 Jan 2017 17:39:32 -0500
Subject: [PATCH 320/401] substr bugfix
---
src/ast/rewriter/str_rewriter.cpp | 45 ++++++++++++++---
src/smt/theory_str.cpp | 81 +++++++++++++++++++++++++++++++
2 files changed, 118 insertions(+), 8 deletions(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index bc64e7218..2e3c82613 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -431,18 +431,47 @@ br_status str_rewriter::mk_str_from_int(expr * arg0, expr_ref & result) {
br_status str_rewriter::mk_str_Substr(expr * base, expr * start, expr * len, expr_ref & result) {
TRACE("t_str_rw", tout << "rewrite (Substr " << mk_pp(base, m()) << " " << mk_pp(start, m()) << " " << mk_pp(len, m()) << ")" << std::endl;);
- rational startVal, lenVal;
- if (m_strutil.is_string(base) && m_autil.is_numeral(start, startVal) && m_autil.is_numeral(len, lenVal)) {
- std::string baseStr = m_strutil.get_string_constant_value(base);
- // TODO handling for invalid start/len
- if (startVal.is_nonneg() && lenVal.is_nonneg() && startVal.get_unsigned() <= baseStr.length()) {
- TRACE("t_str_rw", tout << "rewriting constant Substr expression" << std::endl;);
- std::string substr = baseStr.substr(startVal.get_unsigned(), lenVal.get_unsigned());
- result = m_strutil.mk_string(substr);
+
+ bool constant_base = m_strutil.is_string(base);
+ std::string baseStr;
+ if (constant_base) {
+ baseStr = m_strutil.get_string_constant_value(base);
+ }
+ rational startVal;
+ bool constant_start = m_autil.is_numeral(start, startVal);
+ rational lenVal;
+ bool constant_len = m_autil.is_numeral(len, lenVal);
+
+ // case 1: start < 0 or len < 0
+ if ( (constant_start && startVal.is_neg()) || (constant_len && lenVal.is_neg()) ) {
+ TRACE("t_str_rw", tout << "start/len of substr is negative" << std::endl;);
+ result = m_strutil.mk_string("");
+ return BR_DONE;
+ }
+ // case 1.1: start >= length(base)
+ if (constant_start && constant_base) {
+ rational baseStrlen((unsigned int)baseStr.length());
+ if (startVal >= baseStrlen) {
+ TRACE("t_str_rw", tout << "start >= strlen for substr" << std::endl;);
+ result = m_strutil.mk_string("");
return BR_DONE;
}
}
+ if (constant_base && constant_start && constant_len) {
+ rational baseStrlen((unsigned int)baseStr.length());
+ std::string retval;
+ if (startVal + lenVal >= baseStrlen) {
+ // case 2: pos+len goes past the end of the string
+ retval = baseStr.substr(startVal.get_unsigned(), std::string::npos);
+ } else {
+ // case 3: pos+len still within string
+ retval = baseStr.substr(startVal.get_unsigned(), lenVal.get_unsigned());
+ }
+ result = m_strutil.mk_string(retval);
+ return BR_DONE;
+ }
+
return BR_FAILED;
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3153fa337..706f2cd73 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1579,6 +1579,86 @@ void theory_str::instantiate_axiom_Substr(enode * e) {
TRACE("t_str_detail", tout << "instantiate Substr axiom for " << mk_pp(expr, m) << std::endl;);
+ expr_ref substrBase(expr->get_arg(0), m);
+ expr_ref substrPos(expr->get_arg(1), m);
+ expr_ref substrLen(expr->get_arg(2), m);
+ SASSERT(substrBase);
+ SASSERT(substrPos);
+ SASSERT(substrLen);
+
+ expr_ref zero(m_autil.mk_numeral(rational::zero(), true), m);
+ expr_ref minusOne(m_autil.mk_numeral(rational::minus_one(), true), m);
+ SASSERT(zero);
+ SASSERT(minusOne);
+
+ expr_ref_vector argumentsValid_terms(m);
+ // pos >= 0
+ argumentsValid_terms.push_back(m_autil.mk_ge(substrPos, zero));
+ // pos < strlen(base)
+ // --> pos + -1*strlen(base) < 0
+ argumentsValid_terms.push_back(m.mk_not(m_autil.mk_ge(
+ m_autil.mk_add(substrPos, m_autil.mk_mul(minusOne, substrLen)),
+ zero)));
+ // len >= 0
+ argumentsValid_terms.push_back(m_autil.mk_ge(substrLen, zero));
+
+ expr_ref argumentsValid(mk_and(argumentsValid_terms), m);
+ SASSERT(argumentsValid);
+ ctx.internalize(argumentsValid, false);
+
+ // (pos+len) >= strlen(base)
+ // --> pos + len + -1*strlen(base) >= 0
+ expr_ref lenOutOfBounds(m_autil.mk_ge(
+ m_autil.mk_add(substrPos, substrLen, m_autil.mk_mul(minusOne, mk_strlen(substrBase))),
+ zero), m);
+ SASSERT(lenOutOfBounds);
+ ctx.internalize(argumentsValid, false);
+
+ // Case 1: pos < 0 or pos >= strlen(base) or len < 0
+ // ==> (Substr ...) = ""
+ expr_ref case1_premise(m.mk_not(argumentsValid), m);
+ SASSERT(case1_premise);
+ ctx.internalize(case1_premise, false);
+ expr_ref case1_conclusion(ctx.mk_eq_atom(expr, mk_string("")), m);
+ SASSERT(case1_conclusion);
+ ctx.internalize(case1_conclusion, false);
+ expr_ref case1(rewrite_implication(case1_premise, case1_conclusion), m);
+ SASSERT(case1);
+
+ // Case 2: (pos >= 0 and pos < strlen(base) and len >= 0) and (pos+len) >= strlen(base)
+ // ==> base = t0.t1 AND len(t0) = pos AND (Substr ...) = t1
+ expr_ref t0(mk_str_var("t0"), m);
+ expr_ref t1(mk_str_var("t1"), m);
+ expr_ref case2_conclusion(m.mk_and(
+ ctx.mk_eq_atom(substrBase, mk_concat(t0,t1)),
+ ctx.mk_eq_atom(mk_strlen(t0), substrPos),
+ ctx.mk_eq_atom(expr, t1)), m);
+ expr_ref case2(rewrite_implication(m.mk_and(argumentsValid, lenOutOfBounds), case2_conclusion), m);
+ SASSERT(case2);
+
+ // Case 3: (pos >= 0 and pos < strlen(base) and len >= 0) and (pos+len) < strlen(base)
+ // ==> base = t2.t3.t4 AND len(t2) = pos AND len(t3) = len AND (Substr ...) = t3
+ expr_ref t2(mk_str_var("t2"), m);
+ expr_ref t3(mk_str_var("t3"), m);
+ expr_ref t4(mk_str_var("t4"), m);
+ expr_ref_vector case3_conclusion_terms(m);
+ case3_conclusion_terms.push_back(ctx.mk_eq_atom(substrBase, mk_concat(t2, mk_concat(t3, t4))));
+ case3_conclusion_terms.push_back(ctx.mk_eq_atom(mk_strlen(t2), substrPos));
+ case3_conclusion_terms.push_back(ctx.mk_eq_atom(mk_strlen(t3), substrLen));
+ case3_conclusion_terms.push_back(ctx.mk_eq_atom(expr, t3));
+ expr_ref case3_conclusion(mk_and(case3_conclusion_terms), m);
+ expr_ref case3(rewrite_implication(m.mk_and(argumentsValid, m.mk_not(lenOutOfBounds)), case3_conclusion), m);
+ SASSERT(case3);
+
+ ctx.internalize(case1, false);
+ ctx.internalize(case2, false);
+ ctx.internalize(case3, false);
+
+ expr_ref finalAxiom(m.mk_and(case1, case2, case3), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+
+ /*
expr_ref ts0(mk_str_var("ts0"), m);
expr_ref ts1(mk_str_var("ts1"), m);
expr_ref ts2(mk_str_var("ts2"), m);
@@ -1601,6 +1681,7 @@ void theory_str::instantiate_axiom_Substr(enode * e) {
expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToVar), m);
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
+ */
}
void theory_str::instantiate_axiom_Replace(enode * e) {
From 09ac5645e4c947e134e62534b4e44417a99bf771 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 22 Jan 2017 23:21:20 -0500
Subject: [PATCH 321/401] parameterize theory-aware activity of overlap
---
src/smt/params/smt_params_helper.pyg | 3 ++-
src/smt/params/theory_str_params.cpp | 1 +
src/smt/params/theory_str_params.h | 5 ++++-
src/smt/theory_str.cpp | 18 +++++++++---------
4 files changed, 16 insertions(+), 11 deletions(-)
diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg
index e23915ab4..75ee20ebd 100644
--- a/src/smt/params/smt_params_helper.pyg
+++ b/src/smt/params/smt_params_helper.pyg
@@ -73,5 +73,6 @@ def_module_params(module_name='smt',
('str.binary_search_start', UINT, 64, 'initial upper bound for theory_str binary search'),
('theory_case_split', BOOL, False, 'Allow the context to use heuristics involving theory case splits, which are a set of literals of which exactly one can be assigned True. If this option is false, the context will generate extra axioms to enforce this instead.'),
('theory_aware_branching', BOOL, False, 'Allow the context to use extra information from theory solvers regarding literal branching prioritization.'),
- ('str.finite_overlap_models', BOOL, False, 'attempt a finite model search for overlapping variables instead of completely giving up on the arrangement')
+ ('str.finite_overlap_models', BOOL, False, 'attempt a finite model search for overlapping variables instead of completely giving up on the arrangement'),
+ ('str.overlap_priority', DOUBLE, -0.1, 'theory-aware priority for overlapping variable cases; use smt.theory_aware_branching=true')
))
diff --git a/src/smt/params/theory_str_params.cpp b/src/smt/params/theory_str_params.cpp
index 46302cf82..f86cd9379 100644
--- a/src/smt/params/theory_str_params.cpp
+++ b/src/smt/params/theory_str_params.cpp
@@ -30,4 +30,5 @@ void theory_str_params::updt_params(params_ref const & _p) {
m_FiniteOverlapModels = p.str_finite_overlap_models();
m_UseBinarySearch = p.str_use_binary_search();
m_BinarySearchInitialUpperBound = p.str_binary_search_start();
+ m_OverlapTheoryAwarePriority = p.str_overlap_priority();
}
diff --git a/src/smt/params/theory_str_params.h b/src/smt/params/theory_str_params.h
index 4effb0897..de0945395 100644
--- a/src/smt/params/theory_str_params.h
+++ b/src/smt/params/theory_str_params.h
@@ -78,6 +78,8 @@ struct theory_str_params {
bool m_UseBinarySearch;
unsigned m_BinarySearchInitialUpperBound;
+ double m_OverlapTheoryAwarePriority;
+
theory_str_params(params_ref const & p = params_ref()):
m_AssertStrongerArrangements(true),
m_AggressiveLengthTesting(false),
@@ -88,7 +90,8 @@ struct theory_str_params {
m_StringConstantCache(true),
m_FiniteOverlapModels(false),
m_UseBinarySearch(false),
- m_BinarySearchInitialUpperBound(64)
+ m_BinarySearchInitialUpperBound(64),
+ m_OverlapTheoryAwarePriority(-0.1)
{
updt_params(p);
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 706f2cd73..138b7db9f 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3249,7 +3249,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
if (m_params.m_FiniteOverlapModels) {
expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
assert_implication(ax_l, tester);
- add_theory_aware_branching_info(tester, -0.1, l_true);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
// TODO printCutVar(m, y);
@@ -3307,7 +3307,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
if (m_params.m_FiniteOverlapModels) {
expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
assert_implication(ax_l, tester);
- add_theory_aware_branching_info(tester, -0.1, l_true);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
// TODO printCutVar(m, y);
@@ -3361,7 +3361,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
if (m_params.m_FiniteOverlapModels) {
expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
arrangement_disjunction.push_back(tester);
- add_theory_aware_branching_info(tester, -0.1, l_true);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
@@ -3406,7 +3406,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
// TODO this might repeat the case above, we may wish to avoid doing this twice
expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
arrangement_disjunction.push_back(tester);
- add_theory_aware_branching_info(tester, -0.1, l_true);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
// TODO printCutVar(x, n);
@@ -3645,7 +3645,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
if (m_params.m_FiniteOverlapModels) {
expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
assert_implication(ax_l, tester);
- add_theory_aware_branching_info(tester, -0.1, l_true);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIP" << std::endl;);
// TODO printCutVar(m, y);
@@ -3753,7 +3753,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
if (m_params.m_FiniteOverlapModels) {
expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
arrangement_disjunction.push_back(tester);
- add_theory_aware_branching_info(tester, -0.1, l_true);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
// TODO printCutVar(m, y)
@@ -4046,7 +4046,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
if (m_params.m_FiniteOverlapModels) {
expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
assert_implication(ax_l, tester);
- add_theory_aware_branching_info(tester, -0.1, l_true);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
// TODO printCutVar(x, n);
@@ -4126,7 +4126,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
if (m_params.m_FiniteOverlapModels) {
expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
arrangement_disjunction.push_back(tester);
- add_theory_aware_branching_info(tester, -0.1, l_true);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
// TODO printCutVAR(x, n)
@@ -4532,7 +4532,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
if (m_params.m_FiniteOverlapModels) {
expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
arrangement_disjunction.push_back(tester);
- add_theory_aware_branching_info(tester, -0.1, l_true);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
TRACE("t_str", print_cut_var(m, tout); print_cut_var(y, tout););
From a879b240114e75938ac2668ccd8f178a87c94ad4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 27 Jan 2017 16:26:30 -0500
Subject: [PATCH 322/401] add str.prefixof, str.suffixof in theory_str
---
src/ast/rewriter/str_rewriter.cpp | 18 ++++++++++++++++++
src/ast/rewriter/str_rewriter.h | 2 ++
src/ast/str_decl_plugin.cpp | 14 ++++++++++++++
src/ast/str_decl_plugin.h | 15 +++++++++++++++
4 files changed, 49 insertions(+)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 2e3c82613..3926e66e1 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -375,6 +375,18 @@ br_status str_rewriter::mk_str_Replace(expr * base, expr * source, expr * target
}
}
+br_status str_rewriter::mk_str_prefixof(expr * pre, expr * full, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (str.prefixof " << mk_pp(pre, m()) << " " << mk_pp(full, m()) << ")" << std::endl;);
+ result = m_strutil.mk_str_StartsWith(full, pre);
+ return BR_REWRITE_FULL;
+}
+
+br_status str_rewriter::mk_str_suffixof(expr * post, expr * full, expr_ref & result) {
+ TRACE("t_str_rw", tout << "rewrite (str.suffixof" << mk_pp(post, m()) << " " << mk_pp(full, m()) << ")" << std::endl;);
+ result = m_strutil.mk_str_EndsWith(full, post);
+ return BR_REWRITE_FULL;
+}
+
br_status str_rewriter::mk_str_to_int(expr * arg0, expr_ref & result) {
TRACE("t_str_rw", tout << "rewrite (str.to-int " << mk_pp(arg0, m()) << ")" << std::endl;);
@@ -623,6 +635,12 @@ br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
case OP_STR_REPLACE:
SASSERT(num_args == 3);
return mk_str_Replace(args[0], args[1], args[2], result);
+ case OP_STR_PREFIXOF:
+ SASSERT(num_args == 2);
+ return mk_str_prefixof(args[0], args[1], result);
+ case OP_STR_SUFFIXOF:
+ SASSERT(num_args == 2);
+ return mk_str_suffixof(args[0], args[1], result);
case OP_STR_STR2INT:
SASSERT(num_args == 1);
return mk_str_to_int(args[0], result);
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index 145c0193e..0494d4d1b 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -53,6 +53,8 @@ public:
br_status mk_str_LastIndexof(expr * haystack, expr * needle, expr_ref & result);
br_status mk_str_Replace(expr * base, expr * source, expr * target, expr_ref & result);
br_status mk_str_Substr(expr * base, expr * start, expr * len, expr_ref & result);
+ br_status mk_str_prefixof(expr * pre, expr * full, expr_ref & result);
+ br_status mk_str_suffixof(expr * post, expr * full, expr_ref & result);
br_status mk_str_to_int(expr * arg0, expr_ref & result);
br_status mk_str_from_int(expr * arg0, expr_ref & result);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 8ac1f722f..60f50b5c4 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -38,6 +38,8 @@ str_decl_plugin::str_decl_plugin():
m_replace_decl(0),
m_str2int_decl(0),
m_int2str_decl(0),
+ m_prefixof_decl(0),
+ m_suffixof_decl(0),
m_re_str2regex_decl(0),
m_re_regexin_decl(0),
m_re_regexconcat_decl(0),
@@ -69,6 +71,8 @@ void str_decl_plugin::finalize(void) {
DEC_REF(m_lastindexof_decl);
DEC_REF(m_substr_decl);
DEC_REF(m_replace_decl);
+ DEC_REF(m_prefixof_decl);
+ DEC_REF(m_suffixof_decl);
DEC_REF(m_str2int_decl);
DEC_REF(m_int2str_decl);
DEC_REF(m_re_str2regex_decl);
@@ -149,6 +153,12 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_manager->inc_ref(m_replace_decl);
}
+ m_prefixof_decl = m->mk_func_decl(symbol("str.prefixof"), s, s, boolT, func_decl_info(id, OP_STR_PREFIXOF));
+ m_manager->inc_ref(m_prefixof_decl);
+
+ m_suffixof_decl = m->mk_func_decl(symbol("str.suffixof"), s, s, boolT, func_decl_info(id, OP_STR_SUFFIXOF));
+ m_manager->inc_ref(m_suffixof_decl);
+
m_str2int_decl = m->mk_func_decl(symbol("str.to-int"), s, i, func_decl_info(id, OP_STR_STR2INT));
m_manager->inc_ref(m_str2int_decl);
@@ -206,6 +216,8 @@ func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
case OP_STR_LASTINDEXOF: return m_lastindexof_decl;
case OP_STR_SUBSTR: return m_substr_decl;
case OP_STR_REPLACE: return m_replace_decl;
+ case OP_STR_PREFIXOF: return m_prefixof_decl;
+ case OP_STR_SUFFIXOF: return m_suffixof_decl;
case OP_STR_STR2INT: return m_str2int_decl;
case OP_STR_INT2STR: return m_int2str_decl;
case OP_RE_STR2REGEX: return m_re_str2regex_decl;
@@ -281,6 +293,8 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("LastIndexof", OP_STR_LASTINDEXOF));
op_names.push_back(builtin_name("Substring", OP_STR_SUBSTR));
op_names.push_back(builtin_name("Replace", OP_STR_REPLACE));
+ op_names.push_back(builtin_name("str.prefixof", OP_STR_PREFIXOF));
+ op_names.push_back(builtin_name("str.suffixof", OP_STR_SUFFIXOF));
op_names.push_back(builtin_name("str.to-int", OP_STR_STR2INT));
op_names.push_back(builtin_name("str.from-int", OP_STR_INT2STR));
op_names.push_back(builtin_name("Str2Reg", OP_RE_STR2REGEX));
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index ff531e942..3ae034b45 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -41,6 +41,9 @@ enum str_op_kind {
OP_STR_LASTINDEXOF,
OP_STR_SUBSTR,
OP_STR_REPLACE,
+ // SMT-LIB 2.5 standard operators -- these are rewritten to internal ones
+ OP_STR_PREFIXOF,
+ OP_STR_SUFFIXOF,
// string-integer conversion
OP_STR_STR2INT,
OP_STR_INT2STR, OP_STR_PLACEHOLDER1, OP_STR_PLACEHOLDER2,
@@ -78,6 +81,8 @@ protected:
func_decl * m_replace_decl;
func_decl * m_str2int_decl;
func_decl * m_int2str_decl;
+ func_decl * m_prefixof_decl;
+ func_decl * m_suffixof_decl;
func_decl * m_re_str2regex_decl;
func_decl * m_re_regexin_decl;
@@ -167,6 +172,16 @@ public:
}
app * mk_string_with_escape_characters(std::string & val);
+ app * mk_str_StartsWith(expr * haystack, expr * needle) {
+ expr * es[2] = {haystack, needle};
+ return m_manager.mk_app(get_fid(), OP_STR_STARTSWITH, 2, es);
+ }
+
+ app * mk_str_EndsWith(expr * haystack, expr * needle) {
+ expr * es[2] = {haystack, needle};
+ return m_manager.mk_app(get_fid(), OP_STR_ENDSWITH, 2, es);
+ }
+
app * mk_re_Str2Reg(expr * s) {
expr * es[1] = {s};
return m_manager.mk_app(get_fid(), OP_RE_STR2REGEX, 1, es);
From fa1ec0b80f7c22ef1aef9a58b571d5dd9a18e5d7 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 27 Jan 2017 16:49:40 -0500
Subject: [PATCH 323/401] smtlib25 draft standard in theory_str
---
src/ast/str_decl_plugin.cpp | 60 ++++++++++++++++++-------------------
1 file changed, 30 insertions(+), 30 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 60f50b5c4..bd6d70ebe 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -112,12 +112,12 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
FIELD = m->mk_func_decl(symbol(NAME), SORT, SORT, SORT, func_decl_info(id, KIND)); \
m->inc_ref(FIELD)
- MK_OP(m_concat_decl, "Concat", OP_STRCAT, s);
+ MK_OP(m_concat_decl, "str.++", OP_STRCAT, s);
- m_length_decl = m->mk_func_decl(symbol("Length"), s, i, func_decl_info(id, OP_STRLEN));
+ m_length_decl = m->mk_func_decl(symbol("str.len"), s, i, func_decl_info(id, OP_STRLEN));
m_manager->inc_ref(m_length_decl);
- m_charat_decl = m->mk_func_decl(symbol("CharAt"), s, i, s, func_decl_info(id, OP_STR_CHARAT));
+ m_charat_decl = m->mk_func_decl(symbol("str.at"), s, i, s, func_decl_info(id, OP_STR_CHARAT));
m_manager->inc_ref(m_charat_decl);
m_startswith_decl = m->mk_func_decl(symbol("StartsWith"), s, s, boolT, func_decl_info(id, OP_STR_STARTSWITH));
@@ -126,10 +126,10 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_endswith_decl = m->mk_func_decl(symbol("EndsWith"), s, s, boolT, func_decl_info(id, OP_STR_ENDSWITH));
m_manager->inc_ref(m_endswith_decl);
- m_contains_decl = m->mk_func_decl(symbol("Contains"), s, s, boolT, func_decl_info(id, OP_STR_CONTAINS));
+ m_contains_decl = m->mk_func_decl(symbol("str.contains"), s, s, boolT, func_decl_info(id, OP_STR_CONTAINS));
m_manager->inc_ref(m_contains_decl);
- m_indexof_decl = m->mk_func_decl(symbol("Indexof"), s, s, i, func_decl_info(id, OP_STR_INDEXOF));
+ m_indexof_decl = m->mk_func_decl(symbol("str.indexof"), s, s, i, func_decl_info(id, OP_STR_INDEXOF));
m_manager->inc_ref(m_indexof_decl);
{
@@ -138,18 +138,18 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_manager->inc_ref(m_indexof2_decl);
}
- m_lastindexof_decl = m->mk_func_decl(symbol("LastIndexof"), s, s, i, func_decl_info(id, OP_STR_LASTINDEXOF));
+ m_lastindexof_decl = m->mk_func_decl(symbol("str.lastindexof"), s, s, i, func_decl_info(id, OP_STR_LASTINDEXOF));
m_manager->inc_ref(m_lastindexof_decl);
{
sort * d[3] = {s, i, i };
- m_substr_decl = m->mk_func_decl(symbol("Substring"), 3, d, s, func_decl_info(id, OP_STR_SUBSTR));
+ m_substr_decl = m->mk_func_decl(symbol("str.substr"), 3, d, s, func_decl_info(id, OP_STR_SUBSTR));
m_manager->inc_ref(m_substr_decl);
}
{
sort * d[3] = {s, s, s};
- m_replace_decl = m->mk_func_decl(symbol("Replace"), 3, d, s, func_decl_info(id, OP_STR_REPLACE));
+ m_replace_decl = m->mk_func_decl(symbol("str.replace"), 3, d, s, func_decl_info(id, OP_STR_REPLACE));
m_manager->inc_ref(m_replace_decl);
}
@@ -165,28 +165,28 @@ void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
m_int2str_decl = m->mk_func_decl(symbol("str.from-int"), i, s, func_decl_info(id, OP_STR_INT2STR));
m_manager->inc_ref(m_int2str_decl);
- m_re_str2regex_decl = m->mk_func_decl(symbol("Str2Reg"), s, re, func_decl_info(id, OP_RE_STR2REGEX));
+ m_re_str2regex_decl = m->mk_func_decl(symbol("str.to.re"), s, re, func_decl_info(id, OP_RE_STR2REGEX));
m_manager->inc_ref(m_re_str2regex_decl);
- m_re_regexin_decl = m->mk_func_decl(symbol("RegexIn"), s, re, boolT, func_decl_info(id, OP_RE_REGEXIN));
+ m_re_regexin_decl = m->mk_func_decl(symbol("str.in.re"), s, re, boolT, func_decl_info(id, OP_RE_REGEXIN));
m_manager->inc_ref(m_re_regexin_decl);
- m_re_regexconcat_decl = m->mk_func_decl(symbol("RegexConcat"), re, re, re, func_decl_info(id, OP_RE_REGEXCONCAT));
+ m_re_regexconcat_decl = m->mk_func_decl(symbol("re.++"), re, re, re, func_decl_info(id, OP_RE_REGEXCONCAT));
m_manager->inc_ref(m_re_regexconcat_decl);
- m_re_regexstar_decl = m->mk_func_decl(symbol("RegexStar"), re, re, func_decl_info(id, OP_RE_REGEXSTAR));
+ m_re_regexstar_decl = m->mk_func_decl(symbol("re.*"), re, re, func_decl_info(id, OP_RE_REGEXSTAR));
m_manager->inc_ref(m_re_regexstar_decl);
- m_re_regexplus_decl = m->mk_func_decl(symbol("RegexPlus"), re, re, func_decl_info(id, OP_RE_REGEXPLUS));
+ m_re_regexplus_decl = m->mk_func_decl(symbol("re.+"), re, re, func_decl_info(id, OP_RE_REGEXPLUS));
m_manager->inc_ref(m_re_regexplus_decl);
- m_re_regexunion_decl = m->mk_func_decl(symbol("RegexUnion"), re, re, re, func_decl_info(id, OP_RE_REGEXUNION));
+ m_re_regexunion_decl = m->mk_func_decl(symbol("re.union"), re, re, re, func_decl_info(id, OP_RE_REGEXUNION));
m_manager->inc_ref(m_re_regexunion_decl);
m_re_unroll_decl = m->mk_func_decl(symbol("Unroll"), re, i, s, func_decl_info(id, OP_RE_UNROLL));
m_manager->inc_ref(m_re_unroll_decl);
- m_re_regexcharrange_decl = m->mk_func_decl(symbol("RegexCharRange"), s, s, re, func_decl_info(id, OP_RE_REGEXCHARRANGE));
+ m_re_regexcharrange_decl = m->mk_func_decl(symbol("re.range"), s, s, re, func_decl_info(id, OP_RE_REGEXCHARRANGE));
m_manager->inc_ref(m_re_regexcharrange_decl);
}
@@ -282,29 +282,29 @@ app * str_decl_plugin::mk_fresh_string() {
}
void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol const & logic) {
- op_names.push_back(builtin_name("Concat", OP_STRCAT));
- op_names.push_back(builtin_name("Length", OP_STRLEN));
- op_names.push_back(builtin_name("CharAt", OP_STR_CHARAT));
+ op_names.push_back(builtin_name("str.++", OP_STRCAT));
+ op_names.push_back(builtin_name("str.len", OP_STRLEN));
+ op_names.push_back(builtin_name("str.at", OP_STR_CHARAT));
op_names.push_back(builtin_name("StartsWith", OP_STR_STARTSWITH));
op_names.push_back(builtin_name("EndsWith", OP_STR_ENDSWITH));
- op_names.push_back(builtin_name("Contains", OP_STR_CONTAINS));
- op_names.push_back(builtin_name("Indexof", OP_STR_INDEXOF));
+ op_names.push_back(builtin_name("str.contains", OP_STR_CONTAINS));
+ op_names.push_back(builtin_name("str.indexof", OP_STR_INDEXOF));
op_names.push_back(builtin_name("Indexof2", OP_STR_INDEXOF2));
- op_names.push_back(builtin_name("LastIndexof", OP_STR_LASTINDEXOF));
- op_names.push_back(builtin_name("Substring", OP_STR_SUBSTR));
- op_names.push_back(builtin_name("Replace", OP_STR_REPLACE));
+ op_names.push_back(builtin_name("str.lastindexof", OP_STR_LASTINDEXOF));
+ op_names.push_back(builtin_name("str.substr", OP_STR_SUBSTR));
+ op_names.push_back(builtin_name("str.replace", OP_STR_REPLACE));
op_names.push_back(builtin_name("str.prefixof", OP_STR_PREFIXOF));
op_names.push_back(builtin_name("str.suffixof", OP_STR_SUFFIXOF));
op_names.push_back(builtin_name("str.to-int", OP_STR_STR2INT));
op_names.push_back(builtin_name("str.from-int", OP_STR_INT2STR));
- op_names.push_back(builtin_name("Str2Reg", OP_RE_STR2REGEX));
- op_names.push_back(builtin_name("RegexIn", OP_RE_REGEXIN));
- op_names.push_back(builtin_name("RegexConcat", OP_RE_REGEXCONCAT));
- op_names.push_back(builtin_name("RegexStar", OP_RE_REGEXSTAR));
- op_names.push_back(builtin_name("RegexUnion", OP_RE_REGEXUNION));
- op_names.push_back(builtin_name("RegexPlus", OP_RE_REGEXPLUS));
+ op_names.push_back(builtin_name("str.to.reg", OP_RE_STR2REGEX));
+ op_names.push_back(builtin_name("str.in.reg", OP_RE_REGEXIN));
+ op_names.push_back(builtin_name("re.++", OP_RE_REGEXCONCAT));
+ op_names.push_back(builtin_name("re.*", OP_RE_REGEXSTAR));
+ op_names.push_back(builtin_name("re.union", OP_RE_REGEXUNION));
+ op_names.push_back(builtin_name("re.+", OP_RE_REGEXPLUS));
op_names.push_back(builtin_name("Unroll", OP_RE_UNROLL));
- op_names.push_back(builtin_name("RegexCharRange", OP_RE_REGEXCHARRANGE));
+ op_names.push_back(builtin_name("re.range", OP_RE_REGEXCHARRANGE));
}
void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
From ebcfa966c7e3c6e10371df9e2a4799bcc3421330 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 30 Jan 2017 16:07:32 -0500
Subject: [PATCH 324/401] data structure refactor in theory_str
---
src/smt/theory_str.cpp | 23 ++---------------------
src/smt/theory_str.h | 6 +++---
2 files changed, 5 insertions(+), 24 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 138b7db9f..a59bfb90b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -7870,7 +7870,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
// Step 1: get variables / concat AST appearing in the context
// the thing we iterate over should just be variable_set - internal_variable_set
// so we avoid computing the set difference (but this might be slower)
- for(std::set<expr*>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
+ for(obj_hashtable<expr>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
expr* var = *it;
if (internal_variable_set.find(var) == internal_variable_set.end()) {
TRACE("t_str_detail", tout << "new variable: " << mk_pp(var, m) << std::endl;);
@@ -8819,7 +8819,7 @@ final_check_status theory_str::final_check_eh() {
bool needToAssignFreeVars = false;
std::set<expr*> free_variables;
std::set<expr*> unused_internal_variables;
- if (true) { // Z3str2 free variables check
+ { // Z3str2 free variables check
std::map<expr*, int>::iterator itor = varAppearInAssign.begin();
for (; itor != varAppearInAssign.end(); ++itor) {
/*
@@ -8845,25 +8845,6 @@ final_check_status theory_str::final_check_eh() {
TRACE("t_str_detail", tout << "variable " << mk_pp(itor->first, m) << " = " << mk_pp(eqcString, m) << std::endl;);
}
}
- } else { // new, possibly incorrect free variables check
- // Check every variable to see if it's eq. to some string constant.
- // If not, mark it as free.
- TRACE("t_str_detail", tout << variable_set.size() << " variables in variable_set" << std::endl;);
- for (std::set<expr*>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
- TRACE("t_str_detail", tout << "checking eqc of variable " << mk_ismt2_pp(*it, m) << std::endl;);
- bool has_eqc_value = false;
- get_eqc_value(*it, has_eqc_value);
- if (!has_eqc_value) {
- // if this is an internal variable, it can be ignored...I think
- if (internal_variable_set.find(*it) != internal_variable_set.end() || regex_variable_set.find(*it) != regex_variable_set.end()) {
- TRACE("t_str_detail", tout << "WARNING: free internal variable " << mk_ismt2_pp(*it, m) << std::endl;);
- //unused_internal_variables.insert(*it);
- } else {
- needToAssignFreeVars = true;
- free_variables.insert(*it);
- }
- }
- }
}
if (!needToAssignFreeVars) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 3bb093dcd..97f2b9fa4 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -240,9 +240,9 @@ namespace smt {
bool loopDetected;
obj_map<expr, std::stack<T_cut*> > cut_var_map;
- std::set<expr*> variable_set;
- std::set<expr*> internal_variable_set;
- std::set<expr*> regex_variable_set;
+ obj_hashtable<expr> variable_set;
+ obj_hashtable<expr> internal_variable_set;
+ obj_hashtable<expr> regex_variable_set;
std::map<int, std::set<expr*> > internal_variable_scope_levels;
obj_hashtable<expr> internal_lenTest_vars;
From 19779f1a9b0a567f498a1665805fbe7b3d68f14a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 31 Jan 2017 11:49:10 -0500
Subject: [PATCH 325/401] fix string operators in theory_str, this breaks
theory_seq temporarily
---
src/ast/seq_decl_plugin.cpp | 4 ++--
src/ast/str_decl_plugin.cpp | 4 ++--
2 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/ast/seq_decl_plugin.cpp b/src/ast/seq_decl_plugin.cpp
index 787648e19..779096038 100644
--- a/src/ast/seq_decl_plugin.cpp
+++ b/src/ast/seq_decl_plugin.cpp
@@ -477,8 +477,8 @@ void seq_decl_plugin::init() {
m_sigs[_OP_STRING_CHARAT] = alloc(psig, m, "str.at", 0, 2, strTint2T, strT);
m_sigs[_OP_STRING_PREFIX] = alloc(psig, m, "str.prefixof", 0, 2, str2T, boolT);
m_sigs[_OP_STRING_SUFFIX] = alloc(psig, m, "str.suffixof", 0, 2, str2T, boolT);
- m_sigs[_OP_STRING_IN_REGEXP] = alloc(psig, m, "str.in.re", 0, 2, strTreT, boolT);
- m_sigs[_OP_STRING_TO_REGEXP] = alloc(psig, m, "str.to.re", 0, 1, &strT, reT);
+ m_sigs[_OP_STRING_IN_REGEXP] = alloc(psig, m, "seqstr.in.re", 0, 2, strTreT, boolT);
+ m_sigs[_OP_STRING_TO_REGEXP] = alloc(psig, m, "seqstr.to.re", 0, 1, &strT, reT);
m_sigs[_OP_REGEXP_EMPTY] = alloc(psig, m, "re.nostr", 0, 0, 0, reT);
m_sigs[_OP_REGEXP_FULL] = alloc(psig, m, "re.allchar", 0, 0, 0, reT);
m_sigs[_OP_STRING_SUBSTR] = alloc(psig, m, "str.substr", 0, 3, strTint2T, strT);
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index bd6d70ebe..766fefdcf 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -297,8 +297,8 @@ void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol cons
op_names.push_back(builtin_name("str.suffixof", OP_STR_SUFFIXOF));
op_names.push_back(builtin_name("str.to-int", OP_STR_STR2INT));
op_names.push_back(builtin_name("str.from-int", OP_STR_INT2STR));
- op_names.push_back(builtin_name("str.to.reg", OP_RE_STR2REGEX));
- op_names.push_back(builtin_name("str.in.reg", OP_RE_REGEXIN));
+ op_names.push_back(builtin_name("str.to.re", OP_RE_STR2REGEX));
+ op_names.push_back(builtin_name("str.in.re", OP_RE_REGEXIN));
op_names.push_back(builtin_name("re.++", OP_RE_REGEXCONCAT));
op_names.push_back(builtin_name("re.*", OP_RE_REGEXSTAR));
op_names.push_back(builtin_name("re.union", OP_RE_REGEXUNION));
From 55cb440aae7c24ac1923a57b40e4aa3b5afc5ffe Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 7 Feb 2017 14:41:16 -0500
Subject: [PATCH 326/401] add cut var info for theory_str processtype2
---
src/smt/theory_str.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a59bfb90b..097cfcb15 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3648,7 +3648,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIP" << std::endl;);
- // TODO printCutVar(m, y);
+ TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
}
}
}
@@ -3756,7 +3756,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- // TODO printCutVar(m, y)
+ TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
}
}
}
From c456795acdffcf5ada19c10303487fe0686cd2f1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 7 Feb 2017 17:14:11 -0500
Subject: [PATCH 327/401] temporarily remove finite model finding from
theory_str
---
src/smt/theory_str.cpp | 2 ++
1 file changed, 2 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 097cfcb15..b3f2bc478 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6968,6 +6968,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
return;
}
+ /* // temporarily disabled, we are borrowing these testers for something else
if (m_params.m_FiniteOverlapModels && !finite_model_test_varlists.empty()) {
// TODO NEXT
if (finite_model_test_varlists.contains(lhs)) {
@@ -6976,6 +6977,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
finite_model_test(rhs, lhs); return;
}
}
+ */
if (free_var_attempt(lhs, rhs) || free_var_attempt(rhs, lhs)) {
return;
From 3670fa64e69971727ec8ee7612e426e98a95ef7a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 11 Feb 2017 16:59:06 -0500
Subject: [PATCH 328/401] add hex escape support theory_str
---
src/ast/str_decl_plugin.cpp | 20 ++++++++++++++++----
1 file changed, 16 insertions(+), 4 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 766fefdcf..ea539c0c6 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -375,8 +375,7 @@ app * str_util::mk_string_with_escape_characters(std::string & val) {
// check escape sequence
i++;
if (i >= val.length()) {
- // TODO illegal escape sequence
- NOT_IMPLEMENTED_YET();
+ get_manager().raise_exception("invalid escape sequence");
}
char escapeChar1 = val.at(i);
if (escapeChar1 == 'a') {
@@ -398,8 +397,21 @@ app * str_util::mk_string_with_escape_characters(std::string & val) {
} else if (escapeChar1 == '\\') {
parsedStr.push_back('\\');
} else if (escapeChar1 == 'x') {
- // TODO hex escape
- NOT_IMPLEMENTED_YET();
+ // hex escape: we expect 'x' to be followed by exactly two hex digits
+ // which means that i+2 must be a valid index
+ if (i+2 >= val.length()) {
+ get_manager().raise_exception("invalid hex escape: \\x must be followed by exactly two hex digits");
+ }
+ char hexDigitHi = val.at(i+1);
+ char hexDigitLo = val.at(i+2);
+ i += 2;
+ if (!isxdigit((int)hexDigitHi) || !isxdigit((int)hexDigitLo)) {
+ get_manager().raise_exception("invalid hex escape: \\x must be followed by exactly two hex digits");
+ }
+ char tmp[3] = {hexDigitHi, hexDigitLo, '\0'};
+ long converted = strtol(tmp, NULL, 16);
+ unsigned char convChar = (unsigned char)converted;
+ parsedStr.push_back(convChar);
} else if (escapeChar1 == '0' || escapeChar1 == '1' || escapeChar1 == '2' || escapeChar1 == '3' ||
escapeChar1 == '4' || escapeChar1 == '5' || escapeChar1 == '6' || escapeChar1 == '7') {
// TODO octal escape
From e699f25889c8ba6e0ac608b0e83c77a9f6f3399d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 13 Feb 2017 16:24:32 -0500
Subject: [PATCH 329/401] theory_str cleanup
---
src/smt/theory_str.cpp | 163 ++---------------------------------------
1 file changed, 5 insertions(+), 158 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b3f2bc478..158342cb1 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -273,68 +273,6 @@ bool theory_str::internalize_term(app * term) {
TRACE("t_str_axiom_bug", tout << "add " << mk_pp(e->get_owner(), m) << " to m_basicstr_axiom_todo" << std::endl;);
}
return true;
-
- /* // what I had before
- SASSERT(!ctx.e_internalized(term));
-
- unsigned num_args = term->get_num_args();
- for (unsigned i = 0; i < num_args; i++)
- ctx.internalize(term->get_arg(i), false);
-
- enode * e = (ctx.e_internalized(term)) ? ctx.get_enode(term) :
- ctx.mk_enode(term, false, false, true);
-
- if (is_attached_to_var(e))
- return false;
-
- attach_new_th_var(e);
-
- //if (is_concat(term)) {
- // instantiate_concat_axiom(e);
- //}
- */
-
- // TODO do we still need to do instantiate_concat_axiom()?
-
- // partially from theory_seq::internalize_term()
- /*
- if (ctx.e_internalized(term)) {
- enode* e = ctx.get_enode(term);
- mk_var(e);
- return true;
- }
- TRACE("t_str_detail", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
- unsigned num_args = term->get_num_args();
- expr* arg;
- for (unsigned i = 0; i < num_args; i++) {
- arg = term->get_arg(i);
- mk_var(ensure_enode(arg));
- }
- if (m.is_bool(term)) {
- bool_var bv = ctx.mk_bool_var(term);
- ctx.set_var_theory(bv, get_id());
- ctx.mark_as_relevant(bv);
- }
-
- enode* e = 0;
- if (ctx.e_internalized(term)) {
- e = ctx.get_enode(term);
- }
- else {
- e = ctx.mk_enode(term, false, m.is_bool(term), true);
- }
-
- if (opt_EagerStringConstantLengthAssertions && m_strutil.is_string(term)) {
- TRACE("t_str", tout << "eagerly asserting length of string term " << mk_pp(term, m) << std::endl;);
- m_basicstr_axiom_todo.insert(e);
- TRACE("t_str_axiom_bug", tout << "add " << mk_pp(e->get_owner(), m) << " to m_basicstr_axiom_todo" << std::endl;);
- }
-
- theory_var v = mk_var(e);
- TRACE("t_str_detail", tout << "term " << mk_ismt2_pp(term, get_manager()) << " = v#" << v << std::endl;);
-
- return true;
- */
}
enode* theory_str::ensure_enode(expr* e) {
@@ -351,18 +289,11 @@ void theory_str::refresh_theory_var(expr * e) {
enode * en = ensure_enode(e);
theory_var v = mk_var(en);
TRACE("t_str_detail", tout << "refresh " << mk_pp(e, get_manager()) << ": v#" << v << std::endl;);
- // TODO this is probably sub-optimal
m_basicstr_axiom_todo.push_back(en);
}
theory_var theory_str::mk_var(enode* n) {
TRACE("t_str_detail", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;);
- /*
- if (!m_strutil.is_string(n->get_owner())) {
- return null_theory_var;
- }
- */
- // TODO this may require an overhaul of m_strutil.is_string() if things suddenly start working after the following change:
ast_manager & m = get_manager();
if (!(is_sort_of(m.get_sort(n->get_owner()), m_strutil.get_fid(), STRING_SORT))) {
return null_theory_var;
@@ -503,9 +434,6 @@ app * theory_str::mk_int(rational & q) {
return m_autil.mk_numeral(q, true);
}
-
-// TODO refactor all of these so that they don't use variable counters, but use ast_manager::mk_fresh_const instead
-
expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
ast_manager & m = get_manager();
@@ -539,23 +467,6 @@ void theory_str::track_variable_scope(expr * var) {
}
app * theory_str::mk_internal_xor_var() {
- /*
- ast_manager & m = get_manager();
- std::stringstream ss;
- ss << tmpXorVarCount;
- tmpXorVarCount++;
- std::string name = "$$_xor_" + ss.str();
- // Z3_sort r = of_sort(mk_c(c)->m().mk_sort(mk_c(c)->get_arith_fid(), INT_SORT));
- sort * int_sort = m.mk_sort(m_autil.get_family_id(), INT_SORT);
-
- char * new_buffer = alloc_svect(char, name.length() + 1);
- strcpy(new_buffer, name.c_str());
- symbol sym(new_buffer);
-
- app * a = m.mk_const(m.mk_const_decl(sym, int_sort));
- m_trail.push_back(a);
- return a;
- */
return mk_int_var("$$_xor");
}
@@ -1069,7 +980,6 @@ void theory_str::instantiate_concat_axiom(enode * cat) {
// build LHS
expr_ref len_xy(m);
- // TODO should we use str_util for these and other expressions?
len_xy = mk_strlen(a_cat);
SASSERT(len_xy);
@@ -1106,15 +1016,12 @@ void theory_str::instantiate_concat_axiom(enode * cat) {
* Length(x) == strlen(x)
*/
void theory_str::instantiate_basic_string_axioms(enode * str) {
- // TODO keep track of which enodes we have added axioms for, so we don't add the same ones twice?
-
context & ctx = get_context();
ast_manager & m = get_manager();
TRACE("t_str_axiom_bug", tout << "set up basic string axioms on " << mk_pp(str->get_owner(), m) << std::endl;);
// TESTING: attempt to avoid a crash here when a variable goes out of scope
- // TODO this seems to work so we probably need to do this for other propagate checks, etc.
if (str->get_iscope_lvl() > ctx.get_scope_level()) {
TRACE("t_str_detail", tout << "WARNING: skipping axiom setup on out-of-scope string term" << std::endl;);
return;
@@ -2596,7 +2503,6 @@ void theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
literal_vector ls;
for (unsigned i = 0; i < terms.size(); ++i) {
expr * e = terms.get(i);
- // TODO make sure the terms are internalized, etc.?
literal l = ctx.get_literal(e);
ls.push_back(l);
}
@@ -2605,28 +2511,6 @@ void theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
void theory_str::print_cut_var(expr * node, std::ofstream & xout) {
ast_manager & m = get_manager();
- /*
-#ifdef DEBUGLOG
- __debugPrint(logFile, "\n>> CUT info of [");
- printZ3Node(t, node);
- __debugPrint(logFile, "]\n");
-
- if (cut_VARMap.find(node) != cut_VARMap.end()) {
- if (!cut_VARMap[node].empty()) {
- __debugPrint(logFile, "[%2d] {", cut_VARMap[node].top()->level);
- std::map<Z3_ast, int>::iterator itor = cut_VARMap[node].top()->vars.begin();
- for (; itor != cut_VARMap[node].top()->vars.end(); itor++) {
- printZ3Node(t, itor->first);
- __debugPrint(logFile, ", ");
- }
- __debugPrint(logFile, "}\n");
- } else {
-
- }
- }
- __debugPrint(logFile, "------------------------\n\n");
-#endif
-*/
xout << "Cut info of " << mk_pp(node, m) << std::endl;
if (cut_var_map.contains(node)) {
if (!cut_var_map[node].empty()) {
@@ -2924,8 +2808,6 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
expr * m = to_app(new_nn2)->get_arg(0);
expr * n = to_app(new_nn2)->get_arg(1);
- // TODO is it too slow to perform length checks here to avoid false positives?
-
if (has_self_cut(m, y)) {
TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
return true;
@@ -3193,7 +3075,6 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
t2 = varForBreakConcat[key2][1];
xorFlag = varForBreakConcat[key2][2];
}
- // TODO do I need to refresh the xorFlag, which is an integer var, and if so, how?
refresh_theory_var(t1);
add_nonempty_constraint(t1);
refresh_theory_var(t2);
@@ -3252,7 +3133,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- // TODO printCutVar(m, y);
+ TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
}
}
} else if (splitType == 1) {
@@ -3310,7 +3191,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- // TODO printCutVar(m, y);
+ TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
}
}
} else if (splitType == -1) {
@@ -3409,7 +3290,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- // TODO printCutVar(x, n);
+ TRACE("t_str_detail", {print_cut_var(x, tout); print_cut_var(n, tout);});
}
}
@@ -3572,7 +3453,6 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
temp1 = varForBreakConcat[key2][0];
xorFlag = varForBreakConcat[key2][1];
}
- // TODO refresh xorFlag?
refresh_theory_var(temp1);
add_nonempty_constraint(temp1);
}
@@ -4049,7 +3929,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- // TODO printCutVar(x, n);
+ TRACE("t_str_detail", {print_cut_var(x, tout); print_cut_var(n, tout);});
}
}
}
@@ -4129,7 +4009,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
- // TODO printCutVAR(x, n)
+ TRACE("t_str_detail", {print_cut_var(x, tout); print_cut_var(n, tout);});
}
}
}
@@ -4712,26 +4592,6 @@ void theory_str::unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr) {
* Return that constant if it is found, and set hasEqcValue to true.
* Otherwise, return n, and set hasEqcValue to false.
*/
-/*
-expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
- context & ctx = get_context();
- // I hope this works
- ctx.internalize(n, false);
- enode * nNode = ctx.get_enode(n);
- enode * eqcNode = nNode;
- do {
- app * ast = eqcNode->get_owner();
- if (is_string(eqcNode)) {
- hasEqcValue = true;
- return ast;
- }
- eqcNode = eqcNode->get_next();
- } while (eqcNode != nNode);
- // not found
- hasEqcValue = false;
- return n;
-}
-*/
expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
return z3str2_get_eqc_value(n, hasEqcValue);
@@ -6596,8 +6456,6 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
// check the entries in this map to make sure they're still in scope
// before we use them.
- // TODO XOR variables will always show up as "not in scope" because of how we update internal_variable_set
-
std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
@@ -7409,14 +7267,6 @@ void theory_str::push_scope_eh() {
theory::push_scope_eh();
m_trail_stack.push_scope();
- // TODO out-of-scope term debugging, see comment in pop_scope_eh()
- /*
- context & ctx = get_context();
- ast_manager & m = get_manager();
- expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
- */
-
sLevel += 1;
TRACE("t_str", tout << "push to " << sLevel << std::endl;);
TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
@@ -9846,7 +9696,6 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
andList.push_back(and_expr);
}
- // TODO cache mk_string("more")
expr_ref more_option(ctx.mk_eq_atom(indicator, mk_string("more")), m);
orList.push_back(more_option);
// decrease priority of this option
@@ -10558,8 +10407,6 @@ model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
return alloc(expr_wrapper_proc, val);
} else {
TRACE("t_str", tout << "WARNING: failed to find a concrete value, falling back" << std::endl;);
- // TODO make absolutely sure the reason we can't find a concrete value is because of an unassigned temporary
- // e.g. for an expression like (Concat X $$_str0)
return alloc(expr_wrapper_proc, to_app(mk_string("**UNUSED**")));
}
}
From 5ca4f2a1c86604aafb805189406ead9695729663 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 13 Feb 2017 17:15:13 -0500
Subject: [PATCH 330/401] theory_str cleanup
---
src/smt/theory_str.cpp | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 158342cb1..a36a75868 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4576,7 +4576,8 @@ void theory_str::unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr) {
std::string regStrValue = m_strutil.get_string_constant_value(strInStr2RegFunc);
int strLen = strValue.length();
int regStrLen = regStrValue.length();
- int cnt = strLen / regStrLen; // TODO prevent DIV/0 on regStrLen
+ SASSERT(regStrLen != 0); // this should never occur -- the case for empty string is handled elsewhere
+ int cnt = strLen / regStrLen;
expr_ref implyL(ctx.mk_eq_atom(unrollFunc, eqConstStr), m);
expr_ref implyR1(ctx.mk_eq_atom(oriCnt, mk_int(cnt)), m);
@@ -7446,7 +7447,7 @@ void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap
varMap[node] = 1;
}
// check whether the node is a function that we want to inspect
- else if (is_app(node)) { // TODO
+ else if (is_app(node)) {
app * aNode = to_app(node);
if (is_strlen(aNode)) {
// Length
From 52eaae9da0939c193e60bba43df17f47c26e6732 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Feb 2017 15:19:03 -0500
Subject: [PATCH 331/401] theory_str refactor: check_contain_by_eqc_val uses
contain_pair_idx_map
---
src/smt/theory_str.cpp | 224 +++++++++++++++++++++--------------------
1 file changed, 113 insertions(+), 111 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a36a75868..504e0e2fe 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4842,130 +4842,134 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
expr_ref_vector litems(m);
- // TODO refactor to use the new contain_pair_idx_map
+ if (contain_pair_idx_map.find(varNode) != contain_pair_idx_map.end()) {
+ std::set<std::pair<expr*, expr*> >::iterator itor1 = contain_pair_idx_map[varNode].begin();
+ for (; itor1 != contain_pair_idx_map[varNode].end(); ++itor1) {
+ expr * strAst = itor1->first;
+ expr * substrAst = itor1->second;
- expr_ref_vector::iterator itor1 = contains_map.begin();
- for (; itor1 != contains_map.end(); ++itor1) {
- expr * boolVar = *itor1;
- // boolVar is actually a Contains term
- app * containsApp = to_app(boolVar);
- expr * strAst = containsApp->get_arg(0);
- expr * substrAst = containsApp->get_arg(1);
-
- // we only want to inspect the Contains terms where either of strAst or substrAst
- // are equal to varNode.
-
- TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
-
- if (varNode != strAst && varNode != substrAst) {
- TRACE("t_str_detail", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
- continue;
- }
- TRACE("t_str_detail", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
-
- // varEqcNode is str
- if (strAst == varNode) {
- expr_ref implyR(m);
- litems.reset();
-
- if (strAst != constNode) {
- litems.push_back(ctx.mk_eq_atom(strAst, constNode));
+ expr * boolVar;
+ if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
+ TRACE("t_str_detail", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
}
- std::string strConst = m_strutil.get_string_constant_value(constNode);
- bool subStrHasEqcValue = false;
- expr * substrValue = get_eqc_value(substrAst, subStrHasEqcValue);
- if (substrValue != substrAst) {
- litems.push_back(ctx.mk_eq_atom(substrAst, substrValue));
+ // boolVar is actually a Contains term
+ app * containsApp = to_app(boolVar);
+
+ // we only want to inspect the Contains terms where either of strAst or substrAst
+ // are equal to varNode.
+
+ TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
+
+ if (varNode != strAst && varNode != substrAst) {
+ TRACE("t_str_detail", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
+ continue;
}
+ TRACE("t_str_detail", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
- if (subStrHasEqcValue) {
- // subStr has an eqc constant value
- std::string subStrConst = m_strutil.get_string_constant_value(substrValue);
+ // varEqcNode is str
+ if (strAst == varNode) {
+ expr_ref implyR(m);
+ litems.reset();
- TRACE("t_str_detail", tout << "strConst = " << strConst << ", subStrConst = " << subStrConst << std::endl;);
-
- if (strConst.find(subStrConst) != std::string::npos) {
- //implyR = ctx.mk_eq(ctx, boolVar, Z3_mk_true(ctx));
- implyR = boolVar;
- } else {
- //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
- implyR = m.mk_not(boolVar);
+ if (strAst != constNode) {
+ litems.push_back(ctx.mk_eq_atom(strAst, constNode));
}
- } else {
- // ------------------------------------------------------------------------------------------------
- // subStr doesn't have an eqc contant value
- // however, subStr equals to some concat(arg_1, arg_2, ..., arg_n)
- // if arg_j is a constant and is not a part of the strConst, it's sure that the contains is false
- // ** This check is needed here because the "strConst" and "strAst" may not be in a same eqc yet
- // ------------------------------------------------------------------------------------------------
- // collect eqc concat
- std::set<expr*> eqcConcats;
- get_concats_in_eqc(substrAst, eqcConcats);
- for (std::set<expr*>::iterator concatItor = eqcConcats.begin();
- concatItor != eqcConcats.end(); concatItor++) {
- expr_ref_vector constList(m);
- bool counterEgFound = false;
- // get constant strings in concat
- expr * aConcat = *concatItor;
- get_const_str_asts_in_node(aConcat, constList);
- for (expr_ref_vector::iterator cstItor = constList.begin();
- cstItor != constList.end(); cstItor++) {
- std::string pieceStr = m_strutil.get_string_constant_value(*cstItor);
- if (strConst.find(pieceStr) == std::string::npos) {
- counterEgFound = true;
- if (aConcat != substrAst) {
- litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
+ std::string strConst = m_strutil.get_string_constant_value(constNode);
+ bool subStrHasEqcValue = false;
+ expr * substrValue = get_eqc_value(substrAst, subStrHasEqcValue);
+ if (substrValue != substrAst) {
+ litems.push_back(ctx.mk_eq_atom(substrAst, substrValue));
+ }
+
+ if (subStrHasEqcValue) {
+ // subStr has an eqc constant value
+ std::string subStrConst = m_strutil.get_string_constant_value(substrValue);
+
+ TRACE("t_str_detail", tout << "strConst = " << strConst << ", subStrConst = " << subStrConst << std::endl;);
+
+ if (strConst.find(subStrConst) != std::string::npos) {
+ //implyR = ctx.mk_eq(ctx, boolVar, Z3_mk_true(ctx));
+ implyR = boolVar;
+ } else {
+ //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
+ implyR = m.mk_not(boolVar);
+ }
+ } else {
+ // ------------------------------------------------------------------------------------------------
+ // subStr doesn't have an eqc contant value
+ // however, subStr equals to some concat(arg_1, arg_2, ..., arg_n)
+ // if arg_j is a constant and is not a part of the strConst, it's sure that the contains is false
+ // ** This check is needed here because the "strConst" and "strAst" may not be in a same eqc yet
+ // ------------------------------------------------------------------------------------------------
+ // collect eqc concat
+ std::set<expr*> eqcConcats;
+ get_concats_in_eqc(substrAst, eqcConcats);
+ for (std::set<expr*>::iterator concatItor = eqcConcats.begin();
+ concatItor != eqcConcats.end(); concatItor++) {
+ expr_ref_vector constList(m);
+ bool counterEgFound = false;
+ // get constant strings in concat
+ expr * aConcat = *concatItor;
+ get_const_str_asts_in_node(aConcat, constList);
+ for (expr_ref_vector::iterator cstItor = constList.begin();
+ cstItor != constList.end(); cstItor++) {
+ std::string pieceStr = m_strutil.get_string_constant_value(*cstItor);
+ if (strConst.find(pieceStr) == std::string::npos) {
+ counterEgFound = true;
+ if (aConcat != substrAst) {
+ litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
+ }
+ //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
+ implyR = m.mk_not(boolVar);
+ break;
}
- //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
- implyR = m.mk_not(boolVar);
+ }
+ if (counterEgFound) {
+ TRACE("t_str_detail", tout << "Inconsistency found!" << std::endl;);
break;
}
}
- if (counterEgFound) {
- TRACE("t_str_detail", tout << "Inconsistency found!" << std::endl;);
- break;
+ }
+ // add assertion
+ if (implyR) {
+ expr_ref implyLHS(mk_and(litems), m);
+ assert_implication(implyLHS, implyR);
+ }
+ }
+ // varEqcNode is subStr
+ else if (substrAst == varNode) {
+ expr_ref implyR(m);
+ litems.reset();
+
+ if (substrAst != constNode) {
+ litems.push_back(ctx.mk_eq_atom(substrAst, constNode));
+ }
+ bool strHasEqcValue = false;
+ expr * strValue = get_eqc_value(strAst, strHasEqcValue);
+ if (strValue != strAst) {
+ litems.push_back(ctx.mk_eq_atom(strAst, strValue));
+ }
+
+ if (strHasEqcValue) {
+ std::string strConst = m_strutil.get_string_constant_value(strValue);
+ std::string subStrConst = m_strutil.get_string_constant_value(constNode);
+ if (strConst.find(subStrConst) != std::string::npos) {
+ //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_true(ctx));
+ implyR = boolVar;
+ } else {
+ // implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
+ implyR = m.mk_not(boolVar);
}
}
- }
- // add assertion
- if (implyR) {
- expr_ref implyLHS(mk_and(litems), m);
- assert_implication(implyLHS, implyR);
- }
- }
- // varEqcNode is subStr
- else if (substrAst == varNode) {
- expr_ref implyR(m);
- litems.reset();
- if (substrAst != constNode) {
- litems.push_back(ctx.mk_eq_atom(substrAst, constNode));
- }
- bool strHasEqcValue = false;
- expr * strValue = get_eqc_value(strAst, strHasEqcValue);
- if (strValue != strAst) {
- litems.push_back(ctx.mk_eq_atom(strAst, strValue));
- }
-
- if (strHasEqcValue) {
- std::string strConst = m_strutil.get_string_constant_value(strValue);
- std::string subStrConst = m_strutil.get_string_constant_value(constNode);
- if (strConst.find(subStrConst) != std::string::npos) {
- //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_true(ctx));
- implyR = boolVar;
- } else {
- // implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
- implyR = m.mk_not(boolVar);
+ // add assertion
+ if (implyR) {
+ expr_ref implyLHS(mk_and(litems), m);
+ assert_implication(implyLHS, implyR);
}
}
-
- // add assertion
- if (implyR) {
- expr_ref implyLHS(mk_and(litems), m);
- assert_implication(implyLHS, implyR);
- }
- }
- } // for (itor1 : contains_map)
+ } // for (itor1 : contains_map)
+ } // if varNode in contain_pair_idx_map
}
void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass) {
@@ -5782,7 +5786,6 @@ void theory_str::compute_contains(std::map<expr*, expr*> & varAliasMap,
}
bool theory_str::can_concat_eq_str(expr * concat, std::string str) {
- // TODO this method could use some traces and debugging info
int strLen = str.length();
if (is_concat(to_app(concat))) {
ptr_vector<expr> args;
@@ -5834,7 +5837,6 @@ bool theory_str::can_concat_eq_str(expr * concat, std::string str) {
}
bool theory_str::can_concat_eq_concat(expr * concat1, expr * concat2) {
- // TODO this method could use some traces and debugging info
if (is_concat(to_app(concat1)) && is_concat(to_app(concat2))) {
{
// Suppose concat1 = (Concat X Y) and concat2 = (Concat M N).
From 3e714075c48588751a724df4d64176ede3d1d345 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Feb 2017 16:09:45 -0500
Subject: [PATCH 332/401] theory_str refactor: check_contain_by_substr uses
contain_pair_idx_map
---
src/smt/theory_str.cpp | 102 +++++++++++++++++++++--------------------
1 file changed, 53 insertions(+), 49 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 504e0e2fe..37ebc0c93 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4977,67 +4977,71 @@ void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willE
ast_manager & m = get_manager();
expr_ref_vector litems(m);
- // TODO refactor to use the new contain_pair_idx_map
+ if (contain_pair_idx_map.find(varNode) != contain_pair_idx_map.end()) {
+ std::set<std::pair<expr*, expr*> >::iterator itor1 = contain_pair_idx_map[varNode].begin();
+ for (; itor1 != contain_pair_idx_map[varNode].end(); ++itor1) {
+ expr * strAst = itor1->first;
+ expr * substrAst = itor1->second;
- expr_ref_vector::iterator itor1 = contains_map.begin();
- for (; itor1 != contains_map.end(); ++itor1) {
- expr * boolVar = *itor1;
- // boolVar is actually a Contains term
- app * containsApp = to_app(boolVar);
- expr * strAst = containsApp->get_arg(0);
- expr * substrAst = containsApp->get_arg(1);
+ expr * boolVar;
+ if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
+ TRACE("t_str_detail", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
+ }
+ // boolVar is actually a Contains term
+ app * containsApp = to_app(boolVar);
- // we only want to inspect the Contains terms where either of strAst or substrAst
- // are equal to varNode.
+ // we only want to inspect the Contains terms where either of strAst or substrAst
+ // are equal to varNode.
- TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
+ TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
- if (varNode != strAst && varNode != substrAst) {
- TRACE("t_str_detail", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
- continue;
- }
- TRACE("t_str_detail", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
+ if (varNode != strAst && varNode != substrAst) {
+ TRACE("t_str_detail", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
+ continue;
+ }
+ TRACE("t_str_detail", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
- if (substrAst == varNode) {
- bool strAstHasVal = false;
- expr * strValue = get_eqc_value(strAst, strAstHasVal);
- if (strAstHasVal) {
- TRACE("t_str_detail", tout << mk_pp(strAst, m) << " has constant eqc value " << mk_pp(strValue, m) << std::endl;);
- if (strValue != strAst) {
- litems.push_back(ctx.mk_eq_atom(strAst, strValue));
- }
- std::string strConst = m_strutil.get_string_constant_value(strValue);
- // iterate eqc (also eqc-to-be) of substr
- for (expr_ref_vector::iterator itAst = willEqClass.begin(); itAst != willEqClass.end(); itAst++) {
- bool counterEgFound = false;
- if (is_concat(to_app(*itAst))) {
- expr_ref_vector constList(m);
- // get constant strings in concat
- app * aConcat = to_app(*itAst);
- get_const_str_asts_in_node(aConcat, constList);
- for (expr_ref_vector::iterator cstItor = constList.begin();
- cstItor != constList.end(); cstItor++) {
- std::string pieceStr = m_strutil.get_string_constant_value(*cstItor);
- if (strConst.find(pieceStr) == std::string::npos) {
- TRACE("t_str_detail", tout << "Inconsistency found!" << std::endl;);
- counterEgFound = true;
- if (aConcat != substrAst) {
- litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
+ if (substrAst == varNode) {
+ bool strAstHasVal = false;
+ expr * strValue = get_eqc_value(strAst, strAstHasVal);
+ if (strAstHasVal) {
+ TRACE("t_str_detail", tout << mk_pp(strAst, m) << " has constant eqc value " << mk_pp(strValue, m) << std::endl;);
+ if (strValue != strAst) {
+ litems.push_back(ctx.mk_eq_atom(strAst, strValue));
+ }
+ std::string strConst = m_strutil.get_string_constant_value(strValue);
+ // iterate eqc (also eqc-to-be) of substr
+ for (expr_ref_vector::iterator itAst = willEqClass.begin(); itAst != willEqClass.end(); itAst++) {
+ bool counterEgFound = false;
+ if (is_concat(to_app(*itAst))) {
+ expr_ref_vector constList(m);
+ // get constant strings in concat
+ app * aConcat = to_app(*itAst);
+ get_const_str_asts_in_node(aConcat, constList);
+ for (expr_ref_vector::iterator cstItor = constList.begin();
+ cstItor != constList.end(); cstItor++) {
+ std::string pieceStr = m_strutil.get_string_constant_value(*cstItor);
+ if (strConst.find(pieceStr) == std::string::npos) {
+ TRACE("t_str_detail", tout << "Inconsistency found!" << std::endl;);
+ counterEgFound = true;
+ if (aConcat != substrAst) {
+ litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
+ }
+ expr_ref implyLHS(mk_and(litems), m);
+ expr_ref implyR(m.mk_not(boolVar), m);
+ assert_implication(implyLHS, implyR);
+ break;
}
- expr_ref implyLHS(mk_and(litems), m);
- expr_ref implyR(m.mk_not(boolVar), m);
- assert_implication(implyLHS, implyR);
- break;
}
}
- }
- if (counterEgFound) {
- break;
+ if (counterEgFound) {
+ break;
+ }
}
}
}
}
- }
+ } // varNode in contain_pair_idx_map
}
bool theory_str::in_contain_idx_map(expr * n) {
From d5b1e4b015772730f82e751f2212ce482b8bbf85 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Feb 2017 18:44:40 -0500
Subject: [PATCH 333/401] refactor theory_str: all library-aware/high-level
terms are in one worklist
---
src/smt/theory_str.cpp | 104 ++++++++++++-----------------------------
src/smt/theory_str.h | 4 +-
2 files changed, 31 insertions(+), 77 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 37ebc0c93..9fcf1f084 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -805,11 +805,9 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
}
bool theory_str::can_propagate() {
- return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty() || !m_concat_eval_todo.empty()
- || !m_axiom_CharAt_todo.empty() || !m_axiom_StartsWith_todo.empty() || !m_axiom_EndsWith_todo.empty()
- || !m_axiom_Contains_todo.empty() || !m_axiom_Indexof_todo.empty() || !m_axiom_Indexof2_todo.empty() || !m_axiom_LastIndexof_todo.empty()
- || !m_axiom_Substr_todo.empty() || !m_axiom_Replace_todo.empty()
- || !m_axiom_RegexIn_todo.empty() || !m_library_aware_axiom_todo.empty()
+ return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty()
+ || !m_concat_axiom_todo.empty() || !m_concat_eval_todo.empty()
+ || !m_library_aware_axiom_todo.empty()
|| !m_delayed_axiom_setup_terms.empty();
;
}
@@ -842,62 +840,32 @@ void theory_str::propagate() {
}
m_concat_eval_todo.reset();
- for (unsigned i = 0; i < m_axiom_CharAt_todo.size(); ++i) {
- instantiate_axiom_CharAt(m_axiom_CharAt_todo[i]);
- }
- m_axiom_CharAt_todo.reset();
-
- for (unsigned i = 0; i < m_axiom_StartsWith_todo.size(); ++i) {
- instantiate_axiom_StartsWith(m_axiom_StartsWith_todo[i]);
- }
- m_axiom_StartsWith_todo.reset();
-
- for (unsigned i = 0; i < m_axiom_EndsWith_todo.size(); ++i) {
- instantiate_axiom_EndsWith(m_axiom_EndsWith_todo[i]);
- }
- m_axiom_EndsWith_todo.reset();
-
- for (unsigned i = 0; i < m_axiom_Contains_todo.size(); ++i) {
- instantiate_axiom_Contains(m_axiom_Contains_todo[i]);
- }
- m_axiom_Contains_todo.reset();
-
- for (unsigned i = 0; i < m_axiom_Indexof_todo.size(); ++i) {
- instantiate_axiom_Indexof(m_axiom_Indexof_todo[i]);
- }
- m_axiom_Indexof_todo.reset();
-
- for (unsigned i = 0; i < m_axiom_Indexof2_todo.size(); ++i) {
- instantiate_axiom_Indexof2(m_axiom_Indexof2_todo[i]);
- }
- m_axiom_Indexof2_todo.reset();
-
- for (unsigned i = 0; i < m_axiom_LastIndexof_todo.size(); ++i) {
- instantiate_axiom_LastIndexof(m_axiom_LastIndexof_todo[i]);
- }
- m_axiom_LastIndexof_todo.reset();
-
- for (unsigned i = 0; i < m_axiom_Substr_todo.size(); ++i) {
- instantiate_axiom_Substr(m_axiom_Substr_todo[i]);
- }
- m_axiom_Substr_todo.reset();
-
- for (unsigned i = 0; i < m_axiom_Replace_todo.size(); ++i) {
- instantiate_axiom_Replace(m_axiom_Replace_todo[i]);
- }
- m_axiom_Replace_todo.reset();
-
- for (unsigned i = 0; i < m_axiom_RegexIn_todo.size(); ++i) {
- instantiate_axiom_RegexIn(m_axiom_RegexIn_todo[i]);
- }
- m_axiom_RegexIn_todo.reset();
-
for (unsigned i = 0; i < m_library_aware_axiom_todo.size(); ++i) {
enode * e = m_library_aware_axiom_todo[i];
if (is_str_to_int(e)) {
instantiate_axiom_str_to_int(e);
} else if (is_int_to_str(e)) {
instantiate_axiom_int_to_str(e);
+ } else if (is_CharAt(e)) {
+ instantiate_axiom_CharAt(e);
+ } else if (is_StartsWith(e)) {
+ instantiate_axiom_StartsWith(e);
+ } else if (is_EndsWith(e)) {
+ instantiate_axiom_EndsWith(e);
+ } else if (is_Contains(e)) {
+ instantiate_axiom_Contains(e);
+ } else if (is_Indexof(e)) {
+ instantiate_axiom_Indexof(e);
+ } else if (is_Indexof2(e)) {
+ instantiate_axiom_Indexof2(e);
+ } else if (is_LastIndexof(e)) {
+ instantiate_axiom_LastIndexof(e);
+ } else if (is_Substr(e)) {
+ instantiate_axiom_Substr(e);
+ } else if (is_Replace(e)) {
+ instantiate_axiom_Replace(e);
+ } else if (is_RegexIn(e)) {
+ instantiate_axiom_RegexIn(e);
} else {
TRACE("t_str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_owner(), get_manager()) << std::endl;);
NOT_IMPLEMENTED_YET();
@@ -7099,12 +7067,8 @@ void theory_str::set_up_axioms(expr * ex) {
if (aVar->get_num_args() == 0 && !is_string(aVar)) {
input_var_in_len.insert(var);
}
- } else if (is_CharAt(ap)) {
- m_axiom_CharAt_todo.push_back(n);
- } else if (is_Substr(ap)) {
- m_axiom_Substr_todo.push_back(n);
- } else if (is_Replace(ap)) {
- m_axiom_Replace_todo.push_back(n);
+ } else if (is_CharAt(ap) || is_Substr(ap) || is_Replace(ap)) {
+ m_library_aware_axiom_todo.push_back(n);
} else if (ap->get_num_args() == 0 && !is_string(ap)) {
// if ex is a variable, add it to our list of variables
TRACE("t_str_detail", tout << "tracking variable " << mk_ismt2_pp(ap, get_manager()) << std::endl;);
@@ -7127,14 +7091,8 @@ void theory_str::set_up_axioms(expr * ex) {
if (is_app(ex)) {
app * ap = to_app(ex);
- if (is_StartsWith(ap)) {
- m_axiom_StartsWith_todo.push_back(n);
- } else if (is_EndsWith(ap)) {
- m_axiom_EndsWith_todo.push_back(n);
- } else if (is_Contains(ap)) {
- m_axiom_Contains_todo.push_back(n);
- } else if (is_RegexIn(ap)) {
- m_axiom_RegexIn_todo.push_back(n);
+ if (is_StartsWith(ap) || is_EndsWith(ap) || is_Contains(ap) || is_RegexIn(ap)) {
+ m_library_aware_axiom_todo.push_back(n);
}
}
} else {
@@ -7152,12 +7110,8 @@ void theory_str::set_up_axioms(expr * ex) {
if (is_app(ex)) {
app * ap = to_app(ex);
- if (is_Indexof(ap)) {
- m_axiom_Indexof_todo.push_back(n);
- } else if (is_Indexof2(ap)) {
- m_axiom_Indexof2_todo.push_back(n);
- } else if (is_LastIndexof(ap)) {
- m_axiom_LastIndexof_todo.push_back(n);
+ if (is_Indexof(ap) || is_Indexof2(ap) || is_LastIndexof(ap)) {
+ m_library_aware_axiom_todo.push_back(n);
} else if (is_str_to_int(ap) || is_int_to_str(ap)) {
string_int_conversion_terms.push_back(ap);
m_library_aware_axiom_todo.push_back(n);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 97f2b9fa4..1915763f1 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -210,7 +210,7 @@ namespace smt {
ptr_vector<enode> m_concat_eval_todo;
// enode lists for term-specific axioms
- // TODO maybe refactor this into a generic "library_aware_axiom_todo" list
+ /*
ptr_vector<enode> m_axiom_CharAt_todo;
ptr_vector<enode> m_axiom_StartsWith_todo;
ptr_vector<enode> m_axiom_EndsWith_todo;
@@ -221,8 +221,8 @@ namespace smt {
ptr_vector<enode> m_axiom_Substr_todo;
ptr_vector<enode> m_axiom_Replace_todo;
ptr_vector<enode> m_axiom_RegexIn_todo;
+ */
- // TODO refactor everything to use this worklist
ptr_vector<enode> m_library_aware_axiom_todo;
// hashtable of all exprs for which we've already set up term-specific axioms --
From f9b3c47bf513672f0dcf76c202e8cd7d6b509aa1 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 14 Feb 2017 18:45:09 -0500
Subject: [PATCH 334/401] remove commented-out old worklists
---
src/smt/theory_str.h | 15 +--------------
1 file changed, 1 insertion(+), 14 deletions(-)
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 1915763f1..47a8e8d0b 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -209,20 +209,7 @@ namespace smt {
ptr_vector<enode> m_string_constant_length_todo;
ptr_vector<enode> m_concat_eval_todo;
- // enode lists for term-specific axioms
- /*
- ptr_vector<enode> m_axiom_CharAt_todo;
- ptr_vector<enode> m_axiom_StartsWith_todo;
- ptr_vector<enode> m_axiom_EndsWith_todo;
- ptr_vector<enode> m_axiom_Contains_todo;
- ptr_vector<enode> m_axiom_Indexof_todo;
- ptr_vector<enode> m_axiom_Indexof2_todo;
- ptr_vector<enode> m_axiom_LastIndexof_todo;
- ptr_vector<enode> m_axiom_Substr_todo;
- ptr_vector<enode> m_axiom_Replace_todo;
- ptr_vector<enode> m_axiom_RegexIn_todo;
- */
-
+ // enode lists for library-aware/high-level string terms (e.g. substr, contains)
ptr_vector<enode> m_library_aware_axiom_todo;
// hashtable of all exprs for which we've already set up term-specific axioms --
From d67f732c7cf4a62f3b0d7a992d5096b69e7f6bf6 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 15 Feb 2017 13:39:55 -0500
Subject: [PATCH 335/401] theory_str data structure refactoring
---
src/smt/theory_str.cpp | 6 +++---
src/smt/theory_str.h | 7 +++----
2 files changed, 6 insertions(+), 7 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 9fcf1f084..da6f94afe 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -6606,7 +6606,7 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
}
} else {
bool map_effectively_empty = false;
- if (fvar_len_count_map.find(v) == fvar_len_count_map.end()) {
+ if (!fvar_len_count_map.contains(v)) {
map_effectively_empty = true;
}
@@ -6701,7 +6701,7 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
void theory_str::more_len_tests(expr * lenTester, std::string lenTesterValue) {
ast_manager & m = get_manager();
- if (lenTester_fvar_map.find(lenTester) != lenTester_fvar_map.end()) {
+ if (lenTester_fvar_map.contains(lenTester)) {
expr * fVar = lenTester_fvar_map[lenTester];
expr * toAssert = gen_len_val_options_for_free_var(fVar, lenTester, lenTesterValue);
TRACE("t_str_detail", tout << "asserting more length tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
@@ -9952,7 +9952,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
return binary_search_length_test(freeVar, lenTesterInCbEq, lenTesterValue);
} else {
bool map_effectively_empty = false;
- if (fvar_len_count_map.find(freeVar) == fvar_len_count_map.end()) {
+ if (!fvar_len_count_map.contains(freeVar)) {
TRACE("t_str_detail", tout << "fvar_len_count_map is empty" << std::endl;);
map_effectively_empty = true;
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 47a8e8d0b..f81b4ada7 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -195,7 +195,6 @@ namespace smt {
bool finalCheckProgressIndicator;
- // TODO make sure that all generated expressions are saved into the trail
expr_ref_vector m_trail; // trail for generated terms
str_value_factory * m_factory;
@@ -236,11 +235,11 @@ namespace smt {
obj_hashtable<expr> internal_valTest_vars;
obj_hashtable<expr> internal_unrollTest_vars;
- std::set<expr*> input_var_in_len;
+ obj_hashtable<expr> input_var_in_len;
- std::map<expr*, unsigned int> fvar_len_count_map;
+ obj_map<expr, unsigned int> fvar_len_count_map;
std::map<expr*, ptr_vector<expr> > fvar_lenTester_map;
- std::map<expr*, expr*> lenTester_fvar_map;
+ obj_map<expr, expr*> lenTester_fvar_map;
std::map<expr*, std::map<int, svector<std::pair<int, expr*> > > > fvar_valueTester_map;
std::map<expr*, expr*> valueTester_fvar_map;
From 2e27e1cd366746113ff1717fce8a19bdd9953bf4 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 15 Feb 2017 16:08:54 -0500
Subject: [PATCH 336/401] fix obj_map insertions theory_str
---
src/smt/theory_str.cpp | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index da6f94afe..3673d3e79 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -9981,7 +9981,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
// no length assertions for this free variable have ever been added.
TRACE("t_str_detail", tout << "no length assertions yet" << std::endl;);
- fvar_len_count_map[freeVar] = 1;
+ fvar_len_count_map.insert(freeVar, 1);
unsigned int testNum = fvar_len_count_map[freeVar];
expr_ref indicator(mk_internal_lenTest_var(freeVar, testNum), m);
@@ -9990,7 +9990,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
// since the map is "effectively empty", we can remove those variables that have left scope...
fvar_lenTester_map[freeVar].shrink(0);
fvar_lenTester_map[freeVar].push_back(indicator);
- lenTester_fvar_map[indicator] = freeVar;
+ lenTester_fvar_map.insert(indicator, freeVar);
expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
SASSERT(lenTestAssert != NULL);
@@ -10089,7 +10089,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
testNum = fvar_len_count_map[freeVar];
indicator = mk_internal_lenTest_var(freeVar, testNum);
fvar_lenTester_map[freeVar].push_back(indicator);
- lenTester_fvar_map[indicator] = freeVar;
+ lenTester_fvar_map.insert(indicator, freeVar);
} else {
// TODO make absolutely sure this is safe to do if 'indicator' is technically out of scope
indicator = fvar_lenTester_map[freeVar][i];
From 90705cfd5f3ebba397e029735d2979f40366909b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 17 Feb 2017 13:28:52 -0500
Subject: [PATCH 337/401] remove todo from str api
---
src/api/api_str.cpp | 1 -
1 file changed, 1 deletion(-)
diff --git a/src/api/api_str.cpp b/src/api/api_str.cpp
index 1a1debb5b..eb56a839b 100644
--- a/src/api/api_str.cpp
+++ b/src/api/api_str.cpp
@@ -81,7 +81,6 @@ extern "C" {
MK_UNARY(Z3_mk_str_length, mk_c(c)->get_str_fid(), OP_STRLEN, SKIP);
MK_BINARY(Z3_mk_str_at, mk_c(c)->get_str_fid(), OP_STR_CHARAT, SKIP);
// translate prefixof/suffixof to StartsWith/EndsWith
- // TODO string standardization might just remove StartsWith/EndsWith in future
Z3_ast Z3_API Z3_mk_str_prefixof(Z3_context c, Z3_ast pre, Z3_ast full) {
LOG_Z3_mk_str_prefixof(c, pre, full);
Z3_TRY;
From fe1a976c21778c088f1e59c77cad87497055d663 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 18 Feb 2017 15:25:04 -0500
Subject: [PATCH 338/401] fix merge remnant
---
src/cmd_context/cmd_context.cpp | 32 +-------------------------------
1 file changed, 1 insertion(+), 31 deletions(-)
diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp
index 4f1458318..dc66f5da9 100644
--- a/src/cmd_context/cmd_context.cpp
+++ b/src/cmd_context/cmd_context.cpp
@@ -528,39 +528,13 @@ bool cmd_context::logic_has_pb() const {
}
bool cmd_context::logic_has_fpa() const {
-<<<<<<< HEAD
- return !has_logic() || logic_has_fpa_core(m_logic);
+ return !has_logic() || smt_logics::logic_has_fpa(m_logic);
}
bool cmd_context::logic_has_str() const {
return !has_logic() || m_logic == "QF_S";
}
-bool cmd_context::logic_has_array_core(symbol const & s) const {
- return
- s == "QF_AX" ||
- s == "QF_AUFLIA" ||
- s == "QF_ANIA" ||
- s == "QF_ALIA" ||
- s == "QF_AUFLIRA" ||
- s == "QF_AUFNIA" ||
- s == "QF_AUFNIRA" ||
- s == "ALIA" ||
- s == "AUFLIA" ||
- s == "AUFLIRA" ||
- s == "AUFNIA" ||
- s == "AUFNIRA" ||
- s == "AUFBV" ||
- s == "ABV" ||
- s == "QF_ABV" ||
- s == "QF_AUFBV" ||
- s == "HORN";
-=======
- return !has_logic() || smt_logics::logic_has_fpa(m_logic);
->>>>>>> upstream-master
-}
-
-
bool cmd_context::logic_has_array() const {
return !has_logic() || smt_logics::logic_has_array(m_logic);
}
@@ -601,12 +575,8 @@ void cmd_context::init_manager_core(bool new_manager) {
load_plugin(symbol("datatype"), logic_has_datatype(), fids);
load_plugin(symbol("seq"), logic_has_seq(), fids);
load_plugin(symbol("fpa"), logic_has_fpa(), fids);
-<<<<<<< HEAD
load_plugin(symbol("str"), logic_has_str(), fids);
-=======
load_plugin(symbol("pb"), logic_has_pb(), fids);
-
->>>>>>> upstream-master
svector<family_id>::iterator it = fids.begin();
svector<family_id>::iterator end = fids.end();
for (; it != end; ++it) {
From a081d819413449e73166941cb60758aa0ebd936c Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 20 Feb 2017 13:27:36 -0500
Subject: [PATCH 339/401] remove local dev files from gitignore
---
.gitignore | 7 -------
1 file changed, 7 deletions(-)
diff --git a/.gitignore b/.gitignore
index a5c9c7e66..7cc289168 100644
--- a/.gitignore
+++ b/.gitignore
@@ -87,10 +87,3 @@ src/*/*/*/CMakeLists.txt
src/api/dotnet/cmake_install_gac.cmake.in
src/api/dotnet/cmake_uninstall_gac.cmake.in
-# reference code for z3str2
-Z3-str
-Z3-str/**
-# test cases
-tests
-tests/**
-
From 15e3d3ec3ce8e3547b291b699963a26413b45a1b Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 21 Feb 2017 15:51:08 -0500
Subject: [PATCH 340/401] octal escape theory_str
---
src/ast/str_decl_plugin.cpp | 25 +++++++++++++++++++++++--
1 file changed, 23 insertions(+), 2 deletions(-)
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index ea539c0c6..80493f3cf 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -414,8 +414,29 @@ app * str_util::mk_string_with_escape_characters(std::string & val) {
parsedStr.push_back(convChar);
} else if (escapeChar1 == '0' || escapeChar1 == '1' || escapeChar1 == '2' || escapeChar1 == '3' ||
escapeChar1 == '4' || escapeChar1 == '5' || escapeChar1 == '6' || escapeChar1 == '7') {
- // TODO octal escape
- NOT_IMPLEMENTED_YET();
+ // octal escape: we expect exactly three octal digits
+ // which means that val[i], val[i+1], val[i+2] must all be octal digits
+ // and that i+2 must be a valid index
+ if (i+2 >= val.length()) {
+ get_manager().raise_exception("invalid octal escape: exactly three octal digits required");
+ }
+ char c2 = escapeChar1;
+ char c1 = val.at(i+1);
+ char c0 = val.at(i+2);
+ i += 2;
+
+ if (!isdigit(c2) || !isdigit(c1) || !isdigit(c0)) {
+ get_manager().raise_exception("invalid octal escape: exactly three octal digits required");
+ }
+
+ if (c2 == '8' || c2 == '9' || c1 == '8' || c1 == '9' || c0 == '8' || c0 == '9') {
+ get_manager().raise_exception("invalid octal escape: exactly three octal digits required");
+ }
+
+ char tmp[4] = {c2, c1, c0, '\0'};
+ long converted = strtol(tmp, NULL, 8);
+ unsigned char convChar = (unsigned char)converted;
+ parsedStr.push_back(convChar);
} else {
// unrecognized escape sequence -- just emit that character
parsedStr.push_back(escapeChar1);
From 179b0f763095201bda085456bb05d2fa209b298a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 21 Feb 2017 19:52:27 -0500
Subject: [PATCH 341/401] clean up todos theory_str
---
src/ast/rewriter/str_rewriter.cpp | 5 --
src/smt/theory_str.cpp | 109 +++++-------------------------
src/smt/theory_str.h | 4 --
3 files changed, 17 insertions(+), 101 deletions(-)
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 3926e66e1..045d06b97 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -38,7 +38,6 @@ void nfa::convert_re(expr * e, unsigned & start, unsigned & end, str_util & m_st
std::string str = m_strutil.get_string_constant_value(arg_str);
TRACE("t_str_rw", tout << "build NFA for '" << str << "'" << std::endl;);
- // TODO this assumes the string is not empty
/*
* For an n-character string, we make (n-1) intermediate states,
* labelled i_(0) through i_(n-2).
@@ -219,7 +218,6 @@ br_status str_rewriter::mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & resul
result = m_strutil.mk_string(resultStr);
return BR_DONE;
} else {
- // TODO if we ever figure out how to assert axioms in here, add the axiom code from Z3str2's strAstReduce.cpp
return BR_FAILED;
}
}
@@ -399,7 +397,6 @@ br_status str_rewriter::mk_str_to_int(expr * arg0, expr_ref & result) {
// interpret str as a natural number and rewrite to the corresponding integer.
// if this is not valid, rewrite to -1
- // TODO leading zeroes?
rational convertedRepresentation(0);
rational ten(10);
for (unsigned i = 0; i < str.length(); ++i) {
@@ -692,13 +689,11 @@ br_status str_rewriter::mk_eq_core(expr * l, expr * r, expr_ref & result) {
}
bool str_rewriter::reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change) {
- // TODO inspect seq_rewriter::reduce_eq()
change = false;
return true;
}
bool str_rewriter::reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change) {
- // TODO inspect seq_rewriter::reduce_eq()
change = false;
return true;
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 3673d3e79..84295940a 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -549,7 +549,6 @@ app * theory_str::mk_regex_rep_var() {
TRACE("t_str_axiom_bug", tout << "add " << mk_pp(a, m) << " to m_basicstr_axiom_todo" << std::endl;);
m_trail.push_back(a);
- // TODO cross-check which variable sets we need
variable_set.insert(a);
//internal_variable_set.insert(a);
regex_variable_set.insert(a);
@@ -1215,7 +1214,6 @@ void theory_str::instantiate_axiom_Contains(enode * e) {
// quick path, because this is necessary due to rewriter behaviour
// (at minimum it should fix z3str/concat-006.smt2
- // TODO: see if it's necessary for other such terms
if (m_strutil.is_string(ex->get_arg(0)) && m_strutil.is_string(ex->get_arg(1))) {
TRACE("t_str_detail", tout << "eval constant Contains term " << mk_pp(ex, m) << std::endl;);
std::string haystackStr = m_strutil.get_string_constant_value(ex->get_arg(0));
@@ -1541,7 +1539,6 @@ void theory_str::instantiate_axiom_Substr(enode * e) {
expr_ref ts0_contains_ts1(mk_contains(expr->get_arg(0), ts1), m);
expr_ref_vector and_item(m);
- // TODO simulate this contains check; it causes problems with a few regressions but we might need it for performance
//and_item.push_back(ts0_contains_ts1);
and_item.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, mk_concat(ts1, ts2))));
and_item.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_strlen(ts0)));
@@ -1782,7 +1779,6 @@ void theory_str::reset_eh() {
m_basicstr_axiom_todo.reset();
m_str_eq_todo.reset();
m_concat_axiom_todo.reset();
- // TODO reset a loooooot more internal stuff
pop_scope_eh(get_context().get_scope_level());
}
@@ -2377,7 +2373,7 @@ void theory_str::infer_len_concat_arg(expr * n, rational len) {
if (arg0Len.is_nonneg()) {
axr = ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0Len));
} else {
- // TODO negate?
+ // could negate
}
} else if (arg0_len_exists && !arg1_len_exists) {
//if (mk_length(t, arg0) != mk_int(ctx, arg0_len)) {
@@ -2388,7 +2384,7 @@ void theory_str::infer_len_concat_arg(expr * n, rational len) {
if (arg1Len.is_nonneg()) {
axr = ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len));
} else {
- // TODO negate?
+ // could negate
}
} else {
@@ -3252,7 +3248,6 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
} else {
loopDetected = true;
if (m_params.m_FiniteOverlapModels) {
- // TODO this might repeat the case above, we may wish to avoid doing this twice
expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
arrangement_disjunction.push_back(tester);
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
@@ -5556,7 +5551,7 @@ void theory_str::get_grounded_concats(expr* node, std::map<expr*, expr*> & varAl
else {
std::vector<expr*> concatNodes;
concatNodes.push_back(node);
- groundedMap[node][concatNodes]; // TODO ???
+ groundedMap[node][concatNodes];
}
}
}
@@ -6653,7 +6648,6 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
v_lower_bound == rational::zero();
} else if (lower_bound_exists && !upper_bound_exists) {
// check some finite portion of the search space
- // TODO here and below, factor out the increment to a param
v_upper_bound = v_lower_bound + rational(10);
} else {
// no bounds information
@@ -6678,7 +6672,6 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
expr_ref_vector andList(m);
for (rational l = v_lower_bound; l <= v_upper_bound; l += rational::one()) {
- // TODO integrate with the enhancements in gen_len_test_options()
std::string lStr = l.to_string();
expr_ref str_indicator(m_strutil.mk_string(lStr), m);
expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
@@ -6718,7 +6711,6 @@ void theory_str::more_value_tests(expr * valTester, std::string valTesterValue)
if (m_params.m_UseBinarySearch) {
if (!binary_search_len_tester_stack.contains(fVar) || binary_search_len_tester_stack[fVar].empty()) {
TRACE("t_str_binary_search", tout << "WARNING: no active length testers for " << mk_pp(fVar, m) << std::endl;);
- // TODO handle this?
NOT_IMPLEMENTED_YET();
}
expr * effectiveLenInd = binary_search_len_tester_stack[fVar].back();
@@ -6803,7 +6795,6 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
/* // temporarily disabled, we are borrowing these testers for something else
if (m_params.m_FiniteOverlapModels && !finite_model_test_varlists.empty()) {
- // TODO NEXT
if (finite_model_test_varlists.contains(lhs)) {
finite_model_test(lhs, rhs); return;
} else if (finite_model_test_varlists.contains(rhs)) {
@@ -6879,8 +6870,6 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
}
}
- // TODO some setup with haveEQLength() which I skip for now, not sure if necessary
-
instantiate_str_eq_length_axiom(ctx.get_enode(lhs), ctx.get_enode(rhs));
// group terms by equivalence class (groupNodeInEqc())
@@ -7291,7 +7280,6 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
sLevel -= num_scopes;
TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
- // TODO: figure out what's going out of scope and why
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -7315,7 +7303,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
TRACE("t_str_cut_var_map", tout << "remove cut info for " << mk_pp(e, m) << std::endl; print_cut_var(e, tout););
T_cut * aCut = val.top();
val.pop();
- // dealloc(aCut); // TODO find a safer way to do this, it is causing a crash
+ // dealloc(aCut);
}
if (val.size() == 0) {
cutvarmap_removes.insert(varItor->m_key);
@@ -7331,30 +7319,6 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
}
}
- /*
- // see if any internal variables went out of scope
- for (int check_level = sLevel + num_scopes ; check_level > sLevel; --check_level) {
- TRACE("t_str_detail", tout << "cleaning up internal variables at scope level " << check_level << std::endl;);
- std::map<int, std::set<expr*> >::iterator it = internal_variable_scope_levels.find(check_level);
- if (it != internal_variable_scope_levels.end()) {
- unsigned count = 0;
- std::set<expr*> vars = it->second;
- for (std::set<expr*>::iterator var_it = vars.begin(); var_it != vars.end(); ++var_it) {
- TRACE("t_str_detail", tout << "clean up variable " << mk_pp(*var_it, get_manager()) << std::endl;);
- variable_set.erase(*var_it);
- internal_variable_set.erase(*var_it);
- regex_variable_set.erase(*var_it);
- internal_unrollTest_vars.erase(*var_it);
- count += 1;
- }
- TRACE("t_str_detail", tout << "cleaned up " << count << " variables" << std::endl;);
- vars.clear();
- }
- }
- */
-
- // TODO use the trail stack to do this for us! requires lots of refactoring
- // TODO if this works, possibly remove axioms from other vectors as well
ptr_vector<enode> new_m_basicstr;
for (ptr_vector<enode>::iterator it = m_basicstr_axiom_todo.begin(); it != m_basicstr_axiom_todo.end(); ++it) {
enode * e = *it;
@@ -7732,7 +7696,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
expr * aRoot = NULL;
expr * curr = varItor->first;
do {
- if (variable_set.find(curr) != variable_set.end()) { // TODO internal_variable_set?
+ if (variable_set.find(curr) != variable_set.end()) {
if (aRoot == NULL) {
aRoot = curr;
} else {
@@ -8280,7 +8244,6 @@ bool theory_str::finalcheck_str2int(app * a) {
TRACE("t_str_detail", tout << "integer theory has no assignment for " << mk_pp(a, m) << std::endl;);
NOT_IMPLEMENTED_YET();
}
- // TODO also check assignment in string theory
return axiomAdd;
}
@@ -8303,7 +8266,6 @@ bool theory_str::finalcheck_int2str(app * a) {
// ignore this. we should already assert the axiom for what happens when the string is ""
} else {
// nonempty string --> convert to correct integer value, or disallow it
- // TODO think about whether we need to persist the axiom in this case?
rational convertedRepresentation(0);
rational ten(10);
bool conversionOK = true;
@@ -8341,7 +8303,6 @@ bool theory_str::finalcheck_int2str(app * a) {
TRACE("t_str_detail", tout << "string theory has no assignment for " << mk_pp(a, m) << std::endl;);
NOT_IMPLEMENTED_YET();
}
- // TODO also check assignment in integer theory
return axiomAdd;
}
@@ -8503,7 +8464,6 @@ final_check_status theory_str::final_check_eh() {
context & ctx = get_context();
ast_manager & m = get_manager();
- // TODO out-of-scope term debugging, see comment in pop_scope_eh()
expr_ref_vector assignments(m);
ctx.get_assignments(assignments);
@@ -8811,7 +8771,6 @@ final_check_status theory_str::final_check_eh() {
expr * freeVar = freeVarItor1->first;
rational lenValue;
bool lenValue_exists = get_len_value(freeVar, lenValue);
- // TODO get_bound_strlen()
tout << mk_pp(freeVar, m) << " [depCnt = " << freeVarItor1->second << ", length = "
<< (lenValue_exists ? lenValue.to_string() : "?")
<< "]" << std::endl;
@@ -8842,7 +8801,6 @@ final_check_status theory_str::final_check_eh() {
continue;
}
*/
- // TODO if this variable represents a regular expression, continue
expr * toAssert = gen_len_val_options_for_free_var(freeVar, NULL, "");
if (toAssert != NULL) {
assert_axiom(toAssert);
@@ -9026,12 +8984,10 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
// ----------------------------------------------------------------------------------------
- // TODO refactor this and below to use expr_ref_vector instead of ptr_vector/svect
ptr_vector<expr> orList;
ptr_vector<expr> andList;
for (long long i = l; i < h; i++) {
- // TODO can we share the val_indicator constants with the length tester cache?
orList.push_back(m.mk_eq(val_indicator, mk_string(longlong_to_string(i).c_str()) ));
if (m_params.m_AggressiveValueTesting) {
literal l = mk_eq(val_indicator, mk_string(longlong_to_string(i).c_str()), false);
@@ -9448,7 +9404,6 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
// handle out-of-scope entries in unroll_tries_map
ptr_vector<expr> outOfScopeTesters;
- // TODO refactor unroll_tries_map and internal_unrollTest_vars to use m_trail_stack
for (ptr_vector<expr>::iterator it = unroll_tries_map[var][unrolls].begin();
it != unroll_tries_map[var][unrolls].end(); ++it) {
@@ -9807,10 +9762,8 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
lastTesterConstant = previousLenTesterValue;
TRACE("t_str_binary_search", tout << "invoked with previousLenTester info matching top of stack" << std::endl;);
} else {
- // this is a bit unexpected
TRACE("t_str_binary_search", tout << "WARNING: unexpected reordering of length testers!" << std::endl;);
- // TODO resolve this case
- NOT_IMPLEMENTED_YET(); return NULL;
+ UNREACHABLE(); return NULL;
}
} else {
lastTesterConstant = m_strutil.get_string_constant_value(lastTesterValue);
@@ -9822,8 +9775,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
if (!binary_search_len_tester_info.find(lastTester, lastBounds)) {
// unexpected
TRACE("t_str_binary_search", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
- // TODO resolve this
- NOT_IMPLEMENTED_YET();
+ UNREACHABLE();
}
TRACE("t_str_binary_search", tout << "last bounds are [" << lastBounds.lowerBound << " | " << lastBounds.midPoint << " | " << lastBounds.upperBound << "]!" << lastBounds.windowSize << std::endl;);
binary_search_info newBounds;
@@ -9833,13 +9785,12 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
// we double the window size and adjust the bounds
if (lastBounds.midPoint == lastBounds.upperBound && lastBounds.upperBound == lastBounds.windowSize) {
TRACE("t_str_binary_search", tout << "search hit window size; expanding" << std::endl;);
- // TODO is this correct?
newBounds.lowerBound = lastBounds.windowSize + rational::one();
newBounds.windowSize = lastBounds.windowSize * rational(2);
newBounds.upperBound = newBounds.windowSize;
newBounds.calculate_midpoint();
} else if (false) {
- // TODO handle the case where the midpoint can't be increased further
+ // handle the case where the midpoint can't be increased further
// (e.g. a window like [50 | 50 | 50]!64 and we don't answer "50")
} else {
// general case
@@ -9855,7 +9806,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
refresh_theory_var(newTester);
} else if (lastTesterConstant == "less") {
if (false) {
- // TODO handle the case where the midpoint can't be decreased further
+ // handle the case where the midpoint can't be decreased further
// (e.g. a window like [0 | 0 | 0]!64 and we don't answer "0"
} else {
// general case
@@ -9888,8 +9839,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
if (!binary_search_len_tester_info.find(lastTester, lastBounds)) {
// unexpected
TRACE("t_str_binary_search", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
- // TODO resolve this
- NOT_IMPLEMENTED_YET();
+ UNREACHABLE();
}
if (lastBounds.midPoint.is_neg()) {
TRACE("t_str_binary_search", tout << "WARNING: length search converged on a negative value. Negating this constraint." << std::endl;);
@@ -9960,7 +9910,6 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
if (!map_effectively_empty) {
// check whether any entries correspond to variables that went out of scope;
// if every entry is out of scope then the map counts as being empty
- // TODO: maybe remove them from the map instead? either here or in pop_scope_eh()
// assume empty and find a counterexample
map_effectively_empty = true;
@@ -10059,7 +10008,6 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
if (effectiveHasEqcValue) {
effectiveLenIndiStr = m_strutil.get_string_constant_value(effective_eqc_value);
} else {
- // TODO this should be unreachable, but can we really do anything here?
NOT_IMPLEMENTED_YET();
}
}
@@ -10091,7 +10039,6 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
fvar_lenTester_map[freeVar].push_back(indicator);
lenTester_fvar_map.insert(indicator, freeVar);
} else {
- // TODO make absolutely sure this is safe to do if 'indicator' is technically out of scope
indicator = fvar_lenTester_map[freeVar][i];
refresh_theory_var(indicator);
testNum = i + 1;
@@ -10211,35 +10158,13 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
}
}
- // TODO here's a great place for debugging info
-
- // testing: iterate over leafVarSet deterministically
- if (false) {
- // *** TESTING CODE
- std::vector<expr*> sortedLeafVarSet;
- for (std::set<expr*>::iterator itor1 = leafVarSet.begin(); itor1 != leafVarSet.end(); ++itor1) {
- sortedLeafVarSet.push_back(*itor1);
- }
- std::sort(sortedLeafVarSet.begin(), sortedLeafVarSet.end(), cmpvarnames);
- for(std::vector<expr*>::iterator itor1 = sortedLeafVarSet.begin();
- itor1 != sortedLeafVarSet.end(); ++itor1) {
- expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
- // gen_len_val_options_for_free_var() can legally return NULL,
- // as methods that it calls may assert their own axioms instead.
- if (toAssert != NULL) {
- assert_axiom(toAssert);
- }
- }
- } else {
- // *** CODE FROM BEFORE
- for(std::set<expr*>::iterator itor1 = leafVarSet.begin();
- itor1 != leafVarSet.end(); ++itor1) {
- expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
- // gen_len_val_options_for_free_var() can legally return NULL,
- // as methods that it calls may assert their own axioms instead.
- if (toAssert != NULL) {
- assert_axiom(toAssert);
- }
+ for(std::set<expr*>::iterator itor1 = leafVarSet.begin();
+ itor1 != leafVarSet.end(); ++itor1) {
+ expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
+ // gen_len_val_options_for_free_var() can legally return NULL,
+ // as methods that it calls may assert their own axioms instead.
+ if (toAssert != NULL) {
+ assert_axiom(toAssert);
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index f81b4ada7..6b1ce9023 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -30,8 +30,6 @@ Revision History:
#include"str_rewriter.h"
#include"union_find.h"
-// TODO refactor: anything that returns an expr* instead returns an expr_ref
-
namespace smt {
class str_value_factory : public value_factory {
@@ -256,7 +254,6 @@ namespace smt {
theory_str_contain_pair_bool_map_t contain_pair_bool_map;
//obj_map<expr, obj_pair_set<expr, expr> > contain_pair_idx_map;
- // TODO Find a better data structure, this is 100% a hack right now
std::map<expr*, std::set<std::pair<expr*, expr*> > > contain_pair_idx_map;
std::map<std::pair<expr*, std::string>, expr*> regex_in_bool_map;
@@ -458,7 +455,6 @@ namespace smt {
void check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass);
void check_contain_by_eq_nodes(expr * n1, expr * n2);
bool in_contain_idx_map(expr * n);
- // TODO refactor these methods to use expr_ref_vector instead of std::vector
void compute_contains(std::map<expr*, expr*> & varAliasMap,
std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr *> & varConstMap,
std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap);
From cff7c450c381067402334cb8f10482f9f78cbaba Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 23 Feb 2017 14:57:48 -0500
Subject: [PATCH 342/401] refactor: uint_set
---
src/smt/smt_context.h | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/src/smt/smt_context.h b/src/smt/smt_context.h
index edc122bd6..e23ecaf43 100644
--- a/src/smt/smt_context.h
+++ b/src/smt/smt_context.h
@@ -230,8 +230,7 @@ namespace smt {
// Theory case split
//
// -----------------------------------
- typedef int_hashtable<int_hash, default_eq<int> > int_set;
- int_set m_all_th_case_split_literals;
+ uint_set m_all_th_case_split_literals;
vector<literal_vector> m_th_case_split_sets;
u_map< vector<literal_vector> > m_literal2casesplitsets; // returns the case split literal sets that a literal participates in
unsigned m_th_case_split_qhead;
From 5107e5cafc2dd74d2627de7f9986ba1c88702532 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 23 Feb 2017 15:01:55 -0500
Subject: [PATCH 343/401] refactor: remove t_str_refcount_hack traces
---
src/ast/ast.cpp | 1 -
src/smt/smt_context.cpp | 8 --------
src/smt/theory_str.cpp | 15 ---------------
3 files changed, 24 deletions(-)
diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp
index 37ea297c2..7271048b1 100644
--- a/src/ast/ast.cpp
+++ b/src/ast/ast.cpp
@@ -1829,7 +1829,6 @@ void ast_manager::delete_node(ast * n) {
TRACE("ast", tout << "Deleting object " << n->m_id << " " << n << "\n";);
CTRACE("del_quantifier", is_quantifier(n), tout << "deleting quantifier " << n->m_id << " " << n << "\n";);
TRACE("mk_var_bug", tout << "del_ast: " << n->m_id << "\n";);
- TRACE("t_str_refcount_hack", tout << "delete ast " << n->m_id << std::endl;);
TRACE("ast_delete_node", tout << mk_bounded_pp(n, *this) << "\n";);
SASSERT(m_ast_table.contains(n));
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 7532bf3f8..29321ecf7 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -2403,9 +2403,6 @@ namespace smt {
*/
unsigned context::pop_scope_core(unsigned num_scopes) {
- TRACE("t_str_refcount_hack", tout << "begin pop_scope_core in smt_context" << std::endl;);
-
-
if (m_manager.has_trace_stream())
m_manager.trace_stream() << "[pop] " << num_scopes << " " << m_scope_lvl << "\n";
@@ -2453,9 +2450,7 @@ namespace smt {
ptr_vector<theory>::iterator it = m_theory_set.begin();
ptr_vector<theory>::iterator end = m_theory_set.end();
for (; it != end; ++it) {
- TRACE("t_str_refcount_hack", tout << "begin theory pop_scope_eh" << std::endl;);
(*it)->pop_scope_eh(num_scopes);
- TRACE("t_str_refcount_hack", tout << "end theory pop_scope_eh" << std::endl;);
}
del_justifications(m_justifications, s.m_justifications_lim);
@@ -2482,9 +2477,6 @@ namespace smt {
reassert_units(units_to_reassert_lim);
TRACE("pop_scope_detail", tout << "end of pop_scope: \n"; display(tout););
CASSERT("context", check_invariant());
-
- TRACE("t_str_refcount_hack", tout << "end pop_scope_core in smt_context" << std::endl;);
-
return num_bool_vars;
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 84295940a..b78cbbe59 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1793,7 +1793,6 @@ void theory_str::reset_eh() {
* Then add an assertion: (y2 == (Concat ce m2)) AND ("str3" == (Concat abc x2)) -> (y2 != "str3")
*/
bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
- TRACE("t_str_refcount_hack", tout << "begin new_eq_check in theory_str" << std::endl;);
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -1819,7 +1818,6 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
expr_ref to_assert(m.mk_not(ctx.mk_eq_atom(eqc_nn1, eqc_nn2)), m);
assert_axiom(to_assert);
// this shouldn't use the integer theory at all, so we don't allow the option of quick-return
- TRACE("t_str_refcount_hack", tout << "end new_eq_check in theory_str" << std::endl;);
return false;
}
if (!check_length_consistency(eqc_nn1, eqc_nn2)) {
@@ -1827,7 +1825,6 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
if (opt_NoQuickReturn_IntegerTheory){
TRACE("t_str_detail", tout << "continuing in new_eq_check() due to opt_NoQuickReturn_IntegerTheory" << std::endl;);
} else {
- TRACE("t_str_refcount_hack", tout << "end new_eq_check in theory_str" << std::endl;);
return false;
}
}
@@ -1846,7 +1843,6 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
}
// okay, all checks here passed
- TRACE("t_str_refcount_hack", tout << "end new_eq_check in theory_str" << std::endl;);
return true;
}
@@ -7276,20 +7272,11 @@ void theory_str::check_variable_scope() {
}
void theory_str::pop_scope_eh(unsigned num_scopes) {
- TRACE("t_str_refcount_hack", tout << "begin pop_scope_eh in theory_str" << std::endl;);
-
sLevel -= num_scopes;
TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
context & ctx = get_context();
ast_manager & m = get_manager();
- // {
- // expr_ref_vector assignments(m);
- // ctx.get_assignments(assignments);
- // TRACE("t_str_refcount_hack", tout << "assignment vector about to go out of scope" << std::endl;);
- // }
- // TRACE("t_str_refcount_hack", tout << "assignment vector has gone out of scope" << std::endl;);
-
TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
// list of expr* to remove from cut_var_map
@@ -7337,8 +7324,6 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
theory::pop_scope_eh(num_scopes);
//check_variable_scope();
-
- TRACE("t_str_refcount_hack", tout << "end pop_scope_eh in theory_str" << std::endl;);
}
void theory_str::dump_assignments() {
From 858c754b15ab57b4050e328173193492bcf8a0f7 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 23 Feb 2017 15:05:43 -0500
Subject: [PATCH 344/401] refactor: remove unused variable in
smt_case_split_queue
---
src/smt/smt_case_split_queue.cpp | 46 +++++++++++++-------------------
1 file changed, 18 insertions(+), 28 deletions(-)
diff --git a/src/smt/smt_case_split_queue.cpp b/src/smt/smt_case_split_queue.cpp
index c7ef655f2..67f370da0 100644
--- a/src/smt/smt_case_split_queue.cpp
+++ b/src/smt/smt_case_split_queue.cpp
@@ -1351,35 +1351,25 @@ namespace smt {
p.m_case_split_strategy = CS_ACTIVITY;
}
- case_split_queue * baseQueue;
-
- if (p.m_theory_aware_branching) {
- // override
- baseQueue = alloc(theory_aware_branching_queue, ctx, p);
- } else {
- switch (p.m_case_split_strategy) {
- case CS_ACTIVITY_DELAY_NEW:
- baseQueue = alloc(dact_case_split_queue, ctx, p);
- break;
- case CS_ACTIVITY_WITH_CACHE:
- baseQueue = alloc(cact_case_split_queue, ctx, p);
- break;
- case CS_RELEVANCY:
- baseQueue = alloc(rel_case_split_queue, ctx, p);
- break;
- case CS_RELEVANCY_ACTIVITY:
- baseQueue = alloc(rel_act_case_split_queue, ctx, p);
- break;
- case CS_RELEVANCY_GOAL:
- baseQueue = alloc(rel_goal_case_split_queue, ctx, p);
- break;
- default:
- baseQueue = alloc(act_case_split_queue, ctx, p);
- break;
+ if (p.m_theory_aware_branching) {
+ // override
+ return alloc(theory_aware_branching_queue, ctx, p);
+ } else {
+ switch (p.m_case_split_strategy) {
+ case CS_ACTIVITY_DELAY_NEW:
+ return alloc(dact_case_split_queue, ctx, p);
+ case CS_ACTIVITY_WITH_CACHE:
+ return alloc(cact_case_split_queue, ctx, p);
+ case CS_RELEVANCY:
+ return alloc(rel_case_split_queue, ctx, p);
+ case CS_RELEVANCY_ACTIVITY:
+ return alloc(rel_act_case_split_queue, ctx, p);
+ case CS_RELEVANCY_GOAL:
+ return alloc(rel_goal_case_split_queue, ctx, p);
+ default:
+ return alloc(act_case_split_queue, ctx, p);
+ }
}
- }
-
- return baseQueue;
}
};
From 6387d59f5c37bb7cbc981dd9513457b33fc7a37f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 23 Feb 2017 15:08:05 -0500
Subject: [PATCH 345/401] refactor: remove commented-out code
---
src/smt/smt_case_split_queue.cpp | 113 -------------------------------
1 file changed, 113 deletions(-)
diff --git a/src/smt/smt_case_split_queue.cpp b/src/smt/smt_case_split_queue.cpp
index 67f370da0..6cdfed7ea 100644
--- a/src/smt/smt_case_split_queue.cpp
+++ b/src/smt/smt_case_split_queue.cpp
@@ -1112,119 +1112,6 @@ namespace smt {
}
};
- /*
- class theory_aware_branching_queue : public case_split_queue {
- protected:
- context & m_context;
- smt_params & m_params;
-
- theory_var_priority_map m_theory_var_priority;
- theory_aware_act_queue m_theory_queue;
- case_split_queue * m_base_queue;
- int_hashtable<int_hash, default_eq<bool_var> > m_theory_vars;
- map<bool_var, lbool, int_hash, default_eq<bool_var> > m_theory_var_phase;
- public:
- theory_aware_branching_queue(context & ctx, smt_params & p, case_split_queue * base_queue) :
- m_context(ctx),
- m_params(p),
- m_theory_var_priority(),
- m_theory_queue(1024, theory_aware_act_lt(m_theory_var_priority)),
- m_base_queue(base_queue) {
- }
-
- virtual void activity_increased_eh(bool_var v) {
- m_base_queue->activity_increased_eh(v);
- }
-
- virtual void mk_var_eh(bool_var v) {
- // do nothing. we only "react" if/when we learn this is an important theory literal
- m_base_queue->mk_var_eh(v);
- }
-
- virtual void del_var_eh(bool_var v) {
- if (m_theory_queue.contains(v)) {
- m_theory_queue.erase(v);
- }
- m_base_queue->del_var_eh(v);
- }
-
- virtual void assign_lit_eh(literal l) {
- m_base_queue->assign_lit_eh(l);
- }
-
- virtual void unassign_var_eh(bool_var v) {
- if (m_theory_vars.contains(v) && !m_theory_queue.contains(v)) {
- m_theory_queue.insert(v);
- }
- m_base_queue->unassign_var_eh(v);
- }
-
- virtual void relevant_eh(expr * n) {
- m_base_queue->relevant_eh(n);
- }
-
- virtual void init_search_eh() {
- m_base_queue->init_search_eh();
- }
-
- virtual void end_search_eh() {
- m_base_queue->end_search_eh();
- }
-
- virtual void internalize_instance_eh(expr * e, unsigned gen) {
- m_base_queue->internalize_instance_eh(e, gen);
- }
-
- virtual void reset() {
- m_theory_queue.reset();
- m_theory_vars.reset();
- m_theory_var_phase.reset();
- m_theory_var_priority.reset();
- m_base_queue->reset();
- }
-
- virtual void push_scope() {
- m_base_queue->push_scope();
- }
-
- virtual void pop_scope(unsigned num_scopes) {
- m_base_queue->pop_scope(num_scopes);
- }
-
- virtual void next_case_split(bool_var & next, lbool & phase) {
- while (!m_theory_queue.empty()) {
- next = m_theory_queue.erase_min();
- // if this literal is unassigned, it is the theory literal with the highest priority,
- // so case split on this
- if (m_context.get_assignment(next) == l_undef) {
- TRACE("theory_aware_branching", tout << "Theory-aware branch on l#" << next << std::endl;);
- if (!m_theory_var_phase.find(next, phase)) {
- phase = l_undef;
- }
- return;
- }
- }
- // if we reach this point, the theory literal queue is empty,
- // so fall back to the base queue
- m_base_queue->next_case_split(next, phase);
- }
-
- virtual void add_theory_aware_branching_info(bool_var v, double priority, lbool phase) {
- TRACE("theory_aware_branching", tout << "Add theory-aware branching information for l#" << v << ": priority=" << priority << std::endl;);
- m_theory_vars.insert(v);
- m_theory_var_phase.insert(v, phase);
- m_theory_var_priority.insert(v, priority);
- m_theory_queue.reserve(v+1);
- m_theory_queue.insert(v);
- }
-
- virtual void display(std::ostream & out) {
- // TODO
- m_base_queue->display(out);
- }
- };
- */
-
class theory_aware_branching_queue : public case_split_queue {
protected:
context & m_context;
From 3816779ba12c24fdfd05d9a244101aca1f712b35 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 23 Feb 2017 15:25:20 -0500
Subject: [PATCH 346/401] fix indent
---
src/smt/smt_case_split_queue.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/smt/smt_case_split_queue.cpp b/src/smt/smt_case_split_queue.cpp
index 6cdfed7ea..35cdcb6fe 100644
--- a/src/smt/smt_case_split_queue.cpp
+++ b/src/smt/smt_case_split_queue.cpp
@@ -46,8 +46,8 @@ namespace smt {
bool operator()(bool_var v1, bool_var v2) const {
double p_v1, p_v2;
if (!m_theory_var_priority.find(v1, p_v1)) {
- p_v1 = 0.0;
- }
+ p_v1 = 0.0;
+ }
if (!m_theory_var_priority.find(v2, p_v2)) {
p_v2 = 0.0;
}
From a7b21dc5d51c3256ecadccc499b8b310af2ab31e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 23 Feb 2017 16:00:05 -0500
Subject: [PATCH 347/401] refactor: aligned external/internal names for
str.strong_arrangements option
---
src/smt/params/theory_str_params.cpp | 2 +-
src/smt/params/theory_str_params.h | 4 ++--
src/smt/theory_str.cpp | 36 ++++++++++++++--------------
3 files changed, 21 insertions(+), 21 deletions(-)
diff --git a/src/smt/params/theory_str_params.cpp b/src/smt/params/theory_str_params.cpp
index f86cd9379..6090086b8 100644
--- a/src/smt/params/theory_str_params.cpp
+++ b/src/smt/params/theory_str_params.cpp
@@ -20,7 +20,7 @@ Revision History:
void theory_str_params::updt_params(params_ref const & _p) {
smt_params_helper p(_p);
- m_AssertStrongerArrangements = p.str_strong_arrangements();
+ m_StrongArrangements = p.str_strong_arrangements();
m_AggressiveLengthTesting = p.str_aggressive_length_testing();
m_AggressiveValueTesting = p.str_aggressive_value_testing();
m_AggressiveUnrollTesting = p.str_aggressive_unroll_testing();
diff --git a/src/smt/params/theory_str_params.h b/src/smt/params/theory_str_params.h
index de0945395..207b635d7 100644
--- a/src/smt/params/theory_str_params.h
+++ b/src/smt/params/theory_str_params.h
@@ -28,7 +28,7 @@ struct theory_str_params {
* This is a stronger version of the standard axiom.
* The Z3str2 axioms can be simulated by setting this to false.
*/
- bool m_AssertStrongerArrangements;
+ bool m_StrongArrangements;
/*
* If AggressiveLengthTesting is true, we manipulate the phase of length tester equalities
@@ -81,7 +81,7 @@ struct theory_str_params {
double m_OverlapTheoryAwarePriority;
theory_str_params(params_ref const & p = params_ref()):
- m_AssertStrongerArrangements(true),
+ m_StrongArrangements(true),
m_AggressiveLengthTesting(false),
m_AggressiveValueTesting(false),
m_AggressiveUnrollTesting(true),
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b78cbbe59..80781d6aa 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -3079,7 +3079,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(t1, sLevel, m);
add_cut_info_merge(t1, sLevel, y);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -3137,7 +3137,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(t2, sLevel, x);
add_cut_info_merge(t2, sLevel, n);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -3272,7 +3272,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
if (!arrangement_disjunction.empty()) {
expr_ref premise(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
expr_ref conclusion(mk_or(arrangement_disjunction), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(premise, conclusion), mgr);
assert_axiom(ax_strong);
} else {
@@ -3472,7 +3472,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(temp1, sLevel, y);
add_cut_info_merge(temp1, sLevel, m);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -3547,7 +3547,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
expr_ref ax_l(mk_and(l_items), mgr);
expr_ref ax_r(mk_and(r_items), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -3628,7 +3628,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
if (!arrangement_disjunction.empty()) {
expr_ref implyR(mk_or(arrangement_disjunction), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref implyLHS(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
expr_ref ax_strong(ctx.mk_eq_atom(implyLHS, implyR), mgr);
assert_axiom(ax_strong);
@@ -3816,7 +3816,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
r_items.push_back(ctx.mk_eq_atom(x, prefixAst));
r_items.push_back(ctx.mk_eq_atom(y, suf_n_concat));
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, mk_and(r_items)), mgr);
assert_axiom(ax_strong);
} else {
@@ -3836,7 +3836,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x, strAst), ctx.mk_eq_atom(y, n)), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -3874,7 +3874,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
add_cut_info_merge(temp1, sLevel, x);
add_cut_info_merge(temp1, sLevel, n);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
assert_axiom(ax_strong);
} else {
@@ -3977,7 +3977,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
if (!arrangement_disjunction.empty()) {
expr_ref implyR(mk_or(arrangement_disjunction), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_lhs(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
expr_ref ax_strong(ctx.mk_eq_atom(ax_lhs, implyR), mgr);
assert_axiom(ax_strong);
@@ -4059,7 +4059,7 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
if (!in_same_eqc(tmpAst, n)) {
// break down option 4-1
expr_ref implyR(ctx.mk_eq_atom(n, tmpAst), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -4071,7 +4071,7 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
//break down option 4-2
expr_ref implyR(ctx.mk_eq_atom(n, y), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -4084,7 +4084,7 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
if (!in_same_eqc(y, tmpAst)) {
//break down option 4-3
expr_ref implyR(ctx.mk_eq_atom(y, tmpAst), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -4161,7 +4161,7 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
expr_ref x_deltaStr(mk_concat(x, mk_string(deltaStr)), mgr);
if (!in_same_eqc(m, x_deltaStr)) {
expr_ref implyR(ctx.mk_eq_atom(m, x_deltaStr), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -4172,7 +4172,7 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
// test
if (!in_same_eqc(x, m)) {
expr_ref implyR(ctx.mk_eq_atom(x, m), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -4184,7 +4184,7 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
expr_ref m_deltaStr(mk_concat(m, mk_string(deltaStr)), mgr);
if (!in_same_eqc(x, m_deltaStr)) {
expr_ref implyR(ctx.mk_eq_atom(x, m_deltaStr), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -4420,7 +4420,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
expr_ref implyR(mk_or(arrangement_disjunction), mgr);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
assert_axiom(ax_strong);
} else {
@@ -6515,7 +6515,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
assert_axiom(negate_ast);
} else {
implyR1 = mk_or(arrangement_disjunction);
- if (m_params.m_AssertStrongerArrangements) {
+ if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(implyL, implyR1), m);
assert_axiom(ax_strong);
} else {
From 725352234d8f28e66845304aef8eaeb1ad353621 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 27 Feb 2017 13:22:56 -0500
Subject: [PATCH 348/401] refactoring theory_str
---
src/api/api_ast.cpp | 16 ---
src/api/api_context.cpp | 2 -
src/api/api_context.h | 4 -
src/api/api_str.cpp | 160 ------------------------------
src/api/z3_api.h | 2 -
src/ast/ast_smt2_pp.h | 5 +-
src/ast/ast_smt_pp.cpp | 5 -
src/ast/reg_decl_plugins.cpp | 4 -
src/ast/rewriter/str_rewriter.cpp | 3 +
src/ast/rewriter/str_rewriter.h | 4 +
src/ast/str_decl_plugin.cpp | 5 +
src/ast/str_decl_plugin.h | 5 +
src/cmd_context/check_logic.cpp | 7 +-
src/cmd_context/cmd_context.cpp | 8 +-
src/parsers/smt2/smt2parser.cpp | 27 -----
src/smt/theory_str.cpp | 137 ++++++++++---------------
src/smt/theory_str.h | 83 ++--------------
17 files changed, 87 insertions(+), 390 deletions(-)
delete mode 100644 src/api/api_str.cpp
diff --git a/src/api/api_ast.cpp b/src/api/api_ast.cpp
index f3b3b7edf..c9cdc6ab3 100644
--- a/src/api/api_ast.cpp
+++ b/src/api/api_ast.cpp
@@ -647,12 +647,6 @@ extern "C" {
else if (fid == mk_c(c)->get_seq_fid() && k == RE_SORT) {
return Z3_RE_SORT;
}
- else if (fid == mk_c(c)->get_str_fid() && k == STRING_SORT) {
- return Z3_STRING_SORT;
- }
- else if (fid == mk_c(c)->get_str_fid() && k == REGEX_SORT) {
- return Z3_REGEX_SORT;
- }
else {
return Z3_UNKNOWN_SORT;
}
@@ -1147,16 +1141,6 @@ extern "C" {
}
}
- if (mk_c(c)->get_str_fid() == _d->get_family_id()) {
- switch (_d->get_decl_kind()) {
- // TODO(z3str2) add others
- case OP_STRCAT: return Z3_OP_STR_CONCAT;
- case OP_STRLEN: return Z3_OP_STR_LENGTH;
- default:
- return Z3_OP_UNINTERPRETED;
- }
- }
-
if (mk_c(c)->get_fpa_fid() == _d->get_family_id()) {
switch (_d->get_decl_kind()) {
case OP_FPA_RM_NEAREST_TIES_TO_EVEN: return Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN;
diff --git a/src/api/api_context.cpp b/src/api/api_context.cpp
index fd3d16bd0..bcd3c60f2 100644
--- a/src/api/api_context.cpp
+++ b/src/api/api_context.cpp
@@ -81,7 +81,6 @@ namespace api {
m_fpa_util(m()),
m_dtutil(m()),
m_sutil(m()),
- m_strutil(m()),
m_last_result(m()),
m_ast_trail(m()),
m_pmanager(m_limit) {
@@ -105,7 +104,6 @@ namespace api {
m_datalog_fid = m().mk_family_id("datalog_relation");
m_fpa_fid = m().mk_family_id("fpa");
m_seq_fid = m().mk_family_id("seq");
- m_str_fid = m().mk_family_id("str");
m_dt_plugin = static_cast<datatype_decl_plugin*>(m().get_plugin(m_dt_fid));
install_tactics(*this);
diff --git a/src/api/api_context.h b/src/api/api_context.h
index 7459bd102..6e34f6d6e 100644
--- a/src/api/api_context.h
+++ b/src/api/api_context.h
@@ -26,7 +26,6 @@ Revision History:
#include"arith_decl_plugin.h"
#include"bv_decl_plugin.h"
#include"seq_decl_plugin.h"
-#include"str_decl_plugin.h"
#include"datatype_decl_plugin.h"
#include"dl_decl_plugin.h"
#include"fpa_decl_plugin.h"
@@ -63,8 +62,6 @@ namespace api {
datatype_util m_dtutil;
seq_util m_sutil;
- str_util m_strutil;
-
// Support for old solver API
smt_params m_fparams;
// -------------------------------
@@ -130,7 +127,6 @@ namespace api {
fpa_util & fpautil() { return m_fpa_util; }
datatype_util& dtutil() { return m_dtutil; }
seq_util& sutil() { return m_sutil; }
- str_util& strutil() { return m_strutil; }
family_id get_basic_fid() const { return m_basic_fid; }
family_id get_array_fid() const { return m_array_fid; }
family_id get_arith_fid() const { return m_arith_fid; }
diff --git a/src/api/api_str.cpp b/src/api/api_str.cpp
deleted file mode 100644
index eb56a839b..000000000
--- a/src/api/api_str.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-/*++
-Copyright (c) 2016 Microsoft Corporation
-
-Module Name:
-
- api_str.cpp
-
-Abstract:
-
- API for strings and regular expressions (Z3str2 implementation).
-
-Author:
-
- Murphy Berzish (mtrberzi) 2016-10-03.
-
-Revision History:
-
---*/
-#include<iostream>
-#include"z3.h"
-#include"api_log_macros.h"
-#include"api_context.h"
-#include"api_util.h"
-#include"ast_pp.h"
-
-extern "C" {
-
- Z3_sort Z3_API Z3_mk_str_sort(Z3_context c) {
- Z3_TRY;
- LOG_Z3_mk_str_sort(c);
- RESET_ERROR_CODE();
- sort * ty = mk_c(c)->strutil().mk_string_sort();
- mk_c(c)->save_ast_trail(ty);
- RETURN_Z3(of_sort(ty));
- Z3_CATCH_RETURN(0);
- }
-
- Z3_bool Z3_API Z3_is_str_sort(Z3_context c, Z3_sort s) {
- Z3_TRY;
- LOG_Z3_is_str_sort(c, s);
- RESET_ERROR_CODE();
- bool result = mk_c(c)->strutil().is_str_sort(to_sort(s));
- return result?Z3_TRUE:Z3_FALSE;
- Z3_CATCH_RETURN(Z3_FALSE);
- }
-
- Z3_bool Z3_API Z3_is_str(Z3_context c, Z3_ast s) {
- Z3_TRY;
- LOG_Z3_is_str(c, s);
- RESET_ERROR_CODE();
- bool result = mk_c(c)->strutil().is_string(to_expr(s));
- return result ? Z3_TRUE : Z3_FALSE;
- Z3_CATCH_RETURN(Z3_FALSE);
- }
-
- Z3_string Z3_API Z3_get_str(Z3_context c, Z3_ast s) {
- Z3_TRY;
- LOG_Z3_get_str(c, s);
- RESET_ERROR_CODE();
- if (!mk_c(c)->strutil().is_string(to_expr(s))) {
- SET_ERROR_CODE(Z3_INVALID_ARG);
- return "";
- }
- std::string result = mk_c(c)->strutil().get_string_constant_value(to_expr(s));
- return mk_c(c)->mk_external_string(result);
- Z3_CATCH_RETURN("");
- }
-
- Z3_ast Z3_API Z3_mk_str(Z3_context c, Z3_string str) {
- Z3_TRY;
- LOG_Z3_mk_str(c, str);
- RESET_ERROR_CODE();
- std::string s(str);
- app * a = mk_c(c)->strutil().mk_string(str);
- mk_c(c)->save_ast_trail(a);
- RETURN_Z3(of_ast(a));
- Z3_CATCH_RETURN(0);
- }
-
- MK_BINARY(Z3_mk_str_concat, mk_c(c)->get_str_fid(), OP_STRCAT, SKIP);
- MK_UNARY(Z3_mk_str_length, mk_c(c)->get_str_fid(), OP_STRLEN, SKIP);
- MK_BINARY(Z3_mk_str_at, mk_c(c)->get_str_fid(), OP_STR_CHARAT, SKIP);
- // translate prefixof/suffixof to StartsWith/EndsWith
- Z3_ast Z3_API Z3_mk_str_prefixof(Z3_context c, Z3_ast pre, Z3_ast full) {
- LOG_Z3_mk_str_prefixof(c, pre, full);
- Z3_TRY;
- RESET_ERROR_CODE();
- expr * args[2] = { to_expr(full), to_expr(pre) }; // reverse args
- ast * a = mk_c(c)->m().mk_app(mk_c(c)->get_str_fid(), OP_STR_STARTSWITH, 0, 0, 2, args);
- mk_c(c)->save_ast_trail(a);
- check_sorts(c, a);
- RETURN_Z3(of_ast(a));
- Z3_CATCH_RETURN(0);
- }
- Z3_ast Z3_API Z3_mk_str_suffixof(Z3_context c, Z3_ast suf, Z3_ast full) {
- LOG_Z3_mk_str_suffixof(c, suf, full);
- Z3_TRY;
- RESET_ERROR_CODE();
- expr * args[2] = { to_expr(full), to_expr(suf) }; // reverse args
- ast * a = mk_c(c)->m().mk_app(mk_c(c)->get_str_fid(), OP_STR_ENDSWITH, 0, 0, 2, args);
- mk_c(c)->save_ast_trail(a);
- check_sorts(c, a);
- RETURN_Z3(of_ast(a));
- Z3_CATCH_RETURN(0);
- }
-
- MK_BINARY(Z3_mk_str_contains, mk_c(c)->get_str_fid(), OP_STR_CONTAINS, SKIP);
- MK_TERNARY(Z3_mk_str_indexof, mk_c(c)->get_str_fid(), OP_STR_INDEXOF, SKIP);
- MK_TERNARY(Z3_mk_str_substr, mk_c(c)->get_str_fid(), OP_STR_SUBSTR, SKIP);
- MK_TERNARY(Z3_mk_str_replace, mk_c(c)->get_str_fid(), OP_STR_REPLACE, SKIP);
-
- Z3_ast Z3_API Z3_mk_str_to_regex(Z3_context c, Z3_string str) {
- LOG_Z3_mk_str_to_regex(c, str);
- Z3_TRY;
- RESET_ERROR_CODE();
- std::string s(str);
- app * a = mk_c(c)->strutil().mk_string(str);
- mk_c(c)->save_ast_trail(a);
-
- expr * args[1] = { to_expr(a) };
- ast * re = mk_c(c)->m().mk_app(mk_c(c)->get_str_fid(), OP_RE_STR2REGEX, 0, 0, 1, args);
- mk_c(c)->save_ast_trail(re);
- check_sorts(c, re);
- RETURN_Z3(of_ast(re));
- Z3_CATCH_RETURN(0);
- }
-
- MK_BINARY(Z3_mk_str_in_regex, mk_c(c)->get_str_fid(), OP_RE_REGEXIN, SKIP);
- MK_BINARY(Z3_mk_regex_concat, mk_c(c)->get_str_fid(), OP_RE_REGEXCONCAT, SKIP);
- MK_BINARY(Z3_mk_regex_union, mk_c(c)->get_str_fid(), OP_RE_REGEXUNION, SKIP);
- MK_UNARY(Z3_mk_regex_star, mk_c(c)->get_str_fid(), OP_RE_REGEXSTAR, SKIP);
- MK_UNARY(Z3_mk_regex_plus, mk_c(c)->get_str_fid(), OP_RE_REGEXPLUS, SKIP);
-
- Z3_ast Z3_API Z3_mk_regex_range(Z3_context c, Z3_string start, Z3_string end) {
- LOG_Z3_mk_regex_range(c, start, end);
- Z3_TRY;
- RESET_ERROR_CODE();
-
- std::string cStart(start);
- std::string cEnd(end);
- if(cStart.length() != 1 || cEnd.length() != 1) {
- SET_ERROR_CODE(Z3_INVALID_ARG);
- return 0;
- }
-
- app * a1 = mk_c(c)->strutil().mk_string(cStart);
- mk_c(c)->save_ast_trail(a1);
- app * a2 = mk_c(c)->strutil().mk_string(cEnd);
- mk_c(c)->save_ast_trail(a2);
-
- expr * args[2] = { to_expr(a1), to_expr(a2) };
- ast * range = mk_c(c)->m().mk_app(mk_c(c)->get_str_fid(), OP_RE_REGEXCHARRANGE, 0, 0, 2, args);
- mk_c(c)->save_ast_trail(range);
- check_sorts(c, range);
- RETURN_Z3(of_ast(range));
-
- Z3_CATCH_RETURN(0);
- }
-
-};
diff --git a/src/api/z3_api.h b/src/api/z3_api.h
index aa4701f13..0b8351190 100644
--- a/src/api/z3_api.h
+++ b/src/api/z3_api.h
@@ -165,8 +165,6 @@ typedef enum
Z3_ROUNDING_MODE_SORT,
Z3_SEQ_SORT,
Z3_RE_SORT,
- Z3_STRING_SORT,
- Z3_REGEX_SORT,
Z3_UNKNOWN_SORT = 1000
} Z3_sort_kind;
diff --git a/src/ast/ast_smt2_pp.h b/src/ast/ast_smt2_pp.h
index 0bff579bc..b1bdf52bd 100644
--- a/src/ast/ast_smt2_pp.h
+++ b/src/ast/ast_smt2_pp.h
@@ -50,7 +50,6 @@ public:
virtual array_util & get_arutil() = 0;
virtual fpa_util & get_futil() = 0;
virtual seq_util & get_sutil() = 0;
- virtual str_util & get_strutil() = 0;
virtual datalog::dl_decl_util& get_dlutil() = 0;
virtual bool uses(symbol const & s) const = 0;
virtual format_ns::format * pp_fdecl(func_decl * f, unsigned & len);
@@ -77,17 +76,15 @@ class smt2_pp_environment_dbg : public smt2_pp_environment {
array_util m_arutil;
fpa_util m_futil;
seq_util m_sutil;
- str_util m_strutil;
datalog::dl_decl_util m_dlutil;
public:
- smt2_pp_environment_dbg(ast_manager & m):m_manager(m), m_autil(m), m_bvutil(m), m_arutil(m), m_futil(m), m_sutil(m), m_strutil(m), m_dlutil(m) {}
+ smt2_pp_environment_dbg(ast_manager & m):m_manager(m), m_autil(m), m_bvutil(m), m_arutil(m), m_futil(m), m_sutil(m), m_dlutil(m) {}
virtual ast_manager & get_manager() const { return m_manager; }
virtual arith_util & get_autil() { return m_autil; }
virtual bv_util & get_bvutil() { return m_bvutil; }
virtual seq_util & get_sutil() { return m_sutil; }
virtual array_util & get_arutil() { return m_arutil; }
virtual fpa_util & get_futil() { return m_futil; }
- virtual str_util & get_strutil() { return m_strutil; }
virtual datalog::dl_decl_util& get_dlutil() { return m_dlutil; }
virtual bool uses(symbol const & s) const { return false; }
};
diff --git a/src/ast/ast_smt_pp.cpp b/src/ast/ast_smt_pp.cpp
index 75e6a46f1..de6ae6cc3 100644
--- a/src/ast/ast_smt_pp.cpp
+++ b/src/ast/ast_smt_pp.cpp
@@ -165,7 +165,6 @@ class smt_printer {
bv_util m_bvutil;
seq_util m_sutil;
fpa_util m_futil;
- str_util m_strutil;
family_id m_basic_fid;
family_id m_bv_fid;
family_id m_str_fid;
@@ -473,9 +472,6 @@ class smt_printer {
m_out << ") bv1[1])";
}
}
- else if (m_strutil.is_string(n, &str)) {
- m_out << "\"" << str << "\"";
- }
else if (m_manager.is_label(n, pos, names) && names.size() >= 1) {
if (m_is_smt2) {
m_out << "(! ";
@@ -839,7 +835,6 @@ public:
m_bvutil(m),
m_sutil(m),
m_futil(m),
- m_strutil(m),
m_logic(logic),
m_AUFLIRA("AUFLIRA"),
// It's much easier to read those testcases with that.
diff --git a/src/ast/reg_decl_plugins.cpp b/src/ast/reg_decl_plugins.cpp
index 886e3f495..b4ff63ede 100644
--- a/src/ast/reg_decl_plugins.cpp
+++ b/src/ast/reg_decl_plugins.cpp
@@ -26,7 +26,6 @@ Revision History:
#include"seq_decl_plugin.h"
#include"pb_decl_plugin.h"
#include"fpa_decl_plugin.h"
-#include"str_decl_plugin.h"
void reg_decl_plugins(ast_manager & m) {
if (!m.get_plugin(m.mk_family_id(symbol("arith")))) {
@@ -53,7 +52,4 @@ void reg_decl_plugins(ast_manager & m) {
if (!m.get_plugin(m.mk_family_id(symbol("pb")))) {
m.register_plugin(symbol("pb"), alloc(pb_decl_plugin));
}
- if (!m.get_plugin(m.mk_family_id(symbol("str")))) {
- m.register_plugin(symbol("str"), alloc(str_decl_plugin));
- }
}
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
index 045d06b97..3933e7fdb 100644
--- a/src/ast/rewriter/str_rewriter.cpp
+++ b/src/ast/rewriter/str_rewriter.cpp
@@ -17,6 +17,8 @@ Notes:
--*/
+#if 0
+
#include"str_rewriter.h"
#include"arith_decl_plugin.h"
#include"ast_pp.h"
@@ -698,3 +700,4 @@ bool str_rewriter::reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_
return true;
}
+#endif /* disable */
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
index 0494d4d1b..8d6041a51 100644
--- a/src/ast/rewriter/str_rewriter.h
+++ b/src/ast/rewriter/str_rewriter.h
@@ -17,6 +17,8 @@ Notes:
--*/
+#if 0
+
#include"str_decl_plugin.h"
#include"arith_decl_plugin.h"
#include"rewriter_types.h"
@@ -114,3 +116,5 @@ public:
bool matches(std::string input);
};
+
+#endif /* disable */
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
index 80493f3cf..067420f04 100644
--- a/src/ast/str_decl_plugin.cpp
+++ b/src/ast/str_decl_plugin.cpp
@@ -14,6 +14,9 @@ Author:
Revision History:
--*/
+
+#if 0
+
#include<sstream>
#include"str_decl_plugin.h"
#include"string_buffer.h"
@@ -494,3 +497,5 @@ std::string str_util::get_std_regex_str(expr * regex) {
UNREACHABLE(); return "";
}
}
+
+#endif /* disable */
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
index 3ae034b45..28ecd1e43 100644
--- a/src/ast/str_decl_plugin.h
+++ b/src/ast/str_decl_plugin.h
@@ -14,6 +14,9 @@ Author:
Revision History:
--*/
+
+#if 0
+
#ifndef _STR_DECL_PLUGIN_H_
#define _STR_DECL_PLUGIN_H_
@@ -211,3 +214,5 @@ public:
};
#endif /* _STR_DECL_PLUGIN_H_ */
+
+#endif /* disable */
diff --git a/src/cmd_context/check_logic.cpp b/src/cmd_context/check_logic.cpp
index 02f66fc4d..c75c12689 100644
--- a/src/cmd_context/check_logic.cpp
+++ b/src/cmd_context/check_logic.cpp
@@ -21,7 +21,6 @@ Revision History:
#include"array_decl_plugin.h"
#include"bv_decl_plugin.h"
#include"seq_decl_plugin.h"
-#include"str_decl_plugin.h"
#include"pb_decl_plugin.h"
#include"datatype_decl_plugin.h"
#include"ast_pp.h"
@@ -35,7 +34,6 @@ struct check_logic::imp {
bv_util m_bv_util;
array_util m_ar_util;
seq_util m_seq_util;
- str_util m_str_util;
datatype_util m_dt_util;
pb_util m_pb_util;
bool m_uf; // true if the logic supports uninterpreted functions
@@ -49,7 +47,7 @@ struct check_logic::imp {
bool m_quantifiers; // true if the logic supports quantifiers
bool m_unknown_logic;
- imp(ast_manager & _m):m(_m), m_a_util(m), m_bv_util(m), m_ar_util(m), m_seq_util(m), m_str_util(m), m_dt_util(m), m_pb_util(m) {
+ imp(ast_manager & _m):m(_m), m_a_util(m), m_bv_util(m), m_ar_util(m), m_seq_util(m), m_dt_util(m), m_pb_util(m) {
reset();
}
@@ -444,9 +442,6 @@ struct check_logic::imp {
else if (fid == m_seq_util.get_family_id()) {
// nothing to check
}
- else if (fid == m_str_util.get_family_id()) {
- // nothing to check
- }
else if (fid == m_dt_util.get_family_id() && m_logic == "QF_FD") {
// nothing to check
}
diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp
index dc66f5da9..b387e8810 100644
--- a/src/cmd_context/cmd_context.cpp
+++ b/src/cmd_context/cmd_context.cpp
@@ -26,7 +26,6 @@ Notes:
#include"seq_decl_plugin.h"
#include"pb_decl_plugin.h"
#include"fpa_decl_plugin.h"
-#include"str_decl_plugin.h"
#include"ast_pp.h"
#include"var_subst.h"
#include"pp.h"
@@ -250,7 +249,6 @@ protected:
array_util m_arutil;
fpa_util m_futil;
seq_util m_sutil;
- str_util m_strutil;
datalog::dl_decl_util m_dlutil;
@@ -272,7 +270,7 @@ protected:
}
public:
- pp_env(cmd_context & o):m_owner(o), m_autil(o.m()), m_bvutil(o.m()), m_arutil(o.m()), m_futil(o.m()), m_sutil(o.m()), m_strutil(o.m()), m_dlutil(o.m()) {}
+ pp_env(cmd_context & o):m_owner(o), m_autil(o.m()), m_bvutil(o.m()), m_arutil(o.m()), m_futil(o.m()), m_sutil(o.m()), m_dlutil(o.m()) {}
virtual ~pp_env() {}
virtual ast_manager & get_manager() const { return m_owner.m(); }
virtual arith_util & get_autil() { return m_autil; }
@@ -280,7 +278,7 @@ public:
virtual array_util & get_arutil() { return m_arutil; }
virtual fpa_util & get_futil() { return m_futil; }
virtual seq_util & get_sutil() { return m_sutil; }
- virtual str_util & get_strutil() { return m_strutil; }
+
virtual datalog::dl_decl_util& get_dlutil() { return m_dlutil; }
virtual bool uses(symbol const & s) const {
return
@@ -561,7 +559,6 @@ void cmd_context::init_manager_core(bool new_manager) {
register_plugin(symbol("pb"), alloc(pb_decl_plugin), logic_has_pb());
register_plugin(symbol("fpa"), alloc(fpa_decl_plugin), logic_has_fpa());
register_plugin(symbol("datalog_relation"), alloc(datalog::dl_decl_plugin), !has_logic());
- register_plugin(symbol("str"), alloc(str_decl_plugin), logic_has_str());
}
else {
// the manager was created by an external module
@@ -575,7 +572,6 @@ void cmd_context::init_manager_core(bool new_manager) {
load_plugin(symbol("datatype"), logic_has_datatype(), fids);
load_plugin(symbol("seq"), logic_has_seq(), fids);
load_plugin(symbol("fpa"), logic_has_fpa(), fids);
- load_plugin(symbol("str"), logic_has_str(), fids);
load_plugin(symbol("pb"), logic_has_pb(), fids);
svector<family_id>::iterator it = fids.begin();
svector<family_id>::iterator end = fids.end();
diff --git a/src/parsers/smt2/smt2parser.cpp b/src/parsers/smt2/smt2parser.cpp
index fc28fa6e7..cbfcbf1fe 100644
--- a/src/parsers/smt2/smt2parser.cpp
+++ b/src/parsers/smt2/smt2parser.cpp
@@ -23,7 +23,6 @@ Revision History:
#include"bv_decl_plugin.h"
#include"arith_decl_plugin.h"
#include"seq_decl_plugin.h"
-#include"str_decl_plugin.h"
#include"ast_pp.h"
#include"well_sorted.h"
#include"pattern_validation.h"
@@ -68,7 +67,6 @@ namespace smt2 {
scoped_ptr<bv_util> m_bv_util;
scoped_ptr<arith_util> m_arith_util;
scoped_ptr<seq_util> m_seq_util;
- scoped_ptr<str_util> m_str_util;
scoped_ptr<pattern_validator> m_pattern_validator;
scoped_ptr<var_shifter> m_var_shifter;
@@ -286,12 +284,6 @@ namespace smt2 {
return *(m_bv_util.get());
}
- str_util & strutil() {
- if (m_str_util.get() == 0)
- m_str_util = alloc(str_util, m());
- return *(m_str_util.get());
- }
-
pattern_validator & pat_validator() {
if (m_pattern_validator.get() == 0) {
m_pattern_validator = alloc(pattern_validator, m());
@@ -1086,29 +1078,10 @@ namespace smt2 {
next();
}
- // sorry, breaking theory_seq for a bit
- /*
void parse_string_const() {
SASSERT(curr() == scanner::STRING_TOKEN);
expr_stack().push_back(sutil().str.mk_string(symbol(m_scanner.get_string())));
TRACE("smt2parser", tout << "new string: " << mk_pp(expr_stack().back(), m()) << "\n";);
- next();
- }
- */
-
- void parse_string_const() {
- parse_string();
- }
-
- void parse_string() {
- SASSERT(curr() == scanner::STRING_TOKEN);
- char const *original_token = m_scanner.get_string();
- size_t bufsize = strlen(original_token);
- char * buf = alloc_svect(char, bufsize + 1);
- strncpy(buf, original_token, bufsize);
- buf[bufsize] = '\0';
- TRACE("parse_string", tout << "new string constant: " << buf << " length=" << bufsize << "\n";);
- expr_stack().push_back(strutil().mk_string_with_escape_characters(buf));
next();
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 80781d6aa..1d56c43a4 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -44,7 +44,7 @@ theory_str::theory_str(ast_manager & m, theory_str_params const & params):
/* Internal setup */
search_started(false),
m_autil(m),
- m_strutil(m),
+ u(m),
sLevel(0),
finalCheckProgressIndicator(false),
m_trail(m),
@@ -70,36 +70,26 @@ theory_str::~theory_str() {
m_trail_stack.reset();
}
-expr * theory_str::mk_string(std::string str) {
+expr * theory_str::mk_string(zstring const& str) {
if (m_params.m_StringConstantCache) {
++totalCacheAccessCount;
expr * val;
if (stringConstantCache.find(str, val)) {
- // cache hit
- ++cacheHitCount;
- TRACE("t_str_cache", tout << "cache hit: \"" << str << "\" ("
- << cacheHitCount << " hits, " << cacheMissCount << " misses out of "
- << totalCacheAccessCount << " accesses)" << std::endl;);
return val;
} else {
- // cache miss
- ++cacheMissCount;
- TRACE("t_str_cache", tout << "cache miss: \"" << str << "\" ("
- << cacheHitCount << " hits, " << cacheMissCount << " misses out of "
- << totalCacheAccessCount << " accesses)" << std::endl;);
- val = m_strutil.mk_string(str);
+ val = u.str.mk_string(str);
m_trail.push_back(val);
stringConstantCache.insert(str, val);
return val;
}
} else {
- return m_strutil.mk_string(str);
+ return u.str.mk_string(str);
}
}
expr * theory_str::mk_string(const char * str) {
- std::string valStr(str);
- return mk_string(valStr);
+ symbol sym(str);
+ return u.str.mk_string(sym);
}
void theory_str::initialize_charset() {
@@ -210,25 +200,6 @@ void theory_str::assert_implication(expr * premise, expr * conclusion) {
}
bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
- /*
- TRACE("t_str", tout << "internalizing atom: " << mk_ismt2_pp(atom, get_manager()) << std::endl;);
- SASSERT(atom->get_family_id() == get_family_id());
-
- context & ctx = get_context();
-
- if (ctx.b_internalized(atom))
- return true;
-
- unsigned num_args = atom->get_num_args();
- for (unsigned i = 0; i < num_args; i++)
- ctx.internalize(atom->get_arg(i), false);
-
- literal l(ctx.mk_bool_var(atom));
-
- ctx.set_var_theory(l.var(), get_id());
-
- return true;
- */
return internalize_term(atom);
}
@@ -267,10 +238,9 @@ bool theory_str::internalize_term(app * term) {
theory_var v = mk_var(e);
TRACE("t_str_detail", tout << "term has theory var #" << v << std::endl;);
- if (opt_EagerStringConstantLengthAssertions && m_strutil.is_string(term)) {
+ if (opt_EagerStringConstantLengthAssertions && u.str.is_string(term)) {
TRACE("t_str", tout << "eagerly asserting length of string term " << mk_pp(term, m) << std::endl;);
m_basicstr_axiom_todo.insert(e);
- TRACE("t_str_axiom_bug", tout << "add " << mk_pp(e->get_owner(), m) << " to m_basicstr_axiom_todo" << std::endl;);
}
return true;
}
@@ -295,7 +265,7 @@ void theory_str::refresh_theory_var(expr * e) {
theory_var theory_str::mk_var(enode* n) {
TRACE("t_str_detail", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;);
ast_manager & m = get_manager();
- if (!(is_sort_of(m.get_sort(n->get_owner()), m_strutil.get_fid(), STRING_SORT))) {
+ if (!(is_sort_of(m.get_sort(n->get_owner()), u.get_family_id(), _STRING_SORT))) {
return null_theory_var;
}
if (is_attached_to_var(n)) {
@@ -413,7 +383,7 @@ void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode)
void theory_str::check_and_init_cut_var(expr * node) {
if (cut_var_map.contains(node)) {
return;
- } else if (!m_strutil.is_string(node)) {
+ } else if (!u.str.is_string(node)) {
add_cut_info_one_node(node, -1, node);
}
}
@@ -511,7 +481,7 @@ app * theory_str::mk_str_var(std::string name) {
TRACE("t_str_detail", tout << "creating string variable " << name << " at scope level " << sLevel << std::endl;);
- sort * string_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ sort * string_sort = u.str.mk_string_sort();
app * a = m.mk_fresh_const(name.c_str(), string_sort);
TRACE("t_str_detail", tout << "a->get_family_id() = " << a->get_family_id() << std::endl
@@ -538,7 +508,7 @@ app * theory_str::mk_regex_rep_var() {
context & ctx = get_context();
ast_manager & m = get_manager();
- sort * string_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ sort * string_sort = u.str.mk_string_sort();
app * a = m.mk_fresh_const("regex", string_sort);
ctx.internalize(a, false);
@@ -590,7 +560,7 @@ app * theory_str::mk_nonempty_str_var() {
TRACE("t_str_detail", tout << "creating nonempty string variable " << name << " at scope level " << sLevel << std::endl;);
- sort * string_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ sort * string_sort = u.str.mk_string_sort();
app * a = m.mk_fresh_const(name.c_str(), string_sort);
ctx.internalize(a, false);
@@ -642,8 +612,7 @@ app * theory_str::mk_unroll(expr * n, expr * bound) {
}
app * theory_str::mk_contains(expr * haystack, expr * needle) {
- expr * args[2] = {haystack, needle};
- app * contains = get_manager().mk_app(get_id(), OP_STR_CONTAINS, 0, 0, 2, args);
+ app * contains = u.str.mk_contains(haystack, needle); // TODO double-check semantics/argument order
m_trail.push_back(contains);
// immediately force internalization so that axiom setup does not fail
get_context().internalize(contains, false);
@@ -652,8 +621,8 @@ app * theory_str::mk_contains(expr * haystack, expr * needle) {
}
app * theory_str::mk_indexof(expr * haystack, expr * needle) {
- expr * args[2] = {haystack, needle};
- app * indexof = get_manager().mk_app(get_id(), OP_STR_INDEXOF, 0, 0, 2, args);
+ // TODO check meaning of the third argument here
+ app * indexof = u.str.mk_index(haystack, needle, mk_int(0));
m_trail.push_back(indexof);
// immediately force internalization so that axiom setup does not fail
get_context().internalize(indexof, false);
@@ -663,25 +632,23 @@ app * theory_str::mk_indexof(expr * haystack, expr * needle) {
app * theory_str::mk_strlen(expr * e) {
/*if (m_strutil.is_string(e)) {*/ if (false) {
- const char * strval = 0;
- m_strutil.is_string(e, &strval);
- int len = strlen(strval);
+ zstring strval;
+ u.str.is_string(e, strval);
+ unsigned int len = strval.length();
return m_autil.mk_numeral(rational(len), true);
} else {
if (false) {
// use cache
app * lenTerm = NULL;
if (!length_ast_map.find(e, lenTerm)) {
- expr * args[1] = {e};
- lenTerm = get_manager().mk_app(get_id(), OP_STRLEN, 0, 0, 1, args);
+ lenTerm = u.str.mk_length(e);
length_ast_map.insert(e, lenTerm);
m_trail.push_back(lenTerm);
}
return lenTerm;
} else {
// always regen
- expr * args[1] = {e};
- return get_manager().mk_app(get_id(), OP_STRLEN, 0, 0, 1, args);
+ return u.str.mk_length(e);
}
}
}
@@ -699,24 +666,22 @@ expr * theory_str::mk_concat_const_str(expr * n1, expr * n2) {
expr * v1 = get_eqc_value(n1, n1HasEqcValue);
expr * v2 = get_eqc_value(n2, n2HasEqcValue);
if (n1HasEqcValue && n2HasEqcValue) {
- const char * n1_str_tmp;
- m_strutil.is_string(v1, & n1_str_tmp);
- std::string n1_str(n1_str_tmp);
- const char * n2_str_tmp;
- m_strutil.is_string(v2, & n2_str_tmp);
- std::string n2_str(n2_str_tmp);
- std::string result = n1_str + n2_str;
+ zstring n1_str;
+ u.str.is_string(v1, n1_str);
+ zstring n2_str;
+ u.str.is_string(v2, n2_str);
+ zstring result = n1_str + n2_str;
return mk_string(result);
} else if (n1HasEqcValue && !n2HasEqcValue) {
- const char * n1_str_tmp;
- m_strutil.is_string(v1, & n1_str_tmp);
- if (strcmp(n1_str_tmp, "") == 0) {
+ zstring n1_str;
+ u.str.is_string(v1, n1_str);
+ if (n1_str.empty()) {
return n2;
}
} else if (!n1HasEqcValue && n2HasEqcValue) {
- const char * n2_str_tmp;
- m_strutil.is_string(v2, & n2_str_tmp);
- if (strcmp(n2_str_tmp, "") == 0) {
+ zstring n2_str;
+ u.str.is_string(v2, n2_str);
+ if (n2_str.empty()) {
return n1;
}
}
@@ -735,38 +700,42 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
if (n1HasEqcValue && n2HasEqcValue) {
return mk_concat_const_str(n1, n2);
} else if (n1HasEqcValue && !n2HasEqcValue) {
- bool n2_isConcatFunc = is_concat(to_app(n2));
- if (m_strutil.get_string_constant_value(n1) == "") {
+ bool n2_isConcatFunc = u.str.is_concat(to_app(n2));
+ zstring n1_str;
+ u.str.is_string(n1, n1_str);
+ if (n1_str.empty()) {
return n2;
}
if (n2_isConcatFunc) {
expr * n2_arg0 = to_app(n2)->get_arg(0);
expr * n2_arg1 = to_app(n2)->get_arg(1);
- if (m_strutil.is_string(n2_arg0)) {
+ if (u.str.is_string(n2_arg0)) {
n1 = mk_concat_const_str(n1, n2_arg0); // n1 will be a constant
n2 = n2_arg1;
}
}
} else if (!n1HasEqcValue && n2HasEqcValue) {
- if (m_strutil.get_string_constant_value(n2) == "") {
+ zstring n2_str;
+ u.str.is_string(n2, n2_str);
+ if (n2_str.empty()) {
return n1;
}
- if (is_concat(to_app(n1))) {
+ if (u.str.is_concat(to_app(n1))) {
expr * n1_arg0 = to_app(n1)->get_arg(0);
expr * n1_arg1 = to_app(n1)->get_arg(1);
- if (m_strutil.is_string(n1_arg1)) {
+ if (u.str.is_string(n1_arg1)) {
n1 = n1_arg0;
n2 = mk_concat_const_str(n1_arg1, n2); // n2 will be a constant
}
}
} else {
- if (is_concat(to_app(n1)) && is_concat(to_app(n2))) {
+ if (u.str.is_concat(to_app(n1)) && u.str.is_concat(to_app(n2))) {
expr * n1_arg0 = to_app(n1)->get_arg(0);
expr * n1_arg1 = to_app(n1)->get_arg(1);
expr * n2_arg0 = to_app(n2)->get_arg(0);
expr * n2_arg1 = to_app(n2)->get_arg(1);
- if (m_strutil.is_string(n1_arg1) && m_strutil.is_string(n2_arg0)) {
+ if (u.str.is_string(n1_arg1) && u.str.is_string(n2_arg0)) {
expr * tmpN1 = n1_arg0;
expr * tmpN2 = mk_concat_const_str(n1_arg1, n2_arg0);
n1 = mk_concat(tmpN1, tmpN2);
@@ -784,8 +753,7 @@ expr * theory_str::mk_concat(expr * n1, expr * n2) {
expr * concatAst = NULL;
if (!concat_astNode_map.find(n1, n2, concatAst)) {
- expr * args[2] = {n1, n2};
- concatAst = m.mk_app(get_id(), OP_STRCAT, 0, 0, 2, args);
+ concatAst = u.str.mk_concat(n1, n2);
m_trail.push_back(concatAst);
concat_astNode_map.insert(n1, n2, concatAst);
@@ -841,25 +809,30 @@ void theory_str::propagate() {
for (unsigned i = 0; i < m_library_aware_axiom_todo.size(); ++i) {
enode * e = m_library_aware_axiom_todo[i];
- if (is_str_to_int(e)) {
+ app * a = e->get_owner();
+ if (u.str.is_stoi(a)) {
instantiate_axiom_str_to_int(e);
- } else if (is_int_to_str(e)) {
+ } else if (u.str.is_itos(a)) {
instantiate_axiom_int_to_str(e);
- } else if (is_CharAt(e)) {
+ } else if (u.str.is_at(a)) {
instantiate_axiom_CharAt(e);
+ /* TODO NEXT: StartsWith/EndsWith -> prefixof/suffixof
} else if (is_StartsWith(e)) {
instantiate_axiom_StartsWith(e);
} else if (is_EndsWith(e)) {
instantiate_axiom_EndsWith(e);
- } else if (is_Contains(e)) {
+ */
+ } else if (u.str.is_contains(a)) {
instantiate_axiom_Contains(e);
- } else if (is_Indexof(e)) {
+ } else if (u.str.is_index(a)) {
instantiate_axiom_Indexof(e);
+ /* TODO NEXT: Indexof2/Lastindexof rewrite?
} else if (is_Indexof2(e)) {
instantiate_axiom_Indexof2(e);
} else if (is_LastIndexof(e)) {
instantiate_axiom_LastIndexof(e);
- } else if (is_Substr(e)) {
+ */
+ } else if (u.str.is_substr(a)) {
instantiate_axiom_Substr(e);
} else if (is_Replace(e)) {
instantiate_axiom_Replace(e);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 6b1ce9023..63f5d3cfc 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -27,32 +27,13 @@ Revision History:
#include<set>
#include<stack>
#include<vector>
-#include"str_rewriter.h"
+#include<map>
+#include"seq_decl_plugin.h"
#include"union_find.h"
+#include"theory_seq_empty.h"
namespace smt {
- class str_value_factory : public value_factory {
- str_util m_util;
- public:
- str_value_factory(ast_manager & m, family_id fid) :
- value_factory(m, fid),
- m_util(m) {}
- virtual ~str_value_factory() {}
- virtual expr * get_some_value(sort * s) {
- return m_util.mk_string("some value");
- }
- virtual bool get_some_values(sort * s, expr_ref & v1, expr_ref & v2) {
- v1 = m_util.mk_string("value 1");
- v2 = m_util.mk_string("value 2");
- return true;
- }
- virtual expr * get_fresh_value(sort * s) {
- return m_util.mk_fresh_string();
- }
- virtual void register_value(expr * n) { /* Ignore */ }
- };
-
// rather than modify obj_pair_map I inherit from it and add my own helper methods
class theory_str_contain_pair_bool_map_t : public obj_pair_map<expr, expr, expr*> {
public:
@@ -110,12 +91,12 @@ namespace smt {
typedef union_find<theory_str> th_union_find;
typedef map<rational, expr*, obj_hash<rational>, default_eq<rational> > rational_map;
- struct str_hash_proc {
- unsigned operator()(std::string const & s) const {
- return string_hash(s.c_str(), static_cast<unsigned>(s.length()), 17);
+ struct zstring_hash_proc {
+ unsigned operator()(zstring const & s) const {
+ return string_hash(s.encode().c_str(), static_cast<unsigned>(s.length()), 17);
}
};
- typedef map<std::string, expr*, str_hash_proc, default_eq<std::string> > string_map;
+ typedef map<zstring, expr*, zstring_hash_proc, default_eq<zstring> > string_map;
protected:
theory_str_params const & m_params;
@@ -188,14 +169,14 @@ namespace smt {
bool search_started;
arith_util m_autil;
- str_util m_strutil;
+ seq_util u;
int sLevel;
bool finalCheckProgressIndicator;
expr_ref_vector m_trail; // trail for generated terms
- str_value_factory * m_factory;
+ seq_factory * m_factory;
// terms we couldn't go through set_up_axioms() with because they weren't internalized
expr_ref_vector m_delayed_axiom_setup_terms;
@@ -259,7 +240,7 @@ namespace smt {
std::map<std::pair<expr*, std::string>, expr*> regex_in_bool_map;
std::map<expr*, std::set<std::string> > regex_in_var_reg_str_map;
- std::map<expr*, nfa> regex_nfa_cache; // Regex term --> NFA
+ // std::map<expr*, nfa> regex_nfa_cache; // Regex term --> NFA
char * char_set;
std::map<char, int> charSetLookupTable;
@@ -327,7 +308,7 @@ namespace smt {
void assert_implication(expr * premise, expr * conclusion);
expr * rewrite_implication(expr * premise, expr * conclusion);
- expr * mk_string(std::string str);
+ expr * mk_string(zstring const& str);
expr * mk_string(const char * str);
app * mk_strlen(expr * e);
@@ -359,48 +340,6 @@ namespace smt {
app * mk_unroll_test_var();
void add_nonempty_constraint(expr * s);
- bool is_concat(app const * a) const { return a->is_app_of(get_id(), OP_STRCAT); }
- bool is_concat(enode const * n) const { return is_concat(n->get_owner()); }
- bool is_string(app const * a) const { return a->is_app_of(get_id(), OP_STR); }
- bool is_string(enode const * n) const { return is_string(n->get_owner()); }
- bool is_strlen(app const * a) const { return a->is_app_of(get_id(), OP_STRLEN); }
- bool is_strlen(enode const * n) const { return is_strlen(n->get_owner()); }
- bool is_CharAt(app const * a) const { return a->is_app_of(get_id(), OP_STR_CHARAT); }
- bool is_CharAt(enode const * n) const { return is_CharAt(n->get_owner()); }
- bool is_StartsWith(app const * a) const { return a->is_app_of(get_id(), OP_STR_STARTSWITH); }
- bool is_StartsWith(enode const * n) const { return is_StartsWith(n->get_owner()); }
- bool is_EndsWith(app const * a) const { return a->is_app_of(get_id(), OP_STR_ENDSWITH); }
- bool is_EndsWith(enode const * n) const { return is_EndsWith(n->get_owner()); }
- bool is_Contains(app const * a) const { return a->is_app_of(get_id(), OP_STR_CONTAINS); }
- bool is_Contains(enode const * n) const { return is_Contains(n->get_owner()); }
- bool is_Indexof(app const * a) const { return a->is_app_of(get_id(), OP_STR_INDEXOF); }
- bool is_Indexof(enode const * n) const { return is_Indexof(n->get_owner()); }
- bool is_Indexof2(app const * a) const { return a->is_app_of(get_id(), OP_STR_INDEXOF2); }
- bool is_Indexof2(enode const * n) const { return is_Indexof2(n->get_owner()); }
- bool is_LastIndexof(app const * a) const { return a->is_app_of(get_id(), OP_STR_LASTINDEXOF); }
- bool is_LastIndexof(enode const * n) const { return is_LastIndexof(n->get_owner()); }
- bool is_Substr(app const * a) const { return a->is_app_of(get_id(), OP_STR_SUBSTR); }
- bool is_Substr(enode const * n) const { return is_Substr(n->get_owner()); }
- bool is_Replace(app const * a) const { return a->is_app_of(get_id(), OP_STR_REPLACE); }
- bool is_Replace(enode const * n) const { return is_Replace(n->get_owner()); }
- bool is_str_to_int(app const * a) const { return a->is_app_of(get_id(), OP_STR_STR2INT); }
- bool is_str_to_int(enode const * n) const { return is_str_to_int(n->get_owner()); }
- bool is_int_to_str(app const * a) const { return a->is_app_of(get_id(), OP_STR_INT2STR); }
- bool is_int_to_str(enode const * n) const { return is_int_to_str(n->get_owner()); }
-
- bool is_RegexIn(app const * a) const { return a->is_app_of(get_id(), OP_RE_REGEXIN); }
- bool is_RegexIn(enode const * n) const { return is_RegexIn(n->get_owner()); }
- bool is_RegexConcat(app const * a) const { return a->is_app_of(get_id(), OP_RE_REGEXCONCAT); }
- bool is_RegexConcat(enode const * n) const { return is_RegexConcat(n->get_owner()); }
- bool is_RegexStar(app const * a) const { return a->is_app_of(get_id(), OP_RE_REGEXSTAR); }
- bool is_RegexStar(enode const * n) const { return is_RegexStar(n->get_owner()); }
- bool is_RegexUnion(app const * a) const { return a->is_app_of(get_id(), OP_RE_REGEXUNION); }
- bool is_RegexUnion(enode const * n) const { return is_RegexUnion(n->get_owner()); }
- bool is_Str2Reg(app const * a) const { return a->is_app_of(get_id(), OP_RE_STR2REGEX); }
- bool is_Str2Reg(enode const * n) const { return is_Str2Reg(n->get_owner()); }
- bool is_Unroll(app const * a) const { return a->is_app_of(get_id(), OP_RE_UNROLL); }
- bool is_Unroll(enode const * n) const { return is_Unroll(n->get_owner()); }
-
void instantiate_concat_axiom(enode * cat);
void try_eval_concat(enode * cat);
void instantiate_basic_string_axioms(enode * str);
From 3f1ceedcb14b0ecef4f9f73bb24fec296857c9c8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 27 Feb 2017 20:48:55 -0500
Subject: [PATCH 349/401] theory_str refactor pass 2
---
src/smt/theory_str.cpp | 932 +++++++++++++++++++++--------------------
src/smt/theory_str.h | 57 ++-
2 files changed, 529 insertions(+), 460 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 1d56c43a4..6585bd7f2 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -23,6 +23,7 @@ Revision History:
#include<list>
#include<vector>
#include<algorithm>
+#include"theory_seq_empty.h"
#include "../ast/ast.h"
#include"theory_arith.h"
@@ -832,11 +833,12 @@ void theory_str::propagate() {
} else if (is_LastIndexof(e)) {
instantiate_axiom_LastIndexof(e);
*/
- } else if (u.str.is_substr(a)) {
+ } else if (u.str.is_extract(a)) {
+ // TODO check semantics of substr vs. extract
instantiate_axiom_Substr(e);
- } else if (is_Replace(e)) {
+ } else if (u.str.is_replace(a)) {
instantiate_axiom_Replace(e);
- } else if (is_RegexIn(e)) {
+ } else if (u.str.is_in_re(a)) {
instantiate_axiom_RegexIn(e);
} else {
TRACE("t_str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_owner(), get_manager()) << std::endl;);
@@ -861,8 +863,8 @@ void theory_str::propagate() {
*/
void theory_str::try_eval_concat(enode * cat) {
- SASSERT(is_concat(cat));
app * a_cat = cat->get_owner();
+ SASSERT(u.str.is_concat(a_cat));
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -870,7 +872,7 @@ void theory_str::try_eval_concat(enode * cat) {
TRACE("t_str_detail", tout << "attempting to flatten " << mk_pp(a_cat, m) << std::endl;);
std::stack<app*> worklist;
- std::string flattenedString("");
+ zstring flattenedString("");
bool constOK = true;
{
@@ -883,10 +885,10 @@ void theory_str::try_eval_concat(enode * cat) {
while (constOK && !worklist.empty()) {
app * evalArg = worklist.top(); worklist.pop();
- if (m_strutil.is_string(evalArg)) {
- std::string nextStr = m_strutil.get_string_constant_value(evalArg);
- flattenedString.append(nextStr);
- } else if (is_concat(evalArg)) {
+ zstring nextStr;
+ if (u.str.is_string(evalArg, nextStr)) {
+ flattenedString += nextStr;
+ } else if (u.str.is_concat(evalArg)) {
app * arg0 = to_app(evalArg->get_arg(0));
app * arg1 = to_app(evalArg->get_arg(1));
@@ -899,7 +901,7 @@ void theory_str::try_eval_concat(enode * cat) {
}
}
if (constOK) {
- TRACE("t_str_detail", tout << "flattened to \"" << flattenedString << "\"" << std::endl;);
+ TRACE("t_str_detail", tout << "flattened to \"" << flattenedString.encode().c_str() << "\"" << std::endl;);
expr_ref constStr(mk_string(flattenedString), m);
expr_ref axiom(ctx.mk_eq_atom(a_cat, constStr), m);
assert_axiom(axiom);
@@ -911,8 +913,8 @@ void theory_str::try_eval_concat(enode * cat) {
* Length(Concat(x, y)) = Length(x) + Length(y)
*/
void theory_str::instantiate_concat_axiom(enode * cat) {
- SASSERT(is_concat(cat));
app * a_cat = cat->get_owner();
+ SASSERT(u.str.is_concat(a_cat));
ast_manager & m = get_manager();
@@ -969,15 +971,15 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
// generate a stronger axiom for constant strings
app * a_str = str->get_owner();
- if (m_strutil.is_string(str->get_owner())) {
+ if (u.str.is_string(a_str)) {
expr_ref len_str(m);
len_str = mk_strlen(a_str);
SASSERT(len_str);
- const char * strconst = 0;
- m_strutil.is_string(str->get_owner(), & strconst);
- TRACE("t_str_detail", tout << "instantiating constant string axioms for \"" << strconst << "\"" << std::endl;);
- int l = strlen(strconst);
+ zstring strconst;
+ u.str.is_string(str->get_owner(), strconst);
+ TRACE("t_str_detail", tout << "instantiating constant string axioms for \"" << strconst.encode().c_str() << "\"" << std::endl;);
+ unsigned int l = strconst.length();
expr_ref len(m_autil.mk_numeral(rational(l), true), m);
literal lit(mk_eq(len_str, len, false));
@@ -1186,12 +1188,11 @@ void theory_str::instantiate_axiom_Contains(enode * e) {
axiomatized_terms.insert(ex);
// quick path, because this is necessary due to rewriter behaviour
- // (at minimum it should fix z3str/concat-006.smt2
- if (m_strutil.is_string(ex->get_arg(0)) && m_strutil.is_string(ex->get_arg(1))) {
+ // at minimum it should fix z3str/concat-006.smt2
+ zstring haystackStr, needleStr;
+ if (u.str.is_string(ex->get_arg(0), haystackStr) && u.str.is_string(ex->get_arg(1), needleStr)) {
TRACE("t_str_detail", tout << "eval constant Contains term " << mk_pp(ex, m) << std::endl;);
- std::string haystackStr = m_strutil.get_string_constant_value(ex->get_arg(0));
- std::string needleStr = m_strutil.get_string_constant_value(ex->get_arg(1));
- if (haystackStr.find(needleStr) != std::string::npos) {
+ if (haystackStr.contains(needleStr)) {
assert_axiom(ex);
} else {
assert_axiom(m.mk_not(ex));
@@ -1378,8 +1379,8 @@ void theory_str::instantiate_axiom_LastIndexof(enode * e) {
thenItems.push_back(ctx.mk_eq_atom(indexAst, mk_strlen(x1)));
bool canSkip = false;
- if (m_strutil.is_string(expr->get_arg(1))) {
- std::string arg1Str = m_strutil.get_string_constant_value(expr->get_arg(1));
+ zstring arg1Str;
+ if (u.str.is_string(expr->get_arg(1), arg1Str)) {
if (arg1Str.length() == 1) {
canSkip = true;
}
@@ -1503,30 +1504,6 @@ void theory_str::instantiate_axiom_Substr(enode * e) {
expr_ref finalAxiom(m.mk_and(case1, case2, case3), m);
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
-
- /*
- expr_ref ts0(mk_str_var("ts0"), m);
- expr_ref ts1(mk_str_var("ts1"), m);
- expr_ref ts2(mk_str_var("ts2"), m);
-
- expr_ref ts0_contains_ts1(mk_contains(expr->get_arg(0), ts1), m);
-
- expr_ref_vector and_item(m);
- //and_item.push_back(ts0_contains_ts1);
- and_item.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, mk_concat(ts1, ts2))));
- and_item.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_strlen(ts0)));
- and_item.push_back(ctx.mk_eq_atom(expr->get_arg(2), mk_strlen(ts1)));
-
- expr_ref breakdownAssert(m.mk_and(and_item.size(), and_item.c_ptr()), m);
- SASSERT(breakdownAssert);
-
- expr_ref reduceToVar(ctx.mk_eq_atom(expr, ts1), m);
- SASSERT(reduceToVar);
-
- expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToVar), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
- */
}
void theory_str::instantiate_axiom_Replace(enode * e) {
@@ -1651,14 +1628,58 @@ void theory_str::instantiate_axiom_int_to_str(enode * e) {
}
expr * theory_str::mk_RegexIn(expr * str, expr * regexp) {
- expr * args[2] = {str, regexp};
- app * regexIn = get_manager().mk_app(get_id(), OP_RE_REGEXIN, 0, 0, 2, args);
+ app * regexIn = u.re.mk_in_re(str, regexp);
// immediately force internalization so that axiom setup does not fail
get_context().internalize(regexIn, false);
set_up_axioms(regexIn);
return regexIn;
}
+static zstring str2RegexStr(zstring str) {
+ zstring res("");
+ int len = str.length();
+ for (int i = 0; i < len; i++) {
+ char nc = str[i];
+ // 12 special chars
+ if (nc == '\\' || nc == '^' || nc == '$' || nc == '.' || nc == '|' || nc == '?'
+ || nc == '*' || nc == '+' || nc == '(' || nc == ')' || nc == '[' || nc == '{') {
+ res += zstring("\\");
+ }
+ res += zstring(1, (unsigned)str[i]);
+ }
+ return res;
+}
+
+zstring theory_str::get_std_regex_str(expr * regex) {
+ app * a_regex = to_app(regex);
+ if (u.re.is_to_re(a_regex)) {
+ expr * regAst = a_regex->get_arg(0);
+ zstring regAstVal;
+ u.str.is_string(regAst, regAstVal);
+ zstring regStr = str2RegexStr(regAstVal);
+ return regStr;
+ } else if (u.re.is_concat(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ expr * reg2Ast = a_regex->get_arg(1);
+ zstring reg1Str = get_std_regex_str(reg1Ast);
+ zstring reg2Str = get_std_regex_str(reg2Ast);
+ return zstring("(") + reg1Str + zstring(")(") + reg2Str + zstring(")");
+ } else if (u.re.is_union(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ expr * reg2Ast = a_regex->get_arg(1);
+ zstring reg1Str = get_std_regex_str(reg1Ast);
+ zstring reg2Str = get_std_regex_str(reg2Ast);
+ return zstring("(") + reg1Str + zstring(")|(") + reg2Str + zstring(")");
+ } else if (u.re.is_star(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ zstring reg1Str = get_std_regex_str(reg1Ast);
+ return zstring("(") + reg1Str + zstring(")*");
+ } else {
+ TRACE("t_str", tout << "BUG: unrecognized regex term " << mk_pp(regex, get_manager()) << std::endl;);
+ UNREACHABLE(); return zstring("");
+ }
+}
+
void theory_str::instantiate_axiom_RegexIn(enode * e) {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -1673,8 +1694,8 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
TRACE("t_str_detail", tout << "instantiate RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
{
- std::string regexStr = m_strutil.get_std_regex_str(ex->get_arg(1));
- std::pair<expr*, std::string> key1(ex->get_arg(0), regexStr);
+ zstring regexStr = get_std_regex_str(ex->get_arg(1));
+ std::pair<expr*, zstring> key1(ex->get_arg(0), regexStr);
// skip Z3str's map check, because we already check if we set up axioms on this term
regex_in_bool_map[key1] = ex;
regex_in_var_reg_str_map[ex->get_arg(0)].insert(regexStr);
@@ -1683,7 +1704,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
expr_ref str(ex->get_arg(0), m);
app * regex = to_app(ex->get_arg(1));
- if (is_Str2Reg(regex)) {
+ if (u.re.is_to_re(regex)) {
expr_ref rxStr(regex->get_arg(0), m);
// want to assert 'expr IFF (str == rxStr)'
expr_ref rhs(ctx.mk_eq_atom(str, rxStr), m);
@@ -1691,7 +1712,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
TRACE("t_str", tout << "set up Str2Reg: (RegexIn " << mk_pp(str, m) << " " << mk_pp(regex, m) << ")" << std::endl;);
- } else if (is_RegexConcat(regex)) {
+ } else if (u.re.is_concat(regex)) {
expr_ref var1(mk_regex_rep_var(), m);
expr_ref var2(mk_regex_rep_var(), m);
expr_ref rhs(mk_concat(var1, var2), m);
@@ -1708,7 +1729,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
expr_ref finalAxiom(mk_and(items), m);
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
- } else if (is_RegexUnion(regex)) {
+ } else if (u.re.is_union(regex)) {
expr_ref var1(mk_regex_rep_var(), m);
expr_ref var2(mk_regex_rep_var(), m);
expr_ref orVar(m.mk_or(ctx.mk_eq_atom(str, var1), ctx.mk_eq_atom(str, var2)), m);
@@ -1721,7 +1742,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
items.push_back(var2InRegex2);
items.push_back(ctx.mk_eq_atom(ex, orVar));
assert_axiom(mk_and(items));
- } else if (is_RegexStar(regex)) {
+ } else if (u.re.is_star(regex)) {
// slightly more complex due to the unrolling step.
expr_ref regex1(regex->get_arg(0), m);
expr_ref unrollCount(mk_unroll_bound_var(), m);
@@ -1852,13 +1873,13 @@ void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::se
expr * eqcNode = n;
do {
app * ast = to_app(eqcNode);
- if (is_concat(ast)) {
+ if (u.str.is_concat(ast)) {
expr * simConcat = simplify_concat(ast);
if (simConcat != ast) {
- if (is_concat(to_app(simConcat))) {
+ if (u.str.is_concat(to_app(simConcat))) {
concats.insert(simConcat);
} else {
- if (m_strutil.is_string(simConcat)) {
+ if (u.str.is_string(simConcat)) {
consts.insert(simConcat);
} else {
vars.insert(simConcat);
@@ -1867,7 +1888,7 @@ void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::se
} else {
concats.insert(simConcat);
}
- } else if (is_string(ast)) {
+ } else if (u.str.is_string(ast)) {
consts.insert(ast);
} else {
vars.insert(ast);
@@ -1878,7 +1899,7 @@ void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::se
void theory_str::get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList) {
app * a_node = to_app(node);
- if (!is_concat(a_node)) {
+ if (!u.str.is_concat(a_node)) {
nodeList.push_back(node);
return;
} else {
@@ -1901,16 +1922,21 @@ expr * theory_str::eval_concat(expr * n1, expr * n2) {
expr * v1 = get_eqc_value(n1, n1HasEqcValue);
expr * v2 = get_eqc_value(n2, n2HasEqcValue);
if (n1HasEqcValue && n2HasEqcValue) {
- std::string n1_str = m_strutil.get_string_constant_value(v1);
- std::string n2_str = m_strutil.get_string_constant_value(v2);
- std::string result = n1_str + n2_str;
+ zstring n1_str, n2_str;
+ u.str.is_string(v1, n1_str);
+ u.str.is_string(v2, n2_str);
+ zstring result = n1_str + n2_str;
return mk_string(result);
} else if (n1HasEqcValue && !n2HasEqcValue) {
- if (m_strutil.get_string_constant_value(v1) == "") {
+ zstring v1_str;
+ u.str.is_string(v1, v1_str);
+ if (v1_str.empty()) {
return n2;
}
} else if (n2HasEqcValue && !n1HasEqcValue) {
- if (m_strutil.get_string_constant_value(v2) == "") {
+ zstring v2_str;
+ u.str.is_string(v2, v2_str);
+ if (v2_str.empty()) {
return n1;
}
}
@@ -1943,7 +1969,8 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
ctx.internalize(nn, false);
- std::string eq_strValue = m_strutil.get_string_constant_value(eq_str);
+ zstring eq_strValue;
+ u.str.is_string(eq_str, eq_strValue);
expr * n_eqNode = nn;
do {
enode * n_eq_enode = ctx.get_enode(n_eqNode);
@@ -1966,7 +1993,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
app * a_parent = e_parent->get_owner();
TRACE("t_str_detail", tout << "considering parent " << mk_ismt2_pp(a_parent, m) << std::endl;);
- if (is_concat(a_parent)) {
+ if (u.str.is_concat(a_parent)) {
expr * arg0 = a_parent->get_arg(0);
expr * arg1 = a_parent->get_arg(1);
@@ -2028,7 +2055,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
assert_implication(implyL, implyR);
}
- } else if (is_concat(to_app(n_eqNode))) {
+ } else if (u.str.is_concat(to_app(n_eqNode))) {
expr_ref simpleConcat(m);
simpleConcat = mk_concat(eq_str, arg1);
if (!in_same_eqc(a_parent, simpleConcat)) {
@@ -2097,7 +2124,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
assert_implication(implyL, implyR);
}
- } else if (is_concat(to_app(n_eqNode))) {
+ } else if (u.str.is_concat(to_app(n_eqNode))) {
expr_ref simpleConcat(m);
simpleConcat = mk_concat(arg0, eq_str);
if (!in_same_eqc(a_parent, simpleConcat)) {
@@ -2116,11 +2143,11 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
//---------------------------------------------------------
// Case (2-1) begin: (Concat n_eqNode (Concat str var))
- if (arg0 == n_eqNode && is_concat(to_app(arg1))) {
+ if (arg0 == n_eqNode && u.str.is_concat(to_app(arg1))) {
app * a_arg1 = to_app(arg1);
TRACE("t_str_detail", tout << "simplify_parent #3" << std::endl;);
expr * r_concat_arg0 = a_arg1->get_arg(0);
- if (m_strutil.is_string(r_concat_arg0)) {
+ if (u.str.is_string(r_concat_arg0)) {
expr * combined_str = eval_concat(eq_str, r_concat_arg0);
SASSERT(combined_str);
expr * r_concat_arg1 = a_arg1->get_arg(1);
@@ -2140,11 +2167,11 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
//---------------------------------------------------------
// Case (2-2) begin: (Concat (Concat var str) n_eqNode)
- if (is_concat(to_app(arg0)) && arg1 == n_eqNode) {
+ if (u.str.is_concat(to_app(arg0)) && arg1 == n_eqNode) {
app * a_arg0 = to_app(arg0);
TRACE("t_str_detail", tout << "simplify_parent #4" << std::endl;);
expr * l_concat_arg1 = a_arg0->get_arg(1);
- if (m_strutil.is_string(l_concat_arg1)) {
+ if (u.str.is_string(l_concat_arg1)) {
expr * combined_str = eval_concat(l_concat_arg1, eq_str);
SASSERT(combined_str);
expr * l_concat_arg0 = a_arg0->get_arg(0);
@@ -2169,10 +2196,10 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
concat_parent_it != e_parent->end_parents(); concat_parent_it++) {
enode * e_concat_parent = *concat_parent_it;
app * concat_parent = e_concat_parent->get_owner();
- if (is_concat(concat_parent)) {
+ if (u.str.is_concat(concat_parent)) {
expr * concat_parent_arg0 = concat_parent->get_arg(0);
expr * concat_parent_arg1 = concat_parent->get_arg(1);
- if (concat_parent_arg0 == a_parent && m_strutil.is_string(concat_parent_arg1)) {
+ if (concat_parent_arg0 == a_parent && u.str.is_string(concat_parent_arg1)) {
TRACE("t_str_detail", tout << "simplify_parent #5" << std::endl;);
expr * combinedStr = eval_concat(eq_str, concat_parent_arg1);
SASSERT(combinedStr);
@@ -2195,10 +2222,10 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
concat_parent_it != e_parent->end_parents(); concat_parent_it++) {
enode * e_concat_parent = *concat_parent_it;
app * concat_parent = e_concat_parent->get_owner();
- if (is_concat(concat_parent)) {
+ if (u.str.is_concat(concat_parent)) {
expr * concat_parent_arg0 = concat_parent->get_arg(0);
expr * concat_parent_arg1 = concat_parent->get_arg(1);
- if (concat_parent_arg1 == a_parent && m_strutil.is_string(concat_parent_arg0)) {
+ if (concat_parent_arg1 == a_parent && u.str.is_string(concat_parent_arg0)) {
TRACE("t_str_detail", tout << "simplify_parent #6" << std::endl;);
expr * combinedStr = eval_concat(concat_parent_arg0, eq_str);
SASSERT(combinedStr);
@@ -2376,7 +2403,7 @@ void theory_str::infer_len_concat_equality(expr * nn1, expr * nn2) {
// Known: a1_arg0 and a1_arg1
// Unknown: nn1
- if (is_concat(to_app(nn1))) {
+ if (u.str.is_concat(to_app(nn1))) {
rational nn1ConcatLen;
bool nn1ConcatLen_exists = infer_len_concat(nn1, nn1ConcatLen);
if (nnLen_exists && nn1ConcatLen_exists) {
@@ -2388,7 +2415,7 @@ void theory_str::infer_len_concat_equality(expr * nn1, expr * nn2) {
// Known: a1_arg0 and a1_arg1
// Unknown: nn1
- if (is_concat(to_app(nn2))) {
+ if (u.str.is_concat(to_app(nn2))) {
rational nn2ConcatLen;
bool nn2ConcatLen_exists = infer_len_concat(nn2, nn2ConcatLen);
if (nnLen_exists && nn2ConcatLen_exists) {
@@ -2397,10 +2424,10 @@ void theory_str::infer_len_concat_equality(expr * nn1, expr * nn2) {
}
if (nnLen_exists) {
- if (is_concat(to_app(nn1))) {
+ if (u.str.is_concat(to_app(nn1))) {
infer_len_concat_arg(nn1, nnLen);
}
- if (is_concat(to_app(nn2))) {
+ if (u.str.is_concat(to_app(nn2))) {
infer_len_concat_arg(nn2, nnLen);
}
}
@@ -2604,17 +2631,17 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
// check whether new_nn1 and new_nn2 are still concats
- bool n1IsConcat = is_concat(a_new_nn1);
- bool n2IsConcat = is_concat(a_new_nn2);
+ bool n1IsConcat = u.str.is_concat(a_new_nn1);
+ bool n2IsConcat = u.str.is_concat(a_new_nn2);
if (!n1IsConcat && n2IsConcat) {
TRACE("t_str_detail", tout << "nn1_new is not a concat" << std::endl;);
- if (is_string(a_new_nn1)) {
+ if (u.str.is_string(a_new_nn1)) {
simplify_parent(new_nn2, new_nn1);
}
return;
} else if (n1IsConcat && !n2IsConcat) {
TRACE("t_str_detail", tout << "nn2_new is not a concat" << std::endl;);
- if (is_string(a_new_nn2)) {
+ if (u.str.is_string(a_new_nn2)) {
simplify_parent(new_nn1, new_nn2);
}
return;
@@ -2712,8 +2739,8 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
app * a_new_nn1 = to_app(new_nn1);
app * a_new_nn2 = to_app(new_nn2);
- bool n1IsConcat = is_concat(a_new_nn1);
- bool n2IsConcat = is_concat(a_new_nn2);
+ bool n1IsConcat = u.str.is_concat(a_new_nn1);
+ bool n2IsConcat = u.str.is_concat(a_new_nn2);
if (!n1IsConcat && !n2IsConcat) {
// we simplified both sides to non-concat expressions...
return false;
@@ -2766,7 +2793,7 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
- if (m_strutil.is_string(v1_arg1) && !m_strutil.is_string(v2_arg1)) {
+ if (u.str.is_string(v1_arg1) && !u.str.is_string(v2_arg1)) {
m = v1_arg0;
strAst = v1_arg1;
x = v2_arg0;
@@ -2800,7 +2827,7 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
expr * strAst = NULL;
expr * n = NULL;
- if (m_strutil.is_string(v1_arg0) && !m_strutil.is_string(v2_arg0)) {
+ if (u.str.is_string(v1_arg0) && !u.str.is_string(v2_arg0)) {
strAst = v1_arg0;
n = v1_arg1;
x = v2_arg0;
@@ -2848,7 +2875,7 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
expr * m = NULL;
expr * str2Ast = NULL;
- if (m_strutil.is_string(v1_arg0)) {
+ if (u.str.is_string(v1_arg0)) {
str1Ast = v1_arg0;
y = v1_arg1;
m = v2_arg0;
@@ -2881,7 +2908,7 @@ bool theory_str::is_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
expr * m = to_app(concatAst2)->get_arg(0);
expr * n = to_app(concatAst2)->get_arg(1);
- if (!m_strutil.is_string(x) && !m_strutil.is_string(y) && !m_strutil.is_string(m) && !m_strutil.is_string(n)) {
+ if (!u.str.is_string(x) && !u.str.is_string(y) && !u.str.is_string(m) && !u.str.is_string(n)) {
return true;
} else {
return false;
@@ -2896,11 +2923,11 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
- if (!is_concat(to_app(concatAst1))) {
+ if (!u.str.is_concat(to_app(concatAst1))) {
TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
- if (!is_concat(to_app(concatAst2))) {
+ if (!u.str.is_concat(to_app(concatAst2))) {
TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
@@ -3268,11 +3295,11 @@ bool theory_str::is_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
- if ((!m_strutil.is_string(v1_arg0)) && m_strutil.is_string(v1_arg1)
- && (!m_strutil.is_string(v2_arg0)) && (!m_strutil.is_string(v2_arg1))) {
+ if ((!u.str.is_string(v1_arg0)) && u.str.is_string(v1_arg1)
+ && (!u.str.is_string(v2_arg0)) && (!u.str.is_string(v2_arg1))) {
return true;
- } else if ((!m_strutil.is_string(v2_arg0)) && m_strutil.is_string(v2_arg1)
- && (!m_strutil.is_string(v1_arg0)) && (!m_strutil.is_string(v1_arg1))) {
+ } else if ((!u.str.is_string(v2_arg0)) && u.str.is_string(v2_arg1)
+ && (!u.str.is_string(v1_arg0)) && (!u.str.is_string(v1_arg1))) {
return true;
} else {
return false;
@@ -3287,11 +3314,11 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
- if (!is_concat(to_app(concatAst1))) {
+ if (!u.str.is_concat(to_app(concatAst1))) {
TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
- if (!is_concat(to_app(concatAst2))) {
+ if (!u.str.is_concat(to_app(concatAst2))) {
TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
@@ -3306,7 +3333,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
- if (m_strutil.is_string(v1_arg1) && !m_strutil.is_string(v2_arg1)) {
+ if (u.str.is_string(v1_arg1) && !u.str.is_string(v2_arg1)) {
m = v1_arg0;
strAst = v1_arg1;
x = v2_arg0;
@@ -3318,14 +3345,15 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
y = v1_arg1;
}
- std::string strValue = m_strutil.get_string_constant_value(strAst);
+ zstring strValue;
+ u.str.is_string(strAst, strValue);
rational x_len, y_len, m_len, str_len;
bool x_len_exists = get_len_value(x, x_len);
bool y_len_exists = get_len_value(y, y_len);
bool m_len_exists = get_len_value(m, m_len);
bool str_len_exists = true;
- str_len = rational((unsigned)(strValue.length()));
+ str_len = rational(strValue.length());
// setup
@@ -3502,12 +3530,12 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
<< "mLen = " << m_len.to_string() << std::endl
<< "strLen = " << str_len.to_string() << std::endl
<< "lenDelta = " << lenDelta.to_string() << std::endl
- << "strValue = \"" << strValue << "\" (len=" << strValue.length() << ")" << std::endl
+ << "strValue = \"" << strValue << "\" (len=" << strValue.length() << ")" << "\n"
;
);
- std::string part1Str = strValue.substr(0, lenDelta.get_unsigned());
- std::string part2Str = strValue.substr(lenDelta.get_unsigned(), strValue.length() - lenDelta.get_unsigned());
+ zstring part1Str = strValue.extract(0, lenDelta.get_unsigned());
+ zstring part2Str = strValue.extract(lenDelta.get_unsigned(), strValue.length() - lenDelta.get_unsigned());
expr_ref prefixStr(mk_string(part1Str), mgr);
expr_ref x_concat(mk_concat(m, prefixStr), mgr);
@@ -3573,9 +3601,9 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
}
}
- for (int i = 0; i <= (int)strValue.size(); ++i) {
- std::string part1Str = strValue.substr(0, i);
- std::string part2Str = strValue.substr(i, strValue.size() - i);
+ for (unsigned int i = 0; i <= strValue.length(); ++i) {
+ zstring part1Str = strValue.extract(0, i);
+ zstring part2Str = strValue.extract(i, strValue.length() - i);
expr_ref prefixStr(mk_string(part1Str), mgr);
expr_ref x_concat(mk_concat(m, prefixStr), mgr);
expr_ref cropStr(mk_string(part2Str), mgr);
@@ -3624,11 +3652,11 @@ bool theory_str::is_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
- if (m_strutil.is_string(v1_arg0) && (!m_strutil.is_string(v1_arg1))
- && (!m_strutil.is_string(v2_arg0)) && (!m_strutil.is_string(v2_arg1))) {
+ if (u.str.is_string(v1_arg0) && (!u.str.is_string(v1_arg1))
+ && (!u.str.is_string(v2_arg0)) && (!u.str.is_string(v2_arg1))) {
return true;
- } else if (m_strutil.is_string(v2_arg0) && (!m_strutil.is_string(v2_arg1))
- && (!m_strutil.is_string(v1_arg0)) && (!m_strutil.is_string(v1_arg1))) {
+ } else if (u.str.is_string(v2_arg0) && (!u.str.is_string(v2_arg1))
+ && (!u.str.is_string(v1_arg0)) && (!u.str.is_string(v1_arg1))) {
return true;
} else {
return false;
@@ -3643,11 +3671,11 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
- if (!is_concat(to_app(concatAst1))) {
+ if (!u.str.is_concat(to_app(concatAst1))) {
TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
- if (!is_concat(to_app(concatAst2))) {
+ if (!u.str.is_concat(to_app(concatAst2))) {
TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
@@ -3662,7 +3690,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
expr * strAst = NULL;
expr * n = NULL;
- if (m_strutil.is_string(v1_arg0) && !m_strutil.is_string(v2_arg0)) {
+ if (u.str.is_string(v1_arg0) && !u.str.is_string(v2_arg0)) {
strAst = v1_arg0;
n = v1_arg1;
x = v2_arg0;
@@ -3674,7 +3702,8 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
y = v1_arg1;
}
- std::string strValue = m_strutil.get_string_constant_value(strAst);
+ zstring strValue;
+ u.str.is_string(strAst, strValue);
rational x_len, y_len, str_len, n_len;
bool x_len_exists = get_len_value(x, x_len);
@@ -3776,9 +3805,9 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
prefixLen = x_len;
litems.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
}
- std::string prefixStr = strValue.substr(0, prefixLen.get_unsigned());
+ zstring prefixStr = strValue.extract(0, prefixLen.get_unsigned());
rational str_sub_prefix = str_len - prefixLen;
- std::string suffixStr = strValue.substr(prefixLen.get_unsigned(), str_sub_prefix.get_unsigned());
+ zstring suffixStr = strValue.extract(prefixLen.get_unsigned(), str_sub_prefix.get_unsigned());
expr_ref prefixAst(mk_string(prefixStr), mgr);
expr_ref suffixAst(mk_string(suffixStr), mgr);
expr_ref ax_l(mgr.mk_and(litems.size(), litems.c_ptr()), mgr);
@@ -3878,9 +3907,9 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
unsigned option = 0;
int pos = 1;
- for (int i = 0; i <= (int) strValue.size(); i++) {
- std::string part1Str = strValue.substr(0, i);
- std::string part2Str = strValue.substr(i, strValue.size() - i);
+ for (unsigned int i = 0; i <= strValue.length(); i++) {
+ zstring part1Str = strValue.extract(0, i);
+ zstring part2Str = strValue.extract(i, strValue.length() - i);
expr_ref cropStr(mk_string(part1Str), mgr);
expr_ref suffixStr(mk_string(part2Str), mgr);
expr_ref y_concat(mk_concat(suffixStr, n), mgr);
@@ -3900,7 +3929,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
expr_ref option1(mk_and(and_item), mgr);
arrangement_disjunction.push_back(option1);
double priority;
- if (i == (int)strValue.size()) {
+ if (i == strValue.length()) {
priority = 0.5;
} else {
priority = 0.1;
@@ -3974,8 +4003,8 @@ bool theory_str::is_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
- if (m_strutil.is_string(v1_arg0) && (!m_strutil.is_string(v1_arg1))
- && m_strutil.is_string(v2_arg0) && (!m_strutil.is_string(v2_arg1))) {
+ if (u.str.is_string(v1_arg0) && (!u.str.is_string(v1_arg1))
+ && u.str.is_string(v2_arg0) && (!u.str.is_string(v2_arg1))) {
return true;
} else {
return false;
@@ -3990,11 +4019,11 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
- if (!is_concat(to_app(concatAst1))) {
+ if (!u.str.is_concat(to_app(concatAst1))) {
TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
- if (!is_concat(to_app(concatAst2))) {
+ if (!u.str.is_concat(to_app(concatAst2))) {
TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
@@ -4009,17 +4038,15 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
expr * str2Ast = v2_arg0;
expr * n = v2_arg1;
- const char *tmp = 0;
- m_strutil.is_string(str1Ast, &tmp);
- std::string str1Value(tmp);
- m_strutil.is_string(str2Ast, &tmp);
- std::string str2Value(tmp);
+ zstring str1Value, str2Value;
+ u.str.is_string(str1Ast, str1Value);
+ u.str.is_string(str2Ast, str2Value);
- int str1Len = str1Value.length();
- int str2Len = str2Value.length();
+ unsigned int str1Len = str1Value.length();
+ unsigned int str2Len = str2Value.length();
int commonLen = (str1Len > str2Len) ? str2Len : str1Len;
- if (str1Value.substr(0, commonLen) != str2Value.substr(0, commonLen)) {
+ if (str1Value.extract(0, commonLen) != str2Value.extract(0, commonLen)) {
TRACE("t_str_detail", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
<< " has no common prefix with " << mk_ismt2_pp(concatAst2, mgr) << std::endl;);
expr_ref toNegate(mgr.mk_not(ctx.mk_eq_atom(concatAst1, concatAst2)), mgr);
@@ -4027,7 +4054,7 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
return;
} else {
if (str1Len > str2Len) {
- std::string deltaStr = str1Value.substr(str2Len, str1Len - str2Len);
+ zstring deltaStr = str1Value.extract(str2Len, str1Len - str2Len);
expr_ref tmpAst(mk_concat(mk_string(deltaStr), y), mgr);
if (!in_same_eqc(tmpAst, n)) {
// break down option 4-1
@@ -4052,7 +4079,7 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
}
}
} else {
- std::string deltaStr = str2Value.substr(str1Len, str2Len - str1Len);
+ zstring deltaStr = str2Value.extract(str1Len, str2Len - str1Len);
expr_ref tmpAst(mk_concat(mk_string(deltaStr), n), mgr);
if (!in_same_eqc(y, tmpAst)) {
//break down option 4-3
@@ -4077,8 +4104,8 @@ bool theory_str::is_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
- if ((!m_strutil.is_string(v1_arg0)) && m_strutil.is_string(v1_arg1)
- && (!m_strutil.is_string(v2_arg0)) && m_strutil.is_string(v2_arg1)) {
+ if ((!u.str.is_string(v1_arg0)) && u.str.is_string(v1_arg1)
+ && (!u.str.is_string(v2_arg0)) && u.str.is_string(v2_arg1)) {
return true;
} else {
return false;
@@ -4093,11 +4120,11 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
- if (!is_concat(to_app(concatAst1))) {
+ if (!u.str.is_concat(to_app(concatAst1))) {
TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
- if (!is_concat(to_app(concatAst2))) {
+ if (!u.str.is_concat(to_app(concatAst2))) {
TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
@@ -4112,17 +4139,15 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
expr * m = v2_arg0;
expr * str2Ast = v2_arg1;
- const char *tmp = 0;
- m_strutil.is_string(str1Ast, &tmp);
- std::string str1Value(tmp);
- m_strutil.is_string(str2Ast, &tmp);
- std::string str2Value(tmp);
+ zstring str1Value, str2Value;
+ u.str.is_string(str1Ast, str1Value);
+ u.str.is_string(str2Ast, str2Value);
- int str1Len = str1Value.length();
- int str2Len = str2Value.length();
+ unsigned int str1Len = str1Value.length();
+ unsigned int str2Len = str2Value.length();
int cLen = (str1Len > str2Len) ? str2Len : str1Len;
- if (str1Value.substr(str1Len - cLen, cLen) != str2Value.substr(str2Len - cLen, cLen)) {
+ if (str1Value.extract(str1Len - cLen, cLen) != str2Value.extract(str2Len - cLen, cLen)) {
TRACE("t_str_detail", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
<< " has no common suffix with " << mk_ismt2_pp(concatAst2, mgr) << std::endl;);
expr_ref toNegate(mgr.mk_not(ctx.mk_eq_atom(concatAst1, concatAst2)), mgr);
@@ -4130,7 +4155,7 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
return;
} else {
if (str1Len > str2Len) {
- std::string deltaStr = str1Value.substr(0, str1Len - str2Len);
+ zstring deltaStr = str1Value.extract(0, str1Len - str2Len);
expr_ref x_deltaStr(mk_concat(x, mk_string(deltaStr)), mgr);
if (!in_same_eqc(m, x_deltaStr)) {
expr_ref implyR(ctx.mk_eq_atom(m, x_deltaStr), mgr);
@@ -4153,7 +4178,7 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
}
}
} else {
- std::string deltaStr = str2Value.substr(0, str2Len - str1Len);
+ zstring deltaStr = str2Value.extract(0, str2Len - str1Len);
expr_ref m_deltaStr(mk_concat(m, mk_string(deltaStr)), mgr);
if (!in_same_eqc(x, m_deltaStr)) {
expr_ref implyR(ctx.mk_eq_atom(x, m_deltaStr), mgr);
@@ -4177,11 +4202,11 @@ bool theory_str::is_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
- if (m_strutil.is_string(v1_arg0) && (!m_strutil.is_string(v1_arg1))
- && (!m_strutil.is_string(v2_arg0)) && m_strutil.is_string(v2_arg1)) {
+ if (u.str.is_string(v1_arg0) && (!u.str.is_string(v1_arg1))
+ && (!u.str.is_string(v2_arg0)) && u.str.is_string(v2_arg1)) {
return true;
- } else if (m_strutil.is_string(v2_arg0) && (!m_strutil.is_string(v2_arg1))
- && (!m_strutil.is_string(v1_arg0)) && m_strutil.is_string(v1_arg1)) {
+ } else if (u.str.is_string(v2_arg0) && (!u.str.is_string(v2_arg1))
+ && (!u.str.is_string(v1_arg0)) && u.str.is_string(v1_arg1)) {
return true;
} else {
return false;
@@ -4196,11 +4221,11 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
- if (!is_concat(to_app(concatAst1))) {
+ if (!u.str.is_concat(to_app(concatAst1))) {
TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
- if (!is_concat(to_app(concatAst2))) {
+ if (!u.str.is_concat(to_app(concatAst2))) {
TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
@@ -4216,7 +4241,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
expr * m = NULL;
expr * str2Ast = NULL;
- if (m_strutil.is_string(v1_arg0)) {
+ if (u.str.is_string(v1_arg0)) {
str1Ast = v1_arg0;
y = v1_arg1;
m = v2_arg0;
@@ -4228,14 +4253,12 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
str2Ast = v1_arg1;
}
- const char *tmp = 0;
- m_strutil.is_string(str1Ast, &tmp);
- std::string str1Value(tmp);
- m_strutil.is_string(str2Ast, &tmp);
- std::string str2Value(tmp);
+ zstring str1Value, str2Value;
+ u.str.is_string(str1Ast, str1Value);
+ u.str.is_string(str2Ast, str2Value);
- int str1Len = str1Value.length();
- int str2Len = str2Value.length();
+ unsigned int str1Len = str1Value.length();
+ unsigned int str2Len = str2Value.length();
//----------------------------------------
//(a) |---str1---|----y----|
@@ -4248,11 +4271,11 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
// |------m------|-str2-|
//----------------------------------------
- std::list<int> overlapLen;
+ std::list<unsigned int> overlapLen;
overlapLen.push_back(0);
- for (int i = 1; i <= str1Len && i <= str2Len; i++) {
- if (str1Value.substr(str1Len - i, i) == str2Value.substr(0, i))
+ for (unsigned int i = 1; i <= str1Len && i <= str2Len; i++) {
+ if (str1Value.extract(str1Len - i, i) == str2Value.extract(0, i))
overlapLen.push_back(i);
}
@@ -4351,10 +4374,10 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
}
}
- for (std::list<int>::iterator itor = overlapLen.begin(); itor != overlapLen.end(); itor++) {
- int overLen = *itor;
- std::string prefix = str1Value.substr(0, str1Len - overLen);
- std::string suffix = str2Value.substr(overLen, str2Len - overLen);
+ for (std::list<unsigned int>::iterator itor = overlapLen.begin(); itor != overlapLen.end(); itor++) {
+ unsigned int overLen = *itor;
+ zstring prefix = str1Value.extract(0, str1Len - overLen);
+ zstring suffix = str2Value.extract(overLen, str2Len - overLen);
expr_ref_vector and_item(mgr);
@@ -4408,12 +4431,13 @@ void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr)
if (!is_Unroll(to_app(unrollFunc))) {
return;
}
- if (!m_strutil.is_string(constStr)) {
+ if (!u.str.is_string(constStr)) {
return;
}
expr * funcInUnroll = to_app(unrollFunc)->get_arg(0);
- std::string strValue = m_strutil.get_string_constant_value(constStr);
+ zstring strValue;
+ u.str.is_string(constStr, strValue);
TRACE("t_str_detail", tout << "unrollFunc: " << mk_pp(unrollFunc, m) << std::endl
<< "constStr: " << mk_pp(constStr, m) << std::endl;);
@@ -4422,7 +4446,7 @@ void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr)
return;
}
- if (is_Str2Reg(to_app(funcInUnroll))) {
+ if (u.re.is_to_re(to_app(funcInUnroll))) {
unroll_str2reg_constStr(unrollFunc, constStr);
return;
}
@@ -4504,12 +4528,14 @@ void theory_str::unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr) {
expr * strInStr2RegFunc = to_app(str2RegFunc)->get_arg(0);
expr * oriCnt = to_app(unrollFunc)->get_arg(1);
- std::string strValue = m_strutil.get_string_constant_value(eqConstStr);
- std::string regStrValue = m_strutil.get_string_constant_value(strInStr2RegFunc);
- int strLen = strValue.length();
- int regStrLen = regStrValue.length();
+ zstring strValue;
+ u.str.is_string(eqConstStr, strValue);
+ zstring regStrValue;
+ u.str.is_string(strInStr2RegFunc, regStrValue);
+ unsigned int strLen = strValue.length();
+ unsigned int regStrLen = regStrValue.length();
SASSERT(regStrLen != 0); // this should never occur -- the case for empty string is handled elsewhere
- int cnt = strLen / regStrLen;
+ unsigned int cnt = strLen / regStrLen;
expr_ref implyL(ctx.mk_eq_atom(unrollFunc, eqConstStr), m);
expr_ref implyR1(ctx.mk_eq_atom(oriCnt, mk_int(cnt)), m);
@@ -4537,7 +4563,7 @@ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
expr * theory_str::z3str2_get_eqc_value(expr * n , bool & hasEqcValue) {
expr * curr = n;
do {
- if (m_strutil.is_string(curr)) {
+ if (u.str.is_string(curr)) {
hasEqcValue = true;
return curr;
}
@@ -4649,14 +4675,16 @@ bool theory_str::get_len_value(expr* e, rational& val) {
while (!todo.empty()) {
expr* c = todo.back();
todo.pop_back();
- if (is_concat(to_app(c))) {
+ if (u.str.is_concat(to_app(c))) {
e1 = to_app(c)->get_arg(0);
e2 = to_app(c)->get_arg(1);
todo.push_back(e1);
todo.push_back(e2);
}
- else if (is_string(to_app(c))) {
- int sl = m_strutil.get_string_constant_value(c).length();
+ else if (u.str.is_string(to_app(c))) {
+ zstring tmp;
+ u.str.is_string(to_app(c), tmp);
+ unsigned int sl = tmp.length();
val += rational(sl);
}
else {
@@ -4738,7 +4766,7 @@ expr * theory_str::collect_eq_nodes(expr * n, expr_ref_vector & eqcSet) {
expr * ex = n;
do {
- if (m_strutil.is_string(to_app(ex))) {
+ if (u.str.is_string(to_app(ex))) {
constStrNode = ex;
}
eqcSet.push_back(ex);
@@ -4753,7 +4781,7 @@ expr * theory_str::collect_eq_nodes(expr * n, expr_ref_vector & eqcSet) {
*/
void theory_str::get_const_str_asts_in_node(expr * node, expr_ref_vector & astList) {
ast_manager & m = get_manager();
- if (m_strutil.is_string(node)) {
+ if (u.str.is_string(node)) {
astList.push_back(node);
//} else if (getNodeType(t, node) == my_Z3_Func) {
} else if (is_app(node)) {
@@ -4806,7 +4834,8 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
if (strAst != constNode) {
litems.push_back(ctx.mk_eq_atom(strAst, constNode));
}
- std::string strConst = m_strutil.get_string_constant_value(constNode);
+ zstring strConst;
+ u.str.is_string(constNode, strConst);
bool subStrHasEqcValue = false;
expr * substrValue = get_eqc_value(substrAst, subStrHasEqcValue);
if (substrValue != substrAst) {
@@ -4815,11 +4844,12 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
if (subStrHasEqcValue) {
// subStr has an eqc constant value
- std::string subStrConst = m_strutil.get_string_constant_value(substrValue);
+ zstring subStrConst;
+ u.str.is_string(substrValue, subStrConst);
- TRACE("t_str_detail", tout << "strConst = " << strConst << ", subStrConst = " << subStrConst << std::endl;);
+ TRACE("t_str_detail", tout << "strConst = " << strConst << ", subStrConst = " << subStrConst << "\n";);
- if (strConst.find(subStrConst) != std::string::npos) {
+ if (strConst.contains(subStrConst)) {
//implyR = ctx.mk_eq(ctx, boolVar, Z3_mk_true(ctx));
implyR = boolVar;
} else {
@@ -4845,8 +4875,9 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
get_const_str_asts_in_node(aConcat, constList);
for (expr_ref_vector::iterator cstItor = constList.begin();
cstItor != constList.end(); cstItor++) {
- std::string pieceStr = m_strutil.get_string_constant_value(*cstItor);
- if (strConst.find(pieceStr) == std::string::npos) {
+ zstring pieceStr;
+ u.str.is_string(*cstItor, pieceStr);
+ if (strConst.contains(pieceStr)) {
counterEgFound = true;
if (aConcat != substrAst) {
litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
@@ -4883,9 +4914,10 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
}
if (strHasEqcValue) {
- std::string strConst = m_strutil.get_string_constant_value(strValue);
- std::string subStrConst = m_strutil.get_string_constant_value(constNode);
- if (strConst.find(subStrConst) != std::string::npos) {
+ zstring strConst, subStrConst;
+ u.str.is_string(strValue, strConst);
+ u.str.is_string(constNode, subStrConst);
+ if (strConst.contains(subStrConst)) {
//implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_true(ctx));
implyR = boolVar;
} else {
@@ -4941,19 +4973,21 @@ void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willE
if (strValue != strAst) {
litems.push_back(ctx.mk_eq_atom(strAst, strValue));
}
- std::string strConst = m_strutil.get_string_constant_value(strValue);
+ zstring strConst;
+ u.str.is_string(strValue, strConst);
// iterate eqc (also eqc-to-be) of substr
for (expr_ref_vector::iterator itAst = willEqClass.begin(); itAst != willEqClass.end(); itAst++) {
bool counterEgFound = false;
- if (is_concat(to_app(*itAst))) {
+ if (u.str.is_concat(to_app(*itAst))) {
expr_ref_vector constList(m);
// get constant strings in concat
app * aConcat = to_app(*itAst);
get_const_str_asts_in_node(aConcat, constList);
for (expr_ref_vector::iterator cstItor = constList.begin();
cstItor != constList.end(); cstItor++) {
- std::string pieceStr = m_strutil.get_string_constant_value(*cstItor);
- if (strConst.find(pieceStr) == std::string::npos) {
+ zstring pieceStr;
+ u.str.is_string(*cstItor, pieceStr);
+ if (!strConst.contains(pieceStr)) {
TRACE("t_str_detail", tout << "Inconsistency found!" << std::endl;);
counterEgFound = true;
if (aConcat != substrAst) {
@@ -5045,18 +5079,19 @@ void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
litems1.push_back(ctx.mk_eq_atom(subAst2, subValue2));
}
- std::string subConst1 = m_strutil.get_string_constant_value(subValue1);
- std::string subConst2 = m_strutil.get_string_constant_value(subValue2);
+ zstring subConst1, subConst2;
+ u.str.is_string(subValue1, subConst1);
+ u.str.is_string(subValue2, subConst2);
expr_ref implyR(m);
if (subConst1 == subConst2) {
// key1.first = key2.first /\ key1.second = key2.second
// ==> (containPairBoolMap[key1] = containPairBoolMap[key2])
implyR = ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
- } else if (subConst1.find(subConst2) != std::string::npos) {
+ } else if (subConst1.contains(subConst2)) {
// key1.first = key2.first /\ Contains(key1.second, key2.second)
// ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
implyR = rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
- } else if (subConst2.find(subConst1) != std::string::npos) {
+ } else if (subConst2.contains(subConst1)) {
// key1.first = key2.first /\ Contains(key2.second, key1.second)
// ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
implyR = rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]);
@@ -5191,19 +5226,20 @@ void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
litems1.push_back(ctx.mk_eq_atom(str2, strVal2));
}
- std::string const1 = m_strutil.get_string_constant_value(strVal1);
- std::string const2 = m_strutil.get_string_constant_value(strVal2);
+ zstring const1, const2;
+ u.str.is_string(strVal1, const1);
+ u.str.is_string(strVal2, const2);
expr_ref implyR(m);
if (const1 == const2) {
// key1.second = key2.second /\ key1.first = key2.first
// ==> (containPairBoolMap[key1] = containPairBoolMap[key2])
implyR = ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
- } else if (const1.find(const2) != std::string::npos) {
+ } else if (const1.contains(const2)) {
// key1.second = key2.second /\ Contains(key1.first, key2.first)
// ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
implyR = rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]);
- } else if (const2.find(const1) != std::string::npos) {
+ } else if (const2.contains(const1)) {
// key1.first = key2.first /\ Contains(key2.first, key1.first)
// ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
implyR = rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
@@ -5398,7 +5434,7 @@ void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
expr * theory_str::dealias_node(expr * node, std::map<expr*, expr*> & varAliasMap, std::map<expr*, expr*> & concatAliasMap) {
if (variable_set.find(node) != variable_set.end()) {
return get_alias_index_ast(varAliasMap, node);
- } else if (is_concat(to_app(node))) {
+ } else if (u.str.is_concat(to_app(node))) {
return get_alias_index_ast(concatAliasMap, node);
}
return node;
@@ -5427,13 +5463,13 @@ void theory_str::get_grounded_concats(expr* node, std::map<expr*, expr*> & varAl
ast_manager & m = get_manager();
// const strings: node is de-aliased
- if (m_strutil.is_string(node)) {
+ if (u.str.is_string(node)) {
std::vector<expr*> concatNodes;
concatNodes.push_back(node);
groundedMap[node][concatNodes].clear(); // no condition
}
// Concat functions
- else if (is_concat(to_app(node))) {
+ else if (u.str.is_concat(to_app(node))) {
// if "node" equals to a constant string, thenjust push the constant into the concat vector
// Again "node" has been de-aliased at the very beginning
if (concatConstMap.find(node) != concatConstMap.end()) {
@@ -5461,7 +5497,7 @@ void theory_str::get_grounded_concats(expr* node, std::map<expr*, expr*> & varAl
ndVec.insert(ndVec.end(), arg0_grdItor->first.begin(), arg0_grdItor->first.end());
int arg0VecSize = arg0_grdItor->first.size();
int arg1VecSize = arg1_grdItor->first.size();
- if (arg0VecSize > 0 && arg1VecSize > 0 && m_strutil.is_string(arg0_grdItor->first[arg0VecSize - 1]) && m_strutil.is_string(arg1_grdItor->first[0])) {
+ if (arg0VecSize > 0 && arg1VecSize > 0 && u.str.is_string(arg0_grdItor->first[arg0VecSize - 1]) && u.str.is_string(arg1_grdItor->first[0])) {
ndVec.pop_back();
ndVec.push_back(mk_concat(arg0_grdItor->first[arg0VecSize - 1], arg1_grdItor->first[0]));
for (int i = 1; i < arg1VecSize; i++) {
@@ -5565,11 +5601,11 @@ bool theory_str::is_partial_in_grounded_concat(const std::vector<expr*> & strVec
}
if (subStrCnt == 1) {
- if (m_strutil.is_string(subStrVec[0])) {
- std::string subStrVal = m_strutil.get_string_constant_value(subStrVec[0]);
+ zstring subStrVal;
+ if (u.str.is_string(subStrVec[0]), subStrVal) {
for (int i = 0; i < strCnt; i++) {
- if (m_strutil.is_string(strVec[i])) {
- std::string strVal = m_strutil.get_string_constant_value(strVec[i]);
+ zstring strVal;
+ if (u.str.is_string(strVec[i], strVal)) {
if (strVal.find(subStrVal) != std::string::npos) {
return true;
}
@@ -5589,12 +5625,12 @@ bool theory_str::is_partial_in_grounded_concat(const std::vector<expr*> & strVec
// * constant: a suffix of a note in strVec[i]
// * variable:
bool firstNodesOK = true;
- if (m_strutil.is_string(subStrVec[0])) {
- std::string subStrHeadVal = m_strutil.get_string_constant_value(subStrVec[0]);
- if (m_strutil.is_string(strVec[i])) {
- std::string strHeadVal = m_strutil.get_string_constant_value(strVec[i]);
- if (strHeadVal.size() >= subStrHeadVal.size()) {
- std::string suffix = strHeadVal.substr(strHeadVal.size() - subStrHeadVal.size(), subStrHeadVal.size());
+ zstring subStrHeadVal;
+ if (u.str.is_string(subStrVec[0], subStrHeadVal)) {
+ zstring strHeadVal;
+ if (u.str.is_string(strVec[i], strHeadVal)) {
+ if (strHeadVal.length() >= subStrHeadVal.length()) {
+ std::string suffix = strHeadVal.extract(strHeadVal.length() - subStrHeadVal.length(), subStrHeadVal.length());
if (suffix != subStrHeadVal) {
firstNodesOK = false;
}
@@ -5625,12 +5661,12 @@ bool theory_str::is_partial_in_grounded_concat(const std::vector<expr*> & strVec
// tail nodes
int tailIdx = i + subStrCnt - 1;
- if (m_strutil.is_string(subStrVec[subStrCnt - 1])) {
- std::string subStrTailVal = m_strutil.get_string_constant_value(subStrVec[subStrCnt - 1]);
- if (m_strutil.is_string(strVec[tailIdx])) {
- std::string strTailVal = m_strutil.get_string_constant_value(strVec[tailIdx]);
- if (strTailVal.size() >= subStrTailVal.size()) {
- std::string prefix = strTailVal.substr(0, subStrTailVal.size());
+ zstring subStrTailVal;
+ if (u.str.is_string(subStrVec[subStrCnt - 1], subStrTailVal)) {
+ zstring strTailVal;
+ if (u.str.is_string(strVec[tailIdx], strTailVal)) {
+ if (strTailVal.length() >= subStrTailVal.length()) {
+ zstring prefix = strTailVal.extract(0, subStrTailVal.length());
if (prefix == subStrTailVal) {
return true;
} else {
@@ -5721,44 +5757,44 @@ void theory_str::compute_contains(std::map<expr*, expr*> & varAliasMap,
}
}
-bool theory_str::can_concat_eq_str(expr * concat, std::string str) {
+bool theory_str::can_concat_eq_str(expr * concat, zstring& str) {
int strLen = str.length();
- if (is_concat(to_app(concat))) {
+ if (u.str.is_concat(to_app(concat))) {
ptr_vector<expr> args;
get_nodes_in_concat(concat, args);
expr * ml_node = args[0];
expr * mr_node = args[args.size() - 1];
- if (m_strutil.is_string(ml_node)) {
- std::string ml_str = m_strutil.get_string_constant_value(ml_node);
- int ml_len = ml_str.length();
+ zstring ml_str;
+ if (u.str.is_string(ml_node, ml_str)) {
+ unsigned int ml_len = ml_str.length();
if (ml_len > strLen) {
return false;
}
- int cLen = ml_len;
- if (ml_str != str.substr(0, cLen)) {
+ unsigned int cLen = ml_len;
+ if (ml_str != str.extract(0, cLen)) {
return false;
}
}
- if (m_strutil.is_string(mr_node)) {
- std::string mr_str = m_strutil.get_string_constant_value(mr_node);
- int mr_len = mr_str.length();
+ zstring mr_str;
+ if (u.str.is_string(mr_node, mr_str)) {
+ unsigned int mr_len = mr_str.length();
if (mr_len > strLen) {
return false;
}
- int cLen = mr_len;
- if (mr_str != str.substr(strLen - cLen, cLen)) {
+ unsigned int cLen = mr_len;
+ if (mr_str != str.extract(strLen - cLen, cLen)) {
return false;
}
}
- int sumLen = 0;
+ unsigned int sumLen = 0;
for (unsigned int i = 0 ; i < args.size() ; i++) {
expr * oneArg = args[i];
- if (m_strutil.is_string(oneArg)) {
- std::string arg_str = m_strutil.get_string_constant_value(oneArg);
- if (str.find(arg_str) == std::string::npos) {
+ zstring arg_str;
+ if (u.str.is_string(oneArg, arg_str)) {
+ if (str.contains(arg_str)) {
return false;
}
sumLen += arg_str.length();
@@ -5773,17 +5809,16 @@ bool theory_str::can_concat_eq_str(expr * concat, std::string str) {
}
bool theory_str::can_concat_eq_concat(expr * concat1, expr * concat2) {
- if (is_concat(to_app(concat1)) && is_concat(to_app(concat2))) {
+ if (u.str.is_concat(to_app(concat1)) && u.str.is_concat(to_app(concat2))) {
{
// Suppose concat1 = (Concat X Y) and concat2 = (Concat M N).
expr * concat1_mostL = getMostLeftNodeInConcat(concat1);
expr * concat2_mostL = getMostLeftNodeInConcat(concat2);
// if both X and M are constant strings, check whether they have the same prefix
- if (m_strutil.is_string(concat1_mostL) && m_strutil.is_string(concat2_mostL)) {
- std::string concat1_mostL_str = m_strutil.get_string_constant_value(concat1_mostL);
- std::string concat2_mostL_str = m_strutil.get_string_constant_value(concat2_mostL);
- int cLen = std::min(concat1_mostL_str.length(), concat2_mostL_str.length());
- if (concat1_mostL_str.substr(0, cLen) != concat2_mostL_str.substr(0, cLen)) {
+ zstring concat1_mostL_str, concat2_mostL_str;
+ if (u.str.is_string(concat1_mostL, concat1_mostL_str) && u.str.is_string(concat2_mostL, concat2_mostL_str)) {
+ unsigned int cLen = std::min(concat1_mostL_str.length(), concat2_mostL_str.length());
+ if (concat1_mostL_str.extract(0, cLen) != concat2_mostL_str.extract(0, cLen)) {
return false;
}
}
@@ -5793,12 +5828,11 @@ bool theory_str::can_concat_eq_concat(expr * concat1, expr * concat2) {
// Similarly, if both Y and N are constant strings, check whether they have the same suffix
expr * concat1_mostR = getMostRightNodeInConcat(concat1);
expr * concat2_mostR = getMostRightNodeInConcat(concat2);
- if (m_strutil.is_string(concat1_mostR) && m_strutil.is_string(concat2_mostR)) {
- std::string concat1_mostR_str = m_strutil.get_string_constant_value(concat1_mostR);
- std::string concat2_mostR_str = m_strutil.get_string_constant_value(concat2_mostR);
- int cLen = std::min(concat1_mostR_str.length(), concat2_mostR_str.length());
- if (concat1_mostR_str.substr(concat1_mostR_str.length() - cLen, cLen) !=
- concat2_mostR_str.substr(concat2_mostR_str.length() - cLen, cLen)) {
+ zstring concat1_mostR_str, concat2_mostR_str;
+ if (u.str.is_string(concat1_mostR, concat1_mostR_str) && u.str.is_string(concat2_mostR, concat2_mostR_str)) {
+ unsigned int cLen = std::min(concat1_mostR_str.length(), concat2_mostR_str.length());
+ if (concat1_mostR_str.extract(concat1_mostR_str.length() - cLen, cLen) !=
+ concat2_mostR_str.extract(concat2_mostR_str.length() - cLen, cLen)) {
return false;
}
}
@@ -5817,31 +5851,29 @@ bool theory_str::can_two_nodes_eq(expr * n1, expr * n2) {
app * n2_curr = to_app(n2);
// case 0: n1_curr is const string, n2_curr is const string
- if (is_string(n1_curr) && is_string(n2_curr)) {
+ if (u.str.is_string(n1_curr) && u.str.is_string(n2_curr)) {
if (n1_curr != n2_curr) {
return false;
}
}
// case 1: n1_curr is concat, n2_curr is const string
- else if (is_concat(n1_curr) && is_string(n2_curr)) {
- const char * tmp = 0;
- m_strutil.is_string(n2_curr, & tmp);
- std::string n2_curr_str(tmp);
+ else if (u.str.is_concat(n1_curr) && u.str.is_string(n2_curr)) {
+ zstring n2_curr_str;
+ u.str.is_string(n2_curr, n2_curr_str);
if (!can_concat_eq_str(n1_curr, n2_curr_str)) {
return false;
}
}
// case 2: n2_curr is concat, n1_curr is const string
- else if (is_concat(n2_curr) && is_string(n1_curr)) {
- const char * tmp = 0;
- m_strutil.is_string(n1_curr, & tmp);
- std::string n1_curr_str(tmp);
+ else if (u.str.is_concat(n2_curr) && u.str.is_string(n1_curr)) {
+ zstring n1_curr_str;
+ u.str.is_string(n1_curr, n1_curr_str);
if (!can_concat_eq_str(n2_curr, n1_curr_str)) {
return false;
}
}
// case 3: both are concats
- else if (is_concat(n1_curr) && is_concat(n2_curr)) {
+ else if (u.str.is_concat(n1_curr) && u.str.is_concat(n2_curr)) {
if (!can_concat_eq_concat(n1_curr, n2_curr)) {
return false;
}
@@ -5857,9 +5889,11 @@ bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
ast_manager & mgr = get_manager();
context & ctx = get_context();
- rational strLen((unsigned) (m_strutil.get_string_constant_value(constStr).length()));
+ zstring tmp;
+ u.str.is_string(constStr, tmp);
+ rational strLen(tmp.length());
- if (is_concat(to_app(n1))) {
+ if (u.str.is_concat(to_app(n1))) {
ptr_vector<expr> args;
expr_ref_vector items(mgr);
@@ -5870,7 +5904,7 @@ bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
rational argLen;
bool argLen_exists = get_len_value(args[i], argLen);
if (argLen_exists) {
- if (!m_strutil.is_string(args[i])) {
+ if (!u.str.is_string(args[i])) {
items.push_back(ctx.mk_eq_atom(mk_strlen(args[i]), mk_int(argLen)));
}
TRACE("t_str_detail", tout << "concat arg: " << mk_pp(args[i], mgr) << " has len = " << argLen.to_string() << std::endl;);
@@ -5926,7 +5960,7 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
bool argLen_exists = get_len_value(oneArg, argLen);
if (argLen_exists) {
sum1 += argLen;
- if (!m_strutil.is_string(oneArg)) {
+ if (!u.str.is_string(oneArg)) {
items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
}
} else {
@@ -5940,7 +5974,7 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
bool argLen_exists = get_len_value(oneArg, argLen);
if (argLen_exists) {
sum2 += argLen;
- if (!m_strutil.is_string(oneArg)) {
+ if (!u.str.is_string(oneArg)) {
items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
}
} else {
@@ -5993,7 +6027,7 @@ bool theory_str::check_length_concat_var(expr * concat, expr * var) {
rational argLen;
bool argLen_exists = get_len_value(oneArg, argLen);
if (argLen_exists) {
- if (!m_strutil.is_string(oneArg) && !argLen.is_zero()) {
+ if (!u.str.is_string(oneArg) && !argLen.is_zero()) {
items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
}
sumLen += argLen;
@@ -6036,8 +6070,8 @@ bool theory_str::check_length_var_var(expr * var1, expr * var2) {
// - note that these are different from the semantics in Z3str2
bool theory_str::check_length_eq_var_concat(expr * n1, expr * n2) {
// n1 and n2 are not const string: either variable or concat
- bool n1Concat = is_concat(to_app(n1));
- bool n2Concat = is_concat(to_app(n2));
+ bool n1Concat = u.str.is_concat(to_app(n1));
+ bool n2Concat = u.str.is_concat(to_app(n2));
if (n1Concat && n2Concat) {
return check_length_concat_concat(n1, n2);
}
@@ -6059,12 +6093,12 @@ bool theory_str::check_length_eq_var_concat(expr * n1, expr * n2) {
// returns false if an inconsistency is detected, or true if no inconsistencies were found
// - note that these are different from the semantics of checkLengConsistency() in Z3str2
bool theory_str::check_length_consistency(expr * n1, expr * n2) {
- if (m_strutil.is_string(n1) && m_strutil.is_string(n2)) {
+ if (u.str.is_string(n1) && u.str.is_string(n2)) {
// consistency has already been checked in can_two_nodes_eq().
return true;
- } else if (m_strutil.is_string(n1) && (!m_strutil.is_string(n2))) {
+ } else if (u.str.is_string(n1) && (!u.str.is_string(n2))) {
return check_length_const_string(n2, n1);
- } else if (m_strutil.is_string(n2) && (!m_strutil.is_string(n1))) {
+ } else if (u.str.is_string(n2) && (!u.str.is_string(n1))) {
return check_length_const_string(n1, n2);
} else {
// n1 and n2 are vars or concats
@@ -6082,7 +6116,7 @@ bool theory_str::check_concat_len_in_eqc(expr * concat) {
expr * eqc_n = concat;
do {
- if (is_concat(to_app(eqc_n))) {
+ if (u.str.is_concat(to_app(eqc_n))) {
rational unused;
bool status = infer_len_concat(eqc_n, unused);
if (status) {
@@ -6114,13 +6148,15 @@ void theory_str::check_regex_in(expr * nn1, expr * nn2) {
std::set<std::string>::iterator strItor = regex_in_var_reg_str_map[*itor].begin();
for (; strItor != regex_in_var_reg_str_map[*itor].end(); strItor++) {
std::string regStr = *strItor;
- std::string constStrValue = m_strutil.get_string_constant_value(constStr);
+ zstring constStrValue;
+ u.str.is_string(constStr, constStrValue);
std::pair<expr*, std::string> key1 = std::make_pair(*itor, regStr);
if (regex_in_bool_map.find(key1) != regex_in_bool_map.end()) {
expr * boolVar = regex_in_bool_map[key1]; // actually the RegexIn term
app * a_regexIn = to_app(boolVar);
expr * regexTerm = a_regexIn->get_arg(1);
+ // TODO figure out regex NFA stuff
if (regex_nfa_cache.find(regexTerm) == regex_nfa_cache.end()) {
TRACE("t_str_detail", tout << "regex_nfa_cache: cache miss" << std::endl;);
regex_nfa_cache[regexTerm] = nfa(m_strutil, regexTerm);
@@ -6159,16 +6195,14 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
TRACE("t_str_detail", tout << mk_ismt2_pp(concat, m) << " == " << mk_ismt2_pp(str, m) << std::endl;);
- if (is_concat(to_app(concat)) && is_string(to_app(str))) {
- const char * tmp = 0;
- m_strutil.is_string(str, & tmp);
- std::string const_str(tmp);
+ zstring const_str;
+ if (u.str.is_concat(to_app(concat)) && u.str.is_string(to_app(str), const_str)) {
app * a_concat = to_app(concat);
SASSERT(a_concat->get_num_args() == 2);
expr * a1 = a_concat->get_arg(0);
expr * a2 = a_concat->get_arg(1);
- if (const_str == "") {
+ if (const_str.empty()) {
TRACE("t_str", tout << "quick path: concat == \"\"" << std::endl;);
// assert the following axiom:
// ( (Concat a1 a2) == "" ) -> ( (a1 == "") AND (a2 == "") )
@@ -6211,26 +6245,22 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
if (newConcat == str) {
return;
}
- if (!is_concat(to_app(newConcat))) {
+ if (!u.str.is_concat(to_app(newConcat))) {
return;
}
if (arg1_has_eqc_value && arg2_has_eqc_value) {
// Case 1: Concat(const, const) == const
TRACE("t_str", tout << "Case 1: Concat(const, const) == const" << std::endl;);
- const char * str1;
- m_strutil.is_string(arg1, & str1);
- std::string arg1_str(str1);
+ zstring arg1_str, arg2_str;
+ u.str.is_string(arg1, arg1_str);
+ u.str.is_string(arg2, arg2_str);
- const char * str2;
- m_strutil.is_string(arg2, & str2);
- std::string arg2_str(str2);
-
- std::string result_str = arg1_str + arg2_str;
+ zstring result_str = arg1_str + arg2_str;
if (result_str != const_str) {
// Inconsistency
TRACE("t_str", tout << "inconsistency detected: \""
<< arg1_str << "\" + \"" << arg2_str <<
- "\" != \"" << const_str << "\"" << std::endl;);
+ "\" != \"" << const_str << "\"\n");
expr_ref equality(ctx.mk_eq_atom(concat, str), m);
expr_ref diseq(m.mk_not(equality), m);
assert_axiom(diseq);
@@ -6239,31 +6269,30 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
} else if (!arg1_has_eqc_value && arg2_has_eqc_value) {
// Case 2: Concat(var, const) == const
TRACE("t_str", tout << "Case 2: Concat(var, const) == const" << std::endl;);
- const char * str2;
- m_strutil.is_string(arg2, & str2);
- std::string arg2_str(str2);
- int resultStrLen = const_str.length();
- int arg2StrLen = arg2_str.length();
+ zstring arg2_str;
+ u.str.is_string(arg2, arg2_str);
+ unsigned int resultStrLen = const_str.length();
+ unsigned int arg2StrLen = arg2_str.length();
if (resultStrLen < arg2StrLen) {
// Inconsistency
TRACE("t_str", tout << "inconsistency detected: \""
<< arg2_str <<
"\" is longer than \"" << const_str << "\","
- << " so cannot be concatenated with anything to form it" << std::endl;);
+ << " so cannot be concatenated with anything to form it\n");
expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
expr_ref diseq(m.mk_not(equality), m);
assert_axiom(diseq);
return;
} else {
int varStrLen = resultStrLen - arg2StrLen;
- std::string firstPart = const_str.substr(0, varStrLen);
- std::string secondPart = const_str.substr(varStrLen, arg2StrLen);
+ zstring firstPart = const_str.extract(0, varStrLen);
+ zstring secondPart = const_str.extract(varStrLen, arg2StrLen);
if (arg2_str != secondPart) {
// Inconsistency
TRACE("t_str", tout << "inconsistency detected: "
<< "suffix of concatenation result expected \"" << secondPart << "\", "
<< "actually \"" << arg2_str << "\""
- << std::endl;);
+ << "\n");
expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
expr_ref diseq(m.mk_not(equality), m);
assert_axiom(diseq);
@@ -6279,31 +6308,30 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
} else if (arg1_has_eqc_value && !arg2_has_eqc_value) {
// Case 3: Concat(const, var) == const
TRACE("t_str", tout << "Case 3: Concat(const, var) == const" << std::endl;);
- const char * str1;
- m_strutil.is_string(arg1, & str1);
- std::string arg1_str(str1);
- int resultStrLen = const_str.length();
- int arg1StrLen = arg1_str.length();
+ zstring arg1_str;
+ u.str.is_string(arg1, arg1_str);
+ unsigned int resultStrLen = const_str.length();
+ unsigned int arg1StrLen = arg1_str.length();
if (resultStrLen < arg1StrLen) {
// Inconsistency
TRACE("t_str", tout << "inconsistency detected: \""
<< arg1_str <<
"\" is longer than \"" << const_str << "\","
- << " so cannot be concatenated with anything to form it" << std::endl;);
+ << " so cannot be concatenated with anything to form it" << "\n";);
expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
expr_ref diseq(m.mk_not(equality), m);
assert_axiom(diseq);
return;
} else {
int varStrLen = resultStrLen - arg1StrLen;
- std::string firstPart = const_str.substr(0, arg1StrLen);
- std::string secondPart = const_str.substr(arg1StrLen, varStrLen);
+ zstring firstPart = const_str.extract(0, arg1StrLen);
+ zstring secondPart = const_str.extract(arg1StrLen, varStrLen);
if (arg1_str != firstPart) {
// Inconsistency
TRACE("t_str", tout << "inconsistency detected: "
<< "prefix of concatenation result expected \"" << secondPart << "\", "
<< "actually \"" << arg1_str << "\""
- << std::endl;);
+ << "\n";);
expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
expr_ref diseq(m.mk_not(equality), m);
assert_axiom(diseq);
@@ -6327,7 +6355,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
if (arg1Len_exists || arg2Len_exists) {
expr_ref ax_l1(ctx.mk_eq_atom(concat, str), m);
expr_ref ax_l2(m);
- std::string prefixStr, suffixStr;
+ zstring prefixStr, suffixStr;
if (arg1Len_exists) {
if (arg1Len.is_neg()) {
TRACE("t_str_detail", tout << "length conflict: arg1Len = " << arg1Len << ", concatStrLen = " << concatStrLen << std::endl;);
@@ -6341,9 +6369,9 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
return;
}
- prefixStr = const_str.substr(0, arg1Len.get_unsigned());
+ prefixStr = const_str.extract(0, arg1Len.get_unsigned());
rational concat_minus_arg1 = concatStrLen - arg1Len;
- suffixStr = const_str.substr(arg1Len.get_unsigned(), concat_minus_arg1.get_unsigned());
+ suffixStr = const_str.extract(arg1Len.get_unsigned(), concat_minus_arg1.get_unsigned());
ax_l2 = ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len));
} else {
// arg2's length is available
@@ -6360,17 +6388,17 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
}
rational concat_minus_arg2 = concatStrLen - arg2Len;
- prefixStr = const_str.substr(0, concat_minus_arg2.get_unsigned());
- suffixStr = const_str.substr(concat_minus_arg2.get_unsigned(), arg2Len.get_unsigned());
+ prefixStr = const_str.extract(0, concat_minus_arg2.get_unsigned());
+ suffixStr = const_str.extract(concat_minus_arg2.get_unsigned(), arg2Len.get_unsigned());
ax_l2 = ctx.mk_eq_atom(mk_strlen(arg2), mk_int(arg2Len));
}
// consistency check
- if (is_concat(to_app(arg1)) && !can_concat_eq_str(arg1, prefixStr)) {
+ if (u.str.is_concat(to_app(arg1)) && !can_concat_eq_str(arg1, prefixStr)) {
expr_ref ax_r(m.mk_not(ax_l2), m);
assert_implication(ax_l1, ax_r);
return;
}
- if (is_concat(to_app(arg2)) && !can_concat_eq_str(arg2, suffixStr)) {
+ if (u.str.is_concat(to_app(arg2)) && !can_concat_eq_str(arg2, suffixStr)) {
expr_ref ax_r(m.mk_not(ax_l2), m);
assert_implication(ax_l1, ax_r);
return;
@@ -6379,10 +6407,10 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
r_items.push_back(ctx.mk_eq_atom(arg1, mk_string(prefixStr)));
r_items.push_back(ctx.mk_eq_atom(arg2, mk_string(suffixStr)));
if (!arg1Len_exists) {
- r_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(prefixStr.size())));
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(prefixStr.length())));
}
if (!arg2Len_exists) {
- r_items.push_back(ctx.mk_eq_atom(mk_strlen(arg2), mk_int(suffixStr.size())));
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(arg2), mk_int(suffixStr.length())));
}
expr_ref lhs(m.mk_and(ax_l1, ax_l2), m);
expr_ref rhs(mk_and(r_items), m);
@@ -6456,13 +6484,13 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
for (int i = 0; i < concatStrLen + 1; ++i) {
expr_ref_vector and_items(m);
- std::string prefixStr = const_str.substr(0, i);
- std::string suffixStr = const_str.substr(i, concatStrLen - i);
+ zstring prefixStr = const_str.extract(0, i);
+ zstring suffixStr = const_str.extract(i, concatStrLen - i);
// skip invalid options
- if (is_concat(to_app(arg1)) && !can_concat_eq_str(arg1, prefixStr)) {
+ if (u.str.is_concat(to_app(arg1)) && !can_concat_eq_str(arg1, prefixStr)) {
continue;
}
- if (is_concat(to_app(arg2)) && !can_concat_eq_str(arg2, suffixStr)) {
+ if (u.str.is_concat(to_app(arg2)) && !can_concat_eq_str(arg2, suffixStr)) {
continue;
}
@@ -6530,8 +6558,8 @@ expr_ref theory_str::set_up_finite_model_test(expr * lhs, expr * rhs) {
}
// make things easy for the core wrt. testvar
- expr_ref t1(ctx.mk_eq_atom(testvar, m_strutil.mk_string("")), m);
- expr_ref t_yes(ctx.mk_eq_atom(testvar, m_strutil.mk_string("yes")), m);
+ expr_ref t1(ctx.mk_eq_atom(testvar, u.str.mk_string("")), m);
+ expr_ref t_yes(ctx.mk_eq_atom(testvar, u.str.mk_string("yes")), m);
expr_ref testvaraxiom(m.mk_or(t1, t_yes), m);
assert_axiom(testvaraxiom);
@@ -6544,8 +6572,8 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
context & ctx = get_context();
ast_manager & m = get_manager();
- if (!m_strutil.is_string(str)) return;
- std::string s = m_strutil.get_string_constant_value(str);
+ zstring s;
+ if (!u.str.is_string(str, s)) return;
if (s == "yes") {
TRACE("t_str", tout << "start finite model test for " << mk_pp(testvar, m) << std::endl;);
ptr_vector<expr> & vars = finite_model_test_varlists[testvar];
@@ -6642,7 +6670,7 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
for (rational l = v_lower_bound; l <= v_upper_bound; l += rational::one()) {
std::string lStr = l.to_string();
- expr_ref str_indicator(m_strutil.mk_string(lStr), m);
+ expr_ref str_indicator(u.str.mk_string(lStr), m);
expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
orList.push_back(or_expr);
expr_ref and_expr(ctx.mk_eq_atom(or_expr, ctx.mk_eq_atom(vLengthExpr, m_autil.mk_numeral(l, true))), m);
@@ -6661,7 +6689,7 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
} // (s == "yes")
}
-void theory_str::more_len_tests(expr * lenTester, std::string lenTesterValue) {
+void theory_str::more_len_tests(expr * lenTester, zstring lenTesterValue) {
ast_manager & m = get_manager();
if (lenTester_fvar_map.contains(lenTester)) {
expr * fVar = lenTester_fvar_map[lenTester];
@@ -6673,7 +6701,7 @@ void theory_str::more_len_tests(expr * lenTester, std::string lenTesterValue) {
}
}
-void theory_str::more_value_tests(expr * valTester, std::string valTesterValue) {
+void theory_str::more_value_tests(expr * valTester, zstring valTesterValue) {
ast_manager & m = get_manager();
expr * fVar = valueTester_fvar_map[valTester];
@@ -6689,7 +6717,8 @@ void theory_str::more_value_tests(expr * valTester, std::string valTesterValue)
TRACE("t_str_binary_search", tout << "WARNING: length tester " << mk_pp(effectiveLenInd, m) << " at top of stack for " << mk_pp(fVar, m) << " has no EQC value" << std::endl;);
} else {
// safety check
- std::string effectiveLenIndiStr = m_strutil.get_string_constant_value(len_indicator_value);
+ zstring effectiveLenIndiStr;
+ u.str.is_string(len_indicator_value, effectiveLenIndiStr);
if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "less") {
TRACE("t_str_binary_search", tout << "ERROR: illegal state -- requesting 'more value tests' but a length tester is not yet concrete!" << std::endl;);
UNREACHABLE();
@@ -6704,13 +6733,14 @@ void theory_str::more_value_tests(expr * valTester, std::string valTesterValue)
int lenTesterCount = fvar_lenTester_map[fVar].size();
expr * effectiveLenInd = NULL;
- std::string effectiveLenIndiStr = "";
+ zstring effectiveLenIndiStr = "";
for (int i = 0; i < lenTesterCount; ++i) {
expr * len_indicator_pre = fvar_lenTester_map[fVar][i];
bool indicatorHasEqcValue = false;
expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
if (indicatorHasEqcValue) {
- std::string len_pIndiStr = m_strutil.get_string_constant_value(len_indicator_value);
+ zstring len_pIndiStr;
+ u.str.is_string(len_indicator_value, len_pIndiStr);
if (len_pIndiStr != "more") {
effectiveLenInd = len_indicator_pre;
effectiveLenIndiStr = len_pIndiStr;
@@ -6728,14 +6758,13 @@ void theory_str::more_value_tests(expr * valTester, std::string valTesterValue)
bool theory_str::free_var_attempt(expr * nn1, expr * nn2) {
ast_manager & m = get_manager();
-
- if (internal_lenTest_vars.contains(nn1) && m_strutil.is_string(nn2)) {
+ zstring nn2_str;
+ if (internal_lenTest_vars.contains(nn1) && u.str.is_string(nn2, nn2_str)) {
TRACE("t_str", tout << "acting on equivalence between length tester var " << mk_ismt2_pp(nn1, m)
<< " and constant " << mk_ismt2_pp(nn2, m) << std::endl;);
- more_len_tests(nn1, m_strutil.get_string_constant_value(nn2));
+ more_len_tests(nn1, nn2_str);
return true;
- } else if (internal_valTest_vars.contains(nn1) && m_strutil.is_string(nn2)) {
- std::string nn2_str = m_strutil.get_string_constant_value(nn2);
+ } else if (internal_valTest_vars.contains(nn1) && u.str.is_string(nn2, nn2_str)) {
if (nn2_str == "more") {
TRACE("t_str", tout << "acting on equivalence between value var " << mk_ismt2_pp(nn1, m)
<< " and constant " << mk_ismt2_pp(nn2, m) << std::endl;);
@@ -6755,7 +6784,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
// both terms must be of sort String
sort * lhs_sort = m.get_sort(lhs);
sort * rhs_sort = m.get_sort(rhs);
- sort * str_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ sort * str_sort = u.str.mk_string_sort();
if (lhs_sort != str_sort || rhs_sort != str_sort) {
TRACE("t_str_detail", tout << "skip equality: not String sort" << std::endl;);
@@ -6776,7 +6805,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
return;
}
- if (is_concat(to_app(lhs)) && is_concat(to_app(rhs))) {
+ if (u.str.is_concat(to_app(lhs)) && u.str.is_concat(to_app(rhs))) {
bool nn1HasEqcValue = false;
bool nn2HasEqcValue = false;
expr * nn1_value = get_eqc_value(lhs, nn1HasEqcValue);
@@ -6993,7 +7022,7 @@ void theory_str::set_up_axioms(expr * ex) {
context & ctx = get_context();
sort * ex_sort = m.get_sort(ex);
- sort * str_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ sort * str_sort = u.str.mk_string_sort();
sort * bool_sort = m.mk_bool_sort();
family_id m_arith_fid = m.mk_family_id("arith");
@@ -7011,23 +7040,23 @@ void theory_str::set_up_axioms(expr * ex) {
if (is_app(ex)) {
app * ap = to_app(ex);
- if (is_concat(ap)) {
+ if (u.str.is_concat(ap)) {
// if ex is a concat, set up concat axioms later
m_concat_axiom_todo.push_back(n);
// we also want to check whether we can eval this concat,
// in case the rewriter did not totally finish with this term
m_concat_eval_todo.push_back(n);
- } else if (is_strlen(ap)) {
+ } else if (u.str.is_length(ap)) {
// if the argument is a variable,
// keep track of this for later, we'll need it during model gen
expr * var = ap->get_arg(0);
app * aVar = to_app(var);
- if (aVar->get_num_args() == 0 && !is_string(aVar)) {
+ if (aVar->get_num_args() == 0 && !u.str.is_string(aVar)) {
input_var_in_len.insert(var);
}
- } else if (is_CharAt(ap) || is_Substr(ap) || is_Replace(ap)) {
+ } else if (u.str.is_at(ap) || u.str.is_extract(ap) || u.str.is_replace(ap)) {
m_library_aware_axiom_todo.push_back(n);
- } else if (ap->get_num_args() == 0 && !is_string(ap)) {
+ } else if (ap->get_num_args() == 0 && !u.str.is_string(ap)) {
// if ex is a variable, add it to our list of variables
TRACE("t_str_detail", tout << "tracking variable " << mk_ismt2_pp(ap, get_manager()) << std::endl;);
variable_set.insert(ex);
@@ -7049,7 +7078,7 @@ void theory_str::set_up_axioms(expr * ex) {
if (is_app(ex)) {
app * ap = to_app(ex);
- if (is_StartsWith(ap) || is_EndsWith(ap) || is_Contains(ap) || is_RegexIn(ap)) {
+ if (u.str.is_prefix(ap) || u.str.is_suffix(ap) || u.str.is_contains(ap) || u.str.is_in_re(ap)) {
m_library_aware_axiom_todo.push_back(n);
}
}
@@ -7068,9 +7097,10 @@ void theory_str::set_up_axioms(expr * ex) {
if (is_app(ex)) {
app * ap = to_app(ex);
- if (is_Indexof(ap) || is_Indexof2(ap) || is_LastIndexof(ap)) {
+ // TODO indexof2/lastindexof
+ if (u.str.is_index(ap) /* || is_Indexof2(ap) || is_LastIndexof(ap) */) {
m_library_aware_axiom_todo.push_back(n);
- } else if (is_str_to_int(ap) || is_int_to_str(ap)) {
+ } else if (u.str.is_stoi(ap) || u.str.is_itos(ap)) {
string_int_conversion_terms.push_back(ap);
m_library_aware_axiom_todo.push_back(n);
}
@@ -7200,12 +7230,12 @@ void theory_str::recursive_check_variable_scope(expr * ex) {
if (a->get_num_args() == 0) {
// we only care about string variables
sort * s = m.get_sort(ex);
- sort * string_sort = m.mk_sort(get_family_id(), STRING_SORT);
+ sort * string_sort = u.str.mk_string_sort();
if (s != string_sort) {
return;
}
// base case: string constant / var
- if (m_strutil.is_string(a)) {
+ if (u.str.is_string(a)) {
return;
} else {
// assume var
@@ -7331,10 +7361,10 @@ void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap
// check whether the node is a function that we want to inspect
else if (is_app(node)) {
app * aNode = to_app(node);
- if (is_strlen(aNode)) {
+ if (u.str.is_length(aNode)) {
// Length
return;
- } else if (is_concat(aNode)) {
+ } else if (u.str.is_concat(aNode)) {
expr * arg0 = aNode->get_arg(0);
expr * arg1 = aNode->get_arg(1);
bool arg0HasEq = false;
@@ -7343,10 +7373,13 @@ void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap
expr * arg1Val = get_eqc_value(arg1, arg1HasEq);
int canskip = 0;
- if (arg0HasEq && m_strutil.get_string_constant_value(arg0Val).empty()) {
+ zstring tmp;
+ u.str.is_string(arg0Val, tmp);
+ if (arg0HasEq && tmp.empty()) {
canskip = 1;
}
- if (canskip == 0 && arg1HasEq && m_strutil.get_string_constant_value(arg1Val).empty()) {
+ u.str.is_string(arg1Val, tmp);
+ if (canskip == 0 && arg1HasEq && tmp.empty()) {
canskip = 1;
}
if (canskip == 0 && concatMap.find(node) == concatMap.end()) {
@@ -7402,7 +7435,7 @@ inline expr * theory_str::get_alias_index_ast(std::map<expr*, expr*> & aliasInde
inline expr * theory_str::getMostLeftNodeInConcat(expr * node) {
app * aNode = to_app(node);
- if (!is_concat(aNode)) {
+ if (!u.str.is_concat(aNode)) {
return node;
} else {
expr * concatArgL = aNode->get_arg(0);
@@ -7412,7 +7445,7 @@ inline expr * theory_str::getMostLeftNodeInConcat(expr * node) {
inline expr * theory_str::getMostRightNodeInConcat(expr * node) {
app * aNode = to_app(node);
- if (!is_concat(aNode)) {
+ if (!u.str.is_concat(aNode)) {
return node;
} else {
expr * concatArgR = aNode->get_arg(1);
@@ -7556,7 +7589,7 @@ void theory_str::trace_ctx_dep(std::ofstream & tout,
enode * e_curr_end = e_curr;
do {
app * curr = e_curr->get_owner();
- if (is_concat(curr)) {
+ if (u.str.is_concat(curr)) {
tout << " >>> " << mk_pp(curr, mgr) << std::endl;
}
e_curr = e_curr->get_next();
@@ -7691,7 +7724,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
while (curr != deAliasNode) {
app * aCurr = to_app(curr);
// collect concat
- if (is_concat(aCurr)) {
+ if (u.str.is_concat(aCurr)) {
expr * arg0 = aCurr->get_arg(0);
expr * arg1 = aCurr->get_arg(1);
bool arg0HasEqcValue = false;
@@ -7701,18 +7734,18 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
bool is_arg0_emptyStr = false;
if (arg0HasEqcValue) {
- const char * strval = 0;
- m_strutil.is_string(arg0_value, &strval);
- if (strcmp(strval, "") == 0) {
+ zstring strval;
+ u.str.is_string(arg0_value, strval);
+ if (strval.empty()) {
is_arg0_emptyStr = true;
}
}
bool is_arg1_emptyStr = false;
if (arg1HasEqcValue) {
- const char * strval = 0;
- m_strutil.is_string(arg1_value, &strval);
- if (strcmp(strval, "") == 0) {
+ zstring strval;
+ u.str.is_string(arg1_value, strval);
+ if (strval.empty()) {
is_arg1_emptyStr = true;
}
}
@@ -7746,7 +7779,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
expr * aRoot = NULL;
expr * curr = concatItor->first;
do {
- if (is_concat(to_app(curr))) {
+ if (u.str.is_concat(to_app(curr))) {
if (aRoot == NULL) {
aRoot = curr;
} else {
@@ -7780,7 +7813,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
if (concat_eq_concat_map.find(deAliasConcat) == concat_eq_concat_map.end()) {
expr * curr = deAliasConcat;
do {
- if (is_concat(to_app(curr))) {
+ if (u.str.is_concat(to_app(curr))) {
// curr cannot be reduced
if (concatMap.find(curr) != concatMap.end()) {
concat_eq_concat_map[deAliasConcat][curr] = 1;
@@ -7903,9 +7936,9 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
expr * concatNode = itor1->first;
expr * mLNode = getMostLeftNodeInConcat(concatNode);
- const char * strval;
- if (m_strutil.is_string(to_app(mLNode), & strval)) {
- if (mLConst == NULL && strcmp(strval, "") != 0) {
+ zstring strval;
+ if (u.str.is_string(to_app(mLNode), strval)) {
+ if (mLConst == NULL && strval.empty()) {
mLConst = mLNode;
}
} else {
@@ -7913,8 +7946,8 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
}
expr * mRNode = getMostRightNodeInConcat(concatNode);
- if (m_strutil.is_string(to_app(mRNode), & strval)) {
- if (mRConst == NULL && strcmp(strval, "") != 0) {
+ if (u.str.is_string(to_app(mRNode), strval)) {
+ if (mRConst == NULL && strval.empty()) {
mRConst = mRNode;
}
} else {
@@ -8187,7 +8220,7 @@ bool theory_str::finalcheck_str2int(app * a) {
TRACE("t_str_detail", tout << "integer theory assigns " << mk_pp(a, m) << " = " << Ival.to_string() << std::endl;);
// if that value is not -1, we can assert (str.to-int S) = Ival --> S = "Ival"
if (!Ival.is_minus_one()) {
- std::string Ival_str = Ival.to_string();
+ zstring Ival_str(Ival.to_string().c_str());
expr_ref premise(ctx.mk_eq_atom(a, m_autil.mk_numeral(Ival, true)), m);
expr_ref conclusion(ctx.mk_eq_atom(S, mk_string(Ival_str)), m);
expr_ref axiom(rewrite_implication(premise, conclusion), m);
@@ -8217,8 +8250,9 @@ bool theory_str::finalcheck_int2str(app * a) {
bool Sval_expr_exists;
expr * Sval_expr = get_eqc_value(a, Sval_expr_exists);
if (Sval_expr_exists) {
- std::string Sval = m_strutil.get_string_constant_value(Sval_expr);
- TRACE("t_str_detail", tout << "string theory assigns \"" << mk_pp(a, m) << " = " << Sval << std::endl;);
+ zstring Sval;
+ u.str.is_string(Sval_expr, Sval);
+ TRACE("t_str_detail", tout << "string theory assigns \"" << mk_pp(a, m) << " = " << Sval << "\n";);
// empty string --> integer value < 0
if (Sval.empty()) {
// ignore this. we should already assert the axiom for what happens when the string is ""
@@ -8228,7 +8262,7 @@ bool theory_str::finalcheck_int2str(app * a) {
rational ten(10);
bool conversionOK = true;
for (unsigned i = 0; i < Sval.length(); ++i) {
- char digit = Sval.at(i);
+ char digit = (int)Sval[i];
if (isdigit((int)digit)) {
std::string sDigit(1, digit);
int val = atoi(sDigit.c_str());
@@ -8272,11 +8306,11 @@ void theory_str::collect_var_concat(expr * node, std::set<expr*> & varSet, std::
}
else if (is_app(node)) {
app * aNode = to_app(node);
- if (is_strlen(aNode)) {
+ if (u.str.is_length(aNode)) {
// Length
return;
}
- if (is_concat(aNode)) {
+ if (u.str.is_concat(aNode)) {
expr * arg0 = aNode->get_arg(0);
expr * arg1 = aNode->get_arg(1);
if (concatSet.find(node) == concatSet.end()) {
@@ -8406,7 +8440,7 @@ bool theory_str::propagate_length(std::set<expr*> & varSet, std::set<expr*> & co
void theory_str::get_unique_non_concat_nodes(expr * node, std::set<expr*> & argSet) {
app * a_node = to_app(node);
- if (!is_concat(a_node)) {
+ if (!u.str.is_concat(a_node)) {
argSet.insert(node);
return;
} else {
@@ -8447,7 +8481,7 @@ final_check_status theory_str::final_check_eh() {
for (std::set<enode*>::iterator it = eqc_roots.begin(); it != eqc_roots.end(); ++it) {
enode * e = *it;
app * a = e->get_owner();
- if (!(is_sort_of(m.get_sort(a), m_strutil.get_fid(), STRING_SORT))) {
+ if (!(m.get_sort(a) == u.str.mk_string_sort())) {
TRACE("t_str_detail", tout << "EQC root " << mk_pp(a, m) << " not a string term; skipping" << std::endl;);
} else {
TRACE("t_str_detail", tout << "EQC root " << mk_pp(a, m) << " is a string term. Checking this EQC" << std::endl;);
@@ -8516,9 +8550,10 @@ final_check_status theory_str::final_check_eh() {
if (concat_lhs_haseqc && concat_rhs_haseqc && !var_haseqc) {
TRACE("t_str_detail", tout << "backpropagate into " << mk_pp(var, m) << " = " << mk_pp(concat, m) << std::endl
<< "LHS ~= " << mk_pp(concat_lhs_str, m) << " RHS ~= " << mk_pp(concat_rhs_str, m) << std::endl;);
- std::string lhsString = m_strutil.get_string_constant_value(concat_lhs_str);
- std::string rhsString = m_strutil.get_string_constant_value(concat_rhs_str);
- std::string concatString = lhsString + rhsString;
+ zstring lhsString, rhsString;
+ u.str.is_string(concat_lhs_str, lhsString);
+ u.str.is_string(concat_rhs_str, rhsString);
+ zstring concatString = lhsString + rhsString;
expr_ref lhs1(ctx.mk_eq_atom(concat_lhs, concat_lhs_str), m);
expr_ref lhs2(ctx.mk_eq_atom(concat_rhs, concat_rhs_str), m);
expr_ref lhs(m.mk_and(lhs1, lhs2), m);
@@ -8584,12 +8619,12 @@ final_check_status theory_str::final_check_eh() {
bool addedStrIntAxioms = false;
for (unsigned i = 0; i < string_int_conversion_terms.size(); ++i) {
app * ex = to_app(string_int_conversion_terms[i].get());
- if (is_str_to_int(ex)) {
+ if (u.str.is_stoi(ex)) {
bool axiomAdd = finalcheck_str2int(ex);
if (axiomAdd) {
addedStrIntAxioms = true;
}
- } else if (is_int_to_str(ex)) {
+ } else if (u.str.is_itos(ex)) {
bool axiomAdd = finalcheck_int2str(ex);
if (axiomAdd) {
addedStrIntAxioms = true;
@@ -8664,7 +8699,7 @@ final_check_status theory_str::final_check_eh() {
expr * unroll = urItor->first;
expr * curr = unroll;
do {
- if (is_concat(to_app(curr))) {
+ if (u.str.is_concat(to_app(curr))) {
concatEqUnrollsMap[curr].insert(unroll);
concatEqUnrollsMap[curr].insert(unrollGroup_map[unroll].begin(), unrollGroup_map[unroll].end());
}
@@ -8690,7 +8725,7 @@ final_check_status theory_str::final_check_eh() {
} else {
fvUnrollSet.insert(concatArg1);
}
- } else if (is_concat(to_app(concatArg1))) {
+ } else if (u.str.is_concat(to_app(concatArg1))) {
if (concatEqUnrollsMap.find(concatArg1) == concatEqUnrollsMap.end()) {
arg1Bounded = true;
}
@@ -8702,7 +8737,7 @@ final_check_status theory_str::final_check_eh() {
} else {
fvUnrollSet.insert(concatArg2);
}
- } else if (is_concat(to_app(concatArg2))) {
+ } else if (u.str.is_concat(to_app(concatArg2))) {
if (concatEqUnrollsMap.find(concatArg2) == concatEqUnrollsMap.end()) {
arg2Bounded = true;
}
@@ -8794,10 +8829,11 @@ final_check_status theory_str::final_check_eh() {
return FC_CONTINUE; // since by this point we've added axioms
}
-inline std::string int_to_string(int i) {
+inline zstring int_to_string(int i) {
std::stringstream ss;
ss << i;
- return ss.str();
+ std::string str = ss.str();
+ return zstring(str.c_str());
}
inline std::string longlong_to_string(long long i) {
@@ -8823,11 +8859,11 @@ void theory_str::print_value_tester_list(svector<std::pair<int, expr*> > & teste
);
}
-std::string theory_str::gen_val_string(int len, int_vector & encoding) {
+zstring theory_str::gen_val_string(int len, int_vector & encoding) {
SASSERT(charSetSize > 0);
SASSERT(char_set != NULL);
- std::string re = std::string(len, char_set[0]);
+ zstring re(len, (int) char_set[0]);
for (int i = 0; i < (int) encoding.size() - 1; i++) {
int idx = encoding[i];
re[len - 1 - i] = char_set[idx];
@@ -8876,7 +8912,7 @@ bool theory_str::get_next_val_encode(int_vector & base, int_vector & next) {
}
expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
- std::string lenStr, int tries) {
+ zstring lenStr, int tries) {
ast_manager & m = get_manager();
context & ctx = get_context();
@@ -8894,7 +8930,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
// {0, 0, 1}
// the last item "1" shows this is not a valid encoding, and we have covered all space
// ----------------------------------------------------------------------------------------
- int len = atoi(lenStr.c_str());
+ int len = atoi(lenStr.encode().c_str());
bool coverAll = false;
svector<int_vector> options;
int_vector base;
@@ -8903,8 +8939,8 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
<< "freeVar = " << mk_ismt2_pp(freeVar, m) << std::endl
<< "len_indicator = " << mk_ismt2_pp(len_indicator, m) << std::endl
<< "val_indicator = " << mk_ismt2_pp(val_indicator, m) << std::endl
- << "lenstr = " << lenStr << std::endl
- << "tries = " << tries << std::endl;
+ << "lenstr = " << lenStr << "\n"
+ << "tries = " << tries << "\n";
if (m_params.m_AggressiveValueTesting) {
tout << "note: aggressive value testing is enabled" << std::endl;
}
@@ -8953,7 +8989,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
ctx.force_phase(l);
}
- std::string aStr = gen_val_string(len, options[i - l]);
+ zstring aStr = gen_val_string(len, options[i - l]);
expr * strAst;
if (m_params.m_UseFastValueTesterCache) {
if (!valueTesterCache.find(aStr, strAst)) {
@@ -8996,7 +9032,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
// Should add ($$_len_x_j = 16) /\ ($$_val_x_16_i = "more")
// ---------------------------------------
andList.reset();
- andList.push_back(m.mk_eq(len_indicator, mk_string(lenStr.c_str())));
+ andList.push_back(m.mk_eq(len_indicator, mk_string(lenStr)));
for (int i = 0; i < tries; i++) {
expr * vTester = fvar_valueTester_map[freeVar][len][i].second;
if (vTester != val_indicator)
@@ -9019,10 +9055,10 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
}
expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
- std::string len_valueStr, expr * valTesterInCbEq, std::string valTesterValueStr) {
+ zstring len_valueStr, expr * valTesterInCbEq, zstring valTesterValueStr) {
ast_manager & m = get_manager();
- int len = atoi(len_valueStr.c_str());
+ int len = atoi(len_valueStr.encode().c_str());
// check whether any value tester is actually in scope
TRACE("t_str_detail", tout << "checking scope of previous value testers" << std::endl;);
@@ -9117,7 +9153,7 @@ void theory_str::reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vect
TRACE("t_str_detail", tout << "reduce regex " << mk_pp(regex, mgr) << " with respect to variable " << mk_pp(var, mgr) << std::endl;);
app * regexFuncDecl = to_app(regex);
- if (is_Str2Reg(regexFuncDecl)) {
+ if (u.re.is_to_re(regexFuncDecl)) {
// ---------------------------------------------------------
// var \in Str2Reg(s1)
// ==>
@@ -9129,7 +9165,7 @@ void theory_str::reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vect
return;
}
// RegexUnion
- else if (is_RegexUnion(regexFuncDecl)) {
+ else if (u.re.is_union(regexFuncDecl)) {
// ---------------------------------------------------------
// var \in RegexUnion(r1, r2)
// ==>
@@ -9156,7 +9192,7 @@ void theory_str::reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vect
return;
}
// RegexConcat
- else if (is_RegexConcat(regexFuncDecl)) {
+ else if (u.re.is_concat(regexFuncDecl)) {
// ---------------------------------------------------------
// var \in RegexConcat(r1, r2)
// ==>
@@ -9177,7 +9213,7 @@ void theory_str::reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vect
return;
}
// Unroll
- else if (is_RegexStar(regexFuncDecl)) {
+ else if (u.re.is_star(regexFuncDecl)) {
// ---------------------------------------------------------
// var \in Star(r1)
// ==>
@@ -9190,6 +9226,7 @@ void theory_str::reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vect
items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_strlen(unrollFunc)));
return;
} else {
+ get_manager().raise_exception("unrecognized regex operator");
UNREACHABLE();
}
}
@@ -9291,8 +9328,8 @@ static int computeLCM(int a, int b) {
return temp ? (a / temp * b) : 0;
}
-static std::string get_unrolled_string(std::string core, int count) {
- std::string res = "";
+static zstring get_unrolled_string(zstring core, int count) {
+ zstring res("");
for (int i = 0; i < count; i++) {
res += core;
}
@@ -9306,11 +9343,12 @@ expr * theory_str::gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls
int lcm = 1;
int coreValueCount = 0;
expr * oneUnroll = NULL;
- std::string oneCoreStr = "";
+ zstring oneCoreStr("");
for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
expr * str2RegFunc = to_app(*itor)->get_arg(0);
expr * coreVal = to_app(str2RegFunc)->get_arg(0);
- std::string coreStr = m_strutil.get_string_constant_value(coreVal);
+ zstring coreStr;
+ u.str.is_string(coreVal, coreStr);
if (oneUnroll == NULL) {
oneUnroll = *itor;
oneCoreStr = coreStr;
@@ -9322,13 +9360,14 @@ expr * theory_str::gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls
//
bool canHaveNonEmptyAssign = true;
expr_ref_vector litems(mgr);
- std::string lcmStr = get_unrolled_string(oneCoreStr, (lcm / oneCoreStr.length()));
+ zstring lcmStr = get_unrolled_string(oneCoreStr, (lcm / oneCoreStr.length()));
for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
expr * str2RegFunc = to_app(*itor)->get_arg(0);
expr * coreVal = to_app(str2RegFunc)->get_arg(0);
- std::string coreStr = m_strutil.get_string_constant_value(coreVal);
- int core1Len = coreStr.length();
- std::string uStr = get_unrolled_string(coreStr, (lcm / core1Len));
+ zstring coreStr;
+ u.str.is_string(coreVal, coreStr);
+ unsigned int core1Len = coreStr.length();
+ zstring uStr = get_unrolled_string(coreStr, (lcm / core1Len));
if (uStr != lcmStr) {
canHaveNonEmptyAssign = false;
}
@@ -9346,7 +9385,7 @@ expr * theory_str::gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls
}
}
-expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, std::string lcmStr) {
+expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, zstring lcmStr) {
context & ctx = get_context();
ast_manager & mgr = get_manager();
@@ -9416,8 +9455,9 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
// insert [tester = "more"] to litems so that the implyL for next tester is correct
litems.push_back(ctx.mk_eq_atom(tester, moreAst));
} else {
- std::string testerStr = m_strutil.get_string_constant_value(testerVal);
- TRACE("t_str_detail", tout << "Tester [" << mk_pp(tester, mgr) << "] = " << testerStr << std::endl;);
+ zstring testerStr;
+ u.str.is_string(testerVal, testerStr);
+ TRACE("t_str_detail", tout << "Tester [" << mk_pp(tester, mgr) << "] = " << testerStr << "\n";);
if (testerStr == "more") {
litems.push_back(ctx.mk_eq_atom(tester, moreAst));
}
@@ -9438,12 +9478,12 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
return toAssert;
}
-expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * testerVar, int l, int h) {
+expr * theory_str::gen_unroll_assign(expr * var, zstring lcmStr, expr * testerVar, int l, int h) {
context & ctx = get_context();
ast_manager & mgr = get_manager();
TRACE("t_str_detail", tout << "entry: var = " << mk_pp(var, mgr) << ", lcmStr = " << lcmStr
- << ", l = " << l << ", h = " << h << std::endl;);
+ << ", l = " << l << ", h = " << h << "\n";);
if (m_params.m_AggressiveUnrollTesting) {
TRACE("t_str_detail", tout << "note: aggressive unroll testing is active" << std::endl;);
@@ -9453,7 +9493,7 @@ expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * test
expr_ref_vector andItems(mgr);
for (int i = l; i < h; i++) {
- std::string iStr = int_to_string(i);
+ zstring iStr = int_to_string(i);
expr_ref testerEqAst(ctx.mk_eq_atom(testerVar, mk_string(iStr)), mgr);
TRACE("t_str_detail", tout << "testerEqAst = " << mk_pp(testerEqAst, mgr) << std::endl;);
if (m_params.m_AggressiveUnrollTesting) {
@@ -9463,7 +9503,7 @@ expr * theory_str::gen_unroll_assign(expr * var, std::string lcmStr, expr * test
}
orItems.push_back(testerEqAst);
- std::string unrollStrInstance = get_unrolled_string(lcmStr, i);
+ zstring unrollStrInstance = get_unrolled_string(lcmStr, i);
expr_ref x1(ctx.mk_eq_atom(testerEqAst, ctx.mk_eq_atom(var, mk_string(unrollStrInstance))), mgr);
TRACE("t_str_detail", tout << "x1 = " << mk_pp(x1, mgr) << std::endl;);
@@ -9535,14 +9575,14 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
str_indicator = expr_ref(lookup_val, m);
} else {
// no match; create and insert
- std::string i_str = int_to_string(i);
+ zstring i_str = int_to_string(i);
expr_ref new_val(mk_string(i_str), m);
lengthTesterCache.insert(ri, new_val);
m_trail.push_back(new_val);
str_indicator = expr_ref(new_val, m);
}
} else {
- std::string i_str = int_to_string(i);
+ zstring i_str = int_to_string(i);
str_indicator = expr_ref(mk_string(i_str), m);
}
expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
@@ -9661,7 +9701,7 @@ expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, bin
testerCases.push_back(caseMore);
combinedCaseSplit.push_back(ctx.mk_eq_atom(caseMore, m_autil.mk_ge(lenFreeVar, m_autil.mk_numeral(N_plus_one, true) )));
- expr_ref caseEq(ctx.mk_eq_atom(tester, mk_string(N.to_string())), m);
+ expr_ref caseEq(ctx.mk_eq_atom(tester, mk_string(N.to_string().c_str())), m);
testerCases.push_back(caseEq);
combinedCaseSplit.push_back(ctx.mk_eq_atom(caseEq, ctx.mk_eq_atom(lenFreeVar, m_autil.mk_numeral(N, true))));
@@ -9712,7 +9752,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
expr * lastTester = binary_search_len_tester_stack[freeVar].back();
bool lastTesterHasEqcValue;
expr * lastTesterValue = get_eqc_value(lastTester, lastTesterHasEqcValue);
- std::string lastTesterConstant;
+ zstring lastTesterConstant;
if (!lastTesterHasEqcValue) {
TRACE("t_str_binary_search", tout << "length tester " << mk_pp(lastTester, m) << " at top of stack doesn't have an EQC value yet" << std::endl;);
// check previousLenTester
@@ -9724,9 +9764,9 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
UNREACHABLE(); return NULL;
}
} else {
- lastTesterConstant = m_strutil.get_string_constant_value(lastTesterValue);
+ u.str.is_string(lastTesterValue, lastTesterConstant);
}
- TRACE("t_str_binary_search", tout << "last length tester is assigned \"" << lastTesterConstant << "\"" << std::endl;);
+ TRACE("t_str_binary_search", tout << "last length tester is assigned \"" << lastTesterConstant << "\"" << "\n";);
if (lastTesterConstant == "more" || lastTesterConstant == "less") {
// use the previous bounds info to generate a new midpoint
binary_search_info lastBounds;
@@ -9805,7 +9845,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
return axiom;
}
// length is fixed
- expr * valueAssert = gen_free_var_options(freeVar, lastTester, lastTesterConstant, NULL, "");
+ expr * valueAssert = gen_free_var_options(freeVar, lastTester, lastTesterConstant, NULL, zstring(""));
return valueAssert;
}
} else {
@@ -9906,7 +9946,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
TRACE("t_str_detail", tout << "found previous in-scope length assertions" << std::endl;);
expr * effectiveLenInd = NULL;
- std::string effectiveLenIndiStr = "";
+ zstring effectiveLenIndiStr("");
int lenTesterCount = (int) fvar_lenTester_map[freeVar].size();
TRACE("t_str_detail",
@@ -9934,9 +9974,8 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
TRACE("t_str_detail", tout << "length indicator " << mk_ismt2_pp(len_indicator_pre, m) <<
" = " << mk_ismt2_pp(len_indicator_value, m) << std::endl;);
if (indicatorHasEqcValue) {
- const char * val = 0;
- m_strutil.is_string(len_indicator_value, & val);
- std::string len_pIndiStr(val);
+ zstring len_pIndiStr;
+ u.str.is_string(len_indicator_value, len_pIndiStr);
if (len_pIndiStr != "more") {
effectiveLenInd = len_indicator_pre;
effectiveLenIndiStr = len_pIndiStr;
@@ -9964,7 +10003,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
effectiveLenIndiStr = lenTesterValue;
} else {
if (effectiveHasEqcValue) {
- effectiveLenIndiStr = m_strutil.get_string_constant_value(effective_eqc_value);
+ u.str.is_string(effective_eqc_value, effectiveLenIndiStr);
} else {
NOT_IMPLEMENTED_YET();
}
@@ -9988,7 +10027,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
unsigned int testNum = 0;
TRACE("t_str", tout << "effectiveLenIndiStr = " << effectiveLenIndiStr
- << ", i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
+ << ", i = " << i << ", lenTesterCount = " << lenTesterCount << "\n";);
if (i == lenTesterCount) {
fvar_len_count_map[freeVar] = fvar_len_count_map[freeVar] + 1;
@@ -10007,7 +10046,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
} else {
TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
// length is fixed
- expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, "");
+ expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, zstring(""));
return valueAssert;
}
} // fVarLenCountMap.find(...)
@@ -10020,7 +10059,7 @@ void theory_str::get_concats_in_eqc(expr * n, std::set<expr*> & concats) {
expr * eqcNode = n;
do {
- if (is_concat(to_app(eqcNode))) {
+ if (u.str.is_concat(to_app(eqcNode))) {
concats.insert(eqcNode);
}
eqcNode = get_eqc_next(eqcNode);
@@ -10096,7 +10135,7 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
enode_vector::iterator it = e_freeVar->begin_parents();
for (; it != e_freeVar->end_parents(); ++it) {
expr * parentAst = (*it)->get_owner();
- if (is_concat(to_app(parentAst))) {
+ if (u.str.is_concat(to_app(parentAst))) {
standAlone = false;
break;
}
@@ -10150,7 +10189,7 @@ void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> &
expr * curr = n;
do {
- if (is_string(to_app(curr))) {
+ if (u.str.is_string(to_app(curr))) {
constStr = curr;
} else if (is_Unroll(to_app(curr))) {
if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
@@ -10169,11 +10208,11 @@ void theory_str::get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*
expr * curr = n;
do {
- if (is_string(to_app(curr))) {
+ if (u.str.is_string(to_app(curr))) {
constStr = curr;
} else if (is_Unroll(to_app(curr))) {
expr * core = to_app(curr)->get_arg(0);
- if (is_Str2Reg(to_app(core))) {
+ if (u.re.is_to_re(to_app(core))) {
if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
unrollFuncSet.insert(curr);
}
@@ -10200,9 +10239,9 @@ void theory_str::init_model(model_generator & mg) {
* or else returns NULL if no concrete value was derived.
*/
app * theory_str::mk_value_helper(app * n) {
- if (m_strutil.is_string(n)) {
+ if (u.str.is_string(n)) {
return n;
- } else if (is_concat(n)) {
+ } else if (u.str.is_concat(n)) {
// recursively call this function on each argument
SASSERT(n->get_num_args() == 2);
expr * a0 = n->get_arg(0);
@@ -10212,15 +10251,10 @@ app * theory_str::mk_value_helper(app * n) {
app * a1_conststr = mk_value_helper(to_app(a1));
if (a0_conststr != NULL && a1_conststr != NULL) {
- const char * a0_str = 0;
- m_strutil.is_string(a0_conststr, &a0_str);
-
- const char * a1_str = 0;
- m_strutil.is_string(a1_conststr, &a1_str);
-
- std::string a0_s(a0_str);
- std::string a1_s(a1_str);
- std::string result = a0_s + a1_s;
+ zstring a0_s, a1_s;
+ u.str.is_string(a0_conststr, a0_s);
+ u.str.is_string(a1_conststr, a1_s);
+ zstring result = a0_s + a1_s;
return to_app(mk_string(result));
}
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 63f5d3cfc..3be852cf4 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -30,10 +30,44 @@ Revision History:
#include<map>
#include"seq_decl_plugin.h"
#include"union_find.h"
-#include"theory_seq_empty.h"
namespace smt {
+ class str_value_factory : public value_factory {
+ seq_util u;
+ symbol_set m_strings;
+ std::string delim;
+ unsigned m_next;
+ public:
+ str_value_factory(ast_manager & m, family_id fid) :
+ value_factory(m, fid),
+ u(m), delim("!"), m_next(0) {}
+ virtual ~str_value_factory() {}
+ virtual expr * get_some_value(sort * s) {
+ return u.str.mk_string("some value");
+ }
+ virtual bool get_some_values(sort * s, expr_ref & v1, expr_ref & v2) {
+ v1 = u.str.mk_string("value 1");
+ v2 = u.str.mk_string("value 2");
+ return true;
+ }
+ virtual expr * get_fresh_value(sort * s) {
+ if (u.is_string(s)) {
+ while (true) {
+ std::ostringstream strm;
+ strm << delim << std::hex << (m_next++) << std::dec << delim;
+ symbol sym(strm.str().c_str());
+ if (m_strings.contains(sym)) continue;
+ m_strings.insert(sym);
+ return u.str.mk_string(sym);
+ }
+ } else {
+ UNREACHABLE(); return NULL;
+ }
+ }
+ virtual void register_value(expr * n) { /* Ignore */ }
+ };
+
// rather than modify obj_pair_map I inherit from it and add my own helper methods
class theory_str_contain_pair_bool_map_t : public obj_pair_map<expr, expr, expr*> {
public:
@@ -237,8 +271,8 @@ namespace smt {
//obj_map<expr, obj_pair_set<expr, expr> > contain_pair_idx_map;
std::map<expr*, std::set<std::pair<expr*, expr*> > > contain_pair_idx_map;
- std::map<std::pair<expr*, std::string>, expr*> regex_in_bool_map;
- std::map<expr*, std::set<std::string> > regex_in_var_reg_str_map;
+ std::map<std::pair<expr*, zstring>, expr*> regex_in_bool_map;
+ std::map<expr*, std::set<zstring> > regex_in_var_reg_str_map;
// std::map<expr*, nfa> regex_nfa_cache; // Regex term --> NFA
@@ -380,7 +414,7 @@ namespace smt {
bool upper_bound(expr* _e, rational& hi);
bool can_two_nodes_eq(expr * n1, expr * n2);
- bool can_concat_eq_str(expr * concat, std::string str);
+ bool can_concat_eq_str(expr * concat, zstring& str);
bool can_concat_eq_concat(expr * concat1, expr * concat2);
bool check_concat_len_in_eqc(expr * concat);
bool check_length_consistency(expr * n1, expr * n2);
@@ -462,20 +496,20 @@ namespace smt {
void process_free_var(std::map<expr*, int> & freeVar_map);
expr * gen_len_test_options(expr * freeVar, expr * indicator, int tries);
expr * gen_free_var_options(expr * freeVar, expr * len_indicator,
- std::string len_valueStr, expr * valTesterInCbEq, std::string valTesterValueStr);
+ zstring len_valueStr, expr * valTesterInCbEq, zstring valTesterValueStr);
expr * gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
- std::string lenStr, int tries);
+ zstring lenStr, int tries);
void print_value_tester_list(svector<std::pair<int, expr*> > & testerList);
bool get_next_val_encode(int_vector & base, int_vector & next);
- std::string gen_val_string(int len, int_vector & encoding);
+ zstring gen_val_string(int len, int_vector & encoding);
// binary search heuristic
expr * binary_search_length_test(expr * freeVar, expr * previousLenTester, std::string previousLenTesterValue);
expr_ref binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds, literal_vector & case_split_lits);
bool free_var_attempt(expr * nn1, expr * nn2);
- void more_len_tests(expr * lenTester, std::string lenTesterValue);
- void more_value_tests(expr * valTester, std::string valTesterValue);
+ void more_len_tests(expr * lenTester, zstring lenTesterValue);
+ void more_value_tests(expr * valTester, zstring valTesterValue);
expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
expr * getMostLeftNodeInConcat(expr * node);
@@ -494,10 +528,11 @@ namespace smt {
void get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet);
void gen_assign_unroll_reg(std::set<expr*> & unrolls);
expr * gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls);
- expr * gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, std::string lcmStr);
- expr * gen_unroll_assign(expr * var, std::string lcmStr, expr * testerVar, int l, int h);
+ expr * gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, zstring lcmStr);
+ expr * gen_unroll_assign(expr * var, zstring lcmStr, expr * testerVar, int l, int h);
void reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vector & items);
void check_regex_in(expr * nn1, expr * nn2);
+ zstring get_std_regex_str(expr * r);
void dump_assignments();
void initialize_charset();
From c62b55f9b1edeeb1ffa7497a76577b99cb27aa9e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 27 Feb 2017 20:51:30 -0500
Subject: [PATCH 350/401] fix npos semantics
---
src/smt/theory_str.cpp | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 6585bd7f2..21564c327 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4877,7 +4877,7 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
cstItor != constList.end(); cstItor++) {
zstring pieceStr;
u.str.is_string(*cstItor, pieceStr);
- if (strConst.contains(pieceStr)) {
+ if (!strConst.contains(pieceStr)) {
counterEgFound = true;
if (aConcat != substrAst) {
litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
@@ -5606,7 +5606,7 @@ bool theory_str::is_partial_in_grounded_concat(const std::vector<expr*> & strVec
for (int i = 0; i < strCnt; i++) {
zstring strVal;
if (u.str.is_string(strVec[i], strVal)) {
- if (strVal.find(subStrVal) != std::string::npos) {
+ if (strVal.contains(subStrVal)) {
return true;
}
}
@@ -5794,7 +5794,7 @@ bool theory_str::can_concat_eq_str(expr * concat, zstring& str) {
expr * oneArg = args[i];
zstring arg_str;
if (u.str.is_string(oneArg, arg_str)) {
- if (str.contains(arg_str)) {
+ if (!str.contains(arg_str)) {
return false;
}
sumLen += arg_str.length();
From 11000efbfeb8470cdac95f2da497d03290c22ca8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 27 Feb 2017 21:16:15 -0500
Subject: [PATCH 351/401] fix zstring
---
src/smt/theory_str.cpp | 4 ++--
src/smt/theory_str.h | 4 ++--
2 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 21564c327..4440d6462 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -9723,7 +9723,7 @@ expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, bin
return final_term;
}
-expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenTester, std::string previousLenTesterValue) {
+expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenTester, zstring previousLenTesterValue) {
ast_manager & m = get_manager();
context & ctx = get_context();
@@ -9889,7 +9889,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
// lenTesterInCbEq != NULL, and its value will be passed by lenTesterValue
// The difference is that in new_eq_eh(), lenTesterInCbEq and its value have NOT been put into a same eqc
// -----------------------------------------------------------------------------------------------------
-expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, std::string lenTesterValue) {
+expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, zstring lenTesterValue) {
ast_manager & m = get_manager();
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 3be852cf4..233b3b7f5 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -492,7 +492,7 @@ namespace smt {
std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
expr * mk_internal_lenTest_var(expr * node, int lTries);
- expr * gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, std::string lenTesterValue);
+ expr * gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, zstring lenTesterValue);
void process_free_var(std::map<expr*, int> & freeVar_map);
expr * gen_len_test_options(expr * freeVar, expr * indicator, int tries);
expr * gen_free_var_options(expr * freeVar, expr * len_indicator,
@@ -504,7 +504,7 @@ namespace smt {
zstring gen_val_string(int len, int_vector & encoding);
// binary search heuristic
- expr * binary_search_length_test(expr * freeVar, expr * previousLenTester, std::string previousLenTesterValue);
+ expr * binary_search_length_test(expr * freeVar, expr * previousLenTester, zstring previousLenTesterValue);
expr_ref binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds, literal_vector & case_split_lits);
bool free_var_attempt(expr * nn1, expr * nn2);
From 8b077ebbe799f0be78679f537167103e34904c92 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 28 Feb 2017 14:06:13 -0500
Subject: [PATCH 352/401] re-add regex NFA
---
src/smt/theory_str.cpp | 161 ++++++++++++++++++++++++++++++++++++++---
src/smt/theory_str.h | 48 +++++++++++-
2 files changed, 199 insertions(+), 10 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 4440d6462..d81bb9471 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -598,7 +598,7 @@ app * theory_str::mk_unroll(expr * n, expr * bound) {
ast_manager & m = get_manager();
expr * args[2] = {n, bound};
- app * unrollFunc = get_manager().mk_app(get_id(), OP_RE_UNROLL, 0, 0, 2, args);
+ app * unrollFunc = get_manager().mk_app(get_id(), _OP_RE_UNROLL, 0, 0, 2, args);
m_trail.push_back(unrollFunc);
expr_ref_vector items(m);
@@ -4428,7 +4428,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr) {
ast_manager & m = get_manager();
- if (!is_Unroll(to_app(unrollFunc))) {
+ if (!u.re.is_unroll(to_app(unrollFunc))) {
return;
}
if (!u.str.is_string(constStr)) {
@@ -5444,7 +5444,7 @@ void theory_str::get_grounded_concats(expr* node, std::map<expr*, expr*> & varAl
std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr*> & varConstMap,
std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap,
std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap) {
- if (is_Unroll(to_app(node))) {
+ if (u.re.is_unroll(to_app(node))) {
return;
}
// **************************************************
@@ -6129,6 +6129,149 @@ bool theory_str::check_concat_len_in_eqc(expr * concat) {
return no_assertions;
}
+// Convert a regular expression to an e-NFA using Thompson's construction
+void nfa::convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u) {
+ start = next_id();
+ end = next_id();
+ if (u.re.is_to_re(e)) {
+ app * a = to_app(e);
+ expr * arg_str = a->get_arg(0);
+ zstring str;
+ if (u.str.is_string(arg_str, str)) {
+ TRACE("t_str_rw", tout << "build NFA for '" << str << "'" << "\n";);
+
+ /*
+ * For an n-character string, we make (n-1) intermediate states,
+ * labelled i_(0) through i_(n-2).
+ * Then we construct the following transitions:
+ * start --str[0]--> i_(0) --str[1]--> i_(1) --...--> i_(n-2) --str[n-1]--> final
+ */
+ unsigned last = start;
+ for (int i = 0; i <= ((int)str.length()) - 2; ++i) {
+ unsigned i_state = next_id();
+ make_transition(last, str[i], i_state);
+ TRACE("t_str_rw", tout << "string transition " << last << "--" << str[i] << "--> " << i_state << "\n";);
+ last = i_state;
+ }
+ make_transition(last, str[(str.length() - 1)], end);
+ TRACE("t_str_rw", tout << "string transition " << last << "--" << str[(str.length() - 1)] << "--> " << end << "\n";);
+ TRACE("t_str_rw", tout << "string NFA: start = " << start << ", end = " << end << std::endl;);
+ } else {
+ TRACE("t_str_rw", tout << "invalid string constant in Str2Reg" << std::endl;);
+ m_valid = false;
+ return;
+ }
+ } else if (u.re.is_concat(e)){
+ app * a = to_app(e);
+ expr * re1 = a->get_arg(0);
+ expr * re2 = a->get_arg(1);
+ unsigned start1, end1;
+ convert_re(re1, start1, end1, u);
+ unsigned start2, end2;
+ convert_re(re2, start2, end2, u);
+ // start --e--> start1 --...--> end1 --e--> start2 --...--> end2 --e--> end
+ make_epsilon_move(start, start1);
+ make_epsilon_move(end1, start2);
+ make_epsilon_move(end2, end);
+ TRACE("t_str_rw", tout << "concat NFA: start = " << start << ", end = " << end << std::endl;);
+ } else if (u.re.is_union(e)) {
+ app * a = to_app(e);
+ expr * re1 = a->get_arg(0);
+ expr * re2 = a->get_arg(1);
+ unsigned start1, end1;
+ convert_re(re1, start1, end1, u);
+ unsigned start2, end2;
+ convert_re(re2, start2, end2, u);
+
+ // start --e--> start1 ; start --e--> start2
+ // end1 --e--> end ; end2 --e--> end
+ make_epsilon_move(start, start1);
+ make_epsilon_move(start, start2);
+ make_epsilon_move(end1, end);
+ make_epsilon_move(end2, end);
+ TRACE("t_str_rw", tout << "union NFA: start = " << start << ", end = " << end << std::endl;);
+ } else if (u.re.is_star(e)) {
+ app * a = to_app(e);
+ expr * subex = a->get_arg(0);
+ unsigned start_subex, end_subex;
+ convert_re(subex, start_subex, end_subex, u);
+ // start --e--> start_subex, start --e--> end
+ // end_subex --e--> start_subex, end_subex --e--> end
+ make_epsilon_move(start, start_subex);
+ make_epsilon_move(start, end);
+ make_epsilon_move(end_subex, start_subex);
+ make_epsilon_move(end_subex, end);
+ TRACE("t_str_rw", tout << "star NFA: start = " << start << ", end = " << end << std::endl;);
+ } else {
+ TRACE("t_str_rw", tout << "invalid regular expression" << std::endl;);
+ m_valid = false;
+ return;
+ }
+}
+
+void nfa::epsilon_closure(unsigned start, std::set<unsigned> & closure) {
+ std::deque<unsigned> worklist;
+ closure.insert(start);
+ worklist.push_back(start);
+
+ while(!worklist.empty()) {
+ unsigned state = worklist.front();
+ worklist.pop_front();
+ if (epsilon_map.find(state) != epsilon_map.end()) {
+ for (std::set<unsigned>::iterator it = epsilon_map[state].begin();
+ it != epsilon_map[state].end(); ++it) {
+ unsigned new_state = *it;
+ if (closure.find(new_state) == closure.end()) {
+ closure.insert(new_state);
+ worklist.push_back(new_state);
+ }
+ }
+ }
+ }
+}
+
+bool nfa::matches(zstring input) {
+ /*
+ * Keep a set of all states the NFA can currently be in.
+ * Initially this is the e-closure of m_start_state
+ * For each character A in the input string,
+ * the set of next states contains
+ * all states in transition_map[S][A] for each S in current_states,
+ * and all states in epsilon_map[S] for each S in current_states.
+ * After consuming the entire input string,
+ * the match is successful iff current_states contains m_end_state.
+ */
+ std::set<unsigned> current_states;
+ epsilon_closure(m_start_state, current_states);
+ for (unsigned i = 0; i < input.length(); ++i) {
+ char A = input.at(i);
+ std::set<unsigned> next_states;
+ for (std::set<unsigned>::iterator it = current_states.begin();
+ it != current_states.end(); ++it) {
+ unsigned S = *it;
+ // check transition_map
+ if (transition_map[S].find(A) != transition_map[S].end()) {
+ next_states.insert(transition_map[S][A]);
+ }
+ }
+
+ // take e-closure over next_states to compute the actual next_states
+ std::set<unsigned> epsilon_next_states;
+ for (std::set<unsigned>::iterator it = next_states.begin(); it != next_states.end(); ++it) {
+ unsigned S = *it;
+ std::set<unsigned> closure;
+ epsilon_closure(S, closure);
+ epsilon_next_states.insert(closure.begin(), closure.end());
+ }
+ current_states = epsilon_next_states;
+ }
+ if (current_states.find(m_end_state) != current_states.end()) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
void theory_str::check_regex_in(expr * nn1, expr * nn2) {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -6159,7 +6302,7 @@ void theory_str::check_regex_in(expr * nn1, expr * nn2) {
// TODO figure out regex NFA stuff
if (regex_nfa_cache.find(regexTerm) == regex_nfa_cache.end()) {
TRACE("t_str_detail", tout << "regex_nfa_cache: cache miss" << std::endl;);
- regex_nfa_cache[regexTerm] = nfa(m_strutil, regexTerm);
+ regex_nfa_cache[regexTerm] = nfa(u, regexTerm);
} else {
TRACE("t_str_detail", tout << "regex_nfa_cache: cache hit" << std::endl;);
}
@@ -7385,7 +7528,7 @@ void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap
if (canskip == 0 && concatMap.find(node) == concatMap.end()) {
concatMap[node] = 1;
}
- } else if (is_Unroll(aNode)) {
+ } else if (u.re.is_unroll(aNode)) {
// Unroll
if (unrollMap.find(node) == unrollMap.end()) {
unrollMap[node] = 1;
@@ -7658,7 +7801,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
enode * e_curr = e_currEqc;
do {
app * curr = e_currEqc->get_owner();
- if (is_Unroll(curr)) {
+ if (u.re.is_unroll(curr)) {
if (aRoot == NULL) {
aRoot = curr;
}
@@ -7753,7 +7896,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
if (!is_arg0_emptyStr && !is_arg1_emptyStr) {
var_eq_concat_map[deAliasNode][curr] = 1;
}
- } else if (is_Unroll(to_app(curr))) {
+ } else if (u.re.is_unroll(to_app(curr))) {
var_eq_unroll_map[deAliasNode][curr] = 1;
}
@@ -10191,7 +10334,7 @@ void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> &
do {
if (u.str.is_string(to_app(curr))) {
constStr = curr;
- } else if (is_Unroll(to_app(curr))) {
+ } else if (u.re.is_unroll(to_app(curr))) {
if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
unrollFuncSet.insert(curr);
}
@@ -10210,7 +10353,7 @@ void theory_str::get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*
do {
if (u.str.is_string(to_app(curr))) {
constStr = curr;
- } else if (is_Unroll(to_app(curr))) {
+ } else if (u.re.is_unroll(to_app(curr))) {
expr * core = to_app(curr)->get_arg(0);
if (u.re.is_to_re(to_app(core))) {
if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 233b3b7f5..499bb23f8 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -110,6 +110,52 @@ namespace smt {
}
};
+
+ class nfa {
+ protected:
+ bool m_valid;
+ unsigned m_next_id;
+
+ unsigned next_id() {
+ unsigned retval = m_next_id;
+ ++m_next_id;
+ return retval;
+ }
+
+ unsigned m_start_state;
+ unsigned m_end_state;
+
+ std::map<unsigned, std::map<char, unsigned> > transition_map;
+ std::map<unsigned, std::set<unsigned> > epsilon_map;
+
+ void make_transition(unsigned start, char symbol, unsigned end) {
+ transition_map[start][symbol] = end;
+ }
+
+ void make_epsilon_move(unsigned start, unsigned end) {
+ epsilon_map[start].insert(end);
+ }
+
+ // Convert a regular expression to an e-NFA using Thompson's construction
+ void convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u);
+
+ public:
+ nfa(seq_util & u, expr * e)
+ : m_valid(true), m_next_id(0), m_start_state(0), m_end_state(0) {
+ convert_re(e, m_start_state, m_end_state, u);
+ }
+
+ nfa() : m_valid(false), m_next_id(0), m_start_state(0), m_end_state(0) {}
+
+ bool is_valid() const {
+ return m_valid;
+ }
+
+ void epsilon_closure(unsigned start, std::set<unsigned> & closure);
+
+ bool matches(zstring input);
+ };
+
class theory_str : public theory {
struct T_cut
{
@@ -274,7 +320,7 @@ namespace smt {
std::map<std::pair<expr*, zstring>, expr*> regex_in_bool_map;
std::map<expr*, std::set<zstring> > regex_in_var_reg_str_map;
- // std::map<expr*, nfa> regex_nfa_cache; // Regex term --> NFA
+ std::map<expr*, nfa> regex_nfa_cache; // Regex term --> NFA
char * char_set;
std::map<char, int> charSetLookupTable;
From ab71dea82d574aba85811d858a674f97820c5f0c Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 28 Feb 2017 17:47:55 -0500
Subject: [PATCH 353/401] theory_str refactoring
---
src/api/z3_api.h | 148 -------------------------------
src/ast/ast_smt2_pp.cpp | 55 ------------
src/ast/ast_smt2_pp.h | 3 +-
src/ast/rewriter/th_rewriter.cpp | 8 --
src/ast/seq_decl_plugin.cpp | 50 ++++++++++-
src/ast/seq_decl_plugin.h | 6 +-
src/model/model_evaluator.cpp | 7 --
src/smt/theory_str.cpp | 76 +++++-----------
src/smt/theory_str.h | 10 ++-
9 files changed, 83 insertions(+), 280 deletions(-)
diff --git a/src/api/z3_api.h b/src/api/z3_api.h
index 0b8351190..87c48f3d2 100644
--- a/src/api/z3_api.h
+++ b/src/api/z3_api.h
@@ -3173,154 +3173,6 @@ extern "C" {
/*@}*/
- /** @name Strings and regular expressions (Z3str2 implementation) */
- /*@{*/
-
- /**
- \brief Create a string sort for 8-bit ASCII strings.
-
- This function creates a sort for ASCII strings.
- Each character is 8 bits.
-
- def_API('Z3_mk_str_sort', SORT, (_in(CONTEXT), ))
- */
- Z3_sort Z3_API Z3_mk_str_sort(Z3_context c);
-
- /**
- \brief Check if \c s is a string sort.
-
- def_API('Z3_is_str_sort', BOOL, (_in(CONTEXT), _in(SORT)))
- */
-
- Z3_bool Z3_API Z3_is_str_sort(Z3_context c, Z3_sort s);
-
- /**
- \brief Determine if \c s is a string constant.
-
- def_API('Z3_is_str', BOOL, (_in(CONTEXT), _in(AST)))
- */
-
- Z3_bool Z3_API Z3_is_str(Z3_context c, Z3_ast s);
-
- /**
- \brief Retrieve the string constant stored in \c s.
-
- \pre Z3_is_str(c, s)
-
- def_API('Z3_get_str', STRING, (_in(CONTEXT), _in(AST)))
- */
-
- Z3_string Z3_API Z3_get_str(Z3_context c, Z3_ast s);
-
- /**
- \brief Create a string constant.
-
- \param c logical context.
- \param str The ASCII representation of the string constant.
-
- def_API('Z3_mk_str', AST, (_in(CONTEXT), _in(STRING)))
- */
- Z3_ast Z3_API Z3_mk_str(Z3_context c, Z3_string str);
-
- /**
- \brief Create a string concatenation term.
- def_API('Z3_mk_str_concat', AST, (_in(CONTEXT), _in(AST), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_str_concat(Z3_context c, Z3_ast s1, Z3_ast s2);
-
- /**
- \brief Create a string length term. (Integer representation)
- def_API('Z3_mk_str_length', AST, (_in(CONTEXT), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_str_length(Z3_context c, Z3_ast s);
-
- /**
- \brief Create 'character at index' term.
- def_API('Z3_mk_str_at', AST, (_in(CONTEXT), _in(AST), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_str_at(Z3_context c, Z3_ast s, Z3_ast idx);
-
- /**
- \brief Create 'str.prefixof' term.
- def_API('Z3_mk_str_prefixof', AST, (_in(CONTEXT), _in(AST), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_str_prefixof(Z3_context c, Z3_ast pre, Z3_ast full);
-
- /**
- \brief Create 'str.suffixof' term.
- def_API('Z3_mk_str_suffixof', AST, (_in(CONTEXT), _in(AST), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_str_suffixof(Z3_context c, Z3_ast suf, Z3_ast full);
-
- /**
- \brief Create 'str.contains' term.
- def_API('Z3_mk_str_contains', AST, (_in(CONTEXT), _in(AST), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_str_contains(Z3_context c, Z3_ast needle, Z3_ast haystack);
-
- /**
- \brief Create 'str.indexof' term.
- def_API('Z3_mk_str_indexof', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_str_indexof(Z3_context c, Z3_ast haystack, Z3_ast needle, Z3_ast start);
-
- /**
- \brief Create 'str.substr' term.
- def_API('Z3_mk_str_substr', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_str_substr(Z3_context c, Z3_ast s, Z3_ast start, Z3_ast count);
-
- /**
- \brief Create 'str.replace' term.
- def_API('Z3_mk_str_replace', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_str_replace(Z3_context c, Z3_ast base, Z3_ast target, Z3_ast replacement);
-
-
- /**
- \brief Create a regular expression that matches the given string constant.
- def_API('Z3_mk_str_to_regex', AST, (_in(CONTEXT), _in(STRING)))
- */
- Z3_ast Z3_API Z3_mk_str_to_regex(Z3_context c, Z3_string str);
-
- /**
- \brief Create a regular expression membership predicate.
- def_API('Z3_mk_str_in_regex', AST, (_in(CONTEXT), _in(AST), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_str_in_regex(Z3_context c, Z3_ast str, Z3_ast regex);
-
- /**
- \brief Create a regex concatenation term.
- def_API('Z3_mk_regex_concat', AST, (_in(CONTEXT), _in(AST), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_regex_concat(Z3_context c, Z3_ast r1, Z3_ast r2);
-
- /**
- \brief Create a regex union term.
- def_API('Z3_mk_regex_union', AST, (_in(CONTEXT), _in(AST), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_regex_union(Z3_context c, Z3_ast r1, Z3_ast r2);
-
- /**
- \brief Create a regex Kleene star term.
- def_API('Z3_mk_regex_star', AST, (_in(CONTEXT), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_regex_star(Z3_context c, Z3_ast r);
-
- /**
- \brief Create a regex plus term.
- def_API('Z3_mk_regex_plus', AST, (_in(CONTEXT), _in(AST)))
- */
- Z3_ast Z3_API Z3_mk_regex_plus(Z3_context c, Z3_ast r);
-
- /**
- \brief Create a regex character range term.
- def_API('Z3_mk_regex_range', AST, (_in(CONTEXT), _in(STRING), _in(STRING)))
- */
- Z3_ast Z3_API Z3_mk_regex_range(Z3_context c, Z3_string start, Z3_string end);
-
- /*@}*/
-
/** @name Sequences and regular expressions */
/*@{*/
diff --git a/src/ast/ast_smt2_pp.cpp b/src/ast/ast_smt2_pp.cpp
index 023773f62..98c3b7962 100644
--- a/src/ast/ast_smt2_pp.cpp
+++ b/src/ast/ast_smt2_pp.cpp
@@ -304,58 +304,6 @@ format * smt2_pp_environment::mk_float(rational const & val) const {
return mk_string(get_manager(), s.c_str());
}
-format * smt2_pp_environment::pp_str_literal(app * t) {
- ast_manager & m = get_manager();
- str_util & u = get_strutil();
- TRACE("parse_string", tout << "pp_str_literal\n";);
-
- SASSERT(u.is_string(t));
- std::string strVal = u.get_string_constant_value(t);
- string_buffer<> buf;
- buf << "\"";
-
- // we want to scan strVal and escape every non-printable character
- for (unsigned int i = 0; i < strVal.length(); ++i) {
- char c = strVal.at(i);
- if (c == '"') {
- // SMT-LIB 2.5 string escape
- buf << "\"\"";
- } else if (isprint(c)) {
- buf << c;
- } else if (c == '\a') {
- buf << "\\a";
- } else if (c == '\b') {
- buf << "\\b";
- } else if (c == '\e') {
- buf << "\\e";
- } else if (c == '\f') {
- buf << "\\f";
- } else if (c == '\n') {
- buf << "\\n";
- } else if (c == '\r') {
- buf << "\\r";
- } else if (c == '\t') {
- buf << "\\t";
- } else if (c == '\v') {
- buf << "\\v";
- } else if (c == '\\') {
- buf << "\\" << "\\";
- } else {
- // general hex escape
- buf << "\\x";
- unsigned int cVal = ((unsigned int)c) & 0x000000FF;
- const char convtable[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
- unsigned int highPart = cVal / 16;
- unsigned int lowPart = cVal % 16;
- SASSERT(highPart < 16); SASSERT(lowPart < 16);
- buf << convtable[highPart] << convtable[lowPart];
- }
- }
-
- buf << "\"";
- return mk_string(m, buf.c_str());
-}
-
format * smt2_pp_environment::pp_arith_literal(app * t, bool decimal, unsigned decimal_prec) {
arith_util & u = get_autil();
SASSERT(u.is_numeral(t) || u.is_irrational_algebraic_numeral(t));
@@ -666,9 +614,6 @@ class smt2_printer {
else if (m_env.get_dlutil().is_numeral(c)) {
f = m_env.pp_datalog_literal(c);
}
- else if (m_env.get_strutil().is_string(c)) {
- f = m_env.pp_str_literal(c);
- }
else {
buffer<symbol> names;
if (m().is_label_lit(c, names)) {
diff --git a/src/ast/ast_smt2_pp.h b/src/ast/ast_smt2_pp.h
index b1bdf52bd..2f79ebaec 100644
--- a/src/ast/ast_smt2_pp.h
+++ b/src/ast/ast_smt2_pp.h
@@ -56,9 +56,8 @@ public:
virtual format_ns::format * pp_bv_literal(app * t, bool use_bv_lits, bool bv_neg);
virtual format_ns::format * pp_arith_literal(app * t, bool decimal, unsigned prec);
virtual format_ns::format * pp_float_literal(app * t, bool use_bv_lits, bool use_float_real_lits);
- virtual format_ns::format * pp_str_literal(app * t);
- virtual format_ns::format * pp_datalog_literal(app * t);
virtual format_ns::format * pp_string_literal(app * t);
+ virtual format_ns::format * pp_datalog_literal(app * t);
virtual format_ns::format * pp_sort(sort * s);
virtual format_ns::format * pp_fdecl_ref(func_decl * f);
format_ns::format * pp_fdecl_name(symbol const & fname, unsigned & len) const;
diff --git a/src/ast/rewriter/th_rewriter.cpp b/src/ast/rewriter/th_rewriter.cpp
index 86772cdb4..0c57ea609 100644
--- a/src/ast/rewriter/th_rewriter.cpp
+++ b/src/ast/rewriter/th_rewriter.cpp
@@ -27,7 +27,6 @@ Notes:
#include"dl_rewriter.h"
#include"pb_rewriter.h"
#include"seq_rewriter.h"
-#include"str_rewriter.h"
#include"rewriter_def.h"
#include"expr_substitution.h"
#include"ast_smt2_pp.h"
@@ -46,7 +45,6 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
dl_rewriter m_dl_rw;
pb_rewriter m_pb_rw;
seq_rewriter m_seq_rw;
- str_rewriter m_str_rw;
arith_util m_a_util;
bv_util m_bv_util;
unsigned long long m_max_memory; // in bytes
@@ -81,7 +79,6 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
m_ar_rw.updt_params(p);
m_f_rw.updt_params(p);
m_seq_rw.updt_params(p);
- m_str_rw.updt_params(p);
updt_local_params(p);
}
@@ -182,8 +179,6 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
st = m_ar_rw.mk_eq_core(args[0], args[1], result);
else if (s_fid == m_seq_rw.get_fid())
st = m_seq_rw.mk_eq_core(args[0], args[1], result);
- else if (s_fid == m_str_rw.get_fid())
- st = m_str_rw.mk_eq_core(args[0], args[1], result);
if (st != BR_FAILED)
return st;
@@ -220,8 +215,6 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
return m_pb_rw.mk_app_core(f, num, args, result);
if (fid == m_seq_rw.get_fid())
return m_seq_rw.mk_app_core(f, num, args, result);
- if (fid == m_str_rw.get_fid())
- return m_str_rw.mk_app_core(f, num, args, result);
return BR_FAILED;
}
@@ -680,7 +673,6 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
m_dl_rw(m),
m_pb_rw(m),
m_seq_rw(m),
- m_str_rw(m),
m_a_util(m),
m_bv_util(m),
m_used_dependencies(m),
diff --git a/src/ast/seq_decl_plugin.cpp b/src/ast/seq_decl_plugin.cpp
index 5022c57a6..059fe9674 100644
--- a/src/ast/seq_decl_plugin.cpp
+++ b/src/ast/seq_decl_plugin.cpp
@@ -284,8 +284,54 @@ zstring zstring::operator+(zstring const& other) const {
return result;
}
-std::ostream& zstring::operator<<(std::ostream& out) const {
- return out << encode();
+bool zstring::operator==(const zstring& other) const {
+ // two strings are equal iff they have the same length and characters
+ if (length() != other.length()) {
+ return false;
+ }
+ for (unsigned i = 0; i < length(); ++i) {
+ unsigned Xi = m_buffer[i];
+ unsigned Yi = other[i];
+ if (Xi != Yi) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool zstring::operator!=(const zstring& other) const {
+ return !(*this == other);
+}
+
+std::ostream& operator<<(std::ostream &os, const zstring &str) {
+ return os << str.encode();
+}
+
+bool operator<(const zstring& lhs, const zstring& rhs) {
+ // This has the same semantics as strcmp()
+ unsigned len = lhs.length();
+ if (rhs.length() < len) {
+ len = rhs.length();
+ }
+ for (unsigned i = 0; i < len; ++i) {
+ unsigned Li = lhs[i];
+ unsigned Ri = rhs[i];
+ if (Li < Ri) {
+ return true;
+ } else if (Li > Ri) {
+ return false;
+ } else {
+ continue;
+ }
+ }
+ // at this point, all compared characters are equal,
+ // so decide based on the relative lengths
+ if (lhs.length() < rhs.length()) {
+ return true;
+ } else {
+ return false;
+ }
}
diff --git a/src/ast/seq_decl_plugin.h b/src/ast/seq_decl_plugin.h
index b07e4d307..a7e534bbb 100644
--- a/src/ast/seq_decl_plugin.h
+++ b/src/ast/seq_decl_plugin.h
@@ -114,7 +114,11 @@ public:
int indexof(zstring const& other, int offset) const;
zstring extract(int lo, int hi) const;
zstring operator+(zstring const& other) const;
- std::ostream& operator<<(std::ostream& out) const;
+ bool operator==(const zstring& other) const;
+ bool operator!=(const zstring& other) const;
+
+ friend std::ostream& operator<<(std::ostream &os, const zstring &str);
+ friend bool operator<(const zstring& lhs, const zstring& rhs);
};
class seq_decl_plugin : public decl_plugin {
diff --git a/src/model/model_evaluator.cpp b/src/model/model_evaluator.cpp
index 06bbceb43..af2253801 100644
--- a/src/model/model_evaluator.cpp
+++ b/src/model/model_evaluator.cpp
@@ -28,7 +28,6 @@ Revision History:
#include"datatype_rewriter.h"
#include"array_rewriter.h"
#include"fpa_rewriter.h"
-#include"str_rewriter.h"
#include"rewriter_def.h"
#include"cooperate.h"
#include"ast_pp.h"
@@ -46,7 +45,6 @@ struct evaluator_cfg : public default_rewriter_cfg {
pb_rewriter m_pb_rw;
fpa_rewriter m_f_rw;
seq_rewriter m_seq_rw;
- str_rewriter m_str_rw;
array_util m_ar;
unsigned long long m_max_memory;
unsigned m_max_steps;
@@ -66,7 +64,6 @@ struct evaluator_cfg : public default_rewriter_cfg {
m_pb_rw(m),
m_f_rw(m),
m_seq_rw(m),
- m_str_rw(m),
m_ar(m) {
bool flat = true;
m_b_rw.set_flat(flat);
@@ -158,8 +155,6 @@ struct evaluator_cfg : public default_rewriter_cfg {
st = m_f_rw.mk_eq_core(args[0], args[1], result);
else if (s_fid == m_seq_rw.get_fid())
st = m_seq_rw.mk_eq_core(args[0], args[1], result);
- else if (s_fid == m_str_rw.get_fid())
- st = m_str_rw.mk_eq_core(args[0], args[1], result);
else if (s_fid == m_ar_rw.get_fid())
st = mk_array_eq(args[0], args[1], result);
if (st != BR_FAILED)
@@ -182,8 +177,6 @@ struct evaluator_cfg : public default_rewriter_cfg {
st = m_f_rw.mk_app_core(f, num, args, result);
else if (fid == m_seq_rw.get_fid())
st = m_seq_rw.mk_app_core(f, num, args, result);
- else if (fid == m_str_rw.get_fid())
- st = m_str_rw.mk_app_core(f, num, args, result);
else if (fid == m().get_label_family_id() && num == 1) {
result = args[0];
st = BR_DONE;
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index d81bb9471..79b6efb8b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -887,7 +887,7 @@ void theory_str::try_eval_concat(enode * cat) {
app * evalArg = worklist.top(); worklist.pop();
zstring nextStr;
if (u.str.is_string(evalArg, nextStr)) {
- flattenedString += nextStr;
+ flattenedString = flattenedString + nextStr;
} else if (u.str.is_concat(evalArg)) {
app * arg0 = to_app(evalArg->get_arg(0));
app * arg1 = to_app(evalArg->get_arg(1));
@@ -1643,9 +1643,10 @@ static zstring str2RegexStr(zstring str) {
// 12 special chars
if (nc == '\\' || nc == '^' || nc == '$' || nc == '.' || nc == '|' || nc == '?'
|| nc == '*' || nc == '+' || nc == '(' || nc == ')' || nc == '[' || nc == '{') {
- res += zstring("\\");
+ res = res + zstring("\\");
}
- res += zstring(1, (unsigned)str[i]);
+ char tmp[1] = {(char)str[i]};
+ res = res + zstring(tmp);
}
return res;
}
@@ -2783,11 +2784,9 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
// case 2: concat(x, y) = concat(m, "str")
//*************************************************************
if (is_concat_eq_type2(new_nn1, new_nn2)) {
- expr * x = NULL;
- expr * y = NULL;
- expr * strAst = NULL;
- expr * m = NULL;
+ expr * y = NULL;
+ expr * m = NULL;
expr * v1_arg0 = to_app(new_nn1)->get_arg(0);
expr * v1_arg1 = to_app(new_nn1)->get_arg(1);
expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
@@ -2795,13 +2794,9 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
if (u.str.is_string(v1_arg1) && !u.str.is_string(v2_arg1)) {
m = v1_arg0;
- strAst = v1_arg1;
- x = v2_arg0;
y = v2_arg1;
} else {
m = v2_arg0;
- strAst = v2_arg1;
- x = v1_arg0;
y = v1_arg1;
}
@@ -2823,20 +2818,14 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
expr * x = NULL;
- expr * y = NULL;
- expr * strAst = NULL;
expr * n = NULL;
if (u.str.is_string(v1_arg0) && !u.str.is_string(v2_arg0)) {
- strAst = v1_arg0;
n = v1_arg1;
x = v2_arg0;
- y = v2_arg1;
} else {
- strAst = v2_arg0;
n = v2_arg1;
x = v1_arg0;
- y = v1_arg1;
}
if (has_self_cut(x, n)) {
TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(x, tout); print_cut_var(n, tout););
@@ -2870,21 +2859,15 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
- expr * str1Ast = NULL;
expr * y = NULL;
expr * m = NULL;
- expr * str2Ast = NULL;
if (u.str.is_string(v1_arg0)) {
- str1Ast = v1_arg0;
y = v1_arg1;
m = v2_arg0;
- str2Ast = v2_arg1;
} else {
- str1Ast = v2_arg0;
y = v2_arg1;
m = v1_arg0;
- str2Ast = v1_arg1;
}
if (has_self_cut(m, y)) {
TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
@@ -3160,9 +3143,6 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
// This vector will eventually contain one term for each possible arrangement we explore.
expr_ref_vector arrangement_disjunction(mgr);
- int option = 0;
- int pos = 1;
-
// break option 1: m cuts y
// len(x) < len(m) || len(y) > len(n)
if (!avoidLoopCut || !has_self_cut(m, y)) {
@@ -3508,16 +3488,13 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
// | m | str |
rational lenDelta;
expr_ref_vector l_items(mgr);
- int l_count = 0;
l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
if (x_len_exists && m_len_exists) {
l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
- l_count = 3;
lenDelta = x_len - m_len;
} else {
l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
- l_count = 2;
lenDelta = str_len - y_len;
}
TRACE("t_str",
@@ -3562,12 +3539,8 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
}
} else {
// Split type -1: no idea about the length...
- int optionTotal = 2 + strValue.length();
expr_ref_vector arrangement_disjunction(mgr);
- int option = 0;
- int pos = 1;
-
expr_ref temp1_strAst(mk_concat(temp1, strAst), mgr);
// m cuts y
@@ -3904,7 +3877,6 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
// Split type -1. We know nothing about the length...
expr_ref_vector arrangement_disjunction(mgr);
- unsigned option = 0;
int pos = 1;
for (unsigned int i = 0; i <= strValue.length(); i++) {
@@ -4336,7 +4308,6 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
}
expr_ref_vector arrangement_disjunction(mgr);
- int option = 0;
int pos = 1;
if (!avoidLoopCut || !has_self_cut(m, y)) {
@@ -5602,7 +5573,7 @@ bool theory_str::is_partial_in_grounded_concat(const std::vector<expr*> & strVec
if (subStrCnt == 1) {
zstring subStrVal;
- if (u.str.is_string(subStrVec[0]), subStrVal) {
+ if (u.str.is_string(subStrVec[0], subStrVal)) {
for (int i = 0; i < strCnt; i++) {
zstring strVal;
if (u.str.is_string(strVec[i], strVal)) {
@@ -5630,7 +5601,7 @@ bool theory_str::is_partial_in_grounded_concat(const std::vector<expr*> & strVec
zstring strHeadVal;
if (u.str.is_string(strVec[i], strHeadVal)) {
if (strHeadVal.length() >= subStrHeadVal.length()) {
- std::string suffix = strHeadVal.extract(strHeadVal.length() - subStrHeadVal.length(), subStrHeadVal.length());
+ zstring suffix = strHeadVal.extract(strHeadVal.length() - subStrHeadVal.length(), subStrHeadVal.length());
if (suffix != subStrHeadVal) {
firstNodesOK = false;
}
@@ -5758,7 +5729,7 @@ void theory_str::compute_contains(std::map<expr*, expr*> & varAliasMap,
}
bool theory_str::can_concat_eq_str(expr * concat, zstring& str) {
- int strLen = str.length();
+ unsigned int strLen = str.length();
if (u.str.is_concat(to_app(concat))) {
ptr_vector<expr> args;
get_nodes_in_concat(concat, args);
@@ -6244,7 +6215,7 @@ bool nfa::matches(zstring input) {
std::set<unsigned> current_states;
epsilon_closure(m_start_state, current_states);
for (unsigned i = 0; i < input.length(); ++i) {
- char A = input.at(i);
+ char A = (char)input[i];
std::set<unsigned> next_states;
for (std::set<unsigned>::iterator it = current_states.begin();
it != current_states.end(); ++it) {
@@ -6288,12 +6259,12 @@ void theory_str::check_regex_in(expr * nn1, expr * nn2) {
expr_ref_vector::iterator itor = eqNodeSet.begin();
for (; itor != eqNodeSet.end(); itor++) {
if (regex_in_var_reg_str_map.find(*itor) != regex_in_var_reg_str_map.end()) {
- std::set<std::string>::iterator strItor = regex_in_var_reg_str_map[*itor].begin();
+ std::set<zstring>::iterator strItor = regex_in_var_reg_str_map[*itor].begin();
for (; strItor != regex_in_var_reg_str_map[*itor].end(); strItor++) {
- std::string regStr = *strItor;
+ zstring regStr = *strItor;
zstring constStrValue;
u.str.is_string(constStr, constStrValue);
- std::pair<expr*, std::string> key1 = std::make_pair(*itor, regStr);
+ std::pair<expr*, zstring> key1 = std::make_pair(*itor, regStr);
if (regex_in_bool_map.find(key1) != regex_in_bool_map.end()) {
expr * boolVar = regex_in_bool_map[key1]; // actually the RegexIn term
app * a_regexIn = to_app(boolVar);
@@ -6403,7 +6374,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
// Inconsistency
TRACE("t_str", tout << "inconsistency detected: \""
<< arg1_str << "\" + \"" << arg2_str <<
- "\" != \"" << const_str << "\"\n");
+ "\" != \"" << const_str << "\"" << "\n";);
expr_ref equality(ctx.mk_eq_atom(concat, str), m);
expr_ref diseq(m.mk_not(equality), m);
assert_axiom(diseq);
@@ -6421,7 +6392,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
TRACE("t_str", tout << "inconsistency detected: \""
<< arg2_str <<
"\" is longer than \"" << const_str << "\","
- << " so cannot be concatenated with anything to form it\n");
+ << " so cannot be concatenated with anything to form it" << "\n";);
expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
expr_ref diseq(m.mk_not(equality), m);
assert_axiom(diseq);
@@ -6435,7 +6406,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
TRACE("t_str", tout << "inconsistency detected: "
<< "suffix of concatenation result expected \"" << secondPart << "\", "
<< "actually \"" << arg2_str << "\""
- << "\n");
+ << "\n";);
expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
expr_ref diseq(m.mk_not(equality), m);
assert_axiom(diseq);
@@ -6620,7 +6591,6 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
}
int concatStrLen = const_str.length();
- int xor_pos = 0;
int and_count = 1;
expr_ref_vector arrangement_disjunction(m);
@@ -6701,8 +6671,8 @@ expr_ref theory_str::set_up_finite_model_test(expr * lhs, expr * rhs) {
}
// make things easy for the core wrt. testvar
- expr_ref t1(ctx.mk_eq_atom(testvar, u.str.mk_string("")), m);
- expr_ref t_yes(ctx.mk_eq_atom(testvar, u.str.mk_string("yes")), m);
+ expr_ref t1(ctx.mk_eq_atom(testvar, mk_string("")), m);
+ expr_ref t_yes(ctx.mk_eq_atom(testvar, mk_string("yes")), m);
expr_ref testvaraxiom(m.mk_or(t1, t_yes), m);
assert_axiom(testvaraxiom);
@@ -6812,8 +6782,8 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
expr_ref_vector andList(m);
for (rational l = v_lower_bound; l <= v_upper_bound; l += rational::one()) {
- std::string lStr = l.to_string();
- expr_ref str_indicator(u.str.mk_string(lStr), m);
+ zstring lStr = zstring(l.to_string().c_str());
+ expr_ref str_indicator(mk_string(lStr), m);
expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
orList.push_back(or_expr);
expr_ref and_expr(ctx.mk_eq_atom(or_expr, ctx.mk_eq_atom(vLengthExpr, m_autil.mk_numeral(l, true))), m);
@@ -9006,12 +8976,12 @@ zstring theory_str::gen_val_string(int len, int_vector & encoding) {
SASSERT(charSetSize > 0);
SASSERT(char_set != NULL);
- zstring re(len, (int) char_set[0]);
+ std::string re(len, char_set[0]);
for (int i = 0; i < (int) encoding.size() - 1; i++) {
int idx = encoding[i];
re[len - 1 - i] = char_set[idx];
}
- return re;
+ return zstring(re.c_str());
}
/*
@@ -9474,7 +9444,7 @@ static int computeLCM(int a, int b) {
static zstring get_unrolled_string(zstring core, int count) {
zstring res("");
for (int i = 0; i < count; i++) {
- res += core;
+ res = res + core;
}
return res;
}
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 499bb23f8..fc238acbd 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -33,6 +33,8 @@ Revision History:
namespace smt {
+ typedef hashtable<symbol, symbol_hash_proc, symbol_eq_proc> symbol_set;
+
class str_value_factory : public value_factory {
seq_util u;
symbol_set m_strings;
@@ -44,11 +46,11 @@ namespace smt {
u(m), delim("!"), m_next(0) {}
virtual ~str_value_factory() {}
virtual expr * get_some_value(sort * s) {
- return u.str.mk_string("some value");
+ return u.str.mk_string(symbol("some value"));
}
virtual bool get_some_values(sort * s, expr_ref & v1, expr_ref & v2) {
- v1 = u.str.mk_string("value 1");
- v2 = u.str.mk_string("value 2");
+ v1 = u.str.mk_string(symbol("value 1"));
+ v2 = u.str.mk_string(symbol("value 2"));
return true;
}
virtual expr * get_fresh_value(sort * s) {
@@ -256,7 +258,7 @@ namespace smt {
expr_ref_vector m_trail; // trail for generated terms
- seq_factory * m_factory;
+ str_value_factory * m_factory;
// terms we couldn't go through set_up_axioms() with because they weren't internalized
expr_ref_vector m_delayed_axiom_setup_terms;
From d00723e7ea4252c0a2d7e6cf66668f54f41d830d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 1 Mar 2017 18:23:48 -0500
Subject: [PATCH 354/401] add String name for string sort, SMTLIB2.5 compat
---
src/ast/seq_decl_plugin.cpp | 2 ++
1 file changed, 2 insertions(+)
diff --git a/src/ast/seq_decl_plugin.cpp b/src/ast/seq_decl_plugin.cpp
index 059fe9674..90fd3fb22 100644
--- a/src/ast/seq_decl_plugin.cpp
+++ b/src/ast/seq_decl_plugin.cpp
@@ -830,6 +830,8 @@ void seq_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol
init();
sort_names.push_back(builtin_name("Seq", SEQ_SORT));
sort_names.push_back(builtin_name("RegEx", RE_SORT));
+ // SMT-LIB 2.5 compatibility
+ sort_names.push_back(builtin_name("String", _STRING_SORT));
sort_names.push_back(builtin_name("StringSequence", _STRING_SORT));
}
From 9f79015ee6b2e61fcec3d363b96610948242739d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 1 Mar 2017 22:18:18 -0500
Subject: [PATCH 355/401] patches to theory_str for theory_seq compat
---
src/ast/seq_decl_plugin.cpp | 2 +-
src/smt/smt_setup.cpp | 4 +++-
src/smt/theory_str.cpp | 4 ++--
src/smt/theory_str.h | 2 +-
4 files changed, 7 insertions(+), 5 deletions(-)
diff --git a/src/ast/seq_decl_plugin.cpp b/src/ast/seq_decl_plugin.cpp
index 90fd3fb22..2483d2370 100644
--- a/src/ast/seq_decl_plugin.cpp
+++ b/src/ast/seq_decl_plugin.cpp
@@ -336,7 +336,7 @@ bool operator<(const zstring& lhs, const zstring& rhs) {
seq_decl_plugin::seq_decl_plugin(): m_init(false),
- m_stringc_sym("StringSequence"),
+ m_stringc_sym("String"),
m_charc_sym("Char"),
m_string(0),
m_char(0),
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index 3a4f7f981..78a295e27 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -825,7 +825,9 @@ namespace smt {
}
void setup::setup_seq() {
- m_context.register_plugin(alloc(theory_seq, m_manager));
+ // TODO proper negotiation of theory_str vs. theory_seq
+ //m_context.register_plugin(alloc(theory_seq, m_manager));
+ setup_str();
}
void setup::setup_card() {
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 79b6efb8b..1f276125c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -31,7 +31,7 @@ Revision History:
namespace smt {
theory_str::theory_str(ast_manager & m, theory_str_params const & params):
- theory(m.mk_family_id("str")),
+ theory(m.mk_family_id("seq")),
m_params(params),
/* Options */
opt_EagerStringConstantLengthAssertions(true),
@@ -266,7 +266,7 @@ void theory_str::refresh_theory_var(expr * e) {
theory_var theory_str::mk_var(enode* n) {
TRACE("t_str_detail", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;);
ast_manager & m = get_manager();
- if (!(is_sort_of(m.get_sort(n->get_owner()), u.get_family_id(), _STRING_SORT))) {
+ if (!(m.get_sort(n->get_owner()) == u.str.mk_string_sort())) {
return null_theory_var;
}
if (is_attached_to_var(n)) {
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index fc238acbd..5a67f72f1 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -603,7 +603,7 @@ namespace smt {
theory_str(ast_manager & m, theory_str_params const & params);
virtual ~theory_str();
- virtual char const * get_name() const { return "strings"; }
+ virtual char const * get_name() const { return "seq"; }
virtual void display(std::ostream & out) const;
bool overlapping_variables_detected() const { return loopDetected; }
From 82b1a61b250810c5bd904856f4651bbafcabb730 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sat, 4 Mar 2017 16:30:36 -0500
Subject: [PATCH 356/401] fix string operator names
---
src/ast/seq_decl_plugin.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/ast/seq_decl_plugin.cpp b/src/ast/seq_decl_plugin.cpp
index 2483d2370..465c6f675 100644
--- a/src/ast/seq_decl_plugin.cpp
+++ b/src/ast/seq_decl_plugin.cpp
@@ -558,8 +558,8 @@ void seq_decl_plugin::init() {
m_sigs[_OP_STRING_CHARAT] = alloc(psig, m, "str.at", 0, 2, strTint2T, strT);
m_sigs[_OP_STRING_PREFIX] = alloc(psig, m, "str.prefixof", 0, 2, str2T, boolT);
m_sigs[_OP_STRING_SUFFIX] = alloc(psig, m, "str.suffixof", 0, 2, str2T, boolT);
- m_sigs[_OP_STRING_IN_REGEXP] = alloc(psig, m, "seqstr.in.re", 0, 2, strTreT, boolT);
- m_sigs[_OP_STRING_TO_REGEXP] = alloc(psig, m, "seqstr.to.re", 0, 1, &strT, reT);
+ m_sigs[_OP_STRING_IN_REGEXP] = alloc(psig, m, "str.in.re", 0, 2, strTreT, boolT);
+ m_sigs[_OP_STRING_TO_REGEXP] = alloc(psig, m, "str.to.re", 0, 1, &strT, reT);
m_sigs[_OP_REGEXP_EMPTY] = alloc(psig, m, "re.nostr", 0, 0, 0, reT);
m_sigs[_OP_REGEXP_FULL] = alloc(psig, m, "re.allchar", 0, 0, 0, reT);
m_sigs[_OP_STRING_SUBSTR] = alloc(psig, m, "str.substr", 0, 3, strTint2T, strT);
From 577cb19745f8be7f29988d4dd9fec44e24fd210a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 6 Mar 2017 13:58:03 -0500
Subject: [PATCH 357/401] experimental rewrite of bitvector unit sequences to
string constants
---
src/ast/rewriter/seq_rewriter.cpp | 35 ++++++++++++++++++++++++++++++-
src/ast/rewriter/seq_rewriter.h | 1 +
2 files changed, 35 insertions(+), 1 deletion(-)
diff --git a/src/ast/rewriter/seq_rewriter.cpp b/src/ast/rewriter/seq_rewriter.cpp
index 26c3e23e4..0c77dfcf2 100644
--- a/src/ast/rewriter/seq_rewriter.cpp
+++ b/src/ast/rewriter/seq_rewriter.cpp
@@ -322,7 +322,13 @@ br_status seq_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
switch(f->get_decl_kind()) {
case OP_SEQ_UNIT:
- return BR_FAILED;
+ // TODO configuration param
+ if (true) {
+ SASSERT(num_args == 1);
+ return mk_seq_unit(args[0], result);
+ } else {
+ return BR_FAILED;
+ }
case OP_SEQ_EMPTY:
return BR_FAILED;
case OP_RE_PLUS:
@@ -427,6 +433,33 @@ br_status seq_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
return BR_FAILED;
}
+/*
+ * (seq.unit (_ BitVector 8)) ==> String constant
+ */
+br_status seq_rewriter::mk_seq_unit(expr* e, expr_ref& result) {
+ sort * s = m().get_sort(e);
+ bv_util bvu(m());
+
+ if (is_sort_of(s, bvu.get_family_id(), BV_SORT)) {
+ // specifically we want (_ BitVector 8)
+ rational n_val;
+ unsigned int n_size;
+ if (bvu.is_numeral(e, n_val, n_size)) {
+ if (n_size == 8) {
+ // convert to string constant
+ char ch = (char)n_val.get_int32();
+ TRACE("seq", tout << "rewrite seq.unit of 8-bit value " << n_val.to_string() << " to string constant \"" << ch << "\"" << std::endl;);
+ char s_tmp[2] = {ch, '\0'};
+ symbol s(s_tmp);
+ result = m_util.str.mk_string(s);
+ return BR_DONE;
+ }
+ }
+ }
+
+ return BR_FAILED;
+}
+
/*
string + string = string
a + (b + c) = (a + b) + c
diff --git a/src/ast/rewriter/seq_rewriter.h b/src/ast/rewriter/seq_rewriter.h
index 2b434f475..eed08e376 100644
--- a/src/ast/rewriter/seq_rewriter.h
+++ b/src/ast/rewriter/seq_rewriter.h
@@ -98,6 +98,7 @@ class seq_rewriter {
re2automaton m_re2aut;
expr_ref_vector m_es, m_lhs, m_rhs;
+ br_status mk_seq_unit(expr* e, expr_ref& result);
br_status mk_seq_concat(expr* a, expr* b, expr_ref& result);
br_status mk_seq_length(expr* a, expr_ref& result);
br_status mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& result);
From 4d5c1dcfb696a687c0934259b810305669cb4971 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 6 Mar 2017 17:04:07 -0500
Subject: [PATCH 358/401] fix model gen for regex terms in theory_str
---
src/smt/theory_str.h | 9 +++++++--
1 file changed, 7 insertions(+), 2 deletions(-)
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 5a67f72f1..54fdc6538 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -63,9 +63,14 @@ namespace smt {
m_strings.insert(sym);
return u.str.mk_string(sym);
}
- } else {
- UNREACHABLE(); return NULL;
}
+ sort* seq = 0;
+ if (u.is_re(s, seq)) {
+ expr* v0 = get_fresh_value(seq);
+ return u.re.mk_to_re(v0);
+ }
+ TRACE("t_str", tout << "unexpected sort in get_fresh_value(): " << mk_pp(s, m_manager) << std::endl;);
+ UNREACHABLE(); return NULL;
}
virtual void register_value(expr * n) { /* Ignore */ }
};
From c198bc58638bda1da1621a4a1f373ae4c0c47714 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 10 Mar 2017 13:13:45 -0500
Subject: [PATCH 359/401] fix re.range rewrite for theory_str
---
src/ast/rewriter/seq_rewriter.cpp | 42 ++++++++++++++++++++++++++++---
src/ast/rewriter/seq_rewriter.h | 1 +
2 files changed, 39 insertions(+), 4 deletions(-)
diff --git a/src/ast/rewriter/seq_rewriter.cpp b/src/ast/rewriter/seq_rewriter.cpp
index 0c77dfcf2..4efb4b9d7 100644
--- a/src/ast/rewriter/seq_rewriter.cpp
+++ b/src/ast/rewriter/seq_rewriter.cpp
@@ -350,7 +350,8 @@ br_status seq_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
SASSERT(num_args == 2);
return mk_re_union(args[0], args[1], result);
case OP_RE_RANGE:
- return BR_FAILED;
+ SASSERT(num_args == 2);
+ return mk_re_range(args[0], args[1], result);
case OP_RE_INTERSECT:
SASSERT(num_args == 2);
return mk_re_inter(args[0], args[1], result);
@@ -1313,6 +1314,39 @@ br_status seq_rewriter::mk_re_star(expr* a, expr_ref& result) {
return BR_FAILED;
}
+/*
+ * (re.range c_1 c_n) = (re.union (str.to.re c1) (str.to.re c2) ... (str.to.re cn))
+ */
+br_status seq_rewriter::mk_re_range(expr* lo, expr* hi, expr_ref& result) {
+ TRACE("seq", tout << "rewrite re.range [" << mk_pp(lo, m()) << " " << mk_pp(hi, m()) << "]\n";);
+ zstring str_lo, str_hi;
+ if (m_util.str.is_string(lo, str_lo) && m_util.str.is_string(hi, str_hi)) {
+ if (str_lo.length() == 1 && str_hi.length() == 1) {
+ unsigned int c1 = str_lo[0];
+ unsigned int c2 = str_hi[0];
+ if (c1 > c2) {
+ // exchange c1 and c2
+ unsigned int tmp = c1;
+ c2 = c1;
+ c1 = tmp;
+ }
+ zstring s(c1);
+ expr_ref acc(m_util.re.mk_to_re(m_util.str.mk_string(s)), m());
+ for (unsigned int ch = c1 + 1; ch <= c2; ++ch) {
+ zstring s_ch(ch);
+ expr_ref acc2(m_util.re.mk_to_re(m_util.str.mk_string(s_ch)), m());
+ acc = m_util.re.mk_union(acc, acc2);
+ }
+ result = acc;
+ return BR_REWRITE2;
+ } else {
+ m().raise_exception("string constants in re.range must have length 1");
+ }
+ }
+
+ return BR_FAILED;
+}
+
/*
emp+ = emp
all+ = all
@@ -1342,9 +1376,9 @@ br_status seq_rewriter::mk_re_plus(expr* a, expr_ref& result) {
return BR_DONE;
}
- return BR_FAILED;
-// result = m_util.re.mk_concat(a, m_util.re.mk_star(a));
-// return BR_REWRITE2;
+ //return BR_FAILED;
+ result = m_util.re.mk_concat(a, m_util.re.mk_star(a));
+ return BR_REWRITE2;
}
br_status seq_rewriter::mk_re_opt(expr* a, expr_ref& result) {
diff --git a/src/ast/rewriter/seq_rewriter.h b/src/ast/rewriter/seq_rewriter.h
index eed08e376..210b2d72c 100644
--- a/src/ast/rewriter/seq_rewriter.h
+++ b/src/ast/rewriter/seq_rewriter.h
@@ -120,6 +120,7 @@ class seq_rewriter {
br_status mk_re_plus(expr* a, expr_ref& result);
br_status mk_re_opt(expr* a, expr_ref& result);
br_status mk_re_loop(unsigned num_args, expr* const* args, expr_ref& result);
+ br_status mk_re_range(expr* lo, expr* hi, expr_ref& result);
bool set_empty(unsigned sz, expr* const* es, bool all, expr_ref_vector& lhs, expr_ref_vector& rhs);
bool is_subsequence(unsigned n, expr* const* l, unsigned m, expr* const* r,
From b459d17624c13fdb40d0b802ebc7a4981570ce87 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 10 Mar 2017 13:53:55 -0500
Subject: [PATCH 360/401] fix int-to-str terms in theory_str not being picked
up
---
src/smt/theory_str.cpp | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 1f276125c..ccfdaf8aa 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -7169,6 +7169,10 @@ void theory_str::set_up_axioms(expr * ex) {
}
} else if (u.str.is_at(ap) || u.str.is_extract(ap) || u.str.is_replace(ap)) {
m_library_aware_axiom_todo.push_back(n);
+ } else if (u.str.is_itos(ap)) {
+ TRACE("t_str_detail", tout << "found string-integer conversion term: " << mk_pp(ex, get_manager()) << std::endl;);
+ string_int_conversion_terms.push_back(ap);
+ m_library_aware_axiom_todo.push_back(n);
} else if (ap->get_num_args() == 0 && !u.str.is_string(ap)) {
// if ex is a variable, add it to our list of variables
TRACE("t_str_detail", tout << "tracking variable " << mk_ismt2_pp(ap, get_manager()) << std::endl;);
@@ -7213,7 +7217,8 @@ void theory_str::set_up_axioms(expr * ex) {
// TODO indexof2/lastindexof
if (u.str.is_index(ap) /* || is_Indexof2(ap) || is_LastIndexof(ap) */) {
m_library_aware_axiom_todo.push_back(n);
- } else if (u.str.is_stoi(ap) || u.str.is_itos(ap)) {
+ } else if (u.str.is_stoi(ap)) {
+ TRACE("t_str_detail", tout << "found string-integer conversion term: " << mk_pp(ex, get_manager()) << std::endl;);
string_int_conversion_terms.push_back(ap);
m_library_aware_axiom_todo.push_back(n);
}
From 24df976f956fc728af51d0a7f84e050576ff99e8 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 13 Mar 2017 17:03:36 -0400
Subject: [PATCH 361/401] fixup startswith/endswith to prefixof/suffixof
---
src/smt/theory_str.cpp | 103 ++++++++++++++++++++---------------------
src/smt/theory_str.h | 4 +-
2 files changed, 52 insertions(+), 55 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ccfdaf8aa..0554ae2c2 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -817,12 +817,10 @@ void theory_str::propagate() {
instantiate_axiom_int_to_str(e);
} else if (u.str.is_at(a)) {
instantiate_axiom_CharAt(e);
- /* TODO NEXT: StartsWith/EndsWith -> prefixof/suffixof
- } else if (is_StartsWith(e)) {
- instantiate_axiom_StartsWith(e);
- } else if (is_EndsWith(e)) {
- instantiate_axiom_EndsWith(e);
- */
+ } else if (u.str.is_prefix(a)) {
+ instantiate_axiom_prefixof(e);
+ } else if (u.str.is_suffix(a)) {
+ instantiate_axiom_suffixof(e);
} else if (u.str.is_contains(a)) {
instantiate_axiom_Contains(e);
} else if (u.str.is_index(a)) {
@@ -1101,64 +1099,26 @@ void theory_str::instantiate_axiom_CharAt(enode * e) {
assert_axiom(finalAxiom);
}
-void theory_str::instantiate_axiom_StartsWith(enode * e) {
+void theory_str::instantiate_axiom_prefixof(enode * e) {
context & ctx = get_context();
ast_manager & m = get_manager();
app * expr = e->get_owner();
if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up StartsWith axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("t_str_detail", tout << "already set up prefixof axiom for " << mk_pp(expr, m) << std::endl;);
return;
}
axiomatized_terms.insert(expr);
- TRACE("t_str_detail", tout << "instantiate StartsWith axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("t_str_detail", tout << "instantiate prefixof axiom for " << mk_pp(expr, m) << std::endl;);
expr_ref ts0(mk_str_var("ts0"), m);
expr_ref ts1(mk_str_var("ts1"), m);
expr_ref_vector innerItems(m);
- innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, ts1)));
- innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts0), mk_strlen(expr->get_arg(1))));
- innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts0, expr->get_arg(1)), expr, m.mk_not(expr)));
- expr_ref then1(m.mk_and(innerItems.size(), innerItems.c_ptr()), m);
- SASSERT(then1);
-
- // the top-level condition is Length(arg0) >= Length(arg1).
- // of course, the integer theory is not so accommodating
- expr_ref topLevelCond(
- m_autil.mk_ge(
- m_autil.mk_add(
- mk_strlen(expr->get_arg(0)), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(1)))),
- mk_int(0))
- , m);
- SASSERT(topLevelCond);
-
- expr_ref finalAxiom(m.mk_ite(topLevelCond, then1, m.mk_not(expr)), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
-}
-
-void theory_str::instantiate_axiom_EndsWith(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * expr = e->get_owner();
- if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up EndsWith axiom for " << mk_pp(expr, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(expr);
-
- TRACE("t_str_detail", tout << "instantiate EndsWith axiom for " << mk_pp(expr, m) << std::endl;);
-
- expr_ref ts0(mk_str_var("ts0"), m);
- expr_ref ts1(mk_str_var("ts1"), m);
-
- expr_ref_vector innerItems(m);
- innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, ts1)));
- innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts1), mk_strlen(expr->get_arg(1))));
- innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts1, expr->get_arg(1)), expr, m.mk_not(expr)));
+ innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_concat(ts0, ts1)));
+ innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts0), mk_strlen(expr->get_arg(0))));
+ innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts0, expr->get_arg(0)), expr, m.mk_not(expr)));
expr_ref then1(m.mk_and(innerItems.size(), innerItems.c_ptr()), m);
SASSERT(then1);
@@ -1166,9 +1126,46 @@ void theory_str::instantiate_axiom_EndsWith(enode * e) {
expr_ref topLevelCond(
m_autil.mk_ge(
m_autil.mk_add(
- mk_strlen(expr->get_arg(0)), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(1)))),
- mk_int(0))
- , m);
+ mk_strlen(expr->get_arg(1)), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))),
+ mk_int(0))
+ , m);
+ SASSERT(topLevelCond);
+
+ expr_ref finalAxiom(m.mk_ite(topLevelCond, then1, m.mk_not(expr)), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+}
+
+void theory_str::instantiate_axiom_suffixof(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("t_str_detail", tout << "already set up suffixof axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("t_str_detail", tout << "instantiate suffixof axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref ts0(mk_str_var("ts0"), m);
+ expr_ref ts1(mk_str_var("ts1"), m);
+
+ expr_ref_vector innerItems(m);
+ innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_concat(ts0, ts1)));
+ innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts1), mk_strlen(expr->get_arg(0))));
+ innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts1, expr->get_arg(0)), expr, m.mk_not(expr)));
+ expr_ref then1(m.mk_and(innerItems.size(), innerItems.c_ptr()), m);
+ SASSERT(then1);
+
+ // the top-level condition is Length(arg0) >= Length(arg1)
+ expr_ref topLevelCond(
+ m_autil.mk_ge(
+ m_autil.mk_add(
+ mk_strlen(expr->get_arg(1)), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))),
+ mk_int(0))
+ , m);
SASSERT(topLevelCond);
expr_ref finalAxiom(m.mk_ite(topLevelCond, then1, m.mk_not(expr)), m);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 54fdc6538..3ea4db7d4 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -433,8 +433,8 @@ namespace smt {
void instantiate_str_eq_length_axiom(enode * lhs, enode * rhs);
void instantiate_axiom_CharAt(enode * e);
- void instantiate_axiom_StartsWith(enode * e);
- void instantiate_axiom_EndsWith(enode * e);
+ void instantiate_axiom_prefixof(enode * e);
+ void instantiate_axiom_suffixof(enode * e);
void instantiate_axiom_Contains(enode * e);
void instantiate_axiom_Indexof(enode * e);
void instantiate_axiom_Indexof2(enode * e);
From 8021d63539b697476f510dbd79abeaeca06b9a7e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 15 Mar 2017 15:25:48 -0400
Subject: [PATCH 362/401] remove legacy str_decl_plugin and str_rewriter
classes; these have been unified with sequence-compatible equivalents
---
src/ast/ast_smt2_pp.h | 1 -
src/ast/ast_smt_pp.cpp | 1 -
src/ast/rewriter/str_rewriter.cpp | 703 ------------------------------
src/ast/rewriter/str_rewriter.h | 120 -----
src/ast/str_decl_plugin.cpp | 501 ---------------------
src/ast/str_decl_plugin.h | 218 ---------
6 files changed, 1544 deletions(-)
delete mode 100644 src/ast/rewriter/str_rewriter.cpp
delete mode 100644 src/ast/rewriter/str_rewriter.h
delete mode 100644 src/ast/str_decl_plugin.cpp
delete mode 100644 src/ast/str_decl_plugin.h
diff --git a/src/ast/ast_smt2_pp.h b/src/ast/ast_smt2_pp.h
index 2f79ebaec..244594461 100644
--- a/src/ast/ast_smt2_pp.h
+++ b/src/ast/ast_smt2_pp.h
@@ -30,7 +30,6 @@ Revision History:
#include"fpa_decl_plugin.h"
#include"dl_decl_plugin.h"
#include"seq_decl_plugin.h"
-#include"str_decl_plugin.h"
#include"smt2_util.h"
class smt2_pp_environment {
diff --git a/src/ast/ast_smt_pp.cpp b/src/ast/ast_smt_pp.cpp
index de6ae6cc3..c3f1523b1 100644
--- a/src/ast/ast_smt_pp.cpp
+++ b/src/ast/ast_smt_pp.cpp
@@ -24,7 +24,6 @@ Revision History:
#include"ast_smt_pp.h"
#include"arith_decl_plugin.h"
#include"bv_decl_plugin.h"
-#include"str_decl_plugin.h"
#include"array_decl_plugin.h"
#include"datatype_decl_plugin.h"
#include"fpa_decl_plugin.h"
diff --git a/src/ast/rewriter/str_rewriter.cpp b/src/ast/rewriter/str_rewriter.cpp
deleted file mode 100644
index 3933e7fdb..000000000
--- a/src/ast/rewriter/str_rewriter.cpp
+++ /dev/null
@@ -1,703 +0,0 @@
-/*++
-Copyright (c) 2016 Microsoft Corporation
-
-Module Name:
-
- str_rewriter.cpp
-
-Abstract:
-
- AST rewriting rules for string terms.
-
-Author:
-
- Murphy Berzish
-
-Notes:
-
---*/
-
-#if 0
-
-#include"str_rewriter.h"
-#include"arith_decl_plugin.h"
-#include"ast_pp.h"
-#include"ast_util.h"
-#include"well_sorted.h"
-#include<map>
-#include<set>
-#include<deque>
-#include<cctype>
-
-// Convert a regular expression to an e-NFA using Thompson's construction
-void nfa::convert_re(expr * e, unsigned & start, unsigned & end, str_util & m_strutil) {
- start = next_id();
- end = next_id();
- if (m_strutil.is_re_Str2Reg(e)) {
- app * a = to_app(e);
- expr * arg_str = a->get_arg(0);
- if (m_strutil.is_string(arg_str)) {
- std::string str = m_strutil.get_string_constant_value(arg_str);
- TRACE("t_str_rw", tout << "build NFA for '" << str << "'" << std::endl;);
-
- /*
- * For an n-character string, we make (n-1) intermediate states,
- * labelled i_(0) through i_(n-2).
- * Then we construct the following transitions:
- * start --str[0]--> i_(0) --str[1]--> i_(1) --...--> i_(n-2) --str[n-1]--> final
- */
- unsigned last = start;
- for (int i = 0; i <= ((int)str.length()) - 2; ++i) {
- unsigned i_state = next_id();
- make_transition(last, str.at(i), i_state);
- TRACE("t_str_rw", tout << "string transition " << last << "--" << str.at(i) << "--> " << i_state << std::endl;);
- last = i_state;
- }
- make_transition(last, str.at(str.length() - 1), end);
- TRACE("t_str_rw", tout << "string transition " << last << "--" << str.at(str.length() - 1) << "--> " << end << std::endl;);
- TRACE("t_str_rw", tout << "string NFA: start = " << start << ", end = " << end << std::endl;);
- } else {
- TRACE("t_str_rw", tout << "invalid string constant in Str2Reg" << std::endl;);
- m_valid = false;
- return;
- }
- } else if (m_strutil.is_re_RegexConcat(e)){
- app * a = to_app(e);
- expr * re1 = a->get_arg(0);
- expr * re2 = a->get_arg(1);
- unsigned start1, end1;
- convert_re(re1, start1, end1, m_strutil);
- unsigned start2, end2;
- convert_re(re2, start2, end2, m_strutil);
- // start --e--> start1 --...--> end1 --e--> start2 --...--> end2 --e--> end
- make_epsilon_move(start, start1);
- make_epsilon_move(end1, start2);
- make_epsilon_move(end2, end);
- TRACE("t_str_rw", tout << "concat NFA: start = " << start << ", end = " << end << std::endl;);
- } else if (m_strutil.is_re_RegexUnion(e)) {
- app * a = to_app(e);
- expr * re1 = a->get_arg(0);
- expr * re2 = a->get_arg(1);
- unsigned start1, end1;
- convert_re(re1, start1, end1, m_strutil);
- unsigned start2, end2;
- convert_re(re2, start2, end2, m_strutil);
-
- // start --e--> start1 ; start --e--> start2
- // end1 --e--> end ; end2 --e--> end
- make_epsilon_move(start, start1);
- make_epsilon_move(start, start2);
- make_epsilon_move(end1, end);
- make_epsilon_move(end2, end);
- TRACE("t_str_rw", tout << "union NFA: start = " << start << ", end = " << end << std::endl;);
- } else if (m_strutil.is_re_RegexStar(e)) {
- app * a = to_app(e);
- expr * subex = a->get_arg(0);
- unsigned start_subex, end_subex;
- convert_re(subex, start_subex, end_subex, m_strutil);
- // start --e--> start_subex, start --e--> end
- // end_subex --e--> start_subex, end_subex --e--> end
- make_epsilon_move(start, start_subex);
- make_epsilon_move(start, end);
- make_epsilon_move(end_subex, start_subex);
- make_epsilon_move(end_subex, end);
- TRACE("t_str_rw", tout << "star NFA: start = " << start << ", end = " << end << std::endl;);
- } else {
- TRACE("t_str_rw", tout << "invalid regular expression" << std::endl;);
- m_valid = false;
- return;
- }
-}
-
-void nfa::epsilon_closure(unsigned start, std::set<unsigned> & closure) {
- std::deque<unsigned> worklist;
- closure.insert(start);
- worklist.push_back(start);
-
- while(!worklist.empty()) {
- unsigned state = worklist.front();
- worklist.pop_front();
- if (epsilon_map.find(state) != epsilon_map.end()) {
- for (std::set<unsigned>::iterator it = epsilon_map[state].begin();
- it != epsilon_map[state].end(); ++it) {
- unsigned new_state = *it;
- if (closure.find(new_state) == closure.end()) {
- closure.insert(new_state);
- worklist.push_back(new_state);
- }
- }
- }
- }
-}
-
-bool nfa::matches(std::string input) {
- /*
- * Keep a set of all states the NFA can currently be in.
- * Initially this is the e-closure of m_start_state
- * For each character A in the input string,
- * the set of next states contains
- * all states in transition_map[S][A] for each S in current_states,
- * and all states in epsilon_map[S] for each S in current_states.
- * After consuming the entire input string,
- * the match is successful iff current_states contains m_end_state.
- */
- std::set<unsigned> current_states;
- epsilon_closure(m_start_state, current_states);
- for (unsigned i = 0; i < input.length(); ++i) {
- char A = input.at(i);
- std::set<unsigned> next_states;
- for (std::set<unsigned>::iterator it = current_states.begin();
- it != current_states.end(); ++it) {
- unsigned S = *it;
- // check transition_map
- if (transition_map[S].find(A) != transition_map[S].end()) {
- next_states.insert(transition_map[S][A]);
- }
- }
-
- // take e-closure over next_states to compute the actual next_states
- std::set<unsigned> epsilon_next_states;
- for (std::set<unsigned>::iterator it = next_states.begin(); it != next_states.end(); ++it) {
- unsigned S = *it;
- std::set<unsigned> closure;
- epsilon_closure(S, closure);
- epsilon_next_states.insert(closure.begin(), closure.end());
- }
- current_states = epsilon_next_states;
- }
- if (current_states.find(m_end_state) != current_states.end()) {
- return true;
- } else {
- return false;
- }
-}
-
-
-br_status str_rewriter::mk_str_Concat(expr * arg0, expr * arg1, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (Concat " << mk_pp(arg0, m()) << " " << mk_pp(arg1, m()) << ")" << std::endl;);
- if(m_strutil.is_string(arg0) && m_strutil.is_string(arg1)) {
- TRACE("t_str_rw", tout << "evaluating concat of two constant strings" << std::endl;);
- std::string arg0Str = m_strutil.get_string_constant_value(arg0);
- std::string arg1Str = m_strutil.get_string_constant_value(arg1);
- std::string resultStr = arg0Str + arg1Str;
- result = m_strutil.mk_string(resultStr);
- return BR_DONE;
- } else {
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_str_Length(expr * arg0, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (Length " << mk_pp(arg0, m()) << ")" << std::endl;);
- if (m_strutil.is_string(arg0)) {
- TRACE("t_str_rw", tout << "evaluating length of constant string" << std::endl;);
- std::string arg0Str = m_strutil.get_string_constant_value(arg0);
- rational arg0Len((unsigned)arg0Str.length());
- result = m_autil.mk_numeral(arg0Len, true);
- TRACE("t_str_rw", tout << "result is " << mk_pp(result, m()) << std::endl;);
- return BR_DONE;
- } else {
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (CharAt " << mk_pp(arg0, m()) << " " << mk_pp(arg1, m()) << ")" << std::endl;);
- // if arg0 is a string constant and arg1 is an integer constant,
- // we can rewrite this by evaluating the expression
- rational arg1Int;
- if (m_strutil.is_string(arg0) && m_autil.is_numeral(arg1, arg1Int)) {
- TRACE("t_str_rw", tout << "evaluating constant CharAt expression" << std::endl;);
- std::string arg0Str = m_strutil.get_string_constant_value(arg0);
- std::string resultStr;
- if (arg1Int >= rational(0) && arg1Int <= rational((unsigned)arg0Str.length())) {
- resultStr = arg0Str.at(arg1Int.get_unsigned());
- TRACE("t_str_rw", tout << "result is '" << resultStr << "'" << std::endl;);
- } else {
- resultStr = "";
- TRACE("t_str_rw", tout << "bogus length argument, result is empty string" << std::endl;);
- }
- result = m_strutil.mk_string(resultStr);
- return BR_DONE;
- } else {
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_str_StartsWith(expr * haystack, expr * needle, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (StartsWith " << mk_pp(haystack, m()) << " " << mk_pp(needle, m()) << ")" << std::endl;);
- if (m_strutil.is_string(haystack) && m_strutil.is_string(needle)) {
- TRACE("t_str_rw", tout << "evaluating constant StartsWith predicate" << std::endl;);
- std::string haystackStr = m_strutil.get_string_constant_value(haystack);
- std::string needleStr = m_strutil.get_string_constant_value(needle);
- if (haystackStr.length() < needleStr.length()) {
- result = m().mk_false();
- return BR_DONE;
- } else {
- if (haystackStr.substr(0, needleStr.length()) == needleStr) {
- result = m().mk_true();
- } else {
- result = m().mk_false();
- }
- return BR_DONE;
- }
- } else {
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_str_EndsWith(expr * haystack, expr * needle, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (EndsWith " << mk_pp(haystack, m()) << " " << mk_pp(needle, m()) << ")" << std::endl;);
- if (m_strutil.is_string(haystack) && m_strutil.is_string(needle)) {
- TRACE("t_str_rw", tout << "evaluating constant EndsWith predicate" << std::endl;);
- std::string haystackStr = m_strutil.get_string_constant_value(haystack);
- std::string needleStr = m_strutil.get_string_constant_value(needle);
- if (haystackStr.length() < needleStr.length()) {
- result = m().mk_false();
- return BR_DONE;
- } else {
- if (haystackStr.substr(haystackStr.length() - needleStr.length(), needleStr.length()) == needleStr) {
- result = m().mk_true();
- } else {
- result = m().mk_false();
- }
- return BR_DONE;
- }
- } else {
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_str_Contains(expr * haystack, expr * needle, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (Contains " << mk_pp(haystack, m()) << " " << mk_pp(needle, m()) << ")" << std::endl;);
- if (haystack == needle) {
- TRACE("t_str_rw", tout << "eliminate (Contains) over identical terms" << std::endl;);
- result = m().mk_true();
- return BR_DONE;
- } else if (m_strutil.is_string(haystack) && m_strutil.is_string(needle)) {
- TRACE("t_str_rw", tout << "evaluating constant Contains predicate" << std::endl;);
- std::string haystackStr = m_strutil.get_string_constant_value(haystack);
- std::string needleStr = m_strutil.get_string_constant_value(needle);
- if (haystackStr.find(needleStr) != std::string::npos) {
- result = m().mk_true();
- } else {
- result = m().mk_false();
- }
- return BR_DONE;
- } else {
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_str_Indexof(expr * haystack, expr * needle, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (Indexof " << mk_pp(haystack, m()) << " " << mk_pp(needle, m()) << ")" << std::endl;);
- if (m_strutil.is_string(haystack) && m_strutil.is_string(needle)) {
- TRACE("t_str_rw", tout << "evaluating constant Indexof expression" << std::endl;);
- std::string haystackStr = m_strutil.get_string_constant_value(haystack);
- std::string needleStr = m_strutil.get_string_constant_value(needle);
- if (haystackStr.find(needleStr) != std::string::npos) {
- int index = haystackStr.find(needleStr);
- result = m_autil.mk_numeral(rational(index), true);
- } else {
- result = m_autil.mk_numeral(rational(-1), true);
- }
- return BR_DONE;
- } else {
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_str_Indexof2(expr * arg0, expr * arg1, expr * arg2, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (Indexof2 " << mk_pp(arg0, m()) << " " << mk_pp(arg1, m()) << " " << mk_pp(arg2, m()) << ")" << std::endl;);
- //if (getNodeType(t, args[0]) == my_Z3_ConstStr && getNodeType(t, args[1]) == my_Z3_ConstStr && getNodeType(t, args[2]) == my_Z3_Num) {
- rational arg2Int;
- if (m_strutil.is_string(arg0) && m_strutil.is_string(arg1) && m_autil.is_numeral(arg2, arg2Int)) {
- TRACE("t_str_rw", tout << "evaluating constant Indexof2 expression" << std::endl;);
- std::string arg0str = m_strutil.get_string_constant_value(arg0);
- std::string arg1str = m_strutil.get_string_constant_value(arg1);
- if (arg2Int >= rational((unsigned)arg0str.length())) {
- result = m_autil.mk_numeral(rational(-1), true);
- } else if (arg2Int < rational(0)) {
- int index = arg0str.find(arg1str);
- result = m_autil.mk_numeral(rational(index), true);
- } else {
- std::string suffixStr = arg0str.substr(arg2Int.get_unsigned(), arg0str.length() - arg2Int.get_unsigned());
- if (suffixStr.find(arg1str) != std::string::npos) {
- int index = suffixStr.find(arg1str) + arg2Int.get_unsigned();
- result = m_autil.mk_numeral(rational(index), true);
- } else {
- result = m_autil.mk_numeral(rational(-1), true);
- }
- }
- return BR_DONE;
- } else {
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_str_LastIndexof(expr * haystack, expr * needle, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (LastIndexof " << mk_pp(haystack, m()) << " " << mk_pp(needle, m()) << ")" << std::endl;);
- if (m_strutil.is_string(haystack) && m_strutil.is_string(needle)) {
- TRACE("t_str_rw", tout << "evaluating constant LastIndexof expression" << std::endl;);
- std::string arg0Str = m_strutil.get_string_constant_value(haystack);
- std::string arg1Str = m_strutil.get_string_constant_value(needle);
- if (arg0Str.rfind(arg1Str) != std::string::npos) {
- int index = arg0Str.rfind(arg1Str);
- result = m_autil.mk_numeral(rational(index), true);
- } else {
- result = m_autil.mk_numeral(rational(-1), true);
- }
- return BR_DONE;
- } else {
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_str_Replace(expr * base, expr * source, expr * target, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (Replace " << mk_pp(base, m()) << " " << mk_pp(source, m()) << " " << mk_pp(target, m()) << ")" << std::endl;);
- if (m_strutil.is_string(base) && m_strutil.is_string(source) && m_strutil.is_string(target)) {
- std::string arg0Str = m_strutil.get_string_constant_value(base);
- std::string arg1Str = m_strutil.get_string_constant_value(source);
- std::string arg2Str = m_strutil.get_string_constant_value(target);
- if (arg0Str.find(arg1Str) != std::string::npos) {
- int index1 = arg0Str.find(arg1Str);
- int index2 = index1 + arg1Str.length();
- std::string substr0 = arg0Str.substr(0, index1);
- std::string substr2 = arg0Str.substr(index2);
- std::string replaced = substr0 + arg2Str + substr2;
- result = m_strutil.mk_string(replaced);
- } else {
- result = base;
- }
- return BR_DONE;
- } else {
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_str_prefixof(expr * pre, expr * full, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (str.prefixof " << mk_pp(pre, m()) << " " << mk_pp(full, m()) << ")" << std::endl;);
- result = m_strutil.mk_str_StartsWith(full, pre);
- return BR_REWRITE_FULL;
-}
-
-br_status str_rewriter::mk_str_suffixof(expr * post, expr * full, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (str.suffixof" << mk_pp(post, m()) << " " << mk_pp(full, m()) << ")" << std::endl;);
- result = m_strutil.mk_str_EndsWith(full, post);
- return BR_REWRITE_FULL;
-}
-
-br_status str_rewriter::mk_str_to_int(expr * arg0, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (str.to-int " << mk_pp(arg0, m()) << ")" << std::endl;);
-
- if (m_strutil.is_string(arg0)) {
- std::string str = m_strutil.get_string_constant_value(arg0);
- if (str.length() == 0) {
- result = m_autil.mk_numeral(rational::zero(), true);
- return BR_DONE;
- }
-
- // interpret str as a natural number and rewrite to the corresponding integer.
- // if this is not valid, rewrite to -1
- rational convertedRepresentation(0);
- rational ten(10);
- for (unsigned i = 0; i < str.length(); ++i) {
- char digit = str.at(i);
- if (isdigit((int)digit)) {
- std::string sDigit(1, digit);
- int val = atoi(sDigit.c_str());
- convertedRepresentation = (ten * convertedRepresentation) + rational(val);
- } else {
- // not a digit, invalid
- TRACE("t_str_rw", tout << "str.to-int argument contains non-digit character '" << digit << "'" << std::endl;);
- convertedRepresentation = rational::minus_one();
- break;
- }
- }
- result = m_autil.mk_numeral(convertedRepresentation, true);
- return BR_DONE;
- }
- return BR_FAILED;
-
-}
-
-br_status str_rewriter::mk_str_from_int(expr * arg0, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (str.from-int " << mk_pp(arg0, m()) << ")" << std::endl;);
- rational arg0Int;
- if (m_autil.is_numeral(arg0, arg0Int)) {
- // (str.from-int N) with N non-negative is the corresponding string in decimal notation.
- // otherwise it is the empty string
- if (arg0Int.is_nonneg()) {
- std::string str = arg0Int.to_string();
- result = m_strutil.mk_string(str);
- TRACE("t_str_rw", tout << "convert non-negative integer constant to " << str << std::endl;);
- } else {
- result = m_strutil.mk_string("");
- TRACE("t_str_rw", tout << "convert invalid integer constant to empty string" << std::endl;);
- }
- return BR_DONE;
- }
- return BR_FAILED;
-}
-
-br_status str_rewriter::mk_str_Substr(expr * base, expr * start, expr * len, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (Substr " << mk_pp(base, m()) << " " << mk_pp(start, m()) << " " << mk_pp(len, m()) << ")" << std::endl;);
-
- bool constant_base = m_strutil.is_string(base);
- std::string baseStr;
- if (constant_base) {
- baseStr = m_strutil.get_string_constant_value(base);
- }
- rational startVal;
- bool constant_start = m_autil.is_numeral(start, startVal);
- rational lenVal;
- bool constant_len = m_autil.is_numeral(len, lenVal);
-
- // case 1: start < 0 or len < 0
- if ( (constant_start && startVal.is_neg()) || (constant_len && lenVal.is_neg()) ) {
- TRACE("t_str_rw", tout << "start/len of substr is negative" << std::endl;);
- result = m_strutil.mk_string("");
- return BR_DONE;
- }
- // case 1.1: start >= length(base)
- if (constant_start && constant_base) {
- rational baseStrlen((unsigned int)baseStr.length());
- if (startVal >= baseStrlen) {
- TRACE("t_str_rw", tout << "start >= strlen for substr" << std::endl;);
- result = m_strutil.mk_string("");
- return BR_DONE;
- }
- }
-
- if (constant_base && constant_start && constant_len) {
- rational baseStrlen((unsigned int)baseStr.length());
- std::string retval;
- if (startVal + lenVal >= baseStrlen) {
- // case 2: pos+len goes past the end of the string
- retval = baseStr.substr(startVal.get_unsigned(), std::string::npos);
- } else {
- // case 3: pos+len still within string
- retval = baseStr.substr(startVal.get_unsigned(), lenVal.get_unsigned());
- }
- result = m_strutil.mk_string(retval);
- return BR_DONE;
- }
-
- return BR_FAILED;
-}
-
-br_status str_rewriter::mk_re_Str2Reg(expr * str, expr_ref & result) {
- // the argument to Str2Reg *must* be a string constant
- ENSURE(m_strutil.is_string(str));
- return BR_FAILED;
-}
-
-br_status str_rewriter::mk_re_RegexIn(expr * str, expr * re, expr_ref & result) {
- // fast path:
- // (RegexIn E (Str2Reg S)) --> (= E S)
- if (m_strutil.is_re_Str2Reg(re)) {
- expr * regexStr = to_app(re)->get_arg(0);
- ENSURE(m_strutil.is_string(regexStr));
- result = m().mk_eq(str, regexStr);
- TRACE("t_str_rw", tout << "RegexIn fast path: " << mk_pp(str, m()) << " in " << mk_pp(re, m()) << " ==> " << mk_pp(result, m()) << std::endl;);
- return BR_REWRITE_FULL;
- }
-
- // necessary for model validation
- if (m_strutil.is_string(str)) {
- TRACE("t_str_rw", tout << "RegexIn with constant string argument" << std::endl;);
- nfa regex_nfa(m_strutil, re);
- ENSURE(regex_nfa.is_valid());
- std::string input = m_strutil.get_string_constant_value(str);
- if (regex_nfa.matches(input)) {
- result = m().mk_true();
- } else {
- result = m().mk_false();
- }
- return BR_DONE;
- }
-
- return BR_FAILED;
-}
-
-br_status str_rewriter::mk_re_RegexStar(expr * re, expr_ref & result) {
- if (m_strutil.is_re_RegexStar(re)) {
- result = re;
- return BR_REWRITE_FULL;
- } else {
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_re_RegexConcat(expr * r0, expr * r1, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (RegexConcat " << mk_pp(r0, m()) << " " << mk_pp(r1, m()) << ")" << std::endl;);
- // (RegexConcat (Str2Reg "A") (Str2Reg "B")) --> (Str2Reg "AB")
- if (m_strutil.is_re_Str2Reg(r0) && m_strutil.is_re_Str2Reg(r1)) {
- expr * r0str = to_app(r0)->get_arg(0);
- expr * r1str = to_app(r1)->get_arg(0);
- ENSURE(m_strutil.is_string(r0str));
- ENSURE(m_strutil.is_string(r1str));
- std::string r0val = m_strutil.get_string_constant_value(r0str);
- std::string r1val = m_strutil.get_string_constant_value(r1str);
- std::string simplifyVal = r0val + r1val;
- TRACE("t_str_rw", tout << "RegexConcat fast path: both sides are Str2Reg, simplify to (Str2Reg \"" << simplifyVal << "\")" << std::endl;);
- result = m_strutil.mk_re_Str2Reg(simplifyVal);
- return BR_DONE;
- }
-
- return BR_FAILED;
-}
-
-br_status str_rewriter::mk_re_RegexPlus(expr * re, expr_ref & result) {
- /*
- * Two optimizations are possible if we inspect 're'.
- * If 're' is (RegexPlus X), then reduce to 're'.
- * If 're' is (RegexStar X), then reduce to 're'.
- * Otherwise, reduce to (RegexConcat re (RegexStar re)).
- */
-
- if (m_strutil.is_re_RegexPlus(re)) {
- result = re;
- return BR_REWRITE_FULL;
- } else if (m_strutil.is_re_RegexStar(re)) {
- // Z3str2 re-created the AST under 're' here, but I don't think we need to do that
- result = re;
- return BR_REWRITE_FULL;
- } else {
- result = m_strutil.mk_re_RegexConcat(re, m_strutil.mk_re_RegexStar(re));
- return BR_REWRITE_FULL;
- }
-}
-
-br_status str_rewriter::mk_re_RegexCharRange(expr * start, expr * end, expr_ref & result) {
- TRACE("t_str_rw", tout << "rewrite (RegexCharRange " << mk_pp(start, m()) << " " << mk_pp(end, m()) << ")" << std::endl;);
- // both 'start' and 'end' must be string constants
- ENSURE(m_strutil.is_string(start) && m_strutil.is_string(end));
- std::string arg0Value = m_strutil.get_string_constant_value(start);
- std::string arg1Value = m_strutil.get_string_constant_value(end);
- ENSURE(arg0Value.length() == 1 && arg1Value.length() == 1);
- char low = arg0Value[0];
- char high = arg1Value[0];
- if (low > high) {
- char t = low;
- low = high;
- high = t;
- }
-
- char c = low;
- std::string cStr;
- cStr.push_back(c);
- expr * res = m_strutil.mk_re_Str2Reg(cStr);
- c++;
- for (; c <= high; c++) {
- cStr.clear();
- cStr.push_back(c);
- res = m_strutil.mk_re_RegexUnion(res, m_strutil.mk_re_Str2Reg(cStr));
- }
- result = res;
- return BR_DONE;
-}
-
-br_status str_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
- SASSERT(f->get_family_id() == get_fid());
-
- TRACE("t_str_rw", tout << "rewrite app: " << f->get_name() << std::endl;);
-
- switch(f->get_decl_kind()) {
- case OP_STRCAT:
- SASSERT(num_args == 2);
- return mk_str_Concat(args[0], args[1], result);
- case OP_STRLEN:
- SASSERT(num_args == 1);
- return mk_str_Length(args[0], result);
- case OP_STR_CHARAT:
- SASSERT(num_args == 2);
- return mk_str_CharAt(args[0], args[1], result);
- case OP_STR_STARTSWITH:
- SASSERT(num_args == 2);
- return mk_str_StartsWith(args[0], args[1], result);
- case OP_STR_ENDSWITH:
- SASSERT(num_args == 2);
- return mk_str_EndsWith(args[0], args[1], result);
- case OP_STR_CONTAINS:
- SASSERT(num_args == 2);
- return mk_str_Contains(args[0], args[1], result);
- case OP_STR_INDEXOF:
- SASSERT(num_args == 2);
- return mk_str_Indexof(args[0], args[1], result);
- case OP_STR_INDEXOF2:
- SASSERT(num_args == 3);
- return mk_str_Indexof2(args[0], args[1], args[2], result);
- case OP_STR_LASTINDEXOF:
- SASSERT(num_args == 2);
- return mk_str_LastIndexof(args[0], args[1], result);
- case OP_STR_REPLACE:
- SASSERT(num_args == 3);
- return mk_str_Replace(args[0], args[1], args[2], result);
- case OP_STR_PREFIXOF:
- SASSERT(num_args == 2);
- return mk_str_prefixof(args[0], args[1], result);
- case OP_STR_SUFFIXOF:
- SASSERT(num_args == 2);
- return mk_str_suffixof(args[0], args[1], result);
- case OP_STR_STR2INT:
- SASSERT(num_args == 1);
- return mk_str_to_int(args[0], result);
- case OP_STR_INT2STR:
- SASSERT(num_args == 1);
- return mk_str_from_int(args[0], result);
- case OP_STR_SUBSTR:
- SASSERT(num_args == 3);
- return mk_str_Substr(args[0], args[1], args[2], result);
- case OP_RE_STR2REGEX:
- SASSERT(num_args == 1);
- return mk_re_Str2Reg(args[0], result);
- case OP_RE_REGEXIN:
- SASSERT(num_args == 2);
- return mk_re_RegexIn(args[0], args[1], result);
- case OP_RE_REGEXPLUS:
- SASSERT(num_args == 1);
- return mk_re_RegexPlus(args[0], result);
- case OP_RE_REGEXSTAR:
- SASSERT(num_args == 1);
- return mk_re_RegexStar(args[0], result);
- case OP_RE_REGEXCONCAT:
- SASSERT(num_args == 2);
- return mk_re_RegexConcat(args[0], args[1], result);
- case OP_RE_REGEXCHARRANGE:
- SASSERT(num_args == 2);
- return mk_re_RegexCharRange(args[0], args[1], result);
- default:
- return BR_FAILED;
- }
-}
-
-br_status str_rewriter::mk_eq_core(expr * l, expr * r, expr_ref & result) {
- // from seq_rewriter
- expr_ref_vector lhs(m()), rhs(m()), res(m());
- bool changed = false;
- if (!reduce_eq(l, r, lhs, rhs, changed)) {
- result = m().mk_false();
- return BR_DONE;
- }
- if (!changed) {
- return BR_FAILED;
- }
- for (unsigned i = 0; i < lhs.size(); ++i) {
- res.push_back(m().mk_eq(lhs[i].get(), rhs[i].get()));
- }
- result = mk_and(res);
- return BR_REWRITE3;
-}
-
-bool str_rewriter::reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change) {
- change = false;
- return true;
-}
-
-bool str_rewriter::reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change) {
- change = false;
- return true;
-}
-
-#endif /* disable */
diff --git a/src/ast/rewriter/str_rewriter.h b/src/ast/rewriter/str_rewriter.h
deleted file mode 100644
index 8d6041a51..000000000
--- a/src/ast/rewriter/str_rewriter.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/*++
-Copyright (c) 2016 Microsoft Corporation
-
-Module Name:
-
- str_rewriter.h
-
-Abstract:
-
- AST rewriting rules for string terms.
-
-Author:
-
- Murphy Berzish
-
-Notes:
-
---*/
-
-#if 0
-
-#include"str_decl_plugin.h"
-#include"arith_decl_plugin.h"
-#include"rewriter_types.h"
-#include"params.h"
-#include<set>
-#include<map>
-
-class str_rewriter {
- str_util m_strutil;
- arith_util m_autil;
-
-public:
- str_rewriter(ast_manager & m, params_ref const & p = params_ref()) :
- m_strutil(m), m_autil(m) {
- }
-
- ast_manager & m() const { return m_strutil.get_manager(); }
- family_id get_fid() const { return m_strutil.get_family_id(); }
-
- void updt_params(params_ref const & p) {}
- static void get_param_descrs(param_descrs & r) {}
-
- br_status mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result);
- br_status mk_eq_core(expr * lhs, expr * rhs, expr_ref & result);
-
- br_status mk_str_Concat(expr * arg0, expr * arg1, expr_ref & result);
- br_status mk_str_Length(expr * arg0, expr_ref & result);
- br_status mk_str_CharAt(expr * arg0, expr * arg1, expr_ref & result);
- br_status mk_str_StartsWith(expr * haystack, expr * needle, expr_ref & result);
- br_status mk_str_EndsWith(expr * haystack, expr * needle, expr_ref & result);
- br_status mk_str_Contains(expr * haystack, expr * needle, expr_ref & result);
- br_status mk_str_Indexof(expr * haystack, expr * needle, expr_ref & result);
- br_status mk_str_Indexof2(expr * arg0, expr * arg1, expr * arg2, expr_ref & result);
- br_status mk_str_LastIndexof(expr * haystack, expr * needle, expr_ref & result);
- br_status mk_str_Replace(expr * base, expr * source, expr * target, expr_ref & result);
- br_status mk_str_Substr(expr * base, expr * start, expr * len, expr_ref & result);
- br_status mk_str_prefixof(expr * pre, expr * full, expr_ref & result);
- br_status mk_str_suffixof(expr * post, expr * full, expr_ref & result);
- br_status mk_str_to_int(expr * arg0, expr_ref & result);
- br_status mk_str_from_int(expr * arg0, expr_ref & result);
-
- br_status mk_re_Str2Reg(expr * str, expr_ref & result);
- br_status mk_re_RegexIn(expr * str, expr * re, expr_ref & result);
- br_status mk_re_RegexPlus(expr * re, expr_ref & result);
- br_status mk_re_RegexStar(expr * re, expr_ref & result);
- br_status mk_re_RegexConcat(expr * r0, expr * r1, expr_ref & result);
- br_status mk_re_RegexCharRange(expr * start, expr * end, expr_ref & result);
-
- bool reduce_eq(expr * l, expr * r, expr_ref_vector & lhs, expr_ref_vector & rhs, bool & change);
- bool reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_vector& lhs, expr_ref_vector& rhs, bool& change);
-
-};
-
-class nfa {
-protected:
- bool m_valid;
- unsigned m_next_id;
-
- unsigned next_id() {
- unsigned retval = m_next_id;
- ++m_next_id;
- return retval;
- }
-
- unsigned m_start_state;
- unsigned m_end_state;
-
- std::map<unsigned, std::map<char, unsigned> > transition_map;
- std::map<unsigned, std::set<unsigned> > epsilon_map;
-
- void make_transition(unsigned start, char symbol, unsigned end) {
- transition_map[start][symbol] = end;
- }
-
- void make_epsilon_move(unsigned start, unsigned end) {
- epsilon_map[start].insert(end);
- }
-
- // Convert a regular expression to an e-NFA using Thompson's construction
- void convert_re(expr * e, unsigned & start, unsigned & end, str_util & m_strutil);
-
-public:
- nfa(str_util & m_strutil, expr * e)
-: m_valid(true), m_next_id(0), m_start_state(0), m_end_state(0) {
- convert_re(e, m_start_state, m_end_state, m_strutil);
- }
-
- nfa() : m_valid(false), m_next_id(0), m_start_state(0), m_end_state(0) {}
-
- bool is_valid() const {
- return m_valid;
- }
-
- void epsilon_closure(unsigned start, std::set<unsigned> & closure);
-
- bool matches(std::string input);
-};
-
-#endif /* disable */
diff --git a/src/ast/str_decl_plugin.cpp b/src/ast/str_decl_plugin.cpp
deleted file mode 100644
index 067420f04..000000000
--- a/src/ast/str_decl_plugin.cpp
+++ /dev/null
@@ -1,501 +0,0 @@
-/*++
-Module Name:
-
- str_decl_plugin.h
-
-Abstract:
-
- <abstract>
-
-Author:
-
- Murphy Berzish (mtrberzi) 2015-09-02.
-
-Revision History:
-
---*/
-
-#if 0
-
-#include<sstream>
-#include"str_decl_plugin.h"
-#include"string_buffer.h"
-#include"warning.h"
-#include"ast_pp.h"
-#include"ast_smt2_pp.h"
-
-str_decl_plugin::str_decl_plugin():
- m_strv_sym("String"),
- m_str_decl(0),
- m_regex_decl(0),
- m_concat_decl(0),
- m_length_decl(0),
- m_charat_decl(0),
- m_startswith_decl(0),
- m_endswith_decl(0),
- m_contains_decl(0),
- m_indexof_decl(0),
- m_indexof2_decl(0),
- m_lastindexof_decl(0),
- m_substr_decl(0),
- m_replace_decl(0),
- m_str2int_decl(0),
- m_int2str_decl(0),
- m_prefixof_decl(0),
- m_suffixof_decl(0),
- m_re_str2regex_decl(0),
- m_re_regexin_decl(0),
- m_re_regexconcat_decl(0),
- m_re_regexstar_decl(0),
- m_re_regexunion_decl(0),
- m_re_unroll_decl(0),
- m_re_regexplus_decl(0),
- m_re_regexcharrange_decl(0),
- m_arith_plugin(0),
- m_arith_fid(0),
- m_int_sort(0){
-}
-
-str_decl_plugin::~str_decl_plugin(){
-}
-
-void str_decl_plugin::finalize(void) {
- #define DEC_REF(decl) if (decl) { m_manager->dec_ref(decl); } ((void) 0)
- DEC_REF(m_str_decl);
- DEC_REF(m_regex_decl);
- DEC_REF(m_concat_decl);
- DEC_REF(m_length_decl);
- DEC_REF(m_charat_decl);
- DEC_REF(m_startswith_decl);
- DEC_REF(m_endswith_decl);
- DEC_REF(m_contains_decl);
- DEC_REF(m_indexof_decl);
- DEC_REF(m_indexof2_decl);
- DEC_REF(m_lastindexof_decl);
- DEC_REF(m_substr_decl);
- DEC_REF(m_replace_decl);
- DEC_REF(m_prefixof_decl);
- DEC_REF(m_suffixof_decl);
- DEC_REF(m_str2int_decl);
- DEC_REF(m_int2str_decl);
- DEC_REF(m_re_str2regex_decl);
- DEC_REF(m_re_regexin_decl);
- DEC_REF(m_re_regexconcat_decl);
- DEC_REF(m_re_regexstar_decl);
- DEC_REF(m_re_regexunion_decl);
- DEC_REF(m_re_regexplus_decl);
- DEC_REF(m_re_regexcharrange_decl);
- DEC_REF(m_re_unroll_decl);
- DEC_REF(m_int_sort);
-}
-
-void str_decl_plugin::set_manager(ast_manager * m, family_id id) {
- decl_plugin::set_manager(m, id);
- m_str_decl = m->mk_sort(symbol("String"), sort_info(id, STRING_SORT));
- m->inc_ref(m_str_decl);
- sort * s = m_str_decl;
-
- m_regex_decl = m->mk_sort(symbol("Regex"), sort_info(id, REGEX_SORT));
- m->inc_ref(m_regex_decl);
- sort * re = m_regex_decl;
-
- SASSERT(m_manager->has_plugin(symbol("arith")));
- m_arith_fid = m_manager->mk_family_id("arith");
- m_arith_plugin = static_cast<arith_decl_plugin*>(m_manager->get_plugin(m_arith_fid));
- SASSERT(m_arith_plugin);
-
- m_int_sort = m_manager->mk_sort(m_arith_fid, INT_SORT);
- SASSERT(m_int_sort != 0); // arith_decl_plugin must be installed before str_decl_plugin.
- m_manager->inc_ref(m_int_sort);
- sort * i = m_int_sort;
-
- sort* boolT = m_manager->mk_bool_sort();
-
-#define MK_OP(FIELD, NAME, KIND, SORT) \
- FIELD = m->mk_func_decl(symbol(NAME), SORT, SORT, SORT, func_decl_info(id, KIND)); \
- m->inc_ref(FIELD)
-
- MK_OP(m_concat_decl, "str.++", OP_STRCAT, s);
-
- m_length_decl = m->mk_func_decl(symbol("str.len"), s, i, func_decl_info(id, OP_STRLEN));
- m_manager->inc_ref(m_length_decl);
-
- m_charat_decl = m->mk_func_decl(symbol("str.at"), s, i, s, func_decl_info(id, OP_STR_CHARAT));
- m_manager->inc_ref(m_charat_decl);
-
- m_startswith_decl = m->mk_func_decl(symbol("StartsWith"), s, s, boolT, func_decl_info(id, OP_STR_STARTSWITH));
- m_manager->inc_ref(m_startswith_decl);
-
- m_endswith_decl = m->mk_func_decl(symbol("EndsWith"), s, s, boolT, func_decl_info(id, OP_STR_ENDSWITH));
- m_manager->inc_ref(m_endswith_decl);
-
- m_contains_decl = m->mk_func_decl(symbol("str.contains"), s, s, boolT, func_decl_info(id, OP_STR_CONTAINS));
- m_manager->inc_ref(m_contains_decl);
-
- m_indexof_decl = m->mk_func_decl(symbol("str.indexof"), s, s, i, func_decl_info(id, OP_STR_INDEXOF));
- m_manager->inc_ref(m_indexof_decl);
-
- {
- sort * d[3] = { s, s, i };
- m_indexof2_decl = m->mk_func_decl(symbol("Indexof2"), 3, d, i, func_decl_info(id, OP_STR_INDEXOF2));
- m_manager->inc_ref(m_indexof2_decl);
- }
-
- m_lastindexof_decl = m->mk_func_decl(symbol("str.lastindexof"), s, s, i, func_decl_info(id, OP_STR_LASTINDEXOF));
- m_manager->inc_ref(m_lastindexof_decl);
-
- {
- sort * d[3] = {s, i, i };
- m_substr_decl = m->mk_func_decl(symbol("str.substr"), 3, d, s, func_decl_info(id, OP_STR_SUBSTR));
- m_manager->inc_ref(m_substr_decl);
- }
-
- {
- sort * d[3] = {s, s, s};
- m_replace_decl = m->mk_func_decl(symbol("str.replace"), 3, d, s, func_decl_info(id, OP_STR_REPLACE));
- m_manager->inc_ref(m_replace_decl);
- }
-
- m_prefixof_decl = m->mk_func_decl(symbol("str.prefixof"), s, s, boolT, func_decl_info(id, OP_STR_PREFIXOF));
- m_manager->inc_ref(m_prefixof_decl);
-
- m_suffixof_decl = m->mk_func_decl(symbol("str.suffixof"), s, s, boolT, func_decl_info(id, OP_STR_SUFFIXOF));
- m_manager->inc_ref(m_suffixof_decl);
-
- m_str2int_decl = m->mk_func_decl(symbol("str.to-int"), s, i, func_decl_info(id, OP_STR_STR2INT));
- m_manager->inc_ref(m_str2int_decl);
-
- m_int2str_decl = m->mk_func_decl(symbol("str.from-int"), i, s, func_decl_info(id, OP_STR_INT2STR));
- m_manager->inc_ref(m_int2str_decl);
-
- m_re_str2regex_decl = m->mk_func_decl(symbol("str.to.re"), s, re, func_decl_info(id, OP_RE_STR2REGEX));
- m_manager->inc_ref(m_re_str2regex_decl);
-
- m_re_regexin_decl = m->mk_func_decl(symbol("str.in.re"), s, re, boolT, func_decl_info(id, OP_RE_REGEXIN));
- m_manager->inc_ref(m_re_regexin_decl);
-
- m_re_regexconcat_decl = m->mk_func_decl(symbol("re.++"), re, re, re, func_decl_info(id, OP_RE_REGEXCONCAT));
- m_manager->inc_ref(m_re_regexconcat_decl);
-
- m_re_regexstar_decl = m->mk_func_decl(symbol("re.*"), re, re, func_decl_info(id, OP_RE_REGEXSTAR));
- m_manager->inc_ref(m_re_regexstar_decl);
-
- m_re_regexplus_decl = m->mk_func_decl(symbol("re.+"), re, re, func_decl_info(id, OP_RE_REGEXPLUS));
- m_manager->inc_ref(m_re_regexplus_decl);
-
- m_re_regexunion_decl = m->mk_func_decl(symbol("re.union"), re, re, re, func_decl_info(id, OP_RE_REGEXUNION));
- m_manager->inc_ref(m_re_regexunion_decl);
-
- m_re_unroll_decl = m->mk_func_decl(symbol("Unroll"), re, i, s, func_decl_info(id, OP_RE_UNROLL));
- m_manager->inc_ref(m_re_unroll_decl);
-
- m_re_regexcharrange_decl = m->mk_func_decl(symbol("re.range"), s, s, re, func_decl_info(id, OP_RE_REGEXCHARRANGE));
- m_manager->inc_ref(m_re_regexcharrange_decl);
-
-}
-
-decl_plugin * str_decl_plugin::mk_fresh() {
- return alloc(str_decl_plugin);
-}
-
-sort * str_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) {
- switch (k) {
- case STRING_SORT: return m_str_decl;
- case REGEX_SORT: return m_regex_decl;
- default: return 0;
- }
-}
-
-func_decl * str_decl_plugin::mk_func_decl(decl_kind k) {
- switch(k) {
- case OP_STRCAT: return m_concat_decl;
- case OP_STRLEN: return m_length_decl;
- case OP_STR_CHARAT: return m_charat_decl;
- case OP_STR_STARTSWITH: return m_startswith_decl;
- case OP_STR_ENDSWITH: return m_endswith_decl;
- case OP_STR_CONTAINS: return m_contains_decl;
- case OP_STR_INDEXOF: return m_indexof_decl;
- case OP_STR_INDEXOF2: return m_indexof2_decl;
- case OP_STR_LASTINDEXOF: return m_lastindexof_decl;
- case OP_STR_SUBSTR: return m_substr_decl;
- case OP_STR_REPLACE: return m_replace_decl;
- case OP_STR_PREFIXOF: return m_prefixof_decl;
- case OP_STR_SUFFIXOF: return m_suffixof_decl;
- case OP_STR_STR2INT: return m_str2int_decl;
- case OP_STR_INT2STR: return m_int2str_decl;
- case OP_RE_STR2REGEX: return m_re_str2regex_decl;
- case OP_RE_REGEXIN: return m_re_regexin_decl;
- case OP_RE_REGEXCONCAT: return m_re_regexconcat_decl;
- case OP_RE_REGEXSTAR: return m_re_regexstar_decl;
- case OP_RE_REGEXPLUS: return m_re_regexplus_decl;
- case OP_RE_REGEXUNION: return m_re_regexunion_decl;
- case OP_RE_UNROLL: return m_re_unroll_decl;
- case OP_RE_REGEXCHARRANGE: return m_re_regexcharrange_decl;
- default: return 0;
- }
-}
-
-func_decl * str_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
- unsigned arity, sort * const * domain, sort * range) {
- if (k == OP_STR) {
- m_manager->raise_exception("OP_STR not yet implemented in mk_func_decl!");
- return 0;
- }
- if (arity == 0) {
- m_manager->raise_exception("no arguments supplied to string operator");
- return 0;
- }
- return mk_func_decl(k);
-}
-
-app * str_decl_plugin::mk_string(std::string & val) {
- std::map<std::string, app*>::iterator it = string_cache.find(val);
- //if (it == string_cache.end()) {
- if (true) {
- char * new_buffer = alloc_svect(char, (val.length() + 1));
- strcpy(new_buffer, val.c_str());
- parameter p[1] = {parameter(new_buffer)};
- func_decl * d;
- d = m_manager->mk_const_decl(m_strv_sym, m_str_decl, func_decl_info(m_family_id, OP_STR, 1, p));
- app * str = m_manager->mk_const(d);
- string_cache[val] = str;
- return str;
- } else {
- return it->second;
- }
-}
-
-app * str_decl_plugin::mk_string(const char * val) {
- std::string key(val);
- return mk_string(key);
-}
-
-app * str_decl_plugin::mk_fresh_string() {
- // cheating.
- // take the longest string in the cache, append the letter "A", and call it fresh.
- std::string longestString = "";
- std::map<std::string, app*>::iterator it = string_cache.begin();
- for (; it != string_cache.end(); ++it) {
- if (it->first.length() > longestString.length()) {
- longestString = it->first;
- }
- }
- longestString += "A";
- return mk_string(longestString);
-}
-
-void str_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol const & logic) {
- op_names.push_back(builtin_name("str.++", OP_STRCAT));
- op_names.push_back(builtin_name("str.len", OP_STRLEN));
- op_names.push_back(builtin_name("str.at", OP_STR_CHARAT));
- op_names.push_back(builtin_name("StartsWith", OP_STR_STARTSWITH));
- op_names.push_back(builtin_name("EndsWith", OP_STR_ENDSWITH));
- op_names.push_back(builtin_name("str.contains", OP_STR_CONTAINS));
- op_names.push_back(builtin_name("str.indexof", OP_STR_INDEXOF));
- op_names.push_back(builtin_name("Indexof2", OP_STR_INDEXOF2));
- op_names.push_back(builtin_name("str.lastindexof", OP_STR_LASTINDEXOF));
- op_names.push_back(builtin_name("str.substr", OP_STR_SUBSTR));
- op_names.push_back(builtin_name("str.replace", OP_STR_REPLACE));
- op_names.push_back(builtin_name("str.prefixof", OP_STR_PREFIXOF));
- op_names.push_back(builtin_name("str.suffixof", OP_STR_SUFFIXOF));
- op_names.push_back(builtin_name("str.to-int", OP_STR_STR2INT));
- op_names.push_back(builtin_name("str.from-int", OP_STR_INT2STR));
- op_names.push_back(builtin_name("str.to.re", OP_RE_STR2REGEX));
- op_names.push_back(builtin_name("str.in.re", OP_RE_REGEXIN));
- op_names.push_back(builtin_name("re.++", OP_RE_REGEXCONCAT));
- op_names.push_back(builtin_name("re.*", OP_RE_REGEXSTAR));
- op_names.push_back(builtin_name("re.union", OP_RE_REGEXUNION));
- op_names.push_back(builtin_name("re.+", OP_RE_REGEXPLUS));
- op_names.push_back(builtin_name("Unroll", OP_RE_UNROLL));
- op_names.push_back(builtin_name("re.range", OP_RE_REGEXCHARRANGE));
-}
-
-void str_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
- sort_names.push_back(builtin_name("String", STRING_SORT));
- sort_names.push_back(builtin_name("Regex", REGEX_SORT));
-}
-
-bool str_decl_plugin::is_value(app * e) const {
- if (e->get_family_id() != m_family_id) {
- return false;
- }
- switch (e->get_decl_kind()) {
- case OP_STR:
- return true;
- default:
- return false;
- }
-}
-
-bool str_recognizers::is_string(expr const * n, const char ** val) const {
- if (!is_app_of(n, m_afid, OP_STR))
- return false;
- func_decl * decl = to_app(n)->get_decl();
- *val = decl->get_parameter(0).get_string();
- return true;
-}
-
-bool str_recognizers::is_string(expr const * n) const {
- const char * tmp = 0;
- return is_string(n, & tmp);
-}
-
-std::string str_recognizers::get_string_constant_value(expr const *n) const {
- const char * cstr = 0;
- bool isString = is_string(n, & cstr);
- SASSERT(isString);
- std::string strval(cstr);
- return strval;
-}
-
-str_util::str_util(ast_manager &m) :
- str_recognizers(m.mk_family_id(symbol("str"))),
- m_manager(m) {
- SASSERT(m.has_plugin(symbol("str")));
- m_plugin = static_cast<str_decl_plugin*>(m.get_plugin(m.mk_family_id(symbol("str"))));
- m_fid = m_plugin->get_family_id();
-}
-
-/*
- * Scan through the string 'val' and interpret each instance of "backslash followed by a character"
- * as a possible escape sequence. Emit all other characters as-is.
- * This exists because the SMT-LIB 2.5 standard does not recognize escape sequences other than "" -> " .
- * The escape sequences recognized are as follows:
- * \a \b \e \f \n \r \t \v \\ : as specified by the C++ standard
- * \ooo : produces the ASCII character corresponding to the octal value "ooo", where each "o" is a
- * single octal digit and between 1 and 3 valid digits are given
- * \xhh : produces the ASCII character corresponding to the hexadecimal value "hh", where each "h" is a
- * single case-insensitive hex digit (0-9A-F) and exactly 2 digits are given
- * \C, for any character C that does not start a legal escape sequence : the backslash is ignored and "C" is produced.
- */
-app * str_util::mk_string_with_escape_characters(std::string & val) {
- std::string parsedStr;
- parsedStr.reserve(val.length());
- for (unsigned i = 0; i < val.length(); ++i) {
- char nextChar = val.at(i);
-
- if (nextChar == '\\') {
- // check escape sequence
- i++;
- if (i >= val.length()) {
- get_manager().raise_exception("invalid escape sequence");
- }
- char escapeChar1 = val.at(i);
- if (escapeChar1 == 'a') {
- parsedStr.push_back('\a');
- } else if (escapeChar1 == 'b') {
- parsedStr.push_back('\b');
- } else if (escapeChar1 == 'e') {
- parsedStr.push_back('\e');
- } else if (escapeChar1 == 'f') {
- parsedStr.push_back('\f');
- } else if (escapeChar1 == 'n') {
- parsedStr.push_back('\n');
- } else if (escapeChar1 == 'r') {
- parsedStr.push_back('\r');
- } else if (escapeChar1 == 't') {
- parsedStr.push_back('\t');
- } else if (escapeChar1 == 'v') {
- parsedStr.push_back('\v');
- } else if (escapeChar1 == '\\') {
- parsedStr.push_back('\\');
- } else if (escapeChar1 == 'x') {
- // hex escape: we expect 'x' to be followed by exactly two hex digits
- // which means that i+2 must be a valid index
- if (i+2 >= val.length()) {
- get_manager().raise_exception("invalid hex escape: \\x must be followed by exactly two hex digits");
- }
- char hexDigitHi = val.at(i+1);
- char hexDigitLo = val.at(i+2);
- i += 2;
- if (!isxdigit((int)hexDigitHi) || !isxdigit((int)hexDigitLo)) {
- get_manager().raise_exception("invalid hex escape: \\x must be followed by exactly two hex digits");
- }
- char tmp[3] = {hexDigitHi, hexDigitLo, '\0'};
- long converted = strtol(tmp, NULL, 16);
- unsigned char convChar = (unsigned char)converted;
- parsedStr.push_back(convChar);
- } else if (escapeChar1 == '0' || escapeChar1 == '1' || escapeChar1 == '2' || escapeChar1 == '3' ||
- escapeChar1 == '4' || escapeChar1 == '5' || escapeChar1 == '6' || escapeChar1 == '7') {
- // octal escape: we expect exactly three octal digits
- // which means that val[i], val[i+1], val[i+2] must all be octal digits
- // and that i+2 must be a valid index
- if (i+2 >= val.length()) {
- get_manager().raise_exception("invalid octal escape: exactly three octal digits required");
- }
- char c2 = escapeChar1;
- char c1 = val.at(i+1);
- char c0 = val.at(i+2);
- i += 2;
-
- if (!isdigit(c2) || !isdigit(c1) || !isdigit(c0)) {
- get_manager().raise_exception("invalid octal escape: exactly three octal digits required");
- }
-
- if (c2 == '8' || c2 == '9' || c1 == '8' || c1 == '9' || c0 == '8' || c0 == '9') {
- get_manager().raise_exception("invalid octal escape: exactly three octal digits required");
- }
-
- char tmp[4] = {c2, c1, c0, '\0'};
- long converted = strtol(tmp, NULL, 8);
- unsigned char convChar = (unsigned char)converted;
- parsedStr.push_back(convChar);
- } else {
- // unrecognized escape sequence -- just emit that character
- parsedStr.push_back(escapeChar1);
- }
- } else {
- parsedStr.push_back(nextChar);
- }
-
- // i is incremented at the end of this loop.
- // If it is modified, ensure that it points to the index before
- // the next character.
- }
- return mk_string(parsedStr);
-}
-
-static std::string str2RegexStr(std::string str) {
- std::string res = "";
- int len = str.size();
- for (int i = 0; i < len; i++) {
- char nc = str[i];
- // 12 special chars
- if (nc == '\\' || nc == '^' || nc == '$' || nc == '.' || nc == '|' || nc == '?'
- || nc == '*' || nc == '+' || nc == '(' || nc == ')' || nc == '[' || nc == '{') {
- res.append(1, '\\');
- }
- res.append(1, str[i]);
- }
- return res;
-}
-
-std::string str_util::get_std_regex_str(expr * regex) {
- app * a_regex = to_app(regex);
- if (is_re_Str2Reg(a_regex)) {
- expr * regAst = a_regex->get_arg(0);
- std::string regStr = str2RegexStr(get_string_constant_value(regAst));
- return regStr;
- } else if (is_re_RegexConcat(a_regex)) {
- expr * reg1Ast = a_regex->get_arg(0);
- expr * reg2Ast = a_regex->get_arg(1);
- std::string reg1Str = get_std_regex_str(reg1Ast);
- std::string reg2Str = get_std_regex_str(reg2Ast);
- return "(" + reg1Str + ")(" + reg2Str + ")";
- } else if (is_re_RegexUnion(a_regex)) {
- expr * reg1Ast = a_regex->get_arg(0);
- expr * reg2Ast = a_regex->get_arg(1);
- std::string reg1Str = get_std_regex_str(reg1Ast);
- std::string reg2Str = get_std_regex_str(reg2Ast);
- return "(" + reg1Str + ")|(" + reg2Str + ")";
- } else if (is_re_RegexStar(a_regex)) {
- expr * reg1Ast = a_regex->get_arg(0);
- std::string reg1Str = get_std_regex_str(reg1Ast);
- return "(" + reg1Str + ")*";
- } else {
- TRACE("t_str", tout << "BUG: unrecognized regex term " << mk_pp(regex, get_manager()) << std::endl;);
- UNREACHABLE(); return "";
- }
-}
-
-#endif /* disable */
diff --git a/src/ast/str_decl_plugin.h b/src/ast/str_decl_plugin.h
deleted file mode 100644
index 28ecd1e43..000000000
--- a/src/ast/str_decl_plugin.h
+++ /dev/null
@@ -1,218 +0,0 @@
-/*++
-Module Name:
-
- str_decl_plugin.h
-
-Abstract:
-
- <abstract>
-
-Author:
-
- Murphy Berzish (mtrberzi) 2015-09-02.
-
-Revision History:
-
---*/
-
-#if 0
-
-#ifndef _STR_DECL_PLUGIN_H_
-#define _STR_DECL_PLUGIN_H_
-
-#include"ast.h"
-#include"arith_decl_plugin.h"
-#include<map>
-
-enum str_sort_kind {
- STRING_SORT,
- REGEX_SORT,
-};
-
-enum str_op_kind {
- OP_STR, /* string constants */
- // basic string operators
- OP_STRCAT,
- OP_STRLEN,
- // higher-level string functions -- these are reduced to basic operations
- OP_STR_CHARAT,
- OP_STR_STARTSWITH,
- OP_STR_ENDSWITH,
- OP_STR_CONTAINS,
- OP_STR_INDEXOF,
- OP_STR_INDEXOF2,
- OP_STR_LASTINDEXOF,
- OP_STR_SUBSTR,
- OP_STR_REPLACE,
- // SMT-LIB 2.5 standard operators -- these are rewritten to internal ones
- OP_STR_PREFIXOF,
- OP_STR_SUFFIXOF,
- // string-integer conversion
- OP_STR_STR2INT,
- OP_STR_INT2STR, OP_STR_PLACEHOLDER1, OP_STR_PLACEHOLDER2,
- // regular expression operators
- OP_RE_STR2REGEX,
- OP_RE_REGEXIN,
- OP_RE_REGEXCONCAT,
- OP_RE_REGEXSTAR,
- OP_RE_REGEXUNION,
- OP_RE_UNROLL,
- // higher-level regex operators
- OP_RE_REGEXPLUS,
- OP_RE_REGEXCHARRANGE,
- // end
- LAST_STR_OP
-};
-
-class str_decl_plugin : public decl_plugin {
-protected:
- symbol m_strv_sym;
- sort * m_str_decl;
- sort * m_regex_decl;
-
- func_decl * m_concat_decl;
- func_decl * m_length_decl;
-
- func_decl * m_charat_decl;
- func_decl * m_startswith_decl;
- func_decl * m_endswith_decl;
- func_decl * m_contains_decl;
- func_decl * m_indexof_decl;
- func_decl * m_indexof2_decl;
- func_decl * m_lastindexof_decl;
- func_decl * m_substr_decl;
- func_decl * m_replace_decl;
- func_decl * m_str2int_decl;
- func_decl * m_int2str_decl;
- func_decl * m_prefixof_decl;
- func_decl * m_suffixof_decl;
-
- func_decl * m_re_str2regex_decl;
- func_decl * m_re_regexin_decl;
- func_decl * m_re_regexconcat_decl;
- func_decl * m_re_regexstar_decl;
- func_decl * m_re_regexunion_decl;
- func_decl * m_re_unroll_decl;
- func_decl * m_re_regexplus_decl;
- func_decl * m_re_regexcharrange_decl;
-
- arith_decl_plugin * m_arith_plugin;
- family_id m_arith_fid;
- sort * m_int_sort;
-
- std::map<std::string, app*> string_cache;
-
- virtual void set_manager(ast_manager * m, family_id id);
-
- func_decl * mk_func_decl(decl_kind k);
-public:
- str_decl_plugin();
- virtual ~str_decl_plugin();
- virtual void finalize();
-
- virtual decl_plugin * mk_fresh();
- virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
- virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
- unsigned arity, sort * const * domain, sort * range);
-
- app * mk_string(const char * val);
- app * mk_string(std::string & val);
- app * mk_fresh_string();
-
- virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
- virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
-
- virtual bool is_value(app * e) const;
- virtual bool is_unique_value(app * e) const { return is_value(e); }
-};
-
-class str_recognizers {
- family_id m_afid;
-public:
- str_recognizers(family_id fid):m_afid(fid) {}
- family_id get_fid() const { return m_afid; }
- family_id get_family_id() const { return get_fid(); }
-
- bool is_str_sort(sort* s) const { return is_sort_of(s, m_afid, STRING_SORT); }
-
- bool is_string(expr const * n, const char ** val) const;
- bool is_string(expr const * n) const;
-
- bool is_re_Str2Reg(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_STR2REGEX); }
- bool is_re_RegexConcat(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_REGEXCONCAT); }
- bool is_re_RegexUnion(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_REGEXUNION); }
- bool is_re_RegexStar(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_REGEXSTAR); }
- bool is_re_RegexPlus(expr const * n) const { return is_app_of(n, get_fid(), OP_RE_REGEXPLUS); }
-
- std::string get_string_constant_value(expr const *n) const;
-};
-
-class str_util : public str_recognizers {
- ast_manager & m_manager;
- str_decl_plugin * m_plugin;
- family_id m_fid;
-public:
- str_util(ast_manager & m);
- ast_manager & get_manager() const { return m_manager; }
- str_decl_plugin & plugin() { return *m_plugin; }
-
- sort* mk_string_sort() const { return get_manager().mk_sort(m_fid, STRING_SORT, 0, 0); }
-
- app * mk_string(const char * val) {
- return m_plugin->mk_string(val);
- }
- app * mk_string(std::string & val) {
- return m_plugin->mk_string(val);
- }
-
- app * mk_fresh_string() {
- return m_plugin->mk_fresh_string();
- }
-
- app * mk_string_with_escape_characters(const char * val) {
- std::string str(val);
- return mk_string_with_escape_characters(str);
- }
- app * mk_string_with_escape_characters(std::string & val);
-
- app * mk_str_StartsWith(expr * haystack, expr * needle) {
- expr * es[2] = {haystack, needle};
- return m_manager.mk_app(get_fid(), OP_STR_STARTSWITH, 2, es);
- }
-
- app * mk_str_EndsWith(expr * haystack, expr * needle) {
- expr * es[2] = {haystack, needle};
- return m_manager.mk_app(get_fid(), OP_STR_ENDSWITH, 2, es);
- }
-
- app * mk_re_Str2Reg(expr * s) {
- expr * es[1] = {s};
- return m_manager.mk_app(get_fid(), OP_RE_STR2REGEX, 1, es);
- }
-
- app * mk_re_Str2Reg(std::string s) {
- return mk_re_Str2Reg(mk_string(s));
- }
-
- app * mk_re_RegexUnion(expr * e1, expr * e2) {
- expr * es[2] = {e1, e2};
- return m_manager.mk_app(get_fid(), OP_RE_REGEXUNION, 2, es);
- }
-
- app * mk_re_RegexConcat(expr * e1, expr * e2) {
- expr * es[2] = {e1, e2};
- return m_manager.mk_app(get_fid(), OP_RE_REGEXCONCAT, 2, es);
- }
-
- app * mk_re_RegexStar(expr * r) {
- expr * es[1] = {r};
- return m_manager.mk_app(get_fid(), OP_RE_REGEXSTAR, 1, es);
- }
-
- std::string get_std_regex_str(expr * regex);
-
-};
-
-#endif /* _STR_DECL_PLUGIN_H_ */
-
-#endif /* disable */
From 43f9a0a2bdf3d9be5a5deae97d35b590e010726c Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 17 Mar 2017 13:48:30 -0400
Subject: [PATCH 363/401] fix unterminated char*
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 0554ae2c2..ff32e6f38 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1642,7 +1642,7 @@ static zstring str2RegexStr(zstring str) {
|| nc == '*' || nc == '+' || nc == '(' || nc == ')' || nc == '[' || nc == '{') {
res = res + zstring("\\");
}
- char tmp[1] = {(char)str[i]};
+ char tmp[2] = {(char)str[i], '\0'};
res = res + zstring(tmp);
}
return res;
From 19de682b58901a17c5be8e13fcbee508ff667ae2 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 4 Apr 2017 17:22:55 -0400
Subject: [PATCH 364/401] remove references to m_str_fid in api
---
src/api/api_context.h | 2 --
1 file changed, 2 deletions(-)
diff --git a/src/api/api_context.h b/src/api/api_context.h
index 6e34f6d6e..4685fd04e 100644
--- a/src/api/api_context.h
+++ b/src/api/api_context.h
@@ -82,7 +82,6 @@ namespace api {
family_id m_pb_fid;
family_id m_fpa_fid;
family_id m_seq_fid;
- family_id m_str_fid;
datatype_decl_plugin * m_dt_plugin;
std::string m_string_buffer; // temporary buffer used to cache strings sent to the "external" world.
@@ -136,7 +135,6 @@ namespace api {
family_id get_pb_fid() const { return m_pb_fid; }
family_id get_fpa_fid() const { return m_fpa_fid; }
family_id get_seq_fid() const { return m_seq_fid; }
- family_id get_str_fid() const { return m_str_fid; }
datatype_decl_plugin * get_dt_plugin() const { return m_dt_plugin; }
Z3_error_code get_error_code() const { return m_error_code; }
From f881e854702972d99ca611ea74bd2255222880dd Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 4 Apr 2017 17:54:18 -0400
Subject: [PATCH 365/401] remove old theory_str enums from api
---
src/api/z3_api.h | 4 ----
1 file changed, 4 deletions(-)
diff --git a/src/api/z3_api.h b/src/api/z3_api.h
index 23d04f0be..272c94dda 100644
--- a/src/api/z3_api.h
+++ b/src/api/z3_api.h
@@ -1169,10 +1169,6 @@ typedef enum {
Z3_OP_RE_FULL_SET,
Z3_OP_RE_COMPLEMENT,
- // theory_str
- Z3_OP_STR_CONCAT,
- Z3_OP_STR_LENGTH,
-
// Auxiliary
Z3_OP_LABEL = 0x700,
Z3_OP_LABEL_LIT,
From eef2bbadad9dd51a7c9ea0ded1a986dd7e0ba04a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 4 Apr 2017 20:29:48 -0400
Subject: [PATCH 366/401] remove obsolete PARAM_STRING from ast
---
src/ast/ast.cpp | 4 ----
src/ast/ast.h | 9 ++-------
2 files changed, 2 insertions(+), 11 deletions(-)
diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp
index 7271048b1..5f2de5170 100644
--- a/src/ast/ast.cpp
+++ b/src/ast/ast.cpp
@@ -59,7 +59,6 @@ parameter& parameter::operator=(parameter const& other) {
case PARAM_SYMBOL: new (m_symbol) symbol(other.get_symbol()); break;
case PARAM_RATIONAL: new (m_rational) rational(other.get_rational()); break;
case PARAM_DOUBLE: m_dval = other.m_dval; break;
- case PARAM_STRING: m_string = other.m_string; break;
case PARAM_EXTERNAL: m_ext_id = other.m_ext_id; break;
default:
UNREACHABLE();
@@ -95,7 +94,6 @@ bool parameter::operator==(parameter const & p) const {
case PARAM_SYMBOL: return get_symbol() == p.get_symbol();
case PARAM_RATIONAL: return get_rational() == p.get_rational();
case PARAM_DOUBLE: return m_dval == p.m_dval;
- case PARAM_STRING: return (m_string == NULL && p.m_string == NULL) || strcmp(m_string, p.m_string)==0;
case PARAM_EXTERNAL: return m_ext_id == p.m_ext_id;
default: UNREACHABLE(); return false;
}
@@ -109,7 +107,6 @@ unsigned parameter::hash() const {
case PARAM_SYMBOL: b = get_symbol().hash(); break;
case PARAM_RATIONAL: b = get_rational().hash(); break;
case PARAM_DOUBLE: b = static_cast<unsigned>(m_dval); break;
- case PARAM_STRING: /* TODO */ b = 42; break;
case PARAM_EXTERNAL: b = m_ext_id; break;
}
return (b << 2) | m_kind;
@@ -122,7 +119,6 @@ std::ostream& parameter::display(std::ostream& out) const {
case PARAM_RATIONAL: return out << get_rational();
case PARAM_AST: return out << "#" << get_ast()->get_id();
case PARAM_DOUBLE: return out << m_dval;
- case PARAM_STRING: return out << m_string;
case PARAM_EXTERNAL: return out << "@" << m_ext_id;
default:
UNREACHABLE();
diff --git a/src/ast/ast.h b/src/ast/ast.h
index 066265bb8..6bb3b01c9 100644
--- a/src/ast/ast.h
+++ b/src/ast/ast.h
@@ -87,7 +87,6 @@ public:
PARAM_SYMBOL,
PARAM_RATIONAL,
PARAM_DOUBLE,
- PARAM_STRING,
// PARAM_EXTERNAL is used for handling decl_plugin specific parameters.
// For example, it is used for handling mpf numbers in float_decl_plugin,
// and irrational algebraic numbers in arith_decl_plugin.
@@ -106,7 +105,6 @@ private:
char m_symbol[sizeof(symbol)]; // for PARAM_SYMBOL
char m_rational[sizeof(rational)]; // for PARAM_RATIONAL
double m_dval; // for PARAM_DOUBLE (remark: this is not used in float_decl_plugin)
- const char* m_string; // for PARAM_STRING
unsigned m_ext_id; // for PARAM_EXTERNAL
};
@@ -119,8 +117,8 @@ public:
explicit parameter(symbol const & s): m_kind(PARAM_SYMBOL) { new (m_symbol) symbol(s); }
explicit parameter(rational const & r): m_kind(PARAM_RATIONAL) { new (m_rational) rational(r); }
explicit parameter(double d):m_kind(PARAM_DOUBLE), m_dval(d) {}
- explicit parameter(const char *s):m_kind(PARAM_STRING), m_string(s) {
- TRACE("parse_string", tout << "parameter(const char *): " << s << "\n";);
+ explicit parameter(const char *s):m_kind(PARAM_SYMBOL) {
+ new (m_symbol) symbol(s);
}
explicit parameter(unsigned ext_id, bool):m_kind(PARAM_EXTERNAL), m_ext_id(ext_id) {}
parameter(parameter const&);
@@ -135,7 +133,6 @@ public:
bool is_symbol() const { return m_kind == PARAM_SYMBOL; }
bool is_rational() const { return m_kind == PARAM_RATIONAL; }
bool is_double() const { return m_kind == PARAM_DOUBLE; }
- bool is_string() const { return m_kind == PARAM_STRING; }
bool is_external() const { return m_kind == PARAM_EXTERNAL; }
bool is_int(int & i) const { return is_int() && (i = get_int(), true); }
@@ -143,7 +140,6 @@ public:
bool is_symbol(symbol & s) const { return is_symbol() && (s = get_symbol(), true); }
bool is_rational(rational & r) const { return is_rational() && (r = get_rational(), true); }
bool is_double(double & d) const { return is_double() && (d = get_double(), true); }
- // TODO is_string(char*)
bool is_external(unsigned & id) const { return is_external() && (id = get_ext_id(), true); }
/**
@@ -163,7 +159,6 @@ public:
symbol const & get_symbol() const { SASSERT(is_symbol()); return *(reinterpret_cast<const symbol *>(m_symbol)); }
rational const & get_rational() const { SASSERT(is_rational()); return *(reinterpret_cast<const rational *>(m_rational)); }
double get_double() const { SASSERT(is_double()); return m_dval; }
- const char * get_string() const { SASSERT(is_string()); return m_string; }
unsigned get_ext_id() const { SASSERT(is_external()); return m_ext_id; }
bool operator==(parameter const & p) const;
From 7207cabc9710d7b13b4b91ce8e2f4f4bbbcc6767 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 12 Apr 2017 17:09:35 -0400
Subject: [PATCH 367/401] experimental new unsat core based overlap detection
---
src/smt/smt_context.cpp | 61 ++++++++++++++++++++++++++++++++---------
src/smt/smt_context.h | 20 ++++++++++++++
src/smt/smt_setup.cpp | 2 ++
src/smt/theory_str.cpp | 12 ++++++++
src/smt/theory_str.h | 1 -
5 files changed, 82 insertions(+), 14 deletions(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 4fd027031..dfe396f2b 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -37,7 +37,7 @@ Revision History:
#include"model_pp.h"
#include"ast_smt2_pp.h"
#include"ast_translation.h"
-#include"theory_str.h"
+#include"theory_seq.h"
namespace smt {
@@ -76,6 +76,8 @@ namespace smt {
m_unsat_proof(m),
m_unknown("unknown"),
m_unsat_core(m),
+ m_use_theory_str_overlap_assumption(false),
+ m_theoryStrOverlapAssumption_term(m_manager),
#ifdef Z3DEBUG
m_trail_enabled(true),
#endif
@@ -3269,21 +3271,38 @@ namespace smt {
// PATCH for theory_str:
// UNSAT + overlapping variables => UNKNOWN
- if (r == l_false) {
- ptr_vector<theory>::iterator it = m_theory_set.begin();
- ptr_vector<theory>::iterator end = m_theory_set.end();
- for (; it != end; ++it) {
- theory * th = *it;
- if (strcmp(th->get_name(), "strings") == 0) {
- theory_str * str = (theory_str*)th;
- if (str->overlapping_variables_detected()) {
- TRACE("t_str", tout << "WARNING: overlapping variables detected, UNSAT changed to UNKNOWN!" << std::endl;);
- TRACE("context", tout << "WARNING: overlapping variables detected in theory_str. UNSAT changed to UNKNOWN!" << std::endl;);
- r = l_undef;
- }
+ if (r == l_false && use_theory_str_overlap_assumption()) {
+ // check the unsat core for an assumption from theory_str relating to overlaps.
+ // if we find this assumption, we have to answer UNKNOWN
+ // otherwise, we can pass through UNSAT
+ TRACE("t_str", tout << "unsat core:\n";
+ unsigned sz = m_unsat_core.size();
+ for (unsigned i = 0; i < sz; i++) {
+ tout << mk_pp(m_unsat_core.get(i), m_manager) << "\n";
+ });
+
+ bool assumptionFound = false;
+ unsigned sz = m_unsat_core.size();
+ app * target_term = to_app(m_manager.mk_not(m_theoryStrOverlapAssumption_term));
+ internalize_term(target_term);
+ for (unsigned i = 0; i < sz; ++i) {
+ app * core_term = to_app(m_unsat_core.get(i));
+ // not sure if this is the correct way to compare exprs in this context
+ enode * e1;
+ enode * e2;
+ e1 = get_enode(target_term);
+ e2 = get_enode(core_term);
+ if (e1 == e2) {
+ // found match
+ TRACE("t_str", tout << "overlap detected in unsat core; changing UNSAT to UNKNOWN" << std::endl;);
+ assumptionFound = true;
+ r = l_undef;
break;
}
}
+ if (!assumptionFound) {
+ TRACE("t_str", tout << "no overlaps detected in unsat core, answering UNSAT" << std::endl;);
+ }
}
return r;
@@ -3302,6 +3321,22 @@ namespace smt {
SASSERT(m_scope_lvl == 0);
SASSERT(!m_setup.already_configured());
setup_context(m_fparams.m_auto_config);
+
+ // theory_str requires the context to be set up with a special assumption.
+ // we need to wait until after setup_context() to know whether this is the case
+ if (m_use_theory_str_overlap_assumption) {
+ TRACE("t_str", tout << "enabling theory_str overlap assumption" << std::endl;);
+ // TODO maybe refactor this a bit
+ symbol strOverlap("!!TheoryStrOverlapAssumption!!");
+ expr_ref_vector assumption(get_manager());
+ seq_util m_sequtil(m_manager);
+ sort * s = m_manager.mk_bool_sort();
+ m_theoryStrOverlapAssumption_term = expr_ref(m_manager.mk_const(strOverlap, s), m_manager);
+ assumption.push_back(m_manager.mk_not(m_theoryStrOverlapAssumption_term));
+ // this might work, even though we already did a bit of setup
+ return check(assumption.size(), assumption.c_ptr(), reset_cancel);
+ }
+
internalize_assertions();
lbool r = l_undef;
if (m_asserted_formulas.inconsistent()) {
diff --git a/src/smt/smt_context.h b/src/smt/smt_context.h
index 47ed5d671..0cf3f8d68 100644
--- a/src/smt/smt_context.h
+++ b/src/smt/smt_context.h
@@ -226,6 +226,9 @@ namespace smt {
literal2assumption m_literal2assumption; // maps an expression associated with a literal to the original assumption
expr_ref_vector m_unsat_core;
+ // Unsat core assumption hint for theory_str
+ bool m_use_theory_str_overlap_assumption;
+
// -----------------------------------
//
// Theory case split
@@ -846,6 +849,23 @@ namespace smt {
*/
void add_theory_aware_branching_info(bool_var v, double priority, lbool phase);
+ // unsat core assumption hint for theory_str
+ void set_use_theory_str_overlap_assumption(bool f) {
+ m_use_theory_str_overlap_assumption = f;
+ }
+
+ bool use_theory_str_overlap_assumption() const {
+ return m_use_theory_str_overlap_assumption;
+ }
+
+ expr_ref get_theory_str_overlap_assumption_term() {
+ return m_theoryStrOverlapAssumption_term;
+ }
+
+ protected:
+ expr_ref m_theoryStrOverlapAssumption_term;
+ public:
+
// helper function for trail
void undo_th_case_split(literal l);
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index 78a295e27..fdcf33c0e 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -706,6 +706,7 @@ namespace smt {
}
void setup::setup_QF_S() {
+ m_context.set_use_theory_str_overlap_assumption(true);
m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params));
m_context.register_plugin(alloc(smt::theory_str, m_manager, m_params));
}
@@ -841,6 +842,7 @@ namespace smt {
void setup::setup_str() {
setup_arith();
+ m_context.set_use_theory_str_overlap_assumption(true);
m_context.register_plugin(alloc(theory_str, m_manager, m_params));
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index ff32e6f38..b69ebda4c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4304,6 +4304,8 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
add_nonempty_constraint(commonVar);
}
+ bool overlapAssumptionUsed = false;
+
expr_ref_vector arrangement_disjunction(mgr);
int pos = 1;
@@ -4339,6 +4341,12 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
TRACE("t_str", print_cut_var(m, tout); print_cut_var(y, tout););
+
+ // only add the overlap assumption one time
+ if (!overlapAssumptionUsed) {
+ arrangement_disjunction.push_back(ctx.get_theory_str_overlap_assumption_term());
+ overlapAssumptionUsed = true;
+ }
}
}
@@ -7239,6 +7247,9 @@ void theory_str::init_search_eh() {
ast_manager & m = get_manager();
context & ctx = get_context();
+ // safety
+ SASSERT(ctx.use_theory_str_overlap_assumption());
+
TRACE("t_str_detail",
tout << "dumping all asserted formulas:" << std::endl;
unsigned nFormulas = ctx.get_num_asserted_formulas();
@@ -7301,6 +7312,7 @@ void theory_str::new_eq_eh(theory_var x, theory_var y) {
//TRACE("t_str_detail", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
TRACE("t_str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
+
/*
if (m_find.find(x) == m_find.find(y)) {
return;
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 3ea4db7d4..a8857de24 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -389,7 +389,6 @@ namespace smt {
// finite model finding data
// maps a finite model tester var to a list of variables that will be tested
obj_map<expr, ptr_vector<expr> > finite_model_test_varlists;
-
protected:
void assert_axiom(expr * e);
void assert_implication(expr * premise, expr * conclusion);
From a7f72bf4ef1a8c2aeb459accd2779c3f465f915f Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 13 Apr 2017 13:46:23 -0400
Subject: [PATCH 368/401] add overlap assumption to other cases in theory_str
---
src/smt/theory_str.cpp | 49 ++++++++++++++++++++++++++++++++++++++++++
1 file changed, 49 insertions(+)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index b69ebda4c..9d3fef6d7 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -2898,6 +2898,9 @@ bool theory_str::is_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
ast_manager & mgr = get_manager();
context & ctx = get_context();
+
+ bool overlapAssumptionUsed = false;
+
TRACE("t_str_detail", tout << "process_concat_eq TYPE 1" << std::endl
<< "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
@@ -3074,6 +3077,11 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ assert_implication(ax_l, ctx.get_theory_str_overlap_assumption_term());
+ }
}
}
} else if (splitType == 1) {
@@ -3132,6 +3140,11 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ assert_implication(ax_l, ctx.get_theory_str_overlap_assumption_term());
+ }
}
}
} else if (splitType == -1) {
@@ -3183,6 +3196,11 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ arrangement_disjunction.push_back(ctx.get_theory_str_overlap_assumption_term());
+ }
}
}
@@ -3227,6 +3245,11 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
TRACE("t_str_detail", {print_cut_var(x, tout); print_cut_var(n, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ arrangement_disjunction.push_back(ctx.get_theory_str_overlap_assumption_term());
+ }
}
}
@@ -3286,6 +3309,9 @@ bool theory_str::is_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
ast_manager & mgr = get_manager();
context & ctx = get_context();
+
+ bool overlapAssumptionUsed = false;
+
TRACE("t_str_detail", tout << "process_concat_eq TYPE 2" << std::endl
<< "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
@@ -3466,6 +3492,11 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIP" << std::endl;);
TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ assert_implication(ax_l, ctx.get_theory_str_overlap_assumption_term());
+ }
}
}
}
@@ -3567,6 +3598,11 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ arrangement_disjunction.push_back(ctx.get_theory_str_overlap_assumption_term());
+ }
}
}
}
@@ -3636,6 +3672,9 @@ bool theory_str::is_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
ast_manager & mgr = get_manager();
context & ctx = get_context();
+
+ bool overlapAssumptionUsed = false;
+
TRACE("t_str_detail", tout << "process_concat_eq TYPE 3" << std::endl
<< "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
@@ -3861,6 +3900,11 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
TRACE("t_str_detail", {print_cut_var(x, tout); print_cut_var(n, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ assert_implication(ax_l, ctx.get_theory_str_overlap_assumption_term());
+ }
}
}
}
@@ -3940,6 +3984,11 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
} else {
TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
TRACE("t_str_detail", {print_cut_var(x, tout); print_cut_var(n, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ arrangement_disjunction.push_back(ctx.get_theory_str_overlap_assumption_term());
+ }
}
}
}
From bef64961ae985969ca4a02e9d8e11f0aecb49a26 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 18 Apr 2017 13:12:03 -0400
Subject: [PATCH 369/401] add pre-init assumptions for smt theories
---
src/smt/smt_context.cpp | 17 ++++++++++++++++-
src/smt/smt_context.h | 15 ---------------
src/smt/smt_setup.cpp | 2 --
src/smt/smt_theory.h | 7 +++++++
src/smt/theory_str.cpp | 31 +++++++++++++++++++------------
src/smt/theory_str.h | 2 ++
6 files changed, 44 insertions(+), 30 deletions(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index dfe396f2b..db09552ef 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -77,7 +77,6 @@ namespace smt {
m_unknown("unknown"),
m_unsat_core(m),
m_use_theory_str_overlap_assumption(false),
- m_theoryStrOverlapAssumption_term(m_manager),
#ifdef Z3DEBUG
m_trail_enabled(true),
#endif
@@ -3269,6 +3268,7 @@ namespace smt {
r = l_undef;
}
+ /*
// PATCH for theory_str:
// UNSAT + overlapping variables => UNKNOWN
if (r == l_false && use_theory_str_overlap_assumption()) {
@@ -3304,6 +3304,7 @@ namespace smt {
TRACE("t_str", tout << "no overlaps detected in unsat core, answering UNSAT" << std::endl;);
}
}
+ */
return r;
}
@@ -3322,6 +3323,7 @@ namespace smt {
SASSERT(!m_setup.already_configured());
setup_context(m_fparams.m_auto_config);
+ /*
// theory_str requires the context to be set up with a special assumption.
// we need to wait until after setup_context() to know whether this is the case
if (m_use_theory_str_overlap_assumption) {
@@ -3336,6 +3338,19 @@ namespace smt {
// this might work, even though we already did a bit of setup
return check(assumption.size(), assumption.c_ptr(), reset_cancel);
}
+ */
+
+ expr_ref_vector theory_assumptions(m_manager);
+ ptr_vector<theory>::iterator it = m_theory_set.begin();
+ ptr_vector<theory>::iterator end = m_theory_set.end();
+ for (; it != end; ++it) {
+ (*it)->add_theory_assumptions(theory_assumptions);
+ }
+ if (!theory_assumptions.empty()) {
+ TRACE("search", tout << "Adding theory assumptions to context" << std::endl;);
+ // this works even though we already did part of setup
+ return check(theory_assumptions.size(), theory_assumptions.c_ptr(), reset_cancel);
+ }
internalize_assertions();
lbool r = l_undef;
diff --git a/src/smt/smt_context.h b/src/smt/smt_context.h
index 0cf3f8d68..0667f622e 100644
--- a/src/smt/smt_context.h
+++ b/src/smt/smt_context.h
@@ -849,21 +849,6 @@ namespace smt {
*/
void add_theory_aware_branching_info(bool_var v, double priority, lbool phase);
- // unsat core assumption hint for theory_str
- void set_use_theory_str_overlap_assumption(bool f) {
- m_use_theory_str_overlap_assumption = f;
- }
-
- bool use_theory_str_overlap_assumption() const {
- return m_use_theory_str_overlap_assumption;
- }
-
- expr_ref get_theory_str_overlap_assumption_term() {
- return m_theoryStrOverlapAssumption_term;
- }
-
- protected:
- expr_ref m_theoryStrOverlapAssumption_term;
public:
// helper function for trail
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index fdcf33c0e..78a295e27 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -706,7 +706,6 @@ namespace smt {
}
void setup::setup_QF_S() {
- m_context.set_use_theory_str_overlap_assumption(true);
m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params));
m_context.register_plugin(alloc(smt::theory_str, m_manager, m_params));
}
@@ -842,7 +841,6 @@ namespace smt {
void setup::setup_str() {
setup_arith();
- m_context.set_use_theory_str_overlap_assumption(true);
m_context.register_plugin(alloc(theory_str, m_manager, m_params));
}
diff --git a/src/smt/smt_theory.h b/src/smt/smt_theory.h
index cee36535f..e412f2f1b 100644
--- a/src/smt/smt_theory.h
+++ b/src/smt/smt_theory.h
@@ -177,6 +177,13 @@ namespace smt {
virtual void restart_eh() {
}
+ /**
+ \brief This method is called by smt_context before the search starts to get any
+ extra assumptions the theory wants to use. (see theory_str for an example)
+ */
+ virtual void add_theory_assumptions(expr_ref_vector & assumptions) {
+ }
+
/**
\brief This method is invoked before the search starts.
*/
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 9d3fef6d7..354589318 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -56,6 +56,7 @@ theory_str::theory_str(ast_manager & m, theory_str_params const & params):
tmpValTestVarCount(0),
avoidLoopCut(true),
loopDetected(false),
+ m_theoryStrOverlapAssumption_term(m),
contains_map(m),
string_int_conversion_terms(m),
totalCacheAccessCount(0),
@@ -3080,7 +3081,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
- assert_implication(ax_l, ctx.get_theory_str_overlap_assumption_term());
+ assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
}
}
}
@@ -3143,7 +3144,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
- assert_implication(ax_l, ctx.get_theory_str_overlap_assumption_term());
+ assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
}
}
}
@@ -3199,7 +3200,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
- arrangement_disjunction.push_back(ctx.get_theory_str_overlap_assumption_term());
+ arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
}
}
}
@@ -3248,7 +3249,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
- arrangement_disjunction.push_back(ctx.get_theory_str_overlap_assumption_term());
+ arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
}
}
}
@@ -3495,7 +3496,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
- assert_implication(ax_l, ctx.get_theory_str_overlap_assumption_term());
+ assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
}
}
}
@@ -3601,7 +3602,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
- arrangement_disjunction.push_back(ctx.get_theory_str_overlap_assumption_term());
+ arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
}
}
}
@@ -3903,7 +3904,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
- assert_implication(ax_l, ctx.get_theory_str_overlap_assumption_term());
+ assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
}
}
}
@@ -3987,7 +3988,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
- arrangement_disjunction.push_back(ctx.get_theory_str_overlap_assumption_term());
+ arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
}
}
}
@@ -4393,7 +4394,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
// only add the overlap assumption one time
if (!overlapAssumptionUsed) {
- arrangement_disjunction.push_back(ctx.get_theory_str_overlap_assumption_term());
+ arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
overlapAssumptionUsed = true;
}
}
@@ -7292,13 +7293,19 @@ void theory_str::set_up_axioms(expr * ex) {
}
}
+void theory_str::add_theory_assumptions(expr_ref_vector & assumptions) {
+ TRACE("t_str", tout << "add overlap assumption for theory_str" << std::endl;);
+ symbol strOverlap("!!TheoryStrOverlapAssumption!!");
+ seq_util m_sequtil(get_manager());
+ sort * s = get_manager().mk_bool_sort();
+ m_theoryStrOverlapAssumption_term = expr_ref(get_manager().mk_const(strOverlap, s), get_manager());
+ assumptions.push_back(get_manager().mk_not(m_theoryStrOverlapAssumption_term));
+}
+
void theory_str::init_search_eh() {
ast_manager & m = get_manager();
context & ctx = get_context();
- // safety
- SASSERT(ctx.use_theory_str_overlap_assumption());
-
TRACE("t_str_detail",
tout << "dumping all asserted formulas:" << std::endl;
unsigned nFormulas = ctx.get_num_asserted_formulas();
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index a8857de24..3c273d4e2 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -291,6 +291,7 @@ namespace smt {
bool avoidLoopCut;
bool loopDetected;
obj_map<expr, std::stack<T_cut*> > cut_var_map;
+ expr_ref m_theoryStrOverlapAssumption_term;
obj_hashtable<expr> variable_set;
obj_hashtable<expr> internal_variable_set;
@@ -627,6 +628,7 @@ namespace smt {
virtual theory* mk_fresh(context*) { return alloc(theory_str, get_manager(), m_params); }
virtual void init_search_eh();
+ virtual void add_theory_assumptions(expr_ref_vector & assumptions);
virtual void relevant_eh(app * n);
virtual void assign_eh(bool_var v, bool is_true);
virtual void push_scope_eh();
From 5cfe5e15aca60262ed9fcc1764ef065914fc46fa Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 21 Apr 2017 17:51:14 -0400
Subject: [PATCH 370/401] unsat core validation for smt theories
---
src/smt/smt_context.cpp | 100 +++++++++++++++-------------------------
src/smt/smt_context.h | 2 +-
src/smt/smt_theory.h | 8 ++++
src/smt/theory_str.cpp | 22 +++++++++
src/smt/theory_str.h | 1 +
5 files changed, 68 insertions(+), 65 deletions(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index db09552ef..412e7b13d 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -3211,11 +3211,11 @@ namespace smt {
m_assumptions.reset();
}
- void context::mk_unsat_core() {
+ lbool context::mk_unsat_core() {
SASSERT(inconsistent());
if (!tracking_assumptions()) {
SASSERT(m_assumptions.empty());
- return;
+ return l_false;
}
uint_set already_found_assumptions;
literal_vector::const_iterator it = m_conflict_resolution->begin_unsat_core();
@@ -3240,7 +3240,19 @@ namespace smt {
for (unsigned i = 0; i < sz; i++) {
tout << mk_pp(m_unsat_core.get(i), m_manager) << "\n";
});
- validate_unsat_core();
+ validate_unsat_core();
+ // theory validation of unsat core
+
+ ptr_vector<theory>::iterator th_it = m_theory_set.begin();
+ ptr_vector<theory>::iterator th_end = m_theory_set.end();
+ for (; th_it != th_end; ++th_it) {
+ lbool theory_result = (*th_it)->validate_unsat_core(m_unsat_core);
+ if (theory_result == l_undef) {
+ return l_undef;
+ }
+ }
+
+ return l_false;
}
/**
@@ -3267,45 +3279,6 @@ namespace smt {
if (r == l_true && get_cancel_flag()) {
r = l_undef;
}
-
- /*
- // PATCH for theory_str:
- // UNSAT + overlapping variables => UNKNOWN
- if (r == l_false && use_theory_str_overlap_assumption()) {
- // check the unsat core for an assumption from theory_str relating to overlaps.
- // if we find this assumption, we have to answer UNKNOWN
- // otherwise, we can pass through UNSAT
- TRACE("t_str", tout << "unsat core:\n";
- unsigned sz = m_unsat_core.size();
- for (unsigned i = 0; i < sz; i++) {
- tout << mk_pp(m_unsat_core.get(i), m_manager) << "\n";
- });
-
- bool assumptionFound = false;
- unsigned sz = m_unsat_core.size();
- app * target_term = to_app(m_manager.mk_not(m_theoryStrOverlapAssumption_term));
- internalize_term(target_term);
- for (unsigned i = 0; i < sz; ++i) {
- app * core_term = to_app(m_unsat_core.get(i));
- // not sure if this is the correct way to compare exprs in this context
- enode * e1;
- enode * e2;
- e1 = get_enode(target_term);
- e2 = get_enode(core_term);
- if (e1 == e2) {
- // found match
- TRACE("t_str", tout << "overlap detected in unsat core; changing UNSAT to UNKNOWN" << std::endl;);
- assumptionFound = true;
- r = l_undef;
- break;
- }
- }
- if (!assumptionFound) {
- TRACE("t_str", tout << "no overlaps detected in unsat core, answering UNSAT" << std::endl;);
- }
- }
- */
-
return r;
}
@@ -3323,23 +3296,6 @@ namespace smt {
SASSERT(!m_setup.already_configured());
setup_context(m_fparams.m_auto_config);
- /*
- // theory_str requires the context to be set up with a special assumption.
- // we need to wait until after setup_context() to know whether this is the case
- if (m_use_theory_str_overlap_assumption) {
- TRACE("t_str", tout << "enabling theory_str overlap assumption" << std::endl;);
- // TODO maybe refactor this a bit
- symbol strOverlap("!!TheoryStrOverlapAssumption!!");
- expr_ref_vector assumption(get_manager());
- seq_util m_sequtil(m_manager);
- sort * s = m_manager.mk_bool_sort();
- m_theoryStrOverlapAssumption_term = expr_ref(m_manager.mk_const(strOverlap, s), m_manager);
- assumption.push_back(m_manager.mk_not(m_theoryStrOverlapAssumption_term));
- // this might work, even though we already did a bit of setup
- return check(assumption.size(), assumption.c_ptr(), reset_cancel);
- }
- */
-
expr_ref_vector theory_assumptions(m_manager);
ptr_vector<theory>::iterator it = m_theory_set.begin();
ptr_vector<theory>::iterator end = m_theory_set.end();
@@ -3413,7 +3369,7 @@ namespace smt {
(*it)->setup();
}
- lbool context::check(unsigned num_assumptions, expr * const * assumptions, bool reset_cancel) {
+ lbool context::check(unsigned ext_num_assumptions, expr * const * ext_assumptions, bool reset_cancel) {
m_stats.m_num_checks++;
TRACE("check_bug", tout << "STARTING check(num_assumptions, assumptions)\n";
tout << "inconsistent: " << inconsistent() << ", m_unsat_core.empty(): " << m_unsat_core.empty() << "\n";
@@ -3424,6 +3380,22 @@ namespace smt {
m_unsat_core.reset();
if (!check_preamble(reset_cancel))
return l_undef;
+
+ expr_ref_vector theory_assumptions(m_manager);
+ for (unsigned i = 0; i < ext_num_assumptions; ++i) {
+ theory_assumptions.push_back(ext_assumptions[i]);
+ }
+ ptr_vector<theory>::iterator it = m_theory_set.begin();
+ ptr_vector<theory>::iterator end = m_theory_set.end();
+ for (; it != end; ++it) {
+ (*it)->add_theory_assumptions(theory_assumptions);
+ }
+ if (!theory_assumptions.empty()) {
+ TRACE("search", tout << "Adding theory assumptions to context" << std::endl;);
+ }
+ unsigned num_assumptions = theory_assumptions.size();
+ expr * const * assumptions = theory_assumptions.c_ptr();
+
if (!validate_assumptions(num_assumptions, assumptions))
return l_undef;
TRACE("check_bug", tout << "inconsistent: " << inconsistent() << ", m_unsat_core.empty(): " << m_unsat_core.empty() << "\n";);
@@ -3447,13 +3419,13 @@ namespace smt {
TRACE("after_internalization", display(tout););
if (inconsistent()) {
VERIFY(!resolve_conflict()); // build the proof
- mk_unsat_core();
- r = l_false;
+ r = mk_unsat_core();
}
else {
r = search();
- if (r == l_false)
- mk_unsat_core();
+ if (r == l_false) {
+ r = mk_unsat_core(); // validation may change an l_false to l_undef here
+ }
}
}
}
diff --git a/src/smt/smt_context.h b/src/smt/smt_context.h
index 0667f622e..0943662e8 100644
--- a/src/smt/smt_context.h
+++ b/src/smt/smt_context.h
@@ -1094,7 +1094,7 @@ namespace smt {
void reset_assumptions();
- void mk_unsat_core();
+ lbool mk_unsat_core();
void validate_unsat_core();
diff --git a/src/smt/smt_theory.h b/src/smt/smt_theory.h
index e412f2f1b..ff29c7413 100644
--- a/src/smt/smt_theory.h
+++ b/src/smt/smt_theory.h
@@ -199,6 +199,14 @@ namespace smt {
return FC_DONE;
}
+ /**
+ \brief This method is called from the smt_context when an unsat core is generated.
+ The theory may change the answer to UNKNOWN by returning l_undef from this method.
+ */
+ virtual lbool validate_unsat_core(expr_ref_vector & unsat_core) {
+ return l_false;
+ }
+
/**
\brief Parametric theories (e.g. Arrays) should implement this method.
See example in context::is_shared
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 354589318..bddd0b78e 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -7302,6 +7302,28 @@ void theory_str::add_theory_assumptions(expr_ref_vector & assumptions) {
assumptions.push_back(get_manager().mk_not(m_theoryStrOverlapAssumption_term));
}
+lbool theory_str::validate_unsat_core(expr_ref_vector & unsat_core) {
+ bool assumptionFound = false;
+
+ app * target_term = to_app(get_manager().mk_not(m_theoryStrOverlapAssumption_term));
+ internalize_term(target_term);
+ for (unsigned i = 0; i < unsat_core.size(); ++i) {
+ app * core_term = to_app(unsat_core.get(i));
+ // not sure if this is the correct way to compare terms in this context
+ enode * e1;
+ enode * e2;
+ e1 = get_context().get_enode(target_term);
+ e2 = get_context().get_enode(core_term);
+ if (e1 == e2) {
+ TRACE("t_str", tout << "overlap detected in unsat core, changing UNSAT to UNKNOWN" << std::endl;);
+ assumptionFound = true;
+ return l_undef;
+ }
+ }
+
+ return l_false;
+}
+
void theory_str::init_search_eh() {
ast_manager & m = get_manager();
context & ctx = get_context();
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 3c273d4e2..7c2df9e12 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -629,6 +629,7 @@ namespace smt {
virtual theory* mk_fresh(context*) { return alloc(theory_str, get_manager(), m_params); }
virtual void init_search_eh();
virtual void add_theory_assumptions(expr_ref_vector & assumptions);
+ virtual lbool validate_unsat_core(expr_ref_vector & unsat_core);
virtual void relevant_eh(app * n);
virtual void assign_eh(bool_var v, bool is_true);
virtual void push_scope_eh();
From c46f95a629c07ae2e983ce68ab25f255a0197137 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 24 Apr 2017 12:39:55 -0400
Subject: [PATCH 371/401] remove unused parameter from smt_context
---
src/smt/smt_context.cpp | 1 -
1 file changed, 1 deletion(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 3d0652093..f003dfa37 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -76,7 +76,6 @@ namespace smt {
m_unsat_proof(m),
m_unknown("unknown"),
m_unsat_core(m),
- m_use_theory_str_overlap_assumption(false),
#ifdef Z3DEBUG
m_trail_enabled(true),
#endif
From 8ce93b4ee528776bba150a7fa88d10bce790b777 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 24 Apr 2017 15:39:25 -0400
Subject: [PATCH 372/401] unify tracing in theory_str to 'str' tag
---
src/smt/theory_str.cpp | 832 ++++++++++++++++++++---------------------
1 file changed, 416 insertions(+), 416 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index bddd0b78e..01123a22c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -174,7 +174,7 @@ void theory_str::assert_axiom(expr * e) {
}
if (get_manager().is_true(e)) return;
- TRACE("t_str_detail", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
+ TRACE("str", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
context & ctx = get_context();
if (!ctx.b_internalized(e)) {
ctx.internalize(e, false);
@@ -186,7 +186,7 @@ void theory_str::assert_axiom(expr * e) {
// crash/error avoidance: add all axioms to the trail
m_trail.push_back(e);
- //TRACE("t_str_detail", tout << "done asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
+ //TRACE("str", tout << "done asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
}
expr * theory_str::rewrite_implication(expr * premise, expr * conclusion) {
@@ -196,7 +196,7 @@ expr * theory_str::rewrite_implication(expr * premise, expr * conclusion) {
void theory_str::assert_implication(expr * premise, expr * conclusion) {
ast_manager & m = get_manager();
- TRACE("t_str_detail", tout << "asserting implication " << mk_ismt2_pp(premise, m) << " -> " << mk_ismt2_pp(conclusion, m) << std::endl;);
+ TRACE("str", tout << "asserting implication " << mk_ismt2_pp(premise, m) << " -> " << mk_ismt2_pp(conclusion, m) << std::endl;);
expr_ref axiom(m.mk_or(m.mk_not(premise), conclusion), m);
assert_axiom(axiom);
}
@@ -210,7 +210,7 @@ bool theory_str::internalize_term(app * term) {
ast_manager & m = get_manager();
SASSERT(term->get_family_id() == get_family_id());
- TRACE("t_str_detail", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
+ TRACE("str", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
// emulation of user_smt_theory::internalize_term()
@@ -234,14 +234,14 @@ bool theory_str::internalize_term(app * term) {
for (unsigned i = 0; i < num_args; ++i) {
enode * arg = e->get_arg(i);
theory_var v_arg = mk_var(arg);
- TRACE("t_str_detail", tout << "arg has theory var #" << v_arg << std::endl;);
+ TRACE("str", tout << "arg has theory var #" << v_arg << std::endl;);
}
theory_var v = mk_var(e);
- TRACE("t_str_detail", tout << "term has theory var #" << v << std::endl;);
+ TRACE("str", tout << "term has theory var #" << v << std::endl;);
if (opt_EagerStringConstantLengthAssertions && u.str.is_string(term)) {
- TRACE("t_str", tout << "eagerly asserting length of string term " << mk_pp(term, m) << std::endl;);
+ TRACE("str", tout << "eagerly asserting length of string term " << mk_pp(term, m) << std::endl;);
m_basicstr_axiom_todo.insert(e);
}
return true;
@@ -260,23 +260,23 @@ enode* theory_str::ensure_enode(expr* e) {
void theory_str::refresh_theory_var(expr * e) {
enode * en = ensure_enode(e);
theory_var v = mk_var(en);
- TRACE("t_str_detail", tout << "refresh " << mk_pp(e, get_manager()) << ": v#" << v << std::endl;);
+ TRACE("str", tout << "refresh " << mk_pp(e, get_manager()) << ": v#" << v << std::endl;);
m_basicstr_axiom_todo.push_back(en);
}
theory_var theory_str::mk_var(enode* n) {
- TRACE("t_str_detail", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;);
+ TRACE("str", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;);
ast_manager & m = get_manager();
if (!(m.get_sort(n->get_owner()) == u.str.mk_string_sort())) {
return null_theory_var;
}
if (is_attached_to_var(n)) {
- TRACE("t_str_detail", tout << "already attached to theory var" << std::endl;);
+ TRACE("str", tout << "already attached to theory var" << std::endl;);
return n->get_th_var(get_id());
} else {
theory_var v = theory::mk_var(n);
m_find.mk_var();
- TRACE("t_str_detail", tout << "new theory var v#" << v << std::endl;);
+ TRACE("str", tout << "new theory var v#" << v << std::endl;);
get_context().attach_th_var(n, this, v);
get_context().mark_as_relevant(n);
return v;
@@ -320,14 +320,14 @@ void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node)
varInfo->vars[node] = 1;
cut_var_map.insert(baseNode, std::stack<T_cut*>());
cut_var_map[baseNode].push(varInfo);
- TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
+ TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
if (cut_var_map[baseNode].empty()) {
T_cut * varInfo = alloc(T_cut);
varInfo->level = slevel;
varInfo->vars[node] = 1;
cut_var_map[baseNode].push(varInfo);
- TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
+ TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
if (cut_var_map[baseNode].top()->level < slevel) {
T_cut * varInfo = alloc(T_cut);
@@ -335,10 +335,10 @@ void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node)
cut_vars_map_copy(varInfo->vars, cut_var_map[baseNode].top()->vars);
varInfo->vars[node] = 1;
cut_var_map[baseNode].push(varInfo);
- TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
+ TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
} else if (cut_var_map[baseNode].top()->level == slevel) {
cut_var_map[baseNode].top()->vars[node] = 1;
- TRACE("t_str_cut_var_map", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
+ TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
get_manager().raise_exception("entered illegal state during add_cut_info_one_node()");
}
@@ -364,7 +364,7 @@ void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode)
cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
cut_var_map.insert(destNode, std::stack<T_cut*>());
cut_var_map[destNode].push(varInfo);
- TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
+ TRACE("str", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
if (cut_var_map[destNode].empty() || cut_var_map[destNode].top()->level < slevel) {
T_cut * varInfo = alloc(T_cut);
@@ -372,10 +372,10 @@ void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode)
cut_vars_map_copy(varInfo->vars, cut_var_map[destNode].top()->vars);
cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
cut_var_map[destNode].push(varInfo);
- TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
+ TRACE("str", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
} else if (cut_var_map[destNode].top()->level == slevel) {
cut_vars_map_copy(cut_var_map[destNode].top()->vars, cut_var_map[srcNode].top()->vars);
- TRACE("t_str_cut_var_map", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
+ TRACE("str", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
get_manager().raise_exception("illegal state in add_cut_info_merge(): inconsistent slevels");
}
@@ -446,7 +446,7 @@ app * theory_str::mk_int_var(std::string name) {
context & ctx = get_context();
ast_manager & m = get_manager();
- TRACE("t_str_detail", tout << "creating integer variable " << name << " at scope level " << sLevel << std::endl;);
+ TRACE("str", tout << "creating integer variable " << name << " at scope level " << sLevel << std::endl;);
sort * int_sort = m.mk_sort(m_autil.get_family_id(), INT_SORT);
app * a = m.mk_fresh_const(name.c_str(), int_sort);
@@ -481,12 +481,12 @@ app * theory_str::mk_str_var(std::string name) {
context & ctx = get_context();
ast_manager & m = get_manager();
- TRACE("t_str_detail", tout << "creating string variable " << name << " at scope level " << sLevel << std::endl;);
+ TRACE("str", tout << "creating string variable " << name << " at scope level " << sLevel << std::endl;);
sort * string_sort = u.str.mk_string_sort();
app * a = m.mk_fresh_const(name.c_str(), string_sort);
- TRACE("t_str_detail", tout << "a->get_family_id() = " << a->get_family_id() << std::endl
+ TRACE("str", tout << "a->get_family_id() = " << a->get_family_id() << std::endl
<< "this->get_family_id() = " << this->get_family_id() << std::endl;);
// I have a hunch that this may not get internalized for free...
@@ -496,7 +496,7 @@ app * theory_str::mk_str_var(std::string name) {
// this might help??
mk_var(ctx.get_enode(a));
m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
- TRACE("t_str_axiom_bug", tout << "add " << mk_pp(a, m) << " to m_basicstr_axiom_todo" << std::endl;);
+ TRACE("str", tout << "add " << mk_pp(a, m) << " to m_basicstr_axiom_todo" << std::endl;);
m_trail.push_back(a);
variable_set.insert(a);
@@ -518,7 +518,7 @@ app * theory_str::mk_regex_rep_var() {
SASSERT(ctx.e_internalized(a));
mk_var(ctx.get_enode(a));
m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
- TRACE("t_str_axiom_bug", tout << "add " << mk_pp(a, m) << " to m_basicstr_axiom_todo" << std::endl;);
+ TRACE("str", tout << "add " << mk_pp(a, m) << " to m_basicstr_axiom_todo" << std::endl;);
m_trail.push_back(a);
variable_set.insert(a);
@@ -560,7 +560,7 @@ app * theory_str::mk_nonempty_str_var() {
tmpStringVarCount++;
std::string name = "$$_str" + ss.str();
- TRACE("t_str_detail", tout << "creating nonempty string variable " << name << " at scope level " << sLevel << std::endl;);
+ TRACE("str", tout << "creating nonempty string variable " << name << " at scope level " << sLevel << std::endl;);
sort * string_sort = u.str.mk_string_sort();
app * a = m.mk_fresh_const(name.c_str(), string_sort);
@@ -784,12 +784,12 @@ bool theory_str::can_propagate() {
void theory_str::propagate() {
context & ctx = get_context();
while (can_propagate()) {
- TRACE("t_str_detail", tout << "propagating..." << std::endl;);
+ TRACE("str", tout << "propagating..." << std::endl;);
for (unsigned i = 0; i < m_basicstr_axiom_todo.size(); ++i) {
instantiate_basic_string_axioms(m_basicstr_axiom_todo[i]);
}
m_basicstr_axiom_todo.reset();
- TRACE("t_str_axiom_bug", tout << "reset m_basicstr_axiom_todo" << std::endl;);
+ TRACE("str", tout << "reset m_basicstr_axiom_todo" << std::endl;);
for (unsigned i = 0; i < m_str_eq_todo.size(); ++i) {
std::pair<enode*,enode*> pair = m_str_eq_todo[i];
@@ -840,7 +840,7 @@ void theory_str::propagate() {
} else if (u.str.is_in_re(a)) {
instantiate_axiom_RegexIn(e);
} else {
- TRACE("t_str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_owner(), get_manager()) << std::endl;);
+ TRACE("str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_owner(), get_manager()) << std::endl;);
NOT_IMPLEMENTED_YET();
}
}
@@ -868,7 +868,7 @@ void theory_str::try_eval_concat(enode * cat) {
context & ctx = get_context();
ast_manager & m = get_manager();
- TRACE("t_str_detail", tout << "attempting to flatten " << mk_pp(a_cat, m) << std::endl;);
+ TRACE("str", tout << "attempting to flatten " << mk_pp(a_cat, m) << std::endl;);
std::stack<app*> worklist;
zstring flattenedString("");
@@ -894,13 +894,13 @@ void theory_str::try_eval_concat(enode * cat) {
worklist.push(arg1);
worklist.push(arg0);
} else {
- TRACE("t_str_detail", tout << "non-constant term in concat -- giving up." << std::endl;);
+ TRACE("str", tout << "non-constant term in concat -- giving up." << std::endl;);
constOK = false;
break;
}
}
if (constOK) {
- TRACE("t_str_detail", tout << "flattened to \"" << flattenedString.encode().c_str() << "\"" << std::endl;);
+ TRACE("str", tout << "flattened to \"" << flattenedString.encode().c_str() << "\"" << std::endl;);
expr_ref constStr(mk_string(flattenedString), m);
expr_ref axiom(ctx.mk_eq_atom(a_cat, constStr), m);
assert_axiom(axiom);
@@ -917,7 +917,7 @@ void theory_str::instantiate_concat_axiom(enode * cat) {
ast_manager & m = get_manager();
- TRACE("t_str_detail", tout << "instantiating concat axiom for " << mk_ismt2_pp(a_cat, m) << std::endl;);
+ TRACE("str", tout << "instantiating concat axiom for " << mk_ismt2_pp(a_cat, m) << std::endl;);
// build LHS
expr_ref len_xy(m);
@@ -960,11 +960,11 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
context & ctx = get_context();
ast_manager & m = get_manager();
- TRACE("t_str_axiom_bug", tout << "set up basic string axioms on " << mk_pp(str->get_owner(), m) << std::endl;);
+ TRACE("str", tout << "set up basic string axioms on " << mk_pp(str->get_owner(), m) << std::endl;);
// TESTING: attempt to avoid a crash here when a variable goes out of scope
if (str->get_iscope_lvl() > ctx.get_scope_level()) {
- TRACE("t_str_detail", tout << "WARNING: skipping axiom setup on out-of-scope string term" << std::endl;);
+ TRACE("str", tout << "WARNING: skipping axiom setup on out-of-scope string term" << std::endl;);
return;
}
@@ -977,7 +977,7 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
zstring strconst;
u.str.is_string(str->get_owner(), strconst);
- TRACE("t_str_detail", tout << "instantiating constant string axioms for \"" << strconst.encode().c_str() << "\"" << std::endl;);
+ TRACE("str", tout << "instantiating constant string axioms for \"" << strconst.encode().c_str() << "\"" << std::endl;);
unsigned int l = strconst.length();
expr_ref len(m_autil.mk_numeral(rational(l), true), m);
@@ -998,7 +998,7 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
// build LHS >= RHS and assert
app * lhs_ge_rhs = m_autil.mk_ge(len_str, zero);
SASSERT(lhs_ge_rhs);
- TRACE("t_str_detail", tout << "string axiom 1: " << mk_ismt2_pp(lhs_ge_rhs, m) << std::endl;);
+ TRACE("str", tout << "string axiom 1: " << mk_ismt2_pp(lhs_ge_rhs, m) << std::endl;);
assert_axiom(lhs_ge_rhs);
}
@@ -1022,7 +1022,7 @@ void theory_str::instantiate_basic_string_axioms(enode * str) {
rhs = ctx.mk_eq_atom(a_str, empty_str);
SASSERT(rhs);
// build LHS <=> RHS and assert
- TRACE("t_str_detail", tout << "string axiom 2: " << mk_ismt2_pp(lhs, m) << " <=> " << mk_ismt2_pp(rhs, m) << std::endl;);
+ TRACE("str", tout << "string axiom 2: " << mk_ismt2_pp(lhs, m) << " <=> " << mk_ismt2_pp(rhs, m) << std::endl;);
literal l(mk_eq(lhs, rhs, true));
ctx.mark_as_relevant(l);
ctx.mk_th_axiom(get_id(), 1, &l);
@@ -1052,7 +1052,7 @@ void theory_str::instantiate_str_eq_length_axiom(enode * lhs, enode * rhs) {
SASSERT(len_rhs);
expr_ref conclusion(ctx.mk_eq_atom(len_lhs, len_rhs), m);
- TRACE("t_str_detail", tout << "string-eq length-eq axiom: "
+ TRACE("str", tout << "string-eq length-eq axiom: "
<< mk_ismt2_pp(premise, m) << " -> " << mk_ismt2_pp(conclusion, m) << std::endl;);
assert_implication(premise, conclusion);
}
@@ -1063,12 +1063,12 @@ void theory_str::instantiate_axiom_CharAt(enode * e) {
app * expr = e->get_owner();
if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up CharAt axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "already set up CharAt axiom for " << mk_pp(expr, m) << std::endl;);
return;
}
axiomatized_terms.insert(expr);
- TRACE("t_str_detail", tout << "instantiate CharAt axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "instantiate CharAt axiom for " << mk_pp(expr, m) << std::endl;);
expr_ref ts0(mk_str_var("ts0"), m);
expr_ref ts1(mk_str_var("ts1"), m);
@@ -1106,12 +1106,12 @@ void theory_str::instantiate_axiom_prefixof(enode * e) {
app * expr = e->get_owner();
if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up prefixof axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "already set up prefixof axiom for " << mk_pp(expr, m) << std::endl;);
return;
}
axiomatized_terms.insert(expr);
- TRACE("t_str_detail", tout << "instantiate prefixof axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "instantiate prefixof axiom for " << mk_pp(expr, m) << std::endl;);
expr_ref ts0(mk_str_var("ts0"), m);
expr_ref ts1(mk_str_var("ts1"), m);
@@ -1143,12 +1143,12 @@ void theory_str::instantiate_axiom_suffixof(enode * e) {
app * expr = e->get_owner();
if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up suffixof axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "already set up suffixof axiom for " << mk_pp(expr, m) << std::endl;);
return;
}
axiomatized_terms.insert(expr);
- TRACE("t_str_detail", tout << "instantiate suffixof axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "instantiate suffixof axiom for " << mk_pp(expr, m) << std::endl;);
expr_ref ts0(mk_str_var("ts0"), m);
expr_ref ts1(mk_str_var("ts1"), m);
@@ -1180,7 +1180,7 @@ void theory_str::instantiate_axiom_Contains(enode * e) {
app * ex = e->get_owner();
if (axiomatized_terms.contains(ex)) {
- TRACE("t_str_detail", tout << "already set up Contains axiom for " << mk_pp(ex, m) << std::endl;);
+ TRACE("str", tout << "already set up Contains axiom for " << mk_pp(ex, m) << std::endl;);
return;
}
axiomatized_terms.insert(ex);
@@ -1189,7 +1189,7 @@ void theory_str::instantiate_axiom_Contains(enode * e) {
// at minimum it should fix z3str/concat-006.smt2
zstring haystackStr, needleStr;
if (u.str.is_string(ex->get_arg(0), haystackStr) && u.str.is_string(ex->get_arg(1), needleStr)) {
- TRACE("t_str_detail", tout << "eval constant Contains term " << mk_pp(ex, m) << std::endl;);
+ TRACE("str", tout << "eval constant Contains term " << mk_pp(ex, m) << std::endl;);
if (haystackStr.contains(needleStr)) {
assert_axiom(ex);
} else {
@@ -1208,7 +1208,7 @@ void theory_str::instantiate_axiom_Contains(enode * e) {
contain_pair_idx_map[substr].insert(key);
}
- TRACE("t_str_detail", tout << "instantiate Contains axiom for " << mk_pp(ex, m) << std::endl;);
+ TRACE("str", tout << "instantiate Contains axiom for " << mk_pp(ex, m) << std::endl;);
expr_ref ts0(mk_str_var("ts0"), m);
expr_ref ts1(mk_str_var("ts1"), m);
@@ -1224,12 +1224,12 @@ void theory_str::instantiate_axiom_Indexof(enode * e) {
app * expr = e->get_owner();
if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up Indexof axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "already set up Indexof axiom for " << mk_pp(expr, m) << std::endl;);
return;
}
axiomatized_terms.insert(expr);
- TRACE("t_str_detail", tout << "instantiate Indexof axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "instantiate Indexof axiom for " << mk_pp(expr, m) << std::endl;);
expr_ref x1(mk_str_var("x1"), m);
expr_ref x2(mk_str_var("x2"), m);
@@ -1280,12 +1280,12 @@ void theory_str::instantiate_axiom_Indexof2(enode * e) {
app * expr = e->get_owner();
if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up Indexof2 axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "already set up Indexof2 axiom for " << mk_pp(expr, m) << std::endl;);
return;
}
axiomatized_terms.insert(expr);
- TRACE("t_str_detail", tout << "instantiate Indexof2 axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "instantiate Indexof2 axiom for " << mk_pp(expr, m) << std::endl;);
// -------------------------------------------------------------------------------
// if (arg[2] >= length(arg[0])) // ite2
@@ -1348,12 +1348,12 @@ void theory_str::instantiate_axiom_LastIndexof(enode * e) {
app * expr = e->get_owner();
if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up LastIndexof axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "already set up LastIndexof axiom for " << mk_pp(expr, m) << std::endl;);
return;
}
axiomatized_terms.insert(expr);
- TRACE("t_str_detail", tout << "instantiate LastIndexof axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "instantiate LastIndexof axiom for " << mk_pp(expr, m) << std::endl;);
expr_ref x1(mk_str_var("x1"), m);
expr_ref x2(mk_str_var("x2"), m);
@@ -1417,12 +1417,12 @@ void theory_str::instantiate_axiom_Substr(enode * e) {
app * expr = e->get_owner();
if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up Substr axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "already set up Substr axiom for " << mk_pp(expr, m) << std::endl;);
return;
}
axiomatized_terms.insert(expr);
- TRACE("t_str_detail", tout << "instantiate Substr axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "instantiate Substr axiom for " << mk_pp(expr, m) << std::endl;);
expr_ref substrBase(expr->get_arg(0), m);
expr_ref substrPos(expr->get_arg(1), m);
@@ -1510,12 +1510,12 @@ void theory_str::instantiate_axiom_Replace(enode * e) {
app * expr = e->get_owner();
if (axiomatized_terms.contains(expr)) {
- TRACE("t_str_detail", tout << "already set up Replace axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "already set up Replace axiom for " << mk_pp(expr, m) << std::endl;);
return;
}
axiomatized_terms.insert(expr);
- TRACE("t_str_detail", tout << "instantiate Replace axiom for " << mk_pp(expr, m) << std::endl;);
+ TRACE("str", tout << "instantiate Replace axiom for " << mk_pp(expr, m) << std::endl;);
expr_ref x1(mk_str_var("x1"), m);
expr_ref x2(mk_str_var("x2"), m);
@@ -1560,12 +1560,12 @@ void theory_str::instantiate_axiom_str_to_int(enode * e) {
app * ex = e->get_owner();
if (axiomatized_terms.contains(ex)) {
- TRACE("t_str_detail", tout << "already set up str.to-int axiom for " << mk_pp(ex, m) << std::endl;);
+ TRACE("str", tout << "already set up str.to-int axiom for " << mk_pp(ex, m) << std::endl;);
return;
}
axiomatized_terms.insert(ex);
- TRACE("t_str_detail", tout << "instantiate str.to-int axiom for " << mk_pp(ex, m) << std::endl;);
+ TRACE("str", tout << "instantiate str.to-int axiom for " << mk_pp(ex, m) << std::endl;);
// let expr = (str.to-int S)
// axiom 1: expr >= -1
@@ -1607,12 +1607,12 @@ void theory_str::instantiate_axiom_int_to_str(enode * e) {
app * ex = e->get_owner();
if (axiomatized_terms.contains(ex)) {
- TRACE("t_str_detail", tout << "already set up str.from-int axiom for " << mk_pp(ex, m) << std::endl;);
+ TRACE("str", tout << "already set up str.from-int axiom for " << mk_pp(ex, m) << std::endl;);
return;
}
axiomatized_terms.insert(ex);
- TRACE("t_str_detail", tout << "instantiate str.from-int axiom for " << mk_pp(ex, m) << std::endl;);
+ TRACE("str", tout << "instantiate str.from-int axiom for " << mk_pp(ex, m) << std::endl;);
// axiom 1: N < 0 <==> (str.from-int N) = ""
expr * N = ex->get_arg(0);
@@ -1674,7 +1674,7 @@ zstring theory_str::get_std_regex_str(expr * regex) {
zstring reg1Str = get_std_regex_str(reg1Ast);
return zstring("(") + reg1Str + zstring(")*");
} else {
- TRACE("t_str", tout << "BUG: unrecognized regex term " << mk_pp(regex, get_manager()) << std::endl;);
+ TRACE("str", tout << "BUG: unrecognized regex term " << mk_pp(regex, get_manager()) << std::endl;);
UNREACHABLE(); return zstring("");
}
}
@@ -1685,12 +1685,12 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
app * ex = e->get_owner();
if (axiomatized_terms.contains(ex)) {
- TRACE("t_str_detail", tout << "already set up RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
+ TRACE("str", tout << "already set up RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
return;
}
axiomatized_terms.insert(ex);
- TRACE("t_str_detail", tout << "instantiate RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
+ TRACE("str", tout << "instantiate RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
{
zstring regexStr = get_std_regex_str(ex->get_arg(1));
@@ -1710,7 +1710,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
expr_ref finalAxiom(m.mk_iff(ex, rhs), m);
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
- TRACE("t_str", tout << "set up Str2Reg: (RegexIn " << mk_pp(str, m) << " " << mk_pp(regex, m) << ")" << std::endl;);
+ TRACE("str", tout << "set up Str2Reg: (RegexIn " << mk_pp(str, m) << " " << mk_pp(regex, m) << ")" << std::endl;);
} else if (u.re.is_concat(regex)) {
expr_ref var1(mk_regex_rep_var(), m);
expr_ref var2(mk_regex_rep_var(), m);
@@ -1753,7 +1753,7 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
} else {
- TRACE("t_str_detail", tout << "ERROR: unknown regex expression " << mk_pp(regex, m) << "!" << std::endl;);
+ TRACE("str", tout << "ERROR: unknown regex expression " << mk_pp(regex, m) << "!" << std::endl;);
NOT_IMPLEMENTED_YET();
}
}
@@ -1762,11 +1762,11 @@ void theory_str::attach_new_th_var(enode * n) {
context & ctx = get_context();
theory_var v = mk_var(n);
ctx.attach_th_var(n, this, v);
- TRACE("t_str_detail", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := v#" << v << std::endl;);
+ TRACE("str", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := v#" << v << std::endl;);
}
void theory_str::reset_eh() {
- TRACE("t_str", tout << "resetting" << std::endl;);
+ TRACE("str", tout << "resetting" << std::endl;);
m_trail_stack.reset();
m_basicstr_axiom_todo.reset();
@@ -1804,19 +1804,19 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
do {
expr * eqc_nn2 = rhs;
do {
- TRACE("t_str_detail", tout << "checking whether " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " can be equal" << std::endl;);
+ TRACE("str", tout << "checking whether " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " can be equal" << std::endl;);
// inconsistency check: value
if (!can_two_nodes_eq(eqc_nn1, eqc_nn2)) {
- TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " cannot be equal to " << mk_pp(eqc_nn2, m) << std::endl;);
+ TRACE("str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " cannot be equal to " << mk_pp(eqc_nn2, m) << std::endl;);
expr_ref to_assert(m.mk_not(ctx.mk_eq_atom(eqc_nn1, eqc_nn2)), m);
assert_axiom(to_assert);
// this shouldn't use the integer theory at all, so we don't allow the option of quick-return
return false;
}
if (!check_length_consistency(eqc_nn1, eqc_nn2)) {
- TRACE("t_str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " have inconsistent lengths" << std::endl;);
+ TRACE("str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " have inconsistent lengths" << std::endl;);
if (opt_NoQuickReturn_IntegerTheory){
- TRACE("t_str_detail", tout << "continuing in new_eq_check() due to opt_NoQuickReturn_IntegerTheory" << std::endl;);
+ TRACE("str", tout << "continuing in new_eq_check() due to opt_NoQuickReturn_IntegerTheory" << std::endl;);
} else {
return false;
}
@@ -1831,7 +1831,7 @@ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
}
if (!regex_in_bool_map.empty()) {
- TRACE("t_str", tout << "checking regex consistency" << std::endl;);
+ TRACE("str", tout << "checking regex consistency" << std::endl;);
check_regex_in(lhs, rhs);
}
@@ -1963,7 +1963,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
ast_manager & m = get_manager();
context & ctx = get_context();
- TRACE("t_str", tout << "simplifying parents of " << mk_ismt2_pp(nn, m)
+ TRACE("str", tout << "simplifying parents of " << mk_ismt2_pp(nn, m)
<< " with respect to " << mk_ismt2_pp(eq_str, m) << std::endl;);
ctx.internalize(nn, false);
@@ -1973,7 +1973,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
expr * n_eqNode = nn;
do {
enode * n_eq_enode = ctx.get_enode(n_eqNode);
- TRACE("t_str_detail", tout << "considering all parents of " << mk_ismt2_pp(n_eqNode, m) << std::endl
+ TRACE("str", tout << "considering all parents of " << mk_ismt2_pp(n_eqNode, m) << std::endl
<< "associated n_eq_enode has " << n_eq_enode->get_num_parents() << " parents" << std::endl;);
// the goal of this next bit is to avoid dereferencing a bogus e_parent in the following loop.
@@ -1990,7 +1990,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
SASSERT(e_parent != NULL);
app * a_parent = e_parent->get_owner();
- TRACE("t_str_detail", tout << "considering parent " << mk_ismt2_pp(a_parent, m) << std::endl;);
+ TRACE("str", tout << "considering parent " << mk_ismt2_pp(a_parent, m) << std::endl;);
if (u.str.is_concat(a_parent)) {
expr * arg0 = a_parent->get_arg(0);
@@ -2004,7 +2004,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
bool arg0Len_exists = get_len_value(eq_str, arg0Len);
bool arg1Len_exists = get_len_value(arg1, arg1Len);
- TRACE("t_str_detail",
+ TRACE("str",
tout << "simplify_parent #1:" << std::endl
<< "* parent = " << mk_ismt2_pp(a_parent, m) << std::endl
<< "* |parent| = " << rational_to_string_if_exists(parentLen, parentLen_exists) << std::endl
@@ -2013,7 +2013,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
);
if (parentLen_exists && !arg1Len_exists) {
- TRACE("t_str_detail", tout << "make up len for arg1" << std::endl;);
+ TRACE("str", tout << "make up len for arg1" << std::endl;);
expr_ref implyL11(m.mk_and(ctx.mk_eq_atom(mk_strlen(a_parent), mk_int(parentLen)),
ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0Len))), m);
rational makeUpLenArg1 = parentLen - arg0Len;
@@ -2075,7 +2075,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
bool arg0Len_exists = get_len_value(arg0, arg0Len);
bool arg1Len_exists = get_len_value(eq_str, arg1Len);
- TRACE("t_str_detail",
+ TRACE("str",
tout << "simplify_parent #2:" << std::endl
<< "* parent = " << mk_ismt2_pp(a_parent, m) << std::endl
<< "* |parent| = " << rational_to_string_if_exists(parentLen, parentLen_exists) << std::endl
@@ -2083,7 +2083,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
<< "* |arg1| = " << rational_to_string_if_exists(arg1Len, arg1Len_exists) << std::endl;
);
if (parentLen_exists && !arg0Len_exists) {
- TRACE("t_str_detail", tout << "make up len for arg0" << std::endl;);
+ TRACE("str", tout << "make up len for arg0" << std::endl;);
expr_ref implyL11(m.mk_and(ctx.mk_eq_atom(mk_strlen(a_parent), mk_int(parentLen)),
ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len))), m);
rational makeUpLenArg0 = parentLen - arg1Len;
@@ -2144,7 +2144,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
// Case (2-1) begin: (Concat n_eqNode (Concat str var))
if (arg0 == n_eqNode && u.str.is_concat(to_app(arg1))) {
app * a_arg1 = to_app(arg1);
- TRACE("t_str_detail", tout << "simplify_parent #3" << std::endl;);
+ TRACE("str", tout << "simplify_parent #3" << std::endl;);
expr * r_concat_arg0 = a_arg1->get_arg(0);
if (u.str.is_string(r_concat_arg0)) {
expr * combined_str = eval_concat(eq_str, r_concat_arg0);
@@ -2168,7 +2168,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
// Case (2-2) begin: (Concat (Concat var str) n_eqNode)
if (u.str.is_concat(to_app(arg0)) && arg1 == n_eqNode) {
app * a_arg0 = to_app(arg0);
- TRACE("t_str_detail", tout << "simplify_parent #4" << std::endl;);
+ TRACE("str", tout << "simplify_parent #4" << std::endl;);
expr * l_concat_arg1 = a_arg0->get_arg(1);
if (u.str.is_string(l_concat_arg1)) {
expr * combined_str = eval_concat(l_concat_arg1, eq_str);
@@ -2199,7 +2199,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
expr * concat_parent_arg0 = concat_parent->get_arg(0);
expr * concat_parent_arg1 = concat_parent->get_arg(1);
if (concat_parent_arg0 == a_parent && u.str.is_string(concat_parent_arg1)) {
- TRACE("t_str_detail", tout << "simplify_parent #5" << std::endl;);
+ TRACE("str", tout << "simplify_parent #5" << std::endl;);
expr * combinedStr = eval_concat(eq_str, concat_parent_arg1);
SASSERT(combinedStr);
expr_ref implyL(m);
@@ -2225,7 +2225,7 @@ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
expr * concat_parent_arg0 = concat_parent->get_arg(0);
expr * concat_parent_arg1 = concat_parent->get_arg(1);
if (concat_parent_arg1 == a_parent && u.str.is_string(concat_parent_arg0)) {
- TRACE("t_str_detail", tout << "simplify_parent #6" << std::endl;);
+ TRACE("str", tout << "simplify_parent #6" << std::endl;);
expr * combinedStr = eval_concat(concat_parent_arg0, eq_str);
SASSERT(combinedStr);
expr_ref implyL(m);
@@ -2275,10 +2275,10 @@ expr * theory_str::simplify_concat(expr * node) {
expr * vArg = get_eqc_value(argVec[i], vArgHasEqcValue);
resultAst = mk_concat(resultAst, vArg);
}
- TRACE("t_str_detail", tout << mk_ismt2_pp(node, m) << " is simplified to " << mk_ismt2_pp(resultAst, m) << std::endl;);
+ TRACE("str", tout << mk_ismt2_pp(node, m) << " is simplified to " << mk_ismt2_pp(resultAst, m) << std::endl;);
if (in_same_eqc(node, resultAst)) {
- TRACE("t_str_detail", tout << "SKIP: both concats are already in the same equivalence class" << std::endl;);
+ TRACE("str", tout << "SKIP: both concats are already in the same equivalence class" << std::endl;);
} else {
expr_ref_vector items(m);
int pos = 0;
@@ -2327,7 +2327,7 @@ bool theory_str::infer_len_concat(expr * n, rational & nLen) {
expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
rational nnLen = arg0_len + arg1_len;
expr_ref axr(ctx.mk_eq_atom(mk_strlen(n), mk_int(nnLen)), m);
- TRACE("t_str_detail", tout << "inferred (Length " << mk_pp(n, m) << ") = " << nnLen << std::endl;);
+ TRACE("str", tout << "inferred (Length " << mk_pp(n, m) << ") = " << nnLen << std::endl;);
assert_implication(axl, axr);
nLen = nnLen;
return true;
@@ -2507,10 +2507,10 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
bool a2_arg0_len_exists = get_len_value(a2_arg0, a2_arg0_len);
bool a2_arg1_len_exists = get_len_value(a2_arg1, a2_arg1_len);
- TRACE("t_str", tout << "nn1 = " << mk_ismt2_pp(nn1, m) << std::endl
+ TRACE("str", tout << "nn1 = " << mk_ismt2_pp(nn1, m) << std::endl
<< "nn2 = " << mk_ismt2_pp(nn2, m) << std::endl;);
- TRACE("t_str_detail", tout
+ TRACE("str", tout
<< "len(" << mk_pp(a1_arg0, m) << ") = " << (a1_arg0_len_exists ? a1_arg0_len.to_string() : "?") << std::endl
<< "len(" << mk_pp(a1_arg1, m) << ") = " << (a1_arg1_len_exists ? a1_arg1_len.to_string() : "?") << std::endl
<< "len(" << mk_pp(a2_arg0, m) << ") = " << (a2_arg0_len_exists ? a2_arg0_len.to_string() : "?") << std::endl
@@ -2527,7 +2527,7 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
expr_ref conclusion(m.mk_and(eq1, eq2), m);
assert_implication(premise, conclusion);
}
- TRACE("t_str_detail", tout << "SKIP: a1_arg0 == a2_arg0" << std::endl;);
+ TRACE("str", tout << "SKIP: a1_arg0 == a2_arg0" << std::endl;);
return;
}
@@ -2539,7 +2539,7 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
expr_ref conclusion(m.mk_and(eq1, eq2), m);
assert_implication(premise, conclusion);
}
- TRACE("t_str_detail", tout << "SKIP: a1_arg1 == a2_arg1" << std::endl;);
+ TRACE("str", tout << "SKIP: a1_arg1 == a2_arg1" << std::endl;);
return;
}
@@ -2547,10 +2547,10 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
if (in_same_eqc(a1_arg0, a2_arg0)) {
if (in_same_eqc(a1_arg1, a2_arg1)) {
- TRACE("t_str_detail", tout << "SKIP: a1_arg0 =~ a2_arg0 and a1_arg1 =~ a2_arg1" << std::endl;);
+ TRACE("str", tout << "SKIP: a1_arg0 =~ a2_arg0 and a1_arg1 =~ a2_arg1" << std::endl;);
return;
} else {
- TRACE("t_str_detail", tout << "quick path 1-1: a1_arg0 =~ a2_arg0" << std::endl;);
+ TRACE("str", tout << "quick path 1-1: a1_arg0 =~ a2_arg0" << std::endl;);
expr_ref premise(m.mk_and(ctx.mk_eq_atom(nn1, nn2), ctx.mk_eq_atom(a1_arg0, a2_arg0)), m);
expr_ref conclusion(m.mk_and(ctx.mk_eq_atom(a1_arg1, a2_arg1), ctx.mk_eq_atom(mk_strlen(a1_arg1), mk_strlen(a2_arg1))), m);
assert_implication(premise, conclusion);
@@ -2558,7 +2558,7 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
}
} else {
if (in_same_eqc(a1_arg1, a2_arg1)) {
- TRACE("t_str_detail", tout << "quick path 1-2: a1_arg1 =~ a2_arg1" << std::endl;);
+ TRACE("str", tout << "quick path 1-2: a1_arg1 =~ a2_arg1" << std::endl;);
expr_ref premise(m.mk_and(ctx.mk_eq_atom(nn1, nn2), ctx.mk_eq_atom(a1_arg1, a2_arg1)), m);
expr_ref conclusion(m.mk_and(ctx.mk_eq_atom(a1_arg0, a2_arg0), ctx.mk_eq_atom(mk_strlen(a1_arg0), mk_strlen(a2_arg0))), m);
assert_implication(premise, conclusion);
@@ -2569,7 +2569,7 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
// quick path 2-1
if (a1_arg0_len_exists && a2_arg0_len_exists && a1_arg0_len == a2_arg0_len) {
if (!in_same_eqc(a1_arg0, a2_arg0)) {
- TRACE("t_str_detail", tout << "quick path 2-1: len(nn1.arg0) == len(nn2.arg0)" << std::endl;);
+ TRACE("str", tout << "quick path 2-1: len(nn1.arg0) == len(nn2.arg0)" << std::endl;);
expr_ref ax_l1(ctx.mk_eq_atom(nn1, nn2), m);
expr_ref ax_l2(ctx.mk_eq_atom(mk_strlen(a1_arg0), mk_strlen(a2_arg0)), m);
expr_ref ax_r1(ctx.mk_eq_atom(a1_arg0, a2_arg0), m);
@@ -2581,7 +2581,7 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
assert_implication(premise, conclusion);
if (opt_NoQuickReturn_IntegerTheory) {
- TRACE("t_str_detail", tout << "bypassing quick return from the end of this case" << std::endl;);
+ TRACE("str", tout << "bypassing quick return from the end of this case" << std::endl;);
} else {
return;
}
@@ -2590,7 +2590,7 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
if (a1_arg1_len_exists && a2_arg1_len_exists && a1_arg1_len == a2_arg1_len) {
if (!in_same_eqc(a1_arg1, a2_arg1)) {
- TRACE("t_str_detail", tout << "quick path 2-2: len(nn1.arg1) == len(nn2.arg1)" << std::endl;);
+ TRACE("str", tout << "quick path 2-2: len(nn1.arg1) == len(nn2.arg1)" << std::endl;);
expr_ref ax_l1(ctx.mk_eq_atom(nn1, nn2), m);
expr_ref ax_l2(ctx.mk_eq_atom(mk_strlen(a1_arg1), mk_strlen(a2_arg1)), m);
expr_ref ax_r1(ctx.mk_eq_atom(a1_arg0, a2_arg0), m);
@@ -2601,7 +2601,7 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
assert_implication(premise, conclusion);
if (opt_NoQuickReturn_IntegerTheory) {
- TRACE("t_str_detail", tout << "bypassing quick return from the end of this case" << std::endl;);
+ TRACE("str", tout << "bypassing quick return from the end of this case" << std::endl;);
} else {
return;
}
@@ -2613,17 +2613,17 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
app * a_new_nn1 = to_app(new_nn1);
app * a_new_nn2 = to_app(new_nn2);
- TRACE("t_str_detail", tout << "new_nn1 = " << mk_ismt2_pp(new_nn1, m) << std::endl
+ TRACE("str", tout << "new_nn1 = " << mk_ismt2_pp(new_nn1, m) << std::endl
<< "new_nn2 = " << mk_ismt2_pp(new_nn2, m) << std::endl;);
if (new_nn1 == new_nn2) {
- TRACE("t_str_detail", tout << "equal concats, return" << std::endl;);
+ TRACE("str", tout << "equal concats, return" << std::endl;);
return;
}
if (!can_two_nodes_eq(new_nn1, new_nn2)) {
expr_ref detected(m.mk_not(ctx.mk_eq_atom(new_nn1, new_nn2)), m);
- TRACE("t_str_detail", tout << "inconsistency detected: " << mk_ismt2_pp(detected, m) << std::endl;);
+ TRACE("str", tout << "inconsistency detected: " << mk_ismt2_pp(detected, m) << std::endl;);
assert_axiom(detected);
return;
}
@@ -2633,13 +2633,13 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
bool n1IsConcat = u.str.is_concat(a_new_nn1);
bool n2IsConcat = u.str.is_concat(a_new_nn2);
if (!n1IsConcat && n2IsConcat) {
- TRACE("t_str_detail", tout << "nn1_new is not a concat" << std::endl;);
+ TRACE("str", tout << "nn1_new is not a concat" << std::endl;);
if (u.str.is_string(a_new_nn1)) {
simplify_parent(new_nn2, new_nn1);
}
return;
} else if (n1IsConcat && !n2IsConcat) {
- TRACE("t_str_detail", tout << "nn2_new is not a concat" << std::endl;);
+ TRACE("str", tout << "nn2_new is not a concat" << std::endl;);
if (u.str.is_string(a_new_nn2)) {
simplify_parent(new_nn1, new_nn2);
}
@@ -2647,7 +2647,7 @@ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
} else if (!n1IsConcat && !n2IsConcat) {
// normally this should never happen, because group_terms_by_eqc() should have pre-simplified
// as much as possible. however, we make a defensive check here just in case
- TRACE("t_str_detail", tout << "WARNING: nn1_new and nn2_new both simplify to non-concat terms" << std::endl;);
+ TRACE("str", tout << "WARNING: nn1_new and nn2_new both simplify to non-concat terms" << std::endl;);
return;
}
@@ -2750,7 +2750,7 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
expr * v2_arg0 = a_new_nn2->get_arg(0);
expr * v2_arg1 = a_new_nn2->get_arg(1);
- TRACE("t_str_detail", tout << "checking whether " << mk_pp(new_nn1, m) << " and " << mk_pp(new_nn1, m) << " might overlap." << std::endl;);
+ TRACE("str", tout << "checking whether " << mk_pp(new_nn1, m) << " and " << mk_pp(new_nn1, m) << " might overlap." << std::endl;);
check_and_init_cut_var(v1_arg0);
check_and_init_cut_var(v1_arg1);
@@ -2761,17 +2761,17 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
// case 1: concat(x, y) = concat(m, n)
//*************************************************************
if (is_concat_eq_type1(new_nn1, new_nn2)) {
- TRACE("t_str_detail", tout << "Type 1 check." << std::endl;);
+ TRACE("str", tout << "Type 1 check." << std::endl;);
expr * x = to_app(new_nn1)->get_arg(0);
expr * y = to_app(new_nn1)->get_arg(1);
expr * m = to_app(new_nn2)->get_arg(0);
expr * n = to_app(new_nn2)->get_arg(1);
if (has_self_cut(m, y)) {
- TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
+ TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
return true;
} else if (has_self_cut(x, n)) {
- TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(x, tout); print_cut_var(n, tout););
+ TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(x, tout); print_cut_var(n, tout););
return true;
} else {
return false;
@@ -2799,7 +2799,7 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
}
if (has_self_cut(m, y)) {
- TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
+ TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
return true;
} else {
return false;
@@ -2826,7 +2826,7 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
x = v1_arg0;
}
if (has_self_cut(x, n)) {
- TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(x, tout); print_cut_var(n, tout););
+ TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(x, tout); print_cut_var(n, tout););
return true;
} else {
return false;
@@ -2868,14 +2868,14 @@ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
m = v1_arg0;
}
if (has_self_cut(m, y)) {
- TRACE("t_str_detail", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
+ TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
return true;
} else {
return false;
}
}
- TRACE("t_str_detail", tout << "warning: unrecognized concat case" << std::endl;);
+ TRACE("str", tout << "warning: unrecognized concat case" << std::endl;);
return false;
}
@@ -2902,17 +2902,17 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
bool overlapAssumptionUsed = false;
- TRACE("t_str_detail", tout << "process_concat_eq TYPE 1" << std::endl
+ TRACE("str", tout << "process_concat_eq TYPE 1" << std::endl
<< "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
expr * x = to_app(concatAst1)->get_arg(0);
@@ -2928,7 +2928,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
int splitType = -1;
if (x_len_exists && m_len_exists) {
- TRACE("t_str_int", tout << "length values found: x/m" << std::endl;);
+ TRACE("str", tout << "length values found: x/m" << std::endl;);
if (x_len < m_len) {
splitType = 0;
} else if (x_len == m_len) {
@@ -2939,7 +2939,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
if (splitType == -1 && y_len_exists && n_len_exists) {
- TRACE("t_str_int", tout << "length values found: y/n" << std::endl;);
+ TRACE("str", tout << "length values found: y/n" << std::endl;);
if (y_len > n_len) {
splitType = 0;
} else if (y_len == n_len) {
@@ -2949,7 +2949,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
}
- TRACE("t_str_detail", tout
+ TRACE("str", tout
<< "len(x) = " << (x_len_exists ? x_len.to_string() : "?") << std::endl
<< "len(y) = " << (y_len_exists ? y_len.to_string() : "?") << std::endl
<< "len(m) = " << (m_len_exists ? m_len.to_string() : "?") << std::endl
@@ -2996,7 +2996,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
}
}
- TRACE("t_str_detail", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
<< "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
if (!entry1InScope && !entry2InScope) {
@@ -3076,8 +3076,8 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
assert_implication(ax_l, tester);
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+ TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
@@ -3139,8 +3139,8 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
assert_implication(ax_l, tester);
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+ TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
@@ -3195,8 +3195,8 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
arrangement_disjunction.push_back(tester);
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+ TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
@@ -3244,8 +3244,8 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
arrangement_disjunction.push_back(tester);
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("t_str_detail", {print_cut_var(x, tout); print_cut_var(n, tout);});
+ TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ TRACE("str", {print_cut_var(x, tout); print_cut_var(n, tout);});
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
@@ -3282,7 +3282,7 @@ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
// assert mutual exclusion between each branch of the arrangement
generate_mutual_exclusion(arrangement_disjunction);
} else {
- TRACE("t_str", tout << "STOP: no split option found for two EQ concats." << std::endl;);
+ TRACE("str", tout << "STOP: no split option found for two EQ concats." << std::endl;);
}
} // (splitType == -1)
}
@@ -3313,17 +3313,17 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
bool overlapAssumptionUsed = false;
- TRACE("t_str_detail", tout << "process_concat_eq TYPE 2" << std::endl
+ TRACE("str", tout << "process_concat_eq TYPE 2" << std::endl
<< "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
@@ -3400,7 +3400,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
}
}
- TRACE("t_str_detail", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
<< "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
@@ -3439,7 +3439,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
splitType = 2;
}
- TRACE("t_str_detail", tout << "Split type " << splitType << std::endl;);
+ TRACE("str", tout << "Split type " << splitType << std::endl;);
// Provide fewer split options when length information is available.
@@ -3491,8 +3491,8 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
assert_implication(ax_l, tester);
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
- TRACE("t_str", tout << "AVOID LOOP: SKIP" << std::endl;);
- TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+ TRACE("str", tout << "AVOID LOOP: SKIP" << std::endl;);
+ TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
@@ -3526,7 +3526,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
lenDelta = str_len - y_len;
}
- TRACE("t_str",
+ TRACE("str",
tout
<< "xLen? " << (x_len_exists ? "yes" : "no") << std::endl
<< "mLen? " << (m_len_exists ? "yes" : "no") << std::endl
@@ -3562,7 +3562,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
}
} else {
// negate! It's impossible to split str with these lengths
- TRACE("t_str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
+ TRACE("str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
expr_ref ax_l(mk_and(l_items), mgr);
assert_axiom(mgr.mk_not(ax_l));
}
@@ -3597,8 +3597,8 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
arrangement_disjunction.push_back(tester);
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("t_str_detail", {print_cut_var(m, tout); print_cut_var(y, tout);});
+ TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
@@ -3645,7 +3645,7 @@ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
}
generate_mutual_exclusion(arrangement_disjunction);
} else {
- TRACE("t_str", tout << "STOP: Should not split two EQ concats." << std::endl;);
+ TRACE("str", tout << "STOP: Should not split two EQ concats." << std::endl;);
}
} // (splitType == -1)
}
@@ -3676,17 +3676,17 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
bool overlapAssumptionUsed = false;
- TRACE("t_str_detail", tout << "process_concat_eq TYPE 3" << std::endl
+ TRACE("str", tout << "process_concat_eq TYPE 3" << std::endl
<< "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
@@ -3756,7 +3756,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
}
}
- TRACE("t_str_detail", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
<< "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
@@ -3798,7 +3798,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
splitType = 2;
}
- TRACE("t_str_detail", tout << "Split type " << splitType << std::endl;);
+ TRACE("str", tout << "Split type " << splitType << std::endl;);
// Provide fewer split options when length information is available.
if (splitType == 0) {
@@ -3836,7 +3836,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
}
} else {
// negate! It's impossible to split str with these lengths
- TRACE("t_str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
+ TRACE("str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
assert_axiom(mgr.mk_not(ax_l));
}
}
@@ -3899,8 +3899,8 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
assert_implication(ax_l, tester);
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("t_str_detail", {print_cut_var(x, tout); print_cut_var(n, tout);});
+ TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ TRACE("str", {print_cut_var(x, tout); print_cut_var(n, tout);});
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
@@ -3983,8 +3983,8 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
arrangement_disjunction.push_back(tester);
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
- TRACE("t_str_detail", {print_cut_var(x, tout); print_cut_var(n, tout);});
+ TRACE("str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
+ TRACE("str", {print_cut_var(x, tout); print_cut_var(n, tout);});
if (!overlapAssumptionUsed) {
overlapAssumptionUsed = true;
@@ -4007,7 +4007,7 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
}
generate_mutual_exclusion(arrangement_disjunction);
} else {
- TRACE("t_str", tout << "STOP: should not split two eq. concats" << std::endl;);
+ TRACE("str", tout << "STOP: should not split two eq. concats" << std::endl;);
}
}
@@ -4033,17 +4033,17 @@ bool theory_str::is_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
ast_manager & mgr = get_manager();
context & ctx = get_context();
- TRACE("t_str_detail", tout << "process_concat_eq TYPE 4" << std::endl
+ TRACE("str", tout << "process_concat_eq TYPE 4" << std::endl
<< "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
@@ -4066,7 +4066,7 @@ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
int commonLen = (str1Len > str2Len) ? str2Len : str1Len;
if (str1Value.extract(0, commonLen) != str2Value.extract(0, commonLen)) {
- TRACE("t_str_detail", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
+ TRACE("str", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
<< " has no common prefix with " << mk_ismt2_pp(concatAst2, mgr) << std::endl;);
expr_ref toNegate(mgr.mk_not(ctx.mk_eq_atom(concatAst1, concatAst2)), mgr);
assert_axiom(toNegate);
@@ -4134,17 +4134,17 @@ bool theory_str::is_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
ast_manager & mgr = get_manager();
context & ctx = get_context();
- TRACE("t_str_detail", tout << "process_concat_eq TYPE 5" << std::endl
+ TRACE("str", tout << "process_concat_eq TYPE 5" << std::endl
<< "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
@@ -4167,7 +4167,7 @@ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
int cLen = (str1Len > str2Len) ? str2Len : str1Len;
if (str1Value.extract(str1Len - cLen, cLen) != str2Value.extract(str2Len - cLen, cLen)) {
- TRACE("t_str_detail", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
+ TRACE("str", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
<< " has no common suffix with " << mk_ismt2_pp(concatAst2, mgr) << std::endl;);
expr_ref toNegate(mgr.mk_not(ctx.mk_eq_atom(concatAst1, concatAst2)), mgr);
assert_axiom(toNegate);
@@ -4235,17 +4235,17 @@ bool theory_str::is_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
ast_manager & mgr = get_manager();
context & ctx = get_context();
- TRACE("t_str_detail", tout << "process_concat_eq TYPE 6" << std::endl
+ TRACE("str", tout << "process_concat_eq TYPE 6" << std::endl
<< "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
<< "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
);
if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("t_str_detail", tout << "concatAst1 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
return;
}
if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("t_str_detail", tout << "concatAst2 is not a concat function" << std::endl;);
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
return;
}
@@ -4334,7 +4334,7 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
}
}
- TRACE("t_str_detail", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
<< "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
if (!entry1InScope && !entry2InScope) {
@@ -4389,8 +4389,8 @@ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
arrangement_disjunction.push_back(tester);
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
- TRACE("t_str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
- TRACE("t_str", print_cut_var(m, tout); print_cut_var(y, tout););
+ TRACE("str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
+ TRACE("str", print_cut_var(m, tout); print_cut_var(y, tout););
// only add the overlap assumption one time
if (!overlapAssumptionUsed) {
@@ -4465,7 +4465,7 @@ void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr)
zstring strValue;
u.str.is_string(constStr, strValue);
- TRACE("t_str_detail", tout << "unrollFunc: " << mk_pp(unrollFunc, m) << std::endl
+ TRACE("str", tout << "unrollFunc: " << mk_pp(unrollFunc, m) << std::endl
<< "constStr: " << mk_pp(constStr, m) << std::endl;);
if (strValue == "") {
@@ -4482,7 +4482,7 @@ void theory_str::process_concat_eq_unroll(expr * concat, expr * unroll) {
context & ctx = get_context();
ast_manager & mgr = get_manager();
- TRACE("t_str_detail", tout << "concat = " << mk_pp(concat, mgr) << ", unroll = " << mk_pp(unroll, mgr) << std::endl;);
+ TRACE("str", tout << "concat = " << mk_pp(concat, mgr) << ", unroll = " << mk_pp(unroll, mgr) << std::endl;);
std::pair<expr*, expr*> key = std::make_pair(concat, unroll);
expr_ref toAssert(mgr);
@@ -4613,7 +4613,7 @@ static theory_mi_arith* get_th_arith(context& ctx, theory_id afid, expr* e) {
bool theory_str::get_value(expr* e, rational& val) const {
if (opt_DisableIntegerTheoryIntegration) {
- TRACE("t_str_detail", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
return false;
}
@@ -4623,28 +4623,28 @@ bool theory_str::get_value(expr* e, rational& val) const {
if (!tha) {
return false;
}
- TRACE("t_str_int", tout << "checking eqc of " << mk_pp(e, m) << " for arithmetic value" << std::endl;);
+ TRACE("str", tout << "checking eqc of " << mk_pp(e, m) << " for arithmetic value" << std::endl;);
expr_ref _val(m);
enode * en_e = ctx.get_enode(e);
enode * it = en_e;
do {
if (m_autil.is_numeral(it->get_owner(), val) && val.is_int()) {
// found an arithmetic term
- TRACE("t_str_int", tout << mk_pp(it->get_owner(), m) << " is an integer ( ~= " << val << " )"
+ TRACE("str", tout << mk_pp(it->get_owner(), m) << " is an integer ( ~= " << val << " )"
<< std::endl;);
return true;
} else {
- TRACE("t_str_int", tout << mk_pp(it->get_owner(), m) << " not a numeral" << std::endl;);
+ TRACE("str", tout << mk_pp(it->get_owner(), m) << " not a numeral" << std::endl;);
}
it = it->get_next();
} while (it != en_e);
- TRACE("t_str_int", tout << "no arithmetic values found in eqc" << std::endl;);
+ TRACE("str", tout << "no arithmetic values found in eqc" << std::endl;);
return false;
}
bool theory_str::lower_bound(expr* _e, rational& lo) {
if (opt_DisableIntegerTheoryIntegration) {
- TRACE("t_str_detail", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
return false;
}
@@ -4658,7 +4658,7 @@ bool theory_str::lower_bound(expr* _e, rational& lo) {
bool theory_str::upper_bound(expr* _e, rational& hi) {
if (opt_DisableIntegerTheoryIntegration) {
- TRACE("t_str_detail", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
return false;
}
@@ -4672,7 +4672,7 @@ bool theory_str::upper_bound(expr* _e, rational& hi) {
bool theory_str::get_len_value(expr* e, rational& val) {
if (opt_DisableIntegerTheoryIntegration) {
- TRACE("t_str_detail", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
return false;
}
@@ -4681,16 +4681,16 @@ bool theory_str::get_len_value(expr* e, rational& val) {
theory* th = ctx.get_theory(m_autil.get_family_id());
if (!th) {
- TRACE("t_str_int", tout << "oops, can't get m_autil's theory" << std::endl;);
+ TRACE("str", tout << "oops, can't get m_autil's theory" << std::endl;);
return false;
}
theory_mi_arith* tha = dynamic_cast<theory_mi_arith*>(th);
if (!tha) {
- TRACE("t_str_int", tout << "oops, can't cast to theory_mi_arith" << std::endl;);
+ TRACE("str", tout << "oops, can't cast to theory_mi_arith" << std::endl;);
return false;
}
- TRACE("t_str_int", tout << "checking len value of " << mk_ismt2_pp(e, m) << std::endl;);
+ TRACE("str", tout << "checking len value of " << mk_ismt2_pp(e, m) << std::endl;);
rational val1;
expr_ref len(m), len_val(m);
@@ -4717,7 +4717,7 @@ bool theory_str::get_len_value(expr* e, rational& val) {
len = mk_strlen(c);
// debugging
- TRACE("t_str_int", {
+ TRACE("str", {
tout << mk_pp(len, m) << ":" << std::endl
<< (ctx.is_relevant(len.get()) ? "relevant" : "not relevant") << std::endl
<< (ctx.e_internalized(len) ? "internalized" : "not internalized") << std::endl
@@ -4742,16 +4742,16 @@ bool theory_str::get_len_value(expr* e, rational& val) {
if (ctx.e_internalized(len) && get_value(len, val1)) {
val += val1;
- TRACE("t_str_int", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has length " << val1 << std::endl;);
+ TRACE("str", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has length " << val1 << std::endl;);
}
else {
- TRACE("t_str_int", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has no length assignment; bailing out" << std::endl;);
+ TRACE("str", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has no length assignment; bailing out" << std::endl;);
return false;
}
}
}
- TRACE("t_str_int", tout << "length of " << mk_ismt2_pp(e, m) << " is " << val << std::endl;);
+ TRACE("str", tout << "length of " << mk_ismt2_pp(e, m) << " is " << val << std::endl;);
return val.is_int();
}
@@ -4769,11 +4769,11 @@ bool theory_str::in_same_eqc(expr * n1, expr * n2) {
// that we've set this up properly for the context
if (!ctx.e_internalized(n1)) {
- TRACE("t_str_detail", tout << "WARNING: expression " << mk_ismt2_pp(n1, m) << " was not internalized" << std::endl;);
+ TRACE("str", tout << "WARNING: expression " << mk_ismt2_pp(n1, m) << " was not internalized" << std::endl;);
ctx.internalize(n1, false);
}
if (!ctx.e_internalized(n2)) {
- TRACE("t_str_detail", tout << "WARNING: expression " << mk_ismt2_pp(n2, m) << " was not internalized" << std::endl;);
+ TRACE("str", tout << "WARNING: expression " << mk_ismt2_pp(n2, m) << " was not internalized" << std::endl;);
ctx.internalize(n2, false);
}
@@ -4824,7 +4824,7 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
context & ctx = get_context();
ast_manager & m = get_manager();
- TRACE("t_str_detail", tout << "varNode = " << mk_pp(varNode, m) << ", constNode = " << mk_pp(constNode, m) << std::endl;);
+ TRACE("str", tout << "varNode = " << mk_pp(varNode, m) << ", constNode = " << mk_pp(constNode, m) << std::endl;);
expr_ref_vector litems(m);
@@ -4836,7 +4836,7 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
expr * boolVar;
if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
- TRACE("t_str_detail", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
+ TRACE("str", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
}
// boolVar is actually a Contains term
app * containsApp = to_app(boolVar);
@@ -4844,13 +4844,13 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
// we only want to inspect the Contains terms where either of strAst or substrAst
// are equal to varNode.
- TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
+ TRACE("t_str_detail", tout << "considering Contains with strAst = "str", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
if (varNode != strAst && varNode != substrAst) {
- TRACE("t_str_detail", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
+ TRACE("str", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
continue;
}
- TRACE("t_str_detail", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
+ TRACE("str", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
// varEqcNode is str
if (strAst == varNode) {
@@ -4873,7 +4873,7 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
zstring subStrConst;
u.str.is_string(substrValue, subStrConst);
- TRACE("t_str_detail", tout << "strConst = " << strConst << ", subStrConst = " << subStrConst << "\n";);
+ TRACE("t_str_detail", tout << "strConst = "str", subStrConst = " << subStrConst << "\n";);
if (strConst.contains(subStrConst)) {
//implyR = ctx.mk_eq(ctx, boolVar, Z3_mk_true(ctx));
@@ -4914,7 +4914,7 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
}
}
if (counterEgFound) {
- TRACE("t_str_detail", tout << "Inconsistency found!" << std::endl;);
+ TRACE("str", tout << "Inconsistency found!" << std::endl;);
break;
}
}
@@ -4975,7 +4975,7 @@ void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willE
expr * boolVar;
if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
- TRACE("t_str_detail", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
+ TRACE("str", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
}
// boolVar is actually a Contains term
app * containsApp = to_app(boolVar);
@@ -4983,19 +4983,19 @@ void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willE
// we only want to inspect the Contains terms where either of strAst or substrAst
// are equal to varNode.
- TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
+ TRACE("t_str_detail", tout << "considering Contains with strAst = "str", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
if (varNode != strAst && varNode != substrAst) {
- TRACE("t_str_detail", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
+ TRACE("str", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
continue;
}
- TRACE("t_str_detail", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
+ TRACE("str", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
if (substrAst == varNode) {
bool strAstHasVal = false;
expr * strValue = get_eqc_value(strAst, strAstHasVal);
if (strAstHasVal) {
- TRACE("t_str_detail", tout << mk_pp(strAst, m) << " has constant eqc value " << mk_pp(strValue, m) << std::endl;);
+ TRACE("str", tout << mk_pp(strAst, m) << " has constant eqc value " << mk_pp(strValue, m) << std::endl;);
if (strValue != strAst) {
litems.push_back(ctx.mk_eq_atom(strAst, strValue));
}
@@ -5014,7 +5014,7 @@ void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willE
zstring pieceStr;
u.str.is_string(*cstItor, pieceStr);
if (!strConst.contains(pieceStr)) {
- TRACE("t_str_detail", tout << "Inconsistency found!" << std::endl;);
+ TRACE("str", tout << "Inconsistency found!" << std::endl;);
counterEgFound = true;
if (aConcat != substrAst) {
litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
@@ -5082,7 +5082,7 @@ void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
expr * subValue1 = get_eqc_value(subAst1, subAst1HasValue);
expr * subValue2 = get_eqc_value(subAst2, subAst2HasValue);
- TRACE("t_str_detail",
+ TRACE("str",
tout << "(Contains " << mk_pp(n1, m) << " " << mk_pp(subAst1, m) << ")" << std::endl;
tout << "(Contains " << mk_pp(n2, m) << " " << mk_pp(subAst2, m) << ")" << std::endl;
if (subAst1 != subValue1) {
@@ -5182,7 +5182,7 @@ void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
}
std::pair<expr*, expr*> tryKey1 = std::make_pair(eqSubVar1, eqSubVar2);
if (contain_pair_bool_map.contains(tryKey1)) {
- TRACE("t_str_detail", tout << "(Contains " << mk_pp(eqSubVar1, m) << " " << mk_pp(eqSubVar2, m) << ")" << std::endl;);
+ TRACE("str", tout << "(Contains " << mk_pp(eqSubVar1, m) << " " << mk_pp(eqSubVar2, m) << ")" << std::endl;);
litems3.push_back(contain_pair_bool_map[tryKey1]);
expr_ref implR(rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
assert_implication(mk_and(litems3), implR);
@@ -5207,7 +5207,7 @@ void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
}
std::pair<expr*, expr*> tryKey2 = std::make_pair(eqSubVar2, eqSubVar1);
if (contain_pair_bool_map.contains(tryKey2)) {
- TRACE("t_str_detail", tout << "(Contains " << mk_pp(eqSubVar2, m) << " " << mk_pp(eqSubVar1, m) << ")" << std::endl;);
+ TRACE("str", tout << "(Contains " << mk_pp(eqSubVar2, m) << " " << mk_pp(eqSubVar1, m) << ")" << std::endl;);
litems4.push_back(contain_pair_bool_map[tryKey2]);
expr_ref implR(rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]), m);
assert_implication(mk_and(litems4), implR);
@@ -5229,7 +5229,7 @@ void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
expr * strVal1 = get_eqc_value(str1, str1HasValue);
expr * strVal2 = get_eqc_value(str2, str2HasValue);
- TRACE("t_str_detail",
+ TRACE("str",
tout << "(Contains " << mk_pp(str1, m) << " " << mk_pp(n1, m) << ")" << std::endl;
tout << "(Contains " << mk_pp(str2, m) << " " << mk_pp(n2, m) << ")" << std::endl;
if (str1 != strVal1) {
@@ -5328,7 +5328,7 @@ void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
}
std::pair<expr*, expr*> tryKey1 = std::make_pair(eqStrVar1, eqStrVar2);
if (contain_pair_bool_map.contains(tryKey1)) {
- TRACE("t_str_detail", tout << "(Contains " << mk_pp(eqStrVar1, m) << " " << mk_pp(eqStrVar2, m) << ")" << std::endl;);
+ TRACE("str", tout << "(Contains " << mk_pp(eqStrVar1, m) << " " << mk_pp(eqStrVar2, m) << ")" << std::endl;);
litems3.push_back(contain_pair_bool_map[tryKey1]);
// ------------
@@ -5356,7 +5356,7 @@ void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
std::pair<expr*, expr*> tryKey2 = std::make_pair(eqStrVar2, eqStrVar1);
if (contain_pair_bool_map.contains(tryKey2)) {
- TRACE("t_str_detail", tout << "(Contains " << mk_pp(eqStrVar2, m) << " " << mk_pp(eqStrVar1, m) << ")" << std::endl;);
+ TRACE("str", tout << "(Contains " << mk_pp(eqStrVar2, m) << " " << mk_pp(eqStrVar1, m) << ")" << std::endl;);
litems4.push_back(contain_pair_bool_map[tryKey2]);
// ------------
// key1.first = key2.first /\ containPairBoolMap[<eqc(key2.second), eqc(key1.second)>]
@@ -5388,14 +5388,14 @@ void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
context & ctx = get_context();
ast_manager & m = get_manager();
- TRACE("t_str_detail", tout << "consistency check for contains wrt. " << mk_pp(n1, m) << " and " << mk_pp(n2, m) << std::endl;);
+ TRACE("str", tout << "consistency check for contains wrt. " << mk_pp(n1, m) << " and " << mk_pp(n2, m) << std::endl;);
expr_ref_vector willEqClass(m);
expr * constStrAst_1 = collect_eq_nodes(n1, willEqClass);
expr * constStrAst_2 = collect_eq_nodes(n2, willEqClass);
expr * constStrAst = (constStrAst_1 != NULL) ? constStrAst_1 : constStrAst_2;
- TRACE("t_str_detail", tout << "eqc of n1 is {";
+ TRACE("str", tout << "eqc of n1 is {";
for (expr_ref_vector::iterator it = willEqClass.begin(); it != willEqClass.end(); ++it) {
expr * el = *it;
tout << " " << mk_pp(el, m);
@@ -5589,11 +5589,11 @@ void theory_str::get_grounded_concats(expr* node, std::map<expr*, expr*> & varAl
void theory_str::print_grounded_concat(expr * node, std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap) {
ast_manager & m = get_manager();
- TRACE("t_str_detail", tout << mk_pp(node, m) << std::endl;);
+ TRACE("str", tout << mk_pp(node, m) << std::endl;);
if (groundedMap.find(node) != groundedMap.end()) {
std::map<std::vector<expr*>, std::set<expr*> >::iterator itor = groundedMap[node].begin();
for (; itor != groundedMap[node].end(); ++itor) {
- TRACE("t_str_detail",
+ TRACE("str",
tout << "\t[grounded] ";
std::vector<expr*>::const_iterator vIt = itor->first.begin();
for (; vIt != itor->first.end(); ++vIt) {
@@ -5609,7 +5609,7 @@ void theory_str::print_grounded_concat(expr * node, std::map<expr*, std::map<std
);
}
} else {
- TRACE("t_str_detail", tout << "not found" << std::endl;);
+ TRACE("str", tout << "not found" << std::endl;);
}
}
@@ -5933,12 +5933,12 @@ bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
if (!u.str.is_string(args[i])) {
items.push_back(ctx.mk_eq_atom(mk_strlen(args[i]), mk_int(argLen)));
}
- TRACE("t_str_detail", tout << "concat arg: " << mk_pp(args[i], mgr) << " has len = " << argLen.to_string() << std::endl;);
+ TRACE("str", tout << "concat arg: " << mk_pp(args[i], mgr) << " has len = " << argLen.to_string() << std::endl;);
sumLen += argLen;
if (sumLen > strLen) {
items.push_back(ctx.mk_eq_atom(n1, constStr));
expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
- TRACE("t_str_detail", tout << "inconsistent length: concat (len = " << sumLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
+ TRACE("str", tout << "inconsistent length: concat (len = " << sumLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
assert_axiom(toAssert);
return false;
}
@@ -5948,7 +5948,7 @@ bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
rational oLen;
bool oLen_exists = get_len_value(n1, oLen);
if (oLen_exists && oLen != strLen) {
- TRACE("t_str_detail", tout << "inconsistent length: var (len = " << oLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
+ TRACE("str", tout << "inconsistent length: var (len = " << oLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
expr_ref l(ctx.mk_eq_atom(n1, constStr), mgr);
expr_ref r(ctx.mk_eq_atom(mk_strlen(n1), mk_strlen(constStr)), mgr);
assert_implication(l, r);
@@ -6027,7 +6027,7 @@ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
}
if (conflict) {
- TRACE("t_str_detail", tout << "inconsistent length detected in concat <==> concat" << std::endl;);
+ TRACE("str", tout << "inconsistent length detected in concat <==> concat" << std::endl;);
expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
assert_axiom(toAssert);
return false;
@@ -6058,7 +6058,7 @@ bool theory_str::check_length_concat_var(expr * concat, expr * var) {
}
sumLen += argLen;
if (sumLen > varLen) {
- TRACE("t_str_detail", tout << "inconsistent length detected in concat <==> var" << std::endl;);
+ TRACE("str", tout << "inconsistent length detected in concat <==> var" << std::endl;);
items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_int(varLen)));
items.push_back(ctx.mk_eq_atom(concat, var));
expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
@@ -6080,7 +6080,7 @@ bool theory_str::check_length_var_var(expr * var1, expr * var2) {
bool var2Len_exists = get_len_value(var2, var2Len);
if (var1Len_exists && var2Len_exists && var1Len != var2Len) {
- TRACE("t_str_detail", tout << "inconsistent length detected in var <==> var" << std::endl;);
+ TRACE("str", tout << "inconsistent length detected in var <==> var" << std::endl;);
expr_ref_vector items(mgr);
items.push_back(ctx.mk_eq_atom(mk_strlen(var1), mk_int(var1Len)));
items.push_back(ctx.mk_eq_atom(mk_strlen(var2), mk_int(var2Len)));
@@ -6164,7 +6164,7 @@ void nfa::convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u) {
expr * arg_str = a->get_arg(0);
zstring str;
if (u.str.is_string(arg_str, str)) {
- TRACE("t_str_rw", tout << "build NFA for '" << str << "'" << "\n";);
+ TRACE("str", tout << "build NFA for '" << str << "'" << "\n";);
/*
* For an n-character string, we make (n-1) intermediate states,
@@ -6176,14 +6176,14 @@ void nfa::convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u) {
for (int i = 0; i <= ((int)str.length()) - 2; ++i) {
unsigned i_state = next_id();
make_transition(last, str[i], i_state);
- TRACE("t_str_rw", tout << "string transition " << last << "--" << str[i] << "--> " << i_state << "\n";);
+ TRACE("str", tout << "string transition " << last << "--" << str[i] << "--> " << i_state << "\n";);
last = i_state;
}
make_transition(last, str[(str.length() - 1)], end);
- TRACE("t_str_rw", tout << "string transition " << last << "--" << str[(str.length() - 1)] << "--> " << end << "\n";);
- TRACE("t_str_rw", tout << "string NFA: start = " << start << ", end = " << end << std::endl;);
+ TRACE("str", tout << "string transition " << last << "--" << str[(str.length() - 1)] << "--> " << end << "\n";);
+ TRACE("t_str_rw", tout << "str", end = " << end << std::endl;);
} else {
- TRACE("t_str_rw", tout << "invalid string constant in Str2Reg" << std::endl;);
+ TRACE("str", tout << "invalid string constant in Str2Reg" << std::endl;);
m_valid = false;
return;
}
@@ -6199,7 +6199,7 @@ void nfa::convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u) {
make_epsilon_move(start, start1);
make_epsilon_move(end1, start2);
make_epsilon_move(end2, end);
- TRACE("t_str_rw", tout << "concat NFA: start = " << start << ", end = " << end << std::endl;);
+ TRACE("str", tout << "concat NFA: start = " << start << ", end = " << end << std::endl;);
} else if (u.re.is_union(e)) {
app * a = to_app(e);
expr * re1 = a->get_arg(0);
@@ -6215,7 +6215,7 @@ void nfa::convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u) {
make_epsilon_move(start, start2);
make_epsilon_move(end1, end);
make_epsilon_move(end2, end);
- TRACE("t_str_rw", tout << "union NFA: start = " << start << ", end = " << end << std::endl;);
+ TRACE("str", tout << "union NFA: start = " << start << ", end = " << end << std::endl;);
} else if (u.re.is_star(e)) {
app * a = to_app(e);
expr * subex = a->get_arg(0);
@@ -6227,9 +6227,9 @@ void nfa::convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u) {
make_epsilon_move(start, end);
make_epsilon_move(end_subex, start_subex);
make_epsilon_move(end_subex, end);
- TRACE("t_str_rw", tout << "star NFA: start = " << start << ", end = " << end << std::endl;);
+ TRACE("str", tout << "star NFA: start = " << start << ", end = " << end << std::endl;);
} else {
- TRACE("t_str_rw", tout << "invalid regular expression" << std::endl;);
+ TRACE("str", tout << "invalid regular expression" << std::endl;);
m_valid = false;
return;
}
@@ -6327,17 +6327,17 @@ void theory_str::check_regex_in(expr * nn1, expr * nn2) {
// TODO figure out regex NFA stuff
if (regex_nfa_cache.find(regexTerm) == regex_nfa_cache.end()) {
- TRACE("t_str_detail", tout << "regex_nfa_cache: cache miss" << std::endl;);
+ TRACE("str", tout << "regex_nfa_cache: cache miss" << std::endl;);
regex_nfa_cache[regexTerm] = nfa(u, regexTerm);
} else {
- TRACE("t_str_detail", tout << "regex_nfa_cache: cache hit" << std::endl;);
+ TRACE("str", tout << "regex_nfa_cache: cache hit" << std::endl;);
}
nfa regexNFA = regex_nfa_cache[regexTerm];
ENSURE(regexNFA.is_valid());
bool matchRes = regexNFA.matches(constStrValue);
- TRACE("t_str_detail", tout << mk_pp(*itor, m) << " in " << regStr << " : " << (matchRes ? "yes" : "no") << std::endl;);
+ TRACE("str", tout << mk_pp(*itor, m) << " in " << regStr << " : " << (matchRes ? "yes" : "no") << std::endl;);
expr_ref implyL(ctx.mk_eq_atom(*itor, constStr), m);
if (matchRes) {
@@ -6362,7 +6362,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
ast_manager & m = get_manager();
context & ctx = get_context();
- TRACE("t_str_detail", tout << mk_ismt2_pp(concat, m) << " == " << mk_ismt2_pp(str, m) << std::endl;);
+ TRACE("str", tout << mk_ismt2_pp(concat, m) << " == " << mk_ismt2_pp(str, m) << std::endl;);
zstring const_str;
if (u.str.is_concat(to_app(concat)) && u.str.is_string(to_app(str), const_str)) {
@@ -6372,7 +6372,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
expr * a2 = a_concat->get_arg(1);
if (const_str.empty()) {
- TRACE("t_str", tout << "quick path: concat == \"\"" << std::endl;);
+ TRACE("str", tout << "quick path: concat == \"\"" << std::endl;);
// assert the following axiom:
// ( (Concat a1 a2) == "" ) -> ( (a1 == "") AND (a2 == "") )
@@ -6391,7 +6391,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
expr * arg2 = get_eqc_value(a2, arg2_has_eqc_value);
expr_ref newConcat(m);
if (arg1 != a1 || arg2 != a2) {
- TRACE("t_str", tout << "resolved concat argument(s) to eqc string constants" << std::endl;);
+ TRACE("str", tout << "resolved concat argument(s) to eqc string constants" << std::endl;);
int iPos = 0;
expr_ref_vector item1(m);
if (a1 != arg1) {
@@ -6419,7 +6419,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
}
if (arg1_has_eqc_value && arg2_has_eqc_value) {
// Case 1: Concat(const, const) == const
- TRACE("t_str", tout << "Case 1: Concat(const, const) == const" << std::endl;);
+ TRACE("str", tout << "Case 1: Concat(const, const) == const" << std::endl;);
zstring arg1_str, arg2_str;
u.str.is_string(arg1, arg1_str);
u.str.is_string(arg2, arg2_str);
@@ -6427,7 +6427,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
zstring result_str = arg1_str + arg2_str;
if (result_str != const_str) {
// Inconsistency
- TRACE("t_str", tout << "inconsistency detected: \""
+ TRACE("str", tout << "inconsistency detected: \""
<< arg1_str << "\" + \"" << arg2_str <<
"\" != \"" << const_str << "\"" << "\n";);
expr_ref equality(ctx.mk_eq_atom(concat, str), m);
@@ -6437,14 +6437,14 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
}
} else if (!arg1_has_eqc_value && arg2_has_eqc_value) {
// Case 2: Concat(var, const) == const
- TRACE("t_str", tout << "Case 2: Concat(var, const) == const" << std::endl;);
+ TRACE("str", tout << "Case 2: Concat(var, const) == const" << std::endl;);
zstring arg2_str;
u.str.is_string(arg2, arg2_str);
unsigned int resultStrLen = const_str.length();
unsigned int arg2StrLen = arg2_str.length();
if (resultStrLen < arg2StrLen) {
// Inconsistency
- TRACE("t_str", tout << "inconsistency detected: \""
+ TRACE("str", tout << "inconsistency detected: \""
<< arg2_str <<
"\" is longer than \"" << const_str << "\","
<< " so cannot be concatenated with anything to form it" << "\n";);
@@ -6458,7 +6458,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
zstring secondPart = const_str.extract(varStrLen, arg2StrLen);
if (arg2_str != secondPart) {
// Inconsistency
- TRACE("t_str", tout << "inconsistency detected: "
+ TRACE("str", tout << "inconsistency detected: "
<< "suffix of concatenation result expected \"" << secondPart << "\", "
<< "actually \"" << arg2_str << "\""
<< "\n";);
@@ -6476,14 +6476,14 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
}
} else if (arg1_has_eqc_value && !arg2_has_eqc_value) {
// Case 3: Concat(const, var) == const
- TRACE("t_str", tout << "Case 3: Concat(const, var) == const" << std::endl;);
+ TRACE("str", tout << "Case 3: Concat(const, var) == const" << std::endl;);
zstring arg1_str;
u.str.is_string(arg1, arg1_str);
unsigned int resultStrLen = const_str.length();
unsigned int arg1StrLen = arg1_str.length();
if (resultStrLen < arg1StrLen) {
// Inconsistency
- TRACE("t_str", tout << "inconsistency detected: \""
+ TRACE("str", tout << "inconsistency detected: \""
<< arg1_str <<
"\" is longer than \"" << const_str << "\","
<< " so cannot be concatenated with anything to form it" << "\n";);
@@ -6497,7 +6497,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
zstring secondPart = const_str.extract(arg1StrLen, varStrLen);
if (arg1_str != firstPart) {
// Inconsistency
- TRACE("t_str", tout << "inconsistency detected: "
+ TRACE("str", tout << "inconsistency detected: "
<< "prefix of concatenation result expected \"" << secondPart << "\", "
<< "actually \"" << arg1_str << "\""
<< "\n";);
@@ -6515,7 +6515,7 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
}
} else {
// Case 4: Concat(var, var) == const
- TRACE("t_str", tout << "Case 4: Concat(var, var) == const" << std::endl;);
+ TRACE("str", tout << "Case 4: Concat(var, var) == const" << std::endl;);
if (eval_concat(arg1, arg2) == NULL) {
rational arg1Len, arg2Len;
bool arg1Len_exists = get_len_value(arg1, arg1Len);
@@ -6527,12 +6527,12 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
zstring prefixStr, suffixStr;
if (arg1Len_exists) {
if (arg1Len.is_neg()) {
- TRACE("t_str_detail", tout << "length conflict: arg1Len = " << arg1Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ TRACE("str", tout << "length conflict: arg1Len = " << arg1Len << ", concatStrLen = " << concatStrLen << std::endl;);
expr_ref toAssert(m_autil.mk_ge(mk_strlen(arg1), mk_int(0)), m);
assert_axiom(toAssert);
return;
} else if (arg1Len > concatStrLen) {
- TRACE("t_str_detail", tout << "length conflict: arg1Len = " << arg1Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ TRACE("str", tout << "length conflict: arg1Len = " << arg1Len << ", concatStrLen = " << concatStrLen << std::endl;);
expr_ref ax_r1(m_autil.mk_le(mk_strlen(arg1), mk_int(concatStrLen)), m);
assert_implication(ax_l1, ax_r1);
return;
@@ -6545,12 +6545,12 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
} else {
// arg2's length is available
if (arg2Len.is_neg()) {
- TRACE("t_str_detail", tout << "length conflict: arg2Len = " << arg2Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ TRACE("str", tout << "length conflict: arg2Len = " << arg2Len << ", concatStrLen = " << concatStrLen << std::endl;);
expr_ref toAssert(m_autil.mk_ge(mk_strlen(arg2), mk_int(0)), m);
assert_axiom(toAssert);
return;
} else if (arg2Len > concatStrLen) {
- TRACE("t_str_detail", tout << "length conflict: arg2Len = " << arg2Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ TRACE("str", tout << "length conflict: arg2Len = " << arg2Len << ", concatStrLen = " << concatStrLen << std::endl;);
expr_ref ax_r1(m_autil.mk_le(mk_strlen(arg2), mk_int(concatStrLen)), m);
assert_implication(ax_l1, ax_r1);
return;
@@ -6597,18 +6597,18 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
bool entry1InScope;
if (entry1 == varForBreakConcat.end()) {
- TRACE("t_str_detail", tout << "key1 no entry" << std::endl;);
+ TRACE("str", tout << "key1 no entry" << std::endl;);
entry1InScope = false;
} else {
// OVERRIDE.
entry1InScope = true;
- TRACE("t_str_detail", tout << "key1 entry" << std::endl;);
+ TRACE("str", tout << "key1 entry" << std::endl;);
/*
if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()) {
- TRACE("t_str_detail", tout << "key1 entry not in scope" << std::endl;);
+ TRACE("str", tout << "key1 entry not in scope" << std::endl;);
entry1InScope = false;
} else {
- TRACE("t_str_detail", tout << "key1 entry in scope" << std::endl;);
+ TRACE("str", tout << "key1 entry in scope" << std::endl;);
entry1InScope = true;
}
*/
@@ -6616,24 +6616,24 @@ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
bool entry2InScope;
if (entry2 == varForBreakConcat.end()) {
- TRACE("t_str_detail", tout << "key2 no entry" << std::endl;);
+ TRACE("str", tout << "key2 no entry" << std::endl;);
entry2InScope = false;
} else {
// OVERRIDE.
entry2InScope = true;
- TRACE("t_str_detail", tout << "key2 entry" << std::endl;);
+ TRACE("str", tout << "key2 entry" << std::endl;);
/*
if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()) {
- TRACE("t_str_detail", tout << "key2 entry not in scope" << std::endl;);
+ TRACE("str", tout << "key2 entry not in scope" << std::endl;);
entry2InScope = false;
} else {
- TRACE("t_str_detail", tout << "key2 entry in scope" << std::endl;);
+ TRACE("str", tout << "key2 entry in scope" << std::endl;);
entry2InScope = true;
}
*/
}
- TRACE("t_str_detail", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
<< "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
if (!entry1InScope && !entry2InScope) {
@@ -6702,14 +6702,14 @@ expr_ref theory_str::set_up_finite_model_test(expr * lhs, expr * rhs) {
context & ctx = get_context();
ast_manager & m = get_manager();
- TRACE("t_str", tout << "activating finite model testing for overlapping concats "
+ TRACE("str", tout << "activating finite model testing for overlapping concats "
<< mk_pp(lhs, m) << " and " << mk_pp(rhs, m) << std::endl;);
std::map<expr*, int> concatMap;
std::map<expr*, int> unrollMap;
std::map<expr*, int> varMap;
classify_ast_by_type(lhs, varMap, concatMap, unrollMap);
classify_ast_by_type(rhs, varMap, concatMap, unrollMap);
- TRACE("t_str_detail", tout << "found vars:";
+ TRACE("str", tout << "found vars:";
for (std::map<expr*,int>::iterator it = varMap.begin(); it != varMap.end(); ++it) {
tout << " " << mk_pp(it->first, m);
}
@@ -6743,20 +6743,20 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
zstring s;
if (!u.str.is_string(str, s)) return;
if (s == "yes") {
- TRACE("t_str", tout << "start finite model test for " << mk_pp(testvar, m) << std::endl;);
+ TRACE("str", tout << "start finite model test for " << mk_pp(testvar, m) << std::endl;);
ptr_vector<expr> & vars = finite_model_test_varlists[testvar];
for (ptr_vector<expr>::iterator it = vars.begin(); it != vars.end(); ++it) {
expr * v = *it;
bool v_has_eqc = false;
get_eqc_value(v, v_has_eqc);
if (v_has_eqc) {
- TRACE("t_str_detail", tout << "variable " << mk_pp(v,m) << " already equivalent to a string constant" << std::endl;);
+ TRACE("str", tout << "variable " << mk_pp(v,m) << " already equivalent to a string constant" << std::endl;);
continue;
}
// check for any sort of existing length tester we might interfere with
if (m_params.m_UseBinarySearch) {
if (binary_search_len_tester_stack.contains(v) && !binary_search_len_tester_stack[v].empty()) {
- TRACE("t_str_detail", tout << "already found existing length testers for " << mk_pp(v, m) << std::endl;);
+ TRACE("str", tout << "already found existing length testers for " << mk_pp(v, m) << std::endl;);
continue;
} else {
// start binary search as normal
@@ -6783,19 +6783,19 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
}
if (map_effectively_empty) {
- TRACE("t_str_detail", tout << "no existing length testers for " << mk_pp(v, m) << std::endl;);
+ TRACE("str", tout << "no existing length testers for " << mk_pp(v, m) << std::endl;);
rational v_len;
rational v_lower_bound;
rational v_upper_bound;
expr_ref vLengthExpr(mk_strlen(v), m);
if (get_len_value(v, v_len)) {
- TRACE("t_str_detail", tout << "length = " << v_len.to_string() << std::endl;);
+ TRACE("str", tout << "length = " << v_len.to_string() << std::endl;);
v_lower_bound = v_len;
v_upper_bound = v_len;
} else {
bool lower_bound_exists = lower_bound(vLengthExpr, v_lower_bound);
bool upper_bound_exists = upper_bound(vLengthExpr, v_upper_bound);
- TRACE("t_str_detail", tout << "bounds = [" << (lower_bound_exists?v_lower_bound.to_string():"?")
+ TRACE("str", tout << "bounds = [" << (lower_bound_exists?v_lower_bound.to_string():"?")
<< ".." << (upper_bound_exists?v_upper_bound.to_string():"?") << "]" << std::endl;);
// make sure the bounds are non-negative
@@ -6849,7 +6849,7 @@ void theory_str::finite_model_test(expr * testvar, expr * str) {
expr_ref implRhs(mk_and(andList), m);
assert_implication(implLhs, implRhs);
} else {
- TRACE("t_str_detail", tout << "already found existing length testers for " << mk_pp(v, m) << std::endl;);
+ TRACE("str", tout << "already found existing length testers for " << mk_pp(v, m) << std::endl;);
continue;
}
}
@@ -6862,7 +6862,7 @@ void theory_str::more_len_tests(expr * lenTester, zstring lenTesterValue) {
if (lenTester_fvar_map.contains(lenTester)) {
expr * fVar = lenTester_fvar_map[lenTester];
expr * toAssert = gen_len_val_options_for_free_var(fVar, lenTester, lenTesterValue);
- TRACE("t_str_detail", tout << "asserting more length tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
+ TRACE("str", tout << "asserting more length tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
if (toAssert != NULL) {
assert_axiom(toAssert);
}
@@ -6875,24 +6875,24 @@ void theory_str::more_value_tests(expr * valTester, zstring valTesterValue) {
expr * fVar = valueTester_fvar_map[valTester];
if (m_params.m_UseBinarySearch) {
if (!binary_search_len_tester_stack.contains(fVar) || binary_search_len_tester_stack[fVar].empty()) {
- TRACE("t_str_binary_search", tout << "WARNING: no active length testers for " << mk_pp(fVar, m) << std::endl;);
+ TRACE("str", tout << "WARNING: no active length testers for " << mk_pp(fVar, m) << std::endl;);
NOT_IMPLEMENTED_YET();
}
expr * effectiveLenInd = binary_search_len_tester_stack[fVar].back();
bool hasEqcValue;
expr * len_indicator_value = get_eqc_value(effectiveLenInd, hasEqcValue);
if (!hasEqcValue) {
- TRACE("t_str_binary_search", tout << "WARNING: length tester " << mk_pp(effectiveLenInd, m) << " at top of stack for " << mk_pp(fVar, m) << " has no EQC value" << std::endl;);
+ TRACE("str", tout << "WARNING: length tester " << mk_pp(effectiveLenInd, m) << " at top of stack for " << mk_pp(fVar, m) << " has no EQC value" << std::endl;);
} else {
// safety check
zstring effectiveLenIndiStr;
u.str.is_string(len_indicator_value, effectiveLenIndiStr);
if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "less") {
- TRACE("t_str_binary_search", tout << "ERROR: illegal state -- requesting 'more value tests' but a length tester is not yet concrete!" << std::endl;);
+ TRACE("str", tout << "ERROR: illegal state -- requesting 'more value tests' but a length tester is not yet concrete!" << std::endl;);
UNREACHABLE();
}
expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
- TRACE("t_str_detail", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
+ TRACE("str", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
if (valueAssert != NULL) {
assert_axiom(valueAssert);
}
@@ -6917,7 +6917,7 @@ void theory_str::more_value_tests(expr * valTester, zstring valTesterValue) {
}
}
expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
- TRACE("t_str_detail", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
+ TRACE("str", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
if (valueAssert != NULL) {
assert_axiom(valueAssert);
}
@@ -6928,13 +6928,13 @@ bool theory_str::free_var_attempt(expr * nn1, expr * nn2) {
ast_manager & m = get_manager();
zstring nn2_str;
if (internal_lenTest_vars.contains(nn1) && u.str.is_string(nn2, nn2_str)) {
- TRACE("t_str", tout << "acting on equivalence between length tester var " << mk_ismt2_pp(nn1, m)
+ TRACE("str", tout << "acting on equivalence between length tester var " << mk_ismt2_pp(nn1, m)
<< " and constant " << mk_ismt2_pp(nn2, m) << std::endl;);
more_len_tests(nn1, nn2_str);
return true;
} else if (internal_valTest_vars.contains(nn1) && u.str.is_string(nn2, nn2_str)) {
if (nn2_str == "more") {
- TRACE("t_str", tout << "acting on equivalence between value var " << mk_ismt2_pp(nn1, m)
+ TRACE("str", tout << "acting on equivalence between value var " << mk_ismt2_pp(nn1, m)
<< " and constant " << mk_ismt2_pp(nn2, m) << std::endl;);
more_value_tests(nn1, nn2_str);
}
@@ -6955,7 +6955,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
sort * str_sort = u.str.mk_string_sort();
if (lhs_sort != str_sort || rhs_sort != str_sort) {
- TRACE("t_str_detail", tout << "skip equality: not String sort" << std::endl;);
+ TRACE("str", tout << "skip equality: not String sort" << std::endl;);
return;
}
@@ -6990,18 +6990,18 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
expr * nn2_arg0 = to_app(rhs)->get_arg(0);
expr * nn2_arg1 = to_app(rhs)->get_arg(1);
if (nn1_arg0 == nn2_arg0 && in_same_eqc(nn1_arg1, nn2_arg1)) {
- TRACE("t_str_detail", tout << "skip: lhs arg0 == rhs arg0" << std::endl;);
+ TRACE("str", tout << "skip: lhs arg0 == rhs arg0" << std::endl;);
return;
}
if (nn1_arg1 == nn2_arg1 && in_same_eqc(nn1_arg0, nn2_arg0)) {
- TRACE("t_str_detail", tout << "skip: lhs arg1 == rhs arg1" << std::endl;);
+ TRACE("str", tout << "skip: lhs arg1 == rhs arg1" << std::endl;);
return;
}
}
if (opt_DeferEQCConsistencyCheck) {
- TRACE("t_str_detail", tout << "opt_DeferEQCConsistencyCheck is set; deferring new_eq_check call" << std::endl;);
+ TRACE("str", tout << "opt_DeferEQCConsistencyCheck is set; deferring new_eq_check call" << std::endl;);
} else {
// newEqCheck() -- check consistency wrt. existing equivalence classes
if (!new_eq_check(lhs, rhs)) {
@@ -7050,7 +7050,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
std::set<expr*> eqc_const_rhs;
group_terms_by_eqc(rhs, eqc_concat_rhs, eqc_var_rhs, eqc_const_rhs);
- TRACE("t_str_detail",
+ TRACE("str",
tout << "lhs eqc:" << std::endl;
tout << "Concats:" << std::endl;
for (std::set<expr*>::iterator it = eqc_concat_lhs.begin(); it != eqc_concat_lhs.end(); ++it) {
@@ -7112,10 +7112,10 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
for (itor2 = eqc_concat_rhs.begin(); itor2 != eqc_concat_rhs.end() && !found; ++itor2) {
expr * concat_rhs = *itor2;
if (will_result_in_overlap(concat_lhs, concat_rhs)) {
- TRACE("t_str_detail", tout << "Concats " << mk_pp(concat_lhs, m) << " and "
+ TRACE("str", tout << "Concats " << mk_pp(concat_lhs, m) << " and "
<< mk_pp(concat_rhs, m) << " will result in overlap; skipping." << std::endl;);
} else {
- TRACE("t_str_detail", tout << "Concats " << mk_pp(concat_lhs, m) << " and "
+ TRACE("str", tout << "Concats " << mk_pp(concat_lhs, m) << " and "
<< mk_pp(concat_rhs, m) << " won't overlap. Simplifying here." << std::endl;);
simplify_concat_equality(concat_lhs, concat_rhs);
found = true;
@@ -7124,7 +7124,7 @@ void theory_str::handle_equality(expr * lhs, expr * rhs) {
}
}
if (!found) {
- TRACE("t_str_detail", tout << "All pairs of concats expected to overlap, falling back." << std::endl;);
+ TRACE("str", tout << "All pairs of concats expected to overlap, falling back." << std::endl;);
simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin()));
}
} else {
@@ -7197,13 +7197,13 @@ void theory_str::set_up_axioms(expr * ex) {
sort * int_sort = m.mk_sort(m_arith_fid, INT_SORT);
if (ex_sort == str_sort) {
- TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
": expr is of sort String" << std::endl;);
// set up basic string axioms
enode * n = ctx.get_enode(ex);
SASSERT(n);
m_basicstr_axiom_todo.push_back(n);
- TRACE("t_str_axiom_bug", tout << "add " << mk_pp(ex, m) << " to m_basicstr_axiom_todo" << std::endl;);
+ TRACE("str", tout << "add " << mk_pp(ex, m) << " to m_basicstr_axiom_todo" << std::endl;);
if (is_app(ex)) {
@@ -7225,21 +7225,21 @@ void theory_str::set_up_axioms(expr * ex) {
} else if (u.str.is_at(ap) || u.str.is_extract(ap) || u.str.is_replace(ap)) {
m_library_aware_axiom_todo.push_back(n);
} else if (u.str.is_itos(ap)) {
- TRACE("t_str_detail", tout << "found string-integer conversion term: " << mk_pp(ex, get_manager()) << std::endl;);
+ TRACE("str", tout << "found string-integer conversion term: " << mk_pp(ex, get_manager()) << std::endl;);
string_int_conversion_terms.push_back(ap);
m_library_aware_axiom_todo.push_back(n);
} else if (ap->get_num_args() == 0 && !u.str.is_string(ap)) {
// if ex is a variable, add it to our list of variables
- TRACE("t_str_detail", tout << "tracking variable " << mk_ismt2_pp(ap, get_manager()) << std::endl;);
+ TRACE("str", tout << "tracking variable " << mk_ismt2_pp(ap, get_manager()) << std::endl;);
variable_set.insert(ex);
ctx.mark_as_relevant(ex);
// this might help??
theory_var v = mk_var(n);
- TRACE("t_str_detail", tout << "variable " << mk_ismt2_pp(ap, get_manager()) << " is #" << v << std::endl;);
+ TRACE("str", tout << "variable " << mk_ismt2_pp(ap, get_manager()) << " is #" << v << std::endl;);
}
}
} else if (ex_sort == bool_sort) {
- TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
": expr is of sort Bool" << std::endl;);
// set up axioms for boolean terms
@@ -7255,13 +7255,13 @@ void theory_str::set_up_axioms(expr * ex) {
}
}
} else {
- TRACE("t_str_detail", tout << "WARNING: Bool term " << mk_ismt2_pp(ex, get_manager()) << " not internalized. Delaying axiom setup to prevent a crash." << std::endl;);
+ TRACE("str", tout << "WARNING: Bool term " << mk_ismt2_pp(ex, get_manager()) << " not internalized. Delaying axiom setup to prevent a crash." << std::endl;);
ENSURE(!search_started); // infinite loop prevention
m_delayed_axiom_setup_terms.push_back(ex);
return;
}
} else if (ex_sort == int_sort) {
- TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
": expr is of sort Int" << std::endl;);
// set up axioms for integer terms
enode * n = ensure_enode(ex);
@@ -7273,13 +7273,13 @@ void theory_str::set_up_axioms(expr * ex) {
if (u.str.is_index(ap) /* || is_Indexof2(ap) || is_LastIndexof(ap) */) {
m_library_aware_axiom_todo.push_back(n);
} else if (u.str.is_stoi(ap)) {
- TRACE("t_str_detail", tout << "found string-integer conversion term: " << mk_pp(ex, get_manager()) << std::endl;);
+ TRACE("str", tout << "found string-integer conversion term: " << mk_pp(ex, get_manager()) << std::endl;);
string_int_conversion_terms.push_back(ap);
m_library_aware_axiom_todo.push_back(n);
}
}
} else {
- TRACE("t_str_detail", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
": expr is of wrong sort, ignoring" << std::endl;);
}
@@ -7294,7 +7294,7 @@ void theory_str::set_up_axioms(expr * ex) {
}
void theory_str::add_theory_assumptions(expr_ref_vector & assumptions) {
- TRACE("t_str", tout << "add overlap assumption for theory_str" << std::endl;);
+ TRACE("str", tout << "add overlap assumption for theory_str" << std::endl;);
symbol strOverlap("!!TheoryStrOverlapAssumption!!");
seq_util m_sequtil(get_manager());
sort * s = get_manager().mk_bool_sort();
@@ -7315,7 +7315,7 @@ lbool theory_str::validate_unsat_core(expr_ref_vector & unsat_core) {
e1 = get_context().get_enode(target_term);
e2 = get_context().get_enode(core_term);
if (e1 == e2) {
- TRACE("t_str", tout << "overlap detected in unsat core, changing UNSAT to UNKNOWN" << std::endl;);
+ TRACE("str", tout << "overlap detected in unsat core, changing UNSAT to UNKNOWN" << std::endl;);
assumptionFound = true;
return l_undef;
}
@@ -7328,7 +7328,7 @@ void theory_str::init_search_eh() {
ast_manager & m = get_manager();
context & ctx = get_context();
- TRACE("t_str_detail",
+ TRACE("str",
tout << "dumping all asserted formulas:" << std::endl;
unsigned nFormulas = ctx.get_num_asserted_formulas();
for (unsigned i = 0; i < nFormulas; ++i) {
@@ -7360,7 +7360,7 @@ void theory_str::init_search_eh() {
for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
expr * ex = *i;
if (m.is_eq(ex)) {
- TRACE("t_str_detail", tout << "processing assignment " << mk_ismt2_pp(ex, m) <<
+ TRACE("str", tout << "processing assignment " << mk_ismt2_pp(ex, m) <<
": expr is equality" << std::endl;);
app * eq = (app*)ex;
SASSERT(eq->get_num_args() == 2);
@@ -7372,7 +7372,7 @@ void theory_str::init_search_eh() {
std::pair<enode*,enode*> eq_pair(e_lhs, e_rhs);
m_str_eq_todo.push_back(eq_pair);
} else {
- TRACE("t_str_detail", tout << "processing assignment " << mk_ismt2_pp(ex, m)
+ TRACE("str", tout << "processing assignment " << mk_ismt2_pp(ex, m)
<< ": expr ignored" << std::endl;);
}
}
@@ -7382,13 +7382,13 @@ void theory_str::init_search_eh() {
// before the first call to new_eq_eh()
propagate();
- TRACE("t_str", tout << "search started" << std::endl;);
+ TRACE("str", tout << "search started" << std::endl;);
search_started = true;
}
void theory_str::new_eq_eh(theory_var x, theory_var y) {
- //TRACE("t_str_detail", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
- TRACE("t_str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
+ //TRACE("str", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
+ TRACE("str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
/*
@@ -7403,18 +7403,18 @@ void theory_str::new_eq_eh(theory_var x, theory_var y) {
}
void theory_str::new_diseq_eh(theory_var x, theory_var y) {
- //TRACE("t_str_detail", tout << "new diseq: v#" << x << " != v#" << y << std::endl;);
- TRACE("t_str", tout << "new diseq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
+ //TRACE("str", tout << "new diseq: v#" << x << " != v#" << y << std::endl;);
+ TRACE("str", tout << "new diseq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
}
void theory_str::relevant_eh(app * n) {
- TRACE("t_str", tout << "relevant: " << mk_ismt2_pp(n, get_manager()) << std::endl;);
+ TRACE("str", tout << "relevant: " << mk_ismt2_pp(n, get_manager()) << std::endl;);
}
void theory_str::assign_eh(bool_var v, bool is_true) {
context & ctx = get_context();
- TRACE("t_str", tout << "assert: v" << v << " #" << ctx.bool_var2expr(v)->get_id() << " is_true: " << is_true << std::endl;);
+ TRACE("str", tout << "assert: v" << v << " #" << ctx.bool_var2expr(v)->get_id() << " is_true: " << is_true << std::endl;);
}
void theory_str::push_scope_eh() {
@@ -7422,7 +7422,7 @@ void theory_str::push_scope_eh() {
m_trail_stack.push_scope();
sLevel += 1;
- TRACE("t_str", tout << "push to " << sLevel << std::endl;);
+ TRACE("str", tout << "push to " << sLevel << std::endl;);
TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
}
@@ -7446,7 +7446,7 @@ void theory_str::recursive_check_variable_scope(expr * ex) {
// assume var
if (variable_set.find(ex) == variable_set.end()
&& internal_variable_set.find(ex) == internal_variable_set.end()) {
- TRACE("t_str_detail", tout << "WARNING: possible reference to out-of-scope variable " << mk_pp(ex, m) << std::endl;);
+ TRACE("str", tout << "WARNING: possible reference to out-of-scope variable " << mk_pp(ex, m) << std::endl;);
}
}
} else {
@@ -7466,7 +7466,7 @@ void theory_str::check_variable_scope() {
return;
}
- TRACE("t_str_detail", tout << "checking scopes of variables in the current assignment" << std::endl;);
+ TRACE("str", tout << "checking scopes of variables in the current assignment" << std::endl;);
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -7481,7 +7481,7 @@ void theory_str::check_variable_scope() {
void theory_str::pop_scope_eh(unsigned num_scopes) {
sLevel -= num_scopes;
- TRACE("t_str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
+ TRACE("str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -7495,7 +7495,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
expr * e = varItor->m_key;
std::stack<T_cut*> & val = cut_var_map[varItor->m_key];
while ((val.size() > 0) && (val.top()->level != 0) && (val.top()->level >= sLevel)) {
- TRACE("t_str_cut_var_map", tout << "remove cut info for " << mk_pp(e, m) << std::endl; print_cut_var(e, tout););
+ TRACE("str", tout << "remove cut info for " << mk_pp(e, m) << std::endl; print_cut_var(e, tout););
T_cut * aCut = val.top();
val.pop();
// dealloc(aCut);
@@ -7518,7 +7518,7 @@ void theory_str::pop_scope_eh(unsigned num_scopes) {
for (ptr_vector<enode>::iterator it = m_basicstr_axiom_todo.begin(); it != m_basicstr_axiom_todo.end(); ++it) {
enode * e = *it;
app * a = e->get_owner();
- TRACE("t_str_axiom_bug", tout << "consider deleting " << mk_pp(a, get_manager())
+ TRACE("str", tout << "consider deleting " << mk_pp(a, get_manager())
<< ", enode scope level is " << e->get_iscope_lvl()
<< std::endl;);
if (e->get_iscope_lvl() <= (unsigned)sLevel) {
@@ -7559,7 +7559,7 @@ void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap
&& internal_valTest_vars.find(node) == internal_valTest_vars.end()
&& internal_unrollTest_vars.find(node) == internal_unrollTest_vars.end()) {
if (varMap[node] != 1) {
- TRACE("t_str_detail", tout << "new variable: " << mk_pp(node, get_manager()) << std::endl;);
+ TRACE("str", tout << "new variable: " << mk_pp(node, get_manager()) << std::endl;);
}
varMap[node] = 1;
}
@@ -7622,7 +7622,7 @@ void theory_str::classify_ast_by_type_in_positive_context(std::map<expr*, int> &
// so we bypass a huge amount of work by doing the following...
if (m.is_eq(argAst)) {
- TRACE("t_str_detail", tout
+ TRACE("str", tout
<< "eq ast " << mk_pp(argAst, m) << " is between args of sort "
<< m.get_sort(to_app(argAst)->get_arg(0))->get_name()
<< std::endl;);
@@ -7846,7 +7846,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
for(obj_hashtable<expr>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
expr* var = *it;
if (internal_variable_set.find(var) == internal_variable_set.end()) {
- TRACE("t_str_detail", tout << "new variable: " << mk_pp(var, m) << std::endl;);
+ TRACE("str", tout << "new variable: " << mk_pp(var, m) << std::endl;);
strVarMap[*it] = 1;
}
}
@@ -8030,7 +8030,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
}
// print some debugging info
- TRACE("t_str_detail", trace_ctx_dep(tout, aliasIndexMap, var_eq_constStr_map,
+ TRACE("str", trace_ctx_dep(tout, aliasIndexMap, var_eq_constStr_map,
var_eq_concat_map, var_eq_unroll_map,
concat_eq_constStr_map, concat_eq_concat_map, unrollGroupMap););
@@ -8079,7 +8079,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
for (std::map<expr*, int>::iterator itor2 = inVarMap.begin(); itor2 != inVarMap.end(); itor2++) {
expr * varInFunc = get_alias_index_ast(aliasIndexMap, itor2->first);
- TRACE("t_str_detail", tout << "var in unroll = " <<
+ TRACE("str", tout << "var in unroll = " <<
mk_ismt2_pp(itor2->first, m) << std::endl
<< "dealiased var = " << mk_ismt2_pp(varInFunc, m) << std::endl;);
@@ -8255,7 +8255,7 @@ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr
}
// print the dependence map
- TRACE("t_str_detail",
+ TRACE("str",
tout << "Dependence Map" << std::endl;
for(std::map<expr*, std::map<expr*, int> >::iterator itor = depMap.begin(); itor != depMap.end(); itor++) {
tout << mk_pp(itor->first, m);
@@ -8422,7 +8422,7 @@ bool theory_str::finalcheck_str2int(app * a) {
rational Ival;
bool Ival_exists = get_value(a, Ival);
if (Ival_exists) {
- TRACE("t_str_detail", tout << "integer theory assigns " << mk_pp(a, m) << " = " << Ival.to_string() << std::endl;);
+ TRACE("str", tout << "integer theory assigns " << mk_pp(a, m) << " = " << Ival.to_string() << std::endl;);
// if that value is not -1, we can assert (str.to-int S) = Ival --> S = "Ival"
if (!Ival.is_minus_one()) {
zstring Ival_str(Ival.to_string().c_str());
@@ -8437,7 +8437,7 @@ bool theory_str::finalcheck_str2int(app * a) {
}
}
} else {
- TRACE("t_str_detail", tout << "integer theory has no assignment for " << mk_pp(a, m) << std::endl;);
+ TRACE("str", tout << "integer theory has no assignment for " << mk_pp(a, m) << std::endl;);
NOT_IMPLEMENTED_YET();
}
@@ -8457,7 +8457,7 @@ bool theory_str::finalcheck_int2str(app * a) {
if (Sval_expr_exists) {
zstring Sval;
u.str.is_string(Sval_expr, Sval);
- TRACE("t_str_detail", tout << "string theory assigns \"" << mk_pp(a, m) << " = " << Sval << "\n";);
+ TRACE("str", tout << "string theory assigns \"" << mk_pp(a, m) << " = " << Sval << "\n";);
// empty string --> integer value < 0
if (Sval.empty()) {
// ignore this. we should already assert the axiom for what happens when the string is ""
@@ -8474,7 +8474,7 @@ bool theory_str::finalcheck_int2str(app * a) {
convertedRepresentation = (ten * convertedRepresentation) + rational(val);
} else {
// not a digit, invalid
- TRACE("t_str_rw", tout << "str.to-int argument contains non-digit character '" << digit << "'" << std::endl;);
+ TRACE("str", tout << "str.to-int argument contains non-digit character '" << digit << "'" << std::endl;);
conversionOK = false;
break;
}
@@ -8497,7 +8497,7 @@ bool theory_str::finalcheck_int2str(app * a) {
}
}
} else {
- TRACE("t_str_detail", tout << "string theory has no assignment for " << mk_pp(a, m) << std::endl;);
+ TRACE("str", tout << "string theory has no assignment for " << mk_pp(a, m) << std::endl;);
NOT_IMPLEMENTED_YET();
}
return axiomAdd;
@@ -8535,7 +8535,7 @@ bool theory_str::propagate_length_within_eqc(expr * var) {
ast_manager & m = get_manager();
context & ctx = get_context();
- TRACE("t_str_length", tout << "propagate_length_within_eqc: " << mk_ismt2_pp(var, m) << std::endl ;);
+ TRACE("str", tout << "propagate_length_within_eqc: " << mk_ismt2_pp(var, m) << std::endl ;);
enode * n_eq_enode = ctx.get_enode(var);
rational varLen;
@@ -8565,7 +8565,7 @@ bool theory_str::propagate_length_within_eqc(expr * var) {
expr_ref varLen(mk_strlen(var), m);
expr_ref axr(ctx.mk_eq_atom(varLen, mk_int(varLen)), m);
assert_implication(axl, axr);
- TRACE("t_str_length", tout << mk_ismt2_pp(axl, m) << std::endl << " ---> " << std::endl << mk_ismt2_pp(axr, m););
+ TRACE("str", tout << mk_ismt2_pp(axl, m) << std::endl << " ---> " << std::endl << mk_ismt2_pp(axr, m););
res = true;
}
}
@@ -8598,7 +8598,7 @@ bool theory_str::propagate_length(std::set<expr*> & varSet, std::set<expr*> & co
// the length fo concat is unresolved yet
if (get_len_value(concat, lenValue)) {
// but all leaf nodes have length information
- TRACE("t_str_length", tout << "* length pop-up: " << mk_ismt2_pp(concat, m) << "| = " << lenValue << std::endl;);
+ TRACE("str", tout << "* length pop-up: " << mk_ismt2_pp(concat, m) << "| = " << lenValue << std::endl;);
std::set<expr*> leafNodes;
get_unique_non_concat_nodes(concat, leafNodes);
expr_ref_vector l_items(m);
@@ -8619,7 +8619,7 @@ bool theory_str::propagate_length(std::set<expr*> & varSet, std::set<expr*> & co
expr_ref lenValueExpr (mk_int(lenValue), m);
expr_ref axr(ctx.mk_eq_atom(concatlenExpr, lenValueExpr), m);
assert_implication(axl, axr);
- TRACE("t_str_length", tout << mk_ismt2_pp(axl, m) << std::endl << " ---> " << std::endl << mk_ismt2_pp(axr, m)<< std::endl;);
+ TRACE("str", tout << mk_ismt2_pp(axl, m) << std::endl << " ---> " << std::endl << mk_ismt2_pp(axr, m)<< std::endl;);
axiomAdded = true;
}
}
@@ -8668,12 +8668,12 @@ final_check_status theory_str::final_check_eh() {
finalCheckProgressIndicator = false;
}
- TRACE("t_str", tout << "final check" << std::endl;);
+ TRACE("str", tout << "final check" << std::endl;);
TRACE_CODE(if (is_trace_enabled("t_str_dump_assign")) { dump_assignments(); });
check_variable_scope();
if (opt_DeferEQCConsistencyCheck) {
- TRACE("t_str_detail", tout << "performing deferred EQC consistency check" << std::endl;);
+ TRACE("str", tout << "performing deferred EQC consistency check" << std::endl;);
std::set<enode*> eqc_roots;
for (ptr_vector<enode>::const_iterator it = ctx.begin_enodes(); it != ctx.end_enodes(); ++it) {
enode * e = *it;
@@ -8687,16 +8687,16 @@ final_check_status theory_str::final_check_eh() {
enode * e = *it;
app * a = e->get_owner();
if (!(m.get_sort(a) == u.str.mk_string_sort())) {
- TRACE("t_str_detail", tout << "EQC root " << mk_pp(a, m) << " not a string term; skipping" << std::endl;);
+ TRACE("str", tout << "EQC root " << mk_pp(a, m) << " not a string term; skipping" << std::endl;);
} else {
- TRACE("t_str_detail", tout << "EQC root " << mk_pp(a, m) << " is a string term. Checking this EQC" << std::endl;);
+ TRACE("str", tout << "EQC root " << mk_pp(a, m) << " is a string term. Checking this EQC" << std::endl;);
// first call check_concat_len_in_eqc() on each member of the eqc
enode * e_it = e;
enode * e_root = e_it;
do {
bool status = check_concat_len_in_eqc(e_it->get_owner());
if (!status) {
- TRACE("t_str_detail", tout << "concat-len check asserted an axiom on " << mk_pp(e_it->get_owner(), m) << std::endl;);
+ TRACE("str", tout << "concat-len check asserted an axiom on " << mk_pp(e_it->get_owner(), m) << std::endl;);
found_inconsistency = true;
}
e_it = e_it->get_next();
@@ -8706,10 +8706,10 @@ final_check_status theory_str::final_check_eh() {
enode * e1 = e;
enode * e2 = e1->get_next();
if (e1 != e2) {
- TRACE("t_str_detail", tout << "deferred new_eq_check() over EQC of " << mk_pp(e1->get_owner(), m) << " and " << mk_pp(e2->get_owner(), m) << std::endl;);
+ TRACE("str", tout << "deferred new_eq_check() over EQC of " << mk_pp(e1->get_owner(), m) << " and " << mk_pp(e2->get_owner(), m) << std::endl;);
bool result = new_eq_check(e1->get_owner(), e2->get_owner());
if (!result) {
- TRACE("t_str_detail", tout << "new_eq_check found inconsistencies" << std::endl;);
+ TRACE("str", tout << "new_eq_check found inconsistencies" << std::endl;);
found_inconsistency = true;
}
}
@@ -8717,10 +8717,10 @@ final_check_status theory_str::final_check_eh() {
}
if (found_inconsistency) {
- TRACE("t_str", tout << "Found inconsistency in final check! Returning to search." << std::endl;);
+ TRACE("str", tout << "Found inconsistency in final check! Returning to search." << std::endl;);
return FC_CONTINUE;
} else {
- TRACE("t_str", tout << "Deferred consistency check passed. Continuing in final check." << std::endl;);
+ TRACE("str", tout << "Deferred consistency check passed. Continuing in final check." << std::endl;);
}
}
@@ -8753,7 +8753,7 @@ final_check_status theory_str::final_check_eh() {
expr * concat_rhs_str = get_eqc_value(concat_rhs, concat_rhs_haseqc);
expr * var_str = get_eqc_value(var, var_haseqc);
if (concat_lhs_haseqc && concat_rhs_haseqc && !var_haseqc) {
- TRACE("t_str_detail", tout << "backpropagate into " << mk_pp(var, m) << " = " << mk_pp(concat, m) << std::endl
+ TRACE("str", tout << "backpropagate into " << mk_pp(var, m) << " = " << mk_pp(concat, m) << std::endl
<< "LHS ~= " << mk_pp(concat_lhs_str, m) << " RHS ~= " << mk_pp(concat_rhs_str, m) << std::endl;);
zstring lhsString, rhsString;
u.str.is_string(concat_lhs_str, lhsString);
@@ -8770,7 +8770,7 @@ final_check_status theory_str::final_check_eh() {
}
if (backpropagation_occurred) {
- TRACE("t_str", tout << "Resuming search due to axioms added by backpropagation." << std::endl;);
+ TRACE("str", tout << "Resuming search due to axioms added by backpropagation." << std::endl;);
return FC_CONTINUE;
}
@@ -8782,7 +8782,7 @@ final_check_status theory_str::final_check_eh() {
bool length_propagation_occurred = propagate_length(varSet, concatSet, exprLenMap);
if (length_propagation_occurred) {
- TRACE("t_str", tout << "Resuming search due to axioms added by length propagation." << std::endl;);
+ TRACE("str", tout << "Resuming search due to axioms added by length propagation." << std::endl;);
return FC_CONTINUE;
}
}
@@ -8801,19 +8801,19 @@ final_check_status theory_str::final_check_eh() {
if (internal_variable_set.find(itor->first) != internal_variable_set.end()
|| regex_variable_set.find(itor->first) != regex_variable_set.end()) {
// this can be ignored, I think
- TRACE("t_str_detail", tout << "free internal variable " << mk_pp(itor->first, m) << " ignored" << std::endl;);
+ TRACE("str", tout << "free internal variable " << mk_pp(itor->first, m) << " ignored" << std::endl;);
continue;
}
bool hasEqcValue = false;
expr * eqcString = get_eqc_value(itor->first, hasEqcValue);
if (!hasEqcValue) {
- TRACE("t_str_detail", tout << "found free variable " << mk_pp(itor->first, m) << std::endl;);
+ TRACE("str", tout << "found free variable " << mk_pp(itor->first, m) << std::endl;);
needToAssignFreeVars = true;
free_variables.insert(itor->first);
// break;
} else {
// debug
- TRACE("t_str_detail", tout << "variable " << mk_pp(itor->first, m) << " = " << mk_pp(eqcString, m) << std::endl;);
+ TRACE("str", tout << "variable " << mk_pp(itor->first, m) << " = " << mk_pp(eqcString, m) << std::endl;);
}
}
}
@@ -8839,15 +8839,15 @@ final_check_status theory_str::final_check_eh() {
}
}
if (addedStrIntAxioms) {
- TRACE("t_str", tout << "Resuming search due to addition of string-integer conversion axioms." << std::endl;);
+ TRACE("str", tout << "Resuming search due to addition of string-integer conversion axioms." << std::endl;);
return FC_CONTINUE;
}
if (unused_internal_variables.empty()) {
- TRACE("t_str", tout << "All variables are assigned. Done!" << std::endl;);
+ TRACE("str", tout << "All variables are assigned. Done!" << std::endl;);
return FC_DONE;
} else {
- TRACE("t_str", tout << "Assigning decoy values to free internal variables." << std::endl;);
+ TRACE("str", tout << "Assigning decoy values to free internal variables." << std::endl;);
for (std::set<expr*>::iterator it = unused_internal_variables.begin(); it != unused_internal_variables.end(); ++it) {
expr * var = *it;
expr_ref assignment(m.mk_eq(var, mk_string("**unused**")), m);
@@ -8857,7 +8857,7 @@ final_check_status theory_str::final_check_eh() {
}
}
- CTRACE("t_str", needToAssignFreeVars,
+ CTRACE("str", needToAssignFreeVars,
tout << "Need to assign values to the following free variables:" << std::endl;
for (std::set<expr*>::iterator itx = free_variables.begin(); itx != free_variables.end(); ++itx) {
tout << mk_ismt2_pp(*itx, m) << std::endl;
@@ -8890,7 +8890,7 @@ final_check_status theory_str::final_check_eh() {
for (std::map<expr*, std::set<expr*> >::iterator fvIt3 = fv_unrolls_map.begin();
fvIt3 != fv_unrolls_map.end(); fvIt3++) {
expr * var = fvIt3->first;
- TRACE("t_str_detail", tout << "erase free variable " << mk_pp(var, m) << " from freeVar_map, it is bounded by an Unroll" << std::endl;);
+ TRACE("str", tout << "erase free variable " << mk_pp(var, m) << " from freeVar_map, it is bounded by an Unroll" << std::endl;);
freeVar_map.erase(var);
}
@@ -8954,7 +8954,7 @@ final_check_status theory_str::final_check_eh() {
}
}
for (std::set<expr*>::iterator vItor = fvUnrollSet.begin(); vItor != fvUnrollSet.end(); vItor++) {
- TRACE("t_str_detail", tout << "remove " << mk_pp(*vItor, m) << " from freeVar_map" << std::endl;);
+ TRACE("str", tout << "remove " << mk_pp(*vItor, m) << " from freeVar_map" << std::endl;);
freeVar_map.erase(*vItor);
}
@@ -8964,7 +8964,7 @@ final_check_status theory_str::final_check_eh() {
constValue = NULL;
{
- TRACE("t_str_detail", tout << "free var map (#" << freeVar_map.size() << "):" << std::endl;
+ TRACE("str", tout << "free var map (#" << freeVar_map.size() << "):" << std::endl;
for (std::map<expr*, int>::iterator freeVarItor1 = freeVar_map.begin(); freeVarItor1 != freeVar_map.end(); freeVarItor1++) {
expr * freeVar = freeVarItor1->first;
rational lenValue;
@@ -9010,7 +9010,7 @@ final_check_status theory_str::final_check_eh() {
// experimental free variable assignment - end
// now deal with removed free variables that are bounded by an unroll
- TRACE("t_str", tout << "fv_unrolls_map (#" << fv_unrolls_map.size() << "):" << std::endl;);
+ TRACE("str", tout << "fv_unrolls_map (#" << fv_unrolls_map.size() << "):" << std::endl;);
for (std::map<expr*, std::set<expr*> >::iterator fvIt1 = fv_unrolls_map.begin();
fvIt1 != fv_unrolls_map.end(); fvIt1++) {
expr * var = fvIt1->first;
@@ -9027,7 +9027,7 @@ final_check_status theory_str::final_check_eh() {
}
if (opt_VerifyFinalCheckProgress && !finalCheckProgressIndicator) {
- TRACE("t_str", tout << "BUG: no progress in final check, giving up!!" << std::endl;);
+ TRACE("str", tout << "BUG: no progress in final check, giving up!!" << std::endl;);
m.raise_exception("no progress in theory_str final check");
}
@@ -9049,7 +9049,7 @@ inline std::string longlong_to_string(long long i) {
void theory_str::print_value_tester_list(svector<std::pair<int, expr*> > & testerList) {
ast_manager & m = get_manager();
- TRACE("t_str_detail",
+ TRACE("str",
int ss = testerList.size();
tout << "valueTesterList = {";
for (int i = 0; i < ss; ++i) {
@@ -9084,7 +9084,7 @@ zstring theory_str::gen_val_string(int len, int_vector & encoding) {
bool theory_str::get_next_val_encode(int_vector & base, int_vector & next) {
SASSERT(charSetSize > 0);
- TRACE("t_str_value_test_bug", tout << "base vector: [ ";
+ TRACE("str", tout << "base vector: [ ";
for (unsigned i = 0; i < base.size(); ++i) {
tout << base[i] << " ";
}
@@ -9140,7 +9140,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
svector<int_vector> options;
int_vector base;
- TRACE("t_str_detail", tout
+ TRACE("str", tout
<< "freeVar = " << mk_ismt2_pp(freeVar, m) << std::endl
<< "len_indicator = " << mk_ismt2_pp(len_indicator, m) << std::endl
<< "val_indicator = " << mk_ismt2_pp(val_indicator, m) << std::endl
@@ -9156,7 +9156,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
coverAll = false;
} else {
expr * lastestValIndi = fvar_valueTester_map[freeVar][len][tries - 1].second;
- TRACE("t_str_detail", tout << "last value tester = " << mk_ismt2_pp(lastestValIndi, m) << std::endl;);
+ TRACE("str", tout << "last value tester = " << mk_ismt2_pp(lastestValIndi, m) << std::endl;);
coverAll = get_next_val_encode(val_range_map[lastestValIndi], base);
}
@@ -9171,7 +9171,7 @@ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr *
}
val_range_map[val_indicator] = options[options.size() - 1];
- TRACE("t_str_detail",
+ TRACE("str",
tout << "value tester encoding " << "{" << std::endl;
int_vector vec = val_range_map[val_indicator];
@@ -9266,7 +9266,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
int len = atoi(len_valueStr.encode().c_str());
// check whether any value tester is actually in scope
- TRACE("t_str_detail", tout << "checking scope of previous value testers" << std::endl;);
+ TRACE("str", tout << "checking scope of previous value testers" << std::endl;);
bool map_effectively_empty = true;
if (fvar_valueTester_map[freeVar].find(len) != fvar_valueTester_map[freeVar].end()) {
// there's *something* in the map, but check its scope
@@ -9275,9 +9275,9 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
std::pair<int,expr*> entry = *it;
expr * aTester = entry.second;
if (internal_variable_set.find(aTester) == internal_variable_set.end()) {
- TRACE("t_str_detail", tout << mk_pp(aTester, m) << " out of scope" << std::endl;);
+ TRACE("str", tout << mk_pp(aTester, m) << " out of scope" << std::endl;);
} else {
- TRACE("t_str_detail", tout << mk_pp(aTester, m) << " in scope" << std::endl;);
+ TRACE("str", tout << mk_pp(aTester, m) << " in scope" << std::endl;);
map_effectively_empty = false;
break;
}
@@ -9285,7 +9285,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
}
if (map_effectively_empty) {
- TRACE("t_str_detail", tout << "no previous value testers, or none of them were in scope" << std::endl;);
+ TRACE("str", tout << "no previous value testers, or none of them were in scope" << std::endl;);
int tries = 0;
expr * val_indicator = mk_internal_valTest_var(freeVar, len, tries);
valueTester_fvar_map[val_indicator] = freeVar;
@@ -9293,7 +9293,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
print_value_tester_list(fvar_valueTester_map[freeVar][len]);
return gen_val_options(freeVar, len_indicator, val_indicator, len_valueStr, tries);
} else {
- TRACE("t_str_detail", tout << "checking previous value testers" << std::endl;);
+ TRACE("str", tout << "checking previous value testers" << std::endl;);
print_value_tester_list(fvar_valueTester_map[freeVar][len]);
// go through all previous value testers
@@ -9305,7 +9305,7 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
// it's probably worth checking scope here, actually
if (internal_variable_set.find(aTester) == internal_variable_set.end()) {
- TRACE("t_str_detail", tout << "value tester " << mk_pp(aTester, m) << " out of scope, skipping" << std::endl;);
+ TRACE("str", tout << "value tester " << mk_pp(aTester, m) << " out of scope, skipping" << std::endl;);
continue;
}
@@ -9317,17 +9317,17 @@ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
// Z3_ast anEqc = get_eqc_value(t, aTester, anEqcHasValue);
expr * aTester_eqc_value = get_eqc_value(aTester, anEqcHasValue);
if (!anEqcHasValue) {
- TRACE("t_str_detail", tout << "value tester " << mk_ismt2_pp(aTester, m)
+ TRACE("str", tout << "value tester " << mk_ismt2_pp(aTester, m)
<< " doesn't have an equivalence class value." << std::endl;);
refresh_theory_var(aTester);
expr * makeupAssert = gen_val_options(freeVar, len_indicator, aTester, len_valueStr, i);
- TRACE("t_str_detail", tout << "var: " << mk_ismt2_pp(freeVar, m) << std::endl
+ TRACE("str", tout << "var: " << mk_ismt2_pp(freeVar, m) << std::endl
<< mk_ismt2_pp(makeupAssert, m) << std::endl;);
assert_axiom(makeupAssert);
} else {
- TRACE("t_str_detail", tout << "value tester " << mk_ismt2_pp(aTester, m)
+ TRACE("str", tout << "value tester " << mk_ismt2_pp(aTester, m)
<< " == " << mk_ismt2_pp(aTester_eqc_value, m) << std::endl;);
}
}
@@ -9355,7 +9355,7 @@ void theory_str::reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vect
context & ctx = get_context();
ast_manager & mgr = get_manager();
- TRACE("t_str_detail", tout << "reduce regex " << mk_pp(regex, mgr) << " with respect to variable " << mk_pp(var, mgr) << std::endl;);
+ TRACE("str", tout << "reduce regex " << mk_pp(regex, mgr) << " with respect to variable " << mk_pp(var, mgr) << std::endl;);
app * regexFuncDecl = to_app(regex);
if (u.re.is_to_re(regexFuncDecl)) {
@@ -9443,7 +9443,7 @@ void theory_str::gen_assign_unroll_reg(std::set<expr*> & unrolls) {
expr_ref_vector items(mgr);
for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
expr * unrFunc = *itor;
- TRACE("t_str_detail", tout << "generating assignment for unroll " << mk_pp(unrFunc, mgr) << std::endl;);
+ TRACE("str", tout << "generating assignment for unroll " << mk_pp(unrFunc, mgr) << std::endl;);
expr * regexInUnr = to_app(unrFunc)->get_arg(0);
expr * cntInUnr = to_app(unrFunc)->get_arg(1);
@@ -9453,7 +9453,7 @@ void theory_str::gen_assign_unroll_reg(std::set<expr*> & unrolls) {
bool low_exists = lower_bound(cntInUnr, low);
bool high_exists = upper_bound(cntInUnr, high);
- TRACE("t_str_detail",
+ TRACE("str",
tout << "unroll " << mk_pp(unrFunc, mgr) << std::endl;
rational unrLenValue;
bool unrLenValue_exists = get_len_value(unrFunc, unrLenValue);
@@ -9599,7 +9599,7 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
expr_ref moreAst(mk_string("more"), mgr);
for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
expr_ref item(ctx.mk_eq_atom(var, *itor), mgr);
- TRACE("t_str_detail", tout << "considering unroll " << mk_pp(item, mgr) << std::endl;);
+ TRACE("str", tout << "considering unroll " << mk_pp(item, mgr) << std::endl;);
litems.push_back(item);
}
@@ -9611,7 +9611,7 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
it != unroll_tries_map[var][unrolls].end(); ++it) {
expr * tester = *it;
bool inScope = (internal_unrollTest_vars.find(tester) != internal_unrollTest_vars.end());
- TRACE("t_str_detail", tout << "unroll test var " << mk_pp(tester, mgr)
+ TRACE("str", tout << "unroll test var " << mk_pp(tester, mgr)
<< (inScope ? " in scope" : " out of scope")
<< std::endl;);
if (!inScope) {
@@ -9644,13 +9644,13 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
expr_ref rImp(gen_unroll_assign(var, lcmStr, tester, l, h), mgr);
SASSERT(lImp);
- TRACE("t_str_detail", tout << "lImp = " << mk_pp(lImp, mgr) << std::endl;);
+ TRACE("str", tout << "lImp = " << mk_pp(lImp, mgr) << std::endl;);
SASSERT(rImp);
- TRACE("t_str_detail", tout << "rImp = " << mk_pp(rImp, mgr) << std::endl;);
+ TRACE("str", tout << "rImp = " << mk_pp(rImp, mgr) << std::endl;);
expr_ref toAssert(mgr.mk_or(mgr.mk_not(lImp), rImp), mgr);
SASSERT(toAssert);
- TRACE("t_str_detail", tout << "Making up assignments for variable which is equal to unbounded Unroll" << std::endl;);
+ TRACE("str", tout << "Making up assignments for variable which is equal to unbounded Unroll" << std::endl;);
m_trail.push_back(toAssert);
return toAssert;
@@ -9662,7 +9662,7 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
} else {
zstring testerStr;
u.str.is_string(testerVal, testerStr);
- TRACE("t_str_detail", tout << "Tester [" << mk_pp(tester, mgr) << "] = " << testerStr << "\n";);
+ TRACE("str", tout << "Tester [" << mk_pp(tester, mgr) << "] = " << testerStr << "\n";);
if (testerStr == "more") {
litems.push_back(ctx.mk_eq_atom(tester, moreAst));
}
@@ -9678,7 +9678,7 @@ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> &
SASSERT(rImp);
expr_ref toAssert(mgr.mk_or(mgr.mk_not(lImp), rImp), mgr);
SASSERT(toAssert);
- TRACE("t_str_detail", tout << "Generating assignment for variable which is equal to unbounded Unroll" << std::endl;);
+ TRACE("str", tout << "Generating assignment for variable which is equal to unbounded Unroll" << std::endl;);
m_trail.push_back(toAssert);
return toAssert;
}
@@ -9687,11 +9687,11 @@ expr * theory_str::gen_unroll_assign(expr * var, zstring lcmStr, expr * testerVa
context & ctx = get_context();
ast_manager & mgr = get_manager();
- TRACE("t_str_detail", tout << "entry: var = " << mk_pp(var, mgr) << ", lcmStr = " << lcmStr
+ TRACE("str", tout << "entry: var = " << mk_pp(var, mgr) << ", lcmStr = " << lcmStr
<< ", l = " << l << ", h = " << h << "\n";);
if (m_params.m_AggressiveUnrollTesting) {
- TRACE("t_str_detail", tout << "note: aggressive unroll testing is active" << std::endl;);
+ TRACE("str", tout << "note: aggressive unroll testing is active" << std::endl;);
}
expr_ref_vector orItems(mgr);
@@ -9700,7 +9700,7 @@ expr * theory_str::gen_unroll_assign(expr * var, zstring lcmStr, expr * testerVa
for (int i = l; i < h; i++) {
zstring iStr = int_to_string(i);
expr_ref testerEqAst(ctx.mk_eq_atom(testerVar, mk_string(iStr)), mgr);
- TRACE("t_str_detail", tout << "testerEqAst = " << mk_pp(testerEqAst, mgr) << std::endl;);
+ TRACE("str", tout << "testerEqAst = " << mk_pp(testerEqAst, mgr) << std::endl;);
if (m_params.m_AggressiveUnrollTesting) {
literal l = mk_eq(testerVar, mk_string(iStr), false);
ctx.mark_as_relevant(l);
@@ -9711,15 +9711,15 @@ expr * theory_str::gen_unroll_assign(expr * var, zstring lcmStr, expr * testerVa
zstring unrollStrInstance = get_unrolled_string(lcmStr, i);
expr_ref x1(ctx.mk_eq_atom(testerEqAst, ctx.mk_eq_atom(var, mk_string(unrollStrInstance))), mgr);
- TRACE("t_str_detail", tout << "x1 = " << mk_pp(x1, mgr) << std::endl;);
+ TRACE("str", tout << "x1 = " << mk_pp(x1, mgr) << std::endl;);
andItems.push_back(x1);
expr_ref x2(ctx.mk_eq_atom(testerEqAst, ctx.mk_eq_atom(mk_strlen(var), mk_int(i * lcmStr.length()))), mgr);
- TRACE("t_str_detail", tout << "x2 = " << mk_pp(x2, mgr) << std::endl;);
+ TRACE("str", tout << "x2 = " << mk_pp(x2, mgr) << std::endl;);
andItems.push_back(x2);
}
expr_ref testerEqMore(ctx.mk_eq_atom(testerVar, mk_string("more")), mgr);
- TRACE("t_str_detail", tout << "testerEqMore = " << mk_pp(testerEqMore, mgr) << std::endl;);
+ TRACE("str", tout << "testerEqMore = " << mk_pp(testerEqMore, mgr) << std::endl;);
if (m_params.m_AggressiveUnrollTesting) {
literal l = mk_eq(testerVar, mk_string("more"), false);
ctx.mark_as_relevant(l);
@@ -9732,15 +9732,15 @@ expr * theory_str::gen_unroll_assign(expr * var, zstring lcmStr, expr * testerVa
//Z3_mk_ge(mk_length(t, var), mk_int(ctx, nextLowerLenBound))
m_autil.mk_ge(m_autil.mk_add(mk_strlen(var), mk_int(-1 * nextLowerLenBound)), mk_int(0))
), mgr);
- TRACE("t_str_detail", tout << "more2 = " << mk_pp(more2, mgr) << std::endl;);
+ TRACE("str", tout << "more2 = " << mk_pp(more2, mgr) << std::endl;);
andItems.push_back(more2);
expr_ref finalOR(mgr.mk_or(orItems.size(), orItems.c_ptr()), mgr);
- TRACE("t_str_detail", tout << "finalOR = " << mk_pp(finalOR, mgr) << std::endl;);
+ TRACE("str", tout << "finalOR = " << mk_pp(finalOR, mgr) << std::endl;);
andItems.push_back(mk_or(orItems));
expr_ref finalAND(mgr.mk_and(andItems.size(), andItems.c_ptr()), mgr);
- TRACE("t_str_detail", tout << "finalAND = " << mk_pp(finalAND, mgr) << std::endl;);
+ TRACE("str", tout << "finalAND = " << mk_pp(finalAND, mgr) << std::endl;);
// doing the following avoids a segmentation fault
m_trail.push_back(finalAND);
@@ -9761,7 +9761,7 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
int l = (tries - 1) * distance;
int h = tries * distance;
- TRACE("t_str_detail",
+ TRACE("str",
tout << "building andList and orList" << std::endl;
if (m_params.m_AggressiveLengthTesting) {
tout << "note: aggressive length testing is active" << std::endl;
@@ -9848,11 +9848,11 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
and_items.push_back(andList.get(i));
}
- TRACE("t_str_detail", tout << "check: " << mk_pp(mk_and(and_items), m) << std::endl;);
+ TRACE("str", tout << "check: " << mk_pp(mk_and(and_items), m) << std::endl;);
expr_ref lenTestAssert = mk_and(and_items);
SASSERT(lenTestAssert);
- TRACE("t_str_detail", tout << "crash avoidance lenTestAssert: " << mk_pp(lenTestAssert, m) << std::endl;);
+ TRACE("str", tout << "crash avoidance lenTestAssert: " << mk_pp(lenTestAssert, m) << std::endl;);
int testerCount = tries - 1;
if (testerCount > 0) {
@@ -9861,10 +9861,10 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
for (int i = 0; i < testerCount; ++i) {
expr * indicator = fvar_lenTester_map[freeVar][i];
if (internal_variable_set.find(indicator) == internal_variable_set.end()) {
- TRACE("t_str_detail", tout << "indicator " << mk_pp(indicator, m) << " out of scope; continuing" << std::endl;);
+ TRACE("str", tout << "indicator " << mk_pp(indicator, m) << " out of scope; continuing" << std::endl;);
continue;
} else {
- TRACE("t_str_detail", tout << "indicator " << mk_pp(indicator, m) << " in scope" << std::endl;);
+ TRACE("str", tout << "indicator " << mk_pp(indicator, m) << " in scope" << std::endl;);
and_items_LHS.push_back(ctx.mk_eq_atom(indicator, moreAst));
}
}
@@ -9872,10 +9872,10 @@ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tr
SASSERT(assertL);
expr * finalAxiom = m.mk_or(m.mk_not(assertL), lenTestAssert.get());
SASSERT(finalAxiom != NULL);
- TRACE("t_str_detail", tout << "crash avoidance finalAxiom: " << mk_pp(finalAxiom, m) << std::endl;);
+ TRACE("str", tout << "crash avoidance finalAxiom: " << mk_pp(finalAxiom, m) << std::endl;);
return finalAxiom;
} else {
- TRACE("t_str_detail", tout << "crash avoidance lenTestAssert.get(): " << mk_pp(lenTestAssert.get(), m) << std::endl;);
+ TRACE("str", tout << "crash avoidance lenTestAssert.get(): " << mk_pp(lenTestAssert.get(), m) << std::endl;);
m_trail.push_back(lenTestAssert.get());
return lenTestAssert.get();
}
@@ -9892,7 +9892,7 @@ expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, bin
rational N_plus_one = N + rational::one();
expr_ref lenFreeVar(mk_strlen(freeVar), m);
- TRACE("t_str_binary_search", tout << "create case split for free var " << mk_pp(freeVar, m)
+ TRACE("str", tout << "create case split for free var " << mk_pp(freeVar, m)
<< " over " << mk_pp(tester, m) << " with midpoint " << N << std::endl;);
expr_ref_vector combinedCaseSplit(m);
@@ -9924,7 +9924,7 @@ expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, bin
expr_ref final_term(mk_and(combinedCaseSplit), m);
SASSERT(final_term);
- TRACE("t_str_binary_search", tout << "final term: " << mk_pp(final_term, m) << std::endl;);
+ TRACE("str", tout << "final term: " << mk_pp(final_term, m) << std::endl;);
return final_term;
}
@@ -9933,7 +9933,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
context & ctx = get_context();
if (binary_search_len_tester_stack.contains(freeVar) && !binary_search_len_tester_stack[freeVar].empty()) {
- TRACE("t_str_binary_search", tout << "checking existing length testers for " << mk_pp(freeVar, m) << std::endl;
+ TRACE("str", tout << "checking existing length testers for " << mk_pp(freeVar, m) << std::endl;
for (ptr_vector<expr>::const_iterator it = binary_search_len_tester_stack[freeVar].begin();
it != binary_search_len_tester_stack[freeVar].end(); ++it) {
expr * tester = *it;
@@ -9959,35 +9959,35 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
expr * lastTesterValue = get_eqc_value(lastTester, lastTesterHasEqcValue);
zstring lastTesterConstant;
if (!lastTesterHasEqcValue) {
- TRACE("t_str_binary_search", tout << "length tester " << mk_pp(lastTester, m) << " at top of stack doesn't have an EQC value yet" << std::endl;);
+ TRACE("str", tout << "length tester " << mk_pp(lastTester, m) << " at top of stack doesn't have an EQC value yet" << std::endl;);
// check previousLenTester
if (previousLenTester == lastTester) {
lastTesterConstant = previousLenTesterValue;
- TRACE("t_str_binary_search", tout << "invoked with previousLenTester info matching top of stack" << std::endl;);
+ TRACE("str", tout << "invoked with previousLenTester info matching top of stack" << std::endl;);
} else {
- TRACE("t_str_binary_search", tout << "WARNING: unexpected reordering of length testers!" << std::endl;);
+ TRACE("str", tout << "WARNING: unexpected reordering of length testers!" << std::endl;);
UNREACHABLE(); return NULL;
}
} else {
u.str.is_string(lastTesterValue, lastTesterConstant);
}
- TRACE("t_str_binary_search", tout << "last length tester is assigned \"" << lastTesterConstant << "\"" << "\n";);
+ TRACE("str", tout << "last length tester is assigned \"" << lastTesterConstant << "\"" << "\n";);
if (lastTesterConstant == "more" || lastTesterConstant == "less") {
// use the previous bounds info to generate a new midpoint
binary_search_info lastBounds;
if (!binary_search_len_tester_info.find(lastTester, lastBounds)) {
// unexpected
- TRACE("t_str_binary_search", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
+ TRACE("str", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
UNREACHABLE();
}
- TRACE("t_str_binary_search", tout << "last bounds are [" << lastBounds.lowerBound << " | " << lastBounds.midPoint << " | " << lastBounds.upperBound << "]!" << lastBounds.windowSize << std::endl;);
+ TRACE("str", tout << "last bounds are [" << lastBounds.lowerBound << " | " << lastBounds.midPoint << " | " << lastBounds.upperBound << "]!" << lastBounds.windowSize << std::endl;);
binary_search_info newBounds;
expr * newTester;
if (lastTesterConstant == "more") {
// special case: if the midpoint, upper bound, and window size are all equal,
// we double the window size and adjust the bounds
if (lastBounds.midPoint == lastBounds.upperBound && lastBounds.upperBound == lastBounds.windowSize) {
- TRACE("t_str_binary_search", tout << "search hit window size; expanding" << std::endl;);
+ TRACE("str", tout << "search hit window size; expanding" << std::endl;);
newBounds.lowerBound = lastBounds.windowSize + rational::one();
newBounds.windowSize = lastBounds.windowSize * rational(2);
newBounds.upperBound = newBounds.windowSize;
@@ -10024,7 +10024,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
}
refresh_theory_var(newTester);
}
- TRACE("t_str_binary_search", tout << "new bounds are [" << newBounds.lowerBound << " | " << newBounds.midPoint << " | " << newBounds.upperBound << "]!" << newBounds.windowSize << std::endl;);
+ TRACE("str", tout << "new bounds are [" << newBounds.lowerBound << " | " << newBounds.midPoint << " | " << newBounds.upperBound << "]!" << newBounds.windowSize << std::endl;);
binary_search_len_tester_stack[freeVar].push_back(newTester);
m_trail_stack.push(binary_search_trail<theory_str>(binary_search_len_tester_stack, freeVar));
binary_search_len_tester_info.insert(newTester, newBounds);
@@ -10036,16 +10036,16 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
// ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
return next_case_split;
} else { // lastTesterConstant is a concrete value
- TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
+ TRACE("str", tout << "length is fixed; generating models for free var" << std::endl;);
// defensive check that this length did not converge on a negative value.
binary_search_info lastBounds;
if (!binary_search_len_tester_info.find(lastTester, lastBounds)) {
// unexpected
- TRACE("t_str_binary_search", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
+ TRACE("str", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
UNREACHABLE();
}
if (lastBounds.midPoint.is_neg()) {
- TRACE("t_str_binary_search", tout << "WARNING: length search converged on a negative value. Negating this constraint." << std::endl;);
+ TRACE("str", tout << "WARNING: length search converged on a negative value. Negating this constraint." << std::endl;);
expr_ref axiom(m_autil.mk_ge(mk_strlen(freeVar), m_autil.mk_numeral(rational::zero(), true)), m);
return axiom;
}
@@ -10055,7 +10055,7 @@ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenT
}
} else {
// no length testers yet
- TRACE("t_str_binary_search", tout << "no length testers for " << mk_pp(freeVar, m) << std::endl;);
+ TRACE("str", tout << "no length testers for " << mk_pp(freeVar, m) << std::endl;);
binary_search_len_tester_stack.insert(freeVar, ptr_vector<expr>());
expr * firstTester;
@@ -10098,15 +10098,15 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
ast_manager & m = get_manager();
- TRACE("t_str_detail", tout << "gen for free var " << mk_ismt2_pp(freeVar, m) << std::endl;);
+ TRACE("str", tout << "gen for free var " << mk_ismt2_pp(freeVar, m) << std::endl;);
if (m_params.m_UseBinarySearch) {
- TRACE("t_str_detail", tout << "using binary search heuristic" << std::endl;);
+ TRACE("str", tout << "using binary search heuristic" << std::endl;);
return binary_search_length_test(freeVar, lenTesterInCbEq, lenTesterValue);
} else {
bool map_effectively_empty = false;
if (!fvar_len_count_map.contains(freeVar)) {
- TRACE("t_str_detail", tout << "fvar_len_count_map is empty" << std::endl;);
+ TRACE("str", tout << "fvar_len_count_map is empty" << std::endl;);
map_effectively_empty = true;
}
@@ -10120,18 +10120,18 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
for (ptr_vector<expr>::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) {
expr * indicator = *it;
if (internal_variable_set.find(indicator) != internal_variable_set.end()) {
- TRACE("t_str_detail", tout <<"found active internal variable " << mk_ismt2_pp(indicator, m)
+ TRACE("str", tout <<"found active internal variable " << mk_ismt2_pp(indicator, m)
<< " in fvar_lenTester_map[freeVar]" << std::endl;);
map_effectively_empty = false;
break;
}
}
- CTRACE("t_str_detail", map_effectively_empty, tout << "all variables in fvar_lenTester_map[freeVar] out of scope" << std::endl;);
+ CTRACE("str", map_effectively_empty, tout << "all variables in fvar_lenTester_map[freeVar] out of scope" << std::endl;);
}
if (map_effectively_empty) {
// no length assertions for this free variable have ever been added.
- TRACE("t_str_detail", tout << "no length assertions yet" << std::endl;);
+ TRACE("str", tout << "no length assertions yet" << std::endl;);
fvar_len_count_map.insert(freeVar, 1);
unsigned int testNum = fvar_len_count_map[freeVar];
@@ -10148,13 +10148,13 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
SASSERT(lenTestAssert != NULL);
return lenTestAssert;
} else {
- TRACE("t_str_detail", tout << "found previous in-scope length assertions" << std::endl;);
+ TRACE("str", tout << "found previous in-scope length assertions" << std::endl;);
expr * effectiveLenInd = NULL;
zstring effectiveLenIndiStr("");
int lenTesterCount = (int) fvar_lenTester_map[freeVar].size();
- TRACE("t_str_detail",
+ TRACE("str",
tout << lenTesterCount << " length testers in fvar_lenTester_map[" << mk_pp(freeVar, m) << "]:" << std::endl;
for (int i = 0; i < lenTesterCount; ++i) {
expr * len_indicator = fvar_lenTester_map[freeVar][i];
@@ -10170,13 +10170,13 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
expr * len_indicator_pre = fvar_lenTester_map[freeVar][i];
// check whether this is in scope as well
if (internal_variable_set.find(len_indicator_pre) == internal_variable_set.end()) {
- TRACE("t_str_detail", tout << "length indicator " << mk_pp(len_indicator_pre, m) << " not in scope" << std::endl;);
+ TRACE("str", tout << "length indicator " << mk_pp(len_indicator_pre, m) << " not in scope" << std::endl;);
continue;
}
bool indicatorHasEqcValue = false;
expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
- TRACE("t_str_detail", tout << "length indicator " << mk_ismt2_pp(len_indicator_pre, m) <<
+ TRACE("str", tout << "length indicator " << mk_ismt2_pp(len_indicator_pre, m) <<
" = " << mk_ismt2_pp(len_indicator_value, m) << std::endl;);
if (indicatorHasEqcValue) {
zstring len_pIndiStr;
@@ -10188,7 +10188,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
}
} else {
if (lenTesterInCbEq != len_indicator_pre) {
- TRACE("t_str", tout << "WARNING: length indicator " << mk_ismt2_pp(len_indicator_pre, m)
+ TRACE("str", tout << "WARNING: length indicator " << mk_ismt2_pp(len_indicator_pre, m)
<< " does not have an equivalence class value."
<< " i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
if (i > 0) {
@@ -10196,7 +10196,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
bool effectiveHasEqcValue;
expr * effective_eqc_value = get_eqc_value(effectiveLenInd, effectiveHasEqcValue);
bool effectiveInScope = (internal_variable_set.find(effectiveLenInd) != internal_variable_set.end());
- TRACE("t_str_detail", tout << "checking effective length indicator " << mk_pp(effectiveLenInd, m) << ": "
+ TRACE("str", tout << "checking effective length indicator " << mk_pp(effectiveLenInd, m) << ": "
<< (effectiveInScope ? "in scope" : "NOT in scope") << ", ";
if (effectiveHasEqcValue) {
tout << "~= " << mk_pp(effective_eqc_value, m);
@@ -10227,11 +10227,11 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
} // !indicatorHasEqcValue
} // for (i : [0..lenTesterCount-1])
if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "") {
- TRACE("t_str", tout << "length is not fixed; generating length tester options for free var" << std::endl;);
+ TRACE("str", tout << "length is not fixed; generating length tester options for free var" << std::endl;);
expr_ref indicator(m);
unsigned int testNum = 0;
- TRACE("t_str", tout << "effectiveLenIndiStr = " << effectiveLenIndiStr
+ TRACE("str", tout << "effectiveLenIndiStr = " << effectiveLenIndiStr
<< ", i = " << i << ", lenTesterCount = " << lenTesterCount << "\n";);
if (i == lenTesterCount) {
@@ -10249,7 +10249,7 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
SASSERT(lenTestAssert != NULL);
return lenTestAssert;
} else {
- TRACE("t_str", tout << "length is fixed; generating models for free var" << std::endl;);
+ TRACE("str", tout << "length is fixed; generating models for free var" << std::endl;);
// length is fixed
expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, zstring(""));
return valueAssert;
@@ -10318,7 +10318,7 @@ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
}
}
if (duplicated && dupVar != NULL) {
- TRACE("t_str_detail", tout << "Duplicated free variable found:" << mk_ismt2_pp(freeVar, m)
+ TRACE("str", tout << "Duplicated free variable found:" << mk_ismt2_pp(freeVar, m)
<< " = " << mk_ismt2_pp(dupVar, m) << " (SKIP)" << std::endl;);
continue;
} else {
@@ -10428,7 +10428,7 @@ void theory_str::get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*
}
void theory_str::init_model(model_generator & mg) {
- //TRACE("t_str", tout << "initializing model" << std::endl; display(tout););
+ //TRACE("str", tout << "initializing model" << std::endl; display(tout););
m_factory = alloc(str_value_factory, get_manager(), get_family_id());
mg.register_factory(m_factory);
}
@@ -10475,7 +10475,7 @@ app * theory_str::mk_value_helper(app * n) {
}
model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
- TRACE("t_str", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), get_manager()) <<
+ TRACE("str", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), get_manager()) <<
" (sort " << mk_ismt2_pp(get_manager().get_sort(n->get_owner()), get_manager()) << ")" << std::endl;);
ast_manager & m = get_manager();
context & ctx = get_context();
@@ -10489,7 +10489,7 @@ model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
if (val != NULL) {
return alloc(expr_wrapper_proc, val);
} else {
- TRACE("t_str", tout << "WARNING: failed to find a concrete value, falling back" << std::endl;);
+ TRACE("str", tout << "WARNING: failed to find a concrete value, falling back" << std::endl;);
return alloc(expr_wrapper_proc, to_app(mk_string("**UNUSED**")));
}
}
From 3fe49137d0f678b09340d0c20beded6521812c64 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 24 Apr 2017 19:25:35 -0400
Subject: [PATCH 373/401] fix trace typos
---
src/ast/seq_decl_plugin.h | 4 ++++
src/ast/static_features.cpp | 7 +++++++
src/ast/static_features.h | 4 ++++
src/smt/params/smt_params.cpp | 3 ++-
src/smt/params/smt_params.h | 10 +++++++++-
src/smt/params/smt_params_helper.pyg | 1 +
src/smt/smt_setup.cpp | 27 +++++++++++++++++++--------
src/smt/smt_setup.h | 2 +-
src/smt/theory_str.cpp | 7 +++----
9 files changed, 50 insertions(+), 15 deletions(-)
diff --git a/src/ast/seq_decl_plugin.h b/src/ast/seq_decl_plugin.h
index 2882e905d..030b244e5 100644
--- a/src/ast/seq_decl_plugin.h
+++ b/src/ast/seq_decl_plugin.h
@@ -273,6 +273,10 @@ public:
bool is_in_re(expr const* n) const { return is_app_of(n, m_fid, OP_SEQ_IN_RE); }
bool is_unit(expr const* n) const { return is_app_of(n, m_fid, OP_SEQ_UNIT); }
+ bool is_string_term(expr const * n) const {
+ sort * s = get_sort(n);
+ return is_sort_of(s, m_fid, _STRING_SORT);
+ }
MATCH_BINARY(is_concat);
MATCH_UNARY(is_length);
diff --git a/src/ast/static_features.cpp b/src/ast/static_features.cpp
index 328128794..9958b3d50 100644
--- a/src/ast/static_features.cpp
+++ b/src/ast/static_features.cpp
@@ -25,6 +25,7 @@ static_features::static_features(ast_manager & m):
m_bvutil(m),
m_arrayutil(m),
m_fpautil(m),
+ m_sequtil(m),
m_bfid(m.get_basic_family_id()),
m_afid(m.mk_family_id("arith")),
m_lfid(m.mk_family_id("label")),
@@ -77,6 +78,8 @@ void static_features::reset() {
m_has_real = false;
m_has_bv = false;
m_has_fpa = false;
+ m_has_str = false;
+ m_has_seq_non_str = false;
m_has_arrays = false;
m_arith_k_sum .reset();
m_num_arith_terms = 0;
@@ -279,6 +282,10 @@ void static_features::update_core(expr * e) {
m_has_fpa = true;
if (!m_has_arrays && m_arrayutil.is_array(e))
m_has_arrays = true;
+ if (!m_has_str && m_sequtil.str.is_string_term(e))
+ m_has_str = true;
+ if (!m_has_seq_non_str && m_sequtil.is_seq(e))
+ m_has_seq_non_str = true;
if (is_app(e)) {
family_id fid = to_app(e)->get_family_id();
mark_theory(fid);
diff --git a/src/ast/static_features.h b/src/ast/static_features.h
index 8b20c5463..e7f69e041 100644
--- a/src/ast/static_features.h
+++ b/src/ast/static_features.h
@@ -24,6 +24,7 @@ Revision History:
#include"bv_decl_plugin.h"
#include"array_decl_plugin.h"
#include"fpa_decl_plugin.h"
+#include"seq_decl_plugin.h"
#include"map.h"
struct static_features {
@@ -32,6 +33,7 @@ struct static_features {
bv_util m_bvutil;
array_util m_arrayutil;
fpa_util m_fpautil;
+ seq_util m_sequtil;
family_id m_bfid;
family_id m_afid;
family_id m_lfid;
@@ -77,6 +79,8 @@ struct static_features {
bool m_has_real; //
bool m_has_bv; //
bool m_has_fpa; //
+ bool m_has_str; // has String-typed terms
+ bool m_has_seq_non_str; // has non-String-typed Sequence terms
bool m_has_arrays; //
rational m_arith_k_sum; // sum of the numerals in arith atoms.
unsigned m_num_arith_terms;
diff --git a/src/smt/params/smt_params.cpp b/src/smt/params/smt_params.cpp
index dcf396531..b8d5fe7b5 100644
--- a/src/smt/params/smt_params.cpp
+++ b/src/smt/params/smt_params.cpp
@@ -41,6 +41,7 @@ void smt_params::updt_local_params(params_ref const & _p) {
m_max_conflicts = p.max_conflicts();
m_core_validate = p.core_validate();
m_logic = _p.get_sym("logic", m_logic);
+ m_string_solver = _p.get_sym("string_solver", m_string_solver);
model_params mp(_p);
m_model_compact = mp.compact();
if (_p.get_bool("arith.greatest_error_pivot", false))
@@ -157,4 +158,4 @@ void smt_params::display(std::ostream & out) const {
DISPLAY_PARAM(m_check_at_labels);
DISPLAY_PARAM(m_dump_goal_as_smt);
DISPLAY_PARAM(m_auto_config);
-}
\ No newline at end of file
+}
diff --git a/src/smt/params/smt_params.h b/src/smt/params/smt_params.h
index a86123a33..295e141cc 100644
--- a/src/smt/params/smt_params.h
+++ b/src/smt/params/smt_params.h
@@ -216,6 +216,13 @@ struct smt_params : public preprocessor_params,
bool m_dump_goal_as_smt;
bool m_auto_config;
+ // -----------------------------------
+ //
+ // Solver selection
+ //
+ // -----------------------------------
+ symbol m_string_solver;
+
smt_params(params_ref const & p = params_ref()):
m_display_proof(false),
m_display_dot_proof(false),
@@ -286,7 +293,8 @@ struct smt_params : public preprocessor_params,
m_at_labels_cex(false),
m_check_at_labels(false),
m_dump_goal_as_smt(false),
- m_auto_config(true) {
+ m_auto_config(true),
+ m_string_solver(symbol("auto")){
updt_local_params(p);
}
diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg
index 133d1d527..f99c2df16 100644
--- a/src/smt/params/smt_params_helper.pyg
+++ b/src/smt/params/smt_params_helper.pyg
@@ -62,6 +62,7 @@ def_module_params(module_name='smt',
('dack.gc_inv_decay', DOUBLE, 0.8, 'Dynamic ackermannization garbage collection decay'),
('dack.threshold', UINT, 10, ' number of times the congruence rule must be used before Leibniz\'s axiom is expanded'),
('core.validate', BOOL, False, 'validate unsat core produced by SMT context'),
+ ('string_solver', SYMBOL, 'auto', 'solver for string/sequence theories. options are: \'z3str3\' (specialized string solver), \'seq\' (sequence solver), \'auto\' (use static features to choose best solver)'),
('str.strong_arrangements', BOOL, True, 'assert equivalences instead of implications when generating string arrangement axioms'),
('str.aggressive_length_testing', BOOL, False, 'prioritize testing concrete length values over generating more options'),
('str.aggressive_value_testing', BOOL, False, 'prioritize testing concrete string constant values over generating more options'),
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index 78a295e27..c295801ad 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -206,7 +206,7 @@ namespace smt {
void setup::setup_QF_BVRE() {
setup_QF_BV();
setup_QF_LIA();
- setup_seq();
+ m_context.register_plugin(alloc(theory_seq, m_manager));
}
void setup::setup_QF_UF(static_features const & st) {
@@ -824,10 +824,21 @@ namespace smt {
m_context.register_plugin(mk_theory_dl(m_manager));
}
- void setup::setup_seq() {
- // TODO proper negotiation of theory_str vs. theory_seq
- //m_context.register_plugin(alloc(theory_seq, m_manager));
- setup_str();
+ void setup::setup_seq(static_features const & st) {
+ // check params for what to do here when it's ambiguous
+ if (m_params.m_string_solver == "z3str3") {
+ setup_str();
+ } else if (m_params.m_string_solver == "seq") {
+ m_context.register_plugin(alloc(theory_seq, m_manager));
+ } else if (m_params.m_string_solver == "auto") {
+ if (st.m_has_seq_non_str) {
+ m_context.register_plugin(alloc(theory_seq, m_manager));
+ } else {
+ setup_str();
+ }
+ } else {
+ throw default_exception("invalid parameter for smt.string_solver, valid options are 'z3str3', 'seq', 'auto'");
+ }
}
void setup::setup_card() {
@@ -850,10 +861,10 @@ namespace smt {
setup_bv();
setup_datatypes();
setup_dl();
- setup_seq();
+ // setup_seq()
+ m_context.register_plugin(alloc(theory_seq, m_manager));
setup_card();
setup_fpa();
- setup_str();
}
void setup::setup_unknown(static_features & st) {
@@ -866,7 +877,7 @@ namespace smt {
setup_datatypes();
setup_bv();
setup_dl();
- setup_seq();
+ setup_seq(st);
setup_card();
setup_fpa();
return;
diff --git a/src/smt/smt_setup.h b/src/smt/smt_setup.h
index 031c65c1f..d30c896e5 100644
--- a/src/smt/smt_setup.h
+++ b/src/smt/smt_setup.h
@@ -94,7 +94,7 @@ namespace smt {
void setup_bv();
void setup_arith();
void setup_dl();
- void setup_seq();
+ void setup_seq(static_features const & st);
void setup_card();
void setup_i_arith();
void setup_mi_arith();
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 01123a22c..be268ec5c 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4844,7 +4844,7 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
// we only want to inspect the Contains terms where either of strAst or substrAst
// are equal to varNode.
- TRACE("t_str_detail", tout << "considering Contains with strAst = "str", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
+ TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
if (varNode != strAst && varNode != substrAst) {
TRACE("str", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
@@ -4873,7 +4873,7 @@ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
zstring subStrConst;
u.str.is_string(substrValue, subStrConst);
- TRACE("t_str_detail", tout << "strConst = "str", subStrConst = " << subStrConst << "\n";);
+ TRACE("t_str_detail", tout << "strConst = " << strConst << ", subStrConst = " << subStrConst << "\n";);
if (strConst.contains(subStrConst)) {
//implyR = ctx.mk_eq(ctx, boolVar, Z3_mk_true(ctx));
@@ -4983,7 +4983,7 @@ void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willE
// we only want to inspect the Contains terms where either of strAst or substrAst
// are equal to varNode.
- TRACE("t_str_detail", tout << "considering Contains with strAst = "str", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
+ TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
if (varNode != strAst && varNode != substrAst) {
TRACE("str", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
@@ -6181,7 +6181,6 @@ void nfa::convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u) {
}
make_transition(last, str[(str.length() - 1)], end);
TRACE("str", tout << "string transition " << last << "--" << str[(str.length() - 1)] << "--> " << end << "\n";);
- TRACE("t_str_rw", tout << "str", end = " << end << std::endl;);
} else {
TRACE("str", tout << "invalid string constant in Str2Reg" << std::endl;);
m_valid = false;
From 54e28a4fe73fd807f1c2aebd12e354dcb46c02b3 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 24 Apr 2017 21:02:22 -0400
Subject: [PATCH 374/401] string/sequence static features test
---
src/ast/seq_decl_plugin.h | 11 +++++++++++
src/ast/static_features.cpp | 3 ++-
src/smt/smt_setup.cpp | 16 +++++++++++++---
3 files changed, 26 insertions(+), 4 deletions(-)
diff --git a/src/ast/seq_decl_plugin.h b/src/ast/seq_decl_plugin.h
index 030b244e5..52abb2c45 100644
--- a/src/ast/seq_decl_plugin.h
+++ b/src/ast/seq_decl_plugin.h
@@ -278,6 +278,17 @@ public:
return is_sort_of(s, m_fid, _STRING_SORT);
}
+ bool is_non_string_sequence(expr const * n) const {
+ if (is_string_term(n))
+ return false;
+
+ sort * s = get_sort(n);
+ if (u.is_seq(s) && !u.is_string(s)) {
+ return true;
+ }
+ return false;
+ }
+
MATCH_BINARY(is_concat);
MATCH_UNARY(is_length);
MATCH_TERNARY(is_extract);
diff --git a/src/ast/static_features.cpp b/src/ast/static_features.cpp
index 9958b3d50..daf20e095 100644
--- a/src/ast/static_features.cpp
+++ b/src/ast/static_features.cpp
@@ -284,8 +284,9 @@ void static_features::update_core(expr * e) {
m_has_arrays = true;
if (!m_has_str && m_sequtil.str.is_string_term(e))
m_has_str = true;
- if (!m_has_seq_non_str && m_sequtil.is_seq(e))
+ if (!m_has_seq_non_str && m_sequtil.str.is_non_string_sequence(e)) {
m_has_seq_non_str = true;
+ }
if (is_app(e)) {
family_id fid = to_app(e)->get_family_id();
mark_theory(fid);
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index c295801ad..dd94d9473 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -832,6 +832,7 @@ namespace smt {
m_context.register_plugin(alloc(theory_seq, m_manager));
} else if (m_params.m_string_solver == "auto") {
if (st.m_has_seq_non_str) {
+ NOT_IMPLEMENTED_YET();
m_context.register_plugin(alloc(theory_seq, m_manager));
} else {
setup_str();
@@ -856,13 +857,15 @@ namespace smt {
}
void setup::setup_unknown() {
+ static_features st(m_manager);
+ st.collect(m_context.get_num_asserted_formulas(), m_context.get_asserted_formulas());
+
setup_arith();
setup_arrays();
setup_bv();
setup_datatypes();
setup_dl();
- // setup_seq()
- m_context.register_plugin(alloc(theory_seq, m_manager));
+ setup_seq(st);
setup_card();
setup_fpa();
}
@@ -966,7 +969,14 @@ namespace smt {
return;
}
- // TODO setup_str() by features
+ if (st.num_theories() == 2 && st.m_has_str && !st.m_has_seq_non_str) {
+ setup_QF_S();
+ return;
+ }
+
+ if (st.num_theories() == 2 && st.m_has_seq_non_str) {
+ m_context.register_plugin(alloc(theory_seq, m_manager));
+ }
setup_unknown();
}
From 6fececaad99d8972e2b0780ef32a7c19ad9620fc Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Mon, 24 Apr 2017 21:47:31 -0400
Subject: [PATCH 375/401] fix str/seq parameter config
---
src/smt/params/smt_params.cpp | 2 +-
src/smt/smt_setup.cpp | 10 ----------
2 files changed, 1 insertion(+), 11 deletions(-)
diff --git a/src/smt/params/smt_params.cpp b/src/smt/params/smt_params.cpp
index b8d5fe7b5..92ff1de90 100644
--- a/src/smt/params/smt_params.cpp
+++ b/src/smt/params/smt_params.cpp
@@ -41,7 +41,7 @@ void smt_params::updt_local_params(params_ref const & _p) {
m_max_conflicts = p.max_conflicts();
m_core_validate = p.core_validate();
m_logic = _p.get_sym("logic", m_logic);
- m_string_solver = _p.get_sym("string_solver", m_string_solver);
+ m_string_solver = p.string_solver();
model_params mp(_p);
m_model_compact = mp.compact();
if (_p.get_bool("arith.greatest_error_pivot", false))
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index dd94d9473..4d02218bf 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -832,7 +832,6 @@ namespace smt {
m_context.register_plugin(alloc(theory_seq, m_manager));
} else if (m_params.m_string_solver == "auto") {
if (st.m_has_seq_non_str) {
- NOT_IMPLEMENTED_YET();
m_context.register_plugin(alloc(theory_seq, m_manager));
} else {
setup_str();
@@ -969,15 +968,6 @@ namespace smt {
return;
}
- if (st.num_theories() == 2 && st.m_has_str && !st.m_has_seq_non_str) {
- setup_QF_S();
- return;
- }
-
- if (st.num_theories() == 2 && st.m_has_seq_non_str) {
- m_context.register_plugin(alloc(theory_seq, m_manager));
- }
-
setup_unknown();
}
From 334677a7eb4f5a2395cb621dfe24843561e3fca7 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Thu, 27 Apr 2017 13:58:36 -0400
Subject: [PATCH 376/401] fix is_string_term()
---
src/ast/seq_decl_plugin.h | 10 ++--------
1 file changed, 2 insertions(+), 8 deletions(-)
diff --git a/src/ast/seq_decl_plugin.h b/src/ast/seq_decl_plugin.h
index 52abb2c45..833455ff4 100644
--- a/src/ast/seq_decl_plugin.h
+++ b/src/ast/seq_decl_plugin.h
@@ -275,18 +275,12 @@ public:
bool is_string_term(expr const * n) const {
sort * s = get_sort(n);
- return is_sort_of(s, m_fid, _STRING_SORT);
+ return (u.is_seq(s) && u.is_string(s));
}
bool is_non_string_sequence(expr const * n) const {
- if (is_string_term(n))
- return false;
-
sort * s = get_sort(n);
- if (u.is_seq(s) && !u.is_string(s)) {
- return true;
- }
- return false;
+ return (u.is_seq(s) && !u.is_string(s));
}
MATCH_BINARY(is_concat);
From f1cee803e83bdac80f350e28693ae6801ec0674a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 28 Apr 2017 13:44:48 -0400
Subject: [PATCH 377/401] fixup
---
src/ast/seq_decl_plugin.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/ast/seq_decl_plugin.cpp b/src/ast/seq_decl_plugin.cpp
index 353fb975f..bf238d8c5 100644
--- a/src/ast/seq_decl_plugin.cpp
+++ b/src/ast/seq_decl_plugin.cpp
@@ -573,7 +573,7 @@ void seq_decl_plugin::set_manager(ast_manager* m, family_id id) {
m_char = bv.mk_sort(8);
m->inc_ref(m_char);
parameter param(m_char);
- m_string = m->mk_sort(symbol("StringSequence"), sort_info(m_family_id, SEQ_SORT, 1, ¶m));
+ m_string = m->mk_sort(symbol("String"), sort_info(m_family_id, SEQ_SORT, 1, ¶m));
m->inc_ref(m_string);
parameter paramS(m_string);
m_re = m->mk_sort(m_family_id, RE_SORT, 1, ¶mS);
From d51ebac10a19520917d3725279a3a421e3e2279d Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 28 Apr 2017 14:01:44 -0400
Subject: [PATCH 378/401] remove references to str_fid
---
src/ast/ast_smt_pp.cpp | 2 --
1 file changed, 2 deletions(-)
diff --git a/src/ast/ast_smt_pp.cpp b/src/ast/ast_smt_pp.cpp
index c3f1523b1..f41350dc5 100644
--- a/src/ast/ast_smt_pp.cpp
+++ b/src/ast/ast_smt_pp.cpp
@@ -166,7 +166,6 @@ class smt_printer {
fpa_util m_futil;
family_id m_basic_fid;
family_id m_bv_fid;
- family_id m_str_fid;
family_id m_arith_fid;
family_id m_array_fid;
family_id m_dt_fid;
@@ -846,7 +845,6 @@ public:
m_bv_fid = m.mk_family_id("bv");
m_arith_fid = m.mk_family_id("arith");
m_array_fid = m.mk_family_id("array");
- m_str_fid = m.mk_family_id("str");
m_dt_fid = m.mk_family_id("datatype");
m_fpa_fid = m.mk_family_id("fpa");
}
From e6d527c5d576333ce8be7d9ace47aa52603956aa Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 2 May 2017 15:39:15 -0400
Subject: [PATCH 379/401] remove trace code from theory_arith
---
src/smt/theory_arith.h | 14 +------------
src/smt/theory_arith_core.h | 41 ++-----------------------------------
2 files changed, 3 insertions(+), 52 deletions(-)
diff --git a/src/smt/theory_arith.h b/src/smt/theory_arith.h
index eb36a92fb..439adbdff 100644
--- a/src/smt/theory_arith.h
+++ b/src/smt/theory_arith.h
@@ -577,19 +577,7 @@ namespace smt {
return is_free(get_context().get_enode(n)->get_th_var(get_id()));
}
bool is_fixed(theory_var v) const;
- void set_bound_core(theory_var v, bound * new_bound, bool upper) {
- TRACE("t_str_int",
- tout << "setting " << (upper ? "upper" : "lower") << " bound ";
- if (new_bound) {
- tout << new_bound->get_value();
- } else {
- tout << "(NULL)";
- }
- tout << " for theory var v#" << v;
- tout << std::endl;
- );
- m_bounds[static_cast<unsigned>(upper)][v] = new_bound;
- }
+ void set_bound_core(theory_var v, bound * new_bound, bool upper) { m_bounds[static_cast<unsigned>(upper)][v] = new_bound; }
void restore_bound(theory_var v, bound * new_bound, bool upper) { set_bound_core(v, new_bound, upper); }
void restore_nl_propagated_flag(unsigned old_trail_size);
void set_bound(bound * new_bound, bool upper);
diff --git a/src/smt/theory_arith_core.h b/src/smt/theory_arith_core.h
index 7fed094da..dd1924e44 100644
--- a/src/smt/theory_arith_core.h
+++ b/src/smt/theory_arith_core.h
@@ -3263,50 +3263,13 @@ namespace smt {
bool theory_arith<Ext>::get_value(enode * n, expr_ref & r) {
theory_var v = n->get_th_var(get_id());
inf_numeral val;
- // rewrites for tracing purposes
- if (v == null_theory_var) {
- TRACE("t_str_int", tout << "WARNING: enode " << mk_pp(n->get_owner(), get_manager())
- << " attached to null theory var" << std::endl;
- );
- return false;
- } else {
- val = get_value(v);
- TRACE("t_str_int", tout << "enode " << mk_pp(n->get_owner(), get_manager())
- << " attached to theory var v#" << v
- << ", has val = " << val
- << std::endl;
- );
- if (!is_int(v) || val.is_int()) {
- return to_expr(val, is_int(v), r);
- } else {
- return false;
- }
- }
- // return v != null_theory_var && (val = get_value(v), (!is_int(v) || val.is_int())) && to_expr(val, is_int(v), r);
+ return v != null_theory_var && (val = get_value(v), (!is_int(v) || val.is_int())) && to_expr(val, is_int(v), r);
}
template<typename Ext>
bool theory_arith<Ext>::get_lower(enode * n, expr_ref & r) {
theory_var v = n->get_th_var(get_id());
- bound * b;
- if (v == null_theory_var) {
- TRACE("t_str_int", tout << "WARNING: enode " << mk_pp(n->get_owner(), get_manager())
- << " attached to null theory var" << std::endl;
- );
- b = 0;
- } else {
- b = lower(v);
- TRACE("t_str_int",
- tout << "enode " << mk_pp(n->get_owner(), get_manager())
- << " attached to theory var v#" << v
- << std::endl;
- if (b) {
- tout << "lower bound = " << b->get_value() << std::endl;
- } else {
- tout << "WARNING: b = NULL" << std::endl;
- }
- );
- }
+ bound * b = (v == null_theory_var) ? 0 : lower(v);
return b && to_expr(b->get_value(), is_int(v), r);
}
From a418f0c30b8ea589e08cb8aa1c187ebb1f7003bd Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 2 May 2017 15:52:35 -0400
Subject: [PATCH 380/401] fix spacing
---
src/smt/theory_arith_core.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_arith_core.h b/src/smt/theory_arith_core.h
index dd1924e44..5c652414a 100644
--- a/src/smt/theory_arith_core.h
+++ b/src/smt/theory_arith_core.h
@@ -3269,7 +3269,7 @@ namespace smt {
template<typename Ext>
bool theory_arith<Ext>::get_lower(enode * n, expr_ref & r) {
theory_var v = n->get_th_var(get_id());
- bound * b = (v == null_theory_var) ? 0 : lower(v);
+ bound* b = (v == null_theory_var) ? 0 : lower(v);
return b && to_expr(b->get_value(), is_int(v), r);
}
From 92755b0185e32a31d0ed1e2d700b9971f1523087 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Tue, 2 May 2017 17:16:35 -0400
Subject: [PATCH 381/401] smt_setup framework, all hooks to theory_str are
redirected to theory_seq
---
src/smt/params/smt_params.cpp | 1 +
src/smt/params/smt_params.h | 10 +++++++-
src/smt/params/smt_params_helper.pyg | 1 +
src/smt/smt_setup.cpp | 38 ++++++++++++++++++++++++----
src/smt/smt_setup.h | 4 ++-
src/solver/smt_logics.cpp | 6 ++++-
src/solver/smt_logics.h | 1 +
7 files changed, 53 insertions(+), 8 deletions(-)
diff --git a/src/smt/params/smt_params.cpp b/src/smt/params/smt_params.cpp
index 4b7920596..3d0b59c88 100644
--- a/src/smt/params/smt_params.cpp
+++ b/src/smt/params/smt_params.cpp
@@ -40,6 +40,7 @@ void smt_params::updt_local_params(params_ref const & _p) {
m_max_conflicts = p.max_conflicts();
m_core_validate = p.core_validate();
m_logic = _p.get_sym("logic", m_logic);
+ m_string_solver = p.string_solver();
model_params mp(_p);
m_model_compact = mp.compact();
if (_p.get_bool("arith.greatest_error_pivot", false))
diff --git a/src/smt/params/smt_params.h b/src/smt/params/smt_params.h
index c03eaeaef..b44e782fd 100644
--- a/src/smt/params/smt_params.h
+++ b/src/smt/params/smt_params.h
@@ -213,6 +213,13 @@ struct smt_params : public preprocessor_params,
bool m_dump_goal_as_smt;
bool m_auto_config;
+ // -----------------------------------
+ //
+ // Solver selection
+ //
+ // -----------------------------------
+ symbol m_string_solver;
+
smt_params(params_ref const & p = params_ref()):
m_display_proof(false),
m_display_dot_proof(false),
@@ -281,7 +288,8 @@ struct smt_params : public preprocessor_params,
m_at_labels_cex(false),
m_check_at_labels(false),
m_dump_goal_as_smt(false),
- m_auto_config(true) {
+ m_auto_config(true),
+ m_string_solver(symbol("seq")){
updt_local_params(p);
}
diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg
index faa48400d..a06a37f2a 100644
--- a/src/smt/params/smt_params_helper.pyg
+++ b/src/smt/params/smt_params_helper.pyg
@@ -62,6 +62,7 @@ def_module_params(module_name='smt',
('dack.gc_inv_decay', DOUBLE, 0.8, 'Dynamic ackermannization garbage collection decay'),
('dack.threshold', UINT, 10, ' number of times the congruence rule must be used before Leibniz\'s axiom is expanded'),
('theory_case_split', BOOL, False, 'Allow the context to use heuristics involving theory case splits, which are a set of literals of which exactly one can be assigned True. If this option is false, the context will generate extra axioms to enforce this instead.'),
+ ('string_solver', SYMBOL, 'seq', 'solver for string/sequence theories. options are: \'z3str3\' (specialized string solver), \'seq\' (sequence solver), \'auto\' (use static features to choose best solver)'),
('core.validate', BOOL, False, 'validate unsat core produced by SMT context'),
('core.minimize', BOOL, False, 'minimize unsat core produced by SMT context'),
('core.extend_patterns', BOOL, False, 'extend unsat core with literals that trigger (potential) quantifier instances'),
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index ee92c4f61..84e3dee32 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -120,6 +120,8 @@ namespace smt {
setup_QF_FP();
else if (m_logic == "QF_FPBV" || m_logic == "QF_BVFP")
setup_QF_FPBV();
+ else if (m_logic == "QF_S")
+ setup_QF_S();
else
setup_unknown();
}
@@ -161,6 +163,8 @@ namespace smt {
setup_QF_BVRE();
else if (m_logic == "QF_AUFLIA")
setup_QF_AUFLIA(st);
+ else if (m_logic == "QF_S")
+ setup_QF_S();
else if (m_logic == "AUFLIA")
setup_AUFLIA(st);
else if (m_logic == "AUFLIRA")
@@ -201,7 +205,7 @@ namespace smt {
void setup::setup_QF_BVRE() {
setup_QF_BV();
setup_QF_LIA();
- setup_seq();
+ m_context.register_plugin(alloc(theory_seq, m_manager));
}
void setup::setup_QF_UF(static_features const & st) {
@@ -700,6 +704,10 @@ namespace smt {
m_context.register_plugin(alloc(smt::theory_fpa, m_manager));
}
+ void setup::setup_QF_S() {
+ m_context.register_plugin(alloc(smt::theory_seq, m_manager));
+ }
+
bool is_arith(static_features const & st) {
return st.m_num_arith_ineqs > 0 || st.m_num_arith_terms > 0 || st.m_num_arith_eqs > 0;
}
@@ -814,8 +822,21 @@ namespace smt {
m_context.register_plugin(mk_theory_dl(m_manager));
}
- void setup::setup_seq() {
- m_context.register_plugin(alloc(theory_seq, m_manager));
+ void setup::setup_seq(static_features const & st) {
+ // check params for what to do here when it's ambiguous
+ if (m_params.m_string_solver == "z3str3") {
+ setup_str();
+ } else if (m_params.m_string_solver == "seq") {
+ m_context.register_plugin(alloc(smt::theory_seq, m_manager));
+ } else if (m_params.m_string_solver == "auto") {
+ if (st.m_has_seq_non_str) {
+ m_context.register_plugin(alloc(smt::theory_seq, m_manager));
+ } else {
+ setup_str();
+ }
+ } else {
+ throw default_exception("invalid parameter for smt.string_solver, valid options are 'z3str3', 'seq', 'auto'");
+ }
}
void setup::setup_card() {
@@ -827,13 +848,20 @@ namespace smt {
m_context.register_plugin(alloc(theory_fpa, m_manager));
}
+ void setup::setup_str() {
+ m_context.register_plugin(alloc(smt::theory_seq, m_manager));
+ }
+
void setup::setup_unknown() {
+ static_features st(m_manager);
+ st.collect(m_context.get_num_asserted_formulas(), m_context.get_asserted_formulas());
+
setup_arith();
setup_arrays();
setup_bv();
setup_datatypes();
setup_dl();
- setup_seq();
+ setup_seq(st);
setup_card();
setup_fpa();
}
@@ -848,7 +876,7 @@ namespace smt {
setup_datatypes();
setup_bv();
setup_dl();
- setup_seq();
+ setup_seq(st);
setup_card();
setup_fpa();
return;
diff --git a/src/smt/smt_setup.h b/src/smt/smt_setup.h
index 68cd5703c..d30c896e5 100644
--- a/src/smt/smt_setup.h
+++ b/src/smt/smt_setup.h
@@ -77,6 +77,7 @@ namespace smt {
void setup_QF_AUFLIA(static_features const & st);
void setup_QF_FP();
void setup_QF_FPBV();
+ void setup_QF_S();
void setup_LRA();
void setup_AUFLIA(bool simple_array = true);
void setup_AUFLIA(static_features const & st);
@@ -93,11 +94,12 @@ namespace smt {
void setup_bv();
void setup_arith();
void setup_dl();
- void setup_seq();
+ void setup_seq(static_features const & st);
void setup_card();
void setup_i_arith();
void setup_mi_arith();
void setup_fpa();
+ void setup_str();
public:
setup(context & c, smt_params & params);
diff --git a/src/solver/smt_logics.cpp b/src/solver/smt_logics.cpp
index 210a09f96..c4ead74df 100644
--- a/src/solver/smt_logics.cpp
+++ b/src/solver/smt_logics.cpp
@@ -24,7 +24,7 @@ Revision History:
bool smt_logics::supported_logic(symbol const & s) {
return logic_has_uf(s) || logic_is_all(s) || logic_has_fd(s) ||
logic_has_arith(s) || logic_has_bv(s) ||
- logic_has_array(s) || logic_has_seq(s) ||
+ logic_has_array(s) || logic_has_seq(s) || logic_has_str(s) ||
logic_has_horn(s) || logic_has_fpa(s);
}
@@ -132,6 +132,10 @@ bool smt_logics::logic_has_seq(symbol const & s) {
return s == "QF_BVRE" || s == "QF_S" || s == "ALL";
}
+bool smt_logics::logic_has_str(symbol const & s) {
+ return s == "QF_S" || s == "ALL";
+}
+
bool smt_logics::logic_has_fpa(symbol const & s) {
return s == "QF_FP" || s == "QF_FPBV" || s == "QF_BVFP" || s == "ALL";
}
diff --git a/src/solver/smt_logics.h b/src/solver/smt_logics.h
index 72c3b8764..702431cdd 100644
--- a/src/solver/smt_logics.h
+++ b/src/solver/smt_logics.h
@@ -30,6 +30,7 @@ public:
static bool logic_has_bv(symbol const & s);
static bool logic_has_array(symbol const & s);
static bool logic_has_seq(symbol const & s);
+ static bool logic_has_str(symbol const & s);
static bool logic_has_fpa(symbol const & s);
static bool logic_has_horn(symbol const& s);
static bool logic_has_pb(symbol const& s);
From eeb79e1c3c9343f3dcf7a5ec09c2e503abdeec6a Mon Sep 17 00:00:00 2001
From: Nikolaj Bjorner <nbjorner@microsoft.com>
Date: Tue, 2 May 2017 19:30:54 -0700
Subject: [PATCH 382/401] update to retain original behavior
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
---
src/opt/opt_context.cpp | 2 +-
src/test/cnf_backbones.cpp | 4 ++--
2 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/src/opt/opt_context.cpp b/src/opt/opt_context.cpp
index 1310727aa..d486dfd11 100644
--- a/src/opt/opt_context.cpp
+++ b/src/opt/opt_context.cpp
@@ -406,7 +406,7 @@ namespace opt {
if (r == l_true && !get_lower_as_num(i).is_finite()) {
return r;
}
- if (r == l_true && i + 1 < m_objectives.size()) {
+ if (r == l_true && i + 1 < m_objectives.size() && get_lower_as_num(i).is_finite()) {
update_lower();
}
}
diff --git a/src/test/cnf_backbones.cpp b/src/test/cnf_backbones.cpp
index 07edabece..14fc594b6 100644
--- a/src/test/cnf_backbones.cpp
+++ b/src/test/cnf_backbones.cpp
@@ -252,12 +252,12 @@ static void cnf_backbones(bool use_chunk, char const* file_name) {
vector<sat::literal_vector> tracking_clauses;
track_clauses(solver, solver2, assumptions, tracking_clauses);
}
-
+ // remove this line to limit variables to exclude assumptions
+ num_vars = g_solver->num_vars();
for (unsigned i = 1; i < num_vars; ++i) {
vars.push_back(i);
g_solver->set_external(i);
}
- num_vars = g_solver->num_vars();
lbool r;
if (use_chunk) {
r = core_chunking(*g_solver, vars, assumptions, conseq, 100);
From cc7a176c8936162be94235a6277c93bf7d96fd2f Mon Sep 17 00:00:00 2001
From: Nikolaj Bjorner <nbjorner@microsoft.com>
Date: Tue, 2 May 2017 19:32:03 -0700
Subject: [PATCH 383/401] update to retain original behavior
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
---
src/opt/opt_context.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/opt/opt_context.cpp b/src/opt/opt_context.cpp
index d486dfd11..1310727aa 100644
--- a/src/opt/opt_context.cpp
+++ b/src/opt/opt_context.cpp
@@ -406,7 +406,7 @@ namespace opt {
if (r == l_true && !get_lower_as_num(i).is_finite()) {
return r;
}
- if (r == l_true && i + 1 < m_objectives.size() && get_lower_as_num(i).is_finite()) {
+ if (r == l_true && i + 1 < m_objectives.size()) {
update_lower();
}
}
From 1177be63913b2813f667d7202f09fe31f4a9688e Mon Sep 17 00:00:00 2001
From: Nikolaj Bjorner <nbjorner@microsoft.com>
Date: Tue, 2 May 2017 20:52:39 -0700
Subject: [PATCH 384/401] add common utility to set up seq
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
---
src/smt/smt_setup.cpp | 30 +++++++++++++++++++-----------
src/smt/smt_setup.h | 3 ++-
2 files changed, 21 insertions(+), 12 deletions(-)
diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp
index 84e3dee32..820159d18 100644
--- a/src/smt/smt_setup.cpp
+++ b/src/smt/smt_setup.cpp
@@ -205,7 +205,7 @@ namespace smt {
void setup::setup_QF_BVRE() {
setup_QF_BV();
setup_QF_LIA();
- m_context.register_plugin(alloc(theory_seq, m_manager));
+ setup_seq();
}
void setup::setup_QF_UF(static_features const & st) {
@@ -705,7 +705,7 @@ namespace smt {
}
void setup::setup_QF_S() {
- m_context.register_plugin(alloc(smt::theory_seq, m_manager));
+ setup_seq();
}
bool is_arith(static_features const & st) {
@@ -822,19 +822,23 @@ namespace smt {
m_context.register_plugin(mk_theory_dl(m_manager));
}
- void setup::setup_seq(static_features const & st) {
+ void setup::setup_seq_str(static_features const & st) {
// check params for what to do here when it's ambiguous
if (m_params.m_string_solver == "z3str3") {
setup_str();
- } else if (m_params.m_string_solver == "seq") {
- m_context.register_plugin(alloc(smt::theory_seq, m_manager));
- } else if (m_params.m_string_solver == "auto") {
+ }
+ else if (m_params.m_string_solver == "seq") {
+ setup_seq();
+ }
+ else if (m_params.m_string_solver == "auto") {
if (st.m_has_seq_non_str) {
- m_context.register_plugin(alloc(smt::theory_seq, m_manager));
- } else {
+ setup_seq();
+ }
+ else {
setup_str();
}
- } else {
+ }
+ else {
throw default_exception("invalid parameter for smt.string_solver, valid options are 'z3str3', 'seq', 'auto'");
}
}
@@ -852,6 +856,10 @@ namespace smt {
m_context.register_plugin(alloc(smt::theory_seq, m_manager));
}
+ void setup::setup_seq() {
+ m_context.register_plugin(alloc(smt::theory_seq, m_manager));
+ }
+
void setup::setup_unknown() {
static_features st(m_manager);
st.collect(m_context.get_num_asserted_formulas(), m_context.get_asserted_formulas());
@@ -861,7 +869,7 @@ namespace smt {
setup_bv();
setup_datatypes();
setup_dl();
- setup_seq(st);
+ setup_seq_str(st);
setup_card();
setup_fpa();
}
@@ -876,7 +884,7 @@ namespace smt {
setup_datatypes();
setup_bv();
setup_dl();
- setup_seq(st);
+ setup_seq_str(st);
setup_card();
setup_fpa();
return;
diff --git a/src/smt/smt_setup.h b/src/smt/smt_setup.h
index d30c896e5..80d5d7d1b 100644
--- a/src/smt/smt_setup.h
+++ b/src/smt/smt_setup.h
@@ -94,7 +94,8 @@ namespace smt {
void setup_bv();
void setup_arith();
void setup_dl();
- void setup_seq(static_features const & st);
+ void setup_seq_str(static_features const & st);
+ void setup_seq();
void setup_card();
void setup_i_arith();
void setup_mi_arith();
From ede6d7bb2b95e895afc9b6f596941776cd4b1906 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 3 May 2017 14:55:22 -0400
Subject: [PATCH 385/401] add iterator accessors to obj_pair_set
---
src/util/obj_pair_set.h | 5 +++++
1 file changed, 5 insertions(+)
diff --git a/src/util/obj_pair_set.h b/src/util/obj_pair_set.h
index 29139a51d..c4212977c 100644
--- a/src/util/obj_pair_set.h
+++ b/src/util/obj_pair_set.h
@@ -46,6 +46,11 @@ public:
bool contains(obj_pair const & p) const { return m_set.contains(p); }
void reset() { m_set.reset(); }
bool empty() const { return m_set.empty(); }
+
+ typedef typename chashtable<obj_pair, hash_proc, eq_proc>::iterator iterator;
+
+ iterator begin() { return m_set.begin(); }
+ iterator end() { return m_set.end(); }
};
#endif
From ab4fbe40b67b630203ed688269e98b6427b58b89 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 3 May 2017 17:45:56 -0400
Subject: [PATCH 386/401] cleanup
---
.gitignore | 1 -
src/ast/ast_smt2_pp.h | 2 +-
src/ast/ast_smt_pp.cpp | 1 -
src/ast/rewriter/rewriter.txt | 1 -
src/parsers/smt2/smt2parser.cpp | 3 +--
src/smt/smt_context.cpp | 7 +------
src/smt/smt_theory.h | 16 ++++++++--------
7 files changed, 11 insertions(+), 20 deletions(-)
diff --git a/.gitignore b/.gitignore
index 7cc289168..cc1c2a754 100644
--- a/.gitignore
+++ b/.gitignore
@@ -86,4 +86,3 @@ src/*/*/CMakeLists.txt
src/*/*/*/CMakeLists.txt
src/api/dotnet/cmake_install_gac.cmake.in
src/api/dotnet/cmake_uninstall_gac.cmake.in
-
diff --git a/src/ast/ast_smt2_pp.h b/src/ast/ast_smt2_pp.h
index 244594461..f2d177041 100644
--- a/src/ast/ast_smt2_pp.h
+++ b/src/ast/ast_smt2_pp.h
@@ -55,8 +55,8 @@ public:
virtual format_ns::format * pp_bv_literal(app * t, bool use_bv_lits, bool bv_neg);
virtual format_ns::format * pp_arith_literal(app * t, bool decimal, unsigned prec);
virtual format_ns::format * pp_float_literal(app * t, bool use_bv_lits, bool use_float_real_lits);
- virtual format_ns::format * pp_string_literal(app * t);
virtual format_ns::format * pp_datalog_literal(app * t);
+ virtual format_ns::format * pp_string_literal(app * t);
virtual format_ns::format * pp_sort(sort * s);
virtual format_ns::format * pp_fdecl_ref(func_decl * f);
format_ns::format * pp_fdecl_name(symbol const & fname, unsigned & len) const;
diff --git a/src/ast/ast_smt_pp.cpp b/src/ast/ast_smt_pp.cpp
index f41350dc5..706f65ac4 100644
--- a/src/ast/ast_smt_pp.cpp
+++ b/src/ast/ast_smt_pp.cpp
@@ -406,7 +406,6 @@ class smt_printer {
void visit_app(app* n) {
rational val;
- const char *str;
bool is_int, pos;
buffer<symbol> names;
unsigned bv_size;
diff --git a/src/ast/rewriter/rewriter.txt b/src/ast/rewriter/rewriter.txt
index a7a9e5eff..9eb016af2 100644
--- a/src/ast/rewriter/rewriter.txt
+++ b/src/ast/rewriter/rewriter.txt
@@ -8,7 +8,6 @@ The following classes implement theory specific rewriting rules:
- datatype_rewriter
- fpa_rewriter
- seq_rewriter
- - str_rewriter
Each of them provide the method
br_status mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result)
diff --git a/src/parsers/smt2/smt2parser.cpp b/src/parsers/smt2/smt2parser.cpp
index 491aca8ba..1486f6e6c 100644
--- a/src/parsers/smt2/smt2parser.cpp
+++ b/src/parsers/smt2/smt2parser.cpp
@@ -66,8 +66,7 @@ namespace smt2 {
scoped_ptr<bv_util> m_bv_util;
scoped_ptr<arith_util> m_arith_util;
- scoped_ptr<seq_util> m_seq_util;
-
+ scoped_ptr<seq_util> m_seq_util;
scoped_ptr<pattern_validator> m_pattern_validator;
scoped_ptr<var_shifter> m_var_shifter;
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 68a9f980d..535ae3b1e 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -1714,12 +1714,6 @@ namespace smt {
for (unsigned i = 0; i < m_th_eq_propagation_queue.size() && !inconsistent(); i++) {
new_th_eq curr = m_th_eq_propagation_queue[i];
theory * th = get_theory(curr.m_th_id);
- TRACE("t_str_eq_bug", tout
- << "th->name = " << th->get_name() << std::endl
- << "m_th_id = " << curr.m_th_id << std::endl
- << "m_lhs = " << curr.m_lhs << std::endl
- << "m_rhs = " << curr.m_rhs << std::endl
- << std::endl;);
SASSERT(th);
th->new_eq_eh(curr.m_lhs, curr.m_rhs);
#ifdef Z3DEBUG
@@ -3042,6 +3036,7 @@ namespace smt {
// not counting any literals that get assigned by this method
// this relies on bcp() to give us its old m_qhead and therefore
// bcp() should always be called before this method
+
unsigned assigned_literal_end = m_assigned_literals.size();
for (; qhead < assigned_literal_end; ++qhead) {
literal l = m_assigned_literals[qhead];
diff --git a/src/smt/smt_theory.h b/src/smt/smt_theory.h
index 7dd2819e4..67091c601 100644
--- a/src/smt/smt_theory.h
+++ b/src/smt/smt_theory.h
@@ -185,6 +185,14 @@ namespace smt {
virtual void add_theory_assumptions(expr_ref_vector & assumptions) {
}
+ /**
+ \brief This method is called from the smt_context when an unsat core is generated.
+ The theory may change the answer to UNKNOWN by returning l_undef from this method.
+ */
+ virtual lbool validate_unsat_core(expr_ref_vector & unsat_core) {
+ return l_false;
+ }
+
/**
\brief This method is invoked before the search starts.
*/
@@ -200,14 +208,6 @@ namespace smt {
return FC_DONE;
}
- /**
- \brief This method is called from the smt_context when an unsat core is generated.
- The theory may change the answer to UNKNOWN by returning l_undef from this method.
- */
- virtual lbool validate_unsat_core(expr_ref_vector & unsat_core) {
- return l_false;
- }
-
/**
\brief Parametric theories (e.g. Arrays) should implement this method.
See example in context::is_shared
From c2b5e8cfdafec22eaf7614bfc688566b1c09b42e Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Wed, 3 May 2017 17:46:06 -0400
Subject: [PATCH 387/401] fix overlap detection internalization
---
src/smt/theory_str.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index be268ec5c..a26cb2ee2 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -7305,7 +7305,7 @@ lbool theory_str::validate_unsat_core(expr_ref_vector & unsat_core) {
bool assumptionFound = false;
app * target_term = to_app(get_manager().mk_not(m_theoryStrOverlapAssumption_term));
- internalize_term(target_term);
+ get_context().internalize(target_term, false);
for (unsigned i = 0; i < unsat_core.size(); ++i) {
app * core_term = to_app(unsat_core.get(i));
// not sure if this is the correct way to compare terms in this context
From 6261a5c27bac07275178889052ae983e828a0811 Mon Sep 17 00:00:00 2001
From: Dan Liew <daniel.liew@imperial.ac.uk>
Date: Thu, 4 May 2017 15:28:20 +0100
Subject: [PATCH 388/401] Fix bug in `mk_api_doc.py` where the Z3 python
package path would be checked when building the Z3 python package
documentation was disabled.
---
doc/mk_api_doc.py | 10 ++++++----
1 file changed, 6 insertions(+), 4 deletions(-)
diff --git a/doc/mk_api_doc.py b/doc/mk_api_doc.py
index 014a152b4..234dd670c 100644
--- a/doc/mk_api_doc.py
+++ b/doc/mk_api_doc.py
@@ -103,15 +103,17 @@ def parse_options():
TEMP_DIR = pargs.temp_dir
OUTPUT_DIRECTORY = pargs.output_dir
Z3PY_PACKAGE_PATH = pargs.z3py_package_path
- if not os.path.exists(Z3PY_PACKAGE_PATH):
- raise Exception('"{}" does not exist'.format(Z3PY_PACKAGE_PATH))
- if not os.path.basename(Z3PY_PACKAGE_PATH) == 'z3':
- raise Exception('"{}" does not end with "z3"'.format(Z3PY_PACKAGE_PATH))
Z3PY_ENABLED = not pargs.no_z3py
DOTNET_ENABLED = not pargs.no_dotnet
JAVA_ENABLED = not pargs.no_java
DOTNET_API_SEARCH_PATHS = pargs.dotnet_search_paths
JAVA_API_SEARCH_PATHS = pargs.java_search_paths
+
+ if Z3PY_ENABLED:
+ if not os.path.exists(Z3PY_PACKAGE_PATH):
+ raise Exception('"{}" does not exist'.format(Z3PY_PACKAGE_PATH))
+ if not os.path.basename(Z3PY_PACKAGE_PATH) == 'z3':
+ raise Exception('"{}" does not end with "z3"'.format(Z3PY_PACKAGE_PATH))
return
def mk_dir(d):
From 1db07f1189d6560316537ec4822d41e84f0a7105 Mon Sep 17 00:00:00 2001
From: Dan Liew <daniel.liew@imperial.ac.uk>
Date: Thu, 4 May 2017 15:29:47 +0100
Subject: [PATCH 389/401] [CMake] Remove `BYPRODUCTS` declaration for
`api_docs` target. This breaks the `clean` rule when using Ninja as the CMake
generator. Unfortunately this means `clean` doesn't try to remove the
generated documentation anymore when using Ninja.
---
contrib/cmake/doc/CMakeLists.txt | 1 -
1 file changed, 1 deletion(-)
diff --git a/contrib/cmake/doc/CMakeLists.txt b/contrib/cmake/doc/CMakeLists.txt
index 86e208ab1..2f8ee0dc5 100644
--- a/contrib/cmake/doc/CMakeLists.txt
+++ b/contrib/cmake/doc/CMakeLists.txt
@@ -67,7 +67,6 @@ add_custom_target(api_docs ${ALWAYS_BUILD_DOCS_ARG}
${JAVA_API_OPTIONS}
DEPENDS
${DOC_EXTRA_DEPENDS}
- BYPRODUCTS "${DOC_DEST_DIR}"
COMMENT "Generating documentation"
${ADD_CUSTOM_TARGET_USES_TERMINAL_ARG}
)
From 0ebce66c57e124ebcb4c3bb3d34fe9d35779341b Mon Sep 17 00:00:00 2001
From: "Christoph M. Wintersteiger" <cwinter@microsoft.com>
Date: Fri, 5 May 2017 14:22:40 +0100
Subject: [PATCH 390/401] Fixed bug with .NET keyfile path containing spaces.
Fixes #1003.
---
scripts/mk_util.py | 2 ++
1 file changed, 2 insertions(+)
diff --git a/scripts/mk_util.py b/scripts/mk_util.py
index f05250ae7..b0ac92a8d 100644
--- a/scripts/mk_util.py
+++ b/scripts/mk_util.py
@@ -1633,6 +1633,8 @@ class DotNetDLLComponent(Component):
if not self.key_file is None:
print("%s.dll will be signed using key '%s'." % (self.dll_name, self.key_file))
+ if (self.key_file.find(' ') != -1):
+ self.key_file = '"' + self.key_file + '"'
cscCmdLine.append('/keyfile:{}'.format(self.key_file))
cscCmdLine.extend( ['/unsafe+',
From 79dcf03a42a79f4f6fe09b60ff809be39dce38d8 Mon Sep 17 00:00:00 2001
From: "Christoph M. Wintersteiger" <cwinter@microsoft.com>
Date: Fri, 5 May 2017 15:01:10 +0100
Subject: [PATCH 391/401] Enabled C++11 in GCC and Clang
---
scripts/mk_util.py | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/scripts/mk_util.py b/scripts/mk_util.py
index b0ac92a8d..d1bbd6ca4 100644
--- a/scripts/mk_util.py
+++ b/scripts/mk_util.py
@@ -2421,6 +2421,7 @@ def mk_config():
FOCI2 = False
if GIT_HASH:
CPPFLAGS = '%s -DZ3GITHASH=%s' % (CPPFLAGS, GIT_HASH)
+ CXXFLAGS = '%s -std=c++11' % CXXFLAGS
CXXFLAGS = '%s -fvisibility=hidden -c' % CXXFLAGS
FPMATH = test_fpmath(CXX)
CXXFLAGS = '%s %s' % (CXXFLAGS, FPMATH_FLAGS)
@@ -2445,8 +2446,8 @@ def mk_config():
CXXFLAGS = '%s -Wno-unknown-pragmas -Wno-overloaded-virtual -Wno-unused-value' % CXXFLAGS
sysname, _, _, _, machine = os.uname()
if sysname == 'Darwin':
- SO_EXT = '.dylib'
- SLIBFLAGS = '-dynamiclib'
+ SO_EXT = '.dylib'
+ SLIBFLAGS = '-dynamiclib'
elif sysname == 'Linux':
CXXFLAGS = '%s -fno-strict-aliasing -D_LINUX_' % CXXFLAGS
OS_DEFINES = '-D_LINUX_'
From 7e1fae418a766532f99cea06a1c6021268661864 Mon Sep 17 00:00:00 2001
From: Nikolaj Bjorner <nbjorner@microsoft.com>
Date: Fri, 5 May 2017 10:59:47 -0400
Subject: [PATCH 392/401] fix #1005, disable expansion of regular expression
range to union as it degrades performance significantly
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
---
src/ast/rewriter/seq_rewriter.cpp | 1 +
src/smt/theory_arith.h | 2 +-
src/smt/theory_arith_aux.h | 11 +++++++----
3 files changed, 9 insertions(+), 5 deletions(-)
diff --git a/src/ast/rewriter/seq_rewriter.cpp b/src/ast/rewriter/seq_rewriter.cpp
index 85d2ba749..7aa9329d4 100644
--- a/src/ast/rewriter/seq_rewriter.cpp
+++ b/src/ast/rewriter/seq_rewriter.cpp
@@ -1434,6 +1434,7 @@ br_status seq_rewriter::mk_re_star(expr* a, expr_ref& result) {
* (re.range c_1 c_n) = (re.union (str.to.re c1) (str.to.re c2) ... (str.to.re cn))
*/
br_status seq_rewriter::mk_re_range(expr* lo, expr* hi, expr_ref& result) {
+ return BR_FAILED;
TRACE("seq", tout << "rewrite re.range [" << mk_pp(lo, m()) << " " << mk_pp(hi, m()) << "]\n";);
zstring str_lo, str_hi;
if (m_util.str.is_string(lo, str_lo) && m_util.str.is_string(hi, str_hi)) {
diff --git a/src/smt/theory_arith.h b/src/smt/theory_arith.h
index 439adbdff..cdc1a3933 100644
--- a/src/smt/theory_arith.h
+++ b/src/smt/theory_arith.h
@@ -505,7 +505,7 @@ namespace smt {
struct var_value_eq {
theory_arith & m_th;
var_value_eq(theory_arith & th):m_th(th) {}
- bool operator()(theory_var v1, theory_var v2) const { return m_th.get_value(v1) == m_th.get_value(v2) && m_th.is_int(v1) == m_th.is_int(v2); }
+ bool operator()(theory_var v1, theory_var v2) const { return m_th.get_value(v1) == m_th.get_value(v2) && m_th.is_int_src(v1) == m_th.is_int_src(v2); }
};
typedef int_hashtable<var_value_hash, var_value_eq> var_value_table;
diff --git a/src/smt/theory_arith_aux.h b/src/smt/theory_arith_aux.h
index de357c8d3..54b617152 100644
--- a/src/smt/theory_arith_aux.h
+++ b/src/smt/theory_arith_aux.h
@@ -2201,16 +2201,19 @@ namespace smt {
int num = get_num_vars();
for (theory_var v = 0; v < num; v++) {
enode * n = get_enode(v);
- TRACE("func_interp_bug", tout << "#" << n->get_owner_id() << " -> " << m_value[v] << "\n";);
- if (!is_relevant_and_shared(n))
+ TRACE("func_interp_bug", tout << mk_pp(n->get_owner(), get_manager()) << " -> " << m_value[v] << " root #" << n->get_root()->get_owner_id() << " " << is_relevant_and_shared(n) << "\n";);
+ if (!is_relevant_and_shared(n)) {
continue;
+ }
theory_var other = null_theory_var;
other = m_var_value_table.insert_if_not_there(v);
- if (other == v)
+ if (other == v) {
continue;
+ }
enode * n2 = get_enode(other);
- if (n->get_root() == n2->get_root())
+ if (n->get_root() == n2->get_root()) {
continue;
+ }
TRACE("func_interp_bug", tout << "adding to assume_eq queue #" << n->get_owner_id() << " #" << n2->get_owner_id() << "\n";);
m_assume_eq_candidates.push_back(std::make_pair(other, v));
result = true;
From 75ba4d5a4d537f60f935d47a0f0edf84177de528 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 5 May 2017 14:54:36 -0400
Subject: [PATCH 393/401] remove unneeded include
---
src/smt/smt_context.cpp | 1 -
1 file changed, 1 deletion(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 535ae3b1e..37a6d32b7 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -37,7 +37,6 @@ Revision History:
#include"model_pp.h"
#include"ast_smt2_pp.h"
#include"ast_translation.h"
-#include"theory_seq.h"
namespace smt {
From 7ddd43e16df6275488cec300cc050f87419b7450 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 5 May 2017 15:29:58 -0400
Subject: [PATCH 394/401] first-class re.range support in theory_str
---
src/smt/theory_str.cpp | 98 +++++++++++++++++++++++++++++++++++++++++-
1 file changed, 97 insertions(+), 1 deletion(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index a26cb2ee2..e7c99da69 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1673,6 +1673,13 @@ zstring theory_str::get_std_regex_str(expr * regex) {
expr * reg1Ast = a_regex->get_arg(0);
zstring reg1Str = get_std_regex_str(reg1Ast);
return zstring("(") + reg1Str + zstring(")*");
+ } else if (u.re.is_range(a_regex)) {
+ expr * range1 = a_regex->get_arg(0);
+ expr * range2 = a_regex->get_arg(1);
+ zstring range1val, range2val;
+ u.str.is_string(range1, range1val);
+ u.str.is_string(range2, range2val);
+ return zstring("[") + range1val + zstring("-") + range2val + zstring("]");
} else {
TRACE("str", tout << "BUG: unrecognized regex term " << mk_pp(regex, get_manager()) << std::endl;);
UNREACHABLE(); return zstring("");
@@ -1752,6 +1759,36 @@ void theory_str::instantiate_axiom_RegexIn(enode * e) {
expr_ref finalAxiom(mk_and(items), m);
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
+ } else if (u.re.is_range(regex)) {
+ // (re.range "A" "Z") unfolds to (re.union "A" "B" ... "Z");
+ // we rewrite to expr IFF (str = "A" or str = "B" or ... or str = "Z")
+ expr_ref lo(regex->get_arg(0), m);
+ expr_ref hi(regex->get_arg(1), m);
+ zstring str_lo, str_hi;
+ SASSERT(u.str.is_string(lo));
+ SASSERT(u.str.is_string(hi));
+ u.str.is_string(lo, str_lo);
+ u.str.is_string(hi, str_hi);
+ SASSERT(str_lo.length() == 1);
+ SASSERT(str_hi.length() == 1);
+ unsigned int c1 = str_lo[0];
+ unsigned int c2 = str_hi[0];
+ if (c1 > c2) {
+ // exchange
+ unsigned int tmp = c1;
+ c1 = c2;
+ c2 = tmp;
+ }
+ expr_ref_vector range_cases(m);
+ for (unsigned int ch = c1; ch <= c2; ++ch) {
+ zstring s_ch(ch);
+ expr_ref rhs(ctx.mk_eq_atom(str, u.str.mk_string(s_ch)), m);
+ range_cases.push_back(rhs);
+ }
+ expr_ref rhs(mk_or(range_cases), m);
+ expr_ref finalAxiom(m.mk_iff(ex, rhs), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
} else {
TRACE("str", tout << "ERROR: unknown regex expression " << mk_pp(regex, m) << "!" << std::endl;);
NOT_IMPLEMENTED_YET();
@@ -6165,7 +6202,6 @@ void nfa::convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u) {
zstring str;
if (u.str.is_string(arg_str, str)) {
TRACE("str", tout << "build NFA for '" << str << "'" << "\n";);
-
/*
* For an n-character string, we make (n-1) intermediate states,
* labelled i_(0) through i_(n-2).
@@ -6227,6 +6263,33 @@ void nfa::convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u) {
make_epsilon_move(end_subex, start_subex);
make_epsilon_move(end_subex, end);
TRACE("str", tout << "star NFA: start = " << start << ", end = " << end << std::endl;);
+ } else if (u.re.is_range(e)) {
+ // range('a', 'z')
+ // start --'a'--> end
+ // start --'b'--> end
+ // ...
+ // start --'z'--> end
+ app * a = to_app(e);
+ expr * c1 = a->get_arg(0);
+ expr * c2 = a->get_arg(1);
+ zstring s_c1, s_c2;
+ u.str.is_string(c1, s_c1);
+ u.str.is_string(c2, s_c2);
+
+ unsigned int id1 = s_c1[0];
+ unsigned int id2 = s_c2[0];
+ if (id1 > id2) {
+ unsigned int tmp = id1;
+ id1 = id2;
+ id2 = tmp;
+ }
+
+ for (unsigned int i = id1; i <= id2; ++i) {
+ char ch = (char)i;
+ make_transition(start, ch, end);
+ }
+
+ TRACE("str", tout << "range NFA: start = " << start << ", end = " << end << std::endl;);
} else {
TRACE("str", tout << "invalid regular expression" << std::endl;);
m_valid = false;
@@ -9429,6 +9492,39 @@ void theory_str::reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vect
items.push_back(ctx.mk_eq_atom(var, unrollFunc));
items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_strlen(unrollFunc)));
return;
+ }
+ // re.range
+ else if (u.re.is_range(regexFuncDecl)) {
+ // var in range("a", "z")
+ // ==>
+ // (var = "a" or var = "b" or ... or var = "z")
+ expr_ref lo(regexFuncDecl->get_arg(0), mgr);
+ expr_ref hi(regexFuncDecl->get_arg(1), mgr);
+ zstring str_lo, str_hi;
+ SASSERT(u.str.is_string(lo));
+ SASSERT(u.str.is_string(hi));
+ u.str.is_string(lo, str_lo);
+ u.str.is_string(hi, str_hi);
+ SASSERT(str_lo.length() == 1);
+ SASSERT(str_hi.length() == 1);
+ unsigned int c1 = str_lo[0];
+ unsigned int c2 = str_hi[0];
+ if (c1 > c2) {
+ // exchange
+ unsigned int tmp = c1;
+ c1 = c2;
+ c2 = tmp;
+ }
+ expr_ref_vector range_cases(mgr);
+ for (unsigned int ch = c1; ch <= c2; ++ch) {
+ zstring s_ch(ch);
+ expr_ref rhs(ctx.mk_eq_atom(var, u.str.mk_string(s_ch)), mgr);
+ range_cases.push_back(rhs);
+ }
+ expr_ref rhs(mk_or(range_cases), mgr);
+ SASSERT(rhs);
+ assert_axiom(rhs);
+ return;
} else {
get_manager().raise_exception("unrecognized regex operator");
UNREACHABLE();
From 8eb26e25c298ed17ae9a16ab8ed47983eb9316bb Mon Sep 17 00:00:00 2001
From: Nikolaj Bjorner <nbjorner@microsoft.com>
Date: Fri, 5 May 2017 17:03:03 -0400
Subject: [PATCH 395/401] add new files to cmakelist.txt files
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
---
contrib/cmake/src/smt/CMakeLists.txt | 1 +
contrib/cmake/src/smt/params/CMakeLists.txt | 1 +
2 files changed, 2 insertions(+)
diff --git a/contrib/cmake/src/smt/CMakeLists.txt b/contrib/cmake/src/smt/CMakeLists.txt
index bd8ad3f31..c344e936f 100644
--- a/contrib/cmake/src/smt/CMakeLists.txt
+++ b/contrib/cmake/src/smt/CMakeLists.txt
@@ -58,6 +58,7 @@ z3_add_component(smt
theory_opt.cpp
theory_pb.cpp
theory_seq.cpp
+ theory_str.cpp
theory_utvpi.cpp
theory_wmaxsat.cpp
uses_theory.cpp
diff --git a/contrib/cmake/src/smt/params/CMakeLists.txt b/contrib/cmake/src/smt/params/CMakeLists.txt
index 67224a287..500423dcc 100644
--- a/contrib/cmake/src/smt/params/CMakeLists.txt
+++ b/contrib/cmake/src/smt/params/CMakeLists.txt
@@ -8,6 +8,7 @@ z3_add_component(smt_params
theory_array_params.cpp
theory_bv_params.cpp
theory_pb_params.cpp
+ theory_str_params.cpp
COMPONENT_DEPENDENCIES
ast
bit_blaster
From 21c8f4aae01880dba291cc94accd741a394cb3c6 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 5 May 2017 19:26:15 -0400
Subject: [PATCH 396/401] formatting theory_str.cpp
---
src/smt/theory_str.cpp | 20032 +++++++++++++++++++--------------------
1 file changed, 10015 insertions(+), 10017 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index e7c99da69..4a6a6da5b 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1,19 +1,19 @@
/*++
-Module Name:
+ Module Name:
- theory_str.cpp
+ theory_str.cpp
-Abstract:
+ Abstract:
- String Theory Plugin
+ String Theory Plugin
-Author:
+ Author:
- Murphy Berzish and Yunhui Zheng
+ Murphy Berzish and Yunhui Zheng
-Revision History:
+ Revision History:
---*/
+ --*/
#include"ast_smt2_pp.h"
#include"smt_context.h"
#include"theory_str.h"
@@ -24,13 +24,11 @@ Revision History:
#include<vector>
#include<algorithm>
#include"theory_seq_empty.h"
-
-#include "../ast/ast.h"
#include"theory_arith.h"
namespace smt {
-
-theory_str::theory_str(ast_manager & m, theory_str_params const & params):
+
+ theory_str::theory_str(ast_manager & m, theory_str_params const & params):
theory(m.mk_family_id("seq")),
m_params(params),
/* Options */
@@ -64,3864 +62,3041 @@ theory_str::theory_str(ast_manager & m, theory_str_params const & params):
cacheMissCount(0),
m_find(*this),
m_trail_stack(*this)
-{
- initialize_charset();
-}
+ {
+ initialize_charset();
+ }
-theory_str::~theory_str() {
- m_trail_stack.reset();
-}
+ theory_str::~theory_str() {
+ m_trail_stack.reset();
+ }
-expr * theory_str::mk_string(zstring const& str) {
- if (m_params.m_StringConstantCache) {
- ++totalCacheAccessCount;
- expr * val;
- if (stringConstantCache.find(str, val)) {
- return val;
+ expr * theory_str::mk_string(zstring const& str) {
+ if (m_params.m_StringConstantCache) {
+ ++totalCacheAccessCount;
+ expr * val;
+ if (stringConstantCache.find(str, val)) {
+ return val;
+ } else {
+ val = u.str.mk_string(str);
+ m_trail.push_back(val);
+ stringConstantCache.insert(str, val);
+ return val;
+ }
} else {
- val = u.str.mk_string(str);
- m_trail.push_back(val);
- stringConstantCache.insert(str, val);
- return val;
+ return u.str.mk_string(str);
}
- } else {
- return u.str.mk_string(str);
- }
-}
-
-expr * theory_str::mk_string(const char * str) {
- symbol sym(str);
- return u.str.mk_string(sym);
-}
-
-void theory_str::initialize_charset() {
- bool defaultCharset = true;
- if (defaultCharset) {
- // valid C strings can't contain the null byte ('\0')
- charSetSize = 255;
- char_set = alloc_svect(char, charSetSize);
- int idx = 0;
- // small letters
- for (int i = 97; i < 123; i++) {
- char_set[idx] = (char) i;
- charSetLookupTable[char_set[idx]] = idx;
- idx++;
- }
- // caps
- for (int i = 65; i < 91; i++) {
- char_set[idx] = (char) i;
- charSetLookupTable[char_set[idx]] = idx;
- idx++;
- }
- // numbers
- for (int i = 48; i < 58; i++) {
- char_set[idx] = (char) i;
- charSetLookupTable[char_set[idx]] = idx;
- idx++;
- }
- // printable marks - 1
- for (int i = 32; i < 48; i++) {
- char_set[idx] = (char) i;
- charSetLookupTable[char_set[idx]] = idx;
- idx++;
- }
- // printable marks - 2
- for (int i = 58; i < 65; i++) {
- char_set[idx] = (char) i;
- charSetLookupTable[char_set[idx]] = idx;
- idx++;
- }
- // printable marks - 3
- for (int i = 91; i < 97; i++) {
- char_set[idx] = (char) i;
- charSetLookupTable[char_set[idx]] = idx;
- idx++;
- }
- // printable marks - 4
- for (int i = 123; i < 127; i++) {
- char_set[idx] = (char) i;
- charSetLookupTable[char_set[idx]] = idx;
- idx++;
- }
- // non-printable - 1
- for (int i = 1; i < 32; i++) {
- char_set[idx] = (char) i;
- charSetLookupTable[char_set[idx]] = idx;
- idx++;
- }
- // non-printable - 2
- for (int i = 127; i < 256; i++) {
- char_set[idx] = (char) i;
- charSetLookupTable[char_set[idx]] = idx;
- idx++;
- }
- } else {
- const char setset[] = { 'a', 'b', 'c' };
- int fSize = sizeof(setset) / sizeof(char);
-
- char_set = alloc_svect(char, fSize);
- charSetSize = fSize;
- for (int i = 0; i < charSetSize; i++) {
- char_set[i] = setset[i];
- charSetLookupTable[setset[i]] = i;
- }
- }
-}
-
-void theory_str::assert_axiom(expr * e) {
- if (opt_VerifyFinalCheckProgress) {
- finalCheckProgressIndicator = true;
}
- if (get_manager().is_true(e)) return;
- TRACE("str", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
- context & ctx = get_context();
- if (!ctx.b_internalized(e)) {
- ctx.internalize(e, false);
- }
- literal lit(ctx.get_literal(e));
- ctx.mark_as_relevant(lit);
- ctx.mk_th_axiom(get_id(), 1, &lit);
-
- // crash/error avoidance: add all axioms to the trail
- m_trail.push_back(e);
-
- //TRACE("str", tout << "done asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
-}
-
-expr * theory_str::rewrite_implication(expr * premise, expr * conclusion) {
- ast_manager & m = get_manager();
- return m.mk_or(m.mk_not(premise), conclusion);
-}
-
-void theory_str::assert_implication(expr * premise, expr * conclusion) {
- ast_manager & m = get_manager();
- TRACE("str", tout << "asserting implication " << mk_ismt2_pp(premise, m) << " -> " << mk_ismt2_pp(conclusion, m) << std::endl;);
- expr_ref axiom(m.mk_or(m.mk_not(premise), conclusion), m);
- assert_axiom(axiom);
-}
-
-bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
- return internalize_term(atom);
-}
-
-bool theory_str::internalize_term(app * term) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
- SASSERT(term->get_family_id() == get_family_id());
-
- TRACE("str", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
-
- // emulation of user_smt_theory::internalize_term()
-
- unsigned num_args = term->get_num_args();
- for (unsigned i = 0; i < num_args; ++i) {
- ctx.internalize(term->get_arg(i), false);
- }
- if (ctx.e_internalized(term)) {
- enode * e = ctx.get_enode(term);
- mk_var(e);
- return true;
- }
- // m_parents.push_back(term);
- enode * e = ctx.mk_enode(term, false, m.is_bool(term), true);
- if (m.is_bool(term)) {
- bool_var bv = ctx.mk_bool_var(term);
- ctx.set_var_theory(bv, get_id());
- ctx.set_enode_flag(bv, true);
- }
- // make sure every argument is attached to a theory variable
- for (unsigned i = 0; i < num_args; ++i) {
- enode * arg = e->get_arg(i);
- theory_var v_arg = mk_var(arg);
- TRACE("str", tout << "arg has theory var #" << v_arg << std::endl;);
+ expr * theory_str::mk_string(const char * str) {
+ symbol sym(str);
+ return u.str.mk_string(sym);
}
- theory_var v = mk_var(e);
- TRACE("str", tout << "term has theory var #" << v << std::endl;);
+ void theory_str::initialize_charset() {
+ bool defaultCharset = true;
+ if (defaultCharset) {
+ // valid C strings can't contain the null byte ('\0')
+ charSetSize = 255;
+ char_set = alloc_svect(char, charSetSize);
+ int idx = 0;
+ // small letters
+ for (int i = 97; i < 123; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // caps
+ for (int i = 65; i < 91; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // numbers
+ for (int i = 48; i < 58; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // printable marks - 1
+ for (int i = 32; i < 48; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // printable marks - 2
+ for (int i = 58; i < 65; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // printable marks - 3
+ for (int i = 91; i < 97; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // printable marks - 4
+ for (int i = 123; i < 127; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // non-printable - 1
+ for (int i = 1; i < 32; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ // non-printable - 2
+ for (int i = 127; i < 256; i++) {
+ char_set[idx] = (char) i;
+ charSetLookupTable[char_set[idx]] = idx;
+ idx++;
+ }
+ } else {
+ const char setset[] = { 'a', 'b', 'c' };
+ int fSize = sizeof(setset) / sizeof(char);
- if (opt_EagerStringConstantLengthAssertions && u.str.is_string(term)) {
- TRACE("str", tout << "eagerly asserting length of string term " << mk_pp(term, m) << std::endl;);
- m_basicstr_axiom_todo.insert(e);
- }
- return true;
-}
-
-enode* theory_str::ensure_enode(expr* e) {
- context& ctx = get_context();
- if (!ctx.e_internalized(e)) {
- ctx.internalize(e, false);
- }
- enode* n = ctx.get_enode(e);
- ctx.mark_as_relevant(n);
- return n;
-}
-
-void theory_str::refresh_theory_var(expr * e) {
- enode * en = ensure_enode(e);
- theory_var v = mk_var(en);
- TRACE("str", tout << "refresh " << mk_pp(e, get_manager()) << ": v#" << v << std::endl;);
- m_basicstr_axiom_todo.push_back(en);
-}
-
-theory_var theory_str::mk_var(enode* n) {
- TRACE("str", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;);
- ast_manager & m = get_manager();
- if (!(m.get_sort(n->get_owner()) == u.str.mk_string_sort())) {
- return null_theory_var;
- }
- if (is_attached_to_var(n)) {
- TRACE("str", tout << "already attached to theory var" << std::endl;);
- return n->get_th_var(get_id());
- } else {
- theory_var v = theory::mk_var(n);
- m_find.mk_var();
- TRACE("str", tout << "new theory var v#" << v << std::endl;);
- get_context().attach_th_var(n, this, v);
- get_context().mark_as_relevant(n);
- return v;
- }
-}
-
-static void cut_vars_map_copy(std::map<expr*, int> & dest, std::map<expr*, int> & src) {
- std::map<expr*, int>::iterator itor = src.begin();
- for (; itor != src.end(); itor++) {
- dest[itor->first] = 1;
- }
-}
-
-bool theory_str::has_self_cut(expr * n1, expr * n2) {
- if (!cut_var_map.contains(n1)) {
- return false;
- }
- if (!cut_var_map.contains(n2)) {
- return false;
- }
- if (cut_var_map[n1].empty() || cut_var_map[n2].empty()) {
- return false;
+ char_set = alloc_svect(char, fSize);
+ charSetSize = fSize;
+ for (int i = 0; i < charSetSize; i++) {
+ char_set[i] = setset[i];
+ charSetLookupTable[setset[i]] = i;
+ }
+ }
}
- std::map<expr*, int>::iterator itor = cut_var_map[n1].top()->vars.begin();
- for (; itor != cut_var_map[n1].top()->vars.end(); ++itor) {
- if (cut_var_map[n2].top()->vars.find(itor->first) != cut_var_map[n2].top()->vars.end()) {
+ void theory_str::assert_axiom(expr * e) {
+ if (opt_VerifyFinalCheckProgress) {
+ finalCheckProgressIndicator = true;
+ }
+
+ if (get_manager().is_true(e)) return;
+ TRACE("str", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
+ context & ctx = get_context();
+ if (!ctx.b_internalized(e)) {
+ ctx.internalize(e, false);
+ }
+ literal lit(ctx.get_literal(e));
+ ctx.mark_as_relevant(lit);
+ ctx.mk_th_axiom(get_id(), 1, &lit);
+
+ // crash/error avoidance: add all axioms to the trail
+ m_trail.push_back(e);
+
+ //TRACE("str", tout << "done asserting " << mk_ismt2_pp(e, get_manager()) << std::endl;);
+ }
+
+ expr * theory_str::rewrite_implication(expr * premise, expr * conclusion) {
+ ast_manager & m = get_manager();
+ return m.mk_or(m.mk_not(premise), conclusion);
+ }
+
+ void theory_str::assert_implication(expr * premise, expr * conclusion) {
+ ast_manager & m = get_manager();
+ TRACE("str", tout << "asserting implication " << mk_ismt2_pp(premise, m) << " -> " << mk_ismt2_pp(conclusion, m) << std::endl;);
+ expr_ref axiom(m.mk_or(m.mk_not(premise), conclusion), m);
+ assert_axiom(axiom);
+ }
+
+ bool theory_str::internalize_atom(app * atom, bool gate_ctx) {
+ return internalize_term(atom);
+ }
+
+ bool theory_str::internalize_term(app * term) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ SASSERT(term->get_family_id() == get_family_id());
+
+ TRACE("str", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << std::endl;);
+
+ // emulation of user_smt_theory::internalize_term()
+
+ unsigned num_args = term->get_num_args();
+ for (unsigned i = 0; i < num_args; ++i) {
+ ctx.internalize(term->get_arg(i), false);
+ }
+ if (ctx.e_internalized(term)) {
+ enode * e = ctx.get_enode(term);
+ mk_var(e);
return true;
}
- }
- return false;
-}
+ // m_parents.push_back(term);
+ enode * e = ctx.mk_enode(term, false, m.is_bool(term), true);
+ if (m.is_bool(term)) {
+ bool_var bv = ctx.mk_bool_var(term);
+ ctx.set_var_theory(bv, get_id());
+ ctx.set_enode_flag(bv, true);
+ }
+ // make sure every argument is attached to a theory variable
+ for (unsigned i = 0; i < num_args; ++i) {
+ enode * arg = e->get_arg(i);
+ theory_var v_arg = mk_var(arg);
+ TRACE("str", tout << "arg has theory var #" << v_arg << std::endl;);
+ }
-void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node) {
- // crash avoidance?
- m_trail.push_back(baseNode);
- m_trail.push_back(node);
- if (!cut_var_map.contains(baseNode)) {
- T_cut * varInfo = alloc(T_cut);
- varInfo->level = slevel;
- varInfo->vars[node] = 1;
- cut_var_map.insert(baseNode, std::stack<T_cut*>());
- cut_var_map[baseNode].push(varInfo);
- TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
- } else {
- if (cut_var_map[baseNode].empty()) {
+ theory_var v = mk_var(e);
+ TRACE("str", tout << "term has theory var #" << v << std::endl;);
+
+ if (opt_EagerStringConstantLengthAssertions && u.str.is_string(term)) {
+ TRACE("str", tout << "eagerly asserting length of string term " << mk_pp(term, m) << std::endl;);
+ m_basicstr_axiom_todo.insert(e);
+ }
+ return true;
+ }
+
+ enode* theory_str::ensure_enode(expr* e) {
+ context& ctx = get_context();
+ if (!ctx.e_internalized(e)) {
+ ctx.internalize(e, false);
+ }
+ enode* n = ctx.get_enode(e);
+ ctx.mark_as_relevant(n);
+ return n;
+ }
+
+ void theory_str::refresh_theory_var(expr * e) {
+ enode * en = ensure_enode(e);
+ theory_var v = mk_var(en);
+ TRACE("str", tout << "refresh " << mk_pp(e, get_manager()) << ": v#" << v << std::endl;);
+ m_basicstr_axiom_todo.push_back(en);
+ }
+
+ theory_var theory_str::mk_var(enode* n) {
+ TRACE("str", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;);
+ ast_manager & m = get_manager();
+ if (!(m.get_sort(n->get_owner()) == u.str.mk_string_sort())) {
+ return null_theory_var;
+ }
+ if (is_attached_to_var(n)) {
+ TRACE("str", tout << "already attached to theory var" << std::endl;);
+ return n->get_th_var(get_id());
+ } else {
+ theory_var v = theory::mk_var(n);
+ m_find.mk_var();
+ TRACE("str", tout << "new theory var v#" << v << std::endl;);
+ get_context().attach_th_var(n, this, v);
+ get_context().mark_as_relevant(n);
+ return v;
+ }
+ }
+
+ static void cut_vars_map_copy(std::map<expr*, int> & dest, std::map<expr*, int> & src) {
+ std::map<expr*, int>::iterator itor = src.begin();
+ for (; itor != src.end(); itor++) {
+ dest[itor->first] = 1;
+ }
+ }
+
+ bool theory_str::has_self_cut(expr * n1, expr * n2) {
+ if (!cut_var_map.contains(n1)) {
+ return false;
+ }
+ if (!cut_var_map.contains(n2)) {
+ return false;
+ }
+ if (cut_var_map[n1].empty() || cut_var_map[n2].empty()) {
+ return false;
+ }
+
+ std::map<expr*, int>::iterator itor = cut_var_map[n1].top()->vars.begin();
+ for (; itor != cut_var_map[n1].top()->vars.end(); ++itor) {
+ if (cut_var_map[n2].top()->vars.find(itor->first) != cut_var_map[n2].top()->vars.end()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void theory_str::add_cut_info_one_node(expr * baseNode, int slevel, expr * node) {
+ // crash avoidance?
+ m_trail.push_back(baseNode);
+ m_trail.push_back(node);
+ if (!cut_var_map.contains(baseNode)) {
T_cut * varInfo = alloc(T_cut);
varInfo->level = slevel;
varInfo->vars[node] = 1;
+ cut_var_map.insert(baseNode, std::stack<T_cut*>());
cut_var_map[baseNode].push(varInfo);
TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
- if (cut_var_map[baseNode].top()->level < slevel) {
+ if (cut_var_map[baseNode].empty()) {
T_cut * varInfo = alloc(T_cut);
varInfo->level = slevel;
- cut_vars_map_copy(varInfo->vars, cut_var_map[baseNode].top()->vars);
varInfo->vars[node] = 1;
cut_var_map[baseNode].push(varInfo);
TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
- } else if (cut_var_map[baseNode].top()->level == slevel) {
- cut_var_map[baseNode].top()->vars[node] = 1;
- TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
- get_manager().raise_exception("entered illegal state during add_cut_info_one_node()");
+ if (cut_var_map[baseNode].top()->level < slevel) {
+ T_cut * varInfo = alloc(T_cut);
+ varInfo->level = slevel;
+ cut_vars_map_copy(varInfo->vars, cut_var_map[baseNode].top()->vars);
+ varInfo->vars[node] = 1;
+ cut_var_map[baseNode].push(varInfo);
+ TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
+ } else if (cut_var_map[baseNode].top()->level == slevel) {
+ cut_var_map[baseNode].top()->vars[node] = 1;
+ TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;);
+ } else {
+ get_manager().raise_exception("entered illegal state during add_cut_info_one_node()");
+ }
}
}
}
-}
-void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode) {
- // crash avoidance?
- m_trail.push_back(destNode);
- m_trail.push_back(srcNode);
- if (!cut_var_map.contains(srcNode)) {
- get_manager().raise_exception("illegal state in add_cut_info_merge(): cut_var_map doesn't contain srcNode");
- }
+ void theory_str::add_cut_info_merge(expr * destNode, int slevel, expr * srcNode) {
+ // crash avoidance?
+ m_trail.push_back(destNode);
+ m_trail.push_back(srcNode);
+ if (!cut_var_map.contains(srcNode)) {
+ get_manager().raise_exception("illegal state in add_cut_info_merge(): cut_var_map doesn't contain srcNode");
+ }
- if (cut_var_map[srcNode].empty()) {
- get_manager().raise_exception("illegal state in add_cut_info_merge(): cut_var_map[srcNode] is empty");
- }
+ if (cut_var_map[srcNode].empty()) {
+ get_manager().raise_exception("illegal state in add_cut_info_merge(): cut_var_map[srcNode] is empty");
+ }
- if (!cut_var_map.contains(destNode)) {
- T_cut * varInfo = alloc(T_cut);
- varInfo->level = slevel;
- cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
- cut_var_map.insert(destNode, std::stack<T_cut*>());
- cut_var_map[destNode].push(varInfo);
- TRACE("str", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
- } else {
- if (cut_var_map[destNode].empty() || cut_var_map[destNode].top()->level < slevel) {
+ if (!cut_var_map.contains(destNode)) {
T_cut * varInfo = alloc(T_cut);
varInfo->level = slevel;
- cut_vars_map_copy(varInfo->vars, cut_var_map[destNode].top()->vars);
cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
+ cut_var_map.insert(destNode, std::stack<T_cut*>());
cut_var_map[destNode].push(varInfo);
TRACE("str", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
- } else if (cut_var_map[destNode].top()->level == slevel) {
- cut_vars_map_copy(cut_var_map[destNode].top()->vars, cut_var_map[srcNode].top()->vars);
- TRACE("str", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
} else {
- get_manager().raise_exception("illegal state in add_cut_info_merge(): inconsistent slevels");
- }
- }
-}
-
-void theory_str::check_and_init_cut_var(expr * node) {
- if (cut_var_map.contains(node)) {
- return;
- } else if (!u.str.is_string(node)) {
- add_cut_info_one_node(node, -1, node);
- }
-}
-
-literal theory_str::mk_literal(expr* _e) {
- ast_manager & m = get_manager();
- expr_ref e(_e, m);
- context& ctx = get_context();
- ensure_enode(e);
- return ctx.get_literal(e);
-}
-
-app * theory_str::mk_int(int n) {
- return m_autil.mk_numeral(rational(n), true);
-}
-
-app * theory_str::mk_int(rational & q) {
- return m_autil.mk_numeral(q, true);
-}
-
-expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
- ast_manager & m = get_manager();
-
- std::stringstream ss;
- ss << "$$_len_" << mk_ismt2_pp(node, m) << "_" << lTries << "_" << tmpLenTestVarCount;
- tmpLenTestVarCount += 1;
- std::string name = ss.str();
- app * var = mk_str_var(name);
- internal_lenTest_vars.insert(var);
- m_trail.push_back(var);
- return var;
-}
-
-expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
- ast_manager & m = get_manager();
- std::stringstream ss;
- ss << "$$_val_" << mk_ismt2_pp(node, m) << "_" << len << "_" << vTries << "_" << tmpValTestVarCount;
- tmpValTestVarCount += 1;
- std::string name = ss.str();
- app * var = mk_str_var(name);
- internal_valTest_vars.insert(var);
- m_trail.push_back(var);
- return var;
-}
-
-void theory_str::track_variable_scope(expr * var) {
- if (internal_variable_scope_levels.find(sLevel) == internal_variable_scope_levels.end()) {
- internal_variable_scope_levels[sLevel] = std::set<expr*>();
- }
- internal_variable_scope_levels[sLevel].insert(var);
-}
-
-app * theory_str::mk_internal_xor_var() {
- return mk_int_var("$$_xor");
-}
-
-app * theory_str::mk_int_var(std::string name) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- TRACE("str", tout << "creating integer variable " << name << " at scope level " << sLevel << std::endl;);
-
- sort * int_sort = m.mk_sort(m_autil.get_family_id(), INT_SORT);
- app * a = m.mk_fresh_const(name.c_str(), int_sort);
-
- ctx.internalize(a, false);
- SASSERT(ctx.get_enode(a) != NULL);
- SASSERT(ctx.e_internalized(a));
- ctx.mark_as_relevant(a);
- // I'm assuming that this combination will do the correct thing in the integer theory.
-
- //mk_var(ctx.get_enode(a));
- m_trail.push_back(a);
- //variable_set.insert(a);
- //internal_variable_set.insert(a);
- //track_variable_scope(a);
-
- return a;
-}
-
-app * theory_str::mk_unroll_bound_var() {
- return mk_int_var("unroll");
-}
-
-app * theory_str::mk_unroll_test_var() {
- app * v = mk_str_var("unrollTest"); // was uRt
- internal_unrollTest_vars.insert(v);
- track_variable_scope(v);
- return v;
-}
-
-app * theory_str::mk_str_var(std::string name) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- TRACE("str", tout << "creating string variable " << name << " at scope level " << sLevel << std::endl;);
-
- sort * string_sort = u.str.mk_string_sort();
- app * a = m.mk_fresh_const(name.c_str(), string_sort);
-
- TRACE("str", tout << "a->get_family_id() = " << a->get_family_id() << std::endl
- << "this->get_family_id() = " << this->get_family_id() << std::endl;);
-
- // I have a hunch that this may not get internalized for free...
- ctx.internalize(a, false);
- SASSERT(ctx.get_enode(a) != NULL);
- SASSERT(ctx.e_internalized(a));
- // this might help??
- mk_var(ctx.get_enode(a));
- m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
- TRACE("str", tout << "add " << mk_pp(a, m) << " to m_basicstr_axiom_todo" << std::endl;);
-
- m_trail.push_back(a);
- variable_set.insert(a);
- internal_variable_set.insert(a);
- track_variable_scope(a);
-
- return a;
-}
-
-app * theory_str::mk_regex_rep_var() {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- sort * string_sort = u.str.mk_string_sort();
- app * a = m.mk_fresh_const("regex", string_sort);
-
- ctx.internalize(a, false);
- SASSERT(ctx.get_enode(a) != NULL);
- SASSERT(ctx.e_internalized(a));
- mk_var(ctx.get_enode(a));
- m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
- TRACE("str", tout << "add " << mk_pp(a, m) << " to m_basicstr_axiom_todo" << std::endl;);
-
- m_trail.push_back(a);
- variable_set.insert(a);
- //internal_variable_set.insert(a);
- regex_variable_set.insert(a);
- track_variable_scope(a);
-
- return a;
-}
-
-void theory_str::add_nonempty_constraint(expr * s) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- expr_ref ax1(m.mk_not(ctx.mk_eq_atom(s, mk_string(""))), m);
- assert_axiom(ax1);
-
- {
- // build LHS
- expr_ref len_str(mk_strlen(s), m);
- SASSERT(len_str);
- // build RHS
- expr_ref zero(m_autil.mk_numeral(rational(0), true), m);
- SASSERT(zero);
- // build LHS > RHS and assert
- // we have to build !(LHS <= RHS) instead
- expr_ref lhs_gt_rhs(m.mk_not(m_autil.mk_le(len_str, zero)), m);
- SASSERT(lhs_gt_rhs);
- assert_axiom(lhs_gt_rhs);
- }
-}
-
-app * theory_str::mk_nonempty_str_var() {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- std::stringstream ss;
- ss << tmpStringVarCount;
- tmpStringVarCount++;
- std::string name = "$$_str" + ss.str();
-
- TRACE("str", tout << "creating nonempty string variable " << name << " at scope level " << sLevel << std::endl;);
-
- sort * string_sort = u.str.mk_string_sort();
- app * a = m.mk_fresh_const(name.c_str(), string_sort);
-
- ctx.internalize(a, false);
- SASSERT(ctx.get_enode(a) != NULL);
- // this might help??
- mk_var(ctx.get_enode(a));
-
- // assert a variation of the basic string axioms that ensures this string is nonempty
- {
- // build LHS
- expr_ref len_str(mk_strlen(a), m);
- SASSERT(len_str);
- // build RHS
- expr_ref zero(m_autil.mk_numeral(rational(0), true), m);
- SASSERT(zero);
- // build LHS > RHS and assert
- // we have to build !(LHS <= RHS) instead
- expr_ref lhs_gt_rhs(m.mk_not(m_autil.mk_le(len_str, zero)), m);
- SASSERT(lhs_gt_rhs);
- assert_axiom(lhs_gt_rhs);
- }
-
- // add 'a' to variable sets, so we can keep track of it
- m_trail.push_back(a);
- variable_set.insert(a);
- internal_variable_set.insert(a);
- track_variable_scope(a);
-
- return a;
-}
-
-app * theory_str::mk_unroll(expr * n, expr * bound) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- expr * args[2] = {n, bound};
- app * unrollFunc = get_manager().mk_app(get_id(), _OP_RE_UNROLL, 0, 0, 2, args);
- m_trail.push_back(unrollFunc);
-
- expr_ref_vector items(m);
- items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(bound, mk_int(0)), ctx.mk_eq_atom(unrollFunc, mk_string(""))));
- items.push_back(m_autil.mk_ge(bound, mk_int(0)));
- items.push_back(m_autil.mk_ge(mk_strlen(unrollFunc), mk_int(0)));
-
- expr_ref finalAxiom(mk_and(items), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
- return unrollFunc;
-}
-
-app * theory_str::mk_contains(expr * haystack, expr * needle) {
- app * contains = u.str.mk_contains(haystack, needle); // TODO double-check semantics/argument order
- m_trail.push_back(contains);
- // immediately force internalization so that axiom setup does not fail
- get_context().internalize(contains, false);
- set_up_axioms(contains);
- return contains;
-}
-
-app * theory_str::mk_indexof(expr * haystack, expr * needle) {
- // TODO check meaning of the third argument here
- app * indexof = u.str.mk_index(haystack, needle, mk_int(0));
- m_trail.push_back(indexof);
- // immediately force internalization so that axiom setup does not fail
- get_context().internalize(indexof, false);
- set_up_axioms(indexof);
- return indexof;
-}
-
-app * theory_str::mk_strlen(expr * e) {
- /*if (m_strutil.is_string(e)) {*/ if (false) {
- zstring strval;
- u.str.is_string(e, strval);
- unsigned int len = strval.length();
- return m_autil.mk_numeral(rational(len), true);
- } else {
- if (false) {
- // use cache
- app * lenTerm = NULL;
- if (!length_ast_map.find(e, lenTerm)) {
- lenTerm = u.str.mk_length(e);
- length_ast_map.insert(e, lenTerm);
- m_trail.push_back(lenTerm);
+ if (cut_var_map[destNode].empty() || cut_var_map[destNode].top()->level < slevel) {
+ T_cut * varInfo = alloc(T_cut);
+ varInfo->level = slevel;
+ cut_vars_map_copy(varInfo->vars, cut_var_map[destNode].top()->vars);
+ cut_vars_map_copy(varInfo->vars, cut_var_map[srcNode].top()->vars);
+ cut_var_map[destNode].push(varInfo);
+ TRACE("str", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
+ } else if (cut_var_map[destNode].top()->level == slevel) {
+ cut_vars_map_copy(cut_var_map[destNode].top()->vars, cut_var_map[srcNode].top()->vars);
+ TRACE("str", tout << "merge var info for destNode=" << mk_pp(destNode, get_manager()) << ", srcNode=" << mk_pp(srcNode, get_manager()) << " [" << slevel << "]" << std::endl;);
+ } else {
+ get_manager().raise_exception("illegal state in add_cut_info_merge(): inconsistent slevels");
}
- return lenTerm;
- } else {
- // always regen
- return u.str.mk_length(e);
}
}
-}
-/*
- * Returns the simplified concatenation of two expressions,
- * where either both expressions are constant strings
- * or one expression is the empty string.
- * If this precondition does not hold, the function returns NULL.
- * (note: this function was strTheory::Concat())
- */
-expr * theory_str::mk_concat_const_str(expr * n1, expr * n2) {
- bool n1HasEqcValue = false;
- bool n2HasEqcValue = false;
- expr * v1 = get_eqc_value(n1, n1HasEqcValue);
- expr * v2 = get_eqc_value(n2, n2HasEqcValue);
- if (n1HasEqcValue && n2HasEqcValue) {
- zstring n1_str;
- u.str.is_string(v1, n1_str);
- zstring n2_str;
- u.str.is_string(v2, n2_str);
- zstring result = n1_str + n2_str;
- return mk_string(result);
- } else if (n1HasEqcValue && !n2HasEqcValue) {
- zstring n1_str;
- u.str.is_string(v1, n1_str);
- if (n1_str.empty()) {
- return n2;
- }
- } else if (!n1HasEqcValue && n2HasEqcValue) {
- zstring n2_str;
- u.str.is_string(v2, n2_str);
- if (n2_str.empty()) {
- return n1;
+ void theory_str::check_and_init_cut_var(expr * node) {
+ if (cut_var_map.contains(node)) {
+ return;
+ } else if (!u.str.is_string(node)) {
+ add_cut_info_one_node(node, -1, node);
}
}
- return NULL;
-}
-expr * theory_str::mk_concat(expr * n1, expr * n2) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
- ENSURE(n1 != NULL);
- ENSURE(n2 != NULL);
- bool n1HasEqcValue = false;
- bool n2HasEqcValue = false;
- n1 = get_eqc_value(n1, n1HasEqcValue);
- n2 = get_eqc_value(n2, n2HasEqcValue);
- if (n1HasEqcValue && n2HasEqcValue) {
- return mk_concat_const_str(n1, n2);
- } else if (n1HasEqcValue && !n2HasEqcValue) {
- bool n2_isConcatFunc = u.str.is_concat(to_app(n2));
- zstring n1_str;
- u.str.is_string(n1, n1_str);
- if (n1_str.empty()) {
- return n2;
- }
- if (n2_isConcatFunc) {
- expr * n2_arg0 = to_app(n2)->get_arg(0);
- expr * n2_arg1 = to_app(n2)->get_arg(1);
- if (u.str.is_string(n2_arg0)) {
- n1 = mk_concat_const_str(n1, n2_arg0); // n1 will be a constant
- n2 = n2_arg1;
- }
- }
- } else if (!n1HasEqcValue && n2HasEqcValue) {
- zstring n2_str;
- u.str.is_string(n2, n2_str);
- if (n2_str.empty()) {
- return n1;
- }
-
- if (u.str.is_concat(to_app(n1))) {
- expr * n1_arg0 = to_app(n1)->get_arg(0);
- expr * n1_arg1 = to_app(n1)->get_arg(1);
- if (u.str.is_string(n1_arg1)) {
- n1 = n1_arg0;
- n2 = mk_concat_const_str(n1_arg1, n2); // n2 will be a constant
- }
- }
- } else {
- if (u.str.is_concat(to_app(n1)) && u.str.is_concat(to_app(n2))) {
- expr * n1_arg0 = to_app(n1)->get_arg(0);
- expr * n1_arg1 = to_app(n1)->get_arg(1);
- expr * n2_arg0 = to_app(n2)->get_arg(0);
- expr * n2_arg1 = to_app(n2)->get_arg(1);
- if (u.str.is_string(n1_arg1) && u.str.is_string(n2_arg0)) {
- expr * tmpN1 = n1_arg0;
- expr * tmpN2 = mk_concat_const_str(n1_arg1, n2_arg0);
- n1 = mk_concat(tmpN1, tmpN2);
- n2 = n2_arg1;
- }
- }
- }
-
- //------------------------------------------------------
- // * expr * ast1 = mk_2_arg_app(ctx, td->Concat, n1, n2);
- // * expr * ast2 = mk_2_arg_app(ctx, td->Concat, n1, n2);
- // Z3 treats (ast1) and (ast2) as two different nodes.
- //-------------------------------------------------------
-
- expr * concatAst = NULL;
-
- if (!concat_astNode_map.find(n1, n2, concatAst)) {
- concatAst = u.str.mk_concat(n1, n2);
- m_trail.push_back(concatAst);
- concat_astNode_map.insert(n1, n2, concatAst);
-
- expr_ref concat_length(mk_strlen(concatAst), m);
-
- ptr_vector<expr> childrenVector;
- get_nodes_in_concat(concatAst, childrenVector);
- expr_ref_vector items(m);
- for (unsigned int i = 0; i < childrenVector.size(); i++) {
- items.push_back(mk_strlen(childrenVector.get(i)));
- }
- expr_ref lenAssert(ctx.mk_eq_atom(concat_length, m_autil.mk_add(items.size(), items.c_ptr())), m);
- assert_axiom(lenAssert);
- }
- return concatAst;
-}
-
-bool theory_str::can_propagate() {
- return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty()
- || !m_concat_axiom_todo.empty() || !m_concat_eval_todo.empty()
- || !m_library_aware_axiom_todo.empty()
- || !m_delayed_axiom_setup_terms.empty();
- ;
-}
-
-void theory_str::propagate() {
- context & ctx = get_context();
- while (can_propagate()) {
- TRACE("str", tout << "propagating..." << std::endl;);
- for (unsigned i = 0; i < m_basicstr_axiom_todo.size(); ++i) {
- instantiate_basic_string_axioms(m_basicstr_axiom_todo[i]);
- }
- m_basicstr_axiom_todo.reset();
- TRACE("str", tout << "reset m_basicstr_axiom_todo" << std::endl;);
-
- for (unsigned i = 0; i < m_str_eq_todo.size(); ++i) {
- std::pair<enode*,enode*> pair = m_str_eq_todo[i];
- enode * lhs = pair.first;
- enode * rhs = pair.second;
- handle_equality(lhs->get_owner(), rhs->get_owner());
- }
- m_str_eq_todo.reset();
-
- for (unsigned i = 0; i < m_concat_axiom_todo.size(); ++i) {
- instantiate_concat_axiom(m_concat_axiom_todo[i]);
- }
- m_concat_axiom_todo.reset();
-
- for (unsigned i = 0; i < m_concat_eval_todo.size(); ++i) {
- try_eval_concat(m_concat_eval_todo[i]);
- }
- m_concat_eval_todo.reset();
-
- for (unsigned i = 0; i < m_library_aware_axiom_todo.size(); ++i) {
- enode * e = m_library_aware_axiom_todo[i];
- app * a = e->get_owner();
- if (u.str.is_stoi(a)) {
- instantiate_axiom_str_to_int(e);
- } else if (u.str.is_itos(a)) {
- instantiate_axiom_int_to_str(e);
- } else if (u.str.is_at(a)) {
- instantiate_axiom_CharAt(e);
- } else if (u.str.is_prefix(a)) {
- instantiate_axiom_prefixof(e);
- } else if (u.str.is_suffix(a)) {
- instantiate_axiom_suffixof(e);
- } else if (u.str.is_contains(a)) {
- instantiate_axiom_Contains(e);
- } else if (u.str.is_index(a)) {
- instantiate_axiom_Indexof(e);
- /* TODO NEXT: Indexof2/Lastindexof rewrite?
- } else if (is_Indexof2(e)) {
- instantiate_axiom_Indexof2(e);
- } else if (is_LastIndexof(e)) {
- instantiate_axiom_LastIndexof(e);
- */
- } else if (u.str.is_extract(a)) {
- // TODO check semantics of substr vs. extract
- instantiate_axiom_Substr(e);
- } else if (u.str.is_replace(a)) {
- instantiate_axiom_Replace(e);
- } else if (u.str.is_in_re(a)) {
- instantiate_axiom_RegexIn(e);
- } else {
- TRACE("str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_owner(), get_manager()) << std::endl;);
- NOT_IMPLEMENTED_YET();
- }
- }
- m_library_aware_axiom_todo.reset();
-
- for (unsigned i = 0; i < m_delayed_axiom_setup_terms.size(); ++i) {
- // I think this is okay
- ctx.internalize(m_delayed_axiom_setup_terms[i].get(), false);
- set_up_axioms(m_delayed_axiom_setup_terms[i].get());
- }
- m_delayed_axiom_setup_terms.reset();
- }
-}
-
-/*
- * Attempt to evaluate a concat over constant strings,
- * and if this is possible, assert equality between the
- * flattened string and the original term.
- */
-
-void theory_str::try_eval_concat(enode * cat) {
- app * a_cat = cat->get_owner();
- SASSERT(u.str.is_concat(a_cat));
-
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- TRACE("str", tout << "attempting to flatten " << mk_pp(a_cat, m) << std::endl;);
-
- std::stack<app*> worklist;
- zstring flattenedString("");
- bool constOK = true;
-
- {
- app * arg0 = to_app(a_cat->get_arg(0));
- app * arg1 = to_app(a_cat->get_arg(1));
-
- worklist.push(arg1);
- worklist.push(arg0);
+ literal theory_str::mk_literal(expr* _e) {
+ ast_manager & m = get_manager();
+ expr_ref e(_e, m);
+ context& ctx = get_context();
+ ensure_enode(e);
+ return ctx.get_literal(e);
}
- while (constOK && !worklist.empty()) {
- app * evalArg = worklist.top(); worklist.pop();
- zstring nextStr;
- if (u.str.is_string(evalArg, nextStr)) {
- flattenedString = flattenedString + nextStr;
- } else if (u.str.is_concat(evalArg)) {
- app * arg0 = to_app(evalArg->get_arg(0));
- app * arg1 = to_app(evalArg->get_arg(1));
+ app * theory_str::mk_int(int n) {
+ return m_autil.mk_numeral(rational(n), true);
+ }
- worklist.push(arg1);
- worklist.push(arg0);
- } else {
- TRACE("str", tout << "non-constant term in concat -- giving up." << std::endl;);
- constOK = false;
- break;
+ app * theory_str::mk_int(rational & q) {
+ return m_autil.mk_numeral(q, true);
+ }
+
+ expr * theory_str::mk_internal_lenTest_var(expr * node, int lTries) {
+ ast_manager & m = get_manager();
+
+ std::stringstream ss;
+ ss << "$$_len_" << mk_ismt2_pp(node, m) << "_" << lTries << "_" << tmpLenTestVarCount;
+ tmpLenTestVarCount += 1;
+ std::string name = ss.str();
+ app * var = mk_str_var(name);
+ internal_lenTest_vars.insert(var);
+ m_trail.push_back(var);
+ return var;
+ }
+
+ expr * theory_str::mk_internal_valTest_var(expr * node, int len, int vTries) {
+ ast_manager & m = get_manager();
+ std::stringstream ss;
+ ss << "$$_val_" << mk_ismt2_pp(node, m) << "_" << len << "_" << vTries << "_" << tmpValTestVarCount;
+ tmpValTestVarCount += 1;
+ std::string name = ss.str();
+ app * var = mk_str_var(name);
+ internal_valTest_vars.insert(var);
+ m_trail.push_back(var);
+ return var;
+ }
+
+ void theory_str::track_variable_scope(expr * var) {
+ if (internal_variable_scope_levels.find(sLevel) == internal_variable_scope_levels.end()) {
+ internal_variable_scope_levels[sLevel] = std::set<expr*>();
}
- }
- if (constOK) {
- TRACE("str", tout << "flattened to \"" << flattenedString.encode().c_str() << "\"" << std::endl;);
- expr_ref constStr(mk_string(flattenedString), m);
- expr_ref axiom(ctx.mk_eq_atom(a_cat, constStr), m);
- assert_axiom(axiom);
- }
-}
-
-/*
- * Instantiate an axiom of the following form:
- * Length(Concat(x, y)) = Length(x) + Length(y)
- */
-void theory_str::instantiate_concat_axiom(enode * cat) {
- app * a_cat = cat->get_owner();
- SASSERT(u.str.is_concat(a_cat));
-
- ast_manager & m = get_manager();
-
- TRACE("str", tout << "instantiating concat axiom for " << mk_ismt2_pp(a_cat, m) << std::endl;);
-
- // build LHS
- expr_ref len_xy(m);
- len_xy = mk_strlen(a_cat);
- SASSERT(len_xy);
-
- // build RHS: start by extracting x and y from Concat(x, y)
- unsigned nArgs = a_cat->get_num_args();
- SASSERT(nArgs == 2);
- app * a_x = to_app(a_cat->get_arg(0));
- app * a_y = to_app(a_cat->get_arg(1));
-
- expr_ref len_x(m);
- len_x = mk_strlen(a_x);
- SASSERT(len_x);
-
- expr_ref len_y(m);
- len_y = mk_strlen(a_y);
- SASSERT(len_y);
-
- // now build len_x + len_y
- expr_ref len_x_plus_len_y(m);
- len_x_plus_len_y = m_autil.mk_add(len_x, len_y);
- SASSERT(len_x_plus_len_y);
-
- // finally assert equality between the two subexpressions
- app * eq = m.mk_eq(len_xy, len_x_plus_len_y);
- SASSERT(eq);
- assert_axiom(eq);
-}
-
-/*
- * Add axioms that are true for any string variable:
- * 1. Length(x) >= 0
- * 2. Length(x) == 0 <=> x == ""
- * If the term is a string constant, we can assert something stronger:
- * Length(x) == strlen(x)
- */
-void theory_str::instantiate_basic_string_axioms(enode * str) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- TRACE("str", tout << "set up basic string axioms on " << mk_pp(str->get_owner(), m) << std::endl;);
-
- // TESTING: attempt to avoid a crash here when a variable goes out of scope
- if (str->get_iscope_lvl() > ctx.get_scope_level()) {
- TRACE("str", tout << "WARNING: skipping axiom setup on out-of-scope string term" << std::endl;);
- return;
+ internal_variable_scope_levels[sLevel].insert(var);
}
- // generate a stronger axiom for constant strings
- app * a_str = str->get_owner();
- if (u.str.is_string(a_str)) {
- expr_ref len_str(m);
- len_str = mk_strlen(a_str);
- SASSERT(len_str);
+ app * theory_str::mk_internal_xor_var() {
+ return mk_int_var("$$_xor");
+ }
- zstring strconst;
- u.str.is_string(str->get_owner(), strconst);
- TRACE("str", tout << "instantiating constant string axioms for \"" << strconst.encode().c_str() << "\"" << std::endl;);
- unsigned int l = strconst.length();
- expr_ref len(m_autil.mk_numeral(rational(l), true), m);
+ app * theory_str::mk_int_var(std::string name) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ TRACE("str", tout << "creating integer variable " << name << " at scope level " << sLevel << std::endl;);
+
+ sort * int_sort = m.mk_sort(m_autil.get_family_id(), INT_SORT);
+ app * a = m.mk_fresh_const(name.c_str(), int_sort);
+
+ ctx.internalize(a, false);
+ SASSERT(ctx.get_enode(a) != NULL);
+ SASSERT(ctx.e_internalized(a));
+ ctx.mark_as_relevant(a);
+ // I'm assuming that this combination will do the correct thing in the integer theory.
+
+ //mk_var(ctx.get_enode(a));
+ m_trail.push_back(a);
+ //variable_set.insert(a);
+ //internal_variable_set.insert(a);
+ //track_variable_scope(a);
+
+ return a;
+ }
+
+ app * theory_str::mk_unroll_bound_var() {
+ return mk_int_var("unroll");
+ }
+
+ app * theory_str::mk_unroll_test_var() {
+ app * v = mk_str_var("unrollTest"); // was uRt
+ internal_unrollTest_vars.insert(v);
+ track_variable_scope(v);
+ return v;
+ }
+
+ app * theory_str::mk_str_var(std::string name) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ TRACE("str", tout << "creating string variable " << name << " at scope level " << sLevel << std::endl;);
+
+ sort * string_sort = u.str.mk_string_sort();
+ app * a = m.mk_fresh_const(name.c_str(), string_sort);
+
+ TRACE("str", tout << "a->get_family_id() = " << a->get_family_id() << std::endl
+ << "this->get_family_id() = " << this->get_family_id() << std::endl;);
+
+ // I have a hunch that this may not get internalized for free...
+ ctx.internalize(a, false);
+ SASSERT(ctx.get_enode(a) != NULL);
+ SASSERT(ctx.e_internalized(a));
+ // this might help??
+ mk_var(ctx.get_enode(a));
+ m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
+ TRACE("str", tout << "add " << mk_pp(a, m) << " to m_basicstr_axiom_todo" << std::endl;);
+
+ m_trail.push_back(a);
+ variable_set.insert(a);
+ internal_variable_set.insert(a);
+ track_variable_scope(a);
+
+ return a;
+ }
+
+ app * theory_str::mk_regex_rep_var() {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ sort * string_sort = u.str.mk_string_sort();
+ app * a = m.mk_fresh_const("regex", string_sort);
+
+ ctx.internalize(a, false);
+ SASSERT(ctx.get_enode(a) != NULL);
+ SASSERT(ctx.e_internalized(a));
+ mk_var(ctx.get_enode(a));
+ m_basicstr_axiom_todo.push_back(ctx.get_enode(a));
+ TRACE("str", tout << "add " << mk_pp(a, m) << " to m_basicstr_axiom_todo" << std::endl;);
+
+ m_trail.push_back(a);
+ variable_set.insert(a);
+ //internal_variable_set.insert(a);
+ regex_variable_set.insert(a);
+ track_variable_scope(a);
+
+ return a;
+ }
+
+ void theory_str::add_nonempty_constraint(expr * s) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr_ref ax1(m.mk_not(ctx.mk_eq_atom(s, mk_string(""))), m);
+ assert_axiom(ax1);
- literal lit(mk_eq(len_str, len, false));
- ctx.mark_as_relevant(lit);
- ctx.mk_th_axiom(get_id(), 1, &lit);
- } else {
- // build axiom 1: Length(a_str) >= 0
{
// build LHS
- expr_ref len_str(m);
- len_str = mk_strlen(a_str);
+ expr_ref len_str(mk_strlen(s), m);
SASSERT(len_str);
// build RHS
- expr_ref zero(m);
- zero = m_autil.mk_numeral(rational(0), true);
+ expr_ref zero(m_autil.mk_numeral(rational(0), true), m);
SASSERT(zero);
- // build LHS >= RHS and assert
- app * lhs_ge_rhs = m_autil.mk_ge(len_str, zero);
- SASSERT(lhs_ge_rhs);
- TRACE("str", tout << "string axiom 1: " << mk_ismt2_pp(lhs_ge_rhs, m) << std::endl;);
- assert_axiom(lhs_ge_rhs);
+ // build LHS > RHS and assert
+ // we have to build !(LHS <= RHS) instead
+ expr_ref lhs_gt_rhs(m.mk_not(m_autil.mk_le(len_str, zero)), m);
+ SASSERT(lhs_gt_rhs);
+ assert_axiom(lhs_gt_rhs);
}
+ }
- // build axiom 2: Length(a_str) == 0 <=> a_str == ""
+ app * theory_str::mk_nonempty_str_var() {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ std::stringstream ss;
+ ss << tmpStringVarCount;
+ tmpStringVarCount++;
+ std::string name = "$$_str" + ss.str();
+
+ TRACE("str", tout << "creating nonempty string variable " << name << " at scope level " << sLevel << std::endl;);
+
+ sort * string_sort = u.str.mk_string_sort();
+ app * a = m.mk_fresh_const(name.c_str(), string_sort);
+
+ ctx.internalize(a, false);
+ SASSERT(ctx.get_enode(a) != NULL);
+ // this might help??
+ mk_var(ctx.get_enode(a));
+
+ // assert a variation of the basic string axioms that ensures this string is nonempty
{
- // build LHS of iff
- expr_ref len_str(m);
- len_str = mk_strlen(a_str);
+ // build LHS
+ expr_ref len_str(mk_strlen(a), m);
SASSERT(len_str);
- expr_ref zero(m);
- zero = m_autil.mk_numeral(rational(0), true);
+ // build RHS
+ expr_ref zero(m_autil.mk_numeral(rational(0), true), m);
SASSERT(zero);
- expr_ref lhs(m);
- lhs = ctx.mk_eq_atom(len_str, zero);
- SASSERT(lhs);
- // build RHS of iff
- expr_ref empty_str(m);
- empty_str = mk_string("");
- SASSERT(empty_str);
- expr_ref rhs(m);
- rhs = ctx.mk_eq_atom(a_str, empty_str);
- SASSERT(rhs);
- // build LHS <=> RHS and assert
- TRACE("str", tout << "string axiom 2: " << mk_ismt2_pp(lhs, m) << " <=> " << mk_ismt2_pp(rhs, m) << std::endl;);
- literal l(mk_eq(lhs, rhs, true));
- ctx.mark_as_relevant(l);
- ctx.mk_th_axiom(get_id(), 1, &l);
+ // build LHS > RHS and assert
+ // we have to build !(LHS <= RHS) instead
+ expr_ref lhs_gt_rhs(m.mk_not(m_autil.mk_le(len_str, zero)), m);
+ SASSERT(lhs_gt_rhs);
+ assert_axiom(lhs_gt_rhs);
}
- }
-}
+ // add 'a' to variable sets, so we can keep track of it
+ m_trail.push_back(a);
+ variable_set.insert(a);
+ internal_variable_set.insert(a);
+ track_variable_scope(a);
-/*
- * Add an axiom of the form:
- * (lhs == rhs) -> ( Length(lhs) == Length(rhs) )
- */
-void theory_str::instantiate_str_eq_length_axiom(enode * lhs, enode * rhs) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * a_lhs = lhs->get_owner();
- app * a_rhs = rhs->get_owner();
-
- // build premise: (lhs == rhs)
- expr_ref premise(ctx.mk_eq_atom(a_lhs, a_rhs), m);
-
- // build conclusion: ( Length(lhs) == Length(rhs) )
- expr_ref len_lhs(mk_strlen(a_lhs), m);
- SASSERT(len_lhs);
- expr_ref len_rhs(mk_strlen(a_rhs), m);
- SASSERT(len_rhs);
- expr_ref conclusion(ctx.mk_eq_atom(len_lhs, len_rhs), m);
-
- TRACE("str", tout << "string-eq length-eq axiom: "
- << mk_ismt2_pp(premise, m) << " -> " << mk_ismt2_pp(conclusion, m) << std::endl;);
- assert_implication(premise, conclusion);
-}
-
-void theory_str::instantiate_axiom_CharAt(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * expr = e->get_owner();
- if (axiomatized_terms.contains(expr)) {
- TRACE("str", tout << "already set up CharAt axiom for " << mk_pp(expr, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(expr);
-
- TRACE("str", tout << "instantiate CharAt axiom for " << mk_pp(expr, m) << std::endl;);
-
- expr_ref ts0(mk_str_var("ts0"), m);
- expr_ref ts1(mk_str_var("ts1"), m);
- expr_ref ts2(mk_str_var("ts2"), m);
-
- expr_ref cond(m.mk_and(
- m_autil.mk_ge(expr->get_arg(1), mk_int(0)),
- // REWRITE for arithmetic theory:
- // m_autil.mk_lt(expr->get_arg(1), mk_strlen(expr->get_arg(0)))
- m.mk_not(m_autil.mk_ge(m_autil.mk_add(expr->get_arg(1), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))), mk_int(0)))
- ), m);
-
- expr_ref_vector and_item(m);
- and_item.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, mk_concat(ts1, ts2))));
- and_item.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_strlen(ts0)));
- and_item.push_back(ctx.mk_eq_atom(mk_strlen(ts1), mk_int(1)));
-
- expr_ref thenBranch(m.mk_and(and_item.size(), and_item.c_ptr()), m);
- expr_ref elseBranch(ctx.mk_eq_atom(ts1, mk_string("")), m);
-
- expr_ref axiom(m.mk_ite(cond, thenBranch, elseBranch), m);
- expr_ref reductionVar(ctx.mk_eq_atom(expr, ts1), m);
-
- SASSERT(axiom);
- SASSERT(reductionVar);
-
- expr_ref finalAxiom(m.mk_and(axiom, reductionVar), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
-}
-
-void theory_str::instantiate_axiom_prefixof(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * expr = e->get_owner();
- if (axiomatized_terms.contains(expr)) {
- TRACE("str", tout << "already set up prefixof axiom for " << mk_pp(expr, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(expr);
-
- TRACE("str", tout << "instantiate prefixof axiom for " << mk_pp(expr, m) << std::endl;);
-
- expr_ref ts0(mk_str_var("ts0"), m);
- expr_ref ts1(mk_str_var("ts1"), m);
-
- expr_ref_vector innerItems(m);
- innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_concat(ts0, ts1)));
- innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts0), mk_strlen(expr->get_arg(0))));
- innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts0, expr->get_arg(0)), expr, m.mk_not(expr)));
- expr_ref then1(m.mk_and(innerItems.size(), innerItems.c_ptr()), m);
- SASSERT(then1);
-
- // the top-level condition is Length(arg0) >= Length(arg1)
- expr_ref topLevelCond(
- m_autil.mk_ge(
- m_autil.mk_add(
- mk_strlen(expr->get_arg(1)), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))),
- mk_int(0))
- , m);
- SASSERT(topLevelCond);
-
- expr_ref finalAxiom(m.mk_ite(topLevelCond, then1, m.mk_not(expr)), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
-}
-
-void theory_str::instantiate_axiom_suffixof(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * expr = e->get_owner();
- if (axiomatized_terms.contains(expr)) {
- TRACE("str", tout << "already set up suffixof axiom for " << mk_pp(expr, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(expr);
-
- TRACE("str", tout << "instantiate suffixof axiom for " << mk_pp(expr, m) << std::endl;);
-
- expr_ref ts0(mk_str_var("ts0"), m);
- expr_ref ts1(mk_str_var("ts1"), m);
-
- expr_ref_vector innerItems(m);
- innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_concat(ts0, ts1)));
- innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts1), mk_strlen(expr->get_arg(0))));
- innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts1, expr->get_arg(0)), expr, m.mk_not(expr)));
- expr_ref then1(m.mk_and(innerItems.size(), innerItems.c_ptr()), m);
- SASSERT(then1);
-
- // the top-level condition is Length(arg0) >= Length(arg1)
- expr_ref topLevelCond(
- m_autil.mk_ge(
- m_autil.mk_add(
- mk_strlen(expr->get_arg(1)), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))),
- mk_int(0))
- , m);
- SASSERT(topLevelCond);
-
- expr_ref finalAxiom(m.mk_ite(topLevelCond, then1, m.mk_not(expr)), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
-}
-
-void theory_str::instantiate_axiom_Contains(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * ex = e->get_owner();
- if (axiomatized_terms.contains(ex)) {
- TRACE("str", tout << "already set up Contains axiom for " << mk_pp(ex, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(ex);
-
- // quick path, because this is necessary due to rewriter behaviour
- // at minimum it should fix z3str/concat-006.smt2
- zstring haystackStr, needleStr;
- if (u.str.is_string(ex->get_arg(0), haystackStr) && u.str.is_string(ex->get_arg(1), needleStr)) {
- TRACE("str", tout << "eval constant Contains term " << mk_pp(ex, m) << std::endl;);
- if (haystackStr.contains(needleStr)) {
- assert_axiom(ex);
- } else {
- assert_axiom(m.mk_not(ex));
- }
- return;
+ return a;
}
- { // register Contains()
- expr * str = ex->get_arg(0);
- expr * substr = ex->get_arg(1);
- contains_map.push_back(ex);
- std::pair<expr*, expr*> key = std::pair<expr*, expr*>(str, substr);
- contain_pair_bool_map.insert(str, substr, ex);
- contain_pair_idx_map[str].insert(key);
- contain_pair_idx_map[substr].insert(key);
- }
+ app * theory_str::mk_unroll(expr * n, expr * bound) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
- TRACE("str", tout << "instantiate Contains axiom for " << mk_pp(ex, m) << std::endl;);
+ expr * args[2] = {n, bound};
+ app * unrollFunc = get_manager().mk_app(get_id(), _OP_RE_UNROLL, 0, 0, 2, args);
+ m_trail.push_back(unrollFunc);
- expr_ref ts0(mk_str_var("ts0"), m);
- expr_ref ts1(mk_str_var("ts1"), m);
+ expr_ref_vector items(m);
+ items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(bound, mk_int(0)), ctx.mk_eq_atom(unrollFunc, mk_string(""))));
+ items.push_back(m_autil.mk_ge(bound, mk_int(0)));
+ items.push_back(m_autil.mk_ge(mk_strlen(unrollFunc), mk_int(0)));
- expr_ref breakdownAssert(ctx.mk_eq_atom(ex, ctx.mk_eq_atom(ex->get_arg(0), mk_concat(ts0, mk_concat(ex->get_arg(1), ts1)))), m);
- SASSERT(breakdownAssert);
- assert_axiom(breakdownAssert);
-}
-
-void theory_str::instantiate_axiom_Indexof(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * expr = e->get_owner();
- if (axiomatized_terms.contains(expr)) {
- TRACE("str", tout << "already set up Indexof axiom for " << mk_pp(expr, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(expr);
-
- TRACE("str", tout << "instantiate Indexof axiom for " << mk_pp(expr, m) << std::endl;);
-
- expr_ref x1(mk_str_var("x1"), m);
- expr_ref x2(mk_str_var("x2"), m);
- expr_ref indexAst(mk_int_var("index"), m);
-
- expr_ref condAst(mk_contains(expr->get_arg(0), expr->get_arg(1)), m);
- SASSERT(condAst);
-
- // -----------------------
- // true branch
- expr_ref_vector thenItems(m);
- // args[0] = x1 . args[1] . x2
- thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x1, mk_concat(expr->get_arg(1), x2))));
- // indexAst = |x1|
- thenItems.push_back(ctx.mk_eq_atom(indexAst, mk_strlen(x1)));
- // args[0] = x3 . x4
- // /\ |x3| = |x1| + |args[1]| - 1
- // /\ ! contains(x3, args[1])
- expr_ref x3(mk_str_var("x3"), m);
- expr_ref x4(mk_str_var("x4"), m);
- expr_ref tmpLen(m_autil.mk_add(indexAst, mk_strlen(expr->get_arg(1)), mk_int(-1)), m);
- SASSERT(tmpLen);
- thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x3, x4)));
- thenItems.push_back(ctx.mk_eq_atom(mk_strlen(x3), tmpLen));
- thenItems.push_back(m.mk_not(mk_contains(x3, expr->get_arg(1))));
- expr_ref thenBranch(m.mk_and(thenItems.size(), thenItems.c_ptr()), m);
- SASSERT(thenBranch);
-
- // -----------------------
- // false branch
- expr_ref elseBranch(ctx.mk_eq_atom(indexAst, mk_int(-1)), m);
- SASSERT(elseBranch);
-
- expr_ref breakdownAssert(m.mk_ite(condAst, thenBranch, elseBranch), m);
- SASSERT(breakdownAssert);
-
- expr_ref reduceToIndex(ctx.mk_eq_atom(expr, indexAst), m);
- SASSERT(reduceToIndex);
-
- expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToIndex), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
-}
-
-void theory_str::instantiate_axiom_Indexof2(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * expr = e->get_owner();
- if (axiomatized_terms.contains(expr)) {
- TRACE("str", tout << "already set up Indexof2 axiom for " << mk_pp(expr, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(expr);
-
- TRACE("str", tout << "instantiate Indexof2 axiom for " << mk_pp(expr, m) << std::endl;);
-
- // -------------------------------------------------------------------------------
- // if (arg[2] >= length(arg[0])) // ite2
- // resAst = -1
- // else
- // args[0] = prefix . suffix
- // /\ indexAst = indexof(suffix, arg[1])
- // /\ args[2] = len(prefix)
- // /\ if (indexAst == -1) resAst = indexAst // ite3
- // else resAst = args[2] + indexAst
- // -------------------------------------------------------------------------------
-
- expr_ref resAst(mk_int_var("res"), m);
- expr_ref indexAst(mk_int_var("index"), m);
- expr_ref prefix(mk_str_var("prefix"), m);
- expr_ref suffix(mk_str_var("suffix"), m);
- expr_ref prefixLen(mk_strlen(prefix), m);
- expr_ref zeroAst(mk_int(0), m);
- expr_ref negOneAst(mk_int(-1), m);
-
- expr_ref ite3(m.mk_ite(
- ctx.mk_eq_atom(indexAst, negOneAst),
- ctx.mk_eq_atom(resAst, negOneAst),
- ctx.mk_eq_atom(resAst, m_autil.mk_add(expr->get_arg(2), indexAst))
- ),m);
-
- expr_ref_vector ite2ElseItems(m);
- ite2ElseItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(prefix, suffix)));
- ite2ElseItems.push_back(ctx.mk_eq_atom(indexAst, mk_indexof(suffix, expr->get_arg(1))));
- ite2ElseItems.push_back(ctx.mk_eq_atom(expr->get_arg(2), prefixLen));
- ite2ElseItems.push_back(ite3);
- expr_ref ite2Else(m.mk_and(ite2ElseItems.size(), ite2ElseItems.c_ptr()), m);
- SASSERT(ite2Else);
-
- expr_ref ite2(m.mk_ite(
- //m_autil.mk_ge(expr->get_arg(2), mk_strlen(expr->get_arg(0))),
- m_autil.mk_ge(m_autil.mk_add(expr->get_arg(2), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))), zeroAst),
- ctx.mk_eq_atom(resAst, negOneAst),
- ite2Else
- ), m);
- SASSERT(ite2);
-
- expr_ref ite1(m.mk_ite(
- //m_autil.mk_lt(expr->get_arg(2), zeroAst),
- m.mk_not(m_autil.mk_ge(expr->get_arg(2), zeroAst)),
- ctx.mk_eq_atom(resAst, mk_indexof(expr->get_arg(0), expr->get_arg(1))),
- ite2
- ), m);
- SASSERT(ite1);
- assert_axiom(ite1);
-
- expr_ref reduceTerm(ctx.mk_eq_atom(expr, resAst), m);
- SASSERT(reduceTerm);
- assert_axiom(reduceTerm);
-}
-
-void theory_str::instantiate_axiom_LastIndexof(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * expr = e->get_owner();
- if (axiomatized_terms.contains(expr)) {
- TRACE("str", tout << "already set up LastIndexof axiom for " << mk_pp(expr, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(expr);
-
- TRACE("str", tout << "instantiate LastIndexof axiom for " << mk_pp(expr, m) << std::endl;);
-
- expr_ref x1(mk_str_var("x1"), m);
- expr_ref x2(mk_str_var("x2"), m);
- expr_ref indexAst(mk_int_var("index"), m);
- expr_ref_vector items(m);
-
- // args[0] = x1 . args[1] . x2
- expr_ref eq1(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x1, mk_concat(expr->get_arg(1), x2))), m);
- expr_ref arg0HasArg1(mk_contains(expr->get_arg(0), expr->get_arg(1)), m); // arg0HasArg1 = Contains(args[0], args[1])
- items.push_back(ctx.mk_eq_atom(arg0HasArg1, eq1));
-
-
- expr_ref condAst(arg0HasArg1, m);
- //----------------------------
- // true branch
- expr_ref_vector thenItems(m);
- thenItems.push_back(m_autil.mk_ge(indexAst, mk_int(0)));
- // args[0] = x1 . args[1] . x2
- // x1 doesn't contain args[1]
- thenItems.push_back(m.mk_not(mk_contains(x2, expr->get_arg(1))));
- thenItems.push_back(ctx.mk_eq_atom(indexAst, mk_strlen(x1)));
-
- bool canSkip = false;
- zstring arg1Str;
- if (u.str.is_string(expr->get_arg(1), arg1Str)) {
- if (arg1Str.length() == 1) {
- canSkip = true;
- }
- }
-
- if (!canSkip) {
- // args[0] = x3 . x4 /\ |x3| = |x1| + 1 /\ ! contains(x4, args[1])
- expr_ref x3(mk_str_var("x3"), m);
- expr_ref x4(mk_str_var("x4"), m);
- expr_ref tmpLen(m_autil.mk_add(indexAst, mk_int(1)), m);
- thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x3, x4)));
- thenItems.push_back(ctx.mk_eq_atom(mk_strlen(x3), tmpLen));
- thenItems.push_back(m.mk_not(mk_contains(x4, expr->get_arg(1))));
- }
- //----------------------------
- // else branch
- expr_ref_vector elseItems(m);
- elseItems.push_back(ctx.mk_eq_atom(indexAst, mk_int(-1)));
-
- items.push_back(m.mk_ite(condAst, m.mk_and(thenItems.size(), thenItems.c_ptr()), m.mk_and(elseItems.size(), elseItems.c_ptr())));
-
- expr_ref breakdownAssert(m.mk_and(items.size(), items.c_ptr()), m);
- SASSERT(breakdownAssert);
-
- expr_ref reduceToIndex(ctx.mk_eq_atom(expr, indexAst), m);
- SASSERT(reduceToIndex);
-
- expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToIndex), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
-}
-
-void theory_str::instantiate_axiom_Substr(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * expr = e->get_owner();
- if (axiomatized_terms.contains(expr)) {
- TRACE("str", tout << "already set up Substr axiom for " << mk_pp(expr, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(expr);
-
- TRACE("str", tout << "instantiate Substr axiom for " << mk_pp(expr, m) << std::endl;);
-
- expr_ref substrBase(expr->get_arg(0), m);
- expr_ref substrPos(expr->get_arg(1), m);
- expr_ref substrLen(expr->get_arg(2), m);
- SASSERT(substrBase);
- SASSERT(substrPos);
- SASSERT(substrLen);
-
- expr_ref zero(m_autil.mk_numeral(rational::zero(), true), m);
- expr_ref minusOne(m_autil.mk_numeral(rational::minus_one(), true), m);
- SASSERT(zero);
- SASSERT(minusOne);
-
- expr_ref_vector argumentsValid_terms(m);
- // pos >= 0
- argumentsValid_terms.push_back(m_autil.mk_ge(substrPos, zero));
- // pos < strlen(base)
- // --> pos + -1*strlen(base) < 0
- argumentsValid_terms.push_back(m.mk_not(m_autil.mk_ge(
- m_autil.mk_add(substrPos, m_autil.mk_mul(minusOne, substrLen)),
- zero)));
- // len >= 0
- argumentsValid_terms.push_back(m_autil.mk_ge(substrLen, zero));
-
- expr_ref argumentsValid(mk_and(argumentsValid_terms), m);
- SASSERT(argumentsValid);
- ctx.internalize(argumentsValid, false);
-
- // (pos+len) >= strlen(base)
- // --> pos + len + -1*strlen(base) >= 0
- expr_ref lenOutOfBounds(m_autil.mk_ge(
- m_autil.mk_add(substrPos, substrLen, m_autil.mk_mul(minusOne, mk_strlen(substrBase))),
- zero), m);
- SASSERT(lenOutOfBounds);
- ctx.internalize(argumentsValid, false);
-
- // Case 1: pos < 0 or pos >= strlen(base) or len < 0
- // ==> (Substr ...) = ""
- expr_ref case1_premise(m.mk_not(argumentsValid), m);
- SASSERT(case1_premise);
- ctx.internalize(case1_premise, false);
- expr_ref case1_conclusion(ctx.mk_eq_atom(expr, mk_string("")), m);
- SASSERT(case1_conclusion);
- ctx.internalize(case1_conclusion, false);
- expr_ref case1(rewrite_implication(case1_premise, case1_conclusion), m);
- SASSERT(case1);
-
- // Case 2: (pos >= 0 and pos < strlen(base) and len >= 0) and (pos+len) >= strlen(base)
- // ==> base = t0.t1 AND len(t0) = pos AND (Substr ...) = t1
- expr_ref t0(mk_str_var("t0"), m);
- expr_ref t1(mk_str_var("t1"), m);
- expr_ref case2_conclusion(m.mk_and(
- ctx.mk_eq_atom(substrBase, mk_concat(t0,t1)),
- ctx.mk_eq_atom(mk_strlen(t0), substrPos),
- ctx.mk_eq_atom(expr, t1)), m);
- expr_ref case2(rewrite_implication(m.mk_and(argumentsValid, lenOutOfBounds), case2_conclusion), m);
- SASSERT(case2);
-
- // Case 3: (pos >= 0 and pos < strlen(base) and len >= 0) and (pos+len) < strlen(base)
- // ==> base = t2.t3.t4 AND len(t2) = pos AND len(t3) = len AND (Substr ...) = t3
- expr_ref t2(mk_str_var("t2"), m);
- expr_ref t3(mk_str_var("t3"), m);
- expr_ref t4(mk_str_var("t4"), m);
- expr_ref_vector case3_conclusion_terms(m);
- case3_conclusion_terms.push_back(ctx.mk_eq_atom(substrBase, mk_concat(t2, mk_concat(t3, t4))));
- case3_conclusion_terms.push_back(ctx.mk_eq_atom(mk_strlen(t2), substrPos));
- case3_conclusion_terms.push_back(ctx.mk_eq_atom(mk_strlen(t3), substrLen));
- case3_conclusion_terms.push_back(ctx.mk_eq_atom(expr, t3));
- expr_ref case3_conclusion(mk_and(case3_conclusion_terms), m);
- expr_ref case3(rewrite_implication(m.mk_and(argumentsValid, m.mk_not(lenOutOfBounds)), case3_conclusion), m);
- SASSERT(case3);
-
- ctx.internalize(case1, false);
- ctx.internalize(case2, false);
- ctx.internalize(case3, false);
-
- expr_ref finalAxiom(m.mk_and(case1, case2, case3), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
-}
-
-void theory_str::instantiate_axiom_Replace(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * expr = e->get_owner();
- if (axiomatized_terms.contains(expr)) {
- TRACE("str", tout << "already set up Replace axiom for " << mk_pp(expr, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(expr);
-
- TRACE("str", tout << "instantiate Replace axiom for " << mk_pp(expr, m) << std::endl;);
-
- expr_ref x1(mk_str_var("x1"), m);
- expr_ref x2(mk_str_var("x2"), m);
- expr_ref i1(mk_int_var("i1"), m);
- expr_ref result(mk_str_var("result"), m);
-
- // condAst = Contains(args[0], args[1])
- expr_ref condAst(mk_contains(expr->get_arg(0), expr->get_arg(1)), m);
- // -----------------------
- // true branch
- expr_ref_vector thenItems(m);
- // args[0] = x1 . args[1] . x2
- thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x1, mk_concat(expr->get_arg(1), x2))));
- // i1 = |x1|
- thenItems.push_back(ctx.mk_eq_atom(i1, mk_strlen(x1)));
- // args[0] = x3 . x4 /\ |x3| = |x1| + |args[1]| - 1 /\ ! contains(x3, args[1])
- expr_ref x3(mk_str_var("x3"), m);
- expr_ref x4(mk_str_var("x4"), m);
- expr_ref tmpLen(m_autil.mk_add(i1, mk_strlen(expr->get_arg(1)), mk_int(-1)), m);
- thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x3, x4)));
- thenItems.push_back(ctx.mk_eq_atom(mk_strlen(x3), tmpLen));
- thenItems.push_back(m.mk_not(mk_contains(x3, expr->get_arg(1))));
- thenItems.push_back(ctx.mk_eq_atom(result, mk_concat(x1, mk_concat(expr->get_arg(2), x2))));
- // -----------------------
- // false branch
- expr_ref elseBranch(ctx.mk_eq_atom(result, expr->get_arg(0)), m);
-
- expr_ref breakdownAssert(m.mk_ite(condAst, m.mk_and(thenItems.size(), thenItems.c_ptr()), elseBranch), m);
- SASSERT(breakdownAssert);
-
- expr_ref reduceToResult(ctx.mk_eq_atom(expr, result), m);
- SASSERT(reduceToResult);
-
- expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToResult), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
-}
-
-void theory_str::instantiate_axiom_str_to_int(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * ex = e->get_owner();
- if (axiomatized_terms.contains(ex)) {
- TRACE("str", tout << "already set up str.to-int axiom for " << mk_pp(ex, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(ex);
-
- TRACE("str", tout << "instantiate str.to-int axiom for " << mk_pp(ex, m) << std::endl;);
-
- // let expr = (str.to-int S)
- // axiom 1: expr >= -1
- // axiom 2: expr = 0 <==> S = "0"
- // axiom 3: expr >= 1 ==> len(S) > 0 AND S[0] != "0"
-
- expr * S = ex->get_arg(0);
- {
- expr_ref axiom1(m_autil.mk_ge(ex, m_autil.mk_numeral(rational::minus_one(), true)), m);
- SASSERT(axiom1);
- assert_axiom(axiom1);
- }
-
- {
- expr_ref lhs(ctx.mk_eq_atom(ex, m_autil.mk_numeral(rational::zero(), true)), m);
- expr_ref rhs(ctx.mk_eq_atom(S, mk_string("0")), m);
- expr_ref axiom2(ctx.mk_eq_atom(lhs, rhs), m);
- SASSERT(axiom2);
- assert_axiom(axiom2);
- }
-
- {
- expr_ref premise(m_autil.mk_ge(ex, m_autil.mk_numeral(rational::one(), true)), m);
- expr_ref hd(mk_str_var("hd"), m);
- expr_ref tl(mk_str_var("tl"), m);
- expr_ref conclusion1(ctx.mk_eq_atom(S, mk_concat(hd, tl)), m);
- expr_ref conclusion2(ctx.mk_eq_atom(mk_strlen(hd), m_autil.mk_numeral(rational::one(), true)), m);
- expr_ref conclusion3(m.mk_not(ctx.mk_eq_atom(hd, mk_string("0"))), m);
- expr_ref conclusion(m.mk_and(conclusion1, conclusion2, conclusion3), m);
- SASSERT(premise);
- SASSERT(conclusion);
- assert_implication(premise, conclusion);
- }
-}
-
-void theory_str::instantiate_axiom_int_to_str(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * ex = e->get_owner();
- if (axiomatized_terms.contains(ex)) {
- TRACE("str", tout << "already set up str.from-int axiom for " << mk_pp(ex, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(ex);
-
- TRACE("str", tout << "instantiate str.from-int axiom for " << mk_pp(ex, m) << std::endl;);
-
- // axiom 1: N < 0 <==> (str.from-int N) = ""
- expr * N = ex->get_arg(0);
- {
- expr_ref axiom1_lhs(m.mk_not(m_autil.mk_ge(N, m_autil.mk_numeral(rational::zero(), true))), m);
- expr_ref axiom1_rhs(ctx.mk_eq_atom(ex, mk_string("")), m);
- expr_ref axiom1(ctx.mk_eq_atom(axiom1_lhs, axiom1_rhs), m);
- SASSERT(axiom1);
- assert_axiom(axiom1);
- }
-}
-
-expr * theory_str::mk_RegexIn(expr * str, expr * regexp) {
- app * regexIn = u.re.mk_in_re(str, regexp);
- // immediately force internalization so that axiom setup does not fail
- get_context().internalize(regexIn, false);
- set_up_axioms(regexIn);
- return regexIn;
-}
-
-static zstring str2RegexStr(zstring str) {
- zstring res("");
- int len = str.length();
- for (int i = 0; i < len; i++) {
- char nc = str[i];
- // 12 special chars
- if (nc == '\\' || nc == '^' || nc == '$' || nc == '.' || nc == '|' || nc == '?'
- || nc == '*' || nc == '+' || nc == '(' || nc == ')' || nc == '[' || nc == '{') {
- res = res + zstring("\\");
- }
- char tmp[2] = {(char)str[i], '\0'};
- res = res + zstring(tmp);
- }
- return res;
-}
-
-zstring theory_str::get_std_regex_str(expr * regex) {
- app * a_regex = to_app(regex);
- if (u.re.is_to_re(a_regex)) {
- expr * regAst = a_regex->get_arg(0);
- zstring regAstVal;
- u.str.is_string(regAst, regAstVal);
- zstring regStr = str2RegexStr(regAstVal);
- return regStr;
- } else if (u.re.is_concat(a_regex)) {
- expr * reg1Ast = a_regex->get_arg(0);
- expr * reg2Ast = a_regex->get_arg(1);
- zstring reg1Str = get_std_regex_str(reg1Ast);
- zstring reg2Str = get_std_regex_str(reg2Ast);
- return zstring("(") + reg1Str + zstring(")(") + reg2Str + zstring(")");
- } else if (u.re.is_union(a_regex)) {
- expr * reg1Ast = a_regex->get_arg(0);
- expr * reg2Ast = a_regex->get_arg(1);
- zstring reg1Str = get_std_regex_str(reg1Ast);
- zstring reg2Str = get_std_regex_str(reg2Ast);
- return zstring("(") + reg1Str + zstring(")|(") + reg2Str + zstring(")");
- } else if (u.re.is_star(a_regex)) {
- expr * reg1Ast = a_regex->get_arg(0);
- zstring reg1Str = get_std_regex_str(reg1Ast);
- return zstring("(") + reg1Str + zstring(")*");
- } else if (u.re.is_range(a_regex)) {
- expr * range1 = a_regex->get_arg(0);
- expr * range2 = a_regex->get_arg(1);
- zstring range1val, range2val;
- u.str.is_string(range1, range1val);
- u.str.is_string(range2, range2val);
- return zstring("[") + range1val + zstring("-") + range2val + zstring("]");
- } else {
- TRACE("str", tout << "BUG: unrecognized regex term " << mk_pp(regex, get_manager()) << std::endl;);
- UNREACHABLE(); return zstring("");
- }
-}
-
-void theory_str::instantiate_axiom_RegexIn(enode * e) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- app * ex = e->get_owner();
- if (axiomatized_terms.contains(ex)) {
- TRACE("str", tout << "already set up RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
- return;
- }
- axiomatized_terms.insert(ex);
-
- TRACE("str", tout << "instantiate RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
-
- {
- zstring regexStr = get_std_regex_str(ex->get_arg(1));
- std::pair<expr*, zstring> key1(ex->get_arg(0), regexStr);
- // skip Z3str's map check, because we already check if we set up axioms on this term
- regex_in_bool_map[key1] = ex;
- regex_in_var_reg_str_map[ex->get_arg(0)].insert(regexStr);
- }
-
- expr_ref str(ex->get_arg(0), m);
- app * regex = to_app(ex->get_arg(1));
-
- if (u.re.is_to_re(regex)) {
- expr_ref rxStr(regex->get_arg(0), m);
- // want to assert 'expr IFF (str == rxStr)'
- expr_ref rhs(ctx.mk_eq_atom(str, rxStr), m);
- expr_ref finalAxiom(m.mk_iff(ex, rhs), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
- TRACE("str", tout << "set up Str2Reg: (RegexIn " << mk_pp(str, m) << " " << mk_pp(regex, m) << ")" << std::endl;);
- } else if (u.re.is_concat(regex)) {
- expr_ref var1(mk_regex_rep_var(), m);
- expr_ref var2(mk_regex_rep_var(), m);
- expr_ref rhs(mk_concat(var1, var2), m);
- expr_ref rx1(regex->get_arg(0), m);
- expr_ref rx2(regex->get_arg(1), m);
- expr_ref var1InRegex1(mk_RegexIn(var1, rx1), m);
- expr_ref var2InRegex2(mk_RegexIn(var2, rx2), m);
-
- expr_ref_vector items(m);
- items.push_back(var1InRegex1);
- items.push_back(var2InRegex2);
- items.push_back(ctx.mk_eq_atom(ex, ctx.mk_eq_atom(str, rhs)));
-
- expr_ref finalAxiom(mk_and(items), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
- } else if (u.re.is_union(regex)) {
- expr_ref var1(mk_regex_rep_var(), m);
- expr_ref var2(mk_regex_rep_var(), m);
- expr_ref orVar(m.mk_or(ctx.mk_eq_atom(str, var1), ctx.mk_eq_atom(str, var2)), m);
- expr_ref regex1(regex->get_arg(0), m);
- expr_ref regex2(regex->get_arg(1), m);
- expr_ref var1InRegex1(mk_RegexIn(var1, regex1), m);
- expr_ref var2InRegex2(mk_RegexIn(var2, regex2), m);
- expr_ref_vector items(m);
- items.push_back(var1InRegex1);
- items.push_back(var2InRegex2);
- items.push_back(ctx.mk_eq_atom(ex, orVar));
- assert_axiom(mk_and(items));
- } else if (u.re.is_star(regex)) {
- // slightly more complex due to the unrolling step.
- expr_ref regex1(regex->get_arg(0), m);
- expr_ref unrollCount(mk_unroll_bound_var(), m);
- expr_ref unrollFunc(mk_unroll(regex1, unrollCount), m);
- expr_ref_vector items(m);
- items.push_back(ctx.mk_eq_atom(ex, ctx.mk_eq_atom(str, unrollFunc)));
- items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(unrollCount, mk_int(0)), ctx.mk_eq_atom(unrollFunc, mk_string(""))));
- expr_ref finalAxiom(mk_and(items), m);
- SASSERT(finalAxiom);
- assert_axiom(finalAxiom);
- } else if (u.re.is_range(regex)) {
- // (re.range "A" "Z") unfolds to (re.union "A" "B" ... "Z");
- // we rewrite to expr IFF (str = "A" or str = "B" or ... or str = "Z")
- expr_ref lo(regex->get_arg(0), m);
- expr_ref hi(regex->get_arg(1), m);
- zstring str_lo, str_hi;
- SASSERT(u.str.is_string(lo));
- SASSERT(u.str.is_string(hi));
- u.str.is_string(lo, str_lo);
- u.str.is_string(hi, str_hi);
- SASSERT(str_lo.length() == 1);
- SASSERT(str_hi.length() == 1);
- unsigned int c1 = str_lo[0];
- unsigned int c2 = str_hi[0];
- if (c1 > c2) {
- // exchange
- unsigned int tmp = c1;
- c1 = c2;
- c2 = tmp;
- }
- expr_ref_vector range_cases(m);
- for (unsigned int ch = c1; ch <= c2; ++ch) {
- zstring s_ch(ch);
- expr_ref rhs(ctx.mk_eq_atom(str, u.str.mk_string(s_ch)), m);
- range_cases.push_back(rhs);
- }
- expr_ref rhs(mk_or(range_cases), m);
- expr_ref finalAxiom(m.mk_iff(ex, rhs), m);
+ expr_ref finalAxiom(mk_and(items), m);
SASSERT(finalAxiom);
assert_axiom(finalAxiom);
- } else {
- TRACE("str", tout << "ERROR: unknown regex expression " << mk_pp(regex, m) << "!" << std::endl;);
- NOT_IMPLEMENTED_YET();
- }
-}
-
-void theory_str::attach_new_th_var(enode * n) {
- context & ctx = get_context();
- theory_var v = mk_var(n);
- ctx.attach_th_var(n, this, v);
- TRACE("str", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := v#" << v << std::endl;);
-}
-
-void theory_str::reset_eh() {
- TRACE("str", tout << "resetting" << std::endl;);
- m_trail_stack.reset();
-
- m_basicstr_axiom_todo.reset();
- m_str_eq_todo.reset();
- m_concat_axiom_todo.reset();
- pop_scope_eh(get_context().get_scope_level());
-}
-
-/*
- * Check equality among equivalence class members of LHS and RHS
- * to discover an incorrect LHS == RHS.
- * For example, if we have y2 == "str3"
- * and the equivalence classes are
- * { y2, (Concat ce m2) }
- * { "str3", (Concat abc x2) }
- * then y2 can't be equal to "str3".
- * Then add an assertion: (y2 == (Concat ce m2)) AND ("str3" == (Concat abc x2)) -> (y2 != "str3")
- */
-bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- // skip this check if we defer consistency checking, as we can do it for every EQC in final check
- if (!opt_DeferEQCConsistencyCheck) {
- check_concat_len_in_eqc(lhs);
- check_concat_len_in_eqc(rhs);
+ return unrollFunc;
}
- // Now we iterate over all pairs of terms across both EQCs
- // and check whether we can show that any pair of distinct terms
- // cannot possibly be equal.
- // If that's the case, we assert an axiom to that effect and stop.
+ app * theory_str::mk_contains(expr * haystack, expr * needle) {
+ app * contains = u.str.mk_contains(haystack, needle); // TODO double-check semantics/argument order
+ m_trail.push_back(contains);
+ // immediately force internalization so that axiom setup does not fail
+ get_context().internalize(contains, false);
+ set_up_axioms(contains);
+ return contains;
+ }
- expr * eqc_nn1 = lhs;
- do {
- expr * eqc_nn2 = rhs;
- do {
- TRACE("str", tout << "checking whether " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " can be equal" << std::endl;);
- // inconsistency check: value
- if (!can_two_nodes_eq(eqc_nn1, eqc_nn2)) {
- TRACE("str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " cannot be equal to " << mk_pp(eqc_nn2, m) << std::endl;);
- expr_ref to_assert(m.mk_not(ctx.mk_eq_atom(eqc_nn1, eqc_nn2)), m);
- assert_axiom(to_assert);
- // this shouldn't use the integer theory at all, so we don't allow the option of quick-return
- return false;
- }
- if (!check_length_consistency(eqc_nn1, eqc_nn2)) {
- TRACE("str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " have inconsistent lengths" << std::endl;);
- if (opt_NoQuickReturn_IntegerTheory){
- TRACE("str", tout << "continuing in new_eq_check() due to opt_NoQuickReturn_IntegerTheory" << std::endl;);
- } else {
- return false;
- }
- }
- eqc_nn2 = get_eqc_next(eqc_nn2);
- } while (eqc_nn2 != rhs);
- eqc_nn1 = get_eqc_next(eqc_nn1);
- } while (eqc_nn1 != lhs);
-
- if (!contains_map.empty()) {
- check_contain_in_new_eq(lhs, rhs);
- }
-
- if (!regex_in_bool_map.empty()) {
- TRACE("str", tout << "checking regex consistency" << std::endl;);
- check_regex_in(lhs, rhs);
- }
-
- // okay, all checks here passed
- return true;
-}
-
-// support for user_smt_theory-style EQC handling
-
-app * theory_str::get_ast(theory_var i) {
- return get_enode(i)->get_owner();
-}
-
-theory_var theory_str::get_var(expr * n) const {
- if (!is_app(n)) {
- return null_theory_var;
- }
- context & ctx = get_context();
- if (ctx.e_internalized(to_app(n))) {
- enode * e = ctx.get_enode(to_app(n));
- return e->get_th_var(get_id());
- }
- return null_theory_var;
-}
-
-// simulate Z3_theory_get_eqc_next()
-expr * theory_str::get_eqc_next(expr * n) {
- theory_var v = get_var(n);
- if (v != null_theory_var) {
- theory_var r = m_find.next(v);
- return get_ast(r);
- }
- return n;
-}
-
-void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts) {
- context & ctx = get_context();
- expr * eqcNode = n;
- do {
- app * ast = to_app(eqcNode);
- if (u.str.is_concat(ast)) {
- expr * simConcat = simplify_concat(ast);
- if (simConcat != ast) {
- if (u.str.is_concat(to_app(simConcat))) {
- concats.insert(simConcat);
- } else {
- if (u.str.is_string(simConcat)) {
- consts.insert(simConcat);
- } else {
- vars.insert(simConcat);
- }
+ app * theory_str::mk_indexof(expr * haystack, expr * needle) {
+ // TODO check meaning of the third argument here
+ app * indexof = u.str.mk_index(haystack, needle, mk_int(0));
+ m_trail.push_back(indexof);
+ // immediately force internalization so that axiom setup does not fail
+ get_context().internalize(indexof, false);
+ set_up_axioms(indexof);
+ return indexof;
+ }
+
+ app * theory_str::mk_strlen(expr * e) {
+ /*if (m_strutil.is_string(e)) {*/ if (false) {
+ zstring strval;
+ u.str.is_string(e, strval);
+ unsigned int len = strval.length();
+ return m_autil.mk_numeral(rational(len), true);
+ } else {
+ if (false) {
+ // use cache
+ app * lenTerm = NULL;
+ if (!length_ast_map.find(e, lenTerm)) {
+ lenTerm = u.str.mk_length(e);
+ length_ast_map.insert(e, lenTerm);
+ m_trail.push_back(lenTerm);
}
+ return lenTerm;
} else {
- concats.insert(simConcat);
+ // always regen
+ return u.str.mk_length(e);
}
- } else if (u.str.is_string(ast)) {
- consts.insert(ast);
- } else {
- vars.insert(ast);
- }
- eqcNode = get_eqc_next(eqcNode);
- } while (eqcNode != n);
-}
-
-void theory_str::get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList) {
- app * a_node = to_app(node);
- if (!u.str.is_concat(a_node)) {
- nodeList.push_back(node);
- return;
- } else {
- SASSERT(a_node->get_num_args() == 2);
- expr * leftArg = a_node->get_arg(0);
- expr * rightArg = a_node->get_arg(1);
- get_nodes_in_concat(leftArg, nodeList);
- get_nodes_in_concat(rightArg, nodeList);
- }
-}
-
-// previously Concat() in strTheory.cpp
-// Evaluates the concatenation (n1 . n2) with respect to
-// the current equivalence classes of n1 and n2.
-// Returns a constant string expression representing this concatenation
-// if one can be determined, or NULL if this is not possible.
-expr * theory_str::eval_concat(expr * n1, expr * n2) {
- bool n1HasEqcValue = false;
- bool n2HasEqcValue = false;
- expr * v1 = get_eqc_value(n1, n1HasEqcValue);
- expr * v2 = get_eqc_value(n2, n2HasEqcValue);
- if (n1HasEqcValue && n2HasEqcValue) {
- zstring n1_str, n2_str;
- u.str.is_string(v1, n1_str);
- u.str.is_string(v2, n2_str);
- zstring result = n1_str + n2_str;
- return mk_string(result);
- } else if (n1HasEqcValue && !n2HasEqcValue) {
- zstring v1_str;
- u.str.is_string(v1, v1_str);
- if (v1_str.empty()) {
- return n2;
- }
- } else if (n2HasEqcValue && !n1HasEqcValue) {
- zstring v2_str;
- u.str.is_string(v2, v2_str);
- if (v2_str.empty()) {
- return n1;
- }
- }
- // give up
- return NULL;
-}
-
-static inline std::string rational_to_string_if_exists(const rational & x, bool x_exists) {
- if (x_exists) {
- return x.to_string();
- } else {
- return "?";
- }
-}
-
-/*
- * The inputs:
- * ~ nn: non const node
- * ~ eq_str: the equivalent constant string of nn
- * Iterate the parent of all eqc nodes of nn, looking for:
- * ~ concat node
- * to see whether some concat nodes can be simplified.
- */
-void theory_str::simplify_parent(expr * nn, expr * eq_str) {
- ast_manager & m = get_manager();
- context & ctx = get_context();
-
- TRACE("str", tout << "simplifying parents of " << mk_ismt2_pp(nn, m)
- << " with respect to " << mk_ismt2_pp(eq_str, m) << std::endl;);
-
- ctx.internalize(nn, false);
-
- zstring eq_strValue;
- u.str.is_string(eq_str, eq_strValue);
- expr * n_eqNode = nn;
- do {
- enode * n_eq_enode = ctx.get_enode(n_eqNode);
- TRACE("str", tout << "considering all parents of " << mk_ismt2_pp(n_eqNode, m) << std::endl
- << "associated n_eq_enode has " << n_eq_enode->get_num_parents() << " parents" << std::endl;);
-
- // the goal of this next bit is to avoid dereferencing a bogus e_parent in the following loop.
- // what I imagine is causing this bug is that, for example, we examine some parent, we add an axiom that involves it,
- // and the parent_it iterator becomes invalidated, because we indirectly modified the container that we're iterating over.
-
- enode_vector current_parents;
- for (enode_vector::const_iterator parent_it = n_eq_enode->begin_parents(); parent_it != n_eq_enode->end_parents(); parent_it++) {
- current_parents.insert(*parent_it);
- }
-
- for (enode_vector::iterator parent_it = current_parents.begin(); parent_it != current_parents.end(); ++parent_it) {
- enode * e_parent = *parent_it;
- SASSERT(e_parent != NULL);
-
- app * a_parent = e_parent->get_owner();
- TRACE("str", tout << "considering parent " << mk_ismt2_pp(a_parent, m) << std::endl;);
-
- if (u.str.is_concat(a_parent)) {
- expr * arg0 = a_parent->get_arg(0);
- expr * arg1 = a_parent->get_arg(1);
-
- rational parentLen;
- bool parentLen_exists = get_len_value(a_parent, parentLen);
-
- if (arg0 == n_eq_enode->get_owner()) {
- rational arg0Len, arg1Len;
- bool arg0Len_exists = get_len_value(eq_str, arg0Len);
- bool arg1Len_exists = get_len_value(arg1, arg1Len);
-
- TRACE("str",
- tout << "simplify_parent #1:" << std::endl
- << "* parent = " << mk_ismt2_pp(a_parent, m) << std::endl
- << "* |parent| = " << rational_to_string_if_exists(parentLen, parentLen_exists) << std::endl
- << "* |arg0| = " << rational_to_string_if_exists(arg0Len, arg0Len_exists) << std::endl
- << "* |arg1| = " << rational_to_string_if_exists(arg1Len, arg1Len_exists) << std::endl;
- );
-
- if (parentLen_exists && !arg1Len_exists) {
- TRACE("str", tout << "make up len for arg1" << std::endl;);
- expr_ref implyL11(m.mk_and(ctx.mk_eq_atom(mk_strlen(a_parent), mk_int(parentLen)),
- ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0Len))), m);
- rational makeUpLenArg1 = parentLen - arg0Len;
- if (makeUpLenArg1.is_nonneg()) {
- expr_ref implyR11(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(makeUpLenArg1)), m);
- assert_implication(implyL11, implyR11);
- } else {
- expr_ref neg(m.mk_not(implyL11), m);
- assert_axiom(neg);
- }
- }
-
- // (Concat n_eqNode arg1) /\ arg1 has eq const
-
- expr * concatResult = eval_concat(eq_str, arg1);
- if (concatResult != NULL) {
- bool arg1HasEqcValue = false;
- expr * arg1Value = get_eqc_value(arg1, arg1HasEqcValue);
- expr_ref implyL(m);
- if (arg1 != arg1Value) {
- expr_ref eq_ast1(m);
- eq_ast1 = ctx.mk_eq_atom(n_eqNode, eq_str);
- SASSERT(eq_ast1);
-
- expr_ref eq_ast2(m);
- eq_ast2 = ctx.mk_eq_atom(arg1, arg1Value);
- SASSERT(eq_ast2);
- implyL = m.mk_and(eq_ast1, eq_ast2);
- } else {
- implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
- }
-
-
- if (!in_same_eqc(a_parent, concatResult)) {
- expr_ref implyR(m);
- implyR = ctx.mk_eq_atom(a_parent, concatResult);
- SASSERT(implyR);
-
- assert_implication(implyL, implyR);
- }
- } else if (u.str.is_concat(to_app(n_eqNode))) {
- expr_ref simpleConcat(m);
- simpleConcat = mk_concat(eq_str, arg1);
- if (!in_same_eqc(a_parent, simpleConcat)) {
- expr_ref implyL(m);
- implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
- SASSERT(implyL);
-
- expr_ref implyR(m);
- implyR = ctx.mk_eq_atom(a_parent, simpleConcat);
- SASSERT(implyR);
- assert_implication(implyL, implyR);
- }
- }
- } // if (arg0 == n_eq_enode->get_owner())
-
- if (arg1 == n_eq_enode->get_owner()) {
- rational arg0Len, arg1Len;
- bool arg0Len_exists = get_len_value(arg0, arg0Len);
- bool arg1Len_exists = get_len_value(eq_str, arg1Len);
-
- TRACE("str",
- tout << "simplify_parent #2:" << std::endl
- << "* parent = " << mk_ismt2_pp(a_parent, m) << std::endl
- << "* |parent| = " << rational_to_string_if_exists(parentLen, parentLen_exists) << std::endl
- << "* |arg0| = " << rational_to_string_if_exists(arg0Len, arg0Len_exists) << std::endl
- << "* |arg1| = " << rational_to_string_if_exists(arg1Len, arg1Len_exists) << std::endl;
- );
- if (parentLen_exists && !arg0Len_exists) {
- TRACE("str", tout << "make up len for arg0" << std::endl;);
- expr_ref implyL11(m.mk_and(ctx.mk_eq_atom(mk_strlen(a_parent), mk_int(parentLen)),
- ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len))), m);
- rational makeUpLenArg0 = parentLen - arg1Len;
- if (makeUpLenArg0.is_nonneg()) {
- expr_ref implyR11(ctx.mk_eq_atom(mk_strlen(arg0), mk_int(makeUpLenArg0)), m);
- assert_implication(implyL11, implyR11);
- } else {
- expr_ref neg(m.mk_not(implyL11), m);
- assert_axiom(neg);
- }
- }
-
- // (Concat arg0 n_eqNode) /\ arg0 has eq const
-
- expr * concatResult = eval_concat(arg0, eq_str);
- if (concatResult != NULL) {
- bool arg0HasEqcValue = false;
- expr * arg0Value = get_eqc_value(arg0, arg0HasEqcValue);
- expr_ref implyL(m);
- if (arg0 != arg0Value) {
- expr_ref eq_ast1(m);
- eq_ast1 = ctx.mk_eq_atom(n_eqNode, eq_str);
- SASSERT(eq_ast1);
- expr_ref eq_ast2(m);
- eq_ast2 = ctx.mk_eq_atom(arg0, arg0Value);
- SASSERT(eq_ast2);
-
- implyL = m.mk_and(eq_ast1, eq_ast2);
- } else {
- implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
- }
-
- if (!in_same_eqc(a_parent, concatResult)) {
- expr_ref implyR(m);
- implyR = ctx.mk_eq_atom(a_parent, concatResult);
- SASSERT(implyR);
-
- assert_implication(implyL, implyR);
- }
- } else if (u.str.is_concat(to_app(n_eqNode))) {
- expr_ref simpleConcat(m);
- simpleConcat = mk_concat(arg0, eq_str);
- if (!in_same_eqc(a_parent, simpleConcat)) {
- expr_ref implyL(m);
- implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
- SASSERT(implyL);
-
- expr_ref implyR(m);
- implyR = ctx.mk_eq_atom(a_parent, simpleConcat);
- SASSERT(implyR);
- assert_implication(implyL, implyR);
- }
- }
- } // if (arg1 == n_eq_enode->get_owner
-
-
- //---------------------------------------------------------
- // Case (2-1) begin: (Concat n_eqNode (Concat str var))
- if (arg0 == n_eqNode && u.str.is_concat(to_app(arg1))) {
- app * a_arg1 = to_app(arg1);
- TRACE("str", tout << "simplify_parent #3" << std::endl;);
- expr * r_concat_arg0 = a_arg1->get_arg(0);
- if (u.str.is_string(r_concat_arg0)) {
- expr * combined_str = eval_concat(eq_str, r_concat_arg0);
- SASSERT(combined_str);
- expr * r_concat_arg1 = a_arg1->get_arg(1);
- expr_ref implyL(m);
- implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
- expr * simplifiedAst = mk_concat(combined_str, r_concat_arg1);
- if (!in_same_eqc(a_parent, simplifiedAst)) {
- expr_ref implyR(m);
- implyR = ctx.mk_eq_atom(a_parent, simplifiedAst);
- assert_implication(implyL, implyR);
- }
- }
- }
- // Case (2-1) end: (Concat n_eqNode (Concat str var))
- //---------------------------------------------------------
-
-
- //---------------------------------------------------------
- // Case (2-2) begin: (Concat (Concat var str) n_eqNode)
- if (u.str.is_concat(to_app(arg0)) && arg1 == n_eqNode) {
- app * a_arg0 = to_app(arg0);
- TRACE("str", tout << "simplify_parent #4" << std::endl;);
- expr * l_concat_arg1 = a_arg0->get_arg(1);
- if (u.str.is_string(l_concat_arg1)) {
- expr * combined_str = eval_concat(l_concat_arg1, eq_str);
- SASSERT(combined_str);
- expr * l_concat_arg0 = a_arg0->get_arg(0);
- expr_ref implyL(m);
- implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
- expr * simplifiedAst = mk_concat(l_concat_arg0, combined_str);
- if (!in_same_eqc(a_parent, simplifiedAst)) {
- expr_ref implyR(m);
- implyR = ctx.mk_eq_atom(a_parent, simplifiedAst);
- assert_implication(implyL, implyR);
- }
- }
- }
- // Case (2-2) end: (Concat (Concat var str) n_eqNode)
- //---------------------------------------------------------
-
- // Have to look up one more layer: if the parent of the concat is another concat
- //-------------------------------------------------
- // Case (3-1) begin: (Concat (Concat var n_eqNode) str )
- if (arg1 == n_eqNode) {
- for (enode_vector::iterator concat_parent_it = e_parent->begin_parents();
- concat_parent_it != e_parent->end_parents(); concat_parent_it++) {
- enode * e_concat_parent = *concat_parent_it;
- app * concat_parent = e_concat_parent->get_owner();
- if (u.str.is_concat(concat_parent)) {
- expr * concat_parent_arg0 = concat_parent->get_arg(0);
- expr * concat_parent_arg1 = concat_parent->get_arg(1);
- if (concat_parent_arg0 == a_parent && u.str.is_string(concat_parent_arg1)) {
- TRACE("str", tout << "simplify_parent #5" << std::endl;);
- expr * combinedStr = eval_concat(eq_str, concat_parent_arg1);
- SASSERT(combinedStr);
- expr_ref implyL(m);
- implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
- expr * simplifiedAst = mk_concat(arg0, combinedStr);
- if (!in_same_eqc(concat_parent, simplifiedAst)) {
- expr_ref implyR(m);
- implyR = ctx.mk_eq_atom(concat_parent, simplifiedAst);
- assert_implication(implyL, implyR);
- }
- }
- }
- }
- }
- // Case (3-1) end: (Concat (Concat var n_eqNode) str )
- // Case (3-2) begin: (Concat str (Concat n_eqNode var) )
- if (arg0 == n_eqNode) {
- for (enode_vector::iterator concat_parent_it = e_parent->begin_parents();
- concat_parent_it != e_parent->end_parents(); concat_parent_it++) {
- enode * e_concat_parent = *concat_parent_it;
- app * concat_parent = e_concat_parent->get_owner();
- if (u.str.is_concat(concat_parent)) {
- expr * concat_parent_arg0 = concat_parent->get_arg(0);
- expr * concat_parent_arg1 = concat_parent->get_arg(1);
- if (concat_parent_arg1 == a_parent && u.str.is_string(concat_parent_arg0)) {
- TRACE("str", tout << "simplify_parent #6" << std::endl;);
- expr * combinedStr = eval_concat(concat_parent_arg0, eq_str);
- SASSERT(combinedStr);
- expr_ref implyL(m);
- implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
- expr * simplifiedAst = mk_concat(combinedStr, arg1);
- if (!in_same_eqc(concat_parent, simplifiedAst)) {
- expr_ref implyR(m);
- implyR = ctx.mk_eq_atom(concat_parent, simplifiedAst);
- assert_implication(implyL, implyR);
- }
- }
- }
- }
- }
- // Case (3-2) end: (Concat str (Concat n_eqNode var) )
- } // if is_concat(a_parent)
- } // for parent_it : n_eq_enode->begin_parents()
-
-
- // check next EQC member
- n_eqNode = get_eqc_next(n_eqNode);
- } while (n_eqNode != nn);
-}
-
-expr * theory_str::simplify_concat(expr * node) {
- ast_manager & m = get_manager();
- context & ctx = get_context();
- std::map<expr*, expr*> resolvedMap;
- ptr_vector<expr> argVec;
- get_nodes_in_concat(node, argVec);
-
- for (unsigned i = 0; i < argVec.size(); ++i) {
- bool vArgHasEqcValue = false;
- expr * vArg = get_eqc_value(argVec[i], vArgHasEqcValue);
- if (vArg != argVec[i]) {
- resolvedMap[argVec[i]] = vArg;
- }
- }
-
- if (resolvedMap.size() == 0) {
- // no simplification possible
- return node;
- } else {
- expr * resultAst = mk_string("");
- for (unsigned i = 0; i < argVec.size(); ++i) {
- bool vArgHasEqcValue = false;
- expr * vArg = get_eqc_value(argVec[i], vArgHasEqcValue);
- resultAst = mk_concat(resultAst, vArg);
- }
- TRACE("str", tout << mk_ismt2_pp(node, m) << " is simplified to " << mk_ismt2_pp(resultAst, m) << std::endl;);
-
- if (in_same_eqc(node, resultAst)) {
- TRACE("str", tout << "SKIP: both concats are already in the same equivalence class" << std::endl;);
- } else {
- expr_ref_vector items(m);
- int pos = 0;
- std::map<expr*, expr*>::iterator itor = resolvedMap.begin();
- for (; itor != resolvedMap.end(); ++itor) {
- items.push_back(ctx.mk_eq_atom(itor->first, itor->second));
- pos += 1;
- }
- expr_ref premise(mk_and(items), m);
- expr_ref conclusion(ctx.mk_eq_atom(node, resultAst), m);
- assert_implication(premise, conclusion);
- }
- return resultAst;
- }
-
-}
-
-// Modified signature of Z3str2's inferLenConcat().
-// Returns true iff nLen can be inferred by this method
-// (i.e. the equivalent of a len_exists flag in get_len_value()).
-
-bool theory_str::infer_len_concat(expr * n, rational & nLen) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
- expr * arg0 = to_app(n)->get_arg(0);
- expr * arg1 = to_app(n)->get_arg(1);
-
- rational arg0_len, arg1_len;
- bool arg0_len_exists = get_len_value(arg0, arg0_len);
- bool arg1_len_exists = get_len_value(arg1, arg1_len);
- rational tmp_len;
- bool nLen_exists = get_len_value(n, tmp_len);
-
- if (arg0_len_exists && arg1_len_exists && !nLen_exists) {
- expr_ref_vector l_items(m);
- // if (mk_strlen(arg0) != mk_int(arg0_len)) {
- {
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0_len)));
- }
-
- // if (mk_strlen(arg1) != mk_int(arg1_len)) {
- {
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1_len)));
- }
-
- expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
- rational nnLen = arg0_len + arg1_len;
- expr_ref axr(ctx.mk_eq_atom(mk_strlen(n), mk_int(nnLen)), m);
- TRACE("str", tout << "inferred (Length " << mk_pp(n, m) << ") = " << nnLen << std::endl;);
- assert_implication(axl, axr);
- nLen = nnLen;
- return true;
- } else {
- return false;
- }
-}
-
-void theory_str::infer_len_concat_arg(expr * n, rational len) {
- if (len.is_neg()) {
- return;
- }
-
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- expr * arg0 = to_app(n)->get_arg(0);
- expr * arg1 = to_app(n)->get_arg(1);
- rational arg0_len, arg1_len;
- bool arg0_len_exists = get_len_value(arg0, arg0_len);
- bool arg1_len_exists = get_len_value(arg1, arg1_len);
-
- expr_ref_vector l_items(m);
- expr_ref axr(m);
- axr.reset();
-
- // if (mk_length(t, n) != mk_int(ctx, len)) {
- {
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(len)));
- }
-
- if (!arg0_len_exists && arg1_len_exists) {
- //if (mk_length(t, arg1) != mk_int(ctx, arg1_len)) {
- {
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1_len)));
- }
- rational arg0Len = len - arg1_len;
- if (arg0Len.is_nonneg()) {
- axr = ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0Len));
- } else {
- // could negate
- }
- } else if (arg0_len_exists && !arg1_len_exists) {
- //if (mk_length(t, arg0) != mk_int(ctx, arg0_len)) {
- {
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0_len)));
- }
- rational arg1Len = len - arg0_len;
- if (arg1Len.is_nonneg()) {
- axr = ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len));
- } else {
- // could negate
- }
- } else {
-
- }
-
- if (axr) {
- expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
- assert_implication(axl, axr);
- }
-}
-
-void theory_str::infer_len_concat_equality(expr * nn1, expr * nn2) {
- rational nnLen;
- bool nnLen_exists = get_len_value(nn1, nnLen);
- if (!nnLen_exists) {
- nnLen_exists = get_len_value(nn2, nnLen);
- }
-
- // case 1:
- // Known: a1_arg0 and a1_arg1
- // Unknown: nn1
-
- if (u.str.is_concat(to_app(nn1))) {
- rational nn1ConcatLen;
- bool nn1ConcatLen_exists = infer_len_concat(nn1, nn1ConcatLen);
- if (nnLen_exists && nn1ConcatLen_exists) {
- nnLen = nn1ConcatLen;
- }
- }
-
- // case 2:
- // Known: a1_arg0 and a1_arg1
- // Unknown: nn1
-
- if (u.str.is_concat(to_app(nn2))) {
- rational nn2ConcatLen;
- bool nn2ConcatLen_exists = infer_len_concat(nn2, nn2ConcatLen);
- if (nnLen_exists && nn2ConcatLen_exists) {
- nnLen = nn2ConcatLen;
- }
- }
-
- if (nnLen_exists) {
- if (u.str.is_concat(to_app(nn1))) {
- infer_len_concat_arg(nn1, nnLen);
- }
- if (u.str.is_concat(to_app(nn2))) {
- infer_len_concat_arg(nn2, nnLen);
}
}
/*
- if (isConcatFunc(t, nn2)) {
- int nn2ConcatLen = inferLenConcat(t, nn2);
- if (nnLen == -1 && nn2ConcatLen != -1)
- nnLen = nn2ConcatLen;
- }
-
- if (nnLen != -1) {
- if (isConcatFunc(t, nn1)) {
- inferLenConcatArg(t, nn1, nnLen);
- }
- if (isConcatFunc(t, nn2)) {
- inferLenConcatArg(t, nn2, nnLen);
- }
- }
- */
-}
-
-void theory_str::add_theory_aware_branching_info(expr * term, double priority, lbool phase) {
- context & ctx = get_context();
- ctx.internalize(term, false);
- bool_var v = ctx.get_bool_var(term);
- ctx.add_theory_aware_branching_info(v, priority, phase);
-}
-
-void theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
- context & ctx = get_context();
- // pull each literal out of the arrangement disjunction
- literal_vector ls;
- for (unsigned i = 0; i < terms.size(); ++i) {
- expr * e = terms.get(i);
- literal l = ctx.get_literal(e);
- ls.push_back(l);
- }
- ctx.mk_th_case_split(ls.size(), ls.c_ptr());
-}
-
-void theory_str::print_cut_var(expr * node, std::ofstream & xout) {
- ast_manager & m = get_manager();
- xout << "Cut info of " << mk_pp(node, m) << std::endl;
- if (cut_var_map.contains(node)) {
- if (!cut_var_map[node].empty()) {
- xout << "[" << cut_var_map[node].top()->level << "] ";
- std::map<expr*, int>::iterator itor = cut_var_map[node].top()->vars.begin();
- for (; itor != cut_var_map[node].top()->vars.end(); ++itor) {
- xout << mk_pp(itor->first, m) << ", ";
+ * Returns the simplified concatenation of two expressions,
+ * where either both expressions are constant strings
+ * or one expression is the empty string.
+ * If this precondition does not hold, the function returns NULL.
+ * (note: this function was strTheory::Concat())
+ */
+ expr * theory_str::mk_concat_const_str(expr * n1, expr * n2) {
+ bool n1HasEqcValue = false;
+ bool n2HasEqcValue = false;
+ expr * v1 = get_eqc_value(n1, n1HasEqcValue);
+ expr * v2 = get_eqc_value(n2, n2HasEqcValue);
+ if (n1HasEqcValue && n2HasEqcValue) {
+ zstring n1_str;
+ u.str.is_string(v1, n1_str);
+ zstring n2_str;
+ u.str.is_string(v2, n2_str);
+ zstring result = n1_str + n2_str;
+ return mk_string(result);
+ } else if (n1HasEqcValue && !n2HasEqcValue) {
+ zstring n1_str;
+ u.str.is_string(v1, n1_str);
+ if (n1_str.empty()) {
+ return n2;
+ }
+ } else if (!n1HasEqcValue && n2HasEqcValue) {
+ zstring n2_str;
+ u.str.is_string(v2, n2_str);
+ if (n2_str.empty()) {
+ return n1;
}
- xout << std::endl;
}
- }
-}
-
-/*
- * Handle two equivalent Concats.
- */
-void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
- ast_manager & m = get_manager();
- context & ctx = get_context();
-
- app * a_nn1 = to_app(nn1);
- SASSERT(a_nn1->get_num_args() == 2);
- app * a_nn2 = to_app(nn2);
- SASSERT(a_nn2->get_num_args() == 2);
-
- expr * a1_arg0 = a_nn1->get_arg(0);
- expr * a1_arg1 = a_nn1->get_arg(1);
- expr * a2_arg0 = a_nn2->get_arg(0);
- expr * a2_arg1 = a_nn2->get_arg(1);
-
- rational a1_arg0_len, a1_arg1_len, a2_arg0_len, a2_arg1_len;
-
- bool a1_arg0_len_exists = get_len_value(a1_arg0, a1_arg0_len);
- bool a1_arg1_len_exists = get_len_value(a1_arg1, a1_arg1_len);
- bool a2_arg0_len_exists = get_len_value(a2_arg0, a2_arg0_len);
- bool a2_arg1_len_exists = get_len_value(a2_arg1, a2_arg1_len);
-
- TRACE("str", tout << "nn1 = " << mk_ismt2_pp(nn1, m) << std::endl
- << "nn2 = " << mk_ismt2_pp(nn2, m) << std::endl;);
-
- TRACE("str", tout
- << "len(" << mk_pp(a1_arg0, m) << ") = " << (a1_arg0_len_exists ? a1_arg0_len.to_string() : "?") << std::endl
- << "len(" << mk_pp(a1_arg1, m) << ") = " << (a1_arg1_len_exists ? a1_arg1_len.to_string() : "?") << std::endl
- << "len(" << mk_pp(a2_arg0, m) << ") = " << (a2_arg0_len_exists ? a2_arg0_len.to_string() : "?") << std::endl
- << "len(" << mk_pp(a2_arg1, m) << ") = " << (a2_arg1_len_exists ? a2_arg1_len.to_string() : "?") << std::endl
- << std::endl;);
-
- infer_len_concat_equality(nn1, nn2);
-
- if (a1_arg0 == a2_arg0) {
- if (!in_same_eqc(a1_arg1, a2_arg1)) {
- expr_ref premise(ctx.mk_eq_atom(nn1, nn2), m);
- expr_ref eq1(ctx.mk_eq_atom(a1_arg1, a2_arg1), m);
- expr_ref eq2(ctx.mk_eq_atom(mk_strlen(a1_arg1), mk_strlen(a2_arg1)), m);
- expr_ref conclusion(m.mk_and(eq1, eq2), m);
- assert_implication(premise, conclusion);
- }
- TRACE("str", tout << "SKIP: a1_arg0 == a2_arg0" << std::endl;);
- return;
+ return NULL;
}
- if (a1_arg1 == a2_arg1) {
- if (!in_same_eqc(a1_arg0, a2_arg0)) {
- expr_ref premise(ctx.mk_eq_atom(nn1, nn2), m);
- expr_ref eq1(ctx.mk_eq_atom(a1_arg0, a2_arg0), m);
- expr_ref eq2(ctx.mk_eq_atom(mk_strlen(a1_arg0), mk_strlen(a2_arg0)), m);
- expr_ref conclusion(m.mk_and(eq1, eq2), m);
- assert_implication(premise, conclusion);
- }
- TRACE("str", tout << "SKIP: a1_arg1 == a2_arg1" << std::endl;);
- return;
- }
+ expr * theory_str::mk_concat(expr * n1, expr * n2) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ ENSURE(n1 != NULL);
+ ENSURE(n2 != NULL);
+ bool n1HasEqcValue = false;
+ bool n2HasEqcValue = false;
+ n1 = get_eqc_value(n1, n1HasEqcValue);
+ n2 = get_eqc_value(n2, n2HasEqcValue);
+ if (n1HasEqcValue && n2HasEqcValue) {
+ return mk_concat_const_str(n1, n2);
+ } else if (n1HasEqcValue && !n2HasEqcValue) {
+ bool n2_isConcatFunc = u.str.is_concat(to_app(n2));
+ zstring n1_str;
+ u.str.is_string(n1, n1_str);
+ if (n1_str.empty()) {
+ return n2;
+ }
+ if (n2_isConcatFunc) {
+ expr * n2_arg0 = to_app(n2)->get_arg(0);
+ expr * n2_arg1 = to_app(n2)->get_arg(1);
+ if (u.str.is_string(n2_arg0)) {
+ n1 = mk_concat_const_str(n1, n2_arg0); // n1 will be a constant
+ n2 = n2_arg1;
+ }
+ }
+ } else if (!n1HasEqcValue && n2HasEqcValue) {
+ zstring n2_str;
+ u.str.is_string(n2, n2_str);
+ if (n2_str.empty()) {
+ return n1;
+ }
- // quick path
-
- if (in_same_eqc(a1_arg0, a2_arg0)) {
- if (in_same_eqc(a1_arg1, a2_arg1)) {
- TRACE("str", tout << "SKIP: a1_arg0 =~ a2_arg0 and a1_arg1 =~ a2_arg1" << std::endl;);
- return;
+ if (u.str.is_concat(to_app(n1))) {
+ expr * n1_arg0 = to_app(n1)->get_arg(0);
+ expr * n1_arg1 = to_app(n1)->get_arg(1);
+ if (u.str.is_string(n1_arg1)) {
+ n1 = n1_arg0;
+ n2 = mk_concat_const_str(n1_arg1, n2); // n2 will be a constant
+ }
+ }
} else {
- TRACE("str", tout << "quick path 1-1: a1_arg0 =~ a2_arg0" << std::endl;);
- expr_ref premise(m.mk_and(ctx.mk_eq_atom(nn1, nn2), ctx.mk_eq_atom(a1_arg0, a2_arg0)), m);
- expr_ref conclusion(m.mk_and(ctx.mk_eq_atom(a1_arg1, a2_arg1), ctx.mk_eq_atom(mk_strlen(a1_arg1), mk_strlen(a2_arg1))), m);
- assert_implication(premise, conclusion);
- return;
- }
- } else {
- if (in_same_eqc(a1_arg1, a2_arg1)) {
- TRACE("str", tout << "quick path 1-2: a1_arg1 =~ a2_arg1" << std::endl;);
- expr_ref premise(m.mk_and(ctx.mk_eq_atom(nn1, nn2), ctx.mk_eq_atom(a1_arg1, a2_arg1)), m);
- expr_ref conclusion(m.mk_and(ctx.mk_eq_atom(a1_arg0, a2_arg0), ctx.mk_eq_atom(mk_strlen(a1_arg0), mk_strlen(a2_arg0))), m);
- assert_implication(premise, conclusion);
- return;
- }
- }
-
- // quick path 2-1
- if (a1_arg0_len_exists && a2_arg0_len_exists && a1_arg0_len == a2_arg0_len) {
- if (!in_same_eqc(a1_arg0, a2_arg0)) {
- TRACE("str", tout << "quick path 2-1: len(nn1.arg0) == len(nn2.arg0)" << std::endl;);
- expr_ref ax_l1(ctx.mk_eq_atom(nn1, nn2), m);
- expr_ref ax_l2(ctx.mk_eq_atom(mk_strlen(a1_arg0), mk_strlen(a2_arg0)), m);
- expr_ref ax_r1(ctx.mk_eq_atom(a1_arg0, a2_arg0), m);
- expr_ref ax_r2(ctx.mk_eq_atom(a1_arg1, a2_arg1), m);
-
- expr_ref premise(m.mk_and(ax_l1, ax_l2), m);
- expr_ref conclusion(m.mk_and(ax_r1, ax_r2), m);
-
- assert_implication(premise, conclusion);
-
- if (opt_NoQuickReturn_IntegerTheory) {
- TRACE("str", tout << "bypassing quick return from the end of this case" << std::endl;);
- } else {
- return;
+ if (u.str.is_concat(to_app(n1)) && u.str.is_concat(to_app(n2))) {
+ expr * n1_arg0 = to_app(n1)->get_arg(0);
+ expr * n1_arg1 = to_app(n1)->get_arg(1);
+ expr * n2_arg0 = to_app(n2)->get_arg(0);
+ expr * n2_arg1 = to_app(n2)->get_arg(1);
+ if (u.str.is_string(n1_arg1) && u.str.is_string(n2_arg0)) {
+ expr * tmpN1 = n1_arg0;
+ expr * tmpN2 = mk_concat_const_str(n1_arg1, n2_arg0);
+ n1 = mk_concat(tmpN1, tmpN2);
+ n2 = n2_arg1;
+ }
}
}
+
+ //------------------------------------------------------
+ // * expr * ast1 = mk_2_arg_app(ctx, td->Concat, n1, n2);
+ // * expr * ast2 = mk_2_arg_app(ctx, td->Concat, n1, n2);
+ // Z3 treats (ast1) and (ast2) as two different nodes.
+ //-------------------------------------------------------
+
+ expr * concatAst = NULL;
+
+ if (!concat_astNode_map.find(n1, n2, concatAst)) {
+ concatAst = u.str.mk_concat(n1, n2);
+ m_trail.push_back(concatAst);
+ concat_astNode_map.insert(n1, n2, concatAst);
+
+ expr_ref concat_length(mk_strlen(concatAst), m);
+
+ ptr_vector<expr> childrenVector;
+ get_nodes_in_concat(concatAst, childrenVector);
+ expr_ref_vector items(m);
+ for (unsigned int i = 0; i < childrenVector.size(); i++) {
+ items.push_back(mk_strlen(childrenVector.get(i)));
+ }
+ expr_ref lenAssert(ctx.mk_eq_atom(concat_length, m_autil.mk_add(items.size(), items.c_ptr())), m);
+ assert_axiom(lenAssert);
+ }
+ return concatAst;
}
- if (a1_arg1_len_exists && a2_arg1_len_exists && a1_arg1_len == a2_arg1_len) {
- if (!in_same_eqc(a1_arg1, a2_arg1)) {
- TRACE("str", tout << "quick path 2-2: len(nn1.arg1) == len(nn2.arg1)" << std::endl;);
- expr_ref ax_l1(ctx.mk_eq_atom(nn1, nn2), m);
- expr_ref ax_l2(ctx.mk_eq_atom(mk_strlen(a1_arg1), mk_strlen(a2_arg1)), m);
- expr_ref ax_r1(ctx.mk_eq_atom(a1_arg0, a2_arg0), m);
- expr_ref ax_r2(ctx.mk_eq_atom(a1_arg1, a2_arg1), m);
+ bool theory_str::can_propagate() {
+ return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty()
+ || !m_concat_axiom_todo.empty() || !m_concat_eval_todo.empty()
+ || !m_library_aware_axiom_todo.empty()
+ || !m_delayed_axiom_setup_terms.empty();
+ ;
+ }
- expr_ref premise(m.mk_and(ax_l1, ax_l2), m);
- expr_ref conclusion(m.mk_and(ax_r1, ax_r2), m);
+ void theory_str::propagate() {
+ context & ctx = get_context();
+ while (can_propagate()) {
+ TRACE("str", tout << "propagating..." << std::endl;);
+ for (unsigned i = 0; i < m_basicstr_axiom_todo.size(); ++i) {
+ instantiate_basic_string_axioms(m_basicstr_axiom_todo[i]);
+ }
+ m_basicstr_axiom_todo.reset();
+ TRACE("str", tout << "reset m_basicstr_axiom_todo" << std::endl;);
- assert_implication(premise, conclusion);
- if (opt_NoQuickReturn_IntegerTheory) {
- TRACE("str", tout << "bypassing quick return from the end of this case" << std::endl;);
+ for (unsigned i = 0; i < m_str_eq_todo.size(); ++i) {
+ std::pair<enode*,enode*> pair = m_str_eq_todo[i];
+ enode * lhs = pair.first;
+ enode * rhs = pair.second;
+ handle_equality(lhs->get_owner(), rhs->get_owner());
+ }
+ m_str_eq_todo.reset();
+
+ for (unsigned i = 0; i < m_concat_axiom_todo.size(); ++i) {
+ instantiate_concat_axiom(m_concat_axiom_todo[i]);
+ }
+ m_concat_axiom_todo.reset();
+
+ for (unsigned i = 0; i < m_concat_eval_todo.size(); ++i) {
+ try_eval_concat(m_concat_eval_todo[i]);
+ }
+ m_concat_eval_todo.reset();
+
+ for (unsigned i = 0; i < m_library_aware_axiom_todo.size(); ++i) {
+ enode * e = m_library_aware_axiom_todo[i];
+ app * a = e->get_owner();
+ if (u.str.is_stoi(a)) {
+ instantiate_axiom_str_to_int(e);
+ } else if (u.str.is_itos(a)) {
+ instantiate_axiom_int_to_str(e);
+ } else if (u.str.is_at(a)) {
+ instantiate_axiom_CharAt(e);
+ } else if (u.str.is_prefix(a)) {
+ instantiate_axiom_prefixof(e);
+ } else if (u.str.is_suffix(a)) {
+ instantiate_axiom_suffixof(e);
+ } else if (u.str.is_contains(a)) {
+ instantiate_axiom_Contains(e);
+ } else if (u.str.is_index(a)) {
+ instantiate_axiom_Indexof(e);
+ /* TODO NEXT: Indexof2/Lastindexof rewrite?
+ } else if (is_Indexof2(e)) {
+ instantiate_axiom_Indexof2(e);
+ } else if (is_LastIndexof(e)) {
+ instantiate_axiom_LastIndexof(e);
+ */
+ } else if (u.str.is_extract(a)) {
+ // TODO check semantics of substr vs. extract
+ instantiate_axiom_Substr(e);
+ } else if (u.str.is_replace(a)) {
+ instantiate_axiom_Replace(e);
+ } else if (u.str.is_in_re(a)) {
+ instantiate_axiom_RegexIn(e);
+ } else {
+ TRACE("str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_owner(), get_manager()) << std::endl;);
+ NOT_IMPLEMENTED_YET();
+ }
+ }
+ m_library_aware_axiom_todo.reset();
+
+ for (unsigned i = 0; i < m_delayed_axiom_setup_terms.size(); ++i) {
+ // I think this is okay
+ ctx.internalize(m_delayed_axiom_setup_terms[i].get(), false);
+ set_up_axioms(m_delayed_axiom_setup_terms[i].get());
+ }
+ m_delayed_axiom_setup_terms.reset();
+ }
+ }
+
+ /*
+ * Attempt to evaluate a concat over constant strings,
+ * and if this is possible, assert equality between the
+ * flattened string and the original term.
+ */
+
+ void theory_str::try_eval_concat(enode * cat) {
+ app * a_cat = cat->get_owner();
+ SASSERT(u.str.is_concat(a_cat));
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ TRACE("str", tout << "attempting to flatten " << mk_pp(a_cat, m) << std::endl;);
+
+ std::stack<app*> worklist;
+ zstring flattenedString("");
+ bool constOK = true;
+
+ {
+ app * arg0 = to_app(a_cat->get_arg(0));
+ app * arg1 = to_app(a_cat->get_arg(1));
+
+ worklist.push(arg1);
+ worklist.push(arg0);
+ }
+
+ while (constOK && !worklist.empty()) {
+ app * evalArg = worklist.top(); worklist.pop();
+ zstring nextStr;
+ if (u.str.is_string(evalArg, nextStr)) {
+ flattenedString = flattenedString + nextStr;
+ } else if (u.str.is_concat(evalArg)) {
+ app * arg0 = to_app(evalArg->get_arg(0));
+ app * arg1 = to_app(evalArg->get_arg(1));
+
+ worklist.push(arg1);
+ worklist.push(arg0);
} else {
- return;
+ TRACE("str", tout << "non-constant term in concat -- giving up." << std::endl;);
+ constOK = false;
+ break;
}
}
+ if (constOK) {
+ TRACE("str", tout << "flattened to \"" << flattenedString.encode().c_str() << "\"" << std::endl;);
+ expr_ref constStr(mk_string(flattenedString), m);
+ expr_ref axiom(ctx.mk_eq_atom(a_cat, constStr), m);
+ assert_axiom(axiom);
+ }
}
- expr_ref new_nn1(simplify_concat(nn1), m);
- expr_ref new_nn2(simplify_concat(nn2), m);
- app * a_new_nn1 = to_app(new_nn1);
- app * a_new_nn2 = to_app(new_nn2);
+ /*
+ * Instantiate an axiom of the following form:
+ * Length(Concat(x, y)) = Length(x) + Length(y)
+ */
+ void theory_str::instantiate_concat_axiom(enode * cat) {
+ app * a_cat = cat->get_owner();
+ SASSERT(u.str.is_concat(a_cat));
- TRACE("str", tout << "new_nn1 = " << mk_ismt2_pp(new_nn1, m) << std::endl
- << "new_nn2 = " << mk_ismt2_pp(new_nn2, m) << std::endl;);
+ ast_manager & m = get_manager();
- if (new_nn1 == new_nn2) {
- TRACE("str", tout << "equal concats, return" << std::endl;);
- return;
+ TRACE("str", tout << "instantiating concat axiom for " << mk_ismt2_pp(a_cat, m) << std::endl;);
+
+ // build LHS
+ expr_ref len_xy(m);
+ len_xy = mk_strlen(a_cat);
+ SASSERT(len_xy);
+
+ // build RHS: start by extracting x and y from Concat(x, y)
+ unsigned nArgs = a_cat->get_num_args();
+ SASSERT(nArgs == 2);
+ app * a_x = to_app(a_cat->get_arg(0));
+ app * a_y = to_app(a_cat->get_arg(1));
+
+ expr_ref len_x(m);
+ len_x = mk_strlen(a_x);
+ SASSERT(len_x);
+
+ expr_ref len_y(m);
+ len_y = mk_strlen(a_y);
+ SASSERT(len_y);
+
+ // now build len_x + len_y
+ expr_ref len_x_plus_len_y(m);
+ len_x_plus_len_y = m_autil.mk_add(len_x, len_y);
+ SASSERT(len_x_plus_len_y);
+
+ // finally assert equality between the two subexpressions
+ app * eq = m.mk_eq(len_xy, len_x_plus_len_y);
+ SASSERT(eq);
+ assert_axiom(eq);
}
- if (!can_two_nodes_eq(new_nn1, new_nn2)) {
- expr_ref detected(m.mk_not(ctx.mk_eq_atom(new_nn1, new_nn2)), m);
- TRACE("str", tout << "inconsistency detected: " << mk_ismt2_pp(detected, m) << std::endl;);
- assert_axiom(detected);
- return;
+ /*
+ * Add axioms that are true for any string variable:
+ * 1. Length(x) >= 0
+ * 2. Length(x) == 0 <=> x == ""
+ * If the term is a string constant, we can assert something stronger:
+ * Length(x) == strlen(x)
+ */
+ void theory_str::instantiate_basic_string_axioms(enode * str) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ TRACE("str", tout << "set up basic string axioms on " << mk_pp(str->get_owner(), m) << std::endl;);
+
+ // TESTING: attempt to avoid a crash here when a variable goes out of scope
+ if (str->get_iscope_lvl() > ctx.get_scope_level()) {
+ TRACE("str", tout << "WARNING: skipping axiom setup on out-of-scope string term" << std::endl;);
+ return;
+ }
+
+ // generate a stronger axiom for constant strings
+ app * a_str = str->get_owner();
+ if (u.str.is_string(a_str)) {
+ expr_ref len_str(m);
+ len_str = mk_strlen(a_str);
+ SASSERT(len_str);
+
+ zstring strconst;
+ u.str.is_string(str->get_owner(), strconst);
+ TRACE("str", tout << "instantiating constant string axioms for \"" << strconst.encode().c_str() << "\"" << std::endl;);
+ unsigned int l = strconst.length();
+ expr_ref len(m_autil.mk_numeral(rational(l), true), m);
+
+ literal lit(mk_eq(len_str, len, false));
+ ctx.mark_as_relevant(lit);
+ ctx.mk_th_axiom(get_id(), 1, &lit);
+ } else {
+ // build axiom 1: Length(a_str) >= 0
+ {
+ // build LHS
+ expr_ref len_str(m);
+ len_str = mk_strlen(a_str);
+ SASSERT(len_str);
+ // build RHS
+ expr_ref zero(m);
+ zero = m_autil.mk_numeral(rational(0), true);
+ SASSERT(zero);
+ // build LHS >= RHS and assert
+ app * lhs_ge_rhs = m_autil.mk_ge(len_str, zero);
+ SASSERT(lhs_ge_rhs);
+ TRACE("str", tout << "string axiom 1: " << mk_ismt2_pp(lhs_ge_rhs, m) << std::endl;);
+ assert_axiom(lhs_ge_rhs);
+ }
+
+ // build axiom 2: Length(a_str) == 0 <=> a_str == ""
+ {
+ // build LHS of iff
+ expr_ref len_str(m);
+ len_str = mk_strlen(a_str);
+ SASSERT(len_str);
+ expr_ref zero(m);
+ zero = m_autil.mk_numeral(rational(0), true);
+ SASSERT(zero);
+ expr_ref lhs(m);
+ lhs = ctx.mk_eq_atom(len_str, zero);
+ SASSERT(lhs);
+ // build RHS of iff
+ expr_ref empty_str(m);
+ empty_str = mk_string("");
+ SASSERT(empty_str);
+ expr_ref rhs(m);
+ rhs = ctx.mk_eq_atom(a_str, empty_str);
+ SASSERT(rhs);
+ // build LHS <=> RHS and assert
+ TRACE("str", tout << "string axiom 2: " << mk_ismt2_pp(lhs, m) << " <=> " << mk_ismt2_pp(rhs, m) << std::endl;);
+ literal l(mk_eq(lhs, rhs, true));
+ ctx.mark_as_relevant(l);
+ ctx.mk_th_axiom(get_id(), 1, &l);
+ }
+
+ }
}
- // check whether new_nn1 and new_nn2 are still concats
+ /*
+ * Add an axiom of the form:
+ * (lhs == rhs) -> ( Length(lhs) == Length(rhs) )
+ */
+ void theory_str::instantiate_str_eq_length_axiom(enode * lhs, enode * rhs) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
- bool n1IsConcat = u.str.is_concat(a_new_nn1);
- bool n2IsConcat = u.str.is_concat(a_new_nn2);
- if (!n1IsConcat && n2IsConcat) {
- TRACE("str", tout << "nn1_new is not a concat" << std::endl;);
- if (u.str.is_string(a_new_nn1)) {
- simplify_parent(new_nn2, new_nn1);
- }
- return;
- } else if (n1IsConcat && !n2IsConcat) {
- TRACE("str", tout << "nn2_new is not a concat" << std::endl;);
- if (u.str.is_string(a_new_nn2)) {
- simplify_parent(new_nn1, new_nn2);
- }
- return;
- } else if (!n1IsConcat && !n2IsConcat) {
- // normally this should never happen, because group_terms_by_eqc() should have pre-simplified
- // as much as possible. however, we make a defensive check here just in case
- TRACE("str", tout << "WARNING: nn1_new and nn2_new both simplify to non-concat terms" << std::endl;);
- return;
- }
+ app * a_lhs = lhs->get_owner();
+ app * a_rhs = rhs->get_owner();
- expr * v1_arg0 = a_new_nn1->get_arg(0);
- expr * v1_arg1 = a_new_nn1->get_arg(1);
- expr * v2_arg0 = a_new_nn2->get_arg(0);
- expr * v2_arg1 = a_new_nn2->get_arg(1);
+ // build premise: (lhs == rhs)
+ expr_ref premise(ctx.mk_eq_atom(a_lhs, a_rhs), m);
- if (!in_same_eqc(new_nn1, new_nn2) && (nn1 != new_nn1 || nn2 != new_nn2)) {
- int ii4 = 0;
- expr* item[3];
- if (nn1 != new_nn1) {
- item[ii4++] = ctx.mk_eq_atom(nn1, new_nn1);
- }
- if (nn2 != new_nn2) {
- item[ii4++] = ctx.mk_eq_atom(nn2, new_nn2);
- }
- item[ii4++] = ctx.mk_eq_atom(nn1, nn2);
- expr_ref premise(m.mk_and(ii4, item), m);
- expr_ref conclusion(ctx.mk_eq_atom(new_nn1, new_nn2), m);
+ // build conclusion: ( Length(lhs) == Length(rhs) )
+ expr_ref len_lhs(mk_strlen(a_lhs), m);
+ SASSERT(len_lhs);
+ expr_ref len_rhs(mk_strlen(a_rhs), m);
+ SASSERT(len_rhs);
+ expr_ref conclusion(ctx.mk_eq_atom(len_lhs, len_rhs), m);
+
+ TRACE("str", tout << "string-eq length-eq axiom: "
+ << mk_ismt2_pp(premise, m) << " -> " << mk_ismt2_pp(conclusion, m) << std::endl;);
assert_implication(premise, conclusion);
}
- // start to split both concats
- check_and_init_cut_var(v1_arg0);
- check_and_init_cut_var(v1_arg1);
- check_and_init_cut_var(v2_arg0);
- check_and_init_cut_var(v2_arg1);
+ void theory_str::instantiate_axiom_CharAt(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
- //*************************************************************
- // case 1: concat(x, y) = concat(m, n)
- //*************************************************************
- if (is_concat_eq_type1(new_nn1, new_nn2)) {
- process_concat_eq_type1(new_nn1, new_nn2);
- return;
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("str", tout << "already set up CharAt axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("str", tout << "instantiate CharAt axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref ts0(mk_str_var("ts0"), m);
+ expr_ref ts1(mk_str_var("ts1"), m);
+ expr_ref ts2(mk_str_var("ts2"), m);
+
+ expr_ref cond(m.mk_and(
+ m_autil.mk_ge(expr->get_arg(1), mk_int(0)),
+ // REWRITE for arithmetic theory:
+ // m_autil.mk_lt(expr->get_arg(1), mk_strlen(expr->get_arg(0)))
+ m.mk_not(m_autil.mk_ge(m_autil.mk_add(expr->get_arg(1), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))), mk_int(0)))
+ ), m);
+
+ expr_ref_vector and_item(m);
+ and_item.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(ts0, mk_concat(ts1, ts2))));
+ and_item.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_strlen(ts0)));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(ts1), mk_int(1)));
+
+ expr_ref thenBranch(m.mk_and(and_item.size(), and_item.c_ptr()), m);
+ expr_ref elseBranch(ctx.mk_eq_atom(ts1, mk_string("")), m);
+
+ expr_ref axiom(m.mk_ite(cond, thenBranch, elseBranch), m);
+ expr_ref reductionVar(ctx.mk_eq_atom(expr, ts1), m);
+
+ SASSERT(axiom);
+ SASSERT(reductionVar);
+
+ expr_ref finalAxiom(m.mk_and(axiom, reductionVar), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
}
- //*************************************************************
- // case 2: concat(x, y) = concat(m, "str")
- //*************************************************************
- if (is_concat_eq_type2(new_nn1, new_nn2)) {
- process_concat_eq_type2(new_nn1, new_nn2);
- return;
+ void theory_str::instantiate_axiom_prefixof(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("str", tout << "already set up prefixof axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("str", tout << "instantiate prefixof axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref ts0(mk_str_var("ts0"), m);
+ expr_ref ts1(mk_str_var("ts1"), m);
+
+ expr_ref_vector innerItems(m);
+ innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_concat(ts0, ts1)));
+ innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts0), mk_strlen(expr->get_arg(0))));
+ innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts0, expr->get_arg(0)), expr, m.mk_not(expr)));
+ expr_ref then1(m.mk_and(innerItems.size(), innerItems.c_ptr()), m);
+ SASSERT(then1);
+
+ // the top-level condition is Length(arg0) >= Length(arg1)
+ expr_ref topLevelCond(
+ m_autil.mk_ge(
+ m_autil.mk_add(
+ mk_strlen(expr->get_arg(1)), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))),
+ mk_int(0))
+ , m);
+ SASSERT(topLevelCond);
+
+ expr_ref finalAxiom(m.mk_ite(topLevelCond, then1, m.mk_not(expr)), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
}
- //*************************************************************
- // case 3: concat(x, y) = concat("str", n)
- //*************************************************************
- if (is_concat_eq_type3(new_nn1, new_nn2)) {
- process_concat_eq_type3(new_nn1, new_nn2);
- return;
+ void theory_str::instantiate_axiom_suffixof(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("str", tout << "already set up suffixof axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("str", tout << "instantiate suffixof axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref ts0(mk_str_var("ts0"), m);
+ expr_ref ts1(mk_str_var("ts1"), m);
+
+ expr_ref_vector innerItems(m);
+ innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_concat(ts0, ts1)));
+ innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts1), mk_strlen(expr->get_arg(0))));
+ innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts1, expr->get_arg(0)), expr, m.mk_not(expr)));
+ expr_ref then1(m.mk_and(innerItems.size(), innerItems.c_ptr()), m);
+ SASSERT(then1);
+
+ // the top-level condition is Length(arg0) >= Length(arg1)
+ expr_ref topLevelCond(
+ m_autil.mk_ge(
+ m_autil.mk_add(
+ mk_strlen(expr->get_arg(1)), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))),
+ mk_int(0))
+ , m);
+ SASSERT(topLevelCond);
+
+ expr_ref finalAxiom(m.mk_ite(topLevelCond, then1, m.mk_not(expr)), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
}
- //*************************************************************
- // case 4: concat("str1", y) = concat("str2", n)
- //*************************************************************
- if (is_concat_eq_type4(new_nn1, new_nn2)) {
- process_concat_eq_type4(new_nn1, new_nn2);
- return;
+ void theory_str::instantiate_axiom_Contains(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * ex = e->get_owner();
+ if (axiomatized_terms.contains(ex)) {
+ TRACE("str", tout << "already set up Contains axiom for " << mk_pp(ex, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(ex);
+
+ // quick path, because this is necessary due to rewriter behaviour
+ // at minimum it should fix z3str/concat-006.smt2
+ zstring haystackStr, needleStr;
+ if (u.str.is_string(ex->get_arg(0), haystackStr) && u.str.is_string(ex->get_arg(1), needleStr)) {
+ TRACE("str", tout << "eval constant Contains term " << mk_pp(ex, m) << std::endl;);
+ if (haystackStr.contains(needleStr)) {
+ assert_axiom(ex);
+ } else {
+ assert_axiom(m.mk_not(ex));
+ }
+ return;
+ }
+
+ { // register Contains()
+ expr * str = ex->get_arg(0);
+ expr * substr = ex->get_arg(1);
+ contains_map.push_back(ex);
+ std::pair<expr*, expr*> key = std::pair<expr*, expr*>(str, substr);
+ contain_pair_bool_map.insert(str, substr, ex);
+ contain_pair_idx_map[str].insert(key);
+ contain_pair_idx_map[substr].insert(key);
+ }
+
+ TRACE("str", tout << "instantiate Contains axiom for " << mk_pp(ex, m) << std::endl;);
+
+ expr_ref ts0(mk_str_var("ts0"), m);
+ expr_ref ts1(mk_str_var("ts1"), m);
+
+ expr_ref breakdownAssert(ctx.mk_eq_atom(ex, ctx.mk_eq_atom(ex->get_arg(0), mk_concat(ts0, mk_concat(ex->get_arg(1), ts1)))), m);
+ SASSERT(breakdownAssert);
+ assert_axiom(breakdownAssert);
}
- //*************************************************************
- // case 5: concat(x, "str1") = concat(m, "str2")
- //*************************************************************
- if (is_concat_eq_type5(new_nn1, new_nn2)) {
- process_concat_eq_type5(new_nn1, new_nn2);
- return;
- }
- //*************************************************************
- // case 6: concat("str1", y) = concat(m, "str2")
- //*************************************************************
- if (is_concat_eq_type6(new_nn1, new_nn2)) {
- process_concat_eq_type6(new_nn1, new_nn2);
- return;
+ void theory_str::instantiate_axiom_Indexof(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("str", tout << "already set up Indexof axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("str", tout << "instantiate Indexof axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref x1(mk_str_var("x1"), m);
+ expr_ref x2(mk_str_var("x2"), m);
+ expr_ref indexAst(mk_int_var("index"), m);
+
+ expr_ref condAst(mk_contains(expr->get_arg(0), expr->get_arg(1)), m);
+ SASSERT(condAst);
+
+ // -----------------------
+ // true branch
+ expr_ref_vector thenItems(m);
+ // args[0] = x1 . args[1] . x2
+ thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x1, mk_concat(expr->get_arg(1), x2))));
+ // indexAst = |x1|
+ thenItems.push_back(ctx.mk_eq_atom(indexAst, mk_strlen(x1)));
+ // args[0] = x3 . x4
+ // /\ |x3| = |x1| + |args[1]| - 1
+ // /\ ! contains(x3, args[1])
+ expr_ref x3(mk_str_var("x3"), m);
+ expr_ref x4(mk_str_var("x4"), m);
+ expr_ref tmpLen(m_autil.mk_add(indexAst, mk_strlen(expr->get_arg(1)), mk_int(-1)), m);
+ SASSERT(tmpLen);
+ thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x3, x4)));
+ thenItems.push_back(ctx.mk_eq_atom(mk_strlen(x3), tmpLen));
+ thenItems.push_back(m.mk_not(mk_contains(x3, expr->get_arg(1))));
+ expr_ref thenBranch(m.mk_and(thenItems.size(), thenItems.c_ptr()), m);
+ SASSERT(thenBranch);
+
+ // -----------------------
+ // false branch
+ expr_ref elseBranch(ctx.mk_eq_atom(indexAst, mk_int(-1)), m);
+ SASSERT(elseBranch);
+
+ expr_ref breakdownAssert(m.mk_ite(condAst, thenBranch, elseBranch), m);
+ SASSERT(breakdownAssert);
+
+ expr_ref reduceToIndex(ctx.mk_eq_atom(expr, indexAst), m);
+ SASSERT(reduceToIndex);
+
+ expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToIndex), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
}
-}
+ void theory_str::instantiate_axiom_Indexof2(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
-/*
- * Returns true if attempting to process a concat equality between lhs and rhs
- * will result in overlapping variables (false otherwise).
- */
-bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
- ast_manager & m = get_manager();
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("str", tout << "already set up Indexof2 axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
- expr_ref new_nn1(simplify_concat(lhs), m);
- expr_ref new_nn2(simplify_concat(rhs), m);
- app * a_new_nn1 = to_app(new_nn1);
- app * a_new_nn2 = to_app(new_nn2);
+ TRACE("str", tout << "instantiate Indexof2 axiom for " << mk_pp(expr, m) << std::endl;);
- bool n1IsConcat = u.str.is_concat(a_new_nn1);
- bool n2IsConcat = u.str.is_concat(a_new_nn2);
- if (!n1IsConcat && !n2IsConcat) {
- // we simplified both sides to non-concat expressions...
- return false;
+ // -------------------------------------------------------------------------------
+ // if (arg[2] >= length(arg[0])) // ite2
+ // resAst = -1
+ // else
+ // args[0] = prefix . suffix
+ // /\ indexAst = indexof(suffix, arg[1])
+ // /\ args[2] = len(prefix)
+ // /\ if (indexAst == -1) resAst = indexAst // ite3
+ // else resAst = args[2] + indexAst
+ // -------------------------------------------------------------------------------
+
+ expr_ref resAst(mk_int_var("res"), m);
+ expr_ref indexAst(mk_int_var("index"), m);
+ expr_ref prefix(mk_str_var("prefix"), m);
+ expr_ref suffix(mk_str_var("suffix"), m);
+ expr_ref prefixLen(mk_strlen(prefix), m);
+ expr_ref zeroAst(mk_int(0), m);
+ expr_ref negOneAst(mk_int(-1), m);
+
+ expr_ref ite3(m.mk_ite(
+ ctx.mk_eq_atom(indexAst, negOneAst),
+ ctx.mk_eq_atom(resAst, negOneAst),
+ ctx.mk_eq_atom(resAst, m_autil.mk_add(expr->get_arg(2), indexAst))
+ ),m);
+
+ expr_ref_vector ite2ElseItems(m);
+ ite2ElseItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(prefix, suffix)));
+ ite2ElseItems.push_back(ctx.mk_eq_atom(indexAst, mk_indexof(suffix, expr->get_arg(1))));
+ ite2ElseItems.push_back(ctx.mk_eq_atom(expr->get_arg(2), prefixLen));
+ ite2ElseItems.push_back(ite3);
+ expr_ref ite2Else(m.mk_and(ite2ElseItems.size(), ite2ElseItems.c_ptr()), m);
+ SASSERT(ite2Else);
+
+ expr_ref ite2(m.mk_ite(
+ //m_autil.mk_ge(expr->get_arg(2), mk_strlen(expr->get_arg(0))),
+ m_autil.mk_ge(m_autil.mk_add(expr->get_arg(2), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))), zeroAst),
+ ctx.mk_eq_atom(resAst, negOneAst),
+ ite2Else
+ ), m);
+ SASSERT(ite2);
+
+ expr_ref ite1(m.mk_ite(
+ //m_autil.mk_lt(expr->get_arg(2), zeroAst),
+ m.mk_not(m_autil.mk_ge(expr->get_arg(2), zeroAst)),
+ ctx.mk_eq_atom(resAst, mk_indexof(expr->get_arg(0), expr->get_arg(1))),
+ ite2
+ ), m);
+ SASSERT(ite1);
+ assert_axiom(ite1);
+
+ expr_ref reduceTerm(ctx.mk_eq_atom(expr, resAst), m);
+ SASSERT(reduceTerm);
+ assert_axiom(reduceTerm);
}
- expr * v1_arg0 = a_new_nn1->get_arg(0);
- expr * v1_arg1 = a_new_nn1->get_arg(1);
- expr * v2_arg0 = a_new_nn2->get_arg(0);
- expr * v2_arg1 = a_new_nn2->get_arg(1);
+ void theory_str::instantiate_axiom_LastIndexof(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
- TRACE("str", tout << "checking whether " << mk_pp(new_nn1, m) << " and " << mk_pp(new_nn1, m) << " might overlap." << std::endl;);
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("str", tout << "already set up LastIndexof axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
- check_and_init_cut_var(v1_arg0);
- check_and_init_cut_var(v1_arg1);
- check_and_init_cut_var(v2_arg0);
- check_and_init_cut_var(v2_arg1);
+ TRACE("str", tout << "instantiate LastIndexof axiom for " << mk_pp(expr, m) << std::endl;);
- //*************************************************************
- // case 1: concat(x, y) = concat(m, n)
- //*************************************************************
- if (is_concat_eq_type1(new_nn1, new_nn2)) {
- TRACE("str", tout << "Type 1 check." << std::endl;);
- expr * x = to_app(new_nn1)->get_arg(0);
- expr * y = to_app(new_nn1)->get_arg(1);
- expr * m = to_app(new_nn2)->get_arg(0);
- expr * n = to_app(new_nn2)->get_arg(1);
+ expr_ref x1(mk_str_var("x1"), m);
+ expr_ref x2(mk_str_var("x2"), m);
+ expr_ref indexAst(mk_int_var("index"), m);
+ expr_ref_vector items(m);
- if (has_self_cut(m, y)) {
- TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
- return true;
- } else if (has_self_cut(x, n)) {
- TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(x, tout); print_cut_var(n, tout););
- return true;
- } else {
- return false;
+ // args[0] = x1 . args[1] . x2
+ expr_ref eq1(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x1, mk_concat(expr->get_arg(1), x2))), m);
+ expr_ref arg0HasArg1(mk_contains(expr->get_arg(0), expr->get_arg(1)), m); // arg0HasArg1 = Contains(args[0], args[1])
+ items.push_back(ctx.mk_eq_atom(arg0HasArg1, eq1));
+
+
+ expr_ref condAst(arg0HasArg1, m);
+ //----------------------------
+ // true branch
+ expr_ref_vector thenItems(m);
+ thenItems.push_back(m_autil.mk_ge(indexAst, mk_int(0)));
+ // args[0] = x1 . args[1] . x2
+ // x1 doesn't contain args[1]
+ thenItems.push_back(m.mk_not(mk_contains(x2, expr->get_arg(1))));
+ thenItems.push_back(ctx.mk_eq_atom(indexAst, mk_strlen(x1)));
+
+ bool canSkip = false;
+ zstring arg1Str;
+ if (u.str.is_string(expr->get_arg(1), arg1Str)) {
+ if (arg1Str.length() == 1) {
+ canSkip = true;
+ }
+ }
+
+ if (!canSkip) {
+ // args[0] = x3 . x4 /\ |x3| = |x1| + 1 /\ ! contains(x4, args[1])
+ expr_ref x3(mk_str_var("x3"), m);
+ expr_ref x4(mk_str_var("x4"), m);
+ expr_ref tmpLen(m_autil.mk_add(indexAst, mk_int(1)), m);
+ thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x3, x4)));
+ thenItems.push_back(ctx.mk_eq_atom(mk_strlen(x3), tmpLen));
+ thenItems.push_back(m.mk_not(mk_contains(x4, expr->get_arg(1))));
+ }
+ //----------------------------
+ // else branch
+ expr_ref_vector elseItems(m);
+ elseItems.push_back(ctx.mk_eq_atom(indexAst, mk_int(-1)));
+
+ items.push_back(m.mk_ite(condAst, m.mk_and(thenItems.size(), thenItems.c_ptr()), m.mk_and(elseItems.size(), elseItems.c_ptr())));
+
+ expr_ref breakdownAssert(m.mk_and(items.size(), items.c_ptr()), m);
+ SASSERT(breakdownAssert);
+
+ expr_ref reduceToIndex(ctx.mk_eq_atom(expr, indexAst), m);
+ SASSERT(reduceToIndex);
+
+ expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToIndex), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+ }
+
+ void theory_str::instantiate_axiom_Substr(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("str", tout << "already set up Substr axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("str", tout << "instantiate Substr axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref substrBase(expr->get_arg(0), m);
+ expr_ref substrPos(expr->get_arg(1), m);
+ expr_ref substrLen(expr->get_arg(2), m);
+ SASSERT(substrBase);
+ SASSERT(substrPos);
+ SASSERT(substrLen);
+
+ expr_ref zero(m_autil.mk_numeral(rational::zero(), true), m);
+ expr_ref minusOne(m_autil.mk_numeral(rational::minus_one(), true), m);
+ SASSERT(zero);
+ SASSERT(minusOne);
+
+ expr_ref_vector argumentsValid_terms(m);
+ // pos >= 0
+ argumentsValid_terms.push_back(m_autil.mk_ge(substrPos, zero));
+ // pos < strlen(base)
+ // --> pos + -1*strlen(base) < 0
+ argumentsValid_terms.push_back(m.mk_not(m_autil.mk_ge(
+ m_autil.mk_add(substrPos, m_autil.mk_mul(minusOne, substrLen)),
+ zero)));
+ // len >= 0
+ argumentsValid_terms.push_back(m_autil.mk_ge(substrLen, zero));
+
+ expr_ref argumentsValid(mk_and(argumentsValid_terms), m);
+ SASSERT(argumentsValid);
+ ctx.internalize(argumentsValid, false);
+
+ // (pos+len) >= strlen(base)
+ // --> pos + len + -1*strlen(base) >= 0
+ expr_ref lenOutOfBounds(m_autil.mk_ge(
+ m_autil.mk_add(substrPos, substrLen, m_autil.mk_mul(minusOne, mk_strlen(substrBase))),
+ zero), m);
+ SASSERT(lenOutOfBounds);
+ ctx.internalize(argumentsValid, false);
+
+ // Case 1: pos < 0 or pos >= strlen(base) or len < 0
+ // ==> (Substr ...) = ""
+ expr_ref case1_premise(m.mk_not(argumentsValid), m);
+ SASSERT(case1_premise);
+ ctx.internalize(case1_premise, false);
+ expr_ref case1_conclusion(ctx.mk_eq_atom(expr, mk_string("")), m);
+ SASSERT(case1_conclusion);
+ ctx.internalize(case1_conclusion, false);
+ expr_ref case1(rewrite_implication(case1_premise, case1_conclusion), m);
+ SASSERT(case1);
+
+ // Case 2: (pos >= 0 and pos < strlen(base) and len >= 0) and (pos+len) >= strlen(base)
+ // ==> base = t0.t1 AND len(t0) = pos AND (Substr ...) = t1
+ expr_ref t0(mk_str_var("t0"), m);
+ expr_ref t1(mk_str_var("t1"), m);
+ expr_ref case2_conclusion(m.mk_and(
+ ctx.mk_eq_atom(substrBase, mk_concat(t0,t1)),
+ ctx.mk_eq_atom(mk_strlen(t0), substrPos),
+ ctx.mk_eq_atom(expr, t1)), m);
+ expr_ref case2(rewrite_implication(m.mk_and(argumentsValid, lenOutOfBounds), case2_conclusion), m);
+ SASSERT(case2);
+
+ // Case 3: (pos >= 0 and pos < strlen(base) and len >= 0) and (pos+len) < strlen(base)
+ // ==> base = t2.t3.t4 AND len(t2) = pos AND len(t3) = len AND (Substr ...) = t3
+ expr_ref t2(mk_str_var("t2"), m);
+ expr_ref t3(mk_str_var("t3"), m);
+ expr_ref t4(mk_str_var("t4"), m);
+ expr_ref_vector case3_conclusion_terms(m);
+ case3_conclusion_terms.push_back(ctx.mk_eq_atom(substrBase, mk_concat(t2, mk_concat(t3, t4))));
+ case3_conclusion_terms.push_back(ctx.mk_eq_atom(mk_strlen(t2), substrPos));
+ case3_conclusion_terms.push_back(ctx.mk_eq_atom(mk_strlen(t3), substrLen));
+ case3_conclusion_terms.push_back(ctx.mk_eq_atom(expr, t3));
+ expr_ref case3_conclusion(mk_and(case3_conclusion_terms), m);
+ expr_ref case3(rewrite_implication(m.mk_and(argumentsValid, m.mk_not(lenOutOfBounds)), case3_conclusion), m);
+ SASSERT(case3);
+
+ ctx.internalize(case1, false);
+ ctx.internalize(case2, false);
+ ctx.internalize(case3, false);
+
+ expr_ref finalAxiom(m.mk_and(case1, case2, case3), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+ }
+
+ void theory_str::instantiate_axiom_Replace(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * expr = e->get_owner();
+ if (axiomatized_terms.contains(expr)) {
+ TRACE("str", tout << "already set up Replace axiom for " << mk_pp(expr, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(expr);
+
+ TRACE("str", tout << "instantiate Replace axiom for " << mk_pp(expr, m) << std::endl;);
+
+ expr_ref x1(mk_str_var("x1"), m);
+ expr_ref x2(mk_str_var("x2"), m);
+ expr_ref i1(mk_int_var("i1"), m);
+ expr_ref result(mk_str_var("result"), m);
+
+ // condAst = Contains(args[0], args[1])
+ expr_ref condAst(mk_contains(expr->get_arg(0), expr->get_arg(1)), m);
+ // -----------------------
+ // true branch
+ expr_ref_vector thenItems(m);
+ // args[0] = x1 . args[1] . x2
+ thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x1, mk_concat(expr->get_arg(1), x2))));
+ // i1 = |x1|
+ thenItems.push_back(ctx.mk_eq_atom(i1, mk_strlen(x1)));
+ // args[0] = x3 . x4 /\ |x3| = |x1| + |args[1]| - 1 /\ ! contains(x3, args[1])
+ expr_ref x3(mk_str_var("x3"), m);
+ expr_ref x4(mk_str_var("x4"), m);
+ expr_ref tmpLen(m_autil.mk_add(i1, mk_strlen(expr->get_arg(1)), mk_int(-1)), m);
+ thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x3, x4)));
+ thenItems.push_back(ctx.mk_eq_atom(mk_strlen(x3), tmpLen));
+ thenItems.push_back(m.mk_not(mk_contains(x3, expr->get_arg(1))));
+ thenItems.push_back(ctx.mk_eq_atom(result, mk_concat(x1, mk_concat(expr->get_arg(2), x2))));
+ // -----------------------
+ // false branch
+ expr_ref elseBranch(ctx.mk_eq_atom(result, expr->get_arg(0)), m);
+
+ expr_ref breakdownAssert(m.mk_ite(condAst, m.mk_and(thenItems.size(), thenItems.c_ptr()), elseBranch), m);
+ SASSERT(breakdownAssert);
+
+ expr_ref reduceToResult(ctx.mk_eq_atom(expr, result), m);
+ SASSERT(reduceToResult);
+
+ expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToResult), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+ }
+
+ void theory_str::instantiate_axiom_str_to_int(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ app * ex = e->get_owner();
+ if (axiomatized_terms.contains(ex)) {
+ TRACE("str", tout << "already set up str.to-int axiom for " << mk_pp(ex, m) << std::endl;);
+ return;
+ }
+ axiomatized_terms.insert(ex);
+
+ TRACE("str", tout << "instantiate str.to-int axiom for " << mk_pp(ex, m) << std::endl;);
+
+ // let expr = (str.to-int S)
+ // axiom 1: expr >= -1
+ // axiom 2: expr = 0 <==> S = "0"
+ // axiom 3: expr >= 1 ==> len(S) > 0 AND S[0] != "0"
+
+ expr * S = ex->get_arg(0);
+ {
+ expr_ref axiom1(m_autil.mk_ge(ex, m_autil.mk_numeral(rational::minus_one(), true)), m);
+ SASSERT(axiom1);
+ assert_axiom(axiom1);
+ }
+
+ {
+ expr_ref lhs(ctx.mk_eq_atom(ex, m_autil.mk_numeral(rational::zero(), true)), m);
+ expr_ref rhs(ctx.mk_eq_atom(S, mk_string("0")), m);
+ expr_ref axiom2(ctx.mk_eq_atom(lhs, rhs), m);
+ SASSERT(axiom2);
+ assert_axiom(axiom2);
+ }
+
+ {
+ expr_ref premise(m_autil.mk_ge(ex, m_autil.mk_numeral(rational::one(), true)), m);
+ expr_ref hd(mk_str_var("hd"), m);
+ expr_ref tl(mk_str_var("tl"), m);
+ expr_ref conclusion1(ctx.mk_eq_atom(S, mk_concat(hd, tl)), m);
+ expr_ref conclusion2(ctx.mk_eq_atom(mk_strlen(hd), m_autil.mk_numeral(rational::one(), true)), m);
+ expr_ref conclusion3(m.mk_not(ctx.mk_eq_atom(hd, mk_string("0"))), m);
+ expr_ref conclusion(m.mk_and(conclusion1, conclusion2, conclusion3), m);
+ SASSERT(premise);
+ SASSERT(conclusion);
+ assert_implication(premise, conclusion);
}
}
- //*************************************************************
- // case 2: concat(x, y) = concat(m, "str")
- //*************************************************************
- if (is_concat_eq_type2(new_nn1, new_nn2)) {
+ void theory_str::instantiate_axiom_int_to_str(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
- expr * y = NULL;
- expr * m = NULL;
- expr * v1_arg0 = to_app(new_nn1)->get_arg(0);
- expr * v1_arg1 = to_app(new_nn1)->get_arg(1);
- expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
- expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
-
- if (u.str.is_string(v1_arg1) && !u.str.is_string(v2_arg1)) {
- m = v1_arg0;
- y = v2_arg1;
- } else {
- m = v2_arg0;
- y = v1_arg1;
+ app * ex = e->get_owner();
+ if (axiomatized_terms.contains(ex)) {
+ TRACE("str", tout << "already set up str.from-int axiom for " << mk_pp(ex, m) << std::endl;);
+ return;
}
+ axiomatized_terms.insert(ex);
- if (has_self_cut(m, y)) {
- TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
- return true;
- } else {
- return false;
+ TRACE("str", tout << "instantiate str.from-int axiom for " << mk_pp(ex, m) << std::endl;);
+
+ // axiom 1: N < 0 <==> (str.from-int N) = ""
+ expr * N = ex->get_arg(0);
+ {
+ expr_ref axiom1_lhs(m.mk_not(m_autil.mk_ge(N, m_autil.mk_numeral(rational::zero(), true))), m);
+ expr_ref axiom1_rhs(ctx.mk_eq_atom(ex, mk_string("")), m);
+ expr_ref axiom1(ctx.mk_eq_atom(axiom1_lhs, axiom1_rhs), m);
+ SASSERT(axiom1);
+ assert_axiom(axiom1);
}
}
- //*************************************************************
- // case 3: concat(x, y) = concat("str", n)
- //*************************************************************
- if (is_concat_eq_type3(new_nn1, new_nn2)) {
- expr * v1_arg0 = to_app(new_nn1)->get_arg(0);
- expr * v1_arg1 = to_app(new_nn1)->get_arg(1);
- expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
- expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
+ expr * theory_str::mk_RegexIn(expr * str, expr * regexp) {
+ app * regexIn = u.re.mk_in_re(str, regexp);
+ // immediately force internalization so that axiom setup does not fail
+ get_context().internalize(regexIn, false);
+ set_up_axioms(regexIn);
+ return regexIn;
+ }
- expr * x = NULL;
- expr * n = NULL;
-
- if (u.str.is_string(v1_arg0) && !u.str.is_string(v2_arg0)) {
- n = v1_arg1;
- x = v2_arg0;
- } else {
- n = v2_arg1;
- x = v1_arg0;
+ static zstring str2RegexStr(zstring str) {
+ zstring res("");
+ int len = str.length();
+ for (int i = 0; i < len; i++) {
+ char nc = str[i];
+ // 12 special chars
+ if (nc == '\\' || nc == '^' || nc == '$' || nc == '.' || nc == '|' || nc == '?'
+ || nc == '*' || nc == '+' || nc == '(' || nc == ')' || nc == '[' || nc == '{') {
+ res = res + zstring("\\");
+ }
+ char tmp[2] = {(char)str[i], '\0'};
+ res = res + zstring(tmp);
}
- if (has_self_cut(x, n)) {
- TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(x, tout); print_cut_var(n, tout););
- return true;
+ return res;
+ }
+
+ zstring theory_str::get_std_regex_str(expr * regex) {
+ app * a_regex = to_app(regex);
+ if (u.re.is_to_re(a_regex)) {
+ expr * regAst = a_regex->get_arg(0);
+ zstring regAstVal;
+ u.str.is_string(regAst, regAstVal);
+ zstring regStr = str2RegexStr(regAstVal);
+ return regStr;
+ } else if (u.re.is_concat(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ expr * reg2Ast = a_regex->get_arg(1);
+ zstring reg1Str = get_std_regex_str(reg1Ast);
+ zstring reg2Str = get_std_regex_str(reg2Ast);
+ return zstring("(") + reg1Str + zstring(")(") + reg2Str + zstring(")");
+ } else if (u.re.is_union(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ expr * reg2Ast = a_regex->get_arg(1);
+ zstring reg1Str = get_std_regex_str(reg1Ast);
+ zstring reg2Str = get_std_regex_str(reg2Ast);
+ return zstring("(") + reg1Str + zstring(")|(") + reg2Str + zstring(")");
+ } else if (u.re.is_star(a_regex)) {
+ expr * reg1Ast = a_regex->get_arg(0);
+ zstring reg1Str = get_std_regex_str(reg1Ast);
+ return zstring("(") + reg1Str + zstring(")*");
+ } else if (u.re.is_range(a_regex)) {
+ expr * range1 = a_regex->get_arg(0);
+ expr * range2 = a_regex->get_arg(1);
+ zstring range1val, range2val;
+ u.str.is_string(range1, range1val);
+ u.str.is_string(range2, range2val);
+ return zstring("[") + range1val + zstring("-") + range2val + zstring("]");
} else {
- return false;
+ TRACE("str", tout << "BUG: unrecognized regex term " << mk_pp(regex, get_manager()) << std::endl;);
+ UNREACHABLE(); return zstring("");
}
}
- //*************************************************************
- // case 4: concat("str1", y) = concat("str2", n)
- //*************************************************************
- if (is_concat_eq_type4(new_nn1, new_nn2)) {
- // This case can never result in an overlap.
- return false;
- }
+ void theory_str::instantiate_axiom_RegexIn(enode * e) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
- //*************************************************************
- // case 5: concat(x, "str1") = concat(m, "str2")
- //*************************************************************
- if (is_concat_eq_type5(new_nn1, new_nn2)) {
- // This case can never result in an overlap.
- return false;
- }
- //*************************************************************
- // case 6: concat("str1", y) = concat(m, "str2")
- //*************************************************************
- if (is_concat_eq_type6(new_nn1, new_nn2)) {
- expr * v1_arg0 = to_app(new_nn1)->get_arg(0);
- expr * v1_arg1 = to_app(new_nn1)->get_arg(1);
- expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
- expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
-
- expr * y = NULL;
- expr * m = NULL;
-
- if (u.str.is_string(v1_arg0)) {
- y = v1_arg1;
- m = v2_arg0;
- } else {
- y = v2_arg1;
- m = v1_arg0;
+ app * ex = e->get_owner();
+ if (axiomatized_terms.contains(ex)) {
+ TRACE("str", tout << "already set up RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
+ return;
}
- if (has_self_cut(m, y)) {
- TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
- return true;
+ axiomatized_terms.insert(ex);
+
+ TRACE("str", tout << "instantiate RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
+
+ {
+ zstring regexStr = get_std_regex_str(ex->get_arg(1));
+ std::pair<expr*, zstring> key1(ex->get_arg(0), regexStr);
+ // skip Z3str's map check, because we already check if we set up axioms on this term
+ regex_in_bool_map[key1] = ex;
+ regex_in_var_reg_str_map[ex->get_arg(0)].insert(regexStr);
+ }
+
+ expr_ref str(ex->get_arg(0), m);
+ app * regex = to_app(ex->get_arg(1));
+
+ if (u.re.is_to_re(regex)) {
+ expr_ref rxStr(regex->get_arg(0), m);
+ // want to assert 'expr IFF (str == rxStr)'
+ expr_ref rhs(ctx.mk_eq_atom(str, rxStr), m);
+ expr_ref finalAxiom(m.mk_iff(ex, rhs), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+ TRACE("str", tout << "set up Str2Reg: (RegexIn " << mk_pp(str, m) << " " << mk_pp(regex, m) << ")" << std::endl;);
+ } else if (u.re.is_concat(regex)) {
+ expr_ref var1(mk_regex_rep_var(), m);
+ expr_ref var2(mk_regex_rep_var(), m);
+ expr_ref rhs(mk_concat(var1, var2), m);
+ expr_ref rx1(regex->get_arg(0), m);
+ expr_ref rx2(regex->get_arg(1), m);
+ expr_ref var1InRegex1(mk_RegexIn(var1, rx1), m);
+ expr_ref var2InRegex2(mk_RegexIn(var2, rx2), m);
+
+ expr_ref_vector items(m);
+ items.push_back(var1InRegex1);
+ items.push_back(var2InRegex2);
+ items.push_back(ctx.mk_eq_atom(ex, ctx.mk_eq_atom(str, rhs)));
+
+ expr_ref finalAxiom(mk_and(items), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+ } else if (u.re.is_union(regex)) {
+ expr_ref var1(mk_regex_rep_var(), m);
+ expr_ref var2(mk_regex_rep_var(), m);
+ expr_ref orVar(m.mk_or(ctx.mk_eq_atom(str, var1), ctx.mk_eq_atom(str, var2)), m);
+ expr_ref regex1(regex->get_arg(0), m);
+ expr_ref regex2(regex->get_arg(1), m);
+ expr_ref var1InRegex1(mk_RegexIn(var1, regex1), m);
+ expr_ref var2InRegex2(mk_RegexIn(var2, regex2), m);
+ expr_ref_vector items(m);
+ items.push_back(var1InRegex1);
+ items.push_back(var2InRegex2);
+ items.push_back(ctx.mk_eq_atom(ex, orVar));
+ assert_axiom(mk_and(items));
+ } else if (u.re.is_star(regex)) {
+ // slightly more complex due to the unrolling step.
+ expr_ref regex1(regex->get_arg(0), m);
+ expr_ref unrollCount(mk_unroll_bound_var(), m);
+ expr_ref unrollFunc(mk_unroll(regex1, unrollCount), m);
+ expr_ref_vector items(m);
+ items.push_back(ctx.mk_eq_atom(ex, ctx.mk_eq_atom(str, unrollFunc)));
+ items.push_back(ctx.mk_eq_atom(ctx.mk_eq_atom(unrollCount, mk_int(0)), ctx.mk_eq_atom(unrollFunc, mk_string(""))));
+ expr_ref finalAxiom(mk_and(items), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
+ } else if (u.re.is_range(regex)) {
+ // (re.range "A" "Z") unfolds to (re.union "A" "B" ... "Z");
+ // we rewrite to expr IFF (str = "A" or str = "B" or ... or str = "Z")
+ expr_ref lo(regex->get_arg(0), m);
+ expr_ref hi(regex->get_arg(1), m);
+ zstring str_lo, str_hi;
+ SASSERT(u.str.is_string(lo));
+ SASSERT(u.str.is_string(hi));
+ u.str.is_string(lo, str_lo);
+ u.str.is_string(hi, str_hi);
+ SASSERT(str_lo.length() == 1);
+ SASSERT(str_hi.length() == 1);
+ unsigned int c1 = str_lo[0];
+ unsigned int c2 = str_hi[0];
+ if (c1 > c2) {
+ // exchange
+ unsigned int tmp = c1;
+ c1 = c2;
+ c2 = tmp;
+ }
+ expr_ref_vector range_cases(m);
+ for (unsigned int ch = c1; ch <= c2; ++ch) {
+ zstring s_ch(ch);
+ expr_ref rhs(ctx.mk_eq_atom(str, u.str.mk_string(s_ch)), m);
+ range_cases.push_back(rhs);
+ }
+ expr_ref rhs(mk_or(range_cases), m);
+ expr_ref finalAxiom(m.mk_iff(ex, rhs), m);
+ SASSERT(finalAxiom);
+ assert_axiom(finalAxiom);
} else {
- return false;
+ TRACE("str", tout << "ERROR: unknown regex expression " << mk_pp(regex, m) << "!" << std::endl;);
+ NOT_IMPLEMENTED_YET();
}
}
- TRACE("str", tout << "warning: unrecognized concat case" << std::endl;);
- return false;
-}
+ void theory_str::attach_new_th_var(enode * n) {
+ context & ctx = get_context();
+ theory_var v = mk_var(n);
+ ctx.attach_th_var(n, this, v);
+ TRACE("str", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := v#" << v << std::endl;);
+ }
-/*************************************************************
- * Type 1: concat(x, y) = concat(m, n)
- * x, y, m and n all variables
- *************************************************************/
-bool theory_str::is_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
- expr * x = to_app(concatAst1)->get_arg(0);
- expr * y = to_app(concatAst1)->get_arg(1);
- expr * m = to_app(concatAst2)->get_arg(0);
- expr * n = to_app(concatAst2)->get_arg(1);
+ void theory_str::reset_eh() {
+ TRACE("str", tout << "resetting" << std::endl;);
+ m_trail_stack.reset();
- if (!u.str.is_string(x) && !u.str.is_string(y) && !u.str.is_string(m) && !u.str.is_string(n)) {
+ m_basicstr_axiom_todo.reset();
+ m_str_eq_todo.reset();
+ m_concat_axiom_todo.reset();
+ pop_scope_eh(get_context().get_scope_level());
+ }
+
+ /*
+ * Check equality among equivalence class members of LHS and RHS
+ * to discover an incorrect LHS == RHS.
+ * For example, if we have y2 == "str3"
+ * and the equivalence classes are
+ * { y2, (Concat ce m2) }
+ * { "str3", (Concat abc x2) }
+ * then y2 can't be equal to "str3".
+ * Then add an assertion: (y2 == (Concat ce m2)) AND ("str3" == (Concat abc x2)) -> (y2 != "str3")
+ */
+ bool theory_str::new_eq_check(expr * lhs, expr * rhs) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ // skip this check if we defer consistency checking, as we can do it for every EQC in final check
+ if (!opt_DeferEQCConsistencyCheck) {
+ check_concat_len_in_eqc(lhs);
+ check_concat_len_in_eqc(rhs);
+ }
+
+ // Now we iterate over all pairs of terms across both EQCs
+ // and check whether we can show that any pair of distinct terms
+ // cannot possibly be equal.
+ // If that's the case, we assert an axiom to that effect and stop.
+
+ expr * eqc_nn1 = lhs;
+ do {
+ expr * eqc_nn2 = rhs;
+ do {
+ TRACE("str", tout << "checking whether " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " can be equal" << std::endl;);
+ // inconsistency check: value
+ if (!can_two_nodes_eq(eqc_nn1, eqc_nn2)) {
+ TRACE("str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " cannot be equal to " << mk_pp(eqc_nn2, m) << std::endl;);
+ expr_ref to_assert(m.mk_not(ctx.mk_eq_atom(eqc_nn1, eqc_nn2)), m);
+ assert_axiom(to_assert);
+ // this shouldn't use the integer theory at all, so we don't allow the option of quick-return
+ return false;
+ }
+ if (!check_length_consistency(eqc_nn1, eqc_nn2)) {
+ TRACE("str", tout << "inconsistency detected: " << mk_pp(eqc_nn1, m) << " and " << mk_pp(eqc_nn2, m) << " have inconsistent lengths" << std::endl;);
+ if (opt_NoQuickReturn_IntegerTheory){
+ TRACE("str", tout << "continuing in new_eq_check() due to opt_NoQuickReturn_IntegerTheory" << std::endl;);
+ } else {
+ return false;
+ }
+ }
+ eqc_nn2 = get_eqc_next(eqc_nn2);
+ } while (eqc_nn2 != rhs);
+ eqc_nn1 = get_eqc_next(eqc_nn1);
+ } while (eqc_nn1 != lhs);
+
+ if (!contains_map.empty()) {
+ check_contain_in_new_eq(lhs, rhs);
+ }
+
+ if (!regex_in_bool_map.empty()) {
+ TRACE("str", tout << "checking regex consistency" << std::endl;);
+ check_regex_in(lhs, rhs);
+ }
+
+ // okay, all checks here passed
return true;
- } else {
+ }
+
+ // support for user_smt_theory-style EQC handling
+
+ app * theory_str::get_ast(theory_var i) {
+ return get_enode(i)->get_owner();
+ }
+
+ theory_var theory_str::get_var(expr * n) const {
+ if (!is_app(n)) {
+ return null_theory_var;
+ }
+ context & ctx = get_context();
+ if (ctx.e_internalized(to_app(n))) {
+ enode * e = ctx.get_enode(to_app(n));
+ return e->get_th_var(get_id());
+ }
+ return null_theory_var;
+ }
+
+ // simulate Z3_theory_get_eqc_next()
+ expr * theory_str::get_eqc_next(expr * n) {
+ theory_var v = get_var(n);
+ if (v != null_theory_var) {
+ theory_var r = m_find.next(v);
+ return get_ast(r);
+ }
+ return n;
+ }
+
+ void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts) {
+ context & ctx = get_context();
+ expr * eqcNode = n;
+ do {
+ app * ast = to_app(eqcNode);
+ if (u.str.is_concat(ast)) {
+ expr * simConcat = simplify_concat(ast);
+ if (simConcat != ast) {
+ if (u.str.is_concat(to_app(simConcat))) {
+ concats.insert(simConcat);
+ } else {
+ if (u.str.is_string(simConcat)) {
+ consts.insert(simConcat);
+ } else {
+ vars.insert(simConcat);
+ }
+ }
+ } else {
+ concats.insert(simConcat);
+ }
+ } else if (u.str.is_string(ast)) {
+ consts.insert(ast);
+ } else {
+ vars.insert(ast);
+ }
+ eqcNode = get_eqc_next(eqcNode);
+ } while (eqcNode != n);
+ }
+
+ void theory_str::get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList) {
+ app * a_node = to_app(node);
+ if (!u.str.is_concat(a_node)) {
+ nodeList.push_back(node);
+ return;
+ } else {
+ SASSERT(a_node->get_num_args() == 2);
+ expr * leftArg = a_node->get_arg(0);
+ expr * rightArg = a_node->get_arg(1);
+ get_nodes_in_concat(leftArg, nodeList);
+ get_nodes_in_concat(rightArg, nodeList);
+ }
+ }
+
+ // previously Concat() in strTheory.cpp
+ // Evaluates the concatenation (n1 . n2) with respect to
+ // the current equivalence classes of n1 and n2.
+ // Returns a constant string expression representing this concatenation
+ // if one can be determined, or NULL if this is not possible.
+ expr * theory_str::eval_concat(expr * n1, expr * n2) {
+ bool n1HasEqcValue = false;
+ bool n2HasEqcValue = false;
+ expr * v1 = get_eqc_value(n1, n1HasEqcValue);
+ expr * v2 = get_eqc_value(n2, n2HasEqcValue);
+ if (n1HasEqcValue && n2HasEqcValue) {
+ zstring n1_str, n2_str;
+ u.str.is_string(v1, n1_str);
+ u.str.is_string(v2, n2_str);
+ zstring result = n1_str + n2_str;
+ return mk_string(result);
+ } else if (n1HasEqcValue && !n2HasEqcValue) {
+ zstring v1_str;
+ u.str.is_string(v1, v1_str);
+ if (v1_str.empty()) {
+ return n2;
+ }
+ } else if (n2HasEqcValue && !n1HasEqcValue) {
+ zstring v2_str;
+ u.str.is_string(v2, v2_str);
+ if (v2_str.empty()) {
+ return n1;
+ }
+ }
+ // give up
+ return NULL;
+ }
+
+ static inline std::string rational_to_string_if_exists(const rational & x, bool x_exists) {
+ if (x_exists) {
+ return x.to_string();
+ } else {
+ return "?";
+ }
+ }
+
+ /*
+ * The inputs:
+ * ~ nn: non const node
+ * ~ eq_str: the equivalent constant string of nn
+ * Iterate the parent of all eqc nodes of nn, looking for:
+ * ~ concat node
+ * to see whether some concat nodes can be simplified.
+ */
+ void theory_str::simplify_parent(expr * nn, expr * eq_str) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ TRACE("str", tout << "simplifying parents of " << mk_ismt2_pp(nn, m)
+ << " with respect to " << mk_ismt2_pp(eq_str, m) << std::endl;);
+
+ ctx.internalize(nn, false);
+
+ zstring eq_strValue;
+ u.str.is_string(eq_str, eq_strValue);
+ expr * n_eqNode = nn;
+ do {
+ enode * n_eq_enode = ctx.get_enode(n_eqNode);
+ TRACE("str", tout << "considering all parents of " << mk_ismt2_pp(n_eqNode, m) << std::endl
+ << "associated n_eq_enode has " << n_eq_enode->get_num_parents() << " parents" << std::endl;);
+
+ // the goal of this next bit is to avoid dereferencing a bogus e_parent in the following loop.
+ // what I imagine is causing this bug is that, for example, we examine some parent, we add an axiom that involves it,
+ // and the parent_it iterator becomes invalidated, because we indirectly modified the container that we're iterating over.
+
+ enode_vector current_parents;
+ for (enode_vector::const_iterator parent_it = n_eq_enode->begin_parents(); parent_it != n_eq_enode->end_parents(); parent_it++) {
+ current_parents.insert(*parent_it);
+ }
+
+ for (enode_vector::iterator parent_it = current_parents.begin(); parent_it != current_parents.end(); ++parent_it) {
+ enode * e_parent = *parent_it;
+ SASSERT(e_parent != NULL);
+
+ app * a_parent = e_parent->get_owner();
+ TRACE("str", tout << "considering parent " << mk_ismt2_pp(a_parent, m) << std::endl;);
+
+ if (u.str.is_concat(a_parent)) {
+ expr * arg0 = a_parent->get_arg(0);
+ expr * arg1 = a_parent->get_arg(1);
+
+ rational parentLen;
+ bool parentLen_exists = get_len_value(a_parent, parentLen);
+
+ if (arg0 == n_eq_enode->get_owner()) {
+ rational arg0Len, arg1Len;
+ bool arg0Len_exists = get_len_value(eq_str, arg0Len);
+ bool arg1Len_exists = get_len_value(arg1, arg1Len);
+
+ TRACE("str",
+ tout << "simplify_parent #1:" << std::endl
+ << "* parent = " << mk_ismt2_pp(a_parent, m) << std::endl
+ << "* |parent| = " << rational_to_string_if_exists(parentLen, parentLen_exists) << std::endl
+ << "* |arg0| = " << rational_to_string_if_exists(arg0Len, arg0Len_exists) << std::endl
+ << "* |arg1| = " << rational_to_string_if_exists(arg1Len, arg1Len_exists) << std::endl;
+ );
+
+ if (parentLen_exists && !arg1Len_exists) {
+ TRACE("str", tout << "make up len for arg1" << std::endl;);
+ expr_ref implyL11(m.mk_and(ctx.mk_eq_atom(mk_strlen(a_parent), mk_int(parentLen)),
+ ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0Len))), m);
+ rational makeUpLenArg1 = parentLen - arg0Len;
+ if (makeUpLenArg1.is_nonneg()) {
+ expr_ref implyR11(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(makeUpLenArg1)), m);
+ assert_implication(implyL11, implyR11);
+ } else {
+ expr_ref neg(m.mk_not(implyL11), m);
+ assert_axiom(neg);
+ }
+ }
+
+ // (Concat n_eqNode arg1) /\ arg1 has eq const
+
+ expr * concatResult = eval_concat(eq_str, arg1);
+ if (concatResult != NULL) {
+ bool arg1HasEqcValue = false;
+ expr * arg1Value = get_eqc_value(arg1, arg1HasEqcValue);
+ expr_ref implyL(m);
+ if (arg1 != arg1Value) {
+ expr_ref eq_ast1(m);
+ eq_ast1 = ctx.mk_eq_atom(n_eqNode, eq_str);
+ SASSERT(eq_ast1);
+
+ expr_ref eq_ast2(m);
+ eq_ast2 = ctx.mk_eq_atom(arg1, arg1Value);
+ SASSERT(eq_ast2);
+ implyL = m.mk_and(eq_ast1, eq_ast2);
+ } else {
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ }
+
+
+ if (!in_same_eqc(a_parent, concatResult)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, concatResult);
+ SASSERT(implyR);
+
+ assert_implication(implyL, implyR);
+ }
+ } else if (u.str.is_concat(to_app(n_eqNode))) {
+ expr_ref simpleConcat(m);
+ simpleConcat = mk_concat(eq_str, arg1);
+ if (!in_same_eqc(a_parent, simpleConcat)) {
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ SASSERT(implyL);
+
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, simpleConcat);
+ SASSERT(implyR);
+ assert_implication(implyL, implyR);
+ }
+ }
+ } // if (arg0 == n_eq_enode->get_owner())
+
+ if (arg1 == n_eq_enode->get_owner()) {
+ rational arg0Len, arg1Len;
+ bool arg0Len_exists = get_len_value(arg0, arg0Len);
+ bool arg1Len_exists = get_len_value(eq_str, arg1Len);
+
+ TRACE("str",
+ tout << "simplify_parent #2:" << std::endl
+ << "* parent = " << mk_ismt2_pp(a_parent, m) << std::endl
+ << "* |parent| = " << rational_to_string_if_exists(parentLen, parentLen_exists) << std::endl
+ << "* |arg0| = " << rational_to_string_if_exists(arg0Len, arg0Len_exists) << std::endl
+ << "* |arg1| = " << rational_to_string_if_exists(arg1Len, arg1Len_exists) << std::endl;
+ );
+ if (parentLen_exists && !arg0Len_exists) {
+ TRACE("str", tout << "make up len for arg0" << std::endl;);
+ expr_ref implyL11(m.mk_and(ctx.mk_eq_atom(mk_strlen(a_parent), mk_int(parentLen)),
+ ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len))), m);
+ rational makeUpLenArg0 = parentLen - arg1Len;
+ if (makeUpLenArg0.is_nonneg()) {
+ expr_ref implyR11(ctx.mk_eq_atom(mk_strlen(arg0), mk_int(makeUpLenArg0)), m);
+ assert_implication(implyL11, implyR11);
+ } else {
+ expr_ref neg(m.mk_not(implyL11), m);
+ assert_axiom(neg);
+ }
+ }
+
+ // (Concat arg0 n_eqNode) /\ arg0 has eq const
+
+ expr * concatResult = eval_concat(arg0, eq_str);
+ if (concatResult != NULL) {
+ bool arg0HasEqcValue = false;
+ expr * arg0Value = get_eqc_value(arg0, arg0HasEqcValue);
+ expr_ref implyL(m);
+ if (arg0 != arg0Value) {
+ expr_ref eq_ast1(m);
+ eq_ast1 = ctx.mk_eq_atom(n_eqNode, eq_str);
+ SASSERT(eq_ast1);
+ expr_ref eq_ast2(m);
+ eq_ast2 = ctx.mk_eq_atom(arg0, arg0Value);
+ SASSERT(eq_ast2);
+
+ implyL = m.mk_and(eq_ast1, eq_ast2);
+ } else {
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ }
+
+ if (!in_same_eqc(a_parent, concatResult)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, concatResult);
+ SASSERT(implyR);
+
+ assert_implication(implyL, implyR);
+ }
+ } else if (u.str.is_concat(to_app(n_eqNode))) {
+ expr_ref simpleConcat(m);
+ simpleConcat = mk_concat(arg0, eq_str);
+ if (!in_same_eqc(a_parent, simpleConcat)) {
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ SASSERT(implyL);
+
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, simpleConcat);
+ SASSERT(implyR);
+ assert_implication(implyL, implyR);
+ }
+ }
+ } // if (arg1 == n_eq_enode->get_owner
+
+
+ //---------------------------------------------------------
+ // Case (2-1) begin: (Concat n_eqNode (Concat str var))
+ if (arg0 == n_eqNode && u.str.is_concat(to_app(arg1))) {
+ app * a_arg1 = to_app(arg1);
+ TRACE("str", tout << "simplify_parent #3" << std::endl;);
+ expr * r_concat_arg0 = a_arg1->get_arg(0);
+ if (u.str.is_string(r_concat_arg0)) {
+ expr * combined_str = eval_concat(eq_str, r_concat_arg0);
+ SASSERT(combined_str);
+ expr * r_concat_arg1 = a_arg1->get_arg(1);
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ expr * simplifiedAst = mk_concat(combined_str, r_concat_arg1);
+ if (!in_same_eqc(a_parent, simplifiedAst)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, simplifiedAst);
+ assert_implication(implyL, implyR);
+ }
+ }
+ }
+ // Case (2-1) end: (Concat n_eqNode (Concat str var))
+ //---------------------------------------------------------
+
+
+ //---------------------------------------------------------
+ // Case (2-2) begin: (Concat (Concat var str) n_eqNode)
+ if (u.str.is_concat(to_app(arg0)) && arg1 == n_eqNode) {
+ app * a_arg0 = to_app(arg0);
+ TRACE("str", tout << "simplify_parent #4" << std::endl;);
+ expr * l_concat_arg1 = a_arg0->get_arg(1);
+ if (u.str.is_string(l_concat_arg1)) {
+ expr * combined_str = eval_concat(l_concat_arg1, eq_str);
+ SASSERT(combined_str);
+ expr * l_concat_arg0 = a_arg0->get_arg(0);
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ expr * simplifiedAst = mk_concat(l_concat_arg0, combined_str);
+ if (!in_same_eqc(a_parent, simplifiedAst)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(a_parent, simplifiedAst);
+ assert_implication(implyL, implyR);
+ }
+ }
+ }
+ // Case (2-2) end: (Concat (Concat var str) n_eqNode)
+ //---------------------------------------------------------
+
+ // Have to look up one more layer: if the parent of the concat is another concat
+ //-------------------------------------------------
+ // Case (3-1) begin: (Concat (Concat var n_eqNode) str )
+ if (arg1 == n_eqNode) {
+ for (enode_vector::iterator concat_parent_it = e_parent->begin_parents();
+ concat_parent_it != e_parent->end_parents(); concat_parent_it++) {
+ enode * e_concat_parent = *concat_parent_it;
+ app * concat_parent = e_concat_parent->get_owner();
+ if (u.str.is_concat(concat_parent)) {
+ expr * concat_parent_arg0 = concat_parent->get_arg(0);
+ expr * concat_parent_arg1 = concat_parent->get_arg(1);
+ if (concat_parent_arg0 == a_parent && u.str.is_string(concat_parent_arg1)) {
+ TRACE("str", tout << "simplify_parent #5" << std::endl;);
+ expr * combinedStr = eval_concat(eq_str, concat_parent_arg1);
+ SASSERT(combinedStr);
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ expr * simplifiedAst = mk_concat(arg0, combinedStr);
+ if (!in_same_eqc(concat_parent, simplifiedAst)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(concat_parent, simplifiedAst);
+ assert_implication(implyL, implyR);
+ }
+ }
+ }
+ }
+ }
+ // Case (3-1) end: (Concat (Concat var n_eqNode) str )
+ // Case (3-2) begin: (Concat str (Concat n_eqNode var) )
+ if (arg0 == n_eqNode) {
+ for (enode_vector::iterator concat_parent_it = e_parent->begin_parents();
+ concat_parent_it != e_parent->end_parents(); concat_parent_it++) {
+ enode * e_concat_parent = *concat_parent_it;
+ app * concat_parent = e_concat_parent->get_owner();
+ if (u.str.is_concat(concat_parent)) {
+ expr * concat_parent_arg0 = concat_parent->get_arg(0);
+ expr * concat_parent_arg1 = concat_parent->get_arg(1);
+ if (concat_parent_arg1 == a_parent && u.str.is_string(concat_parent_arg0)) {
+ TRACE("str", tout << "simplify_parent #6" << std::endl;);
+ expr * combinedStr = eval_concat(concat_parent_arg0, eq_str);
+ SASSERT(combinedStr);
+ expr_ref implyL(m);
+ implyL = ctx.mk_eq_atom(n_eqNode, eq_str);
+ expr * simplifiedAst = mk_concat(combinedStr, arg1);
+ if (!in_same_eqc(concat_parent, simplifiedAst)) {
+ expr_ref implyR(m);
+ implyR = ctx.mk_eq_atom(concat_parent, simplifiedAst);
+ assert_implication(implyL, implyR);
+ }
+ }
+ }
+ }
+ }
+ // Case (3-2) end: (Concat str (Concat n_eqNode var) )
+ } // if is_concat(a_parent)
+ } // for parent_it : n_eq_enode->begin_parents()
+
+
+ // check next EQC member
+ n_eqNode = get_eqc_next(n_eqNode);
+ } while (n_eqNode != nn);
+ }
+
+ expr * theory_str::simplify_concat(expr * node) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ std::map<expr*, expr*> resolvedMap;
+ ptr_vector<expr> argVec;
+ get_nodes_in_concat(node, argVec);
+
+ for (unsigned i = 0; i < argVec.size(); ++i) {
+ bool vArgHasEqcValue = false;
+ expr * vArg = get_eqc_value(argVec[i], vArgHasEqcValue);
+ if (vArg != argVec[i]) {
+ resolvedMap[argVec[i]] = vArg;
+ }
+ }
+
+ if (resolvedMap.size() == 0) {
+ // no simplification possible
+ return node;
+ } else {
+ expr * resultAst = mk_string("");
+ for (unsigned i = 0; i < argVec.size(); ++i) {
+ bool vArgHasEqcValue = false;
+ expr * vArg = get_eqc_value(argVec[i], vArgHasEqcValue);
+ resultAst = mk_concat(resultAst, vArg);
+ }
+ TRACE("str", tout << mk_ismt2_pp(node, m) << " is simplified to " << mk_ismt2_pp(resultAst, m) << std::endl;);
+
+ if (in_same_eqc(node, resultAst)) {
+ TRACE("str", tout << "SKIP: both concats are already in the same equivalence class" << std::endl;);
+ } else {
+ expr_ref_vector items(m);
+ int pos = 0;
+ std::map<expr*, expr*>::iterator itor = resolvedMap.begin();
+ for (; itor != resolvedMap.end(); ++itor) {
+ items.push_back(ctx.mk_eq_atom(itor->first, itor->second));
+ pos += 1;
+ }
+ expr_ref premise(mk_and(items), m);
+ expr_ref conclusion(ctx.mk_eq_atom(node, resultAst), m);
+ assert_implication(premise, conclusion);
+ }
+ return resultAst;
+ }
+
+ }
+
+ // Modified signature of Z3str2's inferLenConcat().
+ // Returns true iff nLen can be inferred by this method
+ // (i.e. the equivalent of a len_exists flag in get_len_value()).
+
+ bool theory_str::infer_len_concat(expr * n, rational & nLen) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ expr * arg0 = to_app(n)->get_arg(0);
+ expr * arg1 = to_app(n)->get_arg(1);
+
+ rational arg0_len, arg1_len;
+ bool arg0_len_exists = get_len_value(arg0, arg0_len);
+ bool arg1_len_exists = get_len_value(arg1, arg1_len);
+ rational tmp_len;
+ bool nLen_exists = get_len_value(n, tmp_len);
+
+ if (arg0_len_exists && arg1_len_exists && !nLen_exists) {
+ expr_ref_vector l_items(m);
+ // if (mk_strlen(arg0) != mk_int(arg0_len)) {
+ {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0_len)));
+ }
+
+ // if (mk_strlen(arg1) != mk_int(arg1_len)) {
+ {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1_len)));
+ }
+
+ expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
+ rational nnLen = arg0_len + arg1_len;
+ expr_ref axr(ctx.mk_eq_atom(mk_strlen(n), mk_int(nnLen)), m);
+ TRACE("str", tout << "inferred (Length " << mk_pp(n, m) << ") = " << nnLen << std::endl;);
+ assert_implication(axl, axr);
+ nLen = nnLen;
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ void theory_str::infer_len_concat_arg(expr * n, rational len) {
+ if (len.is_neg()) {
+ return;
+ }
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr * arg0 = to_app(n)->get_arg(0);
+ expr * arg1 = to_app(n)->get_arg(1);
+ rational arg0_len, arg1_len;
+ bool arg0_len_exists = get_len_value(arg0, arg0_len);
+ bool arg1_len_exists = get_len_value(arg1, arg1_len);
+
+ expr_ref_vector l_items(m);
+ expr_ref axr(m);
+ axr.reset();
+
+ // if (mk_length(t, n) != mk_int(ctx, len)) {
+ {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(len)));
+ }
+
+ if (!arg0_len_exists && arg1_len_exists) {
+ //if (mk_length(t, arg1) != mk_int(ctx, arg1_len)) {
+ {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1_len)));
+ }
+ rational arg0Len = len - arg1_len;
+ if (arg0Len.is_nonneg()) {
+ axr = ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0Len));
+ } else {
+ // could negate
+ }
+ } else if (arg0_len_exists && !arg1_len_exists) {
+ //if (mk_length(t, arg0) != mk_int(ctx, arg0_len)) {
+ {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg0), mk_int(arg0_len)));
+ }
+ rational arg1Len = len - arg0_len;
+ if (arg1Len.is_nonneg()) {
+ axr = ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len));
+ } else {
+ // could negate
+ }
+ } else {
+
+ }
+
+ if (axr) {
+ expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
+ assert_implication(axl, axr);
+ }
+ }
+
+ void theory_str::infer_len_concat_equality(expr * nn1, expr * nn2) {
+ rational nnLen;
+ bool nnLen_exists = get_len_value(nn1, nnLen);
+ if (!nnLen_exists) {
+ nnLen_exists = get_len_value(nn2, nnLen);
+ }
+
+ // case 1:
+ // Known: a1_arg0 and a1_arg1
+ // Unknown: nn1
+
+ if (u.str.is_concat(to_app(nn1))) {
+ rational nn1ConcatLen;
+ bool nn1ConcatLen_exists = infer_len_concat(nn1, nn1ConcatLen);
+ if (nnLen_exists && nn1ConcatLen_exists) {
+ nnLen = nn1ConcatLen;
+ }
+ }
+
+ // case 2:
+ // Known: a1_arg0 and a1_arg1
+ // Unknown: nn1
+
+ if (u.str.is_concat(to_app(nn2))) {
+ rational nn2ConcatLen;
+ bool nn2ConcatLen_exists = infer_len_concat(nn2, nn2ConcatLen);
+ if (nnLen_exists && nn2ConcatLen_exists) {
+ nnLen = nn2ConcatLen;
+ }
+ }
+
+ if (nnLen_exists) {
+ if (u.str.is_concat(to_app(nn1))) {
+ infer_len_concat_arg(nn1, nnLen);
+ }
+ if (u.str.is_concat(to_app(nn2))) {
+ infer_len_concat_arg(nn2, nnLen);
+ }
+ }
+
+ /*
+ if (isConcatFunc(t, nn2)) {
+ int nn2ConcatLen = inferLenConcat(t, nn2);
+ if (nnLen == -1 && nn2ConcatLen != -1)
+ nnLen = nn2ConcatLen;
+ }
+
+ if (nnLen != -1) {
+ if (isConcatFunc(t, nn1)) {
+ inferLenConcatArg(t, nn1, nnLen);
+ }
+ if (isConcatFunc(t, nn2)) {
+ inferLenConcatArg(t, nn2, nnLen);
+ }
+ }
+ */
+ }
+
+ void theory_str::add_theory_aware_branching_info(expr * term, double priority, lbool phase) {
+ context & ctx = get_context();
+ ctx.internalize(term, false);
+ bool_var v = ctx.get_bool_var(term);
+ ctx.add_theory_aware_branching_info(v, priority, phase);
+ }
+
+ void theory_str::generate_mutual_exclusion(expr_ref_vector & terms) {
+ context & ctx = get_context();
+ // pull each literal out of the arrangement disjunction
+ literal_vector ls;
+ for (unsigned i = 0; i < terms.size(); ++i) {
+ expr * e = terms.get(i);
+ literal l = ctx.get_literal(e);
+ ls.push_back(l);
+ }
+ ctx.mk_th_case_split(ls.size(), ls.c_ptr());
+ }
+
+ void theory_str::print_cut_var(expr * node, std::ofstream & xout) {
+ ast_manager & m = get_manager();
+ xout << "Cut info of " << mk_pp(node, m) << std::endl;
+ if (cut_var_map.contains(node)) {
+ if (!cut_var_map[node].empty()) {
+ xout << "[" << cut_var_map[node].top()->level << "] ";
+ std::map<expr*, int>::iterator itor = cut_var_map[node].top()->vars.begin();
+ for (; itor != cut_var_map[node].top()->vars.end(); ++itor) {
+ xout << mk_pp(itor->first, m) << ", ";
+ }
+ xout << std::endl;
+ }
+ }
+ }
+
+ /*
+ * Handle two equivalent Concats.
+ */
+ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ app * a_nn1 = to_app(nn1);
+ SASSERT(a_nn1->get_num_args() == 2);
+ app * a_nn2 = to_app(nn2);
+ SASSERT(a_nn2->get_num_args() == 2);
+
+ expr * a1_arg0 = a_nn1->get_arg(0);
+ expr * a1_arg1 = a_nn1->get_arg(1);
+ expr * a2_arg0 = a_nn2->get_arg(0);
+ expr * a2_arg1 = a_nn2->get_arg(1);
+
+ rational a1_arg0_len, a1_arg1_len, a2_arg0_len, a2_arg1_len;
+
+ bool a1_arg0_len_exists = get_len_value(a1_arg0, a1_arg0_len);
+ bool a1_arg1_len_exists = get_len_value(a1_arg1, a1_arg1_len);
+ bool a2_arg0_len_exists = get_len_value(a2_arg0, a2_arg0_len);
+ bool a2_arg1_len_exists = get_len_value(a2_arg1, a2_arg1_len);
+
+ TRACE("str", tout << "nn1 = " << mk_ismt2_pp(nn1, m) << std::endl
+ << "nn2 = " << mk_ismt2_pp(nn2, m) << std::endl;);
+
+ TRACE("str", tout
+ << "len(" << mk_pp(a1_arg0, m) << ") = " << (a1_arg0_len_exists ? a1_arg0_len.to_string() : "?") << std::endl
+ << "len(" << mk_pp(a1_arg1, m) << ") = " << (a1_arg1_len_exists ? a1_arg1_len.to_string() : "?") << std::endl
+ << "len(" << mk_pp(a2_arg0, m) << ") = " << (a2_arg0_len_exists ? a2_arg0_len.to_string() : "?") << std::endl
+ << "len(" << mk_pp(a2_arg1, m) << ") = " << (a2_arg1_len_exists ? a2_arg1_len.to_string() : "?") << std::endl
+ << std::endl;);
+
+ infer_len_concat_equality(nn1, nn2);
+
+ if (a1_arg0 == a2_arg0) {
+ if (!in_same_eqc(a1_arg1, a2_arg1)) {
+ expr_ref premise(ctx.mk_eq_atom(nn1, nn2), m);
+ expr_ref eq1(ctx.mk_eq_atom(a1_arg1, a2_arg1), m);
+ expr_ref eq2(ctx.mk_eq_atom(mk_strlen(a1_arg1), mk_strlen(a2_arg1)), m);
+ expr_ref conclusion(m.mk_and(eq1, eq2), m);
+ assert_implication(premise, conclusion);
+ }
+ TRACE("str", tout << "SKIP: a1_arg0 == a2_arg0" << std::endl;);
+ return;
+ }
+
+ if (a1_arg1 == a2_arg1) {
+ if (!in_same_eqc(a1_arg0, a2_arg0)) {
+ expr_ref premise(ctx.mk_eq_atom(nn1, nn2), m);
+ expr_ref eq1(ctx.mk_eq_atom(a1_arg0, a2_arg0), m);
+ expr_ref eq2(ctx.mk_eq_atom(mk_strlen(a1_arg0), mk_strlen(a2_arg0)), m);
+ expr_ref conclusion(m.mk_and(eq1, eq2), m);
+ assert_implication(premise, conclusion);
+ }
+ TRACE("str", tout << "SKIP: a1_arg1 == a2_arg1" << std::endl;);
+ return;
+ }
+
+ // quick path
+
+ if (in_same_eqc(a1_arg0, a2_arg0)) {
+ if (in_same_eqc(a1_arg1, a2_arg1)) {
+ TRACE("str", tout << "SKIP: a1_arg0 =~ a2_arg0 and a1_arg1 =~ a2_arg1" << std::endl;);
+ return;
+ } else {
+ TRACE("str", tout << "quick path 1-1: a1_arg0 =~ a2_arg0" << std::endl;);
+ expr_ref premise(m.mk_and(ctx.mk_eq_atom(nn1, nn2), ctx.mk_eq_atom(a1_arg0, a2_arg0)), m);
+ expr_ref conclusion(m.mk_and(ctx.mk_eq_atom(a1_arg1, a2_arg1), ctx.mk_eq_atom(mk_strlen(a1_arg1), mk_strlen(a2_arg1))), m);
+ assert_implication(premise, conclusion);
+ return;
+ }
+ } else {
+ if (in_same_eqc(a1_arg1, a2_arg1)) {
+ TRACE("str", tout << "quick path 1-2: a1_arg1 =~ a2_arg1" << std::endl;);
+ expr_ref premise(m.mk_and(ctx.mk_eq_atom(nn1, nn2), ctx.mk_eq_atom(a1_arg1, a2_arg1)), m);
+ expr_ref conclusion(m.mk_and(ctx.mk_eq_atom(a1_arg0, a2_arg0), ctx.mk_eq_atom(mk_strlen(a1_arg0), mk_strlen(a2_arg0))), m);
+ assert_implication(premise, conclusion);
+ return;
+ }
+ }
+
+ // quick path 2-1
+ if (a1_arg0_len_exists && a2_arg0_len_exists && a1_arg0_len == a2_arg0_len) {
+ if (!in_same_eqc(a1_arg0, a2_arg0)) {
+ TRACE("str", tout << "quick path 2-1: len(nn1.arg0) == len(nn2.arg0)" << std::endl;);
+ expr_ref ax_l1(ctx.mk_eq_atom(nn1, nn2), m);
+ expr_ref ax_l2(ctx.mk_eq_atom(mk_strlen(a1_arg0), mk_strlen(a2_arg0)), m);
+ expr_ref ax_r1(ctx.mk_eq_atom(a1_arg0, a2_arg0), m);
+ expr_ref ax_r2(ctx.mk_eq_atom(a1_arg1, a2_arg1), m);
+
+ expr_ref premise(m.mk_and(ax_l1, ax_l2), m);
+ expr_ref conclusion(m.mk_and(ax_r1, ax_r2), m);
+
+ assert_implication(premise, conclusion);
+
+ if (opt_NoQuickReturn_IntegerTheory) {
+ TRACE("str", tout << "bypassing quick return from the end of this case" << std::endl;);
+ } else {
+ return;
+ }
+ }
+ }
+
+ if (a1_arg1_len_exists && a2_arg1_len_exists && a1_arg1_len == a2_arg1_len) {
+ if (!in_same_eqc(a1_arg1, a2_arg1)) {
+ TRACE("str", tout << "quick path 2-2: len(nn1.arg1) == len(nn2.arg1)" << std::endl;);
+ expr_ref ax_l1(ctx.mk_eq_atom(nn1, nn2), m);
+ expr_ref ax_l2(ctx.mk_eq_atom(mk_strlen(a1_arg1), mk_strlen(a2_arg1)), m);
+ expr_ref ax_r1(ctx.mk_eq_atom(a1_arg0, a2_arg0), m);
+ expr_ref ax_r2(ctx.mk_eq_atom(a1_arg1, a2_arg1), m);
+
+ expr_ref premise(m.mk_and(ax_l1, ax_l2), m);
+ expr_ref conclusion(m.mk_and(ax_r1, ax_r2), m);
+
+ assert_implication(premise, conclusion);
+ if (opt_NoQuickReturn_IntegerTheory) {
+ TRACE("str", tout << "bypassing quick return from the end of this case" << std::endl;);
+ } else {
+ return;
+ }
+ }
+ }
+
+ expr_ref new_nn1(simplify_concat(nn1), m);
+ expr_ref new_nn2(simplify_concat(nn2), m);
+ app * a_new_nn1 = to_app(new_nn1);
+ app * a_new_nn2 = to_app(new_nn2);
+
+ TRACE("str", tout << "new_nn1 = " << mk_ismt2_pp(new_nn1, m) << std::endl
+ << "new_nn2 = " << mk_ismt2_pp(new_nn2, m) << std::endl;);
+
+ if (new_nn1 == new_nn2) {
+ TRACE("str", tout << "equal concats, return" << std::endl;);
+ return;
+ }
+
+ if (!can_two_nodes_eq(new_nn1, new_nn2)) {
+ expr_ref detected(m.mk_not(ctx.mk_eq_atom(new_nn1, new_nn2)), m);
+ TRACE("str", tout << "inconsistency detected: " << mk_ismt2_pp(detected, m) << std::endl;);
+ assert_axiom(detected);
+ return;
+ }
+
+ // check whether new_nn1 and new_nn2 are still concats
+
+ bool n1IsConcat = u.str.is_concat(a_new_nn1);
+ bool n2IsConcat = u.str.is_concat(a_new_nn2);
+ if (!n1IsConcat && n2IsConcat) {
+ TRACE("str", tout << "nn1_new is not a concat" << std::endl;);
+ if (u.str.is_string(a_new_nn1)) {
+ simplify_parent(new_nn2, new_nn1);
+ }
+ return;
+ } else if (n1IsConcat && !n2IsConcat) {
+ TRACE("str", tout << "nn2_new is not a concat" << std::endl;);
+ if (u.str.is_string(a_new_nn2)) {
+ simplify_parent(new_nn1, new_nn2);
+ }
+ return;
+ } else if (!n1IsConcat && !n2IsConcat) {
+ // normally this should never happen, because group_terms_by_eqc() should have pre-simplified
+ // as much as possible. however, we make a defensive check here just in case
+ TRACE("str", tout << "WARNING: nn1_new and nn2_new both simplify to non-concat terms" << std::endl;);
+ return;
+ }
+
+ expr * v1_arg0 = a_new_nn1->get_arg(0);
+ expr * v1_arg1 = a_new_nn1->get_arg(1);
+ expr * v2_arg0 = a_new_nn2->get_arg(0);
+ expr * v2_arg1 = a_new_nn2->get_arg(1);
+
+ if (!in_same_eqc(new_nn1, new_nn2) && (nn1 != new_nn1 || nn2 != new_nn2)) {
+ int ii4 = 0;
+ expr* item[3];
+ if (nn1 != new_nn1) {
+ item[ii4++] = ctx.mk_eq_atom(nn1, new_nn1);
+ }
+ if (nn2 != new_nn2) {
+ item[ii4++] = ctx.mk_eq_atom(nn2, new_nn2);
+ }
+ item[ii4++] = ctx.mk_eq_atom(nn1, nn2);
+ expr_ref premise(m.mk_and(ii4, item), m);
+ expr_ref conclusion(ctx.mk_eq_atom(new_nn1, new_nn2), m);
+ assert_implication(premise, conclusion);
+ }
+
+ // start to split both concats
+ check_and_init_cut_var(v1_arg0);
+ check_and_init_cut_var(v1_arg1);
+ check_and_init_cut_var(v2_arg0);
+ check_and_init_cut_var(v2_arg1);
+
+ //*************************************************************
+ // case 1: concat(x, y) = concat(m, n)
+ //*************************************************************
+ if (is_concat_eq_type1(new_nn1, new_nn2)) {
+ process_concat_eq_type1(new_nn1, new_nn2);
+ return;
+ }
+
+ //*************************************************************
+ // case 2: concat(x, y) = concat(m, "str")
+ //*************************************************************
+ if (is_concat_eq_type2(new_nn1, new_nn2)) {
+ process_concat_eq_type2(new_nn1, new_nn2);
+ return;
+ }
+
+ //*************************************************************
+ // case 3: concat(x, y) = concat("str", n)
+ //*************************************************************
+ if (is_concat_eq_type3(new_nn1, new_nn2)) {
+ process_concat_eq_type3(new_nn1, new_nn2);
+ return;
+ }
+
+ //*************************************************************
+ // case 4: concat("str1", y) = concat("str2", n)
+ //*************************************************************
+ if (is_concat_eq_type4(new_nn1, new_nn2)) {
+ process_concat_eq_type4(new_nn1, new_nn2);
+ return;
+ }
+
+ //*************************************************************
+ // case 5: concat(x, "str1") = concat(m, "str2")
+ //*************************************************************
+ if (is_concat_eq_type5(new_nn1, new_nn2)) {
+ process_concat_eq_type5(new_nn1, new_nn2);
+ return;
+ }
+ //*************************************************************
+ // case 6: concat("str1", y) = concat(m, "str2")
+ //*************************************************************
+ if (is_concat_eq_type6(new_nn1, new_nn2)) {
+ process_concat_eq_type6(new_nn1, new_nn2);
+ return;
+ }
+
+ }
+
+ /*
+ * Returns true if attempting to process a concat equality between lhs and rhs
+ * will result in overlapping variables (false otherwise).
+ */
+ bool theory_str::will_result_in_overlap(expr * lhs, expr * rhs) {
+ ast_manager & m = get_manager();
+
+ expr_ref new_nn1(simplify_concat(lhs), m);
+ expr_ref new_nn2(simplify_concat(rhs), m);
+ app * a_new_nn1 = to_app(new_nn1);
+ app * a_new_nn2 = to_app(new_nn2);
+
+ bool n1IsConcat = u.str.is_concat(a_new_nn1);
+ bool n2IsConcat = u.str.is_concat(a_new_nn2);
+ if (!n1IsConcat && !n2IsConcat) {
+ // we simplified both sides to non-concat expressions...
+ return false;
+ }
+
+ expr * v1_arg0 = a_new_nn1->get_arg(0);
+ expr * v1_arg1 = a_new_nn1->get_arg(1);
+ expr * v2_arg0 = a_new_nn2->get_arg(0);
+ expr * v2_arg1 = a_new_nn2->get_arg(1);
+
+ TRACE("str", tout << "checking whether " << mk_pp(new_nn1, m) << " and " << mk_pp(new_nn1, m) << " might overlap." << std::endl;);
+
+ check_and_init_cut_var(v1_arg0);
+ check_and_init_cut_var(v1_arg1);
+ check_and_init_cut_var(v2_arg0);
+ check_and_init_cut_var(v2_arg1);
+
+ //*************************************************************
+ // case 1: concat(x, y) = concat(m, n)
+ //*************************************************************
+ if (is_concat_eq_type1(new_nn1, new_nn2)) {
+ TRACE("str", tout << "Type 1 check." << std::endl;);
+ expr * x = to_app(new_nn1)->get_arg(0);
+ expr * y = to_app(new_nn1)->get_arg(1);
+ expr * m = to_app(new_nn2)->get_arg(0);
+ expr * n = to_app(new_nn2)->get_arg(1);
+
+ if (has_self_cut(m, y)) {
+ TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
+ return true;
+ } else if (has_self_cut(x, n)) {
+ TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(x, tout); print_cut_var(n, tout););
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ //*************************************************************
+ // case 2: concat(x, y) = concat(m, "str")
+ //*************************************************************
+ if (is_concat_eq_type2(new_nn1, new_nn2)) {
+
+ expr * y = NULL;
+ expr * m = NULL;
+ expr * v1_arg0 = to_app(new_nn1)->get_arg(0);
+ expr * v1_arg1 = to_app(new_nn1)->get_arg(1);
+ expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
+ expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
+
+ if (u.str.is_string(v1_arg1) && !u.str.is_string(v2_arg1)) {
+ m = v1_arg0;
+ y = v2_arg1;
+ } else {
+ m = v2_arg0;
+ y = v1_arg1;
+ }
+
+ if (has_self_cut(m, y)) {
+ TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ //*************************************************************
+ // case 3: concat(x, y) = concat("str", n)
+ //*************************************************************
+ if (is_concat_eq_type3(new_nn1, new_nn2)) {
+ expr * v1_arg0 = to_app(new_nn1)->get_arg(0);
+ expr * v1_arg1 = to_app(new_nn1)->get_arg(1);
+ expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
+ expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
+
+ expr * x = NULL;
+ expr * n = NULL;
+
+ if (u.str.is_string(v1_arg0) && !u.str.is_string(v2_arg0)) {
+ n = v1_arg1;
+ x = v2_arg0;
+ } else {
+ n = v2_arg1;
+ x = v1_arg0;
+ }
+ if (has_self_cut(x, n)) {
+ TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(x, tout); print_cut_var(n, tout););
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ //*************************************************************
+ // case 4: concat("str1", y) = concat("str2", n)
+ //*************************************************************
+ if (is_concat_eq_type4(new_nn1, new_nn2)) {
+ // This case can never result in an overlap.
+ return false;
+ }
+
+ //*************************************************************
+ // case 5: concat(x, "str1") = concat(m, "str2")
+ //*************************************************************
+ if (is_concat_eq_type5(new_nn1, new_nn2)) {
+ // This case can never result in an overlap.
+ return false;
+ }
+ //*************************************************************
+ // case 6: concat("str1", y) = concat(m, "str2")
+ //*************************************************************
+ if (is_concat_eq_type6(new_nn1, new_nn2)) {
+ expr * v1_arg0 = to_app(new_nn1)->get_arg(0);
+ expr * v1_arg1 = to_app(new_nn1)->get_arg(1);
+ expr * v2_arg0 = to_app(new_nn2)->get_arg(0);
+ expr * v2_arg1 = to_app(new_nn2)->get_arg(1);
+
+ expr * y = NULL;
+ expr * m = NULL;
+
+ if (u.str.is_string(v1_arg0)) {
+ y = v1_arg1;
+ m = v2_arg0;
+ } else {
+ y = v2_arg1;
+ m = v1_arg0;
+ }
+ if (has_self_cut(m, y)) {
+ TRACE("str", tout << "Possible overlap found" << std::endl; print_cut_var(m, tout); print_cut_var(y, tout););
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ TRACE("str", tout << "warning: unrecognized concat case" << std::endl;);
return false;
}
-}
-void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
- ast_manager & mgr = get_manager();
- context & ctx = get_context();
+ /*************************************************************
+ * Type 1: concat(x, y) = concat(m, n)
+ * x, y, m and n all variables
+ *************************************************************/
+ bool theory_str::is_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+ expr * x = to_app(concatAst1)->get_arg(0);
+ expr * y = to_app(concatAst1)->get_arg(1);
+ expr * m = to_app(concatAst2)->get_arg(0);
+ expr * n = to_app(concatAst2)->get_arg(1);
- bool overlapAssumptionUsed = false;
-
- TRACE("str", tout << "process_concat_eq TYPE 1" << std::endl
- << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
- << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
- );
-
- if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
- return;
- }
- if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
- return;
- }
- expr * x = to_app(concatAst1)->get_arg(0);
- expr * y = to_app(concatAst1)->get_arg(1);
- expr * m = to_app(concatAst2)->get_arg(0);
- expr * n = to_app(concatAst2)->get_arg(1);
-
- rational x_len, y_len, m_len, n_len;
- bool x_len_exists = get_len_value(x, x_len);
- bool y_len_exists = get_len_value(y, y_len);
- bool m_len_exists = get_len_value(m, m_len);
- bool n_len_exists = get_len_value(n, n_len);
-
- int splitType = -1;
- if (x_len_exists && m_len_exists) {
- TRACE("str", tout << "length values found: x/m" << std::endl;);
- if (x_len < m_len) {
- splitType = 0;
- } else if (x_len == m_len) {
- splitType = 1;
+ if (!u.str.is_string(x) && !u.str.is_string(y) && !u.str.is_string(m) && !u.str.is_string(n)) {
+ return true;
} else {
- splitType = 2;
+ return false;
}
}
- if (splitType == -1 && y_len_exists && n_len_exists) {
- TRACE("str", tout << "length values found: y/n" << std::endl;);
- if (y_len > n_len) {
- splitType = 0;
- } else if (y_len == n_len) {
- splitType = 1;
- } else {
- splitType = 2;
+ void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+
+ bool overlapAssumptionUsed = false;
+
+ TRACE("str", tout << "process_concat_eq TYPE 1" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
+ );
+
+ if (!u.str.is_concat(to_app(concatAst1))) {
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
}
- }
+ if (!u.str.is_concat(to_app(concatAst2))) {
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
+ }
+ expr * x = to_app(concatAst1)->get_arg(0);
+ expr * y = to_app(concatAst1)->get_arg(1);
+ expr * m = to_app(concatAst2)->get_arg(0);
+ expr * n = to_app(concatAst2)->get_arg(1);
- TRACE("str", tout
- << "len(x) = " << (x_len_exists ? x_len.to_string() : "?") << std::endl
- << "len(y) = " << (y_len_exists ? y_len.to_string() : "?") << std::endl
- << "len(m) = " << (m_len_exists ? m_len.to_string() : "?") << std::endl
- << "len(n) = " << (n_len_exists ? n_len.to_string() : "?") << std::endl
- << "split type " << splitType << std::endl;
- );
+ rational x_len, y_len, m_len, n_len;
+ bool x_len_exists = get_len_value(x, x_len);
+ bool y_len_exists = get_len_value(y, y_len);
+ bool m_len_exists = get_len_value(m, m_len);
+ bool n_len_exists = get_len_value(n, n_len);
- expr * t1 = NULL;
- expr * t2 = NULL;
- expr * xorFlag = NULL;
+ int splitType = -1;
+ if (x_len_exists && m_len_exists) {
+ TRACE("str", tout << "length values found: x/m" << std::endl;);
+ if (x_len < m_len) {
+ splitType = 0;
+ } else if (x_len == m_len) {
+ splitType = 1;
+ } else {
+ splitType = 2;
+ }
+ }
- std::pair<expr*, expr*> key1(concatAst1, concatAst2);
- std::pair<expr*, expr*> key2(concatAst2, concatAst1);
+ if (splitType == -1 && y_len_exists && n_len_exists) {
+ TRACE("str", tout << "length values found: y/n" << std::endl;);
+ if (y_len > n_len) {
+ splitType = 0;
+ } else if (y_len == n_len) {
+ splitType = 1;
+ } else {
+ splitType = 2;
+ }
+ }
- // check the entries in this map to make sure they're still in scope
- // before we use them.
+ TRACE("str", tout
+ << "len(x) = " << (x_len_exists ? x_len.to_string() : "?") << std::endl
+ << "len(y) = " << (y_len_exists ? y_len.to_string() : "?") << std::endl
+ << "len(m) = " << (m_len_exists ? m_len.to_string() : "?") << std::endl
+ << "len(n) = " << (n_len_exists ? n_len.to_string() : "?") << std::endl
+ << "split type " << splitType << std::endl;
+ );
- std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
- std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
+ expr * t1 = NULL;
+ expr * t2 = NULL;
+ expr * xorFlag = NULL;
- bool entry1InScope;
- if (entry1 == varForBreakConcat.end()) {
- entry1InScope = false;
- } else {
- if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
- || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()
- /*|| internal_variable_set.find((entry1->second)[2]) == internal_variable_set.end() */) {
+ std::pair<expr*, expr*> key1(concatAst1, concatAst2);
+ std::pair<expr*, expr*> key2(concatAst2, concatAst1);
+
+ // check the entries in this map to make sure they're still in scope
+ // before we use them.
+
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
+
+ bool entry1InScope;
+ if (entry1 == varForBreakConcat.end()) {
entry1InScope = false;
} else {
- entry1InScope = true;
+ if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
+ || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()
+ /*|| internal_variable_set.find((entry1->second)[2]) == internal_variable_set.end() */) {
+ entry1InScope = false;
+ } else {
+ entry1InScope = true;
+ }
}
- }
- bool entry2InScope;
- if (entry2 == varForBreakConcat.end()) {
- entry2InScope = false;
- } else {
- if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
- || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()
- /* || internal_variable_set.find((entry2->second)[2]) == internal_variable_set.end() */) {
+ bool entry2InScope;
+ if (entry2 == varForBreakConcat.end()) {
entry2InScope = false;
} else {
- entry2InScope = true;
- }
- }
-
- TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
- << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
-
- if (!entry1InScope && !entry2InScope) {
- t1 = mk_nonempty_str_var();
- t2 = mk_nonempty_str_var();
- xorFlag = mk_internal_xor_var();
- check_and_init_cut_var(t1);
- check_and_init_cut_var(t2);
- varForBreakConcat[key1][0] = t1;
- varForBreakConcat[key1][1] = t2;
- varForBreakConcat[key1][2] = xorFlag;
- } else {
- // match found
- if (entry1InScope) {
- t1 = varForBreakConcat[key1][0];
- t2 = varForBreakConcat[key1][1];
- xorFlag = varForBreakConcat[key1][2];
- } else {
- t1 = varForBreakConcat[key2][0];
- t2 = varForBreakConcat[key2][1];
- xorFlag = varForBreakConcat[key2][2];
- }
- refresh_theory_var(t1);
- add_nonempty_constraint(t1);
- refresh_theory_var(t2);
- add_nonempty_constraint(t2);
- }
-
- // For split types 0 through 2, we can get away with providing
- // fewer split options since more length information is available.
- if (splitType == 0) {
- //--------------------------------------
- // Type 0: M cuts Y.
- // len(x) < len(m) || len(y) > len(n)
- //--------------------------------------
- expr_ref_vector ax_l_items(mgr);
- expr_ref_vector ax_r_items(mgr);
-
- ax_l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
-
- expr_ref x_t1(mk_concat(x, t1), mgr);
- expr_ref t1_n(mk_concat(t1, n), mgr);
-
- ax_r_items.push_back(ctx.mk_eq_atom(m, x_t1));
- ax_r_items.push_back(ctx.mk_eq_atom(y, t1_n));
-
- if (m_len_exists && x_len_exists) {
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
- rational m_sub_x = m_len - x_len;
- ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t1), mk_int(m_sub_x)));
- } else {
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
- rational y_sub_n = y_len - n_len;
- ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t1), mk_int(y_sub_n)));
- }
-
- expr_ref ax_l(mk_and(ax_l_items), mgr);
- expr_ref ax_r(mk_and(ax_r_items), mgr);
-
- if (!has_self_cut(m, y)) {
- // Cut Info
- add_cut_info_merge(t1, sLevel, m);
- add_cut_info_merge(t1, sLevel, y);
-
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
- assert_axiom(ax_strong);
+ if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
+ || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()
+ /* || internal_variable_set.find((entry2->second)[2]) == internal_variable_set.end() */) {
+ entry2InScope = false;
} else {
- assert_implication(ax_l, ax_r);
- }
- } else {
- loopDetected = true;
- if (m_params.m_FiniteOverlapModels) {
- expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
- assert_implication(ax_l, tester);
- add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
- } else {
- TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
-
- if (!overlapAssumptionUsed) {
- overlapAssumptionUsed = true;
- assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
- }
+ entry2InScope = true;
}
}
- } else if (splitType == 1) {
- // Type 1:
- // len(x) = len(m) || len(y) = len(n)
- expr_ref ax_l1(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
- expr_ref ax_l2(mgr.mk_or(ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)), ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n))), mgr);
- expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
- expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x,m), ctx.mk_eq_atom(y,n)), mgr);
- assert_implication(ax_l, ax_r);
- } else if (splitType == 2) {
- // Type 2: X cuts N.
- // len(x) > len(m) || len(y) < len(n)
- expr_ref m_t2(mk_concat(m, t2), mgr);
- expr_ref t2_y(mk_concat(t2, y), mgr);
- expr_ref_vector ax_l_items(mgr);
- ax_l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
+ TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
- expr_ref_vector ax_r_items(mgr);
- ax_r_items.push_back(ctx.mk_eq_atom(x, m_t2));
- ax_r_items.push_back(ctx.mk_eq_atom(t2_y, n));
-
- if (m_len_exists && x_len_exists) {
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
- rational x_sub_m = x_len - m_len;
- ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t2), mk_int(x_sub_m)));
+ if (!entry1InScope && !entry2InScope) {
+ t1 = mk_nonempty_str_var();
+ t2 = mk_nonempty_str_var();
+ xorFlag = mk_internal_xor_var();
+ check_and_init_cut_var(t1);
+ check_and_init_cut_var(t2);
+ varForBreakConcat[key1][0] = t1;
+ varForBreakConcat[key1][1] = t2;
+ varForBreakConcat[key1][2] = xorFlag;
} else {
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
- ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
- rational n_sub_y = n_len - y_len;
- ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t2), mk_int(n_sub_y)));
+ // match found
+ if (entry1InScope) {
+ t1 = varForBreakConcat[key1][0];
+ t2 = varForBreakConcat[key1][1];
+ xorFlag = varForBreakConcat[key1][2];
+ } else {
+ t1 = varForBreakConcat[key2][0];
+ t2 = varForBreakConcat[key2][1];
+ xorFlag = varForBreakConcat[key2][2];
+ }
+ refresh_theory_var(t1);
+ add_nonempty_constraint(t1);
+ refresh_theory_var(t2);
+ add_nonempty_constraint(t2);
}
- expr_ref ax_l(mk_and(ax_l_items), mgr);
- expr_ref ax_r(mk_and(ax_r_items), mgr);
+ // For split types 0 through 2, we can get away with providing
+ // fewer split options since more length information is available.
+ if (splitType == 0) {
+ //--------------------------------------
+ // Type 0: M cuts Y.
+ // len(x) < len(m) || len(y) > len(n)
+ //--------------------------------------
+ expr_ref_vector ax_l_items(mgr);
+ expr_ref_vector ax_r_items(mgr);
- if (!has_self_cut(x, n)) {
- // Cut Info
- add_cut_info_merge(t2, sLevel, x);
- add_cut_info_merge(t2, sLevel, n);
+ ax_l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ax_l, ax_r);
- }
- } else {
- loopDetected = true;
- if (m_params.m_FiniteOverlapModels) {
- expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
- assert_implication(ax_l, tester);
- add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
- } else {
- TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
-
- if (!overlapAssumptionUsed) {
- overlapAssumptionUsed = true;
- assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
- }
- }
- }
- } else if (splitType == -1) {
- // Here we don't really have a choice. We have no length information at all...
-
- // This vector will eventually contain one term for each possible arrangement we explore.
- expr_ref_vector arrangement_disjunction(mgr);
-
- // break option 1: m cuts y
- // len(x) < len(m) || len(y) > len(n)
- if (!avoidLoopCut || !has_self_cut(m, y)) {
- expr_ref_vector and_item(mgr);
- // break down option 1-1
expr_ref x_t1(mk_concat(x, t1), mgr);
expr_ref t1_n(mk_concat(t1, n), mgr);
- and_item.push_back(ctx.mk_eq_atom(m, x_t1));
- and_item.push_back(ctx.mk_eq_atom(y, t1_n));
+ ax_r_items.push_back(ctx.mk_eq_atom(m, x_t1));
+ ax_r_items.push_back(ctx.mk_eq_atom(y, t1_n));
- expr_ref x_plus_t1(m_autil.mk_add(mk_strlen(x), mk_strlen(t1)), mgr);
- and_item.push_back(ctx.mk_eq_atom(mk_strlen(m), x_plus_t1));
- // These were crashing the solver because the integer theory
- // expects a constant on the right-hand side.
- // The things we want to assert here are len(m) > len(x) and len(y) > len(n).
- // We rewrite A > B as A-B > 0 and then as not(A-B <= 0),
- // and then, *because we aren't allowed to use subtraction*,
- // as not(A + -1*B <= 0)
- and_item.push_back(
- mgr.mk_not(m_autil.mk_le(
- m_autil.mk_add(mk_strlen(m), m_autil.mk_mul(mk_int(-1), mk_strlen(x))),
- mk_int(0))) );
- and_item.push_back(
- mgr.mk_not(m_autil.mk_le(
- m_autil.mk_add(mk_strlen(y),m_autil.mk_mul(mk_int(-1), mk_strlen(n))),
- mk_int(0))) );
-
- expr_ref option1(mk_and(and_item), mgr);
- arrangement_disjunction.push_back(option1);
- add_theory_aware_branching_info(option1, 0.1, l_true);
-
- add_cut_info_merge(t1, ctx.get_scope_level(), m);
- add_cut_info_merge(t1, ctx.get_scope_level(), y);
- } else {
- loopDetected = true;
- if (m_params.m_FiniteOverlapModels) {
- expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
- arrangement_disjunction.push_back(tester);
- add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
+ if (m_len_exists && x_len_exists) {
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
+ rational m_sub_x = m_len - x_len;
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t1), mk_int(m_sub_x)));
} else {
- TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
-
- if (!overlapAssumptionUsed) {
- overlapAssumptionUsed = true;
- arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
- }
- }
- }
-
- // break option 2:
- // x = m . t2
- // n = t2 . y
- if (!avoidLoopCut || !has_self_cut(x, n)) {
- expr_ref_vector and_item(mgr);
- // break down option 1-2
- expr_ref m_t2(mk_concat(m, t2), mgr);
- expr_ref t2_y(mk_concat(t2, y), mgr);
-
- and_item.push_back(ctx.mk_eq_atom(x, m_t2));
- and_item.push_back(ctx.mk_eq_atom(n, t2_y));
-
-
- expr_ref m_plus_t2(m_autil.mk_add(mk_strlen(m), mk_strlen(t2)), mgr);
-
- and_item.push_back(ctx.mk_eq_atom(mk_strlen(x), m_plus_t2));
- // want len(x) > len(m) and len(n) > len(y)
- and_item.push_back(
- mgr.mk_not(m_autil.mk_le(
- m_autil.mk_add(mk_strlen(x), m_autil.mk_mul(mk_int(-1), mk_strlen(m))),
- mk_int(0))) );
- and_item.push_back(
- mgr.mk_not(m_autil.mk_le(
- m_autil.mk_add(mk_strlen(n), m_autil.mk_mul(mk_int(-1), mk_strlen(y))),
- mk_int(0))) );
-
- expr_ref option2(mk_and(and_item), mgr);
- arrangement_disjunction.push_back(option2);
- add_theory_aware_branching_info(option2, 0.1, l_true);
-
- add_cut_info_merge(t2, ctx.get_scope_level(), x);
- add_cut_info_merge(t2, ctx.get_scope_level(), n);
- } else {
- loopDetected = true;
- if (m_params.m_FiniteOverlapModels) {
- expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
- arrangement_disjunction.push_back(tester);
- add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
- } else {
- TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("str", {print_cut_var(x, tout); print_cut_var(n, tout);});
-
- if (!overlapAssumptionUsed) {
- overlapAssumptionUsed = true;
- arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
- }
- }
- }
-
- // option 3:
- // x = m, y = n
- if (can_two_nodes_eq(x, m) && can_two_nodes_eq(y, n)) {
- expr_ref_vector and_item(mgr);
-
- and_item.push_back(ctx.mk_eq_atom(x, m));
- and_item.push_back(ctx.mk_eq_atom(y, n));
- and_item.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)));
- and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n)));
-
- expr_ref option3(mk_and(and_item), mgr);
- arrangement_disjunction.push_back(option3);
- // prioritize this case, it is easier
- add_theory_aware_branching_info(option3, 0.5, l_true);
- }
-
- if (!arrangement_disjunction.empty()) {
- expr_ref premise(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
- expr_ref conclusion(mk_or(arrangement_disjunction), mgr);
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom(premise, conclusion), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(premise, conclusion);
- }
- // assert mutual exclusion between each branch of the arrangement
- generate_mutual_exclusion(arrangement_disjunction);
- } else {
- TRACE("str", tout << "STOP: no split option found for two EQ concats." << std::endl;);
- }
- } // (splitType == -1)
-}
-
-/*************************************************************
- * Type 2: concat(x, y) = concat(m, "str")
- *************************************************************/
-bool theory_str::is_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
- expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
- expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
- expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
- expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
-
- if ((!u.str.is_string(v1_arg0)) && u.str.is_string(v1_arg1)
- && (!u.str.is_string(v2_arg0)) && (!u.str.is_string(v2_arg1))) {
- return true;
- } else if ((!u.str.is_string(v2_arg0)) && u.str.is_string(v2_arg1)
- && (!u.str.is_string(v1_arg0)) && (!u.str.is_string(v1_arg1))) {
- return true;
- } else {
- return false;
- }
-}
-
-void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
- ast_manager & mgr = get_manager();
- context & ctx = get_context();
-
- bool overlapAssumptionUsed = false;
-
- TRACE("str", tout << "process_concat_eq TYPE 2" << std::endl
- << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
- << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
- );
-
- if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
- return;
- }
- if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
- return;
- }
-
- expr * x = NULL;
- expr * y = NULL;
- expr * strAst = NULL;
- expr * m = NULL;
-
- expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
- expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
- expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
- expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
-
- if (u.str.is_string(v1_arg1) && !u.str.is_string(v2_arg1)) {
- m = v1_arg0;
- strAst = v1_arg1;
- x = v2_arg0;
- y = v2_arg1;
- } else {
- m = v2_arg0;
- strAst = v2_arg1;
- x = v1_arg0;
- y = v1_arg1;
- }
-
- zstring strValue;
- u.str.is_string(strAst, strValue);
-
- rational x_len, y_len, m_len, str_len;
- bool x_len_exists = get_len_value(x, x_len);
- bool y_len_exists = get_len_value(y, y_len);
- bool m_len_exists = get_len_value(m, m_len);
- bool str_len_exists = true;
- str_len = rational(strValue.length());
-
- // setup
-
- expr * xorFlag = NULL;
- expr * temp1 = NULL;
- std::pair<expr*, expr*> key1(concatAst1, concatAst2);
- std::pair<expr*, expr*> key2(concatAst2, concatAst1);
-
- // check the entries in this map to make sure they're still in scope
- // before we use them.
-
- std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
- std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
-
- // prevent checking scope for the XOR term, as it's always in the same scope as the split var
-
- bool entry1InScope;
- if (entry1 == varForBreakConcat.end()) {
- entry1InScope = false;
- } else {
- if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
- /*|| internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()*/
- ) {
- entry1InScope = false;
- } else {
- entry1InScope = true;
- }
- }
-
- bool entry2InScope;
- if (entry2 == varForBreakConcat.end()) {
- entry2InScope = false;
- } else {
- if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
- /*|| internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()*/
- ) {
- entry2InScope = false;
- } else {
- entry2InScope = true;
- }
- }
-
- TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
- << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
-
-
- if (!entry1InScope && !entry2InScope) {
- temp1 = mk_nonempty_str_var();
- xorFlag = mk_internal_xor_var();
- varForBreakConcat[key1][0] = temp1;
- varForBreakConcat[key1][1] = xorFlag;
- } else {
- if (entry1InScope) {
- temp1 = varForBreakConcat[key1][0];
- xorFlag = varForBreakConcat[key1][1];
- } else if (entry2InScope) {
- temp1 = varForBreakConcat[key2][0];
- xorFlag = varForBreakConcat[key2][1];
- }
- refresh_theory_var(temp1);
- add_nonempty_constraint(temp1);
- }
-
- int splitType = -1;
- if (x_len_exists && m_len_exists) {
- if (x_len < m_len)
- splitType = 0;
- else if (x_len == m_len)
- splitType = 1;
- else
- splitType = 2;
- }
- if (splitType == -1 && y_len_exists && str_len_exists) {
- if (y_len > str_len)
- splitType = 0;
- else if (y_len == str_len)
- splitType = 1;
- else
- splitType = 2;
- }
-
- TRACE("str", tout << "Split type " << splitType << std::endl;);
-
- // Provide fewer split options when length information is available.
-
- if (splitType == 0) {
- // M cuts Y
- // | x | y |
- // | m | str |
- expr_ref temp1_strAst(mk_concat(temp1, strAst), mgr);
- if (can_two_nodes_eq(y, temp1_strAst)) {
- expr_ref_vector l_items(mgr);
- l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
-
- expr_ref_vector r_items(mgr);
- expr_ref x_temp1(mk_concat(x, temp1), mgr);
- r_items.push_back(ctx.mk_eq_atom(m, x_temp1));
- r_items.push_back(ctx.mk_eq_atom(y, temp1_strAst));
-
- if (x_len_exists && m_len_exists) {
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
- rational m_sub_x = (m_len - x_len);
- r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(m_sub_x)));
- } else {
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(strAst), mk_int(str_len)));
- rational y_sub_str = (y_len - str_len);
- r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(y_sub_str)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
+ rational y_sub_n = y_len - n_len;
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t1), mk_int(y_sub_n)));
}
- expr_ref ax_l(mk_and(l_items), mgr);
- expr_ref ax_r(mk_and(r_items), mgr);
+ expr_ref ax_l(mk_and(ax_l_items), mgr);
+ expr_ref ax_r(mk_and(ax_r_items), mgr);
- if (!avoidLoopCut || !(has_self_cut(m, y))) {
- // break down option 2-1
- add_cut_info_merge(temp1, sLevel, y);
- add_cut_info_merge(temp1, sLevel, m);
-
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ax_l, ax_r);
- }
- } else {
- loopDetected = true;
-
- if (m_params.m_FiniteOverlapModels) {
- expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
- assert_implication(ax_l, tester);
- add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
- } else {
- TRACE("str", tout << "AVOID LOOP: SKIP" << std::endl;);
- TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
-
- if (!overlapAssumptionUsed) {
- overlapAssumptionUsed = true;
- assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
- }
- }
- }
- }
- } else if (splitType == 1) {
- // | x | y |
- // | m | str |
- expr_ref ax_l1(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
- expr_ref ax_l2(mgr.mk_or(
- ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)),
- ctx.mk_eq_atom(mk_strlen(y), mk_strlen(strAst))), mgr);
- expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
- expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x, m), ctx.mk_eq_atom(y, strAst)), mgr);
- assert_implication(ax_l, ax_r);
- } else if (splitType == 2) {
- // m cut y,
- // | x | y |
- // | m | str |
- rational lenDelta;
- expr_ref_vector l_items(mgr);
- l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
- if (x_len_exists && m_len_exists) {
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
- lenDelta = x_len - m_len;
- } else {
- l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
- lenDelta = str_len - y_len;
- }
- TRACE("str",
- tout
- << "xLen? " << (x_len_exists ? "yes" : "no") << std::endl
- << "mLen? " << (m_len_exists ? "yes" : "no") << std::endl
- << "yLen? " << (y_len_exists ? "yes" : "no") << std::endl
- << "xLen = " << x_len.to_string() << std::endl
- << "yLen = " << y_len.to_string() << std::endl
- << "mLen = " << m_len.to_string() << std::endl
- << "strLen = " << str_len.to_string() << std::endl
- << "lenDelta = " << lenDelta.to_string() << std::endl
- << "strValue = \"" << strValue << "\" (len=" << strValue.length() << ")" << "\n"
- ;
- );
-
- zstring part1Str = strValue.extract(0, lenDelta.get_unsigned());
- zstring part2Str = strValue.extract(lenDelta.get_unsigned(), strValue.length() - lenDelta.get_unsigned());
-
- expr_ref prefixStr(mk_string(part1Str), mgr);
- expr_ref x_concat(mk_concat(m, prefixStr), mgr);
- expr_ref cropStr(mk_string(part2Str), mgr);
-
- if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
- expr_ref_vector r_items(mgr);
- r_items.push_back(ctx.mk_eq_atom(x, x_concat));
- r_items.push_back(ctx.mk_eq_atom(y, cropStr));
- expr_ref ax_l(mk_and(l_items), mgr);
- expr_ref ax_r(mk_and(r_items), mgr);
-
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ax_l, ax_r);
- }
- } else {
- // negate! It's impossible to split str with these lengths
- TRACE("str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
- expr_ref ax_l(mk_and(l_items), mgr);
- assert_axiom(mgr.mk_not(ax_l));
- }
- } else {
- // Split type -1: no idea about the length...
- expr_ref_vector arrangement_disjunction(mgr);
-
- expr_ref temp1_strAst(mk_concat(temp1, strAst), mgr);
-
- // m cuts y
- if (can_two_nodes_eq(y, temp1_strAst)) {
- if (!avoidLoopCut || !has_self_cut(m, y)) {
- // break down option 2-1
- expr_ref_vector and_item(mgr);
-
- expr_ref x_temp1(mk_concat(x, temp1), mgr);
- and_item.push_back(ctx.mk_eq_atom(m, x_temp1));
- and_item.push_back(ctx.mk_eq_atom(y, temp1_strAst));
-
- and_item.push_back(ctx.mk_eq_atom(mk_strlen(m),
- m_autil.mk_add(mk_strlen(x), mk_strlen(temp1))));
-
- expr_ref option1(mk_and(and_item), mgr);
- arrangement_disjunction.push_back(option1);
- add_theory_aware_branching_info(option1, 0.1, l_true);
- add_cut_info_merge(temp1, ctx.get_scope_level(), y);
- add_cut_info_merge(temp1, ctx.get_scope_level(), m);
- } else {
- loopDetected = true;
- if (m_params.m_FiniteOverlapModels) {
- expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
- arrangement_disjunction.push_back(tester);
- add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
- } else {
- TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
-
- if (!overlapAssumptionUsed) {
- overlapAssumptionUsed = true;
- arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
- }
- }
- }
- }
-
- for (unsigned int i = 0; i <= strValue.length(); ++i) {
- zstring part1Str = strValue.extract(0, i);
- zstring part2Str = strValue.extract(i, strValue.length() - i);
- expr_ref prefixStr(mk_string(part1Str), mgr);
- expr_ref x_concat(mk_concat(m, prefixStr), mgr);
- expr_ref cropStr(mk_string(part2Str), mgr);
- if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
- // break down option 2-2
- expr_ref_vector and_item(mgr);
- and_item.push_back(ctx.mk_eq_atom(x, x_concat));
- and_item.push_back(ctx.mk_eq_atom(y, cropStr));
- and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(part2Str.length())));
- expr_ref option2(mk_and(and_item), mgr);
- arrangement_disjunction.push_back(option2);
- double priority;
- // prioritize the option where y is equal to the original string
- if (i == 0) {
- priority = 0.5;
- } else {
- priority = 0.1;
- }
- add_theory_aware_branching_info(option2, priority, l_true);
- }
- }
-
- if (!arrangement_disjunction.empty()) {
- expr_ref implyR(mk_or(arrangement_disjunction), mgr);
-
- if (m_params.m_StrongArrangements) {
- expr_ref implyLHS(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
- expr_ref ax_strong(ctx.mk_eq_atom(implyLHS, implyR), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
- }
- generate_mutual_exclusion(arrangement_disjunction);
- } else {
- TRACE("str", tout << "STOP: Should not split two EQ concats." << std::endl;);
- }
- } // (splitType == -1)
-}
-
-/*************************************************************
- * Type 3: concat(x, y) = concat("str", n)
- *************************************************************/
-bool theory_str::is_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
- expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
- expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
- expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
- expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
-
- if (u.str.is_string(v1_arg0) && (!u.str.is_string(v1_arg1))
- && (!u.str.is_string(v2_arg0)) && (!u.str.is_string(v2_arg1))) {
- return true;
- } else if (u.str.is_string(v2_arg0) && (!u.str.is_string(v2_arg1))
- && (!u.str.is_string(v1_arg0)) && (!u.str.is_string(v1_arg1))) {
- return true;
- } else {
- return false;
- }
-}
-
-void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
- ast_manager & mgr = get_manager();
- context & ctx = get_context();
-
- bool overlapAssumptionUsed = false;
-
- TRACE("str", tout << "process_concat_eq TYPE 3" << std::endl
- << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
- << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
- );
-
- if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
- return;
- }
- if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
- return;
- }
-
- expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
- expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
- expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
- expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
-
- expr * x = NULL;
- expr * y = NULL;
- expr * strAst = NULL;
- expr * n = NULL;
-
- if (u.str.is_string(v1_arg0) && !u.str.is_string(v2_arg0)) {
- strAst = v1_arg0;
- n = v1_arg1;
- x = v2_arg0;
- y = v2_arg1;
- } else {
- strAst = v2_arg0;
- n = v2_arg1;
- x = v1_arg0;
- y = v1_arg1;
- }
-
- zstring strValue;
- u.str.is_string(strAst, strValue);
-
- rational x_len, y_len, str_len, n_len;
- bool x_len_exists = get_len_value(x, x_len);
- bool y_len_exists = get_len_value(y, y_len);
- str_len = rational((unsigned)(strValue.length()));
- bool n_len_exists = get_len_value(n, n_len);
-
- expr_ref xorFlag(mgr);
- expr_ref temp1(mgr);
- std::pair<expr*, expr*> key1(concatAst1, concatAst2);
- std::pair<expr*, expr*> key2(concatAst2, concatAst1);
-
- // check the entries in this map to make sure they're still in scope
- // before we use them.
-
- std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
- std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
-
- bool entry1InScope;
- if (entry1 == varForBreakConcat.end()) {
- entry1InScope = false;
- } else {
- if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
- /* || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end() */) {
- entry1InScope = false;
- } else {
- entry1InScope = true;
- }
- }
-
- bool entry2InScope;
- if (entry2 == varForBreakConcat.end()) {
- entry2InScope = false;
- } else {
- if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
- /* || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end() */) {
- entry2InScope = false;
- } else {
- entry2InScope = true;
- }
- }
-
- TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
- << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
-
-
- if (!entry1InScope && !entry2InScope) {
- temp1 = mk_nonempty_str_var();
- xorFlag = mk_internal_xor_var();
-
- varForBreakConcat[key1][0] = temp1;
- varForBreakConcat[key1][1] = xorFlag;
- } else {
- if (entry1InScope) {
- temp1 = varForBreakConcat[key1][0];
- xorFlag = varForBreakConcat[key1][1];
- } else if (varForBreakConcat.find(key2) != varForBreakConcat.end()) {
- temp1 = varForBreakConcat[key2][0];
- xorFlag = varForBreakConcat[key2][1];
- }
- refresh_theory_var(temp1);
- add_nonempty_constraint(temp1);
- }
-
-
-
- int splitType = -1;
- if (x_len_exists) {
- if (x_len < str_len)
- splitType = 0;
- else if (x_len == str_len)
- splitType = 1;
- else
- splitType = 2;
- }
- if (splitType == -1 && y_len_exists && n_len_exists) {
- if (y_len > n_len)
- splitType = 0;
- else if (y_len == n_len)
- splitType = 1;
- else
- splitType = 2;
- }
-
- TRACE("str", tout << "Split type " << splitType << std::endl;);
-
- // Provide fewer split options when length information is available.
- if (splitType == 0) {
- // | x | y |
- // | str | n |
- expr_ref_vector litems(mgr);
- litems.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
- rational prefixLen;
- if (!x_len_exists) {
- prefixLen = str_len - (y_len - n_len);
- litems.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
- litems.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
- } else {
- prefixLen = x_len;
- litems.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
- }
- zstring prefixStr = strValue.extract(0, prefixLen.get_unsigned());
- rational str_sub_prefix = str_len - prefixLen;
- zstring suffixStr = strValue.extract(prefixLen.get_unsigned(), str_sub_prefix.get_unsigned());
- expr_ref prefixAst(mk_string(prefixStr), mgr);
- expr_ref suffixAst(mk_string(suffixStr), mgr);
- expr_ref ax_l(mgr.mk_and(litems.size(), litems.c_ptr()), mgr);
-
- expr_ref suf_n_concat(mk_concat(suffixAst, n), mgr);
- if (can_two_nodes_eq(x, prefixAst) && can_two_nodes_eq(y, suf_n_concat)) {
- expr_ref_vector r_items(mgr);
- r_items.push_back(ctx.mk_eq_atom(x, prefixAst));
- r_items.push_back(ctx.mk_eq_atom(y, suf_n_concat));
-
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom(ax_l, mk_and(r_items)), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ax_l, mk_and(r_items));
- }
- } else {
- // negate! It's impossible to split str with these lengths
- TRACE("str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
- assert_axiom(mgr.mk_not(ax_l));
- }
- }
- else if (splitType == 1) {
- expr_ref ax_l1(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
- expr_ref ax_l2(mgr.mk_or(
- ctx.mk_eq_atom(mk_strlen(x), mk_strlen(strAst)),
- ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n))), mgr);
- expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
- expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x, strAst), ctx.mk_eq_atom(y, n)), mgr);
-
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ax_l, ax_r);
- }
- }
- else if (splitType == 2) {
- // | x | y |
- // | str | n |
- expr_ref_vector litems(mgr);
- litems.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
- rational tmpLen;
- if (!x_len_exists) {
- tmpLen = n_len - y_len;
- litems.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
- litems.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
- } else {
- tmpLen = x_len - str_len;
- litems.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
- }
- expr_ref ax_l(mgr.mk_and(litems.size(), litems.c_ptr()), mgr);
-
- expr_ref str_temp1(mk_concat(strAst, temp1), mgr);
- expr_ref temp1_y(mk_concat(temp1, y), mgr);
-
- if (can_two_nodes_eq(x, str_temp1)) {
- if (!avoidLoopCut || !(has_self_cut(x, n))) {
- expr_ref_vector r_items(mgr);
- r_items.push_back(ctx.mk_eq_atom(x, str_temp1));
- r_items.push_back(ctx.mk_eq_atom(n, temp1_y));
- r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(tmpLen)));
- expr_ref ax_r(mk_and(r_items), mgr);
-
- //Cut Info
- add_cut_info_merge(temp1, sLevel, x);
- add_cut_info_merge(temp1, sLevel, n);
+ if (!has_self_cut(m, y)) {
+ // Cut Info
+ add_cut_info_merge(t1, sLevel, m);
+ add_cut_info_merge(t1, sLevel, y);
if (m_params.m_StrongArrangements) {
expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
@@ -3937,82 +3112,117 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
- TRACE("str", {print_cut_var(x, tout); print_cut_var(n, tout);});
+ TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
if (!overlapAssumptionUsed) {
- overlapAssumptionUsed = true;
- assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
+ overlapAssumptionUsed = true;
+ assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
}
}
}
- }
- // else {
- // // negate! It's impossible to split str with these lengths
- // __debugPrint(logFile, "[Conflict] Negate! It's impossible to split str with these lengths @ %d.\n", __LINE__);
- // addAxiom(t, Z3_mk_not(ctx, ax_l), __LINE__);
- // }
- }
- else {
- // Split type -1. We know nothing about the length...
+ } else if (splitType == 1) {
+ // Type 1:
+ // len(x) = len(m) || len(y) = len(n)
+ expr_ref ax_l1(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref ax_l2(mgr.mk_or(ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)), ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n))), mgr);
+ expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
+ expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x,m), ctx.mk_eq_atom(y,n)), mgr);
+ assert_implication(ax_l, ax_r);
+ } else if (splitType == 2) {
+ // Type 2: X cuts N.
+ // len(x) > len(m) || len(y) < len(n)
+ expr_ref m_t2(mk_concat(m, t2), mgr);
+ expr_ref t2_y(mk_concat(t2, y), mgr);
- expr_ref_vector arrangement_disjunction(mgr);
+ expr_ref_vector ax_l_items(mgr);
+ ax_l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
- int pos = 1;
- for (unsigned int i = 0; i <= strValue.length(); i++) {
- zstring part1Str = strValue.extract(0, i);
- zstring part2Str = strValue.extract(i, strValue.length() - i);
- expr_ref cropStr(mk_string(part1Str), mgr);
- expr_ref suffixStr(mk_string(part2Str), mgr);
- expr_ref y_concat(mk_concat(suffixStr, n), mgr);
+ expr_ref_vector ax_r_items(mgr);
+ ax_r_items.push_back(ctx.mk_eq_atom(x, m_t2));
+ ax_r_items.push_back(ctx.mk_eq_atom(t2_y, n));
- if (can_two_nodes_eq(x, cropStr) && can_two_nodes_eq(y, y_concat)) {
+ if (m_len_exists && x_len_exists) {
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
+ rational x_sub_m = x_len - m_len;
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t2), mk_int(x_sub_m)));
+ } else {
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ ax_l_items.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
+ rational n_sub_y = n_len - y_len;
+ ax_r_items.push_back(ctx.mk_eq_atom(mk_strlen(t2), mk_int(n_sub_y)));
+ }
+
+ expr_ref ax_l(mk_and(ax_l_items), mgr);
+ expr_ref ax_r(mk_and(ax_r_items), mgr);
+
+ if (!has_self_cut(x, n)) {
+ // Cut Info
+ add_cut_info_merge(t2, sLevel, x);
+ add_cut_info_merge(t2, sLevel, n);
+
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, ax_r);
+ }
+ } else {
+ loopDetected = true;
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ assert_implication(ax_l, tester);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
+ } else {
+ TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
+ }
+ }
+ }
+ } else if (splitType == -1) {
+ // Here we don't really have a choice. We have no length information at all...
+
+ // This vector will eventually contain one term for each possible arrangement we explore.
+ expr_ref_vector arrangement_disjunction(mgr);
+
+ // break option 1: m cuts y
+ // len(x) < len(m) || len(y) > len(n)
+ if (!avoidLoopCut || !has_self_cut(m, y)) {
expr_ref_vector and_item(mgr);
- // break down option 3-1
- expr_ref x_eq_str(ctx.mk_eq_atom(x, cropStr), mgr);
+ // break down option 1-1
+ expr_ref x_t1(mk_concat(x, t1), mgr);
+ expr_ref t1_n(mk_concat(t1, n), mgr);
- and_item.push_back(x_eq_str); ++pos;
- and_item.push_back(ctx.mk_eq_atom(y, y_concat));
- and_item.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_strlen(cropStr))); ++pos;
+ and_item.push_back(ctx.mk_eq_atom(m, x_t1));
+ and_item.push_back(ctx.mk_eq_atom(y, t1_n));
- // and_item[pos++] = Z3_mk_eq(ctx, or_item[option], Z3_mk_eq(ctx, mk_length(t, y), mk_length(t, y_concat)));
- // adding length constraint for _ = constStr seems slowing things down.
+ expr_ref x_plus_t1(m_autil.mk_add(mk_strlen(x), mk_strlen(t1)), mgr);
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(m), x_plus_t1));
+ // These were crashing the solver because the integer theory
+ // expects a constant on the right-hand side.
+ // The things we want to assert here are len(m) > len(x) and len(y) > len(n).
+ // We rewrite A > B as A-B > 0 and then as not(A-B <= 0),
+ // and then, *because we aren't allowed to use subtraction*,
+ // as not(A + -1*B <= 0)
+ and_item.push_back(
+ mgr.mk_not(m_autil.mk_le(
+ m_autil.mk_add(mk_strlen(m), m_autil.mk_mul(mk_int(-1), mk_strlen(x))),
+ mk_int(0))) );
+ and_item.push_back(
+ mgr.mk_not(m_autil.mk_le(
+ m_autil.mk_add(mk_strlen(y),m_autil.mk_mul(mk_int(-1), mk_strlen(n))),
+ mk_int(0))) );
expr_ref option1(mk_and(and_item), mgr);
arrangement_disjunction.push_back(option1);
- double priority;
- if (i == strValue.length()) {
- priority = 0.5;
- } else {
- priority = 0.1;
- }
- add_theory_aware_branching_info(option1, priority, l_true);
- }
- }
+ add_theory_aware_branching_info(option1, 0.1, l_true);
- expr_ref strAst_temp1(mk_concat(strAst, temp1), mgr);
-
-
- //--------------------------------------------------------
- // x cut n
- //--------------------------------------------------------
- if (can_two_nodes_eq(x, strAst_temp1)) {
- if (!avoidLoopCut || !(has_self_cut(x, n))) {
- // break down option 3-2
- expr_ref_vector and_item(mgr);
-
- expr_ref temp1_y(mk_concat(temp1, y), mgr);
- and_item.push_back(ctx.mk_eq_atom(x, strAst_temp1)); ++pos;
- and_item.push_back(ctx.mk_eq_atom(n, temp1_y)); ++pos;
-
- and_item.push_back(ctx.mk_eq_atom(mk_strlen(x),
- m_autil.mk_add(mk_strlen(strAst), mk_strlen(temp1)) ) ); ++pos;
-
- expr_ref option2(mk_and(and_item), mgr);
- arrangement_disjunction.push_back(option2);
- add_theory_aware_branching_info(option2, 0.1, l_true);
-
- add_cut_info_merge(temp1, sLevel, x);
- add_cut_info_merge(temp1, sLevel, n);
+ add_cut_info_merge(t1, ctx.get_scope_level(), m);
+ add_cut_info_merge(t1, ctx.get_scope_level(), y);
} else {
loopDetected = true;
if (m_params.m_FiniteOverlapModels) {
@@ -4020,6259 +3230,3742 @@ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
arrangement_disjunction.push_back(tester);
add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
} else {
- TRACE("str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
+ TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
+ }
+ }
+ }
+
+ // break option 2:
+ // x = m . t2
+ // n = t2 . y
+ if (!avoidLoopCut || !has_self_cut(x, n)) {
+ expr_ref_vector and_item(mgr);
+ // break down option 1-2
+ expr_ref m_t2(mk_concat(m, t2), mgr);
+ expr_ref t2_y(mk_concat(t2, y), mgr);
+
+ and_item.push_back(ctx.mk_eq_atom(x, m_t2));
+ and_item.push_back(ctx.mk_eq_atom(n, t2_y));
+
+
+ expr_ref m_plus_t2(m_autil.mk_add(mk_strlen(m), mk_strlen(t2)), mgr);
+
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(x), m_plus_t2));
+ // want len(x) > len(m) and len(n) > len(y)
+ and_item.push_back(
+ mgr.mk_not(m_autil.mk_le(
+ m_autil.mk_add(mk_strlen(x), m_autil.mk_mul(mk_int(-1), mk_strlen(m))),
+ mk_int(0))) );
+ and_item.push_back(
+ mgr.mk_not(m_autil.mk_le(
+ m_autil.mk_add(mk_strlen(n), m_autil.mk_mul(mk_int(-1), mk_strlen(y))),
+ mk_int(0))) );
+
+ expr_ref option2(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option2);
+ add_theory_aware_branching_info(option2, 0.1, l_true);
+
+ add_cut_info_merge(t2, ctx.get_scope_level(), x);
+ add_cut_info_merge(t2, ctx.get_scope_level(), n);
+ } else {
+ loopDetected = true;
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ arrangement_disjunction.push_back(tester);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
+ } else {
+ TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
TRACE("str", {print_cut_var(x, tout); print_cut_var(n, tout);});
if (!overlapAssumptionUsed) {
- overlapAssumptionUsed = true;
- arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
+ overlapAssumptionUsed = true;
+ arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
}
}
}
- }
+ // option 3:
+ // x = m, y = n
+ if (can_two_nodes_eq(x, m) && can_two_nodes_eq(y, n)) {
+ expr_ref_vector and_item(mgr);
- if (!arrangement_disjunction.empty()) {
- expr_ref implyR(mk_or(arrangement_disjunction), mgr);
+ and_item.push_back(ctx.mk_eq_atom(x, m));
+ and_item.push_back(ctx.mk_eq_atom(y, n));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n)));
- if (m_params.m_StrongArrangements) {
- expr_ref ax_lhs(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
- expr_ref ax_strong(ctx.mk_eq_atom(ax_lhs, implyR), mgr);
- assert_axiom(ax_strong);
+ expr_ref option3(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option3);
+ // prioritize this case, it is easier
+ add_theory_aware_branching_info(option3, 0.5, l_true);
+ }
+
+ if (!arrangement_disjunction.empty()) {
+ expr_ref premise(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref conclusion(mk_or(arrangement_disjunction), mgr);
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(premise, conclusion), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(premise, conclusion);
+ }
+ // assert mutual exclusion between each branch of the arrangement
+ generate_mutual_exclusion(arrangement_disjunction);
} else {
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ TRACE("str", tout << "STOP: no split option found for two EQ concats." << std::endl;);
}
- generate_mutual_exclusion(arrangement_disjunction);
+ } // (splitType == -1)
+ }
+
+ /*************************************************************
+ * Type 2: concat(x, y) = concat(m, "str")
+ *************************************************************/
+ bool theory_str::is_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ if ((!u.str.is_string(v1_arg0)) && u.str.is_string(v1_arg1)
+ && (!u.str.is_string(v2_arg0)) && (!u.str.is_string(v2_arg1))) {
+ return true;
+ } else if ((!u.str.is_string(v2_arg0)) && u.str.is_string(v2_arg1)
+ && (!u.str.is_string(v1_arg0)) && (!u.str.is_string(v1_arg1))) {
+ return true;
} else {
- TRACE("str", tout << "STOP: should not split two eq. concats" << std::endl;);
+ return false;
}
}
-}
+ void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
-/*************************************************************
- * Type 4: concat("str1", y) = concat("str2", n)
- *************************************************************/
-bool theory_str::is_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
- expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
- expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
- expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
- expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+ bool overlapAssumptionUsed = false;
- if (u.str.is_string(v1_arg0) && (!u.str.is_string(v1_arg1))
- && u.str.is_string(v2_arg0) && (!u.str.is_string(v2_arg1))) {
- return true;
- } else {
- return false;
- }
-}
+ TRACE("str", tout << "process_concat_eq TYPE 2" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
+ );
-void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
- ast_manager & mgr = get_manager();
- context & ctx = get_context();
- TRACE("str", tout << "process_concat_eq TYPE 4" << std::endl
- << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
- << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
- );
-
- if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
- return;
- }
- if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
- return;
- }
-
- expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
- expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
- expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
- expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
-
- expr * str1Ast = v1_arg0;
- expr * y = v1_arg1;
- expr * str2Ast = v2_arg0;
- expr * n = v2_arg1;
-
- zstring str1Value, str2Value;
- u.str.is_string(str1Ast, str1Value);
- u.str.is_string(str2Ast, str2Value);
-
- unsigned int str1Len = str1Value.length();
- unsigned int str2Len = str2Value.length();
-
- int commonLen = (str1Len > str2Len) ? str2Len : str1Len;
- if (str1Value.extract(0, commonLen) != str2Value.extract(0, commonLen)) {
- TRACE("str", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
- << " has no common prefix with " << mk_ismt2_pp(concatAst2, mgr) << std::endl;);
- expr_ref toNegate(mgr.mk_not(ctx.mk_eq_atom(concatAst1, concatAst2)), mgr);
- assert_axiom(toNegate);
- return;
- } else {
- if (str1Len > str2Len) {
- zstring deltaStr = str1Value.extract(str2Len, str1Len - str2Len);
- expr_ref tmpAst(mk_concat(mk_string(deltaStr), y), mgr);
- if (!in_same_eqc(tmpAst, n)) {
- // break down option 4-1
- expr_ref implyR(ctx.mk_eq_atom(n, tmpAst), mgr);
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
- }
- }
- } else if (str1Len == str2Len) {
- if (!in_same_eqc(n, y)) {
- //break down option 4-2
- expr_ref implyR(ctx.mk_eq_atom(n, y), mgr);
-
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
- }
- }
- } else {
- zstring deltaStr = str2Value.extract(str1Len, str2Len - str1Len);
- expr_ref tmpAst(mk_concat(mk_string(deltaStr), n), mgr);
- if (!in_same_eqc(y, tmpAst)) {
- //break down option 4-3
- expr_ref implyR(ctx.mk_eq_atom(y, tmpAst), mgr);
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
- }
- }
+ if (!u.str.is_concat(to_app(concatAst1))) {
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
}
- }
-}
-
-/*************************************************************
- * case 5: concat(x, "str1") = concat(m, "str2")
- *************************************************************/
-bool theory_str::is_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
- expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
- expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
- expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
- expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
-
- if ((!u.str.is_string(v1_arg0)) && u.str.is_string(v1_arg1)
- && (!u.str.is_string(v2_arg0)) && u.str.is_string(v2_arg1)) {
- return true;
- } else {
- return false;
- }
-}
-
-void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
- ast_manager & mgr = get_manager();
- context & ctx = get_context();
- TRACE("str", tout << "process_concat_eq TYPE 5" << std::endl
- << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
- << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
- );
-
- if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
- return;
- }
- if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
- return;
- }
-
- expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
- expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
- expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
- expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
-
- expr * x = v1_arg0;
- expr * str1Ast = v1_arg1;
- expr * m = v2_arg0;
- expr * str2Ast = v2_arg1;
-
- zstring str1Value, str2Value;
- u.str.is_string(str1Ast, str1Value);
- u.str.is_string(str2Ast, str2Value);
-
- unsigned int str1Len = str1Value.length();
- unsigned int str2Len = str2Value.length();
-
- int cLen = (str1Len > str2Len) ? str2Len : str1Len;
- if (str1Value.extract(str1Len - cLen, cLen) != str2Value.extract(str2Len - cLen, cLen)) {
- TRACE("str", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
- << " has no common suffix with " << mk_ismt2_pp(concatAst2, mgr) << std::endl;);
- expr_ref toNegate(mgr.mk_not(ctx.mk_eq_atom(concatAst1, concatAst2)), mgr);
- assert_axiom(toNegate);
- return;
- } else {
- if (str1Len > str2Len) {
- zstring deltaStr = str1Value.extract(0, str1Len - str2Len);
- expr_ref x_deltaStr(mk_concat(x, mk_string(deltaStr)), mgr);
- if (!in_same_eqc(m, x_deltaStr)) {
- expr_ref implyR(ctx.mk_eq_atom(m, x_deltaStr), mgr);
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
- }
- }
- } else if (str1Len == str2Len) {
- // test
- if (!in_same_eqc(x, m)) {
- expr_ref implyR(ctx.mk_eq_atom(x, m), mgr);
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
- }
- }
- } else {
- zstring deltaStr = str2Value.extract(0, str2Len - str1Len);
- expr_ref m_deltaStr(mk_concat(m, mk_string(deltaStr)), mgr);
- if (!in_same_eqc(x, m_deltaStr)) {
- expr_ref implyR(ctx.mk_eq_atom(x, m_deltaStr), mgr);
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
- }
- }
+ if (!u.str.is_concat(to_app(concatAst2))) {
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
}
- }
-}
-/*************************************************************
- * case 6: concat("str1", y) = concat(m, "str2")
- *************************************************************/
-bool theory_str::is_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
- expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
- expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
- expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
- expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+ expr * x = NULL;
+ expr * y = NULL;
+ expr * strAst = NULL;
+ expr * m = NULL;
- if (u.str.is_string(v1_arg0) && (!u.str.is_string(v1_arg1))
- && (!u.str.is_string(v2_arg0)) && u.str.is_string(v2_arg1)) {
- return true;
- } else if (u.str.is_string(v2_arg0) && (!u.str.is_string(v2_arg1))
- && (!u.str.is_string(v1_arg0)) && u.str.is_string(v1_arg1)) {
- return true;
- } else {
- return false;
- }
-}
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
-void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
- ast_manager & mgr = get_manager();
- context & ctx = get_context();
- TRACE("str", tout << "process_concat_eq TYPE 6" << std::endl
- << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
- << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
- );
+ if (u.str.is_string(v1_arg1) && !u.str.is_string(v2_arg1)) {
+ m = v1_arg0;
+ strAst = v1_arg1;
+ x = v2_arg0;
+ y = v2_arg1;
+ } else {
+ m = v2_arg0;
+ strAst = v2_arg1;
+ x = v1_arg0;
+ y = v1_arg1;
+ }
- if (!u.str.is_concat(to_app(concatAst1))) {
- TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
- return;
- }
- if (!u.str.is_concat(to_app(concatAst2))) {
- TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
- return;
- }
+ zstring strValue;
+ u.str.is_string(strAst, strValue);
- expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
- expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
- expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
- expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+ rational x_len, y_len, m_len, str_len;
+ bool x_len_exists = get_len_value(x, x_len);
+ bool y_len_exists = get_len_value(y, y_len);
+ bool m_len_exists = get_len_value(m, m_len);
+ bool str_len_exists = true;
+ str_len = rational(strValue.length());
+ // setup
- expr * str1Ast = NULL;
- expr * y = NULL;
- expr * m = NULL;
- expr * str2Ast = NULL;
+ expr * xorFlag = NULL;
+ expr * temp1 = NULL;
+ std::pair<expr*, expr*> key1(concatAst1, concatAst2);
+ std::pair<expr*, expr*> key2(concatAst2, concatAst1);
- if (u.str.is_string(v1_arg0)) {
- str1Ast = v1_arg0;
- y = v1_arg1;
- m = v2_arg0;
- str2Ast = v2_arg1;
- } else {
- str1Ast = v2_arg0;
- y = v2_arg1;
- m = v1_arg0;
- str2Ast = v1_arg1;
- }
+ // check the entries in this map to make sure they're still in scope
+ // before we use them.
- zstring str1Value, str2Value;
- u.str.is_string(str1Ast, str1Value);
- u.str.is_string(str2Ast, str2Value);
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
- unsigned int str1Len = str1Value.length();
- unsigned int str2Len = str2Value.length();
+ // prevent checking scope for the XOR term, as it's always in the same scope as the split var
- //----------------------------------------
- //(a) |---str1---|----y----|
- // |--m--|-----str2-----|
- //
- //(b) |---str1---|----y----|
- // |-----m----|--str2---|
- //
- //(c) |---str1---|----y----|
- // |------m------|-str2-|
- //----------------------------------------
-
- std::list<unsigned int> overlapLen;
- overlapLen.push_back(0);
-
- for (unsigned int i = 1; i <= str1Len && i <= str2Len; i++) {
- if (str1Value.extract(str1Len - i, i) == str2Value.extract(0, i))
- overlapLen.push_back(i);
- }
-
- //----------------------------------------------------------------
- expr * commonVar = NULL;
- expr * xorFlag = NULL;
- std::pair<expr*, expr*> key1(concatAst1, concatAst2);
- std::pair<expr*, expr*> key2(concatAst2, concatAst1);
-
- // check the entries in this map to make sure they're still in scope
- // before we use them.
-
- std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
- std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
-
- bool entry1InScope;
- if (entry1 == varForBreakConcat.end()) {
- entry1InScope = false;
- } else {
- if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
- /* || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end() */) {
+ bool entry1InScope;
+ if (entry1 == varForBreakConcat.end()) {
entry1InScope = false;
} else {
- entry1InScope = true;
+ if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
+ /*|| internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end()*/
+ ) {
+ entry1InScope = false;
+ } else {
+ entry1InScope = true;
+ }
}
- }
- bool entry2InScope;
- if (entry2 == varForBreakConcat.end()) {
- entry2InScope = false;
- } else {
- if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
- /* || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end() */) {
+ bool entry2InScope;
+ if (entry2 == varForBreakConcat.end()) {
entry2InScope = false;
} else {
- entry2InScope = true;
+ if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
+ /*|| internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end()*/
+ ) {
+ entry2InScope = false;
+ } else {
+ entry2InScope = true;
+ }
}
- }
- TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
- << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
+ TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
- if (!entry1InScope && !entry2InScope) {
- commonVar = mk_nonempty_str_var();
- xorFlag = mk_internal_xor_var();
- varForBreakConcat[key1][0] = commonVar;
- varForBreakConcat[key1][1] = xorFlag;
- } else {
- if (entry1InScope) {
- commonVar = (entry1->second)[0];
- xorFlag = (entry1->second)[1];
+
+ if (!entry1InScope && !entry2InScope) {
+ temp1 = mk_nonempty_str_var();
+ xorFlag = mk_internal_xor_var();
+ varForBreakConcat[key1][0] = temp1;
+ varForBreakConcat[key1][1] = xorFlag;
} else {
- commonVar = (entry2->second)[0];
- xorFlag = (entry2->second)[1];
- }
- refresh_theory_var(commonVar);
- add_nonempty_constraint(commonVar);
- }
-
- bool overlapAssumptionUsed = false;
-
- expr_ref_vector arrangement_disjunction(mgr);
- int pos = 1;
-
- if (!avoidLoopCut || !has_self_cut(m, y)) {
- expr_ref_vector and_item(mgr);
-
- expr_ref str1_commonVar(mk_concat(str1Ast, commonVar), mgr);
- and_item.push_back(ctx.mk_eq_atom(m, str1_commonVar));
- pos += 1;
-
- expr_ref commonVar_str2(mk_concat(commonVar, str2Ast), mgr);
- and_item.push_back(ctx.mk_eq_atom(y, commonVar_str2));
- pos += 1;
-
- and_item.push_back(ctx.mk_eq_atom(mk_strlen(m),
- m_autil.mk_add(mk_strlen(str1Ast), mk_strlen(commonVar)) ));
- pos += 1;
-
- // addItems[0] = mk_length(t, commonVar);
- // addItems[1] = mk_length(t, str2Ast);
- // and_item[pos++] = Z3_mk_eq(ctx, or_item[option], Z3_mk_eq(ctx, mk_length(t, y), Z3_mk_add(ctx, 2, addItems)));
-
- expr_ref option1(mk_and(and_item), mgr);
- arrangement_disjunction.push_back(option1);
- add_theory_aware_branching_info(option1, 0.1, l_true);
- } else {
- loopDetected = true;
-
- if (m_params.m_FiniteOverlapModels) {
- expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
- arrangement_disjunction.push_back(tester);
- add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
- } else {
- TRACE("str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
- TRACE("str", print_cut_var(m, tout); print_cut_var(y, tout););
-
- // only add the overlap assumption one time
- if (!overlapAssumptionUsed) {
- arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
- overlapAssumptionUsed = true;
+ if (entry1InScope) {
+ temp1 = varForBreakConcat[key1][0];
+ xorFlag = varForBreakConcat[key1][1];
+ } else if (entry2InScope) {
+ temp1 = varForBreakConcat[key2][0];
+ xorFlag = varForBreakConcat[key2][1];
}
+ refresh_theory_var(temp1);
+ add_nonempty_constraint(temp1);
}
- }
- for (std::list<unsigned int>::iterator itor = overlapLen.begin(); itor != overlapLen.end(); itor++) {
- unsigned int overLen = *itor;
- zstring prefix = str1Value.extract(0, str1Len - overLen);
- zstring suffix = str2Value.extract(overLen, str2Len - overLen);
-
- expr_ref_vector and_item(mgr);
-
- expr_ref prefixAst(mk_string(prefix), mgr);
- expr_ref x_eq_prefix(ctx.mk_eq_atom(m, prefixAst), mgr);
- and_item.push_back(x_eq_prefix);
- pos += 1;
-
- and_item.push_back(
- ctx.mk_eq_atom(mk_strlen(m), mk_strlen(prefixAst)));
- pos += 1;
-
- // adding length constraint for _ = constStr seems slowing things down.
-
- expr_ref suffixAst(mk_string(suffix), mgr);
- expr_ref y_eq_suffix(ctx.mk_eq_atom(y, suffixAst), mgr);
- and_item.push_back(y_eq_suffix);
- pos += 1;
-
- and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_strlen(suffixAst)));
- pos += 1;
-
- expr_ref option2(mk_and(and_item), mgr);
- arrangement_disjunction.push_back(option2);
- double priority;
- // prefer the option "str1" = x
- if (prefix == str1Value) {
- priority = 0.5;
- } else {
- priority = 0.1;
+ int splitType = -1;
+ if (x_len_exists && m_len_exists) {
+ if (x_len < m_len)
+ splitType = 0;
+ else if (x_len == m_len)
+ splitType = 1;
+ else
+ splitType = 2;
}
- add_theory_aware_branching_info(option2, priority, l_true);
- }
-
- // case 6: concat("str1", y) = concat(m, "str2")
-
- expr_ref implyR(mk_or(arrangement_disjunction), mgr);
-
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
- assert_axiom(ax_strong);
- } else {
- assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
- }
- generate_mutual_exclusion(arrangement_disjunction);
-}
-
-void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr) {
- ast_manager & m = get_manager();
-
- if (!u.re.is_unroll(to_app(unrollFunc))) {
- return;
- }
- if (!u.str.is_string(constStr)) {
- return;
- }
-
- expr * funcInUnroll = to_app(unrollFunc)->get_arg(0);
- zstring strValue;
- u.str.is_string(constStr, strValue);
-
- TRACE("str", tout << "unrollFunc: " << mk_pp(unrollFunc, m) << std::endl
- << "constStr: " << mk_pp(constStr, m) << std::endl;);
-
- if (strValue == "") {
- return;
- }
-
- if (u.re.is_to_re(to_app(funcInUnroll))) {
- unroll_str2reg_constStr(unrollFunc, constStr);
- return;
- }
-}
-
-void theory_str::process_concat_eq_unroll(expr * concat, expr * unroll) {
- context & ctx = get_context();
- ast_manager & mgr = get_manager();
-
- TRACE("str", tout << "concat = " << mk_pp(concat, mgr) << ", unroll = " << mk_pp(unroll, mgr) << std::endl;);
-
- std::pair<expr*, expr*> key = std::make_pair(concat, unroll);
- expr_ref toAssert(mgr);
-
- if (concat_eq_unroll_ast_map.find(key) == concat_eq_unroll_ast_map.end()) {
- expr_ref arg1(to_app(concat)->get_arg(0), mgr);
- expr_ref arg2(to_app(concat)->get_arg(1), mgr);
- expr_ref r1(to_app(unroll)->get_arg(0), mgr);
- expr_ref t1(to_app(unroll)->get_arg(1), mgr);
-
- expr_ref v1(mk_regex_rep_var(), mgr);
- expr_ref v2(mk_regex_rep_var(), mgr);
- expr_ref v3(mk_regex_rep_var(), mgr);
- expr_ref v4(mk_regex_rep_var(), mgr);
- expr_ref v5(mk_regex_rep_var(), mgr);
-
- expr_ref t2(mk_unroll_bound_var(), mgr);
- expr_ref t3(mk_unroll_bound_var(), mgr);
- expr_ref emptyStr(mk_string(""), mgr);
-
- expr_ref unroll1(mk_unroll(r1, t2), mgr);
- expr_ref unroll2(mk_unroll(r1, t3), mgr);
-
- expr_ref op0(ctx.mk_eq_atom(t1, mk_int(0)), mgr);
- expr_ref op1(m_autil.mk_ge(t1, mk_int(1)), mgr);
-
- expr_ref_vector op1Items(mgr);
- expr_ref_vector op2Items(mgr);
-
- op1Items.push_back(ctx.mk_eq_atom(arg1, emptyStr));
- op1Items.push_back(ctx.mk_eq_atom(arg2, emptyStr));
- op1Items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(0)));
- op1Items.push_back(ctx.mk_eq_atom(mk_strlen(arg2), mk_int(0)));
- expr_ref opAnd1(ctx.mk_eq_atom(op0, mk_and(op1Items)), mgr);
-
- expr_ref v1v2(mk_concat(v1, v2), mgr);
- op2Items.push_back(ctx.mk_eq_atom(arg1, v1v2));
- op2Items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), m_autil.mk_add(mk_strlen(v1), mk_strlen(v2))));
- expr_ref v3v4(mk_concat(v3, v4), mgr);
- op2Items.push_back(ctx.mk_eq_atom(arg2, v3v4));
- op2Items.push_back(ctx.mk_eq_atom(mk_strlen(arg2), m_autil.mk_add(mk_strlen(v3), mk_strlen(v4))));
-
- op2Items.push_back(ctx.mk_eq_atom(v1, unroll1));
- op2Items.push_back(ctx.mk_eq_atom(mk_strlen(v1), mk_strlen(unroll1)));
- op2Items.push_back(ctx.mk_eq_atom(v4, unroll2));
- op2Items.push_back(ctx.mk_eq_atom(mk_strlen(v4), mk_strlen(unroll2)));
- expr_ref v2v3(mk_concat(v2, v3), mgr);
- op2Items.push_back(ctx.mk_eq_atom(v5, v2v3));
- reduce_virtual_regex_in(v5, r1, op2Items);
- op2Items.push_back(ctx.mk_eq_atom(mk_strlen(v5), m_autil.mk_add(mk_strlen(v2), mk_strlen(v3))));
- op2Items.push_back(ctx.mk_eq_atom(m_autil.mk_add(t2, t3), m_autil.mk_add(t1, mk_int(-1))));
- expr_ref opAnd2(ctx.mk_eq_atom(op1, mk_and(op2Items)), mgr);
-
- toAssert = mgr.mk_and(opAnd1, opAnd2);
- m_trail.push_back(toAssert);
- concat_eq_unroll_ast_map[key] = toAssert;
- } else {
- toAssert = concat_eq_unroll_ast_map[key];
- }
-
- assert_axiom(toAssert);
-}
-
-void theory_str::unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- expr * str2RegFunc = to_app(unrollFunc)->get_arg(0);
- expr * strInStr2RegFunc = to_app(str2RegFunc)->get_arg(0);
- expr * oriCnt = to_app(unrollFunc)->get_arg(1);
-
- zstring strValue;
- u.str.is_string(eqConstStr, strValue);
- zstring regStrValue;
- u.str.is_string(strInStr2RegFunc, regStrValue);
- unsigned int strLen = strValue.length();
- unsigned int regStrLen = regStrValue.length();
- SASSERT(regStrLen != 0); // this should never occur -- the case for empty string is handled elsewhere
- unsigned int cnt = strLen / regStrLen;
-
- expr_ref implyL(ctx.mk_eq_atom(unrollFunc, eqConstStr), m);
- expr_ref implyR1(ctx.mk_eq_atom(oriCnt, mk_int(cnt)), m);
- expr_ref implyR2(ctx.mk_eq_atom(mk_strlen(unrollFunc), mk_int(strLen)), m);
- expr_ref axiomRHS(m.mk_and(implyR1, implyR2), m);
- SASSERT(implyL);
- SASSERT(axiomRHS);
- assert_implication(implyL, axiomRHS);
-}
-
-/*
- * Look through the equivalence class of n to find a string constant.
- * Return that constant if it is found, and set hasEqcValue to true.
- * Otherwise, return n, and set hasEqcValue to false.
- */
-
-expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
- return z3str2_get_eqc_value(n, hasEqcValue);
-}
-
-
-// Simulate the behaviour of get_eqc_value() from Z3str2.
-// We only check m_find for a string constant.
-
-expr * theory_str::z3str2_get_eqc_value(expr * n , bool & hasEqcValue) {
- expr * curr = n;
- do {
- if (u.str.is_string(curr)) {
- hasEqcValue = true;
- return curr;
+ if (splitType == -1 && y_len_exists && str_len_exists) {
+ if (y_len > str_len)
+ splitType = 0;
+ else if (y_len == str_len)
+ splitType = 1;
+ else
+ splitType = 2;
}
- curr = get_eqc_next(curr);
- } while (curr != n);
- hasEqcValue = false;
- return n;
-}
-// from Z3: theory_seq.cpp
+ TRACE("str", tout << "Split type " << splitType << std::endl;);
-static theory_mi_arith* get_th_arith(context& ctx, theory_id afid, expr* e) {
- theory* th = ctx.get_theory(afid);
- if (th && ctx.e_internalized(e)) {
- return dynamic_cast<theory_mi_arith*>(th);
- }
- else {
- return 0;
- }
-}
+ // Provide fewer split options when length information is available.
-bool theory_str::get_value(expr* e, rational& val) const {
- if (opt_DisableIntegerTheoryIntegration) {
- TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
- return false;
- }
+ if (splitType == 0) {
+ // M cuts Y
+ // | x | y |
+ // | m | str |
+ expr_ref temp1_strAst(mk_concat(temp1, strAst), mgr);
+ if (can_two_nodes_eq(y, temp1_strAst)) {
+ expr_ref_vector l_items(mgr);
+ l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
- context& ctx = get_context();
- ast_manager & m = get_manager();
- theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
- if (!tha) {
- return false;
- }
- TRACE("str", tout << "checking eqc of " << mk_pp(e, m) << " for arithmetic value" << std::endl;);
- expr_ref _val(m);
- enode * en_e = ctx.get_enode(e);
- enode * it = en_e;
- do {
- if (m_autil.is_numeral(it->get_owner(), val) && val.is_int()) {
- // found an arithmetic term
- TRACE("str", tout << mk_pp(it->get_owner(), m) << " is an integer ( ~= " << val << " )"
- << std::endl;);
- return true;
- } else {
- TRACE("str", tout << mk_pp(it->get_owner(), m) << " not a numeral" << std::endl;);
- }
- it = it->get_next();
- } while (it != en_e);
- TRACE("str", tout << "no arithmetic values found in eqc" << std::endl;);
- return false;
-}
+ expr_ref_vector r_items(mgr);
+ expr_ref x_temp1(mk_concat(x, temp1), mgr);
+ r_items.push_back(ctx.mk_eq_atom(m, x_temp1));
+ r_items.push_back(ctx.mk_eq_atom(y, temp1_strAst));
-bool theory_str::lower_bound(expr* _e, rational& lo) {
- if (opt_DisableIntegerTheoryIntegration) {
- TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
- return false;
- }
-
- context& ctx = get_context();
- ast_manager & m = get_manager();
- theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), _e);
- expr_ref _lo(m);
- if (!tha || !tha->get_lower(ctx.get_enode(_e), _lo)) return false;
- return m_autil.is_numeral(_lo, lo) && lo.is_int();
-}
-
-bool theory_str::upper_bound(expr* _e, rational& hi) {
- if (opt_DisableIntegerTheoryIntegration) {
- TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
- return false;
- }
-
- context& ctx = get_context();
- ast_manager & m = get_manager();
- theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), _e);
- expr_ref _hi(m);
- if (!tha || !tha->get_upper(ctx.get_enode(_e), _hi)) return false;
- return m_autil.is_numeral(_hi, hi) && hi.is_int();
-}
-
-bool theory_str::get_len_value(expr* e, rational& val) {
- if (opt_DisableIntegerTheoryIntegration) {
- TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
- return false;
- }
-
- context& ctx = get_context();
- ast_manager & m = get_manager();
-
- theory* th = ctx.get_theory(m_autil.get_family_id());
- if (!th) {
- TRACE("str", tout << "oops, can't get m_autil's theory" << std::endl;);
- return false;
- }
- theory_mi_arith* tha = dynamic_cast<theory_mi_arith*>(th);
- if (!tha) {
- TRACE("str", tout << "oops, can't cast to theory_mi_arith" << std::endl;);
- return false;
- }
-
- TRACE("str", tout << "checking len value of " << mk_ismt2_pp(e, m) << std::endl;);
-
- rational val1;
- expr_ref len(m), len_val(m);
- expr* e1, *e2;
- ptr_vector<expr> todo;
- todo.push_back(e);
- val.reset();
- while (!todo.empty()) {
- expr* c = todo.back();
- todo.pop_back();
- if (u.str.is_concat(to_app(c))) {
- e1 = to_app(c)->get_arg(0);
- e2 = to_app(c)->get_arg(1);
- todo.push_back(e1);
- todo.push_back(e2);
- }
- else if (u.str.is_string(to_app(c))) {
- zstring tmp;
- u.str.is_string(to_app(c), tmp);
- unsigned int sl = tmp.length();
- val += rational(sl);
- }
- else {
- len = mk_strlen(c);
-
- // debugging
- TRACE("str", {
- tout << mk_pp(len, m) << ":" << std::endl
- << (ctx.is_relevant(len.get()) ? "relevant" : "not relevant") << std::endl
- << (ctx.e_internalized(len) ? "internalized" : "not internalized") << std::endl
- ;
- if (ctx.e_internalized(len)) {
- enode * e_len = ctx.get_enode(len);
- tout << "has " << e_len->get_num_th_vars() << " theory vars" << std::endl;
-
- // eqc debugging
- {
- tout << "dump equivalence class of " << mk_pp(len, get_manager()) << std::endl;
- enode * nNode = ctx.get_enode(len);
- enode * eqcNode = nNode;
- do {
- app * ast = eqcNode->get_owner();
- tout << mk_pp(ast, get_manager()) << std::endl;
- eqcNode = eqcNode->get_next();
- } while (eqcNode != nNode);
- }
- }
- });
-
- if (ctx.e_internalized(len) && get_value(len, val1)) {
- val += val1;
- TRACE("str", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has length " << val1 << std::endl;);
- }
- else {
- TRACE("str", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has no length assignment; bailing out" << std::endl;);
- return false;
- }
- }
- }
-
- TRACE("str", tout << "length of " << mk_ismt2_pp(e, m) << " is " << val << std::endl;);
- return val.is_int();
-}
-
-/*
- * Decide whether n1 and n2 are already in the same equivalence class.
- * This only checks whether the core considers them to be equal;
- * they may not actually be equal.
- */
-bool theory_str::in_same_eqc(expr * n1, expr * n2) {
- if (n1 == n2) return true;
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- // similar to get_eqc_value(), make absolutely sure
- // that we've set this up properly for the context
-
- if (!ctx.e_internalized(n1)) {
- TRACE("str", tout << "WARNING: expression " << mk_ismt2_pp(n1, m) << " was not internalized" << std::endl;);
- ctx.internalize(n1, false);
- }
- if (!ctx.e_internalized(n2)) {
- TRACE("str", tout << "WARNING: expression " << mk_ismt2_pp(n2, m) << " was not internalized" << std::endl;);
- ctx.internalize(n2, false);
- }
-
- expr * curr = get_eqc_next(n1);
- while (curr != n1) {
- if (curr == n2)
- return true;
- curr = get_eqc_next(curr);
- }
- return false;
-}
-
-expr * theory_str::collect_eq_nodes(expr * n, expr_ref_vector & eqcSet) {
- context & ctx = get_context();
- expr * constStrNode = NULL;
-
- expr * ex = n;
- do {
- if (u.str.is_string(to_app(ex))) {
- constStrNode = ex;
- }
- eqcSet.push_back(ex);
-
- ex = get_eqc_next(ex);
- } while (ex != n);
- return constStrNode;
-}
-
-/*
- * Collect constant strings (from left to right) in an AST node.
- */
-void theory_str::get_const_str_asts_in_node(expr * node, expr_ref_vector & astList) {
- ast_manager & m = get_manager();
- if (u.str.is_string(node)) {
- astList.push_back(node);
- //} else if (getNodeType(t, node) == my_Z3_Func) {
- } else if (is_app(node)) {
- app * func_app = to_app(node);
- unsigned int argCount = func_app->get_num_args();
- for (unsigned int i = 0; i < argCount; i++) {
- expr * argAst = func_app->get_arg(i);
- get_const_str_asts_in_node(argAst, astList);
- }
- }
-}
-
-void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- TRACE("str", tout << "varNode = " << mk_pp(varNode, m) << ", constNode = " << mk_pp(constNode, m) << std::endl;);
-
- expr_ref_vector litems(m);
-
- if (contain_pair_idx_map.find(varNode) != contain_pair_idx_map.end()) {
- std::set<std::pair<expr*, expr*> >::iterator itor1 = contain_pair_idx_map[varNode].begin();
- for (; itor1 != contain_pair_idx_map[varNode].end(); ++itor1) {
- expr * strAst = itor1->first;
- expr * substrAst = itor1->second;
-
- expr * boolVar;
- if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
- TRACE("str", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
- }
- // boolVar is actually a Contains term
- app * containsApp = to_app(boolVar);
-
- // we only want to inspect the Contains terms where either of strAst or substrAst
- // are equal to varNode.
-
- TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
-
- if (varNode != strAst && varNode != substrAst) {
- TRACE("str", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
- continue;
- }
- TRACE("str", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
-
- // varEqcNode is str
- if (strAst == varNode) {
- expr_ref implyR(m);
- litems.reset();
-
- if (strAst != constNode) {
- litems.push_back(ctx.mk_eq_atom(strAst, constNode));
- }
- zstring strConst;
- u.str.is_string(constNode, strConst);
- bool subStrHasEqcValue = false;
- expr * substrValue = get_eqc_value(substrAst, subStrHasEqcValue);
- if (substrValue != substrAst) {
- litems.push_back(ctx.mk_eq_atom(substrAst, substrValue));
+ if (x_len_exists && m_len_exists) {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
+ rational m_sub_x = (m_len - x_len);
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(m_sub_x)));
+ } else {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(strAst), mk_int(str_len)));
+ rational y_sub_str = (y_len - str_len);
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(y_sub_str)));
}
- if (subStrHasEqcValue) {
- // subStr has an eqc constant value
- zstring subStrConst;
- u.str.is_string(substrValue, subStrConst);
+ expr_ref ax_l(mk_and(l_items), mgr);
+ expr_ref ax_r(mk_and(r_items), mgr);
- TRACE("t_str_detail", tout << "strConst = " << strConst << ", subStrConst = " << subStrConst << "\n";);
+ if (!avoidLoopCut || !(has_self_cut(m, y))) {
+ // break down option 2-1
+ add_cut_info_merge(temp1, sLevel, y);
+ add_cut_info_merge(temp1, sLevel, m);
- if (strConst.contains(subStrConst)) {
- //implyR = ctx.mk_eq(ctx, boolVar, Z3_mk_true(ctx));
- implyR = boolVar;
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
+ assert_axiom(ax_strong);
} else {
- //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
- implyR = m.mk_not(boolVar);
+ assert_implication(ax_l, ax_r);
}
} else {
- // ------------------------------------------------------------------------------------------------
- // subStr doesn't have an eqc contant value
- // however, subStr equals to some concat(arg_1, arg_2, ..., arg_n)
- // if arg_j is a constant and is not a part of the strConst, it's sure that the contains is false
- // ** This check is needed here because the "strConst" and "strAst" may not be in a same eqc yet
- // ------------------------------------------------------------------------------------------------
- // collect eqc concat
- std::set<expr*> eqcConcats;
- get_concats_in_eqc(substrAst, eqcConcats);
- for (std::set<expr*>::iterator concatItor = eqcConcats.begin();
- concatItor != eqcConcats.end(); concatItor++) {
- expr_ref_vector constList(m);
- bool counterEgFound = false;
- // get constant strings in concat
- expr * aConcat = *concatItor;
- get_const_str_asts_in_node(aConcat, constList);
- for (expr_ref_vector::iterator cstItor = constList.begin();
- cstItor != constList.end(); cstItor++) {
- zstring pieceStr;
- u.str.is_string(*cstItor, pieceStr);
- if (!strConst.contains(pieceStr)) {
- counterEgFound = true;
- if (aConcat != substrAst) {
- litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
- }
- //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
- implyR = m.mk_not(boolVar);
- break;
+ loopDetected = true;
+
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ assert_implication(ax_l, tester);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
+ } else {
+ TRACE("str", tout << "AVOID LOOP: SKIP" << std::endl;);
+ TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
+ }
+ }
+ }
+ }
+ } else if (splitType == 1) {
+ // | x | y |
+ // | m | str |
+ expr_ref ax_l1(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref ax_l2(mgr.mk_or(
+ ctx.mk_eq_atom(mk_strlen(x), mk_strlen(m)),
+ ctx.mk_eq_atom(mk_strlen(y), mk_strlen(strAst))), mgr);
+ expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
+ expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x, m), ctx.mk_eq_atom(y, strAst)), mgr);
+ assert_implication(ax_l, ax_r);
+ } else if (splitType == 2) {
+ // m cut y,
+ // | x | y |
+ // | m | str |
+ rational lenDelta;
+ expr_ref_vector l_items(mgr);
+ l_items.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
+ if (x_len_exists && m_len_exists) {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(m), mk_int(m_len)));
+ lenDelta = x_len - m_len;
+ } else {
+ l_items.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ lenDelta = str_len - y_len;
+ }
+ TRACE("str",
+ tout
+ << "xLen? " << (x_len_exists ? "yes" : "no") << std::endl
+ << "mLen? " << (m_len_exists ? "yes" : "no") << std::endl
+ << "yLen? " << (y_len_exists ? "yes" : "no") << std::endl
+ << "xLen = " << x_len.to_string() << std::endl
+ << "yLen = " << y_len.to_string() << std::endl
+ << "mLen = " << m_len.to_string() << std::endl
+ << "strLen = " << str_len.to_string() << std::endl
+ << "lenDelta = " << lenDelta.to_string() << std::endl
+ << "strValue = \"" << strValue << "\" (len=" << strValue.length() << ")" << "\n"
+ ;
+ );
+
+ zstring part1Str = strValue.extract(0, lenDelta.get_unsigned());
+ zstring part2Str = strValue.extract(lenDelta.get_unsigned(), strValue.length() - lenDelta.get_unsigned());
+
+ expr_ref prefixStr(mk_string(part1Str), mgr);
+ expr_ref x_concat(mk_concat(m, prefixStr), mgr);
+ expr_ref cropStr(mk_string(part2Str), mgr);
+
+ if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
+ expr_ref_vector r_items(mgr);
+ r_items.push_back(ctx.mk_eq_atom(x, x_concat));
+ r_items.push_back(ctx.mk_eq_atom(y, cropStr));
+ expr_ref ax_l(mk_and(l_items), mgr);
+ expr_ref ax_r(mk_and(r_items), mgr);
+
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, ax_r);
+ }
+ } else {
+ // negate! It's impossible to split str with these lengths
+ TRACE("str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
+ expr_ref ax_l(mk_and(l_items), mgr);
+ assert_axiom(mgr.mk_not(ax_l));
+ }
+ } else {
+ // Split type -1: no idea about the length...
+ expr_ref_vector arrangement_disjunction(mgr);
+
+ expr_ref temp1_strAst(mk_concat(temp1, strAst), mgr);
+
+ // m cuts y
+ if (can_two_nodes_eq(y, temp1_strAst)) {
+ if (!avoidLoopCut || !has_self_cut(m, y)) {
+ // break down option 2-1
+ expr_ref_vector and_item(mgr);
+
+ expr_ref x_temp1(mk_concat(x, temp1), mgr);
+ and_item.push_back(ctx.mk_eq_atom(m, x_temp1));
+ and_item.push_back(ctx.mk_eq_atom(y, temp1_strAst));
+
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(m),
+ m_autil.mk_add(mk_strlen(x), mk_strlen(temp1))));
+
+ expr_ref option1(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option1);
+ add_theory_aware_branching_info(option1, 0.1, l_true);
+ add_cut_info_merge(temp1, ctx.get_scope_level(), y);
+ add_cut_info_merge(temp1, ctx.get_scope_level(), m);
+ } else {
+ loopDetected = true;
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ arrangement_disjunction.push_back(tester);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
+ } else {
+ TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ TRACE("str", {print_cut_var(m, tout); print_cut_var(y, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
+ }
+ }
+ }
+ }
+
+ for (unsigned int i = 0; i <= strValue.length(); ++i) {
+ zstring part1Str = strValue.extract(0, i);
+ zstring part2Str = strValue.extract(i, strValue.length() - i);
+ expr_ref prefixStr(mk_string(part1Str), mgr);
+ expr_ref x_concat(mk_concat(m, prefixStr), mgr);
+ expr_ref cropStr(mk_string(part2Str), mgr);
+ if (can_two_nodes_eq(x, x_concat) && can_two_nodes_eq(y, cropStr)) {
+ // break down option 2-2
+ expr_ref_vector and_item(mgr);
+ and_item.push_back(ctx.mk_eq_atom(x, x_concat));
+ and_item.push_back(ctx.mk_eq_atom(y, cropStr));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(part2Str.length())));
+ expr_ref option2(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option2);
+ double priority;
+ // prioritize the option where y is equal to the original string
+ if (i == 0) {
+ priority = 0.5;
+ } else {
+ priority = 0.1;
+ }
+ add_theory_aware_branching_info(option2, priority, l_true);
+ }
+ }
+
+ if (!arrangement_disjunction.empty()) {
+ expr_ref implyR(mk_or(arrangement_disjunction), mgr);
+
+ if (m_params.m_StrongArrangements) {
+ expr_ref implyLHS(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref ax_strong(ctx.mk_eq_atom(implyLHS, implyR), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ generate_mutual_exclusion(arrangement_disjunction);
+ } else {
+ TRACE("str", tout << "STOP: Should not split two EQ concats." << std::endl;);
+ }
+ } // (splitType == -1)
+ }
+
+ /*************************************************************
+ * Type 3: concat(x, y) = concat("str", n)
+ *************************************************************/
+ bool theory_str::is_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ if (u.str.is_string(v1_arg0) && (!u.str.is_string(v1_arg1))
+ && (!u.str.is_string(v2_arg0)) && (!u.str.is_string(v2_arg1))) {
+ return true;
+ } else if (u.str.is_string(v2_arg0) && (!u.str.is_string(v2_arg1))
+ && (!u.str.is_string(v1_arg0)) && (!u.str.is_string(v1_arg1))) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+
+ bool overlapAssumptionUsed = false;
+
+ TRACE("str", tout << "process_concat_eq TYPE 3" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
+ );
+
+ if (!u.str.is_concat(to_app(concatAst1))) {
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
+ }
+ if (!u.str.is_concat(to_app(concatAst2))) {
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
+ }
+
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ expr * x = NULL;
+ expr * y = NULL;
+ expr * strAst = NULL;
+ expr * n = NULL;
+
+ if (u.str.is_string(v1_arg0) && !u.str.is_string(v2_arg0)) {
+ strAst = v1_arg0;
+ n = v1_arg1;
+ x = v2_arg0;
+ y = v2_arg1;
+ } else {
+ strAst = v2_arg0;
+ n = v2_arg1;
+ x = v1_arg0;
+ y = v1_arg1;
+ }
+
+ zstring strValue;
+ u.str.is_string(strAst, strValue);
+
+ rational x_len, y_len, str_len, n_len;
+ bool x_len_exists = get_len_value(x, x_len);
+ bool y_len_exists = get_len_value(y, y_len);
+ str_len = rational((unsigned)(strValue.length()));
+ bool n_len_exists = get_len_value(n, n_len);
+
+ expr_ref xorFlag(mgr);
+ expr_ref temp1(mgr);
+ std::pair<expr*, expr*> key1(concatAst1, concatAst2);
+ std::pair<expr*, expr*> key2(concatAst2, concatAst1);
+
+ // check the entries in this map to make sure they're still in scope
+ // before we use them.
+
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
+
+ bool entry1InScope;
+ if (entry1 == varForBreakConcat.end()) {
+ entry1InScope = false;
+ } else {
+ if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
+ /* || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end() */) {
+ entry1InScope = false;
+ } else {
+ entry1InScope = true;
+ }
+ }
+
+ bool entry2InScope;
+ if (entry2 == varForBreakConcat.end()) {
+ entry2InScope = false;
+ } else {
+ if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
+ /* || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end() */) {
+ entry2InScope = false;
+ } else {
+ entry2InScope = true;
+ }
+ }
+
+ TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
+
+
+ if (!entry1InScope && !entry2InScope) {
+ temp1 = mk_nonempty_str_var();
+ xorFlag = mk_internal_xor_var();
+
+ varForBreakConcat[key1][0] = temp1;
+ varForBreakConcat[key1][1] = xorFlag;
+ } else {
+ if (entry1InScope) {
+ temp1 = varForBreakConcat[key1][0];
+ xorFlag = varForBreakConcat[key1][1];
+ } else if (varForBreakConcat.find(key2) != varForBreakConcat.end()) {
+ temp1 = varForBreakConcat[key2][0];
+ xorFlag = varForBreakConcat[key2][1];
+ }
+ refresh_theory_var(temp1);
+ add_nonempty_constraint(temp1);
+ }
+
+
+
+ int splitType = -1;
+ if (x_len_exists) {
+ if (x_len < str_len)
+ splitType = 0;
+ else if (x_len == str_len)
+ splitType = 1;
+ else
+ splitType = 2;
+ }
+ if (splitType == -1 && y_len_exists && n_len_exists) {
+ if (y_len > n_len)
+ splitType = 0;
+ else if (y_len == n_len)
+ splitType = 1;
+ else
+ splitType = 2;
+ }
+
+ TRACE("str", tout << "Split type " << splitType << std::endl;);
+
+ // Provide fewer split options when length information is available.
+ if (splitType == 0) {
+ // | x | y |
+ // | str | n |
+ expr_ref_vector litems(mgr);
+ litems.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
+ rational prefixLen;
+ if (!x_len_exists) {
+ prefixLen = str_len - (y_len - n_len);
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
+ } else {
+ prefixLen = x_len;
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ }
+ zstring prefixStr = strValue.extract(0, prefixLen.get_unsigned());
+ rational str_sub_prefix = str_len - prefixLen;
+ zstring suffixStr = strValue.extract(prefixLen.get_unsigned(), str_sub_prefix.get_unsigned());
+ expr_ref prefixAst(mk_string(prefixStr), mgr);
+ expr_ref suffixAst(mk_string(suffixStr), mgr);
+ expr_ref ax_l(mgr.mk_and(litems.size(), litems.c_ptr()), mgr);
+
+ expr_ref suf_n_concat(mk_concat(suffixAst, n), mgr);
+ if (can_two_nodes_eq(x, prefixAst) && can_two_nodes_eq(y, suf_n_concat)) {
+ expr_ref_vector r_items(mgr);
+ r_items.push_back(ctx.mk_eq_atom(x, prefixAst));
+ r_items.push_back(ctx.mk_eq_atom(y, suf_n_concat));
+
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, mk_and(r_items)), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, mk_and(r_items));
+ }
+ } else {
+ // negate! It's impossible to split str with these lengths
+ TRACE("str", tout << "CONFLICT: Impossible to split str with these lengths." << std::endl;);
+ assert_axiom(mgr.mk_not(ax_l));
+ }
+ }
+ else if (splitType == 1) {
+ expr_ref ax_l1(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref ax_l2(mgr.mk_or(
+ ctx.mk_eq_atom(mk_strlen(x), mk_strlen(strAst)),
+ ctx.mk_eq_atom(mk_strlen(y), mk_strlen(n))), mgr);
+ expr_ref ax_l(mgr.mk_and(ax_l1, ax_l2), mgr);
+ expr_ref ax_r(mgr.mk_and(ctx.mk_eq_atom(x, strAst), ctx.mk_eq_atom(y, n)), mgr);
+
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, ax_r);
+ }
+ }
+ else if (splitType == 2) {
+ // | x | y |
+ // | str | n |
+ expr_ref_vector litems(mgr);
+ litems.push_back(ctx.mk_eq_atom(concatAst1, concatAst2));
+ rational tmpLen;
+ if (!x_len_exists) {
+ tmpLen = n_len - y_len;
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_int(y_len)));
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(n), mk_int(n_len)));
+ } else {
+ tmpLen = x_len - str_len;
+ litems.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
+ }
+ expr_ref ax_l(mgr.mk_and(litems.size(), litems.c_ptr()), mgr);
+
+ expr_ref str_temp1(mk_concat(strAst, temp1), mgr);
+ expr_ref temp1_y(mk_concat(temp1, y), mgr);
+
+ if (can_two_nodes_eq(x, str_temp1)) {
+ if (!avoidLoopCut || !(has_self_cut(x, n))) {
+ expr_ref_vector r_items(mgr);
+ r_items.push_back(ctx.mk_eq_atom(x, str_temp1));
+ r_items.push_back(ctx.mk_eq_atom(n, temp1_y));
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(temp1), mk_int(tmpLen)));
+ expr_ref ax_r(mk_and(r_items), mgr);
+
+ //Cut Info
+ add_cut_info_merge(temp1, sLevel, x);
+ add_cut_info_merge(temp1, sLevel, n);
+
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_l, ax_r), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ax_l, ax_r);
+ }
+ } else {
+ loopDetected = true;
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ assert_implication(ax_l, tester);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
+ } else {
+ TRACE("str", tout << "AVOID LOOP: SKIPPED" << std::endl;);
+ TRACE("str", {print_cut_var(x, tout); print_cut_var(n, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ assert_implication(ax_l, m_theoryStrOverlapAssumption_term);
+ }
+ }
+ }
+ }
+ // else {
+ // // negate! It's impossible to split str with these lengths
+ // __debugPrint(logFile, "[Conflict] Negate! It's impossible to split str with these lengths @ %d.\n", __LINE__);
+ // addAxiom(t, Z3_mk_not(ctx, ax_l), __LINE__);
+ // }
+ }
+ else {
+ // Split type -1. We know nothing about the length...
+
+ expr_ref_vector arrangement_disjunction(mgr);
+
+ int pos = 1;
+ for (unsigned int i = 0; i <= strValue.length(); i++) {
+ zstring part1Str = strValue.extract(0, i);
+ zstring part2Str = strValue.extract(i, strValue.length() - i);
+ expr_ref cropStr(mk_string(part1Str), mgr);
+ expr_ref suffixStr(mk_string(part2Str), mgr);
+ expr_ref y_concat(mk_concat(suffixStr, n), mgr);
+
+ if (can_two_nodes_eq(x, cropStr) && can_two_nodes_eq(y, y_concat)) {
+ expr_ref_vector and_item(mgr);
+ // break down option 3-1
+ expr_ref x_eq_str(ctx.mk_eq_atom(x, cropStr), mgr);
+
+ and_item.push_back(x_eq_str); ++pos;
+ and_item.push_back(ctx.mk_eq_atom(y, y_concat));
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_strlen(cropStr))); ++pos;
+
+ // and_item[pos++] = Z3_mk_eq(ctx, or_item[option], Z3_mk_eq(ctx, mk_length(t, y), mk_length(t, y_concat)));
+ // adding length constraint for _ = constStr seems slowing things down.
+
+ expr_ref option1(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option1);
+ double priority;
+ if (i == strValue.length()) {
+ priority = 0.5;
+ } else {
+ priority = 0.1;
+ }
+ add_theory_aware_branching_info(option1, priority, l_true);
+ }
+ }
+
+ expr_ref strAst_temp1(mk_concat(strAst, temp1), mgr);
+
+
+ //--------------------------------------------------------
+ // x cut n
+ //--------------------------------------------------------
+ if (can_two_nodes_eq(x, strAst_temp1)) {
+ if (!avoidLoopCut || !(has_self_cut(x, n))) {
+ // break down option 3-2
+ expr_ref_vector and_item(mgr);
+
+ expr_ref temp1_y(mk_concat(temp1, y), mgr);
+ and_item.push_back(ctx.mk_eq_atom(x, strAst_temp1)); ++pos;
+ and_item.push_back(ctx.mk_eq_atom(n, temp1_y)); ++pos;
+
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(x),
+ m_autil.mk_add(mk_strlen(strAst), mk_strlen(temp1)) ) ); ++pos;
+
+ expr_ref option2(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option2);
+ add_theory_aware_branching_info(option2, 0.1, l_true);
+
+ add_cut_info_merge(temp1, sLevel, x);
+ add_cut_info_merge(temp1, sLevel, n);
+ } else {
+ loopDetected = true;
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ arrangement_disjunction.push_back(tester);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
+ } else {
+ TRACE("str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
+ TRACE("str", {print_cut_var(x, tout); print_cut_var(n, tout);});
+
+ if (!overlapAssumptionUsed) {
+ overlapAssumptionUsed = true;
+ arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
+ }
+ }
+ }
+ }
+
+
+ if (!arrangement_disjunction.empty()) {
+ expr_ref implyR(mk_or(arrangement_disjunction), mgr);
+
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_lhs(ctx.mk_eq_atom(concatAst1, concatAst2), mgr);
+ expr_ref ax_strong(ctx.mk_eq_atom(ax_lhs, implyR), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ generate_mutual_exclusion(arrangement_disjunction);
+ } else {
+ TRACE("str", tout << "STOP: should not split two eq. concats" << std::endl;);
+ }
+ }
+
+ }
+
+ /*************************************************************
+ * Type 4: concat("str1", y) = concat("str2", n)
+ *************************************************************/
+ bool theory_str::is_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ if (u.str.is_string(v1_arg0) && (!u.str.is_string(v1_arg1))
+ && u.str.is_string(v2_arg0) && (!u.str.is_string(v2_arg1))) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+ TRACE("str", tout << "process_concat_eq TYPE 4" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
+ );
+
+ if (!u.str.is_concat(to_app(concatAst1))) {
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
+ }
+ if (!u.str.is_concat(to_app(concatAst2))) {
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
+ }
+
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ expr * str1Ast = v1_arg0;
+ expr * y = v1_arg1;
+ expr * str2Ast = v2_arg0;
+ expr * n = v2_arg1;
+
+ zstring str1Value, str2Value;
+ u.str.is_string(str1Ast, str1Value);
+ u.str.is_string(str2Ast, str2Value);
+
+ unsigned int str1Len = str1Value.length();
+ unsigned int str2Len = str2Value.length();
+
+ int commonLen = (str1Len > str2Len) ? str2Len : str1Len;
+ if (str1Value.extract(0, commonLen) != str2Value.extract(0, commonLen)) {
+ TRACE("str", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
+ << " has no common prefix with " << mk_ismt2_pp(concatAst2, mgr) << std::endl;);
+ expr_ref toNegate(mgr.mk_not(ctx.mk_eq_atom(concatAst1, concatAst2)), mgr);
+ assert_axiom(toNegate);
+ return;
+ } else {
+ if (str1Len > str2Len) {
+ zstring deltaStr = str1Value.extract(str2Len, str1Len - str2Len);
+ expr_ref tmpAst(mk_concat(mk_string(deltaStr), y), mgr);
+ if (!in_same_eqc(tmpAst, n)) {
+ // break down option 4-1
+ expr_ref implyR(ctx.mk_eq_atom(n, tmpAst), mgr);
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ }
+ } else if (str1Len == str2Len) {
+ if (!in_same_eqc(n, y)) {
+ //break down option 4-2
+ expr_ref implyR(ctx.mk_eq_atom(n, y), mgr);
+
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ }
+ } else {
+ zstring deltaStr = str2Value.extract(str1Len, str2Len - str1Len);
+ expr_ref tmpAst(mk_concat(mk_string(deltaStr), n), mgr);
+ if (!in_same_eqc(y, tmpAst)) {
+ //break down option 4-3
+ expr_ref implyR(ctx.mk_eq_atom(y, tmpAst), mgr);
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ }
+ }
+ }
+ }
+
+ /*************************************************************
+ * case 5: concat(x, "str1") = concat(m, "str2")
+ *************************************************************/
+ bool theory_str::is_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ if ((!u.str.is_string(v1_arg0)) && u.str.is_string(v1_arg1)
+ && (!u.str.is_string(v2_arg0)) && u.str.is_string(v2_arg1)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+ TRACE("str", tout << "process_concat_eq TYPE 5" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
+ );
+
+ if (!u.str.is_concat(to_app(concatAst1))) {
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
+ }
+ if (!u.str.is_concat(to_app(concatAst2))) {
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
+ }
+
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ expr * x = v1_arg0;
+ expr * str1Ast = v1_arg1;
+ expr * m = v2_arg0;
+ expr * str2Ast = v2_arg1;
+
+ zstring str1Value, str2Value;
+ u.str.is_string(str1Ast, str1Value);
+ u.str.is_string(str2Ast, str2Value);
+
+ unsigned int str1Len = str1Value.length();
+ unsigned int str2Len = str2Value.length();
+
+ int cLen = (str1Len > str2Len) ? str2Len : str1Len;
+ if (str1Value.extract(str1Len - cLen, cLen) != str2Value.extract(str2Len - cLen, cLen)) {
+ TRACE("str", tout << "Conflict: " << mk_ismt2_pp(concatAst1, mgr)
+ << " has no common suffix with " << mk_ismt2_pp(concatAst2, mgr) << std::endl;);
+ expr_ref toNegate(mgr.mk_not(ctx.mk_eq_atom(concatAst1, concatAst2)), mgr);
+ assert_axiom(toNegate);
+ return;
+ } else {
+ if (str1Len > str2Len) {
+ zstring deltaStr = str1Value.extract(0, str1Len - str2Len);
+ expr_ref x_deltaStr(mk_concat(x, mk_string(deltaStr)), mgr);
+ if (!in_same_eqc(m, x_deltaStr)) {
+ expr_ref implyR(ctx.mk_eq_atom(m, x_deltaStr), mgr);
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ }
+ } else if (str1Len == str2Len) {
+ // test
+ if (!in_same_eqc(x, m)) {
+ expr_ref implyR(ctx.mk_eq_atom(x, m), mgr);
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ }
+ } else {
+ zstring deltaStr = str2Value.extract(0, str2Len - str1Len);
+ expr_ref m_deltaStr(mk_concat(m, mk_string(deltaStr)), mgr);
+ if (!in_same_eqc(x, m_deltaStr)) {
+ expr_ref implyR(ctx.mk_eq_atom(x, m_deltaStr), mgr);
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ }
+ }
+ }
+ }
+
+ /*************************************************************
+ * case 6: concat("str1", y) = concat(m, "str2")
+ *************************************************************/
+ bool theory_str::is_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+ if (u.str.is_string(v1_arg0) && (!u.str.is_string(v1_arg1))
+ && (!u.str.is_string(v2_arg0)) && u.str.is_string(v2_arg1)) {
+ return true;
+ } else if (u.str.is_string(v2_arg0) && (!u.str.is_string(v2_arg1))
+ && (!u.str.is_string(v1_arg0)) && u.str.is_string(v1_arg1)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+ TRACE("str", tout << "process_concat_eq TYPE 6" << std::endl
+ << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl
+ << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl;
+ );
+
+ if (!u.str.is_concat(to_app(concatAst1))) {
+ TRACE("str", tout << "concatAst1 is not a concat function" << std::endl;);
+ return;
+ }
+ if (!u.str.is_concat(to_app(concatAst2))) {
+ TRACE("str", tout << "concatAst2 is not a concat function" << std::endl;);
+ return;
+ }
+
+ expr * v1_arg0 = to_app(concatAst1)->get_arg(0);
+ expr * v1_arg1 = to_app(concatAst1)->get_arg(1);
+ expr * v2_arg0 = to_app(concatAst2)->get_arg(0);
+ expr * v2_arg1 = to_app(concatAst2)->get_arg(1);
+
+
+ expr * str1Ast = NULL;
+ expr * y = NULL;
+ expr * m = NULL;
+ expr * str2Ast = NULL;
+
+ if (u.str.is_string(v1_arg0)) {
+ str1Ast = v1_arg0;
+ y = v1_arg1;
+ m = v2_arg0;
+ str2Ast = v2_arg1;
+ } else {
+ str1Ast = v2_arg0;
+ y = v2_arg1;
+ m = v1_arg0;
+ str2Ast = v1_arg1;
+ }
+
+ zstring str1Value, str2Value;
+ u.str.is_string(str1Ast, str1Value);
+ u.str.is_string(str2Ast, str2Value);
+
+ unsigned int str1Len = str1Value.length();
+ unsigned int str2Len = str2Value.length();
+
+ //----------------------------------------
+ //(a) |---str1---|----y----|
+ // |--m--|-----str2-----|
+ //
+ //(b) |---str1---|----y----|
+ // |-----m----|--str2---|
+ //
+ //(c) |---str1---|----y----|
+ // |------m------|-str2-|
+ //----------------------------------------
+
+ std::list<unsigned int> overlapLen;
+ overlapLen.push_back(0);
+
+ for (unsigned int i = 1; i <= str1Len && i <= str2Len; i++) {
+ if (str1Value.extract(str1Len - i, i) == str2Value.extract(0, i))
+ overlapLen.push_back(i);
+ }
+
+ //----------------------------------------------------------------
+ expr * commonVar = NULL;
+ expr * xorFlag = NULL;
+ std::pair<expr*, expr*> key1(concatAst1, concatAst2);
+ std::pair<expr*, expr*> key2(concatAst2, concatAst1);
+
+ // check the entries in this map to make sure they're still in scope
+ // before we use them.
+
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
+
+ bool entry1InScope;
+ if (entry1 == varForBreakConcat.end()) {
+ entry1InScope = false;
+ } else {
+ if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()
+ /* || internal_variable_set.find((entry1->second)[1]) == internal_variable_set.end() */) {
+ entry1InScope = false;
+ } else {
+ entry1InScope = true;
+ }
+ }
+
+ bool entry2InScope;
+ if (entry2 == varForBreakConcat.end()) {
+ entry2InScope = false;
+ } else {
+ if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()
+ /* || internal_variable_set.find((entry2->second)[1]) == internal_variable_set.end() */) {
+ entry2InScope = false;
+ } else {
+ entry2InScope = true;
+ }
+ }
+
+ TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
+
+ if (!entry1InScope && !entry2InScope) {
+ commonVar = mk_nonempty_str_var();
+ xorFlag = mk_internal_xor_var();
+ varForBreakConcat[key1][0] = commonVar;
+ varForBreakConcat[key1][1] = xorFlag;
+ } else {
+ if (entry1InScope) {
+ commonVar = (entry1->second)[0];
+ xorFlag = (entry1->second)[1];
+ } else {
+ commonVar = (entry2->second)[0];
+ xorFlag = (entry2->second)[1];
+ }
+ refresh_theory_var(commonVar);
+ add_nonempty_constraint(commonVar);
+ }
+
+ bool overlapAssumptionUsed = false;
+
+ expr_ref_vector arrangement_disjunction(mgr);
+ int pos = 1;
+
+ if (!avoidLoopCut || !has_self_cut(m, y)) {
+ expr_ref_vector and_item(mgr);
+
+ expr_ref str1_commonVar(mk_concat(str1Ast, commonVar), mgr);
+ and_item.push_back(ctx.mk_eq_atom(m, str1_commonVar));
+ pos += 1;
+
+ expr_ref commonVar_str2(mk_concat(commonVar, str2Ast), mgr);
+ and_item.push_back(ctx.mk_eq_atom(y, commonVar_str2));
+ pos += 1;
+
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(m),
+ m_autil.mk_add(mk_strlen(str1Ast), mk_strlen(commonVar)) ));
+ pos += 1;
+
+ // addItems[0] = mk_length(t, commonVar);
+ // addItems[1] = mk_length(t, str2Ast);
+ // and_item[pos++] = Z3_mk_eq(ctx, or_item[option], Z3_mk_eq(ctx, mk_length(t, y), Z3_mk_add(ctx, 2, addItems)));
+
+ expr_ref option1(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option1);
+ add_theory_aware_branching_info(option1, 0.1, l_true);
+ } else {
+ loopDetected = true;
+
+ if (m_params.m_FiniteOverlapModels) {
+ expr_ref tester = set_up_finite_model_test(concatAst1, concatAst2);
+ arrangement_disjunction.push_back(tester);
+ add_theory_aware_branching_info(tester, m_params.m_OverlapTheoryAwarePriority, l_true);
+ } else {
+ TRACE("str", tout << "AVOID LOOP: SKIPPED." << std::endl;);
+ TRACE("str", print_cut_var(m, tout); print_cut_var(y, tout););
+
+ // only add the overlap assumption one time
+ if (!overlapAssumptionUsed) {
+ arrangement_disjunction.push_back(m_theoryStrOverlapAssumption_term);
+ overlapAssumptionUsed = true;
+ }
+ }
+ }
+
+ for (std::list<unsigned int>::iterator itor = overlapLen.begin(); itor != overlapLen.end(); itor++) {
+ unsigned int overLen = *itor;
+ zstring prefix = str1Value.extract(0, str1Len - overLen);
+ zstring suffix = str2Value.extract(overLen, str2Len - overLen);
+
+ expr_ref_vector and_item(mgr);
+
+ expr_ref prefixAst(mk_string(prefix), mgr);
+ expr_ref x_eq_prefix(ctx.mk_eq_atom(m, prefixAst), mgr);
+ and_item.push_back(x_eq_prefix);
+ pos += 1;
+
+ and_item.push_back(
+ ctx.mk_eq_atom(mk_strlen(m), mk_strlen(prefixAst)));
+ pos += 1;
+
+ // adding length constraint for _ = constStr seems slowing things down.
+
+ expr_ref suffixAst(mk_string(suffix), mgr);
+ expr_ref y_eq_suffix(ctx.mk_eq_atom(y, suffixAst), mgr);
+ and_item.push_back(y_eq_suffix);
+ pos += 1;
+
+ and_item.push_back(ctx.mk_eq_atom(mk_strlen(y), mk_strlen(suffixAst)));
+ pos += 1;
+
+ expr_ref option2(mk_and(and_item), mgr);
+ arrangement_disjunction.push_back(option2);
+ double priority;
+ // prefer the option "str1" = x
+ if (prefix == str1Value) {
+ priority = 0.5;
+ } else {
+ priority = 0.1;
+ }
+ add_theory_aware_branching_info(option2, priority, l_true);
+ }
+
+ // case 6: concat("str1", y) = concat(m, "str2")
+
+ expr_ref implyR(mk_or(arrangement_disjunction), mgr);
+
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom( ctx.mk_eq_atom(concatAst1, concatAst2), implyR ), mgr);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(ctx.mk_eq_atom(concatAst1, concatAst2), implyR);
+ }
+ generate_mutual_exclusion(arrangement_disjunction);
+ }
+
+ void theory_str::process_unroll_eq_const_str(expr * unrollFunc, expr * constStr) {
+ ast_manager & m = get_manager();
+
+ if (!u.re.is_unroll(to_app(unrollFunc))) {
+ return;
+ }
+ if (!u.str.is_string(constStr)) {
+ return;
+ }
+
+ expr * funcInUnroll = to_app(unrollFunc)->get_arg(0);
+ zstring strValue;
+ u.str.is_string(constStr, strValue);
+
+ TRACE("str", tout << "unrollFunc: " << mk_pp(unrollFunc, m) << std::endl
+ << "constStr: " << mk_pp(constStr, m) << std::endl;);
+
+ if (strValue == "") {
+ return;
+ }
+
+ if (u.re.is_to_re(to_app(funcInUnroll))) {
+ unroll_str2reg_constStr(unrollFunc, constStr);
+ return;
+ }
+ }
+
+ void theory_str::process_concat_eq_unroll(expr * concat, expr * unroll) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ TRACE("str", tout << "concat = " << mk_pp(concat, mgr) << ", unroll = " << mk_pp(unroll, mgr) << std::endl;);
+
+ std::pair<expr*, expr*> key = std::make_pair(concat, unroll);
+ expr_ref toAssert(mgr);
+
+ if (concat_eq_unroll_ast_map.find(key) == concat_eq_unroll_ast_map.end()) {
+ expr_ref arg1(to_app(concat)->get_arg(0), mgr);
+ expr_ref arg2(to_app(concat)->get_arg(1), mgr);
+ expr_ref r1(to_app(unroll)->get_arg(0), mgr);
+ expr_ref t1(to_app(unroll)->get_arg(1), mgr);
+
+ expr_ref v1(mk_regex_rep_var(), mgr);
+ expr_ref v2(mk_regex_rep_var(), mgr);
+ expr_ref v3(mk_regex_rep_var(), mgr);
+ expr_ref v4(mk_regex_rep_var(), mgr);
+ expr_ref v5(mk_regex_rep_var(), mgr);
+
+ expr_ref t2(mk_unroll_bound_var(), mgr);
+ expr_ref t3(mk_unroll_bound_var(), mgr);
+ expr_ref emptyStr(mk_string(""), mgr);
+
+ expr_ref unroll1(mk_unroll(r1, t2), mgr);
+ expr_ref unroll2(mk_unroll(r1, t3), mgr);
+
+ expr_ref op0(ctx.mk_eq_atom(t1, mk_int(0)), mgr);
+ expr_ref op1(m_autil.mk_ge(t1, mk_int(1)), mgr);
+
+ expr_ref_vector op1Items(mgr);
+ expr_ref_vector op2Items(mgr);
+
+ op1Items.push_back(ctx.mk_eq_atom(arg1, emptyStr));
+ op1Items.push_back(ctx.mk_eq_atom(arg2, emptyStr));
+ op1Items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(0)));
+ op1Items.push_back(ctx.mk_eq_atom(mk_strlen(arg2), mk_int(0)));
+ expr_ref opAnd1(ctx.mk_eq_atom(op0, mk_and(op1Items)), mgr);
+
+ expr_ref v1v2(mk_concat(v1, v2), mgr);
+ op2Items.push_back(ctx.mk_eq_atom(arg1, v1v2));
+ op2Items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), m_autil.mk_add(mk_strlen(v1), mk_strlen(v2))));
+ expr_ref v3v4(mk_concat(v3, v4), mgr);
+ op2Items.push_back(ctx.mk_eq_atom(arg2, v3v4));
+ op2Items.push_back(ctx.mk_eq_atom(mk_strlen(arg2), m_autil.mk_add(mk_strlen(v3), mk_strlen(v4))));
+
+ op2Items.push_back(ctx.mk_eq_atom(v1, unroll1));
+ op2Items.push_back(ctx.mk_eq_atom(mk_strlen(v1), mk_strlen(unroll1)));
+ op2Items.push_back(ctx.mk_eq_atom(v4, unroll2));
+ op2Items.push_back(ctx.mk_eq_atom(mk_strlen(v4), mk_strlen(unroll2)));
+ expr_ref v2v3(mk_concat(v2, v3), mgr);
+ op2Items.push_back(ctx.mk_eq_atom(v5, v2v3));
+ reduce_virtual_regex_in(v5, r1, op2Items);
+ op2Items.push_back(ctx.mk_eq_atom(mk_strlen(v5), m_autil.mk_add(mk_strlen(v2), mk_strlen(v3))));
+ op2Items.push_back(ctx.mk_eq_atom(m_autil.mk_add(t2, t3), m_autil.mk_add(t1, mk_int(-1))));
+ expr_ref opAnd2(ctx.mk_eq_atom(op1, mk_and(op2Items)), mgr);
+
+ toAssert = mgr.mk_and(opAnd1, opAnd2);
+ m_trail.push_back(toAssert);
+ concat_eq_unroll_ast_map[key] = toAssert;
+ } else {
+ toAssert = concat_eq_unroll_ast_map[key];
+ }
+
+ assert_axiom(toAssert);
+ }
+
+ void theory_str::unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr * str2RegFunc = to_app(unrollFunc)->get_arg(0);
+ expr * strInStr2RegFunc = to_app(str2RegFunc)->get_arg(0);
+ expr * oriCnt = to_app(unrollFunc)->get_arg(1);
+
+ zstring strValue;
+ u.str.is_string(eqConstStr, strValue);
+ zstring regStrValue;
+ u.str.is_string(strInStr2RegFunc, regStrValue);
+ unsigned int strLen = strValue.length();
+ unsigned int regStrLen = regStrValue.length();
+ SASSERT(regStrLen != 0); // this should never occur -- the case for empty string is handled elsewhere
+ unsigned int cnt = strLen / regStrLen;
+
+ expr_ref implyL(ctx.mk_eq_atom(unrollFunc, eqConstStr), m);
+ expr_ref implyR1(ctx.mk_eq_atom(oriCnt, mk_int(cnt)), m);
+ expr_ref implyR2(ctx.mk_eq_atom(mk_strlen(unrollFunc), mk_int(strLen)), m);
+ expr_ref axiomRHS(m.mk_and(implyR1, implyR2), m);
+ SASSERT(implyL);
+ SASSERT(axiomRHS);
+ assert_implication(implyL, axiomRHS);
+ }
+
+ /*
+ * Look through the equivalence class of n to find a string constant.
+ * Return that constant if it is found, and set hasEqcValue to true.
+ * Otherwise, return n, and set hasEqcValue to false.
+ */
+
+ expr * theory_str::get_eqc_value(expr * n, bool & hasEqcValue) {
+ return z3str2_get_eqc_value(n, hasEqcValue);
+ }
+
+
+ // Simulate the behaviour of get_eqc_value() from Z3str2.
+ // We only check m_find for a string constant.
+
+ expr * theory_str::z3str2_get_eqc_value(expr * n , bool & hasEqcValue) {
+ expr * curr = n;
+ do {
+ if (u.str.is_string(curr)) {
+ hasEqcValue = true;
+ return curr;
+ }
+ curr = get_eqc_next(curr);
+ } while (curr != n);
+ hasEqcValue = false;
+ return n;
+ }
+
+ // from Z3: theory_seq.cpp
+
+ static theory_mi_arith* get_th_arith(context& ctx, theory_id afid, expr* e) {
+ theory* th = ctx.get_theory(afid);
+ if (th && ctx.e_internalized(e)) {
+ return dynamic_cast<theory_mi_arith*>(th);
+ }
+ else {
+ return 0;
+ }
+ }
+
+ bool theory_str::get_value(expr* e, rational& val) const {
+ if (opt_DisableIntegerTheoryIntegration) {
+ TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ return false;
+ }
+
+ context& ctx = get_context();
+ ast_manager & m = get_manager();
+ theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e);
+ if (!tha) {
+ return false;
+ }
+ TRACE("str", tout << "checking eqc of " << mk_pp(e, m) << " for arithmetic value" << std::endl;);
+ expr_ref _val(m);
+ enode * en_e = ctx.get_enode(e);
+ enode * it = en_e;
+ do {
+ if (m_autil.is_numeral(it->get_owner(), val) && val.is_int()) {
+ // found an arithmetic term
+ TRACE("str", tout << mk_pp(it->get_owner(), m) << " is an integer ( ~= " << val << " )"
+ << std::endl;);
+ return true;
+ } else {
+ TRACE("str", tout << mk_pp(it->get_owner(), m) << " not a numeral" << std::endl;);
+ }
+ it = it->get_next();
+ } while (it != en_e);
+ TRACE("str", tout << "no arithmetic values found in eqc" << std::endl;);
+ return false;
+ }
+
+ bool theory_str::lower_bound(expr* _e, rational& lo) {
+ if (opt_DisableIntegerTheoryIntegration) {
+ TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ return false;
+ }
+
+ context& ctx = get_context();
+ ast_manager & m = get_manager();
+ theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), _e);
+ expr_ref _lo(m);
+ if (!tha || !tha->get_lower(ctx.get_enode(_e), _lo)) return false;
+ return m_autil.is_numeral(_lo, lo) && lo.is_int();
+ }
+
+ bool theory_str::upper_bound(expr* _e, rational& hi) {
+ if (opt_DisableIntegerTheoryIntegration) {
+ TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ return false;
+ }
+
+ context& ctx = get_context();
+ ast_manager & m = get_manager();
+ theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), _e);
+ expr_ref _hi(m);
+ if (!tha || !tha->get_upper(ctx.get_enode(_e), _hi)) return false;
+ return m_autil.is_numeral(_hi, hi) && hi.is_int();
+ }
+
+ bool theory_str::get_len_value(expr* e, rational& val) {
+ if (opt_DisableIntegerTheoryIntegration) {
+ TRACE("str", tout << "WARNING: integer theory integration disabled" << std::endl;);
+ return false;
+ }
+
+ context& ctx = get_context();
+ ast_manager & m = get_manager();
+
+ theory* th = ctx.get_theory(m_autil.get_family_id());
+ if (!th) {
+ TRACE("str", tout << "oops, can't get m_autil's theory" << std::endl;);
+ return false;
+ }
+ theory_mi_arith* tha = dynamic_cast<theory_mi_arith*>(th);
+ if (!tha) {
+ TRACE("str", tout << "oops, can't cast to theory_mi_arith" << std::endl;);
+ return false;
+ }
+
+ TRACE("str", tout << "checking len value of " << mk_ismt2_pp(e, m) << std::endl;);
+
+ rational val1;
+ expr_ref len(m), len_val(m);
+ expr* e1, *e2;
+ ptr_vector<expr> todo;
+ todo.push_back(e);
+ val.reset();
+ while (!todo.empty()) {
+ expr* c = todo.back();
+ todo.pop_back();
+ if (u.str.is_concat(to_app(c))) {
+ e1 = to_app(c)->get_arg(0);
+ e2 = to_app(c)->get_arg(1);
+ todo.push_back(e1);
+ todo.push_back(e2);
+ }
+ else if (u.str.is_string(to_app(c))) {
+ zstring tmp;
+ u.str.is_string(to_app(c), tmp);
+ unsigned int sl = tmp.length();
+ val += rational(sl);
+ }
+ else {
+ len = mk_strlen(c);
+
+ // debugging
+ TRACE("str", {
+ tout << mk_pp(len, m) << ":" << std::endl
+ << (ctx.is_relevant(len.get()) ? "relevant" : "not relevant") << std::endl
+ << (ctx.e_internalized(len) ? "internalized" : "not internalized") << std::endl
+ ;
+ if (ctx.e_internalized(len)) {
+ enode * e_len = ctx.get_enode(len);
+ tout << "has " << e_len->get_num_th_vars() << " theory vars" << std::endl;
+
+ // eqc debugging
+ {
+ tout << "dump equivalence class of " << mk_pp(len, get_manager()) << std::endl;
+ enode * nNode = ctx.get_enode(len);
+ enode * eqcNode = nNode;
+ do {
+ app * ast = eqcNode->get_owner();
+ tout << mk_pp(ast, get_manager()) << std::endl;
+ eqcNode = eqcNode->get_next();
+ } while (eqcNode != nNode);
}
}
- if (counterEgFound) {
- TRACE("str", tout << "Inconsistency found!" << std::endl;);
- break;
- }
- }
+ });
+
+ if (ctx.e_internalized(len) && get_value(len, val1)) {
+ val += val1;
+ TRACE("str", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has length " << val1 << std::endl;);
}
- // add assertion
- if (implyR) {
- expr_ref implyLHS(mk_and(litems), m);
- assert_implication(implyLHS, implyR);
+ else {
+ TRACE("str", tout << "integer theory: subexpression " << mk_ismt2_pp(len, m) << " has no length assignment; bailing out" << std::endl;);
+ return false;
}
}
- // varEqcNode is subStr
- else if (substrAst == varNode) {
- expr_ref implyR(m);
- litems.reset();
+ }
- if (substrAst != constNode) {
- litems.push_back(ctx.mk_eq_atom(substrAst, constNode));
- }
- bool strHasEqcValue = false;
- expr * strValue = get_eqc_value(strAst, strHasEqcValue);
- if (strValue != strAst) {
- litems.push_back(ctx.mk_eq_atom(strAst, strValue));
- }
+ TRACE("str", tout << "length of " << mk_ismt2_pp(e, m) << " is " << val << std::endl;);
+ return val.is_int();
+ }
- if (strHasEqcValue) {
- zstring strConst, subStrConst;
- u.str.is_string(strValue, strConst);
- u.str.is_string(constNode, subStrConst);
- if (strConst.contains(subStrConst)) {
- //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_true(ctx));
- implyR = boolVar;
- } else {
- // implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
- implyR = m.mk_not(boolVar);
- }
- }
+ /*
+ * Decide whether n1 and n2 are already in the same equivalence class.
+ * This only checks whether the core considers them to be equal;
+ * they may not actually be equal.
+ */
+ bool theory_str::in_same_eqc(expr * n1, expr * n2) {
+ if (n1 == n2) return true;
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
- // add assertion
- if (implyR) {
- expr_ref implyLHS(mk_and(litems), m);
- assert_implication(implyLHS, implyR);
- }
+ // similar to get_eqc_value(), make absolutely sure
+ // that we've set this up properly for the context
+
+ if (!ctx.e_internalized(n1)) {
+ TRACE("str", tout << "WARNING: expression " << mk_ismt2_pp(n1, m) << " was not internalized" << std::endl;);
+ ctx.internalize(n1, false);
+ }
+ if (!ctx.e_internalized(n2)) {
+ TRACE("str", tout << "WARNING: expression " << mk_ismt2_pp(n2, m) << " was not internalized" << std::endl;);
+ ctx.internalize(n2, false);
+ }
+
+ expr * curr = get_eqc_next(n1);
+ while (curr != n1) {
+ if (curr == n2)
+ return true;
+ curr = get_eqc_next(curr);
+ }
+ return false;
+ }
+
+ expr * theory_str::collect_eq_nodes(expr * n, expr_ref_vector & eqcSet) {
+ context & ctx = get_context();
+ expr * constStrNode = NULL;
+
+ expr * ex = n;
+ do {
+ if (u.str.is_string(to_app(ex))) {
+ constStrNode = ex;
}
- } // for (itor1 : contains_map)
- } // if varNode in contain_pair_idx_map
-}
+ eqcSet.push_back(ex);
-void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
- expr_ref_vector litems(m);
+ ex = get_eqc_next(ex);
+ } while (ex != n);
+ return constStrNode;
+ }
- if (contain_pair_idx_map.find(varNode) != contain_pair_idx_map.end()) {
- std::set<std::pair<expr*, expr*> >::iterator itor1 = contain_pair_idx_map[varNode].begin();
- for (; itor1 != contain_pair_idx_map[varNode].end(); ++itor1) {
- expr * strAst = itor1->first;
- expr * substrAst = itor1->second;
-
- expr * boolVar;
- if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
- TRACE("str", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
+ /*
+ * Collect constant strings (from left to right) in an AST node.
+ */
+ void theory_str::get_const_str_asts_in_node(expr * node, expr_ref_vector & astList) {
+ ast_manager & m = get_manager();
+ if (u.str.is_string(node)) {
+ astList.push_back(node);
+ //} else if (getNodeType(t, node) == my_Z3_Func) {
+ } else if (is_app(node)) {
+ app * func_app = to_app(node);
+ unsigned int argCount = func_app->get_num_args();
+ for (unsigned int i = 0; i < argCount; i++) {
+ expr * argAst = func_app->get_arg(i);
+ get_const_str_asts_in_node(argAst, astList);
}
- // boolVar is actually a Contains term
- app * containsApp = to_app(boolVar);
+ }
+ }
- // we only want to inspect the Contains terms where either of strAst or substrAst
- // are equal to varNode.
+ void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
- TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
+ TRACE("str", tout << "varNode = " << mk_pp(varNode, m) << ", constNode = " << mk_pp(constNode, m) << std::endl;);
- if (varNode != strAst && varNode != substrAst) {
- TRACE("str", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
- continue;
- }
- TRACE("str", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
+ expr_ref_vector litems(m);
- if (substrAst == varNode) {
- bool strAstHasVal = false;
- expr * strValue = get_eqc_value(strAst, strAstHasVal);
- if (strAstHasVal) {
- TRACE("str", tout << mk_pp(strAst, m) << " has constant eqc value " << mk_pp(strValue, m) << std::endl;);
- if (strValue != strAst) {
- litems.push_back(ctx.mk_eq_atom(strAst, strValue));
+ if (contain_pair_idx_map.find(varNode) != contain_pair_idx_map.end()) {
+ std::set<std::pair<expr*, expr*> >::iterator itor1 = contain_pair_idx_map[varNode].begin();
+ for (; itor1 != contain_pair_idx_map[varNode].end(); ++itor1) {
+ expr * strAst = itor1->first;
+ expr * substrAst = itor1->second;
+
+ expr * boolVar;
+ if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
+ TRACE("str", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
+ }
+ // boolVar is actually a Contains term
+ app * containsApp = to_app(boolVar);
+
+ // we only want to inspect the Contains terms where either of strAst or substrAst
+ // are equal to varNode.
+
+ TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
+
+ if (varNode != strAst && varNode != substrAst) {
+ TRACE("str", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
+ continue;
+ }
+ TRACE("str", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
+
+ // varEqcNode is str
+ if (strAst == varNode) {
+ expr_ref implyR(m);
+ litems.reset();
+
+ if (strAst != constNode) {
+ litems.push_back(ctx.mk_eq_atom(strAst, constNode));
}
zstring strConst;
- u.str.is_string(strValue, strConst);
- // iterate eqc (also eqc-to-be) of substr
- for (expr_ref_vector::iterator itAst = willEqClass.begin(); itAst != willEqClass.end(); itAst++) {
- bool counterEgFound = false;
- if (u.str.is_concat(to_app(*itAst))) {
+ u.str.is_string(constNode, strConst);
+ bool subStrHasEqcValue = false;
+ expr * substrValue = get_eqc_value(substrAst, subStrHasEqcValue);
+ if (substrValue != substrAst) {
+ litems.push_back(ctx.mk_eq_atom(substrAst, substrValue));
+ }
+
+ if (subStrHasEqcValue) {
+ // subStr has an eqc constant value
+ zstring subStrConst;
+ u.str.is_string(substrValue, subStrConst);
+
+ TRACE("t_str_detail", tout << "strConst = " << strConst << ", subStrConst = " << subStrConst << "\n";);
+
+ if (strConst.contains(subStrConst)) {
+ //implyR = ctx.mk_eq(ctx, boolVar, Z3_mk_true(ctx));
+ implyR = boolVar;
+ } else {
+ //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
+ implyR = m.mk_not(boolVar);
+ }
+ } else {
+ // ------------------------------------------------------------------------------------------------
+ // subStr doesn't have an eqc contant value
+ // however, subStr equals to some concat(arg_1, arg_2, ..., arg_n)
+ // if arg_j is a constant and is not a part of the strConst, it's sure that the contains is false
+ // ** This check is needed here because the "strConst" and "strAst" may not be in a same eqc yet
+ // ------------------------------------------------------------------------------------------------
+ // collect eqc concat
+ std::set<expr*> eqcConcats;
+ get_concats_in_eqc(substrAst, eqcConcats);
+ for (std::set<expr*>::iterator concatItor = eqcConcats.begin();
+ concatItor != eqcConcats.end(); concatItor++) {
expr_ref_vector constList(m);
+ bool counterEgFound = false;
// get constant strings in concat
- app * aConcat = to_app(*itAst);
+ expr * aConcat = *concatItor;
get_const_str_asts_in_node(aConcat, constList);
for (expr_ref_vector::iterator cstItor = constList.begin();
- cstItor != constList.end(); cstItor++) {
+ cstItor != constList.end(); cstItor++) {
zstring pieceStr;
u.str.is_string(*cstItor, pieceStr);
if (!strConst.contains(pieceStr)) {
- TRACE("str", tout << "Inconsistency found!" << std::endl;);
counterEgFound = true;
if (aConcat != substrAst) {
litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
}
- expr_ref implyLHS(mk_and(litems), m);
- expr_ref implyR(m.mk_not(boolVar), m);
- assert_implication(implyLHS, implyR);
+ //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
+ implyR = m.mk_not(boolVar);
break;
}
}
- }
- if (counterEgFound) {
- break;
+ if (counterEgFound) {
+ TRACE("str", tout << "Inconsistency found!" << std::endl;);
+ break;
+ }
}
}
+ // add assertion
+ if (implyR) {
+ expr_ref implyLHS(mk_and(litems), m);
+ assert_implication(implyLHS, implyR);
+ }
}
- }
- }
- } // varNode in contain_pair_idx_map
-}
+ // varEqcNode is subStr
+ else if (substrAst == varNode) {
+ expr_ref implyR(m);
+ litems.reset();
-bool theory_str::in_contain_idx_map(expr * n) {
- return contain_pair_idx_map.find(n) != contain_pair_idx_map.end();
-}
+ if (substrAst != constNode) {
+ litems.push_back(ctx.mk_eq_atom(substrAst, constNode));
+ }
+ bool strHasEqcValue = false;
+ expr * strValue = get_eqc_value(strAst, strHasEqcValue);
+ if (strValue != strAst) {
+ litems.push_back(ctx.mk_eq_atom(strAst, strValue));
+ }
-void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
+ if (strHasEqcValue) {
+ zstring strConst, subStrConst;
+ u.str.is_string(strValue, strConst);
+ u.str.is_string(constNode, subStrConst);
+ if (strConst.contains(subStrConst)) {
+ //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_true(ctx));
+ implyR = boolVar;
+ } else {
+ // implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx));
+ implyR = m.mk_not(boolVar);
+ }
+ }
- if (in_contain_idx_map(n1) && in_contain_idx_map(n2)) {
- std::set<std::pair<expr*, expr*> >::iterator keysItor1 = contain_pair_idx_map[n1].begin();
- std::set<std::pair<expr*, expr*> >::iterator keysItor2;
-
- for (; keysItor1 != contain_pair_idx_map[n1].end(); keysItor1++) {
- // keysItor1 is on set {<.., n1>, ..., <n1, ...>, ...}
- std::pair<expr*, expr*> key1 = *keysItor1;
- if (key1.first == n1 && key1.second == n2) {
- expr_ref implyL(m);
- expr_ref implyR(contain_pair_bool_map[key1], m);
- if (n1 != n2) {
- implyL = ctx.mk_eq_atom(n1, n2);
- assert_implication(implyL, implyR);
- } else {
- assert_axiom(implyR);
+ // add assertion
+ if (implyR) {
+ expr_ref implyLHS(mk_and(litems), m);
+ assert_implication(implyLHS, implyR);
+ }
}
- }
+ } // for (itor1 : contains_map)
+ } // if varNode in contain_pair_idx_map
+ }
- for (keysItor2 = contain_pair_idx_map[n2].begin();
- keysItor2 != contain_pair_idx_map[n2].end(); keysItor2++) {
- // keysItor2 is on set {<.., n2>, ..., <n2, ...>, ...}
- std::pair<expr*, expr*> key2 = *keysItor2;
- // skip if the pair is eq
- if (key1 == key2) {
+ void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ expr_ref_vector litems(m);
+
+ if (contain_pair_idx_map.find(varNode) != contain_pair_idx_map.end()) {
+ std::set<std::pair<expr*, expr*> >::iterator itor1 = contain_pair_idx_map[varNode].begin();
+ for (; itor1 != contain_pair_idx_map[varNode].end(); ++itor1) {
+ expr * strAst = itor1->first;
+ expr * substrAst = itor1->second;
+
+ expr * boolVar;
+ if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
+ TRACE("str", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
+ }
+ // boolVar is actually a Contains term
+ app * containsApp = to_app(boolVar);
+
+ // we only want to inspect the Contains terms where either of strAst or substrAst
+ // are equal to varNode.
+
+ TRACE("t_str_detail", tout << "considering Contains with strAst = " << mk_pp(strAst, m) << ", substrAst = " << mk_pp(substrAst, m) << "..." << std::endl;);
+
+ if (varNode != strAst && varNode != substrAst) {
+ TRACE("str", tout << "varNode not equal to strAst or substrAst, skip" << std::endl;);
continue;
}
+ TRACE("str", tout << "varNode matched one of strAst or substrAst. Continuing" << std::endl;);
- // ***************************
- // Case 1: Contains(m, ...) /\ Contains(n, ) /\ m = n
- // ***************************
- if (key1.first == n1 && key2.first == n2) {
- expr * subAst1 = key1.second;
- expr * subAst2 = key2.second;
- bool subAst1HasValue = false;
- bool subAst2HasValue = false;
- expr * subValue1 = get_eqc_value(subAst1, subAst1HasValue);
- expr * subValue2 = get_eqc_value(subAst2, subAst2HasValue);
-
- TRACE("str",
- tout << "(Contains " << mk_pp(n1, m) << " " << mk_pp(subAst1, m) << ")" << std::endl;
- tout << "(Contains " << mk_pp(n2, m) << " " << mk_pp(subAst2, m) << ")" << std::endl;
- if (subAst1 != subValue1) {
- tout << mk_pp(subAst1, m) << " = " << mk_pp(subValue1, m) << std::endl;
+ if (substrAst == varNode) {
+ bool strAstHasVal = false;
+ expr * strValue = get_eqc_value(strAst, strAstHasVal);
+ if (strAstHasVal) {
+ TRACE("str", tout << mk_pp(strAst, m) << " has constant eqc value " << mk_pp(strValue, m) << std::endl;);
+ if (strValue != strAst) {
+ litems.push_back(ctx.mk_eq_atom(strAst, strValue));
+ }
+ zstring strConst;
+ u.str.is_string(strValue, strConst);
+ // iterate eqc (also eqc-to-be) of substr
+ for (expr_ref_vector::iterator itAst = willEqClass.begin(); itAst != willEqClass.end(); itAst++) {
+ bool counterEgFound = false;
+ if (u.str.is_concat(to_app(*itAst))) {
+ expr_ref_vector constList(m);
+ // get constant strings in concat
+ app * aConcat = to_app(*itAst);
+ get_const_str_asts_in_node(aConcat, constList);
+ for (expr_ref_vector::iterator cstItor = constList.begin();
+ cstItor != constList.end(); cstItor++) {
+ zstring pieceStr;
+ u.str.is_string(*cstItor, pieceStr);
+ if (!strConst.contains(pieceStr)) {
+ TRACE("str", tout << "Inconsistency found!" << std::endl;);
+ counterEgFound = true;
+ if (aConcat != substrAst) {
+ litems.push_back(ctx.mk_eq_atom(substrAst, aConcat));
+ }
+ expr_ref implyLHS(mk_and(litems), m);
+ expr_ref implyR(m.mk_not(boolVar), m);
+ assert_implication(implyLHS, implyR);
+ break;
+ }
+ }
}
- if (subAst2 != subValue2) {
- tout << mk_pp(subAst2, m) << " = " << mk_pp(subValue2, m) << std::endl;
- }
- );
-
- if (subAst1HasValue && subAst2HasValue) {
- expr_ref_vector litems1(m);
- if (n1 != n2) {
- litems1.push_back(ctx.mk_eq_atom(n1, n2));
- }
- if (subValue1 != subAst1) {
- litems1.push_back(ctx.mk_eq_atom(subAst1, subValue1));
- }
- if (subValue2 != subAst2) {
- litems1.push_back(ctx.mk_eq_atom(subAst2, subValue2));
- }
-
- zstring subConst1, subConst2;
- u.str.is_string(subValue1, subConst1);
- u.str.is_string(subValue2, subConst2);
- expr_ref implyR(m);
- if (subConst1 == subConst2) {
- // key1.first = key2.first /\ key1.second = key2.second
- // ==> (containPairBoolMap[key1] = containPairBoolMap[key2])
- implyR = ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
- } else if (subConst1.contains(subConst2)) {
- // key1.first = key2.first /\ Contains(key1.second, key2.second)
- // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
- implyR = rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
- } else if (subConst2.contains(subConst1)) {
- // key1.first = key2.first /\ Contains(key2.second, key1.second)
- // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
- implyR = rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]);
- }
-
- if (implyR) {
- if (litems1.empty()) {
- assert_axiom(implyR);
- } else {
- assert_implication(mk_and(litems1), implyR);
+ if (counterEgFound) {
+ break;
}
}
+ }
+ }
+ }
+ } // varNode in contain_pair_idx_map
+ }
+
+ bool theory_str::in_contain_idx_map(expr * n) {
+ return contain_pair_idx_map.find(n) != contain_pair_idx_map.end();
+ }
+
+ void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ if (in_contain_idx_map(n1) && in_contain_idx_map(n2)) {
+ std::set<std::pair<expr*, expr*> >::iterator keysItor1 = contain_pair_idx_map[n1].begin();
+ std::set<std::pair<expr*, expr*> >::iterator keysItor2;
+
+ for (; keysItor1 != contain_pair_idx_map[n1].end(); keysItor1++) {
+ // keysItor1 is on set {<.., n1>, ..., <n1, ...>, ...}
+ std::pair<expr*, expr*> key1 = *keysItor1;
+ if (key1.first == n1 && key1.second == n2) {
+ expr_ref implyL(m);
+ expr_ref implyR(contain_pair_bool_map[key1], m);
+ if (n1 != n2) {
+ implyL = ctx.mk_eq_atom(n1, n2);
+ assert_implication(implyL, implyR);
} else {
- expr_ref_vector subAst1Eqc(m);
- expr_ref_vector subAst2Eqc(m);
- collect_eq_nodes(subAst1, subAst1Eqc);
- collect_eq_nodes(subAst2, subAst2Eqc);
+ assert_axiom(implyR);
+ }
+ }
- if (subAst1Eqc.contains(subAst2)) {
- // -----------------------------------------------------------
- // * key1.first = key2.first /\ key1.second = key2.second
- // --> containPairBoolMap[key1] = containPairBoolMap[key2]
- // -----------------------------------------------------------
- expr_ref_vector litems2(m);
+ for (keysItor2 = contain_pair_idx_map[n2].begin();
+ keysItor2 != contain_pair_idx_map[n2].end(); keysItor2++) {
+ // keysItor2 is on set {<.., n2>, ..., <n2, ...>, ...}
+ std::pair<expr*, expr*> key2 = *keysItor2;
+ // skip if the pair is eq
+ if (key1 == key2) {
+ continue;
+ }
+
+ // ***************************
+ // Case 1: Contains(m, ...) /\ Contains(n, ) /\ m = n
+ // ***************************
+ if (key1.first == n1 && key2.first == n2) {
+ expr * subAst1 = key1.second;
+ expr * subAst2 = key2.second;
+ bool subAst1HasValue = false;
+ bool subAst2HasValue = false;
+ expr * subValue1 = get_eqc_value(subAst1, subAst1HasValue);
+ expr * subValue2 = get_eqc_value(subAst2, subAst2HasValue);
+
+ TRACE("str",
+ tout << "(Contains " << mk_pp(n1, m) << " " << mk_pp(subAst1, m) << ")" << std::endl;
+ tout << "(Contains " << mk_pp(n2, m) << " " << mk_pp(subAst2, m) << ")" << std::endl;
+ if (subAst1 != subValue1) {
+ tout << mk_pp(subAst1, m) << " = " << mk_pp(subValue1, m) << std::endl;
+ }
+ if (subAst2 != subValue2) {
+ tout << mk_pp(subAst2, m) << " = " << mk_pp(subValue2, m) << std::endl;
+ }
+ );
+
+ if (subAst1HasValue && subAst2HasValue) {
+ expr_ref_vector litems1(m);
if (n1 != n2) {
- litems2.push_back(ctx.mk_eq_atom(n1, n2));
+ litems1.push_back(ctx.mk_eq_atom(n1, n2));
}
- if (subAst1 != subAst2) {
- litems2.push_back(ctx.mk_eq_atom(subAst1, subAst2));
+ if (subValue1 != subAst1) {
+ litems1.push_back(ctx.mk_eq_atom(subAst1, subValue1));
}
- expr_ref implyR(ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
- if (litems2.empty()) {
- assert_axiom(implyR);
- } else {
- assert_implication(mk_and(litems2), implyR);
+ if (subValue2 != subAst2) {
+ litems1.push_back(ctx.mk_eq_atom(subAst2, subValue2));
+ }
+
+ zstring subConst1, subConst2;
+ u.str.is_string(subValue1, subConst1);
+ u.str.is_string(subValue2, subConst2);
+ expr_ref implyR(m);
+ if (subConst1 == subConst2) {
+ // key1.first = key2.first /\ key1.second = key2.second
+ // ==> (containPairBoolMap[key1] = containPairBoolMap[key2])
+ implyR = ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
+ } else if (subConst1.contains(subConst2)) {
+ // key1.first = key2.first /\ Contains(key1.second, key2.second)
+ // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
+ implyR = rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
+ } else if (subConst2.contains(subConst1)) {
+ // key1.first = key2.first /\ Contains(key2.second, key1.second)
+ // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
+ implyR = rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]);
+ }
+
+ if (implyR) {
+ if (litems1.empty()) {
+ assert_axiom(implyR);
+ } else {
+ assert_implication(mk_and(litems1), implyR);
+ }
}
} else {
- // -----------------------------------------------------------
- // * key1.first = key2.first
- // check eqc(key1.second) and eqc(key2.second)
- // -----------------------------------------------------------
- expr_ref_vector::iterator eqItorSub1 = subAst1Eqc.begin();
- for (; eqItorSub1 != subAst1Eqc.end(); eqItorSub1++) {
- expr_ref_vector::iterator eqItorSub2 = subAst2Eqc.begin();
- for (; eqItorSub2 != subAst2Eqc.end(); eqItorSub2++) {
- // ------------
- // key1.first = key2.first /\ containPairBoolMap[<eqc(key1.second), eqc(key2.second)>]
- // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
- // ------------
- {
- expr_ref_vector litems3(m);
- if (n1 != n2) {
- litems3.push_back(ctx.mk_eq_atom(n1, n2));
+ expr_ref_vector subAst1Eqc(m);
+ expr_ref_vector subAst2Eqc(m);
+ collect_eq_nodes(subAst1, subAst1Eqc);
+ collect_eq_nodes(subAst2, subAst2Eqc);
+
+ if (subAst1Eqc.contains(subAst2)) {
+ // -----------------------------------------------------------
+ // * key1.first = key2.first /\ key1.second = key2.second
+ // --> containPairBoolMap[key1] = containPairBoolMap[key2]
+ // -----------------------------------------------------------
+ expr_ref_vector litems2(m);
+ if (n1 != n2) {
+ litems2.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ if (subAst1 != subAst2) {
+ litems2.push_back(ctx.mk_eq_atom(subAst1, subAst2));
+ }
+ expr_ref implyR(ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
+ if (litems2.empty()) {
+ assert_axiom(implyR);
+ } else {
+ assert_implication(mk_and(litems2), implyR);
+ }
+ } else {
+ // -----------------------------------------------------------
+ // * key1.first = key2.first
+ // check eqc(key1.second) and eqc(key2.second)
+ // -----------------------------------------------------------
+ expr_ref_vector::iterator eqItorSub1 = subAst1Eqc.begin();
+ for (; eqItorSub1 != subAst1Eqc.end(); eqItorSub1++) {
+ expr_ref_vector::iterator eqItorSub2 = subAst2Eqc.begin();
+ for (; eqItorSub2 != subAst2Eqc.end(); eqItorSub2++) {
+ // ------------
+ // key1.first = key2.first /\ containPairBoolMap[<eqc(key1.second), eqc(key2.second)>]
+ // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
+ // ------------
+ {
+ expr_ref_vector litems3(m);
+ if (n1 != n2) {
+ litems3.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ expr * eqSubVar1 = *eqItorSub1;
+ if (eqSubVar1 != subAst1) {
+ litems3.push_back(ctx.mk_eq_atom(subAst1, eqSubVar1));
+ }
+ expr * eqSubVar2 = *eqItorSub2;
+ if (eqSubVar2 != subAst2) {
+ litems3.push_back(ctx.mk_eq_atom(subAst2, eqSubVar2));
+ }
+ std::pair<expr*, expr*> tryKey1 = std::make_pair(eqSubVar1, eqSubVar2);
+ if (contain_pair_bool_map.contains(tryKey1)) {
+ TRACE("str", tout << "(Contains " << mk_pp(eqSubVar1, m) << " " << mk_pp(eqSubVar2, m) << ")" << std::endl;);
+ litems3.push_back(contain_pair_bool_map[tryKey1]);
+ expr_ref implR(rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
+ assert_implication(mk_and(litems3), implR);
+ }
}
- expr * eqSubVar1 = *eqItorSub1;
- if (eqSubVar1 != subAst1) {
- litems3.push_back(ctx.mk_eq_atom(subAst1, eqSubVar1));
- }
- expr * eqSubVar2 = *eqItorSub2;
- if (eqSubVar2 != subAst2) {
- litems3.push_back(ctx.mk_eq_atom(subAst2, eqSubVar2));
- }
- std::pair<expr*, expr*> tryKey1 = std::make_pair(eqSubVar1, eqSubVar2);
- if (contain_pair_bool_map.contains(tryKey1)) {
- TRACE("str", tout << "(Contains " << mk_pp(eqSubVar1, m) << " " << mk_pp(eqSubVar2, m) << ")" << std::endl;);
- litems3.push_back(contain_pair_bool_map[tryKey1]);
- expr_ref implR(rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
- assert_implication(mk_and(litems3), implR);
- }
- }
- // ------------
- // key1.first = key2.first /\ containPairBoolMap[<eqc(key2.second), eqc(key1.second)>]
- // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
- // ------------
- {
- expr_ref_vector litems4(m);
- if (n1 != n2) {
- litems4.push_back(ctx.mk_eq_atom(n1, n2));
- }
- expr * eqSubVar1 = *eqItorSub1;
- if (eqSubVar1 != subAst1) {
- litems4.push_back(ctx.mk_eq_atom(subAst1, eqSubVar1));
- }
- expr * eqSubVar2 = *eqItorSub2;
- if (eqSubVar2 != subAst2) {
- litems4.push_back(ctx.mk_eq_atom(subAst2, eqSubVar2));
- }
- std::pair<expr*, expr*> tryKey2 = std::make_pair(eqSubVar2, eqSubVar1);
- if (contain_pair_bool_map.contains(tryKey2)) {
- TRACE("str", tout << "(Contains " << mk_pp(eqSubVar2, m) << " " << mk_pp(eqSubVar1, m) << ")" << std::endl;);
- litems4.push_back(contain_pair_bool_map[tryKey2]);
- expr_ref implR(rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]), m);
- assert_implication(mk_and(litems4), implR);
+ // ------------
+ // key1.first = key2.first /\ containPairBoolMap[<eqc(key2.second), eqc(key1.second)>]
+ // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
+ // ------------
+ {
+ expr_ref_vector litems4(m);
+ if (n1 != n2) {
+ litems4.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ expr * eqSubVar1 = *eqItorSub1;
+ if (eqSubVar1 != subAst1) {
+ litems4.push_back(ctx.mk_eq_atom(subAst1, eqSubVar1));
+ }
+ expr * eqSubVar2 = *eqItorSub2;
+ if (eqSubVar2 != subAst2) {
+ litems4.push_back(ctx.mk_eq_atom(subAst2, eqSubVar2));
+ }
+ std::pair<expr*, expr*> tryKey2 = std::make_pair(eqSubVar2, eqSubVar1);
+ if (contain_pair_bool_map.contains(tryKey2)) {
+ TRACE("str", tout << "(Contains " << mk_pp(eqSubVar2, m) << " " << mk_pp(eqSubVar1, m) << ")" << std::endl;);
+ litems4.push_back(contain_pair_bool_map[tryKey2]);
+ expr_ref implR(rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]), m);
+ assert_implication(mk_and(litems4), implR);
+ }
}
}
}
}
}
}
- }
- // ***************************
- // Case 2: Contains(..., m) /\ Contains(... , n) /\ m = n
- // ***************************
- else if (key1.second == n1 && key2.second == n2) {
- expr * str1 = key1.first;
- expr * str2 = key2.first;
- bool str1HasValue = false;
- bool str2HasValue = false;
- expr * strVal1 = get_eqc_value(str1, str1HasValue);
- expr * strVal2 = get_eqc_value(str2, str2HasValue);
+ // ***************************
+ // Case 2: Contains(..., m) /\ Contains(... , n) /\ m = n
+ // ***************************
+ else if (key1.second == n1 && key2.second == n2) {
+ expr * str1 = key1.first;
+ expr * str2 = key2.first;
+ bool str1HasValue = false;
+ bool str2HasValue = false;
+ expr * strVal1 = get_eqc_value(str1, str1HasValue);
+ expr * strVal2 = get_eqc_value(str2, str2HasValue);
- TRACE("str",
- tout << "(Contains " << mk_pp(str1, m) << " " << mk_pp(n1, m) << ")" << std::endl;
- tout << "(Contains " << mk_pp(str2, m) << " " << mk_pp(n2, m) << ")" << std::endl;
- if (str1 != strVal1) {
- tout << mk_pp(str1, m) << " = " << mk_pp(strVal1, m) << std::endl;
- }
- if (str2 != strVal2) {
- tout << mk_pp(str2, m) << " = " << mk_pp(strVal2, m) << std::endl;
- }
- );
+ TRACE("str",
+ tout << "(Contains " << mk_pp(str1, m) << " " << mk_pp(n1, m) << ")" << std::endl;
+ tout << "(Contains " << mk_pp(str2, m) << " " << mk_pp(n2, m) << ")" << std::endl;
+ if (str1 != strVal1) {
+ tout << mk_pp(str1, m) << " = " << mk_pp(strVal1, m) << std::endl;
+ }
+ if (str2 != strVal2) {
+ tout << mk_pp(str2, m) << " = " << mk_pp(strVal2, m) << std::endl;
+ }
+ );
- if (str1HasValue && str2HasValue) {
- expr_ref_vector litems1(m);
- if (n1 != n2) {
- litems1.push_back(ctx.mk_eq_atom(n1, n2));
- }
- if (strVal1 != str1) {
- litems1.push_back(ctx.mk_eq_atom(str1, strVal1));
- }
- if (strVal2 != str2) {
- litems1.push_back(ctx.mk_eq_atom(str2, strVal2));
- }
-
- zstring const1, const2;
- u.str.is_string(strVal1, const1);
- u.str.is_string(strVal2, const2);
- expr_ref implyR(m);
-
- if (const1 == const2) {
- // key1.second = key2.second /\ key1.first = key2.first
- // ==> (containPairBoolMap[key1] = containPairBoolMap[key2])
- implyR = ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
- } else if (const1.contains(const2)) {
- // key1.second = key2.second /\ Contains(key1.first, key2.first)
- // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
- implyR = rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]);
- } else if (const2.contains(const1)) {
- // key1.first = key2.first /\ Contains(key2.first, key1.first)
- // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
- implyR = rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
- }
-
- if (implyR) {
- if (litems1.size() == 0) {
- assert_axiom(implyR);
- } else {
- assert_implication(mk_and(litems1), implyR);
- }
- }
- }
-
- else {
- expr_ref_vector str1Eqc(m);
- expr_ref_vector str2Eqc(m);
- collect_eq_nodes(str1, str1Eqc);
- collect_eq_nodes(str2, str2Eqc);
-
- if (str1Eqc.contains(str2)) {
- // -----------------------------------------------------------
- // * key1.first = key2.first /\ key1.second = key2.second
- // --> containPairBoolMap[key1] = containPairBoolMap[key2]
- // -----------------------------------------------------------
- expr_ref_vector litems2(m);
+ if (str1HasValue && str2HasValue) {
+ expr_ref_vector litems1(m);
if (n1 != n2) {
- litems2.push_back(ctx.mk_eq_atom(n1, n2));
+ litems1.push_back(ctx.mk_eq_atom(n1, n2));
}
- if (str1 != str2) {
- litems2.push_back(ctx.mk_eq_atom(str1, str2));
+ if (strVal1 != str1) {
+ litems1.push_back(ctx.mk_eq_atom(str1, strVal1));
}
- expr_ref implyR(ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
- if (litems2.empty()) {
- assert_axiom(implyR);
+ if (strVal2 != str2) {
+ litems1.push_back(ctx.mk_eq_atom(str2, strVal2));
+ }
+
+ zstring const1, const2;
+ u.str.is_string(strVal1, const1);
+ u.str.is_string(strVal2, const2);
+ expr_ref implyR(m);
+
+ if (const1 == const2) {
+ // key1.second = key2.second /\ key1.first = key2.first
+ // ==> (containPairBoolMap[key1] = containPairBoolMap[key2])
+ implyR = ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
+ } else if (const1.contains(const2)) {
+ // key1.second = key2.second /\ Contains(key1.first, key2.first)
+ // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
+ implyR = rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]);
+ } else if (const2.contains(const1)) {
+ // key1.first = key2.first /\ Contains(key2.first, key1.first)
+ // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
+ implyR = rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]);
+ }
+
+ if (implyR) {
+ if (litems1.size() == 0) {
+ assert_axiom(implyR);
+ } else {
+ assert_implication(mk_and(litems1), implyR);
+ }
+ }
+ }
+
+ else {
+ expr_ref_vector str1Eqc(m);
+ expr_ref_vector str2Eqc(m);
+ collect_eq_nodes(str1, str1Eqc);
+ collect_eq_nodes(str2, str2Eqc);
+
+ if (str1Eqc.contains(str2)) {
+ // -----------------------------------------------------------
+ // * key1.first = key2.first /\ key1.second = key2.second
+ // --> containPairBoolMap[key1] = containPairBoolMap[key2]
+ // -----------------------------------------------------------
+ expr_ref_vector litems2(m);
+ if (n1 != n2) {
+ litems2.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ if (str1 != str2) {
+ litems2.push_back(ctx.mk_eq_atom(str1, str2));
+ }
+ expr_ref implyR(ctx.mk_eq_atom(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
+ if (litems2.empty()) {
+ assert_axiom(implyR);
+ } else {
+ assert_implication(mk_and(litems2), implyR);
+ }
} else {
- assert_implication(mk_and(litems2), implyR);
- }
- } else {
- // -----------------------------------------------------------
- // * key1.second = key2.second
- // check eqc(key1.first) and eqc(key2.first)
- // -----------------------------------------------------------
- expr_ref_vector::iterator eqItorStr1 = str1Eqc.begin();
- for (; eqItorStr1 != str1Eqc.end(); eqItorStr1++) {
- expr_ref_vector::iterator eqItorStr2 = str2Eqc.begin();
- for (; eqItorStr2 != str2Eqc.end(); eqItorStr2++) {
- {
- expr_ref_vector litems3(m);
- if (n1 != n2) {
- litems3.push_back(ctx.mk_eq_atom(n1, n2));
- }
- expr * eqStrVar1 = *eqItorStr1;
- if (eqStrVar1 != str1) {
- litems3.push_back(ctx.mk_eq_atom(str1, eqStrVar1));
- }
- expr * eqStrVar2 = *eqItorStr2;
- if (eqStrVar2 != str2) {
- litems3.push_back(ctx.mk_eq_atom(str2, eqStrVar2));
- }
- std::pair<expr*, expr*> tryKey1 = std::make_pair(eqStrVar1, eqStrVar2);
- if (contain_pair_bool_map.contains(tryKey1)) {
- TRACE("str", tout << "(Contains " << mk_pp(eqStrVar1, m) << " " << mk_pp(eqStrVar2, m) << ")" << std::endl;);
- litems3.push_back(contain_pair_bool_map[tryKey1]);
+ // -----------------------------------------------------------
+ // * key1.second = key2.second
+ // check eqc(key1.first) and eqc(key2.first)
+ // -----------------------------------------------------------
+ expr_ref_vector::iterator eqItorStr1 = str1Eqc.begin();
+ for (; eqItorStr1 != str1Eqc.end(); eqItorStr1++) {
+ expr_ref_vector::iterator eqItorStr2 = str2Eqc.begin();
+ for (; eqItorStr2 != str2Eqc.end(); eqItorStr2++) {
+ {
+ expr_ref_vector litems3(m);
+ if (n1 != n2) {
+ litems3.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ expr * eqStrVar1 = *eqItorStr1;
+ if (eqStrVar1 != str1) {
+ litems3.push_back(ctx.mk_eq_atom(str1, eqStrVar1));
+ }
+ expr * eqStrVar2 = *eqItorStr2;
+ if (eqStrVar2 != str2) {
+ litems3.push_back(ctx.mk_eq_atom(str2, eqStrVar2));
+ }
+ std::pair<expr*, expr*> tryKey1 = std::make_pair(eqStrVar1, eqStrVar2);
+ if (contain_pair_bool_map.contains(tryKey1)) {
+ TRACE("str", tout << "(Contains " << mk_pp(eqStrVar1, m) << " " << mk_pp(eqStrVar2, m) << ")" << std::endl;);
+ litems3.push_back(contain_pair_bool_map[tryKey1]);
- // ------------
- // key1.second = key2.second /\ containPairBoolMap[<eqc(key1.first), eqc(key2.first)>]
- // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
- // ------------
- expr_ref implR(rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]), m);
- assert_implication(mk_and(litems3), implR);
+ // ------------
+ // key1.second = key2.second /\ containPairBoolMap[<eqc(key1.first), eqc(key2.first)>]
+ // ==> (containPairBoolMap[key2] --> containPairBoolMap[key1])
+ // ------------
+ expr_ref implR(rewrite_implication(contain_pair_bool_map[key2], contain_pair_bool_map[key1]), m);
+ assert_implication(mk_and(litems3), implR);
+ }
}
- }
- {
- expr_ref_vector litems4(m);
- if (n1 != n2) {
- litems4.push_back(ctx.mk_eq_atom(n1, n2));
- }
- expr * eqStrVar1 = *eqItorStr1;
- if (eqStrVar1 != str1) {
- litems4.push_back(ctx.mk_eq_atom(str1, eqStrVar1));
- }
- expr *eqStrVar2 = *eqItorStr2;
- if (eqStrVar2 != str2) {
- litems4.push_back(ctx.mk_eq_atom(str2, eqStrVar2));
- }
- std::pair<expr*, expr*> tryKey2 = std::make_pair(eqStrVar2, eqStrVar1);
+ {
+ expr_ref_vector litems4(m);
+ if (n1 != n2) {
+ litems4.push_back(ctx.mk_eq_atom(n1, n2));
+ }
+ expr * eqStrVar1 = *eqItorStr1;
+ if (eqStrVar1 != str1) {
+ litems4.push_back(ctx.mk_eq_atom(str1, eqStrVar1));
+ }
+ expr *eqStrVar2 = *eqItorStr2;
+ if (eqStrVar2 != str2) {
+ litems4.push_back(ctx.mk_eq_atom(str2, eqStrVar2));
+ }
+ std::pair<expr*, expr*> tryKey2 = std::make_pair(eqStrVar2, eqStrVar1);
- if (contain_pair_bool_map.contains(tryKey2)) {
- TRACE("str", tout << "(Contains " << mk_pp(eqStrVar2, m) << " " << mk_pp(eqStrVar1, m) << ")" << std::endl;);
- litems4.push_back(contain_pair_bool_map[tryKey2]);
- // ------------
- // key1.first = key2.first /\ containPairBoolMap[<eqc(key2.second), eqc(key1.second)>]
- // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
- // ------------
- expr_ref implR(rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
- assert_implication(mk_and(litems4), implR);
+ if (contain_pair_bool_map.contains(tryKey2)) {
+ TRACE("str", tout << "(Contains " << mk_pp(eqStrVar2, m) << " " << mk_pp(eqStrVar1, m) << ")" << std::endl;);
+ litems4.push_back(contain_pair_bool_map[tryKey2]);
+ // ------------
+ // key1.first = key2.first /\ containPairBoolMap[<eqc(key2.second), eqc(key1.second)>]
+ // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2])
+ // ------------
+ expr_ref implR(rewrite_implication(contain_pair_bool_map[key1], contain_pair_bool_map[key2]), m);
+ assert_implication(mk_and(litems4), implR);
+ }
}
}
}
}
}
- }
- }
- }
-
- if (n1 == n2) {
- break;
- }
- }
- } // (in_contain_idx_map(n1) && in_contain_idx_map(n2))
-}
-
-void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
- if (contains_map.empty()) {
- return;
- }
-
- context & ctx = get_context();
- ast_manager & m = get_manager();
- TRACE("str", tout << "consistency check for contains wrt. " << mk_pp(n1, m) << " and " << mk_pp(n2, m) << std::endl;);
-
- expr_ref_vector willEqClass(m);
- expr * constStrAst_1 = collect_eq_nodes(n1, willEqClass);
- expr * constStrAst_2 = collect_eq_nodes(n2, willEqClass);
- expr * constStrAst = (constStrAst_1 != NULL) ? constStrAst_1 : constStrAst_2;
-
- TRACE("str", tout << "eqc of n1 is {";
- for (expr_ref_vector::iterator it = willEqClass.begin(); it != willEqClass.end(); ++it) {
- expr * el = *it;
- tout << " " << mk_pp(el, m);
- }
- tout << std::endl;
- if (constStrAst == NULL) {
- tout << "constStrAst = NULL" << std::endl;
- } else {
- tout << "constStrAst = " << mk_pp(constStrAst, m) << std::endl;
- }
- );
-
- // step 1: we may have constant values for Contains checks now
- if (constStrAst != NULL) {
- expr_ref_vector::iterator itAst = willEqClass.begin();
- for (; itAst != willEqClass.end(); itAst++) {
- if (*itAst == constStrAst) {
- continue;
- }
- check_contain_by_eqc_val(*itAst, constStrAst);
- }
- } else {
- // no concrete value to be put in eqc, solely based on context
- // Check here is used to detected the facts as follows:
- // * known: contains(Z, Y) /\ Z = "abcdefg" /\ Y = M
- // * new fact: M = concat(..., "jio", ...)
- // Note that in this branch, either M or concat(..., "jio", ...) has a constant value
- // So, only need to check
- // * "EQC(M) U EQC(concat(..., "jio", ...))" as substr and
- // * If strAst registered has an eqc constant in the context
- // -------------------------------------------------------------
- expr_ref_vector::iterator itAst = willEqClass.begin();
- for (; itAst != willEqClass.end(); ++itAst) {
- check_contain_by_substr(*itAst, willEqClass);
- }
- }
-
- // ------------------------------------------
- // step 2: check for b1 = contains(x, m), b2 = contains(y, n)
- // (1) x = y /\ m = n ==> b1 = b2
- // (2) x = y /\ Contains(const(m), const(n)) ==> (b1 -> b2)
- // (3) x = y /\ Contains(const(n), const(m)) ==> (b2 -> b1)
- // (4) x = y /\ containPairBoolMap[<eqc(m), eqc(n)>] ==> (b1 -> b2)
- // (5) x = y /\ containPairBoolMap[<eqc(n), eqc(m)>] ==> (b2 -> b1)
- // (6) Contains(const(x), const(y)) /\ m = n ==> (b2 -> b1)
- // (7) Contains(const(y), const(x)) /\ m = n ==> (b1 -> b2)
- // (8) containPairBoolMap[<eqc(x), eqc(y)>] /\ m = n ==> (b2 -> b1)
- // (9) containPairBoolMap[<eqc(y), eqc(x)>] /\ m = n ==> (b1 -> b2)
- // ------------------------------------------
-
- expr_ref_vector::iterator varItor1 = willEqClass.begin();
- for (; varItor1 != willEqClass.end(); ++varItor1) {
- expr * varAst1 = *varItor1;
- expr_ref_vector::iterator varItor2 = varItor1;
- for (; varItor2 != willEqClass.end(); ++varItor2) {
- expr * varAst2 = *varItor2;
- check_contain_by_eq_nodes(varAst1, varAst2);
- }
- }
-}
-
-expr * theory_str::dealias_node(expr * node, std::map<expr*, expr*> & varAliasMap, std::map<expr*, expr*> & concatAliasMap) {
- if (variable_set.find(node) != variable_set.end()) {
- return get_alias_index_ast(varAliasMap, node);
- } else if (u.str.is_concat(to_app(node))) {
- return get_alias_index_ast(concatAliasMap, node);
- }
- return node;
-}
-
-void theory_str::get_grounded_concats(expr* node, std::map<expr*, expr*> & varAliasMap,
- std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr*> & varConstMap,
- std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap,
- std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap) {
- if (u.re.is_unroll(to_app(node))) {
- return;
- }
- // **************************************************
- // first deAlias the node if it is a var or concat
- // **************************************************
- node = dealias_node(node, varAliasMap, concatAliasMap);
-
- if (groundedMap.find(node) != groundedMap.end()) {
- return;
- }
-
- // haven't computed grounded concats for "node" (de-aliased)
- // ---------------------------------------------------------
-
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- // const strings: node is de-aliased
- if (u.str.is_string(node)) {
- std::vector<expr*> concatNodes;
- concatNodes.push_back(node);
- groundedMap[node][concatNodes].clear(); // no condition
- }
- // Concat functions
- else if (u.str.is_concat(to_app(node))) {
- // if "node" equals to a constant string, thenjust push the constant into the concat vector
- // Again "node" has been de-aliased at the very beginning
- if (concatConstMap.find(node) != concatConstMap.end()) {
- std::vector<expr*> concatNodes;
- concatNodes.push_back(concatConstMap[node]);
- groundedMap[node][concatNodes].clear();
- groundedMap[node][concatNodes].insert(ctx.mk_eq_atom(node, concatConstMap[node]));
- }
- // node doesn't have eq constant value. Process its children.
- else {
- // merge arg0 and arg1
- expr * arg0 = to_app(node)->get_arg(0);
- expr * arg1 = to_app(node)->get_arg(1);
- expr * arg0DeAlias = dealias_node(arg0, varAliasMap, concatAliasMap);
- expr * arg1DeAlias = dealias_node(arg1, varAliasMap, concatAliasMap);
- get_grounded_concats(arg0DeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
- get_grounded_concats(arg1DeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
-
- std::map<std::vector<expr*>, std::set<expr*> >::iterator arg0_grdItor = groundedMap[arg0DeAlias].begin();
- std::map<std::vector<expr*>, std::set<expr*> >::iterator arg1_grdItor;
- for (; arg0_grdItor != groundedMap[arg0DeAlias].end(); arg0_grdItor++) {
- arg1_grdItor = groundedMap[arg1DeAlias].begin();
- for (; arg1_grdItor != groundedMap[arg1DeAlias].end(); arg1_grdItor++) {
- std::vector<expr*> ndVec;
- ndVec.insert(ndVec.end(), arg0_grdItor->first.begin(), arg0_grdItor->first.end());
- int arg0VecSize = arg0_grdItor->first.size();
- int arg1VecSize = arg1_grdItor->first.size();
- if (arg0VecSize > 0 && arg1VecSize > 0 && u.str.is_string(arg0_grdItor->first[arg0VecSize - 1]) && u.str.is_string(arg1_grdItor->first[0])) {
- ndVec.pop_back();
- ndVec.push_back(mk_concat(arg0_grdItor->first[arg0VecSize - 1], arg1_grdItor->first[0]));
- for (int i = 1; i < arg1VecSize; i++) {
- ndVec.push_back(arg1_grdItor->first[i]);
- }
- } else {
- ndVec.insert(ndVec.end(), arg1_grdItor->first.begin(), arg1_grdItor->first.end());
- }
- // only insert if we don't know "node = concat(ndVec)" since one set of condition leads to this is enough
- if (groundedMap[node].find(ndVec) == groundedMap[node].end()) {
- groundedMap[node][ndVec];
- if (arg0 != arg0DeAlias) {
- groundedMap[node][ndVec].insert(ctx.mk_eq_atom(arg0, arg0DeAlias));
- }
- groundedMap[node][ndVec].insert(arg0_grdItor->second.begin(), arg0_grdItor->second.end());
-
- if (arg1 != arg1DeAlias) {
- groundedMap[node][ndVec].insert(ctx.mk_eq_atom(arg1, arg1DeAlias));
- }
- groundedMap[node][ndVec].insert(arg1_grdItor->second.begin(), arg1_grdItor->second.end());
}
}
+
+ if (n1 == n2) {
+ break;
+ }
+ }
+ } // (in_contain_idx_map(n1) && in_contain_idx_map(n2))
+ }
+
+ void theory_str::check_contain_in_new_eq(expr * n1, expr * n2) {
+ if (contains_map.empty()) {
+ return;
+ }
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ TRACE("str", tout << "consistency check for contains wrt. " << mk_pp(n1, m) << " and " << mk_pp(n2, m) << std::endl;);
+
+ expr_ref_vector willEqClass(m);
+ expr * constStrAst_1 = collect_eq_nodes(n1, willEqClass);
+ expr * constStrAst_2 = collect_eq_nodes(n2, willEqClass);
+ expr * constStrAst = (constStrAst_1 != NULL) ? constStrAst_1 : constStrAst_2;
+
+ TRACE("str", tout << "eqc of n1 is {";
+ for (expr_ref_vector::iterator it = willEqClass.begin(); it != willEqClass.end(); ++it) {
+ expr * el = *it;
+ tout << " " << mk_pp(el, m);
+ }
+ tout << std::endl;
+ if (constStrAst == NULL) {
+ tout << "constStrAst = NULL" << std::endl;
+ } else {
+ tout << "constStrAst = " << mk_pp(constStrAst, m) << std::endl;
+ }
+ );
+
+ // step 1: we may have constant values for Contains checks now
+ if (constStrAst != NULL) {
+ expr_ref_vector::iterator itAst = willEqClass.begin();
+ for (; itAst != willEqClass.end(); itAst++) {
+ if (*itAst == constStrAst) {
+ continue;
+ }
+ check_contain_by_eqc_val(*itAst, constStrAst);
+ }
+ } else {
+ // no concrete value to be put in eqc, solely based on context
+ // Check here is used to detected the facts as follows:
+ // * known: contains(Z, Y) /\ Z = "abcdefg" /\ Y = M
+ // * new fact: M = concat(..., "jio", ...)
+ // Note that in this branch, either M or concat(..., "jio", ...) has a constant value
+ // So, only need to check
+ // * "EQC(M) U EQC(concat(..., "jio", ...))" as substr and
+ // * If strAst registered has an eqc constant in the context
+ // -------------------------------------------------------------
+ expr_ref_vector::iterator itAst = willEqClass.begin();
+ for (; itAst != willEqClass.end(); ++itAst) {
+ check_contain_by_substr(*itAst, willEqClass);
+ }
+ }
+
+ // ------------------------------------------
+ // step 2: check for b1 = contains(x, m), b2 = contains(y, n)
+ // (1) x = y /\ m = n ==> b1 = b2
+ // (2) x = y /\ Contains(const(m), const(n)) ==> (b1 -> b2)
+ // (3) x = y /\ Contains(const(n), const(m)) ==> (b2 -> b1)
+ // (4) x = y /\ containPairBoolMap[<eqc(m), eqc(n)>] ==> (b1 -> b2)
+ // (5) x = y /\ containPairBoolMap[<eqc(n), eqc(m)>] ==> (b2 -> b1)
+ // (6) Contains(const(x), const(y)) /\ m = n ==> (b2 -> b1)
+ // (7) Contains(const(y), const(x)) /\ m = n ==> (b1 -> b2)
+ // (8) containPairBoolMap[<eqc(x), eqc(y)>] /\ m = n ==> (b2 -> b1)
+ // (9) containPairBoolMap[<eqc(y), eqc(x)>] /\ m = n ==> (b1 -> b2)
+ // ------------------------------------------
+
+ expr_ref_vector::iterator varItor1 = willEqClass.begin();
+ for (; varItor1 != willEqClass.end(); ++varItor1) {
+ expr * varAst1 = *varItor1;
+ expr_ref_vector::iterator varItor2 = varItor1;
+ for (; varItor2 != willEqClass.end(); ++varItor2) {
+ expr * varAst2 = *varItor2;
+ check_contain_by_eq_nodes(varAst1, varAst2);
}
}
}
- // string variables
- else if (variable_set.find(node) != variable_set.end()) {
- // deAliasedVar = Constant
- if (varConstMap.find(node) != varConstMap.end()) {
- std::vector<expr*> concatNodes;
- concatNodes.push_back(varConstMap[node]);
- groundedMap[node][concatNodes].clear();
- groundedMap[node][concatNodes].insert(ctx.mk_eq_atom(node, varConstMap[node]));
- }
- // deAliasedVar = someConcat
- else if (varEqConcatMap.find(node) != varEqConcatMap.end()) {
- expr * eqConcat = varEqConcatMap[node].begin()->first;
- expr * deAliasedEqConcat = dealias_node(eqConcat, varAliasMap, concatAliasMap);
- get_grounded_concats(deAliasedEqConcat, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
- std::map<std::vector<expr*>, std::set<expr*> >::iterator grdItor = groundedMap[deAliasedEqConcat].begin();
- for (; grdItor != groundedMap[deAliasedEqConcat].end(); grdItor++) {
- std::vector<expr*> ndVec;
- ndVec.insert(ndVec.end(), grdItor->first.begin(), grdItor->first.end());
- // only insert if we don't know "node = concat(ndVec)" since one set of condition leads to this is enough
- if (groundedMap[node].find(ndVec) == groundedMap[node].end()) {
- // condition: node = deAliasedEqConcat
- groundedMap[node][ndVec].insert(ctx.mk_eq_atom(node, deAliasedEqConcat));
- // appending conditions for "deAliasedEqConcat = CONCAT(ndVec)"
- groundedMap[node][ndVec].insert(grdItor->second.begin(), grdItor->second.end());
- }
- }
+ expr * theory_str::dealias_node(expr * node, std::map<expr*, expr*> & varAliasMap, std::map<expr*, expr*> & concatAliasMap) {
+ if (variable_set.find(node) != variable_set.end()) {
+ return get_alias_index_ast(varAliasMap, node);
+ } else if (u.str.is_concat(to_app(node))) {
+ return get_alias_index_ast(concatAliasMap, node);
}
- // node (has been de-aliased) != constant && node (has been de-aliased) != any concat
- // just push in the deAliasedVar
- else {
+ return node;
+ }
+
+ void theory_str::get_grounded_concats(expr* node, std::map<expr*, expr*> & varAliasMap,
+ std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr*> & varConstMap,
+ std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap,
+ std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap) {
+ if (u.re.is_unroll(to_app(node))) {
+ return;
+ }
+ // **************************************************
+ // first deAlias the node if it is a var or concat
+ // **************************************************
+ node = dealias_node(node, varAliasMap, concatAliasMap);
+
+ if (groundedMap.find(node) != groundedMap.end()) {
+ return;
+ }
+
+ // haven't computed grounded concats for "node" (de-aliased)
+ // ---------------------------------------------------------
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ // const strings: node is de-aliased
+ if (u.str.is_string(node)) {
std::vector<expr*> concatNodes;
concatNodes.push_back(node);
- groundedMap[node][concatNodes];
+ groundedMap[node][concatNodes].clear(); // no condition
+ }
+ // Concat functions
+ else if (u.str.is_concat(to_app(node))) {
+ // if "node" equals to a constant string, thenjust push the constant into the concat vector
+ // Again "node" has been de-aliased at the very beginning
+ if (concatConstMap.find(node) != concatConstMap.end()) {
+ std::vector<expr*> concatNodes;
+ concatNodes.push_back(concatConstMap[node]);
+ groundedMap[node][concatNodes].clear();
+ groundedMap[node][concatNodes].insert(ctx.mk_eq_atom(node, concatConstMap[node]));
+ }
+ // node doesn't have eq constant value. Process its children.
+ else {
+ // merge arg0 and arg1
+ expr * arg0 = to_app(node)->get_arg(0);
+ expr * arg1 = to_app(node)->get_arg(1);
+ expr * arg0DeAlias = dealias_node(arg0, varAliasMap, concatAliasMap);
+ expr * arg1DeAlias = dealias_node(arg1, varAliasMap, concatAliasMap);
+ get_grounded_concats(arg0DeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
+ get_grounded_concats(arg1DeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
+
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator arg0_grdItor = groundedMap[arg0DeAlias].begin();
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator arg1_grdItor;
+ for (; arg0_grdItor != groundedMap[arg0DeAlias].end(); arg0_grdItor++) {
+ arg1_grdItor = groundedMap[arg1DeAlias].begin();
+ for (; arg1_grdItor != groundedMap[arg1DeAlias].end(); arg1_grdItor++) {
+ std::vector<expr*> ndVec;
+ ndVec.insert(ndVec.end(), arg0_grdItor->first.begin(), arg0_grdItor->first.end());
+ int arg0VecSize = arg0_grdItor->first.size();
+ int arg1VecSize = arg1_grdItor->first.size();
+ if (arg0VecSize > 0 && arg1VecSize > 0 && u.str.is_string(arg0_grdItor->first[arg0VecSize - 1]) && u.str.is_string(arg1_grdItor->first[0])) {
+ ndVec.pop_back();
+ ndVec.push_back(mk_concat(arg0_grdItor->first[arg0VecSize - 1], arg1_grdItor->first[0]));
+ for (int i = 1; i < arg1VecSize; i++) {
+ ndVec.push_back(arg1_grdItor->first[i]);
+ }
+ } else {
+ ndVec.insert(ndVec.end(), arg1_grdItor->first.begin(), arg1_grdItor->first.end());
+ }
+ // only insert if we don't know "node = concat(ndVec)" since one set of condition leads to this is enough
+ if (groundedMap[node].find(ndVec) == groundedMap[node].end()) {
+ groundedMap[node][ndVec];
+ if (arg0 != arg0DeAlias) {
+ groundedMap[node][ndVec].insert(ctx.mk_eq_atom(arg0, arg0DeAlias));
+ }
+ groundedMap[node][ndVec].insert(arg0_grdItor->second.begin(), arg0_grdItor->second.end());
+
+ if (arg1 != arg1DeAlias) {
+ groundedMap[node][ndVec].insert(ctx.mk_eq_atom(arg1, arg1DeAlias));
+ }
+ groundedMap[node][ndVec].insert(arg1_grdItor->second.begin(), arg1_grdItor->second.end());
+ }
+ }
+ }
+ }
+ }
+ // string variables
+ else if (variable_set.find(node) != variable_set.end()) {
+ // deAliasedVar = Constant
+ if (varConstMap.find(node) != varConstMap.end()) {
+ std::vector<expr*> concatNodes;
+ concatNodes.push_back(varConstMap[node]);
+ groundedMap[node][concatNodes].clear();
+ groundedMap[node][concatNodes].insert(ctx.mk_eq_atom(node, varConstMap[node]));
+ }
+ // deAliasedVar = someConcat
+ else if (varEqConcatMap.find(node) != varEqConcatMap.end()) {
+ expr * eqConcat = varEqConcatMap[node].begin()->first;
+ expr * deAliasedEqConcat = dealias_node(eqConcat, varAliasMap, concatAliasMap);
+ get_grounded_concats(deAliasedEqConcat, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
+
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator grdItor = groundedMap[deAliasedEqConcat].begin();
+ for (; grdItor != groundedMap[deAliasedEqConcat].end(); grdItor++) {
+ std::vector<expr*> ndVec;
+ ndVec.insert(ndVec.end(), grdItor->first.begin(), grdItor->first.end());
+ // only insert if we don't know "node = concat(ndVec)" since one set of condition leads to this is enough
+ if (groundedMap[node].find(ndVec) == groundedMap[node].end()) {
+ // condition: node = deAliasedEqConcat
+ groundedMap[node][ndVec].insert(ctx.mk_eq_atom(node, deAliasedEqConcat));
+ // appending conditions for "deAliasedEqConcat = CONCAT(ndVec)"
+ groundedMap[node][ndVec].insert(grdItor->second.begin(), grdItor->second.end());
+ }
+ }
+ }
+ // node (has been de-aliased) != constant && node (has been de-aliased) != any concat
+ // just push in the deAliasedVar
+ else {
+ std::vector<expr*> concatNodes;
+ concatNodes.push_back(node);
+ groundedMap[node][concatNodes];
+ }
}
}
-}
-void theory_str::print_grounded_concat(expr * node, std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap) {
- ast_manager & m = get_manager();
- TRACE("str", tout << mk_pp(node, m) << std::endl;);
- if (groundedMap.find(node) != groundedMap.end()) {
- std::map<std::vector<expr*>, std::set<expr*> >::iterator itor = groundedMap[node].begin();
- for (; itor != groundedMap[node].end(); ++itor) {
- TRACE("str",
- tout << "\t[grounded] ";
- std::vector<expr*>::const_iterator vIt = itor->first.begin();
- for (; vIt != itor->first.end(); ++vIt) {
- tout << mk_pp(*vIt, m) << ", ";
- }
- tout << std::endl;
- tout << "\t[condition] ";
- std::set<expr*>::iterator sIt = itor->second.begin();
- for (; sIt != itor->second.end(); sIt++) {
- tout << mk_pp(*sIt, m) << ", ";
- }
- tout << std::endl;
- );
+ void theory_str::print_grounded_concat(expr * node, std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap) {
+ ast_manager & m = get_manager();
+ TRACE("str", tout << mk_pp(node, m) << std::endl;);
+ if (groundedMap.find(node) != groundedMap.end()) {
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator itor = groundedMap[node].begin();
+ for (; itor != groundedMap[node].end(); ++itor) {
+ TRACE("str",
+ tout << "\t[grounded] ";
+ std::vector<expr*>::const_iterator vIt = itor->first.begin();
+ for (; vIt != itor->first.end(); ++vIt) {
+ tout << mk_pp(*vIt, m) << ", ";
+ }
+ tout << std::endl;
+ tout << "\t[condition] ";
+ std::set<expr*>::iterator sIt = itor->second.begin();
+ for (; sIt != itor->second.end(); sIt++) {
+ tout << mk_pp(*sIt, m) << ", ";
+ }
+ tout << std::endl;
+ );
+ }
+ } else {
+ TRACE("str", tout << "not found" << std::endl;);
}
- } else {
- TRACE("str", tout << "not found" << std::endl;);
- }
-}
-
-bool theory_str::is_partial_in_grounded_concat(const std::vector<expr*> & strVec, const std::vector<expr*> & subStrVec) {
- int strCnt = strVec.size();
- int subStrCnt = subStrVec.size();
-
- if (strCnt == 0 || subStrCnt == 0) {
- return false;
}
- // The assumption is that all consecutive constant strings are merged into one node
- if (strCnt < subStrCnt) {
- return false;
- }
+ bool theory_str::is_partial_in_grounded_concat(const std::vector<expr*> & strVec, const std::vector<expr*> & subStrVec) {
+ int strCnt = strVec.size();
+ int subStrCnt = subStrVec.size();
- if (subStrCnt == 1) {
- zstring subStrVal;
- if (u.str.is_string(subStrVec[0], subStrVal)) {
- for (int i = 0; i < strCnt; i++) {
- zstring strVal;
- if (u.str.is_string(strVec[i], strVal)) {
- if (strVal.contains(subStrVal)) {
+ if (strCnt == 0 || subStrCnt == 0) {
+ return false;
+ }
+
+ // The assumption is that all consecutive constant strings are merged into one node
+ if (strCnt < subStrCnt) {
+ return false;
+ }
+
+ if (subStrCnt == 1) {
+ zstring subStrVal;
+ if (u.str.is_string(subStrVec[0], subStrVal)) {
+ for (int i = 0; i < strCnt; i++) {
+ zstring strVal;
+ if (u.str.is_string(strVec[i], strVal)) {
+ if (strVal.contains(subStrVal)) {
+ return true;
+ }
+ }
+ }
+ } else {
+ for (int i = 0; i < strCnt; i++) {
+ if (strVec[i] == subStrVec[0]) {
return true;
}
}
}
+ return false;
} else {
- for (int i = 0; i < strCnt; i++) {
- if (strVec[i] == subStrVec[0]) {
- return true;
- }
- }
- }
- return false;
- } else {
- for (int i = 0; i <= (strCnt - subStrCnt); i++) {
- // The first node in subStrVect should be
- // * constant: a suffix of a note in strVec[i]
- // * variable:
- bool firstNodesOK = true;
- zstring subStrHeadVal;
- if (u.str.is_string(subStrVec[0], subStrHeadVal)) {
- zstring strHeadVal;
- if (u.str.is_string(strVec[i], strHeadVal)) {
- if (strHeadVal.length() >= subStrHeadVal.length()) {
- zstring suffix = strHeadVal.extract(strHeadVal.length() - subStrHeadVal.length(), subStrHeadVal.length());
- if (suffix != subStrHeadVal) {
+ for (int i = 0; i <= (strCnt - subStrCnt); i++) {
+ // The first node in subStrVect should be
+ // * constant: a suffix of a note in strVec[i]
+ // * variable:
+ bool firstNodesOK = true;
+ zstring subStrHeadVal;
+ if (u.str.is_string(subStrVec[0], subStrHeadVal)) {
+ zstring strHeadVal;
+ if (u.str.is_string(strVec[i], strHeadVal)) {
+ if (strHeadVal.length() >= subStrHeadVal.length()) {
+ zstring suffix = strHeadVal.extract(strHeadVal.length() - subStrHeadVal.length(), subStrHeadVal.length());
+ if (suffix != subStrHeadVal) {
+ firstNodesOK = false;
+ }
+ } else {
firstNodesOK = false;
}
} else {
- firstNodesOK = false;
- }
- } else {
- if (subStrVec[0] != strVec[i]) {
- firstNodesOK = false;
+ if (subStrVec[0] != strVec[i]) {
+ firstNodesOK = false;
+ }
}
}
- }
- if (!firstNodesOK) {
- continue;
- }
-
- // middle nodes
- bool midNodesOK = true;
- for (int j = 1; j < subStrCnt - 1; j++) {
- if (subStrVec[j] != strVec[i + j]) {
- midNodesOK = false;
- break;
+ if (!firstNodesOK) {
+ continue;
}
- }
- if (!midNodesOK) {
- continue;
- }
- // tail nodes
- int tailIdx = i + subStrCnt - 1;
- zstring subStrTailVal;
- if (u.str.is_string(subStrVec[subStrCnt - 1], subStrTailVal)) {
- zstring strTailVal;
- if (u.str.is_string(strVec[tailIdx], strTailVal)) {
- if (strTailVal.length() >= subStrTailVal.length()) {
- zstring prefix = strTailVal.extract(0, subStrTailVal.length());
- if (prefix == subStrTailVal) {
- return true;
+ // middle nodes
+ bool midNodesOK = true;
+ for (int j = 1; j < subStrCnt - 1; j++) {
+ if (subStrVec[j] != strVec[i + j]) {
+ midNodesOK = false;
+ break;
+ }
+ }
+ if (!midNodesOK) {
+ continue;
+ }
+
+ // tail nodes
+ int tailIdx = i + subStrCnt - 1;
+ zstring subStrTailVal;
+ if (u.str.is_string(subStrVec[subStrCnt - 1], subStrTailVal)) {
+ zstring strTailVal;
+ if (u.str.is_string(strVec[tailIdx], strTailVal)) {
+ if (strTailVal.length() >= subStrTailVal.length()) {
+ zstring prefix = strTailVal.extract(0, subStrTailVal.length());
+ if (prefix == subStrTailVal) {
+ return true;
+ } else {
+ continue;
+ }
} else {
continue;
}
+ }
+ } else {
+ if (subStrVec[subStrCnt - 1] == strVec[tailIdx]) {
+ return true;
} else {
continue;
}
}
- } else {
- if (subStrVec[subStrCnt - 1] == strVec[tailIdx]) {
- return true;
- } else {
- continue;
- }
}
- }
- return false;
- }
-}
-
-void theory_str::check_subsequence(expr* str, expr* strDeAlias, expr* subStr, expr* subStrDeAlias, expr* boolVar,
- std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap) {
-
- context & ctx = get_context();
- ast_manager & m = get_manager();
- std::map<std::vector<expr*>, std::set<expr*> >::iterator itorStr = groundedMap[strDeAlias].begin();
- std::map<std::vector<expr*>, std::set<expr*> >::iterator itorSubStr;
- for (; itorStr != groundedMap[strDeAlias].end(); itorStr++) {
- itorSubStr = groundedMap[subStrDeAlias].begin();
- for (; itorSubStr != groundedMap[subStrDeAlias].end(); itorSubStr++) {
- bool contain = is_partial_in_grounded_concat(itorStr->first, itorSubStr->first);
- if (contain) {
- expr_ref_vector litems(m);
- if (str != strDeAlias) {
- litems.push_back(ctx.mk_eq_atom(str, strDeAlias));
- }
- if (subStr != subStrDeAlias) {
- litems.push_back(ctx.mk_eq_atom(subStr, subStrDeAlias));
- }
-
- //litems.insert(itorStr->second.begin(), itorStr->second.end());
- //litems.insert(itorSubStr->second.begin(), itorSubStr->second.end());
- for (std::set<expr*>::const_iterator i1 = itorStr->second.begin();
- i1 != itorStr->second.end(); ++i1) {
- litems.push_back(*i1);
- }
- for (std::set<expr*>::const_iterator i1 = itorSubStr->second.begin();
- i1 != itorSubStr->second.end(); ++i1) {
- litems.push_back(*i1);
- }
-
- expr_ref implyR(boolVar, m);
-
- if (litems.empty()) {
- assert_axiom(implyR);
- } else {
- expr_ref implyL(mk_and(litems), m);
- assert_implication(implyL, implyR);
- }
-
- }
- }
- }
-}
-
-void theory_str::compute_contains(std::map<expr*, expr*> & varAliasMap,
- std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr*> & varConstMap,
- std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap) {
- std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > groundedMap;
- theory_str_contain_pair_bool_map_t::iterator containItor = contain_pair_bool_map.begin();
- for (; containItor != contain_pair_bool_map.end(); containItor++) {
- expr* containBoolVar = containItor->get_value();
- expr* str = containItor->get_key1();
- expr* subStr = containItor->get_key2();
-
- expr* strDeAlias = dealias_node(str, varAliasMap, concatAliasMap);
- expr* subStrDeAlias = dealias_node(subStr, varAliasMap, concatAliasMap);
-
- get_grounded_concats(strDeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
- get_grounded_concats(subStrDeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
-
- // debugging
- print_grounded_concat(strDeAlias, groundedMap);
- print_grounded_concat(subStrDeAlias, groundedMap);
-
- check_subsequence(str, strDeAlias, subStr, subStrDeAlias, containBoolVar, groundedMap);
- }
-}
-
-bool theory_str::can_concat_eq_str(expr * concat, zstring& str) {
- unsigned int strLen = str.length();
- if (u.str.is_concat(to_app(concat))) {
- ptr_vector<expr> args;
- get_nodes_in_concat(concat, args);
- expr * ml_node = args[0];
- expr * mr_node = args[args.size() - 1];
-
- zstring ml_str;
- if (u.str.is_string(ml_node, ml_str)) {
- unsigned int ml_len = ml_str.length();
- if (ml_len > strLen) {
- return false;
- }
- unsigned int cLen = ml_len;
- if (ml_str != str.extract(0, cLen)) {
- return false;
- }
- }
-
- zstring mr_str;
- if (u.str.is_string(mr_node, mr_str)) {
- unsigned int mr_len = mr_str.length();
- if (mr_len > strLen) {
- return false;
- }
- unsigned int cLen = mr_len;
- if (mr_str != str.extract(strLen - cLen, cLen)) {
- return false;
- }
- }
-
- unsigned int sumLen = 0;
- for (unsigned int i = 0 ; i < args.size() ; i++) {
- expr * oneArg = args[i];
- zstring arg_str;
- if (u.str.is_string(oneArg, arg_str)) {
- if (!str.contains(arg_str)) {
- return false;
- }
- sumLen += arg_str.length();
- }
- }
-
- if (sumLen > strLen) {
- return false;
- }
- }
- return true;
-}
-
-bool theory_str::can_concat_eq_concat(expr * concat1, expr * concat2) {
- if (u.str.is_concat(to_app(concat1)) && u.str.is_concat(to_app(concat2))) {
- {
- // Suppose concat1 = (Concat X Y) and concat2 = (Concat M N).
- expr * concat1_mostL = getMostLeftNodeInConcat(concat1);
- expr * concat2_mostL = getMostLeftNodeInConcat(concat2);
- // if both X and M are constant strings, check whether they have the same prefix
- zstring concat1_mostL_str, concat2_mostL_str;
- if (u.str.is_string(concat1_mostL, concat1_mostL_str) && u.str.is_string(concat2_mostL, concat2_mostL_str)) {
- unsigned int cLen = std::min(concat1_mostL_str.length(), concat2_mostL_str.length());
- if (concat1_mostL_str.extract(0, cLen) != concat2_mostL_str.extract(0, cLen)) {
- return false;
- }
- }
- }
-
- {
- // Similarly, if both Y and N are constant strings, check whether they have the same suffix
- expr * concat1_mostR = getMostRightNodeInConcat(concat1);
- expr * concat2_mostR = getMostRightNodeInConcat(concat2);
- zstring concat1_mostR_str, concat2_mostR_str;
- if (u.str.is_string(concat1_mostR, concat1_mostR_str) && u.str.is_string(concat2_mostR, concat2_mostR_str)) {
- unsigned int cLen = std::min(concat1_mostR_str.length(), concat2_mostR_str.length());
- if (concat1_mostR_str.extract(concat1_mostR_str.length() - cLen, cLen) !=
- concat2_mostR_str.extract(concat2_mostR_str.length() - cLen, cLen)) {
- return false;
- }
- }
- }
- }
- return true;
-}
-
-/*
- * Check whether n1 and n2 could be equal.
- * Returns true if n1 could equal n2 (maybe),
- * and false if n1 is definitely not equal to n2 (no).
- */
-bool theory_str::can_two_nodes_eq(expr * n1, expr * n2) {
- app * n1_curr = to_app(n1);
- app * n2_curr = to_app(n2);
-
- // case 0: n1_curr is const string, n2_curr is const string
- if (u.str.is_string(n1_curr) && u.str.is_string(n2_curr)) {
- if (n1_curr != n2_curr) {
- return false;
- }
- }
- // case 1: n1_curr is concat, n2_curr is const string
- else if (u.str.is_concat(n1_curr) && u.str.is_string(n2_curr)) {
- zstring n2_curr_str;
- u.str.is_string(n2_curr, n2_curr_str);
- if (!can_concat_eq_str(n1_curr, n2_curr_str)) {
return false;
}
}
- // case 2: n2_curr is concat, n1_curr is const string
- else if (u.str.is_concat(n2_curr) && u.str.is_string(n1_curr)) {
- zstring n1_curr_str;
- u.str.is_string(n1_curr, n1_curr_str);
- if (!can_concat_eq_str(n2_curr, n1_curr_str)) {
- return false;
+
+ void theory_str::check_subsequence(expr* str, expr* strDeAlias, expr* subStr, expr* subStrDeAlias, expr* boolVar,
+ std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap) {
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator itorStr = groundedMap[strDeAlias].begin();
+ std::map<std::vector<expr*>, std::set<expr*> >::iterator itorSubStr;
+ for (; itorStr != groundedMap[strDeAlias].end(); itorStr++) {
+ itorSubStr = groundedMap[subStrDeAlias].begin();
+ for (; itorSubStr != groundedMap[subStrDeAlias].end(); itorSubStr++) {
+ bool contain = is_partial_in_grounded_concat(itorStr->first, itorSubStr->first);
+ if (contain) {
+ expr_ref_vector litems(m);
+ if (str != strDeAlias) {
+ litems.push_back(ctx.mk_eq_atom(str, strDeAlias));
+ }
+ if (subStr != subStrDeAlias) {
+ litems.push_back(ctx.mk_eq_atom(subStr, subStrDeAlias));
+ }
+
+ //litems.insert(itorStr->second.begin(), itorStr->second.end());
+ //litems.insert(itorSubStr->second.begin(), itorSubStr->second.end());
+ for (std::set<expr*>::const_iterator i1 = itorStr->second.begin();
+ i1 != itorStr->second.end(); ++i1) {
+ litems.push_back(*i1);
+ }
+ for (std::set<expr*>::const_iterator i1 = itorSubStr->second.begin();
+ i1 != itorSubStr->second.end(); ++i1) {
+ litems.push_back(*i1);
+ }
+
+ expr_ref implyR(boolVar, m);
+
+ if (litems.empty()) {
+ assert_axiom(implyR);
+ } else {
+ expr_ref implyL(mk_and(litems), m);
+ assert_implication(implyL, implyR);
+ }
+
+ }
+ }
}
}
- // case 3: both are concats
- else if (u.str.is_concat(n1_curr) && u.str.is_concat(n2_curr)) {
- if (!can_concat_eq_concat(n1_curr, n2_curr)) {
- return false;
- }
+
+ void theory_str::compute_contains(std::map<expr*, expr*> & varAliasMap,
+ std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr*> & varConstMap,
+ std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap) {
+ std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > groundedMap;
+ theory_str_contain_pair_bool_map_t::iterator containItor = contain_pair_bool_map.begin();
+ for (; containItor != contain_pair_bool_map.end(); containItor++) {
+ expr* containBoolVar = containItor->get_value();
+ expr* str = containItor->get_key1();
+ expr* subStr = containItor->get_key2();
+
+ expr* strDeAlias = dealias_node(str, varAliasMap, concatAliasMap);
+ expr* subStrDeAlias = dealias_node(subStr, varAliasMap, concatAliasMap);
+
+ get_grounded_concats(strDeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
+ get_grounded_concats(subStrDeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap);
+
+ // debugging
+ print_grounded_concat(strDeAlias, groundedMap);
+ print_grounded_concat(subStrDeAlias, groundedMap);
+
+ check_subsequence(str, strDeAlias, subStr, subStrDeAlias, containBoolVar, groundedMap);
+ }
}
- return true;
-}
+ bool theory_str::can_concat_eq_str(expr * concat, zstring& str) {
+ unsigned int strLen = str.length();
+ if (u.str.is_concat(to_app(concat))) {
+ ptr_vector<expr> args;
+ get_nodes_in_concat(concat, args);
+ expr * ml_node = args[0];
+ expr * mr_node = args[args.size() - 1];
-// was checkLength2ConstStr() in Z3str2
-// returns true if everything is OK, or false if inconsistency detected
-// - note that these are different from the semantics in Z3str2
-bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
- ast_manager & mgr = get_manager();
- context & ctx = get_context();
-
- zstring tmp;
- u.str.is_string(constStr, tmp);
- rational strLen(tmp.length());
-
- if (u.str.is_concat(to_app(n1))) {
- ptr_vector<expr> args;
- expr_ref_vector items(mgr);
-
- get_nodes_in_concat(n1, args);
-
- rational sumLen(0);
- for (unsigned int i = 0; i < args.size(); ++i) {
- rational argLen;
- bool argLen_exists = get_len_value(args[i], argLen);
- if (argLen_exists) {
- if (!u.str.is_string(args[i])) {
- items.push_back(ctx.mk_eq_atom(mk_strlen(args[i]), mk_int(argLen)));
+ zstring ml_str;
+ if (u.str.is_string(ml_node, ml_str)) {
+ unsigned int ml_len = ml_str.length();
+ if (ml_len > strLen) {
+ return false;
}
- TRACE("str", tout << "concat arg: " << mk_pp(args[i], mgr) << " has len = " << argLen.to_string() << std::endl;);
- sumLen += argLen;
- if (sumLen > strLen) {
- items.push_back(ctx.mk_eq_atom(n1, constStr));
- expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
- TRACE("str", tout << "inconsistent length: concat (len = " << sumLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
- assert_axiom(toAssert);
+ unsigned int cLen = ml_len;
+ if (ml_str != str.extract(0, cLen)) {
return false;
}
}
+
+ zstring mr_str;
+ if (u.str.is_string(mr_node, mr_str)) {
+ unsigned int mr_len = mr_str.length();
+ if (mr_len > strLen) {
+ return false;
+ }
+ unsigned int cLen = mr_len;
+ if (mr_str != str.extract(strLen - cLen, cLen)) {
+ return false;
+ }
+ }
+
+ unsigned int sumLen = 0;
+ for (unsigned int i = 0 ; i < args.size() ; i++) {
+ expr * oneArg = args[i];
+ zstring arg_str;
+ if (u.str.is_string(oneArg, arg_str)) {
+ if (!str.contains(arg_str)) {
+ return false;
+ }
+ sumLen += arg_str.length();
+ }
+ }
+
+ if (sumLen > strLen) {
+ return false;
+ }
}
- } else { // !is_concat(n1)
- rational oLen;
- bool oLen_exists = get_len_value(n1, oLen);
- if (oLen_exists && oLen != strLen) {
- TRACE("str", tout << "inconsistent length: var (len = " << oLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
+ return true;
+ }
+
+ bool theory_str::can_concat_eq_concat(expr * concat1, expr * concat2) {
+ if (u.str.is_concat(to_app(concat1)) && u.str.is_concat(to_app(concat2))) {
+ {
+ // Suppose concat1 = (Concat X Y) and concat2 = (Concat M N).
+ expr * concat1_mostL = getMostLeftNodeInConcat(concat1);
+ expr * concat2_mostL = getMostLeftNodeInConcat(concat2);
+ // if both X and M are constant strings, check whether they have the same prefix
+ zstring concat1_mostL_str, concat2_mostL_str;
+ if (u.str.is_string(concat1_mostL, concat1_mostL_str) && u.str.is_string(concat2_mostL, concat2_mostL_str)) {
+ unsigned int cLen = std::min(concat1_mostL_str.length(), concat2_mostL_str.length());
+ if (concat1_mostL_str.extract(0, cLen) != concat2_mostL_str.extract(0, cLen)) {
+ return false;
+ }
+ }
+ }
+
+ {
+ // Similarly, if both Y and N are constant strings, check whether they have the same suffix
+ expr * concat1_mostR = getMostRightNodeInConcat(concat1);
+ expr * concat2_mostR = getMostRightNodeInConcat(concat2);
+ zstring concat1_mostR_str, concat2_mostR_str;
+ if (u.str.is_string(concat1_mostR, concat1_mostR_str) && u.str.is_string(concat2_mostR, concat2_mostR_str)) {
+ unsigned int cLen = std::min(concat1_mostR_str.length(), concat2_mostR_str.length());
+ if (concat1_mostR_str.extract(concat1_mostR_str.length() - cLen, cLen) !=
+ concat2_mostR_str.extract(concat2_mostR_str.length() - cLen, cLen)) {
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+ }
+
+ /*
+ * Check whether n1 and n2 could be equal.
+ * Returns true if n1 could equal n2 (maybe),
+ * and false if n1 is definitely not equal to n2 (no).
+ */
+ bool theory_str::can_two_nodes_eq(expr * n1, expr * n2) {
+ app * n1_curr = to_app(n1);
+ app * n2_curr = to_app(n2);
+
+ // case 0: n1_curr is const string, n2_curr is const string
+ if (u.str.is_string(n1_curr) && u.str.is_string(n2_curr)) {
+ if (n1_curr != n2_curr) {
+ return false;
+ }
+ }
+ // case 1: n1_curr is concat, n2_curr is const string
+ else if (u.str.is_concat(n1_curr) && u.str.is_string(n2_curr)) {
+ zstring n2_curr_str;
+ u.str.is_string(n2_curr, n2_curr_str);
+ if (!can_concat_eq_str(n1_curr, n2_curr_str)) {
+ return false;
+ }
+ }
+ // case 2: n2_curr is concat, n1_curr is const string
+ else if (u.str.is_concat(n2_curr) && u.str.is_string(n1_curr)) {
+ zstring n1_curr_str;
+ u.str.is_string(n1_curr, n1_curr_str);
+ if (!can_concat_eq_str(n2_curr, n1_curr_str)) {
+ return false;
+ }
+ }
+ // case 3: both are concats
+ else if (u.str.is_concat(n1_curr) && u.str.is_concat(n2_curr)) {
+ if (!can_concat_eq_concat(n1_curr, n2_curr)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ // was checkLength2ConstStr() in Z3str2
+ // returns true if everything is OK, or false if inconsistency detected
+ // - note that these are different from the semantics in Z3str2
+ bool theory_str::check_length_const_string(expr * n1, expr * constStr) {
+ ast_manager & mgr = get_manager();
+ context & ctx = get_context();
+
+ zstring tmp;
+ u.str.is_string(constStr, tmp);
+ rational strLen(tmp.length());
+
+ if (u.str.is_concat(to_app(n1))) {
+ ptr_vector<expr> args;
+ expr_ref_vector items(mgr);
+
+ get_nodes_in_concat(n1, args);
+
+ rational sumLen(0);
+ for (unsigned int i = 0; i < args.size(); ++i) {
+ rational argLen;
+ bool argLen_exists = get_len_value(args[i], argLen);
+ if (argLen_exists) {
+ if (!u.str.is_string(args[i])) {
+ items.push_back(ctx.mk_eq_atom(mk_strlen(args[i]), mk_int(argLen)));
+ }
+ TRACE("str", tout << "concat arg: " << mk_pp(args[i], mgr) << " has len = " << argLen.to_string() << std::endl;);
+ sumLen += argLen;
+ if (sumLen > strLen) {
+ items.push_back(ctx.mk_eq_atom(n1, constStr));
+ expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
+ TRACE("str", tout << "inconsistent length: concat (len = " << sumLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
+ assert_axiom(toAssert);
+ return false;
+ }
+ }
+ }
+ } else { // !is_concat(n1)
+ rational oLen;
+ bool oLen_exists = get_len_value(n1, oLen);
+ if (oLen_exists && oLen != strLen) {
+ TRACE("str", tout << "inconsistent length: var (len = " << oLen << ") <==> string constant (len = " << strLen << ")" << std::endl;);
+ expr_ref l(ctx.mk_eq_atom(n1, constStr), mgr);
+ expr_ref r(ctx.mk_eq_atom(mk_strlen(n1), mk_strlen(constStr)), mgr);
+ assert_implication(l, r);
+ return false;
+ }
+ }
+ rational unused;
+ if (get_len_value(n1, unused) == false) {
expr_ref l(ctx.mk_eq_atom(n1, constStr), mgr);
expr_ref r(ctx.mk_eq_atom(mk_strlen(n1), mk_strlen(constStr)), mgr);
assert_implication(l, r);
- return false;
}
- }
- rational unused;
- if (get_len_value(n1, unused) == false) {
- expr_ref l(ctx.mk_eq_atom(n1, constStr), mgr);
- expr_ref r(ctx.mk_eq_atom(mk_strlen(n1), mk_strlen(constStr)), mgr);
- assert_implication(l, r);
- }
- return true;
-}
-
-bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
- context & ctx = get_context();
- ast_manager & mgr = get_manager();
-
- ptr_vector<expr> concat1Args;
- ptr_vector<expr> concat2Args;
- get_nodes_in_concat(n1, concat1Args);
- get_nodes_in_concat(n2, concat2Args);
-
- bool concat1LenFixed = true;
- bool concat2LenFixed = true;
-
- expr_ref_vector items(mgr);
-
- rational sum1(0), sum2(0);
-
- for (unsigned int i = 0; i < concat1Args.size(); ++i) {
- expr * oneArg = concat1Args[i];
- rational argLen;
- bool argLen_exists = get_len_value(oneArg, argLen);
- if (argLen_exists) {
- sum1 += argLen;
- if (!u.str.is_string(oneArg)) {
- items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
- }
- } else {
- concat1LenFixed = false;
- }
- }
-
- for (unsigned int i = 0; i < concat2Args.size(); ++i) {
- expr * oneArg = concat2Args[i];
- rational argLen;
- bool argLen_exists = get_len_value(oneArg, argLen);
- if (argLen_exists) {
- sum2 += argLen;
- if (!u.str.is_string(oneArg)) {
- items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
- }
- } else {
- concat2LenFixed = false;
- }
- }
-
- items.push_back(ctx.mk_eq_atom(n1, n2));
-
- bool conflict = false;
-
- if (concat1LenFixed && concat2LenFixed) {
- if (sum1 != sum2) {
- conflict = true;
- }
- } else if (!concat1LenFixed && concat2LenFixed) {
- if (sum1 > sum2) {
- conflict = true;
- }
- } else if (concat1LenFixed && !concat2LenFixed) {
- if (sum1 < sum2) {
- conflict = true;
- }
- }
-
- if (conflict) {
- TRACE("str", tout << "inconsistent length detected in concat <==> concat" << std::endl;);
- expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
- assert_axiom(toAssert);
- return false;
- }
- return true;
-}
-
-bool theory_str::check_length_concat_var(expr * concat, expr * var) {
- context & ctx = get_context();
- ast_manager & mgr = get_manager();
-
- rational varLen;
- bool varLen_exists = get_len_value(var, varLen);
- if (!varLen_exists) {
return true;
- } else {
- rational sumLen(0);
- ptr_vector<expr> args;
+ }
+
+ bool theory_str::check_length_concat_concat(expr * n1, expr * n2) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ ptr_vector<expr> concat1Args;
+ ptr_vector<expr> concat2Args;
+ get_nodes_in_concat(n1, concat1Args);
+ get_nodes_in_concat(n2, concat2Args);
+
+ bool concat1LenFixed = true;
+ bool concat2LenFixed = true;
+
expr_ref_vector items(mgr);
- get_nodes_in_concat(concat, args);
- for (unsigned int i = 0; i < args.size(); ++i) {
- expr * oneArg = args[i];
+
+ rational sum1(0), sum2(0);
+
+ for (unsigned int i = 0; i < concat1Args.size(); ++i) {
+ expr * oneArg = concat1Args[i];
rational argLen;
bool argLen_exists = get_len_value(oneArg, argLen);
if (argLen_exists) {
- if (!u.str.is_string(oneArg) && !argLen.is_zero()) {
+ sum1 += argLen;
+ if (!u.str.is_string(oneArg)) {
items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
}
- sumLen += argLen;
- if (sumLen > varLen) {
- TRACE("str", tout << "inconsistent length detected in concat <==> var" << std::endl;);
- items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_int(varLen)));
- items.push_back(ctx.mk_eq_atom(concat, var));
- expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
- assert_axiom(toAssert);
- return false;
- }
+ } else {
+ concat1LenFixed = false;
}
}
+
+ for (unsigned int i = 0; i < concat2Args.size(); ++i) {
+ expr * oneArg = concat2Args[i];
+ rational argLen;
+ bool argLen_exists = get_len_value(oneArg, argLen);
+ if (argLen_exists) {
+ sum2 += argLen;
+ if (!u.str.is_string(oneArg)) {
+ items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
+ }
+ } else {
+ concat2LenFixed = false;
+ }
+ }
+
+ items.push_back(ctx.mk_eq_atom(n1, n2));
+
+ bool conflict = false;
+
+ if (concat1LenFixed && concat2LenFixed) {
+ if (sum1 != sum2) {
+ conflict = true;
+ }
+ } else if (!concat1LenFixed && concat2LenFixed) {
+ if (sum1 > sum2) {
+ conflict = true;
+ }
+ } else if (concat1LenFixed && !concat2LenFixed) {
+ if (sum1 < sum2) {
+ conflict = true;
+ }
+ }
+
+ if (conflict) {
+ TRACE("str", tout << "inconsistent length detected in concat <==> concat" << std::endl;);
+ expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
+ assert_axiom(toAssert);
+ return false;
+ }
return true;
}
-}
-bool theory_str::check_length_var_var(expr * var1, expr * var2) {
- context & ctx = get_context();
- ast_manager & mgr = get_manager();
+ bool theory_str::check_length_concat_var(expr * concat, expr * var) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
- rational var1Len, var2Len;
- bool var1Len_exists = get_len_value(var1, var1Len);
- bool var2Len_exists = get_len_value(var2, var2Len);
-
- if (var1Len_exists && var2Len_exists && var1Len != var2Len) {
- TRACE("str", tout << "inconsistent length detected in var <==> var" << std::endl;);
- expr_ref_vector items(mgr);
- items.push_back(ctx.mk_eq_atom(mk_strlen(var1), mk_int(var1Len)));
- items.push_back(ctx.mk_eq_atom(mk_strlen(var2), mk_int(var2Len)));
- items.push_back(ctx.mk_eq_atom(var1, var2));
- expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
- assert_axiom(toAssert);
- return false;
- }
- return true;
-}
-
-// returns true if everything is OK, or false if inconsistency detected
-// - note that these are different from the semantics in Z3str2
-bool theory_str::check_length_eq_var_concat(expr * n1, expr * n2) {
- // n1 and n2 are not const string: either variable or concat
- bool n1Concat = u.str.is_concat(to_app(n1));
- bool n2Concat = u.str.is_concat(to_app(n2));
- if (n1Concat && n2Concat) {
- return check_length_concat_concat(n1, n2);
- }
- // n1 is concat, n2 is variable
- else if (n1Concat && (!n2Concat)) {
- return check_length_concat_var(n1, n2);
- }
- // n1 is variable, n2 is concat
- else if ((!n1Concat) && n2Concat) {
- return check_length_concat_var(n2, n1);
- }
- // n1 and n2 are both variables
- else {
- return check_length_var_var(n1, n2);
- }
- return true;
-}
-
-// returns false if an inconsistency is detected, or true if no inconsistencies were found
-// - note that these are different from the semantics of checkLengConsistency() in Z3str2
-bool theory_str::check_length_consistency(expr * n1, expr * n2) {
- if (u.str.is_string(n1) && u.str.is_string(n2)) {
- // consistency has already been checked in can_two_nodes_eq().
- return true;
- } else if (u.str.is_string(n1) && (!u.str.is_string(n2))) {
- return check_length_const_string(n2, n1);
- } else if (u.str.is_string(n2) && (!u.str.is_string(n1))) {
- return check_length_const_string(n1, n2);
- } else {
- // n1 and n2 are vars or concats
- return check_length_eq_var_concat(n1, n2);
- }
- return true;
-}
-
-// Modified signature: returns true if nothing was learned, or false if at least one axiom was asserted.
-// (This is used for deferred consistency checking)
-bool theory_str::check_concat_len_in_eqc(expr * concat) {
- context & ctx = get_context();
-
- bool no_assertions = true;
-
- expr * eqc_n = concat;
- do {
- if (u.str.is_concat(to_app(eqc_n))) {
- rational unused;
- bool status = infer_len_concat(eqc_n, unused);
- if (status) {
- no_assertions = false;
- }
- }
- eqc_n = get_eqc_next(eqc_n);
- } while (eqc_n != concat);
-
- return no_assertions;
-}
-
-// Convert a regular expression to an e-NFA using Thompson's construction
-void nfa::convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u) {
- start = next_id();
- end = next_id();
- if (u.re.is_to_re(e)) {
- app * a = to_app(e);
- expr * arg_str = a->get_arg(0);
- zstring str;
- if (u.str.is_string(arg_str, str)) {
- TRACE("str", tout << "build NFA for '" << str << "'" << "\n";);
- /*
- * For an n-character string, we make (n-1) intermediate states,
- * labelled i_(0) through i_(n-2).
- * Then we construct the following transitions:
- * start --str[0]--> i_(0) --str[1]--> i_(1) --...--> i_(n-2) --str[n-1]--> final
- */
- unsigned last = start;
- for (int i = 0; i <= ((int)str.length()) - 2; ++i) {
- unsigned i_state = next_id();
- make_transition(last, str[i], i_state);
- TRACE("str", tout << "string transition " << last << "--" << str[i] << "--> " << i_state << "\n";);
- last = i_state;
- }
- make_transition(last, str[(str.length() - 1)], end);
- TRACE("str", tout << "string transition " << last << "--" << str[(str.length() - 1)] << "--> " << end << "\n";);
+ rational varLen;
+ bool varLen_exists = get_len_value(var, varLen);
+ if (!varLen_exists) {
+ return true;
} else {
- TRACE("str", tout << "invalid string constant in Str2Reg" << std::endl;);
+ rational sumLen(0);
+ ptr_vector<expr> args;
+ expr_ref_vector items(mgr);
+ get_nodes_in_concat(concat, args);
+ for (unsigned int i = 0; i < args.size(); ++i) {
+ expr * oneArg = args[i];
+ rational argLen;
+ bool argLen_exists = get_len_value(oneArg, argLen);
+ if (argLen_exists) {
+ if (!u.str.is_string(oneArg) && !argLen.is_zero()) {
+ items.push_back(ctx.mk_eq_atom(mk_strlen(oneArg), mk_int(argLen)));
+ }
+ sumLen += argLen;
+ if (sumLen > varLen) {
+ TRACE("str", tout << "inconsistent length detected in concat <==> var" << std::endl;);
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_int(varLen)));
+ items.push_back(ctx.mk_eq_atom(concat, var));
+ expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
+ assert_axiom(toAssert);
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ bool theory_str::check_length_var_var(expr * var1, expr * var2) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ rational var1Len, var2Len;
+ bool var1Len_exists = get_len_value(var1, var1Len);
+ bool var2Len_exists = get_len_value(var2, var2Len);
+
+ if (var1Len_exists && var2Len_exists && var1Len != var2Len) {
+ TRACE("str", tout << "inconsistent length detected in var <==> var" << std::endl;);
+ expr_ref_vector items(mgr);
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var1), mk_int(var1Len)));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var2), mk_int(var2Len)));
+ items.push_back(ctx.mk_eq_atom(var1, var2));
+ expr_ref toAssert(mgr.mk_not(mk_and(items)), mgr);
+ assert_axiom(toAssert);
+ return false;
+ }
+ return true;
+ }
+
+ // returns true if everything is OK, or false if inconsistency detected
+ // - note that these are different from the semantics in Z3str2
+ bool theory_str::check_length_eq_var_concat(expr * n1, expr * n2) {
+ // n1 and n2 are not const string: either variable or concat
+ bool n1Concat = u.str.is_concat(to_app(n1));
+ bool n2Concat = u.str.is_concat(to_app(n2));
+ if (n1Concat && n2Concat) {
+ return check_length_concat_concat(n1, n2);
+ }
+ // n1 is concat, n2 is variable
+ else if (n1Concat && (!n2Concat)) {
+ return check_length_concat_var(n1, n2);
+ }
+ // n1 is variable, n2 is concat
+ else if ((!n1Concat) && n2Concat) {
+ return check_length_concat_var(n2, n1);
+ }
+ // n1 and n2 are both variables
+ else {
+ return check_length_var_var(n1, n2);
+ }
+ return true;
+ }
+
+ // returns false if an inconsistency is detected, or true if no inconsistencies were found
+ // - note that these are different from the semantics of checkLengConsistency() in Z3str2
+ bool theory_str::check_length_consistency(expr * n1, expr * n2) {
+ if (u.str.is_string(n1) && u.str.is_string(n2)) {
+ // consistency has already been checked in can_two_nodes_eq().
+ return true;
+ } else if (u.str.is_string(n1) && (!u.str.is_string(n2))) {
+ return check_length_const_string(n2, n1);
+ } else if (u.str.is_string(n2) && (!u.str.is_string(n1))) {
+ return check_length_const_string(n1, n2);
+ } else {
+ // n1 and n2 are vars or concats
+ return check_length_eq_var_concat(n1, n2);
+ }
+ return true;
+ }
+
+ // Modified signature: returns true if nothing was learned, or false if at least one axiom was asserted.
+ // (This is used for deferred consistency checking)
+ bool theory_str::check_concat_len_in_eqc(expr * concat) {
+ context & ctx = get_context();
+
+ bool no_assertions = true;
+
+ expr * eqc_n = concat;
+ do {
+ if (u.str.is_concat(to_app(eqc_n))) {
+ rational unused;
+ bool status = infer_len_concat(eqc_n, unused);
+ if (status) {
+ no_assertions = false;
+ }
+ }
+ eqc_n = get_eqc_next(eqc_n);
+ } while (eqc_n != concat);
+
+ return no_assertions;
+ }
+
+ // Convert a regular expression to an e-NFA using Thompson's construction
+ void nfa::convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u) {
+ start = next_id();
+ end = next_id();
+ if (u.re.is_to_re(e)) {
+ app * a = to_app(e);
+ expr * arg_str = a->get_arg(0);
+ zstring str;
+ if (u.str.is_string(arg_str, str)) {
+ TRACE("str", tout << "build NFA for '" << str << "'" << "\n";);
+ /*
+ * For an n-character string, we make (n-1) intermediate states,
+ * labelled i_(0) through i_(n-2).
+ * Then we construct the following transitions:
+ * start --str[0]--> i_(0) --str[1]--> i_(1) --...--> i_(n-2) --str[n-1]--> final
+ */
+ unsigned last = start;
+ for (int i = 0; i <= ((int)str.length()) - 2; ++i) {
+ unsigned i_state = next_id();
+ make_transition(last, str[i], i_state);
+ TRACE("str", tout << "string transition " << last << "--" << str[i] << "--> " << i_state << "\n";);
+ last = i_state;
+ }
+ make_transition(last, str[(str.length() - 1)], end);
+ TRACE("str", tout << "string transition " << last << "--" << str[(str.length() - 1)] << "--> " << end << "\n";);
+ } else {
+ TRACE("str", tout << "invalid string constant in Str2Reg" << std::endl;);
+ m_valid = false;
+ return;
+ }
+ } else if (u.re.is_concat(e)){
+ app * a = to_app(e);
+ expr * re1 = a->get_arg(0);
+ expr * re2 = a->get_arg(1);
+ unsigned start1, end1;
+ convert_re(re1, start1, end1, u);
+ unsigned start2, end2;
+ convert_re(re2, start2, end2, u);
+ // start --e--> start1 --...--> end1 --e--> start2 --...--> end2 --e--> end
+ make_epsilon_move(start, start1);
+ make_epsilon_move(end1, start2);
+ make_epsilon_move(end2, end);
+ TRACE("str", tout << "concat NFA: start = " << start << ", end = " << end << std::endl;);
+ } else if (u.re.is_union(e)) {
+ app * a = to_app(e);
+ expr * re1 = a->get_arg(0);
+ expr * re2 = a->get_arg(1);
+ unsigned start1, end1;
+ convert_re(re1, start1, end1, u);
+ unsigned start2, end2;
+ convert_re(re2, start2, end2, u);
+
+ // start --e--> start1 ; start --e--> start2
+ // end1 --e--> end ; end2 --e--> end
+ make_epsilon_move(start, start1);
+ make_epsilon_move(start, start2);
+ make_epsilon_move(end1, end);
+ make_epsilon_move(end2, end);
+ TRACE("str", tout << "union NFA: start = " << start << ", end = " << end << std::endl;);
+ } else if (u.re.is_star(e)) {
+ app * a = to_app(e);
+ expr * subex = a->get_arg(0);
+ unsigned start_subex, end_subex;
+ convert_re(subex, start_subex, end_subex, u);
+ // start --e--> start_subex, start --e--> end
+ // end_subex --e--> start_subex, end_subex --e--> end
+ make_epsilon_move(start, start_subex);
+ make_epsilon_move(start, end);
+ make_epsilon_move(end_subex, start_subex);
+ make_epsilon_move(end_subex, end);
+ TRACE("str", tout << "star NFA: start = " << start << ", end = " << end << std::endl;);
+ } else if (u.re.is_range(e)) {
+ // range('a', 'z')
+ // start --'a'--> end
+ // start --'b'--> end
+ // ...
+ // start --'z'--> end
+ app * a = to_app(e);
+ expr * c1 = a->get_arg(0);
+ expr * c2 = a->get_arg(1);
+ zstring s_c1, s_c2;
+ u.str.is_string(c1, s_c1);
+ u.str.is_string(c2, s_c2);
+
+ unsigned int id1 = s_c1[0];
+ unsigned int id2 = s_c2[0];
+ if (id1 > id2) {
+ unsigned int tmp = id1;
+ id1 = id2;
+ id2 = tmp;
+ }
+
+ for (unsigned int i = id1; i <= id2; ++i) {
+ char ch = (char)i;
+ make_transition(start, ch, end);
+ }
+
+ TRACE("str", tout << "range NFA: start = " << start << ", end = " << end << std::endl;);
+ } else {
+ TRACE("str", tout << "invalid regular expression" << std::endl;);
m_valid = false;
return;
}
- } else if (u.re.is_concat(e)){
- app * a = to_app(e);
- expr * re1 = a->get_arg(0);
- expr * re2 = a->get_arg(1);
- unsigned start1, end1;
- convert_re(re1, start1, end1, u);
- unsigned start2, end2;
- convert_re(re2, start2, end2, u);
- // start --e--> start1 --...--> end1 --e--> start2 --...--> end2 --e--> end
- make_epsilon_move(start, start1);
- make_epsilon_move(end1, start2);
- make_epsilon_move(end2, end);
- TRACE("str", tout << "concat NFA: start = " << start << ", end = " << end << std::endl;);
- } else if (u.re.is_union(e)) {
- app * a = to_app(e);
- expr * re1 = a->get_arg(0);
- expr * re2 = a->get_arg(1);
- unsigned start1, end1;
- convert_re(re1, start1, end1, u);
- unsigned start2, end2;
- convert_re(re2, start2, end2, u);
-
- // start --e--> start1 ; start --e--> start2
- // end1 --e--> end ; end2 --e--> end
- make_epsilon_move(start, start1);
- make_epsilon_move(start, start2);
- make_epsilon_move(end1, end);
- make_epsilon_move(end2, end);
- TRACE("str", tout << "union NFA: start = " << start << ", end = " << end << std::endl;);
- } else if (u.re.is_star(e)) {
- app * a = to_app(e);
- expr * subex = a->get_arg(0);
- unsigned start_subex, end_subex;
- convert_re(subex, start_subex, end_subex, u);
- // start --e--> start_subex, start --e--> end
- // end_subex --e--> start_subex, end_subex --e--> end
- make_epsilon_move(start, start_subex);
- make_epsilon_move(start, end);
- make_epsilon_move(end_subex, start_subex);
- make_epsilon_move(end_subex, end);
- TRACE("str", tout << "star NFA: start = " << start << ", end = " << end << std::endl;);
- } else if (u.re.is_range(e)) {
- // range('a', 'z')
- // start --'a'--> end
- // start --'b'--> end
- // ...
- // start --'z'--> end
- app * a = to_app(e);
- expr * c1 = a->get_arg(0);
- expr * c2 = a->get_arg(1);
- zstring s_c1, s_c2;
- u.str.is_string(c1, s_c1);
- u.str.is_string(c2, s_c2);
-
- unsigned int id1 = s_c1[0];
- unsigned int id2 = s_c2[0];
- if (id1 > id2) {
- unsigned int tmp = id1;
- id1 = id2;
- id2 = tmp;
- }
-
- for (unsigned int i = id1; i <= id2; ++i) {
- char ch = (char)i;
- make_transition(start, ch, end);
- }
-
- TRACE("str", tout << "range NFA: start = " << start << ", end = " << end << std::endl;);
- } else {
- TRACE("str", tout << "invalid regular expression" << std::endl;);
- m_valid = false;
- return;
}
-}
-void nfa::epsilon_closure(unsigned start, std::set<unsigned> & closure) {
- std::deque<unsigned> worklist;
- closure.insert(start);
- worklist.push_back(start);
+ void nfa::epsilon_closure(unsigned start, std::set<unsigned> & closure) {
+ std::deque<unsigned> worklist;
+ closure.insert(start);
+ worklist.push_back(start);
- while(!worklist.empty()) {
- unsigned state = worklist.front();
- worklist.pop_front();
- if (epsilon_map.find(state) != epsilon_map.end()) {
- for (std::set<unsigned>::iterator it = epsilon_map[state].begin();
- it != epsilon_map[state].end(); ++it) {
- unsigned new_state = *it;
- if (closure.find(new_state) == closure.end()) {
- closure.insert(new_state);
- worklist.push_back(new_state);
+ while(!worklist.empty()) {
+ unsigned state = worklist.front();
+ worklist.pop_front();
+ if (epsilon_map.find(state) != epsilon_map.end()) {
+ for (std::set<unsigned>::iterator it = epsilon_map[state].begin();
+ it != epsilon_map[state].end(); ++it) {
+ unsigned new_state = *it;
+ if (closure.find(new_state) == closure.end()) {
+ closure.insert(new_state);
+ worklist.push_back(new_state);
+ }
+ }
+ }
+ }
+ }
+
+ bool nfa::matches(zstring input) {
+ /*
+ * Keep a set of all states the NFA can currently be in.
+ * Initially this is the e-closure of m_start_state
+ * For each character A in the input string,
+ * the set of next states contains
+ * all states in transition_map[S][A] for each S in current_states,
+ * and all states in epsilon_map[S] for each S in current_states.
+ * After consuming the entire input string,
+ * the match is successful iff current_states contains m_end_state.
+ */
+ std::set<unsigned> current_states;
+ epsilon_closure(m_start_state, current_states);
+ for (unsigned i = 0; i < input.length(); ++i) {
+ char A = (char)input[i];
+ std::set<unsigned> next_states;
+ for (std::set<unsigned>::iterator it = current_states.begin();
+ it != current_states.end(); ++it) {
+ unsigned S = *it;
+ // check transition_map
+ if (transition_map[S].find(A) != transition_map[S].end()) {
+ next_states.insert(transition_map[S][A]);
+ }
+ }
+
+ // take e-closure over next_states to compute the actual next_states
+ std::set<unsigned> epsilon_next_states;
+ for (std::set<unsigned>::iterator it = next_states.begin(); it != next_states.end(); ++it) {
+ unsigned S = *it;
+ std::set<unsigned> closure;
+ epsilon_closure(S, closure);
+ epsilon_next_states.insert(closure.begin(), closure.end());
+ }
+ current_states = epsilon_next_states;
+ }
+ if (current_states.find(m_end_state) != current_states.end()) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ void theory_str::check_regex_in(expr * nn1, expr * nn2) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr_ref_vector eqNodeSet(m);
+
+ expr * constStr_1 = collect_eq_nodes(nn1, eqNodeSet);
+ expr * constStr_2 = collect_eq_nodes(nn2, eqNodeSet);
+ expr * constStr = (constStr_1 != NULL) ? constStr_1 : constStr_2;
+
+ if (constStr == NULL) {
+ return;
+ } else {
+ expr_ref_vector::iterator itor = eqNodeSet.begin();
+ for (; itor != eqNodeSet.end(); itor++) {
+ if (regex_in_var_reg_str_map.find(*itor) != regex_in_var_reg_str_map.end()) {
+ std::set<zstring>::iterator strItor = regex_in_var_reg_str_map[*itor].begin();
+ for (; strItor != regex_in_var_reg_str_map[*itor].end(); strItor++) {
+ zstring regStr = *strItor;
+ zstring constStrValue;
+ u.str.is_string(constStr, constStrValue);
+ std::pair<expr*, zstring> key1 = std::make_pair(*itor, regStr);
+ if (regex_in_bool_map.find(key1) != regex_in_bool_map.end()) {
+ expr * boolVar = regex_in_bool_map[key1]; // actually the RegexIn term
+ app * a_regexIn = to_app(boolVar);
+ expr * regexTerm = a_regexIn->get_arg(1);
+
+ // TODO figure out regex NFA stuff
+ if (regex_nfa_cache.find(regexTerm) == regex_nfa_cache.end()) {
+ TRACE("str", tout << "regex_nfa_cache: cache miss" << std::endl;);
+ regex_nfa_cache[regexTerm] = nfa(u, regexTerm);
+ } else {
+ TRACE("str", tout << "regex_nfa_cache: cache hit" << std::endl;);
+ }
+
+ nfa regexNFA = regex_nfa_cache[regexTerm];
+ ENSURE(regexNFA.is_valid());
+ bool matchRes = regexNFA.matches(constStrValue);
+
+ TRACE("str", tout << mk_pp(*itor, m) << " in " << regStr << " : " << (matchRes ? "yes" : "no") << std::endl;);
+
+ expr_ref implyL(ctx.mk_eq_atom(*itor, constStr), m);
+ if (matchRes) {
+ assert_implication(implyL, boolVar);
+ } else {
+ assert_implication(implyL, m.mk_not(boolVar));
+ }
+ }
+ }
}
}
}
}
-}
-bool nfa::matches(zstring input) {
/*
- * Keep a set of all states the NFA can currently be in.
- * Initially this is the e-closure of m_start_state
- * For each character A in the input string,
- * the set of next states contains
- * all states in transition_map[S][A] for each S in current_states,
- * and all states in epsilon_map[S] for each S in current_states.
- * After consuming the entire input string,
- * the match is successful iff current_states contains m_end_state.
+ * strArgmt::solve_concat_eq_str()
+ * Solve concatenations of the form:
+ * const == Concat(const, X)
+ * const == Concat(X, const)
*/
- std::set<unsigned> current_states;
- epsilon_closure(m_start_state, current_states);
- for (unsigned i = 0; i < input.length(); ++i) {
- char A = (char)input[i];
- std::set<unsigned> next_states;
- for (std::set<unsigned>::iterator it = current_states.begin();
- it != current_states.end(); ++it) {
- unsigned S = *it;
- // check transition_map
- if (transition_map[S].find(A) != transition_map[S].end()) {
- next_states.insert(transition_map[S][A]);
- }
- }
-
- // take e-closure over next_states to compute the actual next_states
- std::set<unsigned> epsilon_next_states;
- for (std::set<unsigned>::iterator it = next_states.begin(); it != next_states.end(); ++it) {
- unsigned S = *it;
- std::set<unsigned> closure;
- epsilon_closure(S, closure);
- epsilon_next_states.insert(closure.begin(), closure.end());
- }
- current_states = epsilon_next_states;
- }
- if (current_states.find(m_end_state) != current_states.end()) {
- return true;
- } else {
- return false;
- }
-}
-
-void theory_str::check_regex_in(expr * nn1, expr * nn2) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- expr_ref_vector eqNodeSet(m);
-
- expr * constStr_1 = collect_eq_nodes(nn1, eqNodeSet);
- expr * constStr_2 = collect_eq_nodes(nn2, eqNodeSet);
- expr * constStr = (constStr_1 != NULL) ? constStr_1 : constStr_2;
-
- if (constStr == NULL) {
- return;
- } else {
- expr_ref_vector::iterator itor = eqNodeSet.begin();
- for (; itor != eqNodeSet.end(); itor++) {
- if (regex_in_var_reg_str_map.find(*itor) != regex_in_var_reg_str_map.end()) {
- std::set<zstring>::iterator strItor = regex_in_var_reg_str_map[*itor].begin();
- for (; strItor != regex_in_var_reg_str_map[*itor].end(); strItor++) {
- zstring regStr = *strItor;
- zstring constStrValue;
- u.str.is_string(constStr, constStrValue);
- std::pair<expr*, zstring> key1 = std::make_pair(*itor, regStr);
- if (regex_in_bool_map.find(key1) != regex_in_bool_map.end()) {
- expr * boolVar = regex_in_bool_map[key1]; // actually the RegexIn term
- app * a_regexIn = to_app(boolVar);
- expr * regexTerm = a_regexIn->get_arg(1);
-
- // TODO figure out regex NFA stuff
- if (regex_nfa_cache.find(regexTerm) == regex_nfa_cache.end()) {
- TRACE("str", tout << "regex_nfa_cache: cache miss" << std::endl;);
- regex_nfa_cache[regexTerm] = nfa(u, regexTerm);
- } else {
- TRACE("str", tout << "regex_nfa_cache: cache hit" << std::endl;);
- }
-
- nfa regexNFA = regex_nfa_cache[regexTerm];
- ENSURE(regexNFA.is_valid());
- bool matchRes = regexNFA.matches(constStrValue);
-
- TRACE("str", tout << mk_pp(*itor, m) << " in " << regStr << " : " << (matchRes ? "yes" : "no") << std::endl;);
-
- expr_ref implyL(ctx.mk_eq_atom(*itor, constStr), m);
- if (matchRes) {
- assert_implication(implyL, boolVar);
- } else {
- assert_implication(implyL, m.mk_not(boolVar));
- }
- }
- }
- }
- }
- }
-}
-
-/*
- * strArgmt::solve_concat_eq_str()
- * Solve concatenations of the form:
- * const == Concat(const, X)
- * const == Concat(X, const)
- */
-void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
- ast_manager & m = get_manager();
- context & ctx = get_context();
-
- TRACE("str", tout << mk_ismt2_pp(concat, m) << " == " << mk_ismt2_pp(str, m) << std::endl;);
-
- zstring const_str;
- if (u.str.is_concat(to_app(concat)) && u.str.is_string(to_app(str), const_str)) {
- app * a_concat = to_app(concat);
- SASSERT(a_concat->get_num_args() == 2);
- expr * a1 = a_concat->get_arg(0);
- expr * a2 = a_concat->get_arg(1);
-
- if (const_str.empty()) {
- TRACE("str", tout << "quick path: concat == \"\"" << std::endl;);
- // assert the following axiom:
- // ( (Concat a1 a2) == "" ) -> ( (a1 == "") AND (a2 == "") )
-
-
- expr_ref premise(ctx.mk_eq_atom(concat, str), m);
- expr_ref c1(ctx.mk_eq_atom(a1, str), m);
- expr_ref c2(ctx.mk_eq_atom(a2, str), m);
- expr_ref conclusion(m.mk_and(c1, c2), m);
- assert_implication(premise, conclusion);
-
- return;
- }
- bool arg1_has_eqc_value = false;
- bool arg2_has_eqc_value = false;
- expr * arg1 = get_eqc_value(a1, arg1_has_eqc_value);
- expr * arg2 = get_eqc_value(a2, arg2_has_eqc_value);
- expr_ref newConcat(m);
- if (arg1 != a1 || arg2 != a2) {
- TRACE("str", tout << "resolved concat argument(s) to eqc string constants" << std::endl;);
- int iPos = 0;
- expr_ref_vector item1(m);
- if (a1 != arg1) {
- item1.push_back(ctx.mk_eq_atom(a1, arg1));
- iPos += 1;
- }
- if (a2 != arg2) {
- item1.push_back(ctx.mk_eq_atom(a2, arg2));
- iPos += 1;
- }
- expr_ref implyL1(mk_and(item1), m);
- newConcat = mk_concat(arg1, arg2);
- if (newConcat != str) {
- expr_ref implyR1(ctx.mk_eq_atom(concat, newConcat), m);
- assert_implication(implyL1, implyR1);
- }
- } else {
- newConcat = concat;
- }
- if (newConcat == str) {
- return;
- }
- if (!u.str.is_concat(to_app(newConcat))) {
- return;
- }
- if (arg1_has_eqc_value && arg2_has_eqc_value) {
- // Case 1: Concat(const, const) == const
- TRACE("str", tout << "Case 1: Concat(const, const) == const" << std::endl;);
- zstring arg1_str, arg2_str;
- u.str.is_string(arg1, arg1_str);
- u.str.is_string(arg2, arg2_str);
-
- zstring result_str = arg1_str + arg2_str;
- if (result_str != const_str) {
- // Inconsistency
- TRACE("str", tout << "inconsistency detected: \""
- << arg1_str << "\" + \"" << arg2_str <<
- "\" != \"" << const_str << "\"" << "\n";);
- expr_ref equality(ctx.mk_eq_atom(concat, str), m);
- expr_ref diseq(m.mk_not(equality), m);
- assert_axiom(diseq);
- return;
- }
- } else if (!arg1_has_eqc_value && arg2_has_eqc_value) {
- // Case 2: Concat(var, const) == const
- TRACE("str", tout << "Case 2: Concat(var, const) == const" << std::endl;);
- zstring arg2_str;
- u.str.is_string(arg2, arg2_str);
- unsigned int resultStrLen = const_str.length();
- unsigned int arg2StrLen = arg2_str.length();
- if (resultStrLen < arg2StrLen) {
- // Inconsistency
- TRACE("str", tout << "inconsistency detected: \""
- << arg2_str <<
- "\" is longer than \"" << const_str << "\","
- << " so cannot be concatenated with anything to form it" << "\n";);
- expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
- expr_ref diseq(m.mk_not(equality), m);
- assert_axiom(diseq);
- return;
- } else {
- int varStrLen = resultStrLen - arg2StrLen;
- zstring firstPart = const_str.extract(0, varStrLen);
- zstring secondPart = const_str.extract(varStrLen, arg2StrLen);
- if (arg2_str != secondPart) {
- // Inconsistency
- TRACE("str", tout << "inconsistency detected: "
- << "suffix of concatenation result expected \"" << secondPart << "\", "
- << "actually \"" << arg2_str << "\""
- << "\n";);
- expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
- expr_ref diseq(m.mk_not(equality), m);
- assert_axiom(diseq);
- return;
- } else {
- expr_ref tmpStrConst(mk_string(firstPart), m);
- expr_ref premise(ctx.mk_eq_atom(newConcat, str), m);
- expr_ref conclusion(ctx.mk_eq_atom(arg1, tmpStrConst), m);
- assert_implication(premise, conclusion);
- return;
- }
- }
- } else if (arg1_has_eqc_value && !arg2_has_eqc_value) {
- // Case 3: Concat(const, var) == const
- TRACE("str", tout << "Case 3: Concat(const, var) == const" << std::endl;);
- zstring arg1_str;
- u.str.is_string(arg1, arg1_str);
- unsigned int resultStrLen = const_str.length();
- unsigned int arg1StrLen = arg1_str.length();
- if (resultStrLen < arg1StrLen) {
- // Inconsistency
- TRACE("str", tout << "inconsistency detected: \""
- << arg1_str <<
- "\" is longer than \"" << const_str << "\","
- << " so cannot be concatenated with anything to form it" << "\n";);
- expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
- expr_ref diseq(m.mk_not(equality), m);
- assert_axiom(diseq);
- return;
- } else {
- int varStrLen = resultStrLen - arg1StrLen;
- zstring firstPart = const_str.extract(0, arg1StrLen);
- zstring secondPart = const_str.extract(arg1StrLen, varStrLen);
- if (arg1_str != firstPart) {
- // Inconsistency
- TRACE("str", tout << "inconsistency detected: "
- << "prefix of concatenation result expected \"" << secondPart << "\", "
- << "actually \"" << arg1_str << "\""
- << "\n";);
- expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
- expr_ref diseq(m.mk_not(equality), m);
- assert_axiom(diseq);
- return;
- } else {
- expr_ref tmpStrConst(mk_string(secondPart), m);
- expr_ref premise(ctx.mk_eq_atom(newConcat, str), m);
- expr_ref conclusion(ctx.mk_eq_atom(arg2, tmpStrConst), m);
- assert_implication(premise, conclusion);
- return;
- }
- }
- } else {
- // Case 4: Concat(var, var) == const
- TRACE("str", tout << "Case 4: Concat(var, var) == const" << std::endl;);
- if (eval_concat(arg1, arg2) == NULL) {
- rational arg1Len, arg2Len;
- bool arg1Len_exists = get_len_value(arg1, arg1Len);
- bool arg2Len_exists = get_len_value(arg2, arg2Len);
- rational concatStrLen((unsigned)const_str.length());
- if (arg1Len_exists || arg2Len_exists) {
- expr_ref ax_l1(ctx.mk_eq_atom(concat, str), m);
- expr_ref ax_l2(m);
- zstring prefixStr, suffixStr;
- if (arg1Len_exists) {
- if (arg1Len.is_neg()) {
- TRACE("str", tout << "length conflict: arg1Len = " << arg1Len << ", concatStrLen = " << concatStrLen << std::endl;);
- expr_ref toAssert(m_autil.mk_ge(mk_strlen(arg1), mk_int(0)), m);
- assert_axiom(toAssert);
- return;
- } else if (arg1Len > concatStrLen) {
- TRACE("str", tout << "length conflict: arg1Len = " << arg1Len << ", concatStrLen = " << concatStrLen << std::endl;);
- expr_ref ax_r1(m_autil.mk_le(mk_strlen(arg1), mk_int(concatStrLen)), m);
- assert_implication(ax_l1, ax_r1);
- return;
- }
-
- prefixStr = const_str.extract(0, arg1Len.get_unsigned());
- rational concat_minus_arg1 = concatStrLen - arg1Len;
- suffixStr = const_str.extract(arg1Len.get_unsigned(), concat_minus_arg1.get_unsigned());
- ax_l2 = ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len));
- } else {
- // arg2's length is available
- if (arg2Len.is_neg()) {
- TRACE("str", tout << "length conflict: arg2Len = " << arg2Len << ", concatStrLen = " << concatStrLen << std::endl;);
- expr_ref toAssert(m_autil.mk_ge(mk_strlen(arg2), mk_int(0)), m);
- assert_axiom(toAssert);
- return;
- } else if (arg2Len > concatStrLen) {
- TRACE("str", tout << "length conflict: arg2Len = " << arg2Len << ", concatStrLen = " << concatStrLen << std::endl;);
- expr_ref ax_r1(m_autil.mk_le(mk_strlen(arg2), mk_int(concatStrLen)), m);
- assert_implication(ax_l1, ax_r1);
- return;
- }
-
- rational concat_minus_arg2 = concatStrLen - arg2Len;
- prefixStr = const_str.extract(0, concat_minus_arg2.get_unsigned());
- suffixStr = const_str.extract(concat_minus_arg2.get_unsigned(), arg2Len.get_unsigned());
- ax_l2 = ctx.mk_eq_atom(mk_strlen(arg2), mk_int(arg2Len));
- }
- // consistency check
- if (u.str.is_concat(to_app(arg1)) && !can_concat_eq_str(arg1, prefixStr)) {
- expr_ref ax_r(m.mk_not(ax_l2), m);
- assert_implication(ax_l1, ax_r);
- return;
- }
- if (u.str.is_concat(to_app(arg2)) && !can_concat_eq_str(arg2, suffixStr)) {
- expr_ref ax_r(m.mk_not(ax_l2), m);
- assert_implication(ax_l1, ax_r);
- return;
- }
- expr_ref_vector r_items(m);
- r_items.push_back(ctx.mk_eq_atom(arg1, mk_string(prefixStr)));
- r_items.push_back(ctx.mk_eq_atom(arg2, mk_string(suffixStr)));
- if (!arg1Len_exists) {
- r_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(prefixStr.length())));
- }
- if (!arg2Len_exists) {
- r_items.push_back(ctx.mk_eq_atom(mk_strlen(arg2), mk_int(suffixStr.length())));
- }
- expr_ref lhs(m.mk_and(ax_l1, ax_l2), m);
- expr_ref rhs(mk_and(r_items), m);
- assert_implication(lhs, rhs);
- } else { /* ! (arg1Len != 1 || arg2Len != 1) */
- expr_ref xorFlag(m);
- std::pair<expr*, expr*> key1(arg1, arg2);
- std::pair<expr*, expr*> key2(arg2, arg1);
-
- // check the entries in this map to make sure they're still in scope
- // before we use them.
-
- std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
- std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
-
- bool entry1InScope;
- if (entry1 == varForBreakConcat.end()) {
- TRACE("str", tout << "key1 no entry" << std::endl;);
- entry1InScope = false;
- } else {
- // OVERRIDE.
- entry1InScope = true;
- TRACE("str", tout << "key1 entry" << std::endl;);
- /*
- if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()) {
- TRACE("str", tout << "key1 entry not in scope" << std::endl;);
- entry1InScope = false;
- } else {
- TRACE("str", tout << "key1 entry in scope" << std::endl;);
- entry1InScope = true;
- }
- */
- }
-
- bool entry2InScope;
- if (entry2 == varForBreakConcat.end()) {
- TRACE("str", tout << "key2 no entry" << std::endl;);
- entry2InScope = false;
- } else {
- // OVERRIDE.
- entry2InScope = true;
- TRACE("str", tout << "key2 entry" << std::endl;);
- /*
- if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()) {
- TRACE("str", tout << "key2 entry not in scope" << std::endl;);
- entry2InScope = false;
- } else {
- TRACE("str", tout << "key2 entry in scope" << std::endl;);
- entry2InScope = true;
- }
- */
- }
-
- TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
- << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
-
- if (!entry1InScope && !entry2InScope) {
- xorFlag = mk_internal_xor_var();
- varForBreakConcat[key1][0] = xorFlag;
- } else if (entry1InScope) {
- xorFlag = varForBreakConcat[key1][0];
- } else { // entry2InScope
- xorFlag = varForBreakConcat[key2][0];
- }
-
- int concatStrLen = const_str.length();
- int and_count = 1;
-
- expr_ref_vector arrangement_disjunction(m);
-
- for (int i = 0; i < concatStrLen + 1; ++i) {
- expr_ref_vector and_items(m);
- zstring prefixStr = const_str.extract(0, i);
- zstring suffixStr = const_str.extract(i, concatStrLen - i);
- // skip invalid options
- if (u.str.is_concat(to_app(arg1)) && !can_concat_eq_str(arg1, prefixStr)) {
- continue;
- }
- if (u.str.is_concat(to_app(arg2)) && !can_concat_eq_str(arg2, suffixStr)) {
- continue;
- }
-
- expr_ref prefixAst(mk_string(prefixStr), m);
- expr_ref arg1_eq (ctx.mk_eq_atom(arg1, prefixAst), m);
- and_items.push_back(arg1_eq);
- and_count += 1;
-
- expr_ref suffixAst(mk_string(suffixStr), m);
- expr_ref arg2_eq (ctx.mk_eq_atom(arg2, suffixAst), m);
- and_items.push_back(arg2_eq);
- and_count += 1;
-
- arrangement_disjunction.push_back(mk_and(and_items));
- }
-
- expr_ref implyL(ctx.mk_eq_atom(concat, str), m);
- expr_ref implyR1(m);
- if (arrangement_disjunction.empty()) {
- // negate
- expr_ref concat_eq_str(ctx.mk_eq_atom(concat, str), m);
- expr_ref negate_ast(m.mk_not(concat_eq_str), m);
- assert_axiom(negate_ast);
- } else {
- implyR1 = mk_or(arrangement_disjunction);
- if (m_params.m_StrongArrangements) {
- expr_ref ax_strong(ctx.mk_eq_atom(implyL, implyR1), m);
- assert_axiom(ax_strong);
- } else {
- assert_implication(implyL, implyR1);
- }
- generate_mutual_exclusion(arrangement_disjunction);
- }
- } /* (arg1Len != 1 || arg2Len != 1) */
- } /* if (Concat(arg1, arg2) == NULL) */
- }
- }
-}
-
-expr_ref theory_str::set_up_finite_model_test(expr * lhs, expr * rhs) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- TRACE("str", tout << "activating finite model testing for overlapping concats "
- << mk_pp(lhs, m) << " and " << mk_pp(rhs, m) << std::endl;);
- std::map<expr*, int> concatMap;
- std::map<expr*, int> unrollMap;
- std::map<expr*, int> varMap;
- classify_ast_by_type(lhs, varMap, concatMap, unrollMap);
- classify_ast_by_type(rhs, varMap, concatMap, unrollMap);
- TRACE("str", tout << "found vars:";
- for (std::map<expr*,int>::iterator it = varMap.begin(); it != varMap.end(); ++it) {
- tout << " " << mk_pp(it->first, m);
- }
- tout << std::endl;
- );
-
- expr_ref testvar(mk_str_var("finiteModelTest"), m);
- m_trail.push_back(testvar);
- ptr_vector<expr> varlist;
-
- for (std::map<expr*, int>::iterator it = varMap.begin(); it != varMap.end(); ++it) {
- expr * v = it->first;
- varlist.push_back(v);
- }
-
- // make things easy for the core wrt. testvar
- expr_ref t1(ctx.mk_eq_atom(testvar, mk_string("")), m);
- expr_ref t_yes(ctx.mk_eq_atom(testvar, mk_string("yes")), m);
- expr_ref testvaraxiom(m.mk_or(t1, t_yes), m);
- assert_axiom(testvaraxiom);
-
- finite_model_test_varlists.insert(testvar, varlist);
- m_trail_stack.push(insert_obj_map<theory_str, expr, ptr_vector<expr> >(finite_model_test_varlists, testvar) );
- return t_yes;
-}
-
-void theory_str::finite_model_test(expr * testvar, expr * str) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- zstring s;
- if (!u.str.is_string(str, s)) return;
- if (s == "yes") {
- TRACE("str", tout << "start finite model test for " << mk_pp(testvar, m) << std::endl;);
- ptr_vector<expr> & vars = finite_model_test_varlists[testvar];
- for (ptr_vector<expr>::iterator it = vars.begin(); it != vars.end(); ++it) {
- expr * v = *it;
- bool v_has_eqc = false;
- get_eqc_value(v, v_has_eqc);
- if (v_has_eqc) {
- TRACE("str", tout << "variable " << mk_pp(v,m) << " already equivalent to a string constant" << std::endl;);
- continue;
- }
- // check for any sort of existing length tester we might interfere with
- if (m_params.m_UseBinarySearch) {
- if (binary_search_len_tester_stack.contains(v) && !binary_search_len_tester_stack[v].empty()) {
- TRACE("str", tout << "already found existing length testers for " << mk_pp(v, m) << std::endl;);
- continue;
- } else {
- // start binary search as normal
- expr_ref implLhs(ctx.mk_eq_atom(testvar, str), m);
- expr_ref implRhs(binary_search_length_test(v, NULL, ""), m);
- assert_implication(implLhs, implRhs);
- }
- } else {
- bool map_effectively_empty = false;
- if (!fvar_len_count_map.contains(v)) {
- map_effectively_empty = true;
- }
-
- if (!map_effectively_empty) {
- map_effectively_empty = true;
- ptr_vector<expr> indicator_set = fvar_lenTester_map[v];
- for (ptr_vector<expr>::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) {
- expr * indicator = *it;
- if (internal_variable_set.find(indicator) != internal_variable_set.end()) {
- map_effectively_empty = false;
- break;
- }
- }
- }
-
- if (map_effectively_empty) {
- TRACE("str", tout << "no existing length testers for " << mk_pp(v, m) << std::endl;);
- rational v_len;
- rational v_lower_bound;
- rational v_upper_bound;
- expr_ref vLengthExpr(mk_strlen(v), m);
- if (get_len_value(v, v_len)) {
- TRACE("str", tout << "length = " << v_len.to_string() << std::endl;);
- v_lower_bound = v_len;
- v_upper_bound = v_len;
- } else {
- bool lower_bound_exists = lower_bound(vLengthExpr, v_lower_bound);
- bool upper_bound_exists = upper_bound(vLengthExpr, v_upper_bound);
- TRACE("str", tout << "bounds = [" << (lower_bound_exists?v_lower_bound.to_string():"?")
- << ".." << (upper_bound_exists?v_upper_bound.to_string():"?") << "]" << std::endl;);
-
- // make sure the bounds are non-negative
- if (lower_bound_exists && v_lower_bound.is_neg()) {
- v_lower_bound = rational::zero();
- }
- if (upper_bound_exists && v_upper_bound.is_neg()) {
- v_upper_bound = rational::zero();
- }
-
- if (lower_bound_exists && upper_bound_exists) {
- // easiest case. we will search within these bounds
- } else if (upper_bound_exists && !lower_bound_exists) {
- // search between 0 and the upper bound
- v_lower_bound == rational::zero();
- } else if (lower_bound_exists && !upper_bound_exists) {
- // check some finite portion of the search space
- v_upper_bound = v_lower_bound + rational(10);
- } else {
- // no bounds information
- v_lower_bound = rational::zero();
- v_upper_bound = v_lower_bound + rational(10);
- }
- }
- // now create a fake length tester over this finite disjunction of lengths
-
- fvar_len_count_map[v] = 1;
- unsigned int testNum = fvar_len_count_map[v];
-
- expr_ref indicator(mk_internal_lenTest_var(v, testNum), m);
- SASSERT(indicator);
- m_trail.push_back(indicator);
-
- fvar_lenTester_map[v].shrink(0);
- fvar_lenTester_map[v].push_back(indicator);
- lenTester_fvar_map[indicator] = v;
-
- expr_ref_vector orList(m);
- expr_ref_vector andList(m);
-
- for (rational l = v_lower_bound; l <= v_upper_bound; l += rational::one()) {
- zstring lStr = zstring(l.to_string().c_str());
- expr_ref str_indicator(mk_string(lStr), m);
- expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
- orList.push_back(or_expr);
- expr_ref and_expr(ctx.mk_eq_atom(or_expr, ctx.mk_eq_atom(vLengthExpr, m_autil.mk_numeral(l, true))), m);
- andList.push_back(and_expr);
- }
- andList.push_back(mk_or(orList));
- expr_ref implLhs(ctx.mk_eq_atom(testvar, str), m);
- expr_ref implRhs(mk_and(andList), m);
- assert_implication(implLhs, implRhs);
- } else {
- TRACE("str", tout << "already found existing length testers for " << mk_pp(v, m) << std::endl;);
- continue;
- }
- }
- } // foreach (v in vars)
- } // (s == "yes")
-}
-
-void theory_str::more_len_tests(expr * lenTester, zstring lenTesterValue) {
- ast_manager & m = get_manager();
- if (lenTester_fvar_map.contains(lenTester)) {
- expr * fVar = lenTester_fvar_map[lenTester];
- expr * toAssert = gen_len_val_options_for_free_var(fVar, lenTester, lenTesterValue);
- TRACE("str", tout << "asserting more length tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
- if (toAssert != NULL) {
- assert_axiom(toAssert);
- }
- }
-}
-
-void theory_str::more_value_tests(expr * valTester, zstring valTesterValue) {
- ast_manager & m = get_manager();
-
- expr * fVar = valueTester_fvar_map[valTester];
- if (m_params.m_UseBinarySearch) {
- if (!binary_search_len_tester_stack.contains(fVar) || binary_search_len_tester_stack[fVar].empty()) {
- TRACE("str", tout << "WARNING: no active length testers for " << mk_pp(fVar, m) << std::endl;);
- NOT_IMPLEMENTED_YET();
- }
- expr * effectiveLenInd = binary_search_len_tester_stack[fVar].back();
- bool hasEqcValue;
- expr * len_indicator_value = get_eqc_value(effectiveLenInd, hasEqcValue);
- if (!hasEqcValue) {
- TRACE("str", tout << "WARNING: length tester " << mk_pp(effectiveLenInd, m) << " at top of stack for " << mk_pp(fVar, m) << " has no EQC value" << std::endl;);
- } else {
- // safety check
- zstring effectiveLenIndiStr;
- u.str.is_string(len_indicator_value, effectiveLenIndiStr);
- if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "less") {
- TRACE("str", tout << "ERROR: illegal state -- requesting 'more value tests' but a length tester is not yet concrete!" << std::endl;);
- UNREACHABLE();
- }
- expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
- TRACE("str", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
- if (valueAssert != NULL) {
- assert_axiom(valueAssert);
- }
- }
- } else {
- int lenTesterCount = fvar_lenTester_map[fVar].size();
-
- expr * effectiveLenInd = NULL;
- zstring effectiveLenIndiStr = "";
- for (int i = 0; i < lenTesterCount; ++i) {
- expr * len_indicator_pre = fvar_lenTester_map[fVar][i];
- bool indicatorHasEqcValue = false;
- expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
- if (indicatorHasEqcValue) {
- zstring len_pIndiStr;
- u.str.is_string(len_indicator_value, len_pIndiStr);
- if (len_pIndiStr != "more") {
- effectiveLenInd = len_indicator_pre;
- effectiveLenIndiStr = len_pIndiStr;
- break;
- }
- }
- }
- expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
- TRACE("str", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
- if (valueAssert != NULL) {
- assert_axiom(valueAssert);
- }
- }
-}
-
-bool theory_str::free_var_attempt(expr * nn1, expr * nn2) {
- ast_manager & m = get_manager();
- zstring nn2_str;
- if (internal_lenTest_vars.contains(nn1) && u.str.is_string(nn2, nn2_str)) {
- TRACE("str", tout << "acting on equivalence between length tester var " << mk_ismt2_pp(nn1, m)
- << " and constant " << mk_ismt2_pp(nn2, m) << std::endl;);
- more_len_tests(nn1, nn2_str);
- return true;
- } else if (internal_valTest_vars.contains(nn1) && u.str.is_string(nn2, nn2_str)) {
- if (nn2_str == "more") {
- TRACE("str", tout << "acting on equivalence between value var " << mk_ismt2_pp(nn1, m)
- << " and constant " << mk_ismt2_pp(nn2, m) << std::endl;);
- more_value_tests(nn1, nn2_str);
- }
- return true;
- } else if (internal_unrollTest_vars.contains(nn1)) {
- return true;
- } else {
- return false;
- }
-}
-
-void theory_str::handle_equality(expr * lhs, expr * rhs) {
- ast_manager & m = get_manager();
- context & ctx = get_context();
- // both terms must be of sort String
- sort * lhs_sort = m.get_sort(lhs);
- sort * rhs_sort = m.get_sort(rhs);
- sort * str_sort = u.str.mk_string_sort();
-
- if (lhs_sort != str_sort || rhs_sort != str_sort) {
- TRACE("str", tout << "skip equality: not String sort" << std::endl;);
- return;
- }
-
- /* // temporarily disabled, we are borrowing these testers for something else
- if (m_params.m_FiniteOverlapModels && !finite_model_test_varlists.empty()) {
- if (finite_model_test_varlists.contains(lhs)) {
- finite_model_test(lhs, rhs); return;
- } else if (finite_model_test_varlists.contains(rhs)) {
- finite_model_test(rhs, lhs); return;
- }
- }
- */
-
- if (free_var_attempt(lhs, rhs) || free_var_attempt(rhs, lhs)) {
- return;
- }
-
- if (u.str.is_concat(to_app(lhs)) && u.str.is_concat(to_app(rhs))) {
- bool nn1HasEqcValue = false;
- bool nn2HasEqcValue = false;
- expr * nn1_value = get_eqc_value(lhs, nn1HasEqcValue);
- expr * nn2_value = get_eqc_value(rhs, nn2HasEqcValue);
- if (nn1HasEqcValue && !nn2HasEqcValue) {
- simplify_parent(rhs, nn1_value);
- }
- if (!nn1HasEqcValue && nn2HasEqcValue) {
- simplify_parent(lhs, nn2_value);
- }
-
- expr * nn1_arg0 = to_app(lhs)->get_arg(0);
- expr * nn1_arg1 = to_app(lhs)->get_arg(1);
- expr * nn2_arg0 = to_app(rhs)->get_arg(0);
- expr * nn2_arg1 = to_app(rhs)->get_arg(1);
- if (nn1_arg0 == nn2_arg0 && in_same_eqc(nn1_arg1, nn2_arg1)) {
- TRACE("str", tout << "skip: lhs arg0 == rhs arg0" << std::endl;);
- return;
- }
-
- if (nn1_arg1 == nn2_arg1 && in_same_eqc(nn1_arg0, nn2_arg0)) {
- TRACE("str", tout << "skip: lhs arg1 == rhs arg1" << std::endl;);
- return;
- }
- }
-
- if (opt_DeferEQCConsistencyCheck) {
- TRACE("str", tout << "opt_DeferEQCConsistencyCheck is set; deferring new_eq_check call" << std::endl;);
- } else {
- // newEqCheck() -- check consistency wrt. existing equivalence classes
- if (!new_eq_check(lhs, rhs)) {
- return;
- }
- }
-
- // BEGIN new_eq_handler() in strTheory
-
- {
- rational nn1Len, nn2Len;
- bool nn1Len_exists = get_len_value(lhs, nn1Len);
- bool nn2Len_exists = get_len_value(rhs, nn2Len);
- expr * emptyStr = mk_string("");
-
- if (nn1Len_exists && nn1Len.is_zero()) {
- if (!in_same_eqc(lhs, emptyStr) && rhs != emptyStr) {
- expr_ref eql(ctx.mk_eq_atom(mk_strlen(lhs), mk_int(0)), m);
- expr_ref eqr(ctx.mk_eq_atom(lhs, emptyStr), m);
- expr_ref toAssert(ctx.mk_eq_atom(eql, eqr), m);
- assert_axiom(toAssert);
- }
- }
-
- if (nn2Len_exists && nn2Len.is_zero()) {
- if (!in_same_eqc(rhs, emptyStr) && lhs != emptyStr) {
- expr_ref eql(ctx.mk_eq_atom(mk_strlen(rhs), mk_int(0)), m);
- expr_ref eqr(ctx.mk_eq_atom(rhs, emptyStr), m);
- expr_ref toAssert(ctx.mk_eq_atom(eql, eqr), m);
- assert_axiom(toAssert);
- }
- }
- }
-
- instantiate_str_eq_length_axiom(ctx.get_enode(lhs), ctx.get_enode(rhs));
-
- // group terms by equivalence class (groupNodeInEqc())
-
- std::set<expr*> eqc_concat_lhs;
- std::set<expr*> eqc_var_lhs;
- std::set<expr*> eqc_const_lhs;
- group_terms_by_eqc(lhs, eqc_concat_lhs, eqc_var_lhs, eqc_const_lhs);
-
- std::set<expr*> eqc_concat_rhs;
- std::set<expr*> eqc_var_rhs;
- std::set<expr*> eqc_const_rhs;
- group_terms_by_eqc(rhs, eqc_concat_rhs, eqc_var_rhs, eqc_const_rhs);
-
- TRACE("str",
- tout << "lhs eqc:" << std::endl;
- tout << "Concats:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_concat_lhs.begin(); it != eqc_concat_lhs.end(); ++it) {
- expr * ex = *it;
- tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
- }
- tout << "Variables:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_var_lhs.begin(); it != eqc_var_lhs.end(); ++it) {
- expr * ex = *it;
- tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
- }
- tout << "Constants:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_const_lhs.begin(); it != eqc_const_lhs.end(); ++it) {
- expr * ex = *it;
- tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
- }
-
- tout << "rhs eqc:" << std::endl;
- tout << "Concats:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_concat_rhs.begin(); it != eqc_concat_rhs.end(); ++it) {
- expr * ex = *it;
- tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
- }
- tout << "Variables:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_var_rhs.begin(); it != eqc_var_rhs.end(); ++it) {
- expr * ex = *it;
- tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
- }
- tout << "Constants:" << std::endl;
- for (std::set<expr*>::iterator it = eqc_const_rhs.begin(); it != eqc_const_rhs.end(); ++it) {
- expr * ex = *it;
- tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
- }
- );
-
- // step 1: Concat == Concat
- int hasCommon = 0;
- if (eqc_concat_lhs.size() != 0 && eqc_concat_rhs.size() != 0) {
- std::set<expr*>::iterator itor1 = eqc_concat_lhs.begin();
- std::set<expr*>::iterator itor2 = eqc_concat_rhs.begin();
- for (; itor1 != eqc_concat_lhs.end(); itor1++) {
- if (eqc_concat_rhs.find(*itor1) != eqc_concat_rhs.end()) {
- hasCommon = 1;
- break;
- }
- }
- for (; itor2 != eqc_concat_rhs.end(); itor2++) {
- if (eqc_concat_lhs.find(*itor2) != eqc_concat_lhs.end()) {
- hasCommon = 1;
- break;
- }
- }
- if (hasCommon == 0) {
- if (opt_ConcatOverlapAvoid) {
- bool found = false;
- // check each pair and take the first ones that won't immediately overlap
- for (itor1 = eqc_concat_lhs.begin(); itor1 != eqc_concat_lhs.end() && !found; ++itor1) {
- expr * concat_lhs = *itor1;
- for (itor2 = eqc_concat_rhs.begin(); itor2 != eqc_concat_rhs.end() && !found; ++itor2) {
- expr * concat_rhs = *itor2;
- if (will_result_in_overlap(concat_lhs, concat_rhs)) {
- TRACE("str", tout << "Concats " << mk_pp(concat_lhs, m) << " and "
- << mk_pp(concat_rhs, m) << " will result in overlap; skipping." << std::endl;);
- } else {
- TRACE("str", tout << "Concats " << mk_pp(concat_lhs, m) << " and "
- << mk_pp(concat_rhs, m) << " won't overlap. Simplifying here." << std::endl;);
- simplify_concat_equality(concat_lhs, concat_rhs);
- found = true;
- break;
- }
- }
- }
- if (!found) {
- TRACE("str", tout << "All pairs of concats expected to overlap, falling back." << std::endl;);
- simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin()));
- }
- } else {
- // default behaviour
- simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin()));
- }
- }
- }
-
- // step 2: Concat == Constant
-
- if (eqc_const_lhs.size() != 0) {
- expr * conStr = *(eqc_const_lhs.begin());
- std::set<expr*>::iterator itor2 = eqc_concat_rhs.begin();
- for (; itor2 != eqc_concat_rhs.end(); itor2++) {
- solve_concat_eq_str(*itor2, conStr);
- }
- } else if (eqc_const_rhs.size() != 0) {
- expr* conStr = *(eqc_const_rhs.begin());
- std::set<expr*>::iterator itor1 = eqc_concat_lhs.begin();
- for (; itor1 != eqc_concat_lhs.end(); itor1++) {
- solve_concat_eq_str(*itor1, conStr);
- }
- }
-
- // simplify parents wrt. the equivalence class of both sides
- bool nn1HasEqcValue = false;
- bool nn2HasEqcValue = false;
- // we want the Z3str2 eqc check here...
- expr * nn1_value = z3str2_get_eqc_value(lhs, nn1HasEqcValue);
- expr * nn2_value = z3str2_get_eqc_value(rhs, nn2HasEqcValue);
- if (nn1HasEqcValue && !nn2HasEqcValue) {
- simplify_parent(rhs, nn1_value);
- }
-
- if (!nn1HasEqcValue && nn2HasEqcValue) {
- simplify_parent(lhs, nn2_value);
- }
-
- expr * nn1EqConst = NULL;
- std::set<expr*> nn1EqUnrollFuncs;
- get_eqc_allUnroll(lhs, nn1EqConst, nn1EqUnrollFuncs);
- expr * nn2EqConst = NULL;
- std::set<expr*> nn2EqUnrollFuncs;
- get_eqc_allUnroll(rhs, nn2EqConst, nn2EqUnrollFuncs);
-
- if (nn2EqConst != NULL) {
- for (std::set<expr*>::iterator itor1 = nn1EqUnrollFuncs.begin(); itor1 != nn1EqUnrollFuncs.end(); itor1++) {
- process_unroll_eq_const_str(*itor1, nn2EqConst);
- }
- }
-
- if (nn1EqConst != NULL) {
- for (std::set<expr*>::iterator itor2 = nn2EqUnrollFuncs.begin(); itor2 != nn2EqUnrollFuncs.end(); itor2++) {
- process_unroll_eq_const_str(*itor2, nn1EqConst);
- }
- }
-
-}
-
-void theory_str::set_up_axioms(expr * ex) {
- ast_manager & m = get_manager();
- context & ctx = get_context();
-
- sort * ex_sort = m.get_sort(ex);
- sort * str_sort = u.str.mk_string_sort();
- sort * bool_sort = m.mk_bool_sort();
-
- family_id m_arith_fid = m.mk_family_id("arith");
- sort * int_sort = m.mk_sort(m_arith_fid, INT_SORT);
-
- if (ex_sort == str_sort) {
- TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
- ": expr is of sort String" << std::endl;);
- // set up basic string axioms
- enode * n = ctx.get_enode(ex);
- SASSERT(n);
- m_basicstr_axiom_todo.push_back(n);
- TRACE("str", tout << "add " << mk_pp(ex, m) << " to m_basicstr_axiom_todo" << std::endl;);
-
-
- if (is_app(ex)) {
- app * ap = to_app(ex);
- if (u.str.is_concat(ap)) {
- // if ex is a concat, set up concat axioms later
- m_concat_axiom_todo.push_back(n);
- // we also want to check whether we can eval this concat,
- // in case the rewriter did not totally finish with this term
- m_concat_eval_todo.push_back(n);
- } else if (u.str.is_length(ap)) {
- // if the argument is a variable,
- // keep track of this for later, we'll need it during model gen
- expr * var = ap->get_arg(0);
- app * aVar = to_app(var);
- if (aVar->get_num_args() == 0 && !u.str.is_string(aVar)) {
- input_var_in_len.insert(var);
- }
- } else if (u.str.is_at(ap) || u.str.is_extract(ap) || u.str.is_replace(ap)) {
- m_library_aware_axiom_todo.push_back(n);
- } else if (u.str.is_itos(ap)) {
- TRACE("str", tout << "found string-integer conversion term: " << mk_pp(ex, get_manager()) << std::endl;);
- string_int_conversion_terms.push_back(ap);
- m_library_aware_axiom_todo.push_back(n);
- } else if (ap->get_num_args() == 0 && !u.str.is_string(ap)) {
- // if ex is a variable, add it to our list of variables
- TRACE("str", tout << "tracking variable " << mk_ismt2_pp(ap, get_manager()) << std::endl;);
- variable_set.insert(ex);
- ctx.mark_as_relevant(ex);
- // this might help??
- theory_var v = mk_var(n);
- TRACE("str", tout << "variable " << mk_ismt2_pp(ap, get_manager()) << " is #" << v << std::endl;);
- }
- }
- } else if (ex_sort == bool_sort) {
- TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
- ": expr is of sort Bool" << std::endl;);
- // set up axioms for boolean terms
-
- ensure_enode(ex);
- if (ctx.e_internalized(ex)) {
- enode * n = ctx.get_enode(ex);
- SASSERT(n);
-
- if (is_app(ex)) {
- app * ap = to_app(ex);
- if (u.str.is_prefix(ap) || u.str.is_suffix(ap) || u.str.is_contains(ap) || u.str.is_in_re(ap)) {
- m_library_aware_axiom_todo.push_back(n);
- }
- }
- } else {
- TRACE("str", tout << "WARNING: Bool term " << mk_ismt2_pp(ex, get_manager()) << " not internalized. Delaying axiom setup to prevent a crash." << std::endl;);
- ENSURE(!search_started); // infinite loop prevention
- m_delayed_axiom_setup_terms.push_back(ex);
- return;
- }
- } else if (ex_sort == int_sort) {
- TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
- ": expr is of sort Int" << std::endl;);
- // set up axioms for integer terms
- enode * n = ensure_enode(ex);
- SASSERT(n);
-
- if (is_app(ex)) {
- app * ap = to_app(ex);
- // TODO indexof2/lastindexof
- if (u.str.is_index(ap) /* || is_Indexof2(ap) || is_LastIndexof(ap) */) {
- m_library_aware_axiom_todo.push_back(n);
- } else if (u.str.is_stoi(ap)) {
- TRACE("str", tout << "found string-integer conversion term: " << mk_pp(ex, get_manager()) << std::endl;);
- string_int_conversion_terms.push_back(ap);
- m_library_aware_axiom_todo.push_back(n);
- }
- }
- } else {
- TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
- ": expr is of wrong sort, ignoring" << std::endl;);
- }
-
- // if expr is an application, recursively inspect all arguments
- if (is_app(ex)) {
- app * term = (app*)ex;
- unsigned num_args = term->get_num_args();
- for (unsigned i = 0; i < num_args; i++) {
- set_up_axioms(term->get_arg(i));
- }
- }
-}
-
-void theory_str::add_theory_assumptions(expr_ref_vector & assumptions) {
- TRACE("str", tout << "add overlap assumption for theory_str" << std::endl;);
- symbol strOverlap("!!TheoryStrOverlapAssumption!!");
- seq_util m_sequtil(get_manager());
- sort * s = get_manager().mk_bool_sort();
- m_theoryStrOverlapAssumption_term = expr_ref(get_manager().mk_const(strOverlap, s), get_manager());
- assumptions.push_back(get_manager().mk_not(m_theoryStrOverlapAssumption_term));
-}
-
-lbool theory_str::validate_unsat_core(expr_ref_vector & unsat_core) {
- bool assumptionFound = false;
-
- app * target_term = to_app(get_manager().mk_not(m_theoryStrOverlapAssumption_term));
- get_context().internalize(target_term, false);
- for (unsigned i = 0; i < unsat_core.size(); ++i) {
- app * core_term = to_app(unsat_core.get(i));
- // not sure if this is the correct way to compare terms in this context
- enode * e1;
- enode * e2;
- e1 = get_context().get_enode(target_term);
- e2 = get_context().get_enode(core_term);
- if (e1 == e2) {
- TRACE("str", tout << "overlap detected in unsat core, changing UNSAT to UNKNOWN" << std::endl;);
- assumptionFound = true;
- return l_undef;
- }
- }
-
- return l_false;
-}
-
-void theory_str::init_search_eh() {
- ast_manager & m = get_manager();
- context & ctx = get_context();
-
- TRACE("str",
- tout << "dumping all asserted formulas:" << std::endl;
- unsigned nFormulas = ctx.get_num_asserted_formulas();
- for (unsigned i = 0; i < nFormulas; ++i) {
- expr * ex = ctx.get_asserted_formula(i);
- tout << mk_ismt2_pp(ex, m) << (ctx.is_relevant(ex) ? " (rel)" : " (NOT REL)") << std::endl;
- }
- );
- /*
- * Recursive descent through all asserted formulas to set up axioms.
- * Note that this is just the input structure and not necessarily things
- * that we know to be true or false. We're just doing this to see
- * which terms are explicitly mentioned.
- */
- unsigned nFormulas = ctx.get_num_asserted_formulas();
- for (unsigned i = 0; i < nFormulas; ++i) {
- expr * ex = ctx.get_asserted_formula(i);
- set_up_axioms(ex);
- }
-
- /*
- * Similar recursive descent, except over all initially assigned terms.
- * This is done to find equalities between terms, etc. that we otherwise
- * might not get a chance to see.
- */
-
- /*
- expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
- for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
- expr * ex = *i;
- if (m.is_eq(ex)) {
- TRACE("str", tout << "processing assignment " << mk_ismt2_pp(ex, m) <<
- ": expr is equality" << std::endl;);
- app * eq = (app*)ex;
- SASSERT(eq->get_num_args() == 2);
- expr * lhs = eq->get_arg(0);
- expr * rhs = eq->get_arg(1);
-
- enode * e_lhs = ctx.get_enode(lhs);
- enode * e_rhs = ctx.get_enode(rhs);
- std::pair<enode*,enode*> eq_pair(e_lhs, e_rhs);
- m_str_eq_todo.push_back(eq_pair);
- } else {
- TRACE("str", tout << "processing assignment " << mk_ismt2_pp(ex, m)
- << ": expr ignored" << std::endl;);
- }
- }
- */
-
- // this might be cheating but we need to make sure that certain maps are populated
- // before the first call to new_eq_eh()
- propagate();
-
- TRACE("str", tout << "search started" << std::endl;);
- search_started = true;
-}
-
-void theory_str::new_eq_eh(theory_var x, theory_var y) {
- //TRACE("str", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
- TRACE("str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
- mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
-
- /*
- if (m_find.find(x) == m_find.find(y)) {
- return;
- }
- */
- handle_equality(get_enode(x)->get_owner(), get_enode(y)->get_owner());
-
- // replicate Z3str2 behaviour: merge eqc **AFTER** handle_equality
- m_find.merge(x, y);
-}
-
-void theory_str::new_diseq_eh(theory_var x, theory_var y) {
- //TRACE("str", tout << "new diseq: v#" << x << " != v#" << y << std::endl;);
- TRACE("str", tout << "new diseq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
- mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
-}
-
-void theory_str::relevant_eh(app * n) {
- TRACE("str", tout << "relevant: " << mk_ismt2_pp(n, get_manager()) << std::endl;);
-}
-
-void theory_str::assign_eh(bool_var v, bool is_true) {
- context & ctx = get_context();
- TRACE("str", tout << "assert: v" << v << " #" << ctx.bool_var2expr(v)->get_id() << " is_true: " << is_true << std::endl;);
-}
-
-void theory_str::push_scope_eh() {
- theory::push_scope_eh();
- m_trail_stack.push_scope();
-
- sLevel += 1;
- TRACE("str", tout << "push to " << sLevel << std::endl;);
- TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
-}
-
-void theory_str::recursive_check_variable_scope(expr * ex) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- if (is_app(ex)) {
- app * a = to_app(ex);
- if (a->get_num_args() == 0) {
- // we only care about string variables
- sort * s = m.get_sort(ex);
- sort * string_sort = u.str.mk_string_sort();
- if (s != string_sort) {
- return;
- }
- // base case: string constant / var
- if (u.str.is_string(a)) {
- return;
- } else {
- // assume var
- if (variable_set.find(ex) == variable_set.end()
- && internal_variable_set.find(ex) == internal_variable_set.end()) {
- TRACE("str", tout << "WARNING: possible reference to out-of-scope variable " << mk_pp(ex, m) << std::endl;);
- }
- }
- } else {
- for (unsigned i = 0; i < a->get_num_args(); ++i) {
- recursive_check_variable_scope(a->get_arg(i));
- }
- }
- }
-}
-
-void theory_str::check_variable_scope() {
- if (!opt_CheckVariableScope) {
- return;
- }
-
- if (!is_trace_enabled("t_str_detail")) {
- return;
- }
-
- TRACE("str", tout << "checking scopes of variables in the current assignment" << std::endl;);
-
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
- for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
- expr * ex = *i;
- recursive_check_variable_scope(ex);
- }
-}
-
-void theory_str::pop_scope_eh(unsigned num_scopes) {
- sLevel -= num_scopes;
- TRACE("str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
-
- // list of expr* to remove from cut_var_map
- ptr_vector<expr> cutvarmap_removes;
-
- obj_map<expr, std::stack<T_cut *> >::iterator varItor = cut_var_map.begin();
- while (varItor != cut_var_map.end()) {
- expr * e = varItor->m_key;
- std::stack<T_cut*> & val = cut_var_map[varItor->m_key];
- while ((val.size() > 0) && (val.top()->level != 0) && (val.top()->level >= sLevel)) {
- TRACE("str", tout << "remove cut info for " << mk_pp(e, m) << std::endl; print_cut_var(e, tout););
- T_cut * aCut = val.top();
- val.pop();
- // dealloc(aCut);
- }
- if (val.size() == 0) {
- cutvarmap_removes.insert(varItor->m_key);
- }
- varItor++;
- }
-
- if (!cutvarmap_removes.empty()) {
- ptr_vector<expr>::iterator it = cutvarmap_removes.begin();
- for (; it != cutvarmap_removes.end(); ++it) {
- expr * ex = *it;
- cut_var_map.remove(ex);
- }
- }
-
- ptr_vector<enode> new_m_basicstr;
- for (ptr_vector<enode>::iterator it = m_basicstr_axiom_todo.begin(); it != m_basicstr_axiom_todo.end(); ++it) {
- enode * e = *it;
- app * a = e->get_owner();
- TRACE("str", tout << "consider deleting " << mk_pp(a, get_manager())
- << ", enode scope level is " << e->get_iscope_lvl()
- << std::endl;);
- if (e->get_iscope_lvl() <= (unsigned)sLevel) {
- new_m_basicstr.push_back(e);
- }
- }
- m_basicstr_axiom_todo.reset();
- m_basicstr_axiom_todo = new_m_basicstr;
-
- m_trail_stack.pop_scope(num_scopes);
- theory::pop_scope_eh(num_scopes);
-
- //check_variable_scope();
-}
-
-void theory_str::dump_assignments() {
- TRACE_CODE(
+ void theory_str::solve_concat_eq_str(expr * concat, expr * str) {
ast_manager & m = get_manager();
context & ctx = get_context();
- tout << "dumping all assignments:" << std::endl;
- expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
- for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
- expr * ex = *i;
- tout << mk_ismt2_pp(ex, m) << (ctx.is_relevant(ex) ? "" : " (NOT REL)") << std::endl;
- }
- );
-}
-void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap,
- std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap) {
+ TRACE("str", tout << mk_ismt2_pp(concat, m) << " == " << mk_ismt2_pp(str, m) << std::endl;);
- // check whether the node is a string variable;
- // testing set membership here bypasses several expensive checks.
- // note that internal variables don't count if they're only length tester / value tester vars.
- if (variable_set.find(node) != variable_set.end()
- && internal_lenTest_vars.find(node) == internal_lenTest_vars.end()
- && internal_valTest_vars.find(node) == internal_valTest_vars.end()
- && internal_unrollTest_vars.find(node) == internal_unrollTest_vars.end()) {
- if (varMap[node] != 1) {
- TRACE("str", tout << "new variable: " << mk_pp(node, get_manager()) << std::endl;);
- }
- varMap[node] = 1;
- }
- // check whether the node is a function that we want to inspect
- else if (is_app(node)) {
- app * aNode = to_app(node);
- if (u.str.is_length(aNode)) {
- // Length
- return;
- } else if (u.str.is_concat(aNode)) {
- expr * arg0 = aNode->get_arg(0);
- expr * arg1 = aNode->get_arg(1);
- bool arg0HasEq = false;
- bool arg1HasEq = false;
- expr * arg0Val = get_eqc_value(arg0, arg0HasEq);
- expr * arg1Val = get_eqc_value(arg1, arg1HasEq);
+ zstring const_str;
+ if (u.str.is_concat(to_app(concat)) && u.str.is_string(to_app(str), const_str)) {
+ app * a_concat = to_app(concat);
+ SASSERT(a_concat->get_num_args() == 2);
+ expr * a1 = a_concat->get_arg(0);
+ expr * a2 = a_concat->get_arg(1);
- int canskip = 0;
- zstring tmp;
- u.str.is_string(arg0Val, tmp);
- if (arg0HasEq && tmp.empty()) {
- canskip = 1;
- }
- u.str.is_string(arg1Val, tmp);
- if (canskip == 0 && arg1HasEq && tmp.empty()) {
- canskip = 1;
- }
- if (canskip == 0 && concatMap.find(node) == concatMap.end()) {
- concatMap[node] = 1;
- }
- } else if (u.re.is_unroll(aNode)) {
- // Unroll
- if (unrollMap.find(node) == unrollMap.end()) {
- unrollMap[node] = 1;
- }
- }
- // recursively visit all arguments
- for (unsigned i = 0; i < aNode->get_num_args(); ++i) {
- expr * arg = aNode->get_arg(i);
- classify_ast_by_type(arg, varMap, concatMap, unrollMap);
- }
- }
-}
+ if (const_str.empty()) {
+ TRACE("str", tout << "quick path: concat == \"\"" << std::endl;);
+ // assert the following axiom:
+ // ( (Concat a1 a2) == "" ) -> ( (a1 == "") AND (a2 == "") )
-// NOTE: this function used to take an argument `Z3_ast node`;
-// it was not used and so was removed from the signature
-void theory_str::classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
- std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
- expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
+ expr_ref premise(ctx.mk_eq_atom(concat, str), m);
+ expr_ref c1(ctx.mk_eq_atom(a1, str), m);
+ expr_ref c2(ctx.mk_eq_atom(a2, str), m);
+ expr_ref conclusion(m.mk_and(c1, c2), m);
+ assert_implication(premise, conclusion);
- for (expr_ref_vector::iterator it = assignments.begin(); it != assignments.end(); ++it) {
- expr * argAst = *it;
- // the original code jumped through some hoops to check whether the AST node
- // is a function, then checked whether that function is "interesting".
- // however, the only thing that's considered "interesting" is an equality predicate.
- // so we bypass a huge amount of work by doing the following...
-
- if (m.is_eq(argAst)) {
- TRACE("str", tout
- << "eq ast " << mk_pp(argAst, m) << " is between args of sort "
- << m.get_sort(to_app(argAst)->get_arg(0))->get_name()
- << std::endl;);
- classify_ast_by_type(argAst, varMap, concatMap, unrollMap);
- }
- }
-}
-
-inline expr * theory_str::get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node) {
- if (aliasIndexMap.find(node) != aliasIndexMap.end())
- return aliasIndexMap[node];
- else
- return node;
-}
-
-inline expr * theory_str::getMostLeftNodeInConcat(expr * node) {
- app * aNode = to_app(node);
- if (!u.str.is_concat(aNode)) {
- return node;
- } else {
- expr * concatArgL = aNode->get_arg(0);
- return getMostLeftNodeInConcat(concatArgL);
- }
-}
-
-inline expr * theory_str::getMostRightNodeInConcat(expr * node) {
- app * aNode = to_app(node);
- if (!u.str.is_concat(aNode)) {
- return node;
- } else {
- expr * concatArgR = aNode->get_arg(1);
- return getMostRightNodeInConcat(concatArgR);
- }
-}
-
-void theory_str::trace_ctx_dep(std::ofstream & tout,
- std::map<expr*, expr*> & aliasIndexMap,
- std::map<expr*, expr*> & var_eq_constStr_map,
- std::map<expr*, std::map<expr*, int> > & var_eq_concat_map,
- std::map<expr*, std::map<expr*, int> > & var_eq_unroll_map,
- std::map<expr*, expr*> & concat_eq_constStr_map,
- std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map,
- std::map<expr*, std::set<expr*> > & unrollGroupMap) {
-#ifdef _TRACE
- context & ctx = get_context();
- ast_manager & mgr = get_manager();
- {
- tout << "(0) alias: variables" << std::endl;
- std::map<expr*, std::map<expr*, int> > aliasSumMap;
- std::map<expr*, expr*>::iterator itor0 = aliasIndexMap.begin();
- for (; itor0 != aliasIndexMap.end(); itor0++) {
- aliasSumMap[itor0->second][itor0->first] = 1;
- }
- std::map<expr*, std::map<expr*, int> >::iterator keyItor = aliasSumMap.begin();
- for (; keyItor != aliasSumMap.end(); keyItor++) {
- tout << " * ";
- tout << mk_pp(keyItor->first, mgr);
- tout << " : ";
- std::map<expr*, int>::iterator innerItor = keyItor->second.begin();
- for (; innerItor != keyItor->second.end(); innerItor++) {
- tout << mk_pp(innerItor->first, mgr);
- tout << ", ";
+ return;
}
- tout << std::endl;
- }
- tout << std::endl;
- }
-
- {
- tout << "(1) var = constStr:" << std::endl;
- std::map<expr*, expr*>::iterator itor1 = var_eq_constStr_map.begin();
- for (; itor1 != var_eq_constStr_map.end(); itor1++) {
- tout << " * ";
- tout << mk_pp(itor1->first, mgr);
- tout << " = ";
- tout << mk_pp(itor1->second, mgr);
- if (!in_same_eqc(itor1->first, itor1->second)) {
- tout << " (not true in ctx)";
- }
- tout << std::endl;
- }
- tout << std::endl;
- }
-
- {
- tout << "(2) var = concat:" << std::endl;
- std::map<expr*, std::map<expr*, int> >::iterator itor2 = var_eq_concat_map.begin();
- for (; itor2 != var_eq_concat_map.end(); itor2++) {
- tout << " * ";
- tout << mk_pp(itor2->first, mgr);
- tout << " = { ";
- std::map<expr*, int>::iterator i_itor = itor2->second.begin();
- for (; i_itor != itor2->second.end(); i_itor++) {
- tout << mk_pp(i_itor->first, mgr);
- tout << ", ";
- }
- tout << std::endl;
- }
- tout << std::endl;
- }
-
- {
- tout << "(3) var = unrollFunc:" << std::endl;
- std::map<expr*, std::map<expr*, int> >::iterator itor2 = var_eq_unroll_map.begin();
- for (; itor2 != var_eq_unroll_map.end(); itor2++) {
- tout << " * " << mk_pp(itor2->first, mgr) << " = { ";
- std::map<expr*, int>::iterator i_itor = itor2->second.begin();
- for (; i_itor != itor2->second.end(); i_itor++) {
- tout << mk_pp(i_itor->first, mgr) << ", ";
- }
- tout << " }" << std::endl;
- }
- tout << std::endl;
- }
-
- {
- tout << "(4) concat = constStr:" << std::endl;
- std::map<expr*, expr*>::iterator itor3 = concat_eq_constStr_map.begin();
- for (; itor3 != concat_eq_constStr_map.end(); itor3++) {
- tout << " * ";
- tout << mk_pp(itor3->first, mgr);
- tout << " = ";
- tout << mk_pp(itor3->second, mgr);
- tout << std::endl;
-
- }
- tout << std::endl;
- }
-
- {
- tout << "(5) eq concats:" << std::endl;
- std::map<expr*, std::map<expr*, int> >::iterator itor4 = concat_eq_concat_map.begin();
- for (; itor4 != concat_eq_concat_map.end(); itor4++) {
- if (itor4->second.size() > 1) {
- std::map<expr*, int>::iterator i_itor = itor4->second.begin();
- tout << " * ";
- for (; i_itor != itor4->second.end(); i_itor++) {
- tout << mk_pp(i_itor->first, mgr);
- tout << " , ";
+ bool arg1_has_eqc_value = false;
+ bool arg2_has_eqc_value = false;
+ expr * arg1 = get_eqc_value(a1, arg1_has_eqc_value);
+ expr * arg2 = get_eqc_value(a2, arg2_has_eqc_value);
+ expr_ref newConcat(m);
+ if (arg1 != a1 || arg2 != a2) {
+ TRACE("str", tout << "resolved concat argument(s) to eqc string constants" << std::endl;);
+ int iPos = 0;
+ expr_ref_vector item1(m);
+ if (a1 != arg1) {
+ item1.push_back(ctx.mk_eq_atom(a1, arg1));
+ iPos += 1;
}
- tout << std::endl;
- }
- }
- tout << std::endl;
- }
-
- {
- tout << "(6) eq unrolls:" << std::endl;
- std::map<expr*, std::set<expr*> >::iterator itor5 = unrollGroupMap.begin();
- for (; itor5 != unrollGroupMap.end(); itor5++) {
- tout << " * ";
- std::set<expr*>::iterator i_itor = itor5->second.begin();
- for (; i_itor != itor5->second.end(); i_itor++) {
- tout << mk_pp(*i_itor, mgr) << ", ";
- }
- tout << std::endl;
- }
- tout << std::endl;
- }
-
- {
- tout << "(7) unroll = concats:" << std::endl;
- std::map<expr*, std::set<expr*> >::iterator itor5 = unrollGroupMap.begin();
- for (; itor5 != unrollGroupMap.end(); itor5++) {
- tout << " * ";
- expr * unroll = itor5->first;
- tout << mk_pp(unroll, mgr) << std::endl;
- enode * e_curr = ctx.get_enode(unroll);
- enode * e_curr_end = e_curr;
- do {
- app * curr = e_curr->get_owner();
- if (u.str.is_concat(curr)) {
- tout << " >>> " << mk_pp(curr, mgr) << std::endl;
+ if (a2 != arg2) {
+ item1.push_back(ctx.mk_eq_atom(a2, arg2));
+ iPos += 1;
}
- e_curr = e_curr->get_next();
- } while (e_curr != e_curr_end);
- tout << std::endl;
- }
- tout << std::endl;
- }
-#else
- return;
-#endif // _TRACE
-}
-
-
-/*
- * Dependence analysis from current context assignment
- * - "freeVarMap" contains a set of variables that doesn't constrained by Concats.
- * But it's possible that it's bounded by unrolls
- * For the case of
- * (1) var1 = unroll(r1, t1)
- * var1 is in the freeVarMap
- * > should unroll r1 for var1
- * (2) var1 = unroll(r1, t1) /\ var1 = Concat(var2, var3)
- * var2, var3 are all in freeVar
- * > should split the unroll function so that var2 and var3 are bounded by new unrolls
- */
-int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr*, int> & freeVarMap,
- std::map<expr*, std::set<expr*> > & unrollGroupMap, std::map<expr*, std::map<expr*, int> > & var_eq_concat_map) {
- std::map<expr*, int> concatMap;
- std::map<expr*, int> unrollMap;
- std::map<expr*, expr*> aliasIndexMap;
- std::map<expr*, expr*> var_eq_constStr_map;
- std::map<expr*, expr*> concat_eq_constStr_map;
- std::map<expr*, std::map<expr*, int> > var_eq_unroll_map;
- std::map<expr*, std::map<expr*, int> > concat_eq_concat_map;
- std::map<expr*, std::map<expr*, int> > depMap;
-
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- // note that the old API concatenated these assignments into
- // a massive conjunction; we may have the opportunity to avoid that here
- expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
-
- // Step 1: get variables / concat AST appearing in the context
- // the thing we iterate over should just be variable_set - internal_variable_set
- // so we avoid computing the set difference (but this might be slower)
- for(obj_hashtable<expr>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
- expr* var = *it;
- if (internal_variable_set.find(var) == internal_variable_set.end()) {
- TRACE("str", tout << "new variable: " << mk_pp(var, m) << std::endl;);
- strVarMap[*it] = 1;
- }
- }
- classify_ast_by_type_in_positive_context(strVarMap, concatMap, unrollMap);
-
- std::map<expr*, expr*> aliasUnrollSet;
- std::map<expr*, int>::iterator unrollItor = unrollMap.begin();
- for (; unrollItor != unrollMap.end(); ++unrollItor) {
- if (aliasUnrollSet.find(unrollItor->first) != aliasUnrollSet.end()) {
- continue;
- }
- expr * aRoot = NULL;
- enode * e_currEqc = ctx.get_enode(unrollItor->first);
- enode * e_curr = e_currEqc;
- do {
- app * curr = e_currEqc->get_owner();
- if (u.re.is_unroll(curr)) {
- if (aRoot == NULL) {
- aRoot = curr;
- }
- aliasUnrollSet[curr] = aRoot;
- }
- e_currEqc = e_currEqc->get_next();
- } while (e_currEqc != e_curr);
- }
-
- for (unrollItor = unrollMap.begin(); unrollItor != unrollMap.end(); unrollItor++) {
- expr * unrFunc = unrollItor->first;
- expr * urKey = aliasUnrollSet[unrFunc];
- unrollGroupMap[urKey].insert(unrFunc);
- }
-
- // Step 2: collect alias relation
- // e.g. suppose we have the equivalence class {x, y, z};
- // then we set aliasIndexMap[y] = x
- // and aliasIndexMap[z] = x
-
- std::map<expr*, int>::iterator varItor = strVarMap.begin();
- for (; varItor != strVarMap.end(); ++varItor) {
- if (aliasIndexMap.find(varItor->first) != aliasIndexMap.end()) {
- continue;
- }
- expr * aRoot = NULL;
- expr * curr = varItor->first;
- do {
- if (variable_set.find(curr) != variable_set.end()) {
- if (aRoot == NULL) {
- aRoot = curr;
- } else {
- aliasIndexMap[curr] = aRoot;
- }
- }
- curr = get_eqc_next(curr);
- } while (curr != varItor->first);
- }
-
- // Step 3: Collect interested cases
-
- varItor = strVarMap.begin();
- for (; varItor != strVarMap.end(); ++varItor) {
- expr * deAliasNode = get_alias_index_ast(aliasIndexMap, varItor->first);
- // Case 1: variable = string constant
- // e.g. z = "str1" ::= var_eq_constStr_map[z] = "str1"
-
- if (var_eq_constStr_map.find(deAliasNode) == var_eq_constStr_map.end()) {
- bool nodeHasEqcValue = false;
- expr * nodeValue = get_eqc_value(deAliasNode, nodeHasEqcValue);
- if (nodeHasEqcValue) {
- var_eq_constStr_map[deAliasNode] = nodeValue;
- }
- }
-
- // Case 2: var_eq_concat
- // e.g. z = concat("str1", b) ::= var_eq_concat[z][concat(c, "str2")] = 1
- // var_eq_unroll
- // e.g. z = unroll(...) ::= var_eq_unroll[z][unroll(...)] = 1
-
- if (var_eq_concat_map.find(deAliasNode) == var_eq_concat_map.end()) {
- expr * curr = get_eqc_next(deAliasNode);
- while (curr != deAliasNode) {
- app * aCurr = to_app(curr);
- // collect concat
- if (u.str.is_concat(aCurr)) {
- expr * arg0 = aCurr->get_arg(0);
- expr * arg1 = aCurr->get_arg(1);
- bool arg0HasEqcValue = false;
- bool arg1HasEqcValue = false;
- expr * arg0_value = get_eqc_value(arg0, arg0HasEqcValue);
- expr * arg1_value = get_eqc_value(arg1, arg1HasEqcValue);
-
- bool is_arg0_emptyStr = false;
- if (arg0HasEqcValue) {
- zstring strval;
- u.str.is_string(arg0_value, strval);
- if (strval.empty()) {
- is_arg0_emptyStr = true;
- }
- }
-
- bool is_arg1_emptyStr = false;
- if (arg1HasEqcValue) {
- zstring strval;
- u.str.is_string(arg1_value, strval);
- if (strval.empty()) {
- is_arg1_emptyStr = true;
- }
- }
-
- if (!is_arg0_emptyStr && !is_arg1_emptyStr) {
- var_eq_concat_map[deAliasNode][curr] = 1;
- }
- } else if (u.re.is_unroll(to_app(curr))) {
- var_eq_unroll_map[deAliasNode][curr] = 1;
- }
-
- curr = get_eqc_next(curr);
- }
- }
-
- } // for(varItor in strVarMap)
-
- // --------------------------------------------------
- // * collect aliasing relation among eq concats
- // e.g EQC={concat1, concat2, concat3}
- // concats_eq_Index_map[concat2] = concat1
- // concats_eq_Index_map[concat3] = concat1
- // --------------------------------------------------
-
- std::map<expr*, expr*> concats_eq_index_map;
- std::map<expr*, int>::iterator concatItor = concatMap.begin();
- for(; concatItor != concatMap.end(); ++concatItor) {
- if (concats_eq_index_map.find(concatItor->first) != concats_eq_index_map.end()) {
- continue;
- }
- expr * aRoot = NULL;
- expr * curr = concatItor->first;
- do {
- if (u.str.is_concat(to_app(curr))) {
- if (aRoot == NULL) {
- aRoot = curr;
- } else {
- concats_eq_index_map[curr] = aRoot;
- }
- }
- curr = get_eqc_next(curr);
- } while (curr != concatItor->first);
- }
-
- concatItor = concatMap.begin();
- for(; concatItor != concatMap.end(); ++concatItor) {
- expr * deAliasConcat = NULL;
- if (concats_eq_index_map.find(concatItor->first) != concats_eq_index_map.end()) {
- deAliasConcat = concats_eq_index_map[concatItor->first];
- } else {
- deAliasConcat = concatItor->first;
- }
-
- // (3) concat_eq_conststr, e.g. concat(a,b) = "str1"
- if (concat_eq_constStr_map.find(deAliasConcat) == concat_eq_constStr_map.end()) {
- bool nodeHasEqcValue = false;
- expr * nodeValue = get_eqc_value(deAliasConcat, nodeHasEqcValue);
- if (nodeHasEqcValue) {
- concat_eq_constStr_map[deAliasConcat] = nodeValue;
- }
- }
-
- // (4) concat_eq_concat, e.g.
- // concat(a,b) = concat("str1", c) AND z = concat(a,b) AND z = concat(e,f)
- if (concat_eq_concat_map.find(deAliasConcat) == concat_eq_concat_map.end()) {
- expr * curr = deAliasConcat;
- do {
- if (u.str.is_concat(to_app(curr))) {
- // curr cannot be reduced
- if (concatMap.find(curr) != concatMap.end()) {
- concat_eq_concat_map[deAliasConcat][curr] = 1;
- }
- }
- curr = get_eqc_next(curr);
- } while (curr != deAliasConcat);
- }
- }
-
- // print some debugging info
- TRACE("str", trace_ctx_dep(tout, aliasIndexMap, var_eq_constStr_map,
- var_eq_concat_map, var_eq_unroll_map,
- concat_eq_constStr_map, concat_eq_concat_map, unrollGroupMap););
-
- if (!contain_pair_bool_map.empty()) {
- compute_contains(aliasIndexMap, concats_eq_index_map, var_eq_constStr_map, concat_eq_constStr_map, var_eq_concat_map);
- }
-
- // step 4: dependence analysis
-
- // (1) var = string constant
- for (std::map<expr*, expr*>::iterator itor = var_eq_constStr_map.begin();
- itor != var_eq_constStr_map.end(); ++itor) {
- expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
- expr * strAst = itor->second;
- depMap[var][strAst] = 1;
- }
-
- // (2) var = concat
- for (std::map<expr*, std::map<expr*, int> >::iterator itor = var_eq_concat_map.begin();
- itor != var_eq_concat_map.end(); ++itor) {
- expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
- for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); ++itor1) {
- expr * concat = itor1->first;
- std::map<expr*, int> inVarMap;
- std::map<expr*, int> inConcatMap;
- std::map<expr*, int> inUnrollMap;
- classify_ast_by_type(concat, inVarMap, inConcatMap, inUnrollMap);
- for (std::map<expr*, int>::iterator itor2 = inVarMap.begin(); itor2 != inVarMap.end(); ++itor2) {
- expr * varInConcat = get_alias_index_ast(aliasIndexMap, itor2->first);
- if (!(depMap[var].find(varInConcat) != depMap[var].end() && depMap[var][varInConcat] == 1)) {
- depMap[var][varInConcat] = 2;
- }
- }
- }
- }
-
- for (std::map<expr*, std::map<expr*, int> >::iterator itor = var_eq_unroll_map.begin();
- itor != var_eq_unroll_map.end(); itor++) {
- expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
- for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
- expr * unrollFunc = itor1->first;
- std::map<expr*, int> inVarMap;
- std::map<expr*, int> inConcatMap;
- std::map<expr*, int> inUnrollMap;
- classify_ast_by_type(unrollFunc, inVarMap, inConcatMap, inUnrollMap);
- for (std::map<expr*, int>::iterator itor2 = inVarMap.begin(); itor2 != inVarMap.end(); itor2++) {
- expr * varInFunc = get_alias_index_ast(aliasIndexMap, itor2->first);
-
- TRACE("str", tout << "var in unroll = " <<
- mk_ismt2_pp(itor2->first, m) << std::endl
- << "dealiased var = " << mk_ismt2_pp(varInFunc, m) << std::endl;);
-
- // it's possible that we have both (Unroll $$_regVar_0 $$_unr_0) /\ (Unroll abcd $$_unr_0),
- // while $$_regVar_0 = "abcd"
- // have to exclude such cases
- bool varHasValue = false;
- get_eqc_value(varInFunc, varHasValue);
- if (varHasValue)
- continue;
-
- if (depMap[var].find(varInFunc) == depMap[var].end()) {
- depMap[var][varInFunc] = 6;
- }
- }
- }
- }
-
- // (3) concat = string constant
- for (std::map<expr*, expr*>::iterator itor = concat_eq_constStr_map.begin();
- itor != concat_eq_constStr_map.end(); itor++) {
- expr * concatAst = itor->first;
- expr * constStr = itor->second;
- std::map<expr*, int> inVarMap;
- std::map<expr*, int> inConcatMap;
- std::map<expr*, int> inUnrollMap;
- classify_ast_by_type(concatAst, inVarMap, inConcatMap, inUnrollMap);
- for (std::map<expr*, int>::iterator itor2 = inVarMap.begin(); itor2 != inVarMap.end(); itor2++) {
- expr * varInConcat = get_alias_index_ast(aliasIndexMap, itor2->first);
- if (!(depMap[varInConcat].find(constStr) != depMap[varInConcat].end() && depMap[varInConcat][constStr] == 1))
- depMap[varInConcat][constStr] = 3;
- }
- }
-
- // (4) equivalent concats
- // - possibility 1 : concat("str", v1) = concat(concat(v2, v3), v4) = concat(v5, v6)
- // ==> v2, v5 are constrained by "str"
- // - possibility 2 : concat(v1, "str") = concat(v2, v3) = concat(v4, v5)
- // ==> v2, v4 are constrained by "str"
- //--------------------------------------------------------------
-
- std::map<expr*, expr*> mostLeftNodes;
- std::map<expr*, expr*> mostRightNodes;
-
- std::map<expr*, int> mLIdxMap;
- std::map<int, std::set<expr*> > mLMap;
- std::map<expr*, int> mRIdxMap;
- std::map<int, std::set<expr*> > mRMap;
- std::set<expr*> nSet;
-
- for (std::map<expr*, std::map<expr*, int> >::iterator itor = concat_eq_concat_map.begin();
- itor != concat_eq_concat_map.end(); itor++) {
- mostLeftNodes.clear();
- mostRightNodes.clear();
-
- expr * mLConst = NULL;
- expr * mRConst = NULL;
-
- for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
- expr * concatNode = itor1->first;
- expr * mLNode = getMostLeftNodeInConcat(concatNode);
- zstring strval;
- if (u.str.is_string(to_app(mLNode), strval)) {
- if (mLConst == NULL && strval.empty()) {
- mLConst = mLNode;
- }
- } else {
- mostLeftNodes[mLNode] = concatNode;
- }
-
- expr * mRNode = getMostRightNodeInConcat(concatNode);
- if (u.str.is_string(to_app(mRNode), strval)) {
- if (mRConst == NULL && strval.empty()) {
- mRConst = mRNode;
- }
- } else {
- mostRightNodes[mRNode] = concatNode;
- }
- }
-
- if (mLConst != NULL) {
- // -------------------------------------------------------------------------------------
- // The left most variable in a concat is constrained by a constant string in eqc concat
- // -------------------------------------------------------------------------------------
- // e.g. Concat(x, ...) = Concat("abc", ...)
- // -------------------------------------------------------------------------------------
- for (std::map<expr*, expr*>::iterator itor1 = mostLeftNodes.begin();
- itor1 != mostLeftNodes.end(); itor1++) {
- expr * deVar = get_alias_index_ast(aliasIndexMap, itor1->first);
- if (depMap[deVar].find(mLConst) == depMap[deVar].end() || depMap[deVar][mLConst] != 1) {
- depMap[deVar][mLConst] = 4;
- }
- }
- }
-
- {
- // -------------------------------------------------------------------------------------
- // The left most variables in eqc concats are constrained by each other
- // -------------------------------------------------------------------------------------
- // e.g. concat(x, ...) = concat(u, ...) = ...
- // x and u are constrained by each other
- // -------------------------------------------------------------------------------------
- nSet.clear();
- std::map<expr*, expr*>::iterator itl = mostLeftNodes.begin();
- for (; itl != mostLeftNodes.end(); itl++) {
- bool lfHasEqcValue = false;
- get_eqc_value(itl->first, lfHasEqcValue);
- if (lfHasEqcValue)
- continue;
- expr * deVar = get_alias_index_ast(aliasIndexMap, itl->first);
- nSet.insert(deVar);
- }
-
- if (nSet.size() > 1) {
- int lId = -1;
- for (std::set<expr*>::iterator itor2 = nSet.begin(); itor2 != nSet.end(); itor2++) {
- if (mLIdxMap.find(*itor2) != mLIdxMap.end()) {
- lId = mLIdxMap[*itor2];
- break;
- }
- }
- if (lId == -1)
- lId = mLMap.size();
- for (std::set<expr*>::iterator itor2 = nSet.begin(); itor2 != nSet.end(); itor2++) {
- bool itorHasEqcValue = false;
- get_eqc_value(*itor2, itorHasEqcValue);
- if (itorHasEqcValue)
- continue;
- mLIdxMap[*itor2] = lId;
- mLMap[lId].insert(*itor2);
- }
- }
- }
-
- if (mRConst != NULL) {
- for (std::map<expr*, expr*>::iterator itor1 = mostRightNodes.begin();
- itor1 != mostRightNodes.end(); itor1++) {
- expr * deVar = get_alias_index_ast(aliasIndexMap, itor1->first);
- if (depMap[deVar].find(mRConst) == depMap[deVar].end() || depMap[deVar][mRConst] != 1) {
- depMap[deVar][mRConst] = 5;
- }
- }
- }
-
- {
- nSet.clear();
- std::map<expr*, expr*>::iterator itr = mostRightNodes.begin();
- for (; itr != mostRightNodes.end(); itr++) {
- expr * deVar = get_alias_index_ast(aliasIndexMap, itr->first);
- nSet.insert(deVar);
- }
- if (nSet.size() > 1) {
- int rId = -1;
- std::set<expr*>::iterator itor2 = nSet.begin();
- for (; itor2 != nSet.end(); itor2++) {
- if (mRIdxMap.find(*itor2) != mRIdxMap.end()) {
- rId = mRIdxMap[*itor2];
- break;
- }
- }
- if (rId == -1)
- rId = mRMap.size();
- for (itor2 = nSet.begin(); itor2 != nSet.end(); itor2++) {
- bool rHasEqcValue = false;
- get_eqc_value(*itor2, rHasEqcValue);
- if (rHasEqcValue)
- continue;
- mRIdxMap[*itor2] = rId;
- mRMap[rId].insert(*itor2);
- }
- }
- }
- }
-
- // print the dependence map
- TRACE("str",
- tout << "Dependence Map" << std::endl;
- for(std::map<expr*, std::map<expr*, int> >::iterator itor = depMap.begin(); itor != depMap.end(); itor++) {
- tout << mk_pp(itor->first, m);
- rational nnLen;
- bool nnLen_exists = get_len_value(itor->first, nnLen);
- tout << " [len = " << (nnLen_exists ? nnLen.to_string() : "?") << "] \t-->\t";
- for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
- tout << mk_pp(itor1->first, m) << "(" << itor1->second << "), ";
- }
- tout << std::endl;
- }
- );
-
- // step, errr, 5: compute free variables based on the dependence map
-
- // the case dependence map is empty, every var in VarMap is free
- //---------------------------------------------------------------
- // remove L/R most var in eq concat since they are constrained with each other
- std::map<expr*, std::map<expr*, int> > lrConstrainedMap;
- for (std::map<int, std::set<expr*> >::iterator itor = mLMap.begin(); itor != mLMap.end(); itor++) {
- for (std::set<expr*>::iterator it1 = itor->second.begin(); it1 != itor->second.end(); it1++) {
- std::set<expr*>::iterator it2 = it1;
- it2++;
- for (; it2 != itor->second.end(); it2++) {
- expr * n1 = *it1;
- expr * n2 = *it2;
- lrConstrainedMap[n1][n2] = 1;
- lrConstrainedMap[n2][n1] = 1;
- }
- }
- }
- for (std::map<int, std::set<expr*> >::iterator itor = mRMap.begin(); itor != mRMap.end(); itor++) {
- for (std::set<expr*>::iterator it1 = itor->second.begin(); it1 != itor->second.end(); it1++) {
- std::set<expr*>::iterator it2 = it1;
- it2++;
- for (; it2 != itor->second.end(); it2++) {
- expr * n1 = *it1;
- expr * n2 = *it2;
- lrConstrainedMap[n1][n2] = 1;
- lrConstrainedMap[n2][n1] = 1;
- }
- }
- }
-
- if (depMap.size() == 0) {
- std::map<expr*, int>::iterator itor = strVarMap.begin();
- for (; itor != strVarMap.end(); itor++) {
- expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
- if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
- freeVarMap[var] = 1;
- } else {
- int lrConstainted = 0;
- std::map<expr*, int>::iterator lrit = freeVarMap.begin();
- for (; lrit != freeVarMap.end(); lrit++) {
- if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
- lrConstainted = 1;
- break;
- }
- }
- if (lrConstainted == 0) {
- freeVarMap[var] = 1;
- }
- }
- }
- } else {
- // if the keys in aliasIndexMap are not contained in keys in depMap, they are free
- // e.g., x= y /\ x = z /\ t = "abc"
- // aliasIndexMap[y]= x, aliasIndexMap[z] = x
- // depMap t ~ "abc"(1)
- // x should be free
- std::map<expr*, int>::iterator itor2 = strVarMap.begin();
- for (; itor2 != strVarMap.end(); itor2++) {
- if (aliasIndexMap.find(itor2->first) != aliasIndexMap.end()) {
- expr * var = aliasIndexMap[itor2->first];
- if (depMap.find(var) == depMap.end()) {
- if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
- freeVarMap[var] = 1;
- } else {
- int lrConstainted = 0;
- std::map<expr*, int>::iterator lrit = freeVarMap.begin();
- for (; lrit != freeVarMap.end(); lrit++) {
- if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
- lrConstainted = 1;
- break;
- }
- }
- if (lrConstainted == 0) {
- freeVarMap[var] = 1;
- }
- }
- }
- } else if (aliasIndexMap.find(itor2->first) == aliasIndexMap.end()) {
- // if a variable is not in aliasIndexMap and not in depMap, it's free
- if (depMap.find(itor2->first) == depMap.end()) {
- expr * var = itor2->first;
- if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
- freeVarMap[var] = 1;
- } else {
- int lrConstainted = 0;
- std::map<expr*, int>::iterator lrit = freeVarMap.begin();
- for (; lrit != freeVarMap.end(); lrit++) {
- if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
- lrConstainted = 1;
- break;
- }
- }
- if (lrConstainted == 0) {
- freeVarMap[var] = 1;
- }
- }
- }
- }
- }
-
- std::map<expr*, std::map<expr*, int> >::iterator itor = depMap.begin();
- for (; itor != depMap.end(); itor++) {
- for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
- if (variable_set.find(itor1->first) != variable_set.end()) { // expr type = var
- expr * var = get_alias_index_ast(aliasIndexMap, itor1->first);
- // if a var is dep on itself and all dependence are type 2, it's a free variable
- // e.g {y --> x(2), y(2), m --> m(2), n(2)} y,m are free
- {
- if (depMap.find(var) == depMap.end()) {
- if (freeVarMap.find(var) == freeVarMap.end()) {
- if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
- freeVarMap[var] = 1;
- } else {
- int lrConstainted = 0;
- std::map<expr*, int>::iterator lrit = freeVarMap.begin();
- for (; lrit != freeVarMap.end(); lrit++) {
- if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
- lrConstainted = 1;
- break;
- }
- }
- if (lrConstainted == 0) {
- freeVarMap[var] = 1;
- }
- }
-
- } else {
- freeVarMap[var] = freeVarMap[var] + 1;
- }
- }
- }
- }
- }
- }
- }
-
- return 0;
-}
-
-// Check agreement between integer and string theories for the term a = (str.to-int S).
-// Returns true if axioms were added, and false otherwise.
-bool theory_str::finalcheck_str2int(app * a) {
- bool axiomAdd = false;
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- expr * S = a->get_arg(0);
-
- // check integer theory
- rational Ival;
- bool Ival_exists = get_value(a, Ival);
- if (Ival_exists) {
- TRACE("str", tout << "integer theory assigns " << mk_pp(a, m) << " = " << Ival.to_string() << std::endl;);
- // if that value is not -1, we can assert (str.to-int S) = Ival --> S = "Ival"
- if (!Ival.is_minus_one()) {
- zstring Ival_str(Ival.to_string().c_str());
- expr_ref premise(ctx.mk_eq_atom(a, m_autil.mk_numeral(Ival, true)), m);
- expr_ref conclusion(ctx.mk_eq_atom(S, mk_string(Ival_str)), m);
- expr_ref axiom(rewrite_implication(premise, conclusion), m);
- if (!string_int_axioms.contains(axiom)) {
- string_int_axioms.insert(axiom);
- assert_axiom(axiom);
- m_trail_stack.push(insert_obj_trail<theory_str, expr>(string_int_axioms, axiom));
- axiomAdd = true;
- }
- }
- } else {
- TRACE("str", tout << "integer theory has no assignment for " << mk_pp(a, m) << std::endl;);
- NOT_IMPLEMENTED_YET();
- }
-
- return axiomAdd;
-}
-
-bool theory_str::finalcheck_int2str(app * a) {
- bool axiomAdd = false;
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- expr * N = a->get_arg(0);
-
- // check string theory
- bool Sval_expr_exists;
- expr * Sval_expr = get_eqc_value(a, Sval_expr_exists);
- if (Sval_expr_exists) {
- zstring Sval;
- u.str.is_string(Sval_expr, Sval);
- TRACE("str", tout << "string theory assigns \"" << mk_pp(a, m) << " = " << Sval << "\n";);
- // empty string --> integer value < 0
- if (Sval.empty()) {
- // ignore this. we should already assert the axiom for what happens when the string is ""
- } else {
- // nonempty string --> convert to correct integer value, or disallow it
- rational convertedRepresentation(0);
- rational ten(10);
- bool conversionOK = true;
- for (unsigned i = 0; i < Sval.length(); ++i) {
- char digit = (int)Sval[i];
- if (isdigit((int)digit)) {
- std::string sDigit(1, digit);
- int val = atoi(sDigit.c_str());
- convertedRepresentation = (ten * convertedRepresentation) + rational(val);
- } else {
- // not a digit, invalid
- TRACE("str", tout << "str.to-int argument contains non-digit character '" << digit << "'" << std::endl;);
- conversionOK = false;
- break;
- }
- }
- if (conversionOK) {
- expr_ref premise(ctx.mk_eq_atom(a, mk_string(Sval)), m);
- expr_ref conclusion(ctx.mk_eq_atom(N, m_autil.mk_numeral(convertedRepresentation, true)), m);
- expr_ref axiom(rewrite_implication(premise, conclusion), m);
- if (!string_int_axioms.contains(axiom)) {
- string_int_axioms.insert(axiom);
- assert_axiom(axiom);
- m_trail_stack.push(insert_obj_trail<theory_str, expr>(string_int_axioms, axiom));
- axiomAdd = true;
+ expr_ref implyL1(mk_and(item1), m);
+ newConcat = mk_concat(arg1, arg2);
+ if (newConcat != str) {
+ expr_ref implyR1(ctx.mk_eq_atom(concat, newConcat), m);
+ assert_implication(implyL1, implyR1);
}
} else {
- expr_ref axiom(m.mk_not(ctx.mk_eq_atom(a, mk_string(Sval))), m);
- // always assert this axiom because this is a conflict clause
- assert_axiom(axiom);
- axiomAdd = true;
+ newConcat = concat;
}
- }
- } else {
- TRACE("str", tout << "string theory has no assignment for " << mk_pp(a, m) << std::endl;);
- NOT_IMPLEMENTED_YET();
- }
- return axiomAdd;
-}
-
-void theory_str::collect_var_concat(expr * node, std::set<expr*> & varSet, std::set<expr*> & concatSet) {
- if (variable_set.find(node) != variable_set.end()) {
- if (internal_lenTest_vars.find(node) == internal_lenTest_vars.end()) {
- varSet.insert(node);
- }
- }
- else if (is_app(node)) {
- app * aNode = to_app(node);
- if (u.str.is_length(aNode)) {
- // Length
- return;
- }
- if (u.str.is_concat(aNode)) {
- expr * arg0 = aNode->get_arg(0);
- expr * arg1 = aNode->get_arg(1);
- if (concatSet.find(node) == concatSet.end()) {
- concatSet.insert(node);
+ if (newConcat == str) {
+ return;
}
- }
- // recursively visit all arguments
- for (unsigned i = 0; i < aNode->get_num_args(); ++i) {
- expr * arg = aNode->get_arg(i);
- collect_var_concat(arg, varSet, concatSet);
- }
- }
-}
-
-bool theory_str::propagate_length_within_eqc(expr * var) {
- bool res = false;
- ast_manager & m = get_manager();
- context & ctx = get_context();
-
- TRACE("str", tout << "propagate_length_within_eqc: " << mk_ismt2_pp(var, m) << std::endl ;);
-
- enode * n_eq_enode = ctx.get_enode(var);
- rational varLen;
- if (! get_len_value(var, varLen)) {
- bool hasLen = false;
- expr * nodeWithLen= var;
- do {
- if (get_len_value(nodeWithLen, varLen)) {
- hasLen = true;
- break;
+ if (!u.str.is_concat(to_app(newConcat))) {
+ return;
}
- nodeWithLen = get_eqc_next(nodeWithLen);
- } while (nodeWithLen != var);
+ if (arg1_has_eqc_value && arg2_has_eqc_value) {
+ // Case 1: Concat(const, const) == const
+ TRACE("str", tout << "Case 1: Concat(const, const) == const" << std::endl;);
+ zstring arg1_str, arg2_str;
+ u.str.is_string(arg1, arg1_str);
+ u.str.is_string(arg2, arg2_str);
- if (hasLen) {
- // var = nodeWithLen --> |var| = |nodeWithLen|
- expr_ref_vector l_items(m);
- expr_ref varEqNode(ctx.mk_eq_atom(var, nodeWithLen), m);
- l_items.push_back(varEqNode);
-
- expr_ref nodeWithLenExpr (mk_strlen(nodeWithLen), m);
- expr_ref varLenExpr (mk_int(varLen), m);
- expr_ref lenEqNum(ctx.mk_eq_atom(nodeWithLenExpr, varLenExpr), m);
- l_items.push_back(lenEqNum);
-
- expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
- expr_ref varLen(mk_strlen(var), m);
- expr_ref axr(ctx.mk_eq_atom(varLen, mk_int(varLen)), m);
- assert_implication(axl, axr);
- TRACE("str", tout << mk_ismt2_pp(axl, m) << std::endl << " ---> " << std::endl << mk_ismt2_pp(axr, m););
- res = true;
- }
- }
- return res;
-}
-
-bool theory_str::propagate_length(std::set<expr*> & varSet, std::set<expr*> & concatSet, std::map<expr*, int> & exprLenMap) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
- expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
- bool axiomAdded = false;
- // collect all concats in context
- for (expr_ref_vector::iterator it = assignments.begin(); it != assignments.end(); ++it) {
- if (! ctx.is_relevant(*it)) {
- continue;
- }
- if (m.is_eq(*it)) {
- collect_var_concat(*it, varSet, concatSet);
- }
- }
- // iterate each concat
- // if a concat doesn't have length info, check if the length of all leaf nodes can be resolved
- for (std::set<expr*>::iterator it = concatSet.begin(); it != concatSet.end(); it++) {
- expr * concat = *it;
- rational lenValue;
- expr_ref concatlenExpr (mk_strlen(concat), m) ;
- bool allLeafResolved = true;
- if (! get_value(concatlenExpr, lenValue)) {
- // the length fo concat is unresolved yet
- if (get_len_value(concat, lenValue)) {
- // but all leaf nodes have length information
- TRACE("str", tout << "* length pop-up: " << mk_ismt2_pp(concat, m) << "| = " << lenValue << std::endl;);
- std::set<expr*> leafNodes;
- get_unique_non_concat_nodes(concat, leafNodes);
- expr_ref_vector l_items(m);
- for (std::set<expr*>::iterator leafIt = leafNodes.begin(); leafIt != leafNodes.end(); ++leafIt) {
- rational leafLenValue;
- if (get_len_value(*leafIt, leafLenValue)) {
- expr_ref leafItLenExpr (mk_strlen(*leafIt), m);
- expr_ref leafLenValueExpr (mk_int(leafLenValue), m);
- expr_ref lcExpr (ctx.mk_eq_atom(leafItLenExpr, leafLenValueExpr), m);
- l_items.push_back(lcExpr);
+ zstring result_str = arg1_str + arg2_str;
+ if (result_str != const_str) {
+ // Inconsistency
+ TRACE("str", tout << "inconsistency detected: \""
+ << arg1_str << "\" + \"" << arg2_str <<
+ "\" != \"" << const_str << "\"" << "\n";);
+ expr_ref equality(ctx.mk_eq_atom(concat, str), m);
+ expr_ref diseq(m.mk_not(equality), m);
+ assert_axiom(diseq);
+ return;
+ }
+ } else if (!arg1_has_eqc_value && arg2_has_eqc_value) {
+ // Case 2: Concat(var, const) == const
+ TRACE("str", tout << "Case 2: Concat(var, const) == const" << std::endl;);
+ zstring arg2_str;
+ u.str.is_string(arg2, arg2_str);
+ unsigned int resultStrLen = const_str.length();
+ unsigned int arg2StrLen = arg2_str.length();
+ if (resultStrLen < arg2StrLen) {
+ // Inconsistency
+ TRACE("str", tout << "inconsistency detected: \""
+ << arg2_str <<
+ "\" is longer than \"" << const_str << "\","
+ << " so cannot be concatenated with anything to form it" << "\n";);
+ expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref diseq(m.mk_not(equality), m);
+ assert_axiom(diseq);
+ return;
+ } else {
+ int varStrLen = resultStrLen - arg2StrLen;
+ zstring firstPart = const_str.extract(0, varStrLen);
+ zstring secondPart = const_str.extract(varStrLen, arg2StrLen);
+ if (arg2_str != secondPart) {
+ // Inconsistency
+ TRACE("str", tout << "inconsistency detected: "
+ << "suffix of concatenation result expected \"" << secondPart << "\", "
+ << "actually \"" << arg2_str << "\""
+ << "\n";);
+ expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref diseq(m.mk_not(equality), m);
+ assert_axiom(diseq);
+ return;
} else {
- allLeafResolved = false;
- break;
+ expr_ref tmpStrConst(mk_string(firstPart), m);
+ expr_ref premise(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref conclusion(ctx.mk_eq_atom(arg1, tmpStrConst), m);
+ assert_implication(premise, conclusion);
+ return;
}
}
- if (allLeafResolved) {
- expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
- expr_ref lenValueExpr (mk_int(lenValue), m);
- expr_ref axr(ctx.mk_eq_atom(concatlenExpr, lenValueExpr), m);
- assert_implication(axl, axr);
- TRACE("str", tout << mk_ismt2_pp(axl, m) << std::endl << " ---> " << std::endl << mk_ismt2_pp(axr, m)<< std::endl;);
- axiomAdded = true;
+ } else if (arg1_has_eqc_value && !arg2_has_eqc_value) {
+ // Case 3: Concat(const, var) == const
+ TRACE("str", tout << "Case 3: Concat(const, var) == const" << std::endl;);
+ zstring arg1_str;
+ u.str.is_string(arg1, arg1_str);
+ unsigned int resultStrLen = const_str.length();
+ unsigned int arg1StrLen = arg1_str.length();
+ if (resultStrLen < arg1StrLen) {
+ // Inconsistency
+ TRACE("str", tout << "inconsistency detected: \""
+ << arg1_str <<
+ "\" is longer than \"" << const_str << "\","
+ << " so cannot be concatenated with anything to form it" << "\n";);
+ expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref diseq(m.mk_not(equality), m);
+ assert_axiom(diseq);
+ return;
+ } else {
+ int varStrLen = resultStrLen - arg1StrLen;
+ zstring firstPart = const_str.extract(0, arg1StrLen);
+ zstring secondPart = const_str.extract(arg1StrLen, varStrLen);
+ if (arg1_str != firstPart) {
+ // Inconsistency
+ TRACE("str", tout << "inconsistency detected: "
+ << "prefix of concatenation result expected \"" << secondPart << "\", "
+ << "actually \"" << arg1_str << "\""
+ << "\n";);
+ expr_ref equality(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref diseq(m.mk_not(equality), m);
+ assert_axiom(diseq);
+ return;
+ } else {
+ expr_ref tmpStrConst(mk_string(secondPart), m);
+ expr_ref premise(ctx.mk_eq_atom(newConcat, str), m);
+ expr_ref conclusion(ctx.mk_eq_atom(arg2, tmpStrConst), m);
+ assert_implication(premise, conclusion);
+ return;
+ }
}
- }
- }
- }
- // if no concat length is propagated, check the length of variables.
- if (! axiomAdded) {
- for (std::set<expr*>::iterator it = varSet.begin(); it != varSet.end(); it++) {
- expr * var = *it;
- rational lenValue;
- expr_ref varlen (mk_strlen(var), m) ;
- bool allLeafResolved = true;
- if (! get_value(varlen, lenValue)) {
- if (propagate_length_within_eqc(var)) {
- axiomAdded = true;
- }
- }
- }
-
- }
- return axiomAdded;
-}
-
-void theory_str::get_unique_non_concat_nodes(expr * node, std::set<expr*> & argSet) {
- app * a_node = to_app(node);
- if (!u.str.is_concat(a_node)) {
- argSet.insert(node);
- return;
- } else {
- SASSERT(a_node->get_num_args() == 2);
- expr * leftArg = a_node->get_arg(0);
- expr * rightArg = a_node->get_arg(1);
- get_unique_non_concat_nodes(leftArg, argSet);
- get_unique_non_concat_nodes(rightArg, argSet);
- }
-}
-
-final_check_status theory_str::final_check_eh() {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- expr_ref_vector assignments(m);
- ctx.get_assignments(assignments);
-
- if (opt_VerifyFinalCheckProgress) {
- finalCheckProgressIndicator = false;
- }
-
- TRACE("str", tout << "final check" << std::endl;);
- TRACE_CODE(if (is_trace_enabled("t_str_dump_assign")) { dump_assignments(); });
- check_variable_scope();
-
- if (opt_DeferEQCConsistencyCheck) {
- TRACE("str", tout << "performing deferred EQC consistency check" << std::endl;);
- std::set<enode*> eqc_roots;
- for (ptr_vector<enode>::const_iterator it = ctx.begin_enodes(); it != ctx.end_enodes(); ++it) {
- enode * e = *it;
- enode * root = e->get_root();
- eqc_roots.insert(root);
- }
-
- bool found_inconsistency = false;
-
- for (std::set<enode*>::iterator it = eqc_roots.begin(); it != eqc_roots.end(); ++it) {
- enode * e = *it;
- app * a = e->get_owner();
- if (!(m.get_sort(a) == u.str.mk_string_sort())) {
- TRACE("str", tout << "EQC root " << mk_pp(a, m) << " not a string term; skipping" << std::endl;);
} else {
- TRACE("str", tout << "EQC root " << mk_pp(a, m) << " is a string term. Checking this EQC" << std::endl;);
- // first call check_concat_len_in_eqc() on each member of the eqc
- enode * e_it = e;
- enode * e_root = e_it;
- do {
- bool status = check_concat_len_in_eqc(e_it->get_owner());
- if (!status) {
- TRACE("str", tout << "concat-len check asserted an axiom on " << mk_pp(e_it->get_owner(), m) << std::endl;);
- found_inconsistency = true;
- }
- e_it = e_it->get_next();
- } while (e_it != e_root);
+ // Case 4: Concat(var, var) == const
+ TRACE("str", tout << "Case 4: Concat(var, var) == const" << std::endl;);
+ if (eval_concat(arg1, arg2) == NULL) {
+ rational arg1Len, arg2Len;
+ bool arg1Len_exists = get_len_value(arg1, arg1Len);
+ bool arg2Len_exists = get_len_value(arg2, arg2Len);
+ rational concatStrLen((unsigned)const_str.length());
+ if (arg1Len_exists || arg2Len_exists) {
+ expr_ref ax_l1(ctx.mk_eq_atom(concat, str), m);
+ expr_ref ax_l2(m);
+ zstring prefixStr, suffixStr;
+ if (arg1Len_exists) {
+ if (arg1Len.is_neg()) {
+ TRACE("str", tout << "length conflict: arg1Len = " << arg1Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ expr_ref toAssert(m_autil.mk_ge(mk_strlen(arg1), mk_int(0)), m);
+ assert_axiom(toAssert);
+ return;
+ } else if (arg1Len > concatStrLen) {
+ TRACE("str", tout << "length conflict: arg1Len = " << arg1Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ expr_ref ax_r1(m_autil.mk_le(mk_strlen(arg1), mk_int(concatStrLen)), m);
+ assert_implication(ax_l1, ax_r1);
+ return;
+ }
- // now grab any two distinct elements from the EQC and call new_eq_check() on them
- enode * e1 = e;
- enode * e2 = e1->get_next();
- if (e1 != e2) {
- TRACE("str", tout << "deferred new_eq_check() over EQC of " << mk_pp(e1->get_owner(), m) << " and " << mk_pp(e2->get_owner(), m) << std::endl;);
- bool result = new_eq_check(e1->get_owner(), e2->get_owner());
- if (!result) {
- TRACE("str", tout << "new_eq_check found inconsistencies" << std::endl;);
- found_inconsistency = true;
- }
- }
+ prefixStr = const_str.extract(0, arg1Len.get_unsigned());
+ rational concat_minus_arg1 = concatStrLen - arg1Len;
+ suffixStr = const_str.extract(arg1Len.get_unsigned(), concat_minus_arg1.get_unsigned());
+ ax_l2 = ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1Len));
+ } else {
+ // arg2's length is available
+ if (arg2Len.is_neg()) {
+ TRACE("str", tout << "length conflict: arg2Len = " << arg2Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ expr_ref toAssert(m_autil.mk_ge(mk_strlen(arg2), mk_int(0)), m);
+ assert_axiom(toAssert);
+ return;
+ } else if (arg2Len > concatStrLen) {
+ TRACE("str", tout << "length conflict: arg2Len = " << arg2Len << ", concatStrLen = " << concatStrLen << std::endl;);
+ expr_ref ax_r1(m_autil.mk_le(mk_strlen(arg2), mk_int(concatStrLen)), m);
+ assert_implication(ax_l1, ax_r1);
+ return;
+ }
+
+ rational concat_minus_arg2 = concatStrLen - arg2Len;
+ prefixStr = const_str.extract(0, concat_minus_arg2.get_unsigned());
+ suffixStr = const_str.extract(concat_minus_arg2.get_unsigned(), arg2Len.get_unsigned());
+ ax_l2 = ctx.mk_eq_atom(mk_strlen(arg2), mk_int(arg2Len));
+ }
+ // consistency check
+ if (u.str.is_concat(to_app(arg1)) && !can_concat_eq_str(arg1, prefixStr)) {
+ expr_ref ax_r(m.mk_not(ax_l2), m);
+ assert_implication(ax_l1, ax_r);
+ return;
+ }
+ if (u.str.is_concat(to_app(arg2)) && !can_concat_eq_str(arg2, suffixStr)) {
+ expr_ref ax_r(m.mk_not(ax_l2), m);
+ assert_implication(ax_l1, ax_r);
+ return;
+ }
+ expr_ref_vector r_items(m);
+ r_items.push_back(ctx.mk_eq_atom(arg1, mk_string(prefixStr)));
+ r_items.push_back(ctx.mk_eq_atom(arg2, mk_string(suffixStr)));
+ if (!arg1Len_exists) {
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(prefixStr.length())));
+ }
+ if (!arg2Len_exists) {
+ r_items.push_back(ctx.mk_eq_atom(mk_strlen(arg2), mk_int(suffixStr.length())));
+ }
+ expr_ref lhs(m.mk_and(ax_l1, ax_l2), m);
+ expr_ref rhs(mk_and(r_items), m);
+ assert_implication(lhs, rhs);
+ } else { /* ! (arg1Len != 1 || arg2Len != 1) */
+ expr_ref xorFlag(m);
+ std::pair<expr*, expr*> key1(arg1, arg2);
+ std::pair<expr*, expr*> key2(arg2, arg1);
+
+ // check the entries in this map to make sure they're still in scope
+ // before we use them.
+
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry1 = varForBreakConcat.find(key1);
+ std::map<std::pair<expr*,expr*>, std::map<int, expr*> >::iterator entry2 = varForBreakConcat.find(key2);
+
+ bool entry1InScope;
+ if (entry1 == varForBreakConcat.end()) {
+ TRACE("str", tout << "key1 no entry" << std::endl;);
+ entry1InScope = false;
+ } else {
+ // OVERRIDE.
+ entry1InScope = true;
+ TRACE("str", tout << "key1 entry" << std::endl;);
+ /*
+ if (internal_variable_set.find((entry1->second)[0]) == internal_variable_set.end()) {
+ TRACE("str", tout << "key1 entry not in scope" << std::endl;);
+ entry1InScope = false;
+ } else {
+ TRACE("str", tout << "key1 entry in scope" << std::endl;);
+ entry1InScope = true;
+ }
+ */
+ }
+
+ bool entry2InScope;
+ if (entry2 == varForBreakConcat.end()) {
+ TRACE("str", tout << "key2 no entry" << std::endl;);
+ entry2InScope = false;
+ } else {
+ // OVERRIDE.
+ entry2InScope = true;
+ TRACE("str", tout << "key2 entry" << std::endl;);
+ /*
+ if (internal_variable_set.find((entry2->second)[0]) == internal_variable_set.end()) {
+ TRACE("str", tout << "key2 entry not in scope" << std::endl;);
+ entry2InScope = false;
+ } else {
+ TRACE("str", tout << "key2 entry in scope" << std::endl;);
+ entry2InScope = true;
+ }
+ */
+ }
+
+ TRACE("str", tout << "entry 1 " << (entry1InScope ? "in scope" : "not in scope") << std::endl
+ << "entry 2 " << (entry2InScope ? "in scope" : "not in scope") << std::endl;);
+
+ if (!entry1InScope && !entry2InScope) {
+ xorFlag = mk_internal_xor_var();
+ varForBreakConcat[key1][0] = xorFlag;
+ } else if (entry1InScope) {
+ xorFlag = varForBreakConcat[key1][0];
+ } else { // entry2InScope
+ xorFlag = varForBreakConcat[key2][0];
+ }
+
+ int concatStrLen = const_str.length();
+ int and_count = 1;
+
+ expr_ref_vector arrangement_disjunction(m);
+
+ for (int i = 0; i < concatStrLen + 1; ++i) {
+ expr_ref_vector and_items(m);
+ zstring prefixStr = const_str.extract(0, i);
+ zstring suffixStr = const_str.extract(i, concatStrLen - i);
+ // skip invalid options
+ if (u.str.is_concat(to_app(arg1)) && !can_concat_eq_str(arg1, prefixStr)) {
+ continue;
+ }
+ if (u.str.is_concat(to_app(arg2)) && !can_concat_eq_str(arg2, suffixStr)) {
+ continue;
+ }
+
+ expr_ref prefixAst(mk_string(prefixStr), m);
+ expr_ref arg1_eq (ctx.mk_eq_atom(arg1, prefixAst), m);
+ and_items.push_back(arg1_eq);
+ and_count += 1;
+
+ expr_ref suffixAst(mk_string(suffixStr), m);
+ expr_ref arg2_eq (ctx.mk_eq_atom(arg2, suffixAst), m);
+ and_items.push_back(arg2_eq);
+ and_count += 1;
+
+ arrangement_disjunction.push_back(mk_and(and_items));
+ }
+
+ expr_ref implyL(ctx.mk_eq_atom(concat, str), m);
+ expr_ref implyR1(m);
+ if (arrangement_disjunction.empty()) {
+ // negate
+ expr_ref concat_eq_str(ctx.mk_eq_atom(concat, str), m);
+ expr_ref negate_ast(m.mk_not(concat_eq_str), m);
+ assert_axiom(negate_ast);
+ } else {
+ implyR1 = mk_or(arrangement_disjunction);
+ if (m_params.m_StrongArrangements) {
+ expr_ref ax_strong(ctx.mk_eq_atom(implyL, implyR1), m);
+ assert_axiom(ax_strong);
+ } else {
+ assert_implication(implyL, implyR1);
+ }
+ generate_mutual_exclusion(arrangement_disjunction);
+ }
+ } /* (arg1Len != 1 || arg2Len != 1) */
+ } /* if (Concat(arg1, arg2) == NULL) */
}
}
-
- if (found_inconsistency) {
- TRACE("str", tout << "Found inconsistency in final check! Returning to search." << std::endl;);
- return FC_CONTINUE;
- } else {
- TRACE("str", tout << "Deferred consistency check passed. Continuing in final check." << std::endl;);
- }
}
- // run dependence analysis to find free string variables
- std::map<expr*, int> varAppearInAssign;
- std::map<expr*, int> freeVar_map;
- std::map<expr*, std::set<expr*> > unrollGroup_map;
- std::map<expr*, std::map<expr*, int> > var_eq_concat_map;
- int conflictInDep = ctx_dep_analysis(varAppearInAssign, freeVar_map, unrollGroup_map, var_eq_concat_map);
- if (conflictInDep == -1) {
- // return Z3_TRUE;
- return FC_DONE;
- }
-
- // enhancement: improved backpropagation of string constants into var=concat terms
- bool backpropagation_occurred = false;
- for (std::map<expr*, std::map<expr*, int> >::iterator veqc_map_it = var_eq_concat_map.begin();
- veqc_map_it != var_eq_concat_map.end(); ++veqc_map_it) {
- expr * var = veqc_map_it->first;
- for (std::map<expr*, int>::iterator concat_map_it = veqc_map_it->second.begin();
- concat_map_it != veqc_map_it->second.end(); ++concat_map_it) {
- app * concat = to_app(concat_map_it->first);
- expr * concat_lhs = concat->get_arg(0);
- expr * concat_rhs = concat->get_arg(1);
- // If the concat LHS and RHS both have a string constant in their EQC,
- // but the var does not, then we assert an axiom of the form
- // (lhs = "lhs" AND rhs = "rhs") --> (Concat lhs rhs) = "lhsrhs"
- bool concat_lhs_haseqc, concat_rhs_haseqc, var_haseqc;
- expr * concat_lhs_str = get_eqc_value(concat_lhs, concat_lhs_haseqc);
- expr * concat_rhs_str = get_eqc_value(concat_rhs, concat_rhs_haseqc);
- expr * var_str = get_eqc_value(var, var_haseqc);
- if (concat_lhs_haseqc && concat_rhs_haseqc && !var_haseqc) {
- TRACE("str", tout << "backpropagate into " << mk_pp(var, m) << " = " << mk_pp(concat, m) << std::endl
- << "LHS ~= " << mk_pp(concat_lhs_str, m) << " RHS ~= " << mk_pp(concat_rhs_str, m) << std::endl;);
- zstring lhsString, rhsString;
- u.str.is_string(concat_lhs_str, lhsString);
- u.str.is_string(concat_rhs_str, rhsString);
- zstring concatString = lhsString + rhsString;
- expr_ref lhs1(ctx.mk_eq_atom(concat_lhs, concat_lhs_str), m);
- expr_ref lhs2(ctx.mk_eq_atom(concat_rhs, concat_rhs_str), m);
- expr_ref lhs(m.mk_and(lhs1, lhs2), m);
- expr_ref rhs(ctx.mk_eq_atom(concat, mk_string(concatString)), m);
- assert_implication(lhs, rhs);
- backpropagation_occurred = true;
- }
- }
- }
-
- if (backpropagation_occurred) {
- TRACE("str", tout << "Resuming search due to axioms added by backpropagation." << std::endl;);
- return FC_CONTINUE;
- }
-
- // enhancement: improved backpropagation of length information
- {
- std::set<expr*> varSet;
- std::set<expr*> concatSet;
- std::map<expr*, int> exprLenMap;
-
- bool length_propagation_occurred = propagate_length(varSet, concatSet, exprLenMap);
- if (length_propagation_occurred) {
- TRACE("str", tout << "Resuming search due to axioms added by length propagation." << std::endl;);
- return FC_CONTINUE;
- }
- }
-
- bool needToAssignFreeVars = false;
- std::set<expr*> free_variables;
- std::set<expr*> unused_internal_variables;
- { // Z3str2 free variables check
- std::map<expr*, int>::iterator itor = varAppearInAssign.begin();
- for (; itor != varAppearInAssign.end(); ++itor) {
- /*
- std::string vName = std::string(Z3_ast_to_string(ctx, itor->first));
- if (vName.length() >= 3 && vName.substr(0, 3) == "$$_")
- continue;
- */
- if (internal_variable_set.find(itor->first) != internal_variable_set.end()
- || regex_variable_set.find(itor->first) != regex_variable_set.end()) {
- // this can be ignored, I think
- TRACE("str", tout << "free internal variable " << mk_pp(itor->first, m) << " ignored" << std::endl;);
- continue;
- }
- bool hasEqcValue = false;
- expr * eqcString = get_eqc_value(itor->first, hasEqcValue);
- if (!hasEqcValue) {
- TRACE("str", tout << "found free variable " << mk_pp(itor->first, m) << std::endl;);
- needToAssignFreeVars = true;
- free_variables.insert(itor->first);
- // break;
- } else {
- // debug
- TRACE("str", tout << "variable " << mk_pp(itor->first, m) << " = " << mk_pp(eqcString, m) << std::endl;);
- }
- }
- }
-
- if (!needToAssignFreeVars) {
-
- // check string-int terms
- bool addedStrIntAxioms = false;
- for (unsigned i = 0; i < string_int_conversion_terms.size(); ++i) {
- app * ex = to_app(string_int_conversion_terms[i].get());
- if (u.str.is_stoi(ex)) {
- bool axiomAdd = finalcheck_str2int(ex);
- if (axiomAdd) {
- addedStrIntAxioms = true;
- }
- } else if (u.str.is_itos(ex)) {
- bool axiomAdd = finalcheck_int2str(ex);
- if (axiomAdd) {
- addedStrIntAxioms = true;
- }
- } else {
- UNREACHABLE();
- }
- }
- if (addedStrIntAxioms) {
- TRACE("str", tout << "Resuming search due to addition of string-integer conversion axioms." << std::endl;);
- return FC_CONTINUE;
- }
-
- if (unused_internal_variables.empty()) {
- TRACE("str", tout << "All variables are assigned. Done!" << std::endl;);
- return FC_DONE;
- } else {
- TRACE("str", tout << "Assigning decoy values to free internal variables." << std::endl;);
- for (std::set<expr*>::iterator it = unused_internal_variables.begin(); it != unused_internal_variables.end(); ++it) {
- expr * var = *it;
- expr_ref assignment(m.mk_eq(var, mk_string("**unused**")), m);
- assert_axiom(assignment);
- }
- return FC_CONTINUE;
- }
- }
-
- CTRACE("str", needToAssignFreeVars,
- tout << "Need to assign values to the following free variables:" << std::endl;
- for (std::set<expr*>::iterator itx = free_variables.begin(); itx != free_variables.end(); ++itx) {
- tout << mk_ismt2_pp(*itx, m) << std::endl;
- }
- tout << "freeVar_map has the following entries:" << std::endl;
- for (std::map<expr*, int>::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) {
- expr * var = fvIt->first;
- tout << mk_ismt2_pp(var, m) << std::endl;
- }
- );
-
- // -----------------------------------------------------------
- // variables in freeVar are those not bounded by Concats
- // classify variables in freeVarMap:
- // (1) freeVar = unroll(r1, t1)
- // (2) vars are not bounded by either concat or unroll
- // -----------------------------------------------------------
- std::map<expr*, std::set<expr*> > fv_unrolls_map;
- std::set<expr*> tmpSet;
- expr * constValue = NULL;
- for (std::map<expr*, int>::iterator fvIt2 = freeVar_map.begin(); fvIt2 != freeVar_map.end(); fvIt2++) {
- expr * var = fvIt2->first;
- tmpSet.clear();
- get_eqc_allUnroll(var, constValue, tmpSet);
- if (tmpSet.size() > 0) {
- fv_unrolls_map[var] = tmpSet;
- }
- }
- // erase var bounded by an unroll function from freeVar_map
- for (std::map<expr*, std::set<expr*> >::iterator fvIt3 = fv_unrolls_map.begin();
- fvIt3 != fv_unrolls_map.end(); fvIt3++) {
- expr * var = fvIt3->first;
- TRACE("str", tout << "erase free variable " << mk_pp(var, m) << " from freeVar_map, it is bounded by an Unroll" << std::endl;);
- freeVar_map.erase(var);
- }
-
- // collect the case:
- // * Concat(X, Y) = unroll(r1, t1) /\ Concat(X, Y) = unroll(r2, t2)
- // concatEqUnrollsMap[Concat(X, Y)] = {unroll(r1, t1), unroll(r2, t2)}
-
- std::map<expr*, std::set<expr*> > concatEqUnrollsMap;
- for (std::map<expr*, std::set<expr*> >::iterator urItor = unrollGroup_map.begin();
- urItor != unrollGroup_map.end(); urItor++) {
- expr * unroll = urItor->first;
- expr * curr = unroll;
- do {
- if (u.str.is_concat(to_app(curr))) {
- concatEqUnrollsMap[curr].insert(unroll);
- concatEqUnrollsMap[curr].insert(unrollGroup_map[unroll].begin(), unrollGroup_map[unroll].end());
- }
- enode * e_curr = ctx.get_enode(curr);
- curr = e_curr->get_next()->get_owner();
- // curr = get_eqc_next(curr);
- } while (curr != unroll);
- }
-
- std::map<expr*, std::set<expr*> > concatFreeArgsEqUnrollsMap;
- std::set<expr*> fvUnrollSet;
- for (std::map<expr*, std::set<expr*> >::iterator concatItor = concatEqUnrollsMap.begin();
- concatItor != concatEqUnrollsMap.end(); concatItor++) {
- expr * concat = concatItor->first;
- expr * concatArg1 = to_app(concat)->get_arg(0);
- expr * concatArg2 = to_app(concat)->get_arg(1);
- bool arg1Bounded = false;
- bool arg2Bounded = false;
- // arg1
- if (variable_set.find(concatArg1) != variable_set.end()) {
- if (freeVar_map.find(concatArg1) == freeVar_map.end()) {
- arg1Bounded = true;
- } else {
- fvUnrollSet.insert(concatArg1);
- }
- } else if (u.str.is_concat(to_app(concatArg1))) {
- if (concatEqUnrollsMap.find(concatArg1) == concatEqUnrollsMap.end()) {
- arg1Bounded = true;
- }
- }
- // arg2
- if (variable_set.find(concatArg2) != variable_set.end()) {
- if (freeVar_map.find(concatArg2) == freeVar_map.end()) {
- arg2Bounded = true;
- } else {
- fvUnrollSet.insert(concatArg2);
- }
- } else if (u.str.is_concat(to_app(concatArg2))) {
- if (concatEqUnrollsMap.find(concatArg2) == concatEqUnrollsMap.end()) {
- arg2Bounded = true;
- }
- }
- if (!arg1Bounded && !arg2Bounded) {
- concatFreeArgsEqUnrollsMap[concat].insert(
- concatEqUnrollsMap[concat].begin(),
- concatEqUnrollsMap[concat].end());
- }
- }
- for (std::set<expr*>::iterator vItor = fvUnrollSet.begin(); vItor != fvUnrollSet.end(); vItor++) {
- TRACE("str", tout << "remove " << mk_pp(*vItor, m) << " from freeVar_map" << std::endl;);
- freeVar_map.erase(*vItor);
- }
-
- // Assign free variables
- std::set<expr*> fSimpUnroll;
-
- constValue = NULL;
-
- {
- TRACE("str", tout << "free var map (#" << freeVar_map.size() << "):" << std::endl;
- for (std::map<expr*, int>::iterator freeVarItor1 = freeVar_map.begin(); freeVarItor1 != freeVar_map.end(); freeVarItor1++) {
- expr * freeVar = freeVarItor1->first;
- rational lenValue;
- bool lenValue_exists = get_len_value(freeVar, lenValue);
- tout << mk_pp(freeVar, m) << " [depCnt = " << freeVarItor1->second << ", length = "
- << (lenValue_exists ? lenValue.to_string() : "?")
- << "]" << std::endl;
- }
- );
- }
-
- for (std::map<expr*, std::set<expr*> >::iterator fvIt2 = concatFreeArgsEqUnrollsMap.begin();
- fvIt2 != concatFreeArgsEqUnrollsMap.end(); fvIt2++) {
- expr * concat = fvIt2->first;
- for (std::set<expr*>::iterator urItor = fvIt2->second.begin(); urItor != fvIt2->second.end(); urItor++) {
- expr * unroll = *urItor;
- process_concat_eq_unroll(concat, unroll);
- }
- }
-
- // --------
- // experimental free variable assignment - begin
- // * special handling for variables that are not used in concat
- // --------
- bool testAssign = true;
- if (!testAssign) {
- for (std::map<expr*, int>::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) {
- expr * freeVar = fvIt->first;
- /*
- std::string vName = std::string(Z3_ast_to_string(ctx, freeVar));
- if (vName.length() >= 9 && vName.substr(0, 9) == "$$_regVar") {
- continue;
- }
- */
- expr * toAssert = gen_len_val_options_for_free_var(freeVar, NULL, "");
- if (toAssert != NULL) {
- assert_axiom(toAssert);
- }
- }
- } else {
- process_free_var(freeVar_map);
- }
- // experimental free variable assignment - end
-
- // now deal with removed free variables that are bounded by an unroll
- TRACE("str", tout << "fv_unrolls_map (#" << fv_unrolls_map.size() << "):" << std::endl;);
- for (std::map<expr*, std::set<expr*> >::iterator fvIt1 = fv_unrolls_map.begin();
- fvIt1 != fv_unrolls_map.end(); fvIt1++) {
- expr * var = fvIt1->first;
- fSimpUnroll.clear();
- get_eqc_simpleUnroll(var, constValue, fSimpUnroll);
- if (fSimpUnroll.size() == 0) {
- gen_assign_unroll_reg(fv_unrolls_map[var]);
- } else {
- expr * toAssert = gen_assign_unroll_Str2Reg(var, fSimpUnroll);
- if (toAssert != NULL) {
- assert_axiom(toAssert);
- }
- }
- }
-
- if (opt_VerifyFinalCheckProgress && !finalCheckProgressIndicator) {
- TRACE("str", tout << "BUG: no progress in final check, giving up!!" << std::endl;);
- m.raise_exception("no progress in theory_str final check");
- }
-
- return FC_CONTINUE; // since by this point we've added axioms
-}
-
-inline zstring int_to_string(int i) {
- std::stringstream ss;
- ss << i;
- std::string str = ss.str();
- return zstring(str.c_str());
-}
-
-inline std::string longlong_to_string(long long i) {
- std::stringstream ss;
- ss << i;
- return ss.str();
-}
-
-void theory_str::print_value_tester_list(svector<std::pair<int, expr*> > & testerList) {
- ast_manager & m = get_manager();
- TRACE("str",
- int ss = testerList.size();
- tout << "valueTesterList = {";
- for (int i = 0; i < ss; ++i) {
- if (i % 4 == 0) {
- tout << std::endl;
- }
- tout << "(" << testerList[i].first << ", ";
- tout << mk_ismt2_pp(testerList[i].second, m);
- tout << "), ";
- }
- tout << std::endl << "}" << std::endl;
- );
-}
-
-zstring theory_str::gen_val_string(int len, int_vector & encoding) {
- SASSERT(charSetSize > 0);
- SASSERT(char_set != NULL);
-
- std::string re(len, char_set[0]);
- for (int i = 0; i < (int) encoding.size() - 1; i++) {
- int idx = encoding[i];
- re[len - 1 - i] = char_set[idx];
- }
- return zstring(re.c_str());
-}
-
-/*
- * The return value indicates whether we covered the search space.
- * - If the next encoding is valid, return false
- * - Otherwise, return true
- */
-bool theory_str::get_next_val_encode(int_vector & base, int_vector & next) {
- SASSERT(charSetSize > 0);
-
- TRACE("str", tout << "base vector: [ ";
- for (unsigned i = 0; i < base.size(); ++i) {
- tout << base[i] << " ";
- }
- tout << "]" << std::endl;
- );
-
- int s = 0;
- int carry = 0;
- next.reset();
-
- for (int i = 0; i < (int) base.size(); i++) {
- if (i == 0) {
- s = base[i] + 1;
- carry = s / charSetSize;
- s = s % charSetSize;
- next.push_back(s);
- } else {
- s = base[i] + carry;
- carry = s / charSetSize;
- s = s % charSetSize;
- next.push_back(s);
- }
- }
- if (next[next.size() - 1] > 0) {
- next.reset();
- return true;
- } else {
- return false;
- }
-}
-
-expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
- zstring lenStr, int tries) {
- ast_manager & m = get_manager();
- context & ctx = get_context();
-
- int distance = 32;
-
- // ----------------------------------------------------------------------------------------
- // generate value options encoding
- // encoding is a vector of size (len + 1)
- // e.g, len = 2,
- // encoding {1, 2, 0} means the value option is "charSet[2]"."charSet[1]"
- // the last item in the encoding indicates whether the whole space is covered
- // for example, if the charSet = {a, b}. All valid encodings are
- // {0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {1, 1, 0}
- // if add 1 to the last one, we get
- // {0, 0, 1}
- // the last item "1" shows this is not a valid encoding, and we have covered all space
- // ----------------------------------------------------------------------------------------
- int len = atoi(lenStr.encode().c_str());
- bool coverAll = false;
- svector<int_vector> options;
- int_vector base;
-
- TRACE("str", tout
- << "freeVar = " << mk_ismt2_pp(freeVar, m) << std::endl
- << "len_indicator = " << mk_ismt2_pp(len_indicator, m) << std::endl
- << "val_indicator = " << mk_ismt2_pp(val_indicator, m) << std::endl
- << "lenstr = " << lenStr << "\n"
- << "tries = " << tries << "\n";
- if (m_params.m_AggressiveValueTesting) {
- tout << "note: aggressive value testing is enabled" << std::endl;
- }
- );
-
- if (tries == 0) {
- base = int_vector(len + 1, 0);
- coverAll = false;
- } else {
- expr * lastestValIndi = fvar_valueTester_map[freeVar][len][tries - 1].second;
- TRACE("str", tout << "last value tester = " << mk_ismt2_pp(lastestValIndi, m) << std::endl;);
- coverAll = get_next_val_encode(val_range_map[lastestValIndi], base);
- }
-
- long long l = (tries) * distance;
- long long h = l;
- for (int i = 0; i < distance; i++) {
- if (coverAll)
- break;
- options.push_back(base);
- h++;
- coverAll = get_next_val_encode(options[options.size() - 1], base);
- }
- val_range_map[val_indicator] = options[options.size() - 1];
-
- TRACE("str",
- tout << "value tester encoding " << "{" << std::endl;
- int_vector vec = val_range_map[val_indicator];
-
- for (int_vector::iterator it = vec.begin(); it != vec.end(); ++it) {
- tout << *it << std::endl;
- }
- tout << "}" << std::endl;
- );
-
- // ----------------------------------------------------------------------------------------
-
- ptr_vector<expr> orList;
- ptr_vector<expr> andList;
-
- for (long long i = l; i < h; i++) {
- orList.push_back(m.mk_eq(val_indicator, mk_string(longlong_to_string(i).c_str()) ));
- if (m_params.m_AggressiveValueTesting) {
- literal l = mk_eq(val_indicator, mk_string(longlong_to_string(i).c_str()), false);
- ctx.mark_as_relevant(l);
- ctx.force_phase(l);
- }
-
- zstring aStr = gen_val_string(len, options[i - l]);
- expr * strAst;
- if (m_params.m_UseFastValueTesterCache) {
- if (!valueTesterCache.find(aStr, strAst)) {
- strAst = mk_string(aStr);
- valueTesterCache.insert(aStr, strAst);
- m_trail.push_back(strAst);
- }
- } else {
- strAst = mk_string(aStr);
- }
- andList.push_back(m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVar, strAst)));
- }
- if (!coverAll) {
- orList.push_back(m.mk_eq(val_indicator, mk_string("more")));
- if (m_params.m_AggressiveValueTesting) {
- literal l = mk_eq(val_indicator, mk_string("more"), false);
- ctx.mark_as_relevant(l);
- ctx.force_phase(~l);
- }
- }
-
- expr ** or_items = alloc_svect(expr*, orList.size());
- expr ** and_items = alloc_svect(expr*, andList.size() + 1);
-
- for (int i = 0; i < (int) orList.size(); i++) {
- or_items[i] = orList[i];
- }
- if (orList.size() > 1)
- and_items[0] = m.mk_or(orList.size(), or_items);
- else
- and_items[0] = or_items[0];
-
- for (int i = 0; i < (int) andList.size(); i++) {
- and_items[i + 1] = andList[i];
- }
- expr * valTestAssert = m.mk_and(andList.size() + 1, and_items);
-
- // ---------------------------------------
- // If the new value tester is $$_val_x_16_i
- // Should add ($$_len_x_j = 16) /\ ($$_val_x_16_i = "more")
- // ---------------------------------------
- andList.reset();
- andList.push_back(m.mk_eq(len_indicator, mk_string(lenStr)));
- for (int i = 0; i < tries; i++) {
- expr * vTester = fvar_valueTester_map[freeVar][len][i].second;
- if (vTester != val_indicator)
- andList.push_back(m.mk_eq(vTester, mk_string("more")));
- }
- expr * assertL = NULL;
- if (andList.size() == 1) {
- assertL = andList[0];
- } else {
- expr ** and_items = alloc_svect(expr*, andList.size());
- for (int i = 0; i < (int) andList.size(); i++) {
- and_items[i] = andList[i];
- }
- assertL = m.mk_and(andList.size(), and_items);
- }
-
- // (assertL => valTestAssert) <=> (!assertL OR valTestAssert)
- valTestAssert = m.mk_or(m.mk_not(assertL), valTestAssert);
- return valTestAssert;
-}
-
-expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
- zstring len_valueStr, expr * valTesterInCbEq, zstring valTesterValueStr) {
- ast_manager & m = get_manager();
-
- int len = atoi(len_valueStr.encode().c_str());
-
- // check whether any value tester is actually in scope
- TRACE("str", tout << "checking scope of previous value testers" << std::endl;);
- bool map_effectively_empty = true;
- if (fvar_valueTester_map[freeVar].find(len) != fvar_valueTester_map[freeVar].end()) {
- // there's *something* in the map, but check its scope
- svector<std::pair<int, expr*> > entries = fvar_valueTester_map[freeVar][len];
- for (svector<std::pair<int,expr*> >::iterator it = entries.begin(); it != entries.end(); ++it) {
- std::pair<int,expr*> entry = *it;
- expr * aTester = entry.second;
- if (internal_variable_set.find(aTester) == internal_variable_set.end()) {
- TRACE("str", tout << mk_pp(aTester, m) << " out of scope" << std::endl;);
- } else {
- TRACE("str", tout << mk_pp(aTester, m) << " in scope" << std::endl;);
- map_effectively_empty = false;
- break;
- }
- }
- }
-
- if (map_effectively_empty) {
- TRACE("str", tout << "no previous value testers, or none of them were in scope" << std::endl;);
- int tries = 0;
- expr * val_indicator = mk_internal_valTest_var(freeVar, len, tries);
- valueTester_fvar_map[val_indicator] = freeVar;
- fvar_valueTester_map[freeVar][len].push_back(std::make_pair(sLevel, val_indicator));
- print_value_tester_list(fvar_valueTester_map[freeVar][len]);
- return gen_val_options(freeVar, len_indicator, val_indicator, len_valueStr, tries);
- } else {
- TRACE("str", tout << "checking previous value testers" << std::endl;);
- print_value_tester_list(fvar_valueTester_map[freeVar][len]);
-
- // go through all previous value testers
- // If some doesn't have an eqc value, add its assertion again.
- int testerTotal = fvar_valueTester_map[freeVar][len].size();
- int i = 0;
- for (; i < testerTotal; i++) {
- expr * aTester = fvar_valueTester_map[freeVar][len][i].second;
-
- // it's probably worth checking scope here, actually
- if (internal_variable_set.find(aTester) == internal_variable_set.end()) {
- TRACE("str", tout << "value tester " << mk_pp(aTester, m) << " out of scope, skipping" << std::endl;);
- continue;
- }
-
- if (aTester == valTesterInCbEq) {
- break;
- }
-
- bool anEqcHasValue = false;
- // Z3_ast anEqc = get_eqc_value(t, aTester, anEqcHasValue);
- expr * aTester_eqc_value = get_eqc_value(aTester, anEqcHasValue);
- if (!anEqcHasValue) {
- TRACE("str", tout << "value tester " << mk_ismt2_pp(aTester, m)
- << " doesn't have an equivalence class value." << std::endl;);
- refresh_theory_var(aTester);
-
- expr * makeupAssert = gen_val_options(freeVar, len_indicator, aTester, len_valueStr, i);
-
- TRACE("str", tout << "var: " << mk_ismt2_pp(freeVar, m) << std::endl
- << mk_ismt2_pp(makeupAssert, m) << std::endl;);
- assert_axiom(makeupAssert);
- } else {
- TRACE("str", tout << "value tester " << mk_ismt2_pp(aTester, m)
- << " == " << mk_ismt2_pp(aTester_eqc_value, m) << std::endl;);
- }
- }
-
- if (valTesterValueStr == "more") {
- expr * valTester = NULL;
- if (i + 1 < testerTotal) {
- valTester = fvar_valueTester_map[freeVar][len][i + 1].second;
- refresh_theory_var(valTester);
- } else {
- valTester = mk_internal_valTest_var(freeVar, len, i + 1);
- valueTester_fvar_map[valTester] = freeVar;
- fvar_valueTester_map[freeVar][len].push_back(std::make_pair(sLevel, valTester));
- print_value_tester_list(fvar_valueTester_map[freeVar][len]);
- }
- expr * nextAssert = gen_val_options(freeVar, len_indicator, valTester, len_valueStr, i + 1);
- return nextAssert;
- }
-
- return NULL;
- }
-}
-
-void theory_str::reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vector & items) {
- context & ctx = get_context();
- ast_manager & mgr = get_manager();
-
- TRACE("str", tout << "reduce regex " << mk_pp(regex, mgr) << " with respect to variable " << mk_pp(var, mgr) << std::endl;);
-
- app * regexFuncDecl = to_app(regex);
- if (u.re.is_to_re(regexFuncDecl)) {
- // ---------------------------------------------------------
- // var \in Str2Reg(s1)
- // ==>
- // var = s1 /\ length(var) = length(s1)
- // ---------------------------------------------------------
- expr * strInside = to_app(regex)->get_arg(0);
- items.push_back(ctx.mk_eq_atom(var, strInside));
- items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_strlen(strInside)));
- return;
- }
- // RegexUnion
- else if (u.re.is_union(regexFuncDecl)) {
- // ---------------------------------------------------------
- // var \in RegexUnion(r1, r2)
- // ==>
- // (var = newVar1 \/ var = newVar2)
- // (var = newVar1 --> length(var) = length(newVar1)) /\ (var = newVar2 --> length(var) = length(newVar2))
- // /\ (newVar1 \in r1) /\ (newVar2 \in r2)
- // ---------------------------------------------------------
- expr_ref newVar1(mk_regex_rep_var(), mgr);
- expr_ref newVar2(mk_regex_rep_var(), mgr);
- items.push_back(mgr.mk_or(ctx.mk_eq_atom(var, newVar1), ctx.mk_eq_atom(var, newVar2)));
- items.push_back(mgr.mk_or(
- mgr.mk_not(ctx.mk_eq_atom(var, newVar1)),
- ctx.mk_eq_atom(mk_strlen(var), mk_strlen(newVar1))));
- items.push_back(mgr.mk_or(
- mgr.mk_not(ctx.mk_eq_atom(var, newVar2)),
- ctx.mk_eq_atom(mk_strlen(var), mk_strlen(newVar2))));
-
- expr * regArg1 = to_app(regex)->get_arg(0);
- reduce_virtual_regex_in(newVar1, regArg1, items);
-
- expr * regArg2 = to_app(regex)->get_arg(1);
- reduce_virtual_regex_in(newVar2, regArg2, items);
-
- return;
- }
- // RegexConcat
- else if (u.re.is_concat(regexFuncDecl)) {
- // ---------------------------------------------------------
- // var \in RegexConcat(r1, r2)
- // ==>
- // (var = newVar1 . newVar2) /\ (length(var) = length(vewVar1 . newVar2) )
- // /\ (newVar1 \in r1) /\ (newVar2 \in r2)
- // ---------------------------------------------------------
- expr_ref newVar1(mk_regex_rep_var(), mgr);
- expr_ref newVar2(mk_regex_rep_var(), mgr);
- expr_ref concatAst(mk_concat(newVar1, newVar2), mgr);
- items.push_back(ctx.mk_eq_atom(var, concatAst));
- items.push_back(ctx.mk_eq_atom(mk_strlen(var),
- m_autil.mk_add(mk_strlen(newVar1), mk_strlen(newVar2))));
-
- expr * regArg1 = to_app(regex)->get_arg(0);
- reduce_virtual_regex_in(newVar1, regArg1, items);
- expr * regArg2 = to_app(regex)->get_arg(1);
- reduce_virtual_regex_in(newVar2, regArg2, items);
- return;
- }
- // Unroll
- else if (u.re.is_star(regexFuncDecl)) {
- // ---------------------------------------------------------
- // var \in Star(r1)
- // ==>
- // var = unroll(r1, t1) /\ |var| = |unroll(r1, t1)|
- // ---------------------------------------------------------
- expr * regArg = to_app(regex)->get_arg(0);
- expr_ref unrollCnt(mk_unroll_bound_var(), mgr);
- expr_ref unrollFunc(mk_unroll(regArg, unrollCnt), mgr);
- items.push_back(ctx.mk_eq_atom(var, unrollFunc));
- items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_strlen(unrollFunc)));
- return;
- }
- // re.range
- else if (u.re.is_range(regexFuncDecl)) {
- // var in range("a", "z")
- // ==>
- // (var = "a" or var = "b" or ... or var = "z")
- expr_ref lo(regexFuncDecl->get_arg(0), mgr);
- expr_ref hi(regexFuncDecl->get_arg(1), mgr);
- zstring str_lo, str_hi;
- SASSERT(u.str.is_string(lo));
- SASSERT(u.str.is_string(hi));
- u.str.is_string(lo, str_lo);
- u.str.is_string(hi, str_hi);
- SASSERT(str_lo.length() == 1);
- SASSERT(str_hi.length() == 1);
- unsigned int c1 = str_lo[0];
- unsigned int c2 = str_hi[0];
- if (c1 > c2) {
- // exchange
- unsigned int tmp = c1;
- c1 = c2;
- c2 = tmp;
- }
- expr_ref_vector range_cases(mgr);
- for (unsigned int ch = c1; ch <= c2; ++ch) {
- zstring s_ch(ch);
- expr_ref rhs(ctx.mk_eq_atom(var, u.str.mk_string(s_ch)), mgr);
- range_cases.push_back(rhs);
- }
- expr_ref rhs(mk_or(range_cases), mgr);
- SASSERT(rhs);
- assert_axiom(rhs);
- return;
- } else {
- get_manager().raise_exception("unrecognized regex operator");
- UNREACHABLE();
- }
-}
-
-void theory_str::gen_assign_unroll_reg(std::set<expr*> & unrolls) {
- context & ctx = get_context();
- ast_manager & mgr = get_manager();
-
- expr_ref_vector items(mgr);
- for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
- expr * unrFunc = *itor;
- TRACE("str", tout << "generating assignment for unroll " << mk_pp(unrFunc, mgr) << std::endl;);
-
- expr * regexInUnr = to_app(unrFunc)->get_arg(0);
- expr * cntInUnr = to_app(unrFunc)->get_arg(1);
- items.reset();
-
- rational low, high;
- bool low_exists = lower_bound(cntInUnr, low);
- bool high_exists = upper_bound(cntInUnr, high);
-
- TRACE("str",
- tout << "unroll " << mk_pp(unrFunc, mgr) << std::endl;
- rational unrLenValue;
- bool unrLenValue_exists = get_len_value(unrFunc, unrLenValue);
- tout << "unroll length: " << (unrLenValue_exists ? unrLenValue.to_string() : "?") << std::endl;
- rational cntInUnrValue;
- bool cntHasValue = get_value(cntInUnr, cntInUnrValue);
- tout << "unroll count: " << (cntHasValue ? cntInUnrValue.to_string() : "?")
- << " low = "
- << (low_exists ? low.to_string() : "?")
- << " high = "
- << (high_exists ? high.to_string() : "?")
- << std::endl;
- );
-
- expr_ref toAssert(mgr);
- if (low.is_neg()) {
- toAssert = m_autil.mk_ge(cntInUnr, mk_int(0));
- } else {
- if (unroll_var_map.find(unrFunc) == unroll_var_map.end()) {
-
- expr_ref newVar1(mk_regex_rep_var(), mgr);
- expr_ref newVar2(mk_regex_rep_var(), mgr);
- expr_ref concatAst(mk_concat(newVar1, newVar2), mgr);
- expr_ref newCnt(mk_unroll_bound_var(), mgr);
- expr_ref newUnrollFunc(mk_unroll(regexInUnr, newCnt), mgr);
-
- // unroll(r1, t1) = newVar1 . newVar2
- items.push_back(ctx.mk_eq_atom(unrFunc, concatAst));
- items.push_back(ctx.mk_eq_atom(mk_strlen(unrFunc), m_autil.mk_add(mk_strlen(newVar1), mk_strlen(newVar2))));
- // mk_strlen(unrFunc) >= mk_strlen(newVar{1,2})
- items.push_back(m_autil.mk_ge(m_autil.mk_add(mk_strlen(unrFunc), m_autil.mk_mul(mk_int(-1), mk_strlen(newVar1))), mk_int(0)));
- items.push_back(m_autil.mk_ge(m_autil.mk_add(mk_strlen(unrFunc), m_autil.mk_mul(mk_int(-1), mk_strlen(newVar2))), mk_int(0)));
- // newVar1 \in r1
- reduce_virtual_regex_in(newVar1, regexInUnr, items);
- items.push_back(ctx.mk_eq_atom(cntInUnr, m_autil.mk_add(newCnt, mk_int(1))));
- items.push_back(ctx.mk_eq_atom(newVar2, newUnrollFunc));
- items.push_back(ctx.mk_eq_atom(mk_strlen(newVar2), mk_strlen(newUnrollFunc)));
- toAssert = ctx.mk_eq_atom(
- m_autil.mk_ge(cntInUnr, mk_int(1)),
- mk_and(items));
-
- // option 0
- expr_ref op0(ctx.mk_eq_atom(cntInUnr, mk_int(0)), mgr);
- expr_ref ast1(ctx.mk_eq_atom(unrFunc, mk_string("")), mgr);
- expr_ref ast2(ctx.mk_eq_atom(mk_strlen(unrFunc), mk_int(0)), mgr);
- expr_ref and1(mgr.mk_and(ast1, ast2), mgr);
-
- // put together
- toAssert = mgr.mk_and(ctx.mk_eq_atom(op0, and1), toAssert);
-
- unroll_var_map[unrFunc] = toAssert;
- } else {
- toAssert = unroll_var_map[unrFunc];
- }
- }
- m_trail.push_back(toAssert);
- assert_axiom(toAssert);
- }
-}
-
-static int computeGCD(int x, int y) {
- if (x == 0) {
- return y;
- }
- while (y != 0) {
- if (x > y) {
- x = x - y;
- } else {
- y = y - x;
- }
- }
- return x;
-}
-
-static int computeLCM(int a, int b) {
- int temp = computeGCD(a, b);
- return temp ? (a / temp * b) : 0;
-}
-
-static zstring get_unrolled_string(zstring core, int count) {
- zstring res("");
- for (int i = 0; i < count; i++) {
- res = res + core;
- }
- return res;
-}
-
-expr * theory_str::gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls) {
- context & ctx = get_context();
- ast_manager & mgr = get_manager();
-
- int lcm = 1;
- int coreValueCount = 0;
- expr * oneUnroll = NULL;
- zstring oneCoreStr("");
- for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
- expr * str2RegFunc = to_app(*itor)->get_arg(0);
- expr * coreVal = to_app(str2RegFunc)->get_arg(0);
- zstring coreStr;
- u.str.is_string(coreVal, coreStr);
- if (oneUnroll == NULL) {
- oneUnroll = *itor;
- oneCoreStr = coreStr;
- }
- coreValueCount++;
- int core1Len = coreStr.length();
- lcm = computeLCM(lcm, core1Len);
- }
- //
- bool canHaveNonEmptyAssign = true;
- expr_ref_vector litems(mgr);
- zstring lcmStr = get_unrolled_string(oneCoreStr, (lcm / oneCoreStr.length()));
- for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
- expr * str2RegFunc = to_app(*itor)->get_arg(0);
- expr * coreVal = to_app(str2RegFunc)->get_arg(0);
- zstring coreStr;
- u.str.is_string(coreVal, coreStr);
- unsigned int core1Len = coreStr.length();
- zstring uStr = get_unrolled_string(coreStr, (lcm / core1Len));
- if (uStr != lcmStr) {
- canHaveNonEmptyAssign = false;
- }
- litems.push_back(ctx.mk_eq_atom(n, *itor));
- }
-
- if (canHaveNonEmptyAssign) {
- return gen_unroll_conditional_options(n, unrolls, lcmStr);
- } else {
- expr_ref implyL(mk_and(litems), mgr);
- expr_ref implyR(ctx.mk_eq_atom(n, mk_string("")), mgr);
- // want to return (implyL -> implyR)
- expr * final_axiom = rewrite_implication(implyL, implyR);
- return final_axiom;
- }
-}
-
-expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, zstring lcmStr) {
- context & ctx = get_context();
- ast_manager & mgr = get_manager();
-
- int dist = opt_LCMUnrollStep;
- expr_ref_vector litems(mgr);
- expr_ref moreAst(mk_string("more"), mgr);
- for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
- expr_ref item(ctx.mk_eq_atom(var, *itor), mgr);
- TRACE("str", tout << "considering unroll " << mk_pp(item, mgr) << std::endl;);
- litems.push_back(item);
- }
-
- // handle out-of-scope entries in unroll_tries_map
-
- ptr_vector<expr> outOfScopeTesters;
-
- for (ptr_vector<expr>::iterator it = unroll_tries_map[var][unrolls].begin();
- it != unroll_tries_map[var][unrolls].end(); ++it) {
- expr * tester = *it;
- bool inScope = (internal_unrollTest_vars.find(tester) != internal_unrollTest_vars.end());
- TRACE("str", tout << "unroll test var " << mk_pp(tester, mgr)
- << (inScope ? " in scope" : " out of scope")
- << std::endl;);
- if (!inScope) {
- outOfScopeTesters.push_back(tester);
- }
- }
-
- for (ptr_vector<expr>::iterator it = outOfScopeTesters.begin();
- it != outOfScopeTesters.end(); ++it) {
- unroll_tries_map[var][unrolls].erase(*it);
- }
-
-
- if (unroll_tries_map[var][unrolls].size() == 0) {
- unroll_tries_map[var][unrolls].push_back(mk_unroll_test_var());
- }
-
- int tries = unroll_tries_map[var][unrolls].size();
- for (int i = 0; i < tries; i++) {
- expr * tester = unroll_tries_map[var][unrolls][i];
- // TESTING
- refresh_theory_var(tester);
- bool testerHasValue = false;
- expr * testerVal = get_eqc_value(tester, testerHasValue);
- if (!testerHasValue) {
- // generate make-up assertion
- int l = i * dist;
- int h = (i + 1) * dist;
- expr_ref lImp(mk_and(litems), mgr);
- expr_ref rImp(gen_unroll_assign(var, lcmStr, tester, l, h), mgr);
-
- SASSERT(lImp);
- TRACE("str", tout << "lImp = " << mk_pp(lImp, mgr) << std::endl;);
- SASSERT(rImp);
- TRACE("str", tout << "rImp = " << mk_pp(rImp, mgr) << std::endl;);
-
- expr_ref toAssert(mgr.mk_or(mgr.mk_not(lImp), rImp), mgr);
- SASSERT(toAssert);
- TRACE("str", tout << "Making up assignments for variable which is equal to unbounded Unroll" << std::endl;);
- m_trail.push_back(toAssert);
- return toAssert;
-
- // note: this is how the code looks in Z3str2's strRegex.cpp:genUnrollConditionalOptions.
- // the return is in the same place
-
- // insert [tester = "more"] to litems so that the implyL for next tester is correct
- litems.push_back(ctx.mk_eq_atom(tester, moreAst));
- } else {
- zstring testerStr;
- u.str.is_string(testerVal, testerStr);
- TRACE("str", tout << "Tester [" << mk_pp(tester, mgr) << "] = " << testerStr << "\n";);
- if (testerStr == "more") {
- litems.push_back(ctx.mk_eq_atom(tester, moreAst));
- }
- }
- }
- expr * tester = mk_unroll_test_var();
- unroll_tries_map[var][unrolls].push_back(tester);
- int l = tries * dist;
- int h = (tries + 1) * dist;
- expr_ref lImp(mk_and(litems), mgr);
- expr_ref rImp(gen_unroll_assign(var, lcmStr, tester, l, h), mgr);
- SASSERT(lImp);
- SASSERT(rImp);
- expr_ref toAssert(mgr.mk_or(mgr.mk_not(lImp), rImp), mgr);
- SASSERT(toAssert);
- TRACE("str", tout << "Generating assignment for variable which is equal to unbounded Unroll" << std::endl;);
- m_trail.push_back(toAssert);
- return toAssert;
-}
-
-expr * theory_str::gen_unroll_assign(expr * var, zstring lcmStr, expr * testerVar, int l, int h) {
- context & ctx = get_context();
- ast_manager & mgr = get_manager();
-
- TRACE("str", tout << "entry: var = " << mk_pp(var, mgr) << ", lcmStr = " << lcmStr
- << ", l = " << l << ", h = " << h << "\n";);
-
- if (m_params.m_AggressiveUnrollTesting) {
- TRACE("str", tout << "note: aggressive unroll testing is active" << std::endl;);
- }
-
- expr_ref_vector orItems(mgr);
- expr_ref_vector andItems(mgr);
-
- for (int i = l; i < h; i++) {
- zstring iStr = int_to_string(i);
- expr_ref testerEqAst(ctx.mk_eq_atom(testerVar, mk_string(iStr)), mgr);
- TRACE("str", tout << "testerEqAst = " << mk_pp(testerEqAst, mgr) << std::endl;);
- if (m_params.m_AggressiveUnrollTesting) {
- literal l = mk_eq(testerVar, mk_string(iStr), false);
- ctx.mark_as_relevant(l);
- ctx.force_phase(l);
- }
-
- orItems.push_back(testerEqAst);
- zstring unrollStrInstance = get_unrolled_string(lcmStr, i);
-
- expr_ref x1(ctx.mk_eq_atom(testerEqAst, ctx.mk_eq_atom(var, mk_string(unrollStrInstance))), mgr);
- TRACE("str", tout << "x1 = " << mk_pp(x1, mgr) << std::endl;);
- andItems.push_back(x1);
-
- expr_ref x2(ctx.mk_eq_atom(testerEqAst, ctx.mk_eq_atom(mk_strlen(var), mk_int(i * lcmStr.length()))), mgr);
- TRACE("str", tout << "x2 = " << mk_pp(x2, mgr) << std::endl;);
- andItems.push_back(x2);
- }
- expr_ref testerEqMore(ctx.mk_eq_atom(testerVar, mk_string("more")), mgr);
- TRACE("str", tout << "testerEqMore = " << mk_pp(testerEqMore, mgr) << std::endl;);
- if (m_params.m_AggressiveUnrollTesting) {
- literal l = mk_eq(testerVar, mk_string("more"), false);
- ctx.mark_as_relevant(l);
- ctx.force_phase(~l);
- }
-
- orItems.push_back(testerEqMore);
- int nextLowerLenBound = h * lcmStr.length();
- expr_ref more2(ctx.mk_eq_atom(testerEqMore,
- //Z3_mk_ge(mk_length(t, var), mk_int(ctx, nextLowerLenBound))
- m_autil.mk_ge(m_autil.mk_add(mk_strlen(var), mk_int(-1 * nextLowerLenBound)), mk_int(0))
- ), mgr);
- TRACE("str", tout << "more2 = " << mk_pp(more2, mgr) << std::endl;);
- andItems.push_back(more2);
-
- expr_ref finalOR(mgr.mk_or(orItems.size(), orItems.c_ptr()), mgr);
- TRACE("str", tout << "finalOR = " << mk_pp(finalOR, mgr) << std::endl;);
- andItems.push_back(mk_or(orItems));
-
- expr_ref finalAND(mgr.mk_and(andItems.size(), andItems.c_ptr()), mgr);
- TRACE("str", tout << "finalAND = " << mk_pp(finalAND, mgr) << std::endl;);
-
- // doing the following avoids a segmentation fault
- m_trail.push_back(finalAND);
- return finalAND;
-}
-
-expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tries) {
- ast_manager & m = get_manager();
- context & ctx = get_context();
-
- expr_ref freeVarLen(mk_strlen(freeVar), m);
- SASSERT(freeVarLen);
-
- expr_ref_vector orList(m);
- expr_ref_vector andList(m);
-
- int distance = 3;
- int l = (tries - 1) * distance;
- int h = tries * distance;
-
- TRACE("str",
- tout << "building andList and orList" << std::endl;
- if (m_params.m_AggressiveLengthTesting) {
- tout << "note: aggressive length testing is active" << std::endl;
- }
- );
-
- // experimental theory-aware case split support
- literal_vector case_split_literals;
-
- for (int i = l; i < h; ++i) {
- expr_ref str_indicator(m);
- if (m_params.m_UseFastLengthTesterCache) {
- rational ri(i);
- expr * lookup_val;
- if(lengthTesterCache.find(ri, lookup_val)) {
- str_indicator = expr_ref(lookup_val, m);
- } else {
- // no match; create and insert
- zstring i_str = int_to_string(i);
- expr_ref new_val(mk_string(i_str), m);
- lengthTesterCache.insert(ri, new_val);
- m_trail.push_back(new_val);
- str_indicator = expr_ref(new_val, m);
- }
- } else {
- zstring i_str = int_to_string(i);
- str_indicator = expr_ref(mk_string(i_str), m);
- }
- expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
- orList.push_back(or_expr);
-
- double priority;
- // give high priority to small lengths if this is available
- if (i <= 5) {
- priority = 0.3;
- } else {
- // prioritize over "more"
- priority = 0.2;
- }
- add_theory_aware_branching_info(or_expr, priority, l_true);
-
- if (m_params.m_AggressiveLengthTesting) {
- literal l = mk_eq(indicator, str_indicator, false);
- ctx.mark_as_relevant(l);
- ctx.force_phase(l);
- }
-
- case_split_literals.insert(mk_eq(freeVarLen, mk_int(i), false));
-
- expr_ref and_expr(ctx.mk_eq_atom(orList.get(orList.size() - 1), m.mk_eq(freeVarLen, mk_int(i))), m);
- andList.push_back(and_expr);
- }
-
- expr_ref more_option(ctx.mk_eq_atom(indicator, mk_string("more")), m);
- orList.push_back(more_option);
- // decrease priority of this option
- add_theory_aware_branching_info(more_option, -0.1, l_true);
- if (m_params.m_AggressiveLengthTesting) {
- literal l = mk_eq(indicator, mk_string("more"), false);
- ctx.mark_as_relevant(l);
- ctx.force_phase(~l);
- }
-
- andList.push_back(ctx.mk_eq_atom(orList.get(orList.size() - 1), m_autil.mk_ge(freeVarLen, mk_int(h))));
-
- /*
- { // more experimental theory case split support
- expr_ref tmp(m_autil.mk_ge(freeVarLen, mk_int(h)), m);
- ctx.internalize(m_autil.mk_ge(freeVarLen, mk_int(h)), false);
- case_split_literals.push_back(ctx.get_literal(tmp));
- ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
- }
- */
-
- expr_ref_vector or_items(m);
- expr_ref_vector and_items(m);
-
- for (unsigned i = 0; i < orList.size(); ++i) {
- or_items.push_back(orList.get(i));
- }
-
- and_items.push_back(mk_or(or_items));
- for(unsigned i = 0; i < andList.size(); ++i) {
- and_items.push_back(andList.get(i));
- }
-
- TRACE("str", tout << "check: " << mk_pp(mk_and(and_items), m) << std::endl;);
-
- expr_ref lenTestAssert = mk_and(and_items);
- SASSERT(lenTestAssert);
- TRACE("str", tout << "crash avoidance lenTestAssert: " << mk_pp(lenTestAssert, m) << std::endl;);
-
- int testerCount = tries - 1;
- if (testerCount > 0) {
- expr_ref_vector and_items_LHS(m);
- expr_ref moreAst(mk_string("more"), m);
- for (int i = 0; i < testerCount; ++i) {
- expr * indicator = fvar_lenTester_map[freeVar][i];
- if (internal_variable_set.find(indicator) == internal_variable_set.end()) {
- TRACE("str", tout << "indicator " << mk_pp(indicator, m) << " out of scope; continuing" << std::endl;);
- continue;
- } else {
- TRACE("str", tout << "indicator " << mk_pp(indicator, m) << " in scope" << std::endl;);
- and_items_LHS.push_back(ctx.mk_eq_atom(indicator, moreAst));
- }
- }
- expr_ref assertL(mk_and(and_items_LHS), m);
- SASSERT(assertL);
- expr * finalAxiom = m.mk_or(m.mk_not(assertL), lenTestAssert.get());
- SASSERT(finalAxiom != NULL);
- TRACE("str", tout << "crash avoidance finalAxiom: " << mk_pp(finalAxiom, m) << std::endl;);
- return finalAxiom;
- } else {
- TRACE("str", tout << "crash avoidance lenTestAssert.get(): " << mk_pp(lenTestAssert.get(), m) << std::endl;);
- m_trail.push_back(lenTestAssert.get());
- return lenTestAssert.get();
- }
-}
-
-// Return an expression of the form
-// (tester = "less" | tester = "N" | tester = "more") &
-// (tester = "less" iff len(freeVar) < N) & (tester = "more" iff len(freeVar) > N) & (tester = "N" iff len(freeVar) = N))
-expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds, literal_vector & case_split) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
- rational N = bounds.midPoint;
- rational N_minus_one = N - rational::one();
- rational N_plus_one = N + rational::one();
- expr_ref lenFreeVar(mk_strlen(freeVar), m);
-
- TRACE("str", tout << "create case split for free var " << mk_pp(freeVar, m)
- << " over " << mk_pp(tester, m) << " with midpoint " << N << std::endl;);
-
- expr_ref_vector combinedCaseSplit(m);
- expr_ref_vector testerCases(m);
-
- expr_ref caseLess(ctx.mk_eq_atom(tester, mk_string("less")), m);
- testerCases.push_back(caseLess);
- combinedCaseSplit.push_back(ctx.mk_eq_atom(caseLess, m_autil.mk_le(lenFreeVar, m_autil.mk_numeral(N_minus_one, true) )));
-
- expr_ref caseMore(ctx.mk_eq_atom(tester, mk_string("more")), m);
- testerCases.push_back(caseMore);
- combinedCaseSplit.push_back(ctx.mk_eq_atom(caseMore, m_autil.mk_ge(lenFreeVar, m_autil.mk_numeral(N_plus_one, true) )));
-
- expr_ref caseEq(ctx.mk_eq_atom(tester, mk_string(N.to_string().c_str())), m);
- testerCases.push_back(caseEq);
- combinedCaseSplit.push_back(ctx.mk_eq_atom(caseEq, ctx.mk_eq_atom(lenFreeVar, m_autil.mk_numeral(N, true))));
-
- combinedCaseSplit.push_back(mk_or(testerCases));
-
- // force internalization on all terms in testerCases so we can extract literals
- for (unsigned i = 0; i < testerCases.size(); ++i) {
- expr * testerCase = testerCases.get(i);
- if (!ctx.b_internalized(testerCase)) {
- ctx.internalize(testerCase, false);
- }
- literal l = ctx.get_literal(testerCase);
- case_split.push_back(l);
- }
-
- expr_ref final_term(mk_and(combinedCaseSplit), m);
- SASSERT(final_term);
- TRACE("str", tout << "final term: " << mk_pp(final_term, m) << std::endl;);
- return final_term;
-}
-
-expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenTester, zstring previousLenTesterValue) {
- ast_manager & m = get_manager();
- context & ctx = get_context();
-
- if (binary_search_len_tester_stack.contains(freeVar) && !binary_search_len_tester_stack[freeVar].empty()) {
- TRACE("str", tout << "checking existing length testers for " << mk_pp(freeVar, m) << std::endl;
- for (ptr_vector<expr>::const_iterator it = binary_search_len_tester_stack[freeVar].begin();
- it != binary_search_len_tester_stack[freeVar].end(); ++it) {
- expr * tester = *it;
- tout << mk_pp(tester, m) << ": ";
- if (binary_search_len_tester_info.contains(tester)) {
- binary_search_info & bounds = binary_search_len_tester_info[tester];
- tout << "[" << bounds.lowerBound << " | " << bounds.midPoint << " | " << bounds.upperBound << "]!" << bounds.windowSize;
- } else {
- tout << "[WARNING: no bounds info available]";
- }
- bool hasEqcValue;
- expr * testerEqcValue = get_eqc_value(tester, hasEqcValue);
- if (hasEqcValue) {
- tout << " = " << mk_pp(testerEqcValue, m);
- } else {
- tout << " [no eqc value]";
- }
- tout << std::endl;
- }
- );
- expr * lastTester = binary_search_len_tester_stack[freeVar].back();
- bool lastTesterHasEqcValue;
- expr * lastTesterValue = get_eqc_value(lastTester, lastTesterHasEqcValue);
- zstring lastTesterConstant;
- if (!lastTesterHasEqcValue) {
- TRACE("str", tout << "length tester " << mk_pp(lastTester, m) << " at top of stack doesn't have an EQC value yet" << std::endl;);
- // check previousLenTester
- if (previousLenTester == lastTester) {
- lastTesterConstant = previousLenTesterValue;
- TRACE("str", tout << "invoked with previousLenTester info matching top of stack" << std::endl;);
- } else {
- TRACE("str", tout << "WARNING: unexpected reordering of length testers!" << std::endl;);
- UNREACHABLE(); return NULL;
- }
- } else {
- u.str.is_string(lastTesterValue, lastTesterConstant);
- }
- TRACE("str", tout << "last length tester is assigned \"" << lastTesterConstant << "\"" << "\n";);
- if (lastTesterConstant == "more" || lastTesterConstant == "less") {
- // use the previous bounds info to generate a new midpoint
- binary_search_info lastBounds;
- if (!binary_search_len_tester_info.find(lastTester, lastBounds)) {
- // unexpected
- TRACE("str", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
- UNREACHABLE();
- }
- TRACE("str", tout << "last bounds are [" << lastBounds.lowerBound << " | " << lastBounds.midPoint << " | " << lastBounds.upperBound << "]!" << lastBounds.windowSize << std::endl;);
- binary_search_info newBounds;
- expr * newTester;
- if (lastTesterConstant == "more") {
- // special case: if the midpoint, upper bound, and window size are all equal,
- // we double the window size and adjust the bounds
- if (lastBounds.midPoint == lastBounds.upperBound && lastBounds.upperBound == lastBounds.windowSize) {
- TRACE("str", tout << "search hit window size; expanding" << std::endl;);
- newBounds.lowerBound = lastBounds.windowSize + rational::one();
- newBounds.windowSize = lastBounds.windowSize * rational(2);
- newBounds.upperBound = newBounds.windowSize;
- newBounds.calculate_midpoint();
- } else if (false) {
- // handle the case where the midpoint can't be increased further
- // (e.g. a window like [50 | 50 | 50]!64 and we don't answer "50")
- } else {
- // general case
- newBounds.lowerBound = lastBounds.midPoint + rational::one();
- newBounds.windowSize = lastBounds.windowSize;
- newBounds.upperBound = lastBounds.upperBound;
- newBounds.calculate_midpoint();
- }
- if (!binary_search_next_var_high.find(lastTester, newTester)) {
- newTester = mk_internal_lenTest_var(freeVar, newBounds.midPoint.get_int32());
- binary_search_next_var_high.insert(lastTester, newTester);
- }
- refresh_theory_var(newTester);
- } else if (lastTesterConstant == "less") {
- if (false) {
- // handle the case where the midpoint can't be decreased further
- // (e.g. a window like [0 | 0 | 0]!64 and we don't answer "0"
- } else {
- // general case
- newBounds.upperBound = lastBounds.midPoint - rational::one();
- newBounds.windowSize = lastBounds.windowSize;
- newBounds.lowerBound = lastBounds.lowerBound;
- newBounds.calculate_midpoint();
- }
- if (!binary_search_next_var_low.find(lastTester, newTester)) {
- newTester = mk_internal_lenTest_var(freeVar, newBounds.midPoint.get_int32());
- binary_search_next_var_low.insert(lastTester, newTester);
- }
- refresh_theory_var(newTester);
- }
- TRACE("str", tout << "new bounds are [" << newBounds.lowerBound << " | " << newBounds.midPoint << " | " << newBounds.upperBound << "]!" << newBounds.windowSize << std::endl;);
- binary_search_len_tester_stack[freeVar].push_back(newTester);
- m_trail_stack.push(binary_search_trail<theory_str>(binary_search_len_tester_stack, freeVar));
- binary_search_len_tester_info.insert(newTester, newBounds);
- m_trail_stack.push(insert_obj_map<theory_str, expr, binary_search_info>(binary_search_len_tester_info, newTester));
-
- literal_vector case_split_literals;
- expr_ref next_case_split(binary_search_case_split(freeVar, newTester, newBounds, case_split_literals));
- m_trail.push_back(next_case_split);
- // ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
- return next_case_split;
- } else { // lastTesterConstant is a concrete value
- TRACE("str", tout << "length is fixed; generating models for free var" << std::endl;);
- // defensive check that this length did not converge on a negative value.
- binary_search_info lastBounds;
- if (!binary_search_len_tester_info.find(lastTester, lastBounds)) {
- // unexpected
- TRACE("str", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
- UNREACHABLE();
- }
- if (lastBounds.midPoint.is_neg()) {
- TRACE("str", tout << "WARNING: length search converged on a negative value. Negating this constraint." << std::endl;);
- expr_ref axiom(m_autil.mk_ge(mk_strlen(freeVar), m_autil.mk_numeral(rational::zero(), true)), m);
- return axiom;
- }
- // length is fixed
- expr * valueAssert = gen_free_var_options(freeVar, lastTester, lastTesterConstant, NULL, zstring(""));
- return valueAssert;
- }
- } else {
- // no length testers yet
- TRACE("str", tout << "no length testers for " << mk_pp(freeVar, m) << std::endl;);
- binary_search_len_tester_stack.insert(freeVar, ptr_vector<expr>());
-
- expr * firstTester;
- rational lowerBound(0);
- rational upperBound(m_params.m_BinarySearchInitialUpperBound);
- rational windowSize(upperBound);
- rational midPoint(floor(upperBound / rational(2)));
- if (!binary_search_starting_len_tester.find(freeVar, firstTester)) {
- firstTester = mk_internal_lenTest_var(freeVar, midPoint.get_int32());
- binary_search_starting_len_tester.insert(freeVar, firstTester);
- }
- refresh_theory_var(firstTester);
-
- binary_search_len_tester_stack[freeVar].push_back(firstTester);
- m_trail_stack.push(binary_search_trail<theory_str>(binary_search_len_tester_stack, freeVar));
- binary_search_info new_info(lowerBound, midPoint, upperBound, windowSize);
- binary_search_len_tester_info.insert(firstTester, new_info);
- m_trail_stack.push(insert_obj_map<theory_str, expr, binary_search_info>(binary_search_len_tester_info, firstTester));
-
- literal_vector case_split_literals;
- expr_ref initial_case_split(binary_search_case_split(freeVar, firstTester, new_info, case_split_literals));
- m_trail.push_back(initial_case_split);
- // ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
- return initial_case_split;
- }
-}
-
-// -----------------------------------------------------------------------------------------------------
-// True branch will be taken in final_check:
-// - When we discover a variable is "free" for the first time
-// lenTesterInCbEq = NULL
-// lenTesterValue = ""
-// False branch will be taken when invoked by new_eq_eh().
-// - After we set up length tester for a "free" var in final_check,
-// when the tester is assigned to some value (e.g. "more" or "4"),
-// lenTesterInCbEq != NULL, and its value will be passed by lenTesterValue
-// The difference is that in new_eq_eh(), lenTesterInCbEq and its value have NOT been put into a same eqc
-// -----------------------------------------------------------------------------------------------------
-expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, zstring lenTesterValue) {
-
- ast_manager & m = get_manager();
-
- TRACE("str", tout << "gen for free var " << mk_ismt2_pp(freeVar, m) << std::endl;);
-
- if (m_params.m_UseBinarySearch) {
- TRACE("str", tout << "using binary search heuristic" << std::endl;);
- return binary_search_length_test(freeVar, lenTesterInCbEq, lenTesterValue);
- } else {
- bool map_effectively_empty = false;
- if (!fvar_len_count_map.contains(freeVar)) {
- TRACE("str", tout << "fvar_len_count_map is empty" << std::endl;);
- map_effectively_empty = true;
+ expr_ref theory_str::set_up_finite_model_test(expr * lhs, expr * rhs) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ TRACE("str", tout << "activating finite model testing for overlapping concats "
+ << mk_pp(lhs, m) << " and " << mk_pp(rhs, m) << std::endl;);
+ std::map<expr*, int> concatMap;
+ std::map<expr*, int> unrollMap;
+ std::map<expr*, int> varMap;
+ classify_ast_by_type(lhs, varMap, concatMap, unrollMap);
+ classify_ast_by_type(rhs, varMap, concatMap, unrollMap);
+ TRACE("str", tout << "found vars:";
+ for (std::map<expr*,int>::iterator it = varMap.begin(); it != varMap.end(); ++it) {
+ tout << " " << mk_pp(it->first, m);
+ }
+ tout << std::endl;
+ );
+
+ expr_ref testvar(mk_str_var("finiteModelTest"), m);
+ m_trail.push_back(testvar);
+ ptr_vector<expr> varlist;
+
+ for (std::map<expr*, int>::iterator it = varMap.begin(); it != varMap.end(); ++it) {
+ expr * v = it->first;
+ varlist.push_back(v);
}
- if (!map_effectively_empty) {
- // check whether any entries correspond to variables that went out of scope;
- // if every entry is out of scope then the map counts as being empty
+ // make things easy for the core wrt. testvar
+ expr_ref t1(ctx.mk_eq_atom(testvar, mk_string("")), m);
+ expr_ref t_yes(ctx.mk_eq_atom(testvar, mk_string("yes")), m);
+ expr_ref testvaraxiom(m.mk_or(t1, t_yes), m);
+ assert_axiom(testvaraxiom);
- // assume empty and find a counterexample
- map_effectively_empty = true;
- ptr_vector<expr> indicator_set = fvar_lenTester_map[freeVar];
- for (ptr_vector<expr>::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) {
- expr * indicator = *it;
- if (internal_variable_set.find(indicator) != internal_variable_set.end()) {
- TRACE("str", tout <<"found active internal variable " << mk_ismt2_pp(indicator, m)
- << " in fvar_lenTester_map[freeVar]" << std::endl;);
- map_effectively_empty = false;
- break;
- }
- }
- CTRACE("str", map_effectively_empty, tout << "all variables in fvar_lenTester_map[freeVar] out of scope" << std::endl;);
- }
+ finite_model_test_varlists.insert(testvar, varlist);
+ m_trail_stack.push(insert_obj_map<theory_str, expr, ptr_vector<expr> >(finite_model_test_varlists, testvar) );
+ return t_yes;
+ }
- if (map_effectively_empty) {
- // no length assertions for this free variable have ever been added.
- TRACE("str", tout << "no length assertions yet" << std::endl;);
+ void theory_str::finite_model_test(expr * testvar, expr * str) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
- fvar_len_count_map.insert(freeVar, 1);
- unsigned int testNum = fvar_len_count_map[freeVar];
-
- expr_ref indicator(mk_internal_lenTest_var(freeVar, testNum), m);
- SASSERT(indicator);
-
- // since the map is "effectively empty", we can remove those variables that have left scope...
- fvar_lenTester_map[freeVar].shrink(0);
- fvar_lenTester_map[freeVar].push_back(indicator);
- lenTester_fvar_map.insert(indicator, freeVar);
-
- expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
- SASSERT(lenTestAssert != NULL);
- return lenTestAssert;
- } else {
- TRACE("str", tout << "found previous in-scope length assertions" << std::endl;);
-
- expr * effectiveLenInd = NULL;
- zstring effectiveLenIndiStr("");
- int lenTesterCount = (int) fvar_lenTester_map[freeVar].size();
-
- TRACE("str",
- tout << lenTesterCount << " length testers in fvar_lenTester_map[" << mk_pp(freeVar, m) << "]:" << std::endl;
- for (int i = 0; i < lenTesterCount; ++i) {
- expr * len_indicator = fvar_lenTester_map[freeVar][i];
- tout << mk_pp(len_indicator, m) << ": ";
- bool effectiveInScope = (internal_variable_set.find(len_indicator) != internal_variable_set.end());
- tout << (effectiveInScope ? "in scope" : "NOT in scope");
- tout << std::endl;
- }
- );
-
- int i = 0;
- for (; i < lenTesterCount; ++i) {
- expr * len_indicator_pre = fvar_lenTester_map[freeVar][i];
- // check whether this is in scope as well
- if (internal_variable_set.find(len_indicator_pre) == internal_variable_set.end()) {
- TRACE("str", tout << "length indicator " << mk_pp(len_indicator_pre, m) << " not in scope" << std::endl;);
+ zstring s;
+ if (!u.str.is_string(str, s)) return;
+ if (s == "yes") {
+ TRACE("str", tout << "start finite model test for " << mk_pp(testvar, m) << std::endl;);
+ ptr_vector<expr> & vars = finite_model_test_varlists[testvar];
+ for (ptr_vector<expr>::iterator it = vars.begin(); it != vars.end(); ++it) {
+ expr * v = *it;
+ bool v_has_eqc = false;
+ get_eqc_value(v, v_has_eqc);
+ if (v_has_eqc) {
+ TRACE("str", tout << "variable " << mk_pp(v,m) << " already equivalent to a string constant" << std::endl;);
continue;
}
+ // check for any sort of existing length tester we might interfere with
+ if (m_params.m_UseBinarySearch) {
+ if (binary_search_len_tester_stack.contains(v) && !binary_search_len_tester_stack[v].empty()) {
+ TRACE("str", tout << "already found existing length testers for " << mk_pp(v, m) << std::endl;);
+ continue;
+ } else {
+ // start binary search as normal
+ expr_ref implLhs(ctx.mk_eq_atom(testvar, str), m);
+ expr_ref implRhs(binary_search_length_test(v, NULL, ""), m);
+ assert_implication(implLhs, implRhs);
+ }
+ } else {
+ bool map_effectively_empty = false;
+ if (!fvar_len_count_map.contains(v)) {
+ map_effectively_empty = true;
+ }
+ if (!map_effectively_empty) {
+ map_effectively_empty = true;
+ ptr_vector<expr> indicator_set = fvar_lenTester_map[v];
+ for (ptr_vector<expr>::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) {
+ expr * indicator = *it;
+ if (internal_variable_set.find(indicator) != internal_variable_set.end()) {
+ map_effectively_empty = false;
+ break;
+ }
+ }
+ }
+
+ if (map_effectively_empty) {
+ TRACE("str", tout << "no existing length testers for " << mk_pp(v, m) << std::endl;);
+ rational v_len;
+ rational v_lower_bound;
+ rational v_upper_bound;
+ expr_ref vLengthExpr(mk_strlen(v), m);
+ if (get_len_value(v, v_len)) {
+ TRACE("str", tout << "length = " << v_len.to_string() << std::endl;);
+ v_lower_bound = v_len;
+ v_upper_bound = v_len;
+ } else {
+ bool lower_bound_exists = lower_bound(vLengthExpr, v_lower_bound);
+ bool upper_bound_exists = upper_bound(vLengthExpr, v_upper_bound);
+ TRACE("str", tout << "bounds = [" << (lower_bound_exists?v_lower_bound.to_string():"?")
+ << ".." << (upper_bound_exists?v_upper_bound.to_string():"?") << "]" << std::endl;);
+
+ // make sure the bounds are non-negative
+ if (lower_bound_exists && v_lower_bound.is_neg()) {
+ v_lower_bound = rational::zero();
+ }
+ if (upper_bound_exists && v_upper_bound.is_neg()) {
+ v_upper_bound = rational::zero();
+ }
+
+ if (lower_bound_exists && upper_bound_exists) {
+ // easiest case. we will search within these bounds
+ } else if (upper_bound_exists && !lower_bound_exists) {
+ // search between 0 and the upper bound
+ v_lower_bound == rational::zero();
+ } else if (lower_bound_exists && !upper_bound_exists) {
+ // check some finite portion of the search space
+ v_upper_bound = v_lower_bound + rational(10);
+ } else {
+ // no bounds information
+ v_lower_bound = rational::zero();
+ v_upper_bound = v_lower_bound + rational(10);
+ }
+ }
+ // now create a fake length tester over this finite disjunction of lengths
+
+ fvar_len_count_map[v] = 1;
+ unsigned int testNum = fvar_len_count_map[v];
+
+ expr_ref indicator(mk_internal_lenTest_var(v, testNum), m);
+ SASSERT(indicator);
+ m_trail.push_back(indicator);
+
+ fvar_lenTester_map[v].shrink(0);
+ fvar_lenTester_map[v].push_back(indicator);
+ lenTester_fvar_map[indicator] = v;
+
+ expr_ref_vector orList(m);
+ expr_ref_vector andList(m);
+
+ for (rational l = v_lower_bound; l <= v_upper_bound; l += rational::one()) {
+ zstring lStr = zstring(l.to_string().c_str());
+ expr_ref str_indicator(mk_string(lStr), m);
+ expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
+ orList.push_back(or_expr);
+ expr_ref and_expr(ctx.mk_eq_atom(or_expr, ctx.mk_eq_atom(vLengthExpr, m_autil.mk_numeral(l, true))), m);
+ andList.push_back(and_expr);
+ }
+ andList.push_back(mk_or(orList));
+ expr_ref implLhs(ctx.mk_eq_atom(testvar, str), m);
+ expr_ref implRhs(mk_and(andList), m);
+ assert_implication(implLhs, implRhs);
+ } else {
+ TRACE("str", tout << "already found existing length testers for " << mk_pp(v, m) << std::endl;);
+ continue;
+ }
+ }
+ } // foreach (v in vars)
+ } // (s == "yes")
+ }
+
+ void theory_str::more_len_tests(expr * lenTester, zstring lenTesterValue) {
+ ast_manager & m = get_manager();
+ if (lenTester_fvar_map.contains(lenTester)) {
+ expr * fVar = lenTester_fvar_map[lenTester];
+ expr * toAssert = gen_len_val_options_for_free_var(fVar, lenTester, lenTesterValue);
+ TRACE("str", tout << "asserting more length tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
+ if (toAssert != NULL) {
+ assert_axiom(toAssert);
+ }
+ }
+ }
+
+ void theory_str::more_value_tests(expr * valTester, zstring valTesterValue) {
+ ast_manager & m = get_manager();
+
+ expr * fVar = valueTester_fvar_map[valTester];
+ if (m_params.m_UseBinarySearch) {
+ if (!binary_search_len_tester_stack.contains(fVar) || binary_search_len_tester_stack[fVar].empty()) {
+ TRACE("str", tout << "WARNING: no active length testers for " << mk_pp(fVar, m) << std::endl;);
+ NOT_IMPLEMENTED_YET();
+ }
+ expr * effectiveLenInd = binary_search_len_tester_stack[fVar].back();
+ bool hasEqcValue;
+ expr * len_indicator_value = get_eqc_value(effectiveLenInd, hasEqcValue);
+ if (!hasEqcValue) {
+ TRACE("str", tout << "WARNING: length tester " << mk_pp(effectiveLenInd, m) << " at top of stack for " << mk_pp(fVar, m) << " has no EQC value" << std::endl;);
+ } else {
+ // safety check
+ zstring effectiveLenIndiStr;
+ u.str.is_string(len_indicator_value, effectiveLenIndiStr);
+ if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "less") {
+ TRACE("str", tout << "ERROR: illegal state -- requesting 'more value tests' but a length tester is not yet concrete!" << std::endl;);
+ UNREACHABLE();
+ }
+ expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
+ TRACE("str", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
+ if (valueAssert != NULL) {
+ assert_axiom(valueAssert);
+ }
+ }
+ } else {
+ int lenTesterCount = fvar_lenTester_map[fVar].size();
+
+ expr * effectiveLenInd = NULL;
+ zstring effectiveLenIndiStr = "";
+ for (int i = 0; i < lenTesterCount; ++i) {
+ expr * len_indicator_pre = fvar_lenTester_map[fVar][i];
bool indicatorHasEqcValue = false;
expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
- TRACE("str", tout << "length indicator " << mk_ismt2_pp(len_indicator_pre, m) <<
- " = " << mk_ismt2_pp(len_indicator_value, m) << std::endl;);
if (indicatorHasEqcValue) {
zstring len_pIndiStr;
u.str.is_string(len_indicator_value, len_pIndiStr);
@@ -10281,318 +6974,3623 @@ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTe
effectiveLenIndiStr = len_pIndiStr;
break;
}
- } else {
- if (lenTesterInCbEq != len_indicator_pre) {
- TRACE("str", tout << "WARNING: length indicator " << mk_ismt2_pp(len_indicator_pre, m)
- << " does not have an equivalence class value."
- << " i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
- if (i > 0) {
- effectiveLenInd = fvar_lenTester_map[freeVar][i - 1];
- bool effectiveHasEqcValue;
- expr * effective_eqc_value = get_eqc_value(effectiveLenInd, effectiveHasEqcValue);
- bool effectiveInScope = (internal_variable_set.find(effectiveLenInd) != internal_variable_set.end());
- TRACE("str", tout << "checking effective length indicator " << mk_pp(effectiveLenInd, m) << ": "
- << (effectiveInScope ? "in scope" : "NOT in scope") << ", ";
- if (effectiveHasEqcValue) {
- tout << "~= " << mk_pp(effective_eqc_value, m);
- } else {
- tout << "no eqc string constant";
- }
- tout << std::endl;);
- if (effectiveLenInd == lenTesterInCbEq) {
- effectiveLenIndiStr = lenTesterValue;
+ }
+ }
+ expr * valueAssert = gen_free_var_options(fVar, effectiveLenInd, effectiveLenIndiStr, valTester, valTesterValue);
+ TRACE("str", tout << "asserting more value tests for free variable " << mk_ismt2_pp(fVar, m) << std::endl;);
+ if (valueAssert != NULL) {
+ assert_axiom(valueAssert);
+ }
+ }
+ }
+
+ bool theory_str::free_var_attempt(expr * nn1, expr * nn2) {
+ ast_manager & m = get_manager();
+ zstring nn2_str;
+ if (internal_lenTest_vars.contains(nn1) && u.str.is_string(nn2, nn2_str)) {
+ TRACE("str", tout << "acting on equivalence between length tester var " << mk_ismt2_pp(nn1, m)
+ << " and constant " << mk_ismt2_pp(nn2, m) << std::endl;);
+ more_len_tests(nn1, nn2_str);
+ return true;
+ } else if (internal_valTest_vars.contains(nn1) && u.str.is_string(nn2, nn2_str)) {
+ if (nn2_str == "more") {
+ TRACE("str", tout << "acting on equivalence between value var " << mk_ismt2_pp(nn1, m)
+ << " and constant " << mk_ismt2_pp(nn2, m) << std::endl;);
+ more_value_tests(nn1, nn2_str);
+ }
+ return true;
+ } else if (internal_unrollTest_vars.contains(nn1)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ void theory_str::handle_equality(expr * lhs, expr * rhs) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ // both terms must be of sort String
+ sort * lhs_sort = m.get_sort(lhs);
+ sort * rhs_sort = m.get_sort(rhs);
+ sort * str_sort = u.str.mk_string_sort();
+
+ if (lhs_sort != str_sort || rhs_sort != str_sort) {
+ TRACE("str", tout << "skip equality: not String sort" << std::endl;);
+ return;
+ }
+
+ /* // temporarily disabled, we are borrowing these testers for something else
+ if (m_params.m_FiniteOverlapModels && !finite_model_test_varlists.empty()) {
+ if (finite_model_test_varlists.contains(lhs)) {
+ finite_model_test(lhs, rhs); return;
+ } else if (finite_model_test_varlists.contains(rhs)) {
+ finite_model_test(rhs, lhs); return;
+ }
+ }
+ */
+
+ if (free_var_attempt(lhs, rhs) || free_var_attempt(rhs, lhs)) {
+ return;
+ }
+
+ if (u.str.is_concat(to_app(lhs)) && u.str.is_concat(to_app(rhs))) {
+ bool nn1HasEqcValue = false;
+ bool nn2HasEqcValue = false;
+ expr * nn1_value = get_eqc_value(lhs, nn1HasEqcValue);
+ expr * nn2_value = get_eqc_value(rhs, nn2HasEqcValue);
+ if (nn1HasEqcValue && !nn2HasEqcValue) {
+ simplify_parent(rhs, nn1_value);
+ }
+ if (!nn1HasEqcValue && nn2HasEqcValue) {
+ simplify_parent(lhs, nn2_value);
+ }
+
+ expr * nn1_arg0 = to_app(lhs)->get_arg(0);
+ expr * nn1_arg1 = to_app(lhs)->get_arg(1);
+ expr * nn2_arg0 = to_app(rhs)->get_arg(0);
+ expr * nn2_arg1 = to_app(rhs)->get_arg(1);
+ if (nn1_arg0 == nn2_arg0 && in_same_eqc(nn1_arg1, nn2_arg1)) {
+ TRACE("str", tout << "skip: lhs arg0 == rhs arg0" << std::endl;);
+ return;
+ }
+
+ if (nn1_arg1 == nn2_arg1 && in_same_eqc(nn1_arg0, nn2_arg0)) {
+ TRACE("str", tout << "skip: lhs arg1 == rhs arg1" << std::endl;);
+ return;
+ }
+ }
+
+ if (opt_DeferEQCConsistencyCheck) {
+ TRACE("str", tout << "opt_DeferEQCConsistencyCheck is set; deferring new_eq_check call" << std::endl;);
+ } else {
+ // newEqCheck() -- check consistency wrt. existing equivalence classes
+ if (!new_eq_check(lhs, rhs)) {
+ return;
+ }
+ }
+
+ // BEGIN new_eq_handler() in strTheory
+
+ {
+ rational nn1Len, nn2Len;
+ bool nn1Len_exists = get_len_value(lhs, nn1Len);
+ bool nn2Len_exists = get_len_value(rhs, nn2Len);
+ expr * emptyStr = mk_string("");
+
+ if (nn1Len_exists && nn1Len.is_zero()) {
+ if (!in_same_eqc(lhs, emptyStr) && rhs != emptyStr) {
+ expr_ref eql(ctx.mk_eq_atom(mk_strlen(lhs), mk_int(0)), m);
+ expr_ref eqr(ctx.mk_eq_atom(lhs, emptyStr), m);
+ expr_ref toAssert(ctx.mk_eq_atom(eql, eqr), m);
+ assert_axiom(toAssert);
+ }
+ }
+
+ if (nn2Len_exists && nn2Len.is_zero()) {
+ if (!in_same_eqc(rhs, emptyStr) && lhs != emptyStr) {
+ expr_ref eql(ctx.mk_eq_atom(mk_strlen(rhs), mk_int(0)), m);
+ expr_ref eqr(ctx.mk_eq_atom(rhs, emptyStr), m);
+ expr_ref toAssert(ctx.mk_eq_atom(eql, eqr), m);
+ assert_axiom(toAssert);
+ }
+ }
+ }
+
+ instantiate_str_eq_length_axiom(ctx.get_enode(lhs), ctx.get_enode(rhs));
+
+ // group terms by equivalence class (groupNodeInEqc())
+
+ std::set<expr*> eqc_concat_lhs;
+ std::set<expr*> eqc_var_lhs;
+ std::set<expr*> eqc_const_lhs;
+ group_terms_by_eqc(lhs, eqc_concat_lhs, eqc_var_lhs, eqc_const_lhs);
+
+ std::set<expr*> eqc_concat_rhs;
+ std::set<expr*> eqc_var_rhs;
+ std::set<expr*> eqc_const_rhs;
+ group_terms_by_eqc(rhs, eqc_concat_rhs, eqc_var_rhs, eqc_const_rhs);
+
+ TRACE("str",
+ tout << "lhs eqc:" << std::endl;
+ tout << "Concats:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_concat_lhs.begin(); it != eqc_concat_lhs.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ tout << "Variables:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_var_lhs.begin(); it != eqc_var_lhs.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ tout << "Constants:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_const_lhs.begin(); it != eqc_const_lhs.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+
+ tout << "rhs eqc:" << std::endl;
+ tout << "Concats:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_concat_rhs.begin(); it != eqc_concat_rhs.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ tout << "Variables:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_var_rhs.begin(); it != eqc_var_rhs.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ tout << "Constants:" << std::endl;
+ for (std::set<expr*>::iterator it = eqc_const_rhs.begin(); it != eqc_const_rhs.end(); ++it) {
+ expr * ex = *it;
+ tout << mk_ismt2_pp(ex, get_manager()) << std::endl;
+ }
+ );
+
+ // step 1: Concat == Concat
+ int hasCommon = 0;
+ if (eqc_concat_lhs.size() != 0 && eqc_concat_rhs.size() != 0) {
+ std::set<expr*>::iterator itor1 = eqc_concat_lhs.begin();
+ std::set<expr*>::iterator itor2 = eqc_concat_rhs.begin();
+ for (; itor1 != eqc_concat_lhs.end(); itor1++) {
+ if (eqc_concat_rhs.find(*itor1) != eqc_concat_rhs.end()) {
+ hasCommon = 1;
+ break;
+ }
+ }
+ for (; itor2 != eqc_concat_rhs.end(); itor2++) {
+ if (eqc_concat_lhs.find(*itor2) != eqc_concat_lhs.end()) {
+ hasCommon = 1;
+ break;
+ }
+ }
+ if (hasCommon == 0) {
+ if (opt_ConcatOverlapAvoid) {
+ bool found = false;
+ // check each pair and take the first ones that won't immediately overlap
+ for (itor1 = eqc_concat_lhs.begin(); itor1 != eqc_concat_lhs.end() && !found; ++itor1) {
+ expr * concat_lhs = *itor1;
+ for (itor2 = eqc_concat_rhs.begin(); itor2 != eqc_concat_rhs.end() && !found; ++itor2) {
+ expr * concat_rhs = *itor2;
+ if (will_result_in_overlap(concat_lhs, concat_rhs)) {
+ TRACE("str", tout << "Concats " << mk_pp(concat_lhs, m) << " and "
+ << mk_pp(concat_rhs, m) << " will result in overlap; skipping." << std::endl;);
} else {
- if (effectiveHasEqcValue) {
- u.str.is_string(effective_eqc_value, effectiveLenIndiStr);
- } else {
- NOT_IMPLEMENTED_YET();
- }
+ TRACE("str", tout << "Concats " << mk_pp(concat_lhs, m) << " and "
+ << mk_pp(concat_rhs, m) << " won't overlap. Simplifying here." << std::endl;);
+ simplify_concat_equality(concat_lhs, concat_rhs);
+ found = true;
+ break;
}
}
- break;
}
- // lenTesterInCbEq == len_indicator_pre
- else {
- if (lenTesterValue != "more") {
- effectiveLenInd = len_indicator_pre;
- effectiveLenIndiStr = lenTesterValue;
+ if (!found) {
+ TRACE("str", tout << "All pairs of concats expected to overlap, falling back." << std::endl;);
+ simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin()));
+ }
+ } else {
+ // default behaviour
+ simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin()));
+ }
+ }
+ }
+
+ // step 2: Concat == Constant
+
+ if (eqc_const_lhs.size() != 0) {
+ expr * conStr = *(eqc_const_lhs.begin());
+ std::set<expr*>::iterator itor2 = eqc_concat_rhs.begin();
+ for (; itor2 != eqc_concat_rhs.end(); itor2++) {
+ solve_concat_eq_str(*itor2, conStr);
+ }
+ } else if (eqc_const_rhs.size() != 0) {
+ expr* conStr = *(eqc_const_rhs.begin());
+ std::set<expr*>::iterator itor1 = eqc_concat_lhs.begin();
+ for (; itor1 != eqc_concat_lhs.end(); itor1++) {
+ solve_concat_eq_str(*itor1, conStr);
+ }
+ }
+
+ // simplify parents wrt. the equivalence class of both sides
+ bool nn1HasEqcValue = false;
+ bool nn2HasEqcValue = false;
+ // we want the Z3str2 eqc check here...
+ expr * nn1_value = z3str2_get_eqc_value(lhs, nn1HasEqcValue);
+ expr * nn2_value = z3str2_get_eqc_value(rhs, nn2HasEqcValue);
+ if (nn1HasEqcValue && !nn2HasEqcValue) {
+ simplify_parent(rhs, nn1_value);
+ }
+
+ if (!nn1HasEqcValue && nn2HasEqcValue) {
+ simplify_parent(lhs, nn2_value);
+ }
+
+ expr * nn1EqConst = NULL;
+ std::set<expr*> nn1EqUnrollFuncs;
+ get_eqc_allUnroll(lhs, nn1EqConst, nn1EqUnrollFuncs);
+ expr * nn2EqConst = NULL;
+ std::set<expr*> nn2EqUnrollFuncs;
+ get_eqc_allUnroll(rhs, nn2EqConst, nn2EqUnrollFuncs);
+
+ if (nn2EqConst != NULL) {
+ for (std::set<expr*>::iterator itor1 = nn1EqUnrollFuncs.begin(); itor1 != nn1EqUnrollFuncs.end(); itor1++) {
+ process_unroll_eq_const_str(*itor1, nn2EqConst);
+ }
+ }
+
+ if (nn1EqConst != NULL) {
+ for (std::set<expr*>::iterator itor2 = nn2EqUnrollFuncs.begin(); itor2 != nn2EqUnrollFuncs.end(); itor2++) {
+ process_unroll_eq_const_str(*itor2, nn1EqConst);
+ }
+ }
+
+ }
+
+ void theory_str::set_up_axioms(expr * ex) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ sort * ex_sort = m.get_sort(ex);
+ sort * str_sort = u.str.mk_string_sort();
+ sort * bool_sort = m.mk_bool_sort();
+
+ family_id m_arith_fid = m.mk_family_id("arith");
+ sort * int_sort = m.mk_sort(m_arith_fid, INT_SORT);
+
+ if (ex_sort == str_sort) {
+ TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ ": expr is of sort String" << std::endl;);
+ // set up basic string axioms
+ enode * n = ctx.get_enode(ex);
+ SASSERT(n);
+ m_basicstr_axiom_todo.push_back(n);
+ TRACE("str", tout << "add " << mk_pp(ex, m) << " to m_basicstr_axiom_todo" << std::endl;);
+
+
+ if (is_app(ex)) {
+ app * ap = to_app(ex);
+ if (u.str.is_concat(ap)) {
+ // if ex is a concat, set up concat axioms later
+ m_concat_axiom_todo.push_back(n);
+ // we also want to check whether we can eval this concat,
+ // in case the rewriter did not totally finish with this term
+ m_concat_eval_todo.push_back(n);
+ } else if (u.str.is_length(ap)) {
+ // if the argument is a variable,
+ // keep track of this for later, we'll need it during model gen
+ expr * var = ap->get_arg(0);
+ app * aVar = to_app(var);
+ if (aVar->get_num_args() == 0 && !u.str.is_string(aVar)) {
+ input_var_in_len.insert(var);
+ }
+ } else if (u.str.is_at(ap) || u.str.is_extract(ap) || u.str.is_replace(ap)) {
+ m_library_aware_axiom_todo.push_back(n);
+ } else if (u.str.is_itos(ap)) {
+ TRACE("str", tout << "found string-integer conversion term: " << mk_pp(ex, get_manager()) << std::endl;);
+ string_int_conversion_terms.push_back(ap);
+ m_library_aware_axiom_todo.push_back(n);
+ } else if (ap->get_num_args() == 0 && !u.str.is_string(ap)) {
+ // if ex is a variable, add it to our list of variables
+ TRACE("str", tout << "tracking variable " << mk_ismt2_pp(ap, get_manager()) << std::endl;);
+ variable_set.insert(ex);
+ ctx.mark_as_relevant(ex);
+ // this might help??
+ theory_var v = mk_var(n);
+ TRACE("str", tout << "variable " << mk_ismt2_pp(ap, get_manager()) << " is #" << v << std::endl;);
+ }
+ }
+ } else if (ex_sort == bool_sort) {
+ TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ ": expr is of sort Bool" << std::endl;);
+ // set up axioms for boolean terms
+
+ ensure_enode(ex);
+ if (ctx.e_internalized(ex)) {
+ enode * n = ctx.get_enode(ex);
+ SASSERT(n);
+
+ if (is_app(ex)) {
+ app * ap = to_app(ex);
+ if (u.str.is_prefix(ap) || u.str.is_suffix(ap) || u.str.is_contains(ap) || u.str.is_in_re(ap)) {
+ m_library_aware_axiom_todo.push_back(n);
+ }
+ }
+ } else {
+ TRACE("str", tout << "WARNING: Bool term " << mk_ismt2_pp(ex, get_manager()) << " not internalized. Delaying axiom setup to prevent a crash." << std::endl;);
+ ENSURE(!search_started); // infinite loop prevention
+ m_delayed_axiom_setup_terms.push_back(ex);
+ return;
+ }
+ } else if (ex_sort == int_sort) {
+ TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ ": expr is of sort Int" << std::endl;);
+ // set up axioms for integer terms
+ enode * n = ensure_enode(ex);
+ SASSERT(n);
+
+ if (is_app(ex)) {
+ app * ap = to_app(ex);
+ // TODO indexof2/lastindexof
+ if (u.str.is_index(ap) /* || is_Indexof2(ap) || is_LastIndexof(ap) */) {
+ m_library_aware_axiom_todo.push_back(n);
+ } else if (u.str.is_stoi(ap)) {
+ TRACE("str", tout << "found string-integer conversion term: " << mk_pp(ex, get_manager()) << std::endl;);
+ string_int_conversion_terms.push_back(ap);
+ m_library_aware_axiom_todo.push_back(n);
+ }
+ }
+ } else {
+ TRACE("str", tout << "setting up axioms for " << mk_ismt2_pp(ex, get_manager()) <<
+ ": expr is of wrong sort, ignoring" << std::endl;);
+ }
+
+ // if expr is an application, recursively inspect all arguments
+ if (is_app(ex)) {
+ app * term = (app*)ex;
+ unsigned num_args = term->get_num_args();
+ for (unsigned i = 0; i < num_args; i++) {
+ set_up_axioms(term->get_arg(i));
+ }
+ }
+ }
+
+ void theory_str::add_theory_assumptions(expr_ref_vector & assumptions) {
+ TRACE("str", tout << "add overlap assumption for theory_str" << std::endl;);
+ symbol strOverlap("!!TheoryStrOverlapAssumption!!");
+ seq_util m_sequtil(get_manager());
+ sort * s = get_manager().mk_bool_sort();
+ m_theoryStrOverlapAssumption_term = expr_ref(get_manager().mk_const(strOverlap, s), get_manager());
+ assumptions.push_back(get_manager().mk_not(m_theoryStrOverlapAssumption_term));
+ }
+
+ lbool theory_str::validate_unsat_core(expr_ref_vector & unsat_core) {
+ bool assumptionFound = false;
+
+ app * target_term = to_app(get_manager().mk_not(m_theoryStrOverlapAssumption_term));
+ get_context().internalize(target_term, false);
+ for (unsigned i = 0; i < unsat_core.size(); ++i) {
+ app * core_term = to_app(unsat_core.get(i));
+ // not sure if this is the correct way to compare terms in this context
+ enode * e1;
+ enode * e2;
+ e1 = get_context().get_enode(target_term);
+ e2 = get_context().get_enode(core_term);
+ if (e1 == e2) {
+ TRACE("str", tout << "overlap detected in unsat core, changing UNSAT to UNKNOWN" << std::endl;);
+ assumptionFound = true;
+ return l_undef;
+ }
+ }
+
+ return l_false;
+ }
+
+ void theory_str::init_search_eh() {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ TRACE("str",
+ tout << "dumping all asserted formulas:" << std::endl;
+ unsigned nFormulas = ctx.get_num_asserted_formulas();
+ for (unsigned i = 0; i < nFormulas; ++i) {
+ expr * ex = ctx.get_asserted_formula(i);
+ tout << mk_ismt2_pp(ex, m) << (ctx.is_relevant(ex) ? " (rel)" : " (NOT REL)") << std::endl;
+ }
+ );
+ /*
+ * Recursive descent through all asserted formulas to set up axioms.
+ * Note that this is just the input structure and not necessarily things
+ * that we know to be true or false. We're just doing this to see
+ * which terms are explicitly mentioned.
+ */
+ unsigned nFormulas = ctx.get_num_asserted_formulas();
+ for (unsigned i = 0; i < nFormulas; ++i) {
+ expr * ex = ctx.get_asserted_formula(i);
+ set_up_axioms(ex);
+ }
+
+ /*
+ * Similar recursive descent, except over all initially assigned terms.
+ * This is done to find equalities between terms, etc. that we otherwise
+ * might not get a chance to see.
+ */
+
+ /*
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+ for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
+ expr * ex = *i;
+ if (m.is_eq(ex)) {
+ TRACE("str", tout << "processing assignment " << mk_ismt2_pp(ex, m) <<
+ ": expr is equality" << std::endl;);
+ app * eq = (app*)ex;
+ SASSERT(eq->get_num_args() == 2);
+ expr * lhs = eq->get_arg(0);
+ expr * rhs = eq->get_arg(1);
+
+ enode * e_lhs = ctx.get_enode(lhs);
+ enode * e_rhs = ctx.get_enode(rhs);
+ std::pair<enode*,enode*> eq_pair(e_lhs, e_rhs);
+ m_str_eq_todo.push_back(eq_pair);
+ } else {
+ TRACE("str", tout << "processing assignment " << mk_ismt2_pp(ex, m)
+ << ": expr ignored" << std::endl;);
+ }
+ }
+ */
+
+ // this might be cheating but we need to make sure that certain maps are populated
+ // before the first call to new_eq_eh()
+ propagate();
+
+ TRACE("str", tout << "search started" << std::endl;);
+ search_started = true;
+ }
+
+ void theory_str::new_eq_eh(theory_var x, theory_var y) {
+ //TRACE("str", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
+ TRACE("str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
+ mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
+
+ /*
+ if (m_find.find(x) == m_find.find(y)) {
+ return;
+ }
+ */
+ handle_equality(get_enode(x)->get_owner(), get_enode(y)->get_owner());
+
+ // replicate Z3str2 behaviour: merge eqc **AFTER** handle_equality
+ m_find.merge(x, y);
+ }
+
+ void theory_str::new_diseq_eh(theory_var x, theory_var y) {
+ //TRACE("str", tout << "new diseq: v#" << x << " != v#" << y << std::endl;);
+ TRACE("str", tout << "new diseq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
+ mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
+ }
+
+ void theory_str::relevant_eh(app * n) {
+ TRACE("str", tout << "relevant: " << mk_ismt2_pp(n, get_manager()) << std::endl;);
+ }
+
+ void theory_str::assign_eh(bool_var v, bool is_true) {
+ context & ctx = get_context();
+ TRACE("str", tout << "assert: v" << v << " #" << ctx.bool_var2expr(v)->get_id() << " is_true: " << is_true << std::endl;);
+ }
+
+ void theory_str::push_scope_eh() {
+ theory::push_scope_eh();
+ m_trail_stack.push_scope();
+
+ sLevel += 1;
+ TRACE("str", tout << "push to " << sLevel << std::endl;);
+ TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
+ }
+
+ void theory_str::recursive_check_variable_scope(expr * ex) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ if (is_app(ex)) {
+ app * a = to_app(ex);
+ if (a->get_num_args() == 0) {
+ // we only care about string variables
+ sort * s = m.get_sort(ex);
+ sort * string_sort = u.str.mk_string_sort();
+ if (s != string_sort) {
+ return;
+ }
+ // base case: string constant / var
+ if (u.str.is_string(a)) {
+ return;
+ } else {
+ // assume var
+ if (variable_set.find(ex) == variable_set.end()
+ && internal_variable_set.find(ex) == internal_variable_set.end()) {
+ TRACE("str", tout << "WARNING: possible reference to out-of-scope variable " << mk_pp(ex, m) << std::endl;);
+ }
+ }
+ } else {
+ for (unsigned i = 0; i < a->get_num_args(); ++i) {
+ recursive_check_variable_scope(a->get_arg(i));
+ }
+ }
+ }
+ }
+
+ void theory_str::check_variable_scope() {
+ if (!opt_CheckVariableScope) {
+ return;
+ }
+
+ if (!is_trace_enabled("t_str_detail")) {
+ return;
+ }
+
+ TRACE("str", tout << "checking scopes of variables in the current assignment" << std::endl;);
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+ for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
+ expr * ex = *i;
+ recursive_check_variable_scope(ex);
+ }
+ }
+
+ void theory_str::pop_scope_eh(unsigned num_scopes) {
+ sLevel -= num_scopes;
+ TRACE("str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
+
+ // list of expr* to remove from cut_var_map
+ ptr_vector<expr> cutvarmap_removes;
+
+ obj_map<expr, std::stack<T_cut *> >::iterator varItor = cut_var_map.begin();
+ while (varItor != cut_var_map.end()) {
+ expr * e = varItor->m_key;
+ std::stack<T_cut*> & val = cut_var_map[varItor->m_key];
+ while ((val.size() > 0) && (val.top()->level != 0) && (val.top()->level >= sLevel)) {
+ TRACE("str", tout << "remove cut info for " << mk_pp(e, m) << std::endl; print_cut_var(e, tout););
+ T_cut * aCut = val.top();
+ val.pop();
+ // dealloc(aCut);
+ }
+ if (val.size() == 0) {
+ cutvarmap_removes.insert(varItor->m_key);
+ }
+ varItor++;
+ }
+
+ if (!cutvarmap_removes.empty()) {
+ ptr_vector<expr>::iterator it = cutvarmap_removes.begin();
+ for (; it != cutvarmap_removes.end(); ++it) {
+ expr * ex = *it;
+ cut_var_map.remove(ex);
+ }
+ }
+
+ ptr_vector<enode> new_m_basicstr;
+ for (ptr_vector<enode>::iterator it = m_basicstr_axiom_todo.begin(); it != m_basicstr_axiom_todo.end(); ++it) {
+ enode * e = *it;
+ app * a = e->get_owner();
+ TRACE("str", tout << "consider deleting " << mk_pp(a, get_manager())
+ << ", enode scope level is " << e->get_iscope_lvl()
+ << std::endl;);
+ if (e->get_iscope_lvl() <= (unsigned)sLevel) {
+ new_m_basicstr.push_back(e);
+ }
+ }
+ m_basicstr_axiom_todo.reset();
+ m_basicstr_axiom_todo = new_m_basicstr;
+
+ m_trail_stack.pop_scope(num_scopes);
+ theory::pop_scope_eh(num_scopes);
+
+ //check_variable_scope();
+ }
+
+ void theory_str::dump_assignments() {
+ TRACE_CODE(
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ tout << "dumping all assignments:" << std::endl;
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+ for (expr_ref_vector::iterator i = assignments.begin(); i != assignments.end(); ++i) {
+ expr * ex = *i;
+ tout << mk_ismt2_pp(ex, m) << (ctx.is_relevant(ex) ? "" : " (NOT REL)") << std::endl;
+ }
+ );
+ }
+
+ void theory_str::classify_ast_by_type(expr * node, std::map<expr*, int> & varMap,
+ std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap) {
+
+ // check whether the node is a string variable;
+ // testing set membership here bypasses several expensive checks.
+ // note that internal variables don't count if they're only length tester / value tester vars.
+ if (variable_set.find(node) != variable_set.end()
+ && internal_lenTest_vars.find(node) == internal_lenTest_vars.end()
+ && internal_valTest_vars.find(node) == internal_valTest_vars.end()
+ && internal_unrollTest_vars.find(node) == internal_unrollTest_vars.end()) {
+ if (varMap[node] != 1) {
+ TRACE("str", tout << "new variable: " << mk_pp(node, get_manager()) << std::endl;);
+ }
+ varMap[node] = 1;
+ }
+ // check whether the node is a function that we want to inspect
+ else if (is_app(node)) {
+ app * aNode = to_app(node);
+ if (u.str.is_length(aNode)) {
+ // Length
+ return;
+ } else if (u.str.is_concat(aNode)) {
+ expr * arg0 = aNode->get_arg(0);
+ expr * arg1 = aNode->get_arg(1);
+ bool arg0HasEq = false;
+ bool arg1HasEq = false;
+ expr * arg0Val = get_eqc_value(arg0, arg0HasEq);
+ expr * arg1Val = get_eqc_value(arg1, arg1HasEq);
+
+ int canskip = 0;
+ zstring tmp;
+ u.str.is_string(arg0Val, tmp);
+ if (arg0HasEq && tmp.empty()) {
+ canskip = 1;
+ }
+ u.str.is_string(arg1Val, tmp);
+ if (canskip == 0 && arg1HasEq && tmp.empty()) {
+ canskip = 1;
+ }
+ if (canskip == 0 && concatMap.find(node) == concatMap.end()) {
+ concatMap[node] = 1;
+ }
+ } else if (u.re.is_unroll(aNode)) {
+ // Unroll
+ if (unrollMap.find(node) == unrollMap.end()) {
+ unrollMap[node] = 1;
+ }
+ }
+ // recursively visit all arguments
+ for (unsigned i = 0; i < aNode->get_num_args(); ++i) {
+ expr * arg = aNode->get_arg(i);
+ classify_ast_by_type(arg, varMap, concatMap, unrollMap);
+ }
+ }
+ }
+
+ // NOTE: this function used to take an argument `Z3_ast node`;
+ // it was not used and so was removed from the signature
+ void theory_str::classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
+ std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap) {
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+
+ for (expr_ref_vector::iterator it = assignments.begin(); it != assignments.end(); ++it) {
+ expr * argAst = *it;
+ // the original code jumped through some hoops to check whether the AST node
+ // is a function, then checked whether that function is "interesting".
+ // however, the only thing that's considered "interesting" is an equality predicate.
+ // so we bypass a huge amount of work by doing the following...
+
+ if (m.is_eq(argAst)) {
+ TRACE("str", tout
+ << "eq ast " << mk_pp(argAst, m) << " is between args of sort "
+ << m.get_sort(to_app(argAst)->get_arg(0))->get_name()
+ << std::endl;);
+ classify_ast_by_type(argAst, varMap, concatMap, unrollMap);
+ }
+ }
+ }
+
+ inline expr * theory_str::get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node) {
+ if (aliasIndexMap.find(node) != aliasIndexMap.end())
+ return aliasIndexMap[node];
+ else
+ return node;
+ }
+
+ inline expr * theory_str::getMostLeftNodeInConcat(expr * node) {
+ app * aNode = to_app(node);
+ if (!u.str.is_concat(aNode)) {
+ return node;
+ } else {
+ expr * concatArgL = aNode->get_arg(0);
+ return getMostLeftNodeInConcat(concatArgL);
+ }
+ }
+
+ inline expr * theory_str::getMostRightNodeInConcat(expr * node) {
+ app * aNode = to_app(node);
+ if (!u.str.is_concat(aNode)) {
+ return node;
+ } else {
+ expr * concatArgR = aNode->get_arg(1);
+ return getMostRightNodeInConcat(concatArgR);
+ }
+ }
+
+ void theory_str::trace_ctx_dep(std::ofstream & tout,
+ std::map<expr*, expr*> & aliasIndexMap,
+ std::map<expr*, expr*> & var_eq_constStr_map,
+ std::map<expr*, std::map<expr*, int> > & var_eq_concat_map,
+ std::map<expr*, std::map<expr*, int> > & var_eq_unroll_map,
+ std::map<expr*, expr*> & concat_eq_constStr_map,
+ std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map,
+ std::map<expr*, std::set<expr*> > & unrollGroupMap) {
+#ifdef _TRACE
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+ {
+ tout << "(0) alias: variables" << std::endl;
+ std::map<expr*, std::map<expr*, int> > aliasSumMap;
+ std::map<expr*, expr*>::iterator itor0 = aliasIndexMap.begin();
+ for (; itor0 != aliasIndexMap.end(); itor0++) {
+ aliasSumMap[itor0->second][itor0->first] = 1;
+ }
+ std::map<expr*, std::map<expr*, int> >::iterator keyItor = aliasSumMap.begin();
+ for (; keyItor != aliasSumMap.end(); keyItor++) {
+ tout << " * ";
+ tout << mk_pp(keyItor->first, mgr);
+ tout << " : ";
+ std::map<expr*, int>::iterator innerItor = keyItor->second.begin();
+ for (; innerItor != keyItor->second.end(); innerItor++) {
+ tout << mk_pp(innerItor->first, mgr);
+ tout << ", ";
+ }
+ tout << std::endl;
+ }
+ tout << std::endl;
+ }
+
+ {
+ tout << "(1) var = constStr:" << std::endl;
+ std::map<expr*, expr*>::iterator itor1 = var_eq_constStr_map.begin();
+ for (; itor1 != var_eq_constStr_map.end(); itor1++) {
+ tout << " * ";
+ tout << mk_pp(itor1->first, mgr);
+ tout << " = ";
+ tout << mk_pp(itor1->second, mgr);
+ if (!in_same_eqc(itor1->first, itor1->second)) {
+ tout << " (not true in ctx)";
+ }
+ tout << std::endl;
+ }
+ tout << std::endl;
+ }
+
+ {
+ tout << "(2) var = concat:" << std::endl;
+ std::map<expr*, std::map<expr*, int> >::iterator itor2 = var_eq_concat_map.begin();
+ for (; itor2 != var_eq_concat_map.end(); itor2++) {
+ tout << " * ";
+ tout << mk_pp(itor2->first, mgr);
+ tout << " = { ";
+ std::map<expr*, int>::iterator i_itor = itor2->second.begin();
+ for (; i_itor != itor2->second.end(); i_itor++) {
+ tout << mk_pp(i_itor->first, mgr);
+ tout << ", ";
+ }
+ tout << std::endl;
+ }
+ tout << std::endl;
+ }
+
+ {
+ tout << "(3) var = unrollFunc:" << std::endl;
+ std::map<expr*, std::map<expr*, int> >::iterator itor2 = var_eq_unroll_map.begin();
+ for (; itor2 != var_eq_unroll_map.end(); itor2++) {
+ tout << " * " << mk_pp(itor2->first, mgr) << " = { ";
+ std::map<expr*, int>::iterator i_itor = itor2->second.begin();
+ for (; i_itor != itor2->second.end(); i_itor++) {
+ tout << mk_pp(i_itor->first, mgr) << ", ";
+ }
+ tout << " }" << std::endl;
+ }
+ tout << std::endl;
+ }
+
+ {
+ tout << "(4) concat = constStr:" << std::endl;
+ std::map<expr*, expr*>::iterator itor3 = concat_eq_constStr_map.begin();
+ for (; itor3 != concat_eq_constStr_map.end(); itor3++) {
+ tout << " * ";
+ tout << mk_pp(itor3->first, mgr);
+ tout << " = ";
+ tout << mk_pp(itor3->second, mgr);
+ tout << std::endl;
+
+ }
+ tout << std::endl;
+ }
+
+ {
+ tout << "(5) eq concats:" << std::endl;
+ std::map<expr*, std::map<expr*, int> >::iterator itor4 = concat_eq_concat_map.begin();
+ for (; itor4 != concat_eq_concat_map.end(); itor4++) {
+ if (itor4->second.size() > 1) {
+ std::map<expr*, int>::iterator i_itor = itor4->second.begin();
+ tout << " * ";
+ for (; i_itor != itor4->second.end(); i_itor++) {
+ tout << mk_pp(i_itor->first, mgr);
+ tout << " , ";
+ }
+ tout << std::endl;
+ }
+ }
+ tout << std::endl;
+ }
+
+ {
+ tout << "(6) eq unrolls:" << std::endl;
+ std::map<expr*, std::set<expr*> >::iterator itor5 = unrollGroupMap.begin();
+ for (; itor5 != unrollGroupMap.end(); itor5++) {
+ tout << " * ";
+ std::set<expr*>::iterator i_itor = itor5->second.begin();
+ for (; i_itor != itor5->second.end(); i_itor++) {
+ tout << mk_pp(*i_itor, mgr) << ", ";
+ }
+ tout << std::endl;
+ }
+ tout << std::endl;
+ }
+
+ {
+ tout << "(7) unroll = concats:" << std::endl;
+ std::map<expr*, std::set<expr*> >::iterator itor5 = unrollGroupMap.begin();
+ for (; itor5 != unrollGroupMap.end(); itor5++) {
+ tout << " * ";
+ expr * unroll = itor5->first;
+ tout << mk_pp(unroll, mgr) << std::endl;
+ enode * e_curr = ctx.get_enode(unroll);
+ enode * e_curr_end = e_curr;
+ do {
+ app * curr = e_curr->get_owner();
+ if (u.str.is_concat(curr)) {
+ tout << " >>> " << mk_pp(curr, mgr) << std::endl;
+ }
+ e_curr = e_curr->get_next();
+ } while (e_curr != e_curr_end);
+ tout << std::endl;
+ }
+ tout << std::endl;
+ }
+#else
+ return;
+#endif // _TRACE
+ }
+
+
+ /*
+ * Dependence analysis from current context assignment
+ * - "freeVarMap" contains a set of variables that doesn't constrained by Concats.
+ * But it's possible that it's bounded by unrolls
+ * For the case of
+ * (1) var1 = unroll(r1, t1)
+ * var1 is in the freeVarMap
+ * > should unroll r1 for var1
+ * (2) var1 = unroll(r1, t1) /\ var1 = Concat(var2, var3)
+ * var2, var3 are all in freeVar
+ * > should split the unroll function so that var2 and var3 are bounded by new unrolls
+ */
+ int theory_str::ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr*, int> & freeVarMap,
+ std::map<expr*, std::set<expr*> > & unrollGroupMap, std::map<expr*, std::map<expr*, int> > & var_eq_concat_map) {
+ std::map<expr*, int> concatMap;
+ std::map<expr*, int> unrollMap;
+ std::map<expr*, expr*> aliasIndexMap;
+ std::map<expr*, expr*> var_eq_constStr_map;
+ std::map<expr*, expr*> concat_eq_constStr_map;
+ std::map<expr*, std::map<expr*, int> > var_eq_unroll_map;
+ std::map<expr*, std::map<expr*, int> > concat_eq_concat_map;
+ std::map<expr*, std::map<expr*, int> > depMap;
+
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ // note that the old API concatenated these assignments into
+ // a massive conjunction; we may have the opportunity to avoid that here
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+
+ // Step 1: get variables / concat AST appearing in the context
+ // the thing we iterate over should just be variable_set - internal_variable_set
+ // so we avoid computing the set difference (but this might be slower)
+ for(obj_hashtable<expr>::iterator it = variable_set.begin(); it != variable_set.end(); ++it) {
+ expr* var = *it;
+ if (internal_variable_set.find(var) == internal_variable_set.end()) {
+ TRACE("str", tout << "new variable: " << mk_pp(var, m) << std::endl;);
+ strVarMap[*it] = 1;
+ }
+ }
+ classify_ast_by_type_in_positive_context(strVarMap, concatMap, unrollMap);
+
+ std::map<expr*, expr*> aliasUnrollSet;
+ std::map<expr*, int>::iterator unrollItor = unrollMap.begin();
+ for (; unrollItor != unrollMap.end(); ++unrollItor) {
+ if (aliasUnrollSet.find(unrollItor->first) != aliasUnrollSet.end()) {
+ continue;
+ }
+ expr * aRoot = NULL;
+ enode * e_currEqc = ctx.get_enode(unrollItor->first);
+ enode * e_curr = e_currEqc;
+ do {
+ app * curr = e_currEqc->get_owner();
+ if (u.re.is_unroll(curr)) {
+ if (aRoot == NULL) {
+ aRoot = curr;
+ }
+ aliasUnrollSet[curr] = aRoot;
+ }
+ e_currEqc = e_currEqc->get_next();
+ } while (e_currEqc != e_curr);
+ }
+
+ for (unrollItor = unrollMap.begin(); unrollItor != unrollMap.end(); unrollItor++) {
+ expr * unrFunc = unrollItor->first;
+ expr * urKey = aliasUnrollSet[unrFunc];
+ unrollGroupMap[urKey].insert(unrFunc);
+ }
+
+ // Step 2: collect alias relation
+ // e.g. suppose we have the equivalence class {x, y, z};
+ // then we set aliasIndexMap[y] = x
+ // and aliasIndexMap[z] = x
+
+ std::map<expr*, int>::iterator varItor = strVarMap.begin();
+ for (; varItor != strVarMap.end(); ++varItor) {
+ if (aliasIndexMap.find(varItor->first) != aliasIndexMap.end()) {
+ continue;
+ }
+ expr * aRoot = NULL;
+ expr * curr = varItor->first;
+ do {
+ if (variable_set.find(curr) != variable_set.end()) {
+ if (aRoot == NULL) {
+ aRoot = curr;
+ } else {
+ aliasIndexMap[curr] = aRoot;
+ }
+ }
+ curr = get_eqc_next(curr);
+ } while (curr != varItor->first);
+ }
+
+ // Step 3: Collect interested cases
+
+ varItor = strVarMap.begin();
+ for (; varItor != strVarMap.end(); ++varItor) {
+ expr * deAliasNode = get_alias_index_ast(aliasIndexMap, varItor->first);
+ // Case 1: variable = string constant
+ // e.g. z = "str1" ::= var_eq_constStr_map[z] = "str1"
+
+ if (var_eq_constStr_map.find(deAliasNode) == var_eq_constStr_map.end()) {
+ bool nodeHasEqcValue = false;
+ expr * nodeValue = get_eqc_value(deAliasNode, nodeHasEqcValue);
+ if (nodeHasEqcValue) {
+ var_eq_constStr_map[deAliasNode] = nodeValue;
+ }
+ }
+
+ // Case 2: var_eq_concat
+ // e.g. z = concat("str1", b) ::= var_eq_concat[z][concat(c, "str2")] = 1
+ // var_eq_unroll
+ // e.g. z = unroll(...) ::= var_eq_unroll[z][unroll(...)] = 1
+
+ if (var_eq_concat_map.find(deAliasNode) == var_eq_concat_map.end()) {
+ expr * curr = get_eqc_next(deAliasNode);
+ while (curr != deAliasNode) {
+ app * aCurr = to_app(curr);
+ // collect concat
+ if (u.str.is_concat(aCurr)) {
+ expr * arg0 = aCurr->get_arg(0);
+ expr * arg1 = aCurr->get_arg(1);
+ bool arg0HasEqcValue = false;
+ bool arg1HasEqcValue = false;
+ expr * arg0_value = get_eqc_value(arg0, arg0HasEqcValue);
+ expr * arg1_value = get_eqc_value(arg1, arg1HasEqcValue);
+
+ bool is_arg0_emptyStr = false;
+ if (arg0HasEqcValue) {
+ zstring strval;
+ u.str.is_string(arg0_value, strval);
+ if (strval.empty()) {
+ is_arg0_emptyStr = true;
+ }
+ }
+
+ bool is_arg1_emptyStr = false;
+ if (arg1HasEqcValue) {
+ zstring strval;
+ u.str.is_string(arg1_value, strval);
+ if (strval.empty()) {
+ is_arg1_emptyStr = true;
+ }
+ }
+
+ if (!is_arg0_emptyStr && !is_arg1_emptyStr) {
+ var_eq_concat_map[deAliasNode][curr] = 1;
+ }
+ } else if (u.re.is_unroll(to_app(curr))) {
+ var_eq_unroll_map[deAliasNode][curr] = 1;
+ }
+
+ curr = get_eqc_next(curr);
+ }
+ }
+
+ } // for(varItor in strVarMap)
+
+ // --------------------------------------------------
+ // * collect aliasing relation among eq concats
+ // e.g EQC={concat1, concat2, concat3}
+ // concats_eq_Index_map[concat2] = concat1
+ // concats_eq_Index_map[concat3] = concat1
+ // --------------------------------------------------
+
+ std::map<expr*, expr*> concats_eq_index_map;
+ std::map<expr*, int>::iterator concatItor = concatMap.begin();
+ for(; concatItor != concatMap.end(); ++concatItor) {
+ if (concats_eq_index_map.find(concatItor->first) != concats_eq_index_map.end()) {
+ continue;
+ }
+ expr * aRoot = NULL;
+ expr * curr = concatItor->first;
+ do {
+ if (u.str.is_concat(to_app(curr))) {
+ if (aRoot == NULL) {
+ aRoot = curr;
+ } else {
+ concats_eq_index_map[curr] = aRoot;
+ }
+ }
+ curr = get_eqc_next(curr);
+ } while (curr != concatItor->first);
+ }
+
+ concatItor = concatMap.begin();
+ for(; concatItor != concatMap.end(); ++concatItor) {
+ expr * deAliasConcat = NULL;
+ if (concats_eq_index_map.find(concatItor->first) != concats_eq_index_map.end()) {
+ deAliasConcat = concats_eq_index_map[concatItor->first];
+ } else {
+ deAliasConcat = concatItor->first;
+ }
+
+ // (3) concat_eq_conststr, e.g. concat(a,b) = "str1"
+ if (concat_eq_constStr_map.find(deAliasConcat) == concat_eq_constStr_map.end()) {
+ bool nodeHasEqcValue = false;
+ expr * nodeValue = get_eqc_value(deAliasConcat, nodeHasEqcValue);
+ if (nodeHasEqcValue) {
+ concat_eq_constStr_map[deAliasConcat] = nodeValue;
+ }
+ }
+
+ // (4) concat_eq_concat, e.g.
+ // concat(a,b) = concat("str1", c) AND z = concat(a,b) AND z = concat(e,f)
+ if (concat_eq_concat_map.find(deAliasConcat) == concat_eq_concat_map.end()) {
+ expr * curr = deAliasConcat;
+ do {
+ if (u.str.is_concat(to_app(curr))) {
+ // curr cannot be reduced
+ if (concatMap.find(curr) != concatMap.end()) {
+ concat_eq_concat_map[deAliasConcat][curr] = 1;
+ }
+ }
+ curr = get_eqc_next(curr);
+ } while (curr != deAliasConcat);
+ }
+ }
+
+ // print some debugging info
+ TRACE("str", trace_ctx_dep(tout, aliasIndexMap, var_eq_constStr_map,
+ var_eq_concat_map, var_eq_unroll_map,
+ concat_eq_constStr_map, concat_eq_concat_map, unrollGroupMap););
+
+ if (!contain_pair_bool_map.empty()) {
+ compute_contains(aliasIndexMap, concats_eq_index_map, var_eq_constStr_map, concat_eq_constStr_map, var_eq_concat_map);
+ }
+
+ // step 4: dependence analysis
+
+ // (1) var = string constant
+ for (std::map<expr*, expr*>::iterator itor = var_eq_constStr_map.begin();
+ itor != var_eq_constStr_map.end(); ++itor) {
+ expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
+ expr * strAst = itor->second;
+ depMap[var][strAst] = 1;
+ }
+
+ // (2) var = concat
+ for (std::map<expr*, std::map<expr*, int> >::iterator itor = var_eq_concat_map.begin();
+ itor != var_eq_concat_map.end(); ++itor) {
+ expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
+ for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); ++itor1) {
+ expr * concat = itor1->first;
+ std::map<expr*, int> inVarMap;
+ std::map<expr*, int> inConcatMap;
+ std::map<expr*, int> inUnrollMap;
+ classify_ast_by_type(concat, inVarMap, inConcatMap, inUnrollMap);
+ for (std::map<expr*, int>::iterator itor2 = inVarMap.begin(); itor2 != inVarMap.end(); ++itor2) {
+ expr * varInConcat = get_alias_index_ast(aliasIndexMap, itor2->first);
+ if (!(depMap[var].find(varInConcat) != depMap[var].end() && depMap[var][varInConcat] == 1)) {
+ depMap[var][varInConcat] = 2;
+ }
+ }
+ }
+ }
+
+ for (std::map<expr*, std::map<expr*, int> >::iterator itor = var_eq_unroll_map.begin();
+ itor != var_eq_unroll_map.end(); itor++) {
+ expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
+ for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
+ expr * unrollFunc = itor1->first;
+ std::map<expr*, int> inVarMap;
+ std::map<expr*, int> inConcatMap;
+ std::map<expr*, int> inUnrollMap;
+ classify_ast_by_type(unrollFunc, inVarMap, inConcatMap, inUnrollMap);
+ for (std::map<expr*, int>::iterator itor2 = inVarMap.begin(); itor2 != inVarMap.end(); itor2++) {
+ expr * varInFunc = get_alias_index_ast(aliasIndexMap, itor2->first);
+
+ TRACE("str", tout << "var in unroll = " <<
+ mk_ismt2_pp(itor2->first, m) << std::endl
+ << "dealiased var = " << mk_ismt2_pp(varInFunc, m) << std::endl;);
+
+ // it's possible that we have both (Unroll $$_regVar_0 $$_unr_0) /\ (Unroll abcd $$_unr_0),
+ // while $$_regVar_0 = "abcd"
+ // have to exclude such cases
+ bool varHasValue = false;
+ get_eqc_value(varInFunc, varHasValue);
+ if (varHasValue)
+ continue;
+
+ if (depMap[var].find(varInFunc) == depMap[var].end()) {
+ depMap[var][varInFunc] = 6;
+ }
+ }
+ }
+ }
+
+ // (3) concat = string constant
+ for (std::map<expr*, expr*>::iterator itor = concat_eq_constStr_map.begin();
+ itor != concat_eq_constStr_map.end(); itor++) {
+ expr * concatAst = itor->first;
+ expr * constStr = itor->second;
+ std::map<expr*, int> inVarMap;
+ std::map<expr*, int> inConcatMap;
+ std::map<expr*, int> inUnrollMap;
+ classify_ast_by_type(concatAst, inVarMap, inConcatMap, inUnrollMap);
+ for (std::map<expr*, int>::iterator itor2 = inVarMap.begin(); itor2 != inVarMap.end(); itor2++) {
+ expr * varInConcat = get_alias_index_ast(aliasIndexMap, itor2->first);
+ if (!(depMap[varInConcat].find(constStr) != depMap[varInConcat].end() && depMap[varInConcat][constStr] == 1))
+ depMap[varInConcat][constStr] = 3;
+ }
+ }
+
+ // (4) equivalent concats
+ // - possibility 1 : concat("str", v1) = concat(concat(v2, v3), v4) = concat(v5, v6)
+ // ==> v2, v5 are constrained by "str"
+ // - possibility 2 : concat(v1, "str") = concat(v2, v3) = concat(v4, v5)
+ // ==> v2, v4 are constrained by "str"
+ //--------------------------------------------------------------
+
+ std::map<expr*, expr*> mostLeftNodes;
+ std::map<expr*, expr*> mostRightNodes;
+
+ std::map<expr*, int> mLIdxMap;
+ std::map<int, std::set<expr*> > mLMap;
+ std::map<expr*, int> mRIdxMap;
+ std::map<int, std::set<expr*> > mRMap;
+ std::set<expr*> nSet;
+
+ for (std::map<expr*, std::map<expr*, int> >::iterator itor = concat_eq_concat_map.begin();
+ itor != concat_eq_concat_map.end(); itor++) {
+ mostLeftNodes.clear();
+ mostRightNodes.clear();
+
+ expr * mLConst = NULL;
+ expr * mRConst = NULL;
+
+ for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
+ expr * concatNode = itor1->first;
+ expr * mLNode = getMostLeftNodeInConcat(concatNode);
+ zstring strval;
+ if (u.str.is_string(to_app(mLNode), strval)) {
+ if (mLConst == NULL && strval.empty()) {
+ mLConst = mLNode;
+ }
+ } else {
+ mostLeftNodes[mLNode] = concatNode;
+ }
+
+ expr * mRNode = getMostRightNodeInConcat(concatNode);
+ if (u.str.is_string(to_app(mRNode), strval)) {
+ if (mRConst == NULL && strval.empty()) {
+ mRConst = mRNode;
+ }
+ } else {
+ mostRightNodes[mRNode] = concatNode;
+ }
+ }
+
+ if (mLConst != NULL) {
+ // -------------------------------------------------------------------------------------
+ // The left most variable in a concat is constrained by a constant string in eqc concat
+ // -------------------------------------------------------------------------------------
+ // e.g. Concat(x, ...) = Concat("abc", ...)
+ // -------------------------------------------------------------------------------------
+ for (std::map<expr*, expr*>::iterator itor1 = mostLeftNodes.begin();
+ itor1 != mostLeftNodes.end(); itor1++) {
+ expr * deVar = get_alias_index_ast(aliasIndexMap, itor1->first);
+ if (depMap[deVar].find(mLConst) == depMap[deVar].end() || depMap[deVar][mLConst] != 1) {
+ depMap[deVar][mLConst] = 4;
+ }
+ }
+ }
+
+ {
+ // -------------------------------------------------------------------------------------
+ // The left most variables in eqc concats are constrained by each other
+ // -------------------------------------------------------------------------------------
+ // e.g. concat(x, ...) = concat(u, ...) = ...
+ // x and u are constrained by each other
+ // -------------------------------------------------------------------------------------
+ nSet.clear();
+ std::map<expr*, expr*>::iterator itl = mostLeftNodes.begin();
+ for (; itl != mostLeftNodes.end(); itl++) {
+ bool lfHasEqcValue = false;
+ get_eqc_value(itl->first, lfHasEqcValue);
+ if (lfHasEqcValue)
+ continue;
+ expr * deVar = get_alias_index_ast(aliasIndexMap, itl->first);
+ nSet.insert(deVar);
+ }
+
+ if (nSet.size() > 1) {
+ int lId = -1;
+ for (std::set<expr*>::iterator itor2 = nSet.begin(); itor2 != nSet.end(); itor2++) {
+ if (mLIdxMap.find(*itor2) != mLIdxMap.end()) {
+ lId = mLIdxMap[*itor2];
break;
}
}
- } // !indicatorHasEqcValue
- } // for (i : [0..lenTesterCount-1])
- if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "") {
- TRACE("str", tout << "length is not fixed; generating length tester options for free var" << std::endl;);
- expr_ref indicator(m);
- unsigned int testNum = 0;
-
- TRACE("str", tout << "effectiveLenIndiStr = " << effectiveLenIndiStr
- << ", i = " << i << ", lenTesterCount = " << lenTesterCount << "\n";);
-
- if (i == lenTesterCount) {
- fvar_len_count_map[freeVar] = fvar_len_count_map[freeVar] + 1;
- testNum = fvar_len_count_map[freeVar];
- indicator = mk_internal_lenTest_var(freeVar, testNum);
- fvar_lenTester_map[freeVar].push_back(indicator);
- lenTester_fvar_map.insert(indicator, freeVar);
- } else {
- indicator = fvar_lenTester_map[freeVar][i];
- refresh_theory_var(indicator);
- testNum = i + 1;
+ if (lId == -1)
+ lId = mLMap.size();
+ for (std::set<expr*>::iterator itor2 = nSet.begin(); itor2 != nSet.end(); itor2++) {
+ bool itorHasEqcValue = false;
+ get_eqc_value(*itor2, itorHasEqcValue);
+ if (itorHasEqcValue)
+ continue;
+ mLIdxMap[*itor2] = lId;
+ mLMap[lId].insert(*itor2);
+ }
}
+ }
+
+ if (mRConst != NULL) {
+ for (std::map<expr*, expr*>::iterator itor1 = mostRightNodes.begin();
+ itor1 != mostRightNodes.end(); itor1++) {
+ expr * deVar = get_alias_index_ast(aliasIndexMap, itor1->first);
+ if (depMap[deVar].find(mRConst) == depMap[deVar].end() || depMap[deVar][mRConst] != 1) {
+ depMap[deVar][mRConst] = 5;
+ }
+ }
+ }
+
+ {
+ nSet.clear();
+ std::map<expr*, expr*>::iterator itr = mostRightNodes.begin();
+ for (; itr != mostRightNodes.end(); itr++) {
+ expr * deVar = get_alias_index_ast(aliasIndexMap, itr->first);
+ nSet.insert(deVar);
+ }
+ if (nSet.size() > 1) {
+ int rId = -1;
+ std::set<expr*>::iterator itor2 = nSet.begin();
+ for (; itor2 != nSet.end(); itor2++) {
+ if (mRIdxMap.find(*itor2) != mRIdxMap.end()) {
+ rId = mRIdxMap[*itor2];
+ break;
+ }
+ }
+ if (rId == -1)
+ rId = mRMap.size();
+ for (itor2 = nSet.begin(); itor2 != nSet.end(); itor2++) {
+ bool rHasEqcValue = false;
+ get_eqc_value(*itor2, rHasEqcValue);
+ if (rHasEqcValue)
+ continue;
+ mRIdxMap[*itor2] = rId;
+ mRMap[rId].insert(*itor2);
+ }
+ }
+ }
+ }
+
+ // print the dependence map
+ TRACE("str",
+ tout << "Dependence Map" << std::endl;
+ for(std::map<expr*, std::map<expr*, int> >::iterator itor = depMap.begin(); itor != depMap.end(); itor++) {
+ tout << mk_pp(itor->first, m);
+ rational nnLen;
+ bool nnLen_exists = get_len_value(itor->first, nnLen);
+ tout << " [len = " << (nnLen_exists ? nnLen.to_string() : "?") << "] \t-->\t";
+ for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
+ tout << mk_pp(itor1->first, m) << "(" << itor1->second << "), ";
+ }
+ tout << std::endl;
+ }
+ );
+
+ // step, errr, 5: compute free variables based on the dependence map
+
+ // the case dependence map is empty, every var in VarMap is free
+ //---------------------------------------------------------------
+ // remove L/R most var in eq concat since they are constrained with each other
+ std::map<expr*, std::map<expr*, int> > lrConstrainedMap;
+ for (std::map<int, std::set<expr*> >::iterator itor = mLMap.begin(); itor != mLMap.end(); itor++) {
+ for (std::set<expr*>::iterator it1 = itor->second.begin(); it1 != itor->second.end(); it1++) {
+ std::set<expr*>::iterator it2 = it1;
+ it2++;
+ for (; it2 != itor->second.end(); it2++) {
+ expr * n1 = *it1;
+ expr * n2 = *it2;
+ lrConstrainedMap[n1][n2] = 1;
+ lrConstrainedMap[n2][n1] = 1;
+ }
+ }
+ }
+ for (std::map<int, std::set<expr*> >::iterator itor = mRMap.begin(); itor != mRMap.end(); itor++) {
+ for (std::set<expr*>::iterator it1 = itor->second.begin(); it1 != itor->second.end(); it1++) {
+ std::set<expr*>::iterator it2 = it1;
+ it2++;
+ for (; it2 != itor->second.end(); it2++) {
+ expr * n1 = *it1;
+ expr * n2 = *it2;
+ lrConstrainedMap[n1][n2] = 1;
+ lrConstrainedMap[n2][n1] = 1;
+ }
+ }
+ }
+
+ if (depMap.size() == 0) {
+ std::map<expr*, int>::iterator itor = strVarMap.begin();
+ for (; itor != strVarMap.end(); itor++) {
+ expr * var = get_alias_index_ast(aliasIndexMap, itor->first);
+ if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
+ freeVarMap[var] = 1;
+ } else {
+ int lrConstainted = 0;
+ std::map<expr*, int>::iterator lrit = freeVarMap.begin();
+ for (; lrit != freeVarMap.end(); lrit++) {
+ if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
+ lrConstainted = 1;
+ break;
+ }
+ }
+ if (lrConstainted == 0) {
+ freeVarMap[var] = 1;
+ }
+ }
+ }
+ } else {
+ // if the keys in aliasIndexMap are not contained in keys in depMap, they are free
+ // e.g., x= y /\ x = z /\ t = "abc"
+ // aliasIndexMap[y]= x, aliasIndexMap[z] = x
+ // depMap t ~ "abc"(1)
+ // x should be free
+ std::map<expr*, int>::iterator itor2 = strVarMap.begin();
+ for (; itor2 != strVarMap.end(); itor2++) {
+ if (aliasIndexMap.find(itor2->first) != aliasIndexMap.end()) {
+ expr * var = aliasIndexMap[itor2->first];
+ if (depMap.find(var) == depMap.end()) {
+ if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
+ freeVarMap[var] = 1;
+ } else {
+ int lrConstainted = 0;
+ std::map<expr*, int>::iterator lrit = freeVarMap.begin();
+ for (; lrit != freeVarMap.end(); lrit++) {
+ if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
+ lrConstainted = 1;
+ break;
+ }
+ }
+ if (lrConstainted == 0) {
+ freeVarMap[var] = 1;
+ }
+ }
+ }
+ } else if (aliasIndexMap.find(itor2->first) == aliasIndexMap.end()) {
+ // if a variable is not in aliasIndexMap and not in depMap, it's free
+ if (depMap.find(itor2->first) == depMap.end()) {
+ expr * var = itor2->first;
+ if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
+ freeVarMap[var] = 1;
+ } else {
+ int lrConstainted = 0;
+ std::map<expr*, int>::iterator lrit = freeVarMap.begin();
+ for (; lrit != freeVarMap.end(); lrit++) {
+ if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
+ lrConstainted = 1;
+ break;
+ }
+ }
+ if (lrConstainted == 0) {
+ freeVarMap[var] = 1;
+ }
+ }
+ }
+ }
+ }
+
+ std::map<expr*, std::map<expr*, int> >::iterator itor = depMap.begin();
+ for (; itor != depMap.end(); itor++) {
+ for (std::map<expr*, int>::iterator itor1 = itor->second.begin(); itor1 != itor->second.end(); itor1++) {
+ if (variable_set.find(itor1->first) != variable_set.end()) { // expr type = var
+ expr * var = get_alias_index_ast(aliasIndexMap, itor1->first);
+ // if a var is dep on itself and all dependence are type 2, it's a free variable
+ // e.g {y --> x(2), y(2), m --> m(2), n(2)} y,m are free
+ {
+ if (depMap.find(var) == depMap.end()) {
+ if (freeVarMap.find(var) == freeVarMap.end()) {
+ if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) {
+ freeVarMap[var] = 1;
+ } else {
+ int lrConstainted = 0;
+ std::map<expr*, int>::iterator lrit = freeVarMap.begin();
+ for (; lrit != freeVarMap.end(); lrit++) {
+ if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) {
+ lrConstainted = 1;
+ break;
+ }
+ }
+ if (lrConstainted == 0) {
+ freeVarMap[var] = 1;
+ }
+ }
+
+ } else {
+ freeVarMap[var] = freeVarMap[var] + 1;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return 0;
+ }
+
+ // Check agreement between integer and string theories for the term a = (str.to-int S).
+ // Returns true if axioms were added, and false otherwise.
+ bool theory_str::finalcheck_str2int(app * a) {
+ bool axiomAdd = false;
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr * S = a->get_arg(0);
+
+ // check integer theory
+ rational Ival;
+ bool Ival_exists = get_value(a, Ival);
+ if (Ival_exists) {
+ TRACE("str", tout << "integer theory assigns " << mk_pp(a, m) << " = " << Ival.to_string() << std::endl;);
+ // if that value is not -1, we can assert (str.to-int S) = Ival --> S = "Ival"
+ if (!Ival.is_minus_one()) {
+ zstring Ival_str(Ival.to_string().c_str());
+ expr_ref premise(ctx.mk_eq_atom(a, m_autil.mk_numeral(Ival, true)), m);
+ expr_ref conclusion(ctx.mk_eq_atom(S, mk_string(Ival_str)), m);
+ expr_ref axiom(rewrite_implication(premise, conclusion), m);
+ if (!string_int_axioms.contains(axiom)) {
+ string_int_axioms.insert(axiom);
+ assert_axiom(axiom);
+ m_trail_stack.push(insert_obj_trail<theory_str, expr>(string_int_axioms, axiom));
+ axiomAdd = true;
+ }
+ }
+ } else {
+ TRACE("str", tout << "integer theory has no assignment for " << mk_pp(a, m) << std::endl;);
+ NOT_IMPLEMENTED_YET();
+ }
+
+ return axiomAdd;
+ }
+
+ bool theory_str::finalcheck_int2str(app * a) {
+ bool axiomAdd = false;
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr * N = a->get_arg(0);
+
+ // check string theory
+ bool Sval_expr_exists;
+ expr * Sval_expr = get_eqc_value(a, Sval_expr_exists);
+ if (Sval_expr_exists) {
+ zstring Sval;
+ u.str.is_string(Sval_expr, Sval);
+ TRACE("str", tout << "string theory assigns \"" << mk_pp(a, m) << " = " << Sval << "\n";);
+ // empty string --> integer value < 0
+ if (Sval.empty()) {
+ // ignore this. we should already assert the axiom for what happens when the string is ""
+ } else {
+ // nonempty string --> convert to correct integer value, or disallow it
+ rational convertedRepresentation(0);
+ rational ten(10);
+ bool conversionOK = true;
+ for (unsigned i = 0; i < Sval.length(); ++i) {
+ char digit = (int)Sval[i];
+ if (isdigit((int)digit)) {
+ std::string sDigit(1, digit);
+ int val = atoi(sDigit.c_str());
+ convertedRepresentation = (ten * convertedRepresentation) + rational(val);
+ } else {
+ // not a digit, invalid
+ TRACE("str", tout << "str.to-int argument contains non-digit character '" << digit << "'" << std::endl;);
+ conversionOK = false;
+ break;
+ }
+ }
+ if (conversionOK) {
+ expr_ref premise(ctx.mk_eq_atom(a, mk_string(Sval)), m);
+ expr_ref conclusion(ctx.mk_eq_atom(N, m_autil.mk_numeral(convertedRepresentation, true)), m);
+ expr_ref axiom(rewrite_implication(premise, conclusion), m);
+ if (!string_int_axioms.contains(axiom)) {
+ string_int_axioms.insert(axiom);
+ assert_axiom(axiom);
+ m_trail_stack.push(insert_obj_trail<theory_str, expr>(string_int_axioms, axiom));
+ axiomAdd = true;
+ }
+ } else {
+ expr_ref axiom(m.mk_not(ctx.mk_eq_atom(a, mk_string(Sval))), m);
+ // always assert this axiom because this is a conflict clause
+ assert_axiom(axiom);
+ axiomAdd = true;
+ }
+ }
+ } else {
+ TRACE("str", tout << "string theory has no assignment for " << mk_pp(a, m) << std::endl;);
+ NOT_IMPLEMENTED_YET();
+ }
+ return axiomAdd;
+ }
+
+ void theory_str::collect_var_concat(expr * node, std::set<expr*> & varSet, std::set<expr*> & concatSet) {
+ if (variable_set.find(node) != variable_set.end()) {
+ if (internal_lenTest_vars.find(node) == internal_lenTest_vars.end()) {
+ varSet.insert(node);
+ }
+ }
+ else if (is_app(node)) {
+ app * aNode = to_app(node);
+ if (u.str.is_length(aNode)) {
+ // Length
+ return;
+ }
+ if (u.str.is_concat(aNode)) {
+ expr * arg0 = aNode->get_arg(0);
+ expr * arg1 = aNode->get_arg(1);
+ if (concatSet.find(node) == concatSet.end()) {
+ concatSet.insert(node);
+ }
+ }
+ // recursively visit all arguments
+ for (unsigned i = 0; i < aNode->get_num_args(); ++i) {
+ expr * arg = aNode->get_arg(i);
+ collect_var_concat(arg, varSet, concatSet);
+ }
+ }
+ }
+
+ bool theory_str::propagate_length_within_eqc(expr * var) {
+ bool res = false;
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ TRACE("str", tout << "propagate_length_within_eqc: " << mk_ismt2_pp(var, m) << std::endl ;);
+
+ enode * n_eq_enode = ctx.get_enode(var);
+ rational varLen;
+ if (! get_len_value(var, varLen)) {
+ bool hasLen = false;
+ expr * nodeWithLen= var;
+ do {
+ if (get_len_value(nodeWithLen, varLen)) {
+ hasLen = true;
+ break;
+ }
+ nodeWithLen = get_eqc_next(nodeWithLen);
+ } while (nodeWithLen != var);
+
+ if (hasLen) {
+ // var = nodeWithLen --> |var| = |nodeWithLen|
+ expr_ref_vector l_items(m);
+ expr_ref varEqNode(ctx.mk_eq_atom(var, nodeWithLen), m);
+ l_items.push_back(varEqNode);
+
+ expr_ref nodeWithLenExpr (mk_strlen(nodeWithLen), m);
+ expr_ref varLenExpr (mk_int(varLen), m);
+ expr_ref lenEqNum(ctx.mk_eq_atom(nodeWithLenExpr, varLenExpr), m);
+ l_items.push_back(lenEqNum);
+
+ expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
+ expr_ref varLen(mk_strlen(var), m);
+ expr_ref axr(ctx.mk_eq_atom(varLen, mk_int(varLen)), m);
+ assert_implication(axl, axr);
+ TRACE("str", tout << mk_ismt2_pp(axl, m) << std::endl << " ---> " << std::endl << mk_ismt2_pp(axr, m););
+ res = true;
+ }
+ }
+ return res;
+ }
+
+ bool theory_str::propagate_length(std::set<expr*> & varSet, std::set<expr*> & concatSet, std::map<expr*, int> & exprLenMap) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+ bool axiomAdded = false;
+ // collect all concats in context
+ for (expr_ref_vector::iterator it = assignments.begin(); it != assignments.end(); ++it) {
+ if (! ctx.is_relevant(*it)) {
+ continue;
+ }
+ if (m.is_eq(*it)) {
+ collect_var_concat(*it, varSet, concatSet);
+ }
+ }
+ // iterate each concat
+ // if a concat doesn't have length info, check if the length of all leaf nodes can be resolved
+ for (std::set<expr*>::iterator it = concatSet.begin(); it != concatSet.end(); it++) {
+ expr * concat = *it;
+ rational lenValue;
+ expr_ref concatlenExpr (mk_strlen(concat), m) ;
+ bool allLeafResolved = true;
+ if (! get_value(concatlenExpr, lenValue)) {
+ // the length fo concat is unresolved yet
+ if (get_len_value(concat, lenValue)) {
+ // but all leaf nodes have length information
+ TRACE("str", tout << "* length pop-up: " << mk_ismt2_pp(concat, m) << "| = " << lenValue << std::endl;);
+ std::set<expr*> leafNodes;
+ get_unique_non_concat_nodes(concat, leafNodes);
+ expr_ref_vector l_items(m);
+ for (std::set<expr*>::iterator leafIt = leafNodes.begin(); leafIt != leafNodes.end(); ++leafIt) {
+ rational leafLenValue;
+ if (get_len_value(*leafIt, leafLenValue)) {
+ expr_ref leafItLenExpr (mk_strlen(*leafIt), m);
+ expr_ref leafLenValueExpr (mk_int(leafLenValue), m);
+ expr_ref lcExpr (ctx.mk_eq_atom(leafItLenExpr, leafLenValueExpr), m);
+ l_items.push_back(lcExpr);
+ } else {
+ allLeafResolved = false;
+ break;
+ }
+ }
+ if (allLeafResolved) {
+ expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
+ expr_ref lenValueExpr (mk_int(lenValue), m);
+ expr_ref axr(ctx.mk_eq_atom(concatlenExpr, lenValueExpr), m);
+ assert_implication(axl, axr);
+ TRACE("str", tout << mk_ismt2_pp(axl, m) << std::endl << " ---> " << std::endl << mk_ismt2_pp(axr, m)<< std::endl;);
+ axiomAdded = true;
+ }
+ }
+ }
+ }
+ // if no concat length is propagated, check the length of variables.
+ if (! axiomAdded) {
+ for (std::set<expr*>::iterator it = varSet.begin(); it != varSet.end(); it++) {
+ expr * var = *it;
+ rational lenValue;
+ expr_ref varlen (mk_strlen(var), m) ;
+ bool allLeafResolved = true;
+ if (! get_value(varlen, lenValue)) {
+ if (propagate_length_within_eqc(var)) {
+ axiomAdded = true;
+ }
+ }
+ }
+
+ }
+ return axiomAdded;
+ }
+
+ void theory_str::get_unique_non_concat_nodes(expr * node, std::set<expr*> & argSet) {
+ app * a_node = to_app(node);
+ if (!u.str.is_concat(a_node)) {
+ argSet.insert(node);
+ return;
+ } else {
+ SASSERT(a_node->get_num_args() == 2);
+ expr * leftArg = a_node->get_arg(0);
+ expr * rightArg = a_node->get_arg(1);
+ get_unique_non_concat_nodes(leftArg, argSet);
+ get_unique_non_concat_nodes(rightArg, argSet);
+ }
+ }
+
+ final_check_status theory_str::final_check_eh() {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+
+ expr_ref_vector assignments(m);
+ ctx.get_assignments(assignments);
+
+ if (opt_VerifyFinalCheckProgress) {
+ finalCheckProgressIndicator = false;
+ }
+
+ TRACE("str", tout << "final check" << std::endl;);
+ TRACE_CODE(if (is_trace_enabled("t_str_dump_assign")) { dump_assignments(); });
+ check_variable_scope();
+
+ if (opt_DeferEQCConsistencyCheck) {
+ TRACE("str", tout << "performing deferred EQC consistency check" << std::endl;);
+ std::set<enode*> eqc_roots;
+ for (ptr_vector<enode>::const_iterator it = ctx.begin_enodes(); it != ctx.end_enodes(); ++it) {
+ enode * e = *it;
+ enode * root = e->get_root();
+ eqc_roots.insert(root);
+ }
+
+ bool found_inconsistency = false;
+
+ for (std::set<enode*>::iterator it = eqc_roots.begin(); it != eqc_roots.end(); ++it) {
+ enode * e = *it;
+ app * a = e->get_owner();
+ if (!(m.get_sort(a) == u.str.mk_string_sort())) {
+ TRACE("str", tout << "EQC root " << mk_pp(a, m) << " not a string term; skipping" << std::endl;);
+ } else {
+ TRACE("str", tout << "EQC root " << mk_pp(a, m) << " is a string term. Checking this EQC" << std::endl;);
+ // first call check_concat_len_in_eqc() on each member of the eqc
+ enode * e_it = e;
+ enode * e_root = e_it;
+ do {
+ bool status = check_concat_len_in_eqc(e_it->get_owner());
+ if (!status) {
+ TRACE("str", tout << "concat-len check asserted an axiom on " << mk_pp(e_it->get_owner(), m) << std::endl;);
+ found_inconsistency = true;
+ }
+ e_it = e_it->get_next();
+ } while (e_it != e_root);
+
+ // now grab any two distinct elements from the EQC and call new_eq_check() on them
+ enode * e1 = e;
+ enode * e2 = e1->get_next();
+ if (e1 != e2) {
+ TRACE("str", tout << "deferred new_eq_check() over EQC of " << mk_pp(e1->get_owner(), m) << " and " << mk_pp(e2->get_owner(), m) << std::endl;);
+ bool result = new_eq_check(e1->get_owner(), e2->get_owner());
+ if (!result) {
+ TRACE("str", tout << "new_eq_check found inconsistencies" << std::endl;);
+ found_inconsistency = true;
+ }
+ }
+ }
+ }
+
+ if (found_inconsistency) {
+ TRACE("str", tout << "Found inconsistency in final check! Returning to search." << std::endl;);
+ return FC_CONTINUE;
+ } else {
+ TRACE("str", tout << "Deferred consistency check passed. Continuing in final check." << std::endl;);
+ }
+ }
+
+ // run dependence analysis to find free string variables
+ std::map<expr*, int> varAppearInAssign;
+ std::map<expr*, int> freeVar_map;
+ std::map<expr*, std::set<expr*> > unrollGroup_map;
+ std::map<expr*, std::map<expr*, int> > var_eq_concat_map;
+ int conflictInDep = ctx_dep_analysis(varAppearInAssign, freeVar_map, unrollGroup_map, var_eq_concat_map);
+ if (conflictInDep == -1) {
+ // return Z3_TRUE;
+ return FC_DONE;
+ }
+
+ // enhancement: improved backpropagation of string constants into var=concat terms
+ bool backpropagation_occurred = false;
+ for (std::map<expr*, std::map<expr*, int> >::iterator veqc_map_it = var_eq_concat_map.begin();
+ veqc_map_it != var_eq_concat_map.end(); ++veqc_map_it) {
+ expr * var = veqc_map_it->first;
+ for (std::map<expr*, int>::iterator concat_map_it = veqc_map_it->second.begin();
+ concat_map_it != veqc_map_it->second.end(); ++concat_map_it) {
+ app * concat = to_app(concat_map_it->first);
+ expr * concat_lhs = concat->get_arg(0);
+ expr * concat_rhs = concat->get_arg(1);
+ // If the concat LHS and RHS both have a string constant in their EQC,
+ // but the var does not, then we assert an axiom of the form
+ // (lhs = "lhs" AND rhs = "rhs") --> (Concat lhs rhs) = "lhsrhs"
+ bool concat_lhs_haseqc, concat_rhs_haseqc, var_haseqc;
+ expr * concat_lhs_str = get_eqc_value(concat_lhs, concat_lhs_haseqc);
+ expr * concat_rhs_str = get_eqc_value(concat_rhs, concat_rhs_haseqc);
+ expr * var_str = get_eqc_value(var, var_haseqc);
+ if (concat_lhs_haseqc && concat_rhs_haseqc && !var_haseqc) {
+ TRACE("str", tout << "backpropagate into " << mk_pp(var, m) << " = " << mk_pp(concat, m) << std::endl
+ << "LHS ~= " << mk_pp(concat_lhs_str, m) << " RHS ~= " << mk_pp(concat_rhs_str, m) << std::endl;);
+ zstring lhsString, rhsString;
+ u.str.is_string(concat_lhs_str, lhsString);
+ u.str.is_string(concat_rhs_str, rhsString);
+ zstring concatString = lhsString + rhsString;
+ expr_ref lhs1(ctx.mk_eq_atom(concat_lhs, concat_lhs_str), m);
+ expr_ref lhs2(ctx.mk_eq_atom(concat_rhs, concat_rhs_str), m);
+ expr_ref lhs(m.mk_and(lhs1, lhs2), m);
+ expr_ref rhs(ctx.mk_eq_atom(concat, mk_string(concatString)), m);
+ assert_implication(lhs, rhs);
+ backpropagation_occurred = true;
+ }
+ }
+ }
+
+ if (backpropagation_occurred) {
+ TRACE("str", tout << "Resuming search due to axioms added by backpropagation." << std::endl;);
+ return FC_CONTINUE;
+ }
+
+ // enhancement: improved backpropagation of length information
+ {
+ std::set<expr*> varSet;
+ std::set<expr*> concatSet;
+ std::map<expr*, int> exprLenMap;
+
+ bool length_propagation_occurred = propagate_length(varSet, concatSet, exprLenMap);
+ if (length_propagation_occurred) {
+ TRACE("str", tout << "Resuming search due to axioms added by length propagation." << std::endl;);
+ return FC_CONTINUE;
+ }
+ }
+
+ bool needToAssignFreeVars = false;
+ std::set<expr*> free_variables;
+ std::set<expr*> unused_internal_variables;
+ { // Z3str2 free variables check
+ std::map<expr*, int>::iterator itor = varAppearInAssign.begin();
+ for (; itor != varAppearInAssign.end(); ++itor) {
+ /*
+ std::string vName = std::string(Z3_ast_to_string(ctx, itor->first));
+ if (vName.length() >= 3 && vName.substr(0, 3) == "$$_")
+ continue;
+ */
+ if (internal_variable_set.find(itor->first) != internal_variable_set.end()
+ || regex_variable_set.find(itor->first) != regex_variable_set.end()) {
+ // this can be ignored, I think
+ TRACE("str", tout << "free internal variable " << mk_pp(itor->first, m) << " ignored" << std::endl;);
+ continue;
+ }
+ bool hasEqcValue = false;
+ expr * eqcString = get_eqc_value(itor->first, hasEqcValue);
+ if (!hasEqcValue) {
+ TRACE("str", tout << "found free variable " << mk_pp(itor->first, m) << std::endl;);
+ needToAssignFreeVars = true;
+ free_variables.insert(itor->first);
+ // break;
+ } else {
+ // debug
+ TRACE("str", tout << "variable " << mk_pp(itor->first, m) << " = " << mk_pp(eqcString, m) << std::endl;);
+ }
+ }
+ }
+
+ if (!needToAssignFreeVars) {
+
+ // check string-int terms
+ bool addedStrIntAxioms = false;
+ for (unsigned i = 0; i < string_int_conversion_terms.size(); ++i) {
+ app * ex = to_app(string_int_conversion_terms[i].get());
+ if (u.str.is_stoi(ex)) {
+ bool axiomAdd = finalcheck_str2int(ex);
+ if (axiomAdd) {
+ addedStrIntAxioms = true;
+ }
+ } else if (u.str.is_itos(ex)) {
+ bool axiomAdd = finalcheck_int2str(ex);
+ if (axiomAdd) {
+ addedStrIntAxioms = true;
+ }
+ } else {
+ UNREACHABLE();
+ }
+ }
+ if (addedStrIntAxioms) {
+ TRACE("str", tout << "Resuming search due to addition of string-integer conversion axioms." << std::endl;);
+ return FC_CONTINUE;
+ }
+
+ if (unused_internal_variables.empty()) {
+ TRACE("str", tout << "All variables are assigned. Done!" << std::endl;);
+ return FC_DONE;
+ } else {
+ TRACE("str", tout << "Assigning decoy values to free internal variables." << std::endl;);
+ for (std::set<expr*>::iterator it = unused_internal_variables.begin(); it != unused_internal_variables.end(); ++it) {
+ expr * var = *it;
+ expr_ref assignment(m.mk_eq(var, mk_string("**unused**")), m);
+ assert_axiom(assignment);
+ }
+ return FC_CONTINUE;
+ }
+ }
+
+ CTRACE("str", needToAssignFreeVars,
+ tout << "Need to assign values to the following free variables:" << std::endl;
+ for (std::set<expr*>::iterator itx = free_variables.begin(); itx != free_variables.end(); ++itx) {
+ tout << mk_ismt2_pp(*itx, m) << std::endl;
+ }
+ tout << "freeVar_map has the following entries:" << std::endl;
+ for (std::map<expr*, int>::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) {
+ expr * var = fvIt->first;
+ tout << mk_ismt2_pp(var, m) << std::endl;
+ }
+ );
+
+ // -----------------------------------------------------------
+ // variables in freeVar are those not bounded by Concats
+ // classify variables in freeVarMap:
+ // (1) freeVar = unroll(r1, t1)
+ // (2) vars are not bounded by either concat or unroll
+ // -----------------------------------------------------------
+ std::map<expr*, std::set<expr*> > fv_unrolls_map;
+ std::set<expr*> tmpSet;
+ expr * constValue = NULL;
+ for (std::map<expr*, int>::iterator fvIt2 = freeVar_map.begin(); fvIt2 != freeVar_map.end(); fvIt2++) {
+ expr * var = fvIt2->first;
+ tmpSet.clear();
+ get_eqc_allUnroll(var, constValue, tmpSet);
+ if (tmpSet.size() > 0) {
+ fv_unrolls_map[var] = tmpSet;
+ }
+ }
+ // erase var bounded by an unroll function from freeVar_map
+ for (std::map<expr*, std::set<expr*> >::iterator fvIt3 = fv_unrolls_map.begin();
+ fvIt3 != fv_unrolls_map.end(); fvIt3++) {
+ expr * var = fvIt3->first;
+ TRACE("str", tout << "erase free variable " << mk_pp(var, m) << " from freeVar_map, it is bounded by an Unroll" << std::endl;);
+ freeVar_map.erase(var);
+ }
+
+ // collect the case:
+ // * Concat(X, Y) = unroll(r1, t1) /\ Concat(X, Y) = unroll(r2, t2)
+ // concatEqUnrollsMap[Concat(X, Y)] = {unroll(r1, t1), unroll(r2, t2)}
+
+ std::map<expr*, std::set<expr*> > concatEqUnrollsMap;
+ for (std::map<expr*, std::set<expr*> >::iterator urItor = unrollGroup_map.begin();
+ urItor != unrollGroup_map.end(); urItor++) {
+ expr * unroll = urItor->first;
+ expr * curr = unroll;
+ do {
+ if (u.str.is_concat(to_app(curr))) {
+ concatEqUnrollsMap[curr].insert(unroll);
+ concatEqUnrollsMap[curr].insert(unrollGroup_map[unroll].begin(), unrollGroup_map[unroll].end());
+ }
+ enode * e_curr = ctx.get_enode(curr);
+ curr = e_curr->get_next()->get_owner();
+ // curr = get_eqc_next(curr);
+ } while (curr != unroll);
+ }
+
+ std::map<expr*, std::set<expr*> > concatFreeArgsEqUnrollsMap;
+ std::set<expr*> fvUnrollSet;
+ for (std::map<expr*, std::set<expr*> >::iterator concatItor = concatEqUnrollsMap.begin();
+ concatItor != concatEqUnrollsMap.end(); concatItor++) {
+ expr * concat = concatItor->first;
+ expr * concatArg1 = to_app(concat)->get_arg(0);
+ expr * concatArg2 = to_app(concat)->get_arg(1);
+ bool arg1Bounded = false;
+ bool arg2Bounded = false;
+ // arg1
+ if (variable_set.find(concatArg1) != variable_set.end()) {
+ if (freeVar_map.find(concatArg1) == freeVar_map.end()) {
+ arg1Bounded = true;
+ } else {
+ fvUnrollSet.insert(concatArg1);
+ }
+ } else if (u.str.is_concat(to_app(concatArg1))) {
+ if (concatEqUnrollsMap.find(concatArg1) == concatEqUnrollsMap.end()) {
+ arg1Bounded = true;
+ }
+ }
+ // arg2
+ if (variable_set.find(concatArg2) != variable_set.end()) {
+ if (freeVar_map.find(concatArg2) == freeVar_map.end()) {
+ arg2Bounded = true;
+ } else {
+ fvUnrollSet.insert(concatArg2);
+ }
+ } else if (u.str.is_concat(to_app(concatArg2))) {
+ if (concatEqUnrollsMap.find(concatArg2) == concatEqUnrollsMap.end()) {
+ arg2Bounded = true;
+ }
+ }
+ if (!arg1Bounded && !arg2Bounded) {
+ concatFreeArgsEqUnrollsMap[concat].insert(
+ concatEqUnrollsMap[concat].begin(),
+ concatEqUnrollsMap[concat].end());
+ }
+ }
+ for (std::set<expr*>::iterator vItor = fvUnrollSet.begin(); vItor != fvUnrollSet.end(); vItor++) {
+ TRACE("str", tout << "remove " << mk_pp(*vItor, m) << " from freeVar_map" << std::endl;);
+ freeVar_map.erase(*vItor);
+ }
+
+ // Assign free variables
+ std::set<expr*> fSimpUnroll;
+
+ constValue = NULL;
+
+ {
+ TRACE("str", tout << "free var map (#" << freeVar_map.size() << "):" << std::endl;
+ for (std::map<expr*, int>::iterator freeVarItor1 = freeVar_map.begin(); freeVarItor1 != freeVar_map.end(); freeVarItor1++) {
+ expr * freeVar = freeVarItor1->first;
+ rational lenValue;
+ bool lenValue_exists = get_len_value(freeVar, lenValue);
+ tout << mk_pp(freeVar, m) << " [depCnt = " << freeVarItor1->second << ", length = "
+ << (lenValue_exists ? lenValue.to_string() : "?")
+ << "]" << std::endl;
+ }
+ );
+ }
+
+ for (std::map<expr*, std::set<expr*> >::iterator fvIt2 = concatFreeArgsEqUnrollsMap.begin();
+ fvIt2 != concatFreeArgsEqUnrollsMap.end(); fvIt2++) {
+ expr * concat = fvIt2->first;
+ for (std::set<expr*>::iterator urItor = fvIt2->second.begin(); urItor != fvIt2->second.end(); urItor++) {
+ expr * unroll = *urItor;
+ process_concat_eq_unroll(concat, unroll);
+ }
+ }
+
+ // --------
+ // experimental free variable assignment - begin
+ // * special handling for variables that are not used in concat
+ // --------
+ bool testAssign = true;
+ if (!testAssign) {
+ for (std::map<expr*, int>::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) {
+ expr * freeVar = fvIt->first;
+ /*
+ std::string vName = std::string(Z3_ast_to_string(ctx, freeVar));
+ if (vName.length() >= 9 && vName.substr(0, 9) == "$$_regVar") {
+ continue;
+ }
+ */
+ expr * toAssert = gen_len_val_options_for_free_var(freeVar, NULL, "");
+ if (toAssert != NULL) {
+ assert_axiom(toAssert);
+ }
+ }
+ } else {
+ process_free_var(freeVar_map);
+ }
+ // experimental free variable assignment - end
+
+ // now deal with removed free variables that are bounded by an unroll
+ TRACE("str", tout << "fv_unrolls_map (#" << fv_unrolls_map.size() << "):" << std::endl;);
+ for (std::map<expr*, std::set<expr*> >::iterator fvIt1 = fv_unrolls_map.begin();
+ fvIt1 != fv_unrolls_map.end(); fvIt1++) {
+ expr * var = fvIt1->first;
+ fSimpUnroll.clear();
+ get_eqc_simpleUnroll(var, constValue, fSimpUnroll);
+ if (fSimpUnroll.size() == 0) {
+ gen_assign_unroll_reg(fv_unrolls_map[var]);
+ } else {
+ expr * toAssert = gen_assign_unroll_Str2Reg(var, fSimpUnroll);
+ if (toAssert != NULL) {
+ assert_axiom(toAssert);
+ }
+ }
+ }
+
+ if (opt_VerifyFinalCheckProgress && !finalCheckProgressIndicator) {
+ TRACE("str", tout << "BUG: no progress in final check, giving up!!" << std::endl;);
+ m.raise_exception("no progress in theory_str final check");
+ }
+
+ return FC_CONTINUE; // since by this point we've added axioms
+ }
+
+ inline zstring int_to_string(int i) {
+ std::stringstream ss;
+ ss << i;
+ std::string str = ss.str();
+ return zstring(str.c_str());
+ }
+
+ inline std::string longlong_to_string(long long i) {
+ std::stringstream ss;
+ ss << i;
+ return ss.str();
+ }
+
+ void theory_str::print_value_tester_list(svector<std::pair<int, expr*> > & testerList) {
+ ast_manager & m = get_manager();
+ TRACE("str",
+ int ss = testerList.size();
+ tout << "valueTesterList = {";
+ for (int i = 0; i < ss; ++i) {
+ if (i % 4 == 0) {
+ tout << std::endl;
+ }
+ tout << "(" << testerList[i].first << ", ";
+ tout << mk_ismt2_pp(testerList[i].second, m);
+ tout << "), ";
+ }
+ tout << std::endl << "}" << std::endl;
+ );
+ }
+
+ zstring theory_str::gen_val_string(int len, int_vector & encoding) {
+ SASSERT(charSetSize > 0);
+ SASSERT(char_set != NULL);
+
+ std::string re(len, char_set[0]);
+ for (int i = 0; i < (int) encoding.size() - 1; i++) {
+ int idx = encoding[i];
+ re[len - 1 - i] = char_set[idx];
+ }
+ return zstring(re.c_str());
+ }
+
+ /*
+ * The return value indicates whether we covered the search space.
+ * - If the next encoding is valid, return false
+ * - Otherwise, return true
+ */
+ bool theory_str::get_next_val_encode(int_vector & base, int_vector & next) {
+ SASSERT(charSetSize > 0);
+
+ TRACE("str", tout << "base vector: [ ";
+ for (unsigned i = 0; i < base.size(); ++i) {
+ tout << base[i] << " ";
+ }
+ tout << "]" << std::endl;
+ );
+
+ int s = 0;
+ int carry = 0;
+ next.reset();
+
+ for (int i = 0; i < (int) base.size(); i++) {
+ if (i == 0) {
+ s = base[i] + 1;
+ carry = s / charSetSize;
+ s = s % charSetSize;
+ next.push_back(s);
+ } else {
+ s = base[i] + carry;
+ carry = s / charSetSize;
+ s = s % charSetSize;
+ next.push_back(s);
+ }
+ }
+ if (next[next.size() - 1] > 0) {
+ next.reset();
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ expr * theory_str::gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
+ zstring lenStr, int tries) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ int distance = 32;
+
+ // ----------------------------------------------------------------------------------------
+ // generate value options encoding
+ // encoding is a vector of size (len + 1)
+ // e.g, len = 2,
+ // encoding {1, 2, 0} means the value option is "charSet[2]"."charSet[1]"
+ // the last item in the encoding indicates whether the whole space is covered
+ // for example, if the charSet = {a, b}. All valid encodings are
+ // {0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {1, 1, 0}
+ // if add 1 to the last one, we get
+ // {0, 0, 1}
+ // the last item "1" shows this is not a valid encoding, and we have covered all space
+ // ----------------------------------------------------------------------------------------
+ int len = atoi(lenStr.encode().c_str());
+ bool coverAll = false;
+ svector<int_vector> options;
+ int_vector base;
+
+ TRACE("str", tout
+ << "freeVar = " << mk_ismt2_pp(freeVar, m) << std::endl
+ << "len_indicator = " << mk_ismt2_pp(len_indicator, m) << std::endl
+ << "val_indicator = " << mk_ismt2_pp(val_indicator, m) << std::endl
+ << "lenstr = " << lenStr << "\n"
+ << "tries = " << tries << "\n";
+ if (m_params.m_AggressiveValueTesting) {
+ tout << "note: aggressive value testing is enabled" << std::endl;
+ }
+ );
+
+ if (tries == 0) {
+ base = int_vector(len + 1, 0);
+ coverAll = false;
+ } else {
+ expr * lastestValIndi = fvar_valueTester_map[freeVar][len][tries - 1].second;
+ TRACE("str", tout << "last value tester = " << mk_ismt2_pp(lastestValIndi, m) << std::endl;);
+ coverAll = get_next_val_encode(val_range_map[lastestValIndi], base);
+ }
+
+ long long l = (tries) * distance;
+ long long h = l;
+ for (int i = 0; i < distance; i++) {
+ if (coverAll)
+ break;
+ options.push_back(base);
+ h++;
+ coverAll = get_next_val_encode(options[options.size() - 1], base);
+ }
+ val_range_map[val_indicator] = options[options.size() - 1];
+
+ TRACE("str",
+ tout << "value tester encoding " << "{" << std::endl;
+ int_vector vec = val_range_map[val_indicator];
+
+ for (int_vector::iterator it = vec.begin(); it != vec.end(); ++it) {
+ tout << *it << std::endl;
+ }
+ tout << "}" << std::endl;
+ );
+
+ // ----------------------------------------------------------------------------------------
+
+ ptr_vector<expr> orList;
+ ptr_vector<expr> andList;
+
+ for (long long i = l; i < h; i++) {
+ orList.push_back(m.mk_eq(val_indicator, mk_string(longlong_to_string(i).c_str()) ));
+ if (m_params.m_AggressiveValueTesting) {
+ literal l = mk_eq(val_indicator, mk_string(longlong_to_string(i).c_str()), false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(l);
+ }
+
+ zstring aStr = gen_val_string(len, options[i - l]);
+ expr * strAst;
+ if (m_params.m_UseFastValueTesterCache) {
+ if (!valueTesterCache.find(aStr, strAst)) {
+ strAst = mk_string(aStr);
+ valueTesterCache.insert(aStr, strAst);
+ m_trail.push_back(strAst);
+ }
+ } else {
+ strAst = mk_string(aStr);
+ }
+ andList.push_back(m.mk_eq(orList[orList.size() - 1], m.mk_eq(freeVar, strAst)));
+ }
+ if (!coverAll) {
+ orList.push_back(m.mk_eq(val_indicator, mk_string("more")));
+ if (m_params.m_AggressiveValueTesting) {
+ literal l = mk_eq(val_indicator, mk_string("more"), false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(~l);
+ }
+ }
+
+ expr ** or_items = alloc_svect(expr*, orList.size());
+ expr ** and_items = alloc_svect(expr*, andList.size() + 1);
+
+ for (int i = 0; i < (int) orList.size(); i++) {
+ or_items[i] = orList[i];
+ }
+ if (orList.size() > 1)
+ and_items[0] = m.mk_or(orList.size(), or_items);
+ else
+ and_items[0] = or_items[0];
+
+ for (int i = 0; i < (int) andList.size(); i++) {
+ and_items[i + 1] = andList[i];
+ }
+ expr * valTestAssert = m.mk_and(andList.size() + 1, and_items);
+
+ // ---------------------------------------
+ // If the new value tester is $$_val_x_16_i
+ // Should add ($$_len_x_j = 16) /\ ($$_val_x_16_i = "more")
+ // ---------------------------------------
+ andList.reset();
+ andList.push_back(m.mk_eq(len_indicator, mk_string(lenStr)));
+ for (int i = 0; i < tries; i++) {
+ expr * vTester = fvar_valueTester_map[freeVar][len][i].second;
+ if (vTester != val_indicator)
+ andList.push_back(m.mk_eq(vTester, mk_string("more")));
+ }
+ expr * assertL = NULL;
+ if (andList.size() == 1) {
+ assertL = andList[0];
+ } else {
+ expr ** and_items = alloc_svect(expr*, andList.size());
+ for (int i = 0; i < (int) andList.size(); i++) {
+ and_items[i] = andList[i];
+ }
+ assertL = m.mk_and(andList.size(), and_items);
+ }
+
+ // (assertL => valTestAssert) <=> (!assertL OR valTestAssert)
+ valTestAssert = m.mk_or(m.mk_not(assertL), valTestAssert);
+ return valTestAssert;
+ }
+
+ expr * theory_str::gen_free_var_options(expr * freeVar, expr * len_indicator,
+ zstring len_valueStr, expr * valTesterInCbEq, zstring valTesterValueStr) {
+ ast_manager & m = get_manager();
+
+ int len = atoi(len_valueStr.encode().c_str());
+
+ // check whether any value tester is actually in scope
+ TRACE("str", tout << "checking scope of previous value testers" << std::endl;);
+ bool map_effectively_empty = true;
+ if (fvar_valueTester_map[freeVar].find(len) != fvar_valueTester_map[freeVar].end()) {
+ // there's *something* in the map, but check its scope
+ svector<std::pair<int, expr*> > entries = fvar_valueTester_map[freeVar][len];
+ for (svector<std::pair<int,expr*> >::iterator it = entries.begin(); it != entries.end(); ++it) {
+ std::pair<int,expr*> entry = *it;
+ expr * aTester = entry.second;
+ if (internal_variable_set.find(aTester) == internal_variable_set.end()) {
+ TRACE("str", tout << mk_pp(aTester, m) << " out of scope" << std::endl;);
+ } else {
+ TRACE("str", tout << mk_pp(aTester, m) << " in scope" << std::endl;);
+ map_effectively_empty = false;
+ break;
+ }
+ }
+ }
+
+ if (map_effectively_empty) {
+ TRACE("str", tout << "no previous value testers, or none of them were in scope" << std::endl;);
+ int tries = 0;
+ expr * val_indicator = mk_internal_valTest_var(freeVar, len, tries);
+ valueTester_fvar_map[val_indicator] = freeVar;
+ fvar_valueTester_map[freeVar][len].push_back(std::make_pair(sLevel, val_indicator));
+ print_value_tester_list(fvar_valueTester_map[freeVar][len]);
+ return gen_val_options(freeVar, len_indicator, val_indicator, len_valueStr, tries);
+ } else {
+ TRACE("str", tout << "checking previous value testers" << std::endl;);
+ print_value_tester_list(fvar_valueTester_map[freeVar][len]);
+
+ // go through all previous value testers
+ // If some doesn't have an eqc value, add its assertion again.
+ int testerTotal = fvar_valueTester_map[freeVar][len].size();
+ int i = 0;
+ for (; i < testerTotal; i++) {
+ expr * aTester = fvar_valueTester_map[freeVar][len][i].second;
+
+ // it's probably worth checking scope here, actually
+ if (internal_variable_set.find(aTester) == internal_variable_set.end()) {
+ TRACE("str", tout << "value tester " << mk_pp(aTester, m) << " out of scope, skipping" << std::endl;);
+ continue;
+ }
+
+ if (aTester == valTesterInCbEq) {
+ break;
+ }
+
+ bool anEqcHasValue = false;
+ // Z3_ast anEqc = get_eqc_value(t, aTester, anEqcHasValue);
+ expr * aTester_eqc_value = get_eqc_value(aTester, anEqcHasValue);
+ if (!anEqcHasValue) {
+ TRACE("str", tout << "value tester " << mk_ismt2_pp(aTester, m)
+ << " doesn't have an equivalence class value." << std::endl;);
+ refresh_theory_var(aTester);
+
+ expr * makeupAssert = gen_val_options(freeVar, len_indicator, aTester, len_valueStr, i);
+
+ TRACE("str", tout << "var: " << mk_ismt2_pp(freeVar, m) << std::endl
+ << mk_ismt2_pp(makeupAssert, m) << std::endl;);
+ assert_axiom(makeupAssert);
+ } else {
+ TRACE("str", tout << "value tester " << mk_ismt2_pp(aTester, m)
+ << " == " << mk_ismt2_pp(aTester_eqc_value, m) << std::endl;);
+ }
+ }
+
+ if (valTesterValueStr == "more") {
+ expr * valTester = NULL;
+ if (i + 1 < testerTotal) {
+ valTester = fvar_valueTester_map[freeVar][len][i + 1].second;
+ refresh_theory_var(valTester);
+ } else {
+ valTester = mk_internal_valTest_var(freeVar, len, i + 1);
+ valueTester_fvar_map[valTester] = freeVar;
+ fvar_valueTester_map[freeVar][len].push_back(std::make_pair(sLevel, valTester));
+ print_value_tester_list(fvar_valueTester_map[freeVar][len]);
+ }
+ expr * nextAssert = gen_val_options(freeVar, len_indicator, valTester, len_valueStr, i + 1);
+ return nextAssert;
+ }
+
+ return NULL;
+ }
+ }
+
+ void theory_str::reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vector & items) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ TRACE("str", tout << "reduce regex " << mk_pp(regex, mgr) << " with respect to variable " << mk_pp(var, mgr) << std::endl;);
+
+ app * regexFuncDecl = to_app(regex);
+ if (u.re.is_to_re(regexFuncDecl)) {
+ // ---------------------------------------------------------
+ // var \in Str2Reg(s1)
+ // ==>
+ // var = s1 /\ length(var) = length(s1)
+ // ---------------------------------------------------------
+ expr * strInside = to_app(regex)->get_arg(0);
+ items.push_back(ctx.mk_eq_atom(var, strInside));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_strlen(strInside)));
+ return;
+ }
+ // RegexUnion
+ else if (u.re.is_union(regexFuncDecl)) {
+ // ---------------------------------------------------------
+ // var \in RegexUnion(r1, r2)
+ // ==>
+ // (var = newVar1 \/ var = newVar2)
+ // (var = newVar1 --> length(var) = length(newVar1)) /\ (var = newVar2 --> length(var) = length(newVar2))
+ // /\ (newVar1 \in r1) /\ (newVar2 \in r2)
+ // ---------------------------------------------------------
+ expr_ref newVar1(mk_regex_rep_var(), mgr);
+ expr_ref newVar2(mk_regex_rep_var(), mgr);
+ items.push_back(mgr.mk_or(ctx.mk_eq_atom(var, newVar1), ctx.mk_eq_atom(var, newVar2)));
+ items.push_back(mgr.mk_or(
+ mgr.mk_not(ctx.mk_eq_atom(var, newVar1)),
+ ctx.mk_eq_atom(mk_strlen(var), mk_strlen(newVar1))));
+ items.push_back(mgr.mk_or(
+ mgr.mk_not(ctx.mk_eq_atom(var, newVar2)),
+ ctx.mk_eq_atom(mk_strlen(var), mk_strlen(newVar2))));
+
+ expr * regArg1 = to_app(regex)->get_arg(0);
+ reduce_virtual_regex_in(newVar1, regArg1, items);
+
+ expr * regArg2 = to_app(regex)->get_arg(1);
+ reduce_virtual_regex_in(newVar2, regArg2, items);
+
+ return;
+ }
+ // RegexConcat
+ else if (u.re.is_concat(regexFuncDecl)) {
+ // ---------------------------------------------------------
+ // var \in RegexConcat(r1, r2)
+ // ==>
+ // (var = newVar1 . newVar2) /\ (length(var) = length(vewVar1 . newVar2) )
+ // /\ (newVar1 \in r1) /\ (newVar2 \in r2)
+ // ---------------------------------------------------------
+ expr_ref newVar1(mk_regex_rep_var(), mgr);
+ expr_ref newVar2(mk_regex_rep_var(), mgr);
+ expr_ref concatAst(mk_concat(newVar1, newVar2), mgr);
+ items.push_back(ctx.mk_eq_atom(var, concatAst));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var),
+ m_autil.mk_add(mk_strlen(newVar1), mk_strlen(newVar2))));
+
+ expr * regArg1 = to_app(regex)->get_arg(0);
+ reduce_virtual_regex_in(newVar1, regArg1, items);
+ expr * regArg2 = to_app(regex)->get_arg(1);
+ reduce_virtual_regex_in(newVar2, regArg2, items);
+ return;
+ }
+ // Unroll
+ else if (u.re.is_star(regexFuncDecl)) {
+ // ---------------------------------------------------------
+ // var \in Star(r1)
+ // ==>
+ // var = unroll(r1, t1) /\ |var| = |unroll(r1, t1)|
+ // ---------------------------------------------------------
+ expr * regArg = to_app(regex)->get_arg(0);
+ expr_ref unrollCnt(mk_unroll_bound_var(), mgr);
+ expr_ref unrollFunc(mk_unroll(regArg, unrollCnt), mgr);
+ items.push_back(ctx.mk_eq_atom(var, unrollFunc));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(var), mk_strlen(unrollFunc)));
+ return;
+ }
+ // re.range
+ else if (u.re.is_range(regexFuncDecl)) {
+ // var in range("a", "z")
+ // ==>
+ // (var = "a" or var = "b" or ... or var = "z")
+ expr_ref lo(regexFuncDecl->get_arg(0), mgr);
+ expr_ref hi(regexFuncDecl->get_arg(1), mgr);
+ zstring str_lo, str_hi;
+ SASSERT(u.str.is_string(lo));
+ SASSERT(u.str.is_string(hi));
+ u.str.is_string(lo, str_lo);
+ u.str.is_string(hi, str_hi);
+ SASSERT(str_lo.length() == 1);
+ SASSERT(str_hi.length() == 1);
+ unsigned int c1 = str_lo[0];
+ unsigned int c2 = str_hi[0];
+ if (c1 > c2) {
+ // exchange
+ unsigned int tmp = c1;
+ c1 = c2;
+ c2 = tmp;
+ }
+ expr_ref_vector range_cases(mgr);
+ for (unsigned int ch = c1; ch <= c2; ++ch) {
+ zstring s_ch(ch);
+ expr_ref rhs(ctx.mk_eq_atom(var, u.str.mk_string(s_ch)), mgr);
+ range_cases.push_back(rhs);
+ }
+ expr_ref rhs(mk_or(range_cases), mgr);
+ SASSERT(rhs);
+ assert_axiom(rhs);
+ return;
+ } else {
+ get_manager().raise_exception("unrecognized regex operator");
+ UNREACHABLE();
+ }
+ }
+
+ void theory_str::gen_assign_unroll_reg(std::set<expr*> & unrolls) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ expr_ref_vector items(mgr);
+ for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
+ expr * unrFunc = *itor;
+ TRACE("str", tout << "generating assignment for unroll " << mk_pp(unrFunc, mgr) << std::endl;);
+
+ expr * regexInUnr = to_app(unrFunc)->get_arg(0);
+ expr * cntInUnr = to_app(unrFunc)->get_arg(1);
+ items.reset();
+
+ rational low, high;
+ bool low_exists = lower_bound(cntInUnr, low);
+ bool high_exists = upper_bound(cntInUnr, high);
+
+ TRACE("str",
+ tout << "unroll " << mk_pp(unrFunc, mgr) << std::endl;
+ rational unrLenValue;
+ bool unrLenValue_exists = get_len_value(unrFunc, unrLenValue);
+ tout << "unroll length: " << (unrLenValue_exists ? unrLenValue.to_string() : "?") << std::endl;
+ rational cntInUnrValue;
+ bool cntHasValue = get_value(cntInUnr, cntInUnrValue);
+ tout << "unroll count: " << (cntHasValue ? cntInUnrValue.to_string() : "?")
+ << " low = "
+ << (low_exists ? low.to_string() : "?")
+ << " high = "
+ << (high_exists ? high.to_string() : "?")
+ << std::endl;
+ );
+
+ expr_ref toAssert(mgr);
+ if (low.is_neg()) {
+ toAssert = m_autil.mk_ge(cntInUnr, mk_int(0));
+ } else {
+ if (unroll_var_map.find(unrFunc) == unroll_var_map.end()) {
+
+ expr_ref newVar1(mk_regex_rep_var(), mgr);
+ expr_ref newVar2(mk_regex_rep_var(), mgr);
+ expr_ref concatAst(mk_concat(newVar1, newVar2), mgr);
+ expr_ref newCnt(mk_unroll_bound_var(), mgr);
+ expr_ref newUnrollFunc(mk_unroll(regexInUnr, newCnt), mgr);
+
+ // unroll(r1, t1) = newVar1 . newVar2
+ items.push_back(ctx.mk_eq_atom(unrFunc, concatAst));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(unrFunc), m_autil.mk_add(mk_strlen(newVar1), mk_strlen(newVar2))));
+ // mk_strlen(unrFunc) >= mk_strlen(newVar{1,2})
+ items.push_back(m_autil.mk_ge(m_autil.mk_add(mk_strlen(unrFunc), m_autil.mk_mul(mk_int(-1), mk_strlen(newVar1))), mk_int(0)));
+ items.push_back(m_autil.mk_ge(m_autil.mk_add(mk_strlen(unrFunc), m_autil.mk_mul(mk_int(-1), mk_strlen(newVar2))), mk_int(0)));
+ // newVar1 \in r1
+ reduce_virtual_regex_in(newVar1, regexInUnr, items);
+ items.push_back(ctx.mk_eq_atom(cntInUnr, m_autil.mk_add(newCnt, mk_int(1))));
+ items.push_back(ctx.mk_eq_atom(newVar2, newUnrollFunc));
+ items.push_back(ctx.mk_eq_atom(mk_strlen(newVar2), mk_strlen(newUnrollFunc)));
+ toAssert = ctx.mk_eq_atom(
+ m_autil.mk_ge(cntInUnr, mk_int(1)),
+ mk_and(items));
+
+ // option 0
+ expr_ref op0(ctx.mk_eq_atom(cntInUnr, mk_int(0)), mgr);
+ expr_ref ast1(ctx.mk_eq_atom(unrFunc, mk_string("")), mgr);
+ expr_ref ast2(ctx.mk_eq_atom(mk_strlen(unrFunc), mk_int(0)), mgr);
+ expr_ref and1(mgr.mk_and(ast1, ast2), mgr);
+
+ // put together
+ toAssert = mgr.mk_and(ctx.mk_eq_atom(op0, and1), toAssert);
+
+ unroll_var_map[unrFunc] = toAssert;
+ } else {
+ toAssert = unroll_var_map[unrFunc];
+ }
+ }
+ m_trail.push_back(toAssert);
+ assert_axiom(toAssert);
+ }
+ }
+
+ static int computeGCD(int x, int y) {
+ if (x == 0) {
+ return y;
+ }
+ while (y != 0) {
+ if (x > y) {
+ x = x - y;
+ } else {
+ y = y - x;
+ }
+ }
+ return x;
+ }
+
+ static int computeLCM(int a, int b) {
+ int temp = computeGCD(a, b);
+ return temp ? (a / temp * b) : 0;
+ }
+
+ static zstring get_unrolled_string(zstring core, int count) {
+ zstring res("");
+ for (int i = 0; i < count; i++) {
+ res = res + core;
+ }
+ return res;
+ }
+
+ expr * theory_str::gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ int lcm = 1;
+ int coreValueCount = 0;
+ expr * oneUnroll = NULL;
+ zstring oneCoreStr("");
+ for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
+ expr * str2RegFunc = to_app(*itor)->get_arg(0);
+ expr * coreVal = to_app(str2RegFunc)->get_arg(0);
+ zstring coreStr;
+ u.str.is_string(coreVal, coreStr);
+ if (oneUnroll == NULL) {
+ oneUnroll = *itor;
+ oneCoreStr = coreStr;
+ }
+ coreValueCount++;
+ int core1Len = coreStr.length();
+ lcm = computeLCM(lcm, core1Len);
+ }
+ //
+ bool canHaveNonEmptyAssign = true;
+ expr_ref_vector litems(mgr);
+ zstring lcmStr = get_unrolled_string(oneCoreStr, (lcm / oneCoreStr.length()));
+ for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
+ expr * str2RegFunc = to_app(*itor)->get_arg(0);
+ expr * coreVal = to_app(str2RegFunc)->get_arg(0);
+ zstring coreStr;
+ u.str.is_string(coreVal, coreStr);
+ unsigned int core1Len = coreStr.length();
+ zstring uStr = get_unrolled_string(coreStr, (lcm / core1Len));
+ if (uStr != lcmStr) {
+ canHaveNonEmptyAssign = false;
+ }
+ litems.push_back(ctx.mk_eq_atom(n, *itor));
+ }
+
+ if (canHaveNonEmptyAssign) {
+ return gen_unroll_conditional_options(n, unrolls, lcmStr);
+ } else {
+ expr_ref implyL(mk_and(litems), mgr);
+ expr_ref implyR(ctx.mk_eq_atom(n, mk_string("")), mgr);
+ // want to return (implyL -> implyR)
+ expr * final_axiom = rewrite_implication(implyL, implyR);
+ return final_axiom;
+ }
+ }
+
+ expr * theory_str::gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, zstring lcmStr) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ int dist = opt_LCMUnrollStep;
+ expr_ref_vector litems(mgr);
+ expr_ref moreAst(mk_string("more"), mgr);
+ for (std::set<expr*>::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) {
+ expr_ref item(ctx.mk_eq_atom(var, *itor), mgr);
+ TRACE("str", tout << "considering unroll " << mk_pp(item, mgr) << std::endl;);
+ litems.push_back(item);
+ }
+
+ // handle out-of-scope entries in unroll_tries_map
+
+ ptr_vector<expr> outOfScopeTesters;
+
+ for (ptr_vector<expr>::iterator it = unroll_tries_map[var][unrolls].begin();
+ it != unroll_tries_map[var][unrolls].end(); ++it) {
+ expr * tester = *it;
+ bool inScope = (internal_unrollTest_vars.find(tester) != internal_unrollTest_vars.end());
+ TRACE("str", tout << "unroll test var " << mk_pp(tester, mgr)
+ << (inScope ? " in scope" : " out of scope")
+ << std::endl;);
+ if (!inScope) {
+ outOfScopeTesters.push_back(tester);
+ }
+ }
+
+ for (ptr_vector<expr>::iterator it = outOfScopeTesters.begin();
+ it != outOfScopeTesters.end(); ++it) {
+ unroll_tries_map[var][unrolls].erase(*it);
+ }
+
+
+ if (unroll_tries_map[var][unrolls].size() == 0) {
+ unroll_tries_map[var][unrolls].push_back(mk_unroll_test_var());
+ }
+
+ int tries = unroll_tries_map[var][unrolls].size();
+ for (int i = 0; i < tries; i++) {
+ expr * tester = unroll_tries_map[var][unrolls][i];
+ // TESTING
+ refresh_theory_var(tester);
+ bool testerHasValue = false;
+ expr * testerVal = get_eqc_value(tester, testerHasValue);
+ if (!testerHasValue) {
+ // generate make-up assertion
+ int l = i * dist;
+ int h = (i + 1) * dist;
+ expr_ref lImp(mk_and(litems), mgr);
+ expr_ref rImp(gen_unroll_assign(var, lcmStr, tester, l, h), mgr);
+
+ SASSERT(lImp);
+ TRACE("str", tout << "lImp = " << mk_pp(lImp, mgr) << std::endl;);
+ SASSERT(rImp);
+ TRACE("str", tout << "rImp = " << mk_pp(rImp, mgr) << std::endl;);
+
+ expr_ref toAssert(mgr.mk_or(mgr.mk_not(lImp), rImp), mgr);
+ SASSERT(toAssert);
+ TRACE("str", tout << "Making up assignments for variable which is equal to unbounded Unroll" << std::endl;);
+ m_trail.push_back(toAssert);
+ return toAssert;
+
+ // note: this is how the code looks in Z3str2's strRegex.cpp:genUnrollConditionalOptions.
+ // the return is in the same place
+
+ // insert [tester = "more"] to litems so that the implyL for next tester is correct
+ litems.push_back(ctx.mk_eq_atom(tester, moreAst));
+ } else {
+ zstring testerStr;
+ u.str.is_string(testerVal, testerStr);
+ TRACE("str", tout << "Tester [" << mk_pp(tester, mgr) << "] = " << testerStr << "\n";);
+ if (testerStr == "more") {
+ litems.push_back(ctx.mk_eq_atom(tester, moreAst));
+ }
+ }
+ }
+ expr * tester = mk_unroll_test_var();
+ unroll_tries_map[var][unrolls].push_back(tester);
+ int l = tries * dist;
+ int h = (tries + 1) * dist;
+ expr_ref lImp(mk_and(litems), mgr);
+ expr_ref rImp(gen_unroll_assign(var, lcmStr, tester, l, h), mgr);
+ SASSERT(lImp);
+ SASSERT(rImp);
+ expr_ref toAssert(mgr.mk_or(mgr.mk_not(lImp), rImp), mgr);
+ SASSERT(toAssert);
+ TRACE("str", tout << "Generating assignment for variable which is equal to unbounded Unroll" << std::endl;);
+ m_trail.push_back(toAssert);
+ return toAssert;
+ }
+
+ expr * theory_str::gen_unroll_assign(expr * var, zstring lcmStr, expr * testerVar, int l, int h) {
+ context & ctx = get_context();
+ ast_manager & mgr = get_manager();
+
+ TRACE("str", tout << "entry: var = " << mk_pp(var, mgr) << ", lcmStr = " << lcmStr
+ << ", l = " << l << ", h = " << h << "\n";);
+
+ if (m_params.m_AggressiveUnrollTesting) {
+ TRACE("str", tout << "note: aggressive unroll testing is active" << std::endl;);
+ }
+
+ expr_ref_vector orItems(mgr);
+ expr_ref_vector andItems(mgr);
+
+ for (int i = l; i < h; i++) {
+ zstring iStr = int_to_string(i);
+ expr_ref testerEqAst(ctx.mk_eq_atom(testerVar, mk_string(iStr)), mgr);
+ TRACE("str", tout << "testerEqAst = " << mk_pp(testerEqAst, mgr) << std::endl;);
+ if (m_params.m_AggressiveUnrollTesting) {
+ literal l = mk_eq(testerVar, mk_string(iStr), false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(l);
+ }
+
+ orItems.push_back(testerEqAst);
+ zstring unrollStrInstance = get_unrolled_string(lcmStr, i);
+
+ expr_ref x1(ctx.mk_eq_atom(testerEqAst, ctx.mk_eq_atom(var, mk_string(unrollStrInstance))), mgr);
+ TRACE("str", tout << "x1 = " << mk_pp(x1, mgr) << std::endl;);
+ andItems.push_back(x1);
+
+ expr_ref x2(ctx.mk_eq_atom(testerEqAst, ctx.mk_eq_atom(mk_strlen(var), mk_int(i * lcmStr.length()))), mgr);
+ TRACE("str", tout << "x2 = " << mk_pp(x2, mgr) << std::endl;);
+ andItems.push_back(x2);
+ }
+ expr_ref testerEqMore(ctx.mk_eq_atom(testerVar, mk_string("more")), mgr);
+ TRACE("str", tout << "testerEqMore = " << mk_pp(testerEqMore, mgr) << std::endl;);
+ if (m_params.m_AggressiveUnrollTesting) {
+ literal l = mk_eq(testerVar, mk_string("more"), false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(~l);
+ }
+
+ orItems.push_back(testerEqMore);
+ int nextLowerLenBound = h * lcmStr.length();
+ expr_ref more2(ctx.mk_eq_atom(testerEqMore,
+ //Z3_mk_ge(mk_length(t, var), mk_int(ctx, nextLowerLenBound))
+ m_autil.mk_ge(m_autil.mk_add(mk_strlen(var), mk_int(-1 * nextLowerLenBound)), mk_int(0))
+ ), mgr);
+ TRACE("str", tout << "more2 = " << mk_pp(more2, mgr) << std::endl;);
+ andItems.push_back(more2);
+
+ expr_ref finalOR(mgr.mk_or(orItems.size(), orItems.c_ptr()), mgr);
+ TRACE("str", tout << "finalOR = " << mk_pp(finalOR, mgr) << std::endl;);
+ andItems.push_back(mk_or(orItems));
+
+ expr_ref finalAND(mgr.mk_and(andItems.size(), andItems.c_ptr()), mgr);
+ TRACE("str", tout << "finalAND = " << mk_pp(finalAND, mgr) << std::endl;);
+
+ // doing the following avoids a segmentation fault
+ m_trail.push_back(finalAND);
+ return finalAND;
+ }
+
+ expr * theory_str::gen_len_test_options(expr * freeVar, expr * indicator, int tries) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ expr_ref freeVarLen(mk_strlen(freeVar), m);
+ SASSERT(freeVarLen);
+
+ expr_ref_vector orList(m);
+ expr_ref_vector andList(m);
+
+ int distance = 3;
+ int l = (tries - 1) * distance;
+ int h = tries * distance;
+
+ TRACE("str",
+ tout << "building andList and orList" << std::endl;
+ if (m_params.m_AggressiveLengthTesting) {
+ tout << "note: aggressive length testing is active" << std::endl;
+ }
+ );
+
+ // experimental theory-aware case split support
+ literal_vector case_split_literals;
+
+ for (int i = l; i < h; ++i) {
+ expr_ref str_indicator(m);
+ if (m_params.m_UseFastLengthTesterCache) {
+ rational ri(i);
+ expr * lookup_val;
+ if(lengthTesterCache.find(ri, lookup_val)) {
+ str_indicator = expr_ref(lookup_val, m);
+ } else {
+ // no match; create and insert
+ zstring i_str = int_to_string(i);
+ expr_ref new_val(mk_string(i_str), m);
+ lengthTesterCache.insert(ri, new_val);
+ m_trail.push_back(new_val);
+ str_indicator = expr_ref(new_val, m);
+ }
+ } else {
+ zstring i_str = int_to_string(i);
+ str_indicator = expr_ref(mk_string(i_str), m);
+ }
+ expr_ref or_expr(ctx.mk_eq_atom(indicator, str_indicator), m);
+ orList.push_back(or_expr);
+
+ double priority;
+ // give high priority to small lengths if this is available
+ if (i <= 5) {
+ priority = 0.3;
+ } else {
+ // prioritize over "more"
+ priority = 0.2;
+ }
+ add_theory_aware_branching_info(or_expr, priority, l_true);
+
+ if (m_params.m_AggressiveLengthTesting) {
+ literal l = mk_eq(indicator, str_indicator, false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(l);
+ }
+
+ case_split_literals.insert(mk_eq(freeVarLen, mk_int(i), false));
+
+ expr_ref and_expr(ctx.mk_eq_atom(orList.get(orList.size() - 1), m.mk_eq(freeVarLen, mk_int(i))), m);
+ andList.push_back(and_expr);
+ }
+
+ expr_ref more_option(ctx.mk_eq_atom(indicator, mk_string("more")), m);
+ orList.push_back(more_option);
+ // decrease priority of this option
+ add_theory_aware_branching_info(more_option, -0.1, l_true);
+ if (m_params.m_AggressiveLengthTesting) {
+ literal l = mk_eq(indicator, mk_string("more"), false);
+ ctx.mark_as_relevant(l);
+ ctx.force_phase(~l);
+ }
+
+ andList.push_back(ctx.mk_eq_atom(orList.get(orList.size() - 1), m_autil.mk_ge(freeVarLen, mk_int(h))));
+
+ /*
+ { // more experimental theory case split support
+ expr_ref tmp(m_autil.mk_ge(freeVarLen, mk_int(h)), m);
+ ctx.internalize(m_autil.mk_ge(freeVarLen, mk_int(h)), false);
+ case_split_literals.push_back(ctx.get_literal(tmp));
+ ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
+ }
+ */
+
+ expr_ref_vector or_items(m);
+ expr_ref_vector and_items(m);
+
+ for (unsigned i = 0; i < orList.size(); ++i) {
+ or_items.push_back(orList.get(i));
+ }
+
+ and_items.push_back(mk_or(or_items));
+ for(unsigned i = 0; i < andList.size(); ++i) {
+ and_items.push_back(andList.get(i));
+ }
+
+ TRACE("str", tout << "check: " << mk_pp(mk_and(and_items), m) << std::endl;);
+
+ expr_ref lenTestAssert = mk_and(and_items);
+ SASSERT(lenTestAssert);
+ TRACE("str", tout << "crash avoidance lenTestAssert: " << mk_pp(lenTestAssert, m) << std::endl;);
+
+ int testerCount = tries - 1;
+ if (testerCount > 0) {
+ expr_ref_vector and_items_LHS(m);
+ expr_ref moreAst(mk_string("more"), m);
+ for (int i = 0; i < testerCount; ++i) {
+ expr * indicator = fvar_lenTester_map[freeVar][i];
+ if (internal_variable_set.find(indicator) == internal_variable_set.end()) {
+ TRACE("str", tout << "indicator " << mk_pp(indicator, m) << " out of scope; continuing" << std::endl;);
+ continue;
+ } else {
+ TRACE("str", tout << "indicator " << mk_pp(indicator, m) << " in scope" << std::endl;);
+ and_items_LHS.push_back(ctx.mk_eq_atom(indicator, moreAst));
+ }
+ }
+ expr_ref assertL(mk_and(and_items_LHS), m);
+ SASSERT(assertL);
+ expr * finalAxiom = m.mk_or(m.mk_not(assertL), lenTestAssert.get());
+ SASSERT(finalAxiom != NULL);
+ TRACE("str", tout << "crash avoidance finalAxiom: " << mk_pp(finalAxiom, m) << std::endl;);
+ return finalAxiom;
+ } else {
+ TRACE("str", tout << "crash avoidance lenTestAssert.get(): " << mk_pp(lenTestAssert.get(), m) << std::endl;);
+ m_trail.push_back(lenTestAssert.get());
+ return lenTestAssert.get();
+ }
+ }
+
+ // Return an expression of the form
+ // (tester = "less" | tester = "N" | tester = "more") &
+ // (tester = "less" iff len(freeVar) < N) & (tester = "more" iff len(freeVar) > N) & (tester = "N" iff len(freeVar) = N))
+ expr_ref theory_str::binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds, literal_vector & case_split) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
+ rational N = bounds.midPoint;
+ rational N_minus_one = N - rational::one();
+ rational N_plus_one = N + rational::one();
+ expr_ref lenFreeVar(mk_strlen(freeVar), m);
+
+ TRACE("str", tout << "create case split for free var " << mk_pp(freeVar, m)
+ << " over " << mk_pp(tester, m) << " with midpoint " << N << std::endl;);
+
+ expr_ref_vector combinedCaseSplit(m);
+ expr_ref_vector testerCases(m);
+
+ expr_ref caseLess(ctx.mk_eq_atom(tester, mk_string("less")), m);
+ testerCases.push_back(caseLess);
+ combinedCaseSplit.push_back(ctx.mk_eq_atom(caseLess, m_autil.mk_le(lenFreeVar, m_autil.mk_numeral(N_minus_one, true) )));
+
+ expr_ref caseMore(ctx.mk_eq_atom(tester, mk_string("more")), m);
+ testerCases.push_back(caseMore);
+ combinedCaseSplit.push_back(ctx.mk_eq_atom(caseMore, m_autil.mk_ge(lenFreeVar, m_autil.mk_numeral(N_plus_one, true) )));
+
+ expr_ref caseEq(ctx.mk_eq_atom(tester, mk_string(N.to_string().c_str())), m);
+ testerCases.push_back(caseEq);
+ combinedCaseSplit.push_back(ctx.mk_eq_atom(caseEq, ctx.mk_eq_atom(lenFreeVar, m_autil.mk_numeral(N, true))));
+
+ combinedCaseSplit.push_back(mk_or(testerCases));
+
+ // force internalization on all terms in testerCases so we can extract literals
+ for (unsigned i = 0; i < testerCases.size(); ++i) {
+ expr * testerCase = testerCases.get(i);
+ if (!ctx.b_internalized(testerCase)) {
+ ctx.internalize(testerCase, false);
+ }
+ literal l = ctx.get_literal(testerCase);
+ case_split.push_back(l);
+ }
+
+ expr_ref final_term(mk_and(combinedCaseSplit), m);
+ SASSERT(final_term);
+ TRACE("str", tout << "final term: " << mk_pp(final_term, m) << std::endl;);
+ return final_term;
+ }
+
+ expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenTester, zstring previousLenTesterValue) {
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+
+ if (binary_search_len_tester_stack.contains(freeVar) && !binary_search_len_tester_stack[freeVar].empty()) {
+ TRACE("str", tout << "checking existing length testers for " << mk_pp(freeVar, m) << std::endl;
+ for (ptr_vector<expr>::const_iterator it = binary_search_len_tester_stack[freeVar].begin();
+ it != binary_search_len_tester_stack[freeVar].end(); ++it) {
+ expr * tester = *it;
+ tout << mk_pp(tester, m) << ": ";
+ if (binary_search_len_tester_info.contains(tester)) {
+ binary_search_info & bounds = binary_search_len_tester_info[tester];
+ tout << "[" << bounds.lowerBound << " | " << bounds.midPoint << " | " << bounds.upperBound << "]!" << bounds.windowSize;
+ } else {
+ tout << "[WARNING: no bounds info available]";
+ }
+ bool hasEqcValue;
+ expr * testerEqcValue = get_eqc_value(tester, hasEqcValue);
+ if (hasEqcValue) {
+ tout << " = " << mk_pp(testerEqcValue, m);
+ } else {
+ tout << " [no eqc value]";
+ }
+ tout << std::endl;
+ }
+ );
+ expr * lastTester = binary_search_len_tester_stack[freeVar].back();
+ bool lastTesterHasEqcValue;
+ expr * lastTesterValue = get_eqc_value(lastTester, lastTesterHasEqcValue);
+ zstring lastTesterConstant;
+ if (!lastTesterHasEqcValue) {
+ TRACE("str", tout << "length tester " << mk_pp(lastTester, m) << " at top of stack doesn't have an EQC value yet" << std::endl;);
+ // check previousLenTester
+ if (previousLenTester == lastTester) {
+ lastTesterConstant = previousLenTesterValue;
+ TRACE("str", tout << "invoked with previousLenTester info matching top of stack" << std::endl;);
+ } else {
+ TRACE("str", tout << "WARNING: unexpected reordering of length testers!" << std::endl;);
+ UNREACHABLE(); return NULL;
+ }
+ } else {
+ u.str.is_string(lastTesterValue, lastTesterConstant);
+ }
+ TRACE("str", tout << "last length tester is assigned \"" << lastTesterConstant << "\"" << "\n";);
+ if (lastTesterConstant == "more" || lastTesterConstant == "less") {
+ // use the previous bounds info to generate a new midpoint
+ binary_search_info lastBounds;
+ if (!binary_search_len_tester_info.find(lastTester, lastBounds)) {
+ // unexpected
+ TRACE("str", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
+ UNREACHABLE();
+ }
+ TRACE("str", tout << "last bounds are [" << lastBounds.lowerBound << " | " << lastBounds.midPoint << " | " << lastBounds.upperBound << "]!" << lastBounds.windowSize << std::endl;);
+ binary_search_info newBounds;
+ expr * newTester;
+ if (lastTesterConstant == "more") {
+ // special case: if the midpoint, upper bound, and window size are all equal,
+ // we double the window size and adjust the bounds
+ if (lastBounds.midPoint == lastBounds.upperBound && lastBounds.upperBound == lastBounds.windowSize) {
+ TRACE("str", tout << "search hit window size; expanding" << std::endl;);
+ newBounds.lowerBound = lastBounds.windowSize + rational::one();
+ newBounds.windowSize = lastBounds.windowSize * rational(2);
+ newBounds.upperBound = newBounds.windowSize;
+ newBounds.calculate_midpoint();
+ } else if (false) {
+ // handle the case where the midpoint can't be increased further
+ // (e.g. a window like [50 | 50 | 50]!64 and we don't answer "50")
+ } else {
+ // general case
+ newBounds.lowerBound = lastBounds.midPoint + rational::one();
+ newBounds.windowSize = lastBounds.windowSize;
+ newBounds.upperBound = lastBounds.upperBound;
+ newBounds.calculate_midpoint();
+ }
+ if (!binary_search_next_var_high.find(lastTester, newTester)) {
+ newTester = mk_internal_lenTest_var(freeVar, newBounds.midPoint.get_int32());
+ binary_search_next_var_high.insert(lastTester, newTester);
+ }
+ refresh_theory_var(newTester);
+ } else if (lastTesterConstant == "less") {
+ if (false) {
+ // handle the case where the midpoint can't be decreased further
+ // (e.g. a window like [0 | 0 | 0]!64 and we don't answer "0"
+ } else {
+ // general case
+ newBounds.upperBound = lastBounds.midPoint - rational::one();
+ newBounds.windowSize = lastBounds.windowSize;
+ newBounds.lowerBound = lastBounds.lowerBound;
+ newBounds.calculate_midpoint();
+ }
+ if (!binary_search_next_var_low.find(lastTester, newTester)) {
+ newTester = mk_internal_lenTest_var(freeVar, newBounds.midPoint.get_int32());
+ binary_search_next_var_low.insert(lastTester, newTester);
+ }
+ refresh_theory_var(newTester);
+ }
+ TRACE("str", tout << "new bounds are [" << newBounds.lowerBound << " | " << newBounds.midPoint << " | " << newBounds.upperBound << "]!" << newBounds.windowSize << std::endl;);
+ binary_search_len_tester_stack[freeVar].push_back(newTester);
+ m_trail_stack.push(binary_search_trail<theory_str>(binary_search_len_tester_stack, freeVar));
+ binary_search_len_tester_info.insert(newTester, newBounds);
+ m_trail_stack.push(insert_obj_map<theory_str, expr, binary_search_info>(binary_search_len_tester_info, newTester));
+
+ literal_vector case_split_literals;
+ expr_ref next_case_split(binary_search_case_split(freeVar, newTester, newBounds, case_split_literals));
+ m_trail.push_back(next_case_split);
+ // ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
+ return next_case_split;
+ } else { // lastTesterConstant is a concrete value
+ TRACE("str", tout << "length is fixed; generating models for free var" << std::endl;);
+ // defensive check that this length did not converge on a negative value.
+ binary_search_info lastBounds;
+ if (!binary_search_len_tester_info.find(lastTester, lastBounds)) {
+ // unexpected
+ TRACE("str", tout << "WARNING: no bounds information available for last tester!" << std::endl;);
+ UNREACHABLE();
+ }
+ if (lastBounds.midPoint.is_neg()) {
+ TRACE("str", tout << "WARNING: length search converged on a negative value. Negating this constraint." << std::endl;);
+ expr_ref axiom(m_autil.mk_ge(mk_strlen(freeVar), m_autil.mk_numeral(rational::zero(), true)), m);
+ return axiom;
+ }
+ // length is fixed
+ expr * valueAssert = gen_free_var_options(freeVar, lastTester, lastTesterConstant, NULL, zstring(""));
+ return valueAssert;
+ }
+ } else {
+ // no length testers yet
+ TRACE("str", tout << "no length testers for " << mk_pp(freeVar, m) << std::endl;);
+ binary_search_len_tester_stack.insert(freeVar, ptr_vector<expr>());
+
+ expr * firstTester;
+ rational lowerBound(0);
+ rational upperBound(m_params.m_BinarySearchInitialUpperBound);
+ rational windowSize(upperBound);
+ rational midPoint(floor(upperBound / rational(2)));
+ if (!binary_search_starting_len_tester.find(freeVar, firstTester)) {
+ firstTester = mk_internal_lenTest_var(freeVar, midPoint.get_int32());
+ binary_search_starting_len_tester.insert(freeVar, firstTester);
+ }
+ refresh_theory_var(firstTester);
+
+ binary_search_len_tester_stack[freeVar].push_back(firstTester);
+ m_trail_stack.push(binary_search_trail<theory_str>(binary_search_len_tester_stack, freeVar));
+ binary_search_info new_info(lowerBound, midPoint, upperBound, windowSize);
+ binary_search_len_tester_info.insert(firstTester, new_info);
+ m_trail_stack.push(insert_obj_map<theory_str, expr, binary_search_info>(binary_search_len_tester_info, firstTester));
+
+ literal_vector case_split_literals;
+ expr_ref initial_case_split(binary_search_case_split(freeVar, firstTester, new_info, case_split_literals));
+ m_trail.push_back(initial_case_split);
+ // ctx.mk_th_case_split(case_split_literals.size(), case_split_literals.c_ptr());
+ return initial_case_split;
+ }
+ }
+
+ // -----------------------------------------------------------------------------------------------------
+ // True branch will be taken in final_check:
+ // - When we discover a variable is "free" for the first time
+ // lenTesterInCbEq = NULL
+ // lenTesterValue = ""
+ // False branch will be taken when invoked by new_eq_eh().
+ // - After we set up length tester for a "free" var in final_check,
+ // when the tester is assigned to some value (e.g. "more" or "4"),
+ // lenTesterInCbEq != NULL, and its value will be passed by lenTesterValue
+ // The difference is that in new_eq_eh(), lenTesterInCbEq and its value have NOT been put into a same eqc
+ // -----------------------------------------------------------------------------------------------------
+ expr * theory_str::gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, zstring lenTesterValue) {
+
+ ast_manager & m = get_manager();
+
+ TRACE("str", tout << "gen for free var " << mk_ismt2_pp(freeVar, m) << std::endl;);
+
+ if (m_params.m_UseBinarySearch) {
+ TRACE("str", tout << "using binary search heuristic" << std::endl;);
+ return binary_search_length_test(freeVar, lenTesterInCbEq, lenTesterValue);
+ } else {
+ bool map_effectively_empty = false;
+ if (!fvar_len_count_map.contains(freeVar)) {
+ TRACE("str", tout << "fvar_len_count_map is empty" << std::endl;);
+ map_effectively_empty = true;
+ }
+
+ if (!map_effectively_empty) {
+ // check whether any entries correspond to variables that went out of scope;
+ // if every entry is out of scope then the map counts as being empty
+
+ // assume empty and find a counterexample
+ map_effectively_empty = true;
+ ptr_vector<expr> indicator_set = fvar_lenTester_map[freeVar];
+ for (ptr_vector<expr>::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) {
+ expr * indicator = *it;
+ if (internal_variable_set.find(indicator) != internal_variable_set.end()) {
+ TRACE("str", tout <<"found active internal variable " << mk_ismt2_pp(indicator, m)
+ << " in fvar_lenTester_map[freeVar]" << std::endl;);
+ map_effectively_empty = false;
+ break;
+ }
+ }
+ CTRACE("str", map_effectively_empty, tout << "all variables in fvar_lenTester_map[freeVar] out of scope" << std::endl;);
+ }
+
+ if (map_effectively_empty) {
+ // no length assertions for this free variable have ever been added.
+ TRACE("str", tout << "no length assertions yet" << std::endl;);
+
+ fvar_len_count_map.insert(freeVar, 1);
+ unsigned int testNum = fvar_len_count_map[freeVar];
+
+ expr_ref indicator(mk_internal_lenTest_var(freeVar, testNum), m);
+ SASSERT(indicator);
+
+ // since the map is "effectively empty", we can remove those variables that have left scope...
+ fvar_lenTester_map[freeVar].shrink(0);
+ fvar_lenTester_map[freeVar].push_back(indicator);
+ lenTester_fvar_map.insert(indicator, freeVar);
+
expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
SASSERT(lenTestAssert != NULL);
return lenTestAssert;
} else {
- TRACE("str", tout << "length is fixed; generating models for free var" << std::endl;);
- // length is fixed
- expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, zstring(""));
- return valueAssert;
+ TRACE("str", tout << "found previous in-scope length assertions" << std::endl;);
+
+ expr * effectiveLenInd = NULL;
+ zstring effectiveLenIndiStr("");
+ int lenTesterCount = (int) fvar_lenTester_map[freeVar].size();
+
+ TRACE("str",
+ tout << lenTesterCount << " length testers in fvar_lenTester_map[" << mk_pp(freeVar, m) << "]:" << std::endl;
+ for (int i = 0; i < lenTesterCount; ++i) {
+ expr * len_indicator = fvar_lenTester_map[freeVar][i];
+ tout << mk_pp(len_indicator, m) << ": ";
+ bool effectiveInScope = (internal_variable_set.find(len_indicator) != internal_variable_set.end());
+ tout << (effectiveInScope ? "in scope" : "NOT in scope");
+ tout << std::endl;
+ }
+ );
+
+ int i = 0;
+ for (; i < lenTesterCount; ++i) {
+ expr * len_indicator_pre = fvar_lenTester_map[freeVar][i];
+ // check whether this is in scope as well
+ if (internal_variable_set.find(len_indicator_pre) == internal_variable_set.end()) {
+ TRACE("str", tout << "length indicator " << mk_pp(len_indicator_pre, m) << " not in scope" << std::endl;);
+ continue;
+ }
+
+ bool indicatorHasEqcValue = false;
+ expr * len_indicator_value = get_eqc_value(len_indicator_pre, indicatorHasEqcValue);
+ TRACE("str", tout << "length indicator " << mk_ismt2_pp(len_indicator_pre, m) <<
+ " = " << mk_ismt2_pp(len_indicator_value, m) << std::endl;);
+ if (indicatorHasEqcValue) {
+ zstring len_pIndiStr;
+ u.str.is_string(len_indicator_value, len_pIndiStr);
+ if (len_pIndiStr != "more") {
+ effectiveLenInd = len_indicator_pre;
+ effectiveLenIndiStr = len_pIndiStr;
+ break;
+ }
+ } else {
+ if (lenTesterInCbEq != len_indicator_pre) {
+ TRACE("str", tout << "WARNING: length indicator " << mk_ismt2_pp(len_indicator_pre, m)
+ << " does not have an equivalence class value."
+ << " i = " << i << ", lenTesterCount = " << lenTesterCount << std::endl;);
+ if (i > 0) {
+ effectiveLenInd = fvar_lenTester_map[freeVar][i - 1];
+ bool effectiveHasEqcValue;
+ expr * effective_eqc_value = get_eqc_value(effectiveLenInd, effectiveHasEqcValue);
+ bool effectiveInScope = (internal_variable_set.find(effectiveLenInd) != internal_variable_set.end());
+ TRACE("str", tout << "checking effective length indicator " << mk_pp(effectiveLenInd, m) << ": "
+ << (effectiveInScope ? "in scope" : "NOT in scope") << ", ";
+ if (effectiveHasEqcValue) {
+ tout << "~= " << mk_pp(effective_eqc_value, m);
+ } else {
+ tout << "no eqc string constant";
+ }
+ tout << std::endl;);
+ if (effectiveLenInd == lenTesterInCbEq) {
+ effectiveLenIndiStr = lenTesterValue;
+ } else {
+ if (effectiveHasEqcValue) {
+ u.str.is_string(effective_eqc_value, effectiveLenIndiStr);
+ } else {
+ NOT_IMPLEMENTED_YET();
+ }
+ }
+ }
+ break;
+ }
+ // lenTesterInCbEq == len_indicator_pre
+ else {
+ if (lenTesterValue != "more") {
+ effectiveLenInd = len_indicator_pre;
+ effectiveLenIndiStr = lenTesterValue;
+ break;
+ }
+ }
+ } // !indicatorHasEqcValue
+ } // for (i : [0..lenTesterCount-1])
+ if (effectiveLenIndiStr == "more" || effectiveLenIndiStr == "") {
+ TRACE("str", tout << "length is not fixed; generating length tester options for free var" << std::endl;);
+ expr_ref indicator(m);
+ unsigned int testNum = 0;
+
+ TRACE("str", tout << "effectiveLenIndiStr = " << effectiveLenIndiStr
+ << ", i = " << i << ", lenTesterCount = " << lenTesterCount << "\n";);
+
+ if (i == lenTesterCount) {
+ fvar_len_count_map[freeVar] = fvar_len_count_map[freeVar] + 1;
+ testNum = fvar_len_count_map[freeVar];
+ indicator = mk_internal_lenTest_var(freeVar, testNum);
+ fvar_lenTester_map[freeVar].push_back(indicator);
+ lenTester_fvar_map.insert(indicator, freeVar);
+ } else {
+ indicator = fvar_lenTester_map[freeVar][i];
+ refresh_theory_var(indicator);
+ testNum = i + 1;
+ }
+ expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum);
+ SASSERT(lenTestAssert != NULL);
+ return lenTestAssert;
+ } else {
+ TRACE("str", tout << "length is fixed; generating models for free var" << std::endl;);
+ // length is fixed
+ expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, NULL, zstring(""));
+ return valueAssert;
+ }
+ } // fVarLenCountMap.find(...)
+
+ } // !UseBinarySearch
+ }
+
+ void theory_str::get_concats_in_eqc(expr * n, std::set<expr*> & concats) {
+ context & ctx = get_context();
+
+ expr * eqcNode = n;
+ do {
+ if (u.str.is_concat(to_app(eqcNode))) {
+ concats.insert(eqcNode);
}
- } // fVarLenCountMap.find(...)
+ eqcNode = get_eqc_next(eqcNode);
+ } while (eqcNode != n);
+ }
- } // !UseBinarySearch
-}
+ void theory_str::get_var_in_eqc(expr * n, std::set<expr*> & varSet) {
+ context & ctx = get_context();
-void theory_str::get_concats_in_eqc(expr * n, std::set<expr*> & concats) {
- context & ctx = get_context();
+ expr * eqcNode = n;
+ do {
+ if (variable_set.find(eqcNode) != variable_set.end()) {
+ varSet.insert(eqcNode);
+ }
+ eqcNode = get_eqc_next(eqcNode);
+ } while (eqcNode != n);
+ }
- expr * eqcNode = n;
- do {
- if (u.str.is_concat(to_app(eqcNode))) {
- concats.insert(eqcNode);
- }
- eqcNode = get_eqc_next(eqcNode);
- } while (eqcNode != n);
-}
+ bool cmpvarnames(expr * lhs, expr * rhs) {
+ symbol lhs_name = to_app(lhs)->get_decl()->get_name();
+ symbol rhs_name = to_app(rhs)->get_decl()->get_name();
+ return lhs_name.str() < rhs_name.str();
+ }
-void theory_str::get_var_in_eqc(expr * n, std::set<expr*> & varSet) {
- context & ctx = get_context();
+ void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
+ context & ctx = get_context();
+ ast_manager & m = get_manager();
- expr * eqcNode = n;
- do {
- if (variable_set.find(eqcNode) != variable_set.end()) {
- varSet.insert(eqcNode);
- }
- eqcNode = get_eqc_next(eqcNode);
- } while (eqcNode != n);
-}
+ std::set<expr*> eqcRepSet;
+ std::set<expr*> leafVarSet;
+ std::map<int, std::set<expr*> > aloneVars;
-bool cmpvarnames(expr * lhs, expr * rhs) {
- symbol lhs_name = to_app(lhs)->get_decl()->get_name();
- symbol rhs_name = to_app(rhs)->get_decl()->get_name();
- return lhs_name.str() < rhs_name.str();
-}
+ for (std::map<expr*, int>::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) {
+ expr * freeVar = fvIt->first;
+ // skip all regular expression vars
+ if (regex_variable_set.find(freeVar) != regex_variable_set.end()) {
+ continue;
+ }
-void theory_str::process_free_var(std::map<expr*, int> & freeVar_map) {
- context & ctx = get_context();
- ast_manager & m = get_manager();
-
- std::set<expr*> eqcRepSet;
- std::set<expr*> leafVarSet;
- std::map<int, std::set<expr*> > aloneVars;
-
- for (std::map<expr*, int>::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) {
- expr * freeVar = fvIt->first;
- // skip all regular expression vars
- if (regex_variable_set.find(freeVar) != regex_variable_set.end()) {
- continue;
- }
-
- // Iterate the EQC of freeVar, its eqc variable should not be in the eqcRepSet.
- // If found, have to filter it out
- std::set<expr*> eqVarSet;
- get_var_in_eqc(freeVar, eqVarSet);
- bool duplicated = false;
- expr * dupVar = NULL;
- for (std::set<expr*>::iterator itorEqv = eqVarSet.begin(); itorEqv != eqVarSet.end(); itorEqv++) {
- if (eqcRepSet.find(*itorEqv) != eqcRepSet.end()) {
- duplicated = true;
- dupVar = *itorEqv;
- break;
- }
- }
- if (duplicated && dupVar != NULL) {
- TRACE("str", tout << "Duplicated free variable found:" << mk_ismt2_pp(freeVar, m)
- << " = " << mk_ismt2_pp(dupVar, m) << " (SKIP)" << std::endl;);
- continue;
- } else {
- eqcRepSet.insert(freeVar);
- }
- }
-
- for (std::set<expr*>::iterator fvIt = eqcRepSet.begin(); fvIt != eqcRepSet.end(); fvIt++) {
- bool standAlone = true;
- expr * freeVar = *fvIt;
- // has length constraint initially
- if (input_var_in_len.find(freeVar) != input_var_in_len.end()) {
- standAlone = false;
- }
- // iterate parents
- if (standAlone) {
- // I hope this works!
- enode * e_freeVar = ctx.get_enode(freeVar);
- enode_vector::iterator it = e_freeVar->begin_parents();
- for (; it != e_freeVar->end_parents(); ++it) {
- expr * parentAst = (*it)->get_owner();
- if (u.str.is_concat(to_app(parentAst))) {
- standAlone = false;
- break;
- }
- }
- }
-
- if (standAlone) {
- rational len_value;
- bool len_value_exists = get_len_value(freeVar, len_value);
- if (len_value_exists) {
- leafVarSet.insert(freeVar);
- } else {
- aloneVars[-1].insert(freeVar);
- }
- } else {
- leafVarSet.insert(freeVar);
- }
- }
-
- for(std::set<expr*>::iterator itor1 = leafVarSet.begin();
- itor1 != leafVarSet.end(); ++itor1) {
- expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
- // gen_len_val_options_for_free_var() can legally return NULL,
- // as methods that it calls may assert their own axioms instead.
- if (toAssert != NULL) {
- assert_axiom(toAssert);
- }
- }
-
- for (std::map<int, std::set<expr*> >::iterator mItor = aloneVars.begin();
- mItor != aloneVars.end(); ++mItor) {
- std::set<expr*>::iterator itor2 = mItor->second.begin();
- for(; itor2 != mItor->second.end(); ++itor2) {
- expr * toAssert = gen_len_val_options_for_free_var(*itor2, NULL, "");
- // same deal with returning a NULL axiom here
- if(toAssert != NULL) {
- assert_axiom(toAssert);
- }
- }
- }
-}
-
-/*
- * Collect all unroll functions
- * and constant string in eqc of node n
- */
-void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet) {
- constStr = NULL;
- unrollFuncSet.clear();
- context & ctx = get_context();
-
- expr * curr = n;
- do {
- if (u.str.is_string(to_app(curr))) {
- constStr = curr;
- } else if (u.re.is_unroll(to_app(curr))) {
- if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
- unrollFuncSet.insert(curr);
+ // Iterate the EQC of freeVar, its eqc variable should not be in the eqcRepSet.
+ // If found, have to filter it out
+ std::set<expr*> eqVarSet;
+ get_var_in_eqc(freeVar, eqVarSet);
+ bool duplicated = false;
+ expr * dupVar = NULL;
+ for (std::set<expr*>::iterator itorEqv = eqVarSet.begin(); itorEqv != eqVarSet.end(); itorEqv++) {
+ if (eqcRepSet.find(*itorEqv) != eqcRepSet.end()) {
+ duplicated = true;
+ dupVar = *itorEqv;
+ break;
+ }
+ }
+ if (duplicated && dupVar != NULL) {
+ TRACE("str", tout << "Duplicated free variable found:" << mk_ismt2_pp(freeVar, m)
+ << " = " << mk_ismt2_pp(dupVar, m) << " (SKIP)" << std::endl;);
+ continue;
+ } else {
+ eqcRepSet.insert(freeVar);
}
}
- curr = get_eqc_next(curr);
- } while (curr != n);
-}
-// Collect simple Unroll functions (whose core is Str2Reg) and constant strings in the EQC of n.
-void theory_str::get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet) {
- constStr = NULL;
- unrollFuncSet.clear();
- context & ctx = get_context();
+ for (std::set<expr*>::iterator fvIt = eqcRepSet.begin(); fvIt != eqcRepSet.end(); fvIt++) {
+ bool standAlone = true;
+ expr * freeVar = *fvIt;
+ // has length constraint initially
+ if (input_var_in_len.find(freeVar) != input_var_in_len.end()) {
+ standAlone = false;
+ }
+ // iterate parents
+ if (standAlone) {
+ // I hope this works!
+ enode * e_freeVar = ctx.get_enode(freeVar);
+ enode_vector::iterator it = e_freeVar->begin_parents();
+ for (; it != e_freeVar->end_parents(); ++it) {
+ expr * parentAst = (*it)->get_owner();
+ if (u.str.is_concat(to_app(parentAst))) {
+ standAlone = false;
+ break;
+ }
+ }
+ }
- expr * curr = n;
- do {
- if (u.str.is_string(to_app(curr))) {
- constStr = curr;
- } else if (u.re.is_unroll(to_app(curr))) {
- expr * core = to_app(curr)->get_arg(0);
- if (u.re.is_to_re(to_app(core))) {
- if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
- unrollFuncSet.insert(curr);
- }
- }
- }
- curr = get_eqc_next(curr);
- } while (curr != n);
-}
+ if (standAlone) {
+ rational len_value;
+ bool len_value_exists = get_len_value(freeVar, len_value);
+ if (len_value_exists) {
+ leafVarSet.insert(freeVar);
+ } else {
+ aloneVars[-1].insert(freeVar);
+ }
+ } else {
+ leafVarSet.insert(freeVar);
+ }
+ }
-void theory_str::init_model(model_generator & mg) {
- //TRACE("str", tout << "initializing model" << std::endl; display(tout););
- m_factory = alloc(str_value_factory, get_manager(), get_family_id());
- mg.register_factory(m_factory);
-}
+ for(std::set<expr*>::iterator itor1 = leafVarSet.begin();
+ itor1 != leafVarSet.end(); ++itor1) {
+ expr * toAssert = gen_len_val_options_for_free_var(*itor1, NULL, "");
+ // gen_len_val_options_for_free_var() can legally return NULL,
+ // as methods that it calls may assert their own axioms instead.
+ if (toAssert != NULL) {
+ assert_axiom(toAssert);
+ }
+ }
-/*
- * Helper function for mk_value().
- * Attempts to resolve the expression 'n' to a string constant.
- * Stronger than get_eqc_value() in that it will perform recursive descent
- * through every subexpression and attempt to resolve those to concrete values as well.
- * Returns the concrete value obtained from this process,
- * guaranteed to satisfy m_strutil.is_string(),
- * if one could be obtained,
- * or else returns NULL if no concrete value was derived.
- */
-app * theory_str::mk_value_helper(app * n) {
- if (u.str.is_string(n)) {
- return n;
- } else if (u.str.is_concat(n)) {
- // recursively call this function on each argument
- SASSERT(n->get_num_args() == 2);
- expr * a0 = n->get_arg(0);
- expr * a1 = n->get_arg(1);
-
- app * a0_conststr = mk_value_helper(to_app(a0));
- app * a1_conststr = mk_value_helper(to_app(a1));
-
- if (a0_conststr != NULL && a1_conststr != NULL) {
- zstring a0_s, a1_s;
- u.str.is_string(a0_conststr, a0_s);
- u.str.is_string(a1_conststr, a1_s);
- zstring result = a0_s + a1_s;
- return to_app(mk_string(result));
+ for (std::map<int, std::set<expr*> >::iterator mItor = aloneVars.begin();
+ mItor != aloneVars.end(); ++mItor) {
+ std::set<expr*>::iterator itor2 = mItor->second.begin();
+ for(; itor2 != mItor->second.end(); ++itor2) {
+ expr * toAssert = gen_len_val_options_for_free_var(*itor2, NULL, "");
+ // same deal with returning a NULL axiom here
+ if(toAssert != NULL) {
+ assert_axiom(toAssert);
+ }
+ }
}
}
- // fallback path
- // try to find some constant string, anything, in the equivalence class of n
- bool hasEqc = false;
- expr * n_eqc = get_eqc_value(n, hasEqc);
- if (hasEqc) {
- return to_app(n_eqc);
- } else {
- return NULL;
+
+ /*
+ * Collect all unroll functions
+ * and constant string in eqc of node n
+ */
+ void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet) {
+ constStr = NULL;
+ unrollFuncSet.clear();
+ context & ctx = get_context();
+
+ expr * curr = n;
+ do {
+ if (u.str.is_string(to_app(curr))) {
+ constStr = curr;
+ } else if (u.re.is_unroll(to_app(curr))) {
+ if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
+ unrollFuncSet.insert(curr);
+ }
+ }
+ curr = get_eqc_next(curr);
+ } while (curr != n);
}
-}
-model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
- TRACE("str", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), get_manager()) <<
- " (sort " << mk_ismt2_pp(get_manager().get_sort(n->get_owner()), get_manager()) << ")" << std::endl;);
- ast_manager & m = get_manager();
- context & ctx = get_context();
- app_ref owner(m);
- owner = n->get_owner();
+ // Collect simple Unroll functions (whose core is Str2Reg) and constant strings in the EQC of n.
+ void theory_str::get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet) {
+ constStr = NULL;
+ unrollFuncSet.clear();
+ context & ctx = get_context();
- // If the owner is not internalized, it doesn't have an enode associated.
- SASSERT(ctx.e_internalized(owner));
-
- app * val = mk_value_helper(owner);
- if (val != NULL) {
- return alloc(expr_wrapper_proc, val);
- } else {
- TRACE("str", tout << "WARNING: failed to find a concrete value, falling back" << std::endl;);
- return alloc(expr_wrapper_proc, to_app(mk_string("**UNUSED**")));
+ expr * curr = n;
+ do {
+ if (u.str.is_string(to_app(curr))) {
+ constStr = curr;
+ } else if (u.re.is_unroll(to_app(curr))) {
+ expr * core = to_app(curr)->get_arg(0);
+ if (u.re.is_to_re(to_app(core))) {
+ if (unrollFuncSet.find(curr) == unrollFuncSet.end()) {
+ unrollFuncSet.insert(curr);
+ }
+ }
+ }
+ curr = get_eqc_next(curr);
+ } while (curr != n);
}
-}
-void theory_str::finalize_model(model_generator & mg) {}
+ void theory_str::init_model(model_generator & mg) {
+ //TRACE("str", tout << "initializing model" << std::endl; display(tout););
+ m_factory = alloc(str_value_factory, get_manager(), get_family_id());
+ mg.register_factory(m_factory);
+ }
-void theory_str::display(std::ostream & out) const {
- out << "TODO: theory_str display" << std::endl;
-}
+ /*
+ * Helper function for mk_value().
+ * Attempts to resolve the expression 'n' to a string constant.
+ * Stronger than get_eqc_value() in that it will perform recursive descent
+ * through every subexpression and attempt to resolve those to concrete values as well.
+ * Returns the concrete value obtained from this process,
+ * guaranteed to satisfy m_strutil.is_string(),
+ * if one could be obtained,
+ * or else returns NULL if no concrete value was derived.
+ */
+ app * theory_str::mk_value_helper(app * n) {
+ if (u.str.is_string(n)) {
+ return n;
+ } else if (u.str.is_concat(n)) {
+ // recursively call this function on each argument
+ SASSERT(n->get_num_args() == 2);
+ expr * a0 = n->get_arg(0);
+ expr * a1 = n->get_arg(1);
+
+ app * a0_conststr = mk_value_helper(to_app(a0));
+ app * a1_conststr = mk_value_helper(to_app(a1));
+
+ if (a0_conststr != NULL && a1_conststr != NULL) {
+ zstring a0_s, a1_s;
+ u.str.is_string(a0_conststr, a0_s);
+ u.str.is_string(a1_conststr, a1_s);
+ zstring result = a0_s + a1_s;
+ return to_app(mk_string(result));
+ }
+ }
+ // fallback path
+ // try to find some constant string, anything, in the equivalence class of n
+ bool hasEqc = false;
+ expr * n_eqc = get_eqc_value(n, hasEqc);
+ if (hasEqc) {
+ return to_app(n_eqc);
+ } else {
+ return NULL;
+ }
+ }
+
+ model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
+ TRACE("str", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), get_manager()) <<
+ " (sort " << mk_ismt2_pp(get_manager().get_sort(n->get_owner()), get_manager()) << ")" << std::endl;);
+ ast_manager & m = get_manager();
+ context & ctx = get_context();
+ app_ref owner(m);
+ owner = n->get_owner();
+
+ // If the owner is not internalized, it doesn't have an enode associated.
+ SASSERT(ctx.e_internalized(owner));
+
+ app * val = mk_value_helper(owner);
+ if (val != NULL) {
+ return alloc(expr_wrapper_proc, val);
+ } else {
+ TRACE("str", tout << "WARNING: failed to find a concrete value, falling back" << std::endl;);
+ return alloc(expr_wrapper_proc, to_app(mk_string("**UNUSED**")));
+ }
+ }
+
+ void theory_str::finalize_model(model_generator & mg) {}
+
+ void theory_str::display(std::ostream & out) const {
+ out << "TODO: theory_str display" << std::endl;
+ }
}; /* namespace smt */
From f904b033ad8f6db0eefe37ebfe40f1bd60b310e5 Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Fri, 5 May 2017 19:29:53 -0400
Subject: [PATCH 397/401] formatting theory_str.h
---
src/smt/theory_str.h | 1110 +++++++++++++++++++++---------------------
1 file changed, 555 insertions(+), 555 deletions(-)
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 7c2df9e12..2e6d96fa7 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -1,19 +1,19 @@
/*++
-Module Name:
+ Module Name:
- theory_str.h
+ theory_str.h
-Abstract:
+ Abstract:
- String Theory Plugin
+ String Theory Plugin
-Author:
+ Author:
- Murphy Berzish and Yunhui Zheng
+ Murphy Berzish and Yunhui Zheng
-Revision History:
+ Revision History:
---*/
+ --*/
#ifndef _THEORY_STR_H_
#define _THEORY_STR_H_
@@ -33,619 +33,619 @@ Revision History:
namespace smt {
- typedef hashtable<symbol, symbol_hash_proc, symbol_eq_proc> symbol_set;
+typedef hashtable<symbol, symbol_hash_proc, symbol_eq_proc> symbol_set;
- class str_value_factory : public value_factory {
- seq_util u;
- symbol_set m_strings;
- std::string delim;
- unsigned m_next;
- public:
- str_value_factory(ast_manager & m, family_id fid) :
- value_factory(m, fid),
- u(m), delim("!"), m_next(0) {}
- virtual ~str_value_factory() {}
- virtual expr * get_some_value(sort * s) {
- return u.str.mk_string(symbol("some value"));
- }
- virtual bool get_some_values(sort * s, expr_ref & v1, expr_ref & v2) {
- v1 = u.str.mk_string(symbol("value 1"));
- v2 = u.str.mk_string(symbol("value 2"));
- return true;
- }
- virtual expr * get_fresh_value(sort * s) {
- if (u.is_string(s)) {
- while (true) {
- std::ostringstream strm;
- strm << delim << std::hex << (m_next++) << std::dec << delim;
- symbol sym(strm.str().c_str());
- if (m_strings.contains(sym)) continue;
- m_strings.insert(sym);
- return u.str.mk_string(sym);
- }
+class str_value_factory : public value_factory {
+ seq_util u;
+ symbol_set m_strings;
+ std::string delim;
+ unsigned m_next;
+public:
+ str_value_factory(ast_manager & m, family_id fid) :
+ value_factory(m, fid),
+ u(m), delim("!"), m_next(0) {}
+ virtual ~str_value_factory() {}
+ virtual expr * get_some_value(sort * s) {
+ return u.str.mk_string(symbol("some value"));
+ }
+ virtual bool get_some_values(sort * s, expr_ref & v1, expr_ref & v2) {
+ v1 = u.str.mk_string(symbol("value 1"));
+ v2 = u.str.mk_string(symbol("value 2"));
+ return true;
+ }
+ virtual expr * get_fresh_value(sort * s) {
+ if (u.is_string(s)) {
+ while (true) {
+ std::ostringstream strm;
+ strm << delim << std::hex << (m_next++) << std::dec << delim;
+ symbol sym(strm.str().c_str());
+ if (m_strings.contains(sym)) continue;
+ m_strings.insert(sym);
+ return u.str.mk_string(sym);
}
- sort* seq = 0;
- if (u.is_re(s, seq)) {
- expr* v0 = get_fresh_value(seq);
- return u.re.mk_to_re(v0);
- }
- TRACE("t_str", tout << "unexpected sort in get_fresh_value(): " << mk_pp(s, m_manager) << std::endl;);
- UNREACHABLE(); return NULL;
}
- virtual void register_value(expr * n) { /* Ignore */ }
- };
+ sort* seq = 0;
+ if (u.is_re(s, seq)) {
+ expr* v0 = get_fresh_value(seq);
+ return u.re.mk_to_re(v0);
+ }
+ TRACE("t_str", tout << "unexpected sort in get_fresh_value(): " << mk_pp(s, m_manager) << std::endl;);
+ UNREACHABLE(); return NULL;
+ }
+ virtual void register_value(expr * n) { /* Ignore */ }
+};
- // rather than modify obj_pair_map I inherit from it and add my own helper methods
- class theory_str_contain_pair_bool_map_t : public obj_pair_map<expr, expr, expr*> {
- public:
- expr * operator[](std::pair<expr*, expr*> key) const {
- expr * value;
- bool found = this->find(key.first, key.second, value);
- if (found) {
- return value;
+// rather than modify obj_pair_map I inherit from it and add my own helper methods
+class theory_str_contain_pair_bool_map_t : public obj_pair_map<expr, expr, expr*> {
+public:
+ expr * operator[](std::pair<expr*, expr*> key) const {
+ expr * value;
+ bool found = this->find(key.first, key.second, value);
+ if (found) {
+ return value;
+ } else {
+ TRACE("t_str", tout << "WARNING: lookup miss in contain_pair_bool_map!" << std::endl;);
+ return NULL;
+ }
+ }
+
+ bool contains(std::pair<expr*, expr*> key) const {
+ expr * unused;
+ return this->find(key.first, key.second, unused);
+ }
+};
+
+template<typename Ctx>
+class binary_search_trail : public trail<Ctx> {
+ obj_map<expr, ptr_vector<expr> > & target;
+ expr * entry;
+public:
+ binary_search_trail(obj_map<expr, ptr_vector<expr> > & target, expr * entry) :
+ target(target), entry(entry) {}
+ virtual ~binary_search_trail() {}
+ virtual void undo(Ctx & ctx) {
+ TRACE("t_str_binary_search", tout << "in binary_search_trail::undo()" << std::endl;);
+ if (target.contains(entry)) {
+ if (!target[entry].empty()) {
+ target[entry].pop_back();
} else {
- TRACE("t_str", tout << "WARNING: lookup miss in contain_pair_bool_map!" << std::endl;);
- return NULL;
+ TRACE("t_str_binary_search", tout << "WARNING: attempt to remove length tester from an empty stack" << std::endl;);
}
+ } else {
+ TRACE("t_str_binary_search", tout << "WARNING: attempt to access length tester map via invalid key" << std::endl;);
}
+ }
+};
- bool contains(std::pair<expr*, expr*> key) const {
- expr * unused;
- return this->find(key.first, key.second, unused);
+
+class nfa {
+protected:
+ bool m_valid;
+ unsigned m_next_id;
+
+ unsigned next_id() {
+ unsigned retval = m_next_id;
+ ++m_next_id;
+ return retval;
+ }
+
+ unsigned m_start_state;
+ unsigned m_end_state;
+
+ std::map<unsigned, std::map<char, unsigned> > transition_map;
+ std::map<unsigned, std::set<unsigned> > epsilon_map;
+
+ void make_transition(unsigned start, char symbol, unsigned end) {
+ transition_map[start][symbol] = end;
+ }
+
+ void make_epsilon_move(unsigned start, unsigned end) {
+ epsilon_map[start].insert(end);
+ }
+
+ // Convert a regular expression to an e-NFA using Thompson's construction
+ void convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u);
+
+public:
+ nfa(seq_util & u, expr * e)
+: m_valid(true), m_next_id(0), m_start_state(0), m_end_state(0) {
+ convert_re(e, m_start_state, m_end_state, u);
+ }
+
+ nfa() : m_valid(false), m_next_id(0), m_start_state(0), m_end_state(0) {}
+
+ bool is_valid() const {
+ return m_valid;
+ }
+
+ void epsilon_closure(unsigned start, std::set<unsigned> & closure);
+
+ bool matches(zstring input);
+};
+
+class theory_str : public theory {
+ struct T_cut
+ {
+ int level;
+ std::map<expr*, int> vars;
+
+ T_cut() {
+ level = -100;
}
};
- template<typename Ctx>
- class binary_search_trail : public trail<Ctx> {
- obj_map<expr, ptr_vector<expr> > & target;
- expr * entry;
- public:
- binary_search_trail(obj_map<expr, ptr_vector<expr> > & target, expr * entry) :
- target(target), entry(entry) {}
- virtual ~binary_search_trail() {}
- virtual void undo(Ctx & ctx) {
- TRACE("t_str_binary_search", tout << "in binary_search_trail::undo()" << std::endl;);
- if (target.contains(entry)) {
- if (!target[entry].empty()) {
- target[entry].pop_back();
- } else {
- TRACE("t_str_binary_search", tout << "WARNING: attempt to remove length tester from an empty stack" << std::endl;);
- }
- } else {
- TRACE("t_str_binary_search", tout << "WARNING: attempt to access length tester map via invalid key" << std::endl;);
- }
+ typedef trail_stack<theory_str> th_trail_stack;
+ typedef union_find<theory_str> th_union_find;
+
+ typedef map<rational, expr*, obj_hash<rational>, default_eq<rational> > rational_map;
+ struct zstring_hash_proc {
+ unsigned operator()(zstring const & s) const {
+ return string_hash(s.encode().c_str(), static_cast<unsigned>(s.length()), 17);
}
};
+ typedef map<zstring, expr*, zstring_hash_proc, default_eq<zstring> > string_map;
+protected:
+ theory_str_params const & m_params;
- class nfa {
- protected:
- bool m_valid;
- unsigned m_next_id;
+ /*
+ * Setting EagerStringConstantLengthAssertions to true allows some methods,
+ * in particular internalize_term(), to add
+ * length assertions about relevant string constants.
+ * Note that currently this should always be set to 'true', or else *no* length assertions
+ * will be made about string constants.
+ */
+ bool opt_EagerStringConstantLengthAssertions;
- unsigned next_id() {
- unsigned retval = m_next_id;
- ++m_next_id;
- return retval;
+ /*
+ * If VerifyFinalCheckProgress is set to true, continuing after final check is invoked
+ * without asserting any new axioms is considered a bug and will throw an exception.
+ */
+ bool opt_VerifyFinalCheckProgress;
+
+ /*
+ * This constant controls how eagerly we expand unrolls in unbounded regex membership tests.
+ */
+ int opt_LCMUnrollStep;
+
+ /*
+ * If NoQuickReturn_IntegerTheory is set to true,
+ * integer theory integration checks that assert axioms
+ * will not return from the function after asserting their axioms.
+ * The default behaviour of Z3str2 is to set this to 'false'. This may be incorrect.
+ */
+ bool opt_NoQuickReturn_IntegerTheory;
+
+ /*
+ * If DisableIntegerTheoryIntegration is set to true,
+ * ALL calls to the integer theory integration methods
+ * (get_value, get_len_value, lower_bound, upper_bound)
+ * will ignore what the arithmetic solver believes about length terms,
+ * and will return no information.
+ *
+ * This reduces performance significantly, but can be useful to enable
+ * if it is suspected that string-integer integration, or the arithmetic solver itself,
+ * might have a bug.
+ *
+ * The default behaviour of Z3str2 is to set this to 'false'.
+ */
+ bool opt_DisableIntegerTheoryIntegration;
+
+ /*
+ * If DeferEQCConsistencyCheck is set to true,
+ * expensive calls to new_eq_check() will be deferred until final check,
+ * at which time the consistency of *all* string equivalence classes will be validated.
+ */
+ bool opt_DeferEQCConsistencyCheck;
+
+ /*
+ * If CheckVariableScope is set to true,
+ * pop_scope_eh() and final_check_eh() will run extra checks
+ * to determine whether the current assignment
+ * contains references to any internal variables that are no longer in scope.
+ */
+ bool opt_CheckVariableScope;
+
+ /*
+ * If ConcatOverlapAvoid is set to true,
+ * the check to simplify Concat = Concat in handle_equality() will
+ * avoid simplifying wrt. pairs of Concat terms that will immediately
+ * result in an overlap. (false = Z3str2 behaviour)
+ */
+ bool opt_ConcatOverlapAvoid;
+
+ bool search_started;
+ arith_util m_autil;
+ seq_util u;
+ int sLevel;
+
+ bool finalCheckProgressIndicator;
+
+ expr_ref_vector m_trail; // trail for generated terms
+
+ str_value_factory * m_factory;
+
+ // terms we couldn't go through set_up_axioms() with because they weren't internalized
+ expr_ref_vector m_delayed_axiom_setup_terms;
+
+ ptr_vector<enode> m_basicstr_axiom_todo;
+ svector<std::pair<enode*,enode*> > m_str_eq_todo;
+ ptr_vector<enode> m_concat_axiom_todo;
+ ptr_vector<enode> m_string_constant_length_todo;
+ ptr_vector<enode> m_concat_eval_todo;
+
+ // enode lists for library-aware/high-level string terms (e.g. substr, contains)
+ ptr_vector<enode> m_library_aware_axiom_todo;
+
+ // hashtable of all exprs for which we've already set up term-specific axioms --
+ // this prevents infinite recursive descent with respect to axioms that
+ // include an occurrence of the term for which axioms are being generated
+ obj_hashtable<expr> axiomatized_terms;
+
+ int tmpStringVarCount;
+ int tmpXorVarCount;
+ int tmpLenTestVarCount;
+ int tmpValTestVarCount;
+ std::map<std::pair<expr*, expr*>, std::map<int, expr*> > varForBreakConcat;
+
+ bool avoidLoopCut;
+ bool loopDetected;
+ obj_map<expr, std::stack<T_cut*> > cut_var_map;
+ expr_ref m_theoryStrOverlapAssumption_term;
+
+ obj_hashtable<expr> variable_set;
+ obj_hashtable<expr> internal_variable_set;
+ obj_hashtable<expr> regex_variable_set;
+ std::map<int, std::set<expr*> > internal_variable_scope_levels;
+
+ obj_hashtable<expr> internal_lenTest_vars;
+ obj_hashtable<expr> internal_valTest_vars;
+ obj_hashtable<expr> internal_unrollTest_vars;
+
+ obj_hashtable<expr> input_var_in_len;
+
+ obj_map<expr, unsigned int> fvar_len_count_map;
+ std::map<expr*, ptr_vector<expr> > fvar_lenTester_map;
+ obj_map<expr, expr*> lenTester_fvar_map;
+
+ std::map<expr*, std::map<int, svector<std::pair<int, expr*> > > > fvar_valueTester_map;
+ std::map<expr*, expr*> valueTester_fvar_map;
+
+ std::map<expr*, int_vector> val_range_map;
+
+ // This can't be an expr_ref_vector because the constructor is wrong,
+ // we would need to modify the allocator so we pass in ast_manager
+ std::map<expr*, std::map<std::set<expr*>, ptr_vector<expr> > > unroll_tries_map;
+ std::map<expr*, expr*> unroll_var_map;
+ std::map<std::pair<expr*, expr*>, expr*> concat_eq_unroll_ast_map;
+
+ expr_ref_vector contains_map;
+
+ theory_str_contain_pair_bool_map_t contain_pair_bool_map;
+ //obj_map<expr, obj_pair_set<expr, expr> > contain_pair_idx_map;
+ std::map<expr*, std::set<std::pair<expr*, expr*> > > contain_pair_idx_map;
+
+ std::map<std::pair<expr*, zstring>, expr*> regex_in_bool_map;
+ std::map<expr*, std::set<zstring> > regex_in_var_reg_str_map;
+
+ std::map<expr*, nfa> regex_nfa_cache; // Regex term --> NFA
+
+ char * char_set;
+ std::map<char, int> charSetLookupTable;
+ int charSetSize;
+
+ obj_pair_map<expr, expr, expr*> concat_astNode_map;
+
+ // all (str.to-int) and (int.to-str) terms
+ expr_ref_vector string_int_conversion_terms;
+ obj_hashtable<expr> string_int_axioms;
+
+ // used when opt_FastLengthTesterCache is true
+ rational_map lengthTesterCache;
+ // used when opt_FastValueTesterCache is true
+ string_map valueTesterCache;
+
+ string_map stringConstantCache;
+ unsigned long totalCacheAccessCount;
+ unsigned long cacheHitCount;
+ unsigned long cacheMissCount;
+
+ // cache mapping each string S to Length(S)
+ obj_map<expr, app*> length_ast_map;
+
+ th_union_find m_find;
+ th_trail_stack m_trail_stack;
+ theory_var get_var(expr * n) const;
+ expr * get_eqc_next(expr * n);
+ app * get_ast(theory_var i);
+
+ // binary search heuristic data
+ struct binary_search_info {
+ rational lowerBound;
+ rational midPoint;
+ rational upperBound;
+ rational windowSize;
+
+ binary_search_info() : lowerBound(rational::zero()), midPoint(rational::zero()),
+ upperBound(rational::zero()), windowSize(rational::zero()) {}
+ binary_search_info(rational lower, rational mid, rational upper, rational windowSize) :
+ lowerBound(lower), midPoint(mid), upperBound(upper), windowSize(windowSize) {}
+
+ void calculate_midpoint() {
+ midPoint = floor(lowerBound + ((upperBound - lowerBound) / rational(2)) );
}
-
- unsigned m_start_state;
- unsigned m_end_state;
-
- std::map<unsigned, std::map<char, unsigned> > transition_map;
- std::map<unsigned, std::set<unsigned> > epsilon_map;
-
- void make_transition(unsigned start, char symbol, unsigned end) {
- transition_map[start][symbol] = end;
- }
-
- void make_epsilon_move(unsigned start, unsigned end) {
- epsilon_map[start].insert(end);
- }
-
- // Convert a regular expression to an e-NFA using Thompson's construction
- void convert_re(expr * e, unsigned & start, unsigned & end, seq_util & u);
-
- public:
- nfa(seq_util & u, expr * e)
- : m_valid(true), m_next_id(0), m_start_state(0), m_end_state(0) {
- convert_re(e, m_start_state, m_end_state, u);
- }
-
- nfa() : m_valid(false), m_next_id(0), m_start_state(0), m_end_state(0) {}
-
- bool is_valid() const {
- return m_valid;
- }
-
- void epsilon_closure(unsigned start, std::set<unsigned> & closure);
-
- bool matches(zstring input);
};
+ // maps a free string var to a stack of active length testers.
+ // can use binary_search_trail to record changes to this object
+ obj_map<expr, ptr_vector<expr> > binary_search_len_tester_stack;
+ // maps a length tester var to the *active* search window
+ obj_map<expr, binary_search_info> binary_search_len_tester_info;
+ // maps a free string var to the first length tester to be (re)used
+ obj_map<expr, expr*> binary_search_starting_len_tester;
+ // maps a length tester to the next length tester to be (re)used if the split is "low"
+ obj_map<expr, expr*> binary_search_next_var_low;
+ // maps a length tester to the next length tester to be (re)used if the split is "high"
+ obj_map<expr, expr*> binary_search_next_var_high;
- class theory_str : public theory {
- struct T_cut
- {
- int level;
- std::map<expr*, int> vars;
+ // finite model finding data
+ // maps a finite model tester var to a list of variables that will be tested
+ obj_map<expr, ptr_vector<expr> > finite_model_test_varlists;
+protected:
+ void assert_axiom(expr * e);
+ void assert_implication(expr * premise, expr * conclusion);
+ expr * rewrite_implication(expr * premise, expr * conclusion);
- T_cut() {
- level = -100;
- }
- };
+ expr * mk_string(zstring const& str);
+ expr * mk_string(const char * str);
- typedef trail_stack<theory_str> th_trail_stack;
- typedef union_find<theory_str> th_union_find;
+ app * mk_strlen(expr * e);
+ expr * mk_concat(expr * n1, expr * n2);
+ expr * mk_concat_const_str(expr * n1, expr * n2);
+ app * mk_contains(expr * haystack, expr * needle);
+ app * mk_indexof(expr * haystack, expr * needle);
- typedef map<rational, expr*, obj_hash<rational>, default_eq<rational> > rational_map;
- struct zstring_hash_proc {
- unsigned operator()(zstring const & s) const {
- return string_hash(s.encode().c_str(), static_cast<unsigned>(s.length()), 17);
- }
- };
- typedef map<zstring, expr*, zstring_hash_proc, default_eq<zstring> > string_map;
+ literal mk_literal(expr* _e);
+ app * mk_int(int n);
+ app * mk_int(rational & q);
- protected:
- theory_str_params const & m_params;
+ void check_and_init_cut_var(expr * node);
+ void add_cut_info_one_node(expr * baseNode, int slevel, expr * node);
+ void add_cut_info_merge(expr * destNode, int slevel, expr * srcNode);
+ bool has_self_cut(expr * n1, expr * n2);
- /*
- * Setting EagerStringConstantLengthAssertions to true allows some methods,
- * in particular internalize_term(), to add
- * length assertions about relevant string constants.
- * Note that currently this should always be set to 'true', or else *no* length assertions
- * will be made about string constants.
- */
- bool opt_EagerStringConstantLengthAssertions;
+ // for ConcatOverlapAvoid
+ bool will_result_in_overlap(expr * lhs, expr * rhs);
- /*
- * If VerifyFinalCheckProgress is set to true, continuing after final check is invoked
- * without asserting any new axioms is considered a bug and will throw an exception.
- */
- bool opt_VerifyFinalCheckProgress;
+ void track_variable_scope(expr * var);
+ app * mk_str_var(std::string name);
+ app * mk_int_var(std::string name);
+ app * mk_nonempty_str_var();
+ app * mk_internal_xor_var();
+ expr * mk_internal_valTest_var(expr * node, int len, int vTries);
+ app * mk_regex_rep_var();
+ app * mk_unroll_bound_var();
+ app * mk_unroll_test_var();
+ void add_nonempty_constraint(expr * s);
- /*
- * This constant controls how eagerly we expand unrolls in unbounded regex membership tests.
- */
- int opt_LCMUnrollStep;
+ void instantiate_concat_axiom(enode * cat);
+ void try_eval_concat(enode * cat);
+ void instantiate_basic_string_axioms(enode * str);
+ void instantiate_str_eq_length_axiom(enode * lhs, enode * rhs);
- /*
- * If NoQuickReturn_IntegerTheory is set to true,
- * integer theory integration checks that assert axioms
- * will not return from the function after asserting their axioms.
- * The default behaviour of Z3str2 is to set this to 'false'. This may be incorrect.
- */
- bool opt_NoQuickReturn_IntegerTheory;
+ void instantiate_axiom_CharAt(enode * e);
+ void instantiate_axiom_prefixof(enode * e);
+ void instantiate_axiom_suffixof(enode * e);
+ void instantiate_axiom_Contains(enode * e);
+ void instantiate_axiom_Indexof(enode * e);
+ void instantiate_axiom_Indexof2(enode * e);
+ void instantiate_axiom_LastIndexof(enode * e);
+ void instantiate_axiom_Substr(enode * e);
+ void instantiate_axiom_Replace(enode * e);
+ void instantiate_axiom_str_to_int(enode * e);
+ void instantiate_axiom_int_to_str(enode * e);
- /*
- * If DisableIntegerTheoryIntegration is set to true,
- * ALL calls to the integer theory integration methods
- * (get_value, get_len_value, lower_bound, upper_bound)
- * will ignore what the arithmetic solver believes about length terms,
- * and will return no information.
- *
- * This reduces performance significantly, but can be useful to enable
- * if it is suspected that string-integer integration, or the arithmetic solver itself,
- * might have a bug.
- *
- * The default behaviour of Z3str2 is to set this to 'false'.
- */
- bool opt_DisableIntegerTheoryIntegration;
+ expr * mk_RegexIn(expr * str, expr * regexp);
+ void instantiate_axiom_RegexIn(enode * e);
+ app * mk_unroll(expr * n, expr * bound);
- /*
- * If DeferEQCConsistencyCheck is set to true,
- * expensive calls to new_eq_check() will be deferred until final check,
- * at which time the consistency of *all* string equivalence classes will be validated.
- */
- bool opt_DeferEQCConsistencyCheck;
+ void process_unroll_eq_const_str(expr * unrollFunc, expr * constStr);
+ void unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr);
+ void process_concat_eq_unroll(expr * concat, expr * unroll);
- /*
- * If CheckVariableScope is set to true,
- * pop_scope_eh() and final_check_eh() will run extra checks
- * to determine whether the current assignment
- * contains references to any internal variables that are no longer in scope.
- */
- bool opt_CheckVariableScope;
+ void set_up_axioms(expr * ex);
+ void handle_equality(expr * lhs, expr * rhs);
- /*
- * If ConcatOverlapAvoid is set to true,
- * the check to simplify Concat = Concat in handle_equality() will
- * avoid simplifying wrt. pairs of Concat terms that will immediately
- * result in an overlap. (false = Z3str2 behaviour)
- */
- bool opt_ConcatOverlapAvoid;
+ app * mk_value_helper(app * n);
+ expr * get_eqc_value(expr * n, bool & hasEqcValue);
+ expr * z3str2_get_eqc_value(expr * n , bool & hasEqcValue);
+ bool in_same_eqc(expr * n1, expr * n2);
+ expr * collect_eq_nodes(expr * n, expr_ref_vector & eqcSet);
- bool search_started;
- arith_util m_autil;
- seq_util u;
- int sLevel;
+ bool get_value(expr* e, rational& val) const;
+ bool get_len_value(expr* e, rational& val);
+ bool lower_bound(expr* _e, rational& lo);
+ bool upper_bound(expr* _e, rational& hi);
- bool finalCheckProgressIndicator;
-
- expr_ref_vector m_trail; // trail for generated terms
-
- str_value_factory * m_factory;
-
- // terms we couldn't go through set_up_axioms() with because they weren't internalized
- expr_ref_vector m_delayed_axiom_setup_terms;
-
- ptr_vector<enode> m_basicstr_axiom_todo;
- svector<std::pair<enode*,enode*> > m_str_eq_todo;
- ptr_vector<enode> m_concat_axiom_todo;
- ptr_vector<enode> m_string_constant_length_todo;
- ptr_vector<enode> m_concat_eval_todo;
-
- // enode lists for library-aware/high-level string terms (e.g. substr, contains)
- ptr_vector<enode> m_library_aware_axiom_todo;
-
- // hashtable of all exprs for which we've already set up term-specific axioms --
- // this prevents infinite recursive descent with respect to axioms that
- // include an occurrence of the term for which axioms are being generated
- obj_hashtable<expr> axiomatized_terms;
-
- int tmpStringVarCount;
- int tmpXorVarCount;
- int tmpLenTestVarCount;
- int tmpValTestVarCount;
- std::map<std::pair<expr*, expr*>, std::map<int, expr*> > varForBreakConcat;
-
- bool avoidLoopCut;
- bool loopDetected;
- obj_map<expr, std::stack<T_cut*> > cut_var_map;
- expr_ref m_theoryStrOverlapAssumption_term;
-
- obj_hashtable<expr> variable_set;
- obj_hashtable<expr> internal_variable_set;
- obj_hashtable<expr> regex_variable_set;
- std::map<int, std::set<expr*> > internal_variable_scope_levels;
-
- obj_hashtable<expr> internal_lenTest_vars;
- obj_hashtable<expr> internal_valTest_vars;
- obj_hashtable<expr> internal_unrollTest_vars;
-
- obj_hashtable<expr> input_var_in_len;
-
- obj_map<expr, unsigned int> fvar_len_count_map;
- std::map<expr*, ptr_vector<expr> > fvar_lenTester_map;
- obj_map<expr, expr*> lenTester_fvar_map;
-
- std::map<expr*, std::map<int, svector<std::pair<int, expr*> > > > fvar_valueTester_map;
- std::map<expr*, expr*> valueTester_fvar_map;
-
- std::map<expr*, int_vector> val_range_map;
-
- // This can't be an expr_ref_vector because the constructor is wrong,
- // we would need to modify the allocator so we pass in ast_manager
- std::map<expr*, std::map<std::set<expr*>, ptr_vector<expr> > > unroll_tries_map;
- std::map<expr*, expr*> unroll_var_map;
- std::map<std::pair<expr*, expr*>, expr*> concat_eq_unroll_ast_map;
-
- expr_ref_vector contains_map;
-
- theory_str_contain_pair_bool_map_t contain_pair_bool_map;
- //obj_map<expr, obj_pair_set<expr, expr> > contain_pair_idx_map;
- std::map<expr*, std::set<std::pair<expr*, expr*> > > contain_pair_idx_map;
-
- std::map<std::pair<expr*, zstring>, expr*> regex_in_bool_map;
- std::map<expr*, std::set<zstring> > regex_in_var_reg_str_map;
-
- std::map<expr*, nfa> regex_nfa_cache; // Regex term --> NFA
-
- char * char_set;
- std::map<char, int> charSetLookupTable;
- int charSetSize;
-
- obj_pair_map<expr, expr, expr*> concat_astNode_map;
-
- // all (str.to-int) and (int.to-str) terms
- expr_ref_vector string_int_conversion_terms;
- obj_hashtable<expr> string_int_axioms;
-
- // used when opt_FastLengthTesterCache is true
- rational_map lengthTesterCache;
- // used when opt_FastValueTesterCache is true
- string_map valueTesterCache;
-
- string_map stringConstantCache;
- unsigned long totalCacheAccessCount;
- unsigned long cacheHitCount;
- unsigned long cacheMissCount;
-
- // cache mapping each string S to Length(S)
- obj_map<expr, app*> length_ast_map;
-
- th_union_find m_find;
- th_trail_stack m_trail_stack;
- theory_var get_var(expr * n) const;
- expr * get_eqc_next(expr * n);
- app * get_ast(theory_var i);
-
- // binary search heuristic data
- struct binary_search_info {
- rational lowerBound;
- rational midPoint;
- rational upperBound;
- rational windowSize;
-
- binary_search_info() : lowerBound(rational::zero()), midPoint(rational::zero()),
- upperBound(rational::zero()), windowSize(rational::zero()) {}
- binary_search_info(rational lower, rational mid, rational upper, rational windowSize) :
- lowerBound(lower), midPoint(mid), upperBound(upper), windowSize(windowSize) {}
-
- void calculate_midpoint() {
- midPoint = floor(lowerBound + ((upperBound - lowerBound) / rational(2)) );
- }
- };
- // maps a free string var to a stack of active length testers.
- // can use binary_search_trail to record changes to this object
- obj_map<expr, ptr_vector<expr> > binary_search_len_tester_stack;
- // maps a length tester var to the *active* search window
- obj_map<expr, binary_search_info> binary_search_len_tester_info;
- // maps a free string var to the first length tester to be (re)used
- obj_map<expr, expr*> binary_search_starting_len_tester;
- // maps a length tester to the next length tester to be (re)used if the split is "low"
- obj_map<expr, expr*> binary_search_next_var_low;
- // maps a length tester to the next length tester to be (re)used if the split is "high"
- obj_map<expr, expr*> binary_search_next_var_high;
-
- // finite model finding data
- // maps a finite model tester var to a list of variables that will be tested
- obj_map<expr, ptr_vector<expr> > finite_model_test_varlists;
- protected:
- void assert_axiom(expr * e);
- void assert_implication(expr * premise, expr * conclusion);
- expr * rewrite_implication(expr * premise, expr * conclusion);
-
- expr * mk_string(zstring const& str);
- expr * mk_string(const char * str);
-
- app * mk_strlen(expr * e);
- expr * mk_concat(expr * n1, expr * n2);
- expr * mk_concat_const_str(expr * n1, expr * n2);
- app * mk_contains(expr * haystack, expr * needle);
- app * mk_indexof(expr * haystack, expr * needle);
-
- literal mk_literal(expr* _e);
- app * mk_int(int n);
- app * mk_int(rational & q);
-
- void check_and_init_cut_var(expr * node);
- void add_cut_info_one_node(expr * baseNode, int slevel, expr * node);
- void add_cut_info_merge(expr * destNode, int slevel, expr * srcNode);
- bool has_self_cut(expr * n1, expr * n2);
-
- // for ConcatOverlapAvoid
- bool will_result_in_overlap(expr * lhs, expr * rhs);
-
- void track_variable_scope(expr * var);
- app * mk_str_var(std::string name);
- app * mk_int_var(std::string name);
- app * mk_nonempty_str_var();
- app * mk_internal_xor_var();
- expr * mk_internal_valTest_var(expr * node, int len, int vTries);
- app * mk_regex_rep_var();
- app * mk_unroll_bound_var();
- app * mk_unroll_test_var();
- void add_nonempty_constraint(expr * s);
-
- void instantiate_concat_axiom(enode * cat);
- void try_eval_concat(enode * cat);
- void instantiate_basic_string_axioms(enode * str);
- void instantiate_str_eq_length_axiom(enode * lhs, enode * rhs);
-
- void instantiate_axiom_CharAt(enode * e);
- void instantiate_axiom_prefixof(enode * e);
- void instantiate_axiom_suffixof(enode * e);
- void instantiate_axiom_Contains(enode * e);
- void instantiate_axiom_Indexof(enode * e);
- void instantiate_axiom_Indexof2(enode * e);
- void instantiate_axiom_LastIndexof(enode * e);
- void instantiate_axiom_Substr(enode * e);
- void instantiate_axiom_Replace(enode * e);
- void instantiate_axiom_str_to_int(enode * e);
- void instantiate_axiom_int_to_str(enode * e);
-
- expr * mk_RegexIn(expr * str, expr * regexp);
- void instantiate_axiom_RegexIn(enode * e);
- app * mk_unroll(expr * n, expr * bound);
-
- void process_unroll_eq_const_str(expr * unrollFunc, expr * constStr);
- void unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr);
- void process_concat_eq_unroll(expr * concat, expr * unroll);
-
- void set_up_axioms(expr * ex);
- void handle_equality(expr * lhs, expr * rhs);
-
- app * mk_value_helper(app * n);
- expr * get_eqc_value(expr * n, bool & hasEqcValue);
- expr * z3str2_get_eqc_value(expr * n , bool & hasEqcValue);
- bool in_same_eqc(expr * n1, expr * n2);
- expr * collect_eq_nodes(expr * n, expr_ref_vector & eqcSet);
-
- bool get_value(expr* e, rational& val) const;
- bool get_len_value(expr* e, rational& val);
- bool lower_bound(expr* _e, rational& lo);
- bool upper_bound(expr* _e, rational& hi);
-
- bool can_two_nodes_eq(expr * n1, expr * n2);
- bool can_concat_eq_str(expr * concat, zstring& str);
- bool can_concat_eq_concat(expr * concat1, expr * concat2);
- bool check_concat_len_in_eqc(expr * concat);
- bool check_length_consistency(expr * n1, expr * n2);
- bool check_length_const_string(expr * n1, expr * constStr);
- bool check_length_eq_var_concat(expr * n1, expr * n2);
- bool check_length_concat_concat(expr * n1, expr * n2);
- bool check_length_concat_var(expr * concat, expr * var);
- bool check_length_var_var(expr * var1, expr * var2);
- void check_contain_in_new_eq(expr * n1, expr * n2);
- void check_contain_by_eqc_val(expr * varNode, expr * constNode);
- void check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass);
- void check_contain_by_eq_nodes(expr * n1, expr * n2);
- bool in_contain_idx_map(expr * n);
- void compute_contains(std::map<expr*, expr*> & varAliasMap,
- std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr *> & varConstMap,
- std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap);
- expr * dealias_node(expr * node, std::map<expr*, expr*> & varAliasMap, std::map<expr*, expr*> & concatAliasMap);
- void get_grounded_concats(expr* node, std::map<expr*, expr*> & varAliasMap,
- std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr*> & varConstMap,
- std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap,
- std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap);
- void print_grounded_concat(expr * node, std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap);
- void check_subsequence(expr* str, expr* strDeAlias, expr* subStr, expr* subStrDeAlias, expr* boolVar,
+ bool can_two_nodes_eq(expr * n1, expr * n2);
+ bool can_concat_eq_str(expr * concat, zstring& str);
+ bool can_concat_eq_concat(expr * concat1, expr * concat2);
+ bool check_concat_len_in_eqc(expr * concat);
+ bool check_length_consistency(expr * n1, expr * n2);
+ bool check_length_const_string(expr * n1, expr * constStr);
+ bool check_length_eq_var_concat(expr * n1, expr * n2);
+ bool check_length_concat_concat(expr * n1, expr * n2);
+ bool check_length_concat_var(expr * concat, expr * var);
+ bool check_length_var_var(expr * var1, expr * var2);
+ void check_contain_in_new_eq(expr * n1, expr * n2);
+ void check_contain_by_eqc_val(expr * varNode, expr * constNode);
+ void check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass);
+ void check_contain_by_eq_nodes(expr * n1, expr * n2);
+ bool in_contain_idx_map(expr * n);
+ void compute_contains(std::map<expr*, expr*> & varAliasMap,
+ std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr *> & varConstMap,
+ std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap);
+ expr * dealias_node(expr * node, std::map<expr*, expr*> & varAliasMap, std::map<expr*, expr*> & concatAliasMap);
+ void get_grounded_concats(expr* node, std::map<expr*, expr*> & varAliasMap,
+ std::map<expr*, expr*> & concatAliasMap, std::map<expr*, expr*> & varConstMap,
+ std::map<expr*, expr*> & concatConstMap, std::map<expr*, std::map<expr*, int> > & varEqConcatMap,
std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap);
- bool is_partial_in_grounded_concat(const std::vector<expr*> & strVec, const std::vector<expr*> & subStrVec);
+ void print_grounded_concat(expr * node, std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap);
+ void check_subsequence(expr* str, expr* strDeAlias, expr* subStr, expr* subStrDeAlias, expr* boolVar,
+ std::map<expr*, std::map<std::vector<expr*>, std::set<expr*> > > & groundedMap);
+ bool is_partial_in_grounded_concat(const std::vector<expr*> & strVec, const std::vector<expr*> & subStrVec);
- void get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList);
- expr * simplify_concat(expr * node);
+ void get_nodes_in_concat(expr * node, ptr_vector<expr> & nodeList);
+ expr * simplify_concat(expr * node);
- void simplify_parent(expr * nn, expr * eq_str);
+ void simplify_parent(expr * nn, expr * eq_str);
- void simplify_concat_equality(expr * lhs, expr * rhs);
- void solve_concat_eq_str(expr * concat, expr * str);
+ void simplify_concat_equality(expr * lhs, expr * rhs);
+ void solve_concat_eq_str(expr * concat, expr * str);
- void infer_len_concat_equality(expr * nn1, expr * nn2);
- bool infer_len_concat(expr * n, rational & nLen);
- void infer_len_concat_arg(expr * n, rational len);
+ void infer_len_concat_equality(expr * nn1, expr * nn2);
+ bool infer_len_concat(expr * n, rational & nLen);
+ void infer_len_concat_arg(expr * n, rational len);
- bool is_concat_eq_type1(expr * concatAst1, expr * concatAst2);
- bool is_concat_eq_type2(expr * concatAst1, expr * concatAst2);
- bool is_concat_eq_type3(expr * concatAst1, expr * concatAst2);
- bool is_concat_eq_type4(expr * concatAst1, expr * concatAst2);
- bool is_concat_eq_type5(expr * concatAst1, expr * concatAst2);
- bool is_concat_eq_type6(expr * concatAst1, expr * concatAst2);
+ bool is_concat_eq_type1(expr * concatAst1, expr * concatAst2);
+ bool is_concat_eq_type2(expr * concatAst1, expr * concatAst2);
+ bool is_concat_eq_type3(expr * concatAst1, expr * concatAst2);
+ bool is_concat_eq_type4(expr * concatAst1, expr * concatAst2);
+ bool is_concat_eq_type5(expr * concatAst1, expr * concatAst2);
+ bool is_concat_eq_type6(expr * concatAst1, expr * concatAst2);
- void process_concat_eq_type1(expr * concatAst1, expr * concatAst2);
- void process_concat_eq_type2(expr * concatAst1, expr * concatAst2);
- void process_concat_eq_type3(expr * concatAst1, expr * concatAst2);
- void process_concat_eq_type4(expr * concatAst1, expr * concatAst2);
- void process_concat_eq_type5(expr * concatAst1, expr * concatAst2);
- void process_concat_eq_type6(expr * concatAst1, expr * concatAst2);
+ void process_concat_eq_type1(expr * concatAst1, expr * concatAst2);
+ void process_concat_eq_type2(expr * concatAst1, expr * concatAst2);
+ void process_concat_eq_type3(expr * concatAst1, expr * concatAst2);
+ void process_concat_eq_type4(expr * concatAst1, expr * concatAst2);
+ void process_concat_eq_type5(expr * concatAst1, expr * concatAst2);
+ void process_concat_eq_type6(expr * concatAst1, expr * concatAst2);
- void print_cut_var(expr * node, std::ofstream & xout);
+ void print_cut_var(expr * node, std::ofstream & xout);
- void generate_mutual_exclusion(expr_ref_vector & exprs);
- void add_theory_aware_branching_info(expr * term, double priority, lbool phase);
+ void generate_mutual_exclusion(expr_ref_vector & exprs);
+ void add_theory_aware_branching_info(expr * term, double priority, lbool phase);
- bool new_eq_check(expr * lhs, expr * rhs);
- void group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts);
+ bool new_eq_check(expr * lhs, expr * rhs);
+ void group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts);
- int ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr*, int> & freeVarMap,
- std::map<expr*, std::set<expr*> > & unrollGroupMap, std::map<expr*, std::map<expr*, int> > & var_eq_concat_map);
- void trace_ctx_dep(std::ofstream & tout,
- std::map<expr*, expr*> & aliasIndexMap,
- std::map<expr*, expr*> & var_eq_constStr_map,
- std::map<expr*, std::map<expr*, int> > & var_eq_concat_map,
- std::map<expr*, std::map<expr*, int> > & var_eq_unroll_map,
- std::map<expr*, expr*> & concat_eq_constStr_map,
- std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map,
- std::map<expr*, std::set<expr*> > & unrollGroupMap);
+ int ctx_dep_analysis(std::map<expr*, int> & strVarMap, std::map<expr*, int> & freeVarMap,
+ std::map<expr*, std::set<expr*> > & unrollGroupMap, std::map<expr*, std::map<expr*, int> > & var_eq_concat_map);
+ void trace_ctx_dep(std::ofstream & tout,
+ std::map<expr*, expr*> & aliasIndexMap,
+ std::map<expr*, expr*> & var_eq_constStr_map,
+ std::map<expr*, std::map<expr*, int> > & var_eq_concat_map,
+ std::map<expr*, std::map<expr*, int> > & var_eq_unroll_map,
+ std::map<expr*, expr*> & concat_eq_constStr_map,
+ std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map,
+ std::map<expr*, std::set<expr*> > & unrollGroupMap);
- void classify_ast_by_type(expr * node, std::map<expr*, int> & varMap,
- std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
- void classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
- std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
+ void classify_ast_by_type(expr * node, std::map<expr*, int> & varMap,
+ std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
+ void classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
+ std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
- expr * mk_internal_lenTest_var(expr * node, int lTries);
- expr * gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, zstring lenTesterValue);
- void process_free_var(std::map<expr*, int> & freeVar_map);
- expr * gen_len_test_options(expr * freeVar, expr * indicator, int tries);
- expr * gen_free_var_options(expr * freeVar, expr * len_indicator,
- zstring len_valueStr, expr * valTesterInCbEq, zstring valTesterValueStr);
- expr * gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
- zstring lenStr, int tries);
- void print_value_tester_list(svector<std::pair<int, expr*> > & testerList);
- bool get_next_val_encode(int_vector & base, int_vector & next);
- zstring gen_val_string(int len, int_vector & encoding);
+ expr * mk_internal_lenTest_var(expr * node, int lTries);
+ expr * gen_len_val_options_for_free_var(expr * freeVar, expr * lenTesterInCbEq, zstring lenTesterValue);
+ void process_free_var(std::map<expr*, int> & freeVar_map);
+ expr * gen_len_test_options(expr * freeVar, expr * indicator, int tries);
+ expr * gen_free_var_options(expr * freeVar, expr * len_indicator,
+ zstring len_valueStr, expr * valTesterInCbEq, zstring valTesterValueStr);
+ expr * gen_val_options(expr * freeVar, expr * len_indicator, expr * val_indicator,
+ zstring lenStr, int tries);
+ void print_value_tester_list(svector<std::pair<int, expr*> > & testerList);
+ bool get_next_val_encode(int_vector & base, int_vector & next);
+ zstring gen_val_string(int len, int_vector & encoding);
- // binary search heuristic
- expr * binary_search_length_test(expr * freeVar, expr * previousLenTester, zstring previousLenTesterValue);
- expr_ref binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds, literal_vector & case_split_lits);
+ // binary search heuristic
+ expr * binary_search_length_test(expr * freeVar, expr * previousLenTester, zstring previousLenTesterValue);
+ expr_ref binary_search_case_split(expr * freeVar, expr * tester, binary_search_info & bounds, literal_vector & case_split_lits);
- bool free_var_attempt(expr * nn1, expr * nn2);
- void more_len_tests(expr * lenTester, zstring lenTesterValue);
- void more_value_tests(expr * valTester, zstring valTesterValue);
+ bool free_var_attempt(expr * nn1, expr * nn2);
+ void more_len_tests(expr * lenTester, zstring lenTesterValue);
+ void more_value_tests(expr * valTester, zstring valTesterValue);
- expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
- expr * getMostLeftNodeInConcat(expr * node);
- expr * getMostRightNodeInConcat(expr * node);
- void get_var_in_eqc(expr * n, std::set<expr*> & varSet);
- void get_concats_in_eqc(expr * n, std::set<expr*> & concats);
- void get_const_str_asts_in_node(expr * node, expr_ref_vector & constList);
- expr * eval_concat(expr * n1, expr * n2);
+ expr * get_alias_index_ast(std::map<expr*, expr*> & aliasIndexMap, expr * node);
+ expr * getMostLeftNodeInConcat(expr * node);
+ expr * getMostRightNodeInConcat(expr * node);
+ void get_var_in_eqc(expr * n, std::set<expr*> & varSet);
+ void get_concats_in_eqc(expr * n, std::set<expr*> & concats);
+ void get_const_str_asts_in_node(expr * node, expr_ref_vector & constList);
+ expr * eval_concat(expr * n1, expr * n2);
- bool finalcheck_str2int(app * a);
- bool finalcheck_int2str(app * a);
+ bool finalcheck_str2int(app * a);
+ bool finalcheck_int2str(app * a);
- // strRegex
+ // strRegex
- void get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet);
- void get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet);
- void gen_assign_unroll_reg(std::set<expr*> & unrolls);
- expr * gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls);
- expr * gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, zstring lcmStr);
- expr * gen_unroll_assign(expr * var, zstring lcmStr, expr * testerVar, int l, int h);
- void reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vector & items);
- void check_regex_in(expr * nn1, expr * nn2);
- zstring get_std_regex_str(expr * r);
+ void get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet);
+ void get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet);
+ void gen_assign_unroll_reg(std::set<expr*> & unrolls);
+ expr * gen_assign_unroll_Str2Reg(expr * n, std::set<expr*> & unrolls);
+ expr * gen_unroll_conditional_options(expr * var, std::set<expr*> & unrolls, zstring lcmStr);
+ expr * gen_unroll_assign(expr * var, zstring lcmStr, expr * testerVar, int l, int h);
+ void reduce_virtual_regex_in(expr * var, expr * regex, expr_ref_vector & items);
+ void check_regex_in(expr * nn1, expr * nn2);
+ zstring get_std_regex_str(expr * r);
- void dump_assignments();
- void initialize_charset();
+ void dump_assignments();
+ void initialize_charset();
- void check_variable_scope();
- void recursive_check_variable_scope(expr * ex);
+ void check_variable_scope();
+ void recursive_check_variable_scope(expr * ex);
- void collect_var_concat(expr * node, std::set<expr*> & varSet, std::set<expr*> & concatSet);
- bool propagate_length(std::set<expr*> & varSet, std::set<expr*> & concatSet, std::map<expr*, int> & exprLenMap);
- void get_unique_non_concat_nodes(expr * node, std::set<expr*> & argSet);
- bool propagate_length_within_eqc(expr * var);
+ void collect_var_concat(expr * node, std::set<expr*> & varSet, std::set<expr*> & concatSet);
+ bool propagate_length(std::set<expr*> & varSet, std::set<expr*> & concatSet, std::map<expr*, int> & exprLenMap);
+ void get_unique_non_concat_nodes(expr * node, std::set<expr*> & argSet);
+ bool propagate_length_within_eqc(expr * var);
- // TESTING
- void refresh_theory_var(expr * e);
+ // TESTING
+ void refresh_theory_var(expr * e);
- expr_ref set_up_finite_model_test(expr * lhs, expr * rhs);
- void finite_model_test(expr * v, expr * c);
+ expr_ref set_up_finite_model_test(expr * lhs, expr * rhs);
+ void finite_model_test(expr * v, expr * c);
- public:
- theory_str(ast_manager & m, theory_str_params const & params);
- virtual ~theory_str();
+public:
+ theory_str(ast_manager & m, theory_str_params const & params);
+ virtual ~theory_str();
- virtual char const * get_name() const { return "seq"; }
- virtual void display(std::ostream & out) const;
+ virtual char const * get_name() const { return "seq"; }
+ virtual void display(std::ostream & out) const;
- bool overlapping_variables_detected() const { return loopDetected; }
+ bool overlapping_variables_detected() const { return loopDetected; }
- th_trail_stack& get_trail_stack() { return m_trail_stack; }
- void merge_eh(theory_var, theory_var, theory_var v1, theory_var v2) {}
- void after_merge_eh(theory_var r1, theory_var r2, theory_var v1, theory_var v2) { }
- void unmerge_eh(theory_var v1, theory_var v2) {}
- protected:
- virtual bool internalize_atom(app * atom, bool gate_ctx);
- virtual bool internalize_term(app * term);
- virtual enode* ensure_enode(expr* e);
- virtual theory_var mk_var(enode * n);
+ th_trail_stack& get_trail_stack() { return m_trail_stack; }
+ void merge_eh(theory_var, theory_var, theory_var v1, theory_var v2) {}
+ void after_merge_eh(theory_var r1, theory_var r2, theory_var v1, theory_var v2) { }
+ void unmerge_eh(theory_var v1, theory_var v2) {}
+protected:
+ virtual bool internalize_atom(app * atom, bool gate_ctx);
+ virtual bool internalize_term(app * term);
+ virtual enode* ensure_enode(expr* e);
+ virtual theory_var mk_var(enode * n);
- virtual void new_eq_eh(theory_var, theory_var);
- virtual void new_diseq_eh(theory_var, theory_var);
+ virtual void new_eq_eh(theory_var, theory_var);
+ virtual void new_diseq_eh(theory_var, theory_var);
- virtual theory* mk_fresh(context*) { return alloc(theory_str, get_manager(), m_params); }
- virtual void init_search_eh();
- virtual void add_theory_assumptions(expr_ref_vector & assumptions);
- virtual lbool validate_unsat_core(expr_ref_vector & unsat_core);
- virtual void relevant_eh(app * n);
- virtual void assign_eh(bool_var v, bool is_true);
- virtual void push_scope_eh();
- virtual void pop_scope_eh(unsigned num_scopes);
- virtual void reset_eh();
+ virtual theory* mk_fresh(context*) { return alloc(theory_str, get_manager(), m_params); }
+ virtual void init_search_eh();
+ virtual void add_theory_assumptions(expr_ref_vector & assumptions);
+ virtual lbool validate_unsat_core(expr_ref_vector & unsat_core);
+ virtual void relevant_eh(app * n);
+ virtual void assign_eh(bool_var v, bool is_true);
+ virtual void push_scope_eh();
+ virtual void pop_scope_eh(unsigned num_scopes);
+ virtual void reset_eh();
- virtual bool can_propagate();
- virtual void propagate();
+ virtual bool can_propagate();
+ virtual void propagate();
- virtual final_check_status final_check_eh();
- virtual void attach_new_th_var(enode * n);
+ virtual final_check_status final_check_eh();
+ virtual void attach_new_th_var(enode * n);
- virtual void init_model(model_generator & m);
- virtual model_value_proc * mk_value(enode * n, model_generator & mg);
- virtual void finalize_model(model_generator & mg);
- };
+ virtual void init_model(model_generator & m);
+ virtual model_value_proc * mk_value(enode * n, model_generator & mg);
+ virtual void finalize_model(model_generator & mg);
+};
};
From 82bdd26817b611829d6417094f86cf3b964c15b0 Mon Sep 17 00:00:00 2001
From: Nikolaj Bjorner <nbjorner@microsoft.com>
Date: Sat, 6 May 2017 13:40:53 -0400
Subject: [PATCH 398/401] clean up some warnings
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
---
src/smt/theory_str.cpp | 16 +---------------
1 file changed, 1 insertion(+), 15 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 4a6a6da5b..d156005fd 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -1903,7 +1903,6 @@ namespace smt {
}
void theory_str::group_terms_by_eqc(expr * n, std::set<expr*> & concats, std::set<expr*> & vars, std::set<expr*> & consts) {
- context & ctx = get_context();
expr * eqcNode = n;
do {
app * ast = to_app(eqcNode);
@@ -4822,7 +4821,6 @@ namespace smt {
}
expr * theory_str::collect_eq_nodes(expr * n, expr_ref_vector & eqcSet) {
- context & ctx = get_context();
expr * constStrNode = NULL;
expr * ex = n;
@@ -4873,8 +4871,6 @@ namespace smt {
if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
TRACE("str", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
}
- // boolVar is actually a Contains term
- app * containsApp = to_app(boolVar);
// we only want to inspect the Contains terms where either of strAst or substrAst
// are equal to varNode.
@@ -5012,8 +5008,6 @@ namespace smt {
if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) {
TRACE("str", tout << "warning: no entry for boolVar in contain_pair_bool_map" << std::endl;);
}
- // boolVar is actually a Contains term
- app * containsApp = to_app(boolVar);
// we only want to inspect the Contains terms where either of strAst or substrAst
// are equal to varNode.
@@ -5421,7 +5415,6 @@ namespace smt {
return;
}
- context & ctx = get_context();
ast_manager & m = get_manager();
TRACE("str", tout << "consistency check for contains wrt. " << mk_pp(n1, m) << " and " << mk_pp(n2, m) << std::endl;);
@@ -6171,8 +6164,6 @@ namespace smt {
// Modified signature: returns true if nothing was learned, or false if at least one axiom was asserted.
// (This is used for deferred consistency checking)
bool theory_str::check_concat_len_in_eqc(expr * concat) {
- context & ctx = get_context();
-
bool no_assertions = true;
expr * eqc_n = concat;
@@ -7542,7 +7533,6 @@ namespace smt {
void theory_str::pop_scope_eh(unsigned num_scopes) {
sLevel -= num_scopes;
TRACE("str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;);
- context & ctx = get_context();
ast_manager & m = get_manager();
TRACE_CODE(if (is_trace_enabled("t_str_dump_assign_on_scope_change")) { dump_assignments(); });
@@ -10023,7 +10013,6 @@ namespace smt {
expr * theory_str::binary_search_length_test(expr * freeVar, expr * previousLenTester, zstring previousLenTesterValue) {
ast_manager & m = get_manager();
- context & ctx = get_context();
if (binary_search_len_tester_stack.contains(freeVar) && !binary_search_len_tester_stack[freeVar].empty()) {
TRACE("str", tout << "checking existing length testers for " << mk_pp(freeVar, m) << std::endl;
@@ -10353,7 +10342,6 @@ namespace smt {
}
void theory_str::get_concats_in_eqc(expr * n, std::set<expr*> & concats) {
- context & ctx = get_context();
expr * eqcNode = n;
do {
@@ -10502,7 +10490,6 @@ namespace smt {
void theory_str::get_eqc_simpleUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet) {
constStr = NULL;
unrollFuncSet.clear();
- context & ctx = get_context();
expr * curr = n;
do {
@@ -10571,12 +10558,11 @@ namespace smt {
TRACE("str", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), get_manager()) <<
" (sort " << mk_ismt2_pp(get_manager().get_sort(n->get_owner()), get_manager()) << ")" << std::endl;);
ast_manager & m = get_manager();
- context & ctx = get_context();
app_ref owner(m);
owner = n->get_owner();
// If the owner is not internalized, it doesn't have an enode associated.
- SASSERT(ctx.e_internalized(owner));
+ SASSERT(get_context().e_internalized(owner));
app * val = mk_value_helper(owner);
if (val != NULL) {
From e02392c0e3e8a52b2999990ec70466ce20a23384 Mon Sep 17 00:00:00 2001
From: Nikolaj Bjorner <nbjorner@microsoft.com>
Date: Sun, 7 May 2017 14:03:24 -0700
Subject: [PATCH 399/401] use skolem function to avoid exposing temporary
variables in models
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
---
src/smt/theory_str.cpp | 13 +++++++++----
src/smt/theory_str.h | 1 +
2 files changed, 10 insertions(+), 4 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index d156005fd..835f3b553 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -440,6 +440,11 @@ namespace smt {
return mk_int_var("$$_xor");
}
+ app * theory_str::mk_fresh_const(char const* name, sort* s) {
+ return u.mk_skolem(symbol(name), 0, 0, s);
+ }
+
+
app * theory_str::mk_int_var(std::string name) {
context & ctx = get_context();
ast_manager & m = get_manager();
@@ -447,7 +452,7 @@ namespace smt {
TRACE("str", tout << "creating integer variable " << name << " at scope level " << sLevel << std::endl;);
sort * int_sort = m.mk_sort(m_autil.get_family_id(), INT_SORT);
- app * a = m.mk_fresh_const(name.c_str(), int_sort);
+ app * a = mk_fresh_const(name.c_str(), int_sort);
ctx.internalize(a, false);
SASSERT(ctx.get_enode(a) != NULL);
@@ -482,7 +487,7 @@ namespace smt {
TRACE("str", tout << "creating string variable " << name << " at scope level " << sLevel << std::endl;);
sort * string_sort = u.str.mk_string_sort();
- app * a = m.mk_fresh_const(name.c_str(), string_sort);
+ app * a = mk_fresh_const(name.c_str(), string_sort);
TRACE("str", tout << "a->get_family_id() = " << a->get_family_id() << std::endl
<< "this->get_family_id() = " << this->get_family_id() << std::endl;);
@@ -509,7 +514,7 @@ namespace smt {
ast_manager & m = get_manager();
sort * string_sort = u.str.mk_string_sort();
- app * a = m.mk_fresh_const("regex", string_sort);
+ app * a = mk_fresh_const("regex", string_sort);
ctx.internalize(a, false);
SASSERT(ctx.get_enode(a) != NULL);
@@ -561,7 +566,7 @@ namespace smt {
TRACE("str", tout << "creating nonempty string variable " << name << " at scope level " << sLevel << std::endl;);
sort * string_sort = u.str.mk_string_sort();
- app * a = m.mk_fresh_const(name.c_str(), string_sort);
+ app * a = mk_fresh_const(name.c_str(), string_sort);
ctx.internalize(a, false);
SASSERT(ctx.get_enode(a) != NULL);
diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h
index 2e6d96fa7..0403b0623 100644
--- a/src/smt/theory_str.h
+++ b/src/smt/theory_str.h
@@ -403,6 +403,7 @@ protected:
expr * mk_concat_const_str(expr * n1, expr * n2);
app * mk_contains(expr * haystack, expr * needle);
app * mk_indexof(expr * haystack, expr * needle);
+ app * mk_fresh_const(char const* name, sort* s);
literal mk_literal(expr* _e);
app * mk_int(int n);
From 3ae722025f44b2c6df646264743a06fe57bf6d04 Mon Sep 17 00:00:00 2001
From: Nikolaj Bjorner <nbjorner@microsoft.com>
Date: Sun, 7 May 2017 14:54:47 -0700
Subject: [PATCH 400/401] relaxing condition for assumptions, add
theory-assumption to skolem functions
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
---
src/smt/smt_context.cpp | 9 ++++++++-
src/smt/theory_str.cpp | 4 ++--
2 files changed, 10 insertions(+), 3 deletions(-)
diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp
index 37a6d32b7..50b957331 100644
--- a/src/smt/smt_context.cpp
+++ b/src/smt/smt_context.cpp
@@ -3115,11 +3115,18 @@ namespace smt {
}
bool is_valid_assumption(ast_manager & m, expr * assumption) {
+ expr* arg;
if (!m.is_bool(assumption))
return false;
if (is_uninterp_const(assumption))
return true;
- if (m.is_not(assumption) && is_uninterp_const(to_app(assumption)->get_arg(0)))
+ if (m.is_not(assumption, arg) && is_uninterp_const(arg))
+ return true;
+ if (!is_app(assumption))
+ return false;
+ if (to_app(assumption)->get_num_args() == 0)
+ return true;
+ if (m.is_not(assumption, arg) && is_app(arg) && to_app(arg)->get_num_args() == 0)
return true;
return false;
}
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 835f3b553..128f93b11 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -7351,10 +7351,10 @@ namespace smt {
void theory_str::add_theory_assumptions(expr_ref_vector & assumptions) {
TRACE("str", tout << "add overlap assumption for theory_str" << std::endl;);
- symbol strOverlap("!!TheoryStrOverlapAssumption!!");
+ char* strOverlap = "!!TheoryStrOverlapAssumption!!";
seq_util m_sequtil(get_manager());
sort * s = get_manager().mk_bool_sort();
- m_theoryStrOverlapAssumption_term = expr_ref(get_manager().mk_const(strOverlap, s), get_manager());
+ m_theoryStrOverlapAssumption_term = expr_ref(mk_fresh_const(strOverlap, s), get_manager());
assumptions.push_back(get_manager().mk_not(m_theoryStrOverlapAssumption_term));
}
From 6b2a800c7fb14a504ece5fb0eae574c8cd7f1f4a Mon Sep 17 00:00:00 2001
From: Murphy Berzish <murphy.berzish@gmail.com>
Date: Sun, 7 May 2017 18:23:47 -0400
Subject: [PATCH 401/401] fix warnings: unused variables, string constants
---
src/smt/theory_str.cpp | 19 +++----------------
1 file changed, 3 insertions(+), 16 deletions(-)
diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp
index 128f93b11..818aca29a 100644
--- a/src/smt/theory_str.cpp
+++ b/src/smt/theory_str.cpp
@@ -4844,7 +4844,6 @@ namespace smt {
* Collect constant strings (from left to right) in an AST node.
*/
void theory_str::get_const_str_asts_in_node(expr * node, expr_ref_vector & astList) {
- ast_manager & m = get_manager();
if (u.str.is_string(node)) {
astList.push_back(node);
//} else if (getNodeType(t, node) == my_Z3_Func) {
@@ -5519,7 +5518,6 @@ namespace smt {
// ---------------------------------------------------------
context & ctx = get_context();
- ast_manager & m = get_manager();
// const strings: node is de-aliased
if (u.str.is_string(node)) {
@@ -7351,7 +7349,7 @@ namespace smt {
void theory_str::add_theory_assumptions(expr_ref_vector & assumptions) {
TRACE("str", tout << "add overlap assumption for theory_str" << std::endl;);
- char* strOverlap = "!!TheoryStrOverlapAssumption!!";
+ const char* strOverlap = "!!TheoryStrOverlapAssumption!!";
seq_util m_sequtil(get_manager());
sort * s = get_manager().mk_bool_sort();
m_theoryStrOverlapAssumption_term = expr_ref(mk_fresh_const(strOverlap, s), get_manager());
@@ -7359,8 +7357,6 @@ namespace smt {
}
lbool theory_str::validate_unsat_core(expr_ref_vector & unsat_core) {
- bool assumptionFound = false;
-
app * target_term = to_app(get_manager().mk_not(m_theoryStrOverlapAssumption_term));
get_context().internalize(target_term, false);
for (unsigned i = 0; i < unsat_core.size(); ++i) {
@@ -7372,7 +7368,6 @@ namespace smt {
e2 = get_context().get_enode(core_term);
if (e1 == e2) {
TRACE("str", tout << "overlap detected in unsat core, changing UNSAT to UNKNOWN" << std::endl;);
- assumptionFound = true;
return l_undef;
}
}
@@ -7483,7 +7478,6 @@ namespace smt {
}
void theory_str::recursive_check_variable_scope(expr * ex) {
- context & ctx = get_context();
ast_manager & m = get_manager();
if (is_app(ex)) {
@@ -7551,7 +7545,7 @@ namespace smt {
std::stack<T_cut*> & val = cut_var_map[varItor->m_key];
while ((val.size() > 0) && (val.top()->level != 0) && (val.top()->level >= sLevel)) {
TRACE("str", tout << "remove cut info for " << mk_pp(e, m) << std::endl; print_cut_var(e, tout););
- T_cut * aCut = val.top();
+ // T_cut * aCut = val.top();
val.pop();
// dealloc(aCut);
}
@@ -8571,8 +8565,6 @@ namespace smt {
return;
}
if (u.str.is_concat(aNode)) {
- expr * arg0 = aNode->get_arg(0);
- expr * arg1 = aNode->get_arg(1);
if (concatSet.find(node) == concatSet.end()) {
concatSet.insert(node);
}
@@ -8592,7 +8584,6 @@ namespace smt {
TRACE("str", tout << "propagate_length_within_eqc: " << mk_ismt2_pp(var, m) << std::endl ;);
- enode * n_eq_enode = ctx.get_enode(var);
rational varLen;
if (! get_len_value(var, varLen)) {
bool hasLen = false;
@@ -8686,7 +8677,6 @@ namespace smt {
expr * var = *it;
rational lenValue;
expr_ref varlen (mk_strlen(var), m) ;
- bool allLeafResolved = true;
if (! get_value(varlen, lenValue)) {
if (propagate_length_within_eqc(var)) {
axiomAdded = true;
@@ -8806,7 +8796,7 @@ namespace smt {
bool concat_lhs_haseqc, concat_rhs_haseqc, var_haseqc;
expr * concat_lhs_str = get_eqc_value(concat_lhs, concat_lhs_haseqc);
expr * concat_rhs_str = get_eqc_value(concat_rhs, concat_rhs_haseqc);
- expr * var_str = get_eqc_value(var, var_haseqc);
+ get_eqc_value(var, var_haseqc);
if (concat_lhs_haseqc && concat_rhs_haseqc && !var_haseqc) {
TRACE("str", tout << "backpropagate into " << mk_pp(var, m) << " = " << mk_pp(concat, m) << std::endl
<< "LHS ~= " << mk_pp(concat_lhs_str, m) << " RHS ~= " << mk_pp(concat_rhs_str, m) << std::endl;);
@@ -10358,8 +10348,6 @@ namespace smt {
}
void theory_str::get_var_in_eqc(expr * n, std::set<expr*> & varSet) {
- context & ctx = get_context();
-
expr * eqcNode = n;
do {
if (variable_set.find(eqcNode) != variable_set.end()) {
@@ -10476,7 +10464,6 @@ namespace smt {
void theory_str::get_eqc_allUnroll(expr * n, expr * &constStr, std::set<expr*> & unrollFuncSet) {
constStr = NULL;
unrollFuncSet.clear();
- context & ctx = get_context();
expr * curr = n;
do {