PTRef Logic::mkConst(SRef s, const char* name) {
vec<SRef> sort_args;
sort_args.push(s);
const char* msg;
SymRef sr = newSymb(name, sort_args, &msg);
if (sr == SymRef_Undef) {
cerr << "Warning: while mkConst " << name << ": " << msg << endl;
assert(symNameToRef(name).size() == 1);
sr = symNameToRef(name)[0];
}
vec<PTRef> tmp;
PTRef ptr = insertTerm(sr, tmp, &msg);
assert (ptr != PTRef_Undef);
return ptr;
}
// The vec argument might be sorted!
PTRef Logic::resolveTerm(const char* s, vec<PTRef>& args, char** msg) {
SymRef sref = term_store.lookupSymbol(s, args);
if (sref == SymRef_Undef) {
asprintf(msg, "Unknown symbol %s", s);
return PTRef_Undef;
}
assert(sref != SymRef_Undef);
simplify(sref, args);
PTRef rval;
const char** msg2 = NULL;
if (sref == SymRef_Undef)
rval = PTRef_Undef;
else
rval = insertTerm(sref, args, msg2);
if (msg2 != NULL)
asprintf(msg, "%s", *msg2);
return rval;
}
//
// Wrapper for simplify. After running this, the reference should be checked
// for other occurrences since simplification might result in duplicate terms.
//
// In order to avoid duplicate appearances of terms making solving after
// cnfization slow a simplifyTree should be called to the subtree after calling
// the method.
//
void Logic::simplify(PTRef& tr) {
Pterm& t = getPterm(tr);
vec<PTRef> args;
for (int i = 0; i < t.size(); i++)
args.push(t[i]);
SymRef sr = t.symb();
SymRef sr_prev = sr;
simplify(sr, args);
const char** msg;
// The if statement is not strictly speaking necessary, since checking for
// duplicates needs to be performed anyway after this step
if (sr != sr_prev && sr == getSym_true())
tr = getTerm_true();
else if (sr != sr_prev && sr == getSym_false())
tr = getTerm_false();
else
tr = insertTerm(sr, args, msg);
}
PTRef Logic::mkFun(SymRef f, vec<PTRef>& args, const char** msg)
{
return insertTerm(f, args, msg);
}
// The constructor initiates the base logic (Boolean)
Logic::Logic(SMTConfig& c, SStore& s, SymStore& t, PtStore& pt) :
config(c)
, sort_store(s)
, sym_store(t)
, term_store(pt)
, is_set(false)
{
sort_store.insertStore(new Sort(*(new Identifier("Bool"))));
sort_BOOL = sort_store["Bool 0"];
vec<SRef> params;
params.push(sort_store["Bool 0"]);
SymRef tr;
const char* msg;
tr = sym_store.newSymb(tk_true, params, &msg);
if (tr == SymRef_Undef) { assert(false); }
sym_store[tr].setNoScoping();
sym_TRUE = tr;
vec<PTRef> tmp;
term_TRUE = insertTerm(sym_TRUE, tmp, &msg);
assert(term_TRUE != PTRef_Undef);
tr = sym_store.newSymb(tk_false, params, &msg);
if (tr == SymRef_Undef) { assert(false); }
sym_store[tr].setNoScoping();
sym_FALSE = tr;
term_FALSE = insertTerm(sym_FALSE, tmp, &msg);
assert(term_FALSE != PTRef_Undef);
params.push(sort_store["Bool 0"]);
tr = sym_store.newSymb(tk_not, params, &msg);
if (tr == SymRef_Undef) { assert(false); }
sym_store[tr].setNoScoping();
sym_NOT = tr;
params.push(sort_store["Bool 0"]);
tr = sym_store.newSymb(tk_equals, params, &msg);
if (tr == SymRef_Undef) { assert(false); }
if (sym_store[tr].setRightAssoc() == false) { assert(false); } // TODO: Remove and clean
sym_store[tr].setNoScoping();
sym_store[tr].setCommutes();
sym_EQ = tr;
equalities.insert(sym_EQ, true);
tr = sym_store.newSymb(tk_implies, params, &msg);
if (tr == SymRef_Undef) { assert(false); }
if (sym_store[tr].setRightAssoc() == false) { assert(false); } // TODO: Remove and clean
sym_store[tr].setNoScoping();
sym_IMPLIES = tr;
tr = sym_store.newSymb(tk_and, params, &msg);
if (tr == SymRef_Undef) { assert(false); }
if (sym_store[tr].setLeftAssoc() == false) assert(false);
sym_store[tr].setNoScoping();
sym_store[tr].setCommutes();
sym_AND = tr;
tr = sym_store.newSymb(tk_or, params, &msg);
if (tr == SymRef_Undef) { assert(false); }
if (sym_store[tr].setLeftAssoc() == false) assert(false);
sym_store[tr].setNoScoping();
sym_store[tr].setCommutes();
sym_OR = tr;
tr = sym_store.newSymb(tk_xor, params, &msg);
if (tr == SymRef_Undef) { assert(false); }
if (sym_store[tr].setLeftAssoc() == false) assert(false);
sym_store[tr].setCommutes();
sym_store[tr].setNoScoping();
sym_XOR = tr;
tr = sym_store.newSymb(tk_distinct, params, &msg);
if (tr == SymRef_Undef) { assert(false); }
if (sym_store[tr].setPairwise() == false) assert(false);
sym_store[tr].setNoScoping();
sym_store[tr].setCommutes();
sym_DISTINCT = tr;
params.push(sort_store["Bool 0"]);
tr = sym_store.newSymb(tk_ite, params, &msg);
if (tr == SymRef_Undef) { assert(false); }
sym_store[tr].setNoScoping();
sym_ITE = tr;
ites.insert(tr, true);
}
poly::poly(int c[], int e[], int size)
{
for (int i=0; i<size; i++)
insertTerm(c[i], e[i]);
//polynomial.selectionSortList(); //orders the link in descending order based on exponent
}
