- name: Install Check
run: |
make -j2 install
- echo -e "#include <cvc4/api/cvc4cpp.h>\nint main() { CVC4::api::Solver s; return 0; }" > /tmp/test.cpp
+ echo -e "#include <cvc4/api/cvc4cpp.h>\nint main() { CVC5::api::Solver s; return 0; }" > /tmp/test.cpp
g++ -std=c++11 /tmp/test.cpp -I install/include -L install/lib -lcvc4
working-directory: build
#include <cvc4/api/cvc4cpp.h>
using namespace std;
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include <cvc4/api/cvc4cpp.h>
using namespace std;
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include <cvc4/api/cvc4cpp.h>
using namespace std;
-using namespace CVC4::api;
+using namespace CVC5::api;
void prefixPrintGetValue(Solver& slv, Term t, int level = 0)
{
#include <cvc4/api/cvc4cpp.h>
-using namespace CVC4::api;
+using namespace CVC5::api;
void test(Solver& slv, Sort& consListSort)
{
#include <cvc4/api/cvc4cpp.h>
using namespace std;
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include <cvc4/api/cvc4cpp.h>
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include "cvc4/api/cvc4cpp.h"
using namespace std;
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include <iostream>
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include <cvc4/api/cvc4cpp.h>
using namespace std;
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include <cvc4/api/cvc4cpp.h>
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include <iostream>
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include <iostream>
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include <iostream>
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include "word.h"
using namespace std;
-using namespace CVC4;
+using namespace CVC5;
hashsmt::cvc4_uchar8 *createInput(unsigned size, std::string prefix, std::ostream& output) {
hashsmt::cvc4_uchar8 *input = new hashsmt::cvc4_uchar8[size];
delete[] cvc4input1;
delete[] cvc4input2;
-
- } catch (CVC4::Exception& e) {
+ }
+ catch (CVC5::Exception& e)
+ {
cerr << e << endl;
}
}
#include "word.h"
using namespace std;
-using namespace CVC4;
+using namespace CVC5;
int main(int argc, char* argv[]) {
// Checksat command
output << CheckSatCommand() << endl;
- } catch (CVC4::Exception& e) {
+ }
+ catch (CVC5::Exception& e)
+ {
cerr << e << endl;
}
}
using namespace std;
using namespace hashsmt;
-using namespace CVC4;
-using namespace CVC4::options;
+using namespace CVC5;
+using namespace CVC5::options;
Expr Word::extendToSize(unsigned newSize) const {
if (newSize <= size()) {
ExprManager* Word::em() {
if (s_manager == 0) {
- CVC4::Options options;
+ CVC5::Options options;
options.setInputLanguage(language::input::LANG_SMTLIB_V2);
options.setOutputLanguage(language::output::LANG_SMTLIB_V2);
- s_manager = new CVC4::ExprManager(options);
+ s_manager = new CVC5::ExprManager(options);
}
return s_manager;
}
}
void Word::print(ostream& out) const {
- out << CVC4::expr::ExprSetDepth(-1) << d_expr;
+ out << CVC5::expr::ExprSetDepth(-1) << d_expr;
}
Word::Word(unsigned newSize, unsigned value) {
class Word {
/** Expression managaer we're using for all word expressions */
- static CVC4::ExprManager* s_manager;
+ static CVC5::ExprManager* s_manager;
-protected:
+ protected:
/** The expression of this word */
- CVC4::Expr d_expr;
+ CVC5::Expr d_expr;
/** Get the expression manager words are using */
- static CVC4::ExprManager* em();
+ static CVC5::ExprManager* em();
- Word(CVC4::Expr expr = CVC4::Expr())
- : d_expr(expr) {}
+ Word(CVC5::Expr expr = CVC5::Expr()) : d_expr(expr) {}
/** Extend the representing expression to the given size >= size() */
- CVC4::Expr extendToSize(unsigned size) const;
+ CVC5::Expr extendToSize(unsigned size) const;
-public:
+ public:
Word(unsigned size, unsigned value = 0);
Word(unsigned size, std::string name);
void print(std::ostream& out) const;
- CVC4::Expr getExpr() const {
- return d_expr;
- }
+ CVC5::Expr getExpr() const { return d_expr; }
- /** Returns the comparison expression */
- CVC4::Expr operator == (const Word& b) const;
+ /** Returns the comparison expression */
+ CVC5::Expr operator==(const Word& b) const;
/** Concatenate the given words */
static Word concat(const Word words[], unsigned size);
#include <cvc4/options/set_language.h>
using namespace std;
-using namespace CVC4;
-using namespace CVC4::parser;
-using namespace CVC4::theory;
+using namespace CVC5;
+using namespace CVC5::parser;
+using namespace CVC5::theory;
int main(int argc, char* argv[])
{
#include <cvc4/cvc4.h>
using namespace std;
-using namespace CVC4;
-using namespace CVC4::parser;
-using namespace CVC4::options;
+using namespace CVC5;
+using namespace CVC5::parser;
+using namespace CVC5::options;
unsigned compute_degree(ExprManager& exprManager, const Expr& term) {
unsigned n = term.getNumChildren();
#include <cvc4/options/set_language.h>
using namespace std;
-using namespace CVC4;
-using namespace CVC4::parser;
-using namespace CVC4::options;
+using namespace CVC5;
+using namespace CVC5::parser;
+using namespace CVC5::options;
int main(int argc, char* argv[])
{
#include <cvc4/cvc4.h>
using namespace std;
-using namespace CVC4;
-using namespace CVC4::parser;
-using namespace CVC4::options;
+using namespace CVC5;
+using namespace CVC5::parser;
+using namespace CVC5::options;
void translate_to_isat(
string input,
#include <cvc4/cvc4.h>
using namespace std;
-using namespace CVC4;
-using namespace CVC4::parser;
+using namespace CVC5;
+using namespace CVC5::parser;
void translate_to_mathematica(
string input,
#include <cvc4/cvc4.h>
using namespace std;
-using namespace CVC4;
-using namespace CVC4::parser;
+using namespace CVC5;
+using namespace CVC5::parser;
void translate_to_qepcad(
string input,
#include <cvc4/cvc4.h>
using namespace std;
-using namespace CVC4;
-using namespace CVC4::parser;
-using namespace CVC4::options;
+using namespace CVC5;
+using namespace CVC5::parser;
+using namespace CVC5::options;
void translate_to_redlog(
string input,
#include <cvc4/options/set_language.h>
using namespace std;
-using namespace CVC4;
-using namespace CVC4::parser;
-using namespace CVC4::options;
+using namespace CVC5;
+using namespace CVC5::parser;
+using namespace CVC5::options;
bool nonsense(char c) { return !isalnum(c); }
#include <iostream>
-using namespace CVC4::api;
+using namespace CVC5::api;
int main() {
Solver slv;
#include <iostream>
-using namespace CVC4::api;
+using namespace CVC5::api;
int main() {
Solver slv;
#include <cvc4/options/set_language.h>
using namespace std;
-using namespace CVC4;
-using namespace CVC4::language;
-using namespace CVC4::parser;
+using namespace CVC5;
+using namespace CVC5::language;
+using namespace CVC5::parser;
enum {
INPUT_LANG = 'L',
this == bv.d_solver, "bound variable", bound_vars, i) \
<< "a term associated with this solver object"; \
CVC4_API_ARG_AT_INDEX_CHECK_EXPECTED( \
- bv.d_node->getKind() == CVC4::Kind::BOUND_VARIABLE, \
+ bv.d_node->getKind() == CVC5::Kind::BOUND_VARIABLE, \
"bound variable", \
bound_vars, \
i) \
this == bv.d_solver, "bound variable", bound_vars, i) \
<< "a term associated with this solver object"; \
CVC4_API_ARG_AT_INDEX_CHECK_EXPECTED( \
- bv.d_node->getKind() == CVC4::Kind::BOUND_VARIABLE, \
+ bv.d_node->getKind() == CVC5::Kind::BOUND_VARIABLE, \
"bound variable", \
bound_vars, \
i) \
#include "util/stats_histogram.h"
#include "util/utility.h"
-namespace CVC4 {
+namespace CVC5 {
namespace api {
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* Mapping from external (API) kind to internal kind. */
-const static std::unordered_map<Kind, CVC4::Kind, KindHashFunction> s_kinds{
- {INTERNAL_KIND, CVC4::Kind::UNDEFINED_KIND},
- {UNDEFINED_KIND, CVC4::Kind::UNDEFINED_KIND},
- {NULL_EXPR, CVC4::Kind::NULL_EXPR},
+const static std::unordered_map<Kind, CVC5::Kind, KindHashFunction> s_kinds{
+ {INTERNAL_KIND, CVC5::Kind::UNDEFINED_KIND},
+ {UNDEFINED_KIND, CVC5::Kind::UNDEFINED_KIND},
+ {NULL_EXPR, CVC5::Kind::NULL_EXPR},
/* Builtin ------------------------------------------------------------- */
- {UNINTERPRETED_CONSTANT, CVC4::Kind::UNINTERPRETED_CONSTANT},
- {ABSTRACT_VALUE, CVC4::Kind::ABSTRACT_VALUE},
- {EQUAL, CVC4::Kind::EQUAL},
- {DISTINCT, CVC4::Kind::DISTINCT},
- {CONSTANT, CVC4::Kind::VARIABLE},
- {VARIABLE, CVC4::Kind::BOUND_VARIABLE},
- {SEXPR, CVC4::Kind::SEXPR},
- {LAMBDA, CVC4::Kind::LAMBDA},
- {WITNESS, CVC4::Kind::WITNESS},
+ {UNINTERPRETED_CONSTANT, CVC5::Kind::UNINTERPRETED_CONSTANT},
+ {ABSTRACT_VALUE, CVC5::Kind::ABSTRACT_VALUE},
+ {EQUAL, CVC5::Kind::EQUAL},
+ {DISTINCT, CVC5::Kind::DISTINCT},
+ {CONSTANT, CVC5::Kind::VARIABLE},
+ {VARIABLE, CVC5::Kind::BOUND_VARIABLE},
+ {SEXPR, CVC5::Kind::SEXPR},
+ {LAMBDA, CVC5::Kind::LAMBDA},
+ {WITNESS, CVC5::Kind::WITNESS},
/* Boolean ------------------------------------------------------------- */
- {CONST_BOOLEAN, CVC4::Kind::CONST_BOOLEAN},
- {NOT, CVC4::Kind::NOT},
- {AND, CVC4::Kind::AND},
- {IMPLIES, CVC4::Kind::IMPLIES},
- {OR, CVC4::Kind::OR},
- {XOR, CVC4::Kind::XOR},
- {ITE, CVC4::Kind::ITE},
- {MATCH, CVC4::Kind::MATCH},
- {MATCH_CASE, CVC4::Kind::MATCH_CASE},
- {MATCH_BIND_CASE, CVC4::Kind::MATCH_BIND_CASE},
+ {CONST_BOOLEAN, CVC5::Kind::CONST_BOOLEAN},
+ {NOT, CVC5::Kind::NOT},
+ {AND, CVC5::Kind::AND},
+ {IMPLIES, CVC5::Kind::IMPLIES},
+ {OR, CVC5::Kind::OR},
+ {XOR, CVC5::Kind::XOR},
+ {ITE, CVC5::Kind::ITE},
+ {MATCH, CVC5::Kind::MATCH},
+ {MATCH_CASE, CVC5::Kind::MATCH_CASE},
+ {MATCH_BIND_CASE, CVC5::Kind::MATCH_BIND_CASE},
/* UF ------------------------------------------------------------------ */
- {APPLY_UF, CVC4::Kind::APPLY_UF},
- {CARDINALITY_CONSTRAINT, CVC4::Kind::CARDINALITY_CONSTRAINT},
- {CARDINALITY_VALUE, CVC4::Kind::CARDINALITY_VALUE},
- {HO_APPLY, CVC4::Kind::HO_APPLY},
+ {APPLY_UF, CVC5::Kind::APPLY_UF},
+ {CARDINALITY_CONSTRAINT, CVC5::Kind::CARDINALITY_CONSTRAINT},
+ {CARDINALITY_VALUE, CVC5::Kind::CARDINALITY_VALUE},
+ {HO_APPLY, CVC5::Kind::HO_APPLY},
/* Arithmetic ---------------------------------------------------------- */
- {PLUS, CVC4::Kind::PLUS},
- {MULT, CVC4::Kind::MULT},
- {IAND, CVC4::Kind::IAND},
- {MINUS, CVC4::Kind::MINUS},
- {UMINUS, CVC4::Kind::UMINUS},
- {DIVISION, CVC4::Kind::DIVISION},
- {INTS_DIVISION, CVC4::Kind::INTS_DIVISION},
- {INTS_MODULUS, CVC4::Kind::INTS_MODULUS},
- {ABS, CVC4::Kind::ABS},
- {DIVISIBLE, CVC4::Kind::DIVISIBLE},
- {POW, CVC4::Kind::POW},
- {EXPONENTIAL, CVC4::Kind::EXPONENTIAL},
- {SINE, CVC4::Kind::SINE},
- {COSINE, CVC4::Kind::COSINE},
- {TANGENT, CVC4::Kind::TANGENT},
- {COSECANT, CVC4::Kind::COSECANT},
- {SECANT, CVC4::Kind::SECANT},
- {COTANGENT, CVC4::Kind::COTANGENT},
- {ARCSINE, CVC4::Kind::ARCSINE},
- {ARCCOSINE, CVC4::Kind::ARCCOSINE},
- {ARCTANGENT, CVC4::Kind::ARCTANGENT},
- {ARCCOSECANT, CVC4::Kind::ARCCOSECANT},
- {ARCSECANT, CVC4::Kind::ARCSECANT},
- {ARCCOTANGENT, CVC4::Kind::ARCCOTANGENT},
- {SQRT, CVC4::Kind::SQRT},
- {CONST_RATIONAL, CVC4::Kind::CONST_RATIONAL},
- {LT, CVC4::Kind::LT},
- {LEQ, CVC4::Kind::LEQ},
- {GT, CVC4::Kind::GT},
- {GEQ, CVC4::Kind::GEQ},
- {IS_INTEGER, CVC4::Kind::IS_INTEGER},
- {TO_INTEGER, CVC4::Kind::TO_INTEGER},
- {TO_REAL, CVC4::Kind::TO_REAL},
- {PI, CVC4::Kind::PI},
+ {PLUS, CVC5::Kind::PLUS},
+ {MULT, CVC5::Kind::MULT},
+ {IAND, CVC5::Kind::IAND},
+ {MINUS, CVC5::Kind::MINUS},
+ {UMINUS, CVC5::Kind::UMINUS},
+ {DIVISION, CVC5::Kind::DIVISION},
+ {INTS_DIVISION, CVC5::Kind::INTS_DIVISION},
+ {INTS_MODULUS, CVC5::Kind::INTS_MODULUS},
+ {ABS, CVC5::Kind::ABS},
+ {DIVISIBLE, CVC5::Kind::DIVISIBLE},
+ {POW, CVC5::Kind::POW},
+ {EXPONENTIAL, CVC5::Kind::EXPONENTIAL},
+ {SINE, CVC5::Kind::SINE},
+ {COSINE, CVC5::Kind::COSINE},
+ {TANGENT, CVC5::Kind::TANGENT},
+ {COSECANT, CVC5::Kind::COSECANT},
+ {SECANT, CVC5::Kind::SECANT},
+ {COTANGENT, CVC5::Kind::COTANGENT},
+ {ARCSINE, CVC5::Kind::ARCSINE},
+ {ARCCOSINE, CVC5::Kind::ARCCOSINE},
+ {ARCTANGENT, CVC5::Kind::ARCTANGENT},
+ {ARCCOSECANT, CVC5::Kind::ARCCOSECANT},
+ {ARCSECANT, CVC5::Kind::ARCSECANT},
+ {ARCCOTANGENT, CVC5::Kind::ARCCOTANGENT},
+ {SQRT, CVC5::Kind::SQRT},
+ {CONST_RATIONAL, CVC5::Kind::CONST_RATIONAL},
+ {LT, CVC5::Kind::LT},
+ {LEQ, CVC5::Kind::LEQ},
+ {GT, CVC5::Kind::GT},
+ {GEQ, CVC5::Kind::GEQ},
+ {IS_INTEGER, CVC5::Kind::IS_INTEGER},
+ {TO_INTEGER, CVC5::Kind::TO_INTEGER},
+ {TO_REAL, CVC5::Kind::TO_REAL},
+ {PI, CVC5::Kind::PI},
/* BV ------------------------------------------------------------------ */
- {CONST_BITVECTOR, CVC4::Kind::CONST_BITVECTOR},
- {BITVECTOR_CONCAT, CVC4::Kind::BITVECTOR_CONCAT},
- {BITVECTOR_AND, CVC4::Kind::BITVECTOR_AND},
- {BITVECTOR_OR, CVC4::Kind::BITVECTOR_OR},
- {BITVECTOR_XOR, CVC4::Kind::BITVECTOR_XOR},
- {BITVECTOR_NOT, CVC4::Kind::BITVECTOR_NOT},
- {BITVECTOR_NAND, CVC4::Kind::BITVECTOR_NAND},
- {BITVECTOR_NOR, CVC4::Kind::BITVECTOR_NOR},
- {BITVECTOR_XNOR, CVC4::Kind::BITVECTOR_XNOR},
- {BITVECTOR_COMP, CVC4::Kind::BITVECTOR_COMP},
- {BITVECTOR_MULT, CVC4::Kind::BITVECTOR_MULT},
- {BITVECTOR_PLUS, CVC4::Kind::BITVECTOR_PLUS},
- {BITVECTOR_SUB, CVC4::Kind::BITVECTOR_SUB},
- {BITVECTOR_NEG, CVC4::Kind::BITVECTOR_NEG},
- {BITVECTOR_UDIV, CVC4::Kind::BITVECTOR_UDIV},
- {BITVECTOR_UREM, CVC4::Kind::BITVECTOR_UREM},
- {BITVECTOR_SDIV, CVC4::Kind::BITVECTOR_SDIV},
- {BITVECTOR_SREM, CVC4::Kind::BITVECTOR_SREM},
- {BITVECTOR_SMOD, CVC4::Kind::BITVECTOR_SMOD},
- {BITVECTOR_SHL, CVC4::Kind::BITVECTOR_SHL},
- {BITVECTOR_LSHR, CVC4::Kind::BITVECTOR_LSHR},
- {BITVECTOR_ASHR, CVC4::Kind::BITVECTOR_ASHR},
- {BITVECTOR_ULT, CVC4::Kind::BITVECTOR_ULT},
- {BITVECTOR_ULE, CVC4::Kind::BITVECTOR_ULE},
- {BITVECTOR_UGT, CVC4::Kind::BITVECTOR_UGT},
- {BITVECTOR_UGE, CVC4::Kind::BITVECTOR_UGE},
- {BITVECTOR_SLT, CVC4::Kind::BITVECTOR_SLT},
- {BITVECTOR_SLE, CVC4::Kind::BITVECTOR_SLE},
- {BITVECTOR_SGT, CVC4::Kind::BITVECTOR_SGT},
- {BITVECTOR_SGE, CVC4::Kind::BITVECTOR_SGE},
- {BITVECTOR_ULTBV, CVC4::Kind::BITVECTOR_ULTBV},
- {BITVECTOR_SLTBV, CVC4::Kind::BITVECTOR_SLTBV},
- {BITVECTOR_ITE, CVC4::Kind::BITVECTOR_ITE},
- {BITVECTOR_REDOR, CVC4::Kind::BITVECTOR_REDOR},
- {BITVECTOR_REDAND, CVC4::Kind::BITVECTOR_REDAND},
- {BITVECTOR_EXTRACT, CVC4::Kind::BITVECTOR_EXTRACT},
- {BITVECTOR_REPEAT, CVC4::Kind::BITVECTOR_REPEAT},
- {BITVECTOR_ZERO_EXTEND, CVC4::Kind::BITVECTOR_ZERO_EXTEND},
- {BITVECTOR_SIGN_EXTEND, CVC4::Kind::BITVECTOR_SIGN_EXTEND},
- {BITVECTOR_ROTATE_LEFT, CVC4::Kind::BITVECTOR_ROTATE_LEFT},
- {BITVECTOR_ROTATE_RIGHT, CVC4::Kind::BITVECTOR_ROTATE_RIGHT},
- {INT_TO_BITVECTOR, CVC4::Kind::INT_TO_BITVECTOR},
- {BITVECTOR_TO_NAT, CVC4::Kind::BITVECTOR_TO_NAT},
+ {CONST_BITVECTOR, CVC5::Kind::CONST_BITVECTOR},
+ {BITVECTOR_CONCAT, CVC5::Kind::BITVECTOR_CONCAT},
+ {BITVECTOR_AND, CVC5::Kind::BITVECTOR_AND},
+ {BITVECTOR_OR, CVC5::Kind::BITVECTOR_OR},
+ {BITVECTOR_XOR, CVC5::Kind::BITVECTOR_XOR},
+ {BITVECTOR_NOT, CVC5::Kind::BITVECTOR_NOT},
+ {BITVECTOR_NAND, CVC5::Kind::BITVECTOR_NAND},
+ {BITVECTOR_NOR, CVC5::Kind::BITVECTOR_NOR},
+ {BITVECTOR_XNOR, CVC5::Kind::BITVECTOR_XNOR},
+ {BITVECTOR_COMP, CVC5::Kind::BITVECTOR_COMP},
+ {BITVECTOR_MULT, CVC5::Kind::BITVECTOR_MULT},
+ {BITVECTOR_PLUS, CVC5::Kind::BITVECTOR_PLUS},
+ {BITVECTOR_SUB, CVC5::Kind::BITVECTOR_SUB},
+ {BITVECTOR_NEG, CVC5::Kind::BITVECTOR_NEG},
+ {BITVECTOR_UDIV, CVC5::Kind::BITVECTOR_UDIV},
+ {BITVECTOR_UREM, CVC5::Kind::BITVECTOR_UREM},
+ {BITVECTOR_SDIV, CVC5::Kind::BITVECTOR_SDIV},
+ {BITVECTOR_SREM, CVC5::Kind::BITVECTOR_SREM},
+ {BITVECTOR_SMOD, CVC5::Kind::BITVECTOR_SMOD},
+ {BITVECTOR_SHL, CVC5::Kind::BITVECTOR_SHL},
+ {BITVECTOR_LSHR, CVC5::Kind::BITVECTOR_LSHR},
+ {BITVECTOR_ASHR, CVC5::Kind::BITVECTOR_ASHR},
+ {BITVECTOR_ULT, CVC5::Kind::BITVECTOR_ULT},
+ {BITVECTOR_ULE, CVC5::Kind::BITVECTOR_ULE},
+ {BITVECTOR_UGT, CVC5::Kind::BITVECTOR_UGT},
+ {BITVECTOR_UGE, CVC5::Kind::BITVECTOR_UGE},
+ {BITVECTOR_SLT, CVC5::Kind::BITVECTOR_SLT},
+ {BITVECTOR_SLE, CVC5::Kind::BITVECTOR_SLE},
+ {BITVECTOR_SGT, CVC5::Kind::BITVECTOR_SGT},
+ {BITVECTOR_SGE, CVC5::Kind::BITVECTOR_SGE},
+ {BITVECTOR_ULTBV, CVC5::Kind::BITVECTOR_ULTBV},
+ {BITVECTOR_SLTBV, CVC5::Kind::BITVECTOR_SLTBV},
+ {BITVECTOR_ITE, CVC5::Kind::BITVECTOR_ITE},
+ {BITVECTOR_REDOR, CVC5::Kind::BITVECTOR_REDOR},
+ {BITVECTOR_REDAND, CVC5::Kind::BITVECTOR_REDAND},
+ {BITVECTOR_EXTRACT, CVC5::Kind::BITVECTOR_EXTRACT},
+ {BITVECTOR_REPEAT, CVC5::Kind::BITVECTOR_REPEAT},
+ {BITVECTOR_ZERO_EXTEND, CVC5::Kind::BITVECTOR_ZERO_EXTEND},
+ {BITVECTOR_SIGN_EXTEND, CVC5::Kind::BITVECTOR_SIGN_EXTEND},
+ {BITVECTOR_ROTATE_LEFT, CVC5::Kind::BITVECTOR_ROTATE_LEFT},
+ {BITVECTOR_ROTATE_RIGHT, CVC5::Kind::BITVECTOR_ROTATE_RIGHT},
+ {INT_TO_BITVECTOR, CVC5::Kind::INT_TO_BITVECTOR},
+ {BITVECTOR_TO_NAT, CVC5::Kind::BITVECTOR_TO_NAT},
/* FP ------------------------------------------------------------------ */
- {CONST_FLOATINGPOINT, CVC4::Kind::CONST_FLOATINGPOINT},
- {CONST_ROUNDINGMODE, CVC4::Kind::CONST_ROUNDINGMODE},
- {FLOATINGPOINT_FP, CVC4::Kind::FLOATINGPOINT_FP},
- {FLOATINGPOINT_EQ, CVC4::Kind::FLOATINGPOINT_EQ},
- {FLOATINGPOINT_ABS, CVC4::Kind::FLOATINGPOINT_ABS},
- {FLOATINGPOINT_NEG, CVC4::Kind::FLOATINGPOINT_NEG},
- {FLOATINGPOINT_PLUS, CVC4::Kind::FLOATINGPOINT_PLUS},
- {FLOATINGPOINT_SUB, CVC4::Kind::FLOATINGPOINT_SUB},
- {FLOATINGPOINT_MULT, CVC4::Kind::FLOATINGPOINT_MULT},
- {FLOATINGPOINT_DIV, CVC4::Kind::FLOATINGPOINT_DIV},
- {FLOATINGPOINT_FMA, CVC4::Kind::FLOATINGPOINT_FMA},
- {FLOATINGPOINT_SQRT, CVC4::Kind::FLOATINGPOINT_SQRT},
- {FLOATINGPOINT_REM, CVC4::Kind::FLOATINGPOINT_REM},
- {FLOATINGPOINT_RTI, CVC4::Kind::FLOATINGPOINT_RTI},
- {FLOATINGPOINT_MIN, CVC4::Kind::FLOATINGPOINT_MIN},
- {FLOATINGPOINT_MAX, CVC4::Kind::FLOATINGPOINT_MAX},
- {FLOATINGPOINT_LEQ, CVC4::Kind::FLOATINGPOINT_LEQ},
- {FLOATINGPOINT_LT, CVC4::Kind::FLOATINGPOINT_LT},
- {FLOATINGPOINT_GEQ, CVC4::Kind::FLOATINGPOINT_GEQ},
- {FLOATINGPOINT_GT, CVC4::Kind::FLOATINGPOINT_GT},
- {FLOATINGPOINT_ISN, CVC4::Kind::FLOATINGPOINT_ISN},
- {FLOATINGPOINT_ISSN, CVC4::Kind::FLOATINGPOINT_ISSN},
- {FLOATINGPOINT_ISZ, CVC4::Kind::FLOATINGPOINT_ISZ},
- {FLOATINGPOINT_ISINF, CVC4::Kind::FLOATINGPOINT_ISINF},
- {FLOATINGPOINT_ISNAN, CVC4::Kind::FLOATINGPOINT_ISNAN},
- {FLOATINGPOINT_ISNEG, CVC4::Kind::FLOATINGPOINT_ISNEG},
- {FLOATINGPOINT_ISPOS, CVC4::Kind::FLOATINGPOINT_ISPOS},
+ {CONST_FLOATINGPOINT, CVC5::Kind::CONST_FLOATINGPOINT},
+ {CONST_ROUNDINGMODE, CVC5::Kind::CONST_ROUNDINGMODE},
+ {FLOATINGPOINT_FP, CVC5::Kind::FLOATINGPOINT_FP},
+ {FLOATINGPOINT_EQ, CVC5::Kind::FLOATINGPOINT_EQ},
+ {FLOATINGPOINT_ABS, CVC5::Kind::FLOATINGPOINT_ABS},
+ {FLOATINGPOINT_NEG, CVC5::Kind::FLOATINGPOINT_NEG},
+ {FLOATINGPOINT_PLUS, CVC5::Kind::FLOATINGPOINT_PLUS},
+ {FLOATINGPOINT_SUB, CVC5::Kind::FLOATINGPOINT_SUB},
+ {FLOATINGPOINT_MULT, CVC5::Kind::FLOATINGPOINT_MULT},
+ {FLOATINGPOINT_DIV, CVC5::Kind::FLOATINGPOINT_DIV},
+ {FLOATINGPOINT_FMA, CVC5::Kind::FLOATINGPOINT_FMA},
+ {FLOATINGPOINT_SQRT, CVC5::Kind::FLOATINGPOINT_SQRT},
+ {FLOATINGPOINT_REM, CVC5::Kind::FLOATINGPOINT_REM},
+ {FLOATINGPOINT_RTI, CVC5::Kind::FLOATINGPOINT_RTI},
+ {FLOATINGPOINT_MIN, CVC5::Kind::FLOATINGPOINT_MIN},
+ {FLOATINGPOINT_MAX, CVC5::Kind::FLOATINGPOINT_MAX},
+ {FLOATINGPOINT_LEQ, CVC5::Kind::FLOATINGPOINT_LEQ},
+ {FLOATINGPOINT_LT, CVC5::Kind::FLOATINGPOINT_LT},
+ {FLOATINGPOINT_GEQ, CVC5::Kind::FLOATINGPOINT_GEQ},
+ {FLOATINGPOINT_GT, CVC5::Kind::FLOATINGPOINT_GT},
+ {FLOATINGPOINT_ISN, CVC5::Kind::FLOATINGPOINT_ISN},
+ {FLOATINGPOINT_ISSN, CVC5::Kind::FLOATINGPOINT_ISSN},
+ {FLOATINGPOINT_ISZ, CVC5::Kind::FLOATINGPOINT_ISZ},
+ {FLOATINGPOINT_ISINF, CVC5::Kind::FLOATINGPOINT_ISINF},
+ {FLOATINGPOINT_ISNAN, CVC5::Kind::FLOATINGPOINT_ISNAN},
+ {FLOATINGPOINT_ISNEG, CVC5::Kind::FLOATINGPOINT_ISNEG},
+ {FLOATINGPOINT_ISPOS, CVC5::Kind::FLOATINGPOINT_ISPOS},
{FLOATINGPOINT_TO_FP_FLOATINGPOINT,
- CVC4::Kind::FLOATINGPOINT_TO_FP_FLOATINGPOINT},
- {FLOATINGPOINT_TO_FP_REAL, CVC4::Kind::FLOATINGPOINT_TO_FP_REAL},
+ CVC5::Kind::FLOATINGPOINT_TO_FP_FLOATINGPOINT},
+ {FLOATINGPOINT_TO_FP_REAL, CVC5::Kind::FLOATINGPOINT_TO_FP_REAL},
{FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR,
- CVC4::Kind::FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR},
+ CVC5::Kind::FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR},
{FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR,
- CVC4::Kind::FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR},
- {FLOATINGPOINT_TO_FP_GENERIC, CVC4::Kind::FLOATINGPOINT_TO_FP_GENERIC},
- {FLOATINGPOINT_TO_UBV, CVC4::Kind::FLOATINGPOINT_TO_UBV},
- {FLOATINGPOINT_TO_SBV, CVC4::Kind::FLOATINGPOINT_TO_SBV},
- {FLOATINGPOINT_TO_REAL, CVC4::Kind::FLOATINGPOINT_TO_REAL},
+ CVC5::Kind::FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR},
+ {FLOATINGPOINT_TO_FP_GENERIC, CVC5::Kind::FLOATINGPOINT_TO_FP_GENERIC},
+ {FLOATINGPOINT_TO_UBV, CVC5::Kind::FLOATINGPOINT_TO_UBV},
+ {FLOATINGPOINT_TO_SBV, CVC5::Kind::FLOATINGPOINT_TO_SBV},
+ {FLOATINGPOINT_TO_REAL, CVC5::Kind::FLOATINGPOINT_TO_REAL},
/* Arrays -------------------------------------------------------------- */
- {SELECT, CVC4::Kind::SELECT},
- {STORE, CVC4::Kind::STORE},
- {CONST_ARRAY, CVC4::Kind::STORE_ALL},
- {EQ_RANGE, CVC4::Kind::EQ_RANGE},
+ {SELECT, CVC5::Kind::SELECT},
+ {STORE, CVC5::Kind::STORE},
+ {CONST_ARRAY, CVC5::Kind::STORE_ALL},
+ {EQ_RANGE, CVC5::Kind::EQ_RANGE},
/* Datatypes ----------------------------------------------------------- */
- {APPLY_SELECTOR, CVC4::Kind::APPLY_SELECTOR},
- {APPLY_CONSTRUCTOR, CVC4::Kind::APPLY_CONSTRUCTOR},
- {APPLY_TESTER, CVC4::Kind::APPLY_TESTER},
- {TUPLE_UPDATE, CVC4::Kind::TUPLE_UPDATE},
- {RECORD_UPDATE, CVC4::Kind::RECORD_UPDATE},
- {DT_SIZE, CVC4::Kind::DT_SIZE},
- {TUPLE_PROJECT, CVC4::Kind::TUPLE_PROJECT},
+ {APPLY_SELECTOR, CVC5::Kind::APPLY_SELECTOR},
+ {APPLY_CONSTRUCTOR, CVC5::Kind::APPLY_CONSTRUCTOR},
+ {APPLY_TESTER, CVC5::Kind::APPLY_TESTER},
+ {TUPLE_UPDATE, CVC5::Kind::TUPLE_UPDATE},
+ {RECORD_UPDATE, CVC5::Kind::RECORD_UPDATE},
+ {DT_SIZE, CVC5::Kind::DT_SIZE},
+ {TUPLE_PROJECT, CVC5::Kind::TUPLE_PROJECT},
/* Separation Logic ---------------------------------------------------- */
- {SEP_NIL, CVC4::Kind::SEP_NIL},
- {SEP_EMP, CVC4::Kind::SEP_EMP},
- {SEP_PTO, CVC4::Kind::SEP_PTO},
- {SEP_STAR, CVC4::Kind::SEP_STAR},
- {SEP_WAND, CVC4::Kind::SEP_WAND},
+ {SEP_NIL, CVC5::Kind::SEP_NIL},
+ {SEP_EMP, CVC5::Kind::SEP_EMP},
+ {SEP_PTO, CVC5::Kind::SEP_PTO},
+ {SEP_STAR, CVC5::Kind::SEP_STAR},
+ {SEP_WAND, CVC5::Kind::SEP_WAND},
/* Sets ---------------------------------------------------------------- */
- {EMPTYSET, CVC4::Kind::EMPTYSET},
- {UNION, CVC4::Kind::UNION},
- {INTERSECTION, CVC4::Kind::INTERSECTION},
- {SETMINUS, CVC4::Kind::SETMINUS},
- {SUBSET, CVC4::Kind::SUBSET},
- {MEMBER, CVC4::Kind::MEMBER},
- {SINGLETON, CVC4::Kind::SINGLETON},
- {INSERT, CVC4::Kind::INSERT},
- {CARD, CVC4::Kind::CARD},
- {COMPLEMENT, CVC4::Kind::COMPLEMENT},
- {UNIVERSE_SET, CVC4::Kind::UNIVERSE_SET},
- {JOIN, CVC4::Kind::JOIN},
- {PRODUCT, CVC4::Kind::PRODUCT},
- {TRANSPOSE, CVC4::Kind::TRANSPOSE},
- {TCLOSURE, CVC4::Kind::TCLOSURE},
- {JOIN_IMAGE, CVC4::Kind::JOIN_IMAGE},
- {IDEN, CVC4::Kind::IDEN},
- {COMPREHENSION, CVC4::Kind::COMPREHENSION},
- {CHOOSE, CVC4::Kind::CHOOSE},
- {IS_SINGLETON, CVC4::Kind::IS_SINGLETON},
+ {EMPTYSET, CVC5::Kind::EMPTYSET},
+ {UNION, CVC5::Kind::UNION},
+ {INTERSECTION, CVC5::Kind::INTERSECTION},
+ {SETMINUS, CVC5::Kind::SETMINUS},
+ {SUBSET, CVC5::Kind::SUBSET},
+ {MEMBER, CVC5::Kind::MEMBER},
+ {SINGLETON, CVC5::Kind::SINGLETON},
+ {INSERT, CVC5::Kind::INSERT},
+ {CARD, CVC5::Kind::CARD},
+ {COMPLEMENT, CVC5::Kind::COMPLEMENT},
+ {UNIVERSE_SET, CVC5::Kind::UNIVERSE_SET},
+ {JOIN, CVC5::Kind::JOIN},
+ {PRODUCT, CVC5::Kind::PRODUCT},
+ {TRANSPOSE, CVC5::Kind::TRANSPOSE},
+ {TCLOSURE, CVC5::Kind::TCLOSURE},
+ {JOIN_IMAGE, CVC5::Kind::JOIN_IMAGE},
+ {IDEN, CVC5::Kind::IDEN},
+ {COMPREHENSION, CVC5::Kind::COMPREHENSION},
+ {CHOOSE, CVC5::Kind::CHOOSE},
+ {IS_SINGLETON, CVC5::Kind::IS_SINGLETON},
/* Bags ---------------------------------------------------------------- */
- {UNION_MAX, CVC4::Kind::UNION_MAX},
- {UNION_DISJOINT, CVC4::Kind::UNION_DISJOINT},
- {INTERSECTION_MIN, CVC4::Kind::INTERSECTION_MIN},
- {DIFFERENCE_SUBTRACT, CVC4::Kind::DIFFERENCE_SUBTRACT},
- {DIFFERENCE_REMOVE, CVC4::Kind::DIFFERENCE_REMOVE},
- {SUBBAG, CVC4::Kind::SUBBAG},
- {BAG_COUNT, CVC4::Kind::BAG_COUNT},
- {DUPLICATE_REMOVAL, CVC4::Kind::DUPLICATE_REMOVAL},
- {MK_BAG, CVC4::Kind::MK_BAG},
- {EMPTYBAG, CVC4::Kind::EMPTYBAG},
- {BAG_CARD, CVC4::Kind::BAG_CARD},
- {BAG_CHOOSE, CVC4::Kind::BAG_CHOOSE},
- {BAG_IS_SINGLETON, CVC4::Kind::BAG_IS_SINGLETON},
- {BAG_FROM_SET, CVC4::Kind::BAG_FROM_SET},
- {BAG_TO_SET, CVC4::Kind::BAG_TO_SET},
+ {UNION_MAX, CVC5::Kind::UNION_MAX},
+ {UNION_DISJOINT, CVC5::Kind::UNION_DISJOINT},
+ {INTERSECTION_MIN, CVC5::Kind::INTERSECTION_MIN},
+ {DIFFERENCE_SUBTRACT, CVC5::Kind::DIFFERENCE_SUBTRACT},
+ {DIFFERENCE_REMOVE, CVC5::Kind::DIFFERENCE_REMOVE},
+ {SUBBAG, CVC5::Kind::SUBBAG},
+ {BAG_COUNT, CVC5::Kind::BAG_COUNT},
+ {DUPLICATE_REMOVAL, CVC5::Kind::DUPLICATE_REMOVAL},
+ {MK_BAG, CVC5::Kind::MK_BAG},
+ {EMPTYBAG, CVC5::Kind::EMPTYBAG},
+ {BAG_CARD, CVC5::Kind::BAG_CARD},
+ {BAG_CHOOSE, CVC5::Kind::BAG_CHOOSE},
+ {BAG_IS_SINGLETON, CVC5::Kind::BAG_IS_SINGLETON},
+ {BAG_FROM_SET, CVC5::Kind::BAG_FROM_SET},
+ {BAG_TO_SET, CVC5::Kind::BAG_TO_SET},
/* Strings ------------------------------------------------------------- */
- {STRING_CONCAT, CVC4::Kind::STRING_CONCAT},
- {STRING_IN_REGEXP, CVC4::Kind::STRING_IN_REGEXP},
- {STRING_LENGTH, CVC4::Kind::STRING_LENGTH},
- {STRING_SUBSTR, CVC4::Kind::STRING_SUBSTR},
- {STRING_UPDATE, CVC4::Kind::STRING_UPDATE},
- {STRING_CHARAT, CVC4::Kind::STRING_CHARAT},
- {STRING_CONTAINS, CVC4::Kind::STRING_STRCTN},
- {STRING_INDEXOF, CVC4::Kind::STRING_STRIDOF},
- {STRING_REPLACE, CVC4::Kind::STRING_STRREPL},
- {STRING_REPLACE_ALL, CVC4::Kind::STRING_STRREPLALL},
- {STRING_REPLACE_RE, CVC4::Kind::STRING_REPLACE_RE},
- {STRING_REPLACE_RE_ALL, CVC4::Kind::STRING_REPLACE_RE_ALL},
- {STRING_TOLOWER, CVC4::Kind::STRING_TOLOWER},
- {STRING_TOUPPER, CVC4::Kind::STRING_TOUPPER},
- {STRING_REV, CVC4::Kind::STRING_REV},
- {STRING_FROM_CODE, CVC4::Kind::STRING_FROM_CODE},
- {STRING_TO_CODE, CVC4::Kind::STRING_TO_CODE},
- {STRING_LT, CVC4::Kind::STRING_LT},
- {STRING_LEQ, CVC4::Kind::STRING_LEQ},
- {STRING_PREFIX, CVC4::Kind::STRING_PREFIX},
- {STRING_SUFFIX, CVC4::Kind::STRING_SUFFIX},
- {STRING_IS_DIGIT, CVC4::Kind::STRING_IS_DIGIT},
- {STRING_FROM_INT, CVC4::Kind::STRING_ITOS},
- {STRING_TO_INT, CVC4::Kind::STRING_STOI},
- {CONST_STRING, CVC4::Kind::CONST_STRING},
- {STRING_TO_REGEXP, CVC4::Kind::STRING_TO_REGEXP},
- {REGEXP_CONCAT, CVC4::Kind::REGEXP_CONCAT},
- {REGEXP_UNION, CVC4::Kind::REGEXP_UNION},
- {REGEXP_INTER, CVC4::Kind::REGEXP_INTER},
- {REGEXP_DIFF, CVC4::Kind::REGEXP_DIFF},
- {REGEXP_STAR, CVC4::Kind::REGEXP_STAR},
- {REGEXP_PLUS, CVC4::Kind::REGEXP_PLUS},
- {REGEXP_OPT, CVC4::Kind::REGEXP_OPT},
- {REGEXP_RANGE, CVC4::Kind::REGEXP_RANGE},
- {REGEXP_REPEAT, CVC4::Kind::REGEXP_REPEAT},
- {REGEXP_LOOP, CVC4::Kind::REGEXP_LOOP},
- {REGEXP_EMPTY, CVC4::Kind::REGEXP_EMPTY},
- {REGEXP_SIGMA, CVC4::Kind::REGEXP_SIGMA},
- {REGEXP_COMPLEMENT, CVC4::Kind::REGEXP_COMPLEMENT},
+ {STRING_CONCAT, CVC5::Kind::STRING_CONCAT},
+ {STRING_IN_REGEXP, CVC5::Kind::STRING_IN_REGEXP},
+ {STRING_LENGTH, CVC5::Kind::STRING_LENGTH},
+ {STRING_SUBSTR, CVC5::Kind::STRING_SUBSTR},
+ {STRING_UPDATE, CVC5::Kind::STRING_UPDATE},
+ {STRING_CHARAT, CVC5::Kind::STRING_CHARAT},
+ {STRING_CONTAINS, CVC5::Kind::STRING_STRCTN},
+ {STRING_INDEXOF, CVC5::Kind::STRING_STRIDOF},
+ {STRING_REPLACE, CVC5::Kind::STRING_STRREPL},
+ {STRING_REPLACE_ALL, CVC5::Kind::STRING_STRREPLALL},
+ {STRING_REPLACE_RE, CVC5::Kind::STRING_REPLACE_RE},
+ {STRING_REPLACE_RE_ALL, CVC5::Kind::STRING_REPLACE_RE_ALL},
+ {STRING_TOLOWER, CVC5::Kind::STRING_TOLOWER},
+ {STRING_TOUPPER, CVC5::Kind::STRING_TOUPPER},
+ {STRING_REV, CVC5::Kind::STRING_REV},
+ {STRING_FROM_CODE, CVC5::Kind::STRING_FROM_CODE},
+ {STRING_TO_CODE, CVC5::Kind::STRING_TO_CODE},
+ {STRING_LT, CVC5::Kind::STRING_LT},
+ {STRING_LEQ, CVC5::Kind::STRING_LEQ},
+ {STRING_PREFIX, CVC5::Kind::STRING_PREFIX},
+ {STRING_SUFFIX, CVC5::Kind::STRING_SUFFIX},
+ {STRING_IS_DIGIT, CVC5::Kind::STRING_IS_DIGIT},
+ {STRING_FROM_INT, CVC5::Kind::STRING_ITOS},
+ {STRING_TO_INT, CVC5::Kind::STRING_STOI},
+ {CONST_STRING, CVC5::Kind::CONST_STRING},
+ {STRING_TO_REGEXP, CVC5::Kind::STRING_TO_REGEXP},
+ {REGEXP_CONCAT, CVC5::Kind::REGEXP_CONCAT},
+ {REGEXP_UNION, CVC5::Kind::REGEXP_UNION},
+ {REGEXP_INTER, CVC5::Kind::REGEXP_INTER},
+ {REGEXP_DIFF, CVC5::Kind::REGEXP_DIFF},
+ {REGEXP_STAR, CVC5::Kind::REGEXP_STAR},
+ {REGEXP_PLUS, CVC5::Kind::REGEXP_PLUS},
+ {REGEXP_OPT, CVC5::Kind::REGEXP_OPT},
+ {REGEXP_RANGE, CVC5::Kind::REGEXP_RANGE},
+ {REGEXP_REPEAT, CVC5::Kind::REGEXP_REPEAT},
+ {REGEXP_LOOP, CVC5::Kind::REGEXP_LOOP},
+ {REGEXP_EMPTY, CVC5::Kind::REGEXP_EMPTY},
+ {REGEXP_SIGMA, CVC5::Kind::REGEXP_SIGMA},
+ {REGEXP_COMPLEMENT, CVC5::Kind::REGEXP_COMPLEMENT},
// maps to the same kind as the string versions
- {SEQ_CONCAT, CVC4::Kind::STRING_CONCAT},
- {SEQ_LENGTH, CVC4::Kind::STRING_LENGTH},
- {SEQ_EXTRACT, CVC4::Kind::STRING_SUBSTR},
- {SEQ_UPDATE, CVC4::Kind::STRING_UPDATE},
- {SEQ_AT, CVC4::Kind::STRING_CHARAT},
- {SEQ_CONTAINS, CVC4::Kind::STRING_STRCTN},
- {SEQ_INDEXOF, CVC4::Kind::STRING_STRIDOF},
- {SEQ_REPLACE, CVC4::Kind::STRING_STRREPL},
- {SEQ_REPLACE_ALL, CVC4::Kind::STRING_STRREPLALL},
- {SEQ_REV, CVC4::Kind::STRING_REV},
- {SEQ_PREFIX, CVC4::Kind::STRING_PREFIX},
- {SEQ_SUFFIX, CVC4::Kind::STRING_SUFFIX},
- {CONST_SEQUENCE, CVC4::Kind::CONST_SEQUENCE},
- {SEQ_UNIT, CVC4::Kind::SEQ_UNIT},
- {SEQ_NTH, CVC4::Kind::SEQ_NTH},
+ {SEQ_CONCAT, CVC5::Kind::STRING_CONCAT},
+ {SEQ_LENGTH, CVC5::Kind::STRING_LENGTH},
+ {SEQ_EXTRACT, CVC5::Kind::STRING_SUBSTR},
+ {SEQ_UPDATE, CVC5::Kind::STRING_UPDATE},
+ {SEQ_AT, CVC5::Kind::STRING_CHARAT},
+ {SEQ_CONTAINS, CVC5::Kind::STRING_STRCTN},
+ {SEQ_INDEXOF, CVC5::Kind::STRING_STRIDOF},
+ {SEQ_REPLACE, CVC5::Kind::STRING_STRREPL},
+ {SEQ_REPLACE_ALL, CVC5::Kind::STRING_STRREPLALL},
+ {SEQ_REV, CVC5::Kind::STRING_REV},
+ {SEQ_PREFIX, CVC5::Kind::STRING_PREFIX},
+ {SEQ_SUFFIX, CVC5::Kind::STRING_SUFFIX},
+ {CONST_SEQUENCE, CVC5::Kind::CONST_SEQUENCE},
+ {SEQ_UNIT, CVC5::Kind::SEQ_UNIT},
+ {SEQ_NTH, CVC5::Kind::SEQ_NTH},
/* Quantifiers --------------------------------------------------------- */
- {FORALL, CVC4::Kind::FORALL},
- {EXISTS, CVC4::Kind::EXISTS},
- {BOUND_VAR_LIST, CVC4::Kind::BOUND_VAR_LIST},
- {INST_PATTERN, CVC4::Kind::INST_PATTERN},
- {INST_NO_PATTERN, CVC4::Kind::INST_NO_PATTERN},
- {INST_ATTRIBUTE, CVC4::Kind::INST_ATTRIBUTE},
- {INST_PATTERN_LIST, CVC4::Kind::INST_PATTERN_LIST},
- {LAST_KIND, CVC4::Kind::LAST_KIND},
+ {FORALL, CVC5::Kind::FORALL},
+ {EXISTS, CVC5::Kind::EXISTS},
+ {BOUND_VAR_LIST, CVC5::Kind::BOUND_VAR_LIST},
+ {INST_PATTERN, CVC5::Kind::INST_PATTERN},
+ {INST_NO_PATTERN, CVC5::Kind::INST_NO_PATTERN},
+ {INST_ATTRIBUTE, CVC5::Kind::INST_ATTRIBUTE},
+ {INST_PATTERN_LIST, CVC5::Kind::INST_PATTERN_LIST},
+ {LAST_KIND, CVC5::Kind::LAST_KIND},
};
/* Mapping from internal kind to external (API) kind. */
-const static std::unordered_map<CVC4::Kind, Kind, CVC4::kind::KindHashFunction>
+const static std::unordered_map<CVC5::Kind, Kind, CVC5::kind::KindHashFunction>
s_kinds_internal{
- {CVC4::Kind::UNDEFINED_KIND, UNDEFINED_KIND},
- {CVC4::Kind::NULL_EXPR, NULL_EXPR},
+ {CVC5::Kind::UNDEFINED_KIND, UNDEFINED_KIND},
+ {CVC5::Kind::NULL_EXPR, NULL_EXPR},
/* Builtin --------------------------------------------------------- */
- {CVC4::Kind::UNINTERPRETED_CONSTANT, UNINTERPRETED_CONSTANT},
- {CVC4::Kind::ABSTRACT_VALUE, ABSTRACT_VALUE},
- {CVC4::Kind::EQUAL, EQUAL},
- {CVC4::Kind::DISTINCT, DISTINCT},
- {CVC4::Kind::VARIABLE, CONSTANT},
- {CVC4::Kind::BOUND_VARIABLE, VARIABLE},
- {CVC4::Kind::SEXPR, SEXPR},
- {CVC4::Kind::LAMBDA, LAMBDA},
- {CVC4::Kind::WITNESS, WITNESS},
+ {CVC5::Kind::UNINTERPRETED_CONSTANT, UNINTERPRETED_CONSTANT},
+ {CVC5::Kind::ABSTRACT_VALUE, ABSTRACT_VALUE},
+ {CVC5::Kind::EQUAL, EQUAL},
+ {CVC5::Kind::DISTINCT, DISTINCT},
+ {CVC5::Kind::VARIABLE, CONSTANT},
+ {CVC5::Kind::BOUND_VARIABLE, VARIABLE},
+ {CVC5::Kind::SEXPR, SEXPR},
+ {CVC5::Kind::LAMBDA, LAMBDA},
+ {CVC5::Kind::WITNESS, WITNESS},
/* Boolean --------------------------------------------------------- */
- {CVC4::Kind::CONST_BOOLEAN, CONST_BOOLEAN},
- {CVC4::Kind::NOT, NOT},
- {CVC4::Kind::AND, AND},
- {CVC4::Kind::IMPLIES, IMPLIES},
- {CVC4::Kind::OR, OR},
- {CVC4::Kind::XOR, XOR},
- {CVC4::Kind::ITE, ITE},
- {CVC4::Kind::MATCH, MATCH},
- {CVC4::Kind::MATCH_CASE, MATCH_CASE},
- {CVC4::Kind::MATCH_BIND_CASE, MATCH_BIND_CASE},
+ {CVC5::Kind::CONST_BOOLEAN, CONST_BOOLEAN},
+ {CVC5::Kind::NOT, NOT},
+ {CVC5::Kind::AND, AND},
+ {CVC5::Kind::IMPLIES, IMPLIES},
+ {CVC5::Kind::OR, OR},
+ {CVC5::Kind::XOR, XOR},
+ {CVC5::Kind::ITE, ITE},
+ {CVC5::Kind::MATCH, MATCH},
+ {CVC5::Kind::MATCH_CASE, MATCH_CASE},
+ {CVC5::Kind::MATCH_BIND_CASE, MATCH_BIND_CASE},
/* UF -------------------------------------------------------------- */
- {CVC4::Kind::APPLY_UF, APPLY_UF},
- {CVC4::Kind::CARDINALITY_CONSTRAINT, CARDINALITY_CONSTRAINT},
- {CVC4::Kind::CARDINALITY_VALUE, CARDINALITY_VALUE},
- {CVC4::Kind::HO_APPLY, HO_APPLY},
+ {CVC5::Kind::APPLY_UF, APPLY_UF},
+ {CVC5::Kind::CARDINALITY_CONSTRAINT, CARDINALITY_CONSTRAINT},
+ {CVC5::Kind::CARDINALITY_VALUE, CARDINALITY_VALUE},
+ {CVC5::Kind::HO_APPLY, HO_APPLY},
/* Arithmetic ------------------------------------------------------ */
- {CVC4::Kind::PLUS, PLUS},
- {CVC4::Kind::MULT, MULT},
- {CVC4::Kind::IAND, IAND},
- {CVC4::Kind::MINUS, MINUS},
- {CVC4::Kind::UMINUS, UMINUS},
- {CVC4::Kind::DIVISION, DIVISION},
- {CVC4::Kind::DIVISION_TOTAL, INTERNAL_KIND},
- {CVC4::Kind::INTS_DIVISION, INTS_DIVISION},
- {CVC4::Kind::INTS_DIVISION_TOTAL, INTERNAL_KIND},
- {CVC4::Kind::INTS_MODULUS, INTS_MODULUS},
- {CVC4::Kind::INTS_MODULUS_TOTAL, INTERNAL_KIND},
- {CVC4::Kind::ABS, ABS},
- {CVC4::Kind::DIVISIBLE, DIVISIBLE},
- {CVC4::Kind::POW, POW},
- {CVC4::Kind::EXPONENTIAL, EXPONENTIAL},
- {CVC4::Kind::SINE, SINE},
- {CVC4::Kind::COSINE, COSINE},
- {CVC4::Kind::TANGENT, TANGENT},
- {CVC4::Kind::COSECANT, COSECANT},
- {CVC4::Kind::SECANT, SECANT},
- {CVC4::Kind::COTANGENT, COTANGENT},
- {CVC4::Kind::ARCSINE, ARCSINE},
- {CVC4::Kind::ARCCOSINE, ARCCOSINE},
- {CVC4::Kind::ARCTANGENT, ARCTANGENT},
- {CVC4::Kind::ARCCOSECANT, ARCCOSECANT},
- {CVC4::Kind::ARCSECANT, ARCSECANT},
- {CVC4::Kind::ARCCOTANGENT, ARCCOTANGENT},
- {CVC4::Kind::SQRT, SQRT},
- {CVC4::Kind::DIVISIBLE_OP, DIVISIBLE},
- {CVC4::Kind::CONST_RATIONAL, CONST_RATIONAL},
- {CVC4::Kind::LT, LT},
- {CVC4::Kind::LEQ, LEQ},
- {CVC4::Kind::GT, GT},
- {CVC4::Kind::GEQ, GEQ},
- {CVC4::Kind::IS_INTEGER, IS_INTEGER},
- {CVC4::Kind::TO_INTEGER, TO_INTEGER},
- {CVC4::Kind::TO_REAL, TO_REAL},
- {CVC4::Kind::PI, PI},
+ {CVC5::Kind::PLUS, PLUS},
+ {CVC5::Kind::MULT, MULT},
+ {CVC5::Kind::IAND, IAND},
+ {CVC5::Kind::MINUS, MINUS},
+ {CVC5::Kind::UMINUS, UMINUS},
+ {CVC5::Kind::DIVISION, DIVISION},
+ {CVC5::Kind::DIVISION_TOTAL, INTERNAL_KIND},
+ {CVC5::Kind::INTS_DIVISION, INTS_DIVISION},
+ {CVC5::Kind::INTS_DIVISION_TOTAL, INTERNAL_KIND},
+ {CVC5::Kind::INTS_MODULUS, INTS_MODULUS},
+ {CVC5::Kind::INTS_MODULUS_TOTAL, INTERNAL_KIND},
+ {CVC5::Kind::ABS, ABS},
+ {CVC5::Kind::DIVISIBLE, DIVISIBLE},
+ {CVC5::Kind::POW, POW},
+ {CVC5::Kind::EXPONENTIAL, EXPONENTIAL},
+ {CVC5::Kind::SINE, SINE},
+ {CVC5::Kind::COSINE, COSINE},
+ {CVC5::Kind::TANGENT, TANGENT},
+ {CVC5::Kind::COSECANT, COSECANT},
+ {CVC5::Kind::SECANT, SECANT},
+ {CVC5::Kind::COTANGENT, COTANGENT},
+ {CVC5::Kind::ARCSINE, ARCSINE},
+ {CVC5::Kind::ARCCOSINE, ARCCOSINE},
+ {CVC5::Kind::ARCTANGENT, ARCTANGENT},
+ {CVC5::Kind::ARCCOSECANT, ARCCOSECANT},
+ {CVC5::Kind::ARCSECANT, ARCSECANT},
+ {CVC5::Kind::ARCCOTANGENT, ARCCOTANGENT},
+ {CVC5::Kind::SQRT, SQRT},
+ {CVC5::Kind::DIVISIBLE_OP, DIVISIBLE},
+ {CVC5::Kind::CONST_RATIONAL, CONST_RATIONAL},
+ {CVC5::Kind::LT, LT},
+ {CVC5::Kind::LEQ, LEQ},
+ {CVC5::Kind::GT, GT},
+ {CVC5::Kind::GEQ, GEQ},
+ {CVC5::Kind::IS_INTEGER, IS_INTEGER},
+ {CVC5::Kind::TO_INTEGER, TO_INTEGER},
+ {CVC5::Kind::TO_REAL, TO_REAL},
+ {CVC5::Kind::PI, PI},
/* BV -------------------------------------------------------------- */
- {CVC4::Kind::CONST_BITVECTOR, CONST_BITVECTOR},
- {CVC4::Kind::BITVECTOR_CONCAT, BITVECTOR_CONCAT},
- {CVC4::Kind::BITVECTOR_AND, BITVECTOR_AND},
- {CVC4::Kind::BITVECTOR_OR, BITVECTOR_OR},
- {CVC4::Kind::BITVECTOR_XOR, BITVECTOR_XOR},
- {CVC4::Kind::BITVECTOR_NOT, BITVECTOR_NOT},
- {CVC4::Kind::BITVECTOR_NAND, BITVECTOR_NAND},
- {CVC4::Kind::BITVECTOR_NOR, BITVECTOR_NOR},
- {CVC4::Kind::BITVECTOR_XNOR, BITVECTOR_XNOR},
- {CVC4::Kind::BITVECTOR_COMP, BITVECTOR_COMP},
- {CVC4::Kind::BITVECTOR_MULT, BITVECTOR_MULT},
- {CVC4::Kind::BITVECTOR_PLUS, BITVECTOR_PLUS},
- {CVC4::Kind::BITVECTOR_SUB, BITVECTOR_SUB},
- {CVC4::Kind::BITVECTOR_NEG, BITVECTOR_NEG},
- {CVC4::Kind::BITVECTOR_UDIV, BITVECTOR_UDIV},
- {CVC4::Kind::BITVECTOR_UREM, BITVECTOR_UREM},
- {CVC4::Kind::BITVECTOR_SDIV, BITVECTOR_SDIV},
- {CVC4::Kind::BITVECTOR_SREM, BITVECTOR_SREM},
- {CVC4::Kind::BITVECTOR_SMOD, BITVECTOR_SMOD},
- {CVC4::Kind::BITVECTOR_SHL, BITVECTOR_SHL},
- {CVC4::Kind::BITVECTOR_LSHR, BITVECTOR_LSHR},
- {CVC4::Kind::BITVECTOR_ASHR, BITVECTOR_ASHR},
- {CVC4::Kind::BITVECTOR_ULT, BITVECTOR_ULT},
- {CVC4::Kind::BITVECTOR_ULE, BITVECTOR_ULE},
- {CVC4::Kind::BITVECTOR_UGT, BITVECTOR_UGT},
- {CVC4::Kind::BITVECTOR_UGE, BITVECTOR_UGE},
- {CVC4::Kind::BITVECTOR_SLT, BITVECTOR_SLT},
- {CVC4::Kind::BITVECTOR_SLE, BITVECTOR_SLE},
- {CVC4::Kind::BITVECTOR_SGT, BITVECTOR_SGT},
- {CVC4::Kind::BITVECTOR_SGE, BITVECTOR_SGE},
- {CVC4::Kind::BITVECTOR_ULTBV, BITVECTOR_ULTBV},
- {CVC4::Kind::BITVECTOR_SLTBV, BITVECTOR_SLTBV},
- {CVC4::Kind::BITVECTOR_ITE, BITVECTOR_ITE},
- {CVC4::Kind::BITVECTOR_REDOR, BITVECTOR_REDOR},
- {CVC4::Kind::BITVECTOR_REDAND, BITVECTOR_REDAND},
- {CVC4::Kind::BITVECTOR_EXTRACT_OP, BITVECTOR_EXTRACT},
- {CVC4::Kind::BITVECTOR_REPEAT_OP, BITVECTOR_REPEAT},
- {CVC4::Kind::BITVECTOR_ZERO_EXTEND_OP, BITVECTOR_ZERO_EXTEND},
- {CVC4::Kind::BITVECTOR_SIGN_EXTEND_OP, BITVECTOR_SIGN_EXTEND},
- {CVC4::Kind::BITVECTOR_ROTATE_LEFT_OP, BITVECTOR_ROTATE_LEFT},
- {CVC4::Kind::BITVECTOR_ROTATE_RIGHT_OP, BITVECTOR_ROTATE_RIGHT},
- {CVC4::Kind::BITVECTOR_EXTRACT, BITVECTOR_EXTRACT},
- {CVC4::Kind::BITVECTOR_REPEAT, BITVECTOR_REPEAT},
- {CVC4::Kind::BITVECTOR_ZERO_EXTEND, BITVECTOR_ZERO_EXTEND},
- {CVC4::Kind::BITVECTOR_SIGN_EXTEND, BITVECTOR_SIGN_EXTEND},
- {CVC4::Kind::BITVECTOR_ROTATE_LEFT, BITVECTOR_ROTATE_LEFT},
- {CVC4::Kind::BITVECTOR_ROTATE_RIGHT, BITVECTOR_ROTATE_RIGHT},
- {CVC4::Kind::INT_TO_BITVECTOR_OP, INT_TO_BITVECTOR},
- {CVC4::Kind::INT_TO_BITVECTOR, INT_TO_BITVECTOR},
- {CVC4::Kind::BITVECTOR_TO_NAT, BITVECTOR_TO_NAT},
+ {CVC5::Kind::CONST_BITVECTOR, CONST_BITVECTOR},
+ {CVC5::Kind::BITVECTOR_CONCAT, BITVECTOR_CONCAT},
+ {CVC5::Kind::BITVECTOR_AND, BITVECTOR_AND},
+ {CVC5::Kind::BITVECTOR_OR, BITVECTOR_OR},
+ {CVC5::Kind::BITVECTOR_XOR, BITVECTOR_XOR},
+ {CVC5::Kind::BITVECTOR_NOT, BITVECTOR_NOT},
+ {CVC5::Kind::BITVECTOR_NAND, BITVECTOR_NAND},
+ {CVC5::Kind::BITVECTOR_NOR, BITVECTOR_NOR},
+ {CVC5::Kind::BITVECTOR_XNOR, BITVECTOR_XNOR},
+ {CVC5::Kind::BITVECTOR_COMP, BITVECTOR_COMP},
+ {CVC5::Kind::BITVECTOR_MULT, BITVECTOR_MULT},
+ {CVC5::Kind::BITVECTOR_PLUS, BITVECTOR_PLUS},
+ {CVC5::Kind::BITVECTOR_SUB, BITVECTOR_SUB},
+ {CVC5::Kind::BITVECTOR_NEG, BITVECTOR_NEG},
+ {CVC5::Kind::BITVECTOR_UDIV, BITVECTOR_UDIV},
+ {CVC5::Kind::BITVECTOR_UREM, BITVECTOR_UREM},
+ {CVC5::Kind::BITVECTOR_SDIV, BITVECTOR_SDIV},
+ {CVC5::Kind::BITVECTOR_SREM, BITVECTOR_SREM},
+ {CVC5::Kind::BITVECTOR_SMOD, BITVECTOR_SMOD},
+ {CVC5::Kind::BITVECTOR_SHL, BITVECTOR_SHL},
+ {CVC5::Kind::BITVECTOR_LSHR, BITVECTOR_LSHR},
+ {CVC5::Kind::BITVECTOR_ASHR, BITVECTOR_ASHR},
+ {CVC5::Kind::BITVECTOR_ULT, BITVECTOR_ULT},
+ {CVC5::Kind::BITVECTOR_ULE, BITVECTOR_ULE},
+ {CVC5::Kind::BITVECTOR_UGT, BITVECTOR_UGT},
+ {CVC5::Kind::BITVECTOR_UGE, BITVECTOR_UGE},
+ {CVC5::Kind::BITVECTOR_SLT, BITVECTOR_SLT},
+ {CVC5::Kind::BITVECTOR_SLE, BITVECTOR_SLE},
+ {CVC5::Kind::BITVECTOR_SGT, BITVECTOR_SGT},
+ {CVC5::Kind::BITVECTOR_SGE, BITVECTOR_SGE},
+ {CVC5::Kind::BITVECTOR_ULTBV, BITVECTOR_ULTBV},
+ {CVC5::Kind::BITVECTOR_SLTBV, BITVECTOR_SLTBV},
+ {CVC5::Kind::BITVECTOR_ITE, BITVECTOR_ITE},
+ {CVC5::Kind::BITVECTOR_REDOR, BITVECTOR_REDOR},
+ {CVC5::Kind::BITVECTOR_REDAND, BITVECTOR_REDAND},
+ {CVC5::Kind::BITVECTOR_EXTRACT_OP, BITVECTOR_EXTRACT},
+ {CVC5::Kind::BITVECTOR_REPEAT_OP, BITVECTOR_REPEAT},
+ {CVC5::Kind::BITVECTOR_ZERO_EXTEND_OP, BITVECTOR_ZERO_EXTEND},
+ {CVC5::Kind::BITVECTOR_SIGN_EXTEND_OP, BITVECTOR_SIGN_EXTEND},
+ {CVC5::Kind::BITVECTOR_ROTATE_LEFT_OP, BITVECTOR_ROTATE_LEFT},
+ {CVC5::Kind::BITVECTOR_ROTATE_RIGHT_OP, BITVECTOR_ROTATE_RIGHT},
+ {CVC5::Kind::BITVECTOR_EXTRACT, BITVECTOR_EXTRACT},
+ {CVC5::Kind::BITVECTOR_REPEAT, BITVECTOR_REPEAT},
+ {CVC5::Kind::BITVECTOR_ZERO_EXTEND, BITVECTOR_ZERO_EXTEND},
+ {CVC5::Kind::BITVECTOR_SIGN_EXTEND, BITVECTOR_SIGN_EXTEND},
+ {CVC5::Kind::BITVECTOR_ROTATE_LEFT, BITVECTOR_ROTATE_LEFT},
+ {CVC5::Kind::BITVECTOR_ROTATE_RIGHT, BITVECTOR_ROTATE_RIGHT},
+ {CVC5::Kind::INT_TO_BITVECTOR_OP, INT_TO_BITVECTOR},
+ {CVC5::Kind::INT_TO_BITVECTOR, INT_TO_BITVECTOR},
+ {CVC5::Kind::BITVECTOR_TO_NAT, BITVECTOR_TO_NAT},
/* FP -------------------------------------------------------------- */
- {CVC4::Kind::CONST_FLOATINGPOINT, CONST_FLOATINGPOINT},
- {CVC4::Kind::CONST_ROUNDINGMODE, CONST_ROUNDINGMODE},
- {CVC4::Kind::FLOATINGPOINT_FP, FLOATINGPOINT_FP},
- {CVC4::Kind::FLOATINGPOINT_EQ, FLOATINGPOINT_EQ},
- {CVC4::Kind::FLOATINGPOINT_ABS, FLOATINGPOINT_ABS},
- {CVC4::Kind::FLOATINGPOINT_NEG, FLOATINGPOINT_NEG},
- {CVC4::Kind::FLOATINGPOINT_PLUS, FLOATINGPOINT_PLUS},
- {CVC4::Kind::FLOATINGPOINT_SUB, FLOATINGPOINT_SUB},
- {CVC4::Kind::FLOATINGPOINT_MULT, FLOATINGPOINT_MULT},
- {CVC4::Kind::FLOATINGPOINT_DIV, FLOATINGPOINT_DIV},
- {CVC4::Kind::FLOATINGPOINT_FMA, FLOATINGPOINT_FMA},
- {CVC4::Kind::FLOATINGPOINT_SQRT, FLOATINGPOINT_SQRT},
- {CVC4::Kind::FLOATINGPOINT_REM, FLOATINGPOINT_REM},
- {CVC4::Kind::FLOATINGPOINT_RTI, FLOATINGPOINT_RTI},
- {CVC4::Kind::FLOATINGPOINT_MIN, FLOATINGPOINT_MIN},
- {CVC4::Kind::FLOATINGPOINT_MAX, FLOATINGPOINT_MAX},
- {CVC4::Kind::FLOATINGPOINT_LEQ, FLOATINGPOINT_LEQ},
- {CVC4::Kind::FLOATINGPOINT_LT, FLOATINGPOINT_LT},
- {CVC4::Kind::FLOATINGPOINT_GEQ, FLOATINGPOINT_GEQ},
- {CVC4::Kind::FLOATINGPOINT_GT, FLOATINGPOINT_GT},
- {CVC4::Kind::FLOATINGPOINT_ISN, FLOATINGPOINT_ISN},
- {CVC4::Kind::FLOATINGPOINT_ISSN, FLOATINGPOINT_ISSN},
- {CVC4::Kind::FLOATINGPOINT_ISZ, FLOATINGPOINT_ISZ},
- {CVC4::Kind::FLOATINGPOINT_ISINF, FLOATINGPOINT_ISINF},
- {CVC4::Kind::FLOATINGPOINT_ISNAN, FLOATINGPOINT_ISNAN},
- {CVC4::Kind::FLOATINGPOINT_ISNEG, FLOATINGPOINT_ISNEG},
- {CVC4::Kind::FLOATINGPOINT_ISPOS, FLOATINGPOINT_ISPOS},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_IEEE_BITVECTOR_OP,
+ {CVC5::Kind::CONST_FLOATINGPOINT, CONST_FLOATINGPOINT},
+ {CVC5::Kind::CONST_ROUNDINGMODE, CONST_ROUNDINGMODE},
+ {CVC5::Kind::FLOATINGPOINT_FP, FLOATINGPOINT_FP},
+ {CVC5::Kind::FLOATINGPOINT_EQ, FLOATINGPOINT_EQ},
+ {CVC5::Kind::FLOATINGPOINT_ABS, FLOATINGPOINT_ABS},
+ {CVC5::Kind::FLOATINGPOINT_NEG, FLOATINGPOINT_NEG},
+ {CVC5::Kind::FLOATINGPOINT_PLUS, FLOATINGPOINT_PLUS},
+ {CVC5::Kind::FLOATINGPOINT_SUB, FLOATINGPOINT_SUB},
+ {CVC5::Kind::FLOATINGPOINT_MULT, FLOATINGPOINT_MULT},
+ {CVC5::Kind::FLOATINGPOINT_DIV, FLOATINGPOINT_DIV},
+ {CVC5::Kind::FLOATINGPOINT_FMA, FLOATINGPOINT_FMA},
+ {CVC5::Kind::FLOATINGPOINT_SQRT, FLOATINGPOINT_SQRT},
+ {CVC5::Kind::FLOATINGPOINT_REM, FLOATINGPOINT_REM},
+ {CVC5::Kind::FLOATINGPOINT_RTI, FLOATINGPOINT_RTI},
+ {CVC5::Kind::FLOATINGPOINT_MIN, FLOATINGPOINT_MIN},
+ {CVC5::Kind::FLOATINGPOINT_MAX, FLOATINGPOINT_MAX},
+ {CVC5::Kind::FLOATINGPOINT_LEQ, FLOATINGPOINT_LEQ},
+ {CVC5::Kind::FLOATINGPOINT_LT, FLOATINGPOINT_LT},
+ {CVC5::Kind::FLOATINGPOINT_GEQ, FLOATINGPOINT_GEQ},
+ {CVC5::Kind::FLOATINGPOINT_GT, FLOATINGPOINT_GT},
+ {CVC5::Kind::FLOATINGPOINT_ISN, FLOATINGPOINT_ISN},
+ {CVC5::Kind::FLOATINGPOINT_ISSN, FLOATINGPOINT_ISSN},
+ {CVC5::Kind::FLOATINGPOINT_ISZ, FLOATINGPOINT_ISZ},
+ {CVC5::Kind::FLOATINGPOINT_ISINF, FLOATINGPOINT_ISINF},
+ {CVC5::Kind::FLOATINGPOINT_ISNAN, FLOATINGPOINT_ISNAN},
+ {CVC5::Kind::FLOATINGPOINT_ISNEG, FLOATINGPOINT_ISNEG},
+ {CVC5::Kind::FLOATINGPOINT_ISPOS, FLOATINGPOINT_ISPOS},
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_IEEE_BITVECTOR_OP,
FLOATINGPOINT_TO_FP_IEEE_BITVECTOR},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_IEEE_BITVECTOR,
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_IEEE_BITVECTOR,
FLOATINGPOINT_TO_FP_IEEE_BITVECTOR},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_FLOATINGPOINT_OP,
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_FLOATINGPOINT_OP,
FLOATINGPOINT_TO_FP_FLOATINGPOINT},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_FLOATINGPOINT,
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_FLOATINGPOINT,
FLOATINGPOINT_TO_FP_FLOATINGPOINT},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_REAL_OP, FLOATINGPOINT_TO_FP_REAL},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_REAL, FLOATINGPOINT_TO_FP_REAL},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR_OP,
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_REAL_OP, FLOATINGPOINT_TO_FP_REAL},
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_REAL, FLOATINGPOINT_TO_FP_REAL},
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR_OP,
FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR,
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR,
FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR_OP,
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR_OP,
FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR,
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR,
FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_GENERIC_OP,
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_GENERIC_OP,
FLOATINGPOINT_TO_FP_GENERIC},
- {CVC4::Kind::FLOATINGPOINT_TO_FP_GENERIC, FLOATINGPOINT_TO_FP_GENERIC},
- {CVC4::Kind::FLOATINGPOINT_TO_UBV_OP, FLOATINGPOINT_TO_UBV},
- {CVC4::Kind::FLOATINGPOINT_TO_UBV, FLOATINGPOINT_TO_UBV},
- {CVC4::Kind::FLOATINGPOINT_TO_UBV_TOTAL_OP, INTERNAL_KIND},
- {CVC4::Kind::FLOATINGPOINT_TO_UBV_TOTAL, INTERNAL_KIND},
- {CVC4::Kind::FLOATINGPOINT_TO_SBV_OP, FLOATINGPOINT_TO_SBV},
- {CVC4::Kind::FLOATINGPOINT_TO_SBV, FLOATINGPOINT_TO_SBV},
- {CVC4::Kind::FLOATINGPOINT_TO_SBV_TOTAL_OP, INTERNAL_KIND},
- {CVC4::Kind::FLOATINGPOINT_TO_SBV_TOTAL, INTERNAL_KIND},
- {CVC4::Kind::FLOATINGPOINT_TO_REAL, FLOATINGPOINT_TO_REAL},
- {CVC4::Kind::FLOATINGPOINT_TO_REAL_TOTAL, INTERNAL_KIND},
+ {CVC5::Kind::FLOATINGPOINT_TO_FP_GENERIC, FLOATINGPOINT_TO_FP_GENERIC},
+ {CVC5::Kind::FLOATINGPOINT_TO_UBV_OP, FLOATINGPOINT_TO_UBV},
+ {CVC5::Kind::FLOATINGPOINT_TO_UBV, FLOATINGPOINT_TO_UBV},
+ {CVC5::Kind::FLOATINGPOINT_TO_UBV_TOTAL_OP, INTERNAL_KIND},
+ {CVC5::Kind::FLOATINGPOINT_TO_UBV_TOTAL, INTERNAL_KIND},
+ {CVC5::Kind::FLOATINGPOINT_TO_SBV_OP, FLOATINGPOINT_TO_SBV},
+ {CVC5::Kind::FLOATINGPOINT_TO_SBV, FLOATINGPOINT_TO_SBV},
+ {CVC5::Kind::FLOATINGPOINT_TO_SBV_TOTAL_OP, INTERNAL_KIND},
+ {CVC5::Kind::FLOATINGPOINT_TO_SBV_TOTAL, INTERNAL_KIND},
+ {CVC5::Kind::FLOATINGPOINT_TO_REAL, FLOATINGPOINT_TO_REAL},
+ {CVC5::Kind::FLOATINGPOINT_TO_REAL_TOTAL, INTERNAL_KIND},
/* Arrays ---------------------------------------------------------- */
- {CVC4::Kind::SELECT, SELECT},
- {CVC4::Kind::STORE, STORE},
- {CVC4::Kind::STORE_ALL, CONST_ARRAY},
+ {CVC5::Kind::SELECT, SELECT},
+ {CVC5::Kind::STORE, STORE},
+ {CVC5::Kind::STORE_ALL, CONST_ARRAY},
/* Datatypes ------------------------------------------------------- */
- {CVC4::Kind::APPLY_SELECTOR, APPLY_SELECTOR},
- {CVC4::Kind::APPLY_CONSTRUCTOR, APPLY_CONSTRUCTOR},
- {CVC4::Kind::APPLY_SELECTOR_TOTAL, INTERNAL_KIND},
- {CVC4::Kind::APPLY_TESTER, APPLY_TESTER},
- {CVC4::Kind::TUPLE_UPDATE_OP, TUPLE_UPDATE},
- {CVC4::Kind::TUPLE_UPDATE, TUPLE_UPDATE},
- {CVC4::Kind::RECORD_UPDATE_OP, RECORD_UPDATE},
- {CVC4::Kind::RECORD_UPDATE, RECORD_UPDATE},
- {CVC4::Kind::DT_SIZE, DT_SIZE},
- {CVC4::Kind::TUPLE_PROJECT, TUPLE_PROJECT},
+ {CVC5::Kind::APPLY_SELECTOR, APPLY_SELECTOR},
+ {CVC5::Kind::APPLY_CONSTRUCTOR, APPLY_CONSTRUCTOR},
+ {CVC5::Kind::APPLY_SELECTOR_TOTAL, INTERNAL_KIND},
+ {CVC5::Kind::APPLY_TESTER, APPLY_TESTER},
+ {CVC5::Kind::TUPLE_UPDATE_OP, TUPLE_UPDATE},
+ {CVC5::Kind::TUPLE_UPDATE, TUPLE_UPDATE},
+ {CVC5::Kind::RECORD_UPDATE_OP, RECORD_UPDATE},
+ {CVC5::Kind::RECORD_UPDATE, RECORD_UPDATE},
+ {CVC5::Kind::DT_SIZE, DT_SIZE},
+ {CVC5::Kind::TUPLE_PROJECT, TUPLE_PROJECT},
/* Separation Logic ------------------------------------------------ */
- {CVC4::Kind::SEP_NIL, SEP_NIL},
- {CVC4::Kind::SEP_EMP, SEP_EMP},
- {CVC4::Kind::SEP_PTO, SEP_PTO},
- {CVC4::Kind::SEP_STAR, SEP_STAR},
- {CVC4::Kind::SEP_WAND, SEP_WAND},
+ {CVC5::Kind::SEP_NIL, SEP_NIL},
+ {CVC5::Kind::SEP_EMP, SEP_EMP},
+ {CVC5::Kind::SEP_PTO, SEP_PTO},
+ {CVC5::Kind::SEP_STAR, SEP_STAR},
+ {CVC5::Kind::SEP_WAND, SEP_WAND},
/* Sets ------------------------------------------------------------ */
- {CVC4::Kind::EMPTYSET, EMPTYSET},
- {CVC4::Kind::UNION, UNION},
- {CVC4::Kind::INTERSECTION, INTERSECTION},
- {CVC4::Kind::SETMINUS, SETMINUS},
- {CVC4::Kind::SUBSET, SUBSET},
- {CVC4::Kind::MEMBER, MEMBER},
- {CVC4::Kind::SINGLETON, SINGLETON},
- {CVC4::Kind::INSERT, INSERT},
- {CVC4::Kind::CARD, CARD},
- {CVC4::Kind::COMPLEMENT, COMPLEMENT},
- {CVC4::Kind::UNIVERSE_SET, UNIVERSE_SET},
- {CVC4::Kind::JOIN, JOIN},
- {CVC4::Kind::PRODUCT, PRODUCT},
- {CVC4::Kind::TRANSPOSE, TRANSPOSE},
- {CVC4::Kind::TCLOSURE, TCLOSURE},
- {CVC4::Kind::JOIN_IMAGE, JOIN_IMAGE},
- {CVC4::Kind::IDEN, IDEN},
- {CVC4::Kind::COMPREHENSION, COMPREHENSION},
- {CVC4::Kind::CHOOSE, CHOOSE},
- {CVC4::Kind::IS_SINGLETON, IS_SINGLETON},
+ {CVC5::Kind::EMPTYSET, EMPTYSET},
+ {CVC5::Kind::UNION, UNION},
+ {CVC5::Kind::INTERSECTION, INTERSECTION},
+ {CVC5::Kind::SETMINUS, SETMINUS},
+ {CVC5::Kind::SUBSET, SUBSET},
+ {CVC5::Kind::MEMBER, MEMBER},
+ {CVC5::Kind::SINGLETON, SINGLETON},
+ {CVC5::Kind::INSERT, INSERT},
+ {CVC5::Kind::CARD, CARD},
+ {CVC5::Kind::COMPLEMENT, COMPLEMENT},
+ {CVC5::Kind::UNIVERSE_SET, UNIVERSE_SET},
+ {CVC5::Kind::JOIN, JOIN},
+ {CVC5::Kind::PRODUCT, PRODUCT},
+ {CVC5::Kind::TRANSPOSE, TRANSPOSE},
+ {CVC5::Kind::TCLOSURE, TCLOSURE},
+ {CVC5::Kind::JOIN_IMAGE, JOIN_IMAGE},
+ {CVC5::Kind::IDEN, IDEN},
+ {CVC5::Kind::COMPREHENSION, COMPREHENSION},
+ {CVC5::Kind::CHOOSE, CHOOSE},
+ {CVC5::Kind::IS_SINGLETON, IS_SINGLETON},
/* Bags ------------------------------------------------------------ */
- {CVC4::Kind::UNION_MAX, UNION_MAX},
- {CVC4::Kind::UNION_DISJOINT, UNION_DISJOINT},
- {CVC4::Kind::INTERSECTION_MIN, INTERSECTION_MIN},
- {CVC4::Kind::DIFFERENCE_SUBTRACT, DIFFERENCE_SUBTRACT},
- {CVC4::Kind::DIFFERENCE_REMOVE, DIFFERENCE_REMOVE},
- {CVC4::Kind::SUBBAG, SUBBAG},
- {CVC4::Kind::BAG_COUNT, BAG_COUNT},
- {CVC4::Kind::DUPLICATE_REMOVAL, DUPLICATE_REMOVAL},
- {CVC4::Kind::MK_BAG, MK_BAG},
- {CVC4::Kind::EMPTYBAG, EMPTYBAG},
- {CVC4::Kind::BAG_CARD, BAG_CARD},
- {CVC4::Kind::BAG_CHOOSE, BAG_CHOOSE},
- {CVC4::Kind::BAG_IS_SINGLETON, BAG_IS_SINGLETON},
- {CVC4::Kind::BAG_FROM_SET, BAG_FROM_SET},
- {CVC4::Kind::BAG_TO_SET, BAG_TO_SET},
+ {CVC5::Kind::UNION_MAX, UNION_MAX},
+ {CVC5::Kind::UNION_DISJOINT, UNION_DISJOINT},
+ {CVC5::Kind::INTERSECTION_MIN, INTERSECTION_MIN},
+ {CVC5::Kind::DIFFERENCE_SUBTRACT, DIFFERENCE_SUBTRACT},
+ {CVC5::Kind::DIFFERENCE_REMOVE, DIFFERENCE_REMOVE},
+ {CVC5::Kind::SUBBAG, SUBBAG},
+ {CVC5::Kind::BAG_COUNT, BAG_COUNT},
+ {CVC5::Kind::DUPLICATE_REMOVAL, DUPLICATE_REMOVAL},
+ {CVC5::Kind::MK_BAG, MK_BAG},
+ {CVC5::Kind::EMPTYBAG, EMPTYBAG},
+ {CVC5::Kind::BAG_CARD, BAG_CARD},
+ {CVC5::Kind::BAG_CHOOSE, BAG_CHOOSE},
+ {CVC5::Kind::BAG_IS_SINGLETON, BAG_IS_SINGLETON},
+ {CVC5::Kind::BAG_FROM_SET, BAG_FROM_SET},
+ {CVC5::Kind::BAG_TO_SET, BAG_TO_SET},
/* Strings --------------------------------------------------------- */
- {CVC4::Kind::STRING_CONCAT, STRING_CONCAT},
- {CVC4::Kind::STRING_IN_REGEXP, STRING_IN_REGEXP},
- {CVC4::Kind::STRING_LENGTH, STRING_LENGTH},
- {CVC4::Kind::STRING_SUBSTR, STRING_SUBSTR},
- {CVC4::Kind::STRING_UPDATE, STRING_UPDATE},
- {CVC4::Kind::STRING_CHARAT, STRING_CHARAT},
- {CVC4::Kind::STRING_STRCTN, STRING_CONTAINS},
- {CVC4::Kind::STRING_STRIDOF, STRING_INDEXOF},
- {CVC4::Kind::STRING_STRREPL, STRING_REPLACE},
- {CVC4::Kind::STRING_STRREPLALL, STRING_REPLACE_ALL},
- {CVC4::Kind::STRING_REPLACE_RE, STRING_REPLACE_RE},
- {CVC4::Kind::STRING_REPLACE_RE_ALL, STRING_REPLACE_RE_ALL},
- {CVC4::Kind::STRING_TOLOWER, STRING_TOLOWER},
- {CVC4::Kind::STRING_TOUPPER, STRING_TOUPPER},
- {CVC4::Kind::STRING_REV, STRING_REV},
- {CVC4::Kind::STRING_FROM_CODE, STRING_FROM_CODE},
- {CVC4::Kind::STRING_TO_CODE, STRING_TO_CODE},
- {CVC4::Kind::STRING_LT, STRING_LT},
- {CVC4::Kind::STRING_LEQ, STRING_LEQ},
- {CVC4::Kind::STRING_PREFIX, STRING_PREFIX},
- {CVC4::Kind::STRING_SUFFIX, STRING_SUFFIX},
- {CVC4::Kind::STRING_IS_DIGIT, STRING_IS_DIGIT},
- {CVC4::Kind::STRING_ITOS, STRING_FROM_INT},
- {CVC4::Kind::STRING_STOI, STRING_TO_INT},
- {CVC4::Kind::CONST_STRING, CONST_STRING},
- {CVC4::Kind::STRING_TO_REGEXP, STRING_TO_REGEXP},
- {CVC4::Kind::REGEXP_CONCAT, REGEXP_CONCAT},
- {CVC4::Kind::REGEXP_UNION, REGEXP_UNION},
- {CVC4::Kind::REGEXP_INTER, REGEXP_INTER},
- {CVC4::Kind::REGEXP_DIFF, REGEXP_DIFF},
- {CVC4::Kind::REGEXP_STAR, REGEXP_STAR},
- {CVC4::Kind::REGEXP_PLUS, REGEXP_PLUS},
- {CVC4::Kind::REGEXP_OPT, REGEXP_OPT},
- {CVC4::Kind::REGEXP_RANGE, REGEXP_RANGE},
- {CVC4::Kind::REGEXP_REPEAT, REGEXP_REPEAT},
- {CVC4::Kind::REGEXP_REPEAT_OP, REGEXP_REPEAT},
- {CVC4::Kind::REGEXP_LOOP, REGEXP_LOOP},
- {CVC4::Kind::REGEXP_LOOP_OP, REGEXP_LOOP},
- {CVC4::Kind::REGEXP_EMPTY, REGEXP_EMPTY},
- {CVC4::Kind::REGEXP_SIGMA, REGEXP_SIGMA},
- {CVC4::Kind::REGEXP_COMPLEMENT, REGEXP_COMPLEMENT},
- {CVC4::Kind::CONST_SEQUENCE, CONST_SEQUENCE},
- {CVC4::Kind::SEQ_UNIT, SEQ_UNIT},
- {CVC4::Kind::SEQ_NTH, SEQ_NTH},
+ {CVC5::Kind::STRING_CONCAT, STRING_CONCAT},
+ {CVC5::Kind::STRING_IN_REGEXP, STRING_IN_REGEXP},
+ {CVC5::Kind::STRING_LENGTH, STRING_LENGTH},
+ {CVC5::Kind::STRING_SUBSTR, STRING_SUBSTR},
+ {CVC5::Kind::STRING_UPDATE, STRING_UPDATE},
+ {CVC5::Kind::STRING_CHARAT, STRING_CHARAT},
+ {CVC5::Kind::STRING_STRCTN, STRING_CONTAINS},
+ {CVC5::Kind::STRING_STRIDOF, STRING_INDEXOF},
+ {CVC5::Kind::STRING_STRREPL, STRING_REPLACE},
+ {CVC5::Kind::STRING_STRREPLALL, STRING_REPLACE_ALL},
+ {CVC5::Kind::STRING_REPLACE_RE, STRING_REPLACE_RE},
+ {CVC5::Kind::STRING_REPLACE_RE_ALL, STRING_REPLACE_RE_ALL},
+ {CVC5::Kind::STRING_TOLOWER, STRING_TOLOWER},
+ {CVC5::Kind::STRING_TOUPPER, STRING_TOUPPER},
+ {CVC5::Kind::STRING_REV, STRING_REV},
+ {CVC5::Kind::STRING_FROM_CODE, STRING_FROM_CODE},
+ {CVC5::Kind::STRING_TO_CODE, STRING_TO_CODE},
+ {CVC5::Kind::STRING_LT, STRING_LT},
+ {CVC5::Kind::STRING_LEQ, STRING_LEQ},
+ {CVC5::Kind::STRING_PREFIX, STRING_PREFIX},
+ {CVC5::Kind::STRING_SUFFIX, STRING_SUFFIX},
+ {CVC5::Kind::STRING_IS_DIGIT, STRING_IS_DIGIT},
+ {CVC5::Kind::STRING_ITOS, STRING_FROM_INT},
+ {CVC5::Kind::STRING_STOI, STRING_TO_INT},
+ {CVC5::Kind::CONST_STRING, CONST_STRING},
+ {CVC5::Kind::STRING_TO_REGEXP, STRING_TO_REGEXP},
+ {CVC5::Kind::REGEXP_CONCAT, REGEXP_CONCAT},
+ {CVC5::Kind::REGEXP_UNION, REGEXP_UNION},
+ {CVC5::Kind::REGEXP_INTER, REGEXP_INTER},
+ {CVC5::Kind::REGEXP_DIFF, REGEXP_DIFF},
+ {CVC5::Kind::REGEXP_STAR, REGEXP_STAR},
+ {CVC5::Kind::REGEXP_PLUS, REGEXP_PLUS},
+ {CVC5::Kind::REGEXP_OPT, REGEXP_OPT},
+ {CVC5::Kind::REGEXP_RANGE, REGEXP_RANGE},
+ {CVC5::Kind::REGEXP_REPEAT, REGEXP_REPEAT},
+ {CVC5::Kind::REGEXP_REPEAT_OP, REGEXP_REPEAT},
+ {CVC5::Kind::REGEXP_LOOP, REGEXP_LOOP},
+ {CVC5::Kind::REGEXP_LOOP_OP, REGEXP_LOOP},
+ {CVC5::Kind::REGEXP_EMPTY, REGEXP_EMPTY},
+ {CVC5::Kind::REGEXP_SIGMA, REGEXP_SIGMA},
+ {CVC5::Kind::REGEXP_COMPLEMENT, REGEXP_COMPLEMENT},
+ {CVC5::Kind::CONST_SEQUENCE, CONST_SEQUENCE},
+ {CVC5::Kind::SEQ_UNIT, SEQ_UNIT},
+ {CVC5::Kind::SEQ_NTH, SEQ_NTH},
/* Quantifiers ----------------------------------------------------- */
- {CVC4::Kind::FORALL, FORALL},
- {CVC4::Kind::EXISTS, EXISTS},
- {CVC4::Kind::BOUND_VAR_LIST, BOUND_VAR_LIST},
- {CVC4::Kind::INST_PATTERN, INST_PATTERN},
- {CVC4::Kind::INST_NO_PATTERN, INST_NO_PATTERN},
- {CVC4::Kind::INST_ATTRIBUTE, INST_ATTRIBUTE},
- {CVC4::Kind::INST_PATTERN_LIST, INST_PATTERN_LIST},
+ {CVC5::Kind::FORALL, FORALL},
+ {CVC5::Kind::EXISTS, EXISTS},
+ {CVC5::Kind::BOUND_VAR_LIST, BOUND_VAR_LIST},
+ {CVC5::Kind::INST_PATTERN, INST_PATTERN},
+ {CVC5::Kind::INST_NO_PATTERN, INST_NO_PATTERN},
+ {CVC5::Kind::INST_ATTRIBUTE, INST_ATTRIBUTE},
+ {CVC5::Kind::INST_PATTERN_LIST, INST_PATTERN_LIST},
/* ----------------------------------------------------------------- */
- {CVC4::Kind::LAST_KIND, LAST_KIND},
+ {CVC5::Kind::LAST_KIND, LAST_KIND},
};
/* Set of kinds for indexed operators */
namespace {
-/** Convert a CVC4::Kind (internal) to a CVC4::api::Kind (external). */
-CVC4::api::Kind intToExtKind(CVC4::Kind k)
+/** Convert a CVC5::Kind (internal) to a CVC5::api::Kind (external). */
+CVC5::api::Kind intToExtKind(CVC5::Kind k)
{
auto it = api::s_kinds_internal.find(k);
if (it == api::s_kinds_internal.end())
return it->second;
}
-/** Convert a CVC4::api::Kind (external) to a CVC4::Kind (internal). */
-CVC4::Kind extToIntKind(CVC4::api::Kind k)
+/** Convert a CVC5::api::Kind (external) to a CVC5::Kind (internal). */
+CVC5::Kind extToIntKind(CVC5::api::Kind k)
{
auto it = api::s_kinds.find(k);
if (it == api::s_kinds.end())
{
- return CVC4::Kind::UNDEFINED_KIND;
+ return CVC5::Kind::UNDEFINED_KIND;
}
return it->second;
}
* as datatype constructors/selectors/testers as terms
* but interally they are not
*/
-bool isApplyKind(CVC4::Kind k)
+bool isApplyKind(CVC5::Kind k)
{
- return (k == CVC4::Kind::APPLY_UF || k == CVC4::Kind::APPLY_CONSTRUCTOR
- || k == CVC4::Kind::APPLY_SELECTOR || k == CVC4::Kind::APPLY_TESTER);
+ return (k == CVC5::Kind::APPLY_UF || k == CVC5::Kind::APPLY_CONSTRUCTOR
+ || k == CVC5::Kind::APPLY_SELECTOR || k == CVC5::Kind::APPLY_TESTER);
}
#ifdef CVC4_ASSERTIONS
/** Return true if given kind is a defined internal kind. */
-bool isDefinedIntKind(CVC4::Kind k)
+bool isDefinedIntKind(CVC5::Kind k)
{
- return k != CVC4::Kind::UNDEFINED_KIND && k != CVC4::Kind::LAST_KIND;
+ return k != CVC5::Kind::UNDEFINED_KIND && k != CVC5::Kind::LAST_KIND;
}
#endif
{
Assert(isDefinedKind(k));
Assert(isDefinedIntKind(extToIntKind(k)));
- uint32_t min = CVC4::kind::metakind::getMinArityForKind(extToIntKind(k));
+ uint32_t min = CVC5::kind::metakind::getMinArityForKind(extToIntKind(k));
// At the API level, we treat functions/constructors/selectors/testers as
// normal terms instead of making them part of the operator
{
Assert(isDefinedKind(k));
Assert(isDefinedIntKind(extToIntKind(k)));
- uint32_t max = CVC4::kind::metakind::getMaxArityForKind(extToIntKind(k));
+ uint32_t max = CVC5::kind::metakind::getMaxArityForKind(extToIntKind(k));
// At the API level, we treat functions/constructors/selectors/testers as
// normal terms instead of making them part of the operator
std::string kindToString(Kind k)
{
return k == INTERNAL_KIND ? "INTERNAL_KIND"
- : CVC4::kind::kindToString(extToIntKind(k));
+ : CVC5::kind::kindToString(extToIntKind(k));
}
std::ostream& operator<<(std::ostream& out, Kind k)
{ \
throw CVC4ApiRecoverableException(e.getMessage()); \
} \
- catch (const CVC4::RecoverableModalException& e) \
+ catch (const CVC5::RecoverableModalException& e) \
{ \
throw CVC4ApiRecoverableException(e.getMessage()); \
} \
- catch (const CVC4::Exception& e) { throw CVC4ApiException(e.getMessage()); } \
+ catch (const CVC5::Exception& e) { throw CVC4ApiException(e.getMessage()); } \
catch (const std::invalid_argument& e) { throw CVC4ApiException(e.what()); }
} // namespace
/* Result */
/* -------------------------------------------------------------------------- */
-Result::Result(const CVC4::Result& r) : d_result(new CVC4::Result(r)) {}
+Result::Result(const CVC5::Result& r) : d_result(new CVC5::Result(r)) {}
-Result::Result() : d_result(new CVC4::Result()) {}
+Result::Result() : d_result(new CVC5::Result()) {}
bool Result::isNull() const
{
- return d_result->getType() == CVC4::Result::TYPE_NONE;
+ return d_result->getType() == CVC5::Result::TYPE_NONE;
}
bool Result::isSat(void) const
{
- return d_result->getType() == CVC4::Result::TYPE_SAT
- && d_result->isSat() == CVC4::Result::SAT;
+ return d_result->getType() == CVC5::Result::TYPE_SAT
+ && d_result->isSat() == CVC5::Result::SAT;
}
bool Result::isUnsat(void) const
{
- return d_result->getType() == CVC4::Result::TYPE_SAT
- && d_result->isSat() == CVC4::Result::UNSAT;
+ return d_result->getType() == CVC5::Result::TYPE_SAT
+ && d_result->isSat() == CVC5::Result::UNSAT;
}
bool Result::isSatUnknown(void) const
{
- return d_result->getType() == CVC4::Result::TYPE_SAT
- && d_result->isSat() == CVC4::Result::SAT_UNKNOWN;
+ return d_result->getType() == CVC5::Result::TYPE_SAT
+ && d_result->isSat() == CVC5::Result::SAT_UNKNOWN;
}
bool Result::isEntailed(void) const
{
- return d_result->getType() == CVC4::Result::TYPE_ENTAILMENT
- && d_result->isEntailed() == CVC4::Result::ENTAILED;
+ return d_result->getType() == CVC5::Result::TYPE_ENTAILMENT
+ && d_result->isEntailed() == CVC5::Result::ENTAILED;
}
bool Result::isNotEntailed(void) const
{
- return d_result->getType() == CVC4::Result::TYPE_ENTAILMENT
- && d_result->isEntailed() == CVC4::Result::NOT_ENTAILED;
+ return d_result->getType() == CVC5::Result::TYPE_ENTAILMENT
+ && d_result->isEntailed() == CVC5::Result::NOT_ENTAILED;
}
bool Result::isEntailmentUnknown(void) const
{
- return d_result->getType() == CVC4::Result::TYPE_ENTAILMENT
- && d_result->isEntailed() == CVC4::Result::ENTAILMENT_UNKNOWN;
+ return d_result->getType() == CVC5::Result::TYPE_ENTAILMENT
+ && d_result->isEntailed() == CVC5::Result::ENTAILMENT_UNKNOWN;
}
bool Result::operator==(const Result& r) const
Result::UnknownExplanation Result::getUnknownExplanation(void) const
{
- CVC4::Result::UnknownExplanation expl = d_result->whyUnknown();
+ CVC5::Result::UnknownExplanation expl = d_result->whyUnknown();
switch (expl)
{
- case CVC4::Result::REQUIRES_FULL_CHECK: return REQUIRES_FULL_CHECK;
- case CVC4::Result::INCOMPLETE: return INCOMPLETE;
- case CVC4::Result::TIMEOUT: return TIMEOUT;
- case CVC4::Result::RESOURCEOUT: return RESOURCEOUT;
- case CVC4::Result::MEMOUT: return MEMOUT;
- case CVC4::Result::INTERRUPTED: return INTERRUPTED;
- case CVC4::Result::NO_STATUS: return NO_STATUS;
- case CVC4::Result::UNSUPPORTED: return UNSUPPORTED;
- case CVC4::Result::OTHER: return OTHER;
+ case CVC5::Result::REQUIRES_FULL_CHECK: return REQUIRES_FULL_CHECK;
+ case CVC5::Result::INCOMPLETE: return INCOMPLETE;
+ case CVC5::Result::TIMEOUT: return TIMEOUT;
+ case CVC5::Result::RESOURCEOUT: return RESOURCEOUT;
+ case CVC5::Result::MEMOUT: return MEMOUT;
+ case CVC5::Result::INTERRUPTED: return INTERRUPTED;
+ case CVC5::Result::NO_STATUS: return NO_STATUS;
+ case CVC5::Result::UNSUPPORTED: return UNSUPPORTED;
+ case CVC5::Result::OTHER: return OTHER;
default: return UNKNOWN_REASON;
}
return UNKNOWN_REASON;
/* Sort */
/* -------------------------------------------------------------------------- */
-Sort::Sort(const Solver* slv, const CVC4::TypeNode& t)
- : d_solver(slv), d_type(new CVC4::TypeNode(t))
+Sort::Sort(const Solver* slv, const CVC5::TypeNode& t)
+ : d_solver(slv), d_type(new CVC5::TypeNode(t))
{
}
-Sort::Sort() : d_solver(nullptr), d_type(new CVC4::TypeNode()) {}
+Sort::Sort() : d_solver(nullptr), d_type(new CVC5::TypeNode()) {}
Sort::~Sort()
{
CVC4_API_CHECK(isParametricDatatype() || isSortConstructor())
<< "Expected parametric datatype or sort constructor sort.";
//////// all checks before this line
- std::vector<CVC4::TypeNode> tparams = sortVectorToTypeNodes(params);
+ std::vector<CVC5::TypeNode> tparams = sortVectorToTypeNodes(params);
if (d_type->isDatatype())
{
return Sort(d_solver, d_type->instantiateParametricDatatype(tparams));
CVC4_API_CHECK_SORTS(replacements);
//////// all checks before this line
- std::vector<CVC4::TypeNode> tSorts = sortVectorToTypeNodes(sorts),
+ std::vector<CVC5::TypeNode> tSorts = sortVectorToTypeNodes(sorts),
tReplacements =
sortVectorToTypeNodes(replacements);
return Sort(d_solver,
CVC4_API_TRY_CATCH_END;
}
-const CVC4::TypeNode& Sort::getTypeNode(void) const { return *d_type; }
+const CVC5::TypeNode& Sort::getTypeNode(void) const { return *d_type; }
/* Constructor sort ------------------------------------------------------- */
/* Op */
/* -------------------------------------------------------------------------- */
-Op::Op() : d_solver(nullptr), d_kind(NULL_EXPR), d_node(new CVC4::Node()) {}
+Op::Op() : d_solver(nullptr), d_kind(NULL_EXPR), d_node(new CVC5::Node()) {}
Op::Op(const Solver* slv, const Kind k)
- : d_solver(slv), d_kind(k), d_node(new CVC4::Node())
+ : d_solver(slv), d_kind(k), d_node(new CVC5::Node())
{
}
-Op::Op(const Solver* slv, const Kind k, const CVC4::Node& n)
- : d_solver(slv), d_kind(k), d_node(new CVC4::Node(n))
+Op::Op(const Solver* slv, const Kind k, const CVC5::Node& n)
+ : d_solver(slv), d_kind(k), d_node(new CVC5::Node(n))
{
}
// using if/else instead of case statement because want local variables
if (k == BITVECTOR_EXTRACT)
{
- CVC4::BitVectorExtract ext = d_node->getConst<BitVectorExtract>();
+ CVC5::BitVectorExtract ext = d_node->getConst<BitVectorExtract>();
indices = std::make_pair(ext.d_high, ext.d_low);
}
else if (k == FLOATINGPOINT_TO_FP_IEEE_BITVECTOR)
{
- CVC4::FloatingPointToFPIEEEBitVector ext =
+ CVC5::FloatingPointToFPIEEEBitVector ext =
d_node->getConst<FloatingPointToFPIEEEBitVector>();
indices = std::make_pair(ext.getSize().exponentWidth(),
ext.getSize().significandWidth());
}
else if (k == FLOATINGPOINT_TO_FP_FLOATINGPOINT)
{
- CVC4::FloatingPointToFPFloatingPoint ext =
+ CVC5::FloatingPointToFPFloatingPoint ext =
d_node->getConst<FloatingPointToFPFloatingPoint>();
indices = std::make_pair(ext.getSize().exponentWidth(),
ext.getSize().significandWidth());
}
else if (k == FLOATINGPOINT_TO_FP_REAL)
{
- CVC4::FloatingPointToFPReal ext = d_node->getConst<FloatingPointToFPReal>();
+ CVC5::FloatingPointToFPReal ext = d_node->getConst<FloatingPointToFPReal>();
indices = std::make_pair(ext.getSize().exponentWidth(),
ext.getSize().significandWidth());
}
else if (k == FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR)
{
- CVC4::FloatingPointToFPSignedBitVector ext =
+ CVC5::FloatingPointToFPSignedBitVector ext =
d_node->getConst<FloatingPointToFPSignedBitVector>();
indices = std::make_pair(ext.getSize().exponentWidth(),
ext.getSize().significandWidth());
}
else if (k == FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR)
{
- CVC4::FloatingPointToFPUnsignedBitVector ext =
+ CVC5::FloatingPointToFPUnsignedBitVector ext =
d_node->getConst<FloatingPointToFPUnsignedBitVector>();
indices = std::make_pair(ext.getSize().exponentWidth(),
ext.getSize().significandWidth());
}
else if (k == FLOATINGPOINT_TO_FP_GENERIC)
{
- CVC4::FloatingPointToFPGeneric ext =
+ CVC5::FloatingPointToFPGeneric ext =
d_node->getConst<FloatingPointToFPGeneric>();
indices = std::make_pair(ext.getSize().exponentWidth(),
ext.getSize().significandWidth());
}
else if (k == REGEXP_LOOP)
{
- CVC4::RegExpLoop ext = d_node->getConst<RegExpLoop>();
+ CVC5::RegExpLoop ext = d_node->getConst<RegExpLoop>();
indices = std::make_pair(ext.d_loopMinOcc, ext.d_loopMaxOcc);
}
else
/* Term */
/* -------------------------------------------------------------------------- */
-Term::Term() : d_solver(nullptr), d_node(new CVC4::Node()) {}
+Term::Term() : d_solver(nullptr), d_node(new CVC5::Node()) {}
-Term::Term(const Solver* slv, const CVC4::Node& n) : d_solver(slv)
+Term::Term(const Solver* slv, const CVC5::Node& n) : d_solver(slv)
{
// Ensure that we create the node in the correct node manager.
NodeManagerScope scope(d_solver->getNodeManager());
- d_node.reset(new CVC4::Node(n));
+ d_node.reset(new CVC5::Node(n));
}
Term::~Term()
{
// it's an indexed operator
// so we should return the indexed op
- CVC4::Node op = d_node->getOperator();
+ CVC5::Node op = d_node->getOperator();
return Op(d_solver, intToExtKind(d_node->getKind()), op);
}
// Notice this is the only case where getKindHelper is used, since the
CVC4_API_TRY_CATCH_BEGIN;
CVC4_API_CHECK_NOT_NULL;
// CONST_ARRAY kind maps to STORE_ALL internal kind
- CVC4_API_CHECK(d_node->getKind() == CVC4::Kind::STORE_ALL)
+ CVC4_API_CHECK(d_node->getKind() == CVC5::Kind::STORE_ALL)
<< "Expecting a CONST_ARRAY Term when calling getConstArrayBase()";
//////// all checks before this line
return Term(d_solver, d_node->getConst<ArrayStoreAll>().getValue());
{
CVC4_API_TRY_CATCH_BEGIN;
CVC4_API_CHECK_NOT_NULL;
- CVC4_API_CHECK(d_node->getKind() == CVC4::Kind::CONST_SEQUENCE)
+ CVC4_API_CHECK(d_node->getKind() == CVC5::Kind::CONST_SEQUENCE)
<< "Expecting a CONST_SEQUENCE Term when calling "
"getConstSequenceElements()";
//////// all checks before this line
}
Term::const_iterator::const_iterator(const Solver* slv,
- const std::shared_ptr<CVC4::Node>& n,
+ const std::shared_ptr<CVC5::Node>& n,
uint32_t p)
: d_solver(slv), d_origNode(n), d_pos(p)
{
return Term::const_iterator(d_solver, d_node, endpos);
}
-const CVC4::Node& Term::getNode(void) const { return *d_node; }
+const CVC5::Node& Term::getNode(void) const { return *d_node; }
namespace detail {
-const Rational& getRational(const CVC4::Node& node)
+const Rational& getRational(const CVC5::Node& node)
{
return node.getConst<Rational>();
}
-Integer getInteger(const CVC4::Node& node)
+Integer getInteger(const CVC5::Node& node)
{
return node.getConst<Rational>().getNumerator();
}
bool isInteger(const Node& node)
{
- return node.getKind() == CVC4::Kind::CONST_RATIONAL
+ return node.getKind() == CVC5::Kind::CONST_RATIONAL
&& node.getConst<Rational>().isIntegral();
}
bool isInt32(const Node& node)
CVC4_API_TRY_CATCH_BEGIN;
CVC4_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == CVC4::Kind::CONST_STRING;
+ return d_node->getKind() == CVC5::Kind::CONST_STRING;
////////
CVC4_API_TRY_CATCH_END;
}
{
CVC4_API_TRY_CATCH_BEGIN;
CVC4_API_CHECK_NOT_NULL;
- CVC4_API_CHECK(d_node->getKind() == CVC4::Kind::CONST_STRING)
+ CVC4_API_CHECK(d_node->getKind() == CVC5::Kind::CONST_STRING)
<< "Term should be a String when calling getString()";
//////// all checks before this line
- return d_node->getConst<CVC4::String>().toWString();
+ return d_node->getConst<CVC5::String>().toWString();
////////
CVC4_API_TRY_CATCH_END;
}
{
switch (d_node->getKind())
{
- case CVC4::Kind::STRING_CONCAT: return SEQ_CONCAT;
- case CVC4::Kind::STRING_LENGTH: return SEQ_LENGTH;
- case CVC4::Kind::STRING_SUBSTR: return SEQ_EXTRACT;
- case CVC4::Kind::STRING_UPDATE: return SEQ_UPDATE;
- case CVC4::Kind::STRING_CHARAT: return SEQ_AT;
- case CVC4::Kind::STRING_STRCTN: return SEQ_CONTAINS;
- case CVC4::Kind::STRING_STRIDOF: return SEQ_INDEXOF;
- case CVC4::Kind::STRING_STRREPL: return SEQ_REPLACE;
- case CVC4::Kind::STRING_STRREPLALL: return SEQ_REPLACE_ALL;
- case CVC4::Kind::STRING_REV: return SEQ_REV;
- case CVC4::Kind::STRING_PREFIX: return SEQ_PREFIX;
- case CVC4::Kind::STRING_SUFFIX: return SEQ_SUFFIX;
+ case CVC5::Kind::STRING_CONCAT: return SEQ_CONCAT;
+ case CVC5::Kind::STRING_LENGTH: return SEQ_LENGTH;
+ case CVC5::Kind::STRING_SUBSTR: return SEQ_EXTRACT;
+ case CVC5::Kind::STRING_UPDATE: return SEQ_UPDATE;
+ case CVC5::Kind::STRING_CHARAT: return SEQ_AT;
+ case CVC5::Kind::STRING_STRCTN: return SEQ_CONTAINS;
+ case CVC5::Kind::STRING_STRIDOF: return SEQ_INDEXOF;
+ case CVC5::Kind::STRING_STRREPL: return SEQ_REPLACE;
+ case CVC5::Kind::STRING_STRREPLALL: return SEQ_REPLACE_ALL;
+ case CVC5::Kind::STRING_REV: return SEQ_REV;
+ case CVC5::Kind::STRING_PREFIX: return SEQ_PREFIX;
+ case CVC5::Kind::STRING_SUFFIX: return SEQ_SUFFIX;
default:
// fall through to conversion below
break;
DatatypeConstructorDecl::DatatypeConstructorDecl(const Solver* slv,
const std::string& name)
- : d_solver(slv), d_ctor(new CVC4::DTypeConstructor(name))
+ : d_solver(slv), d_ctor(new CVC5::DTypeConstructor(name))
{
}
DatatypeConstructorDecl::~DatatypeConstructorDecl()
DatatypeDecl::DatatypeDecl(const Solver* slv,
const std::string& name,
bool isCoDatatype)
- : d_solver(slv), d_dtype(new CVC4::DType(name, isCoDatatype))
+ : d_solver(slv), d_dtype(new CVC5::DType(name, isCoDatatype))
{
}
const Sort& param,
bool isCoDatatype)
: d_solver(slv),
- d_dtype(new CVC4::DType(
+ d_dtype(new CVC5::DType(
name, std::vector<TypeNode>{*param.d_type}, isCoDatatype))
{
}
: d_solver(slv)
{
std::vector<TypeNode> tparams = Sort::sortVectorToTypeNodes(params);
- d_dtype = std::shared_ptr<CVC4::DType>(
- new CVC4::DType(name, tparams, isCoDatatype));
+ d_dtype = std::shared_ptr<CVC5::DType>(
+ new CVC5::DType(name, tparams, isCoDatatype));
}
bool DatatypeDecl::isNullHelper() const { return !d_dtype; }
return out;
}
-CVC4::DType& DatatypeDecl::getDatatype(void) const { return *d_dtype; }
+CVC5::DType& DatatypeDecl::getDatatype(void) const { return *d_dtype; }
/* DatatypeSelector --------------------------------------------------------- */
DatatypeSelector::DatatypeSelector() : d_solver(nullptr), d_stor(nullptr) {}
DatatypeSelector::DatatypeSelector(const Solver* slv,
- const CVC4::DTypeSelector& stor)
- : d_solver(slv), d_stor(new CVC4::DTypeSelector(stor))
+ const CVC5::DTypeSelector& stor)
+ : d_solver(slv), d_stor(new CVC5::DTypeSelector(stor))
{
CVC4_API_CHECK(d_stor->isResolved()) << "Expected resolved datatype selector";
}
}
DatatypeConstructor::DatatypeConstructor(const Solver* slv,
- const CVC4::DTypeConstructor& ctor)
- : d_solver(slv), d_ctor(new CVC4::DTypeConstructor(ctor))
+ const CVC5::DTypeConstructor& ctor)
+ : d_solver(slv), d_ctor(new CVC5::DTypeConstructor(ctor))
{
CVC4_API_CHECK(d_ctor->isResolved())
<< "Expected resolved datatype constructor";
}
DatatypeConstructor::const_iterator::const_iterator(
- const Solver* slv, const CVC4::DTypeConstructor& ctor, bool begin)
+ const Solver* slv, const CVC5::DTypeConstructor& ctor, bool begin)
{
d_solver = slv;
d_int_stors = &ctor.getArgs();
- const std::vector<std::shared_ptr<CVC4::DTypeSelector>>& sels =
+ const std::vector<std::shared_ptr<CVC5::DTypeSelector>>& sels =
ctor.getArgs();
- for (const std::shared_ptr<CVC4::DTypeSelector>& s : sels)
+ for (const std::shared_ptr<CVC5::DTypeSelector>& s : sels)
{
/* Can not use emplace_back here since constructor is private. */
d_stors.push_back(DatatypeSelector(d_solver, *s.get()));
/* Datatype ----------------------------------------------------------------- */
-Datatype::Datatype(const Solver* slv, const CVC4::DType& dtype)
- : d_solver(slv), d_dtype(new CVC4::DType(dtype))
+Datatype::Datatype(const Solver* slv, const CVC5::DType& dtype)
+ : d_solver(slv), d_dtype(new CVC5::DType(dtype))
{
CVC4_API_CHECK(d_dtype->isResolved()) << "Expected resolved datatype";
}
}
Datatype::const_iterator::const_iterator(const Solver* slv,
- const CVC4::DType& dtype,
+ const CVC5::DType& dtype,
bool begin)
: d_solver(slv), d_int_ctors(&dtype.getConstructors())
{
bvl = Term(
d_solver,
d_solver->getNodeManager()->mkNode(
- CVC4::kind::BOUND_VAR_LIST, Term::termVectorToNodes(d_sygusVars)));
+ CVC5::kind::BOUND_VAR_LIST, Term::termVectorToNodes(d_sygusVars)));
}
std::unordered_map<Term, Sort, TermHashFunction> ntsToUnres(d_ntSyms.size());
Sort(d_solver, d_solver->getNodeManager()->mkSort(ntsymbol.toString()));
}
- std::vector<CVC4::DType> datatypes;
+ std::vector<CVC5::DType> datatypes;
std::set<TypeNode> unresTypes;
datatypes.reserve(d_ntSyms.size());
{
Term lbvl =
Term(d_solver,
- d_solver->getNodeManager()->mkNode(CVC4::kind::BOUND_VAR_LIST,
+ d_solver->getNodeManager()->mkNode(CVC5::kind::BOUND_VAR_LIST,
Term::termVectorToNodes(args)));
// its operator is a lambda
op = Term(d_solver,
d_solver->getNodeManager()->mkNode(
- CVC4::kind::LAMBDA, *lbvl.d_node, *op.d_node));
+ CVC5::kind::LAMBDA, *lbvl.d_node, *op.d_node));
}
std::vector<TypeNode> cargst = Sort::sortVectorToTypeNodes(cargs);
dt.d_dtype->addSygusConstructor(*op.d_node, ssCName.str(), cargst);
/* -------------------------------------------------------------------------- */
const static std::
- unordered_map<RoundingMode, CVC4::RoundingMode, RoundingModeHashFunction>
+ unordered_map<RoundingMode, CVC5::RoundingMode, RoundingModeHashFunction>
s_rmodes{
{ROUND_NEAREST_TIES_TO_EVEN,
- CVC4::RoundingMode::ROUND_NEAREST_TIES_TO_EVEN},
- {ROUND_TOWARD_POSITIVE, CVC4::RoundingMode::ROUND_TOWARD_POSITIVE},
- {ROUND_TOWARD_NEGATIVE, CVC4::RoundingMode::ROUND_TOWARD_NEGATIVE},
- {ROUND_TOWARD_ZERO, CVC4::RoundingMode::ROUND_TOWARD_ZERO},
+ CVC5::RoundingMode::ROUND_NEAREST_TIES_TO_EVEN},
+ {ROUND_TOWARD_POSITIVE, CVC5::RoundingMode::ROUND_TOWARD_POSITIVE},
+ {ROUND_TOWARD_NEGATIVE, CVC5::RoundingMode::ROUND_TOWARD_NEGATIVE},
+ {ROUND_TOWARD_ZERO, CVC5::RoundingMode::ROUND_TOWARD_ZERO},
{ROUND_NEAREST_TIES_TO_AWAY,
- CVC4::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY},
+ CVC5::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY},
};
-const static std::unordered_map<CVC4::RoundingMode,
+const static std::unordered_map<CVC5::RoundingMode,
RoundingMode,
- CVC4::RoundingModeHashFunction>
+ CVC5::RoundingModeHashFunction>
s_rmodes_internal{
- {CVC4::RoundingMode::ROUND_NEAREST_TIES_TO_EVEN,
+ {CVC5::RoundingMode::ROUND_NEAREST_TIES_TO_EVEN,
ROUND_NEAREST_TIES_TO_EVEN},
- {CVC4::RoundingMode::ROUND_TOWARD_POSITIVE, ROUND_TOWARD_POSITIVE},
- {CVC4::RoundingMode::ROUND_TOWARD_POSITIVE, ROUND_TOWARD_NEGATIVE},
- {CVC4::RoundingMode::ROUND_TOWARD_ZERO, ROUND_TOWARD_ZERO},
- {CVC4::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY,
+ {CVC5::RoundingMode::ROUND_TOWARD_POSITIVE, ROUND_TOWARD_POSITIVE},
+ {CVC5::RoundingMode::ROUND_TOWARD_POSITIVE, ROUND_TOWARD_NEGATIVE},
+ {CVC5::RoundingMode::ROUND_TOWARD_ZERO, ROUND_TOWARD_ZERO},
+ {CVC5::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY,
ROUND_NEAREST_TIES_TO_AWAY},
};
{
#ifdef CVC4_STATISTICS_ON
const TypeNode tn = sort.getTypeNode();
- TypeConstant tc = tn.getKind() == CVC4::kind::TYPE_CONSTANT
+ TypeConstant tc = tn.getKind() == CVC5::kind::TYPE_CONSTANT
? tn.getConst<TypeConstant>()
: LAST_TYPE;
if (is_var)
//////// all checks before this line
try
{
- CVC4::Rational r = s.find('/') != std::string::npos
- ? CVC4::Rational(s)
- : CVC4::Rational::fromDecimal(s);
- return mkValHelper<CVC4::Rational>(r);
+ CVC5::Rational r = s.find('/') != std::string::npos
+ ? CVC5::Rational(s)
+ : CVC5::Rational::fromDecimal(s);
+ return mkValHelper<CVC5::Rational>(r);
}
catch (const std::invalid_argument& e)
{
{
CVC4_API_ARG_CHECK_EXPECTED(size > 0, size) << "a bit-width > 0";
//////// all checks before this line
- return mkValHelper<CVC4::BitVector>(CVC4::BitVector(size, val));
+ return mkValHelper<CVC5::BitVector>(CVC5::BitVector(size, val));
}
Term Solver::mkBVFromStrHelper(const std::string& s, uint32_t base) const
CVC4_API_ARG_CHECK_EXPECTED(base == 2 || base == 10 || base == 16, base)
<< "base 2, 10, or 16";
//////// all checks before this line
- return mkValHelper<CVC4::BitVector>(CVC4::BitVector(s, base));
+ return mkValHelper<CVC5::BitVector>(CVC5::BitVector(s, base));
}
Term Solver::mkBVFromStrHelper(uint32_t size,
<< size << " too small to hold value " << s << ")";
}
- return mkValHelper<CVC4::BitVector>(CVC4::BitVector(size, val));
+ return mkValHelper<CVC5::BitVector>(CVC5::BitVector(size, val));
}
Term Solver::mkCharFromStrHelper(const std::string& s) const
//////// all checks before this line
std::vector<unsigned> cpts;
cpts.push_back(val);
- return mkValHelper<CVC4::String>(CVC4::String(cpts));
+ return mkValHelper<CVC5::String>(CVC5::String(cpts));
}
Term Solver::getValueHelper(const Term& term) const
Node res;
if (kind == REGEXP_EMPTY || kind == REGEXP_SIGMA)
{
- CVC4::Kind k = extToIntKind(kind);
+ CVC5::Kind k = extToIntKind(kind);
Assert(isDefinedIntKind(k));
res = d_nodeMgr->mkNode(k, std::vector<Node>());
}
else
{
Assert(kind == PI);
- res = d_nodeMgr->mkNullaryOperator(d_nodeMgr->realType(), CVC4::kind::PI);
+ res = d_nodeMgr->mkNullaryOperator(d_nodeMgr->realType(), CVC5::kind::PI);
}
(void)res.getType(true); /* kick off type checking */
increment_term_stats(kind);
//////// all checks before this line
std::vector<Node> echildren = Term::termVectorToNodes(children);
- CVC4::Kind k = extToIntKind(kind);
+ CVC5::Kind k = extToIntKind(kind);
Node res;
if (echildren.size() > 2)
{
return mkTermHelper(op.d_kind, children);
}
- const CVC4::Kind int_kind = extToIntKind(op.d_kind);
+ const CVC5::Kind int_kind = extToIntKind(op.d_kind);
std::vector<Node> echildren = Term::termVectorToNodes(children);
NodeBuilder<> nb(int_kind);
// double checks
//////// all checks before this line
- std::vector<CVC4::DType> datatypes;
+ std::vector<CVC5::DType> datatypes;
for (size_t i = 0, ndts = dtypedecls.size(); i < ndts; ++i)
{
datatypes.push_back(dtypedecls[i].getDatatype());
}
std::set<TypeNode> utypes = Sort::sortSetToTypeNodes(unresolvedSorts);
- std::vector<CVC4::TypeNode> dtypes =
+ std::vector<CVC5::TypeNode> dtypes =
getNodeManager()->mkMutualDatatypeTypes(datatypes, utypes);
std::vector<Sort> retTypes = Sort::typeNodeVectorToSorts(this, dtypes);
return retTypes;
res = Term(this,
d_nodeMgr->mkNode(extToIntKind(DIVISION),
*res.d_node,
- d_nodeMgr->mkConst(CVC4::Rational(1))));
+ d_nodeMgr->mkConst(CVC5::Rational(1))));
}
Assert(res.getSort() == sort);
return res;
{
CVC4_API_KIND_CHECK(kind);
Assert(isDefinedIntKind(extToIntKind(kind)));
- const CVC4::kind::MetaKind mk = kind::metaKindOf(extToIntKind(kind));
+ const CVC5::kind::MetaKind mk = kind::metaKindOf(extToIntKind(kind));
CVC4_API_KIND_CHECK_EXPECTED(
mk == kind::metakind::PARAMETERIZED || mk == kind::metakind::OPERATOR,
kind)
CVC4_API_TRY_CATCH_BEGIN;
//////// all checks before this line
Node res =
- d_nodeMgr->mkNullaryOperator(d_nodeMgr->realType(), CVC4::kind::PI);
+ d_nodeMgr->mkNullaryOperator(d_nodeMgr->realType(), CVC5::kind::PI);
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
////////
NodeManagerScope scope(getNodeManager());
CVC4_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- Term integer = mkValHelper<CVC4::Rational>(CVC4::Rational(val));
+ Term integer = mkValHelper<CVC5::Rational>(CVC5::Rational(val));
Assert(integer.getSort() == getIntegerSort());
return integer;
////////
NodeManagerScope scope(getNodeManager());
CVC4_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- Term rational = mkValHelper<CVC4::Rational>(CVC4::Rational(val));
+ Term rational = mkValHelper<CVC5::Rational>(CVC5::Rational(val));
return ensureRealSort(rational);
////////
CVC4_API_TRY_CATCH_END;
NodeManagerScope scope(getNodeManager());
CVC4_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- Term rational = mkValHelper<CVC4::Rational>(CVC4::Rational(num, den));
+ Term rational = mkValHelper<CVC5::Rational>(CVC5::Rational(num, den));
return ensureRealSort(rational);
////////
CVC4_API_TRY_CATCH_END;
CVC4_API_TRY_CATCH_BEGIN;
//////// all checks before this line
Node res =
- d_nodeMgr->mkNode(CVC4::kind::REGEXP_EMPTY, std::vector<CVC4::Node>());
+ d_nodeMgr->mkNode(CVC5::kind::REGEXP_EMPTY, std::vector<CVC5::Node>());
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
////////
CVC4_API_TRY_CATCH_BEGIN;
//////// all checks before this line
Node res =
- d_nodeMgr->mkNode(CVC4::kind::REGEXP_SIGMA, std::vector<CVC4::Node>());
+ d_nodeMgr->mkNode(CVC5::kind::REGEXP_SIGMA, std::vector<CVC5::Node>());
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
////////
CVC4_API_ARG_CHECK_EXPECTED(sort.isNull() || this == sort.d_solver, sort)
<< "set sort associated with this solver object";
//////// all checks before this line
- return mkValHelper<CVC4::EmptySet>(CVC4::EmptySet(*sort.d_type));
+ return mkValHelper<CVC5::EmptySet>(CVC5::EmptySet(*sort.d_type));
////////
CVC4_API_TRY_CATCH_END;
}
CVC4_API_ARG_CHECK_EXPECTED(sort.isNull() || this == sort.d_solver, sort)
<< "bag sort associated with this solver object";
//////// all checks before this line
- return mkValHelper<CVC4::EmptyBag>(CVC4::EmptyBag(*sort.d_type));
+ return mkValHelper<CVC5::EmptyBag>(CVC5::EmptyBag(*sort.d_type));
////////
CVC4_API_TRY_CATCH_END;
}
CVC4_API_SOLVER_CHECK_SORT(sort);
//////// all checks before this line
Node res =
- getNodeManager()->mkNullaryOperator(*sort.d_type, CVC4::kind::SEP_NIL);
+ getNodeManager()->mkNullaryOperator(*sort.d_type, CVC5::kind::SEP_NIL);
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
////////
NodeManagerScope scope(getNodeManager());
CVC4_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkValHelper<CVC4::String>(CVC4::String(s, useEscSequences));
+ return mkValHelper<CVC5::String>(CVC5::String(s, useEscSequences));
////////
CVC4_API_TRY_CATCH_END;
}
NodeManagerScope scope(getNodeManager());
CVC4_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkValHelper<CVC4::String>(CVC4::String(std::string(1, c)));
+ return mkValHelper<CVC5::String>(CVC5::String(std::string(1, c)));
////////
CVC4_API_TRY_CATCH_END;
}
NodeManagerScope scope(getNodeManager());
CVC4_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkValHelper<CVC4::String>(CVC4::String(s));
+ return mkValHelper<CVC5::String>(CVC5::String(s));
////////
CVC4_API_TRY_CATCH_END;
}
//////// all checks before this line
Node res = getNodeManager()->mkNullaryOperator(*sort.d_type,
- CVC4::kind::UNIVERSE_SET);
+ CVC5::kind::UNIVERSE_SET);
// TODO(#2771): Reenable?
// (void)res->getType(true); /* kick off type checking */
return Term(this, res);
// this is safe because the constant array stores its type
n = n[0];
}
- Term res = mkValHelper<CVC4::ArrayStoreAll>(
- CVC4::ArrayStoreAll(*sort.d_type, n));
+ Term res =
+ mkValHelper<CVC5::ArrayStoreAll>(CVC5::ArrayStoreAll(*sort.d_type, n));
return res;
////////
CVC4_API_TRY_CATCH_END;
CVC4_API_CHECK(Configuration::isBuiltWithSymFPU())
<< "Expected CVC4 to be compiled with SymFPU support";
//////// all checks before this line
- return mkValHelper<CVC4::FloatingPoint>(
+ return mkValHelper<CVC5::FloatingPoint>(
FloatingPoint::makeInf(FloatingPointSize(exp, sig), false));
////////
CVC4_API_TRY_CATCH_END;
CVC4_API_CHECK(Configuration::isBuiltWithSymFPU())
<< "Expected CVC4 to be compiled with SymFPU support";
//////// all checks before this line
- return mkValHelper<CVC4::FloatingPoint>(
+ return mkValHelper<CVC5::FloatingPoint>(
FloatingPoint::makeInf(FloatingPointSize(exp, sig), true));
////////
CVC4_API_TRY_CATCH_END;
CVC4_API_CHECK(Configuration::isBuiltWithSymFPU())
<< "Expected CVC4 to be compiled with SymFPU support";
//////// all checks before this line
- return mkValHelper<CVC4::FloatingPoint>(
+ return mkValHelper<CVC5::FloatingPoint>(
FloatingPoint::makeNaN(FloatingPointSize(exp, sig)));
////////
CVC4_API_TRY_CATCH_END;
CVC4_API_CHECK(Configuration::isBuiltWithSymFPU())
<< "Expected CVC4 to be compiled with SymFPU support";
//////// all checks before this line
- return mkValHelper<CVC4::FloatingPoint>(
+ return mkValHelper<CVC5::FloatingPoint>(
FloatingPoint::makeZero(FloatingPointSize(exp, sig), false));
////////
CVC4_API_TRY_CATCH_END;
CVC4_API_CHECK(Configuration::isBuiltWithSymFPU())
<< "Expected CVC4 to be compiled with SymFPU support";
//////// all checks before this line
- return mkValHelper<CVC4::FloatingPoint>(
+ return mkValHelper<CVC5::FloatingPoint>(
FloatingPoint::makeZero(FloatingPointSize(exp, sig), true));
////////
CVC4_API_TRY_CATCH_END;
CVC4_API_CHECK(Configuration::isBuiltWithSymFPU())
<< "Expected CVC4 to be compiled with SymFPU support";
//////// all checks before this line
- return mkValHelper<CVC4::RoundingMode>(s_rmodes.at(rm));
+ return mkValHelper<CVC5::RoundingMode>(s_rmodes.at(rm));
////////
CVC4_API_TRY_CATCH_END;
}
CVC4_API_TRY_CATCH_BEGIN;
CVC4_API_SOLVER_CHECK_SORT(sort);
//////// all checks before this line
- return mkValHelper<CVC4::UninterpretedConstant>(
- CVC4::UninterpretedConstant(*sort.d_type, index));
+ return mkValHelper<CVC5::UninterpretedConstant>(
+ CVC5::UninterpretedConstant(*sort.d_type, index));
////////
CVC4_API_TRY_CATCH_END;
}
CVC4_API_TRY_CATCH_BEGIN;
CVC4_API_ARG_CHECK_EXPECTED(!index.empty(), index) << "a non-empty string";
- CVC4::Integer idx(index, 10);
+ CVC5::Integer idx(index, 10);
CVC4_API_ARG_CHECK_EXPECTED(idx > 0, index)
<< "a string representing an integer > 0";
//////// all checks before this line
- return Term(this, getNodeManager()->mkConst(CVC4::AbstractValue(idx)));
+ return Term(this, getNodeManager()->mkConst(CVC5::AbstractValue(idx)));
// do not call getType(), for abstract values, type can not be computed
// until it is substituted away
////////
CVC4_API_ARG_CHECK_EXPECTED(index > 0, index) << "an integer > 0";
//////// all checks before this line
return Term(this,
- getNodeManager()->mkConst(CVC4::AbstractValue(Integer(index))));
+ getNodeManager()->mkConst(CVC5::AbstractValue(Integer(index))));
// do not call getType(), for abstract values, type can not be computed
// until it is substituted away
////////
val.getSort().isBitVector() && val.d_node->isConst(), val)
<< "bit-vector constant";
//////// all checks before this line
- return mkValHelper<CVC4::FloatingPoint>(
- CVC4::FloatingPoint(exp, sig, val.d_node->getConst<BitVector>()));
+ return mkValHelper<CVC5::FloatingPoint>(
+ CVC5::FloatingPoint(exp, sig, val.d_node->getConst<BitVector>()));
////////
CVC4_API_TRY_CATCH_END;
}
return mkTermFromKind(op.d_kind);
}
- const CVC4::Kind int_kind = extToIntKind(op.d_kind);
+ const CVC5::Kind int_kind = extToIntKind(op.d_kind);
Term res = Term(this, getNodeManager()->mkNode(int_kind, *op.d_node));
(void)res.d_node->getType(true); /* kick off type checking */
CVC4_API_SOLVER_CHECK_SORTS(sorts);
CVC4_API_SOLVER_CHECK_TERMS(terms);
//////// all checks before this line
- std::vector<CVC4::Node> args;
+ std::vector<CVC5::Node> args;
for (size_t i = 0, size = sorts.size(); i < size; i++)
{
args.push_back(*(ensureTermSort(terms[i], sorts[i])).d_node);
{
res = Op(this,
kind,
- *mkValHelper<CVC4::RecordUpdate>(CVC4::RecordUpdate(arg)).d_node);
+ *mkValHelper<CVC5::RecordUpdate>(CVC5::RecordUpdate(arg)).d_node);
}
else
{
<< "a string representing an integer, real or rational value.";
res = Op(this,
kind,
- *mkValHelper<CVC4::Divisible>(CVC4::Divisible(CVC4::Integer(arg)))
+ *mkValHelper<CVC5::Divisible>(CVC5::Divisible(CVC5::Integer(arg)))
.d_node);
}
return res;
case DIVISIBLE:
res = Op(this,
kind,
- *mkValHelper<CVC4::Divisible>(CVC4::Divisible(arg)).d_node);
+ *mkValHelper<CVC5::Divisible>(CVC5::Divisible(arg)).d_node);
break;
case BITVECTOR_REPEAT:
res = Op(this,
kind,
- *mkValHelper<CVC4::BitVectorRepeat>(CVC4::BitVectorRepeat(arg))
+ *mkValHelper<CVC5::BitVectorRepeat>(CVC5::BitVectorRepeat(arg))
.d_node);
break;
case BITVECTOR_ZERO_EXTEND:
res = Op(this,
kind,
- *mkValHelper<CVC4::BitVectorZeroExtend>(
- CVC4::BitVectorZeroExtend(arg))
+ *mkValHelper<CVC5::BitVectorZeroExtend>(
+ CVC5::BitVectorZeroExtend(arg))
.d_node);
break;
case BITVECTOR_SIGN_EXTEND:
res = Op(this,
kind,
- *mkValHelper<CVC4::BitVectorSignExtend>(
- CVC4::BitVectorSignExtend(arg))
+ *mkValHelper<CVC5::BitVectorSignExtend>(
+ CVC5::BitVectorSignExtend(arg))
.d_node);
break;
case BITVECTOR_ROTATE_LEFT:
res = Op(this,
kind,
- *mkValHelper<CVC4::BitVectorRotateLeft>(
- CVC4::BitVectorRotateLeft(arg))
+ *mkValHelper<CVC5::BitVectorRotateLeft>(
+ CVC5::BitVectorRotateLeft(arg))
.d_node);
break;
case BITVECTOR_ROTATE_RIGHT:
res = Op(this,
kind,
- *mkValHelper<CVC4::BitVectorRotateRight>(
- CVC4::BitVectorRotateRight(arg))
+ *mkValHelper<CVC5::BitVectorRotateRight>(
+ CVC5::BitVectorRotateRight(arg))
.d_node);
break;
case INT_TO_BITVECTOR:
res = Op(
this,
kind,
- *mkValHelper<CVC4::IntToBitVector>(CVC4::IntToBitVector(arg)).d_node);
+ *mkValHelper<CVC5::IntToBitVector>(CVC5::IntToBitVector(arg)).d_node);
break;
case IAND:
res =
- Op(this, kind, *mkValHelper<CVC4::IntAnd>(CVC4::IntAnd(arg)).d_node);
+ Op(this, kind, *mkValHelper<CVC5::IntAnd>(CVC5::IntAnd(arg)).d_node);
break;
case FLOATINGPOINT_TO_UBV:
res = Op(
this,
kind,
- *mkValHelper<CVC4::FloatingPointToUBV>(CVC4::FloatingPointToUBV(arg))
+ *mkValHelper<CVC5::FloatingPointToUBV>(CVC5::FloatingPointToUBV(arg))
.d_node);
break;
case FLOATINGPOINT_TO_SBV:
res = Op(
this,
kind,
- *mkValHelper<CVC4::FloatingPointToSBV>(CVC4::FloatingPointToSBV(arg))
+ *mkValHelper<CVC5::FloatingPointToSBV>(CVC5::FloatingPointToSBV(arg))
.d_node);
break;
case TUPLE_UPDATE:
res = Op(this,
kind,
- *mkValHelper<CVC4::TupleUpdate>(CVC4::TupleUpdate(arg)).d_node);
+ *mkValHelper<CVC5::TupleUpdate>(CVC5::TupleUpdate(arg)).d_node);
break;
case REGEXP_REPEAT:
res =
Op(this,
kind,
- *mkValHelper<CVC4::RegExpRepeat>(CVC4::RegExpRepeat(arg)).d_node);
+ *mkValHelper<CVC5::RegExpRepeat>(CVC5::RegExpRepeat(arg)).d_node);
break;
default:
CVC4_API_KIND_CHECK_EXPECTED(false, kind)
case BITVECTOR_EXTRACT:
res = Op(this,
kind,
- *mkValHelper<CVC4::BitVectorExtract>(
- CVC4::BitVectorExtract(arg1, arg2))
+ *mkValHelper<CVC5::BitVectorExtract>(
+ CVC5::BitVectorExtract(arg1, arg2))
.d_node);
break;
case FLOATINGPOINT_TO_FP_IEEE_BITVECTOR:
res = Op(this,
kind,
- *mkValHelper<CVC4::FloatingPointToFPIEEEBitVector>(
- CVC4::FloatingPointToFPIEEEBitVector(arg1, arg2))
+ *mkValHelper<CVC5::FloatingPointToFPIEEEBitVector>(
+ CVC5::FloatingPointToFPIEEEBitVector(arg1, arg2))
.d_node);
break;
case FLOATINGPOINT_TO_FP_FLOATINGPOINT:
res = Op(this,
kind,
- *mkValHelper<CVC4::FloatingPointToFPFloatingPoint>(
- CVC4::FloatingPointToFPFloatingPoint(arg1, arg2))
+ *mkValHelper<CVC5::FloatingPointToFPFloatingPoint>(
+ CVC5::FloatingPointToFPFloatingPoint(arg1, arg2))
.d_node);
break;
case FLOATINGPOINT_TO_FP_REAL:
res = Op(this,
kind,
- *mkValHelper<CVC4::FloatingPointToFPReal>(
- CVC4::FloatingPointToFPReal(arg1, arg2))
+ *mkValHelper<CVC5::FloatingPointToFPReal>(
+ CVC5::FloatingPointToFPReal(arg1, arg2))
.d_node);
break;
case FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR:
res = Op(this,
kind,
- *mkValHelper<CVC4::FloatingPointToFPSignedBitVector>(
- CVC4::FloatingPointToFPSignedBitVector(arg1, arg2))
+ *mkValHelper<CVC5::FloatingPointToFPSignedBitVector>(
+ CVC5::FloatingPointToFPSignedBitVector(arg1, arg2))
.d_node);
break;
case FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR:
res = Op(this,
kind,
- *mkValHelper<CVC4::FloatingPointToFPUnsignedBitVector>(
- CVC4::FloatingPointToFPUnsignedBitVector(arg1, arg2))
+ *mkValHelper<CVC5::FloatingPointToFPUnsignedBitVector>(
+ CVC5::FloatingPointToFPUnsignedBitVector(arg1, arg2))
.d_node);
break;
case FLOATINGPOINT_TO_FP_GENERIC:
res = Op(this,
kind,
- *mkValHelper<CVC4::FloatingPointToFPGeneric>(
- CVC4::FloatingPointToFPGeneric(arg1, arg2))
+ *mkValHelper<CVC5::FloatingPointToFPGeneric>(
+ CVC5::FloatingPointToFPGeneric(arg1, arg2))
.d_node);
break;
case REGEXP_LOOP:
res = Op(
this,
kind,
- *mkValHelper<CVC4::RegExpLoop>(CVC4::RegExpLoop(arg1, arg2)).d_node);
+ *mkValHelper<CVC5::RegExpLoop>(CVC5::RegExpLoop(arg1, arg2)).d_node);
break;
default:
CVC4_API_KIND_CHECK_EXPECTED(false, kind)
{
res = Op(this,
kind,
- *mkValHelper<CVC4::TupleProjectOp>(CVC4::TupleProjectOp(args))
+ *mkValHelper<CVC5::TupleProjectOp>(CVC5::TupleProjectOp(args))
.d_node);
}
break;
"(try --incremental)";
CVC4_API_SOLVER_CHECK_TERM(term);
//////// all checks before this line
- CVC4::Result r = d_smtEngine->checkEntailed(*term.d_node);
+ CVC5::Result r = d_smtEngine->checkEntailed(*term.d_node);
return Result(r);
////////
CVC4_API_TRY_CATCH_END;
<< "Cannot make multiple queries unless incremental solving is enabled "
"(try --incremental)";
//////// all checks before this line
- CVC4::Result r = d_smtEngine->checkSat();
+ CVC5::Result r = d_smtEngine->checkSat();
return Result(r);
////////
CVC4_API_TRY_CATCH_END;
"(try --incremental)";
CVC4_API_SOLVER_CHECK_TERM_WITH_SORT(assumption, getBooleanSort());
//////// all checks before this line
- CVC4::Result r = d_smtEngine->checkSat(*assumption.d_node);
+ CVC5::Result r = d_smtEngine->checkSat(*assumption.d_node);
return Result(r);
////////
CVC4_API_TRY_CATCH_END;
CVC4_API_SOLVER_CHECK_TERM(term);
}
std::vector<Node> eassumptions = Term::termVectorToNodes(assumptions);
- CVC4::Result r = d_smtEngine->checkSat(eassumptions);
+ CVC5::Result r = d_smtEngine->checkSat(eassumptions);
return Result(r);
////////
CVC4_API_TRY_CATCH_END;
CVC4_API_TRY_CATCH_BEGIN;
CVC4_API_CHECK(!d_smtEngine->isFullyInited())
<< "Invalid call to 'setLogic', solver is already fully initialized";
- CVC4::LogicInfo logic_info(logic);
+ CVC5::LogicInfo logic_info(logic);
//////// all checks before this line
d_smtEngine->setLogic(logic_info);
////////
CVC4_API_TRY_CATCH_BEGIN;
CVC4_API_SOLVER_CHECK_TERM(term);
- std::map<CVC4::Node, CVC4::Node> map;
+ std::map<CVC5::Node, CVC5::Node> map;
CVC4_API_CHECK(d_smtEngine->getSynthSolutions(map))
<< "The solver is not in a state immediately preceded by a "
"successful call to checkSynth";
- std::map<CVC4::Node, CVC4::Node>::const_iterator it = map.find(*term.d_node);
+ std::map<CVC5::Node, CVC5::Node>::const_iterator it = map.find(*term.d_node);
CVC4_API_CHECK(it != map.cend()) << "Synth solution not found for given term";
//////// all checks before this line
CVC4_API_ARG_SIZE_CHECK_EXPECTED(!terms.empty(), terms) << "non-empty vector";
CVC4_API_SOLVER_CHECK_TERMS(terms);
- std::map<CVC4::Node, CVC4::Node> map;
+ std::map<CVC5::Node, CVC5::Node> map;
CVC4_API_CHECK(d_smtEngine->getSynthSolutions(map))
<< "The solver is not in a state immediately preceded by a "
"successful call to checkSynth";
for (size_t i = 0, n = terms.size(); i < n; ++i)
{
- std::map<CVC4::Node, CVC4::Node>::const_iterator it =
+ std::map<CVC5::Node, CVC5::Node>::const_iterator it =
map.find(*terms[i].d_node);
CVC4_API_CHECK(it != map.cend())
} // namespace api
-} // namespace CVC4
+} // namespace CVC5
#include <unordered_set>
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
template <bool ref_count>
class NodeTemplate;
* @param r the internal result that is to be wrapped by this result
* @return the Result
*/
- Result(const CVC4::Result& r);
+ Result(const CVC5::Result& r);
/**
* The interal result wrapped by this result.
- * Note: This is a shared_ptr rather than a unique_ptr since CVC4::Result is
+ * Note: This is a shared_ptr rather than a unique_ptr since CVC5::Result is
* not ref counted.
*/
- std::shared_ptr<CVC4::Result> d_result;
+ std::shared_ptr<CVC5::Result> d_result;
};
/**
*/
class CVC4_EXPORT Sort
{
- friend class CVC4::DatatypeDeclarationCommand;
- friend class CVC4::DeclareFunctionCommand;
- friend class CVC4::DeclareHeapCommand;
- friend class CVC4::DeclareSortCommand;
- friend class CVC4::DeclareSygusVarCommand;
- friend class CVC4::DefineSortCommand;
- friend class CVC4::GetAbductCommand;
- friend class CVC4::GetInterpolCommand;
- friend class CVC4::GetModelCommand;
- friend class CVC4::SynthFunCommand;
+ friend class CVC5::DatatypeDeclarationCommand;
+ friend class CVC5::DeclareFunctionCommand;
+ friend class CVC5::DeclareHeapCommand;
+ friend class CVC5::DeclareSortCommand;
+ friend class CVC5::DeclareSygusVarCommand;
+ friend class CVC5::DefineSortCommand;
+ friend class CVC5::GetAbductCommand;
+ friend class CVC5::GetInterpolCommand;
+ friend class CVC5::GetModelCommand;
+ friend class CVC5::SynthFunCommand;
friend class DatatypeConstructor;
friend class DatatypeConstructorDecl;
friend class DatatypeSelector;
private:
/** @return the internal wrapped TypeNode of this sort. */
- const CVC4::TypeNode& getTypeNode(void) const;
+ const CVC5::TypeNode& getTypeNode(void) const;
/** Helper to convert a set of Sorts to internal TypeNodes. */
std::set<TypeNode> static sortSetToTypeNodes(const std::set<Sort>& sorts);
* @param t the internal type that is to be wrapped by this sort
* @return the Sort
*/
- Sort(const Solver* slv, const CVC4::TypeNode& t);
+ Sort(const Solver* slv, const CVC5::TypeNode& t);
/**
* Helper for isNull checks. This prevents calling an API function with
/**
* The interal type wrapped by this sort.
* Note: This is a shared_ptr rather than a unique_ptr to avoid overhead due
- * to memory allocation (CVC4::Type is already ref counted, so this
+ * to memory allocation (CVC5::Type is already ref counted, so this
* could be a unique_ptr instead).
*/
- std::shared_ptr<CVC4::TypeNode> d_type;
+ std::shared_ptr<CVC5::TypeNode> d_type;
};
/**
* @param n the internal node that is to be wrapped by this term
* @return the Term
*/
- Op(const Solver* slv, const Kind k, const CVC4::Node& n);
+ Op(const Solver* slv, const Kind k, const CVC5::Node& n);
/**
* Helper for isNull checks. This prevents calling an API function with
/**
* The internal node wrapped by this operator.
* Note: This is a shared_ptr rather than a unique_ptr to avoid overhead due
- * to memory allocation (CVC4::Node is already ref counted, so this
+ * to memory allocation (CVC5::Node is already ref counted, so this
* could be a unique_ptr instead).
*/
- std::shared_ptr<CVC4::Node> d_node;
+ std::shared_ptr<CVC5::Node> d_node;
};
/* -------------------------------------------------------------------------- */
*/
class CVC4_EXPORT Term
{
- friend class CVC4::AssertCommand;
- friend class CVC4::BlockModelValuesCommand;
- friend class CVC4::CheckSatCommand;
- friend class CVC4::CheckSatAssumingCommand;
- friend class CVC4::DeclareSygusVarCommand;
- friend class CVC4::DefineFunctionCommand;
- friend class CVC4::DefineFunctionRecCommand;
- friend class CVC4::GetAbductCommand;
- friend class CVC4::GetInterpolCommand;
- friend class CVC4::GetModelCommand;
- friend class CVC4::GetQuantifierEliminationCommand;
- friend class CVC4::GetUnsatCoreCommand;
- friend class CVC4::GetValueCommand;
- friend class CVC4::SetUserAttributeCommand;
- friend class CVC4::SimplifyCommand;
- friend class CVC4::SygusConstraintCommand;
- friend class CVC4::SygusInvConstraintCommand;
- friend class CVC4::SynthFunCommand;
- friend class CVC4::QueryCommand;
+ friend class CVC5::AssertCommand;
+ friend class CVC5::BlockModelValuesCommand;
+ friend class CVC5::CheckSatCommand;
+ friend class CVC5::CheckSatAssumingCommand;
+ friend class CVC5::DeclareSygusVarCommand;
+ friend class CVC5::DefineFunctionCommand;
+ friend class CVC5::DefineFunctionRecCommand;
+ friend class CVC5::GetAbductCommand;
+ friend class CVC5::GetInterpolCommand;
+ friend class CVC5::GetModelCommand;
+ friend class CVC5::GetQuantifierEliminationCommand;
+ friend class CVC5::GetUnsatCoreCommand;
+ friend class CVC5::GetValueCommand;
+ friend class CVC5::SetUserAttributeCommand;
+ friend class CVC5::SimplifyCommand;
+ friend class CVC5::SygusConstraintCommand;
+ friend class CVC5::SygusInvConstraintCommand;
+ friend class CVC5::SynthFunCommand;
+ friend class CVC5::QueryCommand;
friend class Datatype;
friend class DatatypeConstructor;
friend class DatatypeSelector;
* @param p the position of the iterator (e.g. which child it's on)
*/
const_iterator(const Solver* slv,
- const std::shared_ptr<CVC4::Node>& e,
+ const std::shared_ptr<CVC5::Node>& e,
uint32_t p);
/**
*/
const Solver* d_solver;
/** The original node to be iterated over. */
- std::shared_ptr<CVC4::Node> d_origNode;
+ std::shared_ptr<CVC5::Node> d_origNode;
/** Keeps track of the iteration position. */
uint32_t d_pos;
};
* @param n the internal node that is to be wrapped by this term
* @return the Term
*/
- Term(const Solver* slv, const CVC4::Node& n);
+ Term(const Solver* slv, const CVC5::Node& n);
/** @return the internal wrapped Node of this term. */
- const CVC4::Node& getNode(void) const;
+ const CVC5::Node& getNode(void) const;
/**
* Helper for isNull checks. This prevents calling an API function with
/**
* The internal node wrapped by this term.
* Note: This is a shared_ptr rather than a unique_ptr to avoid overhead due
- * to memory allocation (CVC4::Node is already ref counted, so this
+ * to memory allocation (CVC5::Node is already ref counted, so this
* could be a unique_ptr instead).
*/
- std::shared_ptr<CVC4::Node> d_node;
+ std::shared_ptr<CVC5::Node> d_node;
};
/**
* The internal (intermediate) datatype constructor wrapped by this
* datatype constructor declaration.
* Note: This is a shared_ptr rather than a unique_ptr since
- * CVC4::DTypeConstructor is not ref counted.
+ * CVC5::DTypeConstructor is not ref counted.
*/
- std::shared_ptr<CVC4::DTypeConstructor> d_ctor;
+ std::shared_ptr<CVC5::DTypeConstructor> d_ctor;
};
class Solver;
bool isCoDatatype = false);
/** @return the internal wrapped Dtype of this datatype declaration. */
- CVC4::DType& getDatatype(void) const;
+ CVC5::DType& getDatatype(void) const;
/**
* Helper for isNull checks. This prevents calling an API function with
/**
* The internal (intermediate) datatype wrapped by this datatype
* declaration.
- * Note: This is a shared_ptr rather than a unique_ptr since CVC4::DType is
+ * Note: This is a shared_ptr rather than a unique_ptr since CVC5::DType is
* not ref counted.
*/
- std::shared_ptr<CVC4::DType> d_dtype;
+ std::shared_ptr<CVC5::DType> d_dtype;
};
/**
* @param stor the internal datatype selector to be wrapped
* @return the DatatypeSelector
*/
- DatatypeSelector(const Solver* slv, const CVC4::DTypeSelector& stor);
+ DatatypeSelector(const Solver* slv, const CVC5::DTypeSelector& stor);
/**
* Helper for isNull checks. This prevents calling an API function with
/**
* The internal datatype selector wrapped by this datatype selector.
- * Note: This is a shared_ptr rather than a unique_ptr since CVC4::DType is
+ * Note: This is a shared_ptr rather than a unique_ptr since CVC5::DType is
* not ref counted.
*/
- std::shared_ptr<CVC4::DTypeSelector> d_stor;
+ std::shared_ptr<CVC5::DTypeSelector> d_stor;
};
/**
* @param true if this is a begin() iterator
*/
const_iterator(const Solver* slv,
- const CVC4::DTypeConstructor& ctor,
+ const CVC5::DTypeConstructor& ctor,
bool begin);
/**
* @param ctor the internal datatype constructor to be wrapped
* @return the DatatypeConstructor
*/
- DatatypeConstructor(const Solver* slv, const CVC4::DTypeConstructor& ctor);
+ DatatypeConstructor(const Solver* slv, const CVC5::DTypeConstructor& ctor);
/**
* Return selector for name.
/**
* The internal datatype constructor wrapped by this datatype constructor.
- * Note: This is a shared_ptr rather than a unique_ptr since CVC4::DType is
+ * Note: This is a shared_ptr rather than a unique_ptr since CVC5::DType is
* not ref counted.
*/
- std::shared_ptr<CVC4::DTypeConstructor> d_ctor;
+ std::shared_ptr<CVC5::DTypeConstructor> d_ctor;
};
/*
* @param dtype the internal datatype to iterate over
* @param true if this is a begin() iterator
*/
- const_iterator(const Solver* slv, const CVC4::DType& dtype, bool begin);
+ const_iterator(const Solver* slv, const CVC5::DType& dtype, bool begin);
/**
* The associated solver object.
* @param dtype the internal datatype to be wrapped
* @return the Datatype
*/
- Datatype(const Solver* slv, const CVC4::DType& dtype);
+ Datatype(const Solver* slv, const CVC5::DType& dtype);
/**
* Return constructor for name.
/**
* The internal datatype wrapped by this datatype.
- * Note: This is a shared_ptr rather than a unique_ptr since CVC4::DType is
+ * Note: This is a shared_ptr rather than a unique_ptr since CVC5::DType is
* not ref counted.
*/
- std::shared_ptr<CVC4::DType> d_dtype;
+ std::shared_ptr<CVC5::DType> d_dtype;
};
/**
*/
class CVC4_EXPORT Grammar
{
- friend class CVC4::GetAbductCommand;
- friend class CVC4::GetInterpolCommand;
- friend class CVC4::SynthFunCommand;
+ friend class CVC5::GetAbductCommand;
+ friend class CVC5::GetInterpolCommand;
+ friend class CVC5::SynthFunCommand;
friend class Solver;
public:
};
} // namespace api
-} // namespace CVC4
+} // namespace CVC5
#endif
#include <ostream>
-namespace CVC4 {
+namespace CVC5 {
namespace api {
/* -------------------------------------------------------------------------- */
*
* Note that the underlying type of Kind must be signed (to enable range
* checks for validity). The size of this type depends on the size of
- * CVC4::Kind (NodeValue::NBITS_KIND, currently 10 bits, see expr/node_value.h).
+ * CVC5::Kind (NodeValue::NBITS_KIND, currently 10 bits, see expr/node_value.h).
*/
enum CVC4_EXPORT Kind : int32_t
{
};
} // namespace api
-} // namespace CVC4
+} // namespace CVC5
#endif
pass
-cdef extern from "api/cvc4cpp.h" namespace "CVC4::api":
+cdef extern from "api/cvc4cpp.h" namespace "CVC5::api":
cdef cppclass Datatype:
Datatype() except +
DatatypeConstructor operator[](size_t idx) except +
size_t operator()(const Term & t) except +
-cdef extern from "api/cvc4cpp.h" namespace "CVC4::api::RoundingMode":
+cdef extern from "api/cvc4cpp.h" namespace "CVC5::api::RoundingMode":
cdef RoundingMode ROUND_NEAREST_TIES_TO_EVEN,
cdef RoundingMode ROUND_TOWARD_POSITIVE,
cdef RoundingMode ROUND_TOWARD_NEGATIVE,
CDEF_KIND = " cdef Kind "
KINDS_PXD_TOP = \
-r"""cdef extern from "api/cvc4cppkind.h" namespace "CVC4::api":
+r"""cdef extern from "api/cvc4cppkind.h" namespace "CVC5::api":
cdef cppclass Kind:
pass
# Kind declarations: See cvc4cppkind.h for additional information
-cdef extern from "api/cvc4cppkind.h" namespace "CVC4::api::Kind":
+cdef extern from "api/cvc4cppkind.h" namespace "CVC5::api::Kind":
"""
KINDS_PXI_TOP = \
#include <cstdlib>
#include <iostream>
-namespace CVC4 {
+namespace CVC5 {
FatalStream::FatalStream(const char* function, const char* file, int line)
{
line);
}
-} // namespace CVC4
+} // namespace CVC5
#define CVC4_FALLTHROUGH
#endif
-namespace CVC4 {
+namespace CVC5 {
// Implementation notes:
// To understand FatalStream and OStreamVoider, it is useful to understand
#define InternalError() CVC4_FATAL() << "Internal error detected"
#define IllegalArgument(arg, msg...) \
- throw ::CVC4::IllegalArgumentException( \
+ throw ::CVC5::IllegalArgumentException( \
"", \
#arg, \
__PRETTY_FUNCTION__, \
- ::CVC4::IllegalArgumentException::formatVariadic(msg).c_str());
+ ::CVC5::IllegalArgumentException::formatVariadic(msg).c_str());
// This cannot use check argument directly as this forces
// CheckArgument to use a va_list. This is unsupported in Swig.
#define PrettyCheckArgument(cond, arg, msg...) \
{ \
if (__builtin_expect((!(cond)), false)) \
{ \
- throw ::CVC4::IllegalArgumentException( \
+ throw ::CVC5::IllegalArgumentException( \
#cond, \
#arg, \
__PRETTY_FUNCTION__, \
- ::CVC4::IllegalArgumentException::formatVariadic(msg).c_str()); \
+ ::CVC5::IllegalArgumentException::formatVariadic(msg).c_str()); \
} \
} while (0)
#define AlwaysAssertArgument(cond, arg, msg...) \
{ \
if (__builtin_expect((!(cond)), false)) \
{ \
- throw ::CVC4::AssertArgumentException( \
+ throw ::CVC5::AssertArgumentException( \
#cond, #arg, __PRETTY_FUNCTION__, __FILE__, __LINE__, ##msg); \
} \
} while (0)
cond, arg, msg...) /*__builtin_expect( ( cond ), true )*/
#endif /* CVC4_ASSERTIONS */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__CHECK_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
string Configuration::getName() {
return CVC4_PACKAGE_NAME;
stringstream ss;
ss << "git " << branchName << " " << string(getGitCommit()).substr(0, 8)
- << ( ::CVC4::Configuration::hasGitModifications() ? " (with modifications)" : "" );
+ << (::CVC5::Configuration::hasGitModifications() ? " (with modifications)"
+ : "");
return ss.str();
}
return __DATE__ " " __TIME__;
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "cvc4_export.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* Represents the (static) configuration of CVC4.
}; /* class Configuration */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__CONFIGURATION_H */
#include "base/configuration.h"
-namespace CVC4 {
+namespace CVC5 {
#ifdef CVC4_DEBUG
# define IS_DEBUG_BUILD true
#endif /* __has_feature(thread_sanitizer) */
#endif /* defined(__has_feature) */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__CONFIGURATION_PRIVATE_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
std::string Exception::toString() const
{
delete [] buf;
}
-} /* namespace CVC4 */
+} // namespace CVC5
#include "cvc4_export.h"
-namespace CVC4 {
+namespace CVC5 {
class Exception : public std::exception
{
inline void CheckArgument(bool cond, const T& arg, const char* tail);
template <class T> inline void CheckArgument(bool cond, const T& arg CVC4_UNUSED,
const char* tail CVC4_UNUSED) {
- if(__builtin_expect( ( !cond ), false )) { \
- throw ::CVC4::IllegalArgumentException("", "", tail); \
+ if(__builtin_expect( ( !cond ), false )) {
+ throw ::CVC5::IllegalArgumentException("", "", tail);
} \
}
template <class T>
inline void CheckArgument(bool cond, const T& arg);
template <class T> inline void CheckArgument(bool cond, const T& arg CVC4_UNUSED) {
- if(__builtin_expect( ( !cond ), false )) { \
- throw ::CVC4::IllegalArgumentException("", "", ""); \
+ if(__builtin_expect( ( !cond ), false )) {
+ throw ::CVC5::IllegalArgumentException("", "", "");
} \
}
static thread_local LastExceptionBuffer* s_currentBuffer;
}; /* class LastExceptionBuffer */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__EXCEPTION_H */
**/
#include "base/configuration.h"
-const bool ::CVC4::Configuration::IS_GIT_BUILD = @GIT_BUILD@;
-const char* const ::CVC4::Configuration::GIT_BRANCH_NAME = "@GIT_BRANCH@";
-const char* const ::CVC4::Configuration::GIT_COMMIT = "@GIT_SHA1@";
-const bool ::CVC4::Configuration::GIT_HAS_MODIFICATIONS = @GIT_IS_DIRTY@;
+const bool ::CVC5::Configuration::IS_GIT_BUILD = @GIT_BUILD@;
+const char* const ::CVC5::Configuration::GIT_BRANCH_NAME = "@GIT_BRANCH@";
+const char* const ::CVC5::Configuration::GIT_COMMIT = "@GIT_SHA1@";
+const bool ::CVC5::Configuration::GIT_HAS_MODIFICATIONS = @GIT_IS_DIRTY@;
#include "base/listener.h"
-namespace CVC4 {
+namespace CVC5 {
Listener::Listener(){}
Listener::~Listener(){}
-
-}/* CVC4 namespace */
+} // namespace CVC5
#ifndef CVC4__LISTENER_H
#define CVC4__LISTENER_H
-namespace CVC4 {
+namespace CVC5 {
/**
* Listener interface class.
virtual void notify() = 0;
};
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__LISTENER_H */
** new code. Supports:
** - std::map
** - std::unordered_map
- ** - CVC4::context::CDHashmap
- ** - CVC4::context::CDInsertHashmap
+ ** - CVC5::context::CDHashmap
+ ** - CVC5::context::CDInsertHashmap
** The ContainsKey function is also compatible with std::[unordered_]set.
**
** Currently implemented classes of functions:
#include "base/check.h"
-namespace CVC4 {
+namespace CVC5 {
// Returns true if the `map` contains the `key`.
//
return (*it).second;
}
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__BASE__MAP_UTIL_H */
#include "base/exception.h"
-namespace CVC4 {
+namespace CVC5 {
-class ModalException : public CVC4::Exception
+class ModalException : public CVC5::Exception
{
public:
ModalException() :
* TODO(#1108): This exception should not be needed anymore in future versions
* of the public API.
*/
-class RecoverableModalException : public CVC4::ModalException
+class RecoverableModalException : public CVC5::ModalException
{
public:
RecoverableModalException(const std::string& msg) : ModalException(msg) {}
RecoverableModalException(const char* msg) : ModalException(msg) {}
}; /* class RecoverableModalException */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__SMT__MODAL_EXCEPTION_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
/* Definitions of the declared globals from output.h... */
std::ostream DumpOutC::dump_cout(cout.rdbuf());// copy cout stream buffer
DumpOutC DumpOutChannel(&DumpOutC::dump_cout);
-}/* CVC4 namespace */
+} // namespace CVC5
#include "cvc4_export.h"
-namespace CVC4 {
+namespace CVC5 {
template <class T, class U>
std::ostream& operator<<(std::ostream& out,
#ifdef CVC4_MUZZLE
-# define Debug ::CVC4::__cvc4_true() ? ::CVC4::nullCvc4Stream : ::CVC4::DebugChannel
-# define Warning ::CVC4::__cvc4_true() ? ::CVC4::nullCvc4Stream : ::CVC4::WarningChannel
-# define WarningOnce ::CVC4::__cvc4_true() ? ::CVC4::nullCvc4Stream : ::CVC4::WarningChannel
+#define Debug \
+ ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::DebugChannel
+#define Warning \
+ ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::WarningChannel
+#define WarningOnce \
+ ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::WarningChannel
#define CVC4Message \
- ::CVC4::__cvc4_true() ? ::CVC4::nullCvc4Stream : ::CVC4::MessageChannel
-# define Notice ::CVC4::__cvc4_true() ? ::CVC4::nullCvc4Stream : ::CVC4::NoticeChannel
-# define Chat ::CVC4::__cvc4_true() ? ::CVC4::nullCvc4Stream : ::CVC4::ChatChannel
-# define Trace ::CVC4::__cvc4_true() ? ::CVC4::nullCvc4Stream : ::CVC4::TraceChannel
-# define DumpOut ::CVC4::__cvc4_true() ? ::CVC4::nullCvc4Stream : ::CVC4::DumpOutChannel
+ ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::MessageChannel
+#define Notice \
+ ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::NoticeChannel
+#define Chat \
+ ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::ChatChannel
+#define Trace \
+ ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::TraceChannel
+#define DumpOut \
+ ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::DumpOutChannel
#else /* CVC4_MUZZLE */
# if defined(CVC4_DEBUG) && defined(CVC4_TRACING)
-# define Debug ::CVC4::DebugChannel
+#define Debug ::CVC5::DebugChannel
# else /* CVC4_DEBUG && CVC4_TRACING */
-# define Debug ::CVC4::__cvc4_true() ? ::CVC4::nullCvc4Stream : ::CVC4::DebugChannel
+#define Debug \
+ ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::DebugChannel
# endif /* CVC4_DEBUG && CVC4_TRACING */
-# define Warning (! ::CVC4::WarningChannel.isOn()) ? ::CVC4::nullCvc4Stream : ::CVC4::WarningChannel
-# define WarningOnce (! ::CVC4::WarningChannel.isOn() || ! ::CVC4::WarningChannel.warnOnce(__FILE__,__LINE__)) ? ::CVC4::nullCvc4Stream : ::CVC4::WarningChannel
+#define Warning \
+ (!::CVC5::WarningChannel.isOn()) ? ::CVC5::nullCvc4Stream \
+ : ::CVC5::WarningChannel
+#define WarningOnce \
+ (!::CVC5::WarningChannel.isOn() \
+ || !::CVC5::WarningChannel.warnOnce(__FILE__, __LINE__)) \
+ ? ::CVC5::nullCvc4Stream \
+ : ::CVC5::WarningChannel
#define CVC4Message \
- (!::CVC4::MessageChannel.isOn()) ? ::CVC4::nullCvc4Stream \
- : ::CVC4::MessageChannel
-# define Notice (! ::CVC4::NoticeChannel.isOn()) ? ::CVC4::nullCvc4Stream : ::CVC4::NoticeChannel
-# define Chat (! ::CVC4::ChatChannel.isOn()) ? ::CVC4::nullCvc4Stream : ::CVC4::ChatChannel
+ (!::CVC5::MessageChannel.isOn()) ? ::CVC5::nullCvc4Stream \
+ : ::CVC5::MessageChannel
+#define Notice \
+ (!::CVC5::NoticeChannel.isOn()) ? ::CVC5::nullCvc4Stream \
+ : ::CVC5::NoticeChannel
+#define Chat \
+ (!::CVC5::ChatChannel.isOn()) ? ::CVC5::nullCvc4Stream : ::CVC5::ChatChannel
# ifdef CVC4_TRACING
-# define Trace ::CVC4::TraceChannel
+#define Trace ::CVC5::TraceChannel
# else /* CVC4_TRACING */
-# define Trace ::CVC4::__cvc4_true() ? ::CVC4::nullCvc4Stream : ::CVC4::TraceChannel
+#define Trace \
+ ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::TraceChannel
# endif /* CVC4_TRACING */
# ifdef CVC4_DUMPING
-# define DumpOut ::CVC4::DumpOutChannel
+#define DumpOut ::CVC5::DumpOutChannel
# else /* CVC4_DUMPING */
-# define DumpOut ::CVC4::__cvc4_true() ? ::CVC4::nullCvc4Stream : ::CVC4::DumpOutChannel
+#define DumpOut \
+ ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::DumpOutChannel
# endif /* CVC4_DUMPING */
#endif /* CVC4_MUZZLE */
inline IndentedScope::~IndentedScope() {}
#endif /* CVC4_DEBUG && CVC4_TRACING */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__OUTPUT_H */
#include <vector>
#include "context/cdo.h"
-namespace CVC4 {
+namespace CVC5 {
template <class T> class List;
template <class T> class List_iterator;
Assert(curr_level == pop_level);
}
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__UTIL__BACKTRACKABLE_H */
#include "util/index.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
template <class CleanUp = DefaultCleanUp<Index> >
};/* class CDDenseSet<> */
-
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#include "context/cdhashmap_forward.h"
#include "context/context.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
// Auxiliary class: almost the same as CDO (see cdo.h)
};/* class CDHashMap<> */
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#endif /* CVC4__CONTEXT__CDHASHMAP_H */
/// \cond internals
-
-namespace CVC4 {
- namespace context {
- template <class Key, class Data, class HashFcn = std::hash<Key> >
- class CDHashMap;
- }/* CVC4::context namespace */
-}/* CVC4 namespace */
+namespace CVC5 {
+namespace context {
+template <class Key, class Data, class HashFcn = std::hash<Key> >
+class CDHashMap;
+} // namespace context
+} // namespace CVC5
/// \endcond
#include "context/cdinsert_hashmap.h"
#include "context/context.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
template <class V, class HashFcn>
};/* class CDHashSet */
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#endif /* CVC4__CONTEXT__CDHASHSET_H */
#include <functional>
-namespace CVC4 {
+namespace CVC5 {
namespace context {
template <class V, class HashFcn = std::hash<V> >
class CDHashSet;
} // namespace context
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__CONTEXT__CDSET_FORWARD_H */
#pragma once
-namespace CVC4 {
+namespace CVC5 {
namespace context {
"Cannot create a CDInsertHashMap with TNode keys");
};
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#include <functional>
-namespace CVC4 {
+namespace CVC5 {
namespace context {
template <class Key, class Data, class HashFcn = std::hash<Key> >
class CDInsertHashMap;
} // namespace context
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__CONTEXT__CDINSERT_HASHMAP_FORWARD_H */
#include "context/context.h"
#include "context/context_mm.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
/**
"Cannot create a CDList with a ContextMemoryAllocator.");
};
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#endif /* CVC4__CONTEXT__CDLIST_H */
/// \cond internals
-namespace CVC4 {
+namespace CVC5 {
namespace context {
template <class T>
/// \endcond
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#endif /* CVC4__CONTEXT__CDLIST_FORWARD_H */
#include "context/cdo.h"
#include "context/context.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
class CDRaised {
}
};/* class CDMaybe<T> */
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
-
+} // namespace context
+} // namespace CVC5
#include "context/context.h"
-
-namespace CVC4 {
+namespace CVC5 {
namespace context {
/**
};/* class CDO */
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#endif /* CVC4__CONTEXT__CDO_H */
#include "context/context.h"
#include "context/cdlist.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
template <class T, class CleanUp = DefaultCleanUp<T>, class Allocator = std::allocator<T> >
};/* class CDQueue<> */
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#endif /* CVC4__CONTEXT__CDQUEUE_H */
#include "context/cdlist.h"
#include "context/cdo.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
class Context;
};/* class CDTrailQueue<> */
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#endif /* CVC4__CONTEXT__CDTRAIL_QUEUE_H */
#include "base/check.h"
#include "context/context.h"
-
-namespace CVC4 {
+namespace CVC5 {
namespace context {
d_garbage->push_back(obj);
}
-} /* CVC4::context namespace */
-} /* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#include "base/output.h"
#include "context/context_mm.h"
-
-namespace CVC4 {
+namespace CVC5 {
namespace context {
class Context;
d_pContextObjList = pContextObj;
}
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#endif /* CVC4__CONTEXT__CONTEXT_H */
#include "base/output.h"
#include "context/context_mm.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
#ifndef CVC4_DEBUG_CONTEXT_MEMORY_MANAGER
#endif /* CVC4_DEBUG_CONTEXT_MEMORY_MANAGER */
-} /* CVC4::context namespace */
-} /* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#endif
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
namespace context {
#ifndef CVC4_DEBUG_CONTEXT_MEMORY_MANAGER
return a1.d_mm != a2.d_mm;
}
-}/* CVC4::context namespace */
-}/* CVC4 namespace */
+} // namespace context
+} // namespace CVC5
#endif /* CVC4__CONTEXT__CONTEXT_MM_H */
#include "options/decision_weight.h"
#include "expr/attribute.h"
-namespace CVC4 {
+namespace CVC5 {
namespace decision {
namespace attr {
struct DecisionWeightTag {};
-}/* CVC4::decision::attr namespace */
+ } // namespace attr
typedef expr::Attribute<attr::DecisionWeightTag, DecisionWeight> DecisionWeightAttr;
-}/* CVC4::decision namespace */
-}/* CVC4 namespace */
+} // namespace decision
+} // namespace CVC5
#endif /* CVC4__DECISION__DECISION_ATTRIBUTES_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
DecisionEngine::DecisionEngine(context::Context* sc,
context::UserContext* uc,
}
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "prop/sat_solver_types.h"
#include "util/result.h"
-using namespace CVC4::prop;
-using namespace CVC4::decision;
+using namespace CVC5::prop;
+using namespace CVC5::decision;
-namespace CVC4 {
+namespace CVC5 {
class DecisionEngine {
std::unique_ptr<ITEDecisionStrategy> d_enabledITEStrategy;
};/* DecisionEngine class */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__DECISION__DECISION_ENGINE_H */
#include "prop/sat_solver_types.h"
#include "smt/term_formula_removal.h"
-namespace CVC4 {
+namespace CVC5 {
class DecisionEngine;
namespace context {
class Context;
-}/* CVC4::context namespace */
+ } // namespace context
namespace decision {
virtual void addSkolemDefinition(TNode lem, TNode skolem) = 0;
};/* class ITEDecisionStrategy */
-}/* CVC4::decision namespace */
-}/* CVC4 namespace */
+} // namespace decision
+} // namespace CVC5
#endif /* CVC4__DECISION__DECISION_STRATEGY_H */
#include "theory/rewriter.h"
#include "util/random.h"
-namespace CVC4 {
+namespace CVC5 {
namespace decision {
-JustificationHeuristic::JustificationHeuristic(CVC4::DecisionEngine* de,
+JustificationHeuristic::JustificationHeuristic(CVC5::DecisionEngine* de,
context::UserContext* uc,
context::Context* c)
: ITEDecisionStrategy(de, c),
smtStatisticsRegistry()->unregisterStat(&d_timestat);
}
-CVC4::prop::SatLiteral JustificationHeuristic::getNext(bool &stopSearch)
+CVC5::prop::SatLiteral JustificationHeuristic::getNext(bool& stopSearch)
{
if(options::decisionThreshold() > 0) {
bool stopSearchTmp = false;
return getNextThresh(stopSearch, 0);
}
-CVC4::prop::SatLiteral JustificationHeuristic::getNextThresh(bool &stopSearch, DecisionWeight threshold) {
+CVC5::prop::SatLiteral JustificationHeuristic::getNextThresh(
+ bool& stopSearch, DecisionWeight threshold)
+{
Trace("decision") << "JustificationHeuristic::getNextThresh(stopSearch, "<<threshold<<")" << std::endl;
TimerStat::CodeTimer codeTimer(d_timestat);
}
} /* namespace decision */
-} /* namespace CVC4 */
\ No newline at end of file
+} // namespace CVC5
\ No newline at end of file
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace decision {
class JustificationHeuristic : public ITEDecisionStrategy {
};
public:
- JustificationHeuristic(CVC4::DecisionEngine* de,
- context::UserContext *uc,
- context::Context *c);
-
- ~JustificationHeuristic();
-
- prop::SatLiteral getNext(bool &stopSearch) override;
-
- /**
- * Notify this class that assertion is an (input) assertion, not corresponding
- * to a skolem definition.
- */
- void addAssertion(TNode assertion) override;
- /**
- * Notify this class that lem is the skolem definition for skolem, which is
- * a part of the current assertions.
- */
- void addSkolemDefinition(TNode lem, TNode skolem) override;
-
- private:
- /* getNext with an option to specify threshold */
- prop::SatLiteral getNextThresh(bool &stopSearch, DecisionWeight threshold);
-
- prop::SatLiteral findSplitter(TNode node, prop::SatValue desiredVal);
-
- /**
- * Do all the hard work.
- */
- SearchResult findSplitterRec(TNode node, prop::SatValue value);
-
- /* Helper functions */
- void setJustified(TNode);
- bool checkJustified(TNode);
- DecisionWeight getExploredThreshold(TNode);
- void setExploredThreshold(TNode);
- void setPrvsIndex(int);
- int getPrvsIndex();
- DecisionWeight getWeightPolarized(TNode n, bool polarity);
- DecisionWeight getWeightPolarized(TNode n, prop::SatValue);
- static DecisionWeight getWeight(TNode);
- bool compareByWeightFalse(TNode, TNode);
- bool compareByWeightTrue(TNode, TNode);
- TNode getChildByWeight(TNode n, int i, bool polarity);
-
- /* If literal exists corresponding to the node return
- that. Otherwise an UNKNOWN */
- prop::SatValue tryGetSatValue(Node n);
-
- /* Get list of all term-ITEs for the atomic formula v */
- JustificationHeuristic::SkolemList getSkolems(TNode n);
-
- /**
- * For big and/or nodes, a cache to save starting index into children
- * for efficiently.
- */
- typedef context::CDHashMap<Node, int, NodeHashFunction> StartIndexCache;
- StartIndexCache d_startIndexCache;
- int getStartIndex(TNode node);
- void saveStartIndex(TNode node, int val);
-
- /* Compute all term-removal skolems in a node recursively */
- void computeSkolems(TNode n, SkolemList& l);
-
- SearchResult handleAndOrEasy(TNode node, prop::SatValue desiredVal);
- SearchResult handleAndOrHard(TNode node, prop::SatValue desiredVal);
- SearchResult handleBinaryEasy(TNode node1,
- prop::SatValue desiredVal1,
- TNode node2,
- prop::SatValue desiredVal2);
- SearchResult handleBinaryHard(TNode node1,
- prop::SatValue desiredVal1,
- TNode node2,
- prop::SatValue desiredVal2);
- SearchResult handleITE(TNode node, prop::SatValue desiredVal);
- SearchResult handleEmbeddedSkolems(TNode node);
+ JustificationHeuristic(CVC5::DecisionEngine* de,
+ context::UserContext* uc,
+ context::Context* c);
+
+ ~JustificationHeuristic();
+
+ prop::SatLiteral getNext(bool& stopSearch) override;
+
+ /**
+ * Notify this class that assertion is an (input) assertion, not corresponding
+ * to a skolem definition.
+ */
+ void addAssertion(TNode assertion) override;
+ /**
+ * Notify this class that lem is the skolem definition for skolem, which is
+ * a part of the current assertions.
+ */
+ void addSkolemDefinition(TNode lem, TNode skolem) override;
+
+private:
+ /* getNext with an option to specify threshold */
+ prop::SatLiteral getNextThresh(bool& stopSearch, DecisionWeight threshold);
+
+ prop::SatLiteral findSplitter(TNode node, prop::SatValue desiredVal);
+
+ /**
+ * Do all the hard work.
+ */
+ SearchResult findSplitterRec(TNode node, prop::SatValue value);
+
+ /* Helper functions */
+ void setJustified(TNode);
+ bool checkJustified(TNode);
+ DecisionWeight getExploredThreshold(TNode);
+ void setExploredThreshold(TNode);
+ void setPrvsIndex(int);
+ int getPrvsIndex();
+ DecisionWeight getWeightPolarized(TNode n, bool polarity);
+ DecisionWeight getWeightPolarized(TNode n, prop::SatValue);
+ static DecisionWeight getWeight(TNode);
+ bool compareByWeightFalse(TNode, TNode);
+ bool compareByWeightTrue(TNode, TNode);
+ TNode getChildByWeight(TNode n, int i, bool polarity);
+
+ /* If literal exists corresponding to the node return
+ that. Otherwise an UNKNOWN */
+ prop::SatValue tryGetSatValue(Node n);
+
+ /* Get list of all term-ITEs for the atomic formula v */
+ JustificationHeuristic::SkolemList getSkolems(TNode n);
+
+ /**
+ * For big and/or nodes, a cache to save starting index into children
+ * for efficiently.
+ */
+ typedef context::CDHashMap<Node, int, NodeHashFunction> StartIndexCache;
+ StartIndexCache d_startIndexCache;
+ int getStartIndex(TNode node);
+ void saveStartIndex(TNode node, int val);
+
+ /* Compute all term-removal skolems in a node recursively */
+ void computeSkolems(TNode n, SkolemList& l);
+
+ SearchResult handleAndOrEasy(TNode node, prop::SatValue desiredVal);
+ SearchResult handleAndOrHard(TNode node, prop::SatValue desiredVal);
+ SearchResult handleBinaryEasy(TNode node1,
+ prop::SatValue desiredVal1,
+ TNode node2,
+ prop::SatValue desiredVal2);
+ SearchResult handleBinaryHard(TNode node1,
+ prop::SatValue desiredVal1,
+ TNode node2,
+ prop::SatValue desiredVal2);
+ SearchResult handleITE(TNode node, prop::SatValue desiredVal);
+ SearchResult handleEmbeddedSkolems(TNode node);
};/* class JustificationHeuristic */
}/* namespace decision */
-}/* namespace CVC4 */
+} // namespace CVC5
#endif /* CVC4__DECISION__JUSTIFICATION_HEURISTIC */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
ArrayStoreAll::ArrayStoreAll(const TypeNode& type, const Node& value)
: d_type(), d_value()
* NodeHashFunction()(asa.getValue());
}
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
#include <memory>
-
-namespace CVC4 {
+namespace CVC5 {
template <bool ref_count>
class NodeTemplate;
size_t operator()(const ArrayStoreAll& asa) const;
}; /* struct ArrayStoreAllHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__ARRAY_STORE_ALL_H */
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
AscriptionType::AscriptionType(TypeNode t) : d_type(new TypeNode(t)) {}
return out;
}
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
#include <memory>
-namespace CVC4 {
+namespace CVC5 {
class TypeNode;
/** An output routine for AscriptionTypes */
std::ostream& operator<<(std::ostream& out, AscriptionType at);
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__ASCRIPTION_TYPE_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
namespace attr {
}
}
-}/* CVC4::expr::attr namespace */
-}/* CVC4::expr namespace */
-}/* CVC4 namespace */
+} // namespace attr
+} // namespace expr
+} // namespace CVC5
#include "expr/attribute_internals.h"
#undef CVC4_ATTRIBUTE_H__INCLUDING__ATTRIBUTE_INTERNALS_H
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
namespace attr {
void debugHook(int debugFlag);
};
-}/* CVC4::expr::attr namespace */
+} // namespace attr
// MAPPING OF ATTRIBUTE KINDS TO TABLES IN THE ATTRIBUTE MANAGER ===============
}
};
-}/* CVC4::expr::attr namespace */
+} // namespace attr
// ATTRIBUTE MANAGER IMPLEMENTATIONS ===========================================
d_inGarbageCollection = false;
}
-
-}/* CVC4::expr::attr namespace */
-}/* CVC4::expr namespace */
+} // namespace attr
+} // namespace expr
template <class AttrKind>
inline typename AttrKind::value_type
d_attrManager->setAttribute(n.d_nv, AttrKind(), value);
}
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__EXPR__ATTRIBUTE_H */
#include <unordered_map>
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
// ATTRIBUTE HASH FUNCTIONS ====================================================
}
};/* struct AttrBoolHashFunction */
-}/* CVC4::expr::attr namespace */
+} // namespace attr
// ATTRIBUTE TYPE MAPPINGS =====================================================
static T convertBack(const uint64_t& t) { return static_cast<T>(t); }
};
-}/* CVC4::expr::attr namespace */
+} // namespace attr
// ATTRIBUTE HASH TABLES =======================================================
}
};/* class AttrHash<bool> */
-}/* CVC4::expr::attr namespace */
+} // namespace attr
// ATTRIBUTE IDENTIFIER ASSIGNMENT TEMPLATE ====================================
}
};
-}/* CVC4::expr::attr namespace */
+} // namespace attr
// ATTRIBUTE DEFINITION ========================================================
const uint64_t Attribute<T, bool, context_dep>::s_id =
Attribute<T, bool, context_dep>::registerAttribute();
-}/* CVC4::expr namespace */
-}/* CVC4 namespace */
+} // namespace expr
+} // namespace CVC5
#endif /* CVC4__EXPR__ATTRIBUTE_INTERNALS_H */
// ATTRIBUTE IDs ============================================================
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
namespace attr {
AttrTableId getTableId() const{ return d_tableId; }
uint64_t getWithinTypeId() const{ return d_withinTypeId; }
-};/* CVC4::expr::attr::AttributeUniqueId */
+}; /* CVC5::expr::attr::AttributeUniqueId */
-}/* CVC4::expr::attr namespace */
-}/* CVC4::expr namespace */
-}/* CVC4 namespace */
+} // namespace attr
+} // namespace expr
+} // namespace CVC5
#include "expr/node_manager_attributes.h"
-namespace CVC4 {
+namespace CVC5 {
BoundVarManager::BoundVarManager() : d_keepCacheVals(false) {}
return getCacheValue(cv, getCacheValue(i));
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* Bound variable manager.
std::unordered_set<Node, NodeHashFunction> d_cacheVals;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__BOUND_VAR_MANAGER_H */
#include "expr/proof.h"
#include "expr/proof_node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
BufferedProofGenerator::BufferedProofGenerator(context::Context* c,
ProofNodeManager* pnm)
return cdp.getProofFor(fact);
}
-} // namespace CVC4
+} // namespace CVC5
#include "context/cdhashmap.h"
#include "expr/proof_generator.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
class ProofStep;
ProofNodeManager* d_pnm;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__BUFFERED_PROOF_GENERATOR_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
DatatypeIndexConstant::DatatypeIndexConstant(uint32_t index) : d_index(index) {}
std::ostream& operator<<(std::ostream& out, const DatatypeIndexConstant& dic)
return IntegerHashFunction()(dic.getIndex());
}
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
-namespace CVC4 {
+namespace CVC5 {
/* stores an index to Datatype residing in NodeManager */
class DatatypeIndexConstant
size_t operator()(const DatatypeIndexConstant& dic) const;
}; /* struct DatatypeIndexConstantHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__DATATYPE_H */
#include "expr/node_algorithm.h"
#include "expr/type_matcher.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
DType::DType(std::string name, bool isCo)
: d_name(name),
return out << "index_" << dic.getIndex();
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
// ----------------------- datatype attributes
/**
std::ostream& operator<<(std::ostream& os, const DType& dt);
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "expr/type_matcher.h"
#include "options/datatypes_options.h"
-using namespace CVC4::kind;
-using namespace CVC4::theory;
+using namespace CVC5::kind;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
DTypeConstructor::DTypeConstructor(std::string name,
unsigned weight)
return os;
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* The Node-level representation of a constructor for a datatype, which
std::ostream& operator<<(std::ostream& os, const DTypeConstructor& ctor);
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "options/set_language.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
DTypeSelector::DTypeSelector(std::string name, Node selector)
: d_name(name), d_selector(selector), d_resolved(false)
return os;
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
class DatatypeConstructorArg;
class DType;
std::ostream& operator<<(std::ostream& os, const DTypeSelector& arg);
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, const EmptyBag& asa)
{
bool EmptyBag::operator>(const EmptyBag& es) const { return !(*this <= es); }
bool EmptyBag::operator>=(const EmptyBag& es) const { return !(*this < es); }
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
#include <memory>
-namespace CVC4 {
+namespace CVC5 {
class TypeNode;
size_t operator()(const EmptyBag& es) const;
}; /* struct EmptyBagHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EMPTY_BAG_H */
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, const EmptySet& asa) {
return out << "emptyset(" << asa.getType() << ')';
bool EmptySet::operator>(const EmptySet& es) const { return !(*this <= es); }
bool EmptySet::operator>=(const EmptySet& es) const { return !(*this < es); }
-}/* CVC4 namespace */
+} // namespace CVC5
#include <iosfwd>
#include <memory>
-namespace CVC4 {
+namespace CVC5 {
class TypeNode;
size_t operator()(const EmptySet& es) const;
}; /* struct EmptySetHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EMPTY_SET_H */
#include "options/options.h"
#include "options/expr_options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
const int ExprSetDepth::s_iosIndex = std::ios_base::xalloc();
return out;
}
-
-}/* namespace CVC4::expr */
-}/* namespace CVC4 */
+} // namespace expr
+} // namespace CVC5
#include <iosfwd>
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
/**
*/
std::ostream& operator<<(std::ostream& out, ExprSetDepth sd);
-}/* namespace CVC4::expr */
+} // namespace expr
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__EXPR__EXPR_IOMANIP_H */
#include "base/check.h"
#include "expr/kind.h"
-namespace CVC4 {
+namespace CVC5 {
/** A very simple bitmap for Kinds */
class KindMap
std::bitset<kind::LAST_KIND> d_bits;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__KIND_MAP_H */
#include "expr/kind.h"
-namespace CVC4 {
+namespace CVC5 {
namespace kind {
-const char* toString(CVC4::Kind k)
+const char* toString(CVC5::Kind k)
{
- using namespace CVC4::kind;
+ using namespace CVC5::kind;
switch (k)
{
}
}
-std::ostream& operator<<(std::ostream& out, CVC4::Kind k)
+std::ostream& operator<<(std::ostream& out, CVC5::Kind k)
{
out << toString(k);
return out;
* decide whether it's safe to modify big expressions by changing the grouping of
* the arguments. */
/* TODO: This could be generated. */
-bool isAssociative(::CVC4::Kind k) {
+bool isAssociative(::CVC5::Kind k)
+{
switch(k) {
case kind::AND:
case kind::OR:
}
}
-std::string kindToString(::CVC4::Kind k) {
+std::string kindToString(::CVC5::Kind k)
+{
std::stringstream ss;
ss << k;
return ss.str();
}
-}/* CVC4::kind namespace */
+} // namespace kind
std::ostream& operator<<(std::ostream& out, TypeConstant typeConstant) {
switch(typeConstant) {
namespace theory {
-TheoryId kindToTheoryId(::CVC4::Kind k) {
+TheoryId kindToTheoryId(::CVC5::Kind k)
+{
switch(k) {
case kind::UNDEFINED_KIND:
case kind::NULL_EXPR:
throw IllegalArgumentException("", "k", __PRETTY_FUNCTION__, "bad kind");
}
-TheoryId typeConstantToTheoryId(::CVC4::TypeConstant typeConstant)
+TheoryId typeConstantToTheoryId(::CVC5::TypeConstant typeConstant)
{
switch (typeConstant)
{
"", "k", __PRETTY_FUNCTION__, "bad type constant");
}
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "base/exception.h"
#include "theory/theory_id.h"
-namespace CVC4 {
+namespace CVC5 {
namespace kind {
enum Kind_t
}; /* enum Kind_t */
-}/* CVC4::kind namespace */
+} // namespace kind
// import Kind into the "CVC4" namespace but keep the individual kind
// constants under kind::
-typedef ::CVC4::kind::Kind_t Kind;
+typedef ::CVC5::kind::Kind_t Kind;
namespace kind {
* @param k The kind
* @return The name of the kind
*/
-const char* toString(CVC4::Kind k);
+const char* toString(CVC5::Kind k);
/**
* Writes a kind name to a stream.
* @param k The kind to write to the stream
* @return The stream
*/
-std::ostream& operator<<(std::ostream&, CVC4::Kind);
+std::ostream& operator<<(std::ostream&, CVC5::Kind);
/** Returns true if the given kind is associative. This is used by ExprManager to
* decide whether it's safe to modify big expressions by changing the grouping of
* the arguments. */
/* TODO: This could be generated. */
-bool isAssociative(::CVC4::Kind k);
-std::string kindToString(::CVC4::Kind k);
+bool isAssociative(::CVC5::Kind k);
+std::string kindToString(::CVC5::Kind k);
struct KindHashFunction {
- inline size_t operator()(::CVC4::Kind k) const {
- return k;
- }
+ inline size_t operator()(::CVC5::Kind k) const { return k; }
};/* struct KindHashFunction */
-}/* CVC4::kind namespace */
+} // namespace kind
/**
* The enumeration for the built-in atomic types.
namespace theory {
-::CVC4::theory::TheoryId kindToTheoryId(::CVC4::Kind k);
-::CVC4::theory::TheoryId typeConstantToTheoryId(
- ::CVC4::TypeConstant typeConstant);
+::CVC5::theory::TheoryId kindToTheoryId(::CVC5::Kind k);
+::CVC5::theory::TheoryId typeConstantToTheoryId(
+ ::CVC5::TypeConstant typeConstant);
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__KIND_H */
#include "expr/proof_node.h"
#include "expr/proof_node_manager.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
LazyCDProof::LazyCDProof(ProofNodeManager* pnm,
ProofGenerator* dpg,
return it != d_gens.end();
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofGenerator;
class ProofNodeManager;
ProofGenerator* getGeneratorFor(Node fact, bool& isSym);
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__LAZY_PROOF_H */
#include "expr/proof_node_manager.h"
#include "options/proof_options.h"
-namespace CVC4 {
+namespace CVC5 {
LazyCDProofChain::LazyCDProofChain(ProofNodeManager* pnm,
bool cyclic,
std::string LazyCDProofChain::identify() const { return "LazyCDProofChain"; }
-} // namespace CVC4
+} // namespace CVC5
#include "context/cdhashmap.h"
#include "expr/proof_generator.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
ProofGenerator* d_defGen;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__LAZY_PROOF_CHAIN_H */
#include "expr/match_trie.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
bool MatchTrie::getMatches(Node n, NotifyMatch* ntm)
}
} // namespace expr
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
/** A virtual class for notifications regarding matches. */
};
} // namespace expr
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__CANDIDATE_REWRITE_FILTER_H */
#include <iostream>
-namespace CVC4 {
+namespace CVC5 {
namespace kind {
/**
return metaKinds[k + 1];
}/* metaKindOf(k) */
-}/* CVC4::kind namespace */
+} // namespace kind
namespace expr {
${metakind_constantMaps}
-}/* CVC4::expr namespace */
+} // namespace expr
namespace kind {
namespace metakind {
-size_t NodeValueCompare::constHash(const ::CVC4::expr::NodeValue* nv)
+size_t NodeValueCompare::constHash(const ::CVC5::expr::NodeValue* nv)
{
Assert(nv->getMetaKind() == kind::metakind::CONSTANT);
switch (nv->d_kind)
{
${metakind_constHashes}
- default: Unhandled() << ::CVC4::expr::NodeValue::dKindToKind(nv->d_kind);
+default: Unhandled() << ::CVC5::expr::NodeValue::dKindToKind(nv->d_kind);
}
}
template <bool pool>
-bool NodeValueCompare::compare(const ::CVC4::expr::NodeValue* nv1,
- const ::CVC4::expr::NodeValue* nv2) {
+bool NodeValueCompare::compare(const ::CVC5::expr::NodeValue* nv1,
+ const ::CVC5::expr::NodeValue* nv2)
+{
if(nv1->d_kind != nv2->d_kind) {
return false;
}
switch (nv1->d_kind)
{
${metakind_compares}
- default: Unhandled() << ::CVC4::expr::NodeValue::dKindToKind(nv1->d_kind);
+default: Unhandled() << ::CVC5::expr::NodeValue::dKindToKind(nv1->d_kind);
}
}
return false;
}
- ::CVC4::expr::NodeValue::const_nv_iterator i = nv1->nv_begin();
- ::CVC4::expr::NodeValue::const_nv_iterator j = nv2->nv_begin();
- ::CVC4::expr::NodeValue::const_nv_iterator i_end = nv1->nv_end();
+ ::CVC5::expr::NodeValue::const_nv_iterator i = nv1->nv_begin();
+ ::CVC5::expr::NodeValue::const_nv_iterator j = nv2->nv_begin();
+ ::CVC5::expr::NodeValue::const_nv_iterator i_end = nv1->nv_end();
while(i != i_end) {
if((*i) != (*j)) {
return true;
}
-template bool NodeValueCompare::compare<true>(const ::CVC4::expr::NodeValue* nv1,
- const ::CVC4::expr::NodeValue* nv2);
-template bool NodeValueCompare::compare<false>(const ::CVC4::expr::NodeValue* nv1,
- const ::CVC4::expr::NodeValue* nv2);
+template bool NodeValueCompare::compare<true>(
+ const ::CVC5::expr::NodeValue* nv1, const ::CVC5::expr::NodeValue* nv2);
+template bool NodeValueCompare::compare<false>(
+ const ::CVC5::expr::NodeValue* nv1, const ::CVC5::expr::NodeValue* nv2);
void NodeValueConstPrinter::toStream(std::ostream& out,
- const ::CVC4::expr::NodeValue* nv) {
+ const ::CVC5::expr::NodeValue* nv)
+{
Assert(nv->getMetaKind() == kind::metakind::CONSTANT);
switch (nv->d_kind)
{
${metakind_constPrinters}
- default: Unhandled() << ::CVC4::expr::NodeValue::dKindToKind(nv->d_kind);
+default: Unhandled() << ::CVC5::expr::NodeValue::dKindToKind(nv->d_kind);
}
}
* This doesn't support "non-inlined" NodeValues, which shouldn't need this
* kind of cleanup.
*/
-void deleteNodeValueConstant(::CVC4::expr::NodeValue* nv) {
+void deleteNodeValueConstant(::CVC5::expr::NodeValue* nv)
+{
Assert(nv->getMetaKind() == kind::metakind::CONSTANT);
switch (nv->d_kind)
{
${metakind_constDeleters}
- default: Unhandled() << ::CVC4::expr::NodeValue::dKindToKind(nv->d_kind);
+default: Unhandled() << ::CVC5::expr::NodeValue::dKindToKind(nv->d_kind);
}
}
// re-enable the strict-aliasing warning
# pragma GCC diagnostic warning "-Wstrict-aliasing"
-uint32_t getMinArityForKind(::CVC4::Kind k)
+uint32_t getMinArityForKind(::CVC5::Kind k)
{
static const unsigned lbs[] = {
0, /* NULL_EXPR */
return lbs[k];
}
-uint32_t getMaxArityForKind(::CVC4::Kind k)
+uint32_t getMaxArityForKind(::CVC5::Kind k)
{
static const unsigned ubs[] = {
0, /* NULL_EXPR */
* example, since the kind of functions is just VARIABLE, it should map
* VARIABLE to APPLY_UF.
*/
-Kind operatorToKind(::CVC4::expr::NodeValue* nv) {
+Kind operatorToKind(::CVC5::expr::NodeValue* nv)
+{
if(nv->getKind() == kind::BUILTIN) {
return nv->getConst<Kind>();
} else if(nv->getKind() == kind::LAMBDA) {
};
}
-}/* CVC4::kind namespace */
-}/* CVC4 namespace */
+} // namespace kind
+} // namespace CVC5
#include "base/check.h"
#include "expr/kind.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
class NodeValue;
-}/* CVC4::expr namespace */
+ } // namespace expr
namespace kind {
namespace metakind {
*/
template <Kind k, bool pool>
struct NodeValueConstCompare {
- inline static bool compare(const ::CVC4::expr::NodeValue* x,
- const ::CVC4::expr::NodeValue* y);
- inline static size_t constHash(const ::CVC4::expr::NodeValue* nv);
+ inline static bool compare(const ::CVC5::expr::NodeValue* x,
+ const ::CVC5::expr::NodeValue* y);
+ inline static size_t constHash(const ::CVC5::expr::NodeValue* nv);
};/* NodeValueConstCompare<k, pool> */
struct NodeValueCompare {
template <bool pool>
- static bool compare(const ::CVC4::expr::NodeValue* nv1,
- const ::CVC4::expr::NodeValue* nv2);
- static size_t constHash(const ::CVC4::expr::NodeValue* nv);
+ static bool compare(const ::CVC5::expr::NodeValue* nv1,
+ const ::CVC5::expr::NodeValue* nv2);
+ static size_t constHash(const ::CVC5::expr::NodeValue* nv);
};/* struct NodeValueCompare */
/**
NULLARY_OPERATOR /**< nullary operator */
};/* enum MetaKind_t */
-}/* CVC4::kind::metakind namespace */
+} // namespace metakind
-// import MetaKind into the "CVC4::kind" namespace but keep the
+// import MetaKind into the "CVC5::kind" namespace but keep the
// individual MetaKind constants under kind::metakind::
-typedef ::CVC4::kind::metakind::MetaKind_t MetaKind;
+typedef ::CVC5::kind::metakind::MetaKind_t MetaKind;
/**
* Get the metakind for a particular kind.
*/
MetaKind metaKindOf(Kind k);
-}/* CVC4::kind namespace */
+} // namespace kind
namespace expr {
// Comparison predicate
struct NodeValuePoolEq {
inline bool operator()(const NodeValue* nv1, const NodeValue* nv2) const {
- return ::CVC4::kind::metakind::NodeValueCompare::compare<true>(nv1, nv2);
+ return ::CVC5::kind::metakind::NodeValueCompare::compare<true>(nv1, nv2);
}
};
-}/* CVC4::expr namespace */
-}/* CVC4 namespace */
+} // namespace expr
+} // namespace CVC5
#include "expr/node_value.h"
#ifdef CVC4__NODE_MANAGER_NEEDS_CONSTANT_MAP
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
${metakind_getConst_decls}
-}/* CVC4::expr namespace */
+} // namespace expr
namespace kind {
namespace metakind {
template <Kind k, bool pool>
-inline bool NodeValueConstCompare<k, pool>::compare(const ::CVC4::expr::NodeValue* x,
- const ::CVC4::expr::NodeValue* y) {
+inline bool NodeValueConstCompare<k, pool>::compare(
+ const ::CVC5::expr::NodeValue* x, const ::CVC5::expr::NodeValue* y)
+{
typedef typename ConstantMapReverse<k>::T T;
if(pool) {
if(x->d_nchildren == 1) {
}
template <Kind k, bool pool>
-inline size_t NodeValueConstCompare<k, pool>::constHash(const ::CVC4::expr::NodeValue* nv) {
+inline size_t NodeValueConstCompare<k, pool>::constHash(
+ const ::CVC5::expr::NodeValue* nv)
+{
typedef typename ConstantMapReverse<k>::T T;
return nv->getConst<T>().hash();
}
${metakind_constantMaps_decls}
struct NodeValueConstPrinter {
- static void toStream(std::ostream& out,
- const ::CVC4::expr::NodeValue* nv);
+ static void toStream(std::ostream& out, const ::CVC5::expr::NodeValue* nv);
static void toStream(std::ostream& out, TNode n);
};
* This doesn't support "non-inlined" NodeValues, which shouldn't need this
* kind of cleanup.
*/
-void deleteNodeValueConstant(::CVC4::expr::NodeValue* nv);
+void deleteNodeValueConstant(::CVC5::expr::NodeValue* nv);
/** Return the minimum arity of the given kind. */
-uint32_t getMinArityForKind(::CVC4::Kind k);
+uint32_t getMinArityForKind(::CVC5::Kind k);
/** Return the maximum arity of the given kind. */
-uint32_t getMaxArityForKind(::CVC4::Kind k);
+uint32_t getMaxArityForKind(::CVC5::Kind k);
-}/* CVC4::kind::metakind namespace */
+} // namespace metakind
/**
* Map a kind of the operator to the kind of the enclosing expression. For
* example, since the kind of functions is just VARIABLE, it should map
* VARIABLE to APPLY_UF.
*/
-Kind operatorToKind(::CVC4::expr::NodeValue* nv);
+Kind operatorToKind(::CVC5::expr::NodeValue* nv);
-}/* CVC4::kind namespace */
+} // namespace kind
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__NODE_MANAGER_NEEDS_CONSTANT_MAP */
echo "$kf:$lineno: error: \"theory\" directive missing class or header argument" >&2
exit 1
elif ! expr "$2" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::CVC4::theory::foo)" >&2
- elif ! expr "$2" : '\(::CVC4::theory::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class not under ::CVC4::theory namespace" >&2
+ echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::CVC5::theory::foo)" >&2
+ elif ! expr "$2" : '\(::CVC5::theory::*\)' >/dev/null; then
+ echo "$kf:$lineno: warning: theory class not under ::CVC5::theory namespace" >&2
fi
}
"
getConst_implementations="${getConst_implementations}
template <> $2 const & Expr::getConst() const {
- PrettyCheckArgument(getKind() == ::CVC4::kind::$1, *this, \"Improper kind for getConst<$2>()\");
+ PrettyCheckArgument(getKind() == ::CVC5::kind::$1, *this, \"Improper kind for getConst<$2>()\");
return d_node->getConst< $2 >();
}
"
echo "$kf:$lineno: error: \"theory\" directive missing class or header argument" >&2
exit 1
elif ! expr "$2" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::CVC4::theory::foo)" >&2
- elif ! expr "$2" : '\(::CVC4::theory::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class not under ::CVC4::theory namespace" >&2
+ echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::CVC5::theory::foo)" >&2
+ elif ! expr "$2" : '\(::CVC5::theory::*\)' >/dev/null; then
+ echo "$kf:$lineno: warning: theory class not under ::CVC5::theory namespace" >&2
fi
theory_id="$1"
echo "$kf:$lineno: error: \"theory\" directive missing class or header argument" >&2
exit 1
elif ! expr "$2" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class \`$1' isn't fully-qualified (e.g., ::CVC4::theory::foo)" >&2
- elif ! expr "$2" : '\(::CVC4::theory::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class not under ::CVC4::theory namespace" >&2
+ echo "$kf:$lineno: warning: theory class \`$1' isn't fully-qualified (e.g., ::CVC5::theory::foo)" >&2
+ elif ! expr "$2" : '\(::CVC5::theory::*\)' >/dev/null; then
+ echo "$kf:$lineno: warning: theory class not under ::CVC5::theory namespace" >&2
fi
theory_class=$1
# tricky to specify the CONST payload, like "int const*"; in any
# case, this warning gives too many false positives, so disable it
if ! expr "$2" : '..* ..*' >/dev/null; then
- echo "$kf:$lineno: warning: constant $1 class \`$2' isn't fully-qualified (e.g., ::CVC4::Rational)" >&2
+ echo "$kf:$lineno: warning: constant $1 class \`$2' isn't fully-qualified (e.g., ::CVC5::Rational)" >&2
fi
fi
fi
if ! expr "$3" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: constant $1 hasher \`$3' isn't fully-qualified (e.g., ::CVC4::RationalHashFunction)" >&2
+ echo "$kf:$lineno: warning: constant $1 hasher \`$3' isn't fully-qualified (e.g., ::CVC5::RationalHashFunction)" >&2
fi
# Avoid including the same header multiple times
template <>
struct ConstantMap< $2 > {
// typedef $theory_class OwningTheory;
- enum { kind = ::CVC4::kind::$1 };
+ enum { kind = ::CVC5::kind::$1 };
};/* ConstantMap< $2 > */
template <>
-struct ConstantMapReverse< ::CVC4::kind::$1 > {
+struct ConstantMapReverse< ::CVC5::kind::$1 > {
typedef $2 T;
-};/* ConstantMapReverse< ::CVC4::kind::$1 > */
+};/* ConstantMapReverse< ::CVC5::kind::$1 > */
"
metakind_constantMaps="${metakind_constantMaps}
// The reinterpret_cast of d_children to \"$2 const*\"
template <>
$2 const& NodeValue::getConst< $2 >() const {
- AssertArgument(getKind() == ::CVC4::kind::$1, *this,
+ AssertArgument(getKind() == ::CVC5::kind::$1, *this,
\"Improper kind for getConst<$2>()\");
// To support non-inlined CONSTANT-kinded NodeValues (those that are
// \"constructed\" when initially checking them against the NodeManager
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
TypeCheckingExceptionPrivate::TypeCheckingExceptionPrivate(TNode node,
std::string message)
template bool NodeTemplate<true>::isConst() const;
template bool NodeTemplate<false>::isConst() const;
-}/* CVC4 namespace */
+} // namespace CVC5
#include "util/hash.h"
#include "util/utility.h"
-namespace CVC4 {
+namespace CVC5 {
class TypeNode;
class NodeManager;
namespace attr {
class AttributeManager;
struct SmtAttributes;
- }/* CVC4::expr::attr namespace */
+ } // namespace attr
class ExprSetDepth;
-}/* CVC4::expr namespace */
+ } // namespace expr
namespace kind {
namespace metakind {
struct NodeValueConstPrinter;
- }/* CVC4::kind::metakind namespace */
-}/* CVC4::kind namespace */
+ } // namespace metakind
+ } // namespace kind
// for hash_maps, hash_sets..
struct NodeHashFunction {
template <unsigned nchild_thresh>
friend class NodeBuilder;
- friend class ::CVC4::expr::attr::AttributeManager;
- friend struct ::CVC4::expr::attr::SmtAttributes;
+ friend class ::CVC5::expr::attr::AttributeManager;
+ friend struct ::CVC5::expr::attr::SmtAttributes;
- friend struct ::CVC4::kind::metakind::NodeValueConstPrinter;
+ friend struct ::CVC5::kind::metakind::NodeValueConstPrinter;
/**
* Assigns the expression value and does reference counting. No assumptions
return out;
}
-}/* CVC4 namespace */
+} // namespace CVC5
//#include "expr/attribute.h"
#include "expr/node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
inline size_t NodeHashFunction::operator()(Node node) const {
return node.getId();
inline typename AttrKind::value_type NodeTemplate<ref_count>::
getAttribute(const AttrKind&) const {
Assert(NodeManager::currentNM() != NULL)
- << "There is no current CVC4::NodeManager associated to this thread.\n"
+ << "There is no current CVC5::NodeManager associated to this thread.\n"
"Perhaps a public-facing function is missing a NodeManagerScope ?";
assertTNodeNotExpired();
inline bool NodeTemplate<ref_count>::
hasAttribute(const AttrKind&) const {
Assert(NodeManager::currentNM() != NULL)
- << "There is no current CVC4::NodeManager associated to this thread.\n"
+ << "There is no current CVC5::NodeManager associated to this thread.\n"
"Perhaps a public-facing function is missing a NodeManagerScope ?";
assertTNodeNotExpired();
inline bool NodeTemplate<ref_count>::getAttribute(const AttrKind&,
typename AttrKind::value_type& ret) const {
Assert(NodeManager::currentNM() != NULL)
- << "There is no current CVC4::NodeManager associated to this thread.\n"
+ << "There is no current CVC5::NodeManager associated to this thread.\n"
"Perhaps a public-facing function is missing a NodeManagerScope ?";
assertTNodeNotExpired();
inline void NodeTemplate<ref_count>::
setAttribute(const AttrKind&, const typename AttrKind::value_type& value) {
Assert(NodeManager::currentNM() != NULL)
- << "There is no current CVC4::NodeManager associated to this thread.\n"
+ << "There is no current CVC5::NodeManager associated to this thread.\n"
"Perhaps a public-facing function is missing a NodeManagerScope ?";
assertTNodeNotExpired();
NodeTemplate<true> NodeTemplate<ref_count>::getOperator() const
{
Assert(NodeManager::currentNM() != NULL)
- << "There is no current CVC4::NodeManager associated to this thread.\n"
+ << "There is no current CVC5::NodeManager associated to this thread.\n"
"Perhaps a public-facing function is missing a NodeManagerScope ?";
assertTNodeNotExpired();
TypeNode NodeTemplate<ref_count>::getType(bool check) const
{
Assert(NodeManager::currentNM() != NULL)
- << "There is no current CVC4::NodeManager associated to this thread.\n"
+ << "There is no current CVC5::NodeManager associated to this thread.\n"
"Perhaps a public-facing function is missing a NodeManagerScope ?";
assertTNodeNotExpired();
}
#endif /* CVC4_DEBUG */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__NODE_H */
#include "expr/attribute.h"
#include "expr/dtype.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
bool hasSubterm(TNode n, TNode t, bool strict)
}
} // namespace expr
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
/**
std::unordered_map<Node, Node, NodeHashFunction>& subs);
} // namespace expr
-} // namespace CVC4
+} // namespace CVC5
#endif
#include <memory>
#include <vector>
-namespace CVC4 {
- static const unsigned default_nchild_thresh = 10;
+namespace CVC5 {
+static const unsigned default_nchild_thresh = 10;
- template <unsigned nchild_thresh>
- class NodeBuilder;
+template <unsigned nchild_thresh>
+class NodeBuilder;
- class NodeManager;
-}/* CVC4 namespace */
+class NodeManager;
+} // namespace CVC5
#include "base/check.h"
#include "base/output.h"
#include "expr/metakind.h"
#include "expr/node_value.h"
-namespace CVC4 {
+namespace CVC5 {
// Sometimes it's useful for debugging to output a NodeBuilder that
// isn't yet a Node..
};/* class NodeBuilder<> */
-}/* CVC4 namespace */
+} // namespace CVC5
// TODO: add templatized NodeTemplate<ref_count> to all above and
// below inlines for 'const [T]Node&' arguments? Technically a lot of
#include "expr/node_manager.h"
#include "options/expr_options.h"
-namespace CVC4 {
+namespace CVC5 {
template <unsigned nchild_thresh>
void NodeBuilder<nchild_thresh>::clear(Kind k) {
return out << *nb.d_nv;
}
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__NODE_BUILDER_H */
#include "util/resource_manager.h"
using namespace std;
-using namespace CVC4::expr;
+using namespace CVC5::expr;
-namespace CVC4 {
+namespace CVC5 {
thread_local NodeManager* NodeManager::s_current = NULL;
namespace attr {
struct LambdaBoundVarListTag { };
-}/* CVC4::attr namespace */
+ } // namespace attr
// attribute that stores the canonical bound variable list for function types
typedef expr::Attribute<attr::LambdaBoundVarListTag, Node> LambdaBoundVarListAttr;
if(mk == kind::metakind::CONSTANT) {
// Destroy (call the destructor for) the C++ type representing
// the constant in this NodeValue. This is needed for
- // e.g. CVC4::Rational, since it has a gmp internal
+ // e.g. CVC5::Rational, since it has a gmp internal
// representation that mallocs memory and should be cleaned
// up. (This won't delete a pointer value if used as a
// constant, but then, you should probably use a smart-pointer
<< "malformed selector in datatype post-resolution";
// This next one's a "hard" check, performed in non-debug builds
// as well; the other ones should all be guaranteed by the
- // CVC4::DType class, but this actually needs to be checked.
+ // CVC5::DType class, but this actually needs to be checked.
AlwaysAssert(!selectorType.getRangeType().isFunctionLike())
<< "cannot put function-like things in datatypes";
}
return kind::UNDEFINED_KIND;
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "expr/metakind.h"
#include "expr/node_value.h"
-namespace CVC4 {
+namespace CVC5 {
namespace api {
class Solver;
namespace attr {
class AttributeUniqueId;
class AttributeManager;
- }/* CVC4::expr::attr namespace */
+ } // namespace attr
class TypeChecker;
-}/* CVC4::expr namespace */
+ } // namespace expr
/**
* An interface that an interested party can implement and then subscribe
* PLUS, are APPLYs of a PLUS operator to arguments. This array
* holds the set of operators for these things. A PLUS operator is
* a Node with kind "BUILTIN", and if you call
- * plusOperator->getConst<CVC4::Kind>(), you get kind::PLUS back.
+ * plusOperator->getConst<CVC5::Kind>(), you get kind::PLUS back.
*/
Node d_operators[kind::LAST_KIND];
/**
* Get the (singleton) operator of an OPERATOR-kinded kind. The
* returned node n will have kind BUILTIN, and calling
- * n.getConst<CVC4::Kind>() will yield k.
+ * n.getConst<CVC5::Kind>() will yield k.
*/
inline TNode operatorOf(Kind k) {
AssertArgument( kind::metaKindOf(k) == kind::metakind::OPERATOR, k,
d_nodeValuePool.erase(nv);// FIXME multithreading
}
-}/* CVC4 namespace */
+} // namespace CVC5
#define CVC4__NODE_MANAGER_NEEDS_CONSTANT_MAP
#include "expr/metakind.h"
#include "expr/node_builder.h"
-namespace CVC4 {
+namespace CVC5 {
// general expression-builders
return NodeClass(nv);
}
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__NODE_MANAGER_H */
#include "expr/attribute.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
// Definition of an attribute for the variable name.
struct SortArityTag { };
struct TypeTag { };
struct TypeCheckedTag { };
-}/* CVC4::expr::attr namespace */
+ } // namespace attr
typedef Attribute<attr::VarNameTag, std::string> VarNameAttr;
typedef Attribute<attr::SortArityTag, uint64_t> SortArityAttr;
typedef expr::Attribute<expr::attr::TypeTag, TypeNode> TypeAttr;
typedef expr::Attribute<expr::attr::TypeCheckedTag, bool> TypeCheckedAttr;
-}/* CVC4::expr namespace */
-}/* CVC4 namespace */
+} // namespace expr
+} // namespace CVC5
#include "base/check.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
class NodeSelfIterator : public std::iterator<std::input_iterator_tag, Node> {
return !(*this == i);
}
-}/* CVC4::expr namespace */
-}/* CVC4 namespace */
+} // namespace expr
+} // namespace CVC5
#endif /* CVC4__EXPR__NODE_SELF_ITERATOR_H */
#include <functional>
-namespace CVC4 {
+namespace CVC5 {
NodeDfsIterator::NodeDfsIterator(TNode n,
VisitOrder order,
return NodeDfsIterator(d_order);
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* Enum that represents an order in which nodes are visited.
std::function<bool(TNode)> d_skipIf;
};
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__EXPR__NODE_TRAVERSAL_H
#include "expr/node_trie.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
template <bool ref_count>
unsigned depth) const;
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include <map>
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** NodeTemplate trie class
typedef NodeTemplateTrie<false> TNodeTrie;
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__NODE_TRIE_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
string NodeValue::toString() const {
return i + p;
}
-} /* CVC4::expr namespace */
-} /* CVC4 namespace */
+} // namespace expr
+} // namespace CVC5
#include "expr/kind.h"
#include "options/language.h"
-namespace CVC4 {
+namespace CVC5 {
template <bool ref_count> class NodeTemplate;
class TypeNode;
namespace kind {
namespace metakind {
- template < ::CVC4::Kind k, bool pool >
- struct NodeValueConstCompare;
+ template < ::CVC5::Kind k, bool pool>
+ struct NodeValueConstCompare;
- struct NodeValueCompare;
- struct NodeValueConstPrinter;
+ struct NodeValueCompare;
+ struct NodeValueConstPrinter;
- void deleteNodeValueConstant(::CVC4::expr::NodeValue* nv);
- }/* CVC4::kind::metakind namespace */
-}/* CVC4::kind namespace */
+ void deleteNodeValueConstant(::CVC5::expr::NodeValue* nv);
+ } // namespace metakind
+ } // namespace kind
namespace expr {
class NodeValue
{
template <bool>
- friend class ::CVC4::NodeTemplate;
- friend class ::CVC4::TypeNode;
+ friend class ::CVC5::NodeTemplate;
+ friend class ::CVC5::TypeNode;
template <unsigned nchild_thresh>
- friend class ::CVC4::NodeBuilder;
- friend class ::CVC4::NodeManager;
+ friend class ::CVC5::NodeBuilder;
+ friend class ::CVC5::NodeManager;
template <Kind k, bool pool>
- friend struct ::CVC4::kind::metakind::NodeValueConstCompare;
+ friend struct ::CVC5::kind::metakind::NodeValueConstCompare;
- friend struct ::CVC4::kind::metakind::NodeValueCompare;
- friend struct ::CVC4::kind::metakind::NodeValueConstPrinter;
+ friend struct ::CVC5::kind::metakind::NodeValueCompare;
+ friend struct ::CVC5::kind::metakind::NodeValueConstPrinter;
- friend void ::CVC4::kind::metakind::deleteNodeValueConstant(NodeValue* nv);
+ friend void ::CVC5::kind::metakind::deleteNodeValueConstant(NodeValue* nv);
friend class RefCountGuard;
inline std::ostream& operator<<(std::ostream& out, const NodeValue& nv);
-}/* CVC4::expr namespace */
-}/* CVC4 namespace */
+} // namespace expr
+} // namespace CVC5
#include "expr/node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
inline NodeValue::NodeValue(int) :
return d_children[i];
}
-}/* CVC4::expr namespace */
-}/* CVC4 namespace */
+} // namespace expr
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
template <typename T>
return out;
}
-}/* CVC4::expr namespace */
+} // namespace expr
#ifdef CVC4_DEBUG
/**
}
#endif /* CVC4_DEBUG */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__EXPR__NODE_VALUE_H */
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* Traverses the nodes reverse-topologically (children before parents),
template <typename Visitor>
thread_local bool NodeVisitor<Visitor>::s_inRun = false;
-}/* CVC4 namespace */
+} // namespace CVC5
#include "expr/proof_node.h"
#include "expr/proof_node_manager.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
CDProof::CDProof(ProofNodeManager* pnm,
context::Context* c,
std::string CDProof::identify() const { return d_name; }
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_generator.h"
#include "expr/proof_step_buffer.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNode;
class ProofNodeManager;
void notifyNewProof(Node expected);
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__PROOF_MANAGER_H */
#include "options/proof_options.h"
#include "smt/smt_statistics_registry.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
Node ProofRuleChecker::check(PfRule id,
const std::vector<Node>& children,
return false;
}
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_histogram.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofChecker;
class ProofNode;
bool enableOutput);
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__PROOF_CHECKER_H */
#include "options/proof_options.h"
#include "options/smt_options.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* Ensure closed with respect to assumptions, internal version, which
ensureClosedWrtInternal(Node::null(), nullptr, pn, assumps, c, ctx, false);
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofGenerator;
class ProofNode;
const std::vector<Node>& assumps,
const char* c,
const char* ctx);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__PROOF_ENSURE_CLOSED_H */
#include "expr/proof_node_algorithm.h"
#include "options/smt_options.h"
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, CDPOverwrite opol)
{
return false;
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class CDProof;
class ProofNode;
virtual std::string identify() const = 0;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__PROOF_GENERATOR_H */
#include "expr/proof_node_algorithm.h"
#include "expr/proof_node_to_sexpr.h"
-namespace CVC4 {
+namespace CVC5 {
ProofNode::ProofNode(PfRule id,
const std::vector<std::shared_ptr<ProofNode>>& children,
return out;
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/proof_rule.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
class ProofNode;
*/
std::ostream& operator<<(std::ostream& out, const ProofNode& pn);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__PROOF_NODE_H */
#include "expr/proof_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
void getFreeAssumptions(ProofNode* pn, std::vector<Node>& assump)
}
} // namespace expr
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNode;
std::unordered_set<const ProofNode*>& visited);
} // namespace expr
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__PROOF_NODE_ALGORITHM_H */
#include "options/proof_options.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
ProofNodeManager::ProofNodeManager(ProofChecker* pc)
: d_checker(pc)
return true;
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/proof_rule.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofChecker;
class ProofNode;
bool needsCheck);
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__PROOF_NODE_H */
#include "expr/proof_node.h"
#include "options/proof_options.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
ProofNodeToSExpr::ProofNodeToSExpr()
{
return var;
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/proof_rule.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNode;
Node getOrMkNodeVariable(Node n);
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__PROOF_RULE_H */
#include "expr/proof_node_algorithm.h"
#include "expr/proof_node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
ProofNodeUpdaterCallback::ProofNodeUpdaterCallback() {}
ProofNodeUpdaterCallback::~ProofNodeUpdaterCallback() {}
d_debugFreeAssumps = true;
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/proof_node.h"
-namespace CVC4 {
+namespace CVC5 {
class CDProof;
class ProofNode;
bool d_autoSym;
};
-} // namespace CVC4
+} // namespace CVC5
#endif
#include <iostream>
-namespace CVC4 {
+namespace CVC5 {
const char* toString(PfRule id)
{
return static_cast<size_t>(id);
}
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
-namespace CVC4 {
+namespace CVC5 {
/**
* An enumeration for proof rules. This enumeration is analogous to Kind for
size_t operator()(PfRule id) const;
}; /* struct PfRuleHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__PROOF_RULE_H */
#include "context/context.h"
#include "expr/proof_node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* A (context-dependent) set of proofs, which is used for memory
std::string d_namePrefix;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__LAZY_PROOF_SET_H */
#include "expr/proof_checker.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
ProofStep::ProofStep() : d_rule(PfRule::UNKNOWN) {}
ProofStep::ProofStep(PfRule r,
void ProofStepBuffer::clear() { d_steps.clear(); }
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/proof_rule.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofChecker;
std::vector<std::pair<Node, ProofStep>> d_steps;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__PROOF_STEP_BUFFER_H */
#include "base/check.h"
#include "base/output.h"
-
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, const RecordUpdate& t) {
return out << "[" << t.getField() << "]";
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include <utility>
// Forward Declarations
-namespace CVC4 {
+namespace CVC5 {
// This forward delcartion is required to resolve a cicular dependency with
// Record which is a referenced in a Kind file.
class TypeNode;
-} /* namespace CVC4 */
+} // namespace CVC5
-namespace CVC4 {
+namespace CVC5 {
// operators for record update
class RecordUpdate
using Record = std::vector<std::pair<std::string, TypeNode>>;
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__RECORD_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
Sequence::Sequence(const TypeNode& t, const std::vector<Node>& s)
: d_type(new TypeNode(t)), d_seq(s)
return ret;
}
-} // namespace CVC4
+} // namespace CVC5
#include <memory>
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
template <bool ref_count>
class NodeTemplate;
public:
/** constructors for Sequence
*
- * Internally, a CVC4::Sequence is represented by a vector of Nodes (d_seq),
+ * Internally, a CVC5::Sequence is represented by a vector of Nodes (d_seq),
* where each Node in this vector must be a constant.
*/
Sequence() = default;
std::ostream& operator<<(std::ostream& os, const Sequence& s);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__SEQUENCE_H */
#include "expr/bound_var_manager.h"
#include "expr/node_algorithm.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
// Attributes are global maps from Nodes to data. Thus, note that these could
// be implemented as internal maps in SkolemManager.
return k;
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofGenerator;
int flags = NodeManager::SKOLEM_DEFAULT);
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__PROOF_SKOLEM_CACHE_H */
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
bool Subs::empty() const { return d_vars.empty(); }
return out;
}
-} // namespace CVC4
+} // namespace CVC5
#include <vector>
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* Helper substitution class. Stores a substitution in parallel vectors
*/
std::ostream& operator<<(std::ostream& out, const Subs& s);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__SUBS_H */
#include <sstream>
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
SygusDatatype::SygusDatatype(const std::string& name) : d_dt(DType(name)) {}
bool SygusDatatype::isInitialized() const { return d_dt.isSygus(); }
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
/** Attribute true for variables that represent any constant */
struct SygusAnyConstAttributeId
DType d_dt;
};
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "context/cdlist.h"
#include "context/cdo.h"
-using namespace CVC4::context;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
// ---------------------------------------------- SymbolManager::Implementation
d_symtabAllocated.resetAssertions();
}
-} // namespace CVC4
+} // namespace CVC5
#include "cvc4_export.h"
#include "expr/symbol_table.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* Symbol manager, which manages:
bool d_globalDeclarations;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__SYMBOL_MANAGER_H */
#include "context/cdhashset.h"
#include "context/context.h"
-namespace CVC4 {
+namespace CVC5 {
-using ::CVC4::context::CDHashMap;
-using ::CVC4::context::CDHashSet;
-using ::CVC4::context::Context;
+using ::CVC5::context::CDHashMap;
+using ::CVC5::context::CDHashSet;
+using ::CVC5::context::Context;
using ::std::copy;
using ::std::endl;
using ::std::ostream_iterator;
void SymbolTable::reset() { d_implementation->reset(); }
void SymbolTable::resetAssertions() { d_implementation->resetAssertions(); }
-} // namespace CVC4
+} // namespace CVC5
#include "base/exception.h"
#include "cvc4_export.h"
-namespace CVC4 {
+namespace CVC5 {
namespace api {
class Solver;
std::unique_ptr<Implementation> d_implementation;
}; /* class SymbolTable */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SYMBOL_TABLE_H */
#include "expr/proof_node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
TConvSeqProofGenerator::TConvSeqProofGenerator(
ProofNodeManager* pnm,
std::string TConvSeqProofGenerator::identify() const { return d_name; }
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_generator.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
std::string d_name;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__TCONV_SEQ_PROOF_GENERATOR_H */
// TODO #1216: move the code in this include
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
TermCanonize::TermCanonize() : d_op_id_count(0), d_typ_id_count(0) {}
}
} // namespace expr
-} // namespace CVC4
+} // namespace CVC5
#include <map>
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
/** TermCanonize
};
} // namespace expr
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__TERM_CANONIZE_H */
#include "expr/term_context.h"
-namespace CVC4 {
+namespace CVC5 {
uint32_t TermContext::computeValueOp(TNode t, uint32_t tval) const
{
pol = val == 2;
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* This is an abstract class for computing "term context identifiers". A term
static void getFlags(uint32_t val, bool& hasPol, bool& pol);
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__TERM_CONVERSION_PROOF_GENERATOR_H */
#include "expr/term_context.h"
-namespace CVC4 {
+namespace CVC5 {
TCtxNode::TCtxNode(Node n, const TermContext* tctx)
: d_node(n), d_val(tctx->initialValue()), d_tctx(tctx)
return h[0];
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class TCtxStack;
class TermContext;
const TermContext* d_tctx;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__TERM_CONVERSION_PROOF_GENERATOR_H */
#include "expr/term_context.h"
-namespace CVC4 {
+namespace CVC5 {
TCtxStack::TCtxStack(const TermContext* tctx) : d_tctx(tctx) {}
return TCtxNode(curr.first, curr.second, d_tctx);
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/term_context_node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* A stack for term-context-sensitive terms. Its main advantage is that
const TermContext* d_tctx;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__TERM_CONTEXT_STACK_H */
#include "expr/term_context.h"
#include "expr/term_context_stack.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, TConvPolicy tcpol)
{
return ss.str();
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/lazy_proof.h"
#include "expr/proof_generator.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
class TermContext;
std::string toStringDebug() const;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__EXPR__TERM_CONVERSION_PROOF_GENERATOR_H */
#ifndef CVC4__EXPR__TYPE_CHECKER_H
#define CVC4__EXPR__TYPE_CHECKER_H
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
class TypeChecker {
};/* class TypeChecker */
-}/* CVC4::expr namespace */
-}/* CVC4 namespace */
+} // namespace expr
+} // namespace CVC5
#endif /* CVC4__EXPR__TYPE_CHECKER_H */
${typechecker_includes}
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
TypeNode TypeChecker::computeType(NodeManager* nodeManager, TNode n, bool check)
}/* TypeChecker::computeIsConst */
-}/* CVC4::expr namespace */
-}/* CVC4 namespace */
+} // namespace expr
+} // namespace CVC5
#include "expr/node_manager.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace expr {
/** Type check returns the builtin operator sort */
};
} // namespace expr
-} // namespace CVC4
+} // namespace CVC5
#include "type_matcher.h"
-namespace CVC4 {
+namespace CVC5 {
TypeMatcher::TypeMatcher(TypeNode dt)
{
}
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* This class is used for inferring the parameters of an instantiated
void addTypes(const std::vector<TypeNode>& types);
}; /* class TypeMatcher */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__MATCHER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
TypeNode TypeNode::s_null( &expr::NodeValue::null() );
TypeNode TypeNode::commonTypeNode(TypeNode t0, TypeNode t1, bool isLeast) {
Assert(NodeManager::currentNM() != NULL)
- << "There is no current CVC4::NodeManager associated to this thread.\n"
+ << "There is no current CVC5::NodeManager associated to this thread.\n"
"Perhaps a public-facing function is missing a NodeManagerScope ?";
Assert(!t0.isNull());
return (*this)[0];
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "expr/metakind.h"
#include "util/cardinality.h"
-namespace CVC4 {
+namespace CVC5 {
class NodeManager;
class DType;
namespace expr {
class NodeValue;
-}/* CVC4::expr namespace */
+ } // namespace expr
/**
* Encapsulation of an NodeValue pointer for Types. The reference count is
typedef TypeNode::HashFunction TypeNodeHashFunction;
-}/* CVC4 namespace */
+} // namespace CVC5
#include "expr/node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
inline TypeNode
TypeNode::substitute(const TypeNode& type,
inline typename AttrKind::value_type TypeNode::
getAttribute(const AttrKind&) const {
Assert(NodeManager::currentNM() != NULL)
- << "There is no current CVC4::NodeManager associated to this thread.\n"
+ << "There is no current CVC5::NodeManager associated to this thread.\n"
"Perhaps a public-facing function is missing a NodeManagerScope ?";
return NodeManager::currentNM()->getAttribute(d_nv, AttrKind());
}
inline bool TypeNode::
hasAttribute(const AttrKind&) const {
Assert(NodeManager::currentNM() != NULL)
- << "There is no current CVC4::NodeManager associated to this thread.\n"
+ << "There is no current CVC5::NodeManager associated to this thread.\n"
"Perhaps a public-facing function is missing a NodeManagerScope ?";
return NodeManager::currentNM()->hasAttribute(d_nv, AttrKind());
}
template <class AttrKind>
inline bool TypeNode::getAttribute(const AttrKind&, typename AttrKind::value_type& ret) const {
Assert(NodeManager::currentNM() != NULL)
- << "There is no current CVC4::NodeManager associated to this thread.\n"
+ << "There is no current CVC5::NodeManager associated to this thread.\n"
"Perhaps a public-facing function is missing a NodeManagerScope ?";
return NodeManager::currentNM()->getAttribute(d_nv, AttrKind(), ret);
}
inline void TypeNode::
setAttribute(const AttrKind&, const typename AttrKind::value_type& value) {
Assert(NodeManager::currentNM() != NULL)
- << "There is no current CVC4::NodeManager associated to this thread.\n"
+ << "There is no current CVC5::NodeManager associated to this thread.\n"
"Perhaps a public-facing function is missing a NodeManagerScope ?";
NodeManager::currentNM()->setAttribute(d_nv, AttrKind(), value);
}
}
#endif /* CVC4_DEBUG */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__NODE_H */
${type_properties_includes}
-namespace CVC4 {
+namespace CVC5 {
namespace kind {
/**
}
} /* mkGroundTerm(TypeNode) */
-}/* CVC4::kind namespace */
-}/* CVC4 namespace */
+} // namespace kind
+} // namespace CVC5
#endif /* CVC4__TYPE_PROPERTIES_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
UninterpretedConstant::UninterpretedConstant(const TypeNode& type,
Integer index)
* IntegerHashFunction()(uc.getIndex());
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
class TypeNode;
size_t operator()(const UninterpretedConstant& uc) const;
}; /* struct UninterpretedConstantHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__UNINTERPRETED_CONSTANT_H */
#include "main/main.h"
#include "smt/command.h"
-namespace CVC4 {
+namespace CVC5 {
namespace main {
// Function to cancel any (externally-imposed) limit on CPU time.
d_options.flushErr();
}
-}/* CVC4::main namespace */
-}/* CVC4 namespace */
+} // namespace main
+} // namespace CVC5
#include "smt/smt_engine.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
class Command;
* sequence. Eventually uses doCommandSingleton (which can be
* overridden by a derived class).
*/
- bool doCommand(CVC4::Command* cmd);
+ bool doCommand(CVC5::Command* cmd);
- bool doCommand(std::unique_ptr<CVC4::Command>& cmd) {
+ bool doCommand(std::unique_ptr<CVC5::Command>& cmd)
+ {
return doCommand(cmd.get());
}
protected:
/** Executes treating cmd as a singleton */
- virtual bool doCommandSingleton(CVC4::Command* cmd);
+ virtual bool doCommandSingleton(CVC5::Command* cmd);
private:
CommandExecutor();
Command* cmd,
std::ostream* out);
-}/* CVC4::main namespace */
-}/* CVC4 namespace */
+} // namespace main
+} // namespace CVC5
#endif /* CVC4__MAIN__COMMAND_EXECUTOR_H */
#include "util/result.h"
using namespace std;
-using namespace CVC4;
-using namespace CVC4::parser;
-using namespace CVC4::main;
+using namespace CVC5;
+using namespace CVC5::parser;
+using namespace CVC5::main;
-namespace CVC4 {
- namespace main {
- /** Global options variable */
- thread_local Options* pOptions;
+namespace CVC5 {
+namespace main {
+/** Global options variable */
+thread_local Options* pOptions;
- /** Full argv[0] */
- const char *progPath;
+/** Full argv[0] */
+const char* progPath;
- /** Just the basename component of argv[0] */
- const std::string *progName;
+/** Just the basename component of argv[0] */
+const std::string* progName;
- /** A pointer to the CommandExecutor (the signal handlers need it) */
- std::unique_ptr<CVC4::main::CommandExecutor> pExecutor;
+/** A pointer to the CommandExecutor (the signal handlers need it) */
+std::unique_ptr<CVC5::main::CommandExecutor> pExecutor;
- /** The time point the binary started, accessible to signal handlers */
- std::unique_ptr<TotalTimer> totalTime;
+/** The time point the binary started, accessible to signal handlers */
+std::unique_ptr<TotalTimer> totalTime;
- TotalTimer::~TotalTimer()
- {
- if (pExecutor != nullptr)
- {
- auto duration = std::chrono::steady_clock::now() - d_start;
- pExecutor->getSmtEngine()->setTotalTimeStatistic(
- std::chrono::duration<double>(duration).count());
- }
+TotalTimer::~TotalTimer()
+{
+ if (pExecutor != nullptr)
+ {
+ auto duration = std::chrono::steady_clock::now() - d_start;
+ pExecutor->getSmtEngine()->setTotalTimeStatistic(
+ std::chrono::duration<double>(duration).count());
+ }
}
- }/* CVC4::main namespace */
-}/* CVC4 namespace */
-
+ } // namespace main
+ } // namespace CVC5
void printUsage(Options& opts, bool full) {
stringstream ss;
// Determine which messages to show based on smtcomp_mode and verbosity
if(Configuration::isMuzzledBuild()) {
- DebugChannel.setStream(&CVC4::null_os);
- TraceChannel.setStream(&CVC4::null_os);
- NoticeChannel.setStream(&CVC4::null_os);
- ChatChannel.setStream(&CVC4::null_os);
- MessageChannel.setStream(&CVC4::null_os);
- WarningChannel.setStream(&CVC4::null_os);
+ DebugChannel.setStream(&CVC5::null_os);
+ TraceChannel.setStream(&CVC5::null_os);
+ NoticeChannel.setStream(&CVC5::null_os);
+ ChatChannel.setStream(&CVC5::null_os);
+ MessageChannel.setStream(&CVC5::null_os);
+ WarningChannel.setStream(&CVC5::null_os);
}
// important even for muzzled builds (to get result output right)
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
using namespace parser;
using namespace language;
#endif /* HAVE_LIBEDITLINE */
-}/* CVC4 namespace */
+} // namespace CVC5
#include "options/options.h"
#include "util/unsafe_interrupt_exception.h"
-namespace CVC4 {
+namespace CVC5 {
class Command;
class Options;
namespace parser {
class Parser;
-}/* CVC4::parser namespace */
+ } // namespace parser
class SymbolManager;
};/* class InteractiveShell */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__INTERACTIVE_SHELL_H */
#include "util/result.h"
using namespace std;
-using namespace CVC4;
-using namespace CVC4::main;
-using namespace CVC4::language;
+using namespace CVC5;
+using namespace CVC5::main;
+using namespace CVC5::language;
/**
* CVC4's main() routine is just an exception-safe wrapper around CVC4.
#ifndef CVC4__MAIN__MAIN_H
#define CVC4__MAIN__MAIN_H
-namespace CVC4 {
+namespace CVC5 {
namespace main {
class CommandExecutor;
extern const std::string* progName;
/** A reference for use by the signal handlers to print statistics */
-extern std::unique_ptr<CVC4::main::CommandExecutor> pExecutor;
+extern std::unique_ptr<CVC5::main::CommandExecutor> pExecutor;
/** Manages a custom timer for the total runtime in RAII-style. */
class TotalTimer
extern thread_local Options* pOptions;
/** Initialize the driver. Sets signal handlers for SIGINT and SIGSEGV.
- * This can throw a CVC4::Exception.
+ * This can throw a CVC5::Exception.
*/
void cvc4_init();
/** Shutdown the driver. Frees memory for the signal handlers. */
void cvc4_shutdown() noexcept;
-}/* CVC4::main namespace */
-}/* CVC4 namespace */
+} // namespace main
+} // namespace CVC5
/** Actual Cvc4 driver functions **/
-int runCvc4(int argc, char* argv[], CVC4::Options&);
-void printUsage(CVC4::Options&, bool full = false);
+int runCvc4(int argc, char* argv[], CVC5::Options&);
+void printUsage(CVC5::Options&, bool full = false);
#endif /* CVC4__MAIN__MAIN_H */
#include "smt/smt_engine.h"
#include "util/safe_print.h"
-using CVC4::Exception;
+using CVC5::Exception;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace main {
/**
} // namespace signal_handlers
} // namespace main
-} // namespace CVC4
+} // namespace CVC5
#ifndef CVC4__MAIN__SIGNAL_HANDLERS_H
#define CVC4__MAIN__SIGNAL_HANDLERS_H
-namespace CVC4 {
+namespace CVC5 {
namespace main {
namespace signal_handlers {
} // namespace signal_handlers
} // namespace main
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__MAIN__SIGNAL_HANDLERS_H */
#include "signal_handlers.h"
-namespace CVC4 {
+namespace CVC5 {
namespace main {
#if HAVE_SETITIMER
}
} // namespace main
-} // namespace CVC4
+} // namespace CVC5
#include "options/options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace main {
/**
TimeLimit install_time_limit(const Options& opts);
} // namespace main
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__MAIN__TIME_LIMIT_H */
well as an OptionsHandler*.
void custom-notification(
- const std::string& option, CVC4::options::OptionsHandler* handler);
+ const std::string& option, CVC5::options::OptionsHandler* handler);
The name is provided so multiple options can use the same notification
implementation.
#include "options/option_exception.h"
-namespace CVC4 {
+namespace CVC5 {
namespace options {
template <template <class U> class Cmp>
not_equal(double d) : comparator<std::not_equal_to>(d) {}
};/* struct not_equal_to */
-}/* CVC4::options namespace */
-}/* CVC4 namespace */
+} // namespace options
+} // namespace CVC5
#endif /* CVC4__BASE_HANDLERS_H */
#ifndef CVC4__OPTIONS__DECISION_WEIGHT_H
#define CVC4__OPTIONS__DECISION_WEIGHT_H
-namespace CVC4 {
+namespace CVC5 {
namespace decision {
typedef uint64_t DecisionWeight;
-}/* CVC4::decision namespace */
-}/* CVC4 namespace */
+} // namespace decision
+} // namespace CVC5
#endif /* CVC4__OPTIONS__DECISION_WEIGHT_H */
#include <string>
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
std::vector<std::string> DidYouMean::getMatch(std::string input) {
/** Magic numbers */
return oss.str();
}
-} /* CVC4 namespace */
+} // namespace CVC5
#include <string>
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
class DidYouMean {
public:
Words d_words;
};
-} /*CVC4 namespace*/
+} // namespace CVC5
#include <iostream>
using namespace std;
-using namespace CVC4;
+using namespace CVC5;
set<string> getDebugTags();
set<string> getOptionStrings();
#include "base/exception.h"
#include "options/option_exception.h"
-namespace CVC4 {
+namespace CVC5 {
namespace language {
/** define the end points of smt2 languages */
std::stringstream ss;
ss << "Cannot map output language `" << language
<< "' to an input language.";
- throw CVC4::Exception(ss.str());
+ throw CVC5::Exception(ss.str());
}
}/* switch(language) */
}/* toInputLanguage() */
throw OptionException(std::string("unknown input language `" + language + "'"));
}/* toInputLanguage() */
-}/* CVC4::language namespace */
-}/* CVC4 namespace */
+} // namespace language
+} // namespace CVC5
#include "cvc4_export.h"
-namespace CVC4 {
+namespace CVC5 {
namespace language {
namespace input {
return out;
}
-}/* CVC4::language::input namespace */
+} // namespace input
namespace output {
return out;
}
-}/* CVC4::language::output namespace */
+} // namespace output
-}/* CVC4::language namespace */
+} // namespace language
typedef language::input::Language InputLanguage;
typedef language::output::Language OutputLanguage;
InputLanguage toInputLanguage(std::string language) CVC4_EXPORT;
OutputLanguage toOutputLanguage(std::string language) CVC4_EXPORT;
-}/* CVC4::language namespace */
-}/* CVC4 namespace */
+} // namespace language
+} // namespace CVC5
#endif /* CVC4__LANGUAGE_H */
#include "options/options_holder.h"
#include "base/check.h"
-namespace CVC4 {
+// clang-format off
+namespace CVC5 {
${accs}$
${modes}$
} // namespace options
-} // namespace CVC4
+} // namespace CVC5
+// clang-format on
#include "options/options.h"
+// clang-format off
${includes}$
-
${holder_spec}$
-
-namespace CVC4 {
-
+namespace CVC5 {
namespace options {
${modes}$
${specs}$
-
namespace options {
-
${inls}$
} // namespace options
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__OPTIONS__${id}$_H */
+//clang-format on
#include "lib/strtok_r.h"
#include "options/parser_options.h"
-namespace CVC4 {
+namespace CVC5 {
OstreamOpener::OstreamOpener(const char* channelName)
: d_channelName(channelName)
#endif /* HAVE_STRERROR_R */
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include <string>
#include <utility>
-namespace CVC4 {
+namespace CVC5 {
class OstreamOpener {
public:
std::string cvc4_errno_failreason();
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__OPEN_OSTREAM_H */
#include "options/option_exception.h"
-namespace CVC4 {
+namespace CVC5 {
const std::string OptionException::s_errPrefix = "Error in option parsing: ";
-} // namespace CVC4
+} // namespace CVC5
#include "base/exception.h"
#include "cvc4_export.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* Class representing an option-parsing exception such as badly-typed
* name is itself unrecognized, a UnrecognizedOptionException (a derived
* class, below) should be used instead.
*/
-class CVC4_EXPORT OptionException : public CVC4::Exception
+class CVC4_EXPORT OptionException : public CVC5::Exception
{
public:
- OptionException(const std::string& s) : CVC4::Exception(s_errPrefix + s) {}
+ OptionException(const std::string& s) : CVC5::Exception(s_errPrefix + s) {}
/**
* Get the error message without the prefix that is automatically added for
* Class representing an exception in option processing due to an
* unrecognized or unsupported option key.
*/
-class UnrecognizedOptionException : public CVC4::OptionException
+class UnrecognizedOptionException : public CVC5::OptionException
{
public:
- UnrecognizedOptionException() :
- CVC4::OptionException("Unrecognized informational or option key or setting") {
+ UnrecognizedOptionException()
+ : CVC5::OptionException(
+ "Unrecognized informational or option key or setting")
+ {
}
- UnrecognizedOptionException(const std::string& msg) :
- CVC4::OptionException("Unrecognized informational or option key or setting: " + msg) {
+ UnrecognizedOptionException(const std::string& msg)
+ : CVC5::OptionException(
+ "Unrecognized informational or option key or setting: " + msg)
+ {
}
}; /* class UnrecognizedOptionException */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__OPTION_EXCEPTION_H */
#include "options/option_exception.h"
#include "options/printer_modes.h"
-namespace CVC4 {
+namespace CVC5 {
namespace api {
class Solver;
namespace options {
struct OptionsHolder;
class OptionsHandler;
-}/* CVC4::options namespace */
+ } // namespace options
class OptionsListener;
std::vector<std::string>* nonoptions);
}; /* class Options */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__OPTIONS__OPTIONS_H */
#include "options/smt_options.h"
#include "options/theory_options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace options {
// helper functions
void OptionsHandler::setVerbosity(std::string option, int value)
{
if(Configuration::isMuzzledBuild()) {
- DebugChannel.setStream(&CVC4::null_os);
- TraceChannel.setStream(&CVC4::null_os);
- NoticeChannel.setStream(&CVC4::null_os);
- ChatChannel.setStream(&CVC4::null_os);
- MessageChannel.setStream(&CVC4::null_os);
- WarningChannel.setStream(&CVC4::null_os);
+ DebugChannel.setStream(&CVC5::null_os);
+ TraceChannel.setStream(&CVC5::null_os);
+ NoticeChannel.setStream(&CVC5::null_os);
+ ChatChannel.setStream(&CVC5::null_os);
+ MessageChannel.setStream(&CVC5::null_os);
+ WarningChannel.setStream(&CVC5::null_os);
} else {
if(value < 2) {
- ChatChannel.setStream(&CVC4::null_os);
+ ChatChannel.setStream(&CVC5::null_os);
} else {
ChatChannel.setStream(&std::cout);
}
if(value < 1) {
- NoticeChannel.setStream(&CVC4::null_os);
+ NoticeChannel.setStream(&CVC5::null_os);
} else {
NoticeChannel.setStream(&std::cout);
}
if(value < 0) {
- MessageChannel.setStream(&CVC4::null_os);
- WarningChannel.setStream(&CVC4::null_os);
+ MessageChannel.setStream(&CVC5::null_os);
+ WarningChannel.setStream(&CVC5::null_os);
} else {
MessageChannel.setStream(&std::cout);
WarningChannel.setStream(&std::cerr);
setVerbosity(option, options::verbosity());
}
-
-}/* CVC4::options namespace */
-}/* CVC4 namespace */
+} // namespace options
+} // namespace CVC5
#include "options/printer_modes.h"
#include "options/quantifiers_options.h"
-namespace CVC4 {
+namespace CVC5 {
class Options;
#endif
}
-}/* CVC4::options namespace */
-}/* CVC4 namespace */
+} // namespace options
+} // namespace CVC5
#endif /* CVC4__OPTIONS__OPTIONS_HANDLER_H */
#ifndef CVC4__OPTIONS__OPTIONS_HOLDER_H
#define CVC4__OPTIONS__OPTIONS_HOLDER_H
+// clang-format off
${headers_module}$
-
-namespace CVC4 {
+namespace CVC5 {
namespace options {
-struct OptionsHolder {
+struct OptionsHolder
+{
OptionsHolder();
${macros_module}$
-
-};/* struct OptionsHolder */
+}; /* struct OptionsHolder */
} // namespace options
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__OPTIONS__OPTIONS_HOLDER_H */
+// clang-format on
#include <string>
-namespace CVC4 {
+namespace CVC5 {
class OptionsListener
{
virtual void notifySetOption(const std::string& key) = 0;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__OPTIONS__OPTION_LISTENER_H */
#include "options/smt_options.h"
#include "options/uf_options.h"
-namespace CVC4 {
+namespace CVC5 {
// Get accessor functions.
InputLanguage Options::getInputLanguage() const {
}
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "options/options_handler.h"
#include "options/options_listener.h"
+// clang-format off
${headers_module}$
-
#include "options/options_holder.h"
#include "cvc4autoconfig.h"
#include "options/base_handlers.h"
${headers_handler}$
+using namespace CVC5;
+using namespace CVC5::options;
-using namespace CVC4;
-using namespace CVC4::options;
-
-namespace CVC4 {
+namespace CVC5 {
thread_local Options* Options::s_current = NULL;
}
};/* class OptionsGuard */
-}/* CVC4::options namespace */
+} // namespace options
/**
- * Parse argc/argv and put the result into a CVC4::Options.
+ * Parse argc/argv and put the result into a CVC5::Options.
* The return value is what's left of the command line (that is, the
* non-option arguments).
*
Debug("preemptGetopt") << "processing option " << c
<< " (`" << char(c) << "'), " << option << std::endl;
- switch(c) {
+ switch(c)
+ {
${options_handler}$
#undef USE_EARLY_TYPE_CHECKING_BY_DEFAULT
#undef DO_SEMANTIC_CHECKS_BY_DEFAULT
-} // namespace CVC4
+} // namespace CVC5
+// clang-format on
#include "options/printer_modes.h"
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, options::InstFormatMode mode)
{
return out;
}
-} // namespace CVC4
+} // namespace CVC5
#include <iostream>
-namespace CVC4 {
+namespace CVC5 {
namespace options {
/** Enumeration of inst_format modes (how to print models from get-model
std::ostream& operator<<(std::ostream& out, options::InstFormatMode mode);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PRINTER__MODEL_FORMAT_H */
#include "options/language.h"
#include "options/options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace language {
const int SetLanguage::s_iosIndex = std::ios_base::xalloc();
return out;
}
-}/* CVC4::language namespace */
-}/* CVC4 namespace */
+} // namespace language
+} // namespace CVC5
#include "cvc4_export.h"
#include "options/language.h"
-namespace CVC4 {
+namespace CVC5 {
namespace language {
/**
*/
std::ostream& operator<<(std::ostream& out, SetLanguage l) CVC4_EXPORT;
-}/* CVC4::language namespace */
-}/* CVC4 namespace */
+} // namespace language
+} // namespace CVC5
#endif /* CVC4__OPTIONS__SET_LANGUAGE_H */
#include "parser/tptp/tptp_input.h"
using namespace std;
-using namespace CVC4;
-using namespace CVC4::parser;
-using namespace CVC4::kind;
+using namespace CVC5;
+using namespace CVC5::parser;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
// These functions exactly wrap the antlr3 source inconsistencies.
d_parser->rec->mismatch;
}
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include "util/integer.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
/** Wrapper around an ANTLR3 input stream. */
return BitVector(sz, val);
}
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__ANTLR_INPUT_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
/// Report a recognition problem.
} // namespace parser
-} // namespace CVC4
+} // namespace CVC5
#include "base/check.h"
#include "base/output.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
static pANTLR3_INPUT_STREAM antlr3CreateLineBufferedStream(
static ANTLR3_UCHAR bufferedInputLA(pANTLR3_INT_STREAM is, ANTLR3_INT32 la) {
pANTLR3_INPUT_STREAM input = ((pANTLR3_INPUT_STREAM)(is->super));
- CVC4::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM line_buffered_input =
- (CVC4::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM)input;
+ CVC5::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM line_buffered_input =
+ (CVC5::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM)input;
uint8_t* result = line_buffered_input->line_buffer->getPtrWithOffset(
input->line, input->charPositionInLine, la - 1);
return (result != NULL) ? *result : ANTLR3_CHARSTREAM_EOF;
static void bufferedInputConsume(pANTLR3_INT_STREAM is) {
pANTLR3_INPUT_STREAM input = ((pANTLR3_INPUT_STREAM)(is->super));
- CVC4::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM line_buffered_input =
- (CVC4::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM)input;
+ CVC5::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM line_buffered_input =
+ (CVC5::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM)input;
uint8_t* current = line_buffered_input->line_buffer->getPtr(
input->line, input->charPositionInLine);
pANTLR3_INPUT_STREAM input = ((pANTLR3_INPUT_STREAM)(is->super));
// Check that we are not seeking backwards.
- Assert(!((CVC4::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM)input)
+ Assert(!((CVC5::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM)input)
->line_buffer->isPtrBefore(
(uint8_t*)seekPoint, input->line, input->charPositionInLine));
return input;
}
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include "parser/line_buffer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
typedef struct ANTLR3_LINE_BUFFERED_INPUT_STREAM {
pANTLR3_UINT8 name,
LineBuffer* line_buffer);
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__ANTLR_LINE_BUFFERED_INPUT_H */
#include "base/check.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
#ifdef ANTLR3_WINDOWS
return ((pANTLR3_TOKEN_STREAM)(is->super))->tokenSource->fileName;
}
-
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include <antlr3defs.h>
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
#ifdef __cplusplus
}/* extern "C" */
#endif
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__BOUNDED_TOKEN_BUFFER_H */
#include <antlr3interfaces.h>
#include "parser/bounded_token_factory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
static pANTLR3_COMMON_TOKEN
}
}
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#ifndef CVC4__PARSER__BOUNDED_TOKEN_FACTORY_H
#define CVC4__PARSER__BOUNDED_TOKEN_FACTORY_H
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
#ifdef __cplusplus
}/* extern "C" */
#endif
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__BOUNDED_TOKEN_FACTORY_H */
return pivot;
}/* findPivot() */
-CVC4::api::Term createPrecedenceTree(Parser* parser, api::Solver* solver,
- const std::vector<CVC4::api::Term>& expressions,
+CVC5::api::Term createPrecedenceTree(Parser* parser, api::Solver* solver,
+ const std::vector<CVC5::api::Term>& expressions,
const std::vector<unsigned>& operators,
unsigned startIndex, unsigned stopIndex) {
Assert(expressions.size() == operators.size() + 1);
//Debug("prec") << "pivot[" << startIndex << "," << stopIndex - 1 << "] at " << pivot << std::endl;
bool negate;
api::Kind k = getOperatorKind(operators[pivot], negate);
- CVC4::api::Term lhs = createPrecedenceTree(
+ CVC5::api::Term lhs = createPrecedenceTree(
parser, solver, expressions, operators, startIndex, pivot);
- CVC4::api::Term rhs = createPrecedenceTree(
+ CVC5::api::Term rhs = createPrecedenceTree(
parser, solver, expressions, operators, pivot + 1, stopIndex);
if (lhs.getSort().isSet())
}/* createPrecedenceTree() recursive variant */
api::Term createPrecedenceTree(Parser* parser, api::Solver* s,
- const std::vector<CVC4::api::Term>& expressions,
+ const std::vector<CVC5::api::Term>& expressions,
const std::vector<unsigned>& operators) {
if(Debug.isOn("prec") && operators.size() > 1) {
for(unsigned i = 0; i < expressions.size(); ++i) {
#include "smt/command.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
class Expr;
}/* CVC4 namespace */
}); \
})
-using namespace CVC4;
-using namespace CVC4::parser;
+using namespace CVC5;
+using namespace CVC5::parser;
/* These need to be macros so they can refer to the PARSER macro, which will be defined
* by ANTLR *after* this section. (If they were functions, PARSER would be undefined.) */
* Parses an expression.
* @return the parsed expression
*/
-parseExpr returns [CVC4::api::Term expr = CVC4::api::Term()]
+parseExpr returns [CVC5::api::Term expr = CVC5::api::Term()]
: formula[expr]
| EOF
;
* Parses a command (the whole benchmark)
* @return the command of the benchmark
*/
-parseCommand returns [CVC4::Command* cmd_return = NULL]
+parseCommand returns [CVC5::Command* cmd_return = NULL]
@declarations {
- std::unique_ptr<CVC4::Command> cmd;
+ std::unique_ptr<CVC5::Command> cmd;
}
@after {
cmd_return = cmd.release();
* Matches a command of the input. If a declaration, it will return an empty
* command.
*/
-command [std::unique_ptr<CVC4::Command>* cmd]
+command [std::unique_ptr<CVC5::Command>* cmd]
: ( mainCommand[cmd] SEMICOLON
| SEMICOLON
| LET_TOK { PARSER_STATE->pushScope(); }
}
;
-typeOrVarLetDecl[CVC4::parser::DeclarationCheck check]
+typeOrVarLetDecl[CVC5::parser::DeclarationCheck check]
options { backtrack = true; }
: letDecl | typeLetDecl[check]
;
-mainCommand[std::unique_ptr<CVC4::Command>* cmd]
+mainCommand[std::unique_ptr<CVC5::Command>* cmd]
@init {
api::Term f;
api::Term sexpr;
std::string id;
api::Sort t;
- std::vector<CVC4::api::DatatypeDecl> dts;
+ std::vector<CVC5::api::DatatypeDecl> dts;
Debug("parser-extra") << "command: " << AntlrInput::tokenText(LT(1)) << std::endl;
std::string s;
api::Term func;
std::vector<api::Term> formulas;
std::vector<std::vector<api::Term>> formals;
std::vector<std::string> ids;
- std::vector<CVC4::api::Sort> types;
+ std::vector<CVC5::api::Sort> types;
bool idCommaFlag = true;
bool formCommaFlag = true;
}
{ s = AntlrInput::tokenText($IDENTIFIER); }
;
-symbolicExpr[CVC4::api::Term& sexpr]
+symbolicExpr[CVC5::api::Term& sexpr]
@declarations {
std::string s;
std::vector<api::Term> children;
: simpleSymbolicExpr[s]
{ sexpr = SOLVER->mkString(PARSER_STATE->processAdHocStringEsc(s)); }
| LPAREN (symbolicExpr[sexpr] { children.push_back(sexpr); } )* RPAREN
- { sexpr = SOLVER->mkTerm(CVC4::api::SEXPR, children); }
+ { sexpr = SOLVER->mkTerm(CVC5::api::SEXPR, children); }
;
/**
* Match a top-level declaration.
*/
-toplevelDeclaration[std::unique_ptr<CVC4::Command>* cmd]
+toplevelDeclaration[std::unique_ptr<CVC5::Command>* cmd]
@init {
std::vector<std::string> ids;
api::Sort t;
/**
* A bound variable declaration.
*/
-boundVarDecl[std::vector<std::string>& ids, CVC4::api::Sort& t]
+boundVarDecl[std::vector<std::string>& ids, CVC5::api::Sort& t]
@init {
std::unique_ptr<Command> local_cmd;
}
: boundVarDecl[ids,t] ( COMMA boundVarDecl[ids,t] )*
;
-boundVarDeclsReturn[std::vector<CVC4::api::Term>& terms,
- std::vector<CVC4::api::Sort>& types]
+boundVarDeclsReturn[std::vector<CVC5::api::Term>& terms,
+ std::vector<CVC5::api::Sort>& types]
@init {
std::vector<std::string> ids;
api::Sort t;
: boundVarDeclReturn[terms,types] ( COMMA boundVarDeclReturn[terms,types] )*
;
-boundVarDeclReturn[std::vector<CVC4::api::Term>& terms,
- std::vector<CVC4::api::Sort>& types]
+boundVarDeclReturn[std::vector<CVC5::api::Term>& terms,
+ std::vector<CVC5::api::Sort>& types]
@init {
std::vector<std::string> ids;
api::Sort t;
* because type declarations are always top-level, except for
* type-lets, which don't use this rule.
*/
-declareTypes[std::unique_ptr<CVC4::Command>* cmd,
+declareTypes[std::unique_ptr<CVC5::Command>* cmd,
const std::vector<std::string>& idList]
@init {
api::Sort t;
* permitted and "cmd" is output. If topLevel is false, bound vars
* are created
*/
-declareVariables[std::unique_ptr<CVC4::Command>* cmd, CVC4::api::Sort& t,
+declareVariables[std::unique_ptr<CVC5::Command>* cmd, CVC5::api::Sort& t,
const std::vector<std::string>& idList, bool topLevel]
@init {
api::Term f;
* @param check what kinds of check to perform on the symbols
*/
identifierList[std::vector<std::string>& idList,
- CVC4::parser::DeclarationCheck check,
- CVC4::parser::SymbolType type]
+ CVC5::parser::DeclarationCheck check,
+ CVC5::parser::SymbolType type]
@init {
std::string id;
idList.clear();
* Matches an identifier and returns a string.
*/
identifier[std::string& id,
- CVC4::parser::DeclarationCheck check,
- CVC4::parser::SymbolType type]
+ CVC5::parser::DeclarationCheck check,
+ CVC5::parser::SymbolType type]
: IDENTIFIER
{ id = AntlrInput::tokenText($IDENTIFIER);
PARSER_STATE->checkDeclaration(id, check, type); }
* way; then you should trace through Parser::bindMutualDatatypeType()
* to figure out just what you're in for.
*/
-type[CVC4::api::Sort& t,
- CVC4::parser::DeclarationCheck check]
+type[CVC5::api::Sort& t,
+ CVC5::parser::DeclarationCheck check]
@init {
api::Sort t2;
bool lhs;
// there). The "type" rule above uses restictedTypePossiblyFunctionLHS
// directly in order to implement that; this rule allows a type list to
// parse but then issues an error.
-restrictedType[CVC4::api::Sort& t,
- CVC4::parser::DeclarationCheck check]
+restrictedType[CVC5::api::Sort& t,
+ CVC5::parser::DeclarationCheck check]
@init {
bool lhs;
}
* lhs is set to "true" on output if we have a list of types, so an
* ARROW must follow. An ARROW can always follow; lhs means it MUST.
*/
-restrictedTypePossiblyFunctionLHS[CVC4::api::Sort& t,
- CVC4::parser::DeclarationCheck check,
+restrictedTypePossiblyFunctionLHS[CVC5::api::Sort& t,
+ CVC5::parser::DeclarationCheck check,
bool& lhs]
@init {
api::Sort t2;
}
;
-parameterization[CVC4::parser::DeclarationCheck check,
- std::vector<CVC4::api::Sort>& params]
+parameterization[CVC5::parser::DeclarationCheck check,
+ std::vector<CVC5::api::Sort>& params]
@init {
api::Sort t;
}
| integer
;
-typeLetDecl[CVC4::parser::DeclarationCheck check]
+typeLetDecl[CVC5::parser::DeclarationCheck check]
@init {
api::Sort t;
std::string id;
*
* @return the expression representing the formula/term
*/
-formula[CVC4::api::Term& f]
+formula[CVC5::api::Term& f]
@init {
Debug("parser-extra") << "formula: " << AntlrInput::tokenText(LT(1)) << std::endl;
api::Term f2;
- std::vector<CVC4::api::Term> expressions;
+ std::vector<CVC5::api::Term> expressions;
std::vector<unsigned> operators;
unsigned op;
}
)
;
-morecomparisons[std::vector<CVC4::api::Term>& expressions,
+morecomparisons[std::vector<CVC5::api::Term>& expressions,
std::vector<unsigned>& operators] returns [size_t i = 0]
@init {
unsigned op;
: ( NOT_TOK { ++$n; } )*
;
-prefixFormula[CVC4::api::Term& f]
+prefixFormula[CVC5::api::Term& f]
@init {
std::vector<std::string> ids;
std::vector<api::Term> terms;
}
;
-instantiationPatterns[ CVC4::api::Term& expr ]
+instantiationPatterns[ CVC5::api::Term& expr ]
@init {
std::vector<api::Term> args;
api::Term f;
| AND_TOK
;
-comparison[CVC4::api::Term& f]
+comparison[CVC5::api::Term& f]
@init {
- std::vector<CVC4::api::Term> expressions;
+ std::vector<CVC5::api::Term> expressions;
std::vector<unsigned> operators;
unsigned op;
}
;
/** Parses an array/tuple/record assignment term. */
-term[CVC4::api::Term& f]
+term[CVC5::api::Term& f]
@init {
- std::vector<CVC4::api::Term> expressions;
+ std::vector<CVC5::api::Term> expressions;
std::vector<unsigned> operators;
unsigned op;
api::Sort t;
* Parses just part of the array assignment (and constructs
* the store terms).
*/
-arrayStore[CVC4::api::Term& f]
+arrayStore[CVC5::api::Term& f]
@init {
api::Term f2, k;
}
: LBRACKET formula[k] RBRACKET
- { f2 = MK_TERM(CVC4::api::SELECT, f, k); }
+ { f2 = MK_TERM(CVC5::api::SELECT, f, k); }
( ( arrayStore[f2]
| DOT ( tupleStore[f2]
| recordStore[f2] ) )
| ASSIGN_TOK term[f2] )
- { f = MK_TERM(CVC4::api::STORE, f, k, f2); }
+ { f = MK_TERM(CVC5::api::STORE, f, k, f2); }
;
/**
* Parses just part of the tuple assignment (and constructs
* the store terms).
*/
-tupleStore[CVC4::api::Term& f]
+tupleStore[CVC5::api::Term& f]
@init {
api::Term f2;
}
* Parses just part of the record assignment (and constructs
* the store terms).
*/
-recordStore[CVC4::api::Term& f]
+recordStore[CVC5::api::Term& f]
@init {
std::string id;
api::Term f2;
;
/** Parses a unary minus term. */
-uminusTerm[CVC4::api::Term& f]
+uminusTerm[CVC5::api::Term& f]
@init {
unsigned minusCount = 0;
}
while (minusCount > 0)
{
--minusCount;
- f = MK_TERM(CVC4::api::UMINUS, f);
+ f = MK_TERM(CVC5::api::UMINUS, f);
}
};
/** Parses bitvectors. Starts with binary operators @, &, and |. */
-bvBinaryOpTerm[CVC4::api::Term& f]
+bvBinaryOpTerm[CVC5::api::Term& f]
@init {
- std::vector<CVC4::api::Term> expressions;
+ std::vector<CVC5::api::Term> expressions;
std::vector<unsigned> operators;
unsigned op;
}
| BVAND_TOK
;
-bvNegTerm[CVC4::api::Term& f]
+bvNegTerm[CVC5::api::Term& f]
/* BV neg */
: BVNEG_TOK bvNegTerm[f]
{
- f = f.getSort().isSet() ? MK_TERM(CVC4::api::COMPLEMENT, f)
- : MK_TERM(CVC4::api::BITVECTOR_NOT, f);
+ f = f.getSort().isSet() ? MK_TERM(CVC5::api::COMPLEMENT, f)
+ : MK_TERM(CVC5::api::BITVECTOR_NOT, f);
}
| relationBinopTerm[f]
;
| JOIN_IMAGE_TOK
;
-relationBinopTerm[CVC4::api::Term& f]
+relationBinopTerm[CVC5::api::Term& f]
@init {
- std::vector<CVC4::api::Term> expressions;
+ std::vector<CVC5::api::Term> expressions;
std::vector<unsigned> operators;
unsigned op;
}
* brackets ], so we left-factor as much out as possible to make ANTLR
* happy.
*/
-postfixTerm[CVC4::api::Term& f]
+postfixTerm[CVC5::api::Term& f]
@init {
api::Term f2;
bool extract = false, left = false;
f = SOLVER->mkTerm(SOLVER->mkOp(api::BITVECTOR_EXTRACT,k1,k2), f);
} else {
/* array select */
- f = MK_TERM(CVC4::api::SELECT, f, f2);
+ f = MK_TERM(CVC5::api::SELECT, f, f2);
}
}
/* left- or right-shift */
)
)*
| FLOOR_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::TO_INTEGER, f); }
+ { f = MK_TERM(CVC5::api::TO_INTEGER, f); }
| IS_INTEGER_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::IS_INTEGER, f); }
+ { f = MK_TERM(CVC5::api::IS_INTEGER, f); }
| ABS_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::ABS, f); }
+ { f = MK_TERM(CVC5::api::ABS, f); }
| DIVISIBLE_TOK LPAREN formula[f] COMMA n=numeral RPAREN
- { f = MK_TERM(SOLVER->mkOp(CVC4::api::DIVISIBLE, n), f); }
+ { f = MK_TERM(SOLVER->mkOp(CVC5::api::DIVISIBLE, n), f); }
| DISTINCT_TOK LPAREN
formula[f] { args.push_back(f); }
( COMMA formula[f] { args.push_back(f); } )* RPAREN
{
f = (args.size() == 1) ? SOLVER->mkTrue()
- : MK_TERM(CVC4::api::DISTINCT, args);
+ : MK_TERM(CVC5::api::DISTINCT, args);
}
)
( typeAscription[f, t]
)?
;
-relationTerm[CVC4::api::Term& f]
+relationTerm[CVC5::api::Term& f]
/* relation terms */
: TRANSPOSE_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::TRANSPOSE, f); }
+ { f = MK_TERM(CVC5::api::TRANSPOSE, f); }
| TRANSCLOSURE_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::TCLOSURE, f); }
+ { f = MK_TERM(CVC5::api::TCLOSURE, f); }
| TUPLE_TOK LPAREN formula[f] RPAREN
{ std::vector<api::Sort> types;
std::vector<api::Term> args;
f = MK_TERM(api::APPLY_CONSTRUCTOR, args);
}
| IDEN_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::IDEN, f); }
+ { f = MK_TERM(CVC5::api::IDEN, f); }
| bvTerm[f]
;
-bvTerm[CVC4::api::Term& f]
+bvTerm[CVC5::api::Term& f]
@init {
api::Term f2;
std::vector<api::Term> args;
}
/* BV xor */
: BVXOR_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_XOR, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_XOR, f, f2); }
| BVNAND_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_NAND, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_NAND, f, f2); }
| BVNOR_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_NOR, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_NOR, f, f2); }
| BVCOMP_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_COMP, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_COMP, f, f2); }
| BVXNOR_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_XNOR, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_XNOR, f, f2); }
/* BV unary minus */
| BVUMINUS_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_NEG, f); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_NEG, f); }
/* BV addition */
| BVPLUS_TOK LPAREN k=numeral COMMA formula[f] { args.push_back(f); }
( COMMA formula[f2] { args.push_back(f2); } )+ RPAREN
for (unsigned i = 0; i < args.size(); ++ i) {
ENSURE_BV_SIZE(k, args[i]);
}
- f = MK_TERM(CVC4::api::BITVECTOR_PLUS, args);
+ f = MK_TERM(CVC5::api::BITVECTOR_PLUS, args);
}
/* BV subtraction */
| BVSUB_TOK LPAREN k=numeral COMMA formula[f] COMMA formula[f2] RPAREN
}
ENSURE_BV_SIZE(k, f);
ENSURE_BV_SIZE(k, f2);
- f = MK_TERM(CVC4::api::BITVECTOR_SUB, f, f2);
+ f = MK_TERM(CVC5::api::BITVECTOR_SUB, f, f2);
}
/* BV multiplication */
| BVMULT_TOK LPAREN k=numeral COMMA formula[f] COMMA formula[f2] RPAREN
}
ENSURE_BV_SIZE(k, f);
ENSURE_BV_SIZE(k, f2);
- f = MK_TERM(CVC4::api::BITVECTOR_MULT, f, f2);
+ f = MK_TERM(CVC5::api::BITVECTOR_MULT, f, f2);
}
/* BV unsigned division */
| BVUDIV_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_UDIV, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_UDIV, f, f2); }
/* BV signed division */
| BVSDIV_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_SDIV, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_SDIV, f, f2); }
/* BV unsigned remainder */
| BVUREM_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_UREM, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_UREM, f, f2); }
/* BV signed remainder */
| BVSREM_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_SREM, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_SREM, f, f2); }
/* BV signed modulo */
| BVSMOD_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_SMOD, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_SMOD, f, f2); }
/* BV left shift */
| BVSHL_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_SHL, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_SHL, f, f2); }
/* BV arithmetic right shift */
| BVASHR_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_ASHR, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_ASHR, f, f2); }
/* BV logical left shift */
| BVLSHR_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_LSHR, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_LSHR, f, f2); }
/* BV sign extension */
| SX_TOK LPAREN formula[f] COMMA k=numeral RPAREN
{ unsigned n = f.getSort().getBVSize();
/* BV comparisons */
| BVLT_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_ULT, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_ULT, f, f2); }
| BVLE_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_ULE, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_ULE, f, f2); }
| BVGT_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_UGT, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_UGT, f, f2); }
| BVGE_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_UGE, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_UGE, f, f2); }
| BVSLT_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_SLT, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_SLT, f, f2); }
| BVSLE_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_SLE, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_SLE, f, f2); }
| BVSGT_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_SGT, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_SGT, f, f2); }
| BVSGE_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::BITVECTOR_SGE, f, f2); }
+ { f = MK_TERM(CVC5::api::BITVECTOR_SGE, f, f2); }
| stringTerm[f]
;
-stringTerm[CVC4::api::Term& f]
+stringTerm[CVC5::api::Term& f]
@init {
api::Term f2;
api::Term f3;
/* String prefix operators */
: STRING_CONCAT_TOK LPAREN formula[f] { args.push_back(f); }
( COMMA formula[f2] { args.push_back(f2); } )+ RPAREN
- { f = MK_TERM(CVC4::api::STRING_CONCAT, args); }
+ { f = MK_TERM(CVC5::api::STRING_CONCAT, args); }
| STRING_LENGTH_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::STRING_LENGTH, f); }
+ { f = MK_TERM(CVC5::api::STRING_LENGTH, f); }
| STRING_CONTAINS_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::STRING_CONTAINS, f, f2); }
+ { f = MK_TERM(CVC5::api::STRING_CONTAINS, f, f2); }
| STRING_SUBSTR_TOK LPAREN formula[f] COMMA formula[f2] COMMA formula[f3] RPAREN
- { f = MK_TERM(CVC4::api::STRING_SUBSTR, f, f2, f3); }
+ { f = MK_TERM(CVC5::api::STRING_SUBSTR, f, f2, f3); }
| STRING_CHARAT_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::STRING_CHARAT, f, f2); }
+ { f = MK_TERM(CVC5::api::STRING_CHARAT, f, f2); }
| STRING_INDEXOF_TOK LPAREN formula[f] COMMA formula[f2] COMMA formula[f3] RPAREN
- { f = MK_TERM(CVC4::api::STRING_INDEXOF, f, f2, f3); }
+ { f = MK_TERM(CVC5::api::STRING_INDEXOF, f, f2, f3); }
| STRING_REPLACE_TOK LPAREN formula[f] COMMA formula[f2] COMMA formula[f3] RPAREN
- { f = MK_TERM(CVC4::api::STRING_REPLACE, f, f2, f3); }
+ { f = MK_TERM(CVC5::api::STRING_REPLACE, f, f2, f3); }
| STRING_REPLACE_ALL_TOK LPAREN formula[f] COMMA formula[f2] COMMA formula[f3] RPAREN
- { f = MK_TERM(CVC4::api::STRING_REPLACE_ALL, f, f2, f3); }
+ { f = MK_TERM(CVC5::api::STRING_REPLACE_ALL, f, f2, f3); }
| STRING_PREFIXOF_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::STRING_PREFIX, f, f2); }
+ { f = MK_TERM(CVC5::api::STRING_PREFIX, f, f2); }
| STRING_SUFFIXOF_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::STRING_SUFFIX, f, f2); }
+ { f = MK_TERM(CVC5::api::STRING_SUFFIX, f, f2); }
| STRING_STOI_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::STRING_TO_INT, f); }
+ { f = MK_TERM(CVC5::api::STRING_TO_INT, f); }
| STRING_ITOS_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::STRING_FROM_INT, f); }
+ { f = MK_TERM(CVC5::api::STRING_FROM_INT, f); }
| STRING_TO_REGEXP_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::STRING_TO_REGEXP, f); }
+ { f = MK_TERM(CVC5::api::STRING_TO_REGEXP, f); }
| STRING_TOLOWER_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::STRING_TOLOWER, f); }
+ { f = MK_TERM(CVC5::api::STRING_TOLOWER, f); }
| STRING_TOUPPER_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::STRING_TOUPPER, f); }
+ { f = MK_TERM(CVC5::api::STRING_TOUPPER, f); }
| STRING_REV_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::STRING_REV, f); }
+ { f = MK_TERM(CVC5::api::STRING_REV, f); }
| REGEXP_CONCAT_TOK LPAREN formula[f] { args.push_back(f); }
( COMMA formula[f2] { args.push_back(f2); } )+ RPAREN
- { f = MK_TERM(CVC4::api::REGEXP_CONCAT, args); }
+ { f = MK_TERM(CVC5::api::REGEXP_CONCAT, args); }
| REGEXP_UNION_TOK LPAREN formula[f] { args.push_back(f); }
( COMMA formula[f2] { args.push_back(f2); } )+ RPAREN
- { f = MK_TERM(CVC4::api::REGEXP_UNION, args); }
+ { f = MK_TERM(CVC5::api::REGEXP_UNION, args); }
| REGEXP_INTER_TOK LPAREN formula[f] { args.push_back(f); }
( COMMA formula[f2] { args.push_back(f2); } )+ RPAREN
- { f = MK_TERM(CVC4::api::REGEXP_INTER, args); }
+ { f = MK_TERM(CVC5::api::REGEXP_INTER, args); }
| REGEXP_STAR_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::REGEXP_STAR, f); }
+ { f = MK_TERM(CVC5::api::REGEXP_STAR, f); }
| REGEXP_PLUS_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::REGEXP_PLUS, f); }
+ { f = MK_TERM(CVC5::api::REGEXP_PLUS, f); }
| REGEXP_OPT_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::REGEXP_OPT, f); }
+ { f = MK_TERM(CVC5::api::REGEXP_OPT, f); }
| REGEXP_RANGE_TOK LPAREN formula[f] COMMA formula[f2] RPAREN
- { f = MK_TERM(CVC4::api::REGEXP_RANGE, f, f2); }
+ { f = MK_TERM(CVC5::api::REGEXP_RANGE, f, f2); }
| REGEXP_LOOP_TOK LPAREN formula[f] COMMA lo=numeral COMMA hi=numeral RPAREN
{
- api::Op lop = SOLVER->mkOp(CVC4::api::REGEXP_LOOP, lo, hi);
+ api::Op lop = SOLVER->mkOp(CVC5::api::REGEXP_LOOP, lo, hi);
f = MK_TERM(lop, f);
}
| REGEXP_COMPLEMENT_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::REGEXP_COMPLEMENT, f); }
+ { f = MK_TERM(CVC5::api::REGEXP_COMPLEMENT, f); }
| SEQ_UNIT_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::SEQ_UNIT, f); }
+ { f = MK_TERM(CVC5::api::SEQ_UNIT, f); }
| REGEXP_EMPTY_TOK
- { f = MK_TERM(CVC
4::api::REGEXP_EMPTY, std::vector<api::Term>()); }
+ { f = MK_TERM(CVC
5::api::REGEXP_EMPTY, std::vector<api::Term>()); }
| REGEXP_SIGMA_TOK
- { f = MK_TERM(CVC
4::api::REGEXP_SIGMA, std::vector<api::Term>()); }
+ { f = MK_TERM(CVC
5::api::REGEXP_SIGMA, std::vector<api::Term>()); }
/* string literal */
| str[s]
| setsTerm[f]
;
-setsTerm[CVC4::api::Term& f]
+setsTerm[CVC5::api::Term& f]
@init {
}
/* Sets prefix operators */
: SETS_CARD_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::CARD, f); }
+ { f = MK_TERM(CVC5::api::CARD, f); }
| SETS_CHOOSE_TOK LPAREN formula[f] RPAREN
- { f = MK_TERM(CVC4::api::CHOOSE, f); }
+ { f = MK_TERM(CVC5::api::CHOOSE, f); }
| simpleTerm[f]
;
/** Parses a simple term. */
-simpleTerm[CVC4::api::Term& f]
+simpleTerm[CVC5::api::Term& f]
@init {
std::string name;
std::vector<api::Term> args;
api::Sort dtype = f.getSort();
if(dtype.isConstructor() && dtype.getConstructorArity() == 0) {
// don't require parentheses, immediately turn it into an apply
- f = MK_TERM(CVC4::api::APPLY_CONSTRUCTOR, f);
+ f = MK_TERM(CVC5::api::APPLY_CONSTRUCTOR, f);
}
}
;
* Matches a type ascription.
* The f arg is the term to check (it is an input-only argument).
*/
-typeAscription[const CVC4::api::Term& f, CVC4::api::Sort& t]
+typeAscription[const CVC5::api::Term& f, CVC5::api::Sort& t]
@init {
}
: COLON COLON type[t,CHECK_DECLARED]
/**
* Matches an entry in a record literal.
*/
-recordEntry[std::string& name, CVC4::api::Term& ex]
+recordEntry[std::string& name, CVC5::api::Term& ex]
: identifier[name,CHECK_NONE,SYM_VARIABLE] ASSIGN_TOK formula[ex]
;
/**
* Parses an ITE term.
*/
-iteTerm[CVC4::api::Term& f]
+iteTerm[CVC5::api::Term& f]
@init {
std::vector<api::Term> args;
Debug("parser-extra") << "ite: " << AntlrInput::tokenText(LT(1)) << std::endl;
THEN_TOK formula[f] { args.push_back(f); }
iteElseTerm[f] { args.push_back(f); }
ENDIF_TOK
- { f = MK_TERM(CVC4::api::ITE, args); }
+ { f = MK_TERM(CVC5::api::ITE, args); }
;
/**
* Parses the else part of the ITE, i.e. ELSE f, or ELSIF b THEN f1 ...
*/
-iteElseTerm[CVC4::api::Term& f]
+iteElseTerm[CVC5::api::Term& f]
@init {
std::vector<api::Term> args;
Debug("parser-extra") << "else: " << AntlrInput::tokenText(LT(1)) << std::endl;
| ELSEIF_TOK iteCondition = formula[f] { args.push_back(f); }
THEN_TOK iteThen = formula[f] { args.push_back(f); }
iteElse = iteElseTerm[f] { args.push_back(f); }
- { f = MK_TERM(CVC4::api::ITE, args); }
+ { f = MK_TERM(CVC5::api::ITE, args); }
;
/**
* Parses a datatype definition
*/
-datatypeDef[std::vector<CVC4::api::DatatypeDecl>& datatypes]
+datatypeDef[std::vector<CVC5::api::DatatypeDecl>& datatypes]
@init {
std::string id, id2;
api::Sort t;
/**
* Parses a constructor defintion for type
*/
-constructorDef[CVC4::api::DatatypeDecl& type]
+constructorDef[CVC5::api::DatatypeDecl& type]
@init {
std::string id;
- std::unique_ptr<CVC4::api::DatatypeConstructorDecl> ctor;
+ std::unique_ptr<CVC5::api::DatatypeConstructorDecl> ctor;
}
: identifier[id,CHECK_UNDECLARED,SYM_SORT]
{
- ctor.reset(new CVC4::api::DatatypeConstructorDecl(
+ ctor.reset(new CVC5::api::DatatypeConstructorDecl(
SOLVER->mkDatatypeConstructorDecl(id)));
}
( LPAREN
}
;
-selector[std::unique_ptr<CVC4::api::DatatypeConstructorDecl>* ctor]
+selector[std::unique_ptr<CVC5::api::DatatypeConstructorDecl>* ctor]
@init {
std::string id;
api::Sort t, t2;
/**
* Similar to numeral but for arbitrary-precision, signed integer.
*/
-integer returns [CVC4::Rational k = 0]
+integer returns [CVC5::Rational k = 0]
: INTEGER_LITERAL
{ $k = AntlrInput::tokenToInteger($INTEGER_LITERAL); }
| MINUS_TOK INTEGER_LITERAL
#include "parser/cvc/cvc.h"
#include "smt/command.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
void Cvc::forceLogic(const std::string& logic)
}
} // namespace parser
-} // namespace CVC4
+} // namespace CVC5
#include "api/cvc4cpp.h"
#include "parser/parser.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
};
} // namespace parser
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PARSER__CVC_H */
#include "parser/cvc/CvcParser.h"
#include "parser/parser_exception.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
/* Use lookahead=3 */
}
*/
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include "parser/cvc/CvcLexer.h"
#include "parser/cvc/CvcParser.h"
-// extern void CvcParserSetAntlrParser(CVC4::parser::AntlrParser* newAntlrParser);
+// extern void CvcParserSetAntlrParser(CVC5::parser::AntlrParser*
+// newAntlrParser);
-namespace CVC4 {
+namespace CVC5 {
class Command;
class Expr;
}; // class CvcInput
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__CVC_INPUT_H */
using namespace std;
-using namespace CVC4;
-using namespace CVC4::parser;
-using namespace CVC4::kind;
+using namespace CVC5;
+using namespace CVC5::parser;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
InputStreamException::InputStreamException(const std::string& msg) :
return AntlrInput::newInput(lang, *inputStream);
}
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include "options/language.h"
#include "parser/parser_exception.h"
-namespace CVC4 {
+namespace CVC5 {
class Command;
}; /* class Input */
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__ANTLR_INPUT_H */
#include "base/check.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
LineBuffer::LineBuffer(std::istream* stream) : d_stream(stream) {}
}
} // namespace parser
-} // namespace CVC4
+} // namespace CVC5
#include <istream>
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
class LineBuffer {
};
} // namespace parser
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PARSER__LINE_BUFFER_H */
#include "base/exception.h"
#include "parser/memory_mapped_input_buffer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
extern "C" {
}/* extern "C" */
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include <antlr3input.h>
#include <string>
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
#ifdef __cplusplus
}/* extern "C" */
#endif
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__MEMORY_MAPPED_INPUT_BUFFER_H */
#include "parser/parse_op.h"
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& os, const ParseOp& p)
{
return os << out.str();
}
-} // namespace CVC4
+} // namespace CVC5
#include "api/cvc4cpp.h"
-namespace CVC4 {
+namespace CVC5 {
/** A parsed operator
*
std::ostream& operator<<(std::ostream& os, const ParseOp& p);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PARSER__PARSE_OP_H */
#include "smt/command.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
Parser::Parser(api::Solver* solver,
return d_solver->mkString(str);
}
-} /* CVC4::parser namespace */
-} /* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include "parser/parser_exception.h"
#include "util/unsafe_interrupt_exception.h"
-namespace CVC4 {
+namespace CVC5 {
// Forward declarations
class Command;
std::vector<unsigned> processAdHocStringEsc(const std::string& s);
}; /* class Parser */
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__PARSER_STATE_H */
#include "smt2/smt2.h"
#include "tptp/tptp.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
ParserBuilder::ParserBuilder(api::Solver* solver,
return *this;
}
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include "options/language.h"
#include "parser/input.h"
-namespace CVC4 {
+namespace CVC5 {
namespace api {
class Solver;
ParserBuilder& withForcedLogic(const std::string& logic);
}; /* class ParserBuilder */
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__PARSER_BUILDER_H */
#include "base/exception.h"
#include "cvc4_export.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
class CVC4_EXPORT ParserException : public Exception
}; /* class ParserEndOfFileException */
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__PARSER_EXCEPTION_H */
#include "parser/smt2/smt2.h"
#include "parser/antlr_input.h"
-using namespace CVC4;
-using namespace CVC4::parser;
+using namespace CVC5;
+using namespace CVC5::parser;
#undef PARSER_STATE
#define PARSER_STATE ((Smt2*)LEXER->super)
#include "parser/parser.h"
#include "smt/command.h"
-namespace CVC4 {
+namespace CVC5 {
namespace api {
class Term;
#include "util/integer.h"
#include "util/rational.h"
-using namespace CVC4;
-using namespace CVC4::parser;
+using namespace CVC5;
+using namespace CVC5::parser;
/* These need to be macros so they can refer to the PARSER macro, which
* will be defined by ANTLR *after* this section. (If they were functions,
* @return the parsed expression, or the Null Expr if we've reached the
* end of the input
*/
-parseExpr returns [CVC4::api::Term expr = CVC4::api::Term()]
+parseExpr returns [CVC5::api::Term expr = CVC5::api::Term()]
@declarations {
- CVC4::api::Term expr2;
+ CVC5::api::Term expr2;
}
: term[expr, expr2]
| EOF
* Parses a command
* @return the parsed command, or NULL if we've reached the end of the input
*/
-parseCommand returns [CVC4::Command* cmd_return = NULL]
+parseCommand returns [CVC5::Command* cmd_return = NULL]
@declarations {
- std::unique_ptr<CVC4::Command> cmd;
+ std::unique_ptr<CVC5::Command> cmd;
std::string name;
}
@after {
* @return the parsed SyGuS command, or NULL if we've reached the end of the
* input
*/
-parseSygus returns [CVC4::Command* cmd_return = NULL]
+parseSygus returns [CVC5::Command* cmd_return = NULL]
@declarations {
std::string name;
}
* Parse the internal portion of the command, ignoring the surrounding
* parentheses.
*/
-command [std::unique_ptr<CVC4::Command>* cmd]
+command [std::unique_ptr<CVC5::Command>* cmd]
@declarations {
std::string name;
std::vector<std::string> names;
- CVC4::api::Term expr, expr2;
- CVC4::api::Sort t;
- std::vector<CVC4::api::Term> terms;
+ CVC5::api::Term expr, expr2;
+ CVC5::api::Sort t;
+ std::vector<CVC5::api::Term> terms;
std::vector<api::Sort> sorts;
- std::vector<std::pair<std::string, CVC4::api::Sort> > sortedVarNames;
- std::vector<CVC4::api::Term> flattenVars;
+ std::vector<std::pair<std::string, CVC5::api::Sort> > sortedVarNames;
+ std::vector<CVC5::api::Term> flattenVars;
}
: /* set the logic */
SET_LOGIC_TOK symbol[name,CHECK_NONE,SYM_SORT]
}
;
-sygusCommand returns [std::unique_ptr<CVC4::Command> cmd]
+sygusCommand returns [std::unique_ptr<CVC5::Command> cmd]
@declarations {
- CVC4::api::Term expr, expr2, fun;
- CVC4::api::Sort t, range;
+ CVC5::api::Term expr, expr2, fun;
+ CVC5::api::Sort t, range;
std::vector<std::string> names;
- std::vector<std::pair<std::string, CVC4::api::Sort> > sortedVarNames;
- std::vector<CVC4::api::Term> sygusVars;
+ std::vector<std::pair<std::string, CVC5::api::Sort> > sortedVarNames;
+ std::vector<CVC5::api::Term> sygusVars;
std::string name;
bool isInv;
- CVC4::api::Grammar* grammar = nullptr;
+ CVC5::api::Grammar* grammar = nullptr;
}
: /* declare-var */
DECLARE_VAR_TOK { PARSER_STATE->checkThatLogicIsSet(); }
* The argument fun is a unique identifier to avoid naming clashes for the
* datatypes constructed by this call.
*/
-sygusGrammar[CVC4::api::Grammar*& ret,
- const std::vector<CVC4::api::Term>& sygusVars,
+sygusGrammar[CVC5::api::Grammar*& ret,
+ const std::vector<CVC5::api::Term>& sygusVars,
const std::string& fun]
@declarations
{
// the pre-declaration
- std::vector<std::pair<std::string, CVC4::api::Sort>> sortedVarNames;
+ std::vector<std::pair<std::string, CVC5::api::Sort>> sortedVarNames;
// non-terminal symbols of the grammar
- std::vector<CVC4::api::Term> ntSyms;
- CVC4::api::Sort t;
+ std::vector<CVC5::api::Term> ntSyms;
+ CVC5::api::Sort t;
std::string name;
- CVC4::api::Term e, e2;
+ CVC5::api::Term e, e2;
unsigned dtProcessed = 0;
}
:
}
;
-setInfoInternal[std::unique_ptr<CVC4::Command>* cmd]
+setInfoInternal[std::unique_ptr<CVC5::Command>* cmd]
@declarations {
std::string name;
api::Term sexpr;
}
;
-setOptionInternal[std::unique_ptr<CVC4::Command>* cmd]
+setOptionInternal[std::unique_ptr<CVC5::Command>* cmd]
@init {
std::string name;
api::Term sexpr;
}
;
-smt25Command[std::unique_ptr<CVC4::Command>* cmd]
+smt25Command[std::unique_ptr<CVC5::Command>* cmd]
@declarations {
std::string name;
std::string fname;
- CVC4::api::Term expr, expr2;
- std::vector<std::pair<std::string, CVC4::api::Sort> > sortedVarNames;
+ CVC5::api::Term expr, expr2;
+ std::vector<std::pair<std::string, CVC5::api::Sort> > sortedVarNames;
std::string s;
- CVC4::api::Sort t;
- CVC4::api::Term func;
- std::vector<CVC4::api::Term> bvs;
- std::vector<std::vector<std::pair<std::string, CVC4::api::Sort>>>
+ CVC5::api::Sort t;
+ CVC5::api::Term func;
+ std::vector<CVC5::api::Term> bvs;
+ std::vector<std::vector<std::pair<std::string, CVC5::api::Sort>>>
sortedVarNamesList;
- std::vector<std::vector<CVC4::api::Term>> flattenVarsList;
- std::vector<std::vector<CVC4::api::Term>> formals;
- std::vector<CVC4::api::Term> funcs;
- std::vector<CVC4::api::Term> func_defs;
- CVC4::api::Term aexpr;
- std::unique_ptr<CVC4::CommandSequence> seq;
+ std::vector<std::vector<CVC5::api::Term>> flattenVarsList;
+ std::vector<std::vector<CVC5::api::Term>> formals;
+ std::vector<CVC5::api::Term> funcs;
+ std::vector<CVC5::api::Term> func_defs;
+ CVC5::api::Term aexpr;
+ std::unique_ptr<CVC5::CommandSequence> seq;
std::vector<api::Sort> sorts;
- std::vector<CVC4::api::Term> flattenVars;
+ std::vector<CVC5::api::Term> flattenVars;
}
/* declare-const */
: DECLARE_CONST_TOK { PARSER_STATE->checkThatLogicIsSet(); }
}
;
-extendedCommand[std::unique_ptr<CVC4::Command>* cmd]
+extendedCommand[std::unique_ptr<CVC5::Command>* cmd]
@declarations {
std::vector<api::DatatypeDecl> dts;
- CVC4::api::Term e, e2;
- CVC4::api::Sort t, s;
+ CVC5::api::Term e, e2;
+ CVC5::api::Sort t, s;
std::string name;
std::vector<std::string> names;
- std::vector<CVC4::api::Term> terms;
+ std::vector<CVC5::api::Term> terms;
std::vector<api::Sort> sorts;
- std::vector<std::pair<std::string, CVC4::api::Sort> > sortedVarNames;
- std::unique_ptr<CVC4::CommandSequence> seq;
+ std::vector<std::pair<std::string, CVC5::api::Sort> > sortedVarNames;
+ std::unique_ptr<CVC5::CommandSequence> seq;
api::Grammar* g = nullptr;
}
/* Extended SMT-LIB set of commands syntax, not permitted in
{
PARSER_STATE->checkThatLogicIsSet();
PARSER_STATE->checkLogicAllowsFreeSorts();
- seq.reset(new CVC4::CommandSequence());
+ seq.reset(new CVC5::CommandSequence());
}
LPAREN_TOK
( symbol[name,CHECK_UNDECLARED,SYM_SORT]
{ cmd->reset(seq.release()); }
| DECLARE_FUNS_TOK { PARSER_STATE->checkThatLogicIsSet(); }
- { seq.reset(new CVC4::CommandSequence()); }
+ { seq.reset(new CVC5::CommandSequence()); }
LPAREN_TOK
( LPAREN_TOK symbol[name,CHECK_UNDECLARED,SYM_VARIABLE]
{ PARSER_STATE->checkUserSymbol(name); }
RPAREN_TOK
{ cmd->reset(seq.release()); }
| DECLARE_PREDS_TOK { PARSER_STATE->checkThatLogicIsSet(); }
- { seq.reset(new CVC4::CommandSequence()); }
+ { seq.reset(new CVC5::CommandSequence()); }
LPAREN_TOK
( LPAREN_TOK symbol[name,CHECK_UNDECLARED,SYM_VARIABLE]
{ PARSER_STATE->checkUserSymbol(name); }
)
;
-datatypeDefCommand[bool isCo, std::unique_ptr<CVC4::Command>* cmd]
+datatypeDefCommand[bool isCo, std::unique_ptr<CVC5::Command>* cmd]
@declarations {
std::vector<api::DatatypeDecl> dts;
std::string name;
datatypesDef[isCo, dnames, arities, cmd]
;
-datatypesDefCommand[bool isCo, std::unique_ptr<CVC4::Command>* cmd]
+datatypesDefCommand[bool isCo, std::unique_ptr<CVC5::Command>* cmd]
@declarations {
std::vector<api::DatatypeDecl> dts;
std::string name;
datatypesDef[bool isCo,
const std::vector<std::string>& dnames,
const std::vector<int>& arities,
- std::unique_ptr<CVC4::Command>* cmd]
+ std::unique_ptr<CVC5::Command>* cmd]
@declarations {
std::vector<api::DatatypeDecl> dts;
std::string name;
| KEYWORD { s = AntlrInput::tokenText($KEYWORD); }
;
-symbolicExpr[CVC4::api::Term& sexpr]
+symbolicExpr[CVC5::api::Term& sexpr]
@declarations {
std::string s;
std::vector<api::Term> children;
{ sexpr = SOLVER->mkString(PARSER_STATE->processAdHocStringEsc(s)); }
| LPAREN_TOK
( symbolicExpr[sexpr] { children.push_back(sexpr); } )* RPAREN_TOK
- { sexpr = SOLVER->mkTerm(CVC4::api::SEXPR, children); }
+ { sexpr = SOLVER->mkTerm(CVC5::api::SEXPR, children); }
;
/**
* Matches a term.
* @return the expression representing the term.
*/
-term[CVC4::api::Term& expr, CVC4::api::Term& expr2]
+term[CVC5::api::Term& expr, CVC5::api::Term& expr2]
@init {
api::Kind kind = api::NULL_EXPR;
- CVC4::api::Term f;
+ CVC5::api::Term f;
std::string name;
- CVC4::api::Sort type;
+ CVC5::api::Sort type;
ParseOp p;
}
: termNonVariable[expr, expr2]
* @return the expression expr representing the term or formula, and expr2, an
* optional annotation for expr (for instance, for attributed expressions).
*/
-termNonVariable[CVC4::api::Term& expr, CVC4::api::Term& expr2]
+termNonVariable[CVC5::api::Term& expr, CVC5::api::Term& expr2]
@init {
Debug("parser") << "term: " << AntlrInput::tokenText(LT(1)) << std::endl;
api::Kind kind = api::NULL_EXPR;
std::string name;
- std::vector<CVC4::api::Term> args;
- std::vector< std::pair<std::string, CVC4::api::Sort> > sortedVarNames;
- CVC4::api::Term bvl;
- CVC4::api::Term f, f2, f3;
+ std::vector<CVC5::api::Term> args;
+ std::vector< std::pair<std::string, CVC5::api::Sort> > sortedVarNames;
+ CVC5::api::Term bvl;
+ CVC5::api::Term f, f2, f3;
std::string attr;
- CVC4::api::Term attexpr;
- std::vector<CVC4::api::Term> patexprs;
- std::vector<CVC4::api::Term> matchcases;
+ CVC5::api::Term attexpr;
+ std::vector<CVC5::api::Term> patexprs;
+ std::vector<CVC5::api::Term> matchcases;
std::unordered_set<std::string> names;
- std::vector< std::pair<std::string, CVC4::api::Term> > binders;
- CVC4::api::Sort type;
- CVC4::api::Sort type2;
+ std::vector< std::pair<std::string, CVC5::api::Term> > binders;
+ CVC5::api::Sort type;
+ CVC5::api::Sort type2;
api::Term atomTerm;
ParseOp p;
std::vector<api::Sort> argTypes;
)*
RPAREN_TOK term[f3, f2] {
// make the match case
- std::vector<CVC4::api::Term> cargs;
+ std::vector<CVC5::api::Term> cargs;
cargs.push_back(f);
cargs.insert(cargs.end(),args.begin(),args.end());
api::Term c = MK_TERM(api::APPLY_CONSTRUCTOR,cargs);
* expression (3), which may involve disambiguating f based on type T if it is
* overloaded.
*/
-qualIdentifier[CVC4::ParseOp& p]
+qualIdentifier[CVC5::ParseOp& p]
@init {
api::Kind k;
std::string baseName;
- CVC4::api::Term f;
- CVC4::api::Sort type;
+ CVC5::api::Term f;
+ CVC5::api::Sort type;
}
: identifier[p]
| LPAREN_TOK AS_TOK
* (3) An expression expr.
* For examples, see documentation of qualIdentifier.
*/
-identifier[CVC4::ParseOp& p]
+identifier[CVC5::ParseOp& p]
@init {
- CVC4::api::Term f;
- CVC4::api::Term f2;
+ CVC5::api::Term f;
+ CVC5::api::Term f2;
std::vector<uint64_t> numerals;
}
: functionName[p.d_name, CHECK_NONE]
* Matches an atomic term (a term with no subterms).
* @return the expression expr representing the term or formula.
*/
-termAtomic[CVC4::api::Term& atomTerm]
+termAtomic[CVC5::api::Term& atomTerm]
@init {
- CVC4::api::Sort type;
- CVC4::api::Sort type2;
+ CVC5::api::Sort type;
+ CVC5::api::Sort type2;
std::string s;
std::vector<uint64_t> numerals;
}
/**
* Read attribute
*/
-attribute[CVC4::api::Term& expr, CVC4::api::Term& retExpr, std::string& attr]
+attribute[CVC5::api::Term& expr, CVC5::api::Term& retExpr, std::string& attr]
@init {
api::Term sexpr;
std::string s;
- CVC4::api::Term patexpr;
- std::vector<CVC4::api::Term> patexprs;
- CVC4::api::Term e2;
+ CVC5::api::Term patexpr;
+ std::vector<CVC5::api::Term> patexprs;
+ CVC5::api::Term e2;
bool hasValue = false;
}
: KEYWORD ( simpleSymbolicExprNoKeyword[s] { hasValue = true; } )?
* Matches a sequence of terms and puts them into the formulas
* vector.
* @param formulas the vector to fill with terms
- * @param expr an CVC4::api::Term reference for the elements of the sequence
+ * @param expr an CVC5::api::Term reference for the elements of the sequence
*/
-/* NOTE: We pass an CVC4::api::Term in here just to avoid allocating a fresh CVC4::api::Term every
+/* NOTE: We pass an CVC5::api::Term in here just to avoid allocating a fresh CVC5::api::Term every
* time through this rule. */
-termList[std::vector<CVC4::api::Term>& formulas, CVC4::api::Term& expr]
+termList[std::vector<CVC5::api::Term>& formulas, CVC5::api::Term& expr]
@declarations {
- CVC4::api::Term expr2;
+ CVC5::api::Term expr2;
}
: ( term[expr, expr2] { formulas.push_back(expr); } )+
;
}
;
-quantOp[CVC4::api::Kind& kind]
+quantOp[CVC5::api::Kind& kind]
@init {
Debug("parser") << "quant: " << AntlrInput::tokenText(LT(1)) << std::endl;
}
* Matches a (possibly undeclared) function symbol (returning the string)
* @param check what kind of check to do with the symbol
*/
-functionName[std::string& name, CVC4::parser::DeclarationCheck check]
+functionName[std::string& name, CVC5::parser::DeclarationCheck check]
: symbol[name,check,SYM_VARIABLE]
;
* Matches a sequence of sort symbols and fills them into the given
* vector.
*/
-sortList[std::vector<CVC4::api::Sort>& sorts]
+sortList[std::vector<CVC5::api::Sort>& sorts]
@declarations {
- CVC4::api::Sort t;
+ CVC5::api::Sort t;
}
: ( sortSymbol[t,CHECK_DECLARED] { sorts.push_back(t); } )*
;
-nonemptySortList[std::vector<CVC4::api::Sort>& sorts]
+nonemptySortList[std::vector<CVC5::api::Sort>& sorts]
@declarations {
- CVC4::api::Sort t;
+ CVC5::api::Sort t;
}
: ( sortSymbol[t,CHECK_DECLARED] { sorts.push_back(t); } )+
;
* Matches a sequence of (variable,sort) symbol pairs and fills them
* into the given vector.
*/
-sortedVarList[std::vector<std::pair<std::string, CVC4::api::Sort> >& sortedVars]
+sortedVarList[std::vector<std::pair<std::string, CVC5::api::Sort> >& sortedVars]
@declarations {
std::string name;
- CVC4::api::Sort t;
+ CVC5::api::Sort t;
}
: ( LPAREN_TOK symbol[name,CHECK_NONE,SYM_VARIABLE]
sortSymbol[t,CHECK_DECLARED] RPAREN_TOK
* Matches a sequence of (variable, sort) symbol pairs, registers them as bound
* variables, and returns a term corresponding to the list of pairs.
*/
-boundVarList[CVC4::api::Term& expr]
+boundVarList[CVC5::api::Term& expr]
@declarations {
- std::vector<std::pair<std::string, CVC4::api::Sort>> sortedVarNames;
+ std::vector<std::pair<std::string, CVC5::api::Sort>> sortedVarNames;
}
: LPAREN_TOK sortedVarList[sortedVarNames] RPAREN_TOK
{
- std::vector<CVC4::api::Term> args =
+ std::vector<CVC5::api::Term> args =
PARSER_STATE->bindBoundVars(sortedVarNames);
expr = MK_TERM(api::BOUND_VAR_LIST, args);
}
* Matches the sort symbol, which can be an arbitrary symbol.
* @param check the check to perform on the name
*/
-sortName[std::string& name, CVC4::parser::DeclarationCheck check]
+sortName[std::string& name, CVC5::parser::DeclarationCheck check]
: symbol[name,check,SYM_SORT]
;
-sortSymbol[CVC4::api::Sort& t, CVC4::parser::DeclarationCheck check]
+sortSymbol[CVC5::api::Sort& t, CVC5::parser::DeclarationCheck check]
@declarations {
std::string name;
- std::vector<CVC4::api::Sort> args;
+ std::vector<CVC5::api::Sort> args;
std::vector<uint64_t> numerals;
bool indexed = false;
}
* symbol[] rule below.
*/
symbolList[std::vector<std::string>& names,
- CVC4::parser::DeclarationCheck check,
- CVC4::parser::SymbolType type]
+ CVC5::parser::DeclarationCheck check,
+ CVC5::parser::SymbolType type]
@declarations {
std::string id;
}
* @param type the intended namespace for the symbol
*/
symbol[std::string& id,
- CVC4::parser::DeclarationCheck check,
- CVC4::parser::SymbolType type]
+ CVC5::parser::DeclarationCheck check,
+ CVC5::parser::SymbolType type]
: SIMPLE_SYMBOL
{ id = AntlrInput::tokenText($SIMPLE_SYMBOL);
if(!PARSER_STATE->isAbstractValue(id)) {
/**
* Parses a datatype definition
*/
-datatypeDef[bool isCo, std::vector<CVC4::api::DatatypeDecl>& datatypes,
- std::vector< CVC4::api::Sort >& params]
+datatypeDef[bool isCo, std::vector<CVC5::api::DatatypeDecl>& datatypes,
+ std::vector< CVC5::api::Sort >& params]
@init {
std::string id;
}
/**
* Parses a constructor defintion for type
*/
-constructorDef[CVC4::api::DatatypeDecl& type]
+constructorDef[CVC5::api::DatatypeDecl& type]
@init {
std::string id;
- CVC4::api::DatatypeConstructorDecl* ctor = NULL;
+ CVC5::api::DatatypeConstructorDecl* ctor = NULL;
}
: symbol[id,CHECK_NONE,SYM_VARIABLE]
{
}
;
-selector[CVC4::api::DatatypeConstructorDecl& ctor]
+selector[CVC5::api::DatatypeConstructorDecl& ctor]
@init {
std::string id;
- CVC4::api::Sort t, t2;
+ CVC5::api::Sort t, t2;
}
: symbol[id,CHECK_NONE,SYM_SORT] sortSymbol[t,CHECK_NONE]
{
#undef true
#undef false
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
Smt2::Smt2(api::Solver* solver,
}
} // namespace parser
-}/* CVC4 namespace */
+} // namespace CVC5
#include "theory/logic_info.h"
#include "util/abstract_value.h"
-namespace CVC4 {
+namespace CVC5 {
class Command;
}; /* class Smt2 */
} // namespace parser
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PARSER__SMT2_H */
#include "parser/smt2/Smt2Parser.h"
#include "parser/smt2/smt2.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
/* Use lookahead=2 */
return d_pSmt2Parser->parseExpr(d_pSmt2Parser);
}
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include "parser/smt2/Smt2Lexer.h"
#include "parser/smt2/Smt2Parser.h"
-// extern void Smt2ParserSetAntlrParser(CVC4::parser::AntlrParser* newAntlrParser);
+// extern void Smt2ParserSetAntlrParser(CVC5::parser::AntlrParser*
+// newAntlrParser);
-namespace CVC4 {
+namespace CVC5 {
class Command;
class Expr;
};/* class Smt2Input */
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__SMT2_INPUT_H */
#include "parser/smt2/Smt2Parser.h"
#include "parser/smt2/sygus_input.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
/* Use lookahead=2 */
return d_pSmt2Parser->parseExpr(d_pSmt2Parser);
}
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include "parser/smt2/Smt2Lexer.h"
#include "parser/smt2/Smt2Parser.h"
-// extern void Smt2ParserSetAntlrParser(CVC4::parser::AntlrParser* newAntlrParser);
+// extern void Smt2ParserSetAntlrParser(CVC5::parser::AntlrParser*
+// newAntlrParser);
-namespace CVC4 {
+namespace CVC5 {
class Command;
class Expr;
};/* class SygusInput */
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__SYGUS_INPUT_H */
#include "parser/tptp/tptp.h"
#include "parser/antlr_input.h"
-using namespace CVC4;
-using namespace CVC4::parser;
+using namespace CVC5;
+using namespace CVC5::parser;
/* These need to be macros so they can refer to the PARSER macro, which will be defined
* by ANTLR *after* this section. (If they were functions, PARSER would be undefined.) */
#include "util/integer.h"
#include "util/rational.h"
-using namespace CVC4;
-using namespace CVC4::parser;
+using namespace CVC5;
+using namespace CVC5::parser;
/* These need to be macros so they can refer to the PARSER macro, which will be defined
* by ANTLR *after* this section. (If they were functions, PARSER would be undefined.) */
/**
* Parses an expression.
- * @return the parsed expression, or the Null CVC4::api::Term if we've reached
+ * @return the parsed expression, or the Null CVC5::api::Term if we've reached
* the end of the input
*/
-parseExpr returns [CVC4::parser::tptp::myExpr expr]
+parseExpr returns [CVC5::parser::tptp::myExpr expr]
: cnfFormula[expr]
| EOF
;
* Parses a command
* @return the parsed command, or NULL if we've reached the end of the input
*/
-parseCommand returns [CVC4::Command* cmd = NULL]
+parseCommand returns [CVC5::Command* cmd = NULL]
@declarations {
- CVC4::api::Term expr;
+ CVC5::api::Term expr;
Tptp::FormulaRole fr;
std::string name, inclSymbol;
ParseOp p;
}
(COMMA_TOK anything*)? RPAREN_TOK DOT_TOK
{
- CVC4::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr, expr);
+ CVC5::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr, expr);
if( !aexpr.isNull() ){
// set the expression name (e.g. used with unsat core printing)
SYM_MAN->setExpressionName(aexpr, name, true);
{ PARSER_STATE->setCnf(false); PARSER_STATE->setFof(true); }
fofFormula[expr] (COMMA_TOK anything*)? RPAREN_TOK DOT_TOK
{
- CVC4::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr,expr);
+ CVC5::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr,expr);
if( !aexpr.isNull() ){
// set the expression name (e.g. used with unsat core printing)
SYM_MAN->setExpressionName(aexpr, name, true);
{ PARSER_STATE->setCnf(false); PARSER_STATE->setFof(false); }
tffFormula[expr] (COMMA_TOK anything*)?
{
- CVC4::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr,expr);
+ CVC5::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr,expr);
if( !aexpr.isNull() ){
// set the expression name (e.g. used with unsat core printing)
SYM_MAN->setExpressionName(aexpr, name, true);
PARSER_STATE->parseError("Top level expression must be a formula");
}
expr = p.d_expr;
- CVC4::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr, expr);
+ CVC5::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr, expr);
if (!aexpr.isNull())
{
// set the expression name (e.g. used with unsat core printing)
{
CommandSequence* seq = new CommandSequence();
// assert that all distinct constants are distinct
- CVC4::api::Term aexpr = PARSER_STATE->getAssertionDistinctConstants();
+ CVC5::api::Term aexpr = PARSER_STATE->getAssertionDistinctConstants();
if( !aexpr.isNull() )
{
seq->addCommand(new AssertCommand(aexpr, false));
;
/* Parse a formula Role */
-formulaRole[CVC4::parser::Tptp::FormulaRole& role]
+formulaRole[CVC5::parser::Tptp::FormulaRole& role]
: LOWER_WORD
{
std::string r = AntlrInput::tokenText($LOWER_WORD);
/* It can parse a little more than the cnf grammar: false and true can appear.
* Normally only false can appear and only at top level. */
-cnfFormula[CVC4::api::Term& expr]
+cnfFormula[CVC5::api::Term& expr]
: LPAREN_TOK cnfDisjunction[expr] RPAREN_TOK
| cnfDisjunction[expr]
;
-cnfDisjunction[CVC4::api::Term& expr]
+cnfDisjunction[CVC5::api::Term& expr]
@declarations {
std::vector<api::Term> args;
}
}
;
-cnfLiteral[CVC4::api::Term& expr]
+cnfLiteral[CVC5::api::Term& expr]
: atomicFormula[expr]
| NOT_TOK atomicFormula[expr] { expr = MK_TERM(api::NOT, expr); }
;
-atomicFormula[CVC4::api::Term& expr]
+atomicFormula[CVC5::api::Term& expr]
@declarations {
- CVC4::api::Term expr2;
+ CVC5::api::Term expr2;
std::string name;
- std::vector<CVC4::api::Term> args;
+ std::vector<CVC5::api::Term> args;
bool equal;
ParseOp p;
}
| definedProp[expr]
;
-thfAtomicFormula[CVC4::ParseOp& p]
+thfAtomicFormula[CVC5::ParseOp& p]
@declarations {
- CVC4::api::Term expr2;
+ CVC5::api::Term expr2;
std::string name;
- std::vector<CVC4::api::Term> args;
+ std::vector<CVC5::api::Term> args;
bool equal;
}
: atomicWord[p.d_name] (LPAREN_TOK arguments[args] RPAREN_TOK)?
//%----Using <plain_term> removes a reduce/reduce ambiguity in lex/yacc.
//%----Note: "defined" means a word starting with one $ and "system" means $$.
-definedProp[CVC4::api::Term& expr]
+definedProp[CVC5::api::Term& expr]
: TRUE_TOK { expr = SOLVER->mkTrue(); }
| FALSE_TOK { expr = SOLVER->mkFalse(); }
;
-definedPred[CVC4::ParseOp& p]
+definedPred[CVC5::ParseOp& p]
: '$less'
{
p.d_kind = api::LT;
}
;
-thfDefinedPred[CVC4::ParseOp& p]
+thfDefinedPred[CVC5::ParseOp& p]
: '$less'
{
p.d_kind = api::LT;
RPAREN_TOK
;
-definedFun[CVC4::ParseOp& p]
+definedFun[CVC5::ParseOp& p]
@declarations {
bool remainder = false;
}
| DISEQUAL_TOK { equal = false; }
;
-term[CVC4::api::Term& expr]
+term[CVC5::api::Term& expr]
: functionTerm[expr]
| conditionalTerm[expr]
| simpleTerm[expr]
| letTerm[expr]
;
-letTerm[CVC4::api::Term& expr]
+letTerm[CVC5::api::Term& expr]
@declarations {
- CVC4::api::Term lhs, rhs;
+ CVC5::api::Term lhs, rhs;
}
: '$let_ft' LPAREN_TOK { PARSER_STATE->pushScope(); }
tffLetFormulaDefn[lhs, rhs] COMMA_TOK
;
/* Not an application */
-simpleTerm[CVC4::api::Term& expr]
+simpleTerm[CVC5::api::Term& expr]
: variable[expr]
| NUMBER { expr = PARSER_STATE->d_tmp_expr; }
| DISTINCT_OBJECT { expr = PARSER_STATE->convertStrToUnsorted(AntlrInput::tokenText($DISTINCT_OBJECT)); }
;
/* Not an application */
-thfSimpleTerm[CVC4::api::Term& expr]
+thfSimpleTerm[CVC5::api::Term& expr]
: NUMBER { expr = PARSER_STATE->d_tmp_expr; }
| DISTINCT_OBJECT
{
}
;
-functionTerm[CVC4::api::Term& expr]
+functionTerm[CVC5::api::Term& expr]
@declarations {
- std::vector<CVC4::api::Term> args;
+ std::vector<CVC5::api::Term> args;
ParseOp p;
}
: plainTerm[expr]
}
;
-conditionalTerm[CVC4::api::Term& expr]
+conditionalTerm[CVC5::api::Term& expr]
@declarations {
- CVC4::api::Term expr2, expr3;
+ CVC5::api::Term expr2, expr3;
}
: '$ite_t' LPAREN_TOK tffLogicFormula[expr] COMMA_TOK term[expr2] COMMA_TOK term[expr3] RPAREN_TOK
{ expr = MK_TERM(api::ITE, expr, expr2, expr3); }
;
-plainTerm[CVC4::api::Term& expr]
+plainTerm[CVC5::api::Term& expr]
@declarations {
std::string name;
std::vector<api::Term> args;
}
;
-arguments[std::vector<CVC4::api::Term>& args]
+arguments[std::vector<CVC5::api::Term>& args]
@declarations {
- CVC4::api::Term expr;
+ CVC5::api::Term expr;
}
:
term[expr] { args.push_back(expr); } ( COMMA_TOK term[expr] { args.push_back(expr); } )*
;
-variable[CVC4::api::Term& expr]
+variable[CVC5::api::Term& expr]
: UPPER_WORD
{
std::string name = AntlrInput::tokenText($UPPER_WORD);
/*******/
/* FOF */
-fofFormula[CVC4::api::Term& expr] : fofLogicFormula[expr] ;
+fofFormula[CVC5::api::Term& expr] : fofLogicFormula[expr] ;
-fofLogicFormula[CVC4::api::Term& expr]
+fofLogicFormula[CVC5::api::Term& expr]
@declarations {
tptp::NonAssoc na;
- std::vector< CVC4::api::Term > args;
- CVC4::api::Term expr2;
+ std::vector< CVC5::api::Term > args;
+ CVC5::api::Term expr2;
}
: fofUnitaryFormula[expr]
( // Non-associative: <=> <~> ~& ~|
)?
;
-fofUnitaryFormula[CVC4::api::Term& expr]
+fofUnitaryFormula[CVC5::api::Term& expr]
@declarations {
api::Kind kind;
- std::vector< CVC4::api::Term > bv;
+ std::vector< CVC5::api::Term > bv;
}
: atomicFormula[expr]
| LPAREN_TOK fofLogicFormula[expr] RPAREN_TOK
}
;
-bindvariable[CVC4::api::Term& expr]
+bindvariable[CVC5::api::Term& expr]
: UPPER_WORD
{ std::string name = AntlrInput::tokenText($UPPER_WORD);
expr = PARSER_STATE->bindBoundVar(name, PARSER_STATE->d_unsorted);
}
;
-fofBinaryNonAssoc[CVC4::parser::tptp::NonAssoc& na]
+fofBinaryNonAssoc[CVC5::parser::tptp::NonAssoc& na]
: IFF_TOK { na = tptp::NA_IFF; }
| REVIFF_TOK { na = tptp::NA_REVIFF; }
| REVOR_TOK { na = tptp::NA_REVOR; }
| REVIMPLIES_TOK { na = tptp::NA_REVIMPLIES; }
;
-folQuantifier[CVC4::api::Kind& kind]
+folQuantifier[CVC5::api::Kind& kind]
: FORALL_TOK { kind = api::FORALL; }
| EXISTS_TOK { kind = api::EXISTS; }
;
/*******/
/* THF */
-thfQuantifier[CVC4::api::Kind& kind]
+thfQuantifier[CVC5::api::Kind& kind]
: FORALL_TOK { kind = api::FORALL; }
| EXISTS_TOK { kind = api::EXISTS; }
| LAMBDA_TOK { kind = api::LAMBDA; }
}
;
-thfAtomTyping[CVC4::Command*& cmd]
+thfAtomTyping[CVC5::Command*& cmd]
// for now only supports mapping types (i.e. no applied types)
@declarations {
- CVC4::api::Term expr;
- CVC4::api::Sort type;
+ CVC5::api::Term expr;
+ CVC5::api::Sort type;
std::string name;
}
: LPAREN_TOK thfAtomTyping[cmd] RPAREN_TOK
else
{
// as of yet, it's undeclared
- CVC4::api::Term freshExpr;
+ CVC5::api::Term freshExpr;
if (type.isFunction())
{
freshExpr = PARSER_STATE->bindVar(name, type);
)
;
-thfLogicFormula[CVC4::ParseOp& p]
+thfLogicFormula[CVC5::ParseOp& p]
@declarations {
tptp::NonAssoc na;
- std::vector<CVC4::api::Term> args;
+ std::vector<CVC5::api::Term> args;
std::vector<ParseOp> p_args;
- CVC4::api::Term expr2;
+ CVC5::api::Term expr2;
bool equal;
ParseOp p1;
}
)?
;
-thfTupleForm[std::vector<CVC4::api::Term>& args]
+thfTupleForm[std::vector<CVC5::api::Term>& args]
@declarations {
ParseOp p;
}
)+
;
-thfUnitaryFormula[CVC4::ParseOp& p]
+thfUnitaryFormula[CVC5::ParseOp& p]
@declarations {
api::Kind kind;
- std::vector< CVC4::api::Term > bv;
- CVC4::api::Term expr;
+ std::vector< CVC5::api::Term > bv;
+ CVC5::api::Term expr;
bool equal;
ParseOp p1;
}
/*******/
/* TFF */
-tffFormula[CVC4::api::Term& expr] : tffLogicFormula[expr];
+tffFormula[CVC5::api::Term& expr] : tffLogicFormula[expr];
-tffTypedAtom[CVC4::Command*& cmd]
+tffTypedAtom[CVC5::Command*& cmd]
@declarations {
- CVC4::api::Term expr;
- CVC4::api::Sort type;
+ CVC5::api::Term expr;
+ CVC5::api::Sort type;
std::string name;
}
: LPAREN_TOK tffTypedAtom[cmd] RPAREN_TOK
}
} else {
// as yet, it's undeclared
- CVC4::api::Term aexpr = PARSER_STATE->bindVar(name, type);
+ CVC5::api::Term aexpr = PARSER_STATE->bindVar(name, type);
cmd = new DeclareFunctionCommand(name, aexpr, type);
}
}
)
;
-tffLogicFormula[CVC4::api::Term& expr]
+tffLogicFormula[CVC5::api::Term& expr]
@declarations {
tptp::NonAssoc na;
- std::vector< CVC4::api::Term > args;
- CVC4::api::Term expr2;
+ std::vector< CVC5::api::Term > args;
+ CVC5::api::Term expr2;
}
: tffUnitaryFormula[expr]
( // Non Assoc <=> <~> ~& ~|
)?
;
-tffUnitaryFormula[CVC4::api::Term& expr]
+tffUnitaryFormula[CVC5::api::Term& expr]
@declarations {
api::Kind kind;
- std::vector< CVC4::api::Term > bv;
- CVC4::api::Term lhs, rhs;
+ std::vector< CVC5::api::Term > bv;
+ CVC5::api::Term lhs, rhs;
}
: atomicFormula[expr]
| LPAREN_TOK tffLogicFormula[expr] RPAREN_TOK
RPAREN_TOK
;
-tffLetTermDefn[CVC4::api::Term& lhs, CVC4::api::Term& rhs]
+tffLetTermDefn[CVC5::api::Term& lhs, CVC5::api::Term& rhs]
@declarations {
- std::vector<CVC4::api::Term> bvlist;
+ std::vector<CVC5::api::Term> bvlist;
}
: (FORALL_TOK LBRACK_TOK tffVariableList[bvlist] RBRACK_TOK COLON_TOK)*
tffLetTermBinding[bvlist, lhs, rhs]
;
-tffLetTermBinding[std::vector<CVC4::api::Term> & bvlist,
- CVC4::api::Term& lhs,
- CVC4::api::Term& rhs]
+tffLetTermBinding[std::vector<CVC5::api::Term> & bvlist,
+ CVC5::api::Term& lhs,
+ CVC5::api::Term& rhs]
: term[lhs] EQUAL_TOK term[rhs]
{
PARSER_STATE->checkLetBinding(bvlist, lhs, rhs, false);
| LPAREN_TOK tffLetTermBinding[bvlist, lhs, rhs] RPAREN_TOK
;
-tffLetFormulaDefn[CVC4::api::Term& lhs, CVC4::api::Term& rhs]
+tffLetFormulaDefn[CVC5::api::Term& lhs, CVC5::api::Term& rhs]
@declarations {
- std::vector<CVC4::api::Term> bvlist;
+ std::vector<CVC5::api::Term> bvlist;
}
: (FORALL_TOK LBRACK_TOK tffVariableList[bvlist] RBRACK_TOK COLON_TOK)*
tffLetFormulaBinding[bvlist, lhs, rhs]
;
-tffLetFormulaBinding[std::vector<CVC4::api::Term> & bvlist,
- CVC4::api::Term& lhs,
- CVC4::api::Term& rhs]
+tffLetFormulaBinding[std::vector<CVC5::api::Term> & bvlist,
+ CVC5::api::Term& lhs,
+ CVC5::api::Term& rhs]
: atomicFormula[lhs] IFF_TOK tffUnitaryFormula[rhs]
{
| LPAREN_TOK tffLetFormulaBinding[bvlist, lhs, rhs] RPAREN_TOK
;
-thfBindVariable[CVC4::api::Term& expr]
+thfBindVariable[CVC5::api::Term& expr]
@declarations {
std::string name;
- CVC4::api::Sort type = PARSER_STATE->d_unsorted;
+ CVC5::api::Sort type = PARSER_STATE->d_unsorted;
}
: UPPER_WORD
{ name = AntlrInput::tokenText($UPPER_WORD); }
;
-tffbindvariable[CVC4::api::Term& expr]
+tffbindvariable[CVC5::api::Term& expr]
@declarations {
- CVC4::api::Sort type = PARSER_STATE->d_unsorted;
+ CVC5::api::Sort type = PARSER_STATE->d_unsorted;
}
: UPPER_WORD
( COLON_TOK parseType[type] )?
// bvlist is accumulative; it can already contain elements
// on the way in, which are left undisturbed
-tffVariableList[std::vector<CVC4::api::Term>& bvlist]
+tffVariableList[std::vector<CVC5::api::Term>& bvlist]
@declarations {
- CVC4::api::Term e;
+ CVC5::api::Term e;
}
: tffbindvariable[e] { bvlist.push_back(e); }
( COMMA_TOK tffbindvariable[e] { bvlist.push_back(e); } )*
;
-parseThfType[CVC4::api::Sort& type]
+parseThfType[CVC5::api::Sort& type]
// assumes only mapping types (arrows), no tuple type
@declarations {
- std::vector<CVC4::api::Sort> sorts;
+ std::vector<CVC5::api::Sort> sorts;
}
: thfType[type] { sorts.push_back(type); }
(
}
;
-thfType[CVC4::api::Sort& type]
+thfType[CVC5::api::Sort& type]
// assumes only mapping types (arrows), no tuple type
: simpleType[type]
| LPAREN_TOK parseThfType[type] RPAREN_TOK
| LBRACK_TOK { UNSUPPORTED("Tuple types"); } parseThfType[type] RBRACK_TOK
;
-parseType[CVC4::api::Sort & type]
+parseType[CVC5::api::Sort & type]
@declarations
{
- std::vector<CVC4::api::Sort> v;
+ std::vector<CVC5::api::Sort> v;
}
: simpleType[type]
| ( simpleType[type] { v.push_back(type); }
;
// non-function types
-simpleType[CVC4::api::Sort& type]
+simpleType[CVC5::api::Sort& type]
@declarations {
std::string name;
}
#undef true
#undef false
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
Tptp::Tptp(api::Solver* solver,
{
parseError("malformed let: LHS must be formula");
}
- for (const CVC4::api::Term& var : vars)
+ for (const CVC5::api::Term& var : vars)
{
if (var.hasOp())
{
}
}
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include "parser/parser.h"
#include "util/hash.h"
-namespace CVC4 {
+namespace CVC5 {
class Command;
* Just exists to provide the uintptr_t constructor that ANTLR
* requires.
*/
-struct myExpr : public CVC4::api::Term
+struct myExpr : public CVC5::api::Term
{
- myExpr() : CVC4::api::Term() {}
- myExpr(void*) : CVC4::api::Term() {}
- myExpr(const CVC4::api::Term& e) : CVC4::api::Term(e) {}
- myExpr(const myExpr& e) : CVC4::api::Term(e) {}
+ myExpr() : CVC5::api::Term() {}
+ myExpr(void*) : CVC5::api::Term() {}
+ myExpr(const CVC5::api::Term& e) : CVC5::api::Term(e) {}
+ myExpr(const myExpr& e) : CVC5::api::Term(e) {}
}; /* struct myExpr*/
enum NonAssoc {
NA_REVAND,
};
-}/* CVC4::parser::tptp namespace */
+} // namespace tptp
-
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__TPTP_INPUT_H */
#include "parser/tptp/TptpParser.h"
#include "parser/tptp/tptp.h"
-namespace CVC4 {
+namespace CVC5 {
namespace parser {
/* Use lookahead=2 */
return d_pTptpParser->parseExpr(d_pTptpParser);
}
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#include "parser/tptp/TptpLexer.h"
#include "parser/tptp/TptpParser.h"
-// extern void TptpParserSetAntlrParser(CVC4::parser::AntlrParser* newAntlrParser);
+// extern void TptpParserSetAntlrParser(CVC5::parser::AntlrParser*
+// newAntlrParser);
-namespace CVC4 {
+namespace CVC5 {
class Command;
class Expr;
};/* class TptpInput */
-}/* CVC4::parser namespace */
-}/* CVC4 namespace */
+} // namespace parser
+} // namespace CVC5
#endif /* CVC4__PARSER__TPTP_INPUT_H */
#include "theory/builtin/proof_checker.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
AssertionPipeline::AssertionPipeline()
}
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofGenerator;
namespace smt {
}; /* class AssertionPipeline */
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__ASSERTION_PIPELINE_H */
#include "preprocessing/assertion_pipeline.h"
#include "preprocessing/preprocessing_pass_context.h"
-using namespace CVC4;
-using namespace CVC4::theory;
+using namespace CVC5;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "theory/logic_info.h"
#include "theory/substitutions.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__ACKERMANN_H */
#include "theory/rewriter.h"
#include "theory/substitutions.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
class PreprocessingPassContext;
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
-using namespace CVC4::theory;
+using namespace CVC5::theory;
BoolToBV::BoolToBV(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "bool-to-bv"), d_statistics()
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__BOOL_TO_BV_H */
#include "theory/rewriter.h"
#include "theory/theory_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
-using namespace CVC4::theory;
+using namespace CVC5::theory;
BvAbstraction::BvAbstraction(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "bv-abstraction"){};
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__BV_ABSTRACTION_H */
#include "theory/theory_engine.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__BV_EAGER_ATOMS_H */
#include "theory/rewriter.h"
#include "util/bitvector.h"
-using namespace CVC4;
-using namespace CVC4::theory;
-using namespace CVC4::theory::bv;
+using namespace CVC5;
+using namespace CVC5::theory;
+using namespace CVC5::theory::bv;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
{
Node a = assertions.back();
assertions.pop_back();
- CVC4::Kind k = a.getKind();
+ CVC5::Kind k = a.getKind();
if (k == kind::AND)
{
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/bv/theory_bv_rewrite_rules_simplification.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
using NodeMap = std::unordered_map<Node, Node, NodeHashFunction>;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
namespace {
return PreprocessingPassResult::NO_CONFLICT;
}
+} // namespace passes
+} // namespace preprocessing
-}/* CVC4::theory::bv namespace */
-}/* CVC4::theory namespace */
-
-}/* CVC4 namespace */
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__BV_INTRO_POW2_H */
#include "theory/rewriter.h"
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
BVToBool::BVToBool(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "bv-to-bool"),
} // passes
} // Preprocessing
-} // CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__BV_TO_BOOL_H */
#include "theory/bv/theory_bv_rewrite_rules_simplification.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace CVC4::theory;
-using namespace CVC4::theory::bv;
+using namespace CVC5::theory;
+using namespace CVC5::theory::bv;
namespace {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
#include "theory/arith/nl/iand_utils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* __CVC4__PREPROCESSING__PASSES__BV_TO_INT_H */
#include "preprocessing/preprocessing_pass_context.h"
#include "theory/quantifiers/extended_rewrite.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__EXTENDED_REWRITER_PASS_H */
#include "theory/rewriter.h"
#include "theory/strings/arith_entail.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
-using namespace CVC4::theory;
+using namespace CVC5::theory;
ForeignTheoryRewrite::ForeignTheoryRewrite(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "foreign-theory-rewrite"),
d_cache(preprocContext->getUserContext()){};
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__FOREIGN_THEORY_REWRITE_H */
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::theory;
-using namespace CVC4::theory::quantifiers;
+using namespace CVC5::kind;
+using namespace CVC5::theory;
+using namespace CVC5::theory::quantifiers;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__SYGUS_INFERENCE_H_ */
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::theory;
+using namespace CVC5::kind;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING_PASSES__GLOBAL_NEGATE_H */
#include "theory/rewriter.h"
#include "theory/uf/theory_uf_rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* __CVC4__PREPROCESSING__PASSES__HO_ELIM_PASS_H */
#include "theory/rewriter.h"
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
using NodeMap = std::unordered_map<Node, Node, NodeHashFunction>;
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__INT_TO_BV_H */
#include "theory/rewriter.h"
#include "theory/theory_preprocessor.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
-using namespace CVC4::theory;
+using namespace CVC5::theory;
// TODO (project #42): note this preprocessing pass is deprecated
IteRemoval::IteRemoval(PreprocessingPassContext* preprocContext)
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__PREPROCESSING__PASSES__ITE_REMOVAL_H
#include "theory/theory_engine.h"
using namespace std;
-using namespace CVC4;
-using namespace CVC4::theory;
+using namespace CVC5;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
assertionsToPreprocess->resize(before);
size_t lastBeforeItes = assertionsToPreprocess->getRealAssertionsEnd() - 1;
intoConjunction.push_back((*assertionsToPreprocess)[lastBeforeItes]);
- Node newLast = CVC4::util::NaryBuilder::mkAssoc(kind::AND, intoConjunction);
+ Node newLast = CVC5::util::NaryBuilder::mkAssoc(kind::AND, intoConjunction);
assertionsToPreprocess->replace(lastBeforeItes, newLast);
Assert(assertionsToPreprocess->size() == before);
}
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/util/ite_utilities.h"
#include "util/stats_histogram.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/theory_model.h"
#include "theory/trust_substitutions.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
namespace {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__MIPLIB_TRICK_H */
#include "preprocessing/assertion_pipeline.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
Node NlExtPurify::purifyNlTerms(TNode n,
NodeMap& cache,
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__NL_EXT_PURIFY_H */
#include "theory/theory_model.h"
#include "theory/trust_substitutions.h"
-using namespace CVC4;
-using namespace CVC4::theory;
+using namespace CVC5;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
class LazyCDProof;
class ProofNodeManager;
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/normal_form.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
-using namespace CVC4::theory;
-using namespace CVC4::theory::arith;
+using namespace CVC5::theory;
+using namespace CVC5::theory::arith;
PseudoBooleanProcessor::PseudoBooleanProcessor(
PreprocessingPassContext* preprocContext)
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "util/maybe.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__PREPROCESSING__PASSES__PSEUDO_BOOLEAN_PROCESSOR_H
#include "theory/theory_engine.h"
using namespace std;
-using namespace CVC4::theory;
-using namespace CVC4::theory::quantifiers;
-using namespace CVC4::kind;
+using namespace CVC5::theory;
+using namespace CVC5::theory::quantifiers;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // passes
} // preprocessing
-} // CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // passes
} // preprocessing
-} // CVC4
+} // namespace CVC5
#endif /*CVC4__PREPROCESSING__PASSES__QUANTIFIER_MACROS_H */
#include "theory/quantifiers/quantifiers_rewriter.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
QuantifiersPreprocess::QuantifiersPreprocess(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "quantifiers-preprocess"){};
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__QUANTIFIERS_PREPROCESS_H */
#include "theory/rewriter.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
Node RealToInt::realToIntInternal(TNode n, NodeMap& cache, std::vector<Node>& var_eq)
{
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__REAL_TO_INT_H */
#include "preprocessing/assertion_pipeline.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
-using namespace CVC4::theory;
-
+using namespace CVC5::theory;
Rewrite::Rewrite(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "rewrite"){};
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__REWRITE_H */
#include "theory/rewriter.h"
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
namespace {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__SEP_SKOLEM_EMP_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__SORT_INFERENCE_PASS_H_ */
#include "theory/rewriter.h"
#include "theory/theory_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__STATIC_LEARNING_H */
#include "theory/rewriter.h"
#include "theory/strings/theory_strings_preprocess.h"
-using namespace CVC4::theory;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__STRINGS_EAGER_PP_H */
#include "theory/smt_engine_subsolver.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::theory;
+using namespace CVC5::kind;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__SYGUS_INFERENCE_H_ */
#include "theory/quantifiers/term_util.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__SYNTH_REW_RULES_H */
#include "theory/rewriter.h"
#include "theory/theory_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
-using namespace CVC4::theory;
+using namespace CVC5::theory;
TheoryPreprocess::TheoryPreprocess(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "theory-preprocess"){};
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__THEORY_PREPROCESS_H */
#include "preprocessing/preprocessing_pass_context.h"
#include "theory/theory_engine.h"
-using namespace CVC4::theory;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "preprocessing/preprocessing_pass.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PASSES__THEORY_REWRITE_EQ_H */
#include "theory/logic_info.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
UnconstrainedSimplifier::UnconstrainedSimplifier(
PreprocessingPassContext* preprocContext)
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "theory/substitutions.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
class Context;
}
} // namespace passes
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "smt/smt_engine_scope.h"
#include "smt/smt_statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
PreprocessingPassResult PreprocessingPass::apply(
}
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
class AssertionPipeline;
};
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PREPROCESSING_PASS_H */
#include "expr/node_algorithm.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
PreprocessingPassContext::PreprocessingPassContext(
}
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "theory/trust_substitutions.h"
#include "util/resource_manager.h"
-namespace CVC4 {
+namespace CVC5 {
class SmtEngine;
class TheoryEngine;
namespace theory::booleans {
}; // class PreprocessingPassContext
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PREPROCESSING_PASS_CONTEXT_H */
#include "preprocessing/passes/unconstrained_simplifier.h"
#include "preprocessing/preprocessing_pass.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
-using namespace CVC4::preprocessing::passes;
+using namespace CVC5::preprocessing::passes;
PreprocessingPassRegistry& PreprocessingPassRegistry::getInstance()
{
}
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include <string>
#include <unordered_map>
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
class PreprocessingPass;
}; // class PreprocessingPassRegistry
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PREPROCESSING__PREPROCESSING_PASS_REGISTRY_H */
#include "theory/theory.h"
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace util {
} // namespace util
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_histogram.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
class AssertionPipeline;
} // namespace util
} // namespace preprocessing
-} // namespace CVC4
+} // namespace CVC5
#endif
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace printer {
namespace ast {
return false;
}
-}/* CVC4::printer::ast namespace */
-}/* CVC4::printer namespace */
-}/* CVC4 namespace */
+} // namespace ast
+} // namespace printer
+} // namespace CVC5
#include "printer/printer.h"
-namespace CVC4 {
+namespace CVC5 {
class LetBinding;
namespace printer {
namespace ast {
-class AstPrinter : public CVC4::Printer
+class AstPrinter : public CVC5::Printer
{
public:
- using CVC4::Printer::toStream;
+ using CVC5::Printer::toStream;
void toStream(std::ostream& out,
TNode n,
int toDepth,
} // namespace ast
} // namespace printer
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PRINTER__AST_PRINTER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace printer {
namespace cvc {
lbind->popScope();
}
-}/* CVC4::printer::cvc namespace */
-}/* CVC4::printer namespace */
-}/* CVC4 namespace */
+} // namespace cvc
+} // namespace printer
+} // namespace CVC5
#include "printer/printer.h"
-namespace CVC4 {
+namespace CVC5 {
class LetBinding;
namespace printer {
namespace cvc {
-class CvcPrinter : public CVC4::Printer
+class CvcPrinter : public CVC5::Printer
{
public:
- using CVC4::Printer::toStream;
+ using CVC5::Printer::toStream;
CvcPrinter(bool cvc3Mode = false) : d_cvc3Mode(cvc3Mode) {}
void toStream(std::ostream& out,
TNode n,
} // namespace cvc
} // namespace printer
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PRINTER__CVC_PRINTER_H */
#include <sstream>
-namespace CVC4 {
+namespace CVC5 {
LetBinding::LetBinding(uint32_t thresh)
: d_thresh(thresh),
}
}
-} // namespace CVC4
+} // namespace CVC5
#include "context/cdlist.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* A flexible let binding class. This class provides functionalities for
NodeIdMap d_letMap;
};
-} // namespace CVC4
+} // namespace CVC5
#endif
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
unique_ptr<Printer> Printer::d_printers[language::output::LANG_MAX];
unique_ptr<Printer> Printer::makePrinter(OutputLanguage lang)
{
- using namespace CVC4::language::output;
+ using namespace CVC5::language::output;
switch(lang) {
case LANG_SMTLIB_V2_6:
printUnknownCommand(out, "sequence");
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "smt/model.h"
#include "util/result.h"
-namespace CVC4 {
+namespace CVC5 {
class Command;
class CommandStatus;
}; /* class Printer */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PRINTER__PRINTER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace printer {
namespace smt2 {
}
else
{
- out << CVC4::quoteSymbol(dt.getName());
+ out << CVC5::quoteSymbol(dt.getName());
}
break;
}
out << '(';
}
if(n.getAttribute(expr::VarNameAttr(), name)) {
- out << CVC4::quoteSymbol(name);
+ out << CVC5::quoteSymbol(name);
}
if(n.getNumChildren() != 0) {
for(unsigned i = 0; i < n.getNumChildren(); ++i) {
string s;
if (n.getAttribute(expr::VarNameAttr(), s))
{
- out << CVC4::quoteSymbol(s);
+ out << CVC5::quoteSymbol(s);
}
else
{
static std::string quoteSymbol(TNode n) {
std::stringstream ss;
ss << n;
- return CVC4::quoteSymbol(ss.str());
+ return CVC5::quoteSymbol(ss.str());
}
template <class T>
const std::vector<std::string>& cnames = core.getCoreNames();
for (const std::string& cn : cnames)
{
- out << CVC4::quoteSymbol(cn) << std::endl;
+ out << CVC5::quoteSymbol(cn) << std::endl;
}
}
else
const std::string& id,
TypeNode type) const
{
- out << "(declare-fun " << CVC4::quoteSymbol(id) << " (";
+ out << "(declare-fun " << CVC5::quoteSymbol(id) << " (";
if (type.isFunction())
{
const vector<TypeNode> argTypes = type.getArgTypes();
std::stringstream id;
id << type;
size_t arity = type.isSortConstructor() ? type.getSortConstructorArity() : 0;
- out << "(declare-sort " << CVC4::quoteSymbol(id.str()) << " " << arity << ")"
+ out << "(declare-sort " << CVC5::quoteSymbol(id.str()) << " " << arity << ")"
<< std::endl;
}
const std::vector<TypeNode>& params,
TypeNode t) const
{
- out << "(define-sort " << CVC4::quoteSymbol(id) << " (";
+ out << "(define-sort " << CVC5::quoteSymbol(id) << " (";
if (params.size() > 0)
{
copy(
{
out << " ";
}
- out << "(" << CVC4::quoteSymbol(cons.getName());
+ out << "(" << CVC5::quoteSymbol(cons.getName());
for (size_t j = 0, nargs = cons.getNumArgs(); j < nargs; j++)
{
const DTypeSelector& arg = cons[j];
{
Assert(t.isDatatype());
const DType& d = t.getDType();
- out << "(" << CVC4::quoteSymbol(d.getName());
+ out << "(" << CVC5::quoteSymbol(d.getName());
out << " " << d.getNumParameters() << ")";
}
out << ") (";
std::stringstream sym;
sym << f;
out << '(' << (isInv ? "synth-inv " : "synth-fun ")
- << CVC4::quoteSymbol(sym.str()) << ' ';
+ << CVC5::quoteSymbol(sym.str()) << ' ';
out << '(';
if (!vars.empty())
{
return false;
}
-}/* CVC4::printer::smt2 namespace */
-}/* CVC4::printer namespace */
-}/* CVC4 namespace */
+} // namespace smt2
+} // namespace printer
+} // namespace CVC5
#include "printer/printer.h"
-namespace CVC4 {
+namespace CVC5 {
class LetBinding;
// support for the string standard
}; /* enum Variant */
-class Smt2Printer : public CVC4::Printer
+class Smt2Printer : public CVC5::Printer
{
public:
Smt2Printer(Variant variant = no_variant) : d_variant(variant) {}
- using CVC4::Printer::toStream;
+ using CVC5::Printer::toStream;
void toStream(std::ostream& out,
TNode n,
int toDepth,
} // namespace smt2
} // namespace printer
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PRINTER__SMT2_PRINTER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace printer {
namespace tptp {
out << "% SZS output end UnsatCore " << std::endl;
}
-}/* CVC4::printer::tptp namespace */
-}/* CVC4::printer namespace */
-}/* CVC4 namespace */
+} // namespace tptp
+} // namespace printer
+} // namespace CVC5
#include "printer/printer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace printer {
namespace tptp {
-class TptpPrinter : public CVC4::Printer
+class TptpPrinter : public CVC5::Printer
{
public:
- using CVC4::Printer::toStream;
+ using CVC5::Printer::toStream;
void toStream(std::ostream& out,
TNode n,
int toDepth,
} // namespace tptp
} // namespace printer
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PRINTER__TPTP_PRINTER_H */
#ifndef CVC4__PROOF__CLAUSE_ID_H
#define CVC4__PROOF__CLAUSE_ID_H
-namespace CVC4 {
+namespace CVC5 {
/**
* A ClauseId is a shared identifier between the proofs module and the sat
const ClauseId ClauseIdUndef(-2);
const ClauseId ClauseIdError(-3);
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__PROOF__CLAUSE_ID_H */
#include "prop/minisat/minisat.h"
#include "prop/sat_solver_types.h"
-namespace CVC4 {
+namespace CVC5 {
CnfProof::CnfProof(prop::CnfStream* stream,
context::Context* ctx,
return d_currentAssertionStack.back().second;
}
-} /* CVC4 namespace */
+} // namespace CVC5
#include "proof/clause_id.h"
#include "proof/proof_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class CnfStream;
-}/* CVC4::prop namespace */
+ } // namespace prop
class CnfProof;
class CnfProof {
protected:
- CVC4::prop::CnfStream* d_cnfStream;
+ CVC5::prop::CnfStream* d_cnfStream;
- /** Map from ClauseId to the assertion that lead to adding this clause **/
- ClauseIdToNode d_clauseToAssertion;
+ /** Map from ClauseId to the assertion that lead to adding this clause **/
+ ClauseIdToNode d_clauseToAssertion;
- /** Top of stack is assertion currently being converted to CNF. Also saves
- * whether it is input (rather than a lemma). **/
- std::vector<std::pair<Node, bool>> d_currentAssertionStack;
+ /** Top of stack is assertion currently being converted to CNF. Also saves
+ * whether it is input (rather than a lemma). **/
+ std::vector<std::pair<Node, bool>> d_currentAssertionStack;
- /** Map from top-level fact to facts/assertion that it follows from **/
- NodeToNode d_cnfDeps;
+ /** Map from top-level fact to facts/assertion that it follows from **/
+ NodeToNode d_cnfDeps;
- ClauseIdSet d_explanations;
+ ClauseIdSet d_explanations;
- // The clause ID of the unit clause defining the true SAT literal.
- ClauseId d_trueUnitClause;
- // The clause ID of the unit clause defining the false SAT literal.
- ClauseId d_falseUnitClause;
+ // The clause ID of the unit clause defining the true SAT literal.
+ ClauseId d_trueUnitClause;
+ // The clause ID of the unit clause defining the false SAT literal.
+ ClauseId d_falseUnitClause;
- std::string d_name;
+ std::string d_name;
public:
- CnfProof(CVC4::prop::CnfStream* cnfStream,
- context::Context* ctx,
- const std::string& name);
- ~CnfProof();
-
- /** Methods for logging what the CnfStream does **/
- // map the clause back to the current assertion where it came from
- void registerConvertedClause(ClauseId clause);
-
- /** Clause is one of the clauses defining top-level assertion node*/
- void setClauseAssertion(ClauseId clause, Node node);
-
- /** Current assertion being converted and whether it is an input (rather than
- * a lemma) */
- void pushCurrentAssertion(Node assertion, bool isInput = false);
- void popCurrentAssertion();
- Node getCurrentAssertion();
- bool getCurrentAssertionKind();
-
- /**
- * Checks whether the assertion stack is empty.
- */
- bool isAssertionStackEmpty() const { return d_currentAssertionStack.empty(); }
-
- // accessors for the leaf assertions that are being converted to CNF
- Node getAssertionForClause(ClauseId clause);
+ CnfProof(CVC5::prop::CnfStream* cnfStream,
+ context::Context* ctx,
+ const std::string& name);
+ ~CnfProof();
+
+ /** Methods for logging what the CnfStream does **/
+ // map the clause back to the current assertion where it came from
+ void registerConvertedClause(ClauseId clause);
+
+ /** Clause is one of the clauses defining top-level assertion node*/
+ void setClauseAssertion(ClauseId clause, Node node);
+
+ /** Current assertion being converted and whether it is an input (rather than
+ * a lemma) */
+ void pushCurrentAssertion(Node assertion, bool isInput = false);
+ void popCurrentAssertion();
+ Node getCurrentAssertion();
+ bool getCurrentAssertionKind();
+
+ /**
+ * Checks whether the assertion stack is empty.
+ */
+ bool isAssertionStackEmpty() const { return d_currentAssertionStack.empty(); }
+
+ // accessors for the leaf assertions that are being converted to CNF
+ Node getAssertionForClause(ClauseId clause);
};/* class CnfProof */
-} /* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__CNF_PROOF_H */
#include <sstream>
#include "expr/proof_node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace proof {
void DotPrinter::cleanQuotes(std::string& s)
}
} // namespace proof
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace proof {
class DotPrinter
};
} // namespace proof
-} // namespace CVC4
+} // namespace CVC5
#endif
\ No newline at end of file
#include "theory/valuation.h"
#include "util/hash.h"
-namespace CVC4 {
+namespace CVC5 {
ProofManager::ProofManager(context::Context* context)
: d_context(context),
d_outputCoreFormulas.insert(formula);
}
-} /* CVC4 namespace */
+} // namespace CVC5
#include "expr/node.h"
#include "proof/clause_id.h"
-namespace CVC4 {
+namespace CVC5 {
// forward declarations
namespace Minisat {
namespace prop {
class CnfStream;
-}/* CVC4::prop namespace */
+ } // namespace prop
class SmtEngine;
template <class Solver> class TSatProof;
-typedef TSatProof< CVC4::Minisat::Solver> CoreSatProof;
+typedef TSatProof<CVC5::Minisat::Solver> CoreSatProof;
class CnfProof;
-typedef TSatProof<CVC4::Minisat::Solver> CoreSatProof;
+typedef TSatProof<CVC5::Minisat::Solver> CoreSatProof;
namespace prop {
typedef uint64_t SatVariable;
class SatLiteral;
typedef std::vector<SatLiteral> SatClause;
-}/* CVC4::prop namespace */
+ } // namespace prop
typedef std::unordered_map<ClauseId, prop::SatClause*> IdToSatClause;
typedef context::CDHashSet<Node, NodeHashFunction> CDNodeSet;
// initialization
void initSatProof(Minisat::Solver* solver);
- void initCnfProof(CVC4::prop::CnfStream* cnfStream, context::Context* ctx);
+ void initCnfProof(CVC5::prop::CnfStream* cnfStream, context::Context* ctx);
// getting various proofs
static CoreSatProof* getSatProof();
};/* class ProofManager */
-}/* CVC4 namespace */
-
-
+} // namespace CVC5
#endif /* CVC4__PROOF_MANAGER_H */
#include "util/stats_histogram.h"
// Forward declarations.
-namespace CVC4 {
+namespace CVC5 {
class CnfProof;
-} /* namespace CVC4 */
+} // namespace CVC5
-namespace CVC4 {
+namespace CVC5 {
/**
* Helper debugging functions
*/
void toSatClause(const typename Solver::TClause& minisat_cl,
prop::SatClause& sat_cl);
-} /* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__SAT__PROOF_H */
#include "prop/sat_solver_types.h"
#include "smt/smt_statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
template <class Solver>
void printLit(typename Solver::TLit l) {
smtStatisticsRegistry()->unregisterStat(&d_usedClauseGlue);
}
-inline std::ostream& operator<<(std::ostream& out, CVC4::ClauseKind k) {
+inline std::ostream& operator<<(std::ostream& out, CVC5::ClauseKind k)
+{
switch (k) {
- case CVC4::INPUT:
- out << "INPUT";
- break;
- case CVC4::THEORY_LEMMA:
- out << "THEORY_LEMMA";
- break;
- case CVC4::LEARNT:
- out << "LEARNT";
- break;
+ case CVC5::INPUT: out << "INPUT"; break;
+ case CVC5::THEORY_LEMMA: out << "THEORY_LEMMA"; break;
+ case CVC5::LEARNT: out << "LEARNT"; break;
default:
out << "ClauseKind Unknown! [" << unsigned(k) << "]";
}
return out;
}
-} /* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__SAT__PROOF_IMPLEMENTATION_H */
#include "printer/printer.h"
#include "smt/smt_engine_scope.h"
-namespace CVC4 {
+namespace CVC5 {
UnsatCore::UnsatCore(const std::vector<Node>& core)
: d_useNames(false), d_core(core), d_names()
return out;
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* An unsat core, which can optionally be initialized as a list of names
/** Print the unsat core to stream out */
std::ostream& operator<<(std::ostream& out, const UnsatCore& core);
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__UNSAT_CORE_H */
on 11 July 2010.
-The code has been modified to put everything in the CVC4::MiniSat
+The code has been modified to put everything in the CVC5::MiniSat
namespace. The build process has been modified. Other parts have
been modified to serve CVC4's purposes.
#include "prop/sat_solver_types.h"
#include "util/resource_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class BVSatSolverNotify {
};/* class BVSatSolverInterface::Notify */
}
-}
+} // namespace CVC5
#endif
#include "proof/clause_id.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
BVMinisatSatSolver::BVMinisatSatSolver(StatisticsRegistry* registry, context::Context* mainSatContext, const std::string& name)
d_statEliminatedVars.set(minisat->eliminated_vars);
}
-} /* namespace CVC4::prop */
-} /* namespace CVC4 */
+} // namespace prop
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class BVMinisatSatSolver : public BVSatSolverInterface,
Statistics d_statistics;
};
-} /* CVC4::prop namespace */
-} /* CVC4 namespace */
+} // namespace prop
+} // namespace CVC5
#include "prop/bvminisat/core/SolverTypes.h"
#include "prop/bvminisat/utils/ParseUtils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//=================================================================================================
parse_DIMACS_main(in, S); }
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include "theory/interrupted.h"
#include "util/utility.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
#define OUTPUT_TAG "bvminisat: [a=" << assumptions.size() << ",l=" << decisionLevel() << "] "
//=================================================================================================
// Constructor/Destructor:
-Solver::Solver(CVC4::context::Context* context)
+Solver::Solver(CVC5::context::Context* context)
:
// Parameters (user settable):
return l_False;
}
- if (!CVC4::options::bvEagerExplanations())
+ if (!CVC5::options::bvEagerExplanations())
{
// check if uip leads to a conflict
if (backtrack_level < assumptions.size())
isWithinBudget =
withinBudget(ResourceManager::Resource::BvSatConflictsStep);
}
- catch (const CVC4::theory::Interrupted& e)
+ catch (const CVC5::theory::Interrupted& e)
{
// do some clean-up and rethrow
cancelUntil(assumptions.size());
propagations < (uint64_t)propagation_budget);
}
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#include "prop/bvminisat/utils/Options.h"
#include "util/resource_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
class Solver;
Notify* d_notify;
/** Cvc4 context */
- CVC4::context::Context* c;
+ CVC5::context::Context* c;
/** True constant */
Var varTrue;
// Constructor/Destructor:
//
- Solver(CVC4::context::Context* c);
- virtual ~Solver();
-
- void setNotify(Notify* toNotify);
-
- // Problem specification:
- //
- Var newVar (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode.
- Var trueVar() const { return varTrue; }
- Var falseVar() const { return varFalse; }
-
- bool addClause(const vec<Lit>& ps,
- ClauseId& id); // Add a clause to the solver.
- bool addEmptyClause(); // Add the empty clause, making the solver contradictory.
- bool addClause(Lit p, ClauseId& id); // Add a unit clause to the solver.
- bool addClause(Lit p,
- Lit q,
- ClauseId& id); // Add a binary clause to the solver.
- bool addClause(Lit p,
- Lit q,
- Lit r,
- ClauseId& id); // Add a ternary clause to the solver.
- bool addClause_( vec<Lit>& ps, ClauseId& id); // Add a clause to the solver without making superflous internal copy. Will
- // change the passed vector 'ps'.
-
- // Solving:
- //
- bool simplify (); // Removes already satisfied clauses.
- lbool solve (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions.
- lbool solveLimited (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions (With resource constraints).
- lbool solve (); // Search without assumptions.
- lbool solve (Lit p); // Search for a model that respects a single assumption.
- lbool solve (Lit p, Lit q); // Search for a model that respects two assumptions.
- lbool solve (Lit p, Lit q, Lit r); // Search for a model that respects three assumptions.
- bool okay () const; // FALSE means solver is in a conflicting state
- lbool assertAssumption(Lit p, bool propagate); // Assert a new assumption, start BCP if propagate = true
- lbool propagateAssumptions(); // Do BCP over asserted assumptions
- void popAssumption(); // Pop an assumption
-
- void toDimacs (FILE* f, const vec<Lit>& assumps); // Write CNF to file in DIMACS-format.
- void toDimacs (const char *file, const vec<Lit>& assumps);
- void toDimacs (FILE* f, Clause& c, vec<Var>& map, Var& max);
-
- // Convenience versions of 'toDimacs()':
- void toDimacs (const char* file);
- void toDimacs (const char* file, Lit p);
- void toDimacs (const char* file, Lit p, Lit q);
- void toDimacs (const char* file, Lit p, Lit q, Lit r);
-
- // Variable mode:
- //
- void setPolarity (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'.
- void setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic.
-
- // Read state:
- //
- lbool value (Var x) const; // The current value of a variable.
- lbool value (Lit p) const; // The current value of a literal.
- lbool modelValue (Var x) const; // The value of a variable in the last model. The last call to solve must have been satisfiable.
- lbool modelValue (Lit p) const; // The value of a literal in the last model. The last call to solve must have been satisfiable.
- int nAssigns () const; // The current number of assigned literals.
- int nClauses () const; // The current number of original clauses.
- int nLearnts () const; // The current number of learnt clauses.
- int nVars () const; // The current number of variables.
- int nFreeVars () const;
-
- // Resource contraints:
- //
- void setConfBudget(int64_t x);
- void setPropBudget(int64_t x);
- void budgetOff();
- void interrupt(); // Trigger a (potentially asynchronous) interruption of the solver.
- void clearInterrupt(); // Clear interrupt indicator flag.
-
- // Memory managment:
- //
- virtual void garbageCollect();
- void checkGarbage(double gf);
- void checkGarbage();
-
- // Extra results: (read-only member variable)
- //
- vec<lbool> model; // If problem is satisfiable, this vector contains the model (if any).
- vec<Lit> conflict; // If problem is unsatisfiable (possibly under assumptions),
- // this vector represent the final conflict clause expressed in the assumptions.
-
- // Mode of operation:
- //
- int verbosity;
- double var_decay;
- double clause_decay;
- double random_var_freq;
- double random_seed;
- bool luby_restart;
- int ccmin_mode; // Controls conflict clause minimization (0=none, 1=basic, 2=deep).
- int phase_saving; // Controls the level of phase saving (0=none, 1=limited, 2=full).
- bool rnd_pol; // Use random polarities for branching heuristics.
- bool rnd_init_act; // Initialize variable activities with a small random value.
- double garbage_frac; // The fraction of wasted memory allowed before a garbage collection is triggered.
-
- int restart_first; // The initial restart limit. (default 100)
- double restart_inc; // The factor with which the restart limit is multiplied in each restart. (default 1.5)
- double learntsize_factor; // The intitial limit for learnt clauses is a factor of the original clauses. (default 1 / 3)
- double learntsize_inc; // The limit for learnt clauses is multiplied with this factor each restart. (default 1.1)
-
- int learntsize_adjust_start_confl;
- double learntsize_adjust_inc;
-
- // Statistics: (read-only member variable)
- //
- uint64_t solves, starts, decisions, rnd_decisions, propagations, conflicts;
- uint64_t dec_vars, clauses_literals, learnts_literals, max_literals, tot_literals;
-
- // Bitvector Propagations
- //
-
- void addMarkerLiteral(Var var);
-
- bool need_to_propagate; // true if we added new clauses, set to true in
- // propagation
- bool only_bcp; // solving mode in which only boolean constraint propagation is done
- void setOnlyBCP (bool val) { only_bcp = val;}
- void explain(Lit l, std::vector<Lit>& explanation);
-
- protected:
-
- // has a clause been added
- bool clause_added;
-
- // Helper structures:
- //
- struct VarData { CRef reason; int level; };
+ Solver(CVC5::context::Context* c);
+ virtual ~Solver();
+
+ void setNotify(Notify* toNotify);
+
+ // Problem specification:
+ //
+ Var newVar(bool polarity = true,
+ bool dvar = true); // Add a new variable with parameters specifying
+ // variable mode.
+ Var trueVar() const { return varTrue; }
+ Var falseVar() const { return varFalse; }
+
+ bool addClause(const vec<Lit>& ps,
+ ClauseId& id); // Add a clause to the solver.
+ bool addEmptyClause(); // Add the empty clause, making the solver
+ // contradictory.
+ bool addClause(Lit p, ClauseId& id); // Add a unit clause to the solver.
+ bool addClause(Lit p,
+ Lit q,
+ ClauseId& id); // Add a binary clause to the solver.
+ bool addClause(Lit p,
+ Lit q,
+ Lit r,
+ ClauseId& id); // Add a ternary clause to the solver.
+ bool addClause_(
+ vec<Lit>& ps,
+ ClauseId& id); // Add a clause to the solver without making superflous
+ // internal copy. Will change the passed vector 'ps'.
+
+ // Solving:
+ //
+ bool simplify(); // Removes already satisfied clauses.
+ lbool solve(const vec<Lit>& assumps); // Search for a model that respects a
+ // given set of assumptions.
+ lbool solveLimited(
+ const vec<Lit>& assumps); // Search for a model that respects a given set
+ // of assumptions (With resource constraints).
+ lbool solve(); // Search without assumptions.
+ lbool solve(Lit p); // Search for a model that respects a single assumption.
+ lbool solve(Lit p,
+ Lit q); // Search for a model that respects two assumptions.
+ lbool solve(Lit p,
+ Lit q,
+ Lit r); // Search for a model that respects three assumptions.
+ bool okay() const; // FALSE means solver is in a conflicting state
+ lbool assertAssumption(
+ Lit p,
+ bool propagate); // Assert a new assumption, start BCP if propagate = true
+ lbool propagateAssumptions(); // Do BCP over asserted assumptions
+ void popAssumption(); // Pop an assumption
+
+ void toDimacs(FILE* f,
+ const vec<Lit>& assumps); // Write CNF to file in DIMACS-format.
+ void toDimacs(const char* file, const vec<Lit>& assumps);
+ void toDimacs(FILE* f, Clause& c, vec<Var>& map, Var& max);
+
+ // Convenience versions of 'toDimacs()':
+ void toDimacs(const char* file);
+ void toDimacs(const char* file, Lit p);
+ void toDimacs(const char* file, Lit p, Lit q);
+ void toDimacs(const char* file, Lit p, Lit q, Lit r);
+
+ // Variable mode:
+ //
+ void setPolarity(
+ Var v, bool b); // Declare which polarity the decision heuristic should
+ // use for a variable. Requires mode 'polarity_user'.
+ void setDecisionVar(Var v,
+ bool b); // Declare if a variable should be eligible for
+ // selection in the decision heuristic.
+
+ // Read state:
+ //
+ lbool value(Var x) const; // The current value of a variable.
+ lbool value(Lit p) const; // The current value of a literal.
+ lbool modelValue(
+ Var x) const; // The value of a variable in the last model. The last call
+ // to solve must have been satisfiable.
+ lbool modelValue(
+ Lit p) const; // The value of a literal in the last model. The last call
+ // to solve must have been satisfiable.
+ int nAssigns() const; // The current number of assigned literals.
+ int nClauses() const; // The current number of original clauses.
+ int nLearnts() const; // The current number of learnt clauses.
+ int nVars() const; // The current number of variables.
+ int nFreeVars() const;
+
+ // Resource contraints:
+ //
+ void setConfBudget(int64_t x);
+ void setPropBudget(int64_t x);
+ void budgetOff();
+ void interrupt(); // Trigger a (potentially asynchronous) interruption of the
+ // solver.
+ void clearInterrupt(); // Clear interrupt indicator flag.
+
+ // Memory managment:
+ //
+ virtual void garbageCollect();
+ void checkGarbage(double gf);
+ void checkGarbage();
+
+ // Extra results: (read-only member variable)
+ //
+ vec<lbool> model; // If problem is satisfiable, this vector contains the model
+ // (if any).
+ vec<Lit> conflict; // If problem is unsatisfiable (possibly under
+ // assumptions), this vector represent the final conflict
+ // clause expressed in the assumptions.
+
+ // Mode of operation:
+ //
+ int verbosity;
+ double var_decay;
+ double clause_decay;
+ double random_var_freq;
+ double random_seed;
+ bool luby_restart;
+ int ccmin_mode; // Controls conflict clause minimization (0=none, 1=basic,
+ // 2=deep).
+ int phase_saving; // Controls the level of phase saving (0=none, 1=limited,
+ // 2=full).
+ bool rnd_pol; // Use random polarities for branching heuristics.
+ bool
+ rnd_init_act; // Initialize variable activities with a small random value.
+ double garbage_frac; // The fraction of wasted memory allowed before a garbage
+ // collection is triggered.
+
+ int restart_first; // The initial restart limit. (default 100)
+ double restart_inc; // The factor with which the restart limit is multiplied
+ // in each restart. (default 1.5)
+ double
+ learntsize_factor; // The intitial limit for learnt clauses is a factor of
+ // the original clauses. (default 1 / 3)
+ double learntsize_inc; // The limit for learnt clauses is multiplied with this
+ // factor each restart. (default 1.1)
+
+ int learntsize_adjust_start_confl;
+ double learntsize_adjust_inc;
+
+ // Statistics: (read-only member variable)
+ //
+ uint64_t solves, starts, decisions, rnd_decisions, propagations, conflicts;
+ uint64_t dec_vars, clauses_literals, learnts_literals, max_literals,
+ tot_literals;
+
+ // Bitvector Propagations
+ //
+
+ void addMarkerLiteral(Var var);
+
+ bool need_to_propagate; // true if we added new clauses, set to true in
+ // propagation
+ bool only_bcp; // solving mode in which only boolean constraint propagation is
+ // done
+ void setOnlyBCP(bool val) { only_bcp = val; }
+ void explain(Lit l, std::vector<Lit>& explanation);
+
+protected:
+ // has a clause been added
+ bool clause_added;
+
+ // Helper structures:
+ //
+ struct VarData
+ {
+ CRef reason;
+ int level; };
static inline VarData mkVarData(CRef cr, int l){ VarData d = {cr, l}; return d; }
struct Watcher {
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
-
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include "prop/bvminisat/mtl/Map.h"
#include "prop/bvminisat/mtl/Vec.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
class Solver;
}
template <class Solver>
class TSatProof;
-}
+} // namespace CVC5
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include "base/check.h"
#include "prop/bvminisat/mtl/Vec.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//=================================================================================================
static inline void append(const vec<T>& from, vec<T>& to){ copy(from, to, true); }
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include "prop/bvminisat/mtl/Vec.h"
#include "prop/bvminisat/mtl/XAlloc.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//=================================================================================================
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include "base/check.h"
#include "prop/bvminisat/mtl/Vec.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//=================================================================================================
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
-
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include "prop/bvminisat/mtl/IntTypes.h"
#include "prop/bvminisat/mtl/Vec.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//=================================================================================================
};
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include "base/check.h"
#include "prop/bvminisat/mtl/Vec.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//=================================================================================================
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#endif
//=================================================================================================
// Some sorting algorithms for vec's
-
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
template<class T>
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include "prop/bvminisat/mtl/IntTypes.h"
#include "prop/bvminisat/mtl/XAlloc.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//=================================================================================================
if (dealloc) free(data), data = NULL, cap = 0; } }
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include <errno.h>
#include <stdlib.h>
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//=================================================================================================
}
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
-
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include "prop/bvminisat/mtl/Sort.h"
#include "prop/bvminisat/utils/System.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//=================================================================================================
//=================================================================================================
// Constructor/Destructor:
-SimpSolver::SimpSolver(CVC4::context::Context* context)
+SimpSolver::SimpSolver(CVC5::context::Context* context)
: Solver(context),
grow(opt_grow),
clause_lim(opt_clause_lim),
use_asymm(opt_use_asymm),
use_rcheck(opt_use_rcheck),
use_elim(opt_use_elim
- && CVC4::options::bitblastMode()
- == CVC4::options::BitblastMode::EAGER
- && !CVC4::options::produceModels()),
+ && CVC5::options::bitblastMode()
+ == CVC5::options::BitblastMode::EAGER
+ && !CVC5::options::produceModels()),
merges(0),
asymm_lits(0),
eliminated_vars(0),
SimpSolver::~SimpSolver()
{
- // CVC4::StatisticsRegistry::unregisterStat(&total_eliminate_time);
+ // CVC5::StatisticsRegistry::unregisterStat(&total_eliminate_time);
}
bool SimpSolver::eliminate(bool turn_off_elim)
{
+ // CVC5::TimerStat::CodeTimer codeTimer(total_eliminate_time);
- // CVC4::TimerStat::CodeTimer codeTimer(total_eliminate_time);
-
- if (!simplify())
- return false;
- else if (!use_simplification)
- return true;
-
- // Main simplification loop:
- //
- while (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0){
+ if (!simplify())
+ return false;
+ else if (!use_simplification)
+ return true;
- gatherTouchedClauses();
- // printf(" ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n", cpuTime(), subsumption_queue.size(), trail.size() - bwdsub_assigns);
- if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size())
- && !backwardSubsumptionCheck(true))
- {
- ok = false;
- goto cleanup;
- }
+ // Main simplification loop:
+ //
+ while (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0)
+ {
+ gatherTouchedClauses();
+ // printf(" ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n",
+ // cpuTime(), subsumption_queue.size(), trail.size() - bwdsub_assigns);
+ if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size())
+ && !backwardSubsumptionCheck(true))
+ {
+ ok = false;
+ goto cleanup;
+ }
- // Empty elim_heap and return immediately on user-interrupt:
- if (asynch_interrupt){
- Assert(bwdsub_assigns == trail.size());
- Assert(subsumption_queue.size() == 0);
- Assert(n_touched == 0);
- elim_heap.clear();
- goto cleanup;
- }
+ // Empty elim_heap and return immediately on user-interrupt:
+ if (asynch_interrupt)
+ {
+ Assert(bwdsub_assigns == trail.size());
+ Assert(subsumption_queue.size() == 0);
+ Assert(n_touched == 0);
+ elim_heap.clear();
+ goto cleanup;
+ }
- // printf(" ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(), elim_heap.size());
- for (int cnt = 0; !elim_heap.empty(); cnt++){
- Var elim = elim_heap.removeMin();
+ // printf(" ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(),
+ // elim_heap.size());
+ for (int cnt = 0; !elim_heap.empty(); cnt++)
+ {
+ Var elim = elim_heap.removeMin();
- if (asynch_interrupt) break;
+ if (asynch_interrupt) break;
- if (isEliminated(elim) || value(elim) != l_Undef) continue;
+ if (isEliminated(elim) || value(elim) != l_Undef) continue;
- if (verbosity >= 2 && cnt % 100 == 0)
- printf("elimination left: %10d\r", elim_heap.size());
+ if (verbosity >= 2 && cnt % 100 == 0)
+ printf("elimination left: %10d\r", elim_heap.size());
- if (use_asymm){
- // Temporarily freeze variable. Otherwise, it would immediately end up on the queue again:
- bool was_frozen = frozen[elim];
- frozen[elim] = true;
- if (!asymmVar(elim)){
- ok = false; goto cleanup; }
- frozen[elim] = was_frozen; }
+ if (use_asymm)
+ {
+ // Temporarily freeze variable. Otherwise, it would immediately end up
+ // on the queue again:
+ bool was_frozen = frozen[elim];
+ frozen[elim] = true;
+ if (!asymmVar(elim))
+ {
+ ok = false;
+ goto cleanup;
+ }
+ frozen[elim] = was_frozen;
+ }
- // At this point, the variable may have been set by assymetric branching, so check it
- // again. Also, don't eliminate frozen variables:
- if (use_elim && value(elim) == l_Undef && !frozen[elim] && !eliminateVar(elim)){
- ok = false; goto cleanup; }
+ // At this point, the variable may have been set by assymetric branching,
+ // so check it again. Also, don't eliminate frozen variables:
+ if (use_elim && value(elim) == l_Undef && !frozen[elim]
+ && !eliminateVar(elim))
+ {
+ ok = false;
+ goto cleanup;
+ }
- checkGarbage(simp_garbage_frac);
- }
+ checkGarbage(simp_garbage_frac);
+ }
- Assert(subsumption_queue.size() == 0);
+ Assert(subsumption_queue.size() == 0);
}
cleanup:
to.moveTo(ca);
}
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#include "prop/bvminisat/core/Solver.h"
#include "prop/bvminisat/mtl/Queue.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
class Context;
public:
// Constructor/Destructor:
//
- SimpSolver(CVC4::context::Context* context);
+ SimpSolver(CVC5::context::Context* context);
~SimpSolver();
// Problem specification:
int merges;
int asymm_lits;
int eliminated_vars;
- // CVC4::TimerStat total_eliminate_time;
+ // CVC5::TimerStat total_eliminate_time;
- protected:
+ protected:
// Helper structures:
//
return solve_(do_simp, turn_off_simp); }
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
-
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include "prop/bvminisat/mtl/Sort.h"
#include "prop/bvminisat/utils/ParseUtils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
void BVMinisat::parseOptions(int& argc, char** argv, bool strict)
exit(0);
}
-
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#include "prop/bvminisat/mtl/Vec.h"
#include "prop/bvminisat/utils/ParseUtils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//==================================================================================================
};
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#endif
//#include <zlib.h>
#include <unistd.h>
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
//-------------------------------------------------------------------------------------------------
//=================================================================================================
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
#endif
#include <stdio.h>
#include <stdlib.h>
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
// TODO: split the memory reading functions into two: one for reading high-watermark of RSS, and
return 0; }
#endif
-
-} /* CVC4::BVMinisat namespace */
+} /* CVC5::BVMinisat namespace */
} /* CVC4 namespace */
//-------------------------------------------------------------------------------------------------
-namespace CVC4 {
+namespace CVC5 {
namespace BVMinisat {
static inline double cpuTime(void); // CPU-time in seconds.
extern double memUsed(); // Memory in mega bytes (returns 0 for unsupported architectures).
extern double memUsedPeak(); // Peak-memory in mega bytes (returns 0 for unsupported architectures).
-} /* CVC4::BVMinisat namespace */
-} /* CVC4 namespace */
+} // namespace BVMinisat
+} // namespace CVC5
//-------------------------------------------------------------------------------------------------
// Implementation of inline functions:
#if defined(_MSC_VER) || defined(__MINGW32__)
#include <time.h>
-static inline double CVC4::BVMinisat::cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; }
+static inline double CVC5::BVMinisat::cpuTime(void)
+{
+ return (double)clock() / CLOCKS_PER_SEC;
+}
#else
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
-static inline double CVC4::BVMinisat::cpuTime(void) {
- struct rusage ru;
- getrusage(RUSAGE_SELF, &ru);
- return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; }
+static inline double CVC5::BVMinisat::cpuTime(void)
+{
+ struct rusage ru;
+ getrusage(RUSAGE_SELF, &ru);
+ return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000;
+}
#endif
#include "base/check.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
using CadicalLit = int;
}
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4_USE_CADICAL
#include <cadical.hpp>
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class CadicalSolver : public SatSolver
};
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4_USE_CADICAL
#endif // CVC4__PROP__CADICAL_H
#include "theory/theory.h"
#include "theory/theory_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
CnfStream::CnfStream(SatSolver* satSolver,
}
}
-}/* CVC4::prop namespace */
-}/* CVC4 namespace */
+} // namespace prop
+} // namespace CVC5
#include "prop/registrar.h"
#include "prop/sat_solver_types.h"
-namespace CVC4 {
+namespace CVC5 {
class OutputManager;
}; /* class CnfStream */
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PROP__CNF_STREAM_H */
#include <cryptominisat5/cryptominisat.h>
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
using CMSatVar = unsigned;
}
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif
class SATSolver;
}
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class CryptoMinisatSolver : public SatSolver
};
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4_USE_CRYPTOMINISAT
#endif // CVC4__PROP__CRYPTOMINISAT_H
#include "base/check.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
using KissatLit = int32_t;
}
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4_USE_KISSAT
#include <kissat/kissat.h>
}
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class KissatSolver : public SatSolver
};
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4_USE_KISSAT
#endif // CVC4__PROP__KISSAT_H
#include "prop/minisat/utils/ParseUtils.h"
#include "prop/minisat/core/SolverTypes.h"
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
#include "prop/minisat/mtl/Sort.h"
#include "prop/theory_proxy.h"
-using namespace CVC4::prop;
+using namespace CVC5::prop;
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
namespace {
// Writes to Trace macro for propagation tracing
static inline void dtviewBoolPropagationHelper(size_t level,
Lit& l,
- CVC4::prop::TheoryProxy* proxy)
+ CVC5::prop::TheoryProxy* proxy)
{
Trace("dtview::prop") << std::string(
level + 1 - (options::incrementalSolving() ? 1 : 0), ' ')
// Writes to Trace macro for conflict tracing
static inline void dtviewPropConflictHelper(size_t level,
Clause& confl,
- CVC4::prop::TheoryProxy* proxy)
+ CVC5::prop::TheoryProxy* proxy)
{
Trace("dtview::conflict")
<< std::string(level + 1 - (options::incrementalSolving() ? 1 : 0), ' ')
//=================================================================================================
// Constructor/Destructor:
-Solver::Solver(CVC4::prop::TheoryProxy* proxy,
- CVC4::context::Context* context,
- CVC4::context::UserContext* userContext,
+Solver::Solver(CVC5::prop::TheoryProxy* proxy,
+ CVC5::context::Context* context,
+ CVC5::context::UserContext* userContext,
ProofNodeManager* pnm,
bool enableIncremental)
: d_proxy(proxy),
ProofManager::getCnfProof()->registerConvertedClause(id);
}
ProofManager::getSatProof()->finalizeProof(
- CVC4::Minisat::CRef_Lazy);
+ CVC5::Minisat::CRef_Lazy);
}
if (isProofEnabled())
{
id = ProofManager::getSatProof()->storeUnitConflict(
ca[confl][0], LEARNT);
ProofManager::getSatProof()->finalizeProof(
- CVC4::Minisat::CRef_Lazy);
+ CVC5::Minisat::CRef_Lazy);
}
else
{
Trace("pf::sat") << "\n";
}
- Trace("pf::sat") << CVC4::push;
+ Trace("pf::sat") << CVC5::push;
for (int j = (p == lit_Undef) ? 0 : 1, size = ca[confl].size();
j < size;
j++)
}
}
}
- Trace("pf::sat") << CVC4::pop;
+ Trace("pf::sat") << CVC5::pop;
// Select next clause to look at:
while (!seen[var(trail[index--])]);
// theory propagation
if (type == CHECK_FINAL) {
// Do the theory check
- theoryCheck(CVC4::theory::Theory::EFFORT_FULL);
+ theoryCheck(CVC5::theory::Theory::EFFORT_FULL);
// Pick up the theory propagated literals (there could be some,
// if new lemmas are added)
propagateTheory();
if (confl == CRef_Undef && type != CHECK_WITHOUT_THEORY) {
// Do the theory check
if (type == CHECK_FINAL_FAKE) {
- theoryCheck(CVC4::theory::Theory::EFFORT_FULL);
+ theoryCheck(CVC5::theory::Theory::EFFORT_FULL);
} else {
- theoryCheck(CVC4::theory::Theory::EFFORT_STANDARD);
+ theoryCheck(CVC5::theory::Theory::EFFORT_STANDARD);
}
// Pick up the theory propagated literals
propagateTheory();
|
| Note: the propagation queue might be NOT empty
|________________________________________________________________________________________________@*/
-void Solver::theoryCheck(CVC4::theory::Theory::Effort effort)
+void Solver::theoryCheck(CVC5::theory::Theory::Effort effort)
{
d_proxy->theoryCheck(effort);
}
--assertionLevel;
Debug("minisat") << "in user pop, decreasing assertion level to "
<< assertionLevel << "\n"
- << CVC4::push;
+ << CVC5::push;
while (true) {
Debug("minisat") << "== unassigning " << trail.last() << std::endl;
Var x = var(trail.last());
// Remove the clauses
removeClausesAboveLevel(clauses_persistent, assertionLevel);
removeClausesAboveLevel(clauses_removable, assertionLevel);
- Debug("minisat") << CVC4::pop;
+ Debug("minisat") << CVC5::pop;
// Pop the SAT context to notify everyone
d_context->pop(); // SAT context for CVC4
void ClauseAllocator::reloc(CRef& cr,
ClauseAllocator& to,
- CVC4::TSatProof<Solver>* proof)
+ CVC5::TSatProof<Solver>* proof)
{
Debug("minisat") << "ClauseAllocator::reloc: cr " << cr << std::endl;
// FIXME what is this CRef_lazy
bool Solver::isProofEnabled() const { return d_pfManager != nullptr; }
-} /* CVC4::Minisat namespace */
-} /* CVC4 namespace */
+} // namespace Minisat
+} // namespace CVC5
#include "theory/theory.h"
#include "util/resource_manager.h"
-namespace CVC4 {
+namespace CVC5 {
template <class Solver> class TSatProof;
namespace prop {
class PropEngine;
class TheoryProxy;
-}/* CVC4::prop namespace */
-}/* CVC4 namespace */
+} // namespace prop
+} // namespace CVC5
-
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//=================================================================================================
class Solver {
/** The only two CVC4 entry points to the private solver data */
- friend class CVC4::prop::PropEngine;
- friend class CVC4::prop::TheoryProxy;
- friend class CVC4::prop::SatProofManager;
- friend class CVC4::TSatProof<Minisat::Solver>;
+ friend class CVC5::prop::PropEngine;
+ friend class CVC5::prop::TheoryProxy;
+ friend class CVC5::prop::SatProofManager;
+ friend class CVC5::TSatProof<Minisat::Solver>;
-public:
+ public:
static CRef TCRef_Undef;
static CRef TCRef_Lazy;
protected:
/** The pointer to the proxy that provides interfaces to the SMT engine */
- CVC4::prop::TheoryProxy* d_proxy;
+ CVC5::prop::TheoryProxy* d_proxy;
/** The context from the SMT solver */
- CVC4::context::Context* d_context;
+ CVC5::context::Context* d_context;
/** The current assertion level (user) */
int assertionLevel;
Var varFalse;
/** The resolution proof manager */
- std::unique_ptr<CVC4::prop::SatProofManager> d_pfManager;
+ std::unique_ptr<CVC5::prop::SatProofManager> d_pfManager;
public:
/** Returns the current user assertion level */
vec<bool> lemmas_removable;
/** Nodes being converted to CNF */
- std::vector<CVC4::Node> lemmas_cnf_assertion;
+ std::vector<CVC5::Node> lemmas_cnf_assertion;
/** Do a another check if FULL_EFFORT was the last one */
bool recheck;
// Constructor/Destructor:
//
- Solver(CVC4::prop::TheoryProxy* proxy,
- CVC4::context::Context* context,
- CVC4::context::UserContext* userContext,
+ Solver(CVC5::prop::TheoryProxy* proxy,
+ CVC5::context::Context* context,
+ CVC5::context::UserContext* userContext,
ProofNodeManager* pnm,
bool enableIncremental = false);
virtual ~Solver();
Var falseVar() const { return varFalse; }
/** Retrive the SAT proof manager */
- CVC4::prop::SatProofManager* getProofManager();
+ CVC5::prop::SatProofManager* getProofManager();
/** Retrive the refutation proof */
std::shared_ptr<ProofNode> getProof();
CRef propagate (TheoryCheckType type); // Perform Boolean and Theory. Returns possibly conflicting clause.
CRef propagateBool (); // Perform Boolean propagation. Returns possibly conflicting clause.
void propagateTheory (); // Perform Theory propagation.
- void theoryCheck (CVC4::theory::Theory::Effort effort); // Perform a theory satisfiability check. Adds lemmas.
+ void theoryCheck(
+ CVC5::theory::Theory::Effort
+ effort); // Perform a theory satisfiability check. Adds lemmas.
CRef updateLemmas (); // Add the lemmas, backtraking if necessary and return a conflict if there is one
void cancelUntil (int level); // Backtrack until a certain level.
int analyze (CRef confl, vec<Lit>& out_learnt, int& out_btlevel); // (bt = backtrack)
//=================================================================================================
-} /* CVC4::Minisat namespace */
-} /* CVC4 namespace */
+} // namespace Minisat
+} // namespace CVC5
#endif
#include "prop/minisat/mtl/Map.h"
#include "prop/minisat/mtl/Vec.h"
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
class Solver;
}
template <class Solver>
class TSatProof;
-} // namespace CVC4
+} // namespace CVC5
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//=================================================================================================
return out;
}
-} /* namespace CVC4::Minisat */
-} /* namespace CVC4 */
+} // namespace Minisat
+} // namespace CVC5
-
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat{
//=================================================================================================
void reloc(CRef& cr,
ClauseAllocator& to,
- CVC4::TSatProof<Solver>* proof = NULL);
+ CVC5::TSatProof<Solver>* proof = NULL);
// Implementation moved to Solver.cc.
};
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
#include "proof/sat_proof.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
//// DPllMinisatSatSolver
d_statTotLiterals.set(minisat->tot_literals);
}
-} /* namespace CVC4::prop */
-} /* namespace CVC4 */
+} // namespace prop
+} // namespace CVC5
-
-namespace CVC4 {
-template<>
-prop::SatLiteral toSatLiteral< CVC4::Minisat::Solver>(Minisat::Solver::TLit lit) {
+namespace CVC5 {
+template <>
+prop::SatLiteral toSatLiteral<CVC5::Minisat::Solver>(Minisat::Solver::TLit lit)
+{
return prop::MinisatSatSolver::toSatLiteral(lit);
}
-template<>
-void toSatClause< CVC4::Minisat::Solver> (const CVC4::Minisat::Solver::TClause& minisat_cl,
- prop::SatClause& sat_cl) {
+template <>
+void toSatClause<CVC5::Minisat::Solver>(
+ const CVC5::Minisat::Solver::TClause& minisat_cl, prop::SatClause& sat_cl)
+{
prop::MinisatSatSolver::toSatClause(minisat_cl, sat_cl);
}
-} /* namespace CVC4 */
+} // namespace CVC5
#include "prop/minisat/simp/SimpSolver.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class MinisatSatSolver : public CDCLTSatSolverInterface
static void toSatClause (const Minisat::Clause& clause, SatClause& sat_clause);
void initialize(context::Context* context,
TheoryProxy* theoryProxy,
- CVC4::context::UserContext* userContext,
+ CVC5::context::UserContext* userContext,
ProofNodeManager* pnm) override;
ClauseId addClause(SatClause& clause, bool removable) override;
}; /* class MinisatSatSolver */
-}/* CVC4::prop namespace */
-}/* CVC4 namespace */
+} // namespace prop
+} // namespace CVC5
#include "base/check.h"
#include "prop/minisat/mtl/Vec.h"
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
#include "prop/minisat/mtl/Vec.h"
#include "prop/minisat/mtl/XAlloc.h"
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
#include "base/check.h"
#include "prop/minisat/mtl/Vec.h"
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
#include "prop/minisat/mtl/IntTypes.h"
#include "prop/minisat/mtl/Vec.h"
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
#include "base/check.h"
#include "prop/minisat/mtl/Vec.h"
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
//=================================================================================================
// Some sorting algorithms for vec's
-
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
template<class T>
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
#include "prop/minisat/mtl/IntTypes.h"
#include "prop/minisat/mtl/XAlloc.h"
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
#include <errno.h>
#include <stdlib.h>
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
#include "prop/minisat/mtl/Sort.h"
#include "prop/minisat/utils/System.h"
-using namespace CVC4;
-using namespace CVC4::Minisat;
+using namespace CVC5;
+using namespace CVC5::Minisat;
//=================================================================================================
// Options:
//=================================================================================================
// Constructor/Destructor:
-SimpSolver::SimpSolver(CVC4::prop::TheoryProxy* proxy,
- CVC4::context::Context* context,
- CVC4::context::UserContext* userContext,
+SimpSolver::SimpSolver(CVC5::prop::TheoryProxy* proxy,
+ CVC5::context::Context* context,
+ CVC5::context::UserContext* userContext,
ProofNodeManager* pnm,
bool enableIncremental)
: Solver(proxy, context, userContext, pnm, enableIncremental),
#include "prop/minisat/core/Solver.h"
#include "prop/minisat/mtl/Queue.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class TheoryProxy;
}
-}
+} // namespace CVC5
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//=================================================================================================
public:
// Constructor/Destructor:
//
- SimpSolver(CVC4::prop::TheoryProxy* proxy,
- CVC4::context::Context* context,
- CVC4::context::UserContext* userContext,
+ SimpSolver(CVC5::prop::TheoryProxy* proxy,
+ CVC5::context::Context* context,
+ CVC5::context::UserContext* userContext,
ProofNodeManager* pnm,
bool enableIncremental = false);
~SimpSolver();
}
//=================================================================================================
-} /* CVC4::Minisat namespace */
-} /* CVC4 namespace */
+ } // namespace Minisat
+ } // namespace CVC5
#endif
#include "prop/minisat/mtl/Vec.h"
#include "prop/minisat/utils/ParseUtils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//==================================================================================================
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
//#include <zlib.h>
#include <unistd.h>
-namespace CVC4 {
+namespace CVC5 {
namespace Minisat {
//-------------------------------------------------------------------------------------------------
//=================================================================================================
}
-}
+} // namespace CVC5
#endif
#include "prop/minisat/minisat.h"
#include "theory/builtin/proof_checker.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
ProofCnfStream::ProofCnfStream(context::UserContext* u,
}
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#include "theory/eager_proof_generator.h"
#include "theory/theory_proof_step_buffer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class SatProofManager;
};
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/builtin/proof_checker.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
ProofPostprocessCallback::ProofPostprocessCallback(
}
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_node_updater.h"
#include "prop/proof_cnf_stream.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
};
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "util/resource_manager.h"
#include "util/result.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
/** Keeps a boolean flag scoped */
bool PropEngine::isProofEnabled() const { return d_pfCnfStream != nullptr; }
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#include "theory/trust_node.h"
#include "util/result.h"
-namespace CVC4 {
+namespace CVC5 {
class ResourceManager;
class DecisionEngine;
};
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PROP_ENGINE_H */
#include "prop/prop_proof_manager.h"
#include "prop/sat_solver.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
PropPfManager::PropPfManager(context::UserContext* userContext,
}
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#include "prop/proof_post_processor.h"
#include "prop/sat_proof_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
}; /* class PropPfManager */
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PROP__PROOF_MANAGER_H */
#ifndef CVC4__PROP__REGISTRAR_H
#define CVC4__PROP__REGISTRAR_H
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class Registrar {
};/* class NullRegistrar */
-}/* CVC4::prop namespace */
-}/* CVC4 namespace */
+} // namespace prop
+} // namespace CVC5
#endif /* CVC4__PROP__REGISTRAR_H */
#include "prop/minisat/minisat.h"
#include "theory/theory_proof_step_buffer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
SatProofManager::SatProofManager(Minisat::Solver* solver,
}
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
class Solver;
}
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
}; /* class SatProofManager */
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SAT_PROOF_MANAGER_H */
#include "prop/sat_solver_types.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
virtual void initialize(context::Context* context,
prop::TheoryProxy* theoryProxy,
- CVC4::context::UserContext* userContext,
+ CVC5::context::UserContext* userContext,
ProofNodeManager* pnm) = 0;
virtual void push() = 0;
return out;
}
-}/* CVC4::prop namespace */
-}/* CVC4 namespace */
+} // namespace prop
+} // namespace CVC5
#endif /* CVC4__PROP__SAT_MODULE_H */
#include "prop/kissat.h"
#include "prop/minisat/minisat.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
BVSatSolverInterface* SatSolverFactory::createMinisat(
}
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#include "prop/sat_solver.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class SatSolverFactory
}; /* class SatSolverFactory */
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__PROP__SAT_SOLVER_FACTORY_H
#include <algorithm>
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
bool SatClauseLessThan::operator()(const SatClause& l, const SatClause& r) const
{
return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
}
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#include <unordered_set>
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
/**
};
}
-}
+} // namespace CVC5
#include "expr/attribute.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
SkolemDefManager::SkolemDefManager(context::Context* context,
}
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#include "context/context.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
/**
};
} // namespace prop
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PROP__SKOLEM_DEF_MANAGER_H */
#include "theory/theory_engine.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
TheoryProxy::TheoryProxy(PropEngine* propEngine,
theory::TrustNode tte = d_theoryEngine->getExplanation(lNode);
Node theoryExplanation = tte.getNode();
- if (CVC4::options::produceProofs())
+ if (CVC5::options::produceProofs())
{
d_propEngine->getProofCnfStream()->convertPropagation(tte);
}
void TheoryProxy::preRegister(Node n) { d_theoryEngine->preRegister(n); }
-}/* CVC4::prop namespace */
-}/* CVC4 namespace */
+} // namespace prop
+} // namespace CVC5
#include "theory/trust_node.h"
#include "util/resource_manager.h"
-namespace CVC4 {
+namespace CVC5 {
class DecisionEngine;
class TheoryEngine;
std::unique_ptr<SkolemDefManager> d_skdm;
}; /* class TheoryProxy */
-}/* CVC4::prop namespace */
+} // namespace prop
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__PROP__SAT_H */
#include "theory/quantifiers/sygus/sygus_grammar_cons.h"
#include "theory/smt_engine_subsolver.h"
-using namespace CVC4::theory;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
AbductionSolver::AbductionSolver(SmtEngine* parent) : d_parent(parent) {}
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
class SmtEngine;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__ABDUCTION_SOLVER_H */
#include "options/smt_options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
AbstractValues::AbstractValues(NodeManager* nm)
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/substitutions.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
/**
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "smt/abstract_values.h"
#include "smt/smt_engine.h"
-using namespace CVC4::theory;
-using namespace CVC4::kind;
+using namespace CVC5::theory;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
Assertions::Assertions(context::UserContext* u, AbstractValues& absv)
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "preprocessing/assertion_pipeline.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
class AbstractValues;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/substitutions.h"
#include "theory/theory_engine.h"
-using namespace CVC4::theory;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
CheckModels::CheckModels(SmtSolver& s) : d_smt(s) {}
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "context/cdlist.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
class Model;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
std::string sexprToString(api::Term sexpr)
{
out, api::Sort::sortVectorToTypeNodes(d_datatypes));
}
-} // namespace CVC4
+} // namespace CVC5
#include "cvc4_export.h"
#include "options/language.h"
-namespace CVC4 {
+namespace CVC5 {
namespace api {
class Solver;
OutputLanguage language = language::output::LANG_AUTO) const override;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__COMMAND_H */
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
/**
}; /* class DefinedFunction */
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__DEFINED_FUNCTION_H */
#include "smt/command.h"
#include "smt/node_command.h"
-namespace CVC4 {
+namespace CVC5 {
#if defined(CVC4_DUMPING) && !defined(CVC4_MUZZLE)
DumpC DumpChannel;
std::ostream& DumpC::setStream(std::ostream* os) {
- ::CVC4::DumpOutChannel.setStream(os);
+ ::CVC5::DumpOutChannel.setStream(os);
return *os;
}
-std::ostream& DumpC::getStream() { return ::CVC4::DumpOutChannel.getStream(); }
-std::ostream* DumpC::getStreamPointer() { return ::CVC4::DumpOutChannel.getStreamPointer(); }
-
+std::ostream& DumpC::getStream() { return ::CVC5::DumpOutChannel.getStream(); }
+std::ostream* DumpC::getStreamPointer()
+{
+ return ::CVC5::DumpOutChannel.getStreamPointer();
+}
void DumpC::setDumpFromString(const std::string& optarg) {
if (Configuration::isDumpingBuild())
to a file.\n\
";
-}/* CVC4 namespace */
+} // namespace CVC5
#include "base/output.h"
-namespace CVC4 {
+namespace CVC5 {
class Command;
class NodeCommand;
/** The dump singleton */
extern DumpC DumpChannel;
-#define Dump ::CVC4::DumpChannel
+#define Dump ::CVC5::DumpChannel
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__DUMP_H */
#include "smt/dump.h"
#include "smt/node_command.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
DumpManager::DumpManager(context::UserContext* u)
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class NodeCommand;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
#include "util/resource_manager.h"
-using namespace CVC4::smt;
+using namespace CVC5::smt;
-namespace CVC4 {
+namespace CVC5 {
Env::Env(NodeManager* nm)
: d_context(new context::Context()),
std::ostream& Env::getDumpOut() { return *d_options.getOut(); }
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
class NodeManager;
class StatisticsRegistry;
std::unique_ptr<ResourceManager> d_resourceManager;
}; /* class Env */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__ENV_H */
#include "smt/smt_engine_stats.h"
#include "theory/theory_engine.h"
-using namespace CVC4::preprocessing;
-using namespace CVC4::theory;
-using namespace CVC4::kind;
+using namespace CVC5::preprocessing;
+using namespace CVC5::theory;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
ExpandDefs::ExpandDefs(SmtEngine& smt,
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
class ResourceManager;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/quantifiers/sygus/sygus_interpol.h"
#include "theory/smt_engine_subsolver.h"
-using namespace CVC4::theory;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
InterpolationSolver::InterpolationSolver(SmtEngine* parent) : d_parent(parent)
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
class SmtEngine;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__INTERPOLATION_SOLVER_H */
#include "smt/smt_engine.h"
#include "smt/smt_engine_scope.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
ResourceOutListener::ResourceOutListener(SmtEngine& smt) : d_smt(smt) {}
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "base/listener.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class OutputManager;
class SmtEngine;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "base/exception.h"
-namespace CVC4 {
+namespace CVC5 {
-class LogicException : public CVC4::Exception
+class LogicException : public CVC5::Exception
{
public:
LogicException() :
}
}; /* class LogicException */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__SMT__LOGIC_EXCEPTION_H */
#include "options/smt_options.h"
#include "smt/update_ostream.h"
-namespace CVC4 {
+namespace CVC5 {
ManagedOstream::ManagedOstream() : d_managed(NULL) {}
opener->addSpecialCase("stderr", &std::cerr);
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include <ostream>
-namespace CVC4 {
+namespace CVC5 {
class OstreamOpener;
void addSpecialCases(OstreamOpener* opener) const override;
};/* class ManagedRegularOutputChannel */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__MANAGED_OSTREAMS_H */
#include "smt/smt_engine_scope.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
Model::Model(theory::TheoryModel* tm) : d_isKnownSat(false), d_tmodel(tm)
}
} // namespace smt
-}/* CVC4 namespace */
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class SmtEngine;
*/
class Model {
friend std::ostream& operator<<(std::ostream&, const Model&);
- friend class ::CVC4::SmtEngine;
+ friend class ::CVC5::SmtEngine;
public:
/** construct */
};
} // namespace smt
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__MODEL_H */
#include "theory/rewriter.h"
#include "theory/theory_model.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
Node ModelBlocker::getModelBlocker(const std::vector<Node>& assertions,
theory::TheoryModel* m,
return blocker;
}
-} /* namespace CVC4 */
+} // namespace CVC5
#include "expr/node.h"
#include "options/smt_options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class TheoryModel;
const std::vector<Node>& exprToBlock = std::vector<Node>());
}; /* class TheoryModelCoreBuilder */
-} // namespace CVC4
+} // namespace CVC5
#endif /* __CVC4__THEORY__MODEL_BLOCKER_H */
#include "theory/subs_minimize.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
bool ModelCoreBuilder::setModelCore(const std::vector<Node>& assertions,
theory::TheoryModel* m,
return false;
}
-} /* namespace CVC4 */
+} // namespace CVC5
#include "options/smt_options.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* A utility for building model cores.
options::ModelCoresMode mode);
}; /* class TheoryModelCoreBuilder */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__MODEL_CORE_BUILDER_H */
#include "printer/printer.h"
-namespace CVC4 {
+namespace CVC5 {
/* -------------------------------------------------------------------------- */
/* class NodeCommand */
return new DefineFunctionNodeCommand(d_id, d_fun, d_formals, d_formula);
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/type_node.h"
#include "options/language.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* A node version of Command. DO NOT use this version unless there is a need
Node d_formula;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__NODE_COMMAND_H */
#include "theory/quantifiers/quantifiers_attributes.h"
#include "theory/smt_engine_subsolver.h"
-using namespace CVC4::theory;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
/**
Node Objective::getNode() { return d_node; }
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "smt/assertions.h"
#include "util/result.h"
-namespace CVC4 {
+namespace CVC5 {
class SmtEngine;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__OPTIMIZATION_SOLVER_H */
#include "smt/set_defaults.h"
#include "util/resource_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
OptionsManager::OptionsManager(Options* opts, ResourceManager* rm)
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "options/options_listener.h"
#include "smt/managed_ostreams.h"
-namespace CVC4 {
+namespace CVC5 {
class LogicInfo;
class Options;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__OPTIONS_MANAGER_H */
#include "smt/smt_engine.h"
-namespace CVC4 {
+namespace CVC5 {
OutputManager::OutputManager(SmtEngine* smt) : d_smt(smt) {}
return *d_smt->getOptions().getOut();
}
-} // namespace CVC4
+} // namespace CVC5
#include <ostream>
-namespace CVC4 {
+namespace CVC5 {
class Printer;
class SmtEngine;
SmtEngine* d_smt;
};
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__SMT__OUTPUT_MANAGER_H
#include "options/proof_options.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
PreprocessProofGenerator::PreprocessProofGenerator(ProofNodeManager* pnm,
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_generator.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
class LazyCDProof;
class ProofNodeManager;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "smt/smt_engine.h"
using namespace std;
-using namespace CVC4::theory;
-using namespace CVC4::kind;
+using namespace CVC5::theory;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
Preprocessor::Preprocessor(SmtEngine& smt,
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "smt/process_assertions.h"
#include "theory/booleans/circuit_propagator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
class PreprocessingPassContext;
}
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/theory_engine.h"
using namespace std;
-using namespace CVC4::preprocessing;
-using namespace CVC4::theory;
-using namespace CVC4::kind;
+using namespace CVC5::preprocessing;
+using namespace CVC5::theory;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
/** Useful for counting the number of recursive calls. */
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "util/resource_manager.h"
-namespace CVC4 {
+namespace CVC5 {
class SmtEngine;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "smt/preprocess_proof_generator.h"
#include "smt/proof_post_processor.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
PfManager::PfManager(context::UserContext* u, SmtEngine* smte)
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "context/cdhashmap.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofChecker;
class ProofNode;
}; /* class SmtEngine */
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__PROOF_MANAGER_H */
#include "theory/rewriter.h"
#include "theory/theory.h"
-using namespace CVC4::kind;
-using namespace CVC4::theory;
+using namespace CVC5::kind;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
ProofPostprocessCallback::ProofPostprocessCallback(ProofNodeManager* pnm,
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_histogram.h"
-namespace CVC4 {
+namespace CVC5 {
class SmtEngine;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
#include "theory/theory_engine.h"
-using namespace CVC4::theory;
-using namespace CVC4::kind;
+using namespace CVC5::theory;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
QuantElimSolver::QuantElimSolver(SmtSolver& sms) : d_smtSolver(sms) {}
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "smt/assertions.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
class SmtSolver;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__QUANT_ELIM_SOLVER_H */
#include "smt/logic_exception.h"
#include "theory/theory.h"
-using namespace CVC4::theory;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
void setDefaults(LogicInfo& logic, bool isInternalSubsolver)
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "theory/logic_info.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
/**
void setDefaults(LogicInfo& logic, bool isInternalSubsolver);
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__SET_DEFAULTS_H */
#include "base/configuration_private.h"
using namespace std;
-using namespace CVC4::smt;
-using namespace CVC4::preprocessing;
-using namespace CVC4::prop;
-using namespace CVC4::context;
-using namespace CVC4::theory;
+using namespace CVC5::smt;
+using namespace CVC5::preprocessing;
+using namespace CVC5::prop;
+using namespace CVC5::context;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
SmtEngine::SmtEngine(NodeManager* nm, Options* optr)
: d_env(new Env(nm)),
return false;
}
-CVC4::SExpr SmtEngine::getInfo(const std::string& key) const
+CVC5::SExpr SmtEngine::getInfo(const std::string& key) const
{
SmtScope smts(this);
theory::Rewriter* SmtEngine::getRewriter() { return d_env->getRewriter(); }
-}/* CVC4 namespace */
+} // namespace CVC5
#include "util/sexpr.h"
#include "util/statistics.h"
-namespace CVC4 {
+namespace CVC5 {
template <bool ref_count> class NodeTemplate;
typedef NodeTemplate<true> Node;
namespace context {
class Context;
class UserContext;
-}/* CVC4::context namespace */
+ } // namespace context
/* -------------------------------------------------------------------------- */
namespace prop {
class PropEngine;
-}/* CVC4::prop namespace */
+ } // namespace prop
/* -------------------------------------------------------------------------- */
class UnsatCoreManager;
ProofManager* currentProofManager();
-}/* CVC4::smt namespace */
+} // namespace smt
/* -------------------------------------------------------------------------- */
namespace theory {
class Rewriter;
class QuantifiersEngine;
-}/* CVC4::theory namespace */
-
+ } // namespace theory
/* -------------------------------------------------------------------------- */
class CVC4_EXPORT SmtEngine
{
- friend class ::CVC4::api::Solver;
- friend class ::CVC4::smt::SmtEngineState;
- friend class ::CVC4::smt::SmtScope;
- friend class ::CVC4::LogicRequest;
+ friend class ::CVC5::api::Solver;
+ friend class ::CVC5::smt::SmtEngineState;
+ friend class ::CVC5::smt::SmtScope;
+ friend class ::CVC5::LogicRequest;
/* ....................................................................... */
public:
bool isValidGetInfoFlag(const std::string& key) const;
/** Query information about the SMT environment. */
- CVC4::SExpr getInfo(const std::string& key) const;
+ CVC5::SExpr getInfo(const std::string& key) const;
/**
* Set an aspect of the current SMT execution environment.
/* -------------------------------------------------------------------------- */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__SMT_ENGINE_H */
#include "base/output.h"
#include "smt/smt_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
thread_local SmtEngine* s_smtEngine_current = NULL;
return s_smtEngine_current->getStatisticsRegistry();
}
-}/* CVC4::smt namespace */
-}/* CVC4 namespace */
+} // namespace smt
+} // namespace CVC5
#include "options/options.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofManager;
class SmtEngine;
Options::OptionsScope d_optionsScope;
};/* class SmtScope */
-
-}/* CVC4::smt namespace */
-}/* CVC4 namespace */
+} // namespace smt
+} // namespace CVC5
#endif /* CVC4__SMT__SMT_ENGINE_SCOPE_H */
#include "options/smt_options.h"
#include "smt/smt_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
SmtEngineState::SmtEngineState(context::Context* c,
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "smt/smt_mode.h"
#include "util/result.h"
-namespace CVC4 {
+namespace CVC5 {
class SmtEngine;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "smt/smt_statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
SmtEngineStatistics::SmtEngineStatistics()
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
struct SmtEngineStatistics
}; /* struct SmtEngineStatistics */
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__SMT_ENGINE_STATS_H */
#include <iostream>
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, SmtMode m)
{
return out;
}
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
-namespace CVC4 {
+namespace CVC5 {
/**
* The mode of the solver, which is an extension of Figure 4.1 on
*/
std::ostream& operator<<(std::ostream& out, SmtMode m);
-} // namespace CVC4
+} // namespace CVC5
#endif
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
SmtSolver::SmtSolver(SmtEngine& smt,
Preprocessor* SmtSolver::getPreprocessor() { return &d_pp; }
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "theory/logic_info.h"
#include "util/result.h"
-namespace CVC4 {
+namespace CVC5 {
class SmtEngine;
class TheoryEngine;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__SMT_SOLVER_H */
#include "smt/smt_engine_scope.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
StatisticsRegistry* smtStatisticsRegistry() {
return smt::SmtScope::currentStatisticsRegistry();
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* This returns the StatisticsRegistry attached to the currently in scope
*/
StatisticsRegistry* smtStatisticsRegistry();
-}/* CVC4 namespace */
+} // namespace CVC5
#include "theory/quantifiers_engine.h"
#include "theory/smt_engine_subsolver.h"
-using namespace CVC4::theory;
-using namespace CVC4::kind;
+using namespace CVC5::theory;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
SygusSolver::SygusSolver(SmtSolver& sms,
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "smt/assertions.h"
#include "util/result.h"
-namespace CVC4 {
+namespace CVC5 {
class OutputManager;
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__SYGUS_SOLVER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
RemoveTermFormulas::RemoveTermFormulas(context::UserContext* u,
ProofNodeManager* pnm)
bool RemoveTermFormulas::isProofEnabled() const { return d_pnm != nullptr; }
-}/* CVC4 namespace */
+} // namespace CVC5
#include "theory/trust_node.h"
#include "util/hash.h"
-namespace CVC4 {
+namespace CVC5 {
class LazyCDProof;
class ProofNodeManager;
bool isProofEnabled() const;
};/* class RemoveTTE */
-}/* CVC4 namespace */
+} // namespace CVC5
#include "expr/proof_node_algorithm.h"
#include "smt/assertions.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
void UnsatCoreManager::getUnsatCore(std::shared_ptr<ProofNode> pfn,
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/proof_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
}; /* class UnsatCoreManager */
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SMT__UNSAT_CORE_MANAGER_H */
#include "options/set_language.h"
#include "smt/dump.h"
-namespace CVC4 {
+namespace CVC5 {
class ChannelSettings {
public:
void set(std::ostream* setTo) override { Trace.setStream(setTo); }
}; /* class TraceOstreamUpdate */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__UPDATE_OSTREAM_H */
#include "expr/skolem_manager.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
WitnessFormGenerator::WitnessFormGenerator(ProofNodeManager* pnm)
}
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_generator.h"
#include "expr/term_conversion_proof_generator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace smt {
/**
};
} // namespace smt
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "smt_util/boolean_simplification.h"
-namespace CVC4 {
+namespace CVC5 {
bool BooleanSimplification::push_back_associative_commute_recursive(
Node n, std::vector<Node>& buffer, Kind k, Kind notK, bool negateNode)
return true;
}/* BooleanSimplification::push_back_associative_commute_recursive() */
-}/* CVC4 namespace */
+} // namespace CVC5
#include "base/check.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* A class to contain a number of useful functions for simple
};/* class BooleanSimplification */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__BOOLEAN_SIMPLIFICATION_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace util {
Node NaryBuilder::mkAssoc(Kind kind, const std::vector<Node>& children)
}
}/* util namespace */
-}/* CVC4 namespace */
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4{
+namespace CVC5 {
namespace util {
class NaryBuilder {
};/* class RePairAssocCommutativeOperators */
}/* util namespace */
-}/* CVC4 namespace */
+} // namespace CVC5
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
double sumInfeasibilities(bool mip) const override { return 0.0; }
};
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
/* Begin the declaration of GLPK specific code. */
#ifdef CVC4_USE_GLPK
#include <glpk.h>
}/* extern "C" */
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
int ApproxGLPK::s_verbosity = 0;
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /*#ifdef CVC4_USE_GLPK */
/* End the declaration of GLPK specific code. */
/* Begin GPLK/NOGLPK Glue code. */
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
ApproximateSimplex* ApproximateSimplex::mkApproximateSimplexSolver(const ArithVariables& vars, TreeLog& l, ApproximateStatistics& s){
return false;
#endif
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
/* End GPLK/NOGLPK Glue code. */
-
/* Begin GPLK implementation. */
#ifdef CVC4_USE_GLPK
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
}
}
-
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /*#ifdef CVC4_USE_GLPK */
/* End GPLK implementation. */
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
static Integer s_defaultMaxDenom;
};/* class ApproximateSimplex */
-
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
}
Node ArithIteUtils::reduceVariablesInItes(Node n){
- using namespace CVC4::kind;
+ using namespace CVC5::kind;
if(d_reduceVar.find(n) != d_reduceVar.end()){
Node res = d_reduceVar[n];
return res.isNull() ? n : res;
return false;
}
-
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "context/cdo.h"
#include "context/cdinsert_hashmap.h"
-namespace CVC4 {
+namespace CVC5 {
namespace preprocessing {
namespace util {
class ContainsTermITEVisitor;
}; /* class ArithIteUtils */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__ARITH_ITE_UTILS_H */
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
bool ArithMSum::getMonomial(Node n, Node& c, Node& v)
Trace(c) << std::endl;
}
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** Arithmetic utilities regarding monomial sums.
static void debugPrintMonomialSum(std::map<Node, Node>& msum, const char* c);
};
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__MSUM_H */
#include "theory/arith/inference_manager.h"
#include "theory/skolem_lemma.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/arith/operator_elim.h"
#include "theory/logic_info.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class SkolemLemma;
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/theory.h"
#include "util/iand.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
if(exp.sgn() == 0){
return RewriteResponse(REWRITE_DONE, mkRationalNode(Rational(1)));
}else if(exp.sgn() > 0 && exp.isIntegral()){
- CVC4::Rational r(expr::NodeValue::MAX_CHILDREN);
+ CVC5::Rational r(expr::NodeValue::MAX_CHILDREN);
if (exp <= r)
{
unsigned num = exp.getNumerator().toUnsignedInt();
return RewriteResponse(REWRITE_AGAIN_FULL, ret);
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/rewrites.h"
#include "theory/theory_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
static RewriteResponse returnRewrite(TNode t, Node ret, Rewrite r);
}; /* class ArithRewriter */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__ARITH_REWRITER_H */
#include "theory/arith/theory_arith_private.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
}
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/delta_rational.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
class Context;
}
};/* class ArithStaticLearner */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__ARITH_STATIC_LEARNER_H */
#include <cmath>
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "util/integer.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
/** Negates a node in arithmetic proof normal form. */
Node negateProofLiteral(TNode n);
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__ARITH_UTILITIES_H */
#include <limits>
#include <set>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
return asSet.size() == variables.size();
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/index.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
extern bool debugIsASet(const ArithVarVec& variables);
-
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "context/cdhashmap.h"
#include "context/cdo.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
};/* class ArithVarNodeMap */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__ARITHVAR_NODE_MAP_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
}
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/approx_simplex.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} d_statistics;
};/* class AttemptSolutionSDP */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/arithvar.h"
#include "util/dense_map.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
virtual void operator()(ArithVar v, const BoundsInfo& up) = 0;
};
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/normal_form.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
\ No newline at end of file
#include "theory/arith/proof_macros.h"
#include "theory/arith/theory_arith_private.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
return boundsInfo(basic).hasBounds();
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/inference_id.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNode;
BoundCounts hasBounds(ArithVar basic) const;
};
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/uf/proof_equality_engine.h"
#include "options/arith_options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
return a;
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/dense_map.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
std::vector<Node> andComponents(TNode an);
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
return make_pair(a_sgn, b_sgn);
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/trust_node.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
}; /* ConstraintDatabase */
-
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__CONSTRAINT_H */
#include "cvc4_private.h"
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
static const RationalVectorCP RationalVectorCPSentinel = NULL;
static const RationalVectorP RationalVectorPSentinel = NULL;
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__CONSTRAINT_FORWARD_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
out << "]";
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/constraint_forward.h"
#include "util/dense_map.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
void printBranchInfo(std::ostream& os) const;
};
-
-
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& os, const DeltaRational& dq){
return os << "(" << dq.getNoninfinitesimalPart()
}
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "util/integer.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
class DeltaRational;
*/
class DeltaRational {
private:
- CVC4::Rational c;
- CVC4::Rational k;
+ CVC5::Rational c;
+ CVC5::Rational k;
public:
DeltaRational() : c(0,1), k(0,1) {}
- DeltaRational(const CVC4::Rational& base) : c(base), k(0,1) {}
- DeltaRational(const CVC4::Rational& base, const CVC4::Rational& coeff) :
- c(base), k(coeff) {}
-
- const CVC4::Rational& getInfinitesimalPart() const {
- return k;
+ DeltaRational(const CVC5::Rational& base) : c(base), k(0, 1) {}
+ DeltaRational(const CVC5::Rational& base, const CVC5::Rational& coeff)
+ : c(base), k(coeff)
+ {
}
- const CVC4::Rational& getNoninfinitesimalPart() const {
- return c;
- }
+ const CVC5::Rational& getInfinitesimalPart() const { return k; }
+
+ const CVC5::Rational& getNoninfinitesimalPart() const { return c; }
int sgn() const {
int s = getNoninfinitesimalPart().sgn();
}
DeltaRational operator+(const DeltaRational& other) const{
- CVC4::Rational tmpC = c+other.c;
- CVC4::Rational tmpK = k+other.k;
+ CVC5::Rational tmpC = c + other.c;
+ CVC5::Rational tmpK = k + other.k;
return DeltaRational(tmpC, tmpK);
}
DeltaRational operator*(const Rational& a) const{
- CVC4::Rational tmpC = a*c;
- CVC4::Rational tmpK = a*k;
+ CVC5::Rational tmpC = a * c;
+ CVC5::Rational tmpK = a * k;
return DeltaRational(tmpC, tmpK);
}
DeltaRational operator-(const DeltaRational& a) const{
- CVC4::Rational negOne(CVC4::Integer(-1));
+ CVC5::Rational negOne(CVC5::Integer(-1));
return *(this) + (a * negOne);
}
}
DeltaRational operator/(const Rational& a) const{
- CVC4::Rational tmpC = c/a;
- CVC4::Rational tmpK = k/a;
+ CVC5::Rational tmpC = c / a;
+ CVC5::Rational tmpK = k / a;
return DeltaRational(tmpC, tmpK);
}
DeltaRational operator/(const Integer& a) const{
- CVC4::Rational tmpC = c/a;
- CVC4::Rational tmpK = k/a;
+ CVC5::Rational tmpC = c / a;
+ CVC5::Rational tmpK = k / a;
return DeltaRational(tmpC, tmpK);
}
return *(this);
}
- DeltaRational& operator*=(const CVC4::Rational& a){
+ DeltaRational& operator*=(const CVC5::Rational& a)
+ {
c *= a;
k *= a;
std::ostream& operator<<(std::ostream& os, const DeltaRational& n);
-}/* CVC4 namespace */
+} // namespace CVC5
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
return eq;
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
class Context;
}
Statistics d_statistics;
};/* class DioSolver */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__DIO_SOLVER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
return false;
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/simplex.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} d_statistics;
};/* class DualSimplexDecisionProcedure */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
}
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/bin_heap.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
Statistics d_statistics;
};
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
}
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/dense_map.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} d_statistics;
};/* class FCSimplexDecisionProcedure */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/infer_bounds.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} /* namespace arith */
} /* namespace theory */
-} /* namespace CVC4 */
+} // namespace CVC5
#include "util/maybe.h"
#include "util/rational.h"
-
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} /* namespace arith */
} /* namespace theory */
-} /* namespace CVC4 */
+} // namespace CVC5
#include "theory/arith/theory_arith.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/inference_id.h"
#include "theory/inference_manager_buffered.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
# src/theory/builtin/kinds.
#
-theory THEORY_ARITH ::CVC4::theory::arith::TheoryArith "theory/arith/theory_arith.h"
+theory THEORY_ARITH ::CVC5::theory::arith::TheoryArith "theory/arith/theory_arith.h"
typechecker "theory/arith/theory_arith_type_rules.h"
properties stable-infinite
properties check propagate ppStaticLearn presolve notifyRestart
-rewriter ::CVC4::theory::arith::ArithRewriter "theory/arith/arith_rewriter.h"
+rewriter ::CVC5::theory::arith::ArithRewriter "theory/arith/arith_rewriter.h"
operator PLUS 2: "arithmetic addition (N-ary)"
operator MULT 2: "arithmetic multiplication (N-ary)"
operator SQRT 1 "square root"
constant DIVISIBLE_OP \
- ::CVC4::Divisible \
- ::CVC4::DivisibleHashFunction \
+ ::CVC5::Divisible \
+ ::CVC5::DivisibleHashFunction \
"util/divisible.h" \
- "operator for the divisibility-by-k predicate; payload is an instance of the CVC4::Divisible class"
+ "operator for the divisibility-by-k predicate; payload is an instance of the CVC5::Divisible class"
sort REAL_TYPE \
Cardinality::REALS \
"integer type"
constant CONST_RATIONAL \
- ::CVC4::Rational \
- ::CVC4::RationalHashFunction \
+ ::CVC5::Rational \
+ ::CVC5::RationalHashFunction \
"util/rational.h" \
- "a multiple-precision rational constant; payload is an instance of the CVC4::Rational class"
+ "a multiple-precision rational constant; payload is an instance of the CVC5::Rational class"
enumerator REAL_TYPE \
- "::CVC4::theory::arith::RationalEnumerator" \
+ "::CVC5::theory::arith::RationalEnumerator" \
"theory/arith/type_enumerator.h"
enumerator INTEGER_TYPE \
- "::CVC4::theory::arith::IntegerEnumerator" \
+ "::CVC5::theory::arith::IntegerEnumerator" \
"theory/arith/type_enumerator.h"
operator LT 2 "less than, x < y"
# represents an indexed root predicate. See util/indexed_root_predicate.h for more documentation.
constant INDEXED_ROOT_PREDICATE_OP \
- ::CVC4::IndexedRootPredicate \
- ::CVC4::IndexedRootPredicateHashFunction \
+ ::CVC5::IndexedRootPredicate \
+ ::CVC5::IndexedRootPredicateHashFunction \
"util/indexed_root_predicate.h" \
- "operator for the indexed root predicate; payload is an instance of the CVC4::IndexedRootPredicate class"
+ "operator for the indexed root predicate; payload is an instance of the CVC5::IndexedRootPredicate class"
parameterized INDEXED_ROOT_PREDICATE INDEXED_ROOT_PREDICATE_OP 2 "indexed root predicate; first parameter is a INDEXED_ROOT_PREDICATE_OP, second is a real variable compared to zero, third is a polynomial"
operator IS_INTEGER 1 "term-is-integer predicate (parameter is a real-sorted term)"
# This way, we avoid having 2 nested TO_REAL nodess as a result of Solver::mkTerm(TO_REAL, Solver::mkReal(int val))
operator CAST_TO_REAL 1 "cast term to real same as TO_REAL, but it is used internally, whereas TO_REAL is accessible in the API"
-typerule PLUS ::CVC4::theory::arith::ArithOperatorTypeRule
-typerule MULT ::CVC4::theory::arith::ArithOperatorTypeRule
-typerule NONLINEAR_MULT ::CVC4::theory::arith::ArithOperatorTypeRule
-typerule MINUS ::CVC4::theory::arith::ArithOperatorTypeRule
-typerule UMINUS ::CVC4::theory::arith::ArithOperatorTypeRule
-typerule DIVISION ::CVC4::theory::arith::ArithOperatorTypeRule
-typerule POW ::CVC4::theory::arith::ArithOperatorTypeRule
+typerule PLUS ::CVC5::theory::arith::ArithOperatorTypeRule
+typerule MULT ::CVC5::theory::arith::ArithOperatorTypeRule
+typerule NONLINEAR_MULT ::CVC5::theory::arith::ArithOperatorTypeRule
+typerule MINUS ::CVC5::theory::arith::ArithOperatorTypeRule
+typerule UMINUS ::CVC5::theory::arith::ArithOperatorTypeRule
+typerule DIVISION ::CVC5::theory::arith::ArithOperatorTypeRule
+typerule POW ::CVC5::theory::arith::ArithOperatorTypeRule
-typerule CONST_RATIONAL ::CVC4::theory::arith::ArithConstantTypeRule
+typerule CONST_RATIONAL ::CVC5::theory::arith::ArithConstantTypeRule
typerule LT "SimpleTypeRule<RBool, AReal, AReal>"
typerule LEQ "SimpleTypeRule<RBool, AReal, AReal>"
typerule GEQ "SimpleTypeRule<RBool, AReal, AReal>"
typerule INDEXED_ROOT_PREDICATE_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule INDEXED_ROOT_PREDICATE ::CVC4::theory::arith::IndexedRootPredicateTypeRule
+typerule INDEXED_ROOT_PREDICATE ::CVC5::theory::arith::IndexedRootPredicateTypeRule
-typerule TO_REAL ::CVC4::theory::arith::ArithOperatorTypeRule
-typerule CAST_TO_REAL ::CVC4::theory::arith::ArithOperatorTypeRule
-typerule TO_INTEGER ::CVC4::theory::arith::ArithOperatorTypeRule
+typerule TO_REAL ::CVC5::theory::arith::ArithOperatorTypeRule
+typerule CAST_TO_REAL ::CVC5::theory::arith::ArithOperatorTypeRule
+typerule TO_INTEGER ::CVC5::theory::arith::ArithOperatorTypeRule
typerule IS_INTEGER "SimpleTypeRule<RBool, AReal>"
typerule ABS "SimpleTypeRule<RInteger, AInteger>"
typerule DIVISIBLE "SimpleTypeRule<RBool, AInteger>"
typerule DIVISIBLE_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule DIVISION_TOTAL ::CVC4::theory::arith::ArithOperatorTypeRule
+typerule DIVISION_TOTAL ::CVC5::theory::arith::ArithOperatorTypeRule
typerule INTS_DIVISION_TOTAL "SimpleTypeRule<RInteger, AInteger, AInteger>"
typerule INTS_MODULUS_TOTAL "SimpleTypeRule<RInteger, AInteger, AInteger>"
nullaryoperator PI "pi"
-typerule PI ::CVC4::theory::arith::RealNullaryOperatorTypeRule
+typerule PI ::CVC5::theory::arith::RealNullaryOperatorTypeRule
# Integer AND, which is parameterized by a (positive) bitwidth k.
# ((_ iand k) i1 i2) is equivalent to:
# (bv2int (bvand ((_ int2bv k) i1) ((_ int2bv k) i2)))
# for all integers i1, i2.
constant IAND_OP \
- ::CVC4::IntAnd \
- "::CVC4::UnsignedHashFunction< ::CVC4::IntAnd >" \
+ ::CVC5::IntAnd \
+ "::CVC5::UnsignedHashFunction< ::CVC5::IntAnd >" \
"util/iand.h" \
- "operator for integer AND; payload is an instance of the CVC4::IntAnd class"
+ "operator for integer AND; payload is an instance of the CVC5::IntAnd class"
parameterized IAND IAND_OP 2 "integer version of AND operator; first parameter is an IAND_OP, second and third are integer terms"
-typerule IAND_OP ::CVC4::theory::arith::IAndOpTypeRule
-typerule IAND ::CVC4::theory::arith::IAndTypeRule
+typerule IAND_OP ::CVC5::theory::arith::IAndOpTypeRule
+typerule IAND ::CVC5::theory::arith::IAndTypeRule
endtheory
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
d_tableau.directlyAddToCoefficient(row, col, mult, d_trackCallback);
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
}
};
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/matrix.h"
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
void NoEffectCCCB::multiplyRow(RowIndex ridx, int sgn){}
bool NoEffectCCCB::canUseRow(RowIndex ridx) const { return false; }
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/dense_map.h"
#include "util/index.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
typedef MatrixEntry<T> Entry;
protected:
- typedef CVC4::theory::arith::RowVector<T> RowVectorT;
- typedef CVC4::theory::arith::ColumnVector<T> ColumnVectorT;
+ typedef CVC5::theory::arith::RowVector<T> RowVectorT;
+ typedef CVC5::theory::arith::ColumnVector<T> ColumnVectorT;
public:
typedef typename RowVectorT::const_iterator RowIterator;
};/* class Matrix<T> */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
-
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
template <typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v)
{
- CVC4::container_to_stream(os, v);
+ CVC5::container_to_stream(os, v);
return os;
}
} // namespace std
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/cad/proof_generator.h"
#include "theory/arith/nl/cad/variable_ordering.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/cad/projections.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "expr/node.h"
#include "theory/arith/nl/cad/projections.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/poly_conversion.h"
#include "util/poly_util.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/poly_conversion.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "base/check.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "expr/sequence.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/proof_checker.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__PROOF_CHECKER_H */
#include "theory/lazy_tree_proof_generator.h"
#include "theory/arith/nl/poly_conversion.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/cad/cdcac_utils.h"
#include "theory/lazy_tree_proof_generator.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofGenerator;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#endif
#include "util/poly_util.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/cad/constraints.h"
#include "util/poly_util.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/nl_model.h"
#include "theory/arith/nl/poly_conversion.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/arith/nl/cad/cdcac.h"
#include "theory/arith/nl/cad/proof_checker.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__CAD_SOLVER_H */
#include "theory/arith/arith_utilities.h"
#include "theory/arith/nl/ext/monomial.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/kind.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__NL_SOLVER_H */
#include "theory/arith/nl/nl_model.h"
#include "theory/arith/nl/nl_lemma_utils.h"
-
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_set.h"
#include "theory/arith/nl/ext/monomial.h"
-namespace CVC4 {
+namespace CVC5 {
class CDProof;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/ext/ext_state.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class CDProof;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/nl_lemma_utils.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__NL_MONOMIAL_H */
#include "theory/arith/nl/nl_model.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/arith/nl/ext/constraint.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/nl_lemma_utils.h"
#include "theory/arith/nl/ext/ext_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/arith/nl/ext/monomial.h"
#include "theory/theory_inference.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/arith_utilities.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_checker.h"
#include "expr/proof_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__PROOF_CHECKER_H */
#include "theory/arith/nl/ext/ext_state.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "context/cdhashset.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/ext/ext_state.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/arith_utilities.h"
#include "theory/uf/equality_engine.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/ext_theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
class EqualityEngine;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__NL__EXT_THEORY_CALLBACK_H */
#include "theory/rewriter.h"
#include "util/iand.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/arith/nl/iand_utils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__IAND_SOLVER_H */
#include "theory/arith/nl/nl_model.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__IAND_TABLE_H */
#include "theory/arith/nl/icp/intersection.h"
#include "theory/arith/nl/poly_conversion.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "expr/node.h"
#include "theory/arith/nl/icp/intersection.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/icp/contraction_origins.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
#include "util/poly_util.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/arith/nl/icp/intersection.h"
#include "theory/arith/nl/poly_conversion.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "base/output.h"
#include "theory/arith/nl/poly_conversion.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
class Interval;
}
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/arith/nl/nl_model.h"
#include "theory/arith/nl/nonlinear_extension.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/theory_inference.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__NL_LEMMA_UTILS_H */
#include "theory/theory_model.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/kind.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
class Context;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__NONLINEAR_EXTENSION_H */
#include "theory/rewriter.h"
#include "theory/theory_model.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory.h"
#include "util/result.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
class EqualityEngine;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__NONLINEAR_EXTENSION_H */
#include "theory/arith/bound_inference.h"
#include "util/poly_util.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
-poly::Variable VariableMapper::operator()(const CVC4::Node& n)
+poly::Variable VariableMapper::operator()(const CVC5::Node& n)
{
auto it = mVarCVCpoly.find(n);
if (it == mVarCVCpoly.end())
return it->second;
}
-CVC4::Node VariableMapper::operator()(const poly::Variable& n)
+CVC5::Node VariableMapper::operator()(const poly::Variable& n)
{
auto it = mVarpolyCVC.find(n);
Assert(it != mVarpolyCVC.end())
return it->second;
}
-CVC4::Node as_cvc_upolynomial(const poly::UPolynomial& p, const CVC4::Node& var)
+CVC5::Node as_cvc_upolynomial(const poly::UPolynomial& p, const CVC5::Node& var)
{
Trace("poly::conversion")
<< "Converting " << p << " over " << var << std::endl;
return res;
}
-poly::UPolynomial as_poly_upolynomial_impl(const CVC4::Node& n,
+poly::UPolynomial as_poly_upolynomial_impl(const CVC5::Node& n,
poly::Integer& denominator,
- const CVC4::Node& var)
+ const CVC5::Node& var)
{
denominator = poly::Integer(1);
if (n.isVar())
return poly::UPolynomial();
}
-poly::UPolynomial as_poly_upolynomial(const CVC4::Node& n,
- const CVC4::Node& var)
+poly::UPolynomial as_poly_upolynomial(const CVC5::Node& n,
+ const CVC5::Node& var)
{
poly::Integer denom;
return as_poly_upolynomial_impl(n, denom, var);
}
-poly::Polynomial as_poly_polynomial_impl(const CVC4::Node& n,
+poly::Polynomial as_poly_polynomial_impl(const CVC5::Node& n,
poly::Integer& denominator,
VariableMapper& vm)
{
}
return poly::Polynomial();
}
-poly::Polynomial as_poly_polynomial(const CVC4::Node& n, VariableMapper& vm)
+poly::Polynomial as_poly_polynomial(const CVC5::Node& n, VariableMapper& vm)
{
poly::Integer denom;
return as_poly_polynomial_impl(n, denom, vm);
}
-poly::Polynomial as_poly_polynomial(const CVC4::Node& n,
+poly::Polynomial as_poly_polynomial(const CVC5::Node& n,
VariableMapper& vm,
poly::Rational& denominator)
{
}
} // namespace
-CVC4::Node as_cvc_polynomial(const poly::Polynomial& p, VariableMapper& vm)
+CVC5::Node as_cvc_polynomial(const poly::Polynomial& p, VariableMapper& vm)
{
CollectMonomialData cmd(vm);
// Do the actual conversion
return cmd.d_nm->mkNode(Kind::PLUS, cmd.d_terms);
}
-poly::SignCondition normalize_kind(CVC4::Kind kind,
+poly::SignCondition normalize_kind(CVC5::Kind kind,
bool negated,
poly::Polynomial& lhs)
{
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "expr/node.h"
#include "util/real_algebraic_number.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
struct VariableMapper
{
/** A mapping from CVC4 variables to poly variables. */
- std::map<CVC4::Node, poly::Variable> mVarCVCpoly;
+ std::map<CVC5::Node, poly::Variable> mVarCVCpoly;
/** A mapping from poly variables to CVC4 variables. */
- std::map<poly::Variable, CVC4::Node> mVarpolyCVC;
+ std::map<poly::Variable, CVC5::Node> mVarpolyCVC;
/** Retrieves the according poly variable. */
- poly::Variable operator()(const CVC4::Node& n);
+ poly::Variable operator()(const CVC5::Node& n);
/** Retrieves the according CVC4 variable. */
- CVC4::Node operator()(const poly::Variable& n);
+ CVC5::Node operator()(const poly::Variable& n);
};
-/** Convert a poly univariate polynomial to a CVC4::Node. */
-CVC4::Node as_cvc_upolynomial(const poly::UPolynomial& p,
- const CVC4::Node& var);
+/** Convert a poly univariate polynomial to a CVC5::Node. */
+CVC5::Node as_cvc_upolynomial(const poly::UPolynomial& p,
+ const CVC5::Node& var);
-/** Convert a CVC4::Node to a poly univariate polynomial. */
-poly::UPolynomial as_poly_upolynomial(const CVC4::Node& n,
- const CVC4::Node& var);
+/** Convert a CVC5::Node to a poly univariate polynomial. */
+poly::UPolynomial as_poly_upolynomial(const CVC5::Node& n,
+ const CVC5::Node& var);
/**
* Constructs a polynomial from the given node.
* in the context of ICP) the second overload provides the denominator in the
* third argument.
*/
-poly::Polynomial as_poly_polynomial(const CVC4::Node& n, VariableMapper& vm);
-poly::Polynomial as_poly_polynomial(const CVC4::Node& n,
+poly::Polynomial as_poly_polynomial(const CVC5::Node& n, VariableMapper& vm);
+poly::Polynomial as_poly_polynomial(const CVC5::Node& n,
VariableMapper& vm,
poly::Rational& denominator);
* multiplications with one or use NONLINEAR_MULT where regular MULT may be
* sufficient), so it may be sensible to rewrite it afterwards.
*/
-CVC4::Node as_cvc_polynomial(const poly::Polynomial& p, VariableMapper& vm);
+CVC5::Node as_cvc_polynomial(const poly::Polynomial& p, VariableMapper& vm);
/**
* Constructs a constraints (a polynomial and a sign condition) from the given
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "smt/smt_statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__NL__STATS_H */
#include "base/check.h"
#include "options/arith_options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__NL__STRATEGY_H */
#include "theory/arith/nl/transcendental/transcendental_state.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */
#include "theory/arith/nl/transcendental/taylor_generator.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_checker.h"
#include "expr/proof_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__PROOF_CHECKER_H */
#include "theory/arith/nl/transcendental/transcendental_state.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/arith/nl/transcendental/transcendental_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */
#include "theory/arith/nl/nl_model.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */
#include "theory/arith/nl/transcendental/taylor_generator.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/arith/nl/transcendental/sine_solver.h"
#include "theory/arith/nl/transcendental/transcendental_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */
#include "theory/arith/nl/transcendental/taylor_generator.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/arith/nl/transcendental/proof_checker.h"
#include "theory/arith/nl/transcendental/taylor_generator.h"
-namespace CVC4 {
+namespace CVC5 {
class CDProof;
namespace theory {
namespace arith {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__NL__TRANSCENDENTAL__TRANSCENDENTAL_STATE_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} //namespace arith
} //namespace theory
-} //namespace CVC4
+} // namespace CVC5
#include "theory/arith/delta_rational.h"
#include "util/rational.h"
-
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
};/* class Comparison */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__NORMAL_FORM_H */
#include "theory/rewriter.h"
#include "theory/theory.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/logic_info.h"
#include "theory/skolem_lemma.h"
-namespace CVC4 {
+namespace CVC5 {
class TConvProofGenerator;
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
d_pm->popUpperBound(p);
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/constraint_forward.h"
#include "theory/arith/delta_rational.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
class Context;
}
};/* class ArithVariables */
-
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__PARTIAL_MODEL_H */
#include "theory/arith/normal_form.h"
#include "theory/arith/operator_elim.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
}
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/proof_checker.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__PROOF_CHECKER_H */
#include "options/smt_options.h"
-#define ARITH_PROOF(x) \
- if (CVC4::options::produceProofs()) \
- { \
- x; \
+#define ARITH_PROOF(x) \
+ if (CVC5::options::produceProofs()) \
+ { \
+ x; \
}
-#define ARITH_NULLPROOF(x) (CVC4::options::produceProofs()) ? x : NULL
-#define ARITH_PROOF_ON() CVC4::options::produceProofs()
+#define ARITH_NULLPROOF(x) (CVC5::options::produceProofs()) ? x : NULL
+#define ARITH_PROOF_ON() CVC5::options::produceProofs()
#endif // CVC4__THEORY__ARITH__PROOF_MACROS_H
#include <iostream>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__REWRITES_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
pair<ArithVar, int> p = make_pair(col, determinizeSgn(sgn));
return sgns.find(p);
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
};/* class SimplexDecisionProcedure */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
return out;
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/constraint_forward.h"
#include "util/maybe.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
std::ostream& operator<<(std::ostream& out, const UpdateInfo& up);
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
}
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/dense_map.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
} d_statistics;
};/* class FCSimplexDecisionProcedure */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/tableau.h"
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
printRow(basicToRowIndex(basic), out);
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/dense_map.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
};/* class Tableau */
-
-
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/tableau_sizes.h"
#include "theory/arith/tableau.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
return d_tab->getColLength(x);
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/arithvar.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
uint32_t getColumnLength(ArithVar x) const;
}; /* TableauSizes */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
-
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/theory_model.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
return d_im.getProofEqEngine();
}
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "theory/arith/inference_manager.h"
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
namespace nl {
};/* class TheoryArith */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/statistics_registry.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
// return result;
// }
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#include "util/result.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class EagerProofGenerator;
Statistics d_statistics;
};/* class TheoryArithPrivate */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#ifndef CVC4__THEORY__ARITH__THEORY_ARITH_TYPE_RULES_H
#define CVC4__THEORY__ARITH__THEORY_ARITH_TYPE_RULES_H
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
}
}; /* class IndexedRootPredicateTypeRule */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__THEORY_ARITH_TYPE_RULES_H */
#include "util/integer.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arith {
bool isFinished() override { return false; }
};/* class IntegerEnumerator */
-}/* CVC4::theory::arith namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arith
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARITH__TYPE_ENUMERATOR_H */
#include "smt/smt_statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
}
-
-}/* CVC4::theory::arrays namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arrays
+} // namespace theory
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
void mergeInfo(const TNode a, const TNode b);
};/* class ArrayInfo */
-}/* CVC4::theory::arrays namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arrays
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARRAYS__ARRAY_INFO_H */
#include "theory/theory_state.h"
#include "theory/uf/equality_engine.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/eager_proof_generator.h"
#include "theory/theory_inference_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
# src/theory/builtin/kinds.
#
-theory THEORY_ARRAYS ::CVC4::theory::arrays::TheoryArrays "theory/arrays/theory_arrays.h"
+theory THEORY_ARRAYS ::CVC5::theory::arrays::TheoryArrays "theory/arrays/theory_arrays.h"
typechecker "theory/arrays/theory_arrays_type_rules.h"
properties polite stable-infinite parametric
properties check presolve
-rewriter ::CVC4::theory::arrays::TheoryArraysRewriter "theory/arrays/theory_arrays_rewriter.h"
+rewriter ::CVC5::theory::arrays::TheoryArraysRewriter "theory/arrays/theory_arrays_rewriter.h"
operator ARRAY_TYPE 2 "array type"
cardinality ARRAY_TYPE \
- "::CVC4::theory::arrays::ArraysProperties::computeCardinality(%TYPE%)" \
+ "::CVC5::theory::arrays::ArraysProperties::computeCardinality(%TYPE%)" \
"theory/arrays/theory_arrays_type_rules.h"
well-founded ARRAY_TYPE \
- "::CVC4::theory::arrays::ArraysProperties::isWellFounded(%TYPE%)" \
- "::CVC4::theory::arrays::ArraysProperties::mkGroundTerm(%TYPE%)" \
+ "::CVC5::theory::arrays::ArraysProperties::isWellFounded(%TYPE%)" \
+ "::CVC5::theory::arrays::ArraysProperties::mkGroundTerm(%TYPE%)" \
"theory/arrays/theory_arrays_type_rules.h"
enumerator ARRAY_TYPE \
- "::CVC4::theory::arrays::ArrayEnumerator" \
+ "::CVC5::theory::arrays::ArrayEnumerator" \
"theory/arrays/type_enumerator.h"
# select a i is a[i]
# storeall t e is \all i in indexType(t) <= e
constant STORE_ALL \
- ::CVC4::ArrayStoreAll \
- ::CVC4::ArrayStoreAllHashFunction \
+ ::CVC5::ArrayStoreAll \
+ ::CVC5::ArrayStoreAllHashFunction \
"expr/array_store_all.h" \
- "array store-all; payload is an instance of the CVC4::ArrayStoreAll class (this is not supported by arrays decision procedure yet, but it is used for returned array models)"
+ "array store-all; payload is an instance of the CVC5::ArrayStoreAll class (this is not supported by arrays decision procedure yet, but it is used for returned array models)"
# used internally by array theory
operator ARR_TABLE_FUN 4 "array table function (internal-only symbol)"
# as a shifted over one.
operator ARRAY_LAMBDA 1 "array lambda (internal-only symbol)"
-typerule SELECT ::CVC4::theory::arrays::ArraySelectTypeRule
-typerule STORE ::CVC4::theory::arrays::ArrayStoreTypeRule
-typerule STORE_ALL ::CVC4::theory::arrays::ArrayStoreTypeRule
-typerule ARR_TABLE_FUN ::CVC4::theory::arrays::ArrayTableFunTypeRule
-typerule ARRAY_LAMBDA ::CVC4::theory::arrays::ArrayLambdaTypeRule
-typerule EQ_RANGE ::CVC4::theory::arrays::ArrayEqRangeTypeRule
+typerule SELECT ::CVC5::theory::arrays::ArraySelectTypeRule
+typerule STORE ::CVC5::theory::arrays::ArrayStoreTypeRule
+typerule STORE_ALL ::CVC5::theory::arrays::ArrayStoreTypeRule
+typerule ARR_TABLE_FUN ::CVC5::theory::arrays::ArrayTableFunTypeRule
+typerule ARRAY_LAMBDA ::CVC5::theory::arrays::ArrayLambdaTypeRule
+typerule EQ_RANGE ::CVC5::theory::arrays::ArrayEqRangeTypeRule
operator PARTIAL_SELECT_0 0:2 "partial array select, for internal use only"
operator PARTIAL_SELECT_1 0:2 "partial array select, for internal use only"
-typerule PARTIAL_SELECT_0 ::CVC4::theory::arrays::ArrayPartialSelectTypeRule
-typerule PARTIAL_SELECT_1 ::CVC4::theory::arrays::ArrayPartialSelectTypeRule
+typerule PARTIAL_SELECT_0 ::CVC5::theory::arrays::ArrayPartialSelectTypeRule
+typerule PARTIAL_SELECT_1 ::CVC5::theory::arrays::ArrayPartialSelectTypeRule
# store operations that are ordered (by index) over a store-all are constant
-construle STORE ::CVC4::theory::arrays::ArrayStoreTypeRule
+construle STORE ::CVC5::theory::arrays::ArrayStoreTypeRule
endtheory
#include "theory/arrays/skolem_cache.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/proof_checker.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ARRAYS__PROOF_CHECKER_H */
#include "expr/skolem_manager.h"
#include "expr/type_node.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
} while (changed);
}
-}/* CVC4::theory::arrays namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arrays
+} // namespace theory
+} // namespace CVC5
#include "theory/uf/equality_engine.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
void computeRelevantTerms(std::set<Node>& termSet) override;
};/* class TheoryArrays */
-}/* CVC4::theory::arrays namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arrays
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARRAYS__THEORY_ARRAYS_H */
#include "expr/attribute.h"
#include "theory/arrays/theory_arrays_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
namespace attr {
struct ArrayConstantMostFrequentValueTag { };
struct ArrayConstantMostFrequentValueCountTag { };
-}/* CVC4::theory::arrays::attr namespace */
+ } // namespace attr
typedef expr::Attribute<attr::ArrayConstantMostFrequentValueCountTag, uint64_t> ArrayConstantMostFrequentValueCountAttr;
typedef expr::Attribute<attr::ArrayConstantMostFrequentValueTag, Node> ArrayConstantMostFrequentValueAttr;
return store.setAttribute(ArrayConstantMostFrequentValueCountAttr(), count);
}
-}/* CVC4::theory::arrays namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arrays
+} // namespace theory
+} // namespace CVC5
#include "theory/theory_rewriter.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
}; /* class TheoryArraysRewriter */
-}/* CVC4::theory::arrays namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arrays
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARRAYS__THEORY_ARRAYS_REWRITER_H */
#include "theory/arrays/theory_arrays_rewriter.h" // for array-constant attributes
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
}
}; /* struct ArrayEqRangeTypeRule */
-}/* CVC4::theory::arrays namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arrays
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARRAYS__THEORY_ARRAYS_TYPE_RULES_H */
#include "expr/kind.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
};/* class ArrayEnumerator */
-}/* CVC4::theory::arrays namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arrays
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ARRAYS__TYPE_ENUMERATOR_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace arrays {
template void UnionFind<TNode, TNodeHashFunction>::notify();
-}/* CVC4::theory::arrays namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arrays
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
#include "context/cdo.h"
-namespace CVC4 {
+namespace CVC5 {
namespace context {
class Context;
-}/* CVC4::context namespace */
+ } // namespace context
namespace theory {
namespace arrays {
}
}
-}/* CVC4::theory::arrays namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace arrays
+} // namespace theory
+} // namespace CVC5
#endif /*CVC4__THEORY__ARRAYS__UNION_FIND_H */
#include "theory/assertion.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
std::ostream& operator<<(std::ostream& out, const Assertion& a) {
return out << a.d_assertion;
}
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** Information about an assertion for the theories. */
std::ostream& operator<<(std::ostream& out, const Assertion& a);
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__ASSERTION_H */
#include "theory/atom_requests.h"
-using namespace CVC4;
+using namespace CVC5;
AtomRequests::AtomRequests(context::Context* context)
: d_allRequests(context)
#include "context/cdhashset.h"
#include "context/cdhashmap.h"
-namespace CVC4 {
+namespace CVC5 {
class AtomRequests {
};
-}
-
-
-
-
+} // namespace CVC5
#include "theory/uf/equality_engine_iterator.h"
using namespace std;
-using namespace CVC4::context;
-using namespace CVC4::kind;
+using namespace CVC5::context;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bags/inference_generator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAG__SOLVER_H */
#include "theory/bags/normal_form.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_histogram.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS__THEORY_BAGS_REWRITER_H */
#include "smt/smt_statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_histogram.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS_STATISTICS_H */
#include "theory/bags/inference_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/inference_id.h"
#include "theory/theory_inference.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class TheoryInferenceManager;
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS__INFER_INFO_H */
#include "theory/bags/solver_state.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "infer_info.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS__INFERENCE_GENERATOR_H */
#include "theory/bags/solver_state.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/inference_manager_buffered.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS__INFERENCE_MANAGER_H */
#
theory THEORY_BAGS \
- ::CVC4::theory::bags::TheoryBags \
+ ::CVC5::theory::bags::TheoryBags \
"theory/bags/theory_bags.h"
typechecker "theory/bags/theory_bags_type_rules.h"
-rewriter ::CVC4::theory::bags::BagsRewriter \
+rewriter ::CVC5::theory::bags::BagsRewriter \
"theory/bags/bags_rewriter.h"
properties parametric
# constants
constant EMPTYBAG \
- ::CVC4::EmptyBag \
- ::CVC4::EmptyBagHashFunction \
+ ::CVC5::EmptyBag \
+ ::CVC5::EmptyBagHashFunction \
"expr/emptybag.h" \
- "the empty bag constant; payload is an instance of the CVC4::EmptyBag class"
+ "the empty bag constant; payload is an instance of the CVC5::EmptyBag class"
# the type
operator BAG_TYPE 1 "bag type, takes as parameter the type of the elements"
cardinality BAG_TYPE \
- "::CVC4::theory::bags::BagsProperties::computeCardinality(%TYPE%)" \
+ "::CVC5::theory::bags::BagsProperties::computeCardinality(%TYPE%)" \
"theory/bags/theory_bags_type_rules.h"
well-founded BAG_TYPE \
- "::CVC4::theory::bags::BagsProperties::isWellFounded(%TYPE%)" \
- "::CVC4::theory::bags::BagsProperties::mkGroundTerm(%TYPE%)" \
+ "::CVC5::theory::bags::BagsProperties::isWellFounded(%TYPE%)" \
+ "::CVC5::theory::bags::BagsProperties::mkGroundTerm(%TYPE%)" \
"theory/bags/theory_bags_type_rules.h"
enumerator BAG_TYPE \
- "::CVC4::theory::bags::BagEnumerator" \
+ "::CVC5::theory::bags::BagEnumerator" \
"theory/bags/theory_bags_type_enumerator.h"
# operators
operator DUPLICATE_REMOVAL 1 "eliminate duplicates in a bag (also known as the delta operator,or the squash operator)"
constant MK_BAG_OP \
- ::CVC4::MakeBagOp \
- ::CVC4::MakeBagOpHashFunction \
+ ::CVC5::MakeBagOp \
+ ::CVC5::MakeBagOpHashFunction \
"theory/bags/make_bag_op.h" \
- "operator for MK_BAG; payload is an instance of the CVC4::MakeBagOp class"
+ "operator for MK_BAG; payload is an instance of the CVC5::MakeBagOp class"
parameterized MK_BAG MK_BAG_OP 2 \
"constructs a bag from one element along with its multiplicity"
# If the bag has cardinality > 1, then (choose A) will deterministically return an element in A.
operator BAG_CHOOSE 1 "return an element in the bag given as a parameter"
-typerule UNION_MAX ::CVC4::theory::bags::BinaryOperatorTypeRule
-typerule UNION_DISJOINT ::CVC4::theory::bags::BinaryOperatorTypeRule
-typerule INTERSECTION_MIN ::CVC4::theory::bags::BinaryOperatorTypeRule
-typerule DIFFERENCE_SUBTRACT ::CVC4::theory::bags::BinaryOperatorTypeRule
-typerule DIFFERENCE_REMOVE ::CVC4::theory::bags::BinaryOperatorTypeRule
-typerule SUBBAG ::CVC4::theory::bags::SubBagTypeRule
-typerule BAG_COUNT ::CVC4::theory::bags::CountTypeRule
-typerule DUPLICATE_REMOVAL ::CVC4::theory::bags::DuplicateRemovalTypeRule
+typerule UNION_MAX ::CVC5::theory::bags::BinaryOperatorTypeRule
+typerule UNION_DISJOINT ::CVC5::theory::bags::BinaryOperatorTypeRule
+typerule INTERSECTION_MIN ::CVC5::theory::bags::BinaryOperatorTypeRule
+typerule DIFFERENCE_SUBTRACT ::CVC5::theory::bags::BinaryOperatorTypeRule
+typerule DIFFERENCE_REMOVE ::CVC5::theory::bags::BinaryOperatorTypeRule
+typerule SUBBAG ::CVC5::theory::bags::SubBagTypeRule
+typerule BAG_COUNT ::CVC5::theory::bags::CountTypeRule
+typerule DUPLICATE_REMOVAL ::CVC5::theory::bags::DuplicateRemovalTypeRule
typerule MK_BAG_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule MK_BAG ::CVC4::theory::bags::MkBagTypeRule
-typerule EMPTYBAG ::CVC4::theory::bags::EmptyBagTypeRule
-typerule BAG_CARD ::CVC4::theory::bags::CardTypeRule
-typerule BAG_CHOOSE ::CVC4::theory::bags::ChooseTypeRule
-typerule BAG_IS_SINGLETON ::CVC4::theory::bags::IsSingletonTypeRule
-typerule BAG_FROM_SET ::CVC4::theory::bags::FromSetTypeRule
-typerule BAG_TO_SET ::CVC4::theory::bags::ToSetTypeRule
+typerule MK_BAG ::CVC5::theory::bags::MkBagTypeRule
+typerule EMPTYBAG ::CVC5::theory::bags::EmptyBagTypeRule
+typerule BAG_CARD ::CVC5::theory::bags::CardTypeRule
+typerule BAG_CHOOSE ::CVC5::theory::bags::ChooseTypeRule
+typerule BAG_IS_SINGLETON ::CVC5::theory::bags::IsSingletonTypeRule
+typerule BAG_FROM_SET ::CVC5::theory::bags::FromSetTypeRule
+typerule BAG_TO_SET ::CVC5::theory::bags::ToSetTypeRule
-construle UNION_DISJOINT ::CVC4::theory::bags::BinaryOperatorTypeRule
-construle MK_BAG ::CVC4::theory::bags::MkBagTypeRule
+construle UNION_DISJOINT ::CVC5::theory::bags::BinaryOperatorTypeRule
+construle MK_BAG ::CVC5::theory::bags::MkBagTypeRule
endtheory
\ No newline at end of file
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, const MakeBagOp& op)
{
return getType() == op.getType();
}
-} // namespace CVC4
+} // namespace CVC5
#include <memory>
-namespace CVC4 {
+namespace CVC5 {
class TypeNode;
size_t operator()(const MakeBagOp& op) const;
}; /* struct MakeBagOpHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__MAKE_BAG_OP_H */
#include "theory/sets/normal_form.h"
#include "theory/type_enumerator.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#ifndef CVC4__THEORY__BAGS__NORMAL_FORM_H
#define CVC4__THEORY__BAGS__NORMAL_FORM_H
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
};
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS__NORMAL_FORM_H */
#include <iostream>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS__REWRITES_H */
#include "theory/uf/equality_engine.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS__THEORY_SOLVER_STATE_H */
#include "theory/bags/solver_state.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "context/cdhashmap.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS__TERM_REGISTRY_H */
#include "theory/rewriter.h"
#include "theory/theory_model.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory.h"
#include "theory/theory_eq_notify.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS__THEORY_BAGS_H */
#include "theory/rewriter.h"
#include "theory_bags_type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
\ No newline at end of file
+} // namespace CVC5
\ No newline at end of file
#include "expr/type_node.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS__TYPE_ENUMERATOR_H */
\ No newline at end of file
#include "base/check.h"
#include "theory/bags/normal_form.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bags {
}
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
class NodeManager;
} // namespace bags
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BAGS__THEORY_BAGS_TYPE_RULES_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofGenerator;
class ProofNode;
} // namespace booleans
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BOOLEANS__CIRCUIT_PROPAGATOR_H */
# src/theory/builtin/kinds.
#
-theory THEORY_BOOL ::CVC4::theory::booleans::TheoryBool "theory/booleans/theory_bool.h"
+theory THEORY_BOOL ::CVC5::theory::booleans::TheoryBool "theory/booleans/theory_bool.h"
typechecker "theory/booleans/theory_bool_type_rules.h"
properties finite
-rewriter ::CVC4::theory::booleans::TheoryBoolRewriter "theory/booleans/theory_bool_rewriter.h"
+rewriter ::CVC5::theory::booleans::TheoryBoolRewriter "theory/booleans/theory_bool_rewriter.h"
sort BOOLEAN_TYPE \
2 \
constant CONST_BOOLEAN \
bool \
- ::CVC4::BoolHashFunction \
+ ::CVC5::BoolHashFunction \
"util/bool.h" \
"truth and falsity; payload is a (C++) bool"
enumerator BOOLEAN_TYPE \
- "::CVC4::theory::booleans::BooleanEnumerator" \
+ "::CVC5::theory::booleans::BooleanEnumerator" \
"theory/booleans/type_enumerator.h"
operator NOT 1 "logical not"
operator XOR 2 "exclusive or (exactly two parameters)"
operator ITE 3 "if-then-else, used for both Boolean and term ITE constructs; first parameter is (Boolean-sorted) condition, second is 'then', third is 'else' and these two parameters must have same base sort"
-typerule CONST_BOOLEAN ::CVC4::theory::boolean::BooleanTypeRule
+typerule CONST_BOOLEAN ::CVC5::theory::boolean::BooleanTypeRule
-typerule NOT ::CVC4::theory::boolean::BooleanTypeRule
-typerule AND ::CVC4::theory::boolean::BooleanTypeRule
-typerule IMPLIES ::CVC4::theory::boolean::BooleanTypeRule
-typerule OR ::CVC4::theory::boolean::BooleanTypeRule
-typerule XOR ::CVC4::theory::boolean::BooleanTypeRule
-typerule ITE ::CVC4::theory::boolean::IteTypeRule
+typerule NOT ::CVC5::theory::boolean::BooleanTypeRule
+typerule AND ::CVC5::theory::boolean::BooleanTypeRule
+typerule IMPLIES ::CVC5::theory::boolean::BooleanTypeRule
+typerule OR ::CVC5::theory::boolean::BooleanTypeRule
+typerule XOR ::CVC5::theory::boolean::BooleanTypeRule
+typerule ITE ::CVC5::theory::boolean::IteTypeRule
endtheory
#include "expr/skolem_manager.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/proof_checker.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BOOLEANS__PROOF_CHECKER_H */
#include "expr/proof_node.h"
#include "expr/proof_node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/proof_rule.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNode;
class ProofNodeManager;
} // namespace booleans
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace booleans {
return Theory::ppAssert(tin, outSubstitutions);
}
-}/* CVC4::theory::booleans namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace booleans
+} // namespace theory
+} // namespace CVC5
#include "theory/booleans/theory_bool_rewriter.h"
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace booleans {
BoolProofRuleChecker d_bProofChecker;
};/* class TheoryBool */
-}/* CVC4::theory::booleans namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace booleans
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__BOOLEANS__THEORY_BOOL_H */
#include "expr/node_value.h"
#include "theory/booleans/theory_bool_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace booleans {
return RewriteResponse(REWRITE_DONE, n);
}
-}/* CVC4::theory::booleans namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace booleans
+} // namespace theory
+} // namespace CVC5
#include "theory/theory_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace booleans {
}; /* class TheoryBoolRewriter */
-}/* CVC4::theory::booleans namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace booleans
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__BOOLEANS__THEORY_BOOL_REWRITER_H */
#ifndef CVC4__THEORY_BOOL_TYPE_RULES_H
#define CVC4__THEORY_BOOL_TYPE_RULES_H
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace boolean {
}
};/* class IteTypeRule */
-}/* CVC4::theory::boolean namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace boolean
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY_BOOL_TYPE_RULES_H */
#include "expr/type_node.h"
#include "expr/kind.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace booleans {
bool isFinished() override { return d_value == DONE; }
};/* class BooleanEnumerator */
-}/* CVC4::theory::booleans namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace booleans
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__BOOLEANS__TYPE_ENUMERATOR_H */
# is with your type checker:
#
# cardinality MY_TYPE \
-# ::CVC4::theory::foo::TheoryFoo::CardinalityComputer(%TYPE%) \
+# ::CVC5::theory::foo::TheoryFoo::CardinalityComputer(%TYPE%) \
# "theory/foo/theory_foo_type_rules.h"
#
# well-founded K wellfoundedness-computer ground-term-computer [header]
# commands.
#
-theory THEORY_BUILTIN ::CVC4::theory::builtin::TheoryBuiltin "theory/builtin/theory_builtin.h"
+theory THEORY_BUILTIN ::CVC5::theory::builtin::TheoryBuiltin "theory/builtin/theory_builtin.h"
typechecker "theory/builtin/theory_builtin_type_rules.h"
properties stable-infinite
# Rewriter responsible for all the terms of the theory
-rewriter ::CVC4::theory::builtin::TheoryBuiltinRewriter "theory/builtin/theory_builtin_rewriter.h"
+rewriter ::CVC5::theory::builtin::TheoryBuiltinRewriter "theory/builtin/theory_builtin_rewriter.h"
sort BUILTIN_OPERATOR_TYPE \
Cardinality::INTEGERS \
# enough (for now) ?
cardinality SORT_TYPE "Cardinality(Cardinality::INTEGERS)"
well-founded SORT_TYPE \
- "::CVC4::theory::builtin::SortProperties::isWellFounded(%TYPE%)" \
- "::CVC4::theory::builtin::SortProperties::mkGroundTerm(%TYPE%)"
+ "::CVC5::theory::builtin::SortProperties::isWellFounded(%TYPE%)" \
+ "::CVC5::theory::builtin::SortProperties::mkGroundTerm(%TYPE%)"
constant UNINTERPRETED_CONSTANT \
- ::CVC4::UninterpretedConstant \
- ::CVC4::UninterpretedConstantHashFunction \
+ ::CVC5::UninterpretedConstant \
+ ::CVC5::UninterpretedConstantHashFunction \
"expr/uninterpreted_constant.h" \
- "the kind of expressions representing uninterpreted constants; payload is an instance of the CVC4::UninterpretedConstant class (used in models)"
-typerule UNINTERPRETED_CONSTANT ::CVC4::theory::builtin::UninterpretedConstantTypeRule
+ "the kind of expressions representing uninterpreted constants; payload is an instance of the CVC5::UninterpretedConstant class (used in models)"
+typerule UNINTERPRETED_CONSTANT ::CVC5::theory::builtin::UninterpretedConstantTypeRule
enumerator SORT_TYPE \
- ::CVC4::theory::builtin::UninterpretedSortEnumerator \
+ ::CVC5::theory::builtin::UninterpretedSortEnumerator \
"theory/builtin/type_enumerator.h"
constant ABSTRACT_VALUE \
- ::CVC4::AbstractValue \
- ::CVC4::AbstractValueHashFunction \
+ ::CVC5::AbstractValue \
+ ::CVC5::AbstractValueHashFunction \
"util/abstract_value.h" \
- "the kind of expressions representing abstract values (other than uninterpreted sort constants); payload is an instance of the CVC4::AbstractValue class (used in models)"
-typerule ABSTRACT_VALUE ::CVC4::theory::builtin::AbstractValueTypeRule
+ "the kind of expressions representing abstract values (other than uninterpreted sort constants); payload is an instance of the CVC5::AbstractValue class (used in models)"
+typerule ABSTRACT_VALUE ::CVC5::theory::builtin::AbstractValueTypeRule
# A kind representing "inlined" operators defined with OPERATOR
# Conceptually, (EQUAL a b) is actually an (APPLY EQUAL a b), but it's
# not stored that way. If you ask for the operator of (EQUAL a b),
# you'll get a special, singleton (BUILTIN EQUAL) Node.
constant BUILTIN \
- ::CVC4::Kind \
- ::CVC4::kind::KindHashFunction \
+ ::CVC5::Kind \
+ ::CVC5::kind::KindHashFunction \
"expr/kind.h" \
"the kind of expressions representing built-in operators"
operator WITNESS 2 "a witness expression; first parameter is a BOUND_VAR_LIST, second is the witness body"
constant TYPE_CONSTANT \
- ::CVC4::TypeConstant \
- ::CVC4::TypeConstantHashFunction \
+ ::CVC5::TypeConstant \
+ ::CVC5::TypeConstantHashFunction \
"expr/kind.h" \
"a representation for basic types"
operator FUNCTION_TYPE 2: "a function type"
cardinality FUNCTION_TYPE \
- "::CVC4::theory::builtin::FunctionProperties::computeCardinality(%TYPE%)" \
+ "::CVC5::theory::builtin::FunctionProperties::computeCardinality(%TYPE%)" \
"theory/builtin/theory_builtin_type_rules.h"
well-founded FUNCTION_TYPE \
- "::CVC4::theory::builtin::FunctionProperties::isWellFounded(%TYPE%)" \
- "::CVC4::theory::builtin::FunctionProperties::mkGroundTerm(%TYPE%)" \
+ "::CVC5::theory::builtin::FunctionProperties::isWellFounded(%TYPE%)" \
+ "::CVC5::theory::builtin::FunctionProperties::mkGroundTerm(%TYPE%)" \
"theory/builtin/theory_builtin_type_rules.h"
enumerator FUNCTION_TYPE \
- ::CVC4::theory::builtin::FunctionEnumerator \
+ ::CVC5::theory::builtin::FunctionEnumerator \
"theory/builtin/type_enumerator.h"
sort SEXPR_TYPE \
Cardinality::INTEGERS \
not-well-founded \
"the type of a symbolic expression"
-typerule EQUAL ::CVC4::theory::builtin::EqualityTypeRule
-typerule DISTINCT ::CVC4::theory::builtin::DistinctTypeRule
-typerule SEXPR ::CVC4::theory::builtin::SExprTypeRule
-typerule LAMBDA ::CVC4::theory::builtin::LambdaTypeRule
-typerule WITNESS ::CVC4::theory::builtin::WitnessTypeRule
+typerule EQUAL ::CVC5::theory::builtin::EqualityTypeRule
+typerule DISTINCT ::CVC5::theory::builtin::DistinctTypeRule
+typerule SEXPR ::CVC5::theory::builtin::SExprTypeRule
+typerule LAMBDA ::CVC5::theory::builtin::LambdaTypeRule
+typerule WITNESS ::CVC5::theory::builtin::WitnessTypeRule
# lambda expressions that are isomorphic to array constants can be considered constants
-construle LAMBDA ::CVC4::theory::builtin::LambdaTypeRule
+construle LAMBDA ::CVC5::theory::builtin::LambdaTypeRule
endtheory
#include "theory/rewriter.h"
#include "theory/theory.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
const char* toString(MethodId id)
} // namespace builtin
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_node.h"
#include "theory/quantifiers/extended_rewrite.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
} // namespace builtin
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BUILTIN__PROOF_CHECKER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/builtin/theory_builtin_rewriter.h"
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BUILTIN__THEORY_BUILTIN_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace builtin {
return Rewriter::rewrite(anode);
}
-}/* CVC4::theory::builtin namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace builtin
+} // namespace theory
+} // namespace CVC5
#include "theory/theory_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace builtin {
static Node getArrayRepresentationForLambda(TNode n);
}; /* class TheoryBuiltinRewriter */
-}/* CVC4::theory::builtin namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace builtin
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__BUILTIN__THEORY_BUILTIN_REWRITER_H */
#include "expr/attribute.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include <sstream>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace builtin {
}
};/* class FuctionProperties */
-}/* CVC4::theory::builtin namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace builtin
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__BUILTIN__THEORY_BUILTIN_TYPE_RULES_H */
#include "theory/builtin/theory_builtin_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace builtin {
return *this;
}
-} /* CVC4::theory::builtin namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace builtin
+} // namespace theory
+} // namespace CVC5
#include "theory/type_enumerator.h"
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace builtin {
Node d_bvl;
}; /* class FunctionEnumerator */
-}/* CVC4::theory::builtin namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace builtin
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__BUILTIN_TYPE_ENUMERATOR_H */
#include "theory/bv/theory_bv_utils.h"
#include "theory/rewriter.h"
-using namespace CVC4;
-using namespace CVC4::theory;
-using namespace CVC4::theory::bv;
-using namespace CVC4::context;
+using namespace CVC5;
+using namespace CVC5::theory;
+using namespace CVC5::theory::bv;
+using namespace CVC5::context;
using namespace std;
-using namespace CVC4::theory::bv::utils;
+using namespace CVC5::theory::bv::utils;
bool AbstractionModule::applyAbstraction(const std::vector<Node>& assertions,
std::vector<Node>& new_assertions)
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
}
}
-}
+} // namespace CVC5
#endif
return (Lit & 1) ? -(Lit >> 1) - 1 : (Lit >> 1) + 1;
}
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
if (!AigBitblaster::s_abcAigNetwork) {
Abc_Start();
s_abcAigNetwork = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1);
- char pName[] = "CVC4::theory::bv::AigNetwork";
+ char pName[] = "CVC5::theory::bv::AigNetwork";
s_abcAigNetwork->pName = Extra_UtilStrsav(pName);
}
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4_USE_ABC
class Cnf_Dat_t_;
typedef Cnf_Dat_t_ Cnf_Dat_t;
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class SatSolver;
}
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__THEORY__BV__BITBLAST__AIG_BITBLASTER_H
#include "theory/bv/theory_bv_utils.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
}
}
-}
+} // namespace CVC5
#endif
#include <ostream>
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__THEORY__BV__BITBLAST__BITBLAST_UTILS_H
#include "theory/valuation.h"
#include "util/resource_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__BITBLAST__BITBLASTER_H */
#include "theory/bv/theory_bv.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "prop/sat_solver.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__THEORY__BV__BITBLAST__EAGER_BITBLASTER_H
#include "theory/rewriter.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "prop/bv_sat_solver_notify.h"
#include "theory/bv/abstraction.h"
-namespace CVC4 {
+namespace CVC5 {
namespace prop {
class CnfStream;
class NullRegistrat;
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__THEORY__BV__BITBLAST__LAZY_BITBLASTER_H
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bv/bitblast/simple_bitblaster.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/theory_model.h"
#include "theory/theory_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bv/bitblast/bitblaster.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bv/bv_solver_lazy.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__THEORY__BV__BV_EAGER_SOLVER_H
#include "theory/bv/theory_bv_utils.h"
using namespace std;
-using namespace CVC4;
-using namespace CVC4::context;
-using namespace CVC4::theory;
-using namespace CVC4::theory::bv;
-using namespace CVC4::theory::bv::utils;
-
-const TermId CVC4::theory::bv::UndefinedTermId = -1;
-const ReasonId CVC4::theory::bv::UndefinedReasonId = -1;
-const ReasonId CVC4::theory::bv::AxiomReasonId = -2;
-
+using namespace CVC5;
+using namespace CVC5::context;
+using namespace CVC5::theory;
+using namespace CVC5::theory::bv;
+using namespace CVC5::theory::bv::utils;
+
+const TermId CVC5::theory::bv::UndefinedTermId = -1;
+const ReasonId CVC5::theory::bv::UndefinedReasonId = -1;
+const ReasonId CVC5::theory::bv::AxiomReasonId = -2;
bool InequalityGraph::addInequality(TNode a, TNode b, bool strict, TNode reason) {
Debug("bv-inequality") << "InequalityGraph::addInequality " << a << " " << b << " strict: " << strict << "\n";
#include "context/cdqueue.h"
#include "context/context.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
}
}
-}
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__BV_INEQUALITY__GRAPH_H */
#include "theory/bv/bv_solver_lazy.h"
#include "theory/bv/theory_bv_utils.h"
-using namespace CVC4::prop;
+using namespace CVC5::prop;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class TheoryModel;
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__BV_QUICK_CHECK_H */
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__BV_SOLVER_H */
#include "theory/bv/theory_bv_utils.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bv/proof_checker.h"
#include "theory/eager_proof_generator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/theory_model.h"
#include "theory/trust_substitutions.h"
-using namespace CVC4::theory::bv::utils;
+using namespace CVC5::theory::bv::utils;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#include "theory/bv/theory_bv.h"
#include "util/hash.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__BV_SOLVER_LAZY_H */
#include "theory/bv/theory_bv_utils.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bv/proof_checker.h"
#include "theory/eager_proof_generator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/uf/equality_engine.h"
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__BV_SUBTHEORY_H */
#include "theory/rewriter.h"
#include "theory/theory_model.h"
-using namespace CVC4::context;
-using namespace CVC4::prop;
-using namespace CVC4::theory::bv::utils;
+using namespace CVC5::context;
+using namespace CVC5::prop;
+using namespace CVC5::theory::bv::utils;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
return mergeExplanations(expls);
}
-} /* namespace CVC4::theory::bv */
+} // namespace bv
} /* namespace CVc4::theory */
-} /* namespace CVC4 */
+} // namespace CVC5
#include "theory/bv/slicer.h"
#include "theory/substitutions.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bv/theory_bv_utils.h"
using namespace std;
-using namespace CVC4::context;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
d_bv->setConflict(final_conflict);
}
-}/* namespace CVC4::theory::bv */
-}/* namespace CVC4::theory */
-}/* namespace CVC4 */
+} // namespace bv
+} // namespace theory
+} // namespace CVC5
#include "theory/bv/bv_subtheory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#include "theory/theory_model.h"
using namespace std;
-using namespace CVC4;
-using namespace CVC4::context;
-using namespace CVC4::theory;
-using namespace CVC4::theory::bv;
-using namespace CVC4::theory::bv::utils;
+using namespace CVC5;
+using namespace CVC5::context;
+using namespace CVC5::theory;
+using namespace CVC5::theory::bv;
+using namespace CVC5::theory::bv::utils;
bool CoreSolverExtTheoryCallback::getCurrentSubstitution(
int effort,
#include "theory/bv/bv_subtheory.h"
#include "theory/ext_theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
}
}
-}
+} // namespace CVC5
#include "theory/theory_model.h"
using namespace std;
-using namespace CVC4;
-using namespace CVC4::context;
-using namespace CVC4::theory;
-using namespace CVC4::theory::bv;
-using namespace CVC4::theory::bv::utils;
+using namespace CVC5;
+using namespace CVC5::context;
+using namespace CVC5::theory;
+using namespace CVC5::theory::bv;
+using namespace CVC5::theory::bv::utils;
bool InequalitySolver::check(Theory::Effort e) {
Debug("bv-subtheory-inequality") << "InequalitySolveR::check("<< e <<")\n";
#include "theory/bv/bv_inequality_graph.h"
#include "theory/bv/bv_subtheory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__BV_SUBTHEORY__INEQUALITY_H */
#include "options/smt_options.h"
#include "theory/arith/nl/iand_utils.h"
-namespace CVC4 {
+namespace CVC5 {
/*
** Converts bit-vector formulas to integer formulas.
bool d_introduceFreshIntVars;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* __CVC4__THEORY__BV__INT_BLASTER_H */
# src/theory/builtin/kinds.
#
-theory THEORY_BV ::CVC4::theory::bv::TheoryBV "theory/bv/theory_bv.h"
+theory THEORY_BV ::CVC5::theory::bv::TheoryBV "theory/bv/theory_bv.h"
typechecker "theory/bv/theory_bv_type_rules.h"
properties finite
properties check propagate presolve ppStaticLearn
-rewriter ::CVC4::theory::bv::TheoryBVRewriter "theory/bv/theory_bv_rewriter.h"
+rewriter ::CVC5::theory::bv::TheoryBVRewriter "theory/bv/theory_bv_rewriter.h"
constant BITVECTOR_TYPE \
- ::CVC4::BitVectorSize \
- "::CVC4::UnsignedHashFunction< ::CVC4::BitVectorSize >" \
+ ::CVC5::BitVectorSize \
+ "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorSize >" \
"util/bitvector.h" \
"bit-vector type"
cardinality BITVECTOR_TYPE \
- "::CVC4::theory::bv::CardinalityComputer::computeCardinality(%TYPE%)" \
+ "::CVC5::theory::bv::CardinalityComputer::computeCardinality(%TYPE%)" \
"theory/bv/theory_bv_type_rules.h"
constant CONST_BITVECTOR \
- ::CVC4::BitVector \
- ::CVC4::BitVectorHashFunction \
+ ::CVC5::BitVector \
+ ::CVC5::BitVectorHashFunction \
"util/bitvector.h" \
- "a fixed-width bit-vector constant; payload is an instance of the CVC4::BitVector class"
+ "a fixed-width bit-vector constant; payload is an instance of the CVC5::BitVector class"
enumerator BITVECTOR_TYPE \
- "::CVC4::theory::bv::BitVectorEnumerator" \
+ "::CVC5::theory::bv::BitVectorEnumerator" \
"theory/bv/type_enumerator.h"
well-founded BITVECTOR_TYPE \
true \
- "(*CVC4::theory::TypeEnumerator(%TYPE%))" \
+ "(*CVC5::theory::TypeEnumerator(%TYPE%))" \
"theory/type_enumerator.h"
### non-parameterized operator kinds ------------------------------------------
### parameterized operator kinds ----------------------------------------------
constant BITVECTOR_BITOF_OP \
- ::CVC4::BitVectorBitOf \
- ::CVC4::BitVectorBitOfHashFunction \
+ ::CVC5::BitVectorBitOf \
+ ::CVC5::BitVectorBitOfHashFunction \
"util/bitvector.h" \
- "operator for the bit-vector boolean bit extract; payload is an instance of the CVC4::BitVectorBitOf class"
+ "operator for the bit-vector boolean bit extract; payload is an instance of the CVC5::BitVectorBitOf class"
parameterized BITVECTOR_BITOF BITVECTOR_BITOF_OP 1 "bit-vector boolean bit extract; first parameter is a BITVECTOR_BITOF_OP, second is a bit-vector term"
constant BITVECTOR_EXTRACT_OP \
- ::CVC4::BitVectorExtract \
- ::CVC4::BitVectorExtractHashFunction \
+ ::CVC5::BitVectorExtract \
+ ::CVC5::BitVectorExtractHashFunction \
"util/bitvector.h" \
- "operator for the bit-vector extract; payload is an instance of the CVC4::BitVectorExtract class"
+ "operator for the bit-vector extract; payload is an instance of the CVC5::BitVectorExtract class"
parameterized BITVECTOR_EXTRACT BITVECTOR_EXTRACT_OP 1 "bit-vector extract; first parameter is a BITVECTOR_EXTRACT_OP, second is a bit-vector term"
constant BITVECTOR_REPEAT_OP \
- ::CVC4::BitVectorRepeat \
- "::CVC4::UnsignedHashFunction< ::CVC4::BitVectorRepeat >" \
+ ::CVC5::BitVectorRepeat \
+ "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorRepeat >" \
"util/bitvector.h" \
- "operator for the bit-vector repeat; payload is an instance of the CVC4::BitVectorRepeat class"
+ "operator for the bit-vector repeat; payload is an instance of the CVC5::BitVectorRepeat class"
parameterized BITVECTOR_REPEAT BITVECTOR_REPEAT_OP 1 "bit-vector repeat; first parameter is a BITVECTOR_REPEAT_OP, second is a bit-vector term"
constant BITVECTOR_ROTATE_LEFT_OP \
- ::CVC4::BitVectorRotateLeft \
- "::CVC4::UnsignedHashFunction< ::CVC4::BitVectorRotateLeft >" \
+ ::CVC5::BitVectorRotateLeft \
+ "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorRotateLeft >" \
"util/bitvector.h" \
- "operator for the bit-vector rotate left; payload is an instance of the CVC4::BitVectorRotateLeft class"
+ "operator for the bit-vector rotate left; payload is an instance of the CVC5::BitVectorRotateLeft class"
parameterized BITVECTOR_ROTATE_LEFT BITVECTOR_ROTATE_LEFT_OP 1 "bit-vector rotate left; first parameter is a BITVECTOR_ROTATE_LEFT_OP, second is a bit-vector term"
constant BITVECTOR_ROTATE_RIGHT_OP \
- ::CVC4::BitVectorRotateRight \
- "::CVC4::UnsignedHashFunction< ::CVC4::BitVectorRotateRight >" \
+ ::CVC5::BitVectorRotateRight \
+ "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorRotateRight >" \
"util/bitvector.h" \
- "operator for the bit-vector rotate right; payload is an instance of the CVC4::BitVectorRotateRight class"
+ "operator for the bit-vector rotate right; payload is an instance of the CVC5::BitVectorRotateRight class"
parameterized BITVECTOR_ROTATE_RIGHT BITVECTOR_ROTATE_RIGHT_OP 1 "bit-vector rotate right; first parameter is a BITVECTOR_ROTATE_RIGHT_OP, second is a bit-vector term"
constant BITVECTOR_SIGN_EXTEND_OP \
- ::CVC4::BitVectorSignExtend \
- "::CVC4::UnsignedHashFunction< ::CVC4::BitVectorSignExtend >" \
+ ::CVC5::BitVectorSignExtend \
+ "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorSignExtend >" \
"util/bitvector.h" \
- "operator for the bit-vector sign-extend; payload is an instance of the CVC4::BitVectorSignExtend class"
+ "operator for the bit-vector sign-extend; payload is an instance of the CVC5::BitVectorSignExtend class"
parameterized BITVECTOR_SIGN_EXTEND BITVECTOR_SIGN_EXTEND_OP 1 "bit-vector sign-extend; first parameter is a BITVECTOR_SIGN_EXTEND_OP, second is a bit-vector term"
constant BITVECTOR_ZERO_EXTEND_OP \
- ::CVC4::BitVectorZeroExtend \
- "::CVC4::UnsignedHashFunction< ::CVC4::BitVectorZeroExtend >" \
+ ::CVC5::BitVectorZeroExtend \
+ "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorZeroExtend >" \
"util/bitvector.h" \
- "operator for the bit-vector zero-extend; payload is an instance of the CVC4::BitVectorZeroExtend class"
+ "operator for the bit-vector zero-extend; payload is an instance of the CVC5::BitVectorZeroExtend class"
parameterized BITVECTOR_ZERO_EXTEND BITVECTOR_ZERO_EXTEND_OP 1 "bit-vector zero-extend; first parameter is a BITVECTOR_ZERO_EXTEND_OP, second is a bit-vector term"
constant INT_TO_BITVECTOR_OP \
- ::CVC4::IntToBitVector \
- "::CVC4::UnsignedHashFunction< ::CVC4::IntToBitVector >" \
+ ::CVC5::IntToBitVector \
+ "::CVC5::UnsignedHashFunction< ::CVC5::IntToBitVector >" \
"util/bitvector.h" \
- "operator for the integer conversion to bit-vector; payload is an instance of the CVC4::IntToBitVector class"
+ "operator for the integer conversion to bit-vector; payload is an instance of the CVC5::IntToBitVector class"
parameterized INT_TO_BITVECTOR INT_TO_BITVECTOR_OP 1 "integer conversion to bit-vector; first parameter is an INT_TO_BITVECTOR_OP, second is an integer term"
### type rules for non-parameterized operator kinds ---------------------------
-typerule CONST_BITVECTOR ::CVC4::theory::bv::BitVectorConstantTypeRule
+typerule CONST_BITVECTOR ::CVC5::theory::bv::BitVectorConstantTypeRule
## concatentation kind
-typerule BITVECTOR_CONCAT ::CVC4::theory::bv::BitVectorConcatTypeRule
+typerule BITVECTOR_CONCAT ::CVC5::theory::bv::BitVectorConcatTypeRule
## bit-wise kinds
-typerule BITVECTOR_AND ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_COMP ::CVC4::theory::bv::BitVectorBVPredTypeRule
-typerule BITVECTOR_NAND ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_NOR ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_NOT ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_OR ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_XNOR ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_XOR ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_AND ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_COMP ::CVC5::theory::bv::BitVectorBVPredTypeRule
+typerule BITVECTOR_NAND ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_NOR ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_NOT ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_OR ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_XNOR ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_XOR ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
## arithmetic kinds
-typerule BITVECTOR_MULT ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_NEG ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_PLUS ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_SUB ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_UDIV ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_UREM ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_SDIV ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_SMOD ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_SREM ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_MULT ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_NEG ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_PLUS ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_SUB ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_UDIV ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_UREM ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_SDIV ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_SMOD ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_SREM ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
## shift kinds
-typerule BITVECTOR_ASHR ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_LSHR ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_SHL ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_ASHR ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_LSHR ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_SHL ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
## inequality kinds
-typerule BITVECTOR_ULE ::CVC4::theory::bv::BitVectorPredicateTypeRule
-typerule BITVECTOR_ULT ::CVC4::theory::bv::BitVectorPredicateTypeRule
-typerule BITVECTOR_UGE ::CVC4::theory::bv::BitVectorPredicateTypeRule
-typerule BITVECTOR_UGT ::CVC4::theory::bv::BitVectorPredicateTypeRule
-typerule BITVECTOR_SLE ::CVC4::theory::bv::BitVectorPredicateTypeRule
-typerule BITVECTOR_SLT ::CVC4::theory::bv::BitVectorPredicateTypeRule
-typerule BITVECTOR_SGE ::CVC4::theory::bv::BitVectorPredicateTypeRule
-typerule BITVECTOR_SGT ::CVC4::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_ULE ::CVC5::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_ULT ::CVC5::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_UGE ::CVC5::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_UGT ::CVC5::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_SLE ::CVC5::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_SLT ::CVC5::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_SGE ::CVC5::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_SGT ::CVC5::theory::bv::BitVectorPredicateTypeRule
# inequalities with return type bit-vector of size 1
-typerule BITVECTOR_ULTBV ::CVC4::theory::bv::BitVectorBVPredTypeRule
-typerule BITVECTOR_SLTBV ::CVC4::theory::bv::BitVectorBVPredTypeRule
+typerule BITVECTOR_ULTBV ::CVC5::theory::bv::BitVectorBVPredTypeRule
+typerule BITVECTOR_SLTBV ::CVC5::theory::bv::BitVectorBVPredTypeRule
## if-then-else kind
-typerule BITVECTOR_ITE ::CVC4::theory::bv::BitVectorITETypeRule
+typerule BITVECTOR_ITE ::CVC5::theory::bv::BitVectorITETypeRule
## reduction kinds
-typerule BITVECTOR_REDAND ::CVC4::theory::bv::BitVectorUnaryPredicateTypeRule
-typerule BITVECTOR_REDOR ::CVC4::theory::bv::BitVectorUnaryPredicateTypeRule
+typerule BITVECTOR_REDAND ::CVC5::theory::bv::BitVectorUnaryPredicateTypeRule
+typerule BITVECTOR_REDOR ::CVC5::theory::bv::BitVectorUnaryPredicateTypeRule
## conversion kinds
-typerule BITVECTOR_TO_NAT ::CVC4::theory::bv::BitVectorConversionTypeRule
+typerule BITVECTOR_TO_NAT ::CVC5::theory::bv::BitVectorConversionTypeRule
## internal kinds
-typerule BITVECTOR_ACKERMANNIZE_UDIV ::CVC4::theory::bv::BitVectorAckermanizationUdivTypeRule
-typerule BITVECTOR_ACKERMANNIZE_UREM ::CVC4::theory::bv::BitVectorAckermanizationUremTypeRule
-typerule BITVECTOR_EAGER_ATOM ::CVC4::theory::bv::BitVectorEagerAtomTypeRule
+typerule BITVECTOR_ACKERMANNIZE_UDIV ::CVC5::theory::bv::BitVectorAckermanizationUdivTypeRule
+typerule BITVECTOR_ACKERMANNIZE_UREM ::CVC5::theory::bv::BitVectorAckermanizationUremTypeRule
+typerule BITVECTOR_EAGER_ATOM ::CVC5::theory::bv::BitVectorEagerAtomTypeRule
### type rules for parameterized operator kinds -------------------------------
typerule BITVECTOR_BITOF_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_BITOF ::CVC4::theory::bv::BitVectorBitOfTypeRule
+typerule BITVECTOR_BITOF ::CVC5::theory::bv::BitVectorBitOfTypeRule
typerule BITVECTOR_EXTRACT_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_EXTRACT ::CVC4::theory::bv::BitVectorExtractTypeRule
+typerule BITVECTOR_EXTRACT ::CVC5::theory::bv::BitVectorExtractTypeRule
typerule BITVECTOR_REPEAT_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_REPEAT ::CVC4::theory::bv::BitVectorRepeatTypeRule
+typerule BITVECTOR_REPEAT ::CVC5::theory::bv::BitVectorRepeatTypeRule
typerule BITVECTOR_ROTATE_LEFT_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_ROTATE_LEFT ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_ROTATE_LEFT ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
typerule BITVECTOR_ROTATE_RIGHT_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_ROTATE_RIGHT ::CVC4::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_ROTATE_RIGHT ::CVC5::theory::bv::BitVectorFixedWidthTypeRule
typerule BITVECTOR_SIGN_EXTEND_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_SIGN_EXTEND ::CVC4::theory::bv::BitVectorExtendTypeRule
+typerule BITVECTOR_SIGN_EXTEND ::CVC5::theory::bv::BitVectorExtendTypeRule
typerule BITVECTOR_ZERO_EXTEND_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_ZERO_EXTEND ::CVC4::theory::bv::BitVectorExtendTypeRule
-typerule INT_TO_BITVECTOR_OP ::CVC4::theory::bv::IntToBitVectorOpTypeRule
-typerule INT_TO_BITVECTOR ::CVC4::theory::bv::BitVectorConversionTypeRule
+typerule BITVECTOR_ZERO_EXTEND ::CVC5::theory::bv::BitVectorExtendTypeRule
+typerule INT_TO_BITVECTOR_OP ::CVC5::theory::bv::IntToBitVectorOpTypeRule
+typerule INT_TO_BITVECTOR ::CVC5::theory::bv::BitVectorConversionTypeRule
endtheory
#include "theory/bv/proof_checker.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_node.h"
#include "theory/bv/bitblast/simple_bitblaster.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__PROOF_CHECKER_H */
#include "theory/bv/theory_bv_utils.h"
#include "theory/rewriter.h"
-using namespace std;
+using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include <vector>
#include "util/index.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
}
return true;
}
-};
+};
-}/* CVC4::theory::bv namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace bv
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__SLICER_BV_H */
#include "theory/bv/theory_bv_utils.h"
#include "theory/ee_setup_info.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_eq_notify.h"
#include "theory/theory_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__THEORY_BV_H */
#include "theory/theory.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // End namespace bv
} // End namespace theory
-} // End namespace CVC4
+} // End namespace CVC5
#include "theory/bv/theory_bv_rewrite_rules.h"
#include "theory/bv/theory_bv_utils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
}
}
-}
+} // namespace CVC5
#include "theory/bv/theory_bv_rewrite_rules.h"
#include "theory/bv/theory_bv_utils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
}
}
-}
+} // namespace CVC5
#include "theory/bv/theory_bv_utils.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
}
}
-}
+} // namespace CVC5
#include "theory/bv/theory_bv_rewrite_rules.h"
#include "theory/bv/theory_bv_utils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
}
}
-}
+} // namespace CVC5
#include "theory/bv/theory_bv_utils.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bv/theory_bv_rewriter.h"
#include "theory/theory.h"
-using namespace CVC4;
-using namespace CVC4::theory;
-using namespace CVC4::theory::bv;
+using namespace CVC5;
+using namespace CVC5::theory;
+using namespace CVC5::theory::bv;
TheoryBVRewriter::TheoryBVRewriter() { initializeRewrites(); }
#include "theory/theory_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
RewriteFunction d_rewriteTable[kind::LAST_KIND];
}; /* class TheoryBVRewriter */
-}/* CVC4::theory::bv namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace bv
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__THEORY_BV_REWRITER_H */
#ifndef CVC4__THEORY__BV__THEORY_BV_TYPE_RULES_H
#define CVC4__THEORY__BV__THEORY_BV_TYPE_RULES_H
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__THEORY_BV_TYPE_RULES_H */
#include "options/theory_options.h"
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
namespace utils {
return Node(result);
}
-}/* CVC4::theory::bv::utils namespace */
-}/* CVC4::theory::bv namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace utils
+} // namespace bv
+} // namespace theory
+} // namespace CVC5
#include "expr/node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
}
}
}
-}
+} // namespace CVC5
#include "util/bitvector.h"
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace bv {
bool isFinished() override { return d_bits != d_bits.modByPow2(d_size); }
};/* BitVectorEnumerator */
-}/* CVC4::theory::bv namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace bv
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__BV__TYPE_ENUMERATOR_H */
#include "expr/node.h"
#include "theory/theory_id.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
typedef std::set<CarePair> CareGraph;
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__CARE_GRAPH_H */
#include "theory/model_manager.h"
#include "theory/theory_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
CombinationCareGraph::CombinationCareGraph(
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/combination_engine.h"
-namespace CVC4 {
+namespace CVC5 {
class TheoryEngine;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__COMBINATION_DISTRIBUTED__H */
#include "theory/shared_solver_distributed.h"
#include "theory/theory_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
CombinationEngine::CombinationEngine(TheoryEngine& te,
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/ee_manager.h"
#include "theory/valuation.h"
-namespace CVC4 {
+namespace CVC5 {
class TheoryEngine;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__COMBINATION_DISTRIBUTED__H */
#include "theory/datatypes/sygus_datatype_utils.h"
#include "theory/datatypes/theory_datatypes_utils.h"
-using namespace CVC4;
-using namespace CVC4::kind;
+using namespace CVC5;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
return n;
}
-} /* CVC4::theory::datatypes namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace datatypes
+} // namespace theory
+} // namespace CVC5
#include "theory/theory_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
unsigned depth);
}; /* class DatatypesRewriter */
-}/* CVC4::theory::datatypes namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace datatypes
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__DATATYPES__DATATYPES_REWRITER_H */
#include "theory/model_manager.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_generator.h"
#include "theory/datatypes/inference.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__DATATYPES__INFER_PROOF_CONS_H */
#include "theory/datatypes/inference_manager.h"
#include "theory/theory.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_inference.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/theory_state.h"
#include "theory/trust_substitutions.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/datatypes/infer_proof_cons.h"
#include "theory/inference_manager_buffered.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class EagerProofGenerator;
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
# src/theory/builtin/kinds.
#
-theory THEORY_DATATYPES ::CVC4::theory::datatypes::TheoryDatatypes "theory/datatypes/theory_datatypes.h"
+theory THEORY_DATATYPES ::CVC5::theory::datatypes::TheoryDatatypes "theory/datatypes/theory_datatypes.h"
typechecker "theory/datatypes/theory_datatypes_type_rules.h"
properties check parametric
-rewriter ::CVC4::theory::datatypes::DatatypesRewriter "theory/datatypes/datatypes_rewriter.h"
+rewriter ::CVC5::theory::datatypes::DatatypesRewriter "theory/datatypes/datatypes_rewriter.h"
# constructor type has a list of selector types followed by a return type
operator CONSTRUCTOR_TYPE 1: "constructor"
cardinality CONSTRUCTOR_TYPE \
- "::CVC4::theory::datatypes::ConstructorProperties::computeCardinality(%TYPE%)" \
+ "::CVC5::theory::datatypes::ConstructorProperties::computeCardinality(%TYPE%)" \
"theory/datatypes/theory_datatypes_type_rules.h"
# selector type has domain type and a range type
operator SELECTOR_TYPE 2 "selector"
# can re-use function cardinality
cardinality SELECTOR_TYPE \
- "::CVC4::theory::builtin::FunctionProperties::computeCardinality(%TYPE%)" \
+ "::CVC5::theory::builtin::FunctionProperties::computeCardinality(%TYPE%)" \
"theory/builtin/theory_builtin_type_rules.h"
# tester type has a constructor type
operator TESTER_TYPE 1 "tester"
# can re-use function cardinality
cardinality TESTER_TYPE \
- "::CVC4::theory::builtin::FunctionProperties::computeCardinality(%TYPE%)" \
+ "::CVC5::theory::builtin::FunctionProperties::computeCardinality(%TYPE%)" \
"theory/builtin/theory_builtin_type_rules.h"
parameterized APPLY_CONSTRUCTOR APPLY_TYPE_ASCRIPTION 0: "constructor application; first parameter is the constructor, remaining parameters (if any) are parameters to the constructor"
parameterized APPLY_TESTER TESTER_TYPE 1 "tester application; first parameter is a tester, second is a datatype term"
constant DATATYPE_TYPE \
- ::CVC4::DatatypeIndexConstant \
- "::CVC4::DatatypeIndexConstantHashFunction" \
+ ::CVC5::DatatypeIndexConstant \
+ "::CVC5::DatatypeIndexConstantHashFunction" \
"expr/datatype_index.h" \
"a datatype type index"
cardinality DATATYPE_TYPE \
"expr/dtype.h"
enumerator DATATYPE_TYPE \
- "::CVC4::theory::datatypes::DatatypesEnumerator" \
+ "::CVC5::theory::datatypes::DatatypesEnumerator" \
"theory/datatypes/type_enumerator.h"
operator PARAMETRIC_DATATYPE 1: "parametric datatype"
"expr/dtype.h"
enumerator PARAMETRIC_DATATYPE \
- "::CVC4::theory::datatypes::DatatypesEnumerator" \
+ "::CVC5::theory::datatypes::DatatypesEnumerator" \
"theory/datatypes/type_enumerator.h"
parameterized APPLY_TYPE_ASCRIPTION ASCRIPTION_TYPE 1 \
"type ascription, for datatype constructor applications; first parameter is an ASCRIPTION_TYPE, second is the datatype constructor application being ascribed"
constant ASCRIPTION_TYPE \
- ::CVC4::AscriptionType \
- ::CVC4::AscriptionTypeHashFunction \
+ ::CVC5::AscriptionType \
+ ::CVC5::AscriptionTypeHashFunction \
"expr/ascription_type.h" \
- "a type parameter for type ascription; payload is an instance of the CVC4::AscriptionType class"
+ "a type parameter for type ascription; payload is an instance of the CVC5::AscriptionType class"
-typerule APPLY_CONSTRUCTOR ::CVC4::theory::datatypes::DatatypeConstructorTypeRule
-typerule APPLY_SELECTOR ::CVC4::theory::datatypes::DatatypeSelectorTypeRule
-typerule APPLY_SELECTOR_TOTAL ::CVC4::theory::datatypes::DatatypeSelectorTypeRule
-typerule APPLY_TESTER ::CVC4::theory::datatypes::DatatypeTesterTypeRule
-typerule APPLY_TYPE_ASCRIPTION ::CVC4::theory::datatypes::DatatypeAscriptionTypeRule
+typerule APPLY_CONSTRUCTOR ::CVC5::theory::datatypes::DatatypeConstructorTypeRule
+typerule APPLY_SELECTOR ::CVC5::theory::datatypes::DatatypeSelectorTypeRule
+typerule APPLY_SELECTOR_TOTAL ::CVC5::theory::datatypes::DatatypeSelectorTypeRule
+typerule APPLY_TESTER ::CVC5::theory::datatypes::DatatypeTesterTypeRule
+typerule APPLY_TYPE_ASCRIPTION ::CVC5::theory::datatypes::DatatypeAscriptionTypeRule
# constructor applications are constant if they are applied only to constants
-construle APPLY_CONSTRUCTOR ::CVC4::theory::datatypes::DatatypeConstructorTypeRule
+construle APPLY_CONSTRUCTOR ::CVC5::theory::datatypes::DatatypeConstructorTypeRule
constant TUPLE_UPDATE_OP \
- ::CVC4::TupleUpdate \
- ::CVC4::TupleUpdateHashFunction \
+ ::CVC5::TupleUpdate \
+ ::CVC5::TupleUpdateHashFunction \
"util/tuple.h" \
- "operator for a tuple update; payload is an instance of the CVC4::TupleUpdate class"
+ "operator for a tuple update; payload is an instance of the CVC5::TupleUpdate class"
parameterized TUPLE_UPDATE TUPLE_UPDATE_OP 2 "tuple update; first parameter is a TUPLE_UPDATE_OP (which references an index), second is the tuple, third is the element to store in the tuple at the given index"
-typerule TUPLE_UPDATE_OP ::CVC4::theory::datatypes::TupleUpdateOpTypeRule
-typerule TUPLE_UPDATE ::CVC4::theory::datatypes::TupleUpdateTypeRule
+typerule TUPLE_UPDATE_OP ::CVC5::theory::datatypes::TupleUpdateOpTypeRule
+typerule TUPLE_UPDATE ::CVC5::theory::datatypes::TupleUpdateTypeRule
constant RECORD_UPDATE_OP \
- ::CVC4::RecordUpdate \
- ::CVC4::RecordUpdateHashFunction \
+ ::CVC5::RecordUpdate \
+ ::CVC5::RecordUpdateHashFunction \
"expr/record.h" \
- "operator for a record update; payload is an instance CVC4::RecordUpdate class"
+ "operator for a record update; payload is an instance CVC5::RecordUpdate class"
parameterized RECORD_UPDATE RECORD_UPDATE_OP 2 "record update; first parameter is a RECORD_UPDATE_OP (which references a field), second is a record term to update, third is the element to store in the record in the given field"
-typerule RECORD_UPDATE_OP ::CVC4::theory::datatypes::RecordUpdateOpTypeRule
-typerule RECORD_UPDATE ::CVC4::theory::datatypes::RecordUpdateTypeRule
+typerule RECORD_UPDATE_OP ::CVC5::theory::datatypes::RecordUpdateOpTypeRule
+typerule RECORD_UPDATE ::CVC5::theory::datatypes::RecordUpdateTypeRule
operator DT_SIZE 1 "datatypes size"
-typerule DT_SIZE ::CVC4::theory::datatypes::DtSizeTypeRule
+typerule DT_SIZE ::CVC5::theory::datatypes::DtSizeTypeRule
operator DT_HEIGHT_BOUND 2 "datatypes height bound"
-typerule DT_HEIGHT_BOUND ::CVC4::theory::datatypes::DtBoundTypeRule
+typerule DT_HEIGHT_BOUND ::CVC5::theory::datatypes::DtBoundTypeRule
operator DT_SIZE_BOUND 2 "datatypes height bound"
-typerule DT_SIZE_BOUND ::CVC4::theory::datatypes::DtBoundTypeRule
+typerule DT_SIZE_BOUND ::CVC5::theory::datatypes::DtBoundTypeRule
operator DT_SYGUS_BOUND 2 "datatypes sygus bound"
-typerule DT_SYGUS_BOUND ::CVC4::theory::datatypes::DtSygusBoundTypeRule
+typerule DT_SYGUS_BOUND ::CVC5::theory::datatypes::DtSygusBoundTypeRule
operator DT_SYGUS_EVAL 1: "datatypes sygus evaluation function"
-typerule DT_SYGUS_EVAL ::CVC4::theory::datatypes::DtSyguEvalTypeRule
+typerule DT_SYGUS_EVAL ::CVC5::theory::datatypes::DtSyguEvalTypeRule
# Kinds for match terms. For example, the match term
operator MATCH_CASE 2 "a match case"
operator MATCH_BIND_CASE 3 "a match case with bound variables"
-typerule MATCH ::CVC4::theory::datatypes::MatchTypeRule
-typerule MATCH_CASE ::CVC4::theory::datatypes::MatchCaseTypeRule
-typerule MATCH_BIND_CASE ::CVC4::theory::datatypes::MatchBindCaseTypeRule
+typerule MATCH ::CVC5::theory::datatypes::MatchTypeRule
+typerule MATCH_CASE ::CVC5::theory::datatypes::MatchCaseTypeRule
+typerule MATCH_BIND_CASE ::CVC5::theory::datatypes::MatchBindCaseTypeRule
constant TUPLE_PROJECT_OP \
- ::CVC4::TupleProjectOp \
- ::CVC4::TupleProjectOpHashFunction \
+ ::CVC5::TupleProjectOp \
+ ::CVC5::TupleProjectOpHashFunction \
"theory/datatypes/tuple_project_op.h" \
- "operator for TUPLE_PROJECT; payload is an instance of the CVC4::TupleProjectOp class"
+ "operator for TUPLE_PROJECT; payload is an instance of the CVC5::TupleProjectOp class"
parameterized TUPLE_PROJECT TUPLE_PROJECT_OP 1 \
"projects a tuple from an existing tuple using indices passed in TupleProjectOp"
typerule TUPLE_PROJECT_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule TUPLE_PROJECT ::CVC4::theory::datatypes::TupleProjectTypeRule
+typerule TUPLE_PROJECT ::CVC5::theory::datatypes::TupleProjectTypeRule
endtheory
#include "theory/datatypes/theory_datatypes_utils.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_checker.h"
#include "expr/proof_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__DATATYPES__PROOF_CHECKER_H */
#include "theory/evaluator.h"
#include "theory/rewriter.h"
-using namespace CVC4;
-using namespace CVC4::kind;
+using namespace CVC5;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
namespace utils {
} // namespace utils
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node_manager_attributes.h"
#include "theory/datatypes/theory_datatypes_utils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
// ----------------------- sygus datatype attributes
} // namespace utils
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/theory_model.h"
#include "theory/theory_state.h"
-using namespace CVC4;
-using namespace CVC4::kind;
-using namespace CVC4::context;
-using namespace CVC4::theory;
-using namespace CVC4::theory::datatypes;
+using namespace CVC5;
+using namespace CVC5::kind;
+using namespace CVC5::context;
+using namespace CVC5::theory;
+using namespace CVC5::theory::datatypes;
SygusExtension::SygusExtension(TheoryState& s,
InferenceManager& im,
#include "theory/quantifiers/sygus_sampler.h"
#include "theory/quantifiers/term_database.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
class SynthConjecture;
}
}
-}
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_util.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/dtype.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__DATATYPES__SIMPLE_SYM_BREAK_H */
#include "theory/valuation.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
return make_pair(false, Node::null());
}
-} /* namepsace CVC4::theory::datatypes */
-} /* namepsace CVC4::theory */
-} /* namepsace CVC4 */
+} // namespace datatypes
+} // namespace theory
+} // namespace CVC5
#include "theory/uf/equality_engine.h"
#include "util/hash.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
DatatypesProofRuleChecker d_pchecker;
};/* class TheoryDatatypes */
-}/* CVC4::theory::datatypes namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace datatypes
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__DATATYPES__THEORY_DATATYPES_H */
#include "expr/type_matcher.h"
#include "theory/datatypes/theory_datatypes_utils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
}
}; /* class TupleProjectTypeRule */
-} /* CVC4::theory::datatypes namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace datatypes
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__DATATYPES__THEORY_DATATYPES_TYPE_RULES_H */
#include "expr/dtype.h"
#include "expr/dtype_cons.h"
-using namespace CVC4;
-using namespace CVC4::kind;
+using namespace CVC5;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
namespace utils {
} // namespace utils
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/node_manager_attributes.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
namespace utils {
} // namespace utils
} // namespace datatypes
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, const TupleProjectOp& op)
{
return d_indices == op.d_indices;
}
-} // namespace CVC4
+} // namespace CVC5
#include <ostream>
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
class TypeNode;
size_t operator()(const TupleProjectOp& op) const;
}; /* struct TupleProjectOpHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__PROJECT_OP_H */
#include "theory/datatypes/datatypes_rewriter.h"
#include "theory/datatypes/theory_datatypes_utils.h"
-using namespace CVC4;
+using namespace CVC5;
using namespace theory;
using namespace datatypes;
#include "options/quantifiers_options.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace datatypes {
};/* DatatypesEnumerator */
-}/* CVC4::theory::datatypes namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace datatypes
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__DATATYPES__TYPE_ENUMERATOR_H */
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
DecisionManager::DecisionManager(context::Context* userContext)
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "context/cdlist.h"
#include "theory/decision_strategy.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** DecisionManager
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__DECISION_MANAGER__H */
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
DecisionStrategyFmf::DecisionStrategyFmf(context::Context* satContext,
Node DecisionStrategySingleton::getSingleLiteral() { return d_literal; }
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/valuation.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__DECISION_STRATEGY__H */
#include "expr/proof_node.h"
#include "expr/proof_node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
EagerProofGenerator::EagerProofGenerator(ProofNodeManager* pnm,
std::string EagerProofGenerator::identify() const { return d_name; }
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_rule.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNode;
class ProofNodeManager;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__PROOF_GENERATOR_H */
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
EqEngineManager::EqEngineManager(TheoryEngine& te, SharedSolver& shs)
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
class TheoryEngine;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__EE_MANAGER__H */
#include "theory/theory_engine.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
EqEngineManagerDistributed::EqEngineManagerDistributed(TheoryEngine& te,
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/ee_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__EE_MANAGER_DISTRIBUTED__H */
#include <string>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__EE_SETUP_INFO__H */
#include "smt/smt_statistics_registry.h"
#include "theory/theory_engine.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
EngineOutputChannel::Statistics::Statistics(theory::TheoryId theory)
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_id.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
class TheoryEngine;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__ENGINE_OUTPUT_CHANNEL_H */
#include "theory/theory.h"
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
EvalResult::EvalResult(const EvalResult& other)
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "util/rational.h"
#include "util/string.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__EVALUATOR_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
bool ExtTheoryCallback::getCurrentSubstitution(
void ExtTheory::clearCache() { d_gst_cache.clear(); }
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "context/context.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class OutputChannel;
std::map<int, std::map<Node, SubsTermInfo> > d_gst_cache;
};
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__EXT_THEORY_H */
#ifdef CVC4_USE_SYMFPU
namespace symfpu {
-using namespace ::CVC4::theory::fp::symfpuSymbolic;
+using namespace ::CVC5::theory::fp::symfpuSymbolic;
#define CVC4_SYM_ITE_DFN(T) \
template <> \
struct ite<symbolicProposition, T> \
{ \
- static const T iteOp(const symbolicProposition &_cond, \
- const T &_l, \
- const T &_r) \
+ static const T iteOp(const symbolicProposition& _cond, \
+ const T& _l, \
+ const T& _r) \
{ \
- ::CVC4::NodeManager *nm = ::CVC4::NodeManager::currentNM(); \
+ ::CVC5::NodeManager* nm = ::CVC5::NodeManager::currentNM(); \
\
- ::CVC4::Node cond = _cond; \
- ::CVC4::Node l = _l; \
- ::CVC4::Node r = _r; \
+ ::CVC5::Node cond = _cond; \
+ ::CVC5::Node l = _l; \
+ ::CVC5::Node r = _r; \
\
/* Handle some common symfpu idioms */ \
if (cond.isConst()) \
{ \
- return (cond == nm->mkConst(::CVC4::BitVector(1U, 1U))) ? l : r; \
+ return (cond == nm->mkConst(::CVC5::BitVector(1U, 1U))) ? l : r; \
} \
else \
{ \
- if (l.getKind() == ::CVC4::kind::BITVECTOR_ITE) \
+ if (l.getKind() == ::CVC5::kind::BITVECTOR_ITE) \
{ \
if (l[1] == r) \
{ \
return nm->mkNode( \
- ::CVC4::kind::BITVECTOR_ITE, \
- nm->mkNode(::CVC4::kind::BITVECTOR_AND, \
+ ::CVC5::kind::BITVECTOR_ITE, \
+ nm->mkNode(::CVC5::kind::BITVECTOR_AND, \
cond, \
- nm->mkNode(::CVC4::kind::BITVECTOR_NOT, l[0])), \
+ nm->mkNode(::CVC5::kind::BITVECTOR_NOT, l[0])), \
l[2], \
r); \
} \
else if (l[2] == r) \
{ \
return nm->mkNode( \
- ::CVC4::kind::BITVECTOR_ITE, \
- nm->mkNode(::CVC4::kind::BITVECTOR_AND, cond, l[0]), \
+ ::CVC5::kind::BITVECTOR_ITE, \
+ nm->mkNode(::CVC5::kind::BITVECTOR_AND, cond, l[0]), \
l[1], \
r); \
} \
} \
- else if (r.getKind() == ::CVC4::kind::BITVECTOR_ITE) \
+ else if (r.getKind() == ::CVC5::kind::BITVECTOR_ITE) \
{ \
if (r[1] == l) \
{ \
return nm->mkNode( \
- ::CVC4::kind::BITVECTOR_ITE, \
- nm->mkNode(::CVC4::kind::BITVECTOR_AND, \
- nm->mkNode(::CVC4::kind::BITVECTOR_NOT, cond), \
- nm->mkNode(::CVC4::kind::BITVECTOR_NOT, r[0])), \
+ ::CVC5::kind::BITVECTOR_ITE, \
+ nm->mkNode(::CVC5::kind::BITVECTOR_AND, \
+ nm->mkNode(::CVC5::kind::BITVECTOR_NOT, cond), \
+ nm->mkNode(::CVC5::kind::BITVECTOR_NOT, r[0])), \
r[2], \
l); \
} \
else if (r[2] == l) \
{ \
return nm->mkNode( \
- ::CVC4::kind::BITVECTOR_ITE, \
- nm->mkNode(::CVC4::kind::BITVECTOR_AND, \
- nm->mkNode(::CVC4::kind::BITVECTOR_NOT, cond), \
+ ::CVC5::kind::BITVECTOR_ITE, \
+ nm->mkNode(::CVC5::kind::BITVECTOR_AND, \
+ nm->mkNode(::CVC5::kind::BITVECTOR_NOT, cond), \
r[0]), \
r[1], \
l); \
} \
} \
} \
- return T(nm->mkNode(::CVC4::kind::BITVECTOR_ITE, cond, l, r)); \
+ return T(nm->mkNode(::CVC5::kind::BITVECTOR_ITE, cond, l, r)); \
} \
}
#define SYMFPU_NUMBER_OF_ROUNDING_MODES 5
#endif
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace fp {
namespace symfpuSymbolic {
symbolicBitVector<true> leadingZero(symbolicBitVector<true>::zero(1));
symbolicBitVector<true> base(symbolicBitVector<true>::allOnes(w - 1));
- return symbolicBitVector<true>(::CVC4::NodeManager::currentNM()->mkNode(
- ::CVC4::kind::BITVECTOR_CONCAT, leadingZero, base));
+ return symbolicBitVector<true>(::CVC5::NodeManager::currentNM()->mkNode(
+ ::CVC5::kind::BITVECTOR_CONCAT, leadingZero, base));
}
template <>
symbolicBitVector<true> leadingOne(symbolicBitVector<true>::one(1));
symbolicBitVector<true> base(symbolicBitVector<true>::zero(w - 1));
- return symbolicBitVector<true>(::CVC4::NodeManager::currentNM()->mkNode(
- ::CVC4::kind::BITVECTOR_CONCAT, leadingOne, base));
+ return symbolicBitVector<true>(::CVC5::NodeManager::currentNM()->mkNode(
+ ::CVC5::kind::BITVECTOR_CONCAT, leadingOne, base));
}
template <>
{
NodeManager *nm = NodeManager::currentNM();
Node value =
- nm->mkNode(kind::EQUAL, p, nm->mkConst(::CVC4::BitVector(1U, 1U)));
+ nm->mkNode(kind::EQUAL, p, nm->mkConst(::CVC5::BitVector(1U, 1U)));
return value;
}
Node FpConverter::ubvToNode(const ubv &u) const { return u; }
} // namespace fp
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/rewriter.h"
#endif
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace fp {
typedef traits::bwt bwt;
/**
- * Wrap the CVC4::Node types so that we can debug issues with this back-end
+ * Wrap the CVC5::Node types so that we can debug issues with this back-end
*/
class nodeWrapper : public Node
{
} // namespace fp
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__FP__THEORY_FP_H */
# src/theory/builtin/kinds.
#
-theory THEORY_FP ::CVC4::theory::fp::TheoryFp "theory/fp/theory_fp.h"
+theory THEORY_FP ::CVC5::theory::fp::TheoryFp "theory/fp/theory_fp.h"
typechecker "theory/fp/theory_fp_type_rules.h"
-rewriter ::CVC4::theory::fp::TheoryFpRewriter "theory/fp/theory_fp_rewriter.h"
+rewriter ::CVC5::theory::fp::TheoryFpRewriter "theory/fp/theory_fp_rewriter.h"
properties check
# constants...
constant CONST_FLOATINGPOINT \
- ::CVC4::FloatingPoint \
- ::CVC4::FloatingPointHashFunction \
+ ::CVC5::FloatingPoint \
+ ::CVC5::FloatingPointHashFunction \
"util/floatingpoint.h" \
"a floating-point literal"
-typerule CONST_FLOATINGPOINT ::CVC4::theory::fp::FloatingPointConstantTypeRule
+typerule CONST_FLOATINGPOINT ::CVC5::theory::fp::FloatingPointConstantTypeRule
constant CONST_ROUNDINGMODE \
- ::CVC4::RoundingMode \
- ::CVC4::RoundingModeHashFunction \
+ ::CVC5::RoundingMode \
+ ::CVC5::RoundingModeHashFunction \
"util/floatingpoint.h" \
"a floating-point rounding mode"
-typerule CONST_ROUNDINGMODE ::CVC4::theory::fp::RoundingModeConstantTypeRule
+typerule CONST_ROUNDINGMODE ::CVC5::theory::fp::RoundingModeConstantTypeRule
"floating-point rounding mode"
enumerator ROUNDINGMODE_TYPE \
- "::CVC4::theory::fp::RoundingModeEnumerator" \
+ "::CVC5::theory::fp::RoundingModeEnumerator" \
"theory/fp/type_enumerator.h"
constant FLOATINGPOINT_TYPE \
- ::CVC4::FloatingPointSize \
- ::CVC4::FloatingPointSizeHashFunction \
+ ::CVC5::FloatingPointSize \
+ ::CVC5::FloatingPointSizeHashFunction \
"util/floatingpoint.h" \
"floating-point type"
cardinality FLOATINGPOINT_TYPE \
- "::CVC4::theory::fp::CardinalityComputer::computeCardinality(%TYPE%)" \
+ "::CVC5::theory::fp::CardinalityComputer::computeCardinality(%TYPE%)" \
"theory/fp/theory_fp_type_rules.h"
enumerator FLOATINGPOINT_TYPE \
- "::CVC4::theory::fp::FloatingPointEnumerator" \
+ "::CVC5::theory::fp::FloatingPointEnumerator" \
"theory/fp/type_enumerator.h"
well-founded FLOATINGPOINT_TYPE \
true \
- "(*CVC4::theory::TypeEnumerator(%TYPE%))" \
+ "(*CVC5::theory::TypeEnumerator(%TYPE%))" \
"theory/type_enumerator.h"
# operators...
operator FLOATINGPOINT_FP 3 "construct a floating-point literal from bit vectors"
-typerule FLOATINGPOINT_FP ::CVC4::theory::fp::FloatingPointFPTypeRule
+typerule FLOATINGPOINT_FP ::CVC5::theory::fp::FloatingPointFPTypeRule
operator FLOATINGPOINT_EQ 2: "floating-point equality"
-typerule FLOATINGPOINT_EQ ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_EQ ::CVC5::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_ABS 1 "floating-point absolute value"
-typerule FLOATINGPOINT_ABS ::CVC4::theory::fp::FloatingPointOperationTypeRule
+typerule FLOATINGPOINT_ABS ::CVC5::theory::fp::FloatingPointOperationTypeRule
operator FLOATINGPOINT_NEG 1 "floating-point negation"
-typerule FLOATINGPOINT_NEG ::CVC4::theory::fp::FloatingPointOperationTypeRule
+typerule FLOATINGPOINT_NEG ::CVC5::theory::fp::FloatingPointOperationTypeRule
operator FLOATINGPOINT_PLUS 3 "floating-point addition"
-typerule FLOATINGPOINT_PLUS ::CVC4::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_PLUS ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_SUB 3 "floating-point sutraction"
-typerule FLOATINGPOINT_SUB ::CVC4::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_SUB ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_MULT 3 "floating-point multiply"
-typerule FLOATINGPOINT_MULT ::CVC4::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_MULT ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_DIV 3 "floating-point division"
-typerule FLOATINGPOINT_DIV ::CVC4::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_DIV ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_FMA 4 "floating-point fused multiply and add"
-typerule FLOATINGPOINT_FMA ::CVC4::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_FMA ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_SQRT 2 "floating-point square root"
-typerule FLOATINGPOINT_SQRT ::CVC4::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_SQRT ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_REM 2 "floating-point remainder"
-typerule FLOATINGPOINT_REM ::CVC4::theory::fp::FloatingPointOperationTypeRule
+typerule FLOATINGPOINT_REM ::CVC5::theory::fp::FloatingPointOperationTypeRule
operator FLOATINGPOINT_RTI 2 "floating-point round to integral"
-typerule FLOATINGPOINT_RTI ::CVC4::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_RTI ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_MIN 2 "floating-point minimum"
-typerule FLOATINGPOINT_MIN ::CVC4::theory::fp::FloatingPointOperationTypeRule
+typerule FLOATINGPOINT_MIN ::CVC5::theory::fp::FloatingPointOperationTypeRule
operator FLOATINGPOINT_MAX 2 "floating-point maximum"
-typerule FLOATINGPOINT_MAX ::CVC4::theory::fp::FloatingPointOperationTypeRule
+typerule FLOATINGPOINT_MAX ::CVC5::theory::fp::FloatingPointOperationTypeRule
operator FLOATINGPOINT_MIN_TOTAL 3 "floating-point minimum (defined for all inputs)"
-typerule FLOATINGPOINT_MIN_TOTAL ::CVC4::theory::fp::FloatingPointPartialOperationTypeRule
+typerule FLOATINGPOINT_MIN_TOTAL ::CVC5::theory::fp::FloatingPointPartialOperationTypeRule
operator FLOATINGPOINT_MAX_TOTAL 3 "floating-point maximum (defined for all inputs)"
-typerule FLOATINGPOINT_MAX_TOTAL ::CVC4::theory::fp::FloatingPointPartialOperationTypeRule
+typerule FLOATINGPOINT_MAX_TOTAL ::CVC5::theory::fp::FloatingPointPartialOperationTypeRule
operator FLOATINGPOINT_LEQ 2: "floating-point less than or equal"
-typerule FLOATINGPOINT_LEQ ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_LEQ ::CVC5::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_LT 2: "floating-point less than"
-typerule FLOATINGPOINT_LT ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_LT ::CVC5::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_GEQ 2: "floating-point greater than or equal"
-typerule FLOATINGPOINT_GEQ ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_GEQ ::CVC5::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_GT 2: "floating-point greater than"
-typerule FLOATINGPOINT_GT ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_GT ::CVC5::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_ISN 1 "floating-point is normal"
-typerule FLOATINGPOINT_ISN ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_ISN ::CVC5::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_ISSN 1 "floating-point is sub-normal"
-typerule FLOATINGPOINT_ISSN ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_ISSN ::CVC5::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_ISZ 1 "floating-point is zero"
-typerule FLOATINGPOINT_ISZ ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_ISZ ::CVC5::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_ISINF 1 "floating-point is infinite"
-typerule FLOATINGPOINT_ISINF ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_ISINF ::CVC5::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_ISNAN 1 "floating-point is NaN"
-typerule FLOATINGPOINT_ISNAN ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_ISNAN ::CVC5::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_ISNEG 1 "floating-point is negative"
-typerule FLOATINGPOINT_ISNEG ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_ISNEG ::CVC5::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_ISPOS 1 "floating-point is positive"
-typerule FLOATINGPOINT_ISPOS ::CVC4::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_ISPOS ::CVC5::theory::fp::FloatingPointTestTypeRule
constant FLOATINGPOINT_TO_FP_IEEE_BITVECTOR_OP \
- ::CVC4::FloatingPointToFPIEEEBitVector \
- "::CVC4::FloatingPointConvertSortHashFunction<0x1>" \
+ ::CVC5::FloatingPointToFPIEEEBitVector \
+ "::CVC5::FloatingPointConvertSortHashFunction<0x1>" \
"util/floatingpoint.h" \
"operator for to_fp from bit vector"
-typerule FLOATINGPOINT_TO_FP_IEEE_BITVECTOR_OP ::CVC4::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_FP_IEEE_BITVECTOR_OP ::CVC5::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_FP_IEEE_BITVECTOR FLOATINGPOINT_TO_FP_IEEE_BITVECTOR_OP 1 "convert an IEEE-754 bit vector to floating-point"
-typerule FLOATINGPOINT_TO_FP_IEEE_BITVECTOR ::CVC4::theory::fp::FloatingPointToFPIEEEBitVectorTypeRule
+typerule FLOATINGPOINT_TO_FP_IEEE_BITVECTOR ::CVC5::theory::fp::FloatingPointToFPIEEEBitVectorTypeRule
constant FLOATINGPOINT_TO_FP_FLOATINGPOINT_OP \
- ::CVC4::FloatingPointToFPFloatingPoint \
- "::CVC4::FloatingPointConvertSortHashFunction<0x2>" \
+ ::CVC5::FloatingPointToFPFloatingPoint \
+ "::CVC5::FloatingPointConvertSortHashFunction<0x2>" \
"util/floatingpoint.h" \
"operator for to_fp from floating point"
-typerule FLOATINGPOINT_TO_FP_FLOATINGPOINT_OP ::CVC4::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_FP_FLOATINGPOINT_OP ::CVC5::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_FP_FLOATINGPOINT FLOATINGPOINT_TO_FP_FLOATINGPOINT_OP 2 "convert between floating-point sorts"
-typerule FLOATINGPOINT_TO_FP_FLOATINGPOINT ::CVC4::theory::fp::FloatingPointToFPFloatingPointTypeRule
+typerule FLOATINGPOINT_TO_FP_FLOATINGPOINT ::CVC5::theory::fp::FloatingPointToFPFloatingPointTypeRule
constant FLOATINGPOINT_TO_FP_REAL_OP \
- ::CVC4::FloatingPointToFPReal \
- "::CVC4::FloatingPointConvertSortHashFunction<0x4>" \
+ ::CVC5::FloatingPointToFPReal \
+ "::CVC5::FloatingPointConvertSortHashFunction<0x4>" \
"util/floatingpoint.h" \
"operator for to_fp from real"
-typerule FLOATINGPOINT_TO_FP_REAL_OP ::CVC4::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_FP_REAL_OP ::CVC5::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_FP_REAL FLOATINGPOINT_TO_FP_REAL_OP 2 "convert a real to floating-point"
-typerule FLOATINGPOINT_TO_FP_REAL ::CVC4::theory::fp::FloatingPointToFPRealTypeRule
+typerule FLOATINGPOINT_TO_FP_REAL ::CVC5::theory::fp::FloatingPointToFPRealTypeRule
constant FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR_OP \
- ::CVC4::FloatingPointToFPSignedBitVector \
- "::CVC4::FloatingPointConvertSortHashFunction<0x8>" \
+ ::CVC5::FloatingPointToFPSignedBitVector \
+ "::CVC5::FloatingPointConvertSortHashFunction<0x8>" \
"util/floatingpoint.h" \
"operator for to_fp from signed bit vector"
-typerule FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR_OP ::CVC4::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR_OP ::CVC5::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR_OP 2 "convert a signed bit vector to floating-point"
-typerule FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR ::CVC4::theory::fp::FloatingPointToFPSignedBitVectorTypeRule
+typerule FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR ::CVC5::theory::fp::FloatingPointToFPSignedBitVectorTypeRule
constant FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR_OP \
- ::CVC4::FloatingPointToFPUnsignedBitVector \
- "::CVC4::FloatingPointConvertSortHashFunction<0x10>" \
+ ::CVC5::FloatingPointToFPUnsignedBitVector \
+ "::CVC5::FloatingPointConvertSortHashFunction<0x10>" \
"util/floatingpoint.h" \
"operator for to_fp from unsigned bit vector"
-typerule FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR_OP ::CVC4::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR_OP ::CVC5::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR_OP 2 "convert an unsigned bit vector to floating-point"
-typerule FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR ::CVC4::theory::fp::FloatingPointToFPUnsignedBitVectorTypeRule
+typerule FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR ::CVC5::theory::fp::FloatingPointToFPUnsignedBitVectorTypeRule
constant FLOATINGPOINT_TO_FP_GENERIC_OP \
- ::CVC4::FloatingPointToFPGeneric \
- "::CVC4::FloatingPointConvertSortHashFunction<0x11>" \
+ ::CVC5::FloatingPointToFPGeneric \
+ "::CVC5::FloatingPointConvertSortHashFunction<0x11>" \
"util/floatingpoint.h" \
"operator for a generic to_fp"
-typerule FLOATINGPOINT_TO_FP_GENERIC_OP ::CVC4::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_FP_GENERIC_OP ::CVC5::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_FP_GENERIC FLOATINGPOINT_TO_FP_GENERIC_OP 1:2 "a generic conversion to floating-point, used in parsing only"
-typerule FLOATINGPOINT_TO_FP_GENERIC ::CVC4::theory::fp::FloatingPointToFPGenericTypeRule
+typerule FLOATINGPOINT_TO_FP_GENERIC ::CVC5::theory::fp::FloatingPointToFPGenericTypeRule
constant FLOATINGPOINT_TO_UBV_OP \
- ::CVC4::FloatingPointToUBV \
- "::CVC4::FloatingPointToBVHashFunction<0x1>" \
+ ::CVC5::FloatingPointToUBV \
+ "::CVC5::FloatingPointToBVHashFunction<0x1>" \
"util/floatingpoint.h" \
"operator for to_ubv"
-typerule FLOATINGPOINT_TO_UBV_OP ::CVC4::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_UBV_OP ::CVC5::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_UBV FLOATINGPOINT_TO_UBV_OP 2 "convert a floating-point value to an unsigned bit vector"
-typerule FLOATINGPOINT_TO_UBV ::CVC4::theory::fp::FloatingPointToUBVTypeRule
+typerule FLOATINGPOINT_TO_UBV ::CVC5::theory::fp::FloatingPointToUBVTypeRule
constant FLOATINGPOINT_TO_UBV_TOTAL_OP \
- ::CVC4::FloatingPointToUBVTotal \
- "::CVC4::FloatingPointToBVHashFunction<0x4>" \
+ ::CVC5::FloatingPointToUBVTotal \
+ "::CVC5::FloatingPointToBVHashFunction<0x4>" \
"util/floatingpoint.h" \
"operator for to_ubv_total"
-typerule FLOATINGPOINT_TO_UBV_TOTAL_OP ::CVC4::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_UBV_TOTAL_OP ::CVC5::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_UBV_TOTAL FLOATINGPOINT_TO_UBV_TOTAL_OP 3 "convert a floating-point value to an unsigned bit vector (defined for all inputs)"
-typerule FLOATINGPOINT_TO_UBV_TOTAL ::CVC4::theory::fp::FloatingPointToUBVTotalTypeRule
+typerule FLOATINGPOINT_TO_UBV_TOTAL ::CVC5::theory::fp::FloatingPointToUBVTotalTypeRule
constant FLOATINGPOINT_TO_SBV_OP \
- ::CVC4::FloatingPointToSBV \
- "::CVC4::FloatingPointToBVHashFunction<0x2>" \
+ ::CVC5::FloatingPointToSBV \
+ "::CVC5::FloatingPointToBVHashFunction<0x2>" \
"util/floatingpoint.h" \
"operator for to_sbv"
-typerule FLOATINGPOINT_TO_SBV_OP ::CVC4::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_SBV_OP ::CVC5::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_SBV FLOATINGPOINT_TO_SBV_OP 2 "convert a floating-point value to a signed bit vector"
-typerule FLOATINGPOINT_TO_SBV ::CVC4::theory::fp::FloatingPointToSBVTypeRule
+typerule FLOATINGPOINT_TO_SBV ::CVC5::theory::fp::FloatingPointToSBVTypeRule
constant FLOATINGPOINT_TO_SBV_TOTAL_OP \
- ::CVC4::FloatingPointToSBVTotal \
- "::CVC4::FloatingPointToBVHashFunction<0x8>" \
+ ::CVC5::FloatingPointToSBVTotal \
+ "::CVC5::FloatingPointToBVHashFunction<0x8>" \
"util/floatingpoint.h" \
"operator for to_sbv_total"
-typerule FLOATINGPOINT_TO_SBV_TOTAL_OP ::CVC4::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_SBV_TOTAL_OP ::CVC5::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_SBV_TOTAL FLOATINGPOINT_TO_SBV_TOTAL_OP 3 "convert a floating-point value to a signed bit vector (defined for all inputs)"
-typerule FLOATINGPOINT_TO_SBV_TOTAL ::CVC4::theory::fp::FloatingPointToSBVTotalTypeRule
+typerule FLOATINGPOINT_TO_SBV_TOTAL ::CVC5::theory::fp::FloatingPointToSBVTotalTypeRule
operator FLOATINGPOINT_TO_REAL 1 "floating-point to real"
-typerule FLOATINGPOINT_TO_REAL ::CVC4::theory::fp::FloatingPointToRealTypeRule
+typerule FLOATINGPOINT_TO_REAL ::CVC5::theory::fp::FloatingPointToRealTypeRule
operator FLOATINGPOINT_TO_REAL_TOTAL 2 "floating-point to real (defined for all inputs)"
-typerule FLOATINGPOINT_TO_REAL_TOTAL ::CVC4::theory::fp::FloatingPointToRealTotalTypeRule
+typerule FLOATINGPOINT_TO_REAL_TOTAL ::CVC5::theory::fp::FloatingPointToRealTotalTypeRule
operator FLOATINGPOINT_COMPONENT_NAN 1 "NaN component of a word-blasted floating-point number"
-typerule FLOATINGPOINT_COMPONENT_NAN ::CVC4::theory::fp::FloatingPointComponentBit
+typerule FLOATINGPOINT_COMPONENT_NAN ::CVC5::theory::fp::FloatingPointComponentBit
operator FLOATINGPOINT_COMPONENT_INF 1 "Inf component of a word-blasted floating-point number"
-typerule FLOATINGPOINT_COMPONENT_INF ::CVC4::theory::fp::FloatingPointComponentBit
+typerule FLOATINGPOINT_COMPONENT_INF ::CVC5::theory::fp::FloatingPointComponentBit
operator FLOATINGPOINT_COMPONENT_ZERO 1 "Zero component of a word-blasted floating-point number"
-typerule FLOATINGPOINT_COMPONENT_ZERO ::CVC4::theory::fp::FloatingPointComponentBit
+typerule FLOATINGPOINT_COMPONENT_ZERO ::CVC5::theory::fp::FloatingPointComponentBit
operator FLOATINGPOINT_COMPONENT_SIGN 1 "Sign component of a word-blasted floating-point number"
-typerule FLOATINGPOINT_COMPONENT_SIGN ::CVC4::theory::fp::FloatingPointComponentBit
+typerule FLOATINGPOINT_COMPONENT_SIGN ::CVC5::theory::fp::FloatingPointComponentBit
operator FLOATINGPOINT_COMPONENT_EXPONENT 1 "Exponent component of a word-blasted floating-point number"
-typerule FLOATINGPOINT_COMPONENT_EXPONENT ::CVC4::theory::fp::FloatingPointComponentExponent
+typerule FLOATINGPOINT_COMPONENT_EXPONENT ::CVC5::theory::fp::FloatingPointComponentExponent
operator FLOATINGPOINT_COMPONENT_SIGNIFICAND 1 "Significand component of a word-blasted floating-point number"
-typerule FLOATINGPOINT_COMPONENT_SIGNIFICAND ::CVC4::theory::fp::FloatingPointComponentSignificand
+typerule FLOATINGPOINT_COMPONENT_SIGNIFICAND ::CVC5::theory::fp::FloatingPointComponentSignificand
operator ROUNDINGMODE_BITBLAST 1 "The bit-vector for a non-deterministic rounding mode"
-typerule ROUNDINGMODE_BITBLAST ::CVC4::theory::fp::RoundingModeBitBlast
+typerule ROUNDINGMODE_BITBLAST ::CVC5::theory::fp::RoundingModeBitBlast
endtheory
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace fp {
NodeManager *nm = NodeManager::currentNM();
handleLemma(
- nm->mkNode(kind::EQUAL, addA, nm->mkConst(::CVC4::BitVector(1U, 1U))));
+ nm->mkNode(kind::EQUAL, addA, nm->mkConst(::CVC5::BitVector(1U, 1U))));
#endif
++oldAdditionalAssertions;
#ifdef SYMFPUPROPISBOOL
handleLemma(nm->mkNode(kind::EQUAL, node, converted));
#else
- handleLemma(
- nm->mkNode(kind::EQUAL, node,
- nm->mkNode(kind::EQUAL, converted,
- nm->mkConst(::CVC4::BitVector(1U, 1U)))));
+ handleLemma(nm->mkNode(
+ kind::EQUAL,
+ node,
+ nm->mkNode(
+ kind::EQUAL, converted, nm->mkConst(::CVC5::BitVector(1U, 1U)))));
#endif
} else {
} // namespace fp
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_state.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace fp {
} // namespace fp
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__FP__THEORY_FP_H */
#include "theory/fp/fp_converter.h"
#include "theory/fp/theory_fp_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace fp {
return RewriteResponse(REWRITE_DONE, node);
}
-}; /* CVC4::theory::fp::rewrite */
-
+ }; // namespace rewrite
namespace constantFold {
NodeManager::currentNM()->mkConst(value));
}
-}; /* CVC4::theory::fp::constantFold */
-
+ }; // namespace constantFold
/**
* Initialize the rewriter.
return res;
}
-
-}/* CVC4::theory::fp namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
-
+ } // namespace fp
+ } // namespace theory
+ } // namespace CVC5
#include "theory/theory_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace fp {
RewriteFunction d_constantFoldTable[kind::LAST_KIND];
}; /* class TheoryFpRewriter */
-}/* CVC4::theory::fp namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace fp
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__FP__THEORY_FP_REWRITER_H */
#include "theory/theory.h"
#include "util/roundingmode.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace fp {
} // namespace fp
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
class NodeManager;
} // namespace fp
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "util/bitvector.h"
#include "util/floatingpoint.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace fp {
} // namespace fp
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__FP__TYPE_ENUMERATOR_H */
#include <iostream>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
const char* toString(InferenceId i)
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#ifndef CVC4__THEORY__INFERENCE_ID_H
#define CVC4__THEORY__INFERENCE_ID_H
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** Types of inferences used in the procedure
std::ostream& operator<<(std::ostream& out, InferenceId i);
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__INFERENCE_H */
#include "theory/theory.h"
#include "theory/theory_state.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
InferenceManagerBuffered::InferenceManagerBuffered(Theory& t,
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_inference.h"
#include "theory/theory_inference_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
** An exception signaling that a Theory should immediately stop
** performing processing and relinquish control to its caller (e.g.,
** in a parallel environment). A Theory might be interrupted if it
- ** calls into its CVC4::theory::OutputChannel, and it should only
+ ** calls into its CVC5::theory::OutputChannel, and it should only
** catch this exception to perform emergency repair of any invariants
** it must re-establish. Further, if this exception is caught by a
** Theory, the Theory should rethrow the same exception (via "throw;"
#include "base/exception.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
-class Interrupted : public CVC4::Exception {
-};/* class Interrupted */
+class Interrupted : public CVC5::Exception
+{
+}; /* class Interrupted */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__INTERRUPTED_H */
#include "expr/proof_node.h"
#include "expr/proof_node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
LazyTreeProofGenerator::LazyTreeProofGenerator(ProofNodeManager* pnm,
}
} // namespace theory
-} // namespace CVC4
\ No newline at end of file
+} // namespace CVC5
\ No newline at end of file
#include "expr/proof_generator.h"
#include "expr/proof_node_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace detail {
/**
std::ostream& operator<<(std::ostream& os, const LazyTreeProofGenerator& ltpg);
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "expr/kind.h"
using namespace std;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
LogicInfo::LogicInfo()
: d_logicString(""),
return out << logic.getLogicString();
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "cvc4_export.h"
#include "theory/theory_id.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* A LogicInfo instance describes a collection of theory modules and some
std::ostream& operator<<(std::ostream& out, const LogicInfo& logic);
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__LOGIC_INFO_H */
echo "$kf:$lineno: error: \"theory\" directive missing class or header argument" >&2
exit 1
elif ! expr "$2" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::CVC4::theory::foo)" >&2
- elif ! expr "$2" : '\(::CVC4::theory::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class not under ::CVC4::theory namespace" >&2
+ echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::CVC5::theory::foo)" >&2
+ elif ! expr "$2" : '\(::CVC5::theory::*\)' >/dev/null; then
+ echo "$kf:$lineno: warning: theory class not under ::CVC5::theory namespace" >&2
fi
theory_id="$1"
echo "$kf:$lineno: error: \"theory\" directive missing class or header argument" >&2
exit 1
elif ! expr "$2" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::CVC4::theory::foo)" >&2
- elif ! expr "$2" : '\(::CVC4::theory::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class not under ::CVC4::theory namespace" >&2
+ echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::CVC5::theory::foo)" >&2
+ elif ! expr "$2" : '\(::CVC5::theory::*\)' >/dev/null; then
+ echo "$kf:$lineno: warning: theory class not under ::CVC5::theory namespace" >&2
fi
theory_id="$1"
#include "theory/quantifiers/fmf/model_builder.h"
#include "theory/theory_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
ModelManager::ModelManager(TheoryEngine& te, EqEngineManager& eem)
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/ee_manager.h"
#include "theory/logic_info.h"
-namespace CVC4 {
+namespace CVC5 {
class TheoryEngine;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__MODEL_MANAGER__H */
#include "theory/theory_model.h"
#include "theory/theory_model_builder.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
ModelManagerDistributed::ModelManagerDistributed(TheoryEngine& te,
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/ee_manager.h"
#include "theory/model_manager.h"
-namespace CVC4 {
+namespace CVC5 {
class TheoryEngine;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__MODEL_MANAGER_DISTRIBUTED__H */
#include "theory/output_channel.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
LemmaProperty operator|(LemmaProperty lhs, LemmaProperty rhs)
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/trust_node.h"
#include "util/resource_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** Properties of lemmas */
/**
* Generic "theory output channel" interface.
*
- * All methods can throw unrecoverable CVC4::Exception's unless otherwise
+ * All methods can throw unrecoverable CVC5::Exception's unless otherwise
* documented.
*/
class OutputChannel {
}; /* class OutputChannel */
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__OUTPUT_CHANNEL_H */
#include "theory/quantifiers/alpha_equivalence.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/term_canonize.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-}
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__BV_INVERTER_H */
#include "theory/quantifiers/bv_inverter_utils.h"
#include "theory/bv/theory_bv_utils.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace utils {
} // namespace utils
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace utils {
} // namespace utils
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
d_ext_rewrite = er;
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/quantifiers/expr_miner.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
std::unordered_map<Node, Node, NodeHashFunction> d_add_term_cache;
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__CANDIDATE_REWRITE_DATABASE_H */
#include "options/quantifiers_options.h"
#include "printer/printer.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__CANDIDATE_REWRITE_FILTER_H */
#include "util/random.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/cegqi/ceg_instantiator.h"
#include "theory/quantifiers/cegqi/vts_term_cache.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__CEG_ARITH_INSTANTIATOR_H */
#include "util/random.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/bv_inverter.h"
#include "theory/quantifiers/cegqi/ceg_instantiator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__CEG_BV_INSTANTIATOR_H */
#include "theory/bv/theory_bv_utils.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace utils {
} // namespace utils
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/attribute.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace utils
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/datatypes/theory_datatypes_utils.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/quantifiers/cegqi/ceg_instantiator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__CEG_DT_INSTANTIATOR_H */
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return ci->constructInstantiationInc(pv, n, pv_prop, sf);
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/inference_id.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/quant_module.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-}
+} // namespace CVC5
#endif
#include "expr/subs.h"
#include "theory/smt_engine_subsolver.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "context/cdhashmap.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/quantifiers/quantifiers_inference_manager.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/attribute.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** Attribute to mark Skolems as virtual terms */
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__CEGQI__VTS_TERM_CACHE_H */
#include "theory/rewriter.h"
#include "util/random.h"
-using namespace CVC4;
-using namespace CVC4::kind;
-using namespace CVC4::theory;
-using namespace CVC4::theory::quantifiers;
+using namespace CVC5;
+using namespace CVC5::kind;
+using namespace CVC5::theory;
+using namespace CVC5::theory::quantifiers;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
struct sortConjectureScore {
std::vector< int > d_scores;
bool ConjectureGenerator::optStatsOnly() { return false; }
-}
+} // namespace CVC5
#include "theory/quantifiers/quant_module.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-}
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return f;
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "context/cdlist.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
NodeList d_rewrites;
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__DYNAMIC_REWRITER_H */
#include "theory/quantifiers/term_registry.h"
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
Node d_ufOp;
};
-}/* CVC4::theory::inst namespace */
+} // namespace inst
} // namespace quantifiers
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__CANDIDATE_GENERATOR_H */
#include "theory/uf/theory_uf_rewriter.h"
#include "util/hash.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/inst_match.h"
#include "theory/quantifiers/ematching/trigger.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__HO_TRIGGER_H */
#include "theory/quantifiers/ematching/trigger.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/inference_id.h"
#include "theory/quantifiers/inst_match.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace inst
}
}
-}
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_registry.h"
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/inst_match.h"
#include "theory/quantifiers/ematching/im_generator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
}
}
-}
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_util.h"
#include "theory/uf/equality_engine_iterator.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/ematching/inst_match_generator.h"
#include "theory/quantifiers/inst_match_trie.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/quantifiers/ematching/trigger_trie.h"
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/quantifiers/ematching/inst_match_generator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_registry.h"
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node_trie.h"
#include "theory/quantifiers/ematching/inst_match_generator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/quantifiers/quantifiers_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "options/quantifiers_options.h"
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__INSTANTIATION_ENGINE_H */
#include "theory/quantifiers/quantifiers_state.h"
#include "util/random.h"
-using namespace CVC4::kind;
-using namespace CVC4::theory::quantifiers::inst;
+using namespace CVC5::kind;
+using namespace CVC5::theory::quantifiers::inst;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/quantifiers/ematching/trigger.h"
#include "theory/quantifiers/quant_relevance.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
QuantRelevance* d_quant_rel;
}; /* class InstStrategyAutoGenTriggers */
}
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif
#include "theory/quantifiers/ematching/trigger_database.h"
#include "theory/quantifiers/quantifiers_state.h"
-using namespace CVC4::kind;
-using namespace CVC4::theory::quantifiers::inst;
+using namespace CVC5::kind;
+using namespace CVC5::theory::quantifiers::inst;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/ematching/inst_strategy.h"
#include "theory/quantifiers/ematching/trigger.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_database.h"
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
-using namespace CVC4::context;
-using namespace CVC4::theory::quantifiers::inst;
+using namespace CVC5::kind;
+using namespace CVC5::context;
+using namespace CVC5::theory::quantifiers::inst;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/quant_module.h"
#include "theory/quantifiers/quant_relevance.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
std::unique_ptr<QuantRelevance> d_quant_rel;
}; /* class InstantiationEngine */
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__INSTANTIATION_ENGINE_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "options/quantifiers_options.h"
#include "theory/quantifiers/ematching/trigger_term_info.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_util.h"
#include "theory/valuation.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/inference_id.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class QuantifiersEngine;
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__TRIGGER_H */
#include "theory/quantifiers/ematching/trigger.h"
#include "theory/quantifiers/term_util.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/quantifiers/ematching/trigger_trie.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__TRIGGER_DATABASE_H */
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/quantifiers/ematching/trigger_trie.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/quantifiers/ematching/trigger.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__TRIGGER_TRIE_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/quantifiers/ematching/inst_match_generator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_util.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return quantifiers::TermUtil::getTermDepth(n);
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
#include "theory/quantifiers/quant_util.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
int32_t getRepScore(Node n, Node f, size_t index, TypeNode v_tn);
}; /* EqualityQuery */
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS_EQUALITY_QUERY_H */
#include "theory/smt_engine_subsolver.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "smt/smt_engine.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__EXPRESSION_MINER_H */
#include "options/quantifiers_options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/solution_filter.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class QuantifiersEngine;
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__EXPR_MINER_MANAGER_H */
#include "theory/strings/sequences_rewriter.h"
#include "theory/theory.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
//--------------------------------------end theory-specific top-level calls
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__EXTENDED_REWRITE_H */
#include "theory/quantifiers/term_registry.h"
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return n.getAttribute(ModelBasisArgAttribute());
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/theory_model.h"
#include "theory/uf/theory_uf_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class QuantifiersEngine;
void computeModelBasisArgAttribute(Node n);
};/* class FirstOrderModel */
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__FIRST_ORDER_MODEL_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace CVC4;
+using namespace CVC5;
using namespace std;
-using namespace CVC4::theory;
-using namespace CVC4::theory::quantifiers;
-using namespace CVC4::kind;
+using namespace CVC5::theory;
+using namespace CVC5::theory::quantifiers;
+using namespace CVC5::kind;
BoundedIntegers::IntRangeDecisionHeuristic::IntRangeDecisionHeuristic(
Node r,
#include "theory/decision_strategy.h"
#include "theory/quantifiers/quant_bound_inference.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class RepSetIterator;
}
}
-}
+} // namespace CVC5
#endif
#include "theory/quantifiers/fmf/full_model_check.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace fmcheck {
} // namespace fmcheck
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/first_order_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace fmcheck {
} // namespace fmcheck
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__FIRST_ORDER_MODEL_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace fmcheck {
} // namespace fmcheck
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/fmf/first_order_model_fmc.h"
#include "theory/quantifiers/fmf/model_builder.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
namespace fmcheck {
bool isHandled(Node q) const;
};/* class FullModelChecker */
-}/* CVC4::theory::quantifiers::fmcheck namespace */
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace fmcheck
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__FULL_MODEL_CHECK_H */
#include "theory/quantifiers/quantifiers_state.h"
using namespace std;
-using namespace CVC4;
-using namespace CVC4::kind;
-using namespace CVC4::context;
-using namespace CVC4::theory;
-using namespace CVC4::theory::quantifiers;
+using namespace CVC5;
+using namespace CVC5::kind;
+using namespace CVC5::context;
+using namespace CVC5::theory;
+using namespace CVC5::theory::quantifiers;
QModelBuilder::QModelBuilder(QuantifiersState& qs,
QuantifiersRegistry& qr,
#include "theory/quantifiers/inst_match.h"
#include "theory/theory_model_builder.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
quantifiers::QuantifiersInferenceManager& d_qim;
};
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__MODEL_BUILDER_H */
#include "theory/quantifiers/quantifiers_attributes.h"
#include "theory/quantifiers/term_database.h"
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/quant_module.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
QModelBuilder* d_builder;
};/* class ModelEngine */
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__MODEL_ENGINE_H */
#include "theory/quantifiers/quantifiers_attributes.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/evaluator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
**/
#include "theory/quantifiers/index_trie.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "base/check.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* THEORY__QUANTIFIERS__INDEX_TRIE_H */
#include "theory/quantifiers/quantifiers_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
} // namespace quantifiers
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
} // namespace quantifiers
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__INST_MATCH_H */
#include "theory/quantifiers/term_database.h"
#include "theory/uf/equality_engine_iterator.h"
-using namespace CVC4::context;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
} // namespace quantifiers
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "context/cdo.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
};
} // namespace quantifiers
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__INST_MATCH_TRIE_H */
#include "theory/quantifiers/term_tuple_enumerator.h"
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/quant_module.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
int32_t d_fullSaturateLimit;
}; /* class InstStrategyEnum */
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
smtStatisticsRegistry()->unregisterStat(&d_inst_duplicate_ent);
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/quantifiers/quant_util.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
class LazyCDProof;
std::unique_ptr<CDProof> d_pfInst;
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__INSTANTIATE_H */
#include "options/base_options.h"
#include "printer/printer.h"
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, const InstantiationList& ilist)
{
return out;
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
/** A list of instantiations for a quantified formula */
struct InstantiationList
/** Print the skolem list to stream out */
std::ostream& operator<<(std::ostream& out, const SkolemList& skl);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__INSTANTIATION_LIST_H */
# src/theory/builtin/kinds.
#
-theory THEORY_QUANTIFIERS ::CVC4::theory::quantifiers::TheoryQuantifiers "theory/quantifiers/theory_quantifiers.h"
+theory THEORY_QUANTIFIERS ::CVC5::theory::quantifiers::TheoryQuantifiers "theory/quantifiers/theory_quantifiers.h"
typechecker "theory/quantifiers/theory_quantifiers_type_rules.h"
properties check presolve
-rewriter ::CVC4::theory::quantifiers::QuantifiersRewriter "theory/quantifiers/quantifiers_rewriter.h"
+rewriter ::CVC5::theory::quantifiers::QuantifiersRewriter "theory/quantifiers/quantifiers_rewriter.h"
operator FORALL 2:3 "universally quantified formula; first parameter is an BOUND_VAR_LIST, second is quantifier body, and an optional third parameter is an INST_PATTERN_LIST"
# a list of instantiation patterns
operator INST_PATTERN_LIST 1: "a list of instantiation patterns"
-typerule FORALL ::CVC4::theory::quantifiers::QuantifierTypeRule
-typerule EXISTS ::CVC4::theory::quantifiers::QuantifierTypeRule
-typerule BOUND_VAR_LIST ::CVC4::theory::quantifiers::QuantifierBoundVarListTypeRule
-typerule INST_PATTERN_LIST ::CVC4::theory::quantifiers::QuantifierInstPatternListTypeRule
-
-typerule INST_PATTERN ::CVC4::theory::quantifiers::QuantifierInstPatternTypeRule
-typerule INST_NO_PATTERN ::CVC4::theory::quantifiers::QuantifierAnnotationTypeRule
-typerule INST_ATTRIBUTE ::CVC4::theory::quantifiers::QuantifierAnnotationTypeRule
-typerule INST_POOL ::CVC4::theory::quantifiers::QuantifierAnnotationTypeRule
-typerule INST_ADD_TO_POOL ::CVC4::theory::quantifiers::QuantifierAnnotationTypeRule
-typerule SKOLEM_ADD_TO_POOL ::CVC4::theory::quantifiers::QuantifierAnnotationTypeRule
+typerule FORALL ::CVC5::theory::quantifiers::QuantifierTypeRule
+typerule EXISTS ::CVC5::theory::quantifiers::QuantifierTypeRule
+typerule BOUND_VAR_LIST ::CVC5::theory::quantifiers::QuantifierBoundVarListTypeRule
+typerule INST_PATTERN_LIST ::CVC5::theory::quantifiers::QuantifierInstPatternListTypeRule
+
+typerule INST_PATTERN ::CVC5::theory::quantifiers::QuantifierInstPatternTypeRule
+typerule INST_NO_PATTERN ::CVC5::theory::quantifiers::QuantifierAnnotationTypeRule
+typerule INST_ATTRIBUTE ::CVC5::theory::quantifiers::QuantifierAnnotationTypeRule
+typerule INST_POOL ::CVC5::theory::quantifiers::QuantifierAnnotationTypeRule
+typerule INST_ADD_TO_POOL ::CVC5::theory::quantifiers::QuantifierAnnotationTypeRule
+typerule SKOLEM_ADD_TO_POOL ::CVC5::theory::quantifiers::QuantifierAnnotationTypeRule
endtheory
#include "theory/quantifiers/lazy_trie.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
d_rep_to_class.clear();
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
LazyTrie d_trie;
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__LAZY_TRIE_H */
#include "expr/skolem_manager.h"
#include "theory/builtin/proof_checker.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_checker.h"
#include "expr/proof_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__PROOF_CHECKER_H */
#include "theory/quantifiers/fmf/bounded_integers.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include <vector>
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class RepSetIterator;
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__QUANT_BOUND_INFERENCE_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return true;
}
-} /* namespace CVC4::theory::quantifiers */
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node_trie.h"
#include "theory/quantifiers/quant_module.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
std::ostream& operator<<(std::ostream& os, const QuantConflictFind::Effort& e);
-} /* namespace CVC4::theory::quantifiers */
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif
#include "theory/quantifiers/quant_module.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
QuantifiersModule::QuantifiersModule(
}
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
class TermDb;
}; /* class QuantifiersModule */
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANT_UTIL_H */
#include "theory/quantifiers/quant_relevance.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return it->second.size();
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/quantifiers/quant_util.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
void computeSymbols(Node n, std::vector<Node>& syms);
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANT_RELEVANCE_H */
#include "theory/quantifiers/first_order_model.h"
#include "theory/quantifiers/quant_bound_inference.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/rep_set.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__FIRST_ORDER_MODEL_H */
#include "theory/quantifiers/first_order_model.h"
#include "options/quantifiers_options.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "context/cdo.h"
#include "theory/quantifiers/quant_module.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class QuantifiersEngine;
}
}
-}
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
QuantPhaseReq::QuantPhaseReq( Node n, bool computeEq ){
}
}
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** Quantifiers utility
};
}
-}
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANT_UTIL_H */
#include "theory/quantifiers/term_util.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/attribute.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** Attribute true for function definition quantifiers */
}
}
-}
+} // namespace CVC5
#endif
#include "theory/quantifiers/instantiate.h"
#include "theory/quantifiers/skolemize.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/inference_manager_buffered.h"
#include "theory/quantifiers/quantifiers_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__QUANTIFIERS_INFERENCE_MANAGER_H */
#include "theory/quantifiers/relevant_domain.h"
#include "theory/quantifiers/term_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/sygus/synth_engine.h"
#include "theory/quantifiers/sygus_inst.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class QuantifiersEngine;
*/
class QuantifiersModules
{
- friend class ::CVC4::theory::QuantifiersEngine;
+ friend class ::CVC5::theory::QuantifiersEngine;
+
public:
QuantifiersModules();
~QuantifiersModules();
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__QUANTIFIERS_MODULES_H */
#include "theory/quantifiers/quant_module.h"
#include "theory/quantifiers/term_util.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/quant_util.h"
#include "theory/quantifiers/quantifiers_attributes.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class QuantifiersModule;
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__QUANTIFIERS_REGISTRY_H */
#include "theory/strings/theory_strings_utils.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return TrustNode::null();
}
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/theory_rewriter.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
bool marked = false);
}; /* class QuantifiersRewriter */
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__QUANTIFIERS_REWRITER_H */
#include "options/quantifiers_options.h"
#include "theory/uf/equality_engine_iterator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory.h"
#include "theory/theory_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__QUANTIFIERS_STATE_H */
#include "smt/smt_statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__QUANTIFIERS_STATISTICS_H */
#include "util/random.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/lazy_trie.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS___H */
#include "theory/quantifiers/term_registry.h"
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/first_order_model.h"
#include "theory/quantifiers/quant_util.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
void computeRelevantDomainLit( Node q, bool hasPol, bool pol, Node n );
};/* class RelevantDomain */
-
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__RELEVANT_DOMAIN_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace CVC4;
-using namespace CVC4::kind;
+using namespace CVC5;
+using namespace CVC5::kind;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
Trace(c) << std::endl;
}
-} /* namespace CVC4::theory::quantifiers */
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
Node getConjunct(int index);
};
-} /* namespace CVC4::theory::quantifiers */
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SINGLE_INV_PARTITION_H */
#include "theory/rewriter.h"
#include "theory/sort_inference.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
bool Skolemize::isProofEnabled() const { return d_epg != nullptr; }
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/eager_proof_generator.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
class DTypeConstructor;
std::unique_ptr<EagerProofGenerator> d_epg;
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SKOLEMIZE_H */
#include "smt/smt_engine_scope.h"
#include "util/random.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/lazy_trie.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SOLUTION_FILTER_H */
#include "theory/rewriter.h"
#include "theory/smt_engine_subsolver.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/single_inv_partition.h"
#include "theory/quantifiers/sygus/sygus_stats.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
//-------------- end decomposed conjecture
};
-}/* namespace CVC4::theory::quantifiers */
-}/* namespace CVC4::theory */
-}/* namespace CVC4 */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return false;
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/quantifiers/sygus/sygus_module.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
//---------------------------------end for symbolic constructors
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__CEGIS_H */
#include "theory/smt_engine_subsolver.h"
#include "util/random.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/sygus/cegis.h"
#include "util/result.h"
-namespace CVC4 {
+namespace CVC5 {
class SmtEngine;
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_REPAIR_CONST_H */
#include "theory/quantifiers/sygus/synth_conjecture.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/sygus/cegis.h"
#include "theory/quantifiers/sygus/sygus_unif_rl.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include <numeric> // for std::iota
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
Node EnumStreamConcrete::getCurrent() { return d_currTerm; }
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/quantifiers/sygus/synth_conjecture.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/quantifiers/sygus/example_min_eval.h"
#include "theory/quantifiers/sygus/synth_conjecture.h"
-using namespace CVC4;
-using namespace CVC4::kind;
+using namespace CVC5;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node_trie.h"
#include "theory/quantifiers/sygus/example_infer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#endif
#include "theory/quantifiers/quant_util.h"
-using namespace CVC4;
-using namespace CVC4::kind;
+using namespace CVC5;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/sygus/sygus_unif_io.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#endif
#include "expr/node_algorithm.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#include "expr/node.h"
#include "expr/node_trie.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#endif
#include "expr/node_algorithm.h"
#include "theory/datatypes/sygus_datatype_utils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__THEORY__QUANTIFIERS__RCONS_OBLIGATION_INFO_H
#include "theory/datatypes/sygus_datatype_utils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/sygus/sygus_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__THEORY__QUANTIFIERS__RCONS_TYPE_INFO_H
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_ABDUCT_H */
#include "theory/quantifiers/sygus/type_node_id_trie.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/sygus/synth_conjecture.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_ENUMERATOR_H */
#include "options/datatypes_options.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_ENUMERATOR_BASIC_H */
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/quantifiers/sygus/sygus_invariance.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_EVAL_UNFOLD_H */
#include "theory/quantifiers/sygus/sygus_invariance.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
getExplanationFor(trb, n, vn, exp, var_count, et, vnr, vnr_exp, sz);
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
int& sz);
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_EXPLAIN_H */
#include "theory/rewriter.h"
#include "theory/strings/word.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return true;
}
-}/* namespace CVC4::theory::quantifiers */
-}/* namespace CVC4::theory */
-}/* namespace CVC4 */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
#include "expr/sygus_datatype.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
//---------------- end grammar construction
};
-} /* namespace CVC4::theory::quantifiers */
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif
#include <numeric> // for std::iota
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/sygus_datatype.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_util.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
std::vector<Node>& terms);
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_GRAMMAR_RED_H */
#include "theory/rewriter.h"
#include "theory/smt_engine_subsolver.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/type_node.h"
#include "smt/smt_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
/**
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_INTERPOL_H */
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return d_isUniversal;
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
bool d_isUniversal;
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_INVARIANCE_H */
#include "theory/quantifiers/sygus/sygus_module.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
{
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
SynthConjecture* d_parent;
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_MODULE_H */
#include "theory/quantifiers/term_util.h"
#include "util/random.h"
-using namespace CVC4;
-using namespace CVC4::kind;
+using namespace CVC5;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-}
+} // namespace CVC5
#include "theory/quantifiers/sygus/sygus_module.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
std::map<Node, Node> d_enum_to_candidate;
};
-} /* namespace CVC4::theory::quantifiers */
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-} /* namespace CVC4::theory::quantifiers */
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
void getComponentVector(Kind k, Node n, std::vector<Node>& args);
};
-} /* namespace CVC4::theory::quantifiers */
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
#include "theory/smt_engine_subsolver.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS__SYGUS_QE_PREPROC_H */
#include "theory/datatypes/sygus_datatype_utils.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/sygus/rcons_obligation_info.h"
#include "theory/quantifiers/sygus/rcons_type_info.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif // CVC4__THEORY__QUANTIFIERS__SYGUS_RECONSTRUCT_H
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/smt_engine_subsolver.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return true;
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include <unordered_set>
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class LogicInfo;
bool getFitToLogicExcludeVar(LogicInfo& logic, Node n, Node& exvar);
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_REPAIR_CONST_H */
#include "smt/smt_statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#endif
#include "util/random.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
#include "theory/quantifiers/sygus/sygus_unif_strat.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
Node getMinimalTerm(const std::vector<Node>& terms);
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_UNIF_H */
#include <math.h>
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return conds[bestIndex];
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include <map>
#include "theory/quantifiers/sygus/sygus_unif.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
const std::vector<Node>& conds) override;
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_UNIF_IO_H */
#include <math.h>
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/lazy_trie.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_UNIF_RL_H */
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include <map>
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
//------------------------------ end strategy registration
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_UNIF_H */
#include "theory/quantifiers/quantifiers_attributes.h"
#include "theory/quantifiers/sygus/sygus_grammar_cons.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/subs.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS__SYGUS_UTILS_H */
#include "theory/rewriter.h"
#include "theory/smt_engine_subsolver.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#include "theory/quantifiers/sygus/sygus_stats.h"
#include "theory/quantifiers/sygus/template_infer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#endif
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/term_registry.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#include "theory/quantifiers/sygus/sygus_stats.h"
#include "theory/quantifiers/sygus/synth_conjecture.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#endif
#include "theory/quantifiers/sygus/sygus_utils.h"
#include "theory/quantifiers/term_util.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/quantifiers/sygus/transition_inference.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#endif
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return true;
}
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/quantifiers/sygus/type_info.h"
#include "theory/quantifiers/term_database.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
};
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__TERM_DATABASE_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/inst_match_trie.h"
#include "theory/quantifiers/single_inv_partition.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} /* namespace CVC4 */
+} // namespace CVC5
#endif
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/sygus/type_node_id_trie.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS__TYPE_INFO_H */
#include "theory/quantifiers/sygus/type_node_id_trie.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS__TYPE_NODE_ID_TRIE_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/decision_strategy.h"
#include "theory/quantifiers/quant_module.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class QuantifiersEngine;
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "util/random.h"
#include "util/sampler.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/term_enumeration.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
void registerSygusType(TypeNode tn);
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_SAMPLER_H */
#include "theory/rewriter.h"
#include "theory/uf/equality_engine.h"
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return k;
}
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "theory/theory.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
//------------------------------end higher-order term indexing
};/* class TermDb */
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__TERM_DATABASE_H */
#include "theory/quantifiers/quant_bound_inference.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return true;
}
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/type_node.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
std::vector<TypeEnumerator> d_typ_enum;
};
-} /* CVC4::theory::quantifiers namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__TERM_ENUMERATION_H */
#include "theory/quantifiers/fmf/first_order_model_fmc.h"
#include "theory/quantifiers/quantifiers_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/term_database.h"
#include "theory/quantifiers/term_enumeration.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__TERM_REGISTRY_H */
#include "theory/quantifiers/term_util.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
template <typename T>
static CVC4ostream& operator<<(CVC4ostream& out, const std::vector<T>& v)
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* TERM_TUPLE_ENUMERATOR_H_7640 */
#include "theory/strings/word.h"
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
return false;
}
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#include "expr/attribute.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
// attribute for "contains instantiation constants from"
static Node mkTypeConst(TypeNode tn, bool pol);
};/* class TermUtil */
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__TERM_UTIL_H */
#include "theory/quantifiers/quantifiers_rewriter.h"
#include "theory/valuation.h"
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory.h"
#include "theory/valuation.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
std::unique_ptr<QuantifiersEngine> d_qengine;
};/* class TheoryQuantifiers */
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__THEORY_QUANTIFIERS_H */
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace quantifiers {
}
};/* struct QuantifierInstPatternListTypeRule */
-}/* CVC4::theory::quantifiers namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace quantifiers
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS__THEORY_QUANTIFIERS_TYPE_RULES_H */
#include "theory/theory_engine.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
QuantifiersEngine::QuantifiersEngine(
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "context/cdlist.h"
#include "theory/quantifiers/quant_util.h"
-namespace CVC4 {
+namespace CVC5 {
class TheoryEngine;
// TODO: organize this more/review this, github issue #1163
class QuantifiersEngine {
- friend class ::CVC4::TheoryEngine;
+ friend class ::CVC5::TheoryEngine;
typedef context::CDHashMap< Node, bool, NodeHashFunction > BoolMap;
typedef context::CDHashSet<Node, NodeHashFunction> NodeSet;
std::map<Node, Node> d_quants_red_lem;
};/* class QuantifiersEngine */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__QUANTIFIERS_ENGINE_H */
#include <sstream>
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
RelevanceManager::RelevanceManager(context::UserContext* userContext,
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/valuation.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__RELEVANCE_MANAGER__H */
#include "theory/type_enumerator.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
void RepSet::clear(){
Debug( c ) << std::endl;
}
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class QuantifiersEngine;
}
};
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__REP_SET_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** Attribute true for nodes that have been rewritten with proofs enabled */
rewriter->clearCachesInternal();
}
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
#include "theory/theory_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
class TConvProofGenerator;
class ProofNodeManager;
#endif /* CVC4_ASSERTIONS */
};/* class Rewriter */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "expr/attribute.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
template <bool pre, theory::TheoryId theoryId>
}
};/* struct RewriteAttribute */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
${rewriter_includes}
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
Node Rewriter::getPreRewriteCache(theory::TheoryId theoryId, TNode node) {
}
void Rewriter::clearCachesInternal() {
- typedef CVC4::expr::attr::AttributeUniqueId AttributeUniqueId;
+ typedef CVC5::expr::attr::AttributeUniqueId AttributeUniqueId;
std::vector<AttributeUniqueId> preids;
${pre_rewrite_attribute_ids}
NodeManager::currentNM()->deleteAttributes(allids);
}
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
# src/theory/builtin/kinds.
#
-theory THEORY_SEP ::CVC4::theory::sep::TheorySep "theory/sep/theory_sep.h"
+theory THEORY_SEP ::CVC5::theory::sep::TheorySep "theory/sep/theory_sep.h"
typechecker "theory/sep/theory_sep_type_rules.h"
properties polite stable-infinite parametric
properties check presolve
-rewriter ::CVC4::theory::sep::TheorySepRewriter "theory/sep/theory_sep_rewriter.h"
+rewriter ::CVC5::theory::sep::TheorySepRewriter "theory/sep/theory_sep_rewriter.h"
nullaryoperator SEP_NIL "separation nil"
operator SEP_WAND 2 "separation magic wand"
operator SEP_LABEL 2 "separation label (internal use only)"
-typerule SEP_EMP ::CVC4::theory::sep::SepEmpTypeRule
-typerule SEP_PTO ::CVC4::theory::sep::SepPtoTypeRule
-typerule SEP_STAR ::CVC4::theory::sep::SepStarTypeRule
-typerule SEP_WAND ::CVC4::theory::sep::SepWandTypeRule
-typerule SEP_LABEL ::CVC4::theory::sep::SepLabelTypeRule
-typerule SEP_NIL ::CVC4::theory::sep::SepNilTypeRule
+typerule SEP_EMP ::CVC5::theory::sep::SepEmpTypeRule
+typerule SEP_PTO ::CVC5::theory::sep::SepPtoTypeRule
+typerule SEP_STAR ::CVC5::theory::sep::SepStarTypeRule
+typerule SEP_WAND ::CVC5::theory::sep::SepWandTypeRule
+typerule SEP_LABEL ::CVC5::theory::sep::SepLabelTypeRule
+typerule SEP_NIL ::CVC5::theory::sep::SepNilTypeRule
endtheory
#include "theory/valuation.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sep {
return curr;
}
-}/* CVC4::theory::sep namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace sep
+} // namespace theory
+} // namespace CVC5
#include "theory/uf/equality_engine.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class TheoryModel;
void initializeBounds();
};/* class TheorySep */
-}/* CVC4::theory::sep namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace sep
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__SEP__THEORY_SEP_H */
#include "theory/quantifiers/quant_util.h"
#include "options/sep_options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sep {
return RewriteResponse(node==retNode ? REWRITE_DONE : REWRITE_AGAIN_FULL, retNode);
}
-}/* CVC4::theory::sep namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace sep
+} // namespace theory
+} // namespace CVC5
#include "theory/theory_rewriter.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sep {
static bool isSpatial(Node n, std::map<Node, bool>& visited);
}; /* class TheorySepRewriter */
-}/* CVC4::theory::sep namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace sep
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__SEP__THEORY_SEP_REWRITER_H */
#ifndef CVC4__THEORY__SEP__THEORY_SEP_TYPE_RULES_H
#define CVC4__THEORY__SEP__THEORY_SEP_TYPE_RULES_H
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sep {
}
};/* struct SepLabelTypeRule */
-
-}/* CVC4::theory::sep namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace sep
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__SEP__THEORY_SEP_TYPE_RULES_H */
#include "theory/valuation.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/type_set.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/inference_manager_buffered.h"
#include "theory/sets/solver_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__SETS__INFERENCE_MANAGER_H */
#
theory THEORY_SETS \
- ::CVC4::theory::sets::TheorySets \
+ ::CVC5::theory::sets::TheorySets \
"theory/sets/theory_sets.h"
typechecker "theory/sets/theory_sets_type_rules.h"
-rewriter ::CVC4::theory::sets::TheorySetsRewriter \
+rewriter ::CVC5::theory::sets::TheorySetsRewriter \
"theory/sets/theory_sets_rewriter.h"
properties parametric
# constants
constant EMPTYSET \
- ::CVC4::EmptySet \
- ::CVC4::EmptySetHashFunction \
+ ::CVC5::EmptySet \
+ ::CVC5::EmptySetHashFunction \
"expr/emptyset.h" \
- "the empty set constant; payload is an instance of the CVC4::EmptySet class"
+ "the empty set constant; payload is an instance of the CVC5::EmptySet class"
# the type
operator SET_TYPE 1 "set type, takes as parameter the type of the elements"
cardinality SET_TYPE \
- "::CVC4::theory::sets::SetsProperties::computeCardinality(%TYPE%)" \
+ "::CVC5::theory::sets::SetsProperties::computeCardinality(%TYPE%)" \
"theory/sets/theory_sets_type_rules.h"
well-founded SET_TYPE \
- "::CVC4::theory::sets::SetsProperties::isWellFounded(%TYPE%)" \
- "::CVC4::theory::sets::SetsProperties::mkGroundTerm(%TYPE%)" \
+ "::CVC5::theory::sets::SetsProperties::isWellFounded(%TYPE%)" \
+ "::CVC5::theory::sets::SetsProperties::mkGroundTerm(%TYPE%)" \
"theory/sets/theory_sets_type_rules.h"
enumerator SET_TYPE \
- "::CVC4::theory::sets::SetEnumerator" \
+ "::CVC5::theory::sets::SetEnumerator" \
"theory/sets/theory_sets_type_enumerator.h"
# operators
operator MEMBER 2 "set membership predicate; first parameter a member of second"
constant SINGLETON_OP \
- ::CVC4::SingletonOp \
- ::CVC4::SingletonOpHashFunction \
+ ::CVC5::SingletonOp \
+ ::CVC5::SingletonOpHashFunction \
"theory/sets/singleton_op.h" \
- "operator for singletons; payload is an instance of the CVC4::SingletonOp class"
+ "operator for singletons; payload is an instance of the CVC5::SingletonOp class"
parameterized SINGLETON SINGLETON_OP 1 \
"constructs a set of a single element. First parameter is a SingletonOp. Second is a term"
operator JOIN_IMAGE 2 "set join image"
operator IDEN 1 "set identity"
-typerule UNION ::CVC4::theory::sets::SetsBinaryOperatorTypeRule
-typerule INTERSECTION ::CVC4::theory::sets::SetsBinaryOperatorTypeRule
-typerule SETMINUS ::CVC4::theory::sets::SetsBinaryOperatorTypeRule
-typerule SUBSET ::CVC4::theory::sets::SubsetTypeRule
-typerule MEMBER ::CVC4::theory::sets::MemberTypeRule
+typerule UNION ::CVC5::theory::sets::SetsBinaryOperatorTypeRule
+typerule INTERSECTION ::CVC5::theory::sets::SetsBinaryOperatorTypeRule
+typerule SETMINUS ::CVC5::theory::sets::SetsBinaryOperatorTypeRule
+typerule SUBSET ::CVC5::theory::sets::SubsetTypeRule
+typerule MEMBER ::CVC5::theory::sets::MemberTypeRule
typerule SINGLETON_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule SINGLETON ::CVC4::theory::sets::SingletonTypeRule
-typerule EMPTYSET ::CVC4::theory::sets::EmptySetTypeRule
-typerule INSERT ::CVC4::theory::sets::InsertTypeRule
-typerule CARD ::CVC4::theory::sets::CardTypeRule
-typerule COMPLEMENT ::CVC4::theory::sets::ComplementTypeRule
-typerule UNIVERSE_SET ::CVC4::theory::sets::UniverseSetTypeRule
-typerule COMPREHENSION ::CVC4::theory::sets::ComprehensionTypeRule
-typerule CHOOSE ::CVC4::theory::sets::ChooseTypeRule
-typerule IS_SINGLETON ::CVC4::theory::sets::IsSingletonTypeRule
+typerule SINGLETON ::CVC5::theory::sets::SingletonTypeRule
+typerule EMPTYSET ::CVC5::theory::sets::EmptySetTypeRule
+typerule INSERT ::CVC5::theory::sets::InsertTypeRule
+typerule CARD ::CVC5::theory::sets::CardTypeRule
+typerule COMPLEMENT ::CVC5::theory::sets::ComplementTypeRule
+typerule UNIVERSE_SET ::CVC5::theory::sets::UniverseSetTypeRule
+typerule COMPREHENSION ::CVC5::theory::sets::ComprehensionTypeRule
+typerule CHOOSE ::CVC5::theory::sets::ChooseTypeRule
+typerule IS_SINGLETON ::CVC5::theory::sets::IsSingletonTypeRule
-typerule JOIN ::CVC4::theory::sets::RelBinaryOperatorTypeRule
-typerule PRODUCT ::CVC4::theory::sets::RelBinaryOperatorTypeRule
-typerule TRANSPOSE ::CVC4::theory::sets::RelTransposeTypeRule
-typerule TCLOSURE ::CVC4::theory::sets::RelTransClosureTypeRule
-typerule JOIN_IMAGE ::CVC4::theory::sets::JoinImageTypeRule
-typerule IDEN ::CVC4::theory::sets::RelIdenTypeRule
+typerule JOIN ::CVC5::theory::sets::RelBinaryOperatorTypeRule
+typerule PRODUCT ::CVC5::theory::sets::RelBinaryOperatorTypeRule
+typerule TRANSPOSE ::CVC5::theory::sets::RelTransposeTypeRule
+typerule TCLOSURE ::CVC5::theory::sets::RelTransClosureTypeRule
+typerule JOIN_IMAGE ::CVC5::theory::sets::JoinImageTypeRule
+typerule IDEN ::CVC5::theory::sets::RelIdenTypeRule
-construle UNION ::CVC4::theory::sets::SetsBinaryOperatorTypeRule
-construle SINGLETON ::CVC4::theory::sets::SingletonTypeRule
+construle UNION ::CVC5::theory::sets::SetsBinaryOperatorTypeRule
+construle SINGLETON ::CVC5::theory::sets::SingletonTypeRule
endtheory
#ifndef CVC4__THEORY__SETS__NORMAL_FORM_H
#define CVC4__THEORY__SETS__NORMAL_FORM_H
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
};
}
}
-}
+} // namespace CVC5
#endif
#include "expr/dtype_cons.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
kind::APPLY_CONSTRUCTOR, dt[0].getConstructor(), a, b);
}
-};
-}/* CVC4::theory::sets namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+};
+} // namespace sets
+} // namespace theory
+} // namespace CVC5
#endif
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, const SingletonOp& op)
{
return getType() == op.getType();
}
-} // namespace CVC4
+} // namespace CVC5
#include <memory>
-namespace CVC4 {
+namespace CVC5 {
class TypeNode;
size_t operator()(const SingletonOp& op) const;
}; /* struct SingletonOpHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__SINGLETON_OP_H */
#include "theory/rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__SKOLEM_CACHE_H */
#include "theory/sets/theory_sets_private.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_state.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__SETS__THEORY_SOLVER_STATE_H */
#include "expr/emptyset.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/sets/skolem_cache.h"
#include "theory/sets/solver_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__SETS__TERM_REGISTRY_H */
#include "theory/theory_model.h"
#include "theory/trust_substitutions.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
d_theory.eqNotifyDisequal(t1, t2, reason);
}
-}/* CVC4::theory::sets namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace sets
+} // namespace theory
+} // namespace CVC5
#include "theory/theory_eq_notify.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
NotifyClass d_notify;
}; /* class TheorySets */
-}/* CVC4::theory::sets namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace sets
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__SETS__THEORY_SETS_H */
#include "util/result.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
std::map<Node, Node> d_isSingletonNodes;
};/* class TheorySetsPrivate */
-
-}/* CVC4::theory::sets namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace sets
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__SETS__THEORY_SETS_PRIVATE_H */
#include "theory/sets/theory_sets.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
}
}
}
-}
+} // namespace CVC5
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
bool isRel( Node n ) {return n.getType().isSet() && n.getType().getSetElementType().isTuple();}
};
-
-}/* CVC4::theory::sets namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
-
-
+} // namespace sets
+} // namespace theory
+} // namespace CVC5
#endif /* SRC_THEORY_SETS_THEORY_SETS_RELS_H_ */
#include "theory/sets/normal_form.h"
#include "theory/sets/rels_utils.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
return RewriteResponse(REWRITE_DONE, node);
}
-}/* CVC4::theory::sets namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace sets
+} // namespace theory
+} // namespace CVC5
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
bool checkConstantMembership(TNode elementTerm, TNode setTerm);
}; /* class TheorySetsRewriter */
-}/* CVC4::theory::sets namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace sets
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__SETS__THEORY_SETS_REWRITER_H */
#include "theory/sets/theory_sets_type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/sets/normal_form.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__SETS__TYPE_ENUMERATOR_H */
#include "theory/sets/normal_form.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace sets {
throw TypeCheckingExceptionPrivate(
n, " JoinImage cardinality constraint must be a constant");
}
- CVC4::Rational r(INT_MAX);
+ CVC5::Rational r(INT_MAX);
if (n[1].getConst<Rational>() > r) {
throw TypeCheckingExceptionPrivate(
n, " JoinImage Exceeded INT_MAX in cardinality constraint");
}
};/* struct SetsProperties */
-}/* CVC4::theory::sets namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace sets
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__SETS__THEORY_SETS_TYPE_RULES_H */
#include "theory/logic_info.h"
#include "theory/theory_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
// Always creates shared terms database. In all cases, shared terms
bool SharedSolver::isShared(TNode t) const { return d_sharedTerms.isShared(t); }
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/term_registration_visitor.h"
#include "theory/valuation.h"
-namespace CVC4 {
+namespace CVC5 {
class LogicInfo;
class ProofNodeManager;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__SHARED_SOLVER__H */
#include "theory/theory_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
SharedSolverDistributed::SharedSolverDistributed(TheoryEngine& te,
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/shared_solver.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__SHARED_SOLVER_DISTRIBUTED__H */
#include "theory/theory_engine.h"
using namespace std;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
SharedTermsDatabase::SharedTermsDatabase(TheoryEngine* theoryEngine,
context::Context* context,
return TrustNode::mkTrustPropExp(literal, exp, nullptr);
}
-} /* namespace CVC4 */
+} // namespace CVC5
#include "theory/uf/proof_equality_engine.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
class TheoryEngine;
ProofNodeManager* d_pnm;
};
-}
+} // namespace CVC5
#include "expr/skolem_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
SkolemLemma::SkolemLemma(TrustNode lem, Node k) : d_lemma(lem), d_skolem(k)
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__SKOLEM_LEMMA_H */
#include "smt/smt_engine_scope.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
// optimization: try to rewrite to constant
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "smt/smt_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
unsigned long timeout = 0);
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__SMT_ENGINE_SUBSOLVER_H */
#include "theory/rewriter.h"
#include "theory/quantifiers/quant_util.h"
-using namespace CVC4;
-using namespace CVC4::kind;
+using namespace CVC5;
+using namespace CVC5::kind;
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
void SortInference::UnionFind::print(const char * c){
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** sort inference
};
} // namespace theory
-}
+} // namespace CVC5
#endif
#include "theory/strings/word.h"
#include "theory/theory.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/strings/word.h"
using namespace std;
-using namespace CVC4::context;
-using namespace CVC4::kind;
+using namespace CVC5::context;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/strings/skolem_cache.h"
#include "theory/strings/solver_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__BASE_SOLVER_H */
#include "theory/strings/word.h"
using namespace std;
-using namespace CVC4::context;
-using namespace CVC4::kind;
+using namespace CVC5::context;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
return true;
}
-}/* CVC4::theory::strings namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace strings
+} // namespace theory
+} // namespace CVC5
#include "theory/strings/solver_state.h"
#include "theory/strings/term_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__CORE_SOLVER_H */
#include "theory/strings/theory_strings_utils.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/strings/eqc_info.h"
#include "theory/strings/solver_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__EAGER_SOLVER_H */
#include "theory/strings/word.h"
using namespace std;
-using namespace CVC4::context;
-using namespace CVC4::kind;
+using namespace CVC5::context;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "context/context.h"
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__EQC_INFO_H */
#include "theory/strings/theory_strings_utils.h"
using namespace std;
-using namespace CVC4::context;
-using namespace CVC4::kind;
+using namespace CVC5::context;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/strings/strings_rewriter.h"
#include "theory/strings/theory_strings_preprocess.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__EXTF_SOLVER_H */
#include "theory/strings/inference_manager.h"
#include "theory/strings/theory_strings_utils.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_inference.h"
#include "util/safe_print.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__INFER_INFO_H */
#include "theory/strings/regexp_operation.h"
#include "theory/strings/theory_strings_utils.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_proof_step_buffer.h"
#include "theory/uf/proof_equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__INFER_PROOF_CONS_H */
#include "theory/strings/word.h"
using namespace std;
-using namespace CVC4::context;
-using namespace CVC4::kind;
+using namespace CVC5::context;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_inference_manager.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
# src/theory/builtin/kinds.
#
-theory THEORY_STRINGS ::CVC4::theory::strings::TheoryStrings "theory/strings/theory_strings.h"
+theory THEORY_STRINGS ::CVC5::theory::strings::TheoryStrings "theory/strings/theory_strings.h"
properties check parametric presolve
-rewriter ::CVC4::theory::strings::SequencesRewriter "theory/strings/sequences_rewriter.h"
+rewriter ::CVC5::theory::strings::SequencesRewriter "theory/strings/sequences_rewriter.h"
typechecker "theory/strings/theory_strings_type_rules.h"
sort STRING_TYPE \
Cardinality::INTEGERS \
well-founded \
- "NodeManager::currentNM()->mkConst(::CVC4::String())" \
+ "NodeManager::currentNM()->mkConst(::CVC5::String())" \
"util/string.h" \
"String type"
"RegExp type"
enumerator STRING_TYPE \
- "::CVC4::theory::strings::StringEnumerator" \
+ "::CVC5::theory::strings::StringEnumerator" \
"theory/strings/type_enumerator.h"
constant CONST_STRING \
- ::CVC4::String \
- ::CVC4::strings::StringHashFunction \
+ ::CVC5::String \
+ ::CVC5::strings::StringHashFunction \
"util/string.h" \
"a string of characters"
# the type
operator SEQUENCE_TYPE 1 "seuence type, takes as parameter the type of the elements"
cardinality SEQUENCE_TYPE \
- "::CVC4::theory::strings::SequenceProperties::computeCardinality(%TYPE%)" \
+ "::CVC5::theory::strings::SequenceProperties::computeCardinality(%TYPE%)" \
"theory/strings/theory_strings_type_rules.h"
well-founded SEQUENCE_TYPE \
- "::CVC4::theory::strings::SequenceProperties::isWellFounded(%TYPE%)" \
- "::CVC4::theory::strings::SequenceProperties::mkGroundTerm(%TYPE%)" \
+ "::CVC5::theory::strings::SequenceProperties::isWellFounded(%TYPE%)" \
+ "::CVC5::theory::strings::SequenceProperties::mkGroundTerm(%TYPE%)" \
"theory/strings/theory_strings_type_rules.h"
enumerator SEQUENCE_TYPE \
- "::CVC4::theory::strings::SequenceEnumerator" \
+ "::CVC5::theory::strings::SequenceEnumerator" \
"theory/strings/type_enumerator.h"
constant CONST_SEQUENCE \
- ::CVC4::Sequence \
- ::CVC4::SequenceHashFunction \
+ ::CVC5::Sequence \
+ ::CVC5::SequenceHashFunction \
"expr/sequence.h" \
"a sequence of characters"
operator REGEXP_SIGMA 0 "regexp all characters"
constant REGEXP_REPEAT_OP \
- ::CVC4::RegExpRepeat \
- ::CVC4::RegExpRepeatHashFunction \
+ ::CVC5::RegExpRepeat \
+ ::CVC5::RegExpRepeatHashFunction \
"util/regexp.h" \
- "operator for regular expression repeat; payload is an instance of the CVC4::RegExpRepeat class"
+ "operator for regular expression repeat; payload is an instance of the CVC5::RegExpRepeat class"
parameterized REGEXP_REPEAT REGEXP_REPEAT_OP 1 "regular expression repeat; first parameter is a REGEXP_REPEAT_OP, second is a regular expression term"
constant REGEXP_LOOP_OP \
- ::CVC4::RegExpLoop \
- ::CVC4::RegExpLoopHashFunction \
+ ::CVC5::RegExpLoop \
+ ::CVC5::RegExpLoopHashFunction \
"util/regexp.h" \
- "operator for regular expression loop; payload is an instance of the CVC4::RegExpLoop class"
+ "operator for regular expression loop; payload is an instance of the CVC5::RegExpLoop class"
parameterized REGEXP_LOOP REGEXP_LOOP_OP 1 "regular expression loop; first parameter is a REGEXP_LOOP_OP, second is a regular expression term"
#internal
typerule REGEXP_STAR "SimpleTypeRule<RRegExp, ARegExp>"
typerule REGEXP_PLUS "SimpleTypeRule<RRegExp, ARegExp>"
typerule REGEXP_OPT "SimpleTypeRule<RRegExp, ARegExp>"
-typerule REGEXP_RANGE ::CVC4::theory::strings::RegExpRangeTypeRule
+typerule REGEXP_RANGE ::CVC5::theory::strings::RegExpRangeTypeRule
typerule REGEXP_REPEAT_OP "SimpleTypeRule<RBuiltinOperator>"
typerule REGEXP_REPEAT "SimpleTypeRule<RRegExp, ARegExp>"
typerule REGEXP_LOOP_OP "SimpleTypeRule<RBuiltinOperator>"
### operators that apply to both strings and sequences
-typerule STRING_CONCAT ::CVC4::theory::strings::StringConcatTypeRule
-typerule STRING_LENGTH ::CVC4::theory::strings::StringStrToIntTypeRule
-typerule STRING_SUBSTR ::CVC4::theory::strings::StringSubstrTypeRule
-typerule STRING_UPDATE ::CVC4::theory::strings::StringUpdateTypeRule
-typerule STRING_CHARAT ::CVC4::theory::strings::StringAtTypeRule
-typerule STRING_STRCTN ::CVC4::theory::strings::StringRelationTypeRule
-typerule STRING_STRIDOF ::CVC4::theory::strings::StringIndexOfTypeRule
-typerule STRING_STRREPL ::CVC4::theory::strings::StringReplaceTypeRule
-typerule STRING_STRREPLALL ::CVC4::theory::strings::StringReplaceTypeRule
-typerule STRING_PREFIX ::CVC4::theory::strings::StringStrToBoolTypeRule
-typerule STRING_SUFFIX ::CVC4::theory::strings::StringStrToBoolTypeRule
-typerule STRING_REV ::CVC4::theory::strings::StringStrToStrTypeRule
+typerule STRING_CONCAT ::CVC5::theory::strings::StringConcatTypeRule
+typerule STRING_LENGTH ::CVC5::theory::strings::StringStrToIntTypeRule
+typerule STRING_SUBSTR ::CVC5::theory::strings::StringSubstrTypeRule
+typerule STRING_UPDATE ::CVC5::theory::strings::StringUpdateTypeRule
+typerule STRING_CHARAT ::CVC5::theory::strings::StringAtTypeRule
+typerule STRING_STRCTN ::CVC5::theory::strings::StringRelationTypeRule
+typerule STRING_STRIDOF ::CVC5::theory::strings::StringIndexOfTypeRule
+typerule STRING_STRREPL ::CVC5::theory::strings::StringReplaceTypeRule
+typerule STRING_STRREPLALL ::CVC5::theory::strings::StringReplaceTypeRule
+typerule STRING_PREFIX ::CVC5::theory::strings::StringStrToBoolTypeRule
+typerule STRING_SUFFIX ::CVC5::theory::strings::StringStrToBoolTypeRule
+typerule STRING_REV ::CVC5::theory::strings::StringStrToStrTypeRule
### string specific operators
### sequence specific operators
-typerule CONST_SEQUENCE ::CVC4::theory::strings::ConstSequenceTypeRule
-typerule SEQ_UNIT ::CVC4::theory::strings::SeqUnitTypeRule
-typerule SEQ_NTH ::CVC4::theory::strings::SeqNthTypeRule
-typerule SEQ_NTH_TOTAL ::CVC4::theory::strings::SeqNthTypeRule
+typerule CONST_SEQUENCE ::CVC5::theory::strings::ConstSequenceTypeRule
+typerule SEQ_UNIT ::CVC5::theory::strings::SeqUnitTypeRule
+typerule SEQ_NTH ::CVC5::theory::strings::SeqNthTypeRule
+typerule SEQ_NTH_TOTAL ::CVC5::theory::strings::SeqNthTypeRule
endtheory
#include "theory/strings/word.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include <vector>
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__NORMAL_FORM_H */
#include "theory/strings/theory_strings_utils.h"
#include "theory/strings/word.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_checker.h"
#include "expr/proof_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__PROOF_CHECKER_H */
#include "theory/strings/regexp_entail.h"
#include "theory/strings/theory_strings_utils.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/eager_proof_generator.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__REGEXP_ELIM_H */
#include "theory/strings/word.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
else if (xc.isConst())
{
// check for constants
- CVC4::String s = xc.getConst<String>();
+ CVC5::String s = xc.getConst<String>();
if (Word::isEmpty(xc))
{
Trace("regexp-ext-rewrite-debug") << "- ignore empty" << std::endl;
{
std::vector<unsigned> ssVec;
ssVec.push_back(t == 0 ? s.back() : s.front());
- CVC4::String ss(ssVec);
+ CVC5::String ss(ssVec);
if (testConstStringInRegExp(ss, 0, rc))
{
// strip off one character
return true;
}
-bool RegExpEntail::testConstStringInRegExp(CVC4::String& s,
+bool RegExpEntail::testConstStringInRegExp(CVC5::String& s,
unsigned index_start,
TNode r)
{
{
case STRING_TO_REGEXP:
{
- CVC4::String s2 = s.substr(index_start, s.size() - index_start);
+ CVC5::String s2 = s.substr(index_start, s.size() - index_start);
if (r[0].isConst())
{
return (s2 == r[0].getConst<String>());
{
for (vec_k[i] = vec_k[i] + 1; vec_k[i] <= left; ++vec_k[i])
{
- CVC4::String t = s.substr(index_start + start, vec_k[i]);
+ CVC5::String t = s.substr(index_start + start, vec_k[i]);
if (testConstStringInRegExp(t, 0, r[i]))
{
start += vec_k[i];
{
for (unsigned i = s.size() - index_start; i > 0; --i)
{
- CVC4::String t = s.substr(index_start, i);
+ CVC5::String t = s.substr(index_start, i);
if (testConstStringInRegExp(t, 0, r[0]))
{
if (index_start + i == s.size()
uint32_t u = r[2].getConst<Rational>().getNumerator().toUnsignedInt();
for (unsigned len = s.size() - index_start; len >= 1; len--)
{
- CVC4::String t = s.substr(index_start, len);
+ CVC5::String t = s.substr(index_start, len);
if (testConstStringInRegExp(t, 0, r[0]))
{
if (len + index_start == s.size())
}
else
{
- Node num2 = nm->mkConst(CVC4::Rational(u - 1));
+ Node num2 = nm->mkConst(CVC5::Rational(u - 1));
Node r2 = nm->mkNode(REGEXP_LOOP, r[0], r[1], num2);
if (testConstStringInRegExp(s, index_start + len, r2))
{
}
for (unsigned len = 1; len <= s.size() - index_start; len++)
{
- CVC4::String t = s.substr(index_start, len);
+ CVC5::String t = s.substr(index_start, len);
if (testConstStringInRegExp(t, 0, r[0]))
{
- Node num2 = nm->mkConst(CVC4::Rational(l - 1));
+ Node num2 = nm->mkConst(CVC5::Rational(l - 1));
Node r2 = nm->mkNode(REGEXP_LOOP, r[0], num2, num2);
if (testConstStringInRegExp(s, index_start + len, r2))
{
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_rewriter.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
* Does the substring of s starting at index_start occur in constant regular
* expression r?
*/
- static bool testConstStringInRegExp(CVC4::String& s,
+ static bool testConstStringInRegExp(CVC5::String& s,
unsigned index_start,
TNode r);
/** Does regular expression node have (str.to.re "") as a child? */
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__REGEXP_ENTAIL_H */
#include "theory/strings/theory_strings_utils.h"
#include "theory/strings/word.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
d_false(NodeManager::currentNM()->mkConst(false)),
d_emptyRegexp(NodeManager::currentNM()->mkNode(kind::REGEXP_EMPTY,
std::vector<Node>{})),
- d_zero(NodeManager::currentNM()->mkConst(::CVC4::Rational(0))),
- d_one(NodeManager::currentNM()->mkConst(::CVC4::Rational(1))),
+ d_zero(NodeManager::currentNM()->mkConst(::CVC5::Rational(0))),
+ d_one(NodeManager::currentNM()->mkConst(::CVC5::Rational(1))),
d_sigma(NodeManager::currentNM()->mkNode(kind::REGEXP_SIGMA,
std::vector<Node>{})),
d_sigma_star(
}
// 0-unknown, 1-yes, 2-no
-int RegExpOpr::derivativeS( Node r, CVC4::String c, Node &retNode ) {
+int RegExpOpr::derivativeS(Node r, CVC5::String c, Node& retNode)
+{
Assert(c.size() < 2);
Trace("regexp-derive") << "RegExp-derive starts with /" << mkString( r ) << "/, c=" << c << std::endl;
break;
}
case kind::REGEXP_RANGE: {
- CVC4::String a = r[0].getConst<String>();
- CVC4::String b = r[1].getConst<String>();
+ CVC5::String a = r[0].getConst<String>();
+ CVC5::String b = r[1].getConst<String>();
retNode = (a <= c && c <= b) ? d_emptySingleton : d_emptyRegexp;
break;
}
return ret;
}
-Node RegExpOpr::derivativeSingle( Node r, CVC4::String c ) {
+Node RegExpOpr::derivativeSingle(Node r, CVC5::String c)
+{
Assert(c.size() < 2);
Trace("regexp-derive") << "RegExp-derive starts with /" << mkString( r ) << "/, c=" << c << std::endl;
Node retNode = d_emptyRegexp;
break;
}
case kind::REGEXP_RANGE: {
- CVC4::String a = r[0].getConst<String>();
- CVC4::String b = r[1].getConst<String>();
+ CVC5::String a = r[0].getConst<String>();
+ CVC5::String b = r[1].getConst<String>();
retNode = (a <= c && c <= b) ? d_emptySingleton : d_emptyRegexp;
break;
}
rt = itr2->second;
} else {
std::map< PairNodes, Node > cache2(cache);
- cache2[ p ] = NodeManager::currentNM()->mkNode(kind::REGEXP_RV, NodeManager::currentNM()->mkConst(CVC4::Rational(cnt)));
+ cache2[p] = NodeManager::currentNM()->mkNode(
+ kind::REGEXP_RV,
+ NodeManager::currentNM()->mkConst(CVC5::Rational(cnt)));
rt = intersectInternal(r1l, r2l, cache2, cnt+1);
cacheX[ pp ] = rt;
}
return eform;
}
-}/* CVC4::theory::strings namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace strings
+} // namespace theory
+} // namespace CVC5
#include "theory/strings/skolem_cache.h"
#include "util/string.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
};
class RegExpOpr {
- typedef std::pair< Node, CVC4::String > PairNodeStr;
+ typedef std::pair<Node, CVC5::String> PairNodeStr;
typedef std::set< Node > SetNodes;
typedef std::pair< Node, Node > PairNodes;
* - delta( (re.union (re.* "A") R) ) returns 1.
*/
int delta( Node r, Node &exp );
- int derivativeS( Node r, CVC4::String c, Node &retNode );
- Node derivativeSingle( Node r, CVC4::String c );
+ int derivativeS(Node r, CVC5::String c, Node& retNode);
+ Node derivativeSingle(Node r, CVC5::String c);
/**
* Returns the regular expression intersection of r1 and r2. If r1 or r2 is
* not constant, then this method returns null.
SkolemCache* d_sc;
};
-}/* CVC4::theory::strings namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace strings
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__REGEXP__OPERATION_H */
#include "theory/theory_model.h"
using namespace std;
-using namespace CVC4::context;
-using namespace CVC4::kind;
+using namespace CVC5::context;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
d_processed_memberships(s.getSatContext()),
d_regexp_opr(skc)
{
- d_emptyString = NodeManager::currentNM()->mkConst(::CVC4::String(""));
+ d_emptyString = NodeManager::currentNM()->mkConst(::CVC5::String(""));
std::vector<Node> nvec;
d_emptyRegexp = NodeManager::currentNM()->mkNode(REGEXP_EMPTY, nvec);
d_true = NodeManager::currentNM()->mkConst(true);
return true;
}
-CVC4::String RegExpSolver::getHeadConst(Node x)
+CVC5::String RegExpSolver::getHeadConst(Node x)
{
if (x.isConst())
{
Assert(x != d_emptyString);
Trace("regexp-derive") << "RegExpSolver::deriveRegExp: x=" << x
<< ", r= " << r << std::endl;
- CVC4::String s = getHeadConst(x);
+ CVC5::String s = getHeadConst(x);
// only allow RE_DERIVE for concrete constant regular expressions
if (!s.empty() && d_regexp_opr.getRegExpConstType(r) == RE_C_CONRETE_CONSTANT)
{
bool flag = true;
for (unsigned i = 0; i < s.size(); ++i)
{
- CVC4::String c = s.substr(i, 1);
+ CVC5::String c = s.substr(i, 1);
Node dc2;
int rt = d_regexp_opr.derivativeS(dc, c, dc2);
dc = dc2;
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/strings/solver_state.h"
#include "util/string.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
Node x, Node r, Node atom, bool& addedLemma, std::vector<Node>& nf_exp);
Node getMembership(Node n, bool isPos, unsigned i);
unsigned getNumMemberships(Node n, bool isPos);
- CVC4::String getHeadConst(Node x);
+ CVC5::String getHeadConst(Node x);
bool deriveRegExp(Node x, Node r, Node atom, std::vector<Node>& ant);
Node getNormalSymRegExp(Node r, std::vector<Node>& nf_exp);
// regular expression memberships
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__THEORY_STRINGS_H */
#include <iostream>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__REWRITES_H */
#include "theory/strings/word.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
return returnRewrite(node, r, Rewrite::RE_LOOP_STAR);
}
NodeManager* nm = NodeManager::currentNM();
- CVC4::Rational rMaxInt(String::maxSize());
+ CVC5::Rational rMaxInt(String::maxSize());
uint32_t l = utils::getLoopMinOccurrences(node);
std::vector<Node> vec_nodes;
for (unsigned i = 0; i < l; i++)
else if (x.isConst() && RegExpEntail::isConstRegExp(r))
{
// test whether x in node[1]
- CVC4::String s = x.getConst<String>();
+ CVC5::String s = x.getConst<String>();
bool test = RegExpEntail::testConstStringInRegExp(s, 0, r);
Node retNode = NodeManager::currentNM()->mkConst(test);
return returnRewrite(node, retNode, Rewrite::RE_IN_EVAL);
if (node[1].isConst() && node[2].isConst())
{
Node s = node[0];
- CVC4::Rational rMaxInt(String::maxSize());
+ CVC5::Rational rMaxInt(String::maxSize());
uint32_t start;
if (node[1].getConst<Rational>() > rMaxInt)
{
}
}
}
- Node zero = nm->mkConst(CVC4::Rational(0));
+ Node zero = nm->mkConst(CVC5::Rational(0));
// if entailed non-positive length or negative start point
if (ArithEntail::check(zero, node[1], true))
// rewriting for constant arguments
if (node[1].isConst())
{
- CVC4::Rational rMaxInt(String::maxSize());
+ CVC5::Rational rMaxInt(String::maxSize());
if (node[1].getConst<Rational>() > rMaxInt)
{
// start beyond the maximum size of strings
utils::getConcat(node[0], children0);
if (children0[0].isConst() && node[1].isConst() && node[2].isConst())
{
- CVC4::Rational rMaxInt(CVC4::String::maxSize());
+ CVC5::Rational rMaxInt(CVC5::String::maxSize());
if (node[2].getConst<Rational>() > rMaxInt)
{
// We know that, due to limitations on the size of string constants
Node val;
if (isPrefix)
{
- val = NodeManager::currentNM()->mkConst(::CVC4::Rational(0));
+ val = NodeManager::currentNM()->mkConst(::CVC5::Rational(0));
}
else
{
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/strings/strings_entail.h"
#include "theory/theory_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__SEQUENCES_REWRITER_H */
#include "smt/smt_statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
}
}
-}
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_histogram.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
}
}
-}
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__SEQUENCES_STATS_H */
#include "theory/strings/word.h"
#include "util/rational.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/skolem_manager.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__SKOLEM_CACHE_H */
#include "theory/strings/word.h"
using namespace std;
-using namespace CVC4::context;
-using namespace CVC4::kind;
+using namespace CVC5::context;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/uf/equality_engine.h"
#include "theory/valuation.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__SOLVER_STATE_H */
#include "options/strings_options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__STRATEGY_H */
#include "theory/strings/theory_strings_utils.h"
#include "theory/strings/word.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
Assert(dir == 1 || dir == -1);
Assert(nr.empty());
NodeManager* nm = NodeManager::currentNM();
- Node zero = nm->mkConst(CVC4::Rational(0));
+ Node zero = nm->mkConst(CVC5::Rational(0));
bool ret = false;
bool success = true;
unsigned sindex = 0;
Assert(ArithEntail::check(curr, true));
Node s = n1[sindex_use];
size_t slen = Word::getLength(s);
- Node ncl = nm->mkConst(CVC4::Rational(slen));
+ Node ncl = nm->mkConst(CVC5::Rational(slen));
Node next_s = nm->mkNode(MINUS, lowerBound, ncl);
next_s = Rewriter::rewrite(next_s);
Assert(next_s.isConst());
if (n2[index1].isConst())
{
Assert(n2[index1].getType().isString()); // string-only
- CVC4::String t = n2[index1].getConst<String>();
+ CVC5::String t = n2[index1].getConst<String>();
if (n1.size() == 1)
{
// if n1.size()==1, then if n2[index1] is not a number, we can drop
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__STRING_ENTAIL_H */
#include "theory/strings/strings_fmf.h"
using namespace std;
-using namespace CVC4::context;
-using namespace CVC4::kind;
+using namespace CVC5::context;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/strings/term_registry.h"
#include "theory/valuation.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__STRINGS_FMF_H */
#include "theory/strings/theory_strings_utils.h"
#include "util/rational.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/strings/sequences_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__STRINGS_REWRITER_H */
#include "theory/strings/word.h"
using namespace std;
-using namespace CVC4::context;
-using namespace CVC4::kind;
+using namespace CVC5::context;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/strings/solver_state.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__TERM_REGISTRY_H */
#include "theory/valuation.h"
using namespace std;
-using namespace CVC4::context;
-using namespace CVC4::kind;
+using namespace CVC5::context;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
return ss.str();
}
-}/* CVC4::theory::strings namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace strings
+} // namespace theory
+} // namespace CVC5
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
Strategy d_strat;
};/* class TheoryStrings */
-}/* CVC4::theory::strings namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace strings
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__THEORY_STRINGS_H */
#include "theory/strings/sequences_rewriter.h"
#include "theory/strings/word.h"
-using namespace CVC4;
-using namespace CVC4::kind;
+using namespace CVC5;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
return nm->mkNode(FORALL, bvl, body, ipl);
}
-}/* CVC4::theory::strings namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace strings
+} // namespace theory
+} // namespace CVC5
#include "theory/theory.h"
#include "util/hash.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
static Node mkForallInternal(Node bvl, Node body);
};
-}/* CVC4::theory::strings namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace strings
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__PREPROCESS_H */
#include "expr/sequence.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
}
}; /* struct SequenceProperties */
-}/* CVC4::theory::strings namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace strings
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__THEORY_STRINGS_TYPE_RULES_H */
#include "theory/strings/strings_entail.h"
#include "theory/strings/word.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
namespace utils {
} // namespace utils
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
namespace utils {
} // namespace utils
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/strings/theory_strings_utils.h"
#include "util/string.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/type_node.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
SeqEnumLen d_wenum;
}; /* class SequenceEnumerator */
-}/* CVC4::theory::strings namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace strings
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__TYPE_ENUMERATOR_H */
#include "expr/sequence.h"
#include "util/string.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/strings/word.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
SubstitutionMinimize::SubstitutionMinimize() {}
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** SubstitutionMinimize
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__SUBS_MINIMIZE_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
struct substitution_stack_element {
void SubstitutionMap::debugPrint() const { print(CVC4Message.getStream()); }
-}/* CVC4::theory namespace */
+} // namespace theory
std::ostream& operator<<(std::ostream& out, const theory::SubstitutionMap::iterator& i) {
return out << "[CDMap-iterator]";
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "context/cdhashmap.h"
#include "util/hash.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
return out;
}
-}/* CVC4::theory namespace */
+} // namespace theory
std::ostream& operator<<(std::ostream& out, const theory::SubstitutionMap::iterator& i);
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__THEORY__SUBSTITUTIONS_H */
#include "smt/logic_exception.h"
#include "theory/theory_engine.h"
-using namespace CVC4::theory;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
std::string PreRegisterVisitor::toString() const {
std::stringstream ss;
d_visited.clear();
}
-} // namespace CVC4
+} // namespace CVC5
#include <unordered_map>
-namespace CVC4 {
+namespace CVC5 {
class TheoryEngine;
TNodeToTheorySetMap d_preregistered;
};
-
-}
+} // namespace CVC5
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** Default value for the uninterpreted sorts is the UF theory */
return d_equalityEngine;
}
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
class TheoryEngine;
namespace eq {
class EqualityEngine;
-}/* CVC4::theory::eq namespace */
+ } // namespace eq
/**
* Base class for T-solvers. Abstract DPLL(T).
* after the quantifiers engine and model objects have been set up.
*/
class Theory {
- friend class ::CVC4::TheoryEngine;
+ friend class ::CVC5::TheoryEngine;
private:
// Disallow default construction, copy, assignment.
}
inline std::ostream& operator<<(std::ostream& out,
- const CVC4::theory::Theory& theory) {
+ const CVC5::theory::Theory& theory)
+{
return out << theory.identify();
}
return out;
}
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__THEORY_H */
using namespace std;
-using namespace CVC4::theory;
+using namespace CVC5::theory;
-namespace CVC4 {
+namespace CVC5 {
/* -------------------------------------------------------------------------- */
*/
#define CVC4_FOR_EACH_THEORY \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_BUILTIN) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_BOOL) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_UF) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_ARITH) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_BV) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_FP) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_ARRAYS) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_DATATYPES) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_SEP) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_SETS) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_BAGS) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_STRINGS) \
- CVC4_FOR_EACH_THEORY_STATEMENT(CVC4::theory::THEORY_QUANTIFIERS)
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_BUILTIN) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_BOOL) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_UF) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_ARITH) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_BV) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_FP) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_ARRAYS) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_DATATYPES) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_SEP) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_SETS) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_BAGS) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_STRINGS) \
+ CVC4_FOR_EACH_THEORY_STATEMENT(CVC5::theory::THEORY_QUANTIFIERS)
} // namespace theory
d_resourceManager->spendResource(r);
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/unsafe_interrupt_exception.h"
-namespace CVC4 {
+namespace CVC5 {
class ResourceManager;
class OutputManager;
class DecisionManager;
class RelevanceManager;
-}/* CVC4::theory namespace */
+} // namespace theory
namespace prop {
class PropEngine;
void checkTheoryAssertionsWithModel(bool hardFailure);
};/* class TheoryEngine */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__THEORY_ENGINE_H */
#include "expr/proof_node.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
TheoryEngineProofGenerator::TheoryEngineProofGenerator(ProofNodeManager* pnm,
context::UserContext* u)
return "TheoryEngineProofGenerator";
}
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_node_manager.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* A simple proof generator class used by the theory engine. This class
Node d_false;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY_ENGINE_PROOF_GENERATOR_H */
#include "theory/theory_inference_manager.h"
#include "theory/uf/equality_engine_notify.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "base/check.h"
#include "lib/ffs.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
TheoryId& operator++(TheoryId& id)
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/theory_inference_manager.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
SimpleTheoryLemma::SimpleTheoryLemma(InferenceId id,
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/inference_id.h"
#include "theory/output_channel.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class TheoryInferenceManager;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/uf/equality_engine.h"
#include "theory/uf/proof_equality_engine.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
TheoryInferenceManager::TheoryInferenceManager(Theory& t,
void TheoryInferenceManager::setIncomplete() { d_out.setIncomplete(); }
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_histogram.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNodeManager;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__THEORY_INFERENCE_MANAGER_H */
#include "theory/rewriter.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
TheoryModel::TheoryModel(context::Context* c,
return ss.str();
}
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace theory
+} // namespace CVC5
#include "theory/type_set.h"
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/** Theory Model class.
//---------------------------- end function values
};/* class TheoryModel */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__THEORY_MODEL_H */
#include "theory/uf/theory_uf_model.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
void TheoryEngineModelBuilder::Assigner::initialize(
Trace("model-builder") << "Finished assigning function values." << std::endl;
}
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace theory
+} // namespace CVC5
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
class TheoryEngine;
}; /* class TheoryEngineModelBuilder */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__THEORY_MODEL_BUILDER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
TheoryPreprocessor::TheoryPreprocessor(TheoryEngine& engine,
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/skolem_lemma.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
class LogicInfo;
class TheoryEngine;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__THEORY_PREPROCESSOR_H */
#include "expr/proof.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
TheoryProofStepBuffer::TheoryProofStepBuffer(ProofChecker* pc)
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_step_buffer.h"
#include "theory/builtin/proof_checker.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
* Class used to speculatively try and buffer a set of proof steps before
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__THEORY_PROOF_STEP_BUFFER_H */
#include "theory/theory_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
TrustRewriteResponse::TrustRewriteResponse(RewriteStatus status,
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class Rewriter;
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__THEORY_REWRITER_H */
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
TheoryState::TheoryState(context::Context* c,
Valuation& TheoryState::getValuation() { return d_valuation; }
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/valuation.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__SOLVER_STATE_H */
${theory_includes}
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
template <TheoryId theoryId>
default: Unhandled() << id;
}
}
-};/* struct CVC4::theory::TheoryConstructor */
+}; /* struct CVC5::theory::TheoryConstructor */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "expr/proof_ensure_closed.h"
#include "expr/proof_generator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
const char* toString(TrustNodeKind tnk)
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofGenerator;
class ProofNode;
std::ostream& operator<<(std::ostream& out, TrustNode n);
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__TRUST_NODE_H */
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
TrustSubstitutionMap::TrustSubstitutionMap(context::Context* c,
}
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_proof_step_buffer.h"
#include "theory/trust_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/**
};
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__TRUST_SUBSTITUTIONS_H */
#include "expr/node.h"
#include "expr/type_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class NoMoreValuesException : public Exception {
TypeNode getType() const { return d_te->getType(); }
};/* class TypeEnumerator */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__TYPE_ENUMERATOR_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
TypeEnumeratorInterface* TypeEnumerator::mkTypeEnumerator(
Unreachable();
}
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "theory/type_set.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
TypeSet::~TypeSet()
}
}
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace theory
+} // namespace CVC5
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
/* Type set
bool topLevel = true);
}; /* class TypeSet */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__TYPE_SET_H */
#include "theory/uf/theory_uf.h"
using namespace std;
-using namespace CVC4::kind;
-using namespace CVC4::context;
+using namespace CVC5::kind;
+using namespace CVC5::context;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
smtStatisticsRegistry()->unregisterStat(&d_max_model_size);
}
-}/* CVC4::theory namespace::uf */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace uf
+} // namespace theory
+} // namespace CVC5
#include "theory/theory.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
NodeBoolMap d_rel_eqc;
}; /* class CardinalityExtension */
-}/* CVC4::theory namespace::uf */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace uf
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY_UF_STRONG_SOLVER_H */
#include "expr/proof_checker.h"
#include "options/uf_options.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
} // namespace eq
} // Namespace theory
-} // Namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/uf/equality_engine_types.h"
-namespace CVC4 {
+namespace CVC5 {
class CDProof;
} // Namespace eq
} // Namespace theory
-} // Namespace CVC4
+} // namespace CVC5
#include "theory/rewriter.h"
#include "theory/uf/eq_proof.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
} // Namespace uf
} // Namespace theory
-} // Namespace CVC4
+} // namespace CVC5
#include "theory/uf/equality_engine_types.h"
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
} // Namespace eq
} // Namespace theory
-} // Namespace CVC4
+} // namespace CVC5
#endif
#include "theory/uf/equality_engine.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
} // namespace eq
} // Namespace theory
-} // Namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/uf/equality_engine_types.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
} // Namespace eq
} // Namespace theory
-} // Namespace CVC4
+} // namespace CVC5
#endif
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
} // Namespace eq
} // Namespace theory
-} // Namespace CVC4
+} // namespace CVC5
#endif
#include "util/hash.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
} // namespace eq
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__UF__EQUALITY_ENGINE_TYPES_H */
#include "theory/uf/theory_uf_rewriter.h"
using namespace std;
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_model.h"
#include "theory/theory_state.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* __CVC4__THEORY__UF__HO_EXTENSION_H */
# src/theory/builtin/kinds.
#
-theory THEORY_UF ::CVC4::theory::uf::TheoryUF "theory/uf/theory_uf.h"
+theory THEORY_UF ::CVC5::theory::uf::TheoryUF "theory/uf/theory_uf.h"
typechecker "theory/uf/theory_uf_type_rules.h"
properties stable-infinite parametric
properties check ppStaticLearn presolve
-rewriter ::CVC4::theory::uf::TheoryUfRewriter "theory/uf/theory_uf_rewriter.h"
+rewriter ::CVC5::theory::uf::TheoryUfRewriter "theory/uf/theory_uf_rewriter.h"
parameterized APPLY_UF VARIABLE 1: "application of an uninterpreted function; first parameter is the function, remaining ones are parameters to that function"
-typerule APPLY_UF ::CVC4::theory::uf::UfTypeRule
+typerule APPLY_UF ::CVC5::theory::uf::UfTypeRule
variable BOOLEAN_TERM_VARIABLE "Boolean term variable"
operator CARDINALITY_CONSTRAINT 2 "cardinality constraint on sort S: first parameter is (any) term of sort S, second is a positive integer constant k that bounds the cardinality of S"
-typerule CARDINALITY_CONSTRAINT ::CVC4::theory::uf::CardinalityConstraintTypeRule
+typerule CARDINALITY_CONSTRAINT ::CVC5::theory::uf::CardinalityConstraintTypeRule
operator COMBINED_CARDINALITY_CONSTRAINT 1 "combined cardinality constraint; parameter is a positive integer constant k that bounds the sum of the cardinalities of all sorts in the signature"
-typerule COMBINED_CARDINALITY_CONSTRAINT ::CVC4::theory::uf::CombinedCardinalityConstraintTypeRule
+typerule COMBINED_CARDINALITY_CONSTRAINT ::CVC5::theory::uf::CombinedCardinalityConstraintTypeRule
parameterized PARTIAL_APPLY_UF APPLY_UF 1: "partial uninterpreted function application"
-typerule PARTIAL_APPLY_UF ::CVC4::theory::uf::PartialTypeRule
+typerule PARTIAL_APPLY_UF ::CVC5::theory::uf::PartialTypeRule
operator CARDINALITY_VALUE 1 "cardinality value of sort S: first parameter is (any) term of sort S"
-typerule CARDINALITY_VALUE ::CVC4::theory::uf::CardinalityValueTypeRule
+typerule CARDINALITY_VALUE ::CVC5::theory::uf::CardinalityValueTypeRule
operator HO_APPLY 2 "higher-order (partial) function application"
-typerule HO_APPLY ::CVC4::theory::uf::HoApplyTypeRule
+typerule HO_APPLY ::CVC5::theory::uf::HoApplyTypeRule
endtheory
#include "theory/uf/theory_uf_rewriter.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/proof_checker.h"
#include "expr/proof_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__UF__PROOF_CHECKER_H */
#include "theory/uf/equality_engine.h"
#include "theory/uf/proof_checker.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace eq {
} // namespace eq
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
#include "theory/eager_proof_generator.h"
-namespace CVC4 {
+namespace CVC5 {
class ProofNode;
class ProofNodeManager;
} // namespace eq
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__THEORY__STRINGS__PROOF_MANAGER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
-using namespace ::CVC4::context;
+using namespace ::CVC5::context;
SymmetryBreaker::Template::Template() :
d_template(),
}
}
-}/* CVC4::theory::uf namespace */
-}/* CVC4::theory namespace */
+} // namespace uf
+} // namespace theory
std::ostream& operator<<(std::ostream& out, const theory::uf::SymmetryBreaker::Permutation& p) {
out << "{";
return out;
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "util/statistics_registry.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
};/* class SymmetryBreaker */
-}/* CVC4::theory::uf namespace */
-}/* CVC4::theory namespace */
+} // namespace uf
+} // namespace theory
-std::ostream& operator<<(std::ostream& out, const ::CVC4::theory::uf::SymmetryBreaker::Permutation& p);
+std::ostream& operator<<(
+ std::ostream& out,
+ const ::CVC5::theory::uf::SymmetryBreaker::Permutation& p);
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__THEORY__UF__SYMMETRY_BREAKER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
return ret;
}
-} /* namespace CVC4::theory::uf */
-} /* namespace CVC4::theory */
-} /* namespace CVC4 */
+} // namespace uf
+} // namespace theory
+} // namespace CVC5
#include "theory/uf/symmetry_breaker.h"
#include "theory/uf/theory_uf_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
std::map<TypeNode, bool> d_isHoType;
};/* class TheoryUF */
-}/* CVC4::theory::uf namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace uf
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__UF__THEORY_UF_H */
#include "theory/rewriter.h"
#include "theory/theory_model.h"
-using namespace CVC4::kind;
+using namespace CVC5::kind;
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
class TheoryModel;
}
}
-}
+} // namespace CVC5
#endif
#include "theory/substitutions.h"
#include "theory/theory_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
}
}; /* class TheoryUfRewriter */
-}/* CVC4::theory::uf namespace */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace uf
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__UF__THEORY_UF_REWRITER_H */
#include <climits>
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
namespace uf {
throw TypeCheckingExceptionPrivate(
n, "cardinality constraint must be a constant");
}
- CVC4::Rational r(INT_MAX);
+ CVC5::Rational r(INT_MAX);
if (n[1].getConst<Rational>() > r) {
throw TypeCheckingExceptionPrivate(
n, "Exceeded INT_MAX in cardinality constraint");
throw TypeCheckingExceptionPrivate(
n, "combined cardinality constraint must be a constant");
}
- CVC4::Rational r(INT_MAX);
+ CVC5::Rational r(INT_MAX);
if (n[0].getConst<Rational>() > r) {
throw TypeCheckingExceptionPrivate(
n, "Exceeded INT_MAX in combined cardinality constraint");
}
}; /* class HoApplyTypeRule */
-} /* CVC4::theory::uf namespace */
-} /* CVC4::theory namespace */
-} /* CVC4 namespace */
+} // namespace uf
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__UF__THEORY_UF_TYPE_RULES_H */
#include "theory/theory_engine.h"
#include "theory/theory_model.h"
-namespace CVC4 {
+namespace CVC5 {
namespace theory {
std::ostream& operator<<(std::ostream& os, EqualityStatus s)
return theory->facts_end();
}
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#include "expr/node.h"
#include "options/theory_options.h"
-namespace CVC4 {
+namespace CVC5 {
class TheoryEngine;
context::CDList<Assertion>::const_iterator factsEnd(TheoryId tid);
};/* class Valuation */
-}/* CVC4::theory namespace */
-}/* CVC4 namespace */
+} // namespace theory
+} // namespace CVC5
#endif /* CVC4__THEORY__VALUATION_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& out, const AbstractValue& val) {
return out << "@" << val.getIndex();
index.toString().c_str());
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
class AbstractValue
{
}
}; /* struct AbstractValueHashFunction */
-}/* CVC4 namespace */
+} // namespace CVC5
#include "base/check.h"
#include "base/exception.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* BinaryHeap that orders its elements greatest-first (i.e., in the opposite
template <class Elem, class CmpFcn>
const size_t BinaryHeap<Elem,CmpFcn>::MAX_SIZE = (std::numeric_limits<size_t>::max()-2)/2;
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__BIN_HEAP_H */
#include "base/exception.h"
-namespace CVC4 {
+namespace CVC5 {
unsigned BitVector::getSize() const { return d_size; }
return ~BitVector::mkMinSigned(size);
}
-} // namespace CVC4
+} // namespace CVC5
#include "base/exception.h"
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
class BitVector
{
return os << "[" << bv.d_size << "]";
}
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__BITVECTOR_H */
#ifndef CVC4__BOOL_H
#define CVC4__BOOL_H
-namespace CVC4 {
+namespace CVC5 {
struct BoolHashFunction {
inline size_t operator()(bool b) const {
}
};/* struct BoolHashFunction */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__BOOL_H */
#include "base/check.h"
#include "base/exception.h"
-namespace CVC4 {
+namespace CVC5 {
const Integer Cardinality::s_unknownCard(0);
const Integer Cardinality::s_intCard(-1);
return out;
}
-} /* CVC4 namespace */
+} // namespace CVC5
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* Representation for a Beth number, used only to construct
/** Print a cardinality in a human-readable fashion. */
std::ostream& operator<<(std::ostream& out, const Cardinality& c);
-} /* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__CARDINALITY_H */
#include "base/check.h"
#include "util/index.h"
-
-namespace CVC4 {
+namespace CVC5 {
template <class T>
class DenseMap {
void pop_back() { d_map.pop_back(); }
}; /* class DenseMultiset */
-}/* CVC4 namespace */
+} // namespace CVC5
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
Divisible::Divisible(const Integer& n) : k(n) {
PrettyCheckArgument(n > 0, n, "Divisible predicate must be constructed over positive N");
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* The structure representing the divisibility-by-k predicate.
return os << "divisible-by-" << d.k;
}
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__DIVISIBLE_H */
/* -------------------------------------------------------------------------- */
-namespace CVC4 {
+namespace CVC5 {
/* -------------------------------------------------------------------------- */
return os << "(_ to_fp " << fpcs.getSize().exponentWidth() << " "
<< fpcs.getSize().significandWidth() << ")";
}
-}/* CVC4 namespace */
+} // namespace CVC5
/* -------------------------------------------------------------------------- */
-namespace CVC4 {
+namespace CVC5 {
/* -------------------------------------------------------------------------- */
{
inline size_t operator()(const FloatingPointToBV& fptbv) const
{
- UnsignedHashFunction< ::CVC4::BitVectorSize> f;
+ UnsignedHashFunction< ::CVC5::BitVectorSize> f;
return (key ^ 0x46504256) ^ f(fptbv.d_bv_size);
}
}; /* struct FloatingPointToBVHashFunction */
std::ostream& operator<<(std::ostream& os,
const FloatingPointConvertSort& fpcs);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__FLOATINGPOINT_H */
#define CVC4_LIT_ITE_DFN(T) \
template <> \
- struct ite<::CVC4::symfpuLiteral::CVC4Prop, T> \
+ struct ite<::CVC5::symfpuLiteral::CVC4Prop, T> \
{ \
- static const T& iteOp(const ::CVC4::symfpuLiteral::CVC4Prop& cond, \
+ static const T& iteOp(const ::CVC5::symfpuLiteral::CVC4Prop& cond, \
const T& l, \
const T& r) \
{ \
} \
}
-CVC4_LIT_ITE_DFN(::CVC4::symfpuLiteral::traits::rm);
-CVC4_LIT_ITE_DFN(::CVC4::symfpuLiteral::traits::prop);
-CVC4_LIT_ITE_DFN(::CVC4::symfpuLiteral::traits::sbv);
-CVC4_LIT_ITE_DFN(::CVC4::symfpuLiteral::traits::ubv);
+CVC4_LIT_ITE_DFN(::CVC5::symfpuLiteral::traits::rm);
+CVC4_LIT_ITE_DFN(::CVC5::symfpuLiteral::traits::prop);
+CVC4_LIT_ITE_DFN(::CVC5::symfpuLiteral::traits::sbv);
+CVC4_LIT_ITE_DFN(::CVC5::symfpuLiteral::traits::ubv);
#undef CVC4_LIT_ITE_DFN
} // namespace symfpu
/* -------------------------------------------------------------------------- */
-namespace CVC4 {
+namespace CVC5 {
uint32_t FloatingPointLiteral::getUnpackedExponentWidth(FloatingPointSize& size)
{
template class wrappedBitVector<true>;
template class wrappedBitVector<false>;
-traits::rm traits::RNE(void) { return ::CVC4::ROUND_NEAREST_TIES_TO_EVEN; };
-traits::rm traits::RNA(void) { return ::CVC4::ROUND_NEAREST_TIES_TO_AWAY; };
-traits::rm traits::RTP(void) { return ::CVC4::ROUND_TOWARD_POSITIVE; };
-traits::rm traits::RTN(void) { return ::CVC4::ROUND_TOWARD_NEGATIVE; };
-traits::rm traits::RTZ(void) { return ::CVC4::ROUND_TOWARD_ZERO; };
+traits::rm traits::RNE(void) { return ::CVC5::ROUND_NEAREST_TIES_TO_EVEN; };
+traits::rm traits::RNA(void) { return ::CVC5::ROUND_NEAREST_TIES_TO_AWAY; };
+traits::rm traits::RTP(void) { return ::CVC5::ROUND_TOWARD_POSITIVE; };
+traits::rm traits::RTN(void) { return ::CVC5::ROUND_TOWARD_NEGATIVE; };
+traits::rm traits::RTZ(void) { return ::CVC5::ROUND_TOWARD_ZERO; };
// This is a literal back-end so props are actually bools
// so these can be handled in the same way as the internal assertions above
}
} // namespace symfpuLiteral
-} // namespace CVC4
+} // namespace CVC5
/* -------------------------------------------------------------------------- */
-namespace CVC4 {
+namespace CVC5 {
class FloatingPointSize;
class FloatingPointLiteral;
using CVC4BitWidth = uint32_t;
using CVC4Prop = bool;
-using CVC4RM = ::CVC4::RoundingMode;
-using CVC4FPSize = ::CVC4::FloatingPointSize;
+using CVC4RM = ::CVC5::RoundingMode;
+using CVC4FPSize = ::CVC5::FloatingPointSize;
using CVC4UnsignedBitVector = wrappedBitVector<false>;
using CVC4SignedBitVector = wrappedBitVector<true>;
};
/**
- * This extends the interface for CVC4::BitVector for compatibility with symFPU.
+ * This extends the interface for CVC5::BitVector for compatibility with symFPU.
* The template parameter distinguishes signed and unsigned bit-vectors, a
* distinction symfpu uses.
*/
/**
* Inherited but ...
* *sigh* if we use the inherited version then it will return a
- * CVC4::BitVector which can be converted back to a
+ * CVC5::BitVector which can be converted back to a
* wrappedBitVector<isSigned> but isn't done automatically when working
* out types for templates instantiation. ITE is a particular
* problem as expressions and constants no longer derive the
/* -------------------------------------------------------------------------- */
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "base/check.h"
-namespace CVC4 {
+namespace CVC5 {
FloatingPointSize::FloatingPointSize(uint32_t exp_size, uint32_t sig_size)
: d_exp_size(exp_size), d_sig_size(sig_size)
Assert(validSignificandSize(d_sig_size));
}
-} // namespace CVC4
+} // namespace CVC5
#ifndef CVC4__FLOATINGPOINT_SIZE_H
#define CVC4__FLOATINGPOINT_SIZE_H
-namespace CVC4 {
+namespace CVC5 {
// Inline these!
inline bool validExponentSize(uint32_t e) { return e >= 2; }
| t.significandWidth());
}
}; /* struct FloatingPointSizeHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif
#include <gmpxx.h>
-namespace CVC4 {
+namespace CVC5 {
/** Hashes the gmp integer primitive in a word by word fashion. */
inline size_t gmpz_hash(const mpz_t toHash) {
return hash;
}/* gmpz_hash() */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__GMP_UTIL_H */
}/* std namespace */
-namespace CVC4 {
+namespace CVC5 {
namespace fnv1a {
}
};/* struct PairHashFunction */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__HASH_H */
#include "base/exception.h"
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
struct IntAnd
{
return os << "[" << ia.d_size << "]";
}
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__IAND_H */
#include <limits>
-namespace CVC4 {
+namespace CVC5 {
static_assert(sizeof(Index) <= sizeof(size_t),
"Index cannot be larger than size_t");
* (Limited testing suggests a ~1/16 of running time.) Interestingly,
* uint_fast32_t also has a sizeof == 8 on x86_64.
*/
-}/* CVC4 namespace */
+} // namespace CVC5
#ifndef CVC4__INDEX_H
#define CVC4__INDEX_H
-namespace CVC4 {
+namespace CVC5 {
/** Index is a standardized unsigned integer used for efficient indexing. */
using Index = uint32_t;
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__INDEX_H */
#ifndef CVC4__UTIL__INDEXED_ROOT_PREDICATE_H
#define CVC4__UTIL__INDEXED_ROOT_PREDICATE_H
-namespace CVC4 {
+namespace CVC5 {
/**
* The structure representing the index of a root predicate.
}
}; /* struct IndexedRootPredicateHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif
\ No newline at end of file
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
signed int Integer::s_fastSignedIntMin = -(1 << 29);
signed int Integer::s_fastSignedIntMax = (1 << 29) - 1;
{
return os << n.toString();
}
-} /* namespace CVC4 */
+} // namespace CVC5
#include "base/exception.h"
#include "cvc4_export.h" // remove when Cvc language support is removed
-namespace CVC4 {
+namespace CVC5 {
class Rational;
class CVC4_EXPORT Integer
{
- friend class CVC4::Rational;
+ friend class CVC5::Rational;
public:
/**
struct IntegerHashFunction
{
- size_t operator()(const CVC4::Integer& i) const { return i.hash(); }
+ size_t operator()(const CVC5::Integer& i) const { return i.hash(); }
}; /* struct IntegerHashFunction */
std::ostream& operator<<(std::ostream& os, const Integer& n);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__INTEGER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
Integer::Integer(const char* s, unsigned base)
: d_value(s, base)
return (a >= b) ? a : b;
}
-} /* namespace CVC4 */
+} // namespace CVC5
#include "cvc4_export.h" // remove when Cvc language support is removed
-namespace CVC4 {
+namespace CVC5 {
class Rational;
class CVC4_EXPORT Integer
{
- friend class CVC4::Rational;
+ friend class CVC5::Rational;
public:
/**
struct IntegerHashFunction
{
- inline size_t operator()(const CVC4::Integer& i) const { return i.hash(); }
+ inline size_t operator()(const CVC5::Integer& i) const { return i.hash(); }
}; /* struct IntegerHashFunction */
inline std::ostream& operator<<(std::ostream& os, const Integer& n)
return os << n.toString();
}
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__INTEGER_H */
#include "base/exception.h"
-namespace CVC4 {
+namespace CVC5 {
template <class T>
class Maybe
return out;
}
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__UTIL__MAYBE_H */
#include <ostream>
-namespace CVC4 {
+namespace CVC5 {
StreamFormatScope::StreamFormatScope(std::ostream& out)
: d_out(out), d_format_flags(out.flags()), d_precision(out.precision())
d_out.flags(d_format_flags);
}
-} // namespace CVC4
+} // namespace CVC5
#include <ios>
#include <iosfwd>
-namespace CVC4 {
+namespace CVC5 {
// Saves the formatting of an ostream and restores the previous settings on
// destruction. Example usage:
std::streamsize d_precision;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__UTIL__OSTREAM_UTIL_H */
#include "util/rational.h"
#include "util/real_algebraic_number.h"
-namespace CVC4 {
+namespace CVC5 {
namespace poly_utils {
namespace {
}
} // namespace poly_utils
-} // namespace CVC4
+} // namespace CVC5
#endif
#include <poly/polyxx.h>
-namespace CVC4 {
+namespace CVC5 {
/**
* Utilities for working with libpoly.
* This namespace contains various basic conversion routines necessary for the
*/
namespace poly_utils {
-/** Converts a poly::Integer to a CVC4::Integer. */
+/** Converts a poly::Integer to a CVC5::Integer. */
Integer toInteger(const poly::Integer& i);
-/** Converts a poly::Integer to a CVC4::Rational. */
+/** Converts a poly::Integer to a CVC5::Rational. */
Rational toRational(const poly::Integer& r);
-/** Converts a poly::Rational to a CVC4::Rational. */
+/** Converts a poly::Rational to a CVC5::Rational. */
Rational toRational(const poly::Rational& r);
-/** Converts a poly::DyadicRational to a CVC4::Rational. */
+/** Converts a poly::DyadicRational to a CVC5::Rational. */
Rational toRational(const poly::DyadicRational& dr);
-/** Converts a poly::Value to a CVC4::Rational (that may be a bit above). */
+/** Converts a poly::Value to a CVC5::Rational (that may be a bit above). */
Rational toRationalAbove(const poly::Value& v);
-/** Converts a poly::Value to a CVC4::Rational (that may be a bit below). */
+/** Converts a poly::Value to a CVC5::Rational (that may be a bit below). */
Rational toRationalBelow(const poly::Value& v);
-/** Converts a CVC4::Integer to a poly::Integer. */
+/** Converts a CVC5::Integer to a poly::Integer. */
poly::Integer toInteger(const Integer& i);
-/** Converts a vector of CVC4::Integers to a vector of poly::Integers. */
+/** Converts a vector of CVC5::Integers to a vector of poly::Integers. */
std::vector<poly::Integer> toInteger(const std::vector<Integer>& vi);
-/** Converts a CVC4::Rational to a poly::Rational. */
+/** Converts a CVC5::Rational to a poly::Rational. */
poly::Rational toRational(const Rational& r);
/**
- * Converts a CVC4::Rational to a poly::DyadicRational. If the input is not
+ * Converts a CVC5::Rational to a poly::DyadicRational. If the input is not
* dyadic, no result is produced.
*/
Maybe<poly::DyadicRational> toDyadicRational(const Rational& r);
/**
* Constructs a poly::AlgebraicNumber, allowing for refinement of the
- * CVC4::Rational bounds. As a poly::AlgebraicNumber works on
+ * CVC5::Rational bounds. As a poly::AlgebraicNumber works on
* poly::DyadicRationals internally, the bounds are iteratively refined using
* approximateToDyadic until the respective interval is isolating. If the
* provided rational bounds are already dyadic, the refinement is skipped.
const Rational& upper);
/**
- * Constructs a CVC4::RealAlgebraicNumber, simply wrapping
+ * Constructs a CVC5::RealAlgebraicNumber, simply wrapping
* toPolyRanWithRefinement.
*/
RealAlgebraicNumber toRanWithRefinement(poly::UPolynomial&& p,
const poly::Polynomial& poly);
} // namespace poly_utils
-} // namespace CVC4
+} // namespace CVC5
#endif
#include <cfloat>
#include "base/check.h"
-namespace CVC4 {
+namespace CVC5 {
Random::Random(uint64_t seed) { setSeed(seed); }
return r < p;
}
-}
+} // namespace CVC5
#ifndef CVC4__UTIL__RANDOM_H
#define CVC4__UTIL__RANDOM_H
-namespace CVC4 {
+namespace CVC5 {
class Random
{
uint64_t d_state;
};
-} // namespace CVC4
+} // namespace CVC5
#endif
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
/* Computes a rational given a decimal string. The rational
* version of <code>xxx.yyy</code> is <code>xxxyyy/(10^3)</code>.
}
}
-} /* namespace CVC4 */
+} // namespace CVC5
#include "util/integer.h"
#include "util/maybe.h"
-namespace CVC4 {
+namespace CVC5 {
/**
** A multi-precision rational constant.
struct RationalHashFunction
{
- inline size_t operator()(const CVC4::Rational& r) const { return r.hash(); }
+ inline size_t operator()(const CVC5::Rational& r) const { return r.hash(); }
}; /* struct RationalHashFunction */
std::ostream& operator<<(std::ostream& os, const Rational& n) CVC4_EXPORT;
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__RATIONAL_H */
#include "base/check.h"
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& os, const Rational& q){
return os << q.toString();
return Maybe<Rational>();
}
-} /* namespace CVC4 */
+} // namespace CVC5
#include "util/integer.h"
#include "util/maybe.h"
-namespace CVC4 {
+namespace CVC5 {
/**
** A multi-precision rational constant.
struct RationalHashFunction
{
- inline size_t operator()(const CVC4::Rational& r) const { return r.hash(); }
+ inline size_t operator()(const CVC5::Rational& r) const { return r.hash(); }
}; /* struct RationalHashFunction */
std::ostream& operator<<(std::ostream& os, const Rational& n) CVC4_EXPORT;
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__RATIONAL_H */
#include "base/check.h"
#include "util/poly_util.h"
-namespace CVC4 {
+namespace CVC5 {
RealAlgebraicNumber::RealAlgebraicNumber(poly::AlgebraicNumber&& an)
: d_value(std::move(an))
bool isZero(const RealAlgebraicNumber& ran) { return is_zero(ran.getValue()); }
bool isOne(const RealAlgebraicNumber& ran) { return is_one(ran.getValue()); }
-} // namespace CVC4
+} // namespace CVC5
#include "util/integer.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* Represents a real algebraic number based on poly::AlgebraicNumber.
/** Check whether a real algebraic number is one. */
bool isOne(const RealAlgebraicNumber& ran);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__REAL_ALGEBRAIC_NUMBER_H */
#include <ostream>
-namespace CVC4 {
+namespace CVC5 {
RegExpRepeat::RegExpRepeat(uint32_t repeatAmount) : d_repeatAmount(repeatAmount)
{
return os << "[" << r.d_loopMinOcc << ".." << r.d_loopMaxOcc << "]";
}
-} // namespace CVC4
+} // namespace CVC5
#include <iosfwd>
-namespace CVC4 {
+namespace CVC5 {
struct RegExpRepeat
{
std::ostream& operator<<(std::ostream& os, const RegExpLoop& bv);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__UTIL__REGEXP_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
bool WallClockTimer::on() const
{
return d_listeners.push_back(listener);
}
-} /* namespace CVC4 */
+} // namespace CVC5
#include <memory>
#include <vector>
-namespace CVC4 {
+namespace CVC5 {
class Listener;
class Options;
}; /* class ResourceManager */
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__RESOURCE_MANAGER_H */
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
Result::Result()
: d_sat(SAT_UNKNOWN),
};
}
-} /* CVC4 namespace */
+} // namespace CVC5
#include "options/language.h"
-namespace CVC4 {
+namespace CVC5 {
class Result;
bool operator!=(enum Result::Sat s, const Result& r);
bool operator!=(enum Result::Entailment e, const Result& r);
-} /* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__RESULT_H */
#include <fenv.h>
-namespace CVC4 {
+namespace CVC5 {
#define CVC4_NUM_ROUNDING_MODES 5
inline size_t operator()(const RoundingMode& rm) const { return size_t(rm); }
}; /* struct RoundingModeHashFunction */
-} // namespace CVC4
+} // namespace CVC5
#endif
/* Size of buffers used */
#define BUFFER_SIZE 20
-namespace CVC4 {
+namespace CVC5 {
template <>
void safe_print(int fd, const std::string& msg) {
}
}
-} /* CVC4 namespace */
+} // namespace CVC5
#include "cvc4_export.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* Prints arrays of chars (e.g. string literals) of length N. Safe to use in a
*/
void safe_print_right_aligned(int fd, uint64_t i, ssize_t width);
-} /* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__SAFE_PRINT_H */
#include "util/bitvector.h"
#include "util/random.h"
-namespace CVC4 {
+namespace CVC5 {
BitVector Sampler::pickBvUniform(unsigned sz)
{
return FloatingPoint(e, s, bv);
}
-} // namespace CVC4
+} // namespace CVC5
#include "util/floatingpoint.h"
-namespace CVC4 {
+namespace CVC5 {
class Sampler
{
static constexpr double probSpecial = 0.2;
};
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__UTIL_FLOATINGPOINT_SAMPLER_H */
#include "util/ostream_util.h"
#include "util/smt2_quote_string.h"
-namespace CVC4 {
+namespace CVC5 {
const int PrettySExprs::s_iosIndex = std::ios_base::xalloc();
Assert((d_children == NULL) == isAtom());
}
-SExpr::SExpr(const CVC4::Integer& value)
+SExpr::SExpr(const CVC5::Integer& value)
: d_sexprType(SEXPR_INTEGER),
d_integerValue(value),
d_rationalValue(0),
d_stringValue(""),
- d_children(NULL) {}
+ d_children(NULL)
+{
+}
SExpr::SExpr(int value)
: d_sexprType(SEXPR_INTEGER),
d_stringValue(""),
d_children(NULL) {}
-SExpr::SExpr(const CVC4::Rational& value)
+SExpr::SExpr(const CVC5::Rational& value)
: d_sexprType(SEXPR_RATIONAL),
d_integerValue(0),
d_rationalValue(value),
d_stringValue(""),
- d_children(NULL) {}
+ d_children(NULL)
+{
+}
SExpr::SExpr(const std::string& value)
: d_sexprType(SEXPR_STRING),
return std::string();
}
-const CVC4::Integer& SExpr::getIntegerValue() const {
+const CVC5::Integer& SExpr::getIntegerValue() const
+{
PrettyCheckArgument(isInteger(), this);
return d_integerValue;
}
-const CVC4::Rational& SExpr::getRationalValue() const {
+const CVC5::Rational& SExpr::getRationalValue() const
+{
PrettyCheckArgument(isRational(), this);
return d_rationalValue;
}
return SExpr(parsedListsOfAtoms);
}
-} /* CVC4 namespace */
+} // namespace CVC5
#include "util/integer.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
class SExprKeyword
{
SExpr& operator=(const SExpr& other);
~SExpr();
- SExpr(const CVC4::Integer& value);
+ SExpr(const CVC5::Integer& value);
SExpr(int value);
SExpr(long int value);
SExpr(unsigned int value);
SExpr(unsigned long int value);
- SExpr(const CVC4::Rational& value);
+ SExpr(const CVC5::Rational& value);
SExpr(const std::string& value);
* Get the integer value of this S-expression. This will cause an
* error if this S-expression is not an integer.
*/
- const CVC4::Integer& getIntegerValue() const;
+ const CVC5::Integer& getIntegerValue() const;
/**
* Get the rational value of this S-expression. This will cause an
* error if this S-expression is not a rational.
*/
- const CVC4::Rational& getRationalValue() const;
+ const CVC5::Rational& getRationalValue() const;
/**
* Get the children of this S-expression. This will cause an error
} d_sexprType;
/** The value of an atomic integer-valued S-expression. */
- CVC4::Integer d_integerValue;
+ CVC5::Integer d_integerValue;
/** The value of an atomic rational-valued S-expression. */
- CVC4::Rational d_rationalValue;
+ CVC5::Rational d_rationalValue;
/** The value of an atomic S-expression. */
std::string d_stringValue;
*/
std::ostream& operator<<(std::ostream& out, PrettySExprs ps);
-} /* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__SEXPR_H */
#include <sstream>
#include <string>
-namespace CVC4 {
+namespace CVC5 {
/**
* SMT-LIB 2 quoting for symbols
return s;
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include <string>
-namespace CVC4 {
+namespace CVC5 {
/**
* SMT-LIB 2 quoting for symbols
*/
std::string quoteSymbol(const std::string& s);
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__UTIL__SMT2_QUOTE_STRING_H */
#include "util/safe_print.h"
#include "util/statistics_registry.h" // for details about class Stat
-
-namespace CVC4 {
+namespace CVC5 {
bool StatisticsBase::StatCmp::operator()(const Stat* s1, const Stat* s2) const {
return s1->getName() < s2->getName();
}
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "cvc4_export.h"
#include "util/sexpr.h"
-namespace CVC4 {
+namespace CVC5 {
class Stat;
}; /* class Statistics */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__STATISTICS_H */
/****************************************************************************/
/* Some utility functions for timespec */
/****************************************************************************/
-namespace CVC4 {
+namespace CVC5 {
void StatisticsRegistry::registerStat(Stat* s)
{
d_reg->unregisterStat(d_stat);
}
-}/* CVC4 namespace */
+} // namespace CVC5
#include "util/statistics.h"
#include "util/stats_base.h"
-namespace CVC4 {
+namespace CVC5 {
/** A statistic that contains a SExpr. */
class SExprStat : public Stat {
}; /* class RegisterStatistic */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__STATISTICS_REGISTRY_H */
#include "util/statistics_registry.h"
-namespace CVC4 {
+namespace CVC5 {
Stat::Stat(const std::string& name) : d_name(name)
{
return SExpr(Rational::fromDecimal(ss.str()));
}
-} // namespace CVC4
+} // namespace CVC5
#define CVC4_USE_STATISTICS false
#endif
-namespace CVC4 {
+namespace CVC5 {
/**
* The base class for all statistics.
const T& d_sized;
}; /* class SizeStat */
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "util/stats_base.h"
-namespace CVC4 {
+namespace CVC5 {
/**
* A histogram statistic class for integral types.
int64_t d_offset;
}; /* class IntegralHistogramStat */
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "base/check.h"
#include "util/ostream_util.h"
-namespace CVC4 {
+namespace CVC5 {
template <>
void safe_print(int fd, const timer_stat_detail::duration& t)
}
}
-} // namespace CVC4
+} // namespace CVC5
#include "cvc4_export.h"
#include "util/stats_base.h"
-namespace CVC4 {
+namespace CVC5 {
namespace timer_stat_detail {
using clock = std::chrono::steady_clock;
using time_point = clock::time_point;
class CVC4_EXPORT TimerStat : public BackedStat<timer_stat_detail::duration>
{
public:
- typedef CVC4::CodeTimer CodeTimer;
+ typedef CVC5::CodeTimer CodeTimer;
/**
* Construct a timer statistic with the given name. Newly-constructed
CodeTimer& operator=(const CodeTimer& timer) = delete;
}; /* class CodeTimer */
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "util/ostream_util.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
std::ostream& operator<<(std::ostream& os,
const timer_stat_detail::duration& dur)
<< (dur % std::chrono::seconds(1)).count();
}
-} // namespace CVC4
+} // namespace CVC5
#include "cvc4_export.h"
-namespace CVC4 {
+namespace CVC5 {
namespace timer_stat_detail {
struct duration;
std::ostream& operator<<(std::ostream& os,
const timer_stat_detail::duration& dur) CVC4_EXPORT;
-} // namespace CVC4
+} // namespace CVC5
#endif
using namespace std;
-namespace CVC4 {
+namespace CVC5 {
static_assert(UCHAR_MAX == 255, "Unsigned char is assumed to have 256 values.");
std::stringstream serr;
serr << "Illegal string character: \"" << ch
<< "\", must use escape sequence";
- throw CVC4::Exception(serr.str());
+ throw CVC5::Exception(serr.str());
}
else
{
return os << "\"" << s.toString() << "\"";
}
-} // namespace CVC4
+} // namespace CVC5
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
/** The CVC4 string class
*
static inline unsigned num_codes() { return 196608; }
/** constructors for String
*
- * Internally, a CVC4::String is represented by a vector of unsigned
+ * Internally, a CVC5::String is represented by a vector of unsigned
* integers (d_str) representing the code points of the characters.
*
* To build a string from a C++ string, we may process escape sequences
* where d_0 ... d_4 are hexadecimal digits, to the appropriate character.
*
* If useEscSequences is false, then the characters of the constructed
- * CVC4::String correspond one-to-one with the input string.
+ * CVC5::String correspond one-to-one with the input string.
*/
String() = default;
explicit String(const std::string& s, bool useEscSequences = false)
* If useEscSequences is false, the string's printable characters are
* printed as characters. Notice that for all std::string s having only
* printable characters, we have that
- * CVC4::String( s ).toString() = s.
+ * CVC5::String( s ).toString() = s.
*/
std::string toString(bool useEscSequences = false) const;
/* toWString
struct StringHashFunction
{
- size_t operator()(const ::CVC4::String& s) const {
+ size_t operator()(const ::CVC5::String& s) const
+ {
return std::hash<std::string>()(s.toString());
}
}; /* struct StringHashFunction */
std::ostream& operator<<(std::ostream& os, const String& s);
-} // namespace CVC4
+} // namespace CVC5
#endif /* CVC4__UTIL__STRING_H */
#include <vector>
#include <utility>
-namespace CVC4 {
+namespace CVC5 {
class TupleUpdate
{
return out << "[" << t.getIndex() << "]";
}
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__TUPLE_H */
#include "base/exception.h"
#include "cvc4_export.h"
-namespace CVC4 {
+namespace CVC5 {
-class CVC4_EXPORT UnsafeInterruptException : public CVC4::Exception
+class CVC4_EXPORT UnsafeInterruptException : public CVC5::Exception
{
public:
UnsafeInterruptException() :
}
}; /* class UnsafeInterruptException */
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__UNSAFE_INTERRUPT_EXCEPTION_H */
#include "base/check.h"
-namespace CVC4 {
+namespace CVC5 {
std::unique_ptr<std::fstream> openTmpFile(std::string* pattern)
{
return tmpStream;
}
-} // namespace CVC4
+} // namespace CVC5
#include <memory>
#include <string>
-namespace CVC4 {
-
+namespace CVC5 {
/**
* Using std::find_if(), finds the first iterator in [first,last)
*/
std::unique_ptr<std::fstream> openTmpFile(std::string* pattern);
-}/* CVC4 namespace */
+} // namespace CVC5
#endif /* CVC4__UTILITY_H */
#include "api/cvc4cpp.h"
-using namespace CVC4::api;
+using namespace CVC5::api;
using namespace std;
int main() {
#include "api/cvc4cpp.h"
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include "api/cvc4cpp.h"
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include "parser/parser_builder.h"
#include "smt/command.h"
-using namespace CVC4;
-using namespace CVC4::parser;
-using namespace CVC4::language;
+using namespace CVC5;
+using namespace CVC5::parser;
+using namespace CVC5::language;
int runTest();
#include "api/cvc4cpp.h"
-using namespace CVC4::api;
+using namespace CVC5::api;
int main()
{
#include "api/cvc4cpp.h"
-using namespace CVC4::api;
+using namespace CVC5::api;
using namespace std;
/**
#include "smt/command.h"
#include "smt/smt_engine.h"
-using namespace CVC4;
-using namespace CVC4::parser;
+using namespace CVC5;
+using namespace CVC5::parser;
using namespace std;
void testGetInfo(api::Solver* solver, const char* s);
#include "api/cvc4cpp.h"
-using namespace CVC4::api;
+using namespace CVC5::api;
using namespace std;
int main() {
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace api;
ASSERT_THROW(nilc.getSpecializedConstructorTerm(isort), CVC4ApiException);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace api;
ASSERT_THROW(g1.addAnyVariable(start), CVC4ApiException);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace api;
ASSERT_EQ(bitvector_repeat_ot.toString(), op_repr);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace api;
ASSERT_EQ(plus, d_solver.mkOp(PLUS));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace api;
TEST_F(TestApiBlackResult, isNull)
{
- CVC4::api::Result res_null;
+ CVC5::api::Result res_null;
ASSERT_TRUE(res_null.isNull());
ASSERT_FALSE(res_null.isSat());
ASSERT_FALSE(res_null.isUnsat());
Sort u_sort = d_solver.mkUninterpretedSort("u");
Term x = d_solver.mkVar(u_sort, "x");
d_solver.assertFormula(x.eqTerm(x));
- CVC4::api::Result res = d_solver.checkSat();
+ CVC5::api::Result res = d_solver.checkSat();
ASSERT_FALSE(res.isNull());
}
Sort u_sort = d_solver.mkUninterpretedSort("u");
Term x = d_solver.mkVar(u_sort, "x");
d_solver.assertFormula(x.eqTerm(x));
- CVC4::api::Result res;
- CVC4::api::Result res2 = d_solver.checkSat();
- CVC4::api::Result res3 = d_solver.checkSat();
+ CVC5::api::Result res;
+ CVC5::api::Result res2 = d_solver.checkSat();
+ CVC5::api::Result res3 = d_solver.checkSat();
res = res2;
ASSERT_EQ(res, res2);
ASSERT_EQ(res3, res2);
Sort u_sort = d_solver.mkUninterpretedSort("u");
Term x = d_solver.mkVar(u_sort, "x");
d_solver.assertFormula(x.eqTerm(x));
- CVC4::api::Result res = d_solver.checkSat();
+ CVC5::api::Result res = d_solver.checkSat();
ASSERT_TRUE(res.isSat());
ASSERT_FALSE(res.isSatUnknown());
}
Sort u_sort = d_solver.mkUninterpretedSort("u");
Term x = d_solver.mkVar(u_sort, "x");
d_solver.assertFormula(x.eqTerm(x).notTerm());
- CVC4::api::Result res = d_solver.checkSat();
+ CVC5::api::Result res = d_solver.checkSat();
ASSERT_TRUE(res.isUnsat());
ASSERT_FALSE(res.isSatUnknown());
}
Sort int_sort = d_solver.getIntegerSort();
Term x = d_solver.mkVar(int_sort, "x");
d_solver.assertFormula(x.eqTerm(x).notTerm());
- CVC4::api::Result res = d_solver.checkSat();
+ CVC5::api::Result res = d_solver.checkSat();
ASSERT_FALSE(res.isSat());
ASSERT_TRUE(res.isSatUnknown());
}
Term a = x.eqTerm(y).notTerm();
Term b = x.eqTerm(y);
d_solver.assertFormula(a);
- CVC4::api::Result entailed = d_solver.checkEntailed(a);
+ CVC5::api::Result entailed = d_solver.checkEntailed(a);
ASSERT_TRUE(entailed.isEntailed());
ASSERT_FALSE(entailed.isEntailmentUnknown());
- CVC4::api::Result not_entailed = d_solver.checkEntailed(b);
+ CVC5::api::Result not_entailed = d_solver.checkEntailed(b);
ASSERT_TRUE(not_entailed.isNotEntailed());
ASSERT_FALSE(not_entailed.isEntailmentUnknown());
}
Sort int_sort = d_solver.getIntegerSort();
Term x = d_solver.mkVar(int_sort, "x");
d_solver.assertFormula(x.eqTerm(x).notTerm());
- CVC4::api::Result res = d_solver.checkEntailed(x.eqTerm(x));
+ CVC5::api::Result res = d_solver.checkEntailed(x.eqTerm(x));
ASSERT_FALSE(res.isEntailed());
ASSERT_TRUE(res.isEntailmentUnknown());
ASSERT_EQ(res.getUnknownExplanation(), api::Result::UNKNOWN_REASON);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace api;
{
d_solver.assertFormula(t);
}
- CVC4::api::Result res = d_solver.checkSat();
+ CVC5::api::Result res = d_solver.checkSat();
ASSERT_TRUE(res.isUnsat());
}
solver->declareSeparationHeap(integer, integer);
Term x = solver->mkConst(integer, "x");
Term p = solver->mkConst(integer, "p");
- Term heap = solver->mkTerm(CVC4::api::Kind::SEP_PTO, p, x);
+ Term heap = solver->mkTerm(CVC5::api::Kind::SEP_PTO, p, x);
solver->assertFormula(heap);
Term nil = solver->mkSepNil(integer);
solver->assertFormula(nil.eqTerm(solver->mkReal(5)));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "base/configuration.h"
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace api;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace api;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace api;
ASSERT_EQ(x.toString(), "x");
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace api;
ASSERT_EQ(tailTerm.getOp(), Op(&d_solver, APPLY_SELECTOR));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "context/context.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
using context::CDHashMap;
using context::CDInsertHashMap;
TEST_F(TestBaseBlackMap, map)
{
std::map<std::string, std::string> map = default_map();
- ASSERT_TRUE(CVC4::ContainsKey(map, "key"));
- ASSERT_FALSE(CVC4::ContainsKey(map, "non key"));
+ ASSERT_TRUE(CVC5::ContainsKey(map, "key"));
+ ASSERT_FALSE(CVC5::ContainsKey(map, "non key"));
ASSERT_EQ(FindOrNull(map, "non key"), nullptr);
if (std::string* found_value = FindOrNull(map, "other"))
TEST_F(TestBaseBlackMap, constant_map)
{
const std::map<std::string, std::string> map = default_map();
- ASSERT_TRUE(CVC4::ContainsKey(map, "key"));
- ASSERT_FALSE(CVC4::ContainsKey(map, "non key"));
+ ASSERT_TRUE(CVC5::ContainsKey(map, "key"));
+ ASSERT_FALSE(CVC5::ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
{
std::unordered_map<std::string, std::string> map(default_map().begin(),
default_map().end());
- ASSERT_TRUE(CVC4::ContainsKey(map, "key"));
- ASSERT_FALSE(CVC4::ContainsKey(map, "non key"));
+ ASSERT_TRUE(CVC5::ContainsKey(map, "key"));
+ ASSERT_FALSE(CVC5::ContainsKey(map, "non key"));
ASSERT_EQ(FindOrNull(map, "non key"), nullptr);
if (std::string* found_value = FindOrNull(map, "other"))
{
const std::unordered_map<std::string, std::string> map(default_map().begin(),
default_map().end());
- ASSERT_TRUE(CVC4::ContainsKey(map, "key"));
- ASSERT_FALSE(CVC4::ContainsKey(map, "non key"));
+ ASSERT_TRUE(CVC5::ContainsKey(map, "key"));
+ ASSERT_FALSE(CVC5::ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
TEST_F(TestBaseBlackMap, set)
{
std::set<std::string> set{"entry", "other"};
- ASSERT_TRUE(CVC4::ContainsKey(set, "entry"));
- ASSERT_FALSE(CVC4::ContainsKey(set, "non member"));
+ ASSERT_TRUE(CVC5::ContainsKey(set, "entry"));
+ ASSERT_FALSE(CVC5::ContainsKey(set, "non member"));
const std::set<std::string> const_set{"entry", "other"};
- ASSERT_TRUE(CVC4::ContainsKey(const_set, "entry"));
- ASSERT_FALSE(CVC4::ContainsKey(const_set, "non member"));
+ ASSERT_TRUE(CVC5::ContainsKey(const_set, "entry"));
+ ASSERT_FALSE(CVC5::ContainsKey(const_set, "non member"));
}
TEST_F(TestBaseBlackMap, unordered_set)
{
std::unordered_set<std::string> set{"entry", "other"};
- ASSERT_TRUE(CVC4::ContainsKey(set, "entry"));
- ASSERT_FALSE(CVC4::ContainsKey(set, "non member"));
+ ASSERT_TRUE(CVC5::ContainsKey(set, "entry"));
+ ASSERT_FALSE(CVC5::ContainsKey(set, "non member"));
const std::unordered_set<std::string> const_set{"entry", "other"};
- ASSERT_TRUE(CVC4::ContainsKey(const_set, "entry"));
- ASSERT_FALSE(CVC4::ContainsKey(const_set, "non member"));
+ ASSERT_TRUE(CVC5::ContainsKey(const_set, "entry"));
+ ASSERT_FALSE(CVC5::ContainsKey(const_set, "non member"));
}
TEST_F(TestBaseBlackMap, CDHashMap)
CDHashMap<std::string, std::string> map(&context);
insert_all(default_map(), &map);
- ASSERT_TRUE(CVC4::ContainsKey(map, "key"));
- ASSERT_FALSE(CVC4::ContainsKey(map, "non key"));
+ ASSERT_TRUE(CVC5::ContainsKey(map, "key"));
+ ASSERT_FALSE(CVC5::ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
insert_all(default_map(), &store);
const auto& map = store;
- ASSERT_TRUE(CVC4::ContainsKey(map, "key"));
- ASSERT_FALSE(CVC4::ContainsKey(map, "non key"));
+ ASSERT_TRUE(CVC5::ContainsKey(map, "key"));
+ ASSERT_FALSE(CVC5::ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
CDInsertHashMap<std::string, std::string> map(&context);
insert_all(default_map(), &map);
- ASSERT_TRUE(CVC4::ContainsKey(map, "key"));
- ASSERT_FALSE(CVC4::ContainsKey(map, "non key"));
+ ASSERT_TRUE(CVC5::ContainsKey(map, "key"));
+ ASSERT_FALSE(CVC5::ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
insert_all(default_map(), &store);
const auto& map = store;
- ASSERT_TRUE(CVC4::ContainsKey(map, "key"));
- ASSERT_FALSE(CVC4::ContainsKey(map, "non key"));
+ ASSERT_TRUE(CVC5::ContainsKey(map, "key"));
+ ASSERT_FALSE(CVC5::ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
ASSERT_EQ(*found_value, "entry");
ASSERT_EQ(FindOrDie(map, "other"), "entry");
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::context::CDMap<>.
+ ** \brief Black box testing of CVC5::context::CDMap<>.
**
- ** Black box testing of CVC4::context::CDMap<>.
+ ** Black box testing of CVC5::context::CDMap<>.
**/
#include <map>
#include "context/cdlist.h"
#include "test_context.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
-using CVC4::context::CDHashMap;
-using CVC4::context::Context;
+using CVC5::context::CDHashMap;
+using CVC5::context::Context;
class TestContextBlackCDHashMap : public TestContext
{
ASSERT_TRUE(elements_are(map, {{3, 4}, {23, 317}}));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief White box testing of CVC4::context::CDMap<>.
+ ** \brief White box testing of CVC5::context::CDMap<>.
**
- ** White box testing of CVC4::context::CDMap<>.
+ ** White box testing of CVC5::context::CDMap<>.
**/
#include "base/check.h"
#include "context/cdhashmap.h"
#include "test_context.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace context;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::context::CDList<>.
+ ** \brief Black box testing of CVC5::context::CDList<>.
**
- ** Black box testing of CVC4::context::CDList<>.
+ ** Black box testing of CVC5::context::CDList<>.
**/
#include <limits.h>
#include "memory.h"
#include "test_context.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace context;
list.push_back(42);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::context::CDO<>.
+ ** \brief Black box testing of CVC5::context::CDO<>.
**
- ** Black box testing of CVC4::context::CDO<>.
+ ** Black box testing of CVC5::context::CDO<>.
**/
#include <iostream>
#include "context/cdo.h"
#include "test_context.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace context;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::context::Context.
+ ** \brief Black box testing of CVC5::context::Context.
**
- ** Black box testing of CVC4::context::Context.
+ ** Black box testing of CVC5::context::Context.
**/
#include <iostream>
#include "context/cdo.h"
#include "test_context.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace context;
#endif
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::context::ContextMemoryManager.
+ ** \brief Black box testing of CVC5::context::ContextMemoryManager.
**
- ** Black box testing of CVC4::context::ContextMemoryManager.
+ ** Black box testing of CVC5::context::ContextMemoryManager.
**/
#include <cstring>
#include "context/context_mm.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace context;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief White box testing of CVC4::context::Context.
+ ** \brief White box testing of CVC5::context::Context.
**
- ** White box testing of CVC4::context::Context.
+ ** White box testing of CVC5::context::Context.
**/
#include "base/check.h"
#include "context/cdo.h"
#include "test_context.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace context;
ASSERT_EQ(c.d_ppContextObjPrev, &s->d_pContextObjList);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::InteractiveShell.
+ ** \brief Black box testing of CVC5::InteractiveShell.
**
- ** Black box testing of CVC4::InteractiveShell.
+ ** Black box testing of CVC5::InteractiveShell.
**/
#include <sstream>
#include "smt/command.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestMainBlackInteractiveShell : public TestInternal
d_options.set(options::in, d_sin.get());
d_options.set(options::out, d_sout.get());
d_options.set(options::inputLanguage, language::input::LANG_CVC4);
- d_solver.reset(new CVC4::api::Solver(&d_options));
+ d_solver.reset(new CVC5::api::Solver(&d_options));
d_symman.reset(new SymbolManager(d_solver.get()));
}
std::unique_ptr<std::stringstream> d_sin;
std::unique_ptr<std::stringstream> d_sout;
std::unique_ptr<SymbolManager> d_symman;
- std::unique_ptr<CVC4::api::Solver> d_solver;
+ std::unique_ptr<CVC5::api::Solver> d_solver;
Options d_options;
};
countCommands(shell, 0, 3);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
**
** Use it like this (for example):
**
- ** CVC4::test::WithLimitedMemory wlm(amount);
+ ** CVC5::test::WithLimitedMemory wlm(amount);
** TS_ASSERT_THROWS( foo(), bad_alloc );
**
** The WithLimitedMemory destructor will re-establish the previous limit.
# endif
#endif
-namespace CVC4 {
+namespace CVC5 {
namespace test {
#ifndef CVC4_MEMORY_LIMITING_DISABLED
}; /* class WithLimitedMemory */
#endif
-} /* CVC4::test namespace */
-} /* CVC4 namespace */
-
+} // namespace test
+} // namespace CVC5
// Remove CVC4_MEMORY_LIMITING_DISABLED_REASON if it is defined.
#ifdef CVC4_MEMORY_LIMITING_DISABLED_REASON
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::Attribute.
+ ** \brief Black box testing of CVC5::Attribute.
**
- ** Black box testing of CVC4::Attribute.
+ ** Black box testing of CVC5::Attribute.
**/
#include <sstream>
#include "expr/node_value.h"
#include "test_node.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace smt;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_engine.h"
#include "theory/uf/theory_uf.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace smt;
ASSERT_FALSE(unnamed.hasAttribute(VarNameAttr()));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::Kind.
+ ** \brief Black box testing of CVC5::Kind.
**
- ** Black box testing of CVC4::Kind.
+ ** Black box testing of CVC5::Kind.
**/
#include <iostream>
#include "expr/kind.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
ASSERT_EQ(act.str(), exp.str());
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::KindMap
+ ** \brief Black box testing of CVC5::KindMap
**
- ** Black box testing of CVC4::KindMap.
+ ** Black box testing of CVC5::KindMap.
**/
#include <iostream>
#include "expr/kind_map.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "util/integer.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace expr;
using namespace kind;
ASSERT_EQ(subs[x], a);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::Node.
+ ** \brief Black box testing of CVC5::Node.
**
- ** Black box testing of CVC4::Node.
+ ** Black box testing of CVC5::Node.
**/
#include <algorithm>
#include "test_node.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::NodeBuilder.
+ ** \brief Black box testing of CVC5::NodeBuilder.
**
- ** Black box testing of CVC4::NodeBuilder.
+ ** Black box testing of CVC5::NodeBuilder.
**/
#include <limits.h>
#define K 30u
#define LARGE_K UINT_MAX / 40
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
ASSERT_EQ(nexpected, n);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::NodeManager.
+ ** \brief Black box testing of CVC5::NodeManager.
**
- ** Black box testing of CVC4::NodeManager.
+ ** Black box testing of CVC5::NodeManager.
**/
#include <string>
#include "util/integer.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace expr;
#endif
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief White box testing of CVC4::NodeManager.
+ ** \brief White box testing of CVC5::NodeManager.
**
- ** White box testing of CVC4::NodeManager.
+ ** White box testing of CVC5::NodeManager.
**/
#include <string>
#include "util/integer.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
-using namespace CVC4::expr;
+using namespace CVC5::expr;
namespace test {
}
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::expr::NodeSelfIterator
+ ** \brief Black box testing of CVC5::expr::NodeSelfIterator
**
- ** Black box testing of CVC4::expr::NodeSelfIterator
+ ** Black box testing of CVC5::expr::NodeSelfIterator
**/
#include "expr/node.h"
#include "expr/node_self_iterator.h"
#include "test_node.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace expr;
ASSERT_EQ(++i, x_and_y.end());
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "expr/node_value.h"
#include "test_node.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
ASSERT_EQ(actual, expected);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief White box testing of CVC4::Node.
+ ** \brief White box testing of CVC5::Node.
**
- ** White box testing of CVC4::Node.
+ ** White box testing of CVC5::Node.
**/
#include <string>
#include "base/check.h"
#include "test_node.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace expr;
ASSERT_EQ(v[2], y);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::SymbolTable
+ ** \brief Black box testing of CVC5::SymbolTable
**
- ** Black box testing of CVC4::SymbolTable.
+ ** Black box testing of CVC5::SymbolTable.
**/
#include <sstream>
#include "expr/symbol_table.h"
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace context;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "test_node.h"
#include "util/cardinality.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "smt/smt_engine.h"
#include "test_node.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace context;
ASSERT_TRUE(bvType.getBaseType() == bvType);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::parser::Parser for CVC and SMT-LIBv2
+ ** \brief Black box testing of CVC5::parser::Parser for CVC and SMT-LIBv2
** inputs.
**
- ** Black box testing of CVC4::parser::Parser for CVC and SMT-LIbv2 inputs.
+ ** Black box testing of CVC5::parser::Parser for CVC and SMT-LIbv2 inputs.
**/
#include <sstream>
#include "smt/command.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace parser;
using namespace language::input;
TestInternal::SetUp();
d_options.set(options::parseOnly, true);
d_symman.reset(nullptr);
- d_solver.reset(new CVC4::api::Solver(&d_options));
+ d_solver.reset(new CVC5::api::Solver(&d_options));
}
void TearDown() override
Options d_options;
InputLanguage d_lang;
- std::unique_ptr<CVC4::api::Solver> d_solver;
+ std::unique_ptr<CVC5::api::Solver> d_solver;
std::unique_ptr<SymbolManager> d_symman;
};
#endif
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::parser::ParserBuilder.
+ ** \brief Black box testing of CVC5::parser::ParserBuilder.
**
- ** Black box testing of CVC4::parser::ParserBuilder.
+ ** Black box testing of CVC5::parser::ParserBuilder.
**/
#include <stdio.h>
#include "parser/parser_builder.h"
#include "test_api.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace parser;
using namespace language::input;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/rewriter.h"
#include "util/bitvector.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace preprocessing;
using namespace preprocessing::passes;
ASSERT_EQ(BVGauss::getMinBwExpr(Rewriter::rewrite(plus7)), 17);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "smt/smt_engine.h"
#include "test_smt.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace preprocessing::passes;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "smt/smt_engine.h"
#include "test_smt.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
checkToString(n, "((_ re.loop 1 3) (str.to_re \"x\"))");
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief White box testing of CVC4::prop::CnfStream.
+ ** \brief White box testing of CVC5::prop::CnfStream.
**
- ** White box testing of CVC4::prop::CnfStream.
+ ** White box testing of CVC5::prop::CnfStream.
**/
#include "base/check.h"
#include "theory/theory.h"
#include "theory/theory_engine.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace context;
using namespace prop;
d_cnfContext.reset(new context::Context());
d_cnfRegistrar.reset(new prop::NullRegistrar);
d_cnfStream.reset(
- new CVC4::prop::CnfStream(d_satSolver.get(),
+ new CVC5::prop::CnfStream(d_satSolver.get(),
d_cnfRegistrar.get(),
d_cnfContext.get(),
&d_smtEngine->getOutputManager(),
ASSERT_TRUE(d_cnfStream->hasLiteral(a_and_b));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "gtest/gtest.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestInternal : public ::testing::Test
};
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "api/cvc4cpp.h"
#include "gtest/gtest.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestApi : public ::testing::Test
{
protected:
- CVC4::api::Solver d_solver;
+ CVC5::api::Solver d_solver;
};
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "context/context.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestContext : public TestInternal
{
protected:
- void SetUp() override { d_context.reset(new CVC4::context::Context()); }
- std::unique_ptr<CVC4::context::Context> d_context;
+ void SetUp() override { d_context.reset(new CVC5::context::Context()); }
+ std::unique_ptr<CVC5::context::Context> d_context;
};
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "smt/smt_engine_scope.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestNode : public TestInternal
};
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "util/resource_manager.h"
#include "util/unsafe_interrupt_exception.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
/* -------------------------------------------------------------------------- */
}
}
-class DummyOutputChannel : public CVC4::theory::OutputChannel
+class DummyOutputChannel : public CVC5::theory::OutputChannel
{
public:
DummyOutputChannel() {}
/* -------------------------------------------------------------------------- */
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#endif
#include "theory/rewriter.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
}
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Unit testing for CVC4::LogicInfo class
+ ** \brief Unit testing for CVC5::LogicInfo class
**
- ** Unit testing for CVC4::LogicInfo class.
+ ** Unit testing for CVC5::LogicInfo class.
**/
#include "base/configuration.h"
#include "test.h"
#include "theory/logic_info.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
LogicInfo info;
ASSERT_FALSE(info.isLocked());
- ASSERT_THROW(info.getLogicString(), CVC4::IllegalArgumentException);
+ ASSERT_THROW(info.getLogicString(), CVC5::IllegalArgumentException);
ASSERT_THROW(info.isTheoryEnabled(THEORY_BUILTIN),
- CVC4::IllegalArgumentException);
+ CVC5::IllegalArgumentException);
ASSERT_THROW(info.isTheoryEnabled(THEORY_BOOL),
- CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isTheoryEnabled(THEORY_UF), CVC4::IllegalArgumentException);
+ CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isTheoryEnabled(THEORY_UF), CVC5::IllegalArgumentException);
ASSERT_THROW(info.isTheoryEnabled(THEORY_ARITH),
- CVC4::IllegalArgumentException);
+ CVC5::IllegalArgumentException);
ASSERT_THROW(info.isTheoryEnabled(THEORY_ARRAYS),
- CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isTheoryEnabled(THEORY_BV), CVC4::IllegalArgumentException);
+ CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isTheoryEnabled(THEORY_BV), CVC5::IllegalArgumentException);
ASSERT_THROW(info.isTheoryEnabled(THEORY_DATATYPES),
- CVC4::IllegalArgumentException);
+ CVC5::IllegalArgumentException);
ASSERT_THROW(info.isTheoryEnabled(THEORY_QUANTIFIERS),
- CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isPure(THEORY_BUILTIN), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isPure(THEORY_BOOL), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isPure(THEORY_UF), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isPure(THEORY_ARITH), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isPure(THEORY_ARRAYS), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isPure(THEORY_BV), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isPure(THEORY_DATATYPES), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isPure(THEORY_QUANTIFIERS), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isQuantified(), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.areIntegersUsed(), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.areRealsUsed(), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.isLinear(), CVC4::IllegalArgumentException);
+ CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_BUILTIN), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_BOOL), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_UF), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_ARITH), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_ARRAYS), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_BV), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_DATATYPES), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_QUANTIFIERS), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isQuantified(), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.areIntegersUsed(), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.areRealsUsed(), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.isLinear(), CVC5::IllegalArgumentException);
info.lock();
ASSERT_TRUE(info.isLocked());
ASSERT_TRUE(info.areTranscendentalsUsed());
ASSERT_FALSE(info.isLinear());
- ASSERT_THROW(info.arithOnlyLinear(), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.disableIntegers(), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.disableQuantifiers(), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.disableTheory(THEORY_BV), CVC4::IllegalArgumentException);
+ ASSERT_THROW(info.arithOnlyLinear(), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.disableIntegers(), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.disableQuantifiers(), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.disableTheory(THEORY_BV), CVC5::IllegalArgumentException);
ASSERT_THROW(info.disableTheory(THEORY_DATATYPES),
- CVC4::IllegalArgumentException);
- ASSERT_THROW(info.enableIntegers(), CVC4::IllegalArgumentException);
- ASSERT_THROW(info.disableReals(), CVC4::IllegalArgumentException);
+ CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.enableIntegers(), CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.disableReals(), CVC5::IllegalArgumentException);
ASSERT_THROW(info.disableTheory(THEORY_ARITH),
- CVC4::IllegalArgumentException);
- ASSERT_THROW(info.disableTheory(THEORY_UF), CVC4::IllegalArgumentException);
+ CVC5::IllegalArgumentException);
+ ASSERT_THROW(info.disableTheory(THEORY_UF), CVC5::IllegalArgumentException);
info = info.getUnlockedCopy();
ASSERT_FALSE(info.isLocked());
info.disableTheory(THEORY_STRINGS);
info.arithOnlyLinear();
info.disableIntegers();
info.lock();
- if (CVC4::Configuration::isBuiltWithSymFPU())
+ if (CVC5::Configuration::isBuiltWithSymFPU())
{
ASSERT_EQ(info.getLogicString(), "SEP_AUFBVFPDTLRA");
}
info.disableQuantifiers();
info.disableTheory(THEORY_BAGS);
info.lock();
- if (CVC4::Configuration::isBuiltWithSymFPU())
+ if (CVC5::Configuration::isBuiltWithSymFPU())
{
ASSERT_EQ(info.getLogicString(), "QF_SEP_AUFBVFPDTLRA");
}
info.enableIntegers();
info.disableReals();
info.lock();
- if (CVC4::Configuration::isBuiltWithSymFPU())
+ if (CVC5::Configuration::isBuiltWithSymFPU())
{
ASSERT_EQ(info.getLogicString(), "QF_SEP_AUFFPLIA");
}
gt(ufHo, "QF_UF");
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/strings/regexp_operation.h"
#include "theory/strings/skolem_cache.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace theory;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/strings/strings_entail.h"
#include "theory/strings/strings_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace theory::quantifiers;
TypeNode intType = d_nodeManager->integerType();
TypeNode strType = d_nodeManager->stringType();
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
- Node abcd = d_nodeManager->mkConst(::CVC4::String("ABCD"));
- Node aaad = d_nodeManager->mkConst(::CVC4::String("AAAD"));
- Node b = d_nodeManager->mkConst(::CVC4::String("B"));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
+ Node abcd = d_nodeManager->mkConst(::CVC5::String("ABCD"));
+ Node aaad = d_nodeManager->mkConst(::CVC5::String("AAAD"));
+ Node b = d_nodeManager->mkConst(::CVC5::String("B"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node negOne = d_nodeManager->mkConst(Rational(-1));
Node zero = d_nodeManager->mkConst(Rational(0));
Node one = d_nodeManager->mkConst(Rational(1));
- Node empty = d_nodeManager->mkConst(::CVC4::String(""));
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
+ Node empty = d_nodeManager->mkConst(::CVC5::String(""));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
Node slen_y = d_nodeManager->mkNode(kind::STRING_LENGTH, y);
Node x_plus_slen_y = d_nodeManager->mkNode(kind::PLUS, x, slen_y);
TypeNode intType = d_nodeManager->integerType();
TypeNode strType = d_nodeManager->stringType();
- Node empty = d_nodeManager->mkConst(::CVC4::String(""));
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
- Node b = d_nodeManager->mkConst(::CVC4::String("B"));
- Node abcd = d_nodeManager->mkConst(::CVC4::String("ABCD"));
+ Node empty = d_nodeManager->mkConst(::CVC5::String(""));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
+ Node b = d_nodeManager->mkConst(::CVC5::String("B"));
+ Node abcd = d_nodeManager->mkConst(::CVC5::String("ABCD"));
Node negone = d_nodeManager->mkConst(Rational(-1));
Node zero = d_nodeManager->mkConst(Rational(0));
Node one = d_nodeManager->mkConst(Rational(1));
TypeNode intType = d_nodeManager->integerType();
TypeNode strType = d_nodeManager->stringType();
- Node empty = d_nodeManager->mkConst(::CVC4::String(""));
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
+ Node empty = d_nodeManager->mkConst(::CVC5::String(""));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
Node zero = d_nodeManager->mkConst(Rational(0));
Node three = d_nodeManager->mkConst(Rational(3));
TypeNode intType = d_nodeManager->integerType();
TypeNode strType = d_nodeManager->stringType();
- Node empty = d_nodeManager->mkConst(::CVC4::String(""));
- Node abcd = d_nodeManager->mkConst(::CVC4::String("ABCD"));
- Node f = d_nodeManager->mkConst(::CVC4::String("F"));
- Node gh = d_nodeManager->mkConst(::CVC4::String("GH"));
- Node ij = d_nodeManager->mkConst(::CVC4::String("IJ"));
+ Node empty = d_nodeManager->mkConst(::CVC5::String(""));
+ Node abcd = d_nodeManager->mkConst(::CVC5::String("ABCD"));
+ Node f = d_nodeManager->mkConst(::CVC5::String("F"));
+ Node gh = d_nodeManager->mkConst(::CVC5::String("GH"));
+ Node ij = d_nodeManager->mkConst(::CVC5::String("IJ"));
Node i = d_nodeManager->mkVar("i", intType);
Node s = d_nodeManager->mkVar("s", strType);
TypeNode intType = d_nodeManager->integerType();
TypeNode strType = d_nodeManager->stringType();
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
- Node abcd = d_nodeManager->mkConst(::CVC4::String("ABCD"));
- Node aaad = d_nodeManager->mkConst(::CVC4::String("AAAD"));
- Node b = d_nodeManager->mkConst(::CVC4::String("B"));
- Node c = d_nodeManager->mkConst(::CVC4::String("C"));
- Node ccc = d_nodeManager->mkConst(::CVC4::String("CCC"));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
+ Node abcd = d_nodeManager->mkConst(::CVC5::String("ABCD"));
+ Node aaad = d_nodeManager->mkConst(::CVC5::String("AAAD"));
+ Node b = d_nodeManager->mkConst(::CVC5::String("B"));
+ Node c = d_nodeManager->mkConst(::CVC5::String("C"));
+ Node ccc = d_nodeManager->mkConst(::CVC5::String("CCC"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node negOne = d_nodeManager->mkConst(Rational(-1));
TypeNode intType = d_nodeManager->integerType();
TypeNode strType = d_nodeManager->stringType();
- Node empty = d_nodeManager->mkConst(::CVC4::String(""));
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
- Node ab = d_nodeManager->mkConst(::CVC4::String("AB"));
- Node b = d_nodeManager->mkConst(::CVC4::String("B"));
- Node c = d_nodeManager->mkConst(::CVC4::String("C"));
- Node d = d_nodeManager->mkConst(::CVC4::String("D"));
+ Node empty = d_nodeManager->mkConst(::CVC5::String(""));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
+ Node ab = d_nodeManager->mkConst(::CVC5::String("AB"));
+ Node b = d_nodeManager->mkConst(::CVC5::String("B"));
+ Node c = d_nodeManager->mkConst(::CVC5::String("C"));
+ Node d = d_nodeManager->mkConst(::CVC5::String("D"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node z = d_nodeManager->mkVar("z", strType);
d_nodeManager->mkConst(String("AZZZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String("FOO"));
+ Node res = d_nodeManager->mkConst(::CVC5::String("FOO"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZAZZZBZZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String("ZFOOZZB"));
+ Node res = d_nodeManager->mkConst(::CVC5::String("ZFOOZZB"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZAZZZBZAZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String("ZFOOZAZB"));
+ Node res = d_nodeManager->mkConst(::CVC5::String("ZFOOZAZB"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZZZ")),
re,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String("ZZZ"));
+ Node res = d_nodeManager->mkConst(::CVC5::String("ZZZ"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZZZ")),
sigStar,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String("FOOZZZ"));
+ Node res = d_nodeManager->mkConst(::CVC5::String("FOOZZZ"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("")),
sigStar,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String("FOO"));
+ Node res = d_nodeManager->mkConst(::CVC5::String("FOO"));
sameNormalForm(t, res);
}
}
d_nodeManager->mkConst(String("AZZZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String("FOO"));
+ Node res = d_nodeManager->mkConst(::CVC5::String("FOO"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZAZZZBZZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String("ZFOOZZB"));
+ Node res = d_nodeManager->mkConst(::CVC5::String("ZFOOZZB"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZAZZZBZAZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String("ZFOOZFOO"));
+ Node res = d_nodeManager->mkConst(::CVC5::String("ZFOOZFOO"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZZZ")),
re,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String("ZZZ"));
+ Node res = d_nodeManager->mkConst(::CVC5::String("ZZZ"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZZZ")),
sigStar,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String("FOOFOOFOO"));
+ Node res = d_nodeManager->mkConst(::CVC5::String("FOOFOOFOO"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("")),
sigStar,
foo);
- Node res = d_nodeManager->mkConst(::CVC4::String(""));
+ Node res = d_nodeManager->mkConst(::CVC5::String(""));
sameNormalForm(t, res);
}
}
TypeNode intType = d_nodeManager->integerType();
TypeNode strType = d_nodeManager->stringType();
- Node empty = d_nodeManager->mkConst(::CVC4::String(""));
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
- Node ab = d_nodeManager->mkConst(::CVC4::String("AB"));
- Node b = d_nodeManager->mkConst(::CVC4::String("B"));
- Node c = d_nodeManager->mkConst(::CVC4::String("C"));
- Node e = d_nodeManager->mkConst(::CVC4::String("E"));
- Node h = d_nodeManager->mkConst(::CVC4::String("H"));
- Node j = d_nodeManager->mkConst(::CVC4::String("J"));
- Node p = d_nodeManager->mkConst(::CVC4::String("P"));
- Node abc = d_nodeManager->mkConst(::CVC4::String("ABC"));
- Node def = d_nodeManager->mkConst(::CVC4::String("DEF"));
- Node ghi = d_nodeManager->mkConst(::CVC4::String("GHI"));
+ Node empty = d_nodeManager->mkConst(::CVC5::String(""));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
+ Node ab = d_nodeManager->mkConst(::CVC5::String("AB"));
+ Node b = d_nodeManager->mkConst(::CVC5::String("B"));
+ Node c = d_nodeManager->mkConst(::CVC5::String("C"));
+ Node e = d_nodeManager->mkConst(::CVC5::String("E"));
+ Node h = d_nodeManager->mkConst(::CVC5::String("H"));
+ Node j = d_nodeManager->mkConst(::CVC5::String("J"));
+ Node p = d_nodeManager->mkConst(::CVC5::String("P"));
+ Node abc = d_nodeManager->mkConst(::CVC5::String("ABC"));
+ Node def = d_nodeManager->mkConst(::CVC5::String("DEF"));
+ Node ghi = d_nodeManager->mkConst(::CVC5::String("GHI"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node xy = d_nodeManager->mkNode(kind::STRING_CONCAT, x, y);
{
TypeNode strType = d_nodeManager->stringType();
- Node empty = d_nodeManager->mkConst(::CVC4::String(""));
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
- Node b = d_nodeManager->mkConst(::CVC4::String("B"));
+ Node empty = d_nodeManager->mkConst(::CVC5::String(""));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
+ Node b = d_nodeManager->mkConst(::CVC5::String("B"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node xy = d_nodeManager->mkNode(kind::STRING_CONCAT, x, y);
{
TypeNode strType = d_nodeManager->stringType();
- Node empty = d_nodeManager->mkConst(::CVC4::String(""));
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
+ Node empty = d_nodeManager->mkConst(::CVC5::String(""));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node xx = d_nodeManager->mkNode(kind::STRING_CONCAT, x, x);
TypeNode strType = d_nodeManager->stringType();
TypeNode intType = d_nodeManager->integerType();
- Node empty = d_nodeManager->mkConst(::CVC4::String(""));
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
- Node aaa = d_nodeManager->mkConst(::CVC4::String("AAA"));
- Node b = d_nodeManager->mkConst(::CVC4::String("B"));
- Node ba = d_nodeManager->mkConst(::CVC4::String("BA"));
+ Node empty = d_nodeManager->mkConst(::CVC5::String(""));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
+ Node aaa = d_nodeManager->mkConst(::CVC5::String("AAA"));
+ Node b = d_nodeManager->mkConst(::CVC5::String("B"));
+ Node ba = d_nodeManager->mkConst(::CVC5::String("BA"));
Node w = d_nodeManager->mkVar("w", strType);
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
TypeNode intType = d_nodeManager->integerType();
TypeNode strType = d_nodeManager->stringType();
- Node empty = d_nodeManager->mkConst(::CVC4::String(""));
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
- Node ab = d_nodeManager->mkConst(::CVC4::String("AB"));
- Node abc = d_nodeManager->mkConst(::CVC4::String("ABC"));
- Node abcd = d_nodeManager->mkConst(::CVC4::String("ABCD"));
- Node bc = d_nodeManager->mkConst(::CVC4::String("BC"));
- Node c = d_nodeManager->mkConst(::CVC4::String("C"));
- Node cd = d_nodeManager->mkConst(::CVC4::String("CD"));
+ Node empty = d_nodeManager->mkConst(::CVC5::String(""));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
+ Node ab = d_nodeManager->mkConst(::CVC5::String("AB"));
+ Node abc = d_nodeManager->mkConst(::CVC5::String("ABC"));
+ Node abcd = d_nodeManager->mkConst(::CVC5::String("ABCD"));
+ Node bc = d_nodeManager->mkConst(::CVC5::String("BC"));
+ Node c = d_nodeManager->mkConst(::CVC5::String("C"));
+ Node cd = d_nodeManager->mkConst(::CVC5::String("CD"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node n = d_nodeManager->mkVar("n", intType);
TypeNode strType = d_nodeManager->stringType();
std::vector<Node> vec_empty;
- Node abc = d_nodeManager->mkConst(::CVC4::String("ABC"));
+ Node abc = d_nodeManager->mkConst(::CVC5::String("ABC"));
Node re_abc = d_nodeManager->mkNode(kind::STRING_TO_REGEXP, abc);
Node x = d_nodeManager->mkVar("x", strType);
}
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/rewriter.h"
#include "theory/strings/strings_rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace theory;
TypeNode intType = d_nodeManager->integerType();
TypeNode strType = d_nodeManager->stringType();
- Node a = d_nodeManager->mkConst(::CVC4::String("A"));
- Node bc = d_nodeManager->mkConst(::CVC4::String("BC"));
+ Node a = d_nodeManager->mkConst(::CVC5::String("A"));
+ Node bc = d_nodeManager->mkConst(::CVC5::String("BC"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory_engine.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace theory::arith;
ASSERT_EQ(Rewriter::rewrite(Rewriter::rewrite(t)), Rewriter::rewrite(t));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bags/normal_form.h"
#include "theory/strings/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace kind;
std::vector<Node> getNStrings(size_t n)
{
std::vector<Node> elements(n);
- CVC4::theory::strings::StringEnumerator enumerator(
+ CVC5::theory::strings::StringEnumerator enumerator(
d_nodeManager->stringType());
for (size_t i = 0; i < n; i++)
ASSERT_EQ(output3, NormalForm::evaluate(input3));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bags/bags_rewriter.h"
#include "theory/strings/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace kind;
&& response.d_status == REWRITE_AGAIN_FULL);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bags/theory_bags_type_rules.h"
#include "theory/strings/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace kind;
std::vector<Node> getNStrings(size_t n)
{
std::vector<Node> elements(n);
- CVC4::theory::strings::StringEnumerator enumerator(
+ CVC5::theory::strings::StringEnumerator enumerator(
d_nodeManager->stringType());
for (size_t i = 0; i < n; i++)
ASSERT_TRUE(d_nodeManager->mkNode(BAG_TO_SET, bag).getType().isSet());
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::theory
+ ** \brief Black box testing of CVC5::theory
**
- ** Black box testing of CVC4::theory
+ ** Black box testing of CVC5::theory
**/
#include <sstream>
#include "test_smt.h"
#include "theory/rewriter.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace context;
ASSERT_TRUE(arr2.isConst());
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/bv/int_blaster.h"
#include "util/bitvector.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace theory;
Node d_one;
};
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/rewriter.h"
#include "util/bitvector.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace theory;
ASSERT_EQ(nr, Rewriter::rewrite(nr));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/theory.h"
#include "theory/theory_engine.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace theory::bv;
}
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief White box testing of CVC4::theory::Theory.
+ ** \brief White box testing of CVC5::theory::Theory.
**
- ** White box testing of CVC4::theory::Theory. This test creates
+ ** White box testing of CVC5::theory::Theory. This test creates
** "fake" theory interfaces and injects them into TheoryEngine, so we
** can test TheoryEngine's behavior without relying on independent
** theory behavior. This is done in TheoryEngineWhite::setUp() by
#include "util/integer.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace expr;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "smt/optimization_solver.h"
#include "test_smt.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace smt;
std::cout << "Result is :" << r << std::endl;
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/rewriter.h"
#include "util/bitvector.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace theory::bv;
ASSERT_EQ(norm_axax[1], a);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "theory/quantifiers/bv_inverter_utils.h"
#include "util/result.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace kind;
using namespace theory;
runTestSext(false, BITVECTOR_SGT);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief White box testing of CVC4::theory::sets::SetsTypeEnumerator
+ ** \brief White box testing of CVC5::theory::sets::SetsTypeEnumerator
**
- ** White box testing of CVC4::theory::sets::SetsTypeEnumerator. (These tests
+ ** White box testing of CVC5::theory::sets::SetsTypeEnumerator. (These tests
** depends on the ordering that the SetsTypeEnumerator use, so it's a
*white-box
** test.)
#include "test_smt.h"
#include "theory/sets/theory_sets_type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace kind;
ASSERT_TRUE(setEnumerator.isFinished());
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "test_api.h"
#include "test_node.h"
-namespace CVC4 {
+namespace CVC5 {
-using namespace CVC4::api;
+using namespace CVC5::api;
namespace test {
ASSERT_TRUE(n.isConst());
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "util/rational.h"
#include "util/string.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory::strings;
}
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "test_node.h"
#include "theory/strings/word.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace theory::strings;
ASSERT_TRUE(Word::roverlap(aaaaa, aa) == 2);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::theory::Theory.
+ ** \brief Black box testing of CVC5::theory::Theory.
**
- ** Black box testing of CVC4::theory::Theory.
+ ** Black box testing of CVC5::theory::Theory.
**/
#include <memory>
#include "theory/theory_engine.h"
#include "util/resource_manager.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace expr;
d_outputChannel.d_callHistory.clear();
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief White box testing of CVC4::theory::TypeEnumerator
+ ** \brief White box testing of CVC5::theory::TypeEnumerator
**
- ** White box testing of CVC4::theory::TypeEnumerator. (These tests depends
+ ** White box testing of CVC5::theory::TypeEnumerator. (These tests depends
** on the ordering that the TypeEnumerators use, so it's a white-box test.)
**/
#include "test_smt.h"
#include "theory/type_enumerator.h"
-namespace CVC4 {
+namespace CVC5 {
using namespace theory;
using namespace kind;
ASSERT_THROW(*++te, NoMoreValuesException);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::ArrayStoreAll
+ ** \brief Black box testing of CVC5::ArrayStoreAll
**
- ** Black box testing of CVC4::ArrayStoreAll.
+ ** Black box testing of CVC5::ArrayStoreAll.
**/
#include "expr/array_store_all.h"
#include "test_smt.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilWhiteArrayStoreAll : public TestSmt
IllegalArgumentException);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief White box testing of CVC4::Configuration.
+ ** \brief White box testing of CVC5::Configuration.
**
- ** White box testing of CVC4::Configuration.
+ ** White box testing of CVC5::Configuration.
**/
#include <cstring>
#include "base/check.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilWhite : public TestInternal
ASSERT_THROW(CheckArgument(false, "x"), IllegalArgumentException);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::BinaryHeap
+ ** \brief Black box testing of CVC5::BinaryHeap
**
- ** Black box testing of CVC4::BinaryHeap.
+ ** Black box testing of CVC5::BinaryHeap.
**/
#include <iostream>
#include "test.h"
#include "util/bin_heap.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackBinaryHeap : public TestInternal
ASSERT_TRUE(heap.empty());
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::BitVector
+ ** \brief Black box testing of CVC5::BitVector
**
- ** Black box testing of CVC4::BitVector.
+ ** Black box testing of CVC5::BitVector.
**/
#include <sstream>
#include "test.h"
#include "util/bitvector.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackBitVector : public TestInternal
ASSERT_EQ(BitVector::mkMaxSigned(4).toSignedInteger(), Integer(7));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::BooleanSimplification
+ ** \brief Black box testing of CVC5::BooleanSimplification
**
- ** Black box testing of CVC4::BooleanSimplification.
+ ** Black box testing of CVC5::BooleanSimplification.
**/
#include <algorithm>
#include "smt_util/boolean_simplification.h"
#include "test_node.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackBooleanSimplification : public TestNode
#endif
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Public-box testing of CVC4::Cardinality
+ ** \brief Public-box testing of CVC5::Cardinality
**
- ** Public-box testing of CVC4::Cardinality.
+ ** Public-box testing of CVC5::Cardinality.
**/
#include <sstream>
#include "util/cardinality.h"
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackCardinality : public TestInternal
ASSERT_EQ((z ^ z).getBethNumber(), 3);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "base/check.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilWhiteCheck : public TestInternal
ASSERT_DEATH(AlwaysAssert(false), "false");
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::Configuration.
+ ** \brief Black box testing of CVC5::Configuration.
**
- ** Black box testing of CVC4::Configuration.
+ ** Black box testing of CVC5::Configuration.
**/
#include "base/configuration.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackConfiguration : public TestInternal
Configuration::about();
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::DType
+ ** \brief Black box testing of CVC5::DType
**
- ** Black box testing of CVC4::DType.
+ ** Black box testing of CVC5::DType.
**/
#include <sstream>
#include "expr/type_node.h"
#include "test_smt.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackDatatype : public TestSmt
ASSERT_EQ(TypeNode::leastCommonTypeNode(pairIntInt, pairIntInt), pairIntInt);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::Exception.
+ ** \brief Black box testing of CVC5::Exception.
**
- ** Black box testing of CVC4::Exception.
+ ** Black box testing of CVC5::Exception.
**/
#include <iostream>
#include "base/exception.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackException : public TestInternal
{
};
-// CVC4::Exception is a simple class, just test it all at once.
+// CVC5::Exception is a simple class, just test it all at once.
TEST_F(TestUtilBlackException, exceptions)
{
Exception e1;
ASSERT_EQ(s3.str(), std::string("three of 'em!"));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::FloatingPoint.
+ ** \brief Black box testing of CVC5::FloatingPoint.
**
- ** Black box testing of CVC4::FloatingPoint.
+ ** Black box testing of CVC5::FloatingPoint.
**/
#include "test.h"
#include "util/floatingpoint.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackFloatingPoint : public TestInternal
ASSERT_TRUE(mfp128.isNormal());
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::Integer.
+ ** \brief Black box testing of CVC5::Integer.
**
- ** Black box testing of CVC4::Integer.
+ ** Black box testing of CVC5::Integer.
**/
#include <limits>
#include "test.h"
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackInteger : public TestInternal
}
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief White box testing of CVC4::Integer.
+ ** \brief White box testing of CVC5::Integer.
**
- ** White box testing of CVC4::Integer.
+ ** White box testing of CVC5::Integer.
**/
#include <sstream>
#include "test.h"
#include "util/integer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilWhiteInteger : public TestInternal
ASSERT_EQ(Integer(u), Integer(u));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
#include "base/output.h"
#include "test.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackOutput : public TestInternal
#endif /* CVC4_MUZZLE */
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::Rational.
+ ** \brief Black box testing of CVC5::Rational.
**
- ** Black box testing of CVC4::Rational.
+ ** Black box testing of CVC5::Rational.
**/
#include <sstream>
#include "test.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackRational : public TestInternal
ASSERT_THROW(Rational::fromDecimal("Hello, world!");, std::invalid_argument);
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief White box testing of CVC4::Rational.
+ ** \brief White box testing of CVC5::Rational.
**
- ** White box testing of CVC4::Rational.
+ ** White box testing of CVC5::Rational.
**/
#include <sstream>
#include "test.h"
#include "util/rational.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilWhiteRational : public TestInternal
ASSERT_EQ(Rational(u), Rational(u));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::RealAlgebraicNumber.
+ ** \brief Black box testing of CVC5::RealAlgebraicNumber.
**
- ** Black box testing of CVC4::RealAlgebraicNumber.
+ ** Black box testing of CVC5::RealAlgebraicNumber.
**/
#include "test.h"
#include "util/real_algebraic_number.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
#ifndef CVC4_POLY_IMP
ASSERT_EQ(msqrt2 * sqrt2, RealAlgebraicNumber(Integer(-2)));
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
** All rights reserved. See the file COPYING in the top-level source
** directory for licensing information.\endverbatim
**
- ** \brief Black box testing of CVC4::Stat and associated classes
+ ** \brief Black box testing of CVC5::Stat and associated classes
**
- ** Black box testing of CVC4::Stat and associated classes.
+ ** Black box testing of CVC5::Stat and associated classes.
**/
#include <fcntl.h>
#include "util/stats_histogram.h"
#include "util/stats_timer.h"
-namespace CVC4 {
+namespace CVC5 {
namespace test {
class TestUtilBlackStats : public TestInternal
BackedStat<void*> backedAddr("backedDouble", (void*)0xDEADBEEF);
IntegralHistogramStat<std::int64_t> histIntStat("hist-int");
histIntStat << 15 << 16 << 15 << 14 << 16;
- IntegralHistogramStat<CVC4::PfRule> histPfRuleStat("hist-pfrule");
+ IntegralHistogramStat<CVC5::PfRule> histPfRuleStat("hist-pfrule");
histPfRuleStat << PfRule::ASSUME << PfRule::SCOPE << PfRule::ASSUME;
// A statistic with no safe_print support
#endif
}
} // namespace test
-} // namespace CVC4
+} // namespace CVC5
projects / cvc5.git / commitdiff