Expr ExprManager::mkExpr(Kind kind, Expr child1, Expr child2, Expr child3,
Expr child4) {
const kind::MetaKind mk = kind::metaKindOf(kind);
const unsigned n = 4 - (mk == kind::metakind::PARAMETERIZED ? 1 : 0);
CheckArgument(mk == kind::metakind::PARAMETERIZED ||
mk == kind::metakind::OPERATOR, kind,
"Only operator-style expressions are made with mkExpr(); "
"to make variables and constants, see mkVar(), mkBoundVar(), "
"and mkConst().");
CheckArgument(n >= minArity(kind) && n <= maxArity(kind), kind,
"Exprs with kind %s must have at least %u children and "
"at most %u children (the one under construction has %u)",
kind::kindToString(kind).c_str(),
minArity(kind), maxArity(kind), n);
NodeManagerScope nms(d_nodeManager);
try {
INC_STAT(kind);
return Expr(this, d_nodeManager->mkNodePtr(kind,
child1.getNode(),
child2.getNode(),
child3.getNode(),
child4.getNode()));
} catch (const TypeCheckingExceptionPrivate& e) {
throw TypeCheckingException(this, &e);
}
}
void TheoryProxy::notifyRestart() {
d_propEngine->checkTime();
d_theoryEngine->notifyRestart();
static uint32_t lemmaCount = 0;
if(options::lemmaInputChannel() != NULL) {
while(options::lemmaInputChannel()->hasNewLemma()) {
Debug("shared") << "shared" << std::endl;
Expr lemma = options::lemmaInputChannel()->getNewLemma();
Node asNode = lemma.getNode();
asNode = theory::Rewriter::rewrite(asNode);
if(d_shared.find(asNode) == d_shared.end()) {
d_shared.insert(asNode);
if(asNode.getKind() == kind::OR) {
++lemmaCount;
if(lemmaCount % 1 == 0) {
Debug("shared") << "=) " << asNode << std::endl;
}
d_propEngine->assertLemma(d_theoryEngine->preprocess(asNode), false, true);
} else {
Debug("shared") << "=(" << asNode << std::endl;
}
} else {
Debug("shared") <<"drop shared " << asNode << std::endl;
}
}
}
}
Expr ExprManager::mkExpr(Kind kind, Expr child1,
const std::vector<Expr>& otherChildren) {
const kind::MetaKind mk = kind::metaKindOf(kind);
const unsigned n = otherChildren.size() - (mk == kind::metakind::PARAMETERIZED ? 1 : 0) + 1;
CheckArgument(mk == kind::metakind::PARAMETERIZED ||
mk == kind::metakind::OPERATOR, kind,
"Only operator-style expressions are made with mkExpr(); "
"to make variables and constants, see mkVar(), mkBoundVar(), "
"and mkConst().");
CheckArgument(n >= minArity(kind) && n <= maxArity(kind), kind,
"Exprs with kind %s must have at least %u children and "
"at most %u children (the one under construction has %u)",
kind::kindToString(kind).c_str(),
minArity(kind), maxArity(kind), n);
NodeManagerScope nms(d_nodeManager);
vector<Node> nodes;
nodes.push_back(child1.getNode());
vector<Expr>::const_iterator it = otherChildren.begin();
vector<Expr>::const_iterator it_end = otherChildren.end();
while(it != it_end) {
nodes.push_back(it->getNode());
++it;
}
try {
INC_STAT(kind);
return Expr(this, d_nodeManager->mkNodePtr(kind, nodes));
} catch (const TypeCheckingExceptionPrivate& e) {
throw TypeCheckingException(this, &e);
}
}
Expr ExprManager::mkExpr(Expr opExpr, Expr child1) {
const unsigned n = 1;
Kind kind = NodeManager::operatorToKind(opExpr.getNode());
CheckArgument(opExpr.getKind() == kind::BUILTIN || kind::metaKindOf(kind) == kind::metakind::PARAMETERIZED, opExpr,
"This Expr constructor is for parameterized kinds only");
CheckArgument(n >= minArity(kind) && n <= maxArity(kind), kind,
"Exprs with kind %s must have at least %u children and "
"at most %u children (the one under construction has %u)",
kind::kindToString(kind).c_str(),
minArity(kind), maxArity(kind), n);
NodeManagerScope nms(d_nodeManager);
try {
INC_STAT(kind);
return Expr(this, d_nodeManager->mkNodePtr(opExpr.getNode(), child1.getNode()));
} catch (const TypeCheckingExceptionPrivate& e) {
throw TypeCheckingException(this, &e);
}
}
/**
* Get the type for the given Expr and optionally do type checking.
*
* Initial type computation will be near-constant time if
* type checking is not requested. Results are memoized, so that
* subsequent calls to getType() without type checking will be
* constant time.
*
* Initial type checking is linear in the size of the expression.
* Again, the results are memoized, so that subsequent calls to
* getType(), with or without type checking, will be constant
* time.
*
* NOTE: A TypeCheckingException can be thrown even when type
* checking is not requested. getType() will always return a
* valid and correct type and, thus, an exception will be thrown
* when no valid or correct type can be computed (e.g., if the
* arguments to a bit-vector operation aren't bit-vectors). When
* type checking is not requested, getType() will do the minimum
* amount of checking required to return a valid result.
*
* @param e the Expr for which we want a type
* @param check whether we should check the type as we compute it
* (default: false)
*/
Type ExprManager::getType(Expr e, bool check) throw (TypeCheckingException) {
NodeManagerScope nms(d_nodeManager);
Type t;
try {
t = Type(d_nodeManager,
new TypeNode(d_nodeManager->getType(e.getNode(), check)));
} catch (const TypeCheckingExceptionPrivate& e) {
throw TypeCheckingException(this, &e);
}
return t;
}
void Pickler::debugPickleTest(Expr e) {
//ExprManager *em = e.getExprManager();
//Expr e1 = mkVar("x", makeType());
//return ;
Pickler pickler(e.getExprManager());
Pickle p;
pickler.toPickle(e, p);
uint32_t size = p.d_data->size();
std::string str = p.d_data->toString();
Expr from = pickler.fromPickle(p);
ExprManagerScope ems(e);
Debug("pickle") << "before: " << e << std::endl;
Debug("pickle") << "after: " << from.getNode() << std::endl;
Debug("pickle") << "pickle: (oct) "<< size << " " << str.length() << " " << str << std::endl;
Assert(p.d_data->empty());
Assert(e == from);
}
