bool PreRegisterVisitor::alreadyVisited(TNode current, TNode parent) {
Debug("register::internal") << "PreRegisterVisitor::alreadyVisited(" << current << "," << parent << ")" << std::endl;
if( ( parent.getKind() == kind::FORALL ||
parent.getKind() == kind::EXISTS ||
parent.getKind() == kind::REWRITE_RULE /*||
parent.getKind() == kind::CARDINALITY_CONSTRAINT*/ ) &&
current != parent ) {
Debug("register::internal") << "quantifier:true" << std::endl;
return true;
}
TheoryId currentTheoryId = Theory::theoryOf(current);
TheoryId parentTheoryId = Theory::theoryOf(parent);
d_theories = Theory::setInsert(currentTheoryId, d_theories);
d_theories = Theory::setInsert(parentTheoryId, d_theories);
// Should we use the theory of the type
bool useType = current != parent && currentTheoryId != parentTheoryId;
// Get the theories that have already visited this node
TNodeToTheorySetMap::iterator find = d_visited.find(current);
if (find == d_visited.end()) {
if (useType) {
TheoryId typeTheoryId = Theory::theoryOf(current.getType());
d_theories = Theory::setInsert(typeTheoryId, d_theories);
}
return false;
}
Theory::Set visitedTheories = (*find).second;
if (Theory::setContains(currentTheoryId, visitedTheories)) {
// The current theory has already visited it, so now it depends on the parent and the type
if (Theory::setContains(parentTheoryId, visitedTheories)) {
if (useType) {
TheoryId typeTheoryId = Theory::theoryOf(current.getType());
d_theories = Theory::setInsert(typeTheoryId, d_theories);
return Theory::setContains(typeTheoryId, visitedTheories);
} else {
return true;
}
} else {
return false;
}
} else {
return false;
}
}
bool ITESimplifier::leavesAreConst(TNode e, TheoryId tid)
{
Assert((e.getKind() == kind::ITE && !e.getType().isBoolean()) ||
Theory::theoryOf(e) != THEORY_BOOL);
if (e.isConst()) {
return true;
}
hash_map<Node, bool, NodeHashFunction>::iterator it;
it = d_leavesConstCache.find(e);
if (it != d_leavesConstCache.end()) {
return (*it).second;
}
if (!containsTermITE(e) && Theory::isLeafOf(e, tid)) {
d_leavesConstCache[e] = false;
return false;
}
Assert(e.getNumChildren() > 0);
size_t k = 0, sz = e.getNumChildren();
if (e.getKind() == kind::ITE) {
k = 1;
}
for (; k < sz; ++k) {
if (!leavesAreConst(e[k], tid)) {
d_leavesConstCache[e] = false;
return false;
}
}
d_leavesConstCache[e] = true;
return true;
}
prop::SatValue BVQuickCheck::checkSat(std::vector<Node>& assumptions, unsigned long budget) {
Node conflict;
for (unsigned i = 0; i < assumptions.size(); ++i) {
TNode a = assumptions[i];
Assert (a.getType().isBoolean());
d_bitblaster->bbAtom(a);
bool ok = d_bitblaster->assertToSat(a, false);
if (!ok) {
setConflict();
return SAT_VALUE_FALSE;
}
}
if (budget == 0) {
bool ok = d_bitblaster->propagate();
if (!ok) {
setConflict();
return SAT_VALUE_FALSE;
}
return SAT_VALUE_UNKNOWN; // could check if assignment is full and return SAT_VALUE_TRUE
}
prop::SatValue res = d_bitblaster->solveWithBudget(budget);
if (res == SAT_VALUE_FALSE) {
setConflict();
return res;
}
// could be unknown or could be sat
return res;
}
Node CandidateGeneratorQEAll::getNextCandidate() {
while( !d_eq.isFinished() ){
TNode n = (*d_eq);
++d_eq;
if( n.getType().isSubtypeOf( d_match_pattern_type ) ){
TNode nh = d_qe->getTermDatabase()->getEligibleTermInEqc( n );
if( !nh.isNull() ){
if( options::instMaxLevel()!=-1 || options::lteRestrictInstClosure() ){
nh = d_qe->getEqualityQuery()->getInternalRepresentative( nh, d_f, d_index );
//don't consider this if already the instantiation is ineligible
if( !d_qe->getTermDatabase()->isTermEligibleForInstantiation( nh, d_f, false ) ){
nh = Node::null();
}
}
if( !nh.isNull() ){
d_firstTime = false;
//an equivalence class with the same type as the pattern, return it
return nh;
}
}
}
}
if( d_firstTime ){
Assert( d_qe->getTermDatabase()->d_type_map[d_match_pattern_type].empty() );
//must return something
d_firstTime = false;
return d_qe->getTermDatabase()->getModelBasisTerm( d_match_pattern_type );
}
return Node::null();
}
void ArrayInfo::addIndex(const Node a, const TNode i) {
Assert(a.getType().isArray());
Assert(!i.getType().isArray()); // temporary for flat arrays
Trace("arrays-ind")<<"Arrays::addIndex "<<a<<"["<<i<<"]\n";
CTNodeList* temp_indices;
Info* temp_info;
CNodeInfoMap::iterator it = info_map.find(a);
if(it == info_map.end()) {
temp_indices = new(true) CTNodeList(ct);
temp_indices->push_back(i);
temp_info = new Info(ct, bck);
temp_info->indices = temp_indices;
info_map[a] = temp_info;
} else {
temp_indices = (*it).second->indices;
if (! inList(temp_indices, i)) {
temp_indices->push_back(i);
}
}
if(Trace.isOn("arrays-ind")) {
printList((*(info_map.find(a))).second->indices);
}
}
Node CVC4::theory::bv::mergeExplanations(const std::vector<Node>& expls) {
TNodeSet literals;
for (unsigned i = 0; i < expls.size(); ++i) {
TNode expl = expls[i];
Assert (expl.getType().isBoolean());
if (expl.getKind() == kind::AND) {
for (unsigned i = 0; i < expl.getNumChildren(); ++i) {
TNode child = expl[i];
if (child == utils::mkTrue())
continue;
literals.insert(child);
}
} else if (expl != utils::mkTrue()) {
literals.insert(expl);
}
}
if (literals.size() == 0)
return utils::mkTrue();
if (literals.size() == 1)
return *literals.begin();
NodeBuilder<> nb(kind::AND);
for (TNodeSet::const_iterator it = literals.begin(); it!= literals.end(); ++it) {
nb << *it;
}
return nb;
}
string QueryEvaluator::fillResult(TNode * node, int value) {
string name = node->getValue();
string type = table.getType(name);
// special case
if (type==KEYWORD_CALL) {
if (node->getNumChildren()!=0) {
TNode * attr = node->getChildAtIndex(0);
if (attr->getType()==Attr &&
attr->getValue()=="procName") {
value = PKB::getCalledProc(value);
type=KEYWORD_PROCEDURE;
}
}
}
if (type==KEYWORD_PROCEDURE) {
return PKB::getProcName(value);
} else if (type==KEYWORD_VAR) {
return PKB::getVarName(value);
} else if (type==KEYWORD_CONST) {
return PKB::getConstName(value);
} else if (type==KEYWORD_PROG_LINE || SyntaxHelper::isStmtSymbol(type)) {
return to_string((long long)value);
} else {
}
return "-1";
}
void PropEngine::requirePhase(TNode n, bool phase) {
Debug("prop") << "requirePhase(" << n << ", " << phase << ")" << endl;
Assert(n.getType().isBoolean());
SatLiteral lit = d_cnfStream->getLiteral(n);
d_satSolver->requirePhase(phase ? lit : ~lit);
}
void BVToBool::addToLiftCache(TNode term, Node new_term)
{
Assert(new_term != Node());
Assert(!hasLiftCache(term));
Assert(term.getType() == new_term.getType());
d_liftCache[term] = new_term;
}
Node AbstractionModule::abstractSignatures(TNode assertion) {
Debug("bv-abstraction") << "AbstractionModule::abstractSignatures "<< assertion <<"\n";
// assume the assertion has been fully abstracted
Node signature = getGeneralizedSignature(assertion);
Debug("bv-abstraction") << " with sig "<< signature <<"\n";
NodeNodeMap::iterator it = d_signatureToFunc.find(signature);
if (it!= d_signatureToFunc.end()) {
std::vector<Node> args;
TNode func = it->second;
// pushing the function symbol
args.push_back(func);
TNodeSet seen;
collectArguments(assertion, signature, args, seen);
std::vector<TNode> real_args;
for (unsigned i = 1; i < args.size(); ++i) {
real_args.push_back(args[i]);
}
d_argsTable.addEntry(func, real_args);
Node result = utils::mkNode(kind::EQUAL, utils::mkNode(kind::APPLY_UF, args),
utils::mkConst(1, 1u));
Debug("bv-abstraction") << "=> "<< result << "\n";
Assert (result.getType() == assertion.getType());
return result;
}
return assertion;
}
void TheoryUF::preRegisterTerm(TNode node) {
Debug("uf") << "TheoryUF::preRegisterTerm(" << node << ")" << std::endl;
if (d_thss != NULL) {
d_thss->preRegisterTerm(node);
}
switch (node.getKind()) {
case kind::EQUAL:
// Add the trigger for equality
d_equalityEngine.addTriggerEquality(node);
break;
case kind::APPLY_UF:
// Maybe it's a predicate
if (node.getType().isBoolean()) {
// Get triggered for both equal and dis-equal
d_equalityEngine.addTriggerPredicate(node);
} else {
// Function applications/predicates
d_equalityEngine.addTerm(node);
}
// Remember the function and predicate terms
d_functionsTerms.push_back(node);
break;
case kind::CARDINALITY_CONSTRAINT:
case kind::COMBINED_CARDINALITY_CONSTRAINT:
//do nothing
break;
default:
// Variables etc
d_equalityEngine.addTerm(node);
break;
}
}/* TheoryUF::preRegisterTerm() */
bool AbstractionModule::isLemmaAtom(TNode node) const {
Assert (node.getType().isBoolean());
node = node.getKind() == kind::NOT? node[0] : node;
return d_inputAtoms.find(node) == d_inputAtoms.end() &&
d_lemmaAtoms.find(node) != d_lemmaAtoms.end();
}
Node BvToBoolPreprocessor::liftNode(TNode current) {
Node result;
if (hasLiftCache(current)) {
result = getLiftCache(current);
}else if (isConvertibleBvAtom(current)) {
result = convertBvAtom(current);
addToLiftCache(current, result);
} else {
if (current.getNumChildren() == 0) {
result = current;
} else {
NodeBuilder<> builder(current.getKind());
if (current.getMetaKind() == kind::metakind::PARAMETERIZED) {
builder << current.getOperator();
}
for (unsigned i = 0; i < current.getNumChildren(); ++i) {
Node converted = liftNode(current[i]);
Assert (converted.getType() == current[i].getType());
builder << converted;
}
result = builder;
addToLiftCache(current, result);
}
}
Assert (result != Node());
Assert(result.getType() == current.getType());
Debug("bv-to-bool") << "BvToBoolPreprocessor::liftNode " << current << " => \n" << result << "\n";
return result;
}
Node ITESimplifier::createSimpContext(TNode c, Node& iteNode, Node& simpVar)
{
NodeMap::iterator it;
it = d_simpContextCache.find(c);
if (it != d_simpContextCache.end()) {
return (*it).second;
}
if (!containsTermITE(c)) {
d_simpContextCache[c] = c;
return c;
}
if (c.getKind() == kind::ITE && !c.getType().isBoolean()) {
// Currently only support one ite node in a simp context
// Return Null if more than one is found
if (!iteNode.isNull()) {
return Node();
}
simpVar = getSimpVar(c.getType());
if (simpVar.isNull()) {
return Node();
}
d_simpContextCache[c] = simpVar;
iteNode = c;
return simpVar;
}
NodeBuilder<> builder(c.getKind());
if (c.getMetaKind() == kind::metakind::PARAMETERIZED) {
builder << c.getOperator();
}
unsigned i = 0;
for (; i < c.getNumChildren(); ++ i) {
Node newChild = createSimpContext(c[i], iteNode, simpVar);
if (newChild.isNull()) {
return newChild;
}
builder << newChild;
}
// Mark the substitution and continue
Node result = builder;
d_simpContextCache[c] = result;
return result;
}
/* Call during quantifier engine's check */
void QuantDSplit::check( Theory::Effort e, unsigned quant_e ) {
//add lemmas ASAP (they are a reduction)
if( quant_e==QuantifiersEngine::QEFFORT_CONFLICT ){
std::vector< Node > lemmas;
for(std::map< Node, int >::iterator it = d_quant_to_reduce.begin(); it != d_quant_to_reduce.end(); ++it) {
Node q = it->first;
if( d_added_split.find( q )==d_added_split.end() ){
d_added_split.insert( q );
std::vector< Node > bvs;
for( unsigned i=0; i<q[0].getNumChildren(); i++ ){
if( (int)i!=it->second ){
bvs.push_back( q[0][i] );
}
}
std::vector< Node > disj;
disj.push_back( q.negate() );
TNode svar = q[0][it->second];
TypeNode tn = svar.getType();
if( tn.isDatatype() ){
std::vector< Node > cons;
const Datatype& dt = ((DatatypeType)(tn).toType()).getDatatype();
for( unsigned j=0; j<dt.getNumConstructors(); j++ ){
std::vector< Node > vars;
for( unsigned k=0; k<dt[j].getNumArgs(); k++ ){
TypeNode tns = TypeNode::fromType( dt[j][k].getRangeType() );
Node v = NodeManager::currentNM()->mkBoundVar( tns );
vars.push_back( v );
}
std::vector< Node > bvs_cmb;
bvs_cmb.insert( bvs_cmb.end(), bvs.begin(), bvs.end() );
bvs_cmb.insert( bvs_cmb.end(), vars.begin(), vars.end() );
vars.insert( vars.begin(), Node::fromExpr( dt[j].getConstructor() ) );
Node c = NodeManager::currentNM()->mkNode( kind::APPLY_CONSTRUCTOR, vars );
TNode ct = c;
Node body = q[1].substitute( svar, ct );
if( !bvs_cmb.empty() ){
body = NodeManager::currentNM()->mkNode( kind::FORALL, NodeManager::currentNM()->mkNode( kind::BOUND_VAR_LIST, bvs_cmb ), body );
}
cons.push_back( body );
}
Node conc = cons.size()==1 ? cons[0] : NodeManager::currentNM()->mkNode( kind::AND, cons );
disj.push_back( conc );
}else{
Assert( false );
}
lemmas.push_back( disj.size()==1 ? disj[0] : NodeManager::currentNM()->mkNode( kind::OR, disj ) );
}
}
//add lemmas to quantifiers engine
for( unsigned i=0; i<lemmas.size(); i++ ){
Trace("quant-dsplit") << "QuantDSplit lemma : " << lemmas[i] << std::endl;
d_quantEngine->addLemma( lemmas[i], false );
}
d_quant_to_reduce.clear();
}
}
void AlgebraicSolver::collectModelInfo(TheoryModel* model, bool fullModel) {
Debug("bitvector-model") << "AlgebraicSolver::collectModelInfo\n";
AlwaysAssert (!d_quickSolver->inConflict());
set<Node> termSet;
d_bv->computeRelevantTerms(termSet);
// collect relevant terms that the bv theory abstracts to variables
// (variables and parametric terms such as select apply_uf)
std::vector<TNode> variables;
std::vector<Node> values;
for (set<Node>::const_iterator it = termSet.begin(); it != termSet.end(); ++it) {
TNode term = *it;
if (term.getType().isBitVector() &&
(term.getMetaKind() == kind::metakind::VARIABLE ||
Theory::theoryOf(term) != THEORY_BV)) {
variables.push_back(term);
values.push_back(term);
}
}
NodeSet leaf_vars;
Debug("bitvector-model") << "Substitutions:\n";
for (unsigned i = 0; i < variables.size(); ++i) {
TNode current = variables[i];
TNode subst = Rewriter::rewrite(d_modelMap->apply(current));
Debug("bitvector-model") << " " << current << " => " << subst << "\n";
values[i] = subst;
utils::collectVariables(subst, leaf_vars);
}
Debug("bitvector-model") << "Model:\n";
for (NodeSet::const_iterator it = leaf_vars.begin(); it != leaf_vars.end(); ++it) {
TNode var = *it;
Node value = d_quickSolver->getVarValue(var, true);
Assert (!value.isNull() || !fullModel);
// may be a shared term that did not appear in the current assertions
if (!value.isNull()) {
Debug("bitvector-model") << " " << var << " => " << value << "\n";
Assert (value.getKind() == kind::CONST_BITVECTOR);
d_modelMap->addSubstitution(var, value);
}
}
Debug("bitvector-model") << "Final Model:\n";
for (unsigned i = 0; i < variables.size(); ++i) {
TNode current = values[i];
TNode subst = Rewriter::rewrite(d_modelMap->apply(current));
Debug("bitvector-model") << "AlgebraicSolver: " << variables[i] << " => " << subst << "\n";
// Doesn't have to be constant as it may be irrelevant
Assert (subst.getKind() == kind::CONST_BITVECTOR);
model->assertEquality(variables[i], subst, true);
}
}
bool BvToBoolPreprocessor::isConvertibleBvTerm(TNode node) {
if (!node.getType().isBitVector() ||
node.getType().getBitVectorSize() != 1)
return false;
Kind kind = node.getKind();
if (kind == kind::CONST_BITVECTOR ||
kind == kind::ITE ||
kind == kind::BITVECTOR_AND ||
kind == kind::BITVECTOR_OR ||
kind == kind::BITVECTOR_NOT ||
kind == kind::BITVECTOR_XOR ||
kind == kind::BITVECTOR_COMP) {
return true;
}
return false;
}
bool BVQuickCheck::addAssertion(TNode assertion) {
Assert (assertion.getType().isBoolean());
d_bitblaster->bbAtom(assertion);
// assert to sat solver and run bcp to detect easy conflicts
bool ok = d_bitblaster->assertToSat(assertion, true);
if (!ok) {
setConflict();
}
return ok;
}
Node BvToBoolPreprocessor::convertBvAtom(TNode node) {
Assert (node.getType().isBoolean() &&
node.getKind() == kind::EQUAL);
Assert (utils::getSize(node[0]) == 1);
Assert (utils::getSize(node[1]) == 1);
Node a = convertBvTerm(node[0]);
Node b = convertBvTerm(node[1]);
Node result = utils::mkNode(kind::IFF, a, b);
Debug("bv-to-bool") << "BvToBoolPreprocessor::convertBvAtom " << node <<" => " << result << "\n";
++(d_statistics.d_numAtomsLifted);
return result;
}
void ArrayInfo::setModelRep(const TNode a, const TNode b) {
Assert(a.getType().isArray());
Info* temp_info;
CNodeInfoMap::iterator it = info_map.find(a);
if(it == info_map.end()) {
temp_info = new Info(ct, bck);
temp_info->modelRep = b;
info_map[a] = temp_info;
} else {
(*it).second->modelRep = b;
}
}
void ArrayInfo::setRIntro1Applied(const TNode a) {
Assert(a.getType().isArray());
Info* temp_info;
CNodeInfoMap::iterator it = info_map.find(a);
if(it == info_map.end()) {
temp_info = new Info(ct, bck);
temp_info->rIntro1Applied = true;
info_map[a] = temp_info;
} else {
(*it).second->rIntro1Applied = true;
}
}
void ArrayInfo::addInStore(const TNode a, const TNode b){
Trace("arrays-addinstore")<<"Arrays::addInStore "<<a<<" ~ "<<b<<"\n";
Assert(a.getType().isArray());
Assert(b.getType().isArray());
CTNodeList* temp_inst;
Info* temp_info;
CNodeInfoMap::iterator it = info_map.find(a);
if(it == info_map.end()) {
temp_inst = new(true) CTNodeList(ct);
temp_inst->push_back(b);
temp_info = new Info(ct, bck);
temp_info->in_stores = temp_inst;
info_map[a] = temp_info;
} else {
temp_inst = (*it).second->in_stores;
if(! inList(temp_inst, b)) {
temp_inst->push_back(b);
}
}
};
Node BVToBool::convertBvAtom(TNode node)
{
Assert(node.getType().isBoolean() && node.getKind() == kind::EQUAL);
Assert(bv::utils::getSize(node[0]) == 1);
Assert(bv::utils::getSize(node[1]) == 1);
Node a = convertBvTerm(node[0]);
Node b = convertBvTerm(node[1]);
Node result = NodeManager::currentNM()->mkNode(kind::EQUAL, a, b);
Debug("bv-to-bool") << "BVToBool::convertBvAtom " << node << " => " << result
<< "\n";
++(d_statistics.d_numAtomsLifted);
return result;
}
Node ModelPostprocessor::rewriteAs(TNode n, TypeNode asType) {
if(n.getType().isSubtypeOf(asType)) {
// good to go, we have the right type
return n;
}
if(!n.isConst()) {
// we don't handle non-const right now
return n;
}
if(asType.isBoolean()) {
if(n.getType().isBitVector(1u)) {
// type mismatch: should only happen for Boolean-term conversion under
// datatype constructor applications; rewrite from BV(1) back to Boolean
bool tf = (n.getConst<BitVector>().getValue() == 1);
return NodeManager::currentNM()->mkConst(tf);
}
if(n.getType().isDatatype() && n.getType().hasAttribute(BooleanTermAttr())) {
// type mismatch: should only happen for Boolean-term conversion under
// datatype constructor applications; rewrite from datatype back to Boolean
Assert(n.getKind() == kind::APPLY_CONSTRUCTOR);
Assert(n.getNumChildren() == 0);
// we assume (by construction) false is first; see boolean_terms.cpp
bool tf = (Datatype::indexOf(n.getOperator().toExpr()) == 1);
Debug("boolean-terms") << "+++ rewriteAs " << n << " : " << asType << " ==> " << tf << endl;
return NodeManager::currentNM()->mkConst(tf);
}
}
if(n.getType().isBoolean()) {
bool tf = n.getConst<bool>();
if(asType.isBitVector(1u)) {
return NodeManager::currentNM()->mkConst(BitVector(1u, tf ? 1u : 0u));
}
if(asType.isDatatype() && asType.hasAttribute(BooleanTermAttr())) {
const Datatype& asDatatype = asType.getConst<Datatype>();
return NodeManager::currentNM()->mkNode(kind::APPLY_CONSTRUCTOR, (tf ? asDatatype[0] : asDatatype[1]).getConstructor());
}
}
if(n.getType().isRecord() && asType.isRecord()) {
Debug("boolean-terms") << "+++ got a record - rewriteAs " << n << " : " << asType << endl;
const Record& rec CVC4_UNUSED = n.getType().getConst<Record>();
const Record& asRec = asType.getConst<Record>();
Assert(rec.getNumFields() == asRec.getNumFields());
Assert(n.getNumChildren() == asRec.getNumFields());
NodeBuilder<> b(n.getKind());
b << asType;
for(size_t i = 0; i < n.getNumChildren(); ++i) {
b << rewriteAs(n[i], TypeNode::fromType(asRec[i].second));
}
Node out = b;
Debug("boolean-terms") << "+++ returning record " << out << endl;
return out;
}
void Theory::computeCareGraph() {
Debug("sharing") << "Theory::computeCareGraph<" << getId() << ">()" << endl;
for (unsigned i = 0; i < d_sharedTerms.size(); ++ i) {
TNode a = d_sharedTerms[i];
TypeNode aType = a.getType();
for (unsigned j = i + 1; j < d_sharedTerms.size(); ++ j) {
TNode b = d_sharedTerms[j];
if (b.getType() != aType) {
// We don't care about the terms of different types
continue;
}
switch (d_valuation.getEqualityStatus(a, b)) {
case EQUALITY_TRUE_AND_PROPAGATED:
case EQUALITY_FALSE_AND_PROPAGATED:
// If we know about it, we should have propagated it, so we can skip
break;
default:
// Let's split on it
addCarePair(a, b);
break;
}
}
}
}
void AbstractionModule::collectArgumentTypes(TNode sig, std::vector<TypeNode>& types, TNodeSet& seen) {
if (seen.find(sig) != seen.end())
return;
if (sig.getKind() == kind::SKOLEM) {
types.push_back(sig.getType());
seen.insert(sig);
return;
}
for (unsigned i = 0; i < sig.getNumChildren(); ++i) {
collectArgumentTypes(sig[i], types, seen);
seen.insert(sig);
}
}
Node PropEngine::getValue(TNode node) const {
Assert(node.getType().isBoolean());
Assert(d_cnfStream->hasLiteral(node));
SatLiteral lit = d_cnfStream->getLiteral(node);
SatValue v = d_satSolver->value(lit);
if(v == SAT_VALUE_TRUE) {
return NodeManager::currentNM()->mkConst(true);
} else if(v == SAT_VALUE_FALSE) {
return NodeManager::currentNM()->mkConst(false);
} else {
Assert(v == SAT_VALUE_UNKNOWN);
return Node::null();
}
}
void PreRegisterVisitor::visit(TNode current, TNode parent) {
Debug("register") << "PreRegisterVisitor::visit(" << current << "," << parent << ")" << std::endl;
if (Debug.isOn("register::internal")) {
Debug("register::internal") << toString() << std::endl;
}
// Get the theories of the terms
TheoryId currentTheoryId = Theory::theoryOf(current);
TheoryId parentTheoryId = Theory::theoryOf(parent);
// Should we use the theory of the type
bool useType = current != parent && currentTheoryId != parentTheoryId;
Theory::Set visitedTheories = d_visited[current];
Debug("register::internal") << "PreRegisterVisitor::visit(" << current << "," << parent << "): previously registered with " << Theory::setToString(visitedTheories) << std::endl;
if (!Theory::setContains(currentTheoryId, visitedTheories)) {
visitedTheories = Theory::setInsert(currentTheoryId, visitedTheories);
d_visited[current] = visitedTheories;
Theory* th = d_engine->theoryOf(currentTheoryId);
th->preRegisterTerm(current);
Debug("register::internal") << "PreRegisterVisitor::visit(" << current << "," << parent << "): adding " << currentTheoryId << std::endl;
}
if (!Theory::setContains(parentTheoryId, visitedTheories)) {
visitedTheories = Theory::setInsert(parentTheoryId, visitedTheories);
d_visited[current] = visitedTheories;
Theory* th = d_engine->theoryOf(parentTheoryId);
th->preRegisterTerm(current);
Debug("register::internal") << "PreRegisterVisitor::visit(" << current << "," << parent << "): adding " << parentTheoryId << std::endl;
}
if (useType) {
TheoryId typeTheoryId = Theory::theoryOf(current.getType());
if (!Theory::setContains(typeTheoryId, visitedTheories)) {
visitedTheories = Theory::setInsert(typeTheoryId, visitedTheories);
d_visited[current] = visitedTheories;
Theory* th = d_engine->theoryOf(typeTheoryId);
th->preRegisterTerm(current);
Debug("register::internal") << "PreRegisterVisitor::visit(" << current << "," << parent << "): adding " << parentTheoryId << std::endl;
}
}
Debug("register::internal") << "PreRegisterVisitor::visit(" << current << "," << parent << "): now registered with " << Theory::setToString(visitedTheories) << std::endl;
Assert(d_visited.find(current) != d_visited.end());
Assert(alreadyVisited(current, parent));
}
vector<string> QueryEvaluator::getSymbolsUsedBy(TNode * node) {
vector<string> results;
int size = node->getNumChildren();
for (int i=0; i<size; i++) {
TNode * child = node->getChildAtIndex(i);
if (child->getType()==QuerySymbol) {
results.push_back(child->getValue());
}
vector<string> sub_results = getSymbolsUsedBy(child);
for (size_t j=0; j<sub_results.size(); j++) {
if (find(results.begin(), results.end(), sub_results[j])==results.end())
results.push_back(sub_results[j]);
}
}
return results;
}
bool PropEngine::hasValue(TNode node, bool& value) const {
Assert(node.getType().isBoolean());
Assert(d_cnfStream->hasLiteral(node));
SatLiteral lit = d_cnfStream->getLiteral(node);
SatValue v = d_satSolver->value(lit);
if(v == SAT_VALUE_TRUE) {
value = true;
return true;
} else if(v == SAT_VALUE_FALSE) {
value = false;
return true;
} else {
Assert(v == SAT_VALUE_UNKNOWN);
return false;
}
}
