bool VCCmd::evaluateNext()
{
readAgain:
if(d_parser->done()) return false; // No more commands
Expr e;
try {
TRACE_MSG("commands", "** [commands] Parsing command...");
e = d_parser->next();
TRACE("commands verbose", "evaluateNext(", e, ")");
}
catch(Exception& e) {
cerr << "*** " << e << endl;
IF_DEBUG(++(debugger.counter("parse errors"));)
}
// The parser may return a Null Expr in case of parse errors or end
// of file. The right thing to do is to ignore it and repeat
// reading.
if(e.isNull()) {
TRACE_MSG("commands", "** [commands] Null command; read again");
goto readAgain;
}
if( d_vc->getFlags()["parse-only"].getBool() ) {
TRACE_MSG("commands", "** [commands] parse-only; skipping evaluateCommand");
goto readAgain;
}
return evaluateCommand(e);
}
void SymbolTable::bind(const std::string& name, Expr obj,
bool levelZero) throw() {
PrettyCheckArgument(!obj.isNull(), obj, "cannot bind to a null Expr");
ExprManagerScope ems(obj);
if(levelZero) d_exprMap->insertAtContextLevelZero(name, obj);
else d_exprMap->insert(name, obj);
}
bool Expr::operator>(const Expr& e) const {
Assert(d_node != NULL, "Unexpected NULL expression pointer!");
Assert(e.d_node != NULL, "Unexpected NULL expression pointer!");
if(isNull() && !e.isNull()) {
return true;
}
ExprManagerScope ems(*this);
return *d_node > *e.d_node;
}
SatLiteral TheoryProxy::getNextReplayDecision() {
#ifdef CVC4_REPLAY
if(options::replayStream() != NULL) {
Expr e = options::replayStream()->nextExpr();
if(!e.isNull()) { // we get null node when out of decisions to replay
// convert & return
++d_replayedDecisions;
return d_cnfStream->getLiteral(e);
}
}
#endif /* CVC4_REPLAY */
return undefSatLiteral;
}
Expr conjunct_list() {
if (lookahead == NUM || lookahead == ID) {
// conjunct_list -> bool _conjunct_list
Expr temp = boolean();
Expr test = _conjunct_list();
if (test.isNull()) { // test lack a left node
return temp;
} else {
test.setLeft(temp);
return test;
}
} else {
throw ParseError("Syntax error");
}
}
Expr Parser::nextExpression() throw(ParserException) {
Debug("parser") << "nextExpression()" << std::endl;
Expr result;
if(!done()) {
try {
result = d_input->parseExpr();
setDone(result.isNull());
} catch(ParserException& e) {
setDone();
throw;
} catch(exception& e) {
setDone();
parseError(e.what());
}
}
Debug("parser") << "nextExpression() => " << result << std::endl;
return result;
}
TypeNode NodeManager::mkPredicateSubtype(Expr lambda, Expr witness)
throw(TypeCheckingExceptionPrivate) {
Node lambdan = Node::fromExpr(lambda);
if(lambda.isNull()) {
throw TypeCheckingExceptionPrivate(lambdan, "cannot make a predicate subtype based on null expression");
}
TypeNode tn = lambdan.getType();
if(! tn.isPredicateLike() ||
tn.getArgTypes().size() != 1) {
stringstream ss;
ss << "expected a predicate of one argument to define predicate subtype, but got type `" << tn << "'";
throw TypeCheckingExceptionPrivate(lambdan, ss.str());
}
return TypeNode(mkTypeConst(Predicate(lambda, witness)));
}
Expr Parser::nextExpression() throw(ParserException, UnsafeInterruptException) {
Debug("parser") << "nextExpression()" << std::endl;
const Options& options = d_exprManager->getOptions();
d_resourceManager->spendResource(options.getParseStep());
Expr result;
if (!done()) {
try {
result = d_input->parseExpr();
setDone(result.isNull());
} catch (ParserException& e) {
setDone();
throw;
} catch (exception& e) {
setDone();
parseError(e.what());
}
}
Debug("parser") << "nextExpression() => " << result << std::endl;
return result;
}
Expr _conjunct_list() {
if (lookahead == AND) {
// _conjunct_list -> AND bool _conjunct_list
match(AND);
Expr root(AND);
Expr temp = boolean();
Expr test = _conjunct_list();
if (test.isNull()) {
root.setRight(temp);
return root;
} else {
test.setLeft(temp);
root.setRight(test);
return root;
}
} else if (lookahead == SEMICOLON || lookahead == END) {
return NULL_EXPR;
} else {
throw ParseError("Syntax error");
}
}
Theorem QuantTheoremProducer::universalInst(const Theorem& t1, const vector<Expr>& terms, int quantLevel, Expr gterm){
Expr e = t1.getExpr();
const vector<Expr>& boundVars = e.getVars();
for(unsigned int i=0; i<terms.size(); i++){
if (d_theoryQuant->getBaseType(boundVars[i]) !=
d_theoryQuant->getBaseType(terms[i])){
Proof pf;
return newRWTheorem(terms[i],terms[i],
Assumptions::emptyAssump(), pf);
}
//this is the same as return a TRUE theorem, which will be ignored immeridatele. So, this is just return doing nothing.
}
if(CHECK_PROOFS) {
CHECK_SOUND(boundVars.size() == terms.size(),
"Universal instantiation: size of terms array does "
"not match quanitfied variables array size");
CHECK_SOUND(e.isForall(),
"universal instantiation: expr must be FORALL:\n"
+e.toString());
for(unsigned int i=0; i<terms.size(); i++)
CHECK_SOUND(d_theoryQuant->getBaseType(boundVars[i]) ==
d_theoryQuant->getBaseType(terms[i]),
"Universal instantiation: type mismatch");
}
//build up a conjunction of type predicates for expression
Expr tr = e.getEM()->trueExpr();
Expr typePred = tr;
// unsigned qlevel, qlevelMax = 0;
for(unsigned int i=0; i<terms.size(); i++) {
Expr p = d_theoryQuant->getTypePred(boundVars[i].getType(),terms[i]);
if(p!=tr) {
if(typePred==tr)
typePred = p;
else
typePred = typePred.andExpr(p);
}
// qlevel = d_theoryQuant->theoryCore()->getQuantLevelForTerm(terms[i]);
// if (qlevel > qlevelMax) qlevel = qlevelMax;
}
// Expr inst = e.getBody().substExprQuant(e.getVars(), terms);
Expr inst = e.getBody().substExpr(e.getVars(), terms);
// Expr inst = e.getBody().substExpr(e.getVars(), terms);
Proof pf;
if(withProof()) {
vector<Proof> pfs;
vector<Expr> es;
pfs.push_back(t1.getProof());
es.push_back(e);
es.push_back(Expr(RAW_LIST,terms));
// es.insert(es.end(), terms.begin(), terms.end());
es.push_back(inst);
if (gterm.isNull()) {
es.push_back( d_theoryQuant->getEM()->newRatExpr(0));
}
else {es.push_back(gterm);
}
pf= newPf("universal_elimination1", es, pfs);
}
// Expr inst = e.getBody().substExpr(e.getVars(), terms);
Expr imp;
if(typePred == tr ) //just for a easy life, yeting, change this assp
imp = inst;
else
imp = typePred.impExpr(inst);
Theorem ret = newTheorem(imp, t1.getAssumptionsRef(), pf);
int thmLevel = t1.getQuantLevel();
if(quantLevel >= thmLevel) {
ret.setQuantLevel(quantLevel+1);
}
else{
ret.setQuantLevel(thmLevel+1);
}
// ret.setQuantLevel(quantLevel+1);
return ret;
}
void CVC4Problem::insertAssertion(const Expr &e){
if (!e.isNull()) {
assertions.push_back(e);
}
}
void TheoryUF::assertFact(const Theorem& e)
{
const Expr& expr = e.getExpr();
switch (expr.getKind()) {
case NOT:
break;
case APPLY:
if (expr.getOpExpr().computeTransClosure()) {
enqueueFact(d_rules->relToClosure(e));
}
else if (expr.getOpKind() == TRANS_CLOSURE) {
// const Expr& rel = expr.getFun();
DebugAssert(expr.isApply(), "Should be apply");
Expr rel = resolveID(expr.getOpExpr().getName());
DebugAssert(!rel.isNull(), "Expected known identifier");
DebugAssert(rel.isSymbol() && rel.getKind()==UFUNC && expr.arity()==2,
"Unexpected use of transitive closure: "+expr.toString());
// Insert into transitive closure table
ExprMap<TCMapPair*>::iterator i = d_transClosureMap.find(rel);
TCMapPair* pTable;
if (i == d_transClosureMap.end()) {
pTable = new TCMapPair();
d_transClosureMap[rel] = pTable;
}
else {
pTable = (*i).second;
}
ExprMap<CDList<Theorem>*>::iterator i2 = pTable->appearsFirstMap.find(expr[0]);
CDList<Theorem>* pList;
if (i2 == pTable->appearsFirstMap.end()) {
pList = new(true) CDList<Theorem>(theoryCore()->getCM()->getCurrentContext());
pTable->appearsFirstMap[expr[0]] = pList;
}
else {
pList = (*i2).second;
}
pList->push_back(e);
i2 = pTable->appearsSecondMap.find(expr[1]);
if (i2 == pTable->appearsSecondMap.end()) {
pList = new(true) CDList<Theorem>(theoryCore()->getCM()->getCurrentContext());
pTable->appearsSecondMap[expr[1]] = pList;
}
else {
pList = (*i2).second;
}
pList->push_back(e);
// Compute transitive closure with existing relations
size_t s,l;
i2 = pTable->appearsFirstMap.find(expr[1]);
if (i2 != pTable->appearsFirstMap.end()) {
pList = (*i2).second;
s = pList->size();
for (l = 0; l < s; ++l) {
enqueueFact(d_rules->relTrans(e,(*pList)[l]));
}
}
i2 = pTable->appearsSecondMap.find(expr[0]);
if (i2 != pTable->appearsSecondMap.end()) {
pList = (*i2).second;
s = pList->size();
for (l = 0; l < s; ++l) {
enqueueFact(d_rules->relTrans((*pList)[l],e));
}
}
}
break;
default:
break;
}
}
