//Add new numerical assignment to the building clause void CVC4Problem::AddConditionToCluase(const assignment* numericalAssignment, FastEnvironment *env, int significantTimePoint){ ExpressionConvertor variableConvertor(env, this, significantTimePoint); Expr variable = variableConvertor.convertExpressionToCVC4Expr(numericalAssignment->getFTerm()); if (variable.isConst()){ //This case is happening just in initial case when initial state determine the value of a static variable return; } ExpressionConvertor expressionConvertor(env, this, significantTimePoint - 1); Expr result = expressionConvertor.convertExpressionToCVC4Expr(numericalAssignment->getExpr()); Kind assignmentOperator = kind::EQUAL; switch (numericalAssignment->getOp()){ case E_INCREASE: assignmentOperator = kind::PLUS; break; case E_DECREASE: assignmentOperator = kind::MINUS; break; case E_SCALE_UP: assignmentOperator = kind::MULT; break; case E_SCALE_DOWN: assignmentOperator = kind::DIVISION; break; case E_ASSIGN: break; case E_ASSIGN_CTS: cerr << "Oops!!!, I don't know what is \"E_ASSIGN_CTS\"" << endl; exit(1); break; default: cerr << numericalAssignment->getOp() << endl; cerr << "I think the program should never reach at this line, BTW we just was processing a numerical assignment!" << endl; exit (1); } if (assignmentOperator != kind::EQUAL){ Expr variableInPreviousTime = expressionConvertor.convertExpressionToCVC4Expr(numericalAssignment->getFTerm()); result = em.mkExpr(assignmentOperator, variableInPreviousTime, result); } buildingClause.push_back(em.mkExpr(kind::EQUAL, variable, result)); }
ArrayStoreAll::ArrayStoreAll(const ArrayType& type, const Expr& expr) : d_type(), d_expr() { // this check is stronger than the assertion check in the expr manager that // ArrayTypes are actually array types // because this check is done in production builds too PrettyCheckArgument( type.isArray(), type, "array store-all constants can only be created for array types, not `%s'", type.toString().c_str()); PrettyCheckArgument( expr.getType().isComparableTo(type.getConstituentType()), expr, "expr type `%s' does not match constituent type of array type `%s'", expr.getType().toString().c_str(), type.toString().c_str()); PrettyCheckArgument(expr.isConst(), expr, "ArrayStoreAll requires a constant expression"); // Delay allocation until the checks above have been performed. If these fail, // the memory for d_type and d_expr should not leak. The alternative is catch, // delete and re-throw. d_type.reset(new ArrayType(type)); d_expr.reset(new Expr(expr)); }
void translate_to_redlog(const map<Expr, unsigned>& variables, const Expr& assertion) { bool first; unsigned n = assertion.getNumChildren(); if (n == 0) { if (assertion.isConst()) { if (assertion.getConst<bool>()) { cout << "(1 > 0)"; } else { cout << "(1 < 0)"; } } else { assert(false); } } else { std::string op; bool binary = false; bool theory = false; switch (assertion.getKind()) { case kind::NOT: cout << "(not "; translate_to_redlog(variables, assertion[0]); cout << ")"; break; case kind::OR: first = true; cout << "("; for (unsigned i = 0; i < n; ++ i) { if (!first) { cout << " or "; } first = false; translate_to_redlog(variables, assertion[i]); } cout << ")"; break; case kind::AND: first = true; cout << "("; for (unsigned i = 0; i < n; ++ i) { if (!first) { cout << " and "; } first = false; translate_to_redlog(variables, assertion[i]); } cout << ")"; break; case kind::IMPLIES: cout << "("; translate_to_redlog(variables, assertion[0]); cout << " impl "; translate_to_redlog(variables, assertion[1]); cout << ")"; break; case kind::IFF: cout << "("; translate_to_redlog(variables, assertion[0]); cout << " equiv "; translate_to_redlog(variables, assertion[1]); cout << ")"; break; case kind::EQUAL: op = "="; theory = true; break; case kind::LT: op = "<"; theory = true; break; case kind::LEQ: op = "<="; theory = true; break; case kind::GT: op = ">"; theory = true; break; case kind::GEQ: op = ">="; theory = true; break; default: assert(false); break; } if (binary) { cout << "("; translate_to_redlog(variables, assertion[0]); cout << " " << op << " "; translate_to_redlog(variables, assertion[1]); cout << ")"; } if (theory) { cout << "("; translate_to_redlog_term(variables, assertion[0]); cout << " " << op << " "; translate_to_redlog_term(variables, assertion[1]); cout << ")"; } } }