diff options
1458 files changed, 6661 insertions, 6619 deletions
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3930adbfa..5ba5cf444 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -168,7 +168,7 @@ jobs: - 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 diff --git a/examples/api/bitvectors.cpp b/examples/api/bitvectors.cpp index 6c0a1e875..1cbfdb031 100644 --- a/examples/api/bitvectors.cpp +++ b/examples/api/bitvectors.cpp @@ -19,7 +19,7 @@ #include <cvc4/api/cvc4cpp.h> using namespace std; -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/examples/api/bitvectors_and_arrays.cpp b/examples/api/bitvectors_and_arrays.cpp index ebc1da9fe..5c243e1d1 100644 --- a/examples/api/bitvectors_and_arrays.cpp +++ b/examples/api/bitvectors_and_arrays.cpp @@ -20,7 +20,7 @@ #include <cvc4/api/cvc4cpp.h> using namespace std; -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/examples/api/combination.cpp b/examples/api/combination.cpp index 9e0b47f33..2651bf80f 100644 --- a/examples/api/combination.cpp +++ b/examples/api/combination.cpp @@ -21,7 +21,7 @@ #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) { diff --git a/examples/api/datatypes.cpp b/examples/api/datatypes.cpp index fcd2757d7..c2b3bc4c4 100644 --- a/examples/api/datatypes.cpp +++ b/examples/api/datatypes.cpp @@ -18,7 +18,7 @@ #include <cvc4/api/cvc4cpp.h> -using namespace CVC4::api; +using namespace CVC5::api; void test(Solver& slv, Sort& consListSort) { diff --git a/examples/api/extract.cpp b/examples/api/extract.cpp index cbb1468b2..a6a43a7c2 100644 --- a/examples/api/extract.cpp +++ b/examples/api/extract.cpp @@ -19,7 +19,7 @@ #include <cvc4/api/cvc4cpp.h> using namespace std; -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/examples/api/helloworld.cpp b/examples/api/helloworld.cpp index 79477c9b8..89b0e212d 100644 --- a/examples/api/helloworld.cpp +++ b/examples/api/helloworld.cpp @@ -18,7 +18,7 @@ #include <cvc4/api/cvc4cpp.h> -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/examples/api/linear_arith.cpp b/examples/api/linear_arith.cpp index 039ae586f..ca3e8a2b9 100644 --- a/examples/api/linear_arith.cpp +++ b/examples/api/linear_arith.cpp @@ -20,7 +20,7 @@ #include "cvc4/api/cvc4cpp.h" using namespace std; -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/examples/api/sequences.cpp b/examples/api/sequences.cpp index ef479cbd3..6272b423b 100644 --- a/examples/api/sequences.cpp +++ b/examples/api/sequences.cpp @@ -18,7 +18,7 @@ #include <iostream> -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/examples/api/sets.cpp b/examples/api/sets.cpp index b1090d19b..cac705415 100644 --- a/examples/api/sets.cpp +++ b/examples/api/sets.cpp @@ -19,7 +19,7 @@ #include <cvc4/api/cvc4cpp.h> using namespace std; -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/examples/api/strings.cpp b/examples/api/strings.cpp index bae9c9ec2..b926395de 100644 --- a/examples/api/strings.cpp +++ b/examples/api/strings.cpp @@ -18,7 +18,7 @@ #include <cvc4/api/cvc4cpp.h> -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/examples/api/sygus-fun.cpp b/examples/api/sygus-fun.cpp index dc6f4df0f..a29cdb132 100644 --- a/examples/api/sygus-fun.cpp +++ b/examples/api/sygus-fun.cpp @@ -49,7 +49,7 @@ #include <iostream> -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/examples/api/sygus-grammar.cpp b/examples/api/sygus-grammar.cpp index 9dc801e66..6491dc0a5 100644 --- a/examples/api/sygus-grammar.cpp +++ b/examples/api/sygus-grammar.cpp @@ -46,7 +46,7 @@ #include <iostream> -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/examples/api/sygus-inv.cpp b/examples/api/sygus-inv.cpp index 8435eea44..206803eb6 100644 --- a/examples/api/sygus-inv.cpp +++ b/examples/api/sygus-inv.cpp @@ -37,7 +37,7 @@ #include <iostream> -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/examples/hashsmt/sha1_collision.cpp b/examples/hashsmt/sha1_collision.cpp index 7887cb3e9..6fa7954ea 100644 --- a/examples/hashsmt/sha1_collision.cpp +++ b/examples/hashsmt/sha1_collision.cpp @@ -34,7 +34,7 @@ #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]; @@ -101,8 +101,9 @@ int main(int argc, char* argv[]) { delete[] cvc4input1; delete[] cvc4input2; - - } catch (CVC4::Exception& e) { + } + catch (CVC5::Exception& e) + { cerr << e << endl; } } diff --git a/examples/hashsmt/sha1_inversion.cpp b/examples/hashsmt/sha1_inversion.cpp index e555486d2..957f9225e 100644 --- a/examples/hashsmt/sha1_inversion.cpp +++ b/examples/hashsmt/sha1_inversion.cpp @@ -43,7 +43,7 @@ #include "word.h" using namespace std; -using namespace CVC4; +using namespace CVC5; int main(int argc, char* argv[]) { @@ -104,7 +104,9 @@ int main(int argc, char* argv[]) { // Checksat command output << CheckSatCommand() << endl; - } catch (CVC4::Exception& e) { + } + catch (CVC5::Exception& e) + { cerr << e << endl; } } diff --git a/examples/hashsmt/word.cpp b/examples/hashsmt/word.cpp index 4d86d062e..5fd5b7979 100644 --- a/examples/hashsmt/word.cpp +++ b/examples/hashsmt/word.cpp @@ -33,8 +33,8 @@ 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()) { @@ -50,10 +50,10 @@ ExprManager* Word::s_manager = 0; 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; } @@ -71,7 +71,7 @@ Word Word::concat(const Word words[], unsigned size) { } 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) { diff --git a/examples/hashsmt/word.h b/examples/hashsmt/word.h index 11871e951..4a1d142f4 100644 --- a/examples/hashsmt/word.h +++ b/examples/hashsmt/word.h @@ -35,23 +35,22 @@ namespace hashsmt { 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); @@ -71,12 +70,10 @@ public: 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); diff --git a/examples/nra-translate/normalize.cpp b/examples/nra-translate/normalize.cpp index 43e120f08..daa7d920d 100644 --- a/examples/nra-translate/normalize.cpp +++ b/examples/nra-translate/normalize.cpp @@ -28,9 +28,9 @@ #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[]) { diff --git a/examples/nra-translate/smt2info.cpp b/examples/nra-translate/smt2info.cpp index b73b0d28f..661747ab0 100644 --- a/examples/nra-translate/smt2info.cpp +++ b/examples/nra-translate/smt2info.cpp @@ -25,9 +25,9 @@ #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(); diff --git a/examples/nra-translate/smt2todreal.cpp b/examples/nra-translate/smt2todreal.cpp index fe27b01bd..2a12b828e 100644 --- a/examples/nra-translate/smt2todreal.cpp +++ b/examples/nra-translate/smt2todreal.cpp @@ -28,9 +28,9 @@ #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[]) { diff --git a/examples/nra-translate/smt2toisat.cpp b/examples/nra-translate/smt2toisat.cpp index 33efcbbfe..aecdf5ba2 100644 --- a/examples/nra-translate/smt2toisat.cpp +++ b/examples/nra-translate/smt2toisat.cpp @@ -26,9 +26,9 @@ #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, diff --git a/examples/nra-translate/smt2tomathematica.cpp b/examples/nra-translate/smt2tomathematica.cpp index 0c7a4f275..02795dc1f 100644 --- a/examples/nra-translate/smt2tomathematica.cpp +++ b/examples/nra-translate/smt2tomathematica.cpp @@ -26,8 +26,8 @@ #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, diff --git a/examples/nra-translate/smt2toqepcad.cpp b/examples/nra-translate/smt2toqepcad.cpp index 6164f437c..1bfe9424b 100644 --- a/examples/nra-translate/smt2toqepcad.cpp +++ b/examples/nra-translate/smt2toqepcad.cpp @@ -26,8 +26,8 @@ #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, diff --git a/examples/nra-translate/smt2toredlog.cpp b/examples/nra-translate/smt2toredlog.cpp index 97d600797..4238e9f13 100644 --- a/examples/nra-translate/smt2toredlog.cpp +++ b/examples/nra-translate/smt2toredlog.cpp @@ -26,9 +26,9 @@ #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, diff --git a/examples/sets-translate/sets_translate.cpp b/examples/sets-translate/sets_translate.cpp index 3e59eaa2a..b9ced3d79 100644 --- a/examples/sets-translate/sets_translate.cpp +++ b/examples/sets-translate/sets_translate.cpp @@ -28,9 +28,9 @@ #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); } diff --git a/examples/simple_vc_cxx.cpp b/examples/simple_vc_cxx.cpp index f99a0170e..b6890e6ef 100644 --- a/examples/simple_vc_cxx.cpp +++ b/examples/simple_vc_cxx.cpp @@ -20,7 +20,7 @@ #include <iostream> -using namespace CVC4::api; +using namespace CVC5::api; int main() { Solver slv; diff --git a/examples/simple_vc_quant_cxx.cpp b/examples/simple_vc_quant_cxx.cpp index 9fb720652..e6778fa41 100644 --- a/examples/simple_vc_quant_cxx.cpp +++ b/examples/simple_vc_quant_cxx.cpp @@ -18,7 +18,7 @@ #include <iostream> -using namespace CVC4::api; +using namespace CVC5::api; int main() { Solver slv; diff --git a/examples/translator.cpp b/examples/translator.cpp index 0783989fc..1a9de7f80 100644 --- a/examples/translator.cpp +++ b/examples/translator.cpp @@ -28,9 +28,9 @@ #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', diff --git a/src/api/checks.h b/src/api/checks.h index d5408d312..4686c0694 100644 --- a/src/api/checks.h +++ b/src/api/checks.h @@ -528,7 +528,7 @@ namespace api { 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) \ @@ -560,7 +560,7 @@ namespace api { 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) \ diff --git a/src/api/cvc4cpp.cpp b/src/api/cvc4cpp.cpp index e8b190003..66ddff9d4 100644 --- a/src/api/cvc4cpp.cpp +++ b/src/api/cvc4cpp.cpp @@ -64,7 +64,7 @@ #include "util/stats_histogram.h" #include "util/utility.h" -namespace CVC4 { +namespace CVC5 { namespace api { /* -------------------------------------------------------------------------- */ @@ -87,570 +87,570 @@ struct Statistics /* -------------------------------------------------------------------------- */ /* 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 */ @@ -677,8 +677,8 @@ const static std::unordered_set<Kind, KindHashFunction> s_indexed_kinds( 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()) @@ -688,13 +688,13 @@ CVC4::api::Kind intToExtKind(CVC4::Kind k) 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; } @@ -709,17 +709,17 @@ bool isDefinedKind(Kind k) { return k > UNDEFINED_KIND && k < LAST_KIND; } * 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 @@ -728,7 +728,7 @@ uint32_t minArity(Kind k) { 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 @@ -744,7 +744,7 @@ uint32_t maxArity(Kind k) { 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 @@ -762,7 +762,7 @@ uint32_t maxArity(Kind k) 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) @@ -834,11 +834,11 @@ class CVC4ApiRecoverableExceptionStream { \ 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 @@ -847,49 +847,49 @@ class CVC4ApiRecoverableExceptionStream /* 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 @@ -904,18 +904,18 @@ 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; @@ -952,12 +952,12 @@ std::ostream& operator<<(std::ostream& out, enum Result::UnknownExplanation e) /* 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() { @@ -1332,7 +1332,7 @@ Sort Sort::instantiate(const std::vector<Sort>& params) const 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)); @@ -1368,7 +1368,7 @@ Sort Sort::substitute(const std::vector<Sort>& sorts, 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, @@ -1394,7 +1394,7 @@ std::string Sort::toString() const 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 ------------------------------------------------------- */ @@ -1757,15 +1757,15 @@ bool Sort::isNullHelper() const { return d_type->isNull(); } /* 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)) { } @@ -1914,53 +1914,53 @@ std::pair<uint32_t, uint32_t> Op::getIndices() const // 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 @@ -2031,13 +2031,13 @@ bool Op::isIndexedHelper() const { return !d_node->isNull(); } /* 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() @@ -2251,7 +2251,7 @@ Op Term::getOp() const { // 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 @@ -2276,7 +2276,7 @@ Term Term::getConstArrayBase() const 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()); @@ -2288,7 +2288,7 @@ std::vector<Term> Term::getConstSequenceElements() const { 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 @@ -2414,7 +2414,7 @@ Term::const_iterator::const_iterator() } 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) { @@ -2515,14 +2515,14 @@ Term::const_iterator Term::end() const 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(); } @@ -2545,7 +2545,7 @@ bool checkReal64Bounds(const Rational& r) 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) @@ -2658,7 +2658,7 @@ bool Term::isString() const 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; } @@ -2667,10 +2667,10 @@ std::wstring Term::getString() const { 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; } @@ -2754,18 +2754,18 @@ Kind Term::getKindHelper() const { 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; @@ -2802,7 +2802,7 @@ DatatypeConstructorDecl::DatatypeConstructorDecl() 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() @@ -2884,7 +2884,7 @@ DatatypeDecl::DatatypeDecl() : d_solver(nullptr), d_dtype(nullptr) {} 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)) { } @@ -2893,7 +2893,7 @@ DatatypeDecl::DatatypeDecl(const Solver* slv, 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)) { } @@ -2905,8 +2905,8 @@ DatatypeDecl::DatatypeDecl(const Solver* slv, : 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; } @@ -2991,15 +2991,15 @@ std::ostream& operator<<(std::ostream& out, const DatatypeDecl& dtdecl) 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"; } @@ -3079,8 +3079,8 @@ DatatypeConstructor::DatatypeConstructor() : d_solver(nullptr), d_ctor(nullptr) } 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"; @@ -3214,14 +3214,14 @@ DatatypeConstructor::const_iterator DatatypeConstructor::end() const } 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())); @@ -3341,8 +3341,8 @@ std::ostream& operator<<(std::ostream& out, const DatatypeConstructor& ctor) /* 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"; } @@ -3549,7 +3549,7 @@ DatatypeConstructor Datatype::getConstructorForName( } 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()) { @@ -3816,7 +3816,7 @@ Sort Grammar::resolve() 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()); @@ -3829,7 +3829,7 @@ Sort Grammar::resolve() 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()); @@ -3903,12 +3903,12 @@ void Grammar::addSygusConstructorTerm( { 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); @@ -4027,27 +4027,27 @@ std::ostream& operator<<(std::ostream& out, const Grammar& grammar) /* -------------------------------------------------------------------------- */ 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}, }; @@ -4093,7 +4093,7 @@ void Solver::increment_vars_consts_stats(const Sort& sort, bool is_var) const { #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) @@ -4124,10 +4124,10 @@ Term Solver::mkRealFromStrHelper(const std::string& s) const //////// 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) { @@ -4144,7 +4144,7 @@ Term Solver::mkBVFromIntHelper(uint32_t size, uint64_t val) const { 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 @@ -4153,7 +4153,7 @@ 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, @@ -4180,7 +4180,7 @@ 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 @@ -4195,7 +4195,7 @@ 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 @@ -4230,14 +4230,14 @@ Term Solver::mkTermFromKind(Kind kind) 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); @@ -4250,7 +4250,7 @@ Term Solver::mkTermHelper(Kind kind, const std::vector<Term>& children) const //////// 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) { @@ -4340,7 +4340,7 @@ Term Solver::mkTermHelper(const Op& op, const std::vector<Term>& children) const 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); @@ -4360,14 +4360,14 @@ std::vector<Sort> Solver::mkDatatypeSortsInternal( // 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; @@ -4439,7 +4439,7 @@ Term Solver::ensureTermSort(const Term& term, const Sort& sort) const 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; @@ -4507,7 +4507,7 @@ void Solver::checkMkTerm(Kind kind, uint32_t nchildren) const { 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) @@ -4870,7 +4870,7 @@ Term Solver::mkPi() const 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); //////// @@ -4896,7 +4896,7 @@ Term Solver::mkInteger(int64_t val) const 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; //////// @@ -4924,7 +4924,7 @@ Term Solver::mkReal(int64_t val) const 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; @@ -4935,7 +4935,7 @@ Term Solver::mkReal(int64_t num, int64_t den) const 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; @@ -4947,7 +4947,7 @@ Term Solver::mkRegexpEmpty() const 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); //////// @@ -4960,7 +4960,7 @@ Term Solver::mkRegexpSigma() const 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); //////// @@ -4976,7 +4976,7 @@ Term Solver::mkEmptySet(const Sort& sort) const 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; } @@ -4990,7 +4990,7 @@ Term Solver::mkEmptyBag(const Sort& sort) const 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; } @@ -5002,7 +5002,7 @@ Term Solver::mkSepNil(const Sort& sort) const 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); //////// @@ -5014,7 +5014,7 @@ Term Solver::mkString(const std::string& s, bool useEscSequences) const 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; } @@ -5024,7 +5024,7 @@ Term Solver::mkString(const unsigned char c) const 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; } @@ -5034,7 +5034,7 @@ Term Solver::mkString(const std::vector<uint32_t>& s) const 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; } @@ -5070,7 +5070,7 @@ Term Solver::mkUniverseSet(const Sort& sort) const //////// 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); @@ -5128,8 +5128,8 @@ Term Solver::mkConstArray(const Sort& sort, const Term& val) const // 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; @@ -5142,7 +5142,7 @@ Term Solver::mkPosInf(uint32_t exp, uint32_t sig) const 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; @@ -5155,7 +5155,7 @@ Term Solver::mkNegInf(uint32_t exp, uint32_t sig) const 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; @@ -5168,7 +5168,7 @@ Term Solver::mkNaN(uint32_t exp, uint32_t sig) const 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; @@ -5181,7 +5181,7 @@ Term Solver::mkPosZero(uint32_t exp, uint32_t sig) const 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; @@ -5194,7 +5194,7 @@ Term Solver::mkNegZero(uint32_t exp, uint32_t sig) const 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; @@ -5207,7 +5207,7 @@ Term Solver::mkRoundingMode(RoundingMode rm) const 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; } @@ -5218,8 +5218,8 @@ Term Solver::mkUninterpretedConst(const Sort& sort, int32_t index) const 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; } @@ -5230,11 +5230,11 @@ Term Solver::mkAbstractValue(const std::string& index) const 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 //////// @@ -5248,7 +5248,7 @@ Term Solver::mkAbstractValue(uint64_t index) const 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 //////// @@ -5271,8 +5271,8 @@ Term Solver::mkFloatingPoint(uint32_t exp, uint32_t sig, Term val) const 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; } @@ -5461,7 +5461,7 @@ Term Solver::mkTerm(const Op& op) const 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 */ @@ -5534,7 +5534,7 @@ Term Solver::mkTuple(const std::vector<Sort>& sorts, 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); @@ -5580,7 +5580,7 @@ Op Solver::mkOp(Kind kind, const std::string& arg) const { res = Op(this, kind, - *mkValHelper<CVC4::RecordUpdate>(CVC4::RecordUpdate(arg)).d_node); + *mkValHelper<CVC5::RecordUpdate>(CVC5::RecordUpdate(arg)).d_node); } else { @@ -5591,7 +5591,7 @@ Op Solver::mkOp(Kind kind, const std::string& arg) const << "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; @@ -5610,76 +5610,76 @@ Op Solver::mkOp(Kind kind, uint32_t arg) const 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) @@ -5703,57 +5703,57 @@ Op Solver::mkOp(Kind kind, uint32_t arg1, uint32_t arg2) const 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) @@ -5778,7 +5778,7 @@ Op Solver::mkOp(Kind kind, const std::vector<uint32_t>& args) const { res = Op(this, kind, - *mkValHelper<CVC4::TupleProjectOp>(CVC4::TupleProjectOp(args)) + *mkValHelper<CVC5::TupleProjectOp>(CVC5::TupleProjectOp(args)) .d_node); } break; @@ -5819,7 +5819,7 @@ Result Solver::checkEntailed(const Term& term) const "(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; @@ -5869,7 +5869,7 @@ Result Solver::checkSat(void) const << "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; @@ -5888,7 +5888,7 @@ Result Solver::checkSatAssuming(const Term& assumption) const "(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; @@ -5912,7 +5912,7 @@ Result Solver::checkSatAssuming(const std::vector<Term>& assumptions) const 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; @@ -6641,7 +6641,7 @@ void Solver::setLogic(const std::string& logic) const 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); //////// @@ -6824,12 +6824,12 @@ Term Solver::getSynthSolution(Term term) const 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 @@ -6845,7 +6845,7 @@ std::vector<Term> Solver::getSynthSolutions( 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"; @@ -6856,7 +6856,7 @@ std::vector<Term> Solver::getSynthSolutions( 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()) @@ -6893,4 +6893,4 @@ Options& Solver::getOptions(void) { return d_smtEngine->getOptions(); } } // namespace api -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/api/cvc4cpp.h b/src/api/cvc4cpp.h index 5a8f62983..8e5ddf28d 100644 --- a/src/api/cvc4cpp.h +++ b/src/api/cvc4cpp.h @@ -30,7 +30,7 @@ #include <unordered_set> #include <vector> -namespace CVC4 { +namespace CVC5 { template <bool ref_count> class NodeTemplate; @@ -201,14 +201,14 @@ class CVC4_EXPORT Result * @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; }; /** @@ -239,16 +239,16 @@ class Datatype; */ 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; @@ -700,7 +700,7 @@ class CVC4_EXPORT Sort 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); @@ -717,7 +717,7 @@ class CVC4_EXPORT Sort * @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 @@ -733,10 +733,10 @@ class CVC4_EXPORT Sort /** * 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; }; /** @@ -847,7 +847,7 @@ class CVC4_EXPORT Op * @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 @@ -874,10 +874,10 @@ class CVC4_EXPORT Op /** * 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; }; /* -------------------------------------------------------------------------- */ @@ -889,25 +889,25 @@ class CVC4_EXPORT Op */ 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; @@ -1116,7 +1116,7 @@ class CVC4_EXPORT Term * @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); /** @@ -1169,7 +1169,7 @@ class CVC4_EXPORT Term */ 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; }; @@ -1259,10 +1259,10 @@ class CVC4_EXPORT Term * @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 @@ -1285,10 +1285,10 @@ class CVC4_EXPORT Term /** * 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; }; /** @@ -1445,9 +1445,9 @@ class CVC4_EXPORT DatatypeConstructorDecl * 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; @@ -1534,7 +1534,7 @@ class CVC4_EXPORT DatatypeDecl 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 @@ -1550,10 +1550,10 @@ class CVC4_EXPORT DatatypeDecl /** * 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; }; /** @@ -1604,7 +1604,7 @@ class CVC4_EXPORT DatatypeSelector * @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 @@ -1619,10 +1619,10 @@ class CVC4_EXPORT DatatypeSelector /** * 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; }; /** @@ -1785,7 +1785,7 @@ class CVC4_EXPORT DatatypeConstructor * @param true if this is a begin() iterator */ const_iterator(const Solver* slv, - const CVC4::DTypeConstructor& ctor, + const CVC5::DTypeConstructor& ctor, bool begin); /** @@ -1823,7 +1823,7 @@ class CVC4_EXPORT DatatypeConstructor * @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. @@ -1845,10 +1845,10 @@ class CVC4_EXPORT DatatypeConstructor /** * 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; }; /* @@ -2007,7 +2007,7 @@ class CVC4_EXPORT Datatype * @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. @@ -2044,7 +2044,7 @@ class CVC4_EXPORT Datatype * @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. @@ -2066,10 +2066,10 @@ class CVC4_EXPORT Datatype /** * 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; }; /** @@ -2135,9 +2135,9 @@ std::ostream& operator<<(std::ostream& out, */ 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: @@ -3704,5 +3704,5 @@ class CVC4_EXPORT Solver }; } // namespace api -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/api/cvc4cppkind.h b/src/api/cvc4cppkind.h index c98667da7..ef2f6af74 100644 --- a/src/api/cvc4cppkind.h +++ b/src/api/cvc4cppkind.h @@ -21,7 +21,7 @@ #include <ostream> -namespace CVC4 { +namespace CVC5 { namespace api { /* -------------------------------------------------------------------------- */ @@ -33,7 +33,7 @@ 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 { @@ -2868,6 +2868,6 @@ struct CVC4_EXPORT KindHashFunction }; } // namespace api -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/api/python/cvc4.pxd b/src/api/python/cvc4.pxd index 19e7eb092..9d69e2a15 100644 --- a/src/api/python/cvc4.pxd +++ b/src/api/python/cvc4.pxd @@ -19,7 +19,7 @@ cdef extern from "api/cvc4cpp.h" namespace "CVC4": 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 + @@ -353,7 +353,7 @@ cdef extern from "api/cvc4cpp.h" namespace "CVC4::api": 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, diff --git a/src/api/python/genkinds.py.in b/src/api/python/genkinds.py.in index 0f8ba4b45..46bf2b45e 100644 --- a/src/api/python/genkinds.py.in +++ b/src/api/python/genkinds.py.in @@ -40,13 +40,13 @@ PYCOMMENT = '#' 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 = \ diff --git a/src/base/check.cpp b/src/base/check.cpp index c19b30f6a..4aa6bfce0 100644 --- a/src/base/check.cpp +++ b/src/base/check.cpp @@ -19,7 +19,7 @@ #include <cstdlib> #include <iostream> -namespace CVC4 { +namespace CVC5 { FatalStream::FatalStream(const char* function, const char* file, int line) { @@ -209,4 +209,4 @@ AssertArgumentException::AssertArgumentException(const char* condStr, line); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/base/check.h b/src/base/check.h index 70c5c9016..1e46ea85c 100644 --- a/src/base/check.h +++ b/src/base/check.h @@ -75,7 +75,7 @@ #define CVC4_FALLTHROUGH #endif -namespace CVC4 { +namespace CVC5 { // Implementation notes: // To understand FatalStream and OStreamVoider, it is useful to understand @@ -206,11 +206,11 @@ class AssertArgumentException : public Exception #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...) \ @@ -218,11 +218,11 @@ class AssertArgumentException : public Exception { \ 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...) \ @@ -230,7 +230,7 @@ class AssertArgumentException : public Exception { \ if (__builtin_expect((!(cond)), false)) \ { \ - throw ::CVC4::AssertArgumentException( \ + throw ::CVC5::AssertArgumentException( \ #cond, #arg, __PRETTY_FUNCTION__, __FILE__, __LINE__, ##msg); \ } \ } while (0) @@ -245,6 +245,6 @@ class AssertArgumentException : public Exception cond, arg, msg...) /*__builtin_expect( ( cond ), true )*/ #endif /* CVC4_ASSERTIONS */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__CHECK_H */ diff --git a/src/base/configuration.cpp b/src/base/configuration.cpp index 39284227a..1b8be7bf9 100644 --- a/src/base/configuration.cpp +++ b/src/base/configuration.cpp @@ -36,7 +36,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { string Configuration::getName() { return CVC4_PACKAGE_NAME; @@ -375,7 +375,8 @@ std::string Configuration::getGitId() { stringstream ss; ss << "git " << branchName << " " << string(getGitCommit()).substr(0, 8) - << ( ::CVC4::Configuration::hasGitModifications() ? " (with modifications)" : "" ); + << (::CVC5::Configuration::hasGitModifications() ? " (with modifications)" + : ""); return ss.str(); } @@ -398,4 +399,4 @@ std::string Configuration::getCompiledDateTime() { return __DATE__ " " __TIME__; } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/base/configuration.h b/src/base/configuration.h index ec8cc879b..c6cf3b229 100644 --- a/src/base/configuration.h +++ b/src/base/configuration.h @@ -25,7 +25,7 @@ #include "cvc4_export.h" -namespace CVC4 { +namespace CVC5 { /** * Represents the (static) configuration of CVC4. @@ -135,6 +135,6 @@ public: }; /* class Configuration */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__CONFIGURATION_H */ diff --git a/src/base/configuration_private.h b/src/base/configuration_private.h index cc1983734..7de4f0e97 100644 --- a/src/base/configuration_private.h +++ b/src/base/configuration_private.h @@ -22,7 +22,7 @@ #include "base/configuration.h" -namespace CVC4 { +namespace CVC5 { #ifdef CVC4_DEBUG # define IS_DEBUG_BUILD true @@ -182,6 +182,6 @@ namespace CVC4 { #endif /* __has_feature(thread_sanitizer) */ #endif /* defined(__has_feature) */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__CONFIGURATION_PRIVATE_H */ diff --git a/src/base/exception.cpp b/src/base/exception.cpp index 43227cce5..631f1cc35 100644 --- a/src/base/exception.cpp +++ b/src/base/exception.cpp @@ -27,7 +27,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { std::string Exception::toString() const { @@ -187,4 +187,4 @@ void IllegalArgumentException::construct(const char* header, const char* extra, delete [] buf; } -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/base/exception.h b/src/base/exception.h index d9bf83f44..a0ad0819c 100644 --- a/src/base/exception.h +++ b/src/base/exception.h @@ -25,7 +25,7 @@ #include "cvc4_export.h" -namespace CVC4 { +namespace CVC5 { class Exception : public std::exception { @@ -121,15 +121,15 @@ template <class T> 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("", "", ""); } \ } @@ -159,6 +159,6 @@ private: static thread_local LastExceptionBuffer* s_currentBuffer; }; /* class LastExceptionBuffer */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__EXCEPTION_H */ diff --git a/src/base/git_versioninfo.cpp.in b/src/base/git_versioninfo.cpp.in index 78f9115b0..333564b97 100644 --- a/src/base/git_versioninfo.cpp.in +++ b/src/base/git_versioninfo.cpp.in @@ -16,7 +16,7 @@ **/ #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@; diff --git a/src/base/listener.cpp b/src/base/listener.cpp index 02a052a09..b7d92e6a3 100644 --- a/src/base/listener.cpp +++ b/src/base/listener.cpp @@ -16,10 +16,9 @@ #include "base/listener.h" -namespace CVC4 { +namespace CVC5 { Listener::Listener(){} Listener::~Listener(){} - -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/base/listener.h b/src/base/listener.h index 4205aca01..0bb81e63a 100644 --- a/src/base/listener.h +++ b/src/base/listener.h @@ -20,7 +20,7 @@ #ifndef CVC4__LISTENER_H #define CVC4__LISTENER_H -namespace CVC4 { +namespace CVC5 { /** * Listener interface class. @@ -37,6 +37,6 @@ class Listener virtual void notify() = 0; }; -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__LISTENER_H */ diff --git a/src/base/map_util.h b/src/base/map_util.h index 2af0113b5..f428a9943 100644 --- a/src/base/map_util.h +++ b/src/base/map_util.h @@ -16,8 +16,8 @@ ** 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: @@ -40,7 +40,7 @@ #include "base/check.h" -namespace CVC4 { +namespace CVC5 { // Returns true if the `map` contains the `key`. // @@ -92,6 +92,6 @@ const MapMappedTypeT<M>& FindOrDie(const M& map, const MapKeyTypeT<M>& key) return (*it).second; } -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__BASE__MAP_UTIL_H */ diff --git a/src/base/modal_exception.h b/src/base/modal_exception.h index bfd5c9469..eab6c66b1 100644 --- a/src/base/modal_exception.h +++ b/src/base/modal_exception.h @@ -24,9 +24,9 @@ #include "base/exception.h" -namespace CVC4 { +namespace CVC5 { -class ModalException : public CVC4::Exception +class ModalException : public CVC5::Exception { public: ModalException() : @@ -50,7 +50,7 @@ class ModalException : public CVC4::Exception * 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) {} @@ -58,6 +58,6 @@ class RecoverableModalException : public CVC4::ModalException RecoverableModalException(const char* msg) : ModalException(msg) {} }; /* class RecoverableModalException */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__SMT__MODAL_EXCEPTION_H */ diff --git a/src/base/output.cpp b/src/base/output.cpp index 93ebf2a70..7876f0fbe 100644 --- a/src/base/output.cpp +++ b/src/base/output.cpp @@ -20,7 +20,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { /* Definitions of the declared globals from output.h... */ @@ -41,4 +41,4 @@ TraceC TraceChannel(&cout); std::ostream DumpOutC::dump_cout(cout.rdbuf());// copy cout stream buffer DumpOutC DumpOutChannel(&DumpOutC::dump_cout); -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/base/output.h b/src/base/output.h index 5791d6f8f..b1f15d98b 100644 --- a/src/base/output.h +++ b/src/base/output.h @@ -28,7 +28,7 @@ #include "cvc4_export.h" -namespace CVC4 { +namespace CVC5 { template <class T, class U> std::ostream& operator<<(std::ostream& out, @@ -412,39 +412,58 @@ extern DumpOutC DumpOutChannel CVC4_EXPORT; #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 */ @@ -560,6 +579,6 @@ inline IndentedScope::IndentedScope(CVC4ostream out) {} inline IndentedScope::~IndentedScope() {} #endif /* CVC4_DEBUG && CVC4_TRACING */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__OUTPUT_H */ diff --git a/src/context/backtrackable.h b/src/context/backtrackable.h index 7ef91617d..2d5416eab 100644 --- a/src/context/backtrackable.h +++ b/src/context/backtrackable.h @@ -23,7 +23,7 @@ #include <vector> #include "context/cdo.h" -namespace CVC4 { +namespace CVC5 { template <class T> class List; template <class T> class List_iterator; @@ -217,6 +217,6 @@ template <class T> void Backtracker<T>::checkConsistency() { Assert(curr_level == pop_level); } -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__UTIL__BACKTRACKABLE_H */ diff --git a/src/context/cddense_set.h b/src/context/cddense_set.h index 168e901a8..765e0f75d 100644 --- a/src/context/cddense_set.h +++ b/src/context/cddense_set.h @@ -29,7 +29,7 @@ #include "util/index.h" -namespace CVC4 { +namespace CVC5 { namespace context { template <class CleanUp = DefaultCleanUp<Index> > @@ -96,6 +96,5 @@ public: };/* class CDDenseSet<> */ - -}/* CVC4::context namespace */ -}/* CVC4 namespace */ +} // namespace context +} // namespace CVC5 diff --git a/src/context/cdhashmap.h b/src/context/cdhashmap.h index 4ab552001..165080bd1 100644 --- a/src/context/cdhashmap.h +++ b/src/context/cdhashmap.h @@ -91,7 +91,7 @@ #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) @@ -452,7 +452,7 @@ public: };/* class CDHashMap<> */ -}/* CVC4::context namespace */ -}/* CVC4 namespace */ +} // namespace context +} // namespace CVC5 #endif /* CVC4__CONTEXT__CDHASHMAP_H */ diff --git a/src/context/cdhashmap_forward.h b/src/context/cdhashmap_forward.h index 7ef3874a9..b34981c73 100644 --- a/src/context/cdhashmap_forward.h +++ b/src/context/cdhashmap_forward.h @@ -30,13 +30,12 @@ /// \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 diff --git a/src/context/cdhashset.h b/src/context/cdhashset.h index 665bf8f0d..418bc8bf0 100644 --- a/src/context/cdhashset.h +++ b/src/context/cdhashset.h @@ -23,7 +23,7 @@ #include "context/cdinsert_hashmap.h" #include "context/context.h" -namespace CVC4 { +namespace CVC5 { namespace context { template <class V, class HashFcn> @@ -155,7 +155,7 @@ public: };/* class CDHashSet */ -}/* CVC4::context namespace */ -}/* CVC4 namespace */ +} // namespace context +} // namespace CVC5 #endif /* CVC4__CONTEXT__CDHASHSET_H */ diff --git a/src/context/cdhashset_forward.h b/src/context/cdhashset_forward.h index e8877c3c2..81154db5d 100644 --- a/src/context/cdhashset_forward.h +++ b/src/context/cdhashset_forward.h @@ -28,11 +28,11 @@ #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 */ diff --git a/src/context/cdinsert_hashmap.h b/src/context/cdinsert_hashmap.h index 56004463a..6bd15c645 100644 --- a/src/context/cdinsert_hashmap.h +++ b/src/context/cdinsert_hashmap.h @@ -45,7 +45,7 @@ #pragma once -namespace CVC4 { +namespace CVC5 { namespace context { @@ -406,5 +406,5 @@ class CDInsertHashMap<TNode, Data, HashFcn> : public ContextObj { "Cannot create a CDInsertHashMap with TNode keys"); }; -}/* CVC4::context namespace */ -}/* CVC4 namespace */ +} // namespace context +} // namespace CVC5 diff --git a/src/context/cdinsert_hashmap_forward.h b/src/context/cdinsert_hashmap_forward.h index 07e8d16e9..9729ea2f4 100644 --- a/src/context/cdinsert_hashmap_forward.h +++ b/src/context/cdinsert_hashmap_forward.h @@ -28,11 +28,11 @@ #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 */ diff --git a/src/context/cdlist.h b/src/context/cdlist.h index b1c8229f0..7174152cb 100644 --- a/src/context/cdlist.h +++ b/src/context/cdlist.h @@ -29,7 +29,7 @@ #include "context/context.h" #include "context/context_mm.h" -namespace CVC4 { +namespace CVC5 { namespace context { /** @@ -434,7 +434,7 @@ class CDList<T, CleanUp, ContextMemoryAllocator<T> > : public ContextObj { "Cannot create a CDList with a ContextMemoryAllocator."); }; -}/* CVC4::context namespace */ -}/* CVC4 namespace */ +} // namespace context +} // namespace CVC5 #endif /* CVC4__CONTEXT__CDLIST_H */ diff --git a/src/context/cdlist_forward.h b/src/context/cdlist_forward.h index 576463399..bd3a911af 100644 --- a/src/context/cdlist_forward.h +++ b/src/context/cdlist_forward.h @@ -36,7 +36,7 @@ /// \cond internals -namespace CVC4 { +namespace CVC5 { namespace context { template <class T> @@ -50,7 +50,7 @@ class CDList; /// \endcond -}/* CVC4::context namespace */ -}/* CVC4 namespace */ +} // namespace context +} // namespace CVC5 #endif /* CVC4__CONTEXT__CDLIST_FORWARD_H */ diff --git a/src/context/cdmaybe.h b/src/context/cdmaybe.h index 8b62c619f..1455ca5f0 100644 --- a/src/context/cdmaybe.h +++ b/src/context/cdmaybe.h @@ -24,7 +24,7 @@ #include "context/cdo.h" #include "context/context.h" -namespace CVC4 { +namespace CVC5 { namespace context { class CDRaised { @@ -73,6 +73,5 @@ public: } };/* class CDMaybe<T> */ -}/* CVC4::context namespace */ -}/* CVC4 namespace */ - +} // namespace context +} // namespace CVC5 diff --git a/src/context/cdo.h b/src/context/cdo.h index c6d9e93f6..79e73d38f 100644 --- a/src/context/cdo.h +++ b/src/context/cdo.h @@ -21,8 +21,7 @@ #include "context/context.h" - -namespace CVC4 { +namespace CVC5 { namespace context { /** @@ -176,7 +175,7 @@ public: };/* class CDO */ -}/* CVC4::context namespace */ -}/* CVC4 namespace */ +} // namespace context +} // namespace CVC5 #endif /* CVC4__CONTEXT__CDO_H */ diff --git a/src/context/cdqueue.h b/src/context/cdqueue.h index 3659f5653..20d078184 100644 --- a/src/context/cdqueue.h +++ b/src/context/cdqueue.h @@ -28,7 +28,7 @@ #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> > @@ -162,7 +162,7 @@ public: };/* class CDQueue<> */ -}/* CVC4::context namespace */ -}/* CVC4 namespace */ +} // namespace context +} // namespace CVC5 #endif /* CVC4__CONTEXT__CDQUEUE_H */ diff --git a/src/context/cdtrail_queue.h b/src/context/cdtrail_queue.h index f505004cb..d9bf6d572 100644 --- a/src/context/cdtrail_queue.h +++ b/src/context/cdtrail_queue.h @@ -25,7 +25,7 @@ #include "context/cdlist.h" #include "context/cdo.h" -namespace CVC4 { +namespace CVC5 { namespace context { class Context; @@ -89,7 +89,7 @@ public: };/* class CDTrailQueue<> */ -}/* CVC4::context namespace */ -}/* CVC4 namespace */ +} // namespace context +} // namespace CVC5 #endif /* CVC4__CONTEXT__CDTRAIL_QUEUE_H */ diff --git a/src/context/context.cpp b/src/context/context.cpp index 06485c0ba..88c783303 100644 --- a/src/context/context.cpp +++ b/src/context/context.cpp @@ -21,8 +21,7 @@ #include "base/check.h" #include "context/context.h" - -namespace CVC4 { +namespace CVC5 { namespace context { @@ -388,5 +387,5 @@ void Scope::enqueueToGarbageCollect(ContextObj* obj) { d_garbage->push_back(obj); } -} /* CVC4::context namespace */ -} /* CVC4 namespace */ +} // namespace context +} // namespace CVC5 diff --git a/src/context/context.h b/src/context/context.h index d9f98b993..7cf72e4d2 100644 --- a/src/context/context.h +++ b/src/context/context.h @@ -29,8 +29,7 @@ #include "base/output.h" #include "context/context_mm.h" - -namespace CVC4 { +namespace CVC5 { namespace context { class Context; @@ -740,7 +739,7 @@ inline void Scope::addToChain(ContextObj* pContextObj) d_pContextObjList = pContextObj; } -}/* CVC4::context namespace */ -}/* CVC4 namespace */ +} // namespace context +} // namespace CVC5 #endif /* CVC4__CONTEXT__CONTEXT_H */ diff --git a/src/context/context_mm.cpp b/src/context/context_mm.cpp index 4d9413320..2a69bc26f 100644 --- a/src/context/context_mm.cpp +++ b/src/context/context_mm.cpp @@ -29,7 +29,7 @@ #include "base/output.h" #include "context/context_mm.h" -namespace CVC4 { +namespace CVC5 { namespace context { #ifndef CVC4_DEBUG_CONTEXT_MEMORY_MANAGER @@ -177,5 +177,5 @@ unsigned ContextMemoryManager::getMaxAllocationSize() #endif /* CVC4_DEBUG_CONTEXT_MEMORY_MANAGER */ -} /* CVC4::context namespace */ -} /* CVC4 namespace */ +} // namespace context +} // namespace CVC5 diff --git a/src/context/context_mm.h b/src/context/context_mm.h index e20b9fdb9..72c2bcd3a 100644 --- a/src/context/context_mm.h +++ b/src/context/context_mm.h @@ -25,7 +25,7 @@ #endif #include <vector> -namespace CVC4 { +namespace CVC5 { namespace context { #ifndef CVC4_DEBUG_CONTEXT_MEMORY_MANAGER @@ -261,7 +261,7 @@ inline bool operator!=(const ContextMemoryAllocator<T>& a1, return a1.d_mm != a2.d_mm; } -}/* CVC4::context namespace */ -}/* CVC4 namespace */ +} // namespace context +} // namespace CVC5 #endif /* CVC4__CONTEXT__CONTEXT_MM_H */ diff --git a/src/decision/decision_attributes.h b/src/decision/decision_attributes.h index 918710dc8..be5987e6d 100644 --- a/src/decision/decision_attributes.h +++ b/src/decision/decision_attributes.h @@ -22,15 +22,15 @@ #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 */ diff --git a/src/decision/decision_engine.cpp b/src/decision/decision_engine.cpp index e535e5415..3196336aa 100644 --- a/src/decision/decision_engine.cpp +++ b/src/decision/decision_engine.cpp @@ -24,7 +24,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { DecisionEngine::DecisionEngine(context::Context* sc, context::UserContext* uc, @@ -101,4 +101,4 @@ void DecisionEngine::addSkolemDefinition(TNode lem, TNode skolem) } } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/decision/decision_engine.h b/src/decision/decision_engine.h index 2e7eaaa76..7405498b5 100644 --- a/src/decision/decision_engine.h +++ b/src/decision/decision_engine.h @@ -28,10 +28,10 @@ #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 { @@ -160,6 +160,6 @@ class DecisionEngine { std::unique_ptr<ITEDecisionStrategy> d_enabledITEStrategy; };/* DecisionEngine class */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__DECISION__DECISION_ENGINE_H */ diff --git a/src/decision/decision_strategy.h b/src/decision/decision_strategy.h index 829ad18a4..6a9353474 100644 --- a/src/decision/decision_strategy.h +++ b/src/decision/decision_strategy.h @@ -25,13 +25,13 @@ #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 { @@ -65,7 +65,7 @@ public: 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 */ diff --git a/src/decision/justification_heuristic.cpp b/src/decision/justification_heuristic.cpp index a313dcf15..f9f9cb7df 100644 --- a/src/decision/justification_heuristic.cpp +++ b/src/decision/justification_heuristic.cpp @@ -28,10 +28,10 @@ #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), @@ -66,7 +66,7 @@ JustificationHeuristic::~JustificationHeuristic() 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; @@ -82,7 +82,9 @@ CVC4::prop::SatLiteral JustificationHeuristic::getNext(bool &stopSearch) 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); @@ -731,4 +733,4 @@ JustificationHeuristic::handleEmbeddedSkolems(TNode node) } } /* namespace decision */ -} /* namespace CVC4 */
\ No newline at end of file +} // namespace CVC5
\ No newline at end of file diff --git a/src/decision/justification_heuristic.h b/src/decision/justification_heuristic.h index 6c1ff3378..9ec61d540 100644 --- a/src/decision/justification_heuristic.h +++ b/src/decision/justification_heuristic.h @@ -37,7 +37,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace decision { class JustificationHeuristic : public ITEDecisionStrategy { @@ -117,84 +117,84 @@ 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 */ diff --git a/src/expr/array_store_all.cpp b/src/expr/array_store_all.cpp index 6d14ac40d..d50921598 100644 --- a/src/expr/array_store_all.cpp +++ b/src/expr/array_store_all.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { ArrayStoreAll::ArrayStoreAll(const TypeNode& type, const Node& value) : d_type(), d_value() @@ -115,4 +115,4 @@ size_t ArrayStoreAllHashFunction::operator()(const ArrayStoreAll& asa) const { * NodeHashFunction()(asa.getValue()); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/array_store_all.h b/src/expr/array_store_all.h index dac967668..974f456ef 100644 --- a/src/expr/array_store_all.h +++ b/src/expr/array_store_all.h @@ -24,8 +24,7 @@ #include <iosfwd> #include <memory> - -namespace CVC4 { +namespace CVC5 { template <bool ref_count> class NodeTemplate; @@ -70,6 +69,6 @@ struct ArrayStoreAllHashFunction size_t operator()(const ArrayStoreAll& asa) const; }; /* struct ArrayStoreAllHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__ARRAY_STORE_ALL_H */ diff --git a/src/expr/ascription_type.cpp b/src/expr/ascription_type.cpp index 6f50568f1..6fecb2978 100644 --- a/src/expr/ascription_type.cpp +++ b/src/expr/ascription_type.cpp @@ -18,7 +18,7 @@ #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { AscriptionType::AscriptionType(TypeNode t) : d_type(new TypeNode(t)) {} @@ -55,4 +55,4 @@ std::ostream& operator<<(std::ostream& out, AscriptionType at) return out; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/ascription_type.h b/src/expr/ascription_type.h index 66f376b18..5b0ff2b71 100644 --- a/src/expr/ascription_type.h +++ b/src/expr/ascription_type.h @@ -22,7 +22,7 @@ #include <iosfwd> #include <memory> -namespace CVC4 { +namespace CVC5 { class TypeNode; @@ -60,6 +60,6 @@ struct AscriptionTypeHashFunction /** An output routine for AscriptionTypes */ std::ostream& operator<<(std::ostream& out, AscriptionType at); -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__ASCRIPTION_TYPE_H */ diff --git a/src/expr/attribute.cpp b/src/expr/attribute.cpp index 5973aab17..fe1bff897 100644 --- a/src/expr/attribute.cpp +++ b/src/expr/attribute.cpp @@ -22,7 +22,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace expr { namespace attr { @@ -114,6 +114,6 @@ void AttributeManager::deleteAttributes(const AttrIdVec& atids) { } } -}/* CVC4::expr::attr namespace */ -}/* CVC4::expr namespace */ -}/* CVC4 namespace */ +} // namespace attr +} // namespace expr +} // namespace CVC5 diff --git a/src/expr/attribute.h b/src/expr/attribute.h index 9a1f4682e..b3a3eb717 100644 --- a/src/expr/attribute.h +++ b/src/expr/attribute.h @@ -32,7 +32,7 @@ #include "expr/attribute_internals.h" #undef CVC4_ATTRIBUTE_H__INCLUDING__ATTRIBUTE_INTERNALS_H -namespace CVC4 { +namespace CVC5 { namespace expr { namespace attr { @@ -218,7 +218,7 @@ public: void debugHook(int debugFlag); }; -}/* CVC4::expr::attr namespace */ +} // namespace attr // MAPPING OF ATTRIBUTE KINDS TO TABLES IN THE ATTRIBUTE MANAGER =============== @@ -318,7 +318,7 @@ struct getTable<std::string, false> { } }; -}/* CVC4::expr::attr namespace */ +} // namespace attr // ATTRIBUTE MANAGER IMPLEMENTATIONS =========================================== @@ -540,9 +540,8 @@ void AttributeManager::reconstructTable(AttrHash<T>& table){ d_inGarbageCollection = false; } - -}/* CVC4::expr::attr namespace */ -}/* CVC4::expr namespace */ +} // namespace attr +} // namespace expr template <class AttrKind> inline typename AttrKind::value_type @@ -622,6 +621,6 @@ NodeManager::setAttribute(TypeNode n, const AttrKind&, d_attrManager->setAttribute(n.d_nv, AttrKind(), value); } -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__EXPR__ATTRIBUTE_H */ diff --git a/src/expr/attribute_internals.h b/src/expr/attribute_internals.h index 271c34d3c..bbd5455be 100644 --- a/src/expr/attribute_internals.h +++ b/src/expr/attribute_internals.h @@ -25,7 +25,7 @@ #include <unordered_map> -namespace CVC4 { +namespace CVC5 { namespace expr { // ATTRIBUTE HASH FUNCTIONS ==================================================== @@ -54,7 +54,7 @@ struct AttrBoolHashFunction { } };/* struct AttrBoolHashFunction */ -}/* CVC4::expr::attr namespace */ +} // namespace attr // ATTRIBUTE TYPE MAPPINGS ===================================================== @@ -131,7 +131,7 @@ struct KindValueToTableValueMapping< static T convertBack(const uint64_t& t) { return static_cast<T>(t); } }; -}/* CVC4::expr::attr namespace */ +} // namespace attr // ATTRIBUTE HASH TABLES ======================================================= @@ -363,7 +363,7 @@ public: } };/* class AttrHash<bool> */ -}/* CVC4::expr::attr namespace */ +} // namespace attr // ATTRIBUTE IDENTIFIER ASSIGNMENT TEMPLATE ==================================== @@ -393,7 +393,7 @@ struct LastAttributeId { } }; -}/* CVC4::expr::attr namespace */ +} // namespace attr // ATTRIBUTE DEFINITION ======================================================== @@ -511,7 +511,7 @@ template <class T, bool context_dep> 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 */ diff --git a/src/expr/attribute_unique_id.h b/src/expr/attribute_unique_id.h index 247e0b1f1..f084baaa1 100644 --- a/src/expr/attribute_unique_id.h +++ b/src/expr/attribute_unique_id.h @@ -21,7 +21,7 @@ // ATTRIBUTE IDs ============================================================ -namespace CVC4 { +namespace CVC5 { namespace expr { namespace attr { @@ -59,8 +59,8 @@ public: 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 diff --git a/src/expr/bound_var_manager.cpp b/src/expr/bound_var_manager.cpp index 36b824c31..ca257d313 100644 --- a/src/expr/bound_var_manager.cpp +++ b/src/expr/bound_var_manager.cpp @@ -16,7 +16,7 @@ #include "expr/node_manager_attributes.h" -namespace CVC4 { +namespace CVC5 { BoundVarManager::BoundVarManager() : d_keepCacheVals(false) {} @@ -53,4 +53,4 @@ Node BoundVarManager::getCacheValue(TNode cv, size_t i) return getCacheValue(cv, getCacheValue(i)); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/bound_var_manager.h b/src/expr/bound_var_manager.h index 16ff97cce..08705f6d2 100644 --- a/src/expr/bound_var_manager.h +++ b/src/expr/bound_var_manager.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { /** * Bound variable manager. @@ -98,6 +98,6 @@ class BoundVarManager std::unordered_set<Node, NodeHashFunction> d_cacheVals; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__BOUND_VAR_MANAGER_H */ diff --git a/src/expr/buffered_proof_generator.cpp b/src/expr/buffered_proof_generator.cpp index b1abee0d0..caf6b0841 100644 --- a/src/expr/buffered_proof_generator.cpp +++ b/src/expr/buffered_proof_generator.cpp @@ -17,7 +17,7 @@ #include "expr/proof.h" #include "expr/proof_node_manager.h" -namespace CVC4 { +namespace CVC5 { BufferedProofGenerator::BufferedProofGenerator(context::Context* c, ProofNodeManager* pnm) @@ -80,4 +80,4 @@ std::shared_ptr<ProofNode> BufferedProofGenerator::getProofFor(Node fact) return cdp.getProofFor(fact); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/buffered_proof_generator.h b/src/expr/buffered_proof_generator.h index 4b46aa56a..db8e50274 100644 --- a/src/expr/buffered_proof_generator.h +++ b/src/expr/buffered_proof_generator.h @@ -20,7 +20,7 @@ #include "context/cdhashmap.h" #include "expr/proof_generator.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; class ProofStep; @@ -57,6 +57,6 @@ class BufferedProofGenerator : public ProofGenerator ProofNodeManager* d_pnm; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__BUFFERED_PROOF_GENERATOR_H */ diff --git a/src/expr/datatype_index.cpp b/src/expr/datatype_index.cpp index 5f9d782ad..2459c86d8 100644 --- a/src/expr/datatype_index.cpp +++ b/src/expr/datatype_index.cpp @@ -20,7 +20,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { DatatypeIndexConstant::DatatypeIndexConstant(uint32_t index) : d_index(index) {} std::ostream& operator<<(std::ostream& out, const DatatypeIndexConstant& dic) @@ -34,4 +34,4 @@ size_t DatatypeIndexConstantHashFunction::operator()( return IntegerHashFunction()(dic.getIndex()); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/datatype_index.h b/src/expr/datatype_index.h index 6020759fb..08d33ca83 100644 --- a/src/expr/datatype_index.h +++ b/src/expr/datatype_index.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC4 { +namespace CVC5 { /* stores an index to Datatype residing in NodeManager */ class DatatypeIndexConstant @@ -64,6 +64,6 @@ struct DatatypeIndexConstantHashFunction size_t operator()(const DatatypeIndexConstant& dic) const; }; /* struct DatatypeIndexConstantHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__DATATYPE_H */ diff --git a/src/expr/dtype.cpp b/src/expr/dtype.cpp index 162afd84a..35ad5ff4c 100644 --- a/src/expr/dtype.cpp +++ b/src/expr/dtype.cpp @@ -19,9 +19,9 @@ #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), @@ -954,4 +954,4 @@ std::ostream& operator<<(std::ostream& out, const DTypeIndexConstant& dic) return out << "index_" << dic.getIndex(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/dtype.h b/src/expr/dtype.h index 18694bf64..5b6ec4a7d 100644 --- a/src/expr/dtype.h +++ b/src/expr/dtype.h @@ -24,7 +24,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { // ----------------------- datatype attributes /** @@ -696,6 +696,6 @@ struct DTypeIndexConstantHashFunction std::ostream& operator<<(std::ostream& os, const DType& dt); -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/expr/dtype_cons.cpp b/src/expr/dtype_cons.cpp index d02435465..089d41637 100644 --- a/src/expr/dtype_cons.cpp +++ b/src/expr/dtype_cons.cpp @@ -18,10 +18,10 @@ #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) @@ -693,4 +693,4 @@ std::ostream& operator<<(std::ostream& os, const DTypeConstructor& ctor) return os; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/dtype_cons.h b/src/expr/dtype_cons.h index dd9fc6a0b..245d461b0 100644 --- a/src/expr/dtype_cons.h +++ b/src/expr/dtype_cons.h @@ -24,7 +24,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { /** * The Node-level representation of a constructor for a datatype, which @@ -371,6 +371,6 @@ struct DTypeConstructorHashFunction std::ostream& operator<<(std::ostream& os, const DTypeConstructor& ctor); -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/expr/dtype_selector.cpp b/src/expr/dtype_selector.cpp index 522e6b4c1..a276c3734 100644 --- a/src/expr/dtype_selector.cpp +++ b/src/expr/dtype_selector.cpp @@ -16,9 +16,9 @@ #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) @@ -83,4 +83,4 @@ std::ostream& operator<<(std::ostream& os, const DTypeSelector& arg) return os; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/dtype_selector.h b/src/expr/dtype_selector.h index b134c7f7d..7404c0c96 100644 --- a/src/expr/dtype_selector.h +++ b/src/expr/dtype_selector.h @@ -21,7 +21,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { class DatatypeConstructorArg; class DType; @@ -90,6 +90,6 @@ class DTypeSelector std::ostream& operator<<(std::ostream& os, const DTypeSelector& arg); -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/expr/emptybag.cpp b/src/expr/emptybag.cpp index d23ccef09..0f7a3a73e 100644 --- a/src/expr/emptybag.cpp +++ b/src/expr/emptybag.cpp @@ -18,7 +18,7 @@ #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& out, const EmptyBag& asa) { @@ -64,4 +64,4 @@ bool EmptyBag::operator<=(const EmptyBag& es) const bool EmptyBag::operator>(const EmptyBag& es) const { return !(*this <= es); } bool EmptyBag::operator>=(const EmptyBag& es) const { return !(*this < es); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/emptybag.h b/src/expr/emptybag.h index e9763108e..59060eaa8 100644 --- a/src/expr/emptybag.h +++ b/src/expr/emptybag.h @@ -20,7 +20,7 @@ #include <iosfwd> #include <memory> -namespace CVC4 { +namespace CVC5 { class TypeNode; @@ -58,6 +58,6 @@ struct EmptyBagHashFunction size_t operator()(const EmptyBag& es) const; }; /* struct EmptyBagHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EMPTY_BAG_H */ diff --git a/src/expr/emptyset.cpp b/src/expr/emptyset.cpp index 97a986054..4a0bd4e51 100644 --- a/src/expr/emptyset.cpp +++ b/src/expr/emptyset.cpp @@ -21,7 +21,7 @@ #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& out, const EmptySet& asa) { return out << "emptyset(" << asa.getType() << ')'; @@ -64,4 +64,4 @@ bool EmptySet::operator<=(const EmptySet& es) const bool EmptySet::operator>(const EmptySet& es) const { return !(*this <= es); } bool EmptySet::operator>=(const EmptySet& es) const { return !(*this < es); } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/expr/emptyset.h b/src/expr/emptyset.h index 1c441e519..febb4e111 100644 --- a/src/expr/emptyset.h +++ b/src/expr/emptyset.h @@ -23,7 +23,7 @@ #include <iosfwd> #include <memory> -namespace CVC4 { +namespace CVC5 { class TypeNode; @@ -60,6 +60,6 @@ struct EmptySetHashFunction size_t operator()(const EmptySet& es) const; }; /* struct EmptySetHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EMPTY_SET_H */ diff --git a/src/expr/expr_iomanip.cpp b/src/expr/expr_iomanip.cpp index 82ac83d33..4aec28b85 100644 --- a/src/expr/expr_iomanip.cpp +++ b/src/expr/expr_iomanip.cpp @@ -22,7 +22,7 @@ #include "options/options.h" #include "options/expr_options.h" -namespace CVC4 { +namespace CVC5 { namespace expr { const int ExprSetDepth::s_iosIndex = std::ios_base::xalloc(); @@ -122,6 +122,5 @@ std::ostream& operator<<(std::ostream& out, ExprSetDepth sd) { return out; } - -}/* namespace CVC4::expr */ -}/* namespace CVC4 */ +} // namespace expr +} // namespace CVC5 diff --git a/src/expr/expr_iomanip.h b/src/expr/expr_iomanip.h index 5306e2a2b..c40840cd4 100644 --- a/src/expr/expr_iomanip.h +++ b/src/expr/expr_iomanip.h @@ -21,7 +21,7 @@ #include <iosfwd> -namespace CVC4 { +namespace CVC5 { namespace expr { /** @@ -171,8 +171,8 @@ std::ostream& operator<<(std::ostream& out, ExprDag d); */ std::ostream& operator<<(std::ostream& out, ExprSetDepth sd); -}/* namespace CVC4::expr */ +} // namespace expr -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__EXPR__EXPR_IOMANIP_H */ diff --git a/src/expr/kind_map.h b/src/expr/kind_map.h index d118b7077..e6f6f9ca0 100644 --- a/src/expr/kind_map.h +++ b/src/expr/kind_map.h @@ -25,7 +25,7 @@ #include "base/check.h" #include "expr/kind.h" -namespace CVC4 { +namespace CVC5 { /** A very simple bitmap for Kinds */ class KindMap @@ -51,6 +51,6 @@ class KindMap std::bitset<kind::LAST_KIND> d_bits; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__KIND_MAP_H */ diff --git a/src/expr/kind_template.cpp b/src/expr/kind_template.cpp index 0aff7a79b..cbe979642 100644 --- a/src/expr/kind_template.cpp +++ b/src/expr/kind_template.cpp @@ -19,12 +19,12 @@ #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) { @@ -37,7 +37,7 @@ const char* toString(CVC4::Kind k) } } -std::ostream& operator<<(std::ostream& out, CVC4::Kind k) +std::ostream& operator<<(std::ostream& out, CVC5::Kind k) { out << toString(k); return out; @@ -47,7 +47,8 @@ std::ostream& operator<<(std::ostream& out, CVC4::Kind k) * 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: @@ -60,13 +61,14 @@ bool isAssociative(::CVC4::Kind k) { } } -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) { @@ -80,7 +82,8 @@ ${type_constant_descriptions} namespace theory { -TheoryId kindToTheoryId(::CVC4::Kind k) { +TheoryId kindToTheoryId(::CVC5::Kind k) +{ switch(k) { case kind::UNDEFINED_KIND: case kind::NULL_EXPR: @@ -92,7 +95,7 @@ ${kind_to_theory_id} throw IllegalArgumentException("", "k", __PRETTY_FUNCTION__, "bad kind"); } -TheoryId typeConstantToTheoryId(::CVC4::TypeConstant typeConstant) +TheoryId typeConstantToTheoryId(::CVC5::TypeConstant typeConstant) { switch (typeConstant) { @@ -103,5 +106,5 @@ ${type_constant_to_theory_id} "", "k", __PRETTY_FUNCTION__, "bad type constant"); } -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/expr/kind_template.h b/src/expr/kind_template.h index ccb7656a9..4661cfa15 100644 --- a/src/expr/kind_template.h +++ b/src/expr/kind_template.h @@ -24,7 +24,7 @@ #include "base/exception.h" #include "theory/theory_id.h" -namespace CVC4 { +namespace CVC5 { namespace kind { enum Kind_t @@ -35,11 +35,11 @@ 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 { @@ -52,7 +52,7 @@ 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. @@ -61,22 +61,20 @@ const char* toString(CVC4::Kind k); * @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. @@ -99,11 +97,11 @@ std::ostream& operator<<(std::ostream& out, TypeConstant typeConstant); 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 */ diff --git a/src/expr/lazy_proof.cpp b/src/expr/lazy_proof.cpp index 3f333eeab..701cc55dc 100644 --- a/src/expr/lazy_proof.cpp +++ b/src/expr/lazy_proof.cpp @@ -18,9 +18,9 @@ #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, @@ -228,4 +228,4 @@ bool LazyCDProof::hasGenerator(Node fact) const return it != d_gens.end(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/lazy_proof.h b/src/expr/lazy_proof.h index 989fd55dc..5c0de5c5b 100644 --- a/src/expr/lazy_proof.h +++ b/src/expr/lazy_proof.h @@ -19,7 +19,7 @@ #include "expr/proof.h" -namespace CVC4 { +namespace CVC5 { class ProofGenerator; class ProofNodeManager; @@ -105,6 +105,6 @@ class LazyCDProof : public CDProof ProofGenerator* getGeneratorFor(Node fact, bool& isSym); }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__LAZY_PROOF_H */ diff --git a/src/expr/lazy_proof_chain.cpp b/src/expr/lazy_proof_chain.cpp index e6fba747e..3651e53e1 100644 --- a/src/expr/lazy_proof_chain.cpp +++ b/src/expr/lazy_proof_chain.cpp @@ -21,7 +21,7 @@ #include "expr/proof_node_manager.h" #include "options/proof_options.h" -namespace CVC4 { +namespace CVC5 { LazyCDProofChain::LazyCDProofChain(ProofNodeManager* pnm, bool cyclic, @@ -317,4 +317,4 @@ ProofGenerator* LazyCDProofChain::getGeneratorForInternal(Node fact, bool& rec) std::string LazyCDProofChain::identify() const { return "LazyCDProofChain"; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/lazy_proof_chain.h b/src/expr/lazy_proof_chain.h index 4c21eea99..7482e3ca4 100644 --- a/src/expr/lazy_proof_chain.h +++ b/src/expr/lazy_proof_chain.h @@ -22,7 +22,7 @@ #include "context/cdhashmap.h" #include "expr/proof_generator.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; @@ -148,6 +148,6 @@ class LazyCDProofChain : public ProofGenerator ProofGenerator* d_defGen; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__LAZY_PROOF_CHAIN_H */ diff --git a/src/expr/match_trie.cpp b/src/expr/match_trie.cpp index f2465e030..d3adeb50e 100644 --- a/src/expr/match_trie.cpp +++ b/src/expr/match_trie.cpp @@ -14,9 +14,9 @@ #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) @@ -196,4 +196,4 @@ void MatchTrie::clear() } } // namespace expr -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/match_trie.h b/src/expr/match_trie.h index 976b70fba..45ff0c0c7 100644 --- a/src/expr/match_trie.h +++ b/src/expr/match_trie.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace expr { /** A virtual class for notifications regarding matches. */ @@ -77,6 +77,6 @@ class MatchTrie }; } // namespace expr -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__CANDIDATE_REWRITE_FILTER_H */ diff --git a/src/expr/metakind_template.cpp b/src/expr/metakind_template.cpp index 6e76c0da3..2f147b8b4 100644 --- a/src/expr/metakind_template.cpp +++ b/src/expr/metakind_template.cpp @@ -19,7 +19,7 @@ #include <iostream> -namespace CVC4 { +namespace CVC5 { namespace kind { /** @@ -41,31 +41,32 @@ ${metakind_kinds} 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; } @@ -75,7 +76,7 @@ bool NodeValueCompare::compare(const ::CVC4::expr::NodeValue* nv1, switch (nv1->d_kind) { ${metakind_compares} - default: Unhandled() << ::CVC4::expr::NodeValue::dKindToKind(nv1->d_kind); +default: Unhandled() << ::CVC5::expr::NodeValue::dKindToKind(nv1->d_kind); } } @@ -83,9 +84,9 @@ ${metakind_compares} 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)) { @@ -98,19 +99,20 @@ ${metakind_compares} 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); } } @@ -134,20 +136,21 @@ void NodeValueConstPrinter::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) +{ 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 */ @@ -159,7 +162,7 @@ ${metakind_lbchildren} return lbs[k]; } -uint32_t getMaxArityForKind(::CVC4::Kind k) +uint32_t getMaxArityForKind(::CVC5::Kind k) { static const unsigned ubs[] = { 0, /* NULL_EXPR */ @@ -177,7 +180,8 @@ ${metakind_ubchildren} * 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) { @@ -192,5 +196,5 @@ ${metakind_operatorKinds} }; } -}/* CVC4::kind namespace */ -}/* CVC4 namespace */ +} // namespace kind +} // namespace CVC5 diff --git a/src/expr/metakind_template.h b/src/expr/metakind_template.h index 42b7da248..ba1b47b4a 100644 --- a/src/expr/metakind_template.h +++ b/src/expr/metakind_template.h @@ -24,11 +24,11 @@ #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 { @@ -74,16 +74,16 @@ struct ConstantMapReverse; */ 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 */ /** @@ -102,29 +102,29 @@ enum MetaKind_t { 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" @@ -134,18 +134,19 @@ ${metakind_includes} #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) { @@ -163,7 +164,9 @@ inline bool NodeValueConstCompare<k, pool>::compare(const ::CVC4::expr::NodeValu } 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(); } @@ -171,8 +174,7 @@ inline size_t NodeValueConstCompare<k, pool>::constHash(const ::CVC4::expr::Node ${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); }; @@ -185,24 +187,24 @@ struct NodeValueConstPrinter { * 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 */ diff --git a/src/expr/mkexpr b/src/expr/mkexpr index 58531cba4..cc5162fef 100755 --- a/src/expr/mkexpr +++ b/src/expr/mkexpr @@ -92,9 +92,9 @@ function theory { 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 } @@ -226,7 +226,7 @@ template <> $2 const & Expr::getConst< $2 >() const; " 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 >(); } " diff --git a/src/expr/mkkind b/src/expr/mkkind index 55276549a..3b987746a 100755 --- a/src/expr/mkkind +++ b/src/expr/mkkind @@ -97,9 +97,9 @@ function theory { 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" diff --git a/src/expr/mkmetakind b/src/expr/mkmetakind index 9d2f0a475..b88a70c71 100755 --- a/src/expr/mkmetakind +++ b/src/expr/mkmetakind @@ -76,9 +76,9 @@ function theory { 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 @@ -211,12 +211,12 @@ function constant { # 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 @@ -233,13 +233,13 @@ $2 const& NodeValue::getConst< $2 >() const; 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*\" @@ -250,7 +250,7 @@ struct ConstantMapReverse< ::CVC4::kind::$1 > { 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 diff --git a/src/expr/node.cpp b/src/expr/node.cpp index 59d002631..fa2a8860c 100644 --- a/src/expr/node.cpp +++ b/src/expr/node.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { TypeCheckingExceptionPrivate::TypeCheckingExceptionPrivate(TNode node, std::string message) @@ -110,4 +110,4 @@ bool NodeTemplate<ref_count>::isConst() const { template bool NodeTemplate<true>::isConst() const; template bool NodeTemplate<false>::isConst() const; -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/expr/node.h b/src/expr/node.h index 9e485ae78..291c2e538 100644 --- a/src/expr/node.h +++ b/src/expr/node.h @@ -41,7 +41,7 @@ #include "util/hash.h" #include "util/utility.h" -namespace CVC4 { +namespace CVC5 { class TypeNode; class NodeManager; @@ -138,16 +138,16 @@ class NodeValue; 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 { @@ -199,10 +199,10 @@ class NodeTemplate { 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 @@ -951,12 +951,12 @@ std::ostream& operator<<( 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(); @@ -986,7 +986,7 @@ template <class AttrKind> 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(); @@ -999,7 +999,7 @@ template <class AttrKind> 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(); @@ -1012,7 +1012,7 @@ template <class AttrKind> 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(); @@ -1025,7 +1025,7 @@ template <class AttrKind> 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(); @@ -1225,7 +1225,7 @@ template <bool ref_count> 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(); @@ -1255,7 +1255,7 @@ template <bool ref_count> 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(); @@ -1491,6 +1491,6 @@ static void __attribute__((used)) debugPrintRawTNode(const NodeTemplate<false>& } #endif /* CVC4_DEBUG */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__NODE_H */ diff --git a/src/expr/node_algorithm.cpp b/src/expr/node_algorithm.cpp index 1ec6c7f3a..318b7c85b 100644 --- a/src/expr/node_algorithm.cpp +++ b/src/expr/node_algorithm.cpp @@ -20,7 +20,7 @@ #include "expr/attribute.h" #include "expr/dtype.h" -namespace CVC4 { +namespace CVC5 { namespace expr { bool hasSubterm(TNode n, TNode t, bool strict) @@ -764,4 +764,4 @@ bool match(Node x, } } // namespace expr -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/node_algorithm.h b/src/expr/node_algorithm.h index e7d71ce3a..ca1ee2e39 100644 --- a/src/expr/node_algorithm.h +++ b/src/expr/node_algorithm.h @@ -27,7 +27,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { namespace expr { /** @@ -235,6 +235,6 @@ bool match(Node n1, std::unordered_map<Node, Node, NodeHashFunction>& subs); } // namespace expr -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/expr/node_builder.h b/src/expr/node_builder.h index 91b378c5f..724e03451 100644 --- a/src/expr/node_builder.h +++ b/src/expr/node_builder.h @@ -160,14 +160,14 @@ #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" @@ -175,7 +175,7 @@ namespace CVC4 { #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.. @@ -729,7 +729,7 @@ public: };/* 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 @@ -741,7 +741,7 @@ public: #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) { @@ -1324,6 +1324,6 @@ std::ostream& operator<<(std::ostream& out, const NodeBuilder<nchild_thresh>& nb return out << *nb.d_nv; } -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__NODE_BUILDER_H */ diff --git a/src/expr/node_manager.cpp b/src/expr/node_manager.cpp index a5329147b..370f0fb4c 100644 --- a/src/expr/node_manager.cpp +++ b/src/expr/node_manager.cpp @@ -35,9 +35,9 @@ #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; @@ -87,7 +87,7 @@ struct NVReclaim { 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; @@ -373,7 +373,7 @@ void NodeManager::reclaimZombies() { 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 @@ -678,7 +678,7 @@ std::vector<TypeNode> NodeManager::mkMutualDatatypeTypes( << "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"; } @@ -1170,4 +1170,4 @@ Kind NodeManager::getKindForFunction(TNode fun) return kind::UNDEFINED_KIND; } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/expr/node_manager.h b/src/expr/node_manager.h index 52ce096d5..aeea179d4 100644 --- a/src/expr/node_manager.h +++ b/src/expr/node_manager.h @@ -35,7 +35,7 @@ #include "expr/metakind.h" #include "expr/node_value.h" -namespace CVC4 { +namespace CVC5 { namespace api { class Solver; @@ -51,10 +51,10 @@ namespace expr { 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 @@ -163,7 +163,7 @@ class NodeManager * 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]; @@ -660,7 +660,7 @@ class NodeManager /** * 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, @@ -1203,7 +1203,7 @@ inline void NodeManager::poolRemove(expr::NodeValue* nv) { d_nodeValuePool.erase(nv);// FIXME multithreading } -}/* CVC4 namespace */ +} // namespace CVC5 #define CVC4__NODE_MANAGER_NEEDS_CONSTANT_MAP #include "expr/metakind.h" @@ -1211,7 +1211,7 @@ inline void NodeManager::poolRemove(expr::NodeValue* nv) { #include "expr/node_builder.h" -namespace CVC4 { +namespace CVC5 { // general expression-builders @@ -1577,6 +1577,6 @@ NodeClass NodeManager::mkConstInternal(const T& val) { return NodeClass(nv); } -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__NODE_MANAGER_H */ diff --git a/src/expr/node_manager_attributes.h b/src/expr/node_manager_attributes.h index 2add5a314..b7f6319eb 100644 --- a/src/expr/node_manager_attributes.h +++ b/src/expr/node_manager_attributes.h @@ -19,7 +19,7 @@ #include "expr/attribute.h" -namespace CVC4 { +namespace CVC5 { namespace expr { // Definition of an attribute for the variable name. @@ -29,12 +29,12 @@ namespace attr { 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 diff --git a/src/expr/node_self_iterator.h b/src/expr/node_self_iterator.h index 475e0a122..831eace65 100644 --- a/src/expr/node_self_iterator.h +++ b/src/expr/node_self_iterator.h @@ -24,7 +24,7 @@ #include "base/check.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace expr { class NodeSelfIterator : public std::iterator<std::input_iterator_tag, Node> { @@ -122,7 +122,7 @@ inline bool NodeSelfIterator::operator!=(NodeSelfIterator i) const { return !(*this == i); } -}/* CVC4::expr namespace */ -}/* CVC4 namespace */ +} // namespace expr +} // namespace CVC5 #endif /* CVC4__EXPR__NODE_SELF_ITERATOR_H */ diff --git a/src/expr/node_traversal.cpp b/src/expr/node_traversal.cpp index f3b4c2ede..c7d3ab3f8 100644 --- a/src/expr/node_traversal.cpp +++ b/src/expr/node_traversal.cpp @@ -16,7 +16,7 @@ #include <functional> -namespace CVC4 { +namespace CVC5 { NodeDfsIterator::NodeDfsIterator(TNode n, VisitOrder order, @@ -156,4 +156,4 @@ NodeDfsIterator NodeDfsIterable::end() const return NodeDfsIterator(d_order); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/node_traversal.h b/src/expr/node_traversal.h index 1f3b1f563..934ec6bd8 100644 --- a/src/expr/node_traversal.h +++ b/src/expr/node_traversal.h @@ -23,7 +23,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { /** * Enum that represents an order in which nodes are visited. @@ -144,6 +144,6 @@ class NodeDfsIterable std::function<bool(TNode)> d_skipIf; }; -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__EXPR__NODE_TRAVERSAL_H diff --git a/src/expr/node_trie.cpp b/src/expr/node_trie.cpp index f02035c43..195011c1f 100644 --- a/src/expr/node_trie.cpp +++ b/src/expr/node_trie.cpp @@ -14,7 +14,7 @@ #include "expr/node_trie.h" -namespace CVC4 { +namespace CVC5 { namespace theory { template <bool ref_count> @@ -92,4 +92,4 @@ template void NodeTemplateTrie<true>::debugPrint(const char* c, unsigned depth) const; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/node_trie.h b/src/expr/node_trie.h index 81529f38e..f765105d3 100644 --- a/src/expr/node_trie.h +++ b/src/expr/node_trie.h @@ -20,7 +20,7 @@ #include <map> #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** NodeTemplate trie class @@ -107,6 +107,6 @@ typedef NodeTemplateTrie<true> NodeTrie; typedef NodeTemplateTrie<false> TNodeTrie; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__NODE_TRIE_H */ diff --git a/src/expr/node_value.cpp b/src/expr/node_value.cpp index dc682a9fb..027c15a0a 100644 --- a/src/expr/node_value.cpp +++ b/src/expr/node_value.cpp @@ -31,7 +31,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace expr { string NodeValue::toString() const { @@ -94,5 +94,5 @@ NodeValue::iterator<NodeTemplate<false> > operator+( return i + p; } -} /* CVC4::expr namespace */ -} /* CVC4 namespace */ +} // namespace expr +} // namespace CVC5 diff --git a/src/expr/node_value.h b/src/expr/node_value.h index d6b6d3c45..ecc054a75 100644 --- a/src/expr/node_value.h +++ b/src/expr/node_value.h @@ -32,7 +32,7 @@ #include "expr/kind.h" #include "options/language.h" -namespace CVC4 { +namespace CVC5 { template <bool ref_count> class NodeTemplate; class TypeNode; @@ -45,15 +45,15 @@ namespace expr { 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 { @@ -63,19 +63,19 @@ 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; @@ -395,12 +395,12 @@ struct NodeValueIDEquality { 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) : @@ -496,12 +496,12 @@ inline NodeValue* NodeValue::getChild(int i) const { 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> @@ -517,7 +517,7 @@ inline std::ostream& operator<<(std::ostream& out, const NodeValue& nv) { return out; } -}/* CVC4::expr namespace */ +} // namespace expr #ifdef CVC4_DEBUG /** @@ -545,6 +545,6 @@ static void __attribute__((used)) debugPrintRawNodeValue(const expr::NodeValue* } #endif /* CVC4_DEBUG */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__EXPR__NODE_VALUE_H */ diff --git a/src/expr/node_visitor.h b/src/expr/node_visitor.h index dcf8e38e0..a3e24772a 100644 --- a/src/expr/node_visitor.h +++ b/src/expr/node_visitor.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { /** * Traverses the nodes reverse-topologically (children before parents), @@ -123,4 +123,4 @@ public: template <typename Visitor> thread_local bool NodeVisitor<Visitor>::s_inRun = false; -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/expr/proof.cpp b/src/expr/proof.cpp index e3c70590c..a55b3c69a 100644 --- a/src/expr/proof.cpp +++ b/src/expr/proof.cpp @@ -18,9 +18,9 @@ #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, @@ -455,4 +455,4 @@ Node CDProof::getSymmFact(TNode f) std::string CDProof::identify() const { return d_name; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/proof.h b/src/expr/proof.h index e676731ea..164880cea 100644 --- a/src/expr/proof.h +++ b/src/expr/proof.h @@ -24,7 +24,7 @@ #include "expr/proof_generator.h" #include "expr/proof_step_buffer.h" -namespace CVC4 { +namespace CVC5 { class ProofNode; class ProofNodeManager; @@ -273,6 +273,6 @@ class CDProof : public ProofGenerator void notifyNewProof(Node expected); }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__PROOF_MANAGER_H */ diff --git a/src/expr/proof_checker.cpp b/src/expr/proof_checker.cpp index bcff07c30..b5955e991 100644 --- a/src/expr/proof_checker.cpp +++ b/src/expr/proof_checker.cpp @@ -19,9 +19,9 @@ #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, @@ -347,4 +347,4 @@ bool ProofChecker::isPedanticFailure(PfRule id, return false; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/proof_checker.h b/src/expr/proof_checker.h index a84f17c28..edb0fec3a 100644 --- a/src/expr/proof_checker.h +++ b/src/expr/proof_checker.h @@ -24,7 +24,7 @@ #include "util/statistics_registry.h" #include "util/stats_histogram.h" -namespace CVC4 { +namespace CVC5 { class ProofChecker; class ProofNode; @@ -202,6 +202,6 @@ class ProofChecker bool enableOutput); }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__PROOF_CHECKER_H */ diff --git a/src/expr/proof_ensure_closed.cpp b/src/expr/proof_ensure_closed.cpp index e4a59c8f0..487c52bc6 100644 --- a/src/expr/proof_ensure_closed.cpp +++ b/src/expr/proof_ensure_closed.cpp @@ -22,7 +22,7 @@ #include "options/proof_options.h" #include "options/smt_options.h" -namespace CVC4 { +namespace CVC5 { /** * Ensure closed with respect to assumptions, internal version, which @@ -179,4 +179,4 @@ void pfnEnsureClosedWrt(ProofNode* pn, ensureClosedWrtInternal(Node::null(), nullptr, pn, assumps, c, ctx, false); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/proof_ensure_closed.h b/src/expr/proof_ensure_closed.h index dd137343a..40143f814 100644 --- a/src/expr/proof_ensure_closed.h +++ b/src/expr/proof_ensure_closed.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class ProofGenerator; class ProofNode; @@ -67,6 +67,6 @@ void pfnEnsureClosedWrt(ProofNode* pn, const std::vector<Node>& assumps, const char* c, const char* ctx); -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__PROOF_ENSURE_CLOSED_H */ diff --git a/src/expr/proof_generator.cpp b/src/expr/proof_generator.cpp index 53bc54d7a..102435cea 100644 --- a/src/expr/proof_generator.cpp +++ b/src/expr/proof_generator.cpp @@ -21,7 +21,7 @@ #include "expr/proof_node_algorithm.h" #include "options/smt_options.h" -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& out, CDPOverwrite opol) { @@ -73,4 +73,4 @@ bool ProofGenerator::addProofTo(Node f, return false; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/proof_generator.h b/src/expr/proof_generator.h index 497e89d7a..446cb2c83 100644 --- a/src/expr/proof_generator.h +++ b/src/expr/proof_generator.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class CDProof; class ProofNode; @@ -107,6 +107,6 @@ class ProofGenerator virtual std::string identify() const = 0; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__PROOF_GENERATOR_H */ diff --git a/src/expr/proof_node.cpp b/src/expr/proof_node.cpp index 755a37643..923bdeacd 100644 --- a/src/expr/proof_node.cpp +++ b/src/expr/proof_node.cpp @@ -17,7 +17,7 @@ #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, @@ -81,4 +81,4 @@ std::ostream& operator<<(std::ostream& out, const ProofNode& pn) return out; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/proof_node.h b/src/expr/proof_node.h index f7b323018..67600e2d0 100644 --- a/src/expr/proof_node.h +++ b/src/expr/proof_node.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "expr/proof_rule.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; class ProofNode; @@ -141,6 +141,6 @@ inline size_t ProofNodeHashFunction::operator()( */ std::ostream& operator<<(std::ostream& out, const ProofNode& pn); -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__PROOF_NODE_H */ diff --git a/src/expr/proof_node_algorithm.cpp b/src/expr/proof_node_algorithm.cpp index 90b1e9030..142a9b37f 100644 --- a/src/expr/proof_node_algorithm.cpp +++ b/src/expr/proof_node_algorithm.cpp @@ -16,7 +16,7 @@ #include "expr/proof_node.h" -namespace CVC4 { +namespace CVC5 { namespace expr { void getFreeAssumptions(ProofNode* pn, std::vector<Node>& assump) @@ -172,4 +172,4 @@ bool containsSubproof(ProofNode* pn, } } // namespace expr -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/proof_node_algorithm.h b/src/expr/proof_node_algorithm.h index 9106bb36f..9266c7251 100644 --- a/src/expr/proof_node_algorithm.h +++ b/src/expr/proof_node_algorithm.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class ProofNode; @@ -70,6 +70,6 @@ bool containsSubproof(ProofNode* pn, std::unordered_set<const ProofNode*>& visited); } // namespace expr -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__PROOF_NODE_ALGORITHM_H */ diff --git a/src/expr/proof_node_manager.cpp b/src/expr/proof_node_manager.cpp index a018db4c0..ceb9d4eac 100644 --- a/src/expr/proof_node_manager.cpp +++ b/src/expr/proof_node_manager.cpp @@ -23,9 +23,9 @@ #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) @@ -356,4 +356,4 @@ bool ProofNodeManager::updateNodeInternal( return true; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/proof_node_manager.h b/src/expr/proof_node_manager.h index 434cffe28..8e019818d 100644 --- a/src/expr/proof_node_manager.h +++ b/src/expr/proof_node_manager.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "expr/proof_rule.h" -namespace CVC4 { +namespace CVC5 { class ProofChecker; class ProofNode; @@ -192,6 +192,6 @@ class ProofNodeManager bool needsCheck); }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__PROOF_NODE_H */ diff --git a/src/expr/proof_node_to_sexpr.cpp b/src/expr/proof_node_to_sexpr.cpp index c298dafe6..7468ecb5a 100644 --- a/src/expr/proof_node_to_sexpr.cpp +++ b/src/expr/proof_node_to_sexpr.cpp @@ -20,9 +20,9 @@ #include "expr/proof_node.h" #include "options/proof_options.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { ProofNodeToSExpr::ProofNodeToSExpr() { @@ -144,4 +144,4 @@ Node ProofNodeToSExpr::getOrMkNodeVariable(Node n) return var; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/proof_node_to_sexpr.h b/src/expr/proof_node_to_sexpr.h index cf2e86263..8da094da2 100644 --- a/src/expr/proof_node_to_sexpr.h +++ b/src/expr/proof_node_to_sexpr.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "expr/proof_rule.h" -namespace CVC4 { +namespace CVC5 { class ProofNode; @@ -64,6 +64,6 @@ class ProofNodeToSExpr Node getOrMkNodeVariable(Node n); }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__PROOF_RULE_H */ diff --git a/src/expr/proof_node_updater.cpp b/src/expr/proof_node_updater.cpp index cacadc815..4c1883e93 100644 --- a/src/expr/proof_node_updater.cpp +++ b/src/expr/proof_node_updater.cpp @@ -19,7 +19,7 @@ #include "expr/proof_node_algorithm.h" #include "expr/proof_node_manager.h" -namespace CVC4 { +namespace CVC5 { ProofNodeUpdaterCallback::ProofNodeUpdaterCallback() {} ProofNodeUpdaterCallback::~ProofNodeUpdaterCallback() {} @@ -261,4 +261,4 @@ void ProofNodeUpdater::setDebugFreeAssumptions( d_debugFreeAssumps = true; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/proof_node_updater.h b/src/expr/proof_node_updater.h index 693168a25..5a22af61a 100644 --- a/src/expr/proof_node_updater.h +++ b/src/expr/proof_node_updater.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "expr/proof_node.h" -namespace CVC4 { +namespace CVC5 { class CDProof; class ProofNode; @@ -155,6 +155,6 @@ class ProofNodeUpdater bool d_autoSym; }; -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/expr/proof_rule.cpp b/src/expr/proof_rule.cpp index 579b06c76..1323520c3 100644 --- a/src/expr/proof_rule.cpp +++ b/src/expr/proof_rule.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC4 { +namespace CVC5 { const char* toString(PfRule id) { @@ -210,4 +210,4 @@ size_t PfRuleHashFunction::operator()(PfRule id) const return static_cast<size_t>(id); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/proof_rule.h b/src/expr/proof_rule.h index efa673409..95f97ae44 100644 --- a/src/expr/proof_rule.h +++ b/src/expr/proof_rule.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC4 { +namespace CVC5 { /** * An enumeration for proof rules. This enumeration is analogous to Kind for @@ -1379,6 +1379,6 @@ struct PfRuleHashFunction size_t operator()(PfRule id) const; }; /* struct PfRuleHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__PROOF_RULE_H */ diff --git a/src/expr/proof_set.h b/src/expr/proof_set.h index a45a0f1f8..ccfac350a 100644 --- a/src/expr/proof_set.h +++ b/src/expr/proof_set.h @@ -23,7 +23,7 @@ #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 @@ -70,6 +70,6 @@ class CDProofSet std::string d_namePrefix; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__LAZY_PROOF_SET_H */ diff --git a/src/expr/proof_step_buffer.cpp b/src/expr/proof_step_buffer.cpp index 51aa9f098..23f0f5997 100644 --- a/src/expr/proof_step_buffer.cpp +++ b/src/expr/proof_step_buffer.cpp @@ -16,9 +16,9 @@ #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, @@ -108,4 +108,4 @@ const std::vector<std::pair<Node, ProofStep>>& ProofStepBuffer::getSteps() const void ProofStepBuffer::clear() { d_steps.clear(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/proof_step_buffer.h b/src/expr/proof_step_buffer.h index 0b4b8552b..b78d1d605 100644 --- a/src/expr/proof_step_buffer.h +++ b/src/expr/proof_step_buffer.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "expr/proof_rule.h" -namespace CVC4 { +namespace CVC5 { class ProofChecker; @@ -92,6 +92,6 @@ class ProofStepBuffer std::vector<std::pair<Node, ProofStep>> d_steps; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__PROOF_STEP_BUFFER_H */ diff --git a/src/expr/record.cpp b/src/expr/record.cpp index ed4e05567..affd2615c 100644 --- a/src/expr/record.cpp +++ b/src/expr/record.cpp @@ -19,11 +19,10 @@ #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 diff --git a/src/expr/record.h b/src/expr/record.h index a9201fca3..d4b41b9b9 100644 --- a/src/expr/record.h +++ b/src/expr/record.h @@ -25,13 +25,13 @@ #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 @@ -56,6 +56,6 @@ std::ostream& operator<<(std::ostream& out, const RecordUpdate& t); using Record = std::vector<std::pair<std::string, TypeNode>>; -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__RECORD_H */ diff --git a/src/expr/sequence.cpp b/src/expr/sequence.cpp index b02b68815..90b57f58d 100644 --- a/src/expr/sequence.cpp +++ b/src/expr/sequence.cpp @@ -22,7 +22,7 @@ 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) @@ -378,4 +378,4 @@ size_t SequenceHashFunction::operator()(const Sequence& s) const return ret; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/sequence.h b/src/expr/sequence.h index 1c0b1fbb9..461adb667 100644 --- a/src/expr/sequence.h +++ b/src/expr/sequence.h @@ -20,7 +20,7 @@ #include <memory> #include <vector> -namespace CVC4 { +namespace CVC5 { template <bool ref_count> class NodeTemplate; @@ -36,7 +36,7 @@ class Sequence 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; @@ -173,6 +173,6 @@ struct SequenceHashFunction std::ostream& operator<<(std::ostream& os, const Sequence& s); -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__SEQUENCE_H */ diff --git a/src/expr/skolem_manager.cpp b/src/expr/skolem_manager.cpp index c65180ed3..2b04c0755 100644 --- a/src/expr/skolem_manager.cpp +++ b/src/expr/skolem_manager.cpp @@ -18,9 +18,9 @@ #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. @@ -298,4 +298,4 @@ Node SkolemManager::mkSkolemInternal(Node w, return k; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/skolem_manager.h b/src/expr/skolem_manager.h index 44a8f87c2..1078bc11f 100644 --- a/src/expr/skolem_manager.h +++ b/src/expr/skolem_manager.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class ProofGenerator; @@ -234,6 +234,6 @@ class SkolemManager int flags = NodeManager::SKOLEM_DEFAULT); }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__PROOF_SKOLEM_CACHE_H */ diff --git a/src/expr/subs.cpp b/src/expr/subs.cpp index 0434cacf3..897c6fdba 100644 --- a/src/expr/subs.cpp +++ b/src/expr/subs.cpp @@ -18,7 +18,7 @@ #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { bool Subs::empty() const { return d_vars.empty(); } @@ -176,4 +176,4 @@ std::ostream& operator<<(std::ostream& out, const Subs& s) return out; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/subs.h b/src/expr/subs.h index 86c7d1758..c2854bf36 100644 --- a/src/expr/subs.h +++ b/src/expr/subs.h @@ -19,7 +19,7 @@ #include <vector> #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { /** * Helper substitution class. Stores a substitution in parallel vectors @@ -80,6 +80,6 @@ class Subs */ std::ostream& operator<<(std::ostream& out, const Subs& s); -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__SUBS_H */ diff --git a/src/expr/sygus_datatype.cpp b/src/expr/sygus_datatype.cpp index d2e845452..352dd157a 100644 --- a/src/expr/sygus_datatype.cpp +++ b/src/expr/sygus_datatype.cpp @@ -16,9 +16,9 @@ #include <sstream> -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { SygusDatatype::SygusDatatype(const std::string& name) : d_dt(DType(name)) {} @@ -99,4 +99,4 @@ const DType& SygusDatatype::getDatatype() const bool SygusDatatype::isInitialized() const { return d_dt.isSygus(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/sygus_datatype.h b/src/expr/sygus_datatype.h index 1350e9e57..f4635bdb3 100644 --- a/src/expr/sygus_datatype.h +++ b/src/expr/sygus_datatype.h @@ -24,7 +24,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { /** Attribute true for variables that represent any constant */ struct SygusAnyConstAttributeId @@ -134,6 +134,6 @@ class SygusDatatype DType d_dt; }; -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/expr/symbol_manager.cpp b/src/expr/symbol_manager.cpp index 0fa2db1d4..1e99f4a68 100644 --- a/src/expr/symbol_manager.cpp +++ b/src/expr/symbol_manager.cpp @@ -19,9 +19,9 @@ #include "context/cdlist.h" #include "context/cdo.h" -using namespace CVC4::context; +using namespace CVC5::context; -namespace CVC4 { +namespace CVC5 { // ---------------------------------------------- SymbolManager::Implementation @@ -367,4 +367,4 @@ void SymbolManager::resetAssertions() d_symtabAllocated.resetAssertions(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/symbol_manager.h b/src/expr/symbol_manager.h index 40ea44b34..6795ce3b3 100644 --- a/src/expr/symbol_manager.h +++ b/src/expr/symbol_manager.h @@ -25,7 +25,7 @@ #include "cvc4_export.h" #include "expr/symbol_table.h" -namespace CVC4 { +namespace CVC5 { /** * Symbol manager, which manages: @@ -156,6 +156,6 @@ class CVC4_EXPORT SymbolManager bool d_globalDeclarations; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__SYMBOL_MANAGER_H */ diff --git a/src/expr/symbol_table.cpp b/src/expr/symbol_table.cpp index 3942f3775..774e2bb39 100644 --- a/src/expr/symbol_table.cpp +++ b/src/expr/symbol_table.cpp @@ -28,11 +28,11 @@ #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; @@ -679,4 +679,4 @@ size_t SymbolTable::getLevel() const { return d_implementation->getLevel(); } void SymbolTable::reset() { d_implementation->reset(); } void SymbolTable::resetAssertions() { d_implementation->resetAssertions(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/symbol_table.h b/src/expr/symbol_table.h index 297917120..113dea704 100644 --- a/src/expr/symbol_table.h +++ b/src/expr/symbol_table.h @@ -26,7 +26,7 @@ #include "base/exception.h" #include "cvc4_export.h" -namespace CVC4 { +namespace CVC5 { namespace api { class Solver; @@ -210,6 +210,6 @@ class CVC4_EXPORT SymbolTable std::unique_ptr<Implementation> d_implementation; }; /* class SymbolTable */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SYMBOL_TABLE_H */ diff --git a/src/expr/tconv_seq_proof_generator.cpp b/src/expr/tconv_seq_proof_generator.cpp index e7fba5088..9b099de2d 100644 --- a/src/expr/tconv_seq_proof_generator.cpp +++ b/src/expr/tconv_seq_proof_generator.cpp @@ -18,7 +18,7 @@ #include "expr/proof_node_manager.h" -namespace CVC4 { +namespace CVC5 { TConvSeqProofGenerator::TConvSeqProofGenerator( ProofNodeManager* pnm, @@ -168,4 +168,4 @@ theory::TrustNode TConvSeqProofGenerator::mkTrustRewriteSequence( std::string TConvSeqProofGenerator::identify() const { return d_name; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/tconv_seq_proof_generator.h b/src/expr/tconv_seq_proof_generator.h index e907ef09c..a5b1de101 100644 --- a/src/expr/tconv_seq_proof_generator.h +++ b/src/expr/tconv_seq_proof_generator.h @@ -22,7 +22,7 @@ #include "expr/proof_generator.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; @@ -115,6 +115,6 @@ class TConvSeqProofGenerator : public ProofGenerator std::string d_name; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__TCONV_SEQ_PROOF_GENERATOR_H */ diff --git a/src/expr/term_canonize.cpp b/src/expr/term_canonize.cpp index 72c59136b..97f3c2539 100644 --- a/src/expr/term_canonize.cpp +++ b/src/expr/term_canonize.cpp @@ -19,9 +19,9 @@ // 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) {} @@ -209,4 +209,4 @@ Node TermCanonize::getCanonicalTerm(TNode n, bool apply_torder, bool doHoVar) } } // namespace expr -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/term_canonize.h b/src/expr/term_canonize.h index 3eefb0c4a..f9f0fda24 100644 --- a/src/expr/term_canonize.h +++ b/src/expr/term_canonize.h @@ -20,7 +20,7 @@ #include <map> #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace expr { /** TermCanonize @@ -100,6 +100,6 @@ class TermCanonize }; } // namespace expr -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__TERM_CANONIZE_H */ diff --git a/src/expr/term_context.cpp b/src/expr/term_context.cpp index 2ade0943d..56c38a17c 100644 --- a/src/expr/term_context.cpp +++ b/src/expr/term_context.cpp @@ -14,7 +14,7 @@ #include "expr/term_context.h" -namespace CVC4 { +namespace CVC5 { uint32_t TermContext::computeValueOp(TNode t, uint32_t tval) const { @@ -132,4 +132,4 @@ void PolarityTermContext::getFlags(uint32_t val, bool& hasPol, bool& pol) pol = val == 2; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/term_context.h b/src/expr/term_context.h index 7b4dbe928..65cdbb23e 100644 --- a/src/expr/term_context.h +++ b/src/expr/term_context.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { /** * This is an abstract class for computing "term context identifiers". A term @@ -163,6 +163,6 @@ class PolarityTermContext : public TermContext static void getFlags(uint32_t val, bool& hasPol, bool& pol); }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__TERM_CONVERSION_PROOF_GENERATOR_H */ diff --git a/src/expr/term_context_node.cpp b/src/expr/term_context_node.cpp index 871193442..1afc599d2 100644 --- a/src/expr/term_context_node.cpp +++ b/src/expr/term_context_node.cpp @@ -16,7 +16,7 @@ #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) @@ -73,4 +73,4 @@ Node TCtxNode::decomposeNodeHash(Node h, uint32_t& val) return h[0]; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/term_context_node.h b/src/expr/term_context_node.h index 15e7f9f1b..67d747557 100644 --- a/src/expr/term_context_node.h +++ b/src/expr/term_context_node.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class TCtxStack; class TermContext; @@ -74,6 +74,6 @@ class TCtxNode const TermContext* d_tctx; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__TERM_CONVERSION_PROOF_GENERATOR_H */ diff --git a/src/expr/term_context_stack.cpp b/src/expr/term_context_stack.cpp index 07d7746ed..557683498 100644 --- a/src/expr/term_context_stack.cpp +++ b/src/expr/term_context_stack.cpp @@ -16,7 +16,7 @@ #include "expr/term_context.h" -namespace CVC4 { +namespace CVC5 { TCtxStack::TCtxStack(const TermContext* tctx) : d_tctx(tctx) {} @@ -75,4 +75,4 @@ TCtxNode TCtxStack::getCurrentNode() const return TCtxNode(curr.first, curr.second, d_tctx); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/term_context_stack.h b/src/expr/term_context_stack.h index f40f5f6b2..34c474a52 100644 --- a/src/expr/term_context_stack.h +++ b/src/expr/term_context_stack.h @@ -19,7 +19,7 @@ #include "expr/term_context_node.h" -namespace CVC4 { +namespace CVC5 { /** * A stack for term-context-sensitive terms. Its main advantage is that @@ -68,6 +68,6 @@ class TCtxStack const TermContext* d_tctx; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__TERM_CONTEXT_STACK_H */ diff --git a/src/expr/term_conversion_proof_generator.cpp b/src/expr/term_conversion_proof_generator.cpp index 470b8c9f8..bfdf4d188 100644 --- a/src/expr/term_conversion_proof_generator.cpp +++ b/src/expr/term_conversion_proof_generator.cpp @@ -21,9 +21,9 @@ #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) { @@ -588,4 +588,4 @@ std::string TConvProofGenerator::toStringDebug() const return ss.str(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/term_conversion_proof_generator.h b/src/expr/term_conversion_proof_generator.h index acff2ded1..734ef103e 100644 --- a/src/expr/term_conversion_proof_generator.h +++ b/src/expr/term_conversion_proof_generator.h @@ -21,7 +21,7 @@ #include "expr/lazy_proof.h" #include "expr/proof_generator.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; class TermContext; @@ -242,6 +242,6 @@ class TConvProofGenerator : public ProofGenerator std::string toStringDebug() const; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__EXPR__TERM_CONVERSION_PROOF_GENERATOR_H */ diff --git a/src/expr/type_checker.h b/src/expr/type_checker.h index 0ca2fb806..b502d8013 100644 --- a/src/expr/type_checker.h +++ b/src/expr/type_checker.h @@ -22,7 +22,7 @@ #ifndef CVC4__EXPR__TYPE_CHECKER_H #define CVC4__EXPR__TYPE_CHECKER_H -namespace CVC4 { +namespace CVC5 { namespace expr { class TypeChecker { @@ -35,7 +35,7 @@ public: };/* class TypeChecker */ -}/* CVC4::expr namespace */ -}/* CVC4 namespace */ +} // namespace expr +} // namespace CVC5 #endif /* CVC4__EXPR__TYPE_CHECKER_H */ diff --git a/src/expr/type_checker_template.cpp b/src/expr/type_checker_template.cpp index 527f98384..07dca77e2 100644 --- a/src/expr/type_checker_template.cpp +++ b/src/expr/type_checker_template.cpp @@ -23,7 +23,7 @@ ${typechecker_includes} -namespace CVC4 { +namespace CVC5 { namespace expr { TypeNode TypeChecker::computeType(NodeManager* nodeManager, TNode n, bool check) @@ -71,5 +71,5 @@ ${construles} }/* TypeChecker::computeIsConst */ -}/* CVC4::expr namespace */ -}/* CVC4 namespace */ +} // namespace expr +} // namespace CVC5 diff --git a/src/expr/type_checker_util.h b/src/expr/type_checker_util.h index 5f227423b..1ca23d374 100644 --- a/src/expr/type_checker_util.h +++ b/src/expr/type_checker_util.h @@ -26,7 +26,7 @@ #include "expr/node_manager.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { namespace expr { /** Type check returns the builtin operator sort */ @@ -202,4 +202,4 @@ class SimpleTypeRuleVar }; } // namespace expr -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/type_matcher.cpp b/src/expr/type_matcher.cpp index b71a4b515..76d256157 100644 --- a/src/expr/type_matcher.cpp +++ b/src/expr/type_matcher.cpp @@ -14,7 +14,7 @@ #include "type_matcher.h" -namespace CVC4 { +namespace CVC5 { TypeMatcher::TypeMatcher(TypeNode dt) { @@ -125,4 +125,4 @@ void TypeMatcher::getMatches(std::vector<TypeNode>& types) const } } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/expr/type_matcher.h b/src/expr/type_matcher.h index 98c3ce865..651054313 100644 --- a/src/expr/type_matcher.h +++ b/src/expr/type_matcher.h @@ -21,7 +21,7 @@ #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { /** * This class is used for inferring the parameters of an instantiated @@ -68,6 +68,6 @@ class TypeMatcher void addTypes(const std::vector<TypeNode>& types); }; /* class TypeMatcher */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__MATCHER_H */ diff --git a/src/expr/type_node.cpp b/src/expr/type_node.cpp index 8d474ca5f..f73bde3eb 100644 --- a/src/expr/type_node.cpp +++ b/src/expr/type_node.cpp @@ -25,7 +25,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { TypeNode TypeNode::s_null( &expr::NodeValue::null() ); @@ -499,7 +499,7 @@ TypeNode TypeNode::mostCommonTypeNode(TypeNode t0, TypeNode t1){ 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()); @@ -717,4 +717,4 @@ TypeNode TypeNode::getBagElementType() const return (*this)[0]; } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/expr/type_node.h b/src/expr/type_node.h index baff528ff..7b752c3e5 100644 --- a/src/expr/type_node.h +++ b/src/expr/type_node.h @@ -32,14 +32,14 @@ #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 @@ -749,11 +749,11 @@ inline std::ostream& operator<<(std::ostream& out, const TypeNode& n) { typedef TypeNode::HashFunction TypeNodeHashFunction; -}/* CVC4 namespace */ +} // namespace CVC5 #include "expr/node_manager.h" -namespace CVC4 { +namespace CVC5 { inline TypeNode TypeNode::substitute(const TypeNode& type, @@ -860,7 +860,7 @@ template <class AttrKind> 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()); } @@ -869,7 +869,7 @@ template <class 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()); } @@ -877,7 +877,7 @@ hasAttribute(const AttrKind&) const { 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); } @@ -886,7 +886,7 @@ template <class AttrKind> 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); } @@ -1069,6 +1069,6 @@ static void __attribute__((used)) debugPrintRawTypeNode(const TypeNode& n) { } #endif /* CVC4_DEBUG */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__NODE_H */ diff --git a/src/expr/type_properties_template.h b/src/expr/type_properties_template.h index c0f9fb844..abf5e6173 100644 --- a/src/expr/type_properties_template.h +++ b/src/expr/type_properties_template.h @@ -29,7 +29,7 @@ ${type_properties_includes} -namespace CVC4 { +namespace CVC5 { namespace kind { /** @@ -113,7 +113,7 @@ ${type_groundterms} } } /* mkGroundTerm(TypeNode) */ -}/* CVC4::kind namespace */ -}/* CVC4 namespace */ +} // namespace kind +} // namespace CVC5 #endif /* CVC4__TYPE_PROPERTIES_H */ diff --git a/src/expr/uninterpreted_constant.cpp b/src/expr/uninterpreted_constant.cpp index b2d5a2b12..9d8b12264 100644 --- a/src/expr/uninterpreted_constant.cpp +++ b/src/expr/uninterpreted_constant.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { UninterpretedConstant::UninterpretedConstant(const TypeNode& type, Integer index) @@ -95,4 +95,4 @@ size_t UninterpretedConstantHashFunction::operator()( * IntegerHashFunction()(uc.getIndex()); } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/expr/uninterpreted_constant.h b/src/expr/uninterpreted_constant.h index e7c0f9830..00ad68212 100644 --- a/src/expr/uninterpreted_constant.h +++ b/src/expr/uninterpreted_constant.h @@ -24,7 +24,7 @@ #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { class TypeNode; @@ -60,6 +60,6 @@ struct UninterpretedConstantHashFunction size_t operator()(const UninterpretedConstant& uc) const; }; /* struct UninterpretedConstantHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__UNINTERPRETED_CONSTANT_H */ diff --git a/src/main/command_executor.cpp b/src/main/command_executor.cpp index 551880b98..ebe51f359 100644 --- a/src/main/command_executor.cpp +++ b/src/main/command_executor.cpp @@ -26,7 +26,7 @@ #include "main/main.h" #include "smt/command.h" -namespace CVC4 { +namespace CVC5 { namespace main { // Function to cancel any (externally-imposed) limit on CPU time. @@ -331,5 +331,5 @@ void CommandExecutor::flushOutputStreams() { d_options.flushErr(); } -}/* CVC4::main namespace */ -}/* CVC4 namespace */ +} // namespace main +} // namespace CVC5 diff --git a/src/main/command_executor.h b/src/main/command_executor.h index 0dea41383..a2dc4a4e9 100644 --- a/src/main/command_executor.h +++ b/src/main/command_executor.h @@ -24,7 +24,7 @@ #include "smt/smt_engine.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { class Command; @@ -65,9 +65,10 @@ class CommandExecutor * 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()); } @@ -100,7 +101,7 @@ class CommandExecutor protected: /** Executes treating cmd as a singleton */ - virtual bool doCommandSingleton(CVC4::Command* cmd); + virtual bool doCommandSingleton(CVC5::Command* cmd); private: CommandExecutor(); @@ -112,7 +113,7 @@ bool solverInvoke(api::Solver* solver, Command* cmd, std::ostream* out); -}/* CVC4::main namespace */ -}/* CVC4 namespace */ +} // namespace main +} // namespace CVC5 #endif /* CVC4__MAIN__COMMAND_EXECUTOR_H */ diff --git a/src/main/driver_unified.cpp b/src/main/driver_unified.cpp index 2bca01e08..40ed674c0 100644 --- a/src/main/driver_unified.cpp +++ b/src/main/driver_unified.cpp @@ -41,40 +41,39 @@ #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; @@ -176,12 +175,12 @@ int runCvc4(int argc, char* argv[], Options& opts) { // 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) diff --git a/src/main/interactive_shell.cpp b/src/main/interactive_shell.cpp index 4fe8d4da9..91b3d53b3 100644 --- a/src/main/interactive_shell.cpp +++ b/src/main/interactive_shell.cpp @@ -49,7 +49,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { using namespace parser; using namespace language; @@ -432,4 +432,4 @@ char* commandGenerator(const char* text, int state) { #endif /* HAVE_LIBEDITLINE */ -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/main/interactive_shell.h b/src/main/interactive_shell.h index b3c54f580..2c421d7b2 100644 --- a/src/main/interactive_shell.h +++ b/src/main/interactive_shell.h @@ -22,7 +22,7 @@ #include "options/options.h" #include "util/unsafe_interrupt_exception.h" -namespace CVC4 { +namespace CVC5 { class Command; class Options; @@ -33,7 +33,7 @@ class Solver; namespace parser { class Parser; -}/* CVC4::parser namespace */ + } // namespace parser class SymbolManager; @@ -72,6 +72,6 @@ public: };/* class InteractiveShell */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__INTERACTIVE_SHELL_H */ diff --git a/src/main/main.cpp b/src/main/main.cpp index 65b341a12..f880d5ee1 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -34,9 +34,9 @@ #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. diff --git a/src/main/main.h b/src/main/main.h index 518145577..47312c465 100644 --- a/src/main/main.h +++ b/src/main/main.h @@ -26,7 +26,7 @@ #ifndef CVC4__MAIN__MAIN_H #define CVC4__MAIN__MAIN_H -namespace CVC4 { +namespace CVC5 { namespace main { class CommandExecutor; @@ -38,7 +38,7 @@ extern const char* progPath; 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 @@ -64,18 +64,18 @@ extern bool segvSpin; 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 */ diff --git a/src/main/signal_handlers.cpp b/src/main/signal_handlers.cpp index 93014b256..a7a3a073c 100644 --- a/src/main/signal_handlers.cpp +++ b/src/main/signal_handlers.cpp @@ -41,10 +41,10 @@ #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 { /** @@ -343,4 +343,4 @@ void cleanup() noexcept } // namespace signal_handlers } // namespace main -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/main/signal_handlers.h b/src/main/signal_handlers.h index c313b7747..1312ca27d 100644 --- a/src/main/signal_handlers.h +++ b/src/main/signal_handlers.h @@ -17,7 +17,7 @@ #ifndef CVC4__MAIN__SIGNAL_HANDLERS_H #define CVC4__MAIN__SIGNAL_HANDLERS_H -namespace CVC4 { +namespace CVC5 { namespace main { namespace signal_handlers { @@ -41,6 +41,6 @@ void cleanup(); } // namespace signal_handlers } // namespace main -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__MAIN__SIGNAL_HANDLERS_H */ diff --git a/src/main/time_limit.cpp b/src/main/time_limit.cpp index fd7164d2c..7f2bc0c61 100644 --- a/src/main/time_limit.cpp +++ b/src/main/time_limit.cpp @@ -58,7 +58,7 @@ #include "signal_handlers.h" -namespace CVC4 { +namespace CVC5 { namespace main { #if HAVE_SETITIMER @@ -133,4 +133,4 @@ TimeLimit install_time_limit(const Options& opts) } } // namespace main -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/main/time_limit.h b/src/main/time_limit.h index 4f7425839..62dc6a6a3 100644 --- a/src/main/time_limit.h +++ b/src/main/time_limit.h @@ -19,7 +19,7 @@ #include "options/options.h" -namespace CVC4 { +namespace CVC5 { namespace main { /** @@ -47,6 +47,6 @@ struct TimeLimit TimeLimit install_time_limit(const Options& opts); } // namespace main -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__MAIN__TIME_LIMIT_H */ diff --git a/src/options/README b/src/options/README index 47a7d9db7..92609f433 100644 --- a/src/options/README +++ b/src/options/README @@ -215,7 +215,7 @@ Further information (the old option package) 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. diff --git a/src/options/base_handlers.h b/src/options/base_handlers.h index 64353af5d..5c223d770 100644 --- a/src/options/base_handlers.h +++ b/src/options/base_handlers.h @@ -26,7 +26,7 @@ #include "options/option_exception.h" -namespace CVC4 { +namespace CVC5 { namespace options { template <template <class U> class Cmp> @@ -80,7 +80,7 @@ struct not_equal : public comparator<std::not_equal_to> { 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 */ diff --git a/src/options/decision_weight.h b/src/options/decision_weight.h index 42fef60bc..88def99e6 100644 --- a/src/options/decision_weight.h +++ b/src/options/decision_weight.h @@ -19,12 +19,12 @@ #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 */ diff --git a/src/options/didyoumean.cpp b/src/options/didyoumean.cpp index 305d9b5c4..02307063b 100644 --- a/src/options/didyoumean.cpp +++ b/src/options/didyoumean.cpp @@ -25,7 +25,7 @@ #include <string> #include <vector> -namespace CVC4 { +namespace CVC5 { std::vector<std::string> DidYouMean::getMatch(std::string input) { /** Magic numbers */ @@ -158,4 +158,4 @@ std::string DidYouMean::getMatchAsString(std::string input, int prefixNewLines, return oss.str(); } -} /* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/options/didyoumean.h b/src/options/didyoumean.h index d829214e4..79deeb004 100644 --- a/src/options/didyoumean.h +++ b/src/options/didyoumean.h @@ -23,7 +23,7 @@ #include <string> #include <vector> -namespace CVC4 { +namespace CVC5 { class DidYouMean { public: @@ -50,4 +50,4 @@ class DidYouMean { Words d_words; }; -} /*CVC4 namespace*/ +} // namespace CVC5 diff --git a/src/options/didyoumean_test.cpp b/src/options/didyoumean_test.cpp index 20d4ee162..7ea8e1243 100644 --- a/src/options/didyoumean_test.cpp +++ b/src/options/didyoumean_test.cpp @@ -23,7 +23,7 @@ #include <iostream> using namespace std; -using namespace CVC4; +using namespace CVC5; set<string> getDebugTags(); set<string> getOptionStrings(); diff --git a/src/options/language.cpp b/src/options/language.cpp index abd0d9124..bf8f5d7bf 100644 --- a/src/options/language.cpp +++ b/src/options/language.cpp @@ -21,7 +21,7 @@ #include "base/exception.h" #include "options/option_exception.h" -namespace CVC4 { +namespace CVC5 { namespace language { /** define the end points of smt2 languages */ @@ -83,7 +83,7 @@ InputLanguage toInputLanguage(OutputLanguage language) { 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() */ @@ -170,5 +170,5 @@ InputLanguage toInputLanguage(std::string language) { throw OptionException(std::string("unknown input language `" + language + "'")); }/* toInputLanguage() */ -}/* CVC4::language namespace */ -}/* CVC4 namespace */ +} // namespace language +} // namespace CVC5 diff --git a/src/options/language.h b/src/options/language.h index a8b42fec1..99ee40c28 100644 --- a/src/options/language.h +++ b/src/options/language.h @@ -24,7 +24,7 @@ #include "cvc4_export.h" -namespace CVC4 { +namespace CVC5 { namespace language { namespace input { @@ -83,7 +83,7 @@ inline std::ostream& operator<<(std::ostream& out, Language lang) { return out; } -}/* CVC4::language::input namespace */ +} // namespace input namespace output { @@ -147,9 +147,9 @@ inline std::ostream& operator<<(std::ostream& out, Language lang) { return out; } -}/* CVC4::language::output namespace */ +} // namespace output -}/* CVC4::language namespace */ +} // namespace language typedef language::input::Language InputLanguage; typedef language::output::Language OutputLanguage; @@ -176,7 +176,7 @@ OutputLanguage toOutputLanguage(InputLanguage language) CVC4_EXPORT; 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 */ diff --git a/src/options/module_template.cpp b/src/options/module_template.cpp index 32670d846..105ab94f8 100644 --- a/src/options/module_template.cpp +++ b/src/options/module_template.cpp @@ -18,7 +18,8 @@ #include "options/options_holder.h" #include "base/check.h" -namespace CVC4 { +// clang-format off +namespace CVC5 { ${accs}$ @@ -30,4 +31,5 @@ ${defs}$ ${modes}$ } // namespace options -} // namespace CVC4 +} // namespace CVC5 +// clang-format on diff --git a/src/options/module_template.h b/src/options/module_template.h index 33d0de629..501e5cf43 100644 --- a/src/options/module_template.h +++ b/src/options/module_template.h @@ -22,14 +22,12 @@ #include "options/options.h" +// clang-format off ${includes}$ - ${holder_spec}$ - -namespace CVC4 { - +namespace CVC5 { namespace options { ${modes}$ @@ -40,12 +38,11 @@ ${decls}$ ${specs}$ - namespace options { - ${inls}$ } // namespace options -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__OPTIONS__${id}$_H */ +//clang-format on diff --git a/src/options/open_ostream.cpp b/src/options/open_ostream.cpp index f03584c55..03c3e63ff 100644 --- a/src/options/open_ostream.cpp +++ b/src/options/open_ostream.cpp @@ -28,7 +28,7 @@ #include "lib/strtok_r.h" #include "options/parser_options.h" -namespace CVC4 { +namespace CVC5 { OstreamOpener::OstreamOpener(const char* channelName) : d_channelName(channelName) @@ -98,4 +98,4 @@ std::string cvc4_errno_failreason() { #endif /* HAVE_STRERROR_R */ } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/options/open_ostream.h b/src/options/open_ostream.h index 6c6046d86..4f879cd6d 100644 --- a/src/options/open_ostream.h +++ b/src/options/open_ostream.h @@ -25,7 +25,7 @@ #include <string> #include <utility> -namespace CVC4 { +namespace CVC5 { class OstreamOpener { public: @@ -55,6 +55,6 @@ class OstreamOpener { std::string cvc4_errno_failreason(); -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__OPEN_OSTREAM_H */ diff --git a/src/options/option_exception.cpp b/src/options/option_exception.cpp index 35cbc9b73..997f7d84a 100644 --- a/src/options/option_exception.cpp +++ b/src/options/option_exception.cpp @@ -16,6 +16,6 @@ #include "options/option_exception.h" -namespace CVC4 { +namespace CVC5 { const std::string OptionException::s_errPrefix = "Error in option parsing: "; -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/options/option_exception.h b/src/options/option_exception.h index 11d6b8fd3..6b522c30a 100644 --- a/src/options/option_exception.h +++ b/src/options/option_exception.h @@ -22,7 +22,7 @@ #include "base/exception.h" #include "cvc4_export.h" -namespace CVC4 { +namespace CVC5 { /** * Class representing an option-parsing exception such as badly-typed @@ -30,10 +30,10 @@ namespace CVC4 { * 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 @@ -53,18 +53,22 @@ class CVC4_EXPORT OptionException : public CVC4::Exception * 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 */ diff --git a/src/options/options.h b/src/options/options.h index 728e5c7c8..6958f350c 100644 --- a/src/options/options.h +++ b/src/options/options.h @@ -31,7 +31,7 @@ #include "options/option_exception.h" #include "options/printer_modes.h" -namespace CVC4 { +namespace CVC5 { namespace api { class Solver; @@ -39,7 +39,7 @@ class Solver; namespace options { struct OptionsHolder; class OptionsHandler; -}/* CVC4::options namespace */ + } // namespace options class OptionsListener; @@ -306,6 +306,6 @@ public: std::vector<std::string>* nonoptions); }; /* class Options */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__OPTIONS__OPTIONS_H */ diff --git a/src/options/options_handler.cpp b/src/options/options_handler.cpp index ee3242067..250fd98ac 100644 --- a/src/options/options_handler.cpp +++ b/src/options/options_handler.cpp @@ -38,7 +38,7 @@ #include "options/smt_options.h" #include "options/theory_options.h" -namespace CVC4 { +namespace CVC5 { namespace options { // helper functions @@ -505,26 +505,26 @@ InputLanguage OptionsHandler::stringToInputLanguage(std::string option, 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); @@ -542,6 +542,5 @@ void OptionsHandler::decreaseVerbosity(std::string option) { setVerbosity(option, options::verbosity()); } - -}/* CVC4::options namespace */ -}/* CVC4 namespace */ +} // namespace options +} // namespace CVC5 diff --git a/src/options/options_handler.h b/src/options/options_handler.h index b24fb032f..cf59c783a 100644 --- a/src/options/options_handler.h +++ b/src/options/options_handler.h @@ -30,7 +30,7 @@ #include "options/printer_modes.h" #include "options/quantifiers_options.h" -namespace CVC4 { +namespace CVC5 { class Options; @@ -133,7 +133,7 @@ void OptionsHandler::checkSatSolverEnabled(std::string option, T m) #endif } -}/* CVC4::options namespace */ -}/* CVC4 namespace */ +} // namespace options +} // namespace CVC5 #endif /* CVC4__OPTIONS__OPTIONS_HANDLER_H */ diff --git a/src/options/options_holder_template.h b/src/options/options_holder_template.h index 781d6f037..e8cab00c7 100644 --- a/src/options/options_holder_template.h +++ b/src/options/options_holder_template.h @@ -19,20 +19,21 @@ #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 diff --git a/src/options/options_listener.h b/src/options/options_listener.h index 589d49323..9cbdfaf97 100644 --- a/src/options/options_listener.h +++ b/src/options/options_listener.h @@ -19,7 +19,7 @@ #include <string> -namespace CVC4 { +namespace CVC5 { class OptionsListener { @@ -32,6 +32,6 @@ class OptionsListener virtual void notifySetOption(const std::string& key) = 0; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__OPTIONS__OPTION_LISTENER_H */ diff --git a/src/options/options_public_functions.cpp b/src/options/options_public_functions.cpp index 5ef04bc6d..d7768c6c8 100644 --- a/src/options/options_public_functions.cpp +++ b/src/options/options_public_functions.cpp @@ -36,7 +36,7 @@ #include "options/smt_options.h" #include "options/uf_options.h" -namespace CVC4 { +namespace CVC5 { // Get accessor functions. InputLanguage Options::getInputLanguage() const { @@ -238,4 +238,4 @@ void Options::flushOut() { } } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/options/options_template.cpp b/src/options/options_template.cpp index 4d11aa522..a0037d162 100644 --- a/src/options/options_template.cpp +++ b/src/options/options_template.cpp @@ -55,20 +55,19 @@ extern int optreset; #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; @@ -367,10 +366,10 @@ public: } };/* 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). * @@ -505,7 +504,8 @@ void Options::parseOptionsRecursive(Options* options, Debug("preemptGetopt") << "processing option " << c << " (`" << char(c) << "'), " << option << std::endl; - switch(c) { + switch(c) + { ${options_handler}$ @@ -601,4 +601,5 @@ std::string Options::getOption(const std::string& key) const #undef USE_EARLY_TYPE_CHECKING_BY_DEFAULT #undef DO_SEMANTIC_CHECKS_BY_DEFAULT -} // namespace CVC4 +} // namespace CVC5 +// clang-format on diff --git a/src/options/printer_modes.cpp b/src/options/printer_modes.cpp index 3fe73be29..7e659b14c 100644 --- a/src/options/printer_modes.cpp +++ b/src/options/printer_modes.cpp @@ -17,7 +17,7 @@ #include "options/printer_modes.h" -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& out, options::InstFormatMode mode) { @@ -31,4 +31,4 @@ std::ostream& operator<<(std::ostream& out, options::InstFormatMode mode) return out; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/options/printer_modes.h b/src/options/printer_modes.h index d4cdbd9a4..7f9bcc58b 100644 --- a/src/options/printer_modes.h +++ b/src/options/printer_modes.h @@ -22,7 +22,7 @@ #include <iostream> -namespace CVC4 { +namespace CVC5 { namespace options { /** Enumeration of inst_format modes (how to print models from get-model @@ -39,6 +39,6 @@ enum class InstFormatMode std::ostream& operator<<(std::ostream& out, options::InstFormatMode mode); -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PRINTER__MODEL_FORMAT_H */ diff --git a/src/options/set_language.cpp b/src/options/set_language.cpp index 567d909cb..53dca6220 100644 --- a/src/options/set_language.cpp +++ b/src/options/set_language.cpp @@ -22,7 +22,7 @@ #include "options/language.h" #include "options/options.h" -namespace CVC4 { +namespace CVC5 { namespace language { const int SetLanguage::s_iosIndex = std::ios_base::xalloc(); @@ -78,5 +78,5 @@ std::ostream& operator<<(std::ostream& out, SetLanguage l) { return out; } -}/* CVC4::language namespace */ -}/* CVC4 namespace */ +} // namespace language +} // namespace CVC5 diff --git a/src/options/set_language.h b/src/options/set_language.h index b94bdf1d8..d6b9a2da9 100644 --- a/src/options/set_language.h +++ b/src/options/set_language.h @@ -24,7 +24,7 @@ #include "cvc4_export.h" #include "options/language.h" -namespace CVC4 { +namespace CVC5 { namespace language { /** @@ -90,7 +90,7 @@ private: */ 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 */ diff --git a/src/parser/antlr_input.cpp b/src/parser/antlr_input.cpp index d0737bad6..ac9417197 100644 --- a/src/parser/antlr_input.cpp +++ b/src/parser/antlr_input.cpp @@ -34,11 +34,11 @@ #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. @@ -581,5 +581,5 @@ void AntlrInput::setAntlr3Parser(pANTLR3_PARSER pParser) { d_parser->rec->mismatch; } -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/antlr_input.h b/src/parser/antlr_input.h index 805ac9a48..de0d563ef 100644 --- a/src/parser/antlr_input.h +++ b/src/parser/antlr_input.h @@ -36,7 +36,7 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { namespace parser { /** Wrapper around an ANTLR3 input stream. */ @@ -291,7 +291,7 @@ inline BitVector AntlrInput::tokenToBitvector(pANTLR3_COMMON_TOKEN number, pANTL return BitVector(sz, val); } -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__ANTLR_INPUT_H */ diff --git a/src/parser/antlr_input_imports.cpp b/src/parser/antlr_input_imports.cpp index 121298c4f..98c071ed3 100644 --- a/src/parser/antlr_input_imports.cpp +++ b/src/parser/antlr_input_imports.cpp @@ -60,7 +60,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace parser { /// Report a recognition problem. @@ -436,4 +436,4 @@ AntlrInput::nextToken (pANTLR3_TOKEN_SOURCE toksource) } // namespace parser -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/parser/antlr_line_buffered_input.cpp b/src/parser/antlr_line_buffered_input.cpp index 37c38e83b..66ebff7b3 100644 --- a/src/parser/antlr_line_buffered_input.cpp +++ b/src/parser/antlr_line_buffered_input.cpp @@ -38,7 +38,7 @@ #include "base/check.h" #include "base/output.h" -namespace CVC4 { +namespace CVC5 { namespace parser { static pANTLR3_INPUT_STREAM antlr3CreateLineBufferedStream( @@ -218,8 +218,8 @@ setupInputStream(pANTLR3_INPUT_STREAM input) 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; @@ -255,8 +255,8 @@ static void bufferedInputRewind(pANTLR3_INT_STREAM is, ANTLR3_MARKER mark) { 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); @@ -285,7 +285,7 @@ static void bufferedInputSeek(pANTLR3_INT_STREAM is, ANTLR3_MARKER seekPoint) { 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)); @@ -411,5 +411,5 @@ static pANTLR3_INPUT_STREAM antlr3CreateLineBufferedStream( return input; } -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/antlr_line_buffered_input.h b/src/parser/antlr_line_buffered_input.h index cb1e047c7..0699c16d0 100644 --- a/src/parser/antlr_line_buffered_input.h +++ b/src/parser/antlr_line_buffered_input.h @@ -30,7 +30,7 @@ #include "parser/line_buffer.h" -namespace CVC4 { +namespace CVC5 { namespace parser { typedef struct ANTLR3_LINE_BUFFERED_INPUT_STREAM { @@ -44,7 +44,7 @@ pANTLR3_INPUT_STREAM antlr3LineBufferedStreamNew(std::istream& in, pANTLR3_UINT8 name, LineBuffer* line_buffer); -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__ANTLR_LINE_BUFFERED_INPUT_H */ diff --git a/src/parser/bounded_token_buffer.cpp b/src/parser/bounded_token_buffer.cpp index 5db0127c5..d1b0ea20b 100644 --- a/src/parser/bounded_token_buffer.cpp +++ b/src/parser/bounded_token_buffer.cpp @@ -57,7 +57,7 @@ #include "base/check.h" -namespace CVC4 { +namespace CVC5 { namespace parser { #ifdef ANTLR3_WINDOWS @@ -525,6 +525,5 @@ getSourceName (pANTLR3_INT_STREAM is) return ((pANTLR3_TOKEN_STREAM)(is->super))->tokenSource->fileName; } - -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/bounded_token_buffer.h b/src/parser/bounded_token_buffer.h index 8fe0d1705..c6599b5af 100644 --- a/src/parser/bounded_token_buffer.h +++ b/src/parser/bounded_token_buffer.h @@ -30,7 +30,7 @@ #include <antlr3defs.h> -namespace CVC4 { +namespace CVC5 { namespace parser { #ifdef __cplusplus @@ -58,7 +58,7 @@ BoundedTokenBufferFree(pBOUNDED_TOKEN_BUFFER buffer); }/* extern "C" */ #endif -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__BOUNDED_TOKEN_BUFFER_H */ diff --git a/src/parser/bounded_token_factory.cpp b/src/parser/bounded_token_factory.cpp index 6e4f57881..f7f8a245f 100644 --- a/src/parser/bounded_token_factory.cpp +++ b/src/parser/bounded_token_factory.cpp @@ -19,7 +19,7 @@ #include <antlr3interfaces.h> #include "parser/bounded_token_factory.h" -namespace CVC4 { +namespace CVC5 { namespace parser { static pANTLR3_COMMON_TOKEN @@ -140,5 +140,5 @@ setInputStream (pANTLR3_TOKEN_FACTORY factory, pANTLR3_INPUT_STREAM input) } } -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/bounded_token_factory.h b/src/parser/bounded_token_factory.h index 51e6f5b05..0f29bbb99 100644 --- a/src/parser/bounded_token_factory.h +++ b/src/parser/bounded_token_factory.h @@ -22,7 +22,7 @@ #ifndef CVC4__PARSER__BOUNDED_TOKEN_FACTORY_H #define CVC4__PARSER__BOUNDED_TOKEN_FACTORY_H -namespace CVC4 { +namespace CVC5 { namespace parser { #ifdef __cplusplus @@ -45,7 +45,7 @@ BoundedTokenFactoryNew(pANTLR3_INPUT_STREAM input,ANTLR3_UINT32 size); }/* extern "C" */ #endif -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__BOUNDED_TOKEN_FACTORY_H */ diff --git a/src/parser/cvc/Cvc.g b/src/parser/cvc/Cvc.g index c12c1efc6..2ed1a924c 100644 --- a/src/parser/cvc/Cvc.g +++ b/src/parser/cvc/Cvc.g @@ -430,8 +430,8 @@ unsigned findPivot(const std::vector<unsigned>& operators, 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); @@ -447,9 +447,9 @@ CVC4::api::Term createPrecedenceTree(Parser* parser, api::Solver* solver, //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()) @@ -477,7 +477,7 @@ CVC4::api::Term createPrecedenceTree(Parser* parser, api::Solver* solver, }/* 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) { @@ -552,7 +552,7 @@ api::Term addNots(api::Solver* s, size_t n, api::Term e) { #include "smt/command.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { class Expr; }/* CVC4 namespace */ @@ -582,8 +582,8 @@ namespace CVC4 { }); \ }) -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.) */ @@ -611,7 +611,7 @@ using namespace CVC4::parser; * 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 ; @@ -620,9 +620,9 @@ parseExpr returns [CVC4::api::Term expr = CVC4::api::Term()] * 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(); @@ -652,7 +652,7 @@ parseCommand returns [CVC4::Command* cmd_return = NULL] * 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(); } @@ -674,18 +674,18 @@ command [std::unique_ptr<CVC4::Command>* cmd] } ; -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; @@ -694,7 +694,7 @@ mainCommand[std::unique_ptr<CVC4::Command>* cmd] 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; } @@ -953,7 +953,7 @@ simpleSymbolicExpr[std::string& s] { s = AntlrInput::tokenText($IDENTIFIER); } ; -symbolicExpr[CVC4::api::Term& sexpr] +symbolicExpr[CVC5::api::Term& sexpr] @declarations { std::string s; std::vector<api::Term> children; @@ -961,13 +961,13 @@ symbolicExpr[CVC4::api::Term& sexpr] : 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; @@ -982,7 +982,7 @@ toplevelDeclaration[std::unique_ptr<CVC4::Command>* cmd] /** * 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; } @@ -1001,8 +1001,8 @@ boundVarDecls : 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; @@ -1012,8 +1012,8 @@ boundVarDeclsReturn[std::vector<CVC4::api::Term>& terms, : 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; @@ -1035,7 +1035,7 @@ boundVarDeclReturn[std::vector<CVC4::api::Term>& terms, * 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; @@ -1077,7 +1077,7 @@ declareTypes[std::unique_ptr<CVC4::Command>* cmd, * 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; @@ -1167,8 +1167,8 @@ declareVariables[std::unique_ptr<CVC4::Command>* cmd, CVC4::api::Sort& t, * @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(); @@ -1181,8 +1181,8 @@ identifierList[std::vector<std::string>& idList, * 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); } @@ -1200,8 +1200,8 @@ identifier[std::string& id, * 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; @@ -1244,8 +1244,8 @@ type[CVC4::api::Sort& t, // 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; } @@ -1257,8 +1257,8 @@ restrictedType[CVC4::api::Sort& t, * 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; @@ -1369,8 +1369,8 @@ restrictedTypePossiblyFunctionLHS[CVC4::api::Sort& t, } ; -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; } @@ -1383,7 +1383,7 @@ bound | integer ; -typeLetDecl[CVC4::parser::DeclarationCheck check] +typeLetDecl[CVC5::parser::DeclarationCheck check] @init { api::Sort t; std::string id; @@ -1399,11 +1399,11 @@ typeLetDecl[CVC4::parser::DeclarationCheck check] * * @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; } @@ -1421,7 +1421,7 @@ formula[CVC4::api::Term& f] ) ; -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; @@ -1445,7 +1445,7 @@ nots returns [size_t n = 0] : ( NOT_TOK { ++$n; } )* ; -prefixFormula[CVC4::api::Term& f] +prefixFormula[CVC5::api::Term& f] @init { std::vector<std::string> ids; std::vector<api::Term> terms; @@ -1499,7 +1499,7 @@ prefixFormula[CVC4::api::Term& f] } ; -instantiationPatterns[ CVC4::api::Term& expr ] +instantiationPatterns[ CVC5::api::Term& expr ] @init { std::vector<api::Term> args; api::Term f; @@ -1545,9 +1545,9 @@ booleanBinop[unsigned& op] | 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; } @@ -1585,9 +1585,9 @@ arithmeticBinop[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; @@ -1607,24 +1607,24 @@ term[CVC4::api::Term& f] * 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; } @@ -1654,7 +1654,7 @@ tupleStore[CVC4::api::Term& f] * 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; @@ -1680,7 +1680,7 @@ recordStore[CVC4::api::Term& f] ; /** Parses a unary minus term. */ -uminusTerm[CVC4::api::Term& f] +uminusTerm[CVC5::api::Term& f] @init { unsigned minusCount = 0; } @@ -1690,14 +1690,14 @@ uminusTerm[CVC4::api::Term& f] 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; } @@ -1714,12 +1714,12 @@ bvBinop[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] ; @@ -1733,9 +1733,9 @@ relationBinop[unsigned& op] | 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; } @@ -1753,7 +1753,7 @@ relationBinopTerm[CVC4::api::Term& f] * 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; @@ -1772,7 +1772,7 @@ postfixTerm[CVC4::api::Term& f] 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 */ @@ -1834,19 +1834,19 @@ postfixTerm[CVC4::api::Term& f] ) )* | 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] @@ -1856,12 +1856,12 @@ postfixTerm[CVC4::api::Term& f] )? ; -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; @@ -1873,30 +1873,30 @@ relationTerm[CVC4::api::Term& f] 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 @@ -1907,7 +1907,7 @@ bvTerm[CVC4::api::Term& f] 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 @@ -1917,7 +1917,7 @@ bvTerm[CVC4::api::Term& f] } 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 @@ -1927,32 +1927,32 @@ bvTerm[CVC4::api::Term& f] } 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(); @@ -1983,25 +1983,25 @@ bvTerm[CVC4::api::Term& f] /* 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; @@ -2011,67 +2011,67 @@ stringTerm[CVC4::api::Term& f] /* 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(CVC4::api::REGEXP_EMPTY, std::vector<api::Term>()); } + { f = MK_TERM(CVC5::api::REGEXP_EMPTY, std::vector<api::Term>()); } | REGEXP_SIGMA_TOK - { f = MK_TERM(CVC4::api::REGEXP_SIGMA, std::vector<api::Term>()); } + { f = MK_TERM(CVC5::api::REGEXP_SIGMA, std::vector<api::Term>()); } /* string literal */ | str[s] @@ -2080,20 +2080,20 @@ stringTerm[CVC4::api::Term& f] | 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; @@ -2234,7 +2234,7 @@ simpleTerm[CVC4::api::Term& f] 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); } } ; @@ -2243,7 +2243,7 @@ simpleTerm[CVC4::api::Term& 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] @@ -2252,14 +2252,14 @@ typeAscription[const CVC4::api::Term& f, CVC4::api::Sort& t] /** * 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; @@ -2268,13 +2268,13 @@ iteTerm[CVC4::api::Term& f] 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; @@ -2283,13 +2283,13 @@ iteElseTerm[CVC4::api::Term& f] | 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; @@ -2324,14 +2324,14 @@ datatypeDef[std::vector<CVC4::api::DatatypeDecl>& datatypes] /** * 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 @@ -2345,7 +2345,7 @@ constructorDef[CVC4::api::DatatypeDecl& type] } ; -selector[std::unique_ptr<CVC4::api::DatatypeConstructorDecl>* ctor] +selector[std::unique_ptr<CVC5::api::DatatypeConstructorDecl>* ctor] @init { std::string id; api::Sort t, t2; @@ -2377,7 +2377,7 @@ numeral returns [unsigned k = 0] /** * 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 diff --git a/src/parser/cvc/cvc.cpp b/src/parser/cvc/cvc.cpp index c68cef39c..3cd486981 100644 --- a/src/parser/cvc/cvc.cpp +++ b/src/parser/cvc/cvc.cpp @@ -17,7 +17,7 @@ #include "parser/cvc/cvc.h" #include "smt/command.h" -namespace CVC4 { +namespace CVC5 { namespace parser { void Cvc::forceLogic(const std::string& logic) @@ -35,4 +35,4 @@ bool Cvc::getTesterName(api::Term cons, std::string& name) } } // namespace parser -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/parser/cvc/cvc.h b/src/parser/cvc/cvc.h index 400ed0d4a..c36e36979 100644 --- a/src/parser/cvc/cvc.h +++ b/src/parser/cvc/cvc.h @@ -22,7 +22,7 @@ #include "api/cvc4cpp.h" #include "parser/parser.h" -namespace CVC4 { +namespace CVC5 { namespace parser { @@ -48,6 +48,6 @@ class Cvc : public Parser }; } // namespace parser -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PARSER__CVC_H */ diff --git a/src/parser/cvc/cvc_input.cpp b/src/parser/cvc/cvc_input.cpp index 50a85bf01..a4a9c27f2 100644 --- a/src/parser/cvc/cvc_input.cpp +++ b/src/parser/cvc/cvc_input.cpp @@ -24,7 +24,7 @@ #include "parser/cvc/CvcParser.h" #include "parser/parser_exception.h" -namespace CVC4 { +namespace CVC5 { namespace parser { /* Use lookahead=3 */ @@ -72,5 +72,5 @@ pANTLR3_LEXER CvcInput::getLexer() { } */ -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/cvc/cvc_input.h b/src/parser/cvc/cvc_input.h index 64a0e7f77..c9862916a 100644 --- a/src/parser/cvc/cvc_input.h +++ b/src/parser/cvc/cvc_input.h @@ -23,9 +23,10 @@ #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; @@ -71,7 +72,7 @@ class CvcInput : public AntlrInput { }; // class CvcInput -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__CVC_INPUT_H */ diff --git a/src/parser/input.cpp b/src/parser/input.cpp index 8a9a2ee8a..d0c71bd13 100644 --- a/src/parser/input.cpp +++ b/src/parser/input.cpp @@ -25,11 +25,11 @@ 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) : @@ -79,5 +79,5 @@ Input* Input::newStringInput(InputLanguage lang, return AntlrInput::newInput(lang, *inputStream); } -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/input.h b/src/parser/input.h index f6be43028..2a401521c 100644 --- a/src/parser/input.h +++ b/src/parser/input.h @@ -30,7 +30,7 @@ #include "options/language.h" #include "parser/parser_exception.h" -namespace CVC4 { +namespace CVC5 { class Command; @@ -176,7 +176,7 @@ class CVC4_EXPORT Input }; /* class Input */ -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__ANTLR_INPUT_H */ diff --git a/src/parser/line_buffer.cpp b/src/parser/line_buffer.cpp index 967503f0f..1675d8f99 100644 --- a/src/parser/line_buffer.cpp +++ b/src/parser/line_buffer.cpp @@ -22,7 +22,7 @@ #include "base/check.h" -namespace CVC4 { +namespace CVC5 { namespace parser { LineBuffer::LineBuffer(std::istream* stream) : d_stream(stream) {} @@ -90,4 +90,4 @@ bool LineBuffer::readToLine(size_t line_size) } } // namespace parser -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/parser/line_buffer.h b/src/parser/line_buffer.h index b2d792076..3625ade87 100644 --- a/src/parser/line_buffer.h +++ b/src/parser/line_buffer.h @@ -25,7 +25,7 @@ #include <istream> #include <vector> -namespace CVC4 { +namespace CVC5 { namespace parser { class LineBuffer { @@ -71,6 +71,6 @@ class LineBuffer { }; } // namespace parser -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PARSER__LINE_BUFFER_H */ diff --git a/src/parser/memory_mapped_input_buffer.cpp b/src/parser/memory_mapped_input_buffer.cpp index 8fca6c6eb..04a2ef2eb 100644 --- a/src/parser/memory_mapped_input_buffer.cpp +++ b/src/parser/memory_mapped_input_buffer.cpp @@ -30,7 +30,7 @@ #include "base/exception.h" #include "parser/memory_mapped_input_buffer.h" -namespace CVC4 { +namespace CVC5 { namespace parser { extern "C" { @@ -129,5 +129,5 @@ void UnmapFile(pANTLR3_INPUT_STREAM input) { }/* extern "C" */ -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/memory_mapped_input_buffer.h b/src/parser/memory_mapped_input_buffer.h index ea48d1e3a..31f15d459 100644 --- a/src/parser/memory_mapped_input_buffer.h +++ b/src/parser/memory_mapped_input_buffer.h @@ -22,7 +22,7 @@ #include <antlr3input.h> #include <string> -namespace CVC4 { +namespace CVC5 { namespace parser { #ifdef __cplusplus @@ -36,7 +36,7 @@ MemoryMappedInputBufferNew(const std::string& filename); }/* extern "C" */ #endif -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__MEMORY_MAPPED_INPUT_BUFFER_H */ diff --git a/src/parser/parse_op.cpp b/src/parser/parse_op.cpp index c056f4140..377958ecd 100644 --- a/src/parser/parse_op.cpp +++ b/src/parser/parse_op.cpp @@ -14,7 +14,7 @@ #include "parser/parse_op.h" -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& os, const ParseOp& p) { @@ -44,4 +44,4 @@ std::ostream& operator<<(std::ostream& os, const ParseOp& p) return os << out.str(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/parser/parse_op.h b/src/parser/parse_op.h index e5de7c998..1c508a92e 100644 --- a/src/parser/parse_op.h +++ b/src/parser/parse_op.h @@ -21,7 +21,7 @@ #include "api/cvc4cpp.h" -namespace CVC4 { +namespace CVC5 { /** A parsed operator * @@ -79,6 +79,6 @@ struct ParseOp std::ostream& operator<<(std::ostream& os, const ParseOp& p); -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PARSER__PARSE_OP_H */ diff --git a/src/parser/parser.cpp b/src/parser/parser.cpp index 086792375..a4268e74e 100644 --- a/src/parser/parser.cpp +++ b/src/parser/parser.cpp @@ -33,9 +33,9 @@ #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, @@ -908,5 +908,5 @@ api::Term Parser::mkStringConstant(const std::string& s) return d_solver->mkString(str); } -} /* CVC4::parser namespace */ -} /* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/parser.h b/src/parser/parser.h index c2fad6656..0ae63cdd1 100644 --- a/src/parser/parser.h +++ b/src/parser/parser.h @@ -33,7 +33,7 @@ #include "parser/parser_exception.h" #include "util/unsafe_interrupt_exception.h" -namespace CVC4 { +namespace CVC5 { // Forward declarations class Command; @@ -773,7 +773,7 @@ public: 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 */ diff --git a/src/parser/parser_builder.cpp b/src/parser/parser_builder.cpp index f47558418..ffd993383 100644 --- a/src/parser/parser_builder.cpp +++ b/src/parser/parser_builder.cpp @@ -29,7 +29,7 @@ #include "smt2/smt2.h" #include "tptp/tptp.h" -namespace CVC4 { +namespace CVC5 { namespace parser { ParserBuilder::ParserBuilder(api::Solver* solver, @@ -217,5 +217,5 @@ ParserBuilder& ParserBuilder::withStringInput(const std::string& input) { return *this; } -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/parser_builder.h b/src/parser/parser_builder.h index c5de761b8..8ec59d4b2 100644 --- a/src/parser/parser_builder.h +++ b/src/parser/parser_builder.h @@ -25,7 +25,7 @@ #include "options/language.h" #include "parser/input.h" -namespace CVC4 { +namespace CVC5 { namespace api { class Solver; @@ -188,7 +188,7 @@ class CVC4_EXPORT ParserBuilder ParserBuilder& withForcedLogic(const std::string& logic); }; /* class ParserBuilder */ -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__PARSER_BUILDER_H */ diff --git a/src/parser/parser_exception.h b/src/parser/parser_exception.h index 8b6bd3b50..1863b39cd 100644 --- a/src/parser/parser_exception.h +++ b/src/parser/parser_exception.h @@ -26,7 +26,7 @@ #include "base/exception.h" #include "cvc4_export.h" -namespace CVC4 { +namespace CVC5 { namespace parser { class CVC4_EXPORT ParserException : public Exception @@ -99,7 +99,7 @@ class ParserEndOfFileException : public ParserException }; /* class ParserEndOfFileException */ -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__PARSER_EXCEPTION_H */ diff --git a/src/parser/smt2/Smt2.g b/src/parser/smt2/Smt2.g index e1e1f1cb1..e55cbf510 100644 --- a/src/parser/smt2/Smt2.g +++ b/src/parser/smt2/Smt2.g @@ -66,8 +66,8 @@ options { #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) @@ -83,7 +83,7 @@ using namespace CVC4::parser; #include "parser/parser.h" #include "smt/command.h" -namespace CVC4 { +namespace CVC5 { namespace api { class Term; @@ -113,8 +113,8 @@ namespace CVC4 { #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, @@ -136,9 +136,9 @@ using namespace CVC4::parser; * @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 @@ -148,9 +148,9 @@ parseExpr returns [CVC4::api::Term expr = CVC4::api::Term()] * 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 { @@ -184,7 +184,7 @@ parseCommand returns [CVC4::Command* cmd_return = NULL] * @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; } @@ -199,16 +199,16 @@ parseSygus returns [CVC4::Command* cmd_return = NULL] * 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] @@ -505,16 +505,16 @@ command [std::unique_ptr<CVC4::Command>* cmd] } ; -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(); } @@ -597,18 +597,18 @@ sygusCommand returns [std::unique_ptr<CVC4::Command> cmd] * 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; } : @@ -710,7 +710,7 @@ sygusGrammar[CVC4::api::Grammar*& ret, } ; -setInfoInternal[std::unique_ptr<CVC4::Command>* cmd] +setInfoInternal[std::unique_ptr<CVC5::Command>* cmd] @declarations { std::string name; api::Term sexpr; @@ -721,7 +721,7 @@ setInfoInternal[std::unique_ptr<CVC4::Command>* cmd] } ; -setOptionInternal[std::unique_ptr<CVC4::Command>* cmd] +setOptionInternal[std::unique_ptr<CVC5::Command>* cmd] @init { std::string name; api::Term sexpr; @@ -738,26 +738,26 @@ setOptionInternal[std::unique_ptr<CVC4::Command>* cmd] } ; -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(); } @@ -880,17 +880,17 @@ smt25Command[std::unique_ptr<CVC4::Command>* cmd] } ; -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 @@ -904,7 +904,7 @@ extendedCommand[std::unique_ptr<CVC4::Command>* cmd] { PARSER_STATE->checkThatLogicIsSet(); PARSER_STATE->checkLogicAllowsFreeSorts(); - seq.reset(new CVC4::CommandSequence()); + seq.reset(new CVC5::CommandSequence()); } LPAREN_TOK ( symbol[name,CHECK_UNDECLARED,SYM_SORT] @@ -917,7 +917,7 @@ extendedCommand[std::unique_ptr<CVC4::Command>* cmd] { 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); } @@ -942,7 +942,7 @@ extendedCommand[std::unique_ptr<CVC4::Command>* cmd] 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); } @@ -1074,7 +1074,7 @@ extendedCommand[std::unique_ptr<CVC4::Command>* cmd] ) ; -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; @@ -1090,7 +1090,7 @@ datatypeDefCommand[bool isCo, std::unique_ptr<CVC4::Command>* cmd] 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; @@ -1123,7 +1123,7 @@ datatypesDefCommand[bool isCo, std::unique_ptr<CVC4::Command>* cmd] 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; @@ -1239,7 +1239,7 @@ simpleSymbolicExpr[std::string& s] | KEYWORD { s = AntlrInput::tokenText($KEYWORD); } ; -symbolicExpr[CVC4::api::Term& sexpr] +symbolicExpr[CVC5::api::Term& sexpr] @declarations { std::string s; std::vector<api::Term> children; @@ -1248,19 +1248,19 @@ symbolicExpr[CVC4::api::Term& sexpr] { 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] @@ -1278,23 +1278,23 @@ term[CVC4::api::Term& expr, CVC4::api::Term& 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; @@ -1409,7 +1409,7 @@ termNonVariable[CVC4::api::Term& expr, CVC4::api::Term& expr2] )* 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); @@ -1577,12 +1577,12 @@ termNonVariable[CVC4::api::Term& expr, CVC4::api::Term& expr2] * 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 @@ -1608,10 +1608,10 @@ qualIdentifier[CVC4::ParseOp& p] * (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] @@ -1670,10 +1670,10 @@ identifier[CVC4::ParseOp& p] * 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; } @@ -1746,13 +1746,13 @@ termAtomic[CVC4::api::Term& atomTerm] /** * 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; } )? @@ -1811,13 +1811,13 @@ attribute[CVC4::api::Term& expr, CVC4::api::Term& retExpr, std::string& attr] * 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); } )+ ; @@ -1872,7 +1872,7 @@ str[std::string& s, bool fsmtlib] } ; -quantOp[CVC4::api::Kind& kind] +quantOp[CVC5::api::Kind& kind] @init { Debug("parser") << "quant: " << AntlrInput::tokenText(LT(1)) << std::endl; } @@ -1884,7 +1884,7 @@ quantOp[CVC4::api::Kind& kind] * 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] ; @@ -1892,16 +1892,16 @@ functionName[std::string& name, CVC4::parser::DeclarationCheck check] * 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); } )+ ; @@ -1910,10 +1910,10 @@ nonemptySortList[std::vector<CVC4::api::Sort>& sorts] * 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 @@ -1925,13 +1925,13 @@ sortedVarList[std::vector<std::pair<std::string, CVC4::api::Sort> >& sortedVars] * 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); } @@ -1941,14 +1941,14 @@ boundVarList[CVC4::api::Term& expr] * 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; } @@ -2070,8 +2070,8 @@ sortSymbol[CVC4::api::Sort& t, CVC4::parser::DeclarationCheck check] * 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; } @@ -2085,8 +2085,8 @@ symbolList[std::vector<std::string>& names, * @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)) { @@ -2125,8 +2125,8 @@ nonemptyNumeralList[std::vector<uint64_t>& numerals] /** * 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; } @@ -2145,10 +2145,10 @@ datatypeDef[bool isCo, std::vector<CVC4::api::DatatypeDecl>& datatypes, /** * 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] { @@ -2163,10 +2163,10 @@ constructorDef[CVC4::api::DatatypeDecl& type] } ; -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] { diff --git a/src/parser/smt2/smt2.cpp b/src/parser/smt2/smt2.cpp index a014e1349..e05401da0 100644 --- a/src/parser/smt2/smt2.cpp +++ b/src/parser/smt2/smt2.cpp @@ -28,7 +28,7 @@ #undef true #undef false -namespace CVC4 { +namespace CVC5 { namespace parser { Smt2::Smt2(api::Solver* solver, @@ -1209,4 +1209,4 @@ api::Term Smt2::mkAnd(const std::vector<api::Term>& es) } } // namespace parser -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/parser/smt2/smt2.h b/src/parser/smt2/smt2.h index a7fe65f67..ccb6456e7 100644 --- a/src/parser/smt2/smt2.h +++ b/src/parser/smt2/smt2.h @@ -31,7 +31,7 @@ #include "theory/logic_info.h" #include "util/abstract_value.h" -namespace CVC4 { +namespace CVC5 { class Command; @@ -430,6 +430,6 @@ class Smt2 : public Parser }; /* class Smt2 */ } // namespace parser -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PARSER__SMT2_H */ diff --git a/src/parser/smt2/smt2_input.cpp b/src/parser/smt2/smt2_input.cpp index c9019811b..3d6670469 100644 --- a/src/parser/smt2/smt2_input.cpp +++ b/src/parser/smt2/smt2_input.cpp @@ -26,7 +26,7 @@ #include "parser/smt2/Smt2Parser.h" #include "parser/smt2/smt2.h" -namespace CVC4 { +namespace CVC5 { namespace parser { /* Use lookahead=2 */ @@ -67,5 +67,5 @@ api::Term Smt2Input::parseExpr() return d_pSmt2Parser->parseExpr(d_pSmt2Parser); } -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/smt2/smt2_input.h b/src/parser/smt2/smt2_input.h index be8f37f52..0c5be3f97 100644 --- a/src/parser/smt2/smt2_input.h +++ b/src/parser/smt2/smt2_input.h @@ -23,9 +23,10 @@ #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; @@ -80,7 +81,7 @@ class Smt2Input : public AntlrInput { };/* class Smt2Input */ -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__SMT2_INPUT_H */ diff --git a/src/parser/smt2/sygus_input.cpp b/src/parser/smt2/sygus_input.cpp index 6487e5dd6..bdddd47e8 100644 --- a/src/parser/smt2/sygus_input.cpp +++ b/src/parser/smt2/sygus_input.cpp @@ -26,7 +26,7 @@ #include "parser/smt2/Smt2Parser.h" #include "parser/smt2/sygus_input.h" -namespace CVC4 { +namespace CVC5 { namespace parser { /* Use lookahead=2 */ @@ -68,5 +68,5 @@ api::Term SygusInput::parseExpr() return d_pSmt2Parser->parseExpr(d_pSmt2Parser); } -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/smt2/sygus_input.h b/src/parser/smt2/sygus_input.h index ac7f56856..38497dfd2 100644 --- a/src/parser/smt2/sygus_input.h +++ b/src/parser/smt2/sygus_input.h @@ -23,9 +23,10 @@ #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; @@ -80,7 +81,7 @@ class SygusInput : public AntlrInput { };/* class SygusInput */ -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__SYGUS_INPUT_H */ diff --git a/src/parser/tptp/Tptp.g b/src/parser/tptp/Tptp.g index 08e37392a..265784d48 100644 --- a/src/parser/tptp/Tptp.g +++ b/src/parser/tptp/Tptp.g @@ -65,8 +65,8 @@ options { #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.) */ @@ -108,8 +108,8 @@ using namespace CVC4::parser; #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.) */ @@ -127,10 +127,10 @@ using namespace CVC4::parser; /** * 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 ; @@ -139,9 +139,9 @@ parseExpr returns [CVC4::parser::tptp::myExpr expr] * 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; @@ -159,7 +159,7 @@ parseCommand returns [CVC4::Command* cmd = NULL] } (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); @@ -171,7 +171,7 @@ parseCommand returns [CVC4::Command* cmd = NULL] { 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); @@ -185,7 +185,7 @@ parseCommand returns [CVC4::Command* cmd = NULL] { 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); @@ -207,7 +207,7 @@ parseCommand returns [CVC4::Command* cmd = NULL] 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) @@ -242,7 +242,7 @@ parseCommand returns [CVC4::Command* cmd = NULL] { 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)); @@ -268,7 +268,7 @@ parseCommand returns [CVC4::Command* cmd = NULL] ; /* 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); @@ -296,12 +296,12 @@ formulaRole[CVC4::parser::Tptp::FormulaRole& role] /* 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; } @@ -313,16 +313,16 @@ cnfDisjunction[CVC4::api::Term& expr] } ; -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; } @@ -386,11 +386,11 @@ atomicFormula[CVC4::api::Term& expr] | 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)? @@ -432,12 +432,12 @@ thfAtomicFormula[CVC4::ParseOp& p] //%----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; @@ -497,7 +497,7 @@ definedPred[CVC4::ParseOp& p] } ; -thfDefinedPred[CVC4::ParseOp& p] +thfDefinedPred[CVC5::ParseOp& p] : '$less' { p.d_kind = api::LT; @@ -561,7 +561,7 @@ thfDefinedPred[CVC4::ParseOp& p] RPAREN_TOK ; -definedFun[CVC4::ParseOp& p] +definedFun[CVC5::ParseOp& p] @declarations { bool remainder = false; } @@ -724,16 +724,16 @@ equalOp[bool& equal] | 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 @@ -752,14 +752,14 @@ letTerm[CVC4::api::Term& expr] ; /* 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 { @@ -768,9 +768,9 @@ thfSimpleTerm[CVC4::api::Term& expr] } ; -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] @@ -780,15 +780,15 @@ functionTerm[CVC4::api::Term& 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; @@ -801,15 +801,15 @@ plainTerm[CVC4::api::Term& expr] } ; -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); @@ -824,13 +824,13 @@ variable[CVC4::api::Term& expr] /*******/ /* 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: <=> <~> ~& ~| @@ -870,10 +870,10 @@ fofLogicFormula[CVC4::api::Term& expr] )? ; -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 @@ -888,14 +888,14 @@ fofUnitaryFormula[CVC4::api::Term& expr] } ; -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; } @@ -904,7 +904,7 @@ fofBinaryNonAssoc[CVC4::parser::tptp::NonAssoc& na] | 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; } ; @@ -912,7 +912,7 @@ folQuantifier[CVC4::api::Kind& kind] /*******/ /* 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; } @@ -930,11 +930,11 @@ thfQuantifier[CVC4::api::Kind& kind] } ; -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 @@ -988,7 +988,7 @@ thfAtomTyping[CVC4::Command*& cmd] else { // as of yet, it's undeclared - CVC4::api::Term freshExpr; + CVC5::api::Term freshExpr; if (type.isFunction()) { freshExpr = PARSER_STATE->bindVar(name, type); @@ -1003,12 +1003,12 @@ thfAtomTyping[CVC4::Command*& cmd] ) ; -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; } @@ -1194,7 +1194,7 @@ thfLogicFormula[CVC4::ParseOp& p] )? ; -thfTupleForm[std::vector<CVC4::api::Term>& args] +thfTupleForm[std::vector<CVC5::api::Term>& args] @declarations { ParseOp p; } @@ -1217,11 +1217,11 @@ thfTupleForm[std::vector<CVC4::api::Term>& args] )+ ; -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; } @@ -1289,12 +1289,12 @@ thfUnitaryFormula[CVC4::ParseOp& p] /*******/ /* 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 @@ -1327,18 +1327,18 @@ tffTypedAtom[CVC4::Command*& cmd] } } 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 <=> <~> ~& ~| @@ -1378,11 +1378,11 @@ tffLogicFormula[CVC4::api::Term& expr] )? ; -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 @@ -1413,17 +1413,17 @@ tffUnitaryFormula[CVC4::api::Term& expr] 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); @@ -1438,17 +1438,17 @@ tffLetTermBinding[std::vector<CVC4::api::Term> & bvlist, | 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] { @@ -1464,10 +1464,10 @@ tffLetFormulaBinding[std::vector<CVC4::api::Term> & bvlist, | 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); } @@ -1478,9 +1478,9 @@ thfBindVariable[CVC4::api::Term& expr] ; -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] )? @@ -1491,18 +1491,18 @@ tffbindvariable[CVC4::api::Term& expr] // 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); } ( @@ -1522,17 +1522,17 @@ parseThfType[CVC4::api::Sort& 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); } @@ -1546,7 +1546,7 @@ parseType[CVC4::api::Sort & type] ; // non-function types -simpleType[CVC4::api::Sort& type] +simpleType[CVC5::api::Sort& type] @declarations { std::string name; } diff --git a/src/parser/tptp/tptp.cpp b/src/parser/tptp/tptp.cpp index 1177c8010..e6b4969c3 100644 --- a/src/parser/tptp/tptp.cpp +++ b/src/parser/tptp/tptp.cpp @@ -28,7 +28,7 @@ #undef true #undef false -namespace CVC4 { +namespace CVC5 { namespace parser { Tptp::Tptp(api::Solver* solver, @@ -202,7 +202,7 @@ void Tptp::checkLetBinding(const std::vector<api::Term>& bvlist, { parseError("malformed let: LHS must be formula"); } - for (const CVC4::api::Term& var : vars) + for (const CVC5::api::Term& var : vars) { if (var.hasOp()) { @@ -568,5 +568,5 @@ Command* Tptp::makeAssertCommand(FormulaRole fr, } } -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/tptp/tptp.h b/src/parser/tptp/tptp.h index 76ae4ee3e..318ef7f4a 100644 --- a/src/parser/tptp/tptp.h +++ b/src/parser/tptp/tptp.h @@ -27,7 +27,7 @@ #include "parser/parser.h" #include "util/hash.h" -namespace CVC4 { +namespace CVC5 { class Command; @@ -218,12 +218,12 @@ namespace tptp { * 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 { @@ -235,10 +235,9 @@ 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 */ diff --git a/src/parser/tptp/tptp_input.cpp b/src/parser/tptp/tptp_input.cpp index 97021b4e9..f3489f3fe 100644 --- a/src/parser/tptp/tptp_input.cpp +++ b/src/parser/tptp/tptp_input.cpp @@ -26,7 +26,7 @@ #include "parser/tptp/TptpParser.h" #include "parser/tptp/tptp.h" -namespace CVC4 { +namespace CVC5 { namespace parser { /* Use lookahead=2 */ @@ -68,5 +68,5 @@ api::Term TptpInput::parseExpr() return d_pTptpParser->parseExpr(d_pTptpParser); } -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 diff --git a/src/parser/tptp/tptp_input.h b/src/parser/tptp/tptp_input.h index 4280c51ef..bfe8562fc 100644 --- a/src/parser/tptp/tptp_input.h +++ b/src/parser/tptp/tptp_input.h @@ -23,9 +23,10 @@ #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; @@ -80,7 +81,7 @@ class TptpInput : public AntlrInput { };/* class TptpInput */ -}/* CVC4::parser namespace */ -}/* CVC4 namespace */ +} // namespace parser +} // namespace CVC5 #endif /* CVC4__PARSER__TPTP_INPUT_H */ diff --git a/src/preprocessing/assertion_pipeline.cpp b/src/preprocessing/assertion_pipeline.cpp index 42c386220..ab3e950b9 100644 --- a/src/preprocessing/assertion_pipeline.cpp +++ b/src/preprocessing/assertion_pipeline.cpp @@ -23,7 +23,7 @@ #include "theory/builtin/proof_checker.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { AssertionPipeline::AssertionPipeline() @@ -212,4 +212,4 @@ void AssertionPipeline::conjoin(size_t i, Node n, ProofGenerator* pg) } } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/assertion_pipeline.h b/src/preprocessing/assertion_pipeline.h index 71a992e3c..454606315 100644 --- a/src/preprocessing/assertion_pipeline.h +++ b/src/preprocessing/assertion_pipeline.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { class ProofGenerator; namespace smt { @@ -198,6 +198,6 @@ class AssertionPipeline }; /* class AssertionPipeline */ } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__ASSERTION_PIPELINE_H */ diff --git a/src/preprocessing/passes/ackermann.cpp b/src/preprocessing/passes/ackermann.cpp index 198ce6f1f..a67861664 100644 --- a/src/preprocessing/passes/ackermann.cpp +++ b/src/preprocessing/passes/ackermann.cpp @@ -32,10 +32,10 @@ #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 { @@ -336,4 +336,4 @@ PreprocessingPassResult Ackermann::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/ackermann.h b/src/preprocessing/passes/ackermann.h index f74d8cb27..e177b4270 100644 --- a/src/preprocessing/passes/ackermann.h +++ b/src/preprocessing/passes/ackermann.h @@ -33,7 +33,7 @@ #include "theory/logic_info.h" #include "theory/substitutions.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -82,6 +82,6 @@ class Ackermann : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__ACKERMANN_H */ diff --git a/src/preprocessing/passes/apply_substs.cpp b/src/preprocessing/passes/apply_substs.cpp index f706ea7e3..16f06540e 100644 --- a/src/preprocessing/passes/apply_substs.cpp +++ b/src/preprocessing/passes/apply_substs.cpp @@ -23,7 +23,7 @@ #include "theory/rewriter.h" #include "theory/substitutions.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -63,4 +63,4 @@ PreprocessingPassResult ApplySubsts::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/apply_substs.h b/src/preprocessing/passes/apply_substs.h index 7f206387f..6345f35dd 100644 --- a/src/preprocessing/passes/apply_substs.h +++ b/src/preprocessing/passes/apply_substs.h @@ -22,7 +22,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { class PreprocessingPassContext; @@ -46,6 +46,6 @@ class ApplySubsts : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/preprocessing/passes/bool_to_bv.cpp b/src/preprocessing/passes/bool_to_bv.cpp index 62c747bc3..042bc3e01 100644 --- a/src/preprocessing/passes/bool_to_bv.cpp +++ b/src/preprocessing/passes/bool_to_bv.cpp @@ -26,10 +26,10 @@ #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() @@ -422,4 +422,4 @@ BoolToBV::Statistics::~Statistics() } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/bool_to_bv.h b/src/preprocessing/passes/bool_to_bv.h index 357acd374..885c57302 100644 --- a/src/preprocessing/passes/bool_to_bv.h +++ b/src/preprocessing/passes/bool_to_bv.h @@ -23,7 +23,7 @@ #include "preprocessing/preprocessing_pass.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -121,6 +121,6 @@ class BoolToBV : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__BOOL_TO_BV_H */ diff --git a/src/preprocessing/passes/bv_abstraction.cpp b/src/preprocessing/passes/bv_abstraction.cpp index 539cc3b36..045b4295b 100644 --- a/src/preprocessing/passes/bv_abstraction.cpp +++ b/src/preprocessing/passes/bv_abstraction.cpp @@ -32,11 +32,11 @@ #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"){}; @@ -60,4 +60,4 @@ PreprocessingPassResult BvAbstraction::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/bv_abstraction.h b/src/preprocessing/passes/bv_abstraction.h index 3e04aa6e1..b16a2f973 100644 --- a/src/preprocessing/passes/bv_abstraction.h +++ b/src/preprocessing/passes/bv_abstraction.h @@ -28,7 +28,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -44,6 +44,6 @@ class BvAbstraction : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__BV_ABSTRACTION_H */ diff --git a/src/preprocessing/passes/bv_eager_atoms.cpp b/src/preprocessing/passes/bv_eager_atoms.cpp index 2158a7299..15b7662c4 100644 --- a/src/preprocessing/passes/bv_eager_atoms.cpp +++ b/src/preprocessing/passes/bv_eager_atoms.cpp @@ -22,7 +22,7 @@ #include "theory/theory_engine.h" #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -47,4 +47,4 @@ PreprocessingPassResult BvEagerAtoms::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/bv_eager_atoms.h b/src/preprocessing/passes/bv_eager_atoms.h index 6fe17115e..a3c7a424a 100644 --- a/src/preprocessing/passes/bv_eager_atoms.h +++ b/src/preprocessing/passes/bv_eager_atoms.h @@ -22,7 +22,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -38,6 +38,6 @@ class BvEagerAtoms : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__BV_EAGER_ATOMS_H */ diff --git a/src/preprocessing/passes/bv_gauss.cpp b/src/preprocessing/passes/bv_gauss.cpp index e1e4b20a2..2ec12256a 100644 --- a/src/preprocessing/passes/bv_gauss.cpp +++ b/src/preprocessing/passes/bv_gauss.cpp @@ -28,11 +28,11 @@ #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 { @@ -704,7 +704,7 @@ PreprocessingPassResult BVGauss::applyInternal( { Node a = assertions.back(); assertions.pop_back(); - CVC4::Kind k = a.getKind(); + CVC5::Kind k = a.getKind(); if (k == kind::AND) { @@ -800,4 +800,4 @@ PreprocessingPassResult BVGauss::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/bv_gauss.h b/src/preprocessing/passes/bv_gauss.h index c677a0f87..d06071867 100644 --- a/src/preprocessing/passes/bv_gauss.h +++ b/src/preprocessing/passes/bv_gauss.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -104,6 +104,6 @@ class BVGauss : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/preprocessing/passes/bv_intro_pow2.cpp b/src/preprocessing/passes/bv_intro_pow2.cpp index 08fe0cbc9..c611c8af3 100644 --- a/src/preprocessing/passes/bv_intro_pow2.cpp +++ b/src/preprocessing/passes/bv_intro_pow2.cpp @@ -25,12 +25,12 @@ #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 { @@ -100,8 +100,7 @@ PreprocessingPassResult BvIntroPow2::applyInternal( return PreprocessingPassResult::NO_CONFLICT; } +} // namespace passes +} // namespace preprocessing -}/* CVC4::theory::bv namespace */ -}/* CVC4::theory namespace */ - -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/preprocessing/passes/bv_intro_pow2.h b/src/preprocessing/passes/bv_intro_pow2.h index 870eacf04..98e1efc1d 100644 --- a/src/preprocessing/passes/bv_intro_pow2.h +++ b/src/preprocessing/passes/bv_intro_pow2.h @@ -23,7 +23,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -39,6 +39,6 @@ class BvIntroPow2 : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__BV_INTRO_POW2_H */ diff --git a/src/preprocessing/passes/bv_to_bool.cpp b/src/preprocessing/passes/bv_to_bool.cpp index 014ddc170..5153f3b7f 100644 --- a/src/preprocessing/passes/bv_to_bool.cpp +++ b/src/preprocessing/passes/bv_to_bool.cpp @@ -30,12 +30,12 @@ #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"), @@ -310,4 +310,4 @@ BVToBool::Statistics::~Statistics() } // passes } // Preprocessing -} // CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/bv_to_bool.h b/src/preprocessing/passes/bv_to_bool.h index 17d02c82a..45fa4a5df 100644 --- a/src/preprocessing/passes/bv_to_bool.h +++ b/src/preprocessing/passes/bv_to_bool.h @@ -23,7 +23,7 @@ #include "preprocessing/preprocessing_pass.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -73,6 +73,6 @@ class BVToBool : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__BV_TO_BOOL_H */ diff --git a/src/preprocessing/passes/bv_to_int.cpp b/src/preprocessing/passes/bv_to_int.cpp index f5e81bb9c..f7a87d51f 100644 --- a/src/preprocessing/passes/bv_to_int.cpp +++ b/src/preprocessing/passes/bv_to_int.cpp @@ -33,13 +33,13 @@ #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 { @@ -1046,4 +1046,4 @@ Node BVToInt::createBVNotNode(Node n, uint64_t bvsize) } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/bv_to_int.h b/src/preprocessing/passes/bv_to_int.h index 21587a6b4..bc949bff2 100644 --- a/src/preprocessing/passes/bv_to_int.h +++ b/src/preprocessing/passes/bv_to_int.h @@ -73,7 +73,7 @@ #include "preprocessing/preprocessing_pass.h" #include "theory/arith/nl/iand_utils.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -285,6 +285,6 @@ class BVToInt : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* __CVC4__PREPROCESSING__PASSES__BV_TO_INT_H */ diff --git a/src/preprocessing/passes/extended_rewriter_pass.cpp b/src/preprocessing/passes/extended_rewriter_pass.cpp index 78898a3dc..245c889d3 100644 --- a/src/preprocessing/passes/extended_rewriter_pass.cpp +++ b/src/preprocessing/passes/extended_rewriter_pass.cpp @@ -21,7 +21,7 @@ #include "preprocessing/preprocessing_pass_context.h" #include "theory/quantifiers/extended_rewrite.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -43,4 +43,4 @@ PreprocessingPassResult ExtRewPre::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/extended_rewriter_pass.h b/src/preprocessing/passes/extended_rewriter_pass.h index 0b921ad46..60ab6af98 100644 --- a/src/preprocessing/passes/extended_rewriter_pass.h +++ b/src/preprocessing/passes/extended_rewriter_pass.h @@ -21,7 +21,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -37,6 +37,6 @@ class ExtRewPre : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__EXTENDED_REWRITER_PASS_H */ diff --git a/src/preprocessing/passes/foreign_theory_rewrite.cpp b/src/preprocessing/passes/foreign_theory_rewrite.cpp index b4e6107cc..c1a995469 100644 --- a/src/preprocessing/passes/foreign_theory_rewrite.cpp +++ b/src/preprocessing/passes/foreign_theory_rewrite.cpp @@ -22,11 +22,11 @@ #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()){}; @@ -149,4 +149,4 @@ PreprocessingPassResult ForeignTheoryRewrite::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/foreign_theory_rewrite.h b/src/preprocessing/passes/foreign_theory_rewrite.h index c693a1192..e50909617 100644 --- a/src/preprocessing/passes/foreign_theory_rewrite.h +++ b/src/preprocessing/passes/foreign_theory_rewrite.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -62,6 +62,6 @@ class ForeignTheoryRewrite : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__FOREIGN_THEORY_REWRITE_H */ diff --git a/src/preprocessing/passes/fun_def_fmf.cpp b/src/preprocessing/passes/fun_def_fmf.cpp index 312437c38..b34df8ca3 100644 --- a/src/preprocessing/passes/fun_def_fmf.cpp +++ b/src/preprocessing/passes/fun_def_fmf.cpp @@ -26,11 +26,11 @@ #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 { @@ -466,4 +466,4 @@ void FunDefFmf::getConstraints(Node n, } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/fun_def_fmf.h b/src/preprocessing/passes/fun_def_fmf.h index 90f3829f6..194c520ab 100644 --- a/src/preprocessing/passes/fun_def_fmf.h +++ b/src/preprocessing/passes/fun_def_fmf.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -100,6 +100,6 @@ class FunDefFmf : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__SYGUS_INFERENCE_H_ */ diff --git a/src/preprocessing/passes/global_negate.cpp b/src/preprocessing/passes/global_negate.cpp index 364e44e09..60f584225 100644 --- a/src/preprocessing/passes/global_negate.cpp +++ b/src/preprocessing/passes/global_negate.cpp @@ -21,10 +21,10 @@ #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 { @@ -124,4 +124,4 @@ PreprocessingPassResult GlobalNegate::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/global_negate.h b/src/preprocessing/passes/global_negate.h index 857664838..2e9dbdcb7 100644 --- a/src/preprocessing/passes/global_negate.h +++ b/src/preprocessing/passes/global_negate.h @@ -29,7 +29,7 @@ #include "expr/node.h" #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -48,6 +48,6 @@ class GlobalNegate : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING_PASSES__GLOBAL_NEGATE_H */ diff --git a/src/preprocessing/passes/ho_elim.cpp b/src/preprocessing/passes/ho_elim.cpp index 284fbc72b..13a59a92d 100644 --- a/src/preprocessing/passes/ho_elim.cpp +++ b/src/preprocessing/passes/ho_elim.cpp @@ -24,9 +24,9 @@ #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 { @@ -539,4 +539,4 @@ TypeNode HoElim::getUSort(TypeNode tn) } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/ho_elim.h b/src/preprocessing/passes/ho_elim.h index d7a0de599..36aa53acf 100644 --- a/src/preprocessing/passes/ho_elim.h +++ b/src/preprocessing/passes/ho_elim.h @@ -26,7 +26,7 @@ #include "expr/node.h" #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -150,6 +150,6 @@ class HoElim : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* __CVC4__PREPROCESSING__PASSES__HO_ELIM_PASS_H */ diff --git a/src/preprocessing/passes/int_to_bv.cpp b/src/preprocessing/passes/int_to_bv.cpp index e857b7b61..bf59a7311 100644 --- a/src/preprocessing/passes/int_to_bv.cpp +++ b/src/preprocessing/passes/int_to_bv.cpp @@ -29,12 +29,12 @@ #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>; @@ -267,4 +267,4 @@ PreprocessingPassResult IntToBV::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/int_to_bv.h b/src/preprocessing/passes/int_to_bv.h index 774d8cb46..a6eda934f 100644 --- a/src/preprocessing/passes/int_to_bv.h +++ b/src/preprocessing/passes/int_to_bv.h @@ -23,7 +23,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -39,6 +39,6 @@ class IntToBV : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__INT_TO_BV_H */ diff --git a/src/preprocessing/passes/ite_removal.cpp b/src/preprocessing/passes/ite_removal.cpp index afa1d3ba2..91b805004 100644 --- a/src/preprocessing/passes/ite_removal.cpp +++ b/src/preprocessing/passes/ite_removal.cpp @@ -25,11 +25,11 @@ #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) @@ -79,4 +79,4 @@ PreprocessingPassResult IteRemoval::applyInternal(AssertionPipeline* assertions) } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/ite_removal.h b/src/preprocessing/passes/ite_removal.h index 3881eab2d..ceb9af4ac 100644 --- a/src/preprocessing/passes/ite_removal.h +++ b/src/preprocessing/passes/ite_removal.h @@ -22,7 +22,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -37,6 +37,6 @@ class IteRemoval : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__PREPROCESSING__PASSES__ITE_REMOVAL_H diff --git a/src/preprocessing/passes/ite_simp.cpp b/src/preprocessing/passes/ite_simp.cpp index e298b39e2..8b9ad9587 100644 --- a/src/preprocessing/passes/ite_simp.cpp +++ b/src/preprocessing/passes/ite_simp.cpp @@ -26,10 +26,10 @@ #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 { @@ -97,7 +97,7 @@ void compressBeforeRealAssertions(AssertionPipeline* assertionsToPreprocess, 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); } @@ -262,4 +262,4 @@ PreprocessingPassResult ITESimp::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/ite_simp.h b/src/preprocessing/passes/ite_simp.h index 110ce6057..e5ab27620 100644 --- a/src/preprocessing/passes/ite_simp.h +++ b/src/preprocessing/passes/ite_simp.h @@ -21,7 +21,7 @@ #include "preprocessing/util/ite_utilities.h" #include "util/stats_histogram.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -52,6 +52,6 @@ class ITESimp : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/preprocessing/passes/miplib_trick.cpp b/src/preprocessing/passes/miplib_trick.cpp index f6ae77bc2..a810d3e19 100644 --- a/src/preprocessing/passes/miplib_trick.cpp +++ b/src/preprocessing/passes/miplib_trick.cpp @@ -30,12 +30,12 @@ #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 { @@ -667,4 +667,4 @@ MipLibTrick::Statistics::~Statistics() } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/miplib_trick.h b/src/preprocessing/passes/miplib_trick.h index 66622d06a..61bf40040 100644 --- a/src/preprocessing/passes/miplib_trick.h +++ b/src/preprocessing/passes/miplib_trick.h @@ -21,7 +21,7 @@ #include "expr/node.h" #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -57,6 +57,6 @@ class MipLibTrick : public PreprocessingPass, public NodeManagerListener } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__MIPLIB_TRICK_H */ diff --git a/src/preprocessing/passes/nl_ext_purify.cpp b/src/preprocessing/passes/nl_ext_purify.cpp index 1f85f0caf..3bc8ff8dd 100644 --- a/src/preprocessing/passes/nl_ext_purify.cpp +++ b/src/preprocessing/passes/nl_ext_purify.cpp @@ -19,12 +19,12 @@ #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, @@ -140,4 +140,4 @@ PreprocessingPassResult NlExtPurify::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/nl_ext_purify.h b/src/preprocessing/passes/nl_ext_purify.h index c49336308..c9b5c344c 100644 --- a/src/preprocessing/passes/nl_ext_purify.h +++ b/src/preprocessing/passes/nl_ext_purify.h @@ -26,7 +26,7 @@ #include "expr/node.h" #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -51,6 +51,6 @@ class NlExtPurify : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__NL_EXT_PURIFY_H */ diff --git a/src/preprocessing/passes/non_clausal_simp.cpp b/src/preprocessing/passes/non_clausal_simp.cpp index b03d21dd9..29e7233c0 100644 --- a/src/preprocessing/passes/non_clausal_simp.cpp +++ b/src/preprocessing/passes/non_clausal_simp.cpp @@ -30,10 +30,10 @@ #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 { @@ -491,4 +491,4 @@ Node NonClausalSimp::processRewrittenLearnedLit(theory::TrustNode trn) } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/non_clausal_simp.h b/src/preprocessing/passes/non_clausal_simp.h index 27fac3f60..dfaa24a93 100644 --- a/src/preprocessing/passes/non_clausal_simp.h +++ b/src/preprocessing/passes/non_clausal_simp.h @@ -22,7 +22,7 @@ #include "preprocessing/preprocessing_pass.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { class LazyCDProof; class ProofNodeManager; @@ -97,6 +97,6 @@ class NonClausalSimp : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/preprocessing/passes/pseudo_boolean_processor.cpp b/src/preprocessing/passes/pseudo_boolean_processor.cpp index bc410a70a..5ce7338f3 100644 --- a/src/preprocessing/passes/pseudo_boolean_processor.cpp +++ b/src/preprocessing/passes/pseudo_boolean_processor.cpp @@ -24,12 +24,12 @@ #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) @@ -418,4 +418,4 @@ void PseudoBooleanProcessor::clear() } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/pseudo_boolean_processor.h b/src/preprocessing/passes/pseudo_boolean_processor.h index 84f7f7f31..6e1b426bf 100644 --- a/src/preprocessing/passes/pseudo_boolean_processor.h +++ b/src/preprocessing/passes/pseudo_boolean_processor.h @@ -31,7 +31,7 @@ #include "util/maybe.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -110,6 +110,6 @@ class PseudoBooleanProcessor : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__PREPROCESSING__PASSES__PSEUDO_BOOLEAN_PROCESSOR_H diff --git a/src/preprocessing/passes/quantifier_macros.cpp b/src/preprocessing/passes/quantifier_macros.cpp index f0b51e6a5..b296f9c17 100644 --- a/src/preprocessing/passes/quantifier_macros.cpp +++ b/src/preprocessing/passes/quantifier_macros.cpp @@ -35,11 +35,11 @@ #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 { @@ -568,4 +568,4 @@ void QuantifierMacros::addMacro( Node op, Node n, std::vector< Node >& opc ) { } // passes } // preprocessing -} // CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/quantifier_macros.h b/src/preprocessing/passes/quantifier_macros.h index 3d6a56396..51b3c7951 100644 --- a/src/preprocessing/passes/quantifier_macros.h +++ b/src/preprocessing/passes/quantifier_macros.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -91,6 +91,6 @@ class QuantifierMacros : public PreprocessingPass } // passes } // preprocessing -} // CVC4 +} // namespace CVC5 #endif /*CVC4__PREPROCESSING__PASSES__QUANTIFIER_MACROS_H */ diff --git a/src/preprocessing/passes/quantifiers_preprocess.cpp b/src/preprocessing/passes/quantifiers_preprocess.cpp index af1eb5071..15f0fc54b 100644 --- a/src/preprocessing/passes/quantifiers_preprocess.cpp +++ b/src/preprocessing/passes/quantifiers_preprocess.cpp @@ -24,12 +24,12 @@ #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"){}; @@ -58,4 +58,4 @@ PreprocessingPassResult QuantifiersPreprocess::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/quantifiers_preprocess.h b/src/preprocessing/passes/quantifiers_preprocess.h index 1c0125217..b9ea842cb 100644 --- a/src/preprocessing/passes/quantifiers_preprocess.h +++ b/src/preprocessing/passes/quantifiers_preprocess.h @@ -24,7 +24,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -40,6 +40,6 @@ class QuantifiersPreprocess : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__QUANTIFIERS_PREPROCESS_H */ diff --git a/src/preprocessing/passes/real_to_int.cpp b/src/preprocessing/passes/real_to_int.cpp index 9c58250e3..bc8ba0b79 100644 --- a/src/preprocessing/passes/real_to_int.cpp +++ b/src/preprocessing/passes/real_to_int.cpp @@ -24,12 +24,12 @@ #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) { @@ -213,4 +213,4 @@ PreprocessingPassResult RealToInt::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/real_to_int.h b/src/preprocessing/passes/real_to_int.h index 7bfdfd428..5579e3faf 100644 --- a/src/preprocessing/passes/real_to_int.h +++ b/src/preprocessing/passes/real_to_int.h @@ -24,7 +24,7 @@ #include "expr/node.h" #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -45,6 +45,6 @@ class RealToInt : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__REAL_TO_INT_H */ diff --git a/src/preprocessing/passes/rewrite.cpp b/src/preprocessing/passes/rewrite.cpp index f1a4ec283..35c2e9926 100644 --- a/src/preprocessing/passes/rewrite.cpp +++ b/src/preprocessing/passes/rewrite.cpp @@ -19,12 +19,11 @@ #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"){}; @@ -43,4 +42,4 @@ PreprocessingPassResult Rewrite::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/rewrite.h b/src/preprocessing/passes/rewrite.h index 22400911f..4848c8a98 100644 --- a/src/preprocessing/passes/rewrite.h +++ b/src/preprocessing/passes/rewrite.h @@ -21,7 +21,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -37,7 +37,7 @@ class Rewrite : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__REWRITE_H */ diff --git a/src/preprocessing/passes/sep_skolem_emp.cpp b/src/preprocessing/passes/sep_skolem_emp.cpp index 381282b38..6100e0762 100644 --- a/src/preprocessing/passes/sep_skolem_emp.cpp +++ b/src/preprocessing/passes/sep_skolem_emp.cpp @@ -25,12 +25,12 @@ #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 { @@ -124,4 +124,4 @@ PreprocessingPassResult SepSkolemEmp::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/sep_skolem_emp.h b/src/preprocessing/passes/sep_skolem_emp.h index 51e421505..11e7bec24 100644 --- a/src/preprocessing/passes/sep_skolem_emp.h +++ b/src/preprocessing/passes/sep_skolem_emp.h @@ -20,7 +20,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -36,6 +36,6 @@ class SepSkolemEmp : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__SEP_SKOLEM_EMP_H */ diff --git a/src/preprocessing/passes/sort_infer.cpp b/src/preprocessing/passes/sort_infer.cpp index 6e399bcca..07c5e7cc5 100644 --- a/src/preprocessing/passes/sort_infer.cpp +++ b/src/preprocessing/passes/sort_infer.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -91,4 +91,4 @@ PreprocessingPassResult SortInferencePass::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/sort_infer.h b/src/preprocessing/passes/sort_infer.h index 74ae0bd2b..5874b4363 100644 --- a/src/preprocessing/passes/sort_infer.h +++ b/src/preprocessing/passes/sort_infer.h @@ -17,7 +17,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -38,6 +38,6 @@ class SortInferencePass : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__SORT_INFERENCE_PASS_H_ */ diff --git a/src/preprocessing/passes/static_learning.cpp b/src/preprocessing/passes/static_learning.cpp index 7b49de141..1cc2ce06f 100644 --- a/src/preprocessing/passes/static_learning.cpp +++ b/src/preprocessing/passes/static_learning.cpp @@ -23,7 +23,7 @@ #include "theory/rewriter.h" #include "theory/theory_engine.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -57,4 +57,4 @@ PreprocessingPassResult StaticLearning::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/static_learning.h b/src/preprocessing/passes/static_learning.h index e9c5d70f5..67bf053f9 100644 --- a/src/preprocessing/passes/static_learning.h +++ b/src/preprocessing/passes/static_learning.h @@ -20,7 +20,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -36,6 +36,6 @@ class StaticLearning : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__STATIC_LEARNING_H */ diff --git a/src/preprocessing/passes/strings_eager_pp.cpp b/src/preprocessing/passes/strings_eager_pp.cpp index 08f6a8de3..775a09441 100644 --- a/src/preprocessing/passes/strings_eager_pp.cpp +++ b/src/preprocessing/passes/strings_eager_pp.cpp @@ -18,9 +18,9 @@ #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 { @@ -57,4 +57,4 @@ PreprocessingPassResult StringsEagerPp::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/strings_eager_pp.h b/src/preprocessing/passes/strings_eager_pp.h index 16324368e..3af59766c 100644 --- a/src/preprocessing/passes/strings_eager_pp.h +++ b/src/preprocessing/passes/strings_eager_pp.h @@ -19,7 +19,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -39,6 +39,6 @@ class StringsEagerPp : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__STRINGS_EAGER_PP_H */ diff --git a/src/preprocessing/passes/sygus_inference.cpp b/src/preprocessing/passes/sygus_inference.cpp index ff60173ed..f05afe54f 100644 --- a/src/preprocessing/passes/sygus_inference.cpp +++ b/src/preprocessing/passes/sygus_inference.cpp @@ -27,10 +27,10 @@ #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 { @@ -345,4 +345,4 @@ bool SygusInference::solveSygus(const std::vector<Node>& assertions, } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/sygus_inference.h b/src/preprocessing/passes/sygus_inference.h index f9d8bf9dd..b31e5ca7c 100644 --- a/src/preprocessing/passes/sygus_inference.h +++ b/src/preprocessing/passes/sygus_inference.h @@ -20,7 +20,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -63,6 +63,6 @@ class SygusInference : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__SYGUS_INFERENCE_H_ */ diff --git a/src/preprocessing/passes/synth_rew_rules.cpp b/src/preprocessing/passes/synth_rew_rules.cpp index bf84ee76e..7213dc8a8 100644 --- a/src/preprocessing/passes/synth_rew_rules.cpp +++ b/src/preprocessing/passes/synth_rew_rules.cpp @@ -30,9 +30,9 @@ #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 { @@ -474,4 +474,4 @@ PreprocessingPassResult SynthRewRulesPass::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/synth_rew_rules.h b/src/preprocessing/passes/synth_rew_rules.h index 82adde0d6..eb52688e7 100644 --- a/src/preprocessing/passes/synth_rew_rules.h +++ b/src/preprocessing/passes/synth_rew_rules.h @@ -18,7 +18,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -71,6 +71,6 @@ class SynthRewRulesPass : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__SYNTH_REW_RULES_H */ diff --git a/src/preprocessing/passes/theory_preprocess.cpp b/src/preprocessing/passes/theory_preprocess.cpp index 1a6abd723..7112dd50f 100644 --- a/src/preprocessing/passes/theory_preprocess.cpp +++ b/src/preprocessing/passes/theory_preprocess.cpp @@ -24,11 +24,11 @@ #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"){}; @@ -72,4 +72,4 @@ PreprocessingPassResult TheoryPreprocess::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/theory_preprocess.h b/src/preprocessing/passes/theory_preprocess.h index fe5dcbd7c..bd450840e 100644 --- a/src/preprocessing/passes/theory_preprocess.h +++ b/src/preprocessing/passes/theory_preprocess.h @@ -21,7 +21,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -37,6 +37,6 @@ class TheoryPreprocess : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__THEORY_PREPROCESS_H */ diff --git a/src/preprocessing/passes/theory_rewrite_eq.cpp b/src/preprocessing/passes/theory_rewrite_eq.cpp index 79338d63b..c70458b91 100644 --- a/src/preprocessing/passes/theory_rewrite_eq.cpp +++ b/src/preprocessing/passes/theory_rewrite_eq.cpp @@ -18,9 +18,9 @@ #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 { @@ -116,4 +116,4 @@ theory::TrustNode TheoryRewriteEq::rewriteAssertion(TNode n) } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/theory_rewrite_eq.h b/src/preprocessing/passes/theory_rewrite_eq.h index ada99a7cb..626efe8e3 100644 --- a/src/preprocessing/passes/theory_rewrite_eq.h +++ b/src/preprocessing/passes/theory_rewrite_eq.h @@ -21,7 +21,7 @@ #include "preprocessing/preprocessing_pass.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace passes { @@ -51,6 +51,6 @@ class TheoryRewriteEq : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PASSES__THEORY_REWRITE_EQ_H */ diff --git a/src/preprocessing/passes/unconstrained_simplifier.cpp b/src/preprocessing/passes/unconstrained_simplifier.cpp index cf2e96c79..502889dd3 100644 --- a/src/preprocessing/passes/unconstrained_simplifier.cpp +++ b/src/preprocessing/passes/unconstrained_simplifier.cpp @@ -26,12 +26,12 @@ #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) @@ -880,4 +880,4 @@ PreprocessingPassResult UnconstrainedSimplifier::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/passes/unconstrained_simplifier.h b/src/preprocessing/passes/unconstrained_simplifier.h index 5609273da..da368de51 100644 --- a/src/preprocessing/passes/unconstrained_simplifier.h +++ b/src/preprocessing/passes/unconstrained_simplifier.h @@ -29,7 +29,7 @@ #include "theory/substitutions.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace context { class Context; } @@ -72,6 +72,6 @@ class UnconstrainedSimplifier : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/preprocessing/preprocessing_pass.cpp b/src/preprocessing/preprocessing_pass.cpp index 5741b19be..127b22758 100644 --- a/src/preprocessing/preprocessing_pass.cpp +++ b/src/preprocessing/preprocessing_pass.cpp @@ -24,7 +24,7 @@ #include "smt/smt_engine_scope.h" #include "smt/smt_statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { PreprocessingPassResult PreprocessingPass::apply( @@ -70,4 +70,4 @@ PreprocessingPass::~PreprocessingPass() { } } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/preprocessing_pass.h b/src/preprocessing/preprocessing_pass.h index 498c507d0..f112d5f54 100644 --- a/src/preprocessing/preprocessing_pass.h +++ b/src/preprocessing/preprocessing_pass.h @@ -36,7 +36,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { class AssertionPipeline; @@ -81,6 +81,6 @@ class PreprocessingPass { }; } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PREPROCESSING_PASS_H */ diff --git a/src/preprocessing/preprocessing_pass_context.cpp b/src/preprocessing/preprocessing_pass_context.cpp index 8cf885c27..3c64ce301 100644 --- a/src/preprocessing/preprocessing_pass_context.cpp +++ b/src/preprocessing/preprocessing_pass_context.cpp @@ -18,7 +18,7 @@ #include "expr/node_algorithm.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { PreprocessingPassContext::PreprocessingPassContext( @@ -61,4 +61,4 @@ ProofNodeManager* PreprocessingPassContext::getProofNodeManager() } } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/preprocessing_pass_context.h b/src/preprocessing/preprocessing_pass_context.h index d210f6b60..93563e3a2 100644 --- a/src/preprocessing/preprocessing_pass_context.h +++ b/src/preprocessing/preprocessing_pass_context.h @@ -26,7 +26,7 @@ #include "theory/trust_substitutions.h" #include "util/resource_manager.h" -namespace CVC4 { +namespace CVC5 { class SmtEngine; class TheoryEngine; namespace theory::booleans { @@ -106,6 +106,6 @@ class PreprocessingPassContext }; // class PreprocessingPassContext } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PREPROCESSING_PASS_CONTEXT_H */ diff --git a/src/preprocessing/preprocessing_pass_registry.cpp b/src/preprocessing/preprocessing_pass_registry.cpp index 271a3aba5..a46ce0205 100644 --- a/src/preprocessing/preprocessing_pass_registry.cpp +++ b/src/preprocessing/preprocessing_pass_registry.cpp @@ -59,10 +59,10 @@ #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() { @@ -158,4 +158,4 @@ PreprocessingPassRegistry::PreprocessingPassRegistry() } } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/preprocessing_pass_registry.h b/src/preprocessing/preprocessing_pass_registry.h index 4dbab05fe..4843b810b 100644 --- a/src/preprocessing/preprocessing_pass_registry.h +++ b/src/preprocessing/preprocessing_pass_registry.h @@ -23,7 +23,7 @@ #include <string> #include <unordered_map> -namespace CVC4 { +namespace CVC5 { namespace preprocessing { class PreprocessingPass; @@ -94,6 +94,6 @@ class PreprocessingPassRegistry { }; // class PreprocessingPassRegistry } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PREPROCESSING__PREPROCESSING_PASS_REGISTRY_H */ diff --git a/src/preprocessing/util/ite_utilities.cpp b/src/preprocessing/util/ite_utilities.cpp index 59c6184de..2b215f9b4 100644 --- a/src/preprocessing/util/ite_utilities.cpp +++ b/src/preprocessing/util/ite_utilities.cpp @@ -28,7 +28,7 @@ #include "theory/theory.h" using namespace std; -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace util { @@ -1909,4 +1909,4 @@ ITECareSimplifier::CareSetPtr ITECareSimplifier::CareSetPtr::mkNew( } // namespace util } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/preprocessing/util/ite_utilities.h b/src/preprocessing/util/ite_utilities.h index 90c240478..ff58bbacf 100644 --- a/src/preprocessing/util/ite_utilities.h +++ b/src/preprocessing/util/ite_utilities.h @@ -31,7 +31,7 @@ #include "util/statistics_registry.h" #include "util/stats_histogram.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { class AssertionPipeline; @@ -417,6 +417,6 @@ class ITECareSimplifier } // namespace util } // namespace preprocessing -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/printer/ast/ast_printer.cpp b/src/printer/ast/ast_printer.cpp index 3a9b20566..5d3fb1adc 100644 --- a/src/printer/ast/ast_printer.cpp +++ b/src/printer/ast/ast_printer.cpp @@ -29,7 +29,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace printer { namespace ast { @@ -473,6 +473,6 @@ static bool tryToStream(std::ostream& out, const CommandStatus* s) return false; } -}/* CVC4::printer::ast namespace */ -}/* CVC4::printer namespace */ -}/* CVC4 namespace */ +} // namespace ast +} // namespace printer +} // namespace CVC5 diff --git a/src/printer/ast/ast_printer.h b/src/printer/ast/ast_printer.h index 3564ff592..985cf9872 100644 --- a/src/printer/ast/ast_printer.h +++ b/src/printer/ast/ast_printer.h @@ -23,17 +23,17 @@ #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, @@ -196,6 +196,6 @@ class AstPrinter : public CVC4::Printer } // namespace ast } // namespace printer -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PRINTER__AST_PRINTER_H */ diff --git a/src/printer/cvc/cvc_printer.cpp b/src/printer/cvc/cvc_printer.cpp index ab532bc43..867bc204a 100644 --- a/src/printer/cvc/cvc_printer.cpp +++ b/src/printer/cvc/cvc_printer.cpp @@ -42,7 +42,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace printer { namespace cvc { @@ -1612,6 +1612,6 @@ void CvcPrinter::toStreamNodeWithLetify(std::ostream& out, lbind->popScope(); } -}/* CVC4::printer::cvc namespace */ -}/* CVC4::printer namespace */ -}/* CVC4 namespace */ +} // namespace cvc +} // namespace printer +} // namespace CVC5 diff --git a/src/printer/cvc/cvc_printer.h b/src/printer/cvc/cvc_printer.h index d8501b9ed..2b240568e 100644 --- a/src/printer/cvc/cvc_printer.h +++ b/src/printer/cvc/cvc_printer.h @@ -23,17 +23,17 @@ #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, @@ -204,6 +204,6 @@ class CvcPrinter : public CVC4::Printer } // namespace cvc } // namespace printer -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PRINTER__CVC_PRINTER_H */ diff --git a/src/printer/let_binding.cpp b/src/printer/let_binding.cpp index ca3ab40f6..638503c1a 100644 --- a/src/printer/let_binding.cpp +++ b/src/printer/let_binding.cpp @@ -16,7 +16,7 @@ #include <sstream> -namespace CVC4 { +namespace CVC5 { LetBinding::LetBinding(uint32_t thresh) : d_thresh(thresh), @@ -212,4 +212,4 @@ void LetBinding::convertCountToLet() } } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/printer/let_binding.h b/src/printer/let_binding.h index 83f3183ca..9eaeb039a 100644 --- a/src/printer/let_binding.h +++ b/src/printer/let_binding.h @@ -23,7 +23,7 @@ #include "context/cdlist.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { /** * A flexible let binding class. This class provides functionalities for @@ -157,6 +157,6 @@ class LetBinding NodeIdMap d_letMap; }; -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/printer/printer.cpp b/src/printer/printer.cpp index 40471b9a2..c4236d711 100644 --- a/src/printer/printer.cpp +++ b/src/printer/printer.cpp @@ -30,13 +30,13 @@ 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: @@ -459,4 +459,4 @@ void Printer::toStreamCmdDeclarationSequence( printUnknownCommand(out, "sequence"); } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/printer/printer.h b/src/printer/printer.h index 17fd66848..02ffdc939 100644 --- a/src/printer/printer.h +++ b/src/printer/printer.h @@ -26,7 +26,7 @@ #include "smt/model.h" #include "util/result.h" -namespace CVC4 { +namespace CVC5 { class Command; class CommandStatus; @@ -308,6 +308,6 @@ class Printer }; /* class Printer */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PRINTER__PRINTER_H */ diff --git a/src/printer/smt2/smt2_printer.cpp b/src/printer/smt2/smt2_printer.cpp index af555d298..7e80baebc 100644 --- a/src/printer/smt2/smt2_printer.cpp +++ b/src/printer/smt2/smt2_printer.cpp @@ -46,7 +46,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace printer { namespace smt2 { @@ -292,7 +292,7 @@ void Smt2Printer::toStream(std::ostream& out, } else { - out << CVC4::quoteSymbol(dt.getName()); + out << CVC5::quoteSymbol(dt.getName()); } break; } @@ -437,7 +437,7 @@ void Smt2Printer::toStream(std::ostream& out, 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) { @@ -509,7 +509,7 @@ void Smt2Printer::toStream(std::ostream& out, string s; if (n.getAttribute(expr::VarNameAttr(), s)) { - out << CVC4::quoteSymbol(s); + out << CVC5::quoteSymbol(s); } else { @@ -1334,7 +1334,7 @@ static bool tryToStream(std::ostream& out, const Command* c, Variant v); static std::string quoteSymbol(TNode n) { std::stringstream ss; ss << n; - return CVC4::quoteSymbol(ss.str()); + return CVC5::quoteSymbol(ss.str()); } template <class T> @@ -1364,7 +1364,7 @@ void Smt2Printer::toStream(std::ostream& out, const UnsatCore& core) const 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 @@ -1582,7 +1582,7 @@ void Smt2Printer::toStreamCmdDeclareFunction(std::ostream& out, 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(); @@ -1702,7 +1702,7 @@ void Smt2Printer::toStreamCmdDeclareType(std::ostream& out, 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; } @@ -1711,7 +1711,7 @@ void Smt2Printer::toStreamCmdDefineType(std::ostream& out, 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( @@ -1811,7 +1811,7 @@ void Smt2Printer::toStream(std::ostream& out, const DType& dt) const { 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]; @@ -1844,7 +1844,7 @@ void Smt2Printer::toStreamCmdDatatypeDeclaration( { Assert(t.isDatatype()); const DType& d = t.getDType(); - out << "(" << CVC4::quoteSymbol(d.getName()); + out << "(" << CVC5::quoteSymbol(d.getName()); out << " " << d.getNumParameters() << ")"; } out << ") ("; @@ -1986,7 +1986,7 @@ void Smt2Printer::toStreamCmdSynthFun(std::ostream& out, std::stringstream sym; sym << f; out << '(' << (isInv ? "synth-inv " : "synth-fun ") - << CVC4::quoteSymbol(sym.str()) << ' '; + << CVC5::quoteSymbol(sym.str()) << ' '; out << '('; if (!vars.empty()) { @@ -2137,6 +2137,6 @@ static bool tryToStream(std::ostream& out, const CommandStatus* s, Variant v) return false; } -}/* CVC4::printer::smt2 namespace */ -}/* CVC4::printer namespace */ -}/* CVC4 namespace */ +} // namespace smt2 +} // namespace printer +} // namespace CVC5 diff --git a/src/printer/smt2/smt2_printer.h b/src/printer/smt2/smt2_printer.h index 26ccf5821..a997f789a 100644 --- a/src/printer/smt2/smt2_printer.h +++ b/src/printer/smt2/smt2_printer.h @@ -21,7 +21,7 @@ #include "printer/printer.h" -namespace CVC4 { +namespace CVC5 { class LetBinding; @@ -35,11 +35,11 @@ enum Variant // 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, @@ -275,6 +275,6 @@ class Smt2Printer : public CVC4::Printer } // namespace smt2 } // namespace printer -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PRINTER__SMT2_PRINTER_H */ diff --git a/src/printer/tptp/tptp_printer.cpp b/src/printer/tptp/tptp_printer.cpp index 3ec261360..c740f7b76 100644 --- a/src/printer/tptp/tptp_printer.cpp +++ b/src/printer/tptp/tptp_printer.cpp @@ -30,7 +30,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace printer { namespace tptp { @@ -97,6 +97,6 @@ void TptpPrinter::toStream(std::ostream& out, const UnsatCore& core) const out << "% SZS output end UnsatCore " << std::endl; } -}/* CVC4::printer::tptp namespace */ -}/* CVC4::printer namespace */ -}/* CVC4 namespace */ +} // namespace tptp +} // namespace printer +} // namespace CVC5 diff --git a/src/printer/tptp/tptp_printer.h b/src/printer/tptp/tptp_printer.h index c1bd2b1d8..ea538a245 100644 --- a/src/printer/tptp/tptp_printer.h +++ b/src/printer/tptp/tptp_printer.h @@ -23,14 +23,14 @@ #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, @@ -64,6 +64,6 @@ class TptpPrinter : public CVC4::Printer } // namespace tptp } // namespace printer -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PRINTER__TPTP_PRINTER_H */ diff --git a/src/proof/clause_id.h b/src/proof/clause_id.h index 721da20e4..6f3caaf19 100644 --- a/src/proof/clause_id.h +++ b/src/proof/clause_id.h @@ -20,7 +20,7 @@ #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 @@ -35,6 +35,6 @@ const ClauseId ClauseIdEmpty(-1); const ClauseId ClauseIdUndef(-2); const ClauseId ClauseIdError(-3); -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__PROOF__CLAUSE_ID_H */ diff --git a/src/proof/cnf_proof.cpp b/src/proof/cnf_proof.cpp index a0f80ccd6..dc1a6dd61 100644 --- a/src/proof/cnf_proof.cpp +++ b/src/proof/cnf_proof.cpp @@ -23,7 +23,7 @@ #include "prop/minisat/minisat.h" #include "prop/sat_solver_types.h" -namespace CVC4 { +namespace CVC5 { CnfProof::CnfProof(prop::CnfStream* stream, context::Context* ctx, @@ -113,4 +113,4 @@ bool CnfProof::getCurrentAssertionKind() return d_currentAssertionStack.back().second; } -} /* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/proof/cnf_proof.h b/src/proof/cnf_proof.h index abea75d50..1319b83d6 100644 --- a/src/proof/cnf_proof.h +++ b/src/proof/cnf_proof.h @@ -28,10 +28,10 @@ #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; @@ -46,55 +46,55 @@ typedef std::unordered_set<Node, NodeHashFunction> NodeSet; 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 */ diff --git a/src/proof/dot/dot_printer.cpp b/src/proof/dot/dot_printer.cpp index f542924b1..8ecec8484 100644 --- a/src/proof/dot/dot_printer.cpp +++ b/src/proof/dot/dot_printer.cpp @@ -17,7 +17,7 @@ #include <sstream> #include "expr/proof_node_manager.h" -namespace CVC4 { +namespace CVC5 { namespace proof { void DotPrinter::cleanQuotes(std::string& s) @@ -91,4 +91,4 @@ void DotPrinter::ruleArguments(std::ostringstream& currentArguments, } } // namespace proof -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/proof/dot/dot_printer.h b/src/proof/dot/dot_printer.h index 4b7d7660c..173495780 100644 --- a/src/proof/dot/dot_printer.h +++ b/src/proof/dot/dot_printer.h @@ -21,7 +21,7 @@ #include "expr/proof_node.h" -namespace CVC4 { +namespace CVC5 { namespace proof { class DotPrinter @@ -69,6 +69,6 @@ class DotPrinter }; } // namespace proof -} // namespace CVC4 +} // namespace CVC5 #endif
\ No newline at end of file diff --git a/src/proof/proof_manager.cpp b/src/proof/proof_manager.cpp index 424c667fd..8b3dfd17a 100644 --- a/src/proof/proof_manager.cpp +++ b/src/proof/proof_manager.cpp @@ -36,7 +36,7 @@ #include "theory/valuation.h" #include "util/hash.h" -namespace CVC4 { +namespace CVC5 { ProofManager::ProofManager(context::Context* context) : d_context(context), @@ -217,4 +217,4 @@ void ProofManager::addUnsatCore(Node formula) d_outputCoreFormulas.insert(formula); } -} /* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/proof/proof_manager.h b/src/proof/proof_manager.h index 61470e2b4..b303b996f 100644 --- a/src/proof/proof_manager.h +++ b/src/proof/proof_manager.h @@ -28,7 +28,7 @@ #include "expr/node.h" #include "proof/clause_id.h" -namespace CVC4 { +namespace CVC5 { // forward declarations namespace Minisat { @@ -37,22 +37,22 @@ 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; @@ -81,7 +81,7 @@ public: // 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(); @@ -120,8 +120,6 @@ private: };/* class ProofManager */ -}/* CVC4 namespace */ - - +} // namespace CVC5 #endif /* CVC4__PROOF_MANAGER_H */ diff --git a/src/proof/sat_proof.h b/src/proof/sat_proof.h index d16f8259e..298b82624 100644 --- a/src/proof/sat_proof.h +++ b/src/proof/sat_proof.h @@ -34,11 +34,11 @@ #include "util/stats_histogram.h" // Forward declarations. -namespace CVC4 { +namespace CVC5 { class CnfProof; -} /* namespace CVC4 */ +} // namespace CVC5 -namespace CVC4 { +namespace CVC5 { /** * Helper debugging functions */ @@ -369,6 +369,6 @@ template <class Solver> void toSatClause(const typename Solver::TClause& minisat_cl, prop::SatClause& sat_cl); -} /* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__SAT__PROOF_H */ diff --git a/src/proof/sat_proof_implementation.h b/src/proof/sat_proof_implementation.h index 06a3cc00e..6049c4876 100644 --- a/src/proof/sat_proof_implementation.h +++ b/src/proof/sat_proof_implementation.h @@ -26,7 +26,7 @@ #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) { @@ -1040,17 +1040,12 @@ TSatProof<Solver>::Statistics::~Statistics() { 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) << "]"; } @@ -1058,6 +1053,6 @@ inline std::ostream& operator<<(std::ostream& out, CVC4::ClauseKind k) { return out; } -} /* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__SAT__PROOF_IMPLEMENTATION_H */ diff --git a/src/proof/unsat_core.cpp b/src/proof/unsat_core.cpp index 1c7a6a556..2415daf98 100644 --- a/src/proof/unsat_core.cpp +++ b/src/proof/unsat_core.cpp @@ -20,7 +20,7 @@ #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() @@ -58,4 +58,4 @@ std::ostream& operator<<(std::ostream& out, const UnsatCore& core) { return out; } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/proof/unsat_core.h b/src/proof/unsat_core.h index 472661db9..46dd7bf69 100644 --- a/src/proof/unsat_core.h +++ b/src/proof/unsat_core.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { /** * An unsat core, which can optionally be initialized as a list of names @@ -68,6 +68,6 @@ class UnsatCore /** 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 */ diff --git a/src/prop/README.minisat b/src/prop/README.minisat index 2f1d8bb47..081e79191 100644 --- a/src/prop/README.minisat +++ b/src/prop/README.minisat @@ -4,7 +4,7 @@ This is MiniSAT 2.2.0, downloaded from here: 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. diff --git a/src/prop/bv_sat_solver_notify.h b/src/prop/bv_sat_solver_notify.h index 9a303a514..1645a096a 100644 --- a/src/prop/bv_sat_solver_notify.h +++ b/src/prop/bv_sat_solver_notify.h @@ -21,7 +21,7 @@ #include "prop/sat_solver_types.h" #include "util/resource_manager.h" -namespace CVC4 { +namespace CVC5 { namespace prop { class BVSatSolverNotify { @@ -45,6 +45,6 @@ public: };/* class BVSatSolverInterface::Notify */ } -} +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/bvminisat.cpp b/src/prop/bvminisat/bvminisat.cpp index e58060191..fb764631f 100644 --- a/src/prop/bvminisat/bvminisat.cpp +++ b/src/prop/bvminisat/bvminisat.cpp @@ -20,7 +20,7 @@ #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) @@ -297,5 +297,5 @@ void BVMinisatSatSolver::Statistics::init(BVMinisat::SimpSolver* minisat){ d_statEliminatedVars.set(minisat->eliminated_vars); } -} /* namespace CVC4::prop */ -} /* namespace CVC4 */ +} // namespace prop +} // namespace CVC5 diff --git a/src/prop/bvminisat/bvminisat.h b/src/prop/bvminisat/bvminisat.h index f91ed4d1d..2a099ad21 100644 --- a/src/prop/bvminisat/bvminisat.h +++ b/src/prop/bvminisat/bvminisat.h @@ -28,7 +28,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace prop { class BVMinisatSatSolver : public BVSatSolverInterface, @@ -147,5 +147,5 @@ public: Statistics d_statistics; }; -} /* CVC4::prop namespace */ -} /* CVC4 namespace */ +} // namespace prop +} // namespace CVC5 diff --git a/src/prop/bvminisat/core/Dimacs.h b/src/prop/bvminisat/core/Dimacs.h index c94f473a9..be82fb557 100644 --- a/src/prop/bvminisat/core/Dimacs.h +++ b/src/prop/bvminisat/core/Dimacs.h @@ -26,7 +26,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/bvminisat/core/SolverTypes.h" #include "prop/bvminisat/utils/ParseUtils.h" -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { //================================================================================================= @@ -85,7 +85,7 @@ static void parse_DIMACS(gzFile input_stream, Solver& S) { parse_DIMACS_main(in, S); } //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/core/Solver.cc b/src/prop/bvminisat/core/Solver.cc index 3b2b814cd..d7dc3f6d4 100644 --- a/src/prop/bvminisat/core/Solver.cc +++ b/src/prop/bvminisat/core/Solver.cc @@ -34,7 +34,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "theory/interrupted.h" #include "util/utility.h" -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { #define OUTPUT_TAG "bvminisat: [a=" << assumptions.size() << ",l=" << decisionLevel() << "] " @@ -82,7 +82,7 @@ CRef Solver::TCRef_Lazy = CRef_Undef - 1; // no real lazy ref here //================================================================================================= // Constructor/Destructor: -Solver::Solver(CVC4::context::Context* context) +Solver::Solver(CVC5::context::Context* context) : // Parameters (user settable): @@ -976,7 +976,7 @@ lbool Solver::search(int nof_conflicts, UIP uip) return l_False; } - if (!CVC4::options::bvEagerExplanations()) + if (!CVC5::options::bvEagerExplanations()) { // check if uip leads to a conflict if (backtrack_level < assumptions.size()) @@ -1028,7 +1028,7 @@ lbool Solver::search(int nof_conflicts, UIP uip) 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()); @@ -1417,5 +1417,5 @@ bool Solver::withinBudget(ResourceManager::Resource r) const propagations < (uint64_t)propagation_budget); } -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 diff --git a/src/prop/bvminisat/core/Solver.h b/src/prop/bvminisat/core/Solver.h index 03c46985b..6386c33fa 100644 --- a/src/prop/bvminisat/core/Solver.h +++ b/src/prop/bvminisat/core/Solver.h @@ -33,7 +33,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/bvminisat/utils/Options.h" #include "util/resource_manager.h" -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { class Solver; @@ -80,7 +80,7 @@ private: Notify* d_notify; /** Cvc4 context */ - CVC4::context::Context* c; + CVC5::context::Context* c; /** True constant */ Var varTrue; @@ -92,138 +92,175 @@ public: // 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 { @@ -496,8 +533,7 @@ inline void Solver::toDimacs (const char* file, Lit p, Lit q, Lit r){ ve //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ - +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/core/SolverTypes.h b/src/prop/bvminisat/core/SolverTypes.h index 776052848..96022efbf 100644 --- a/src/prop/bvminisat/core/SolverTypes.h +++ b/src/prop/bvminisat/core/SolverTypes.h @@ -28,15 +28,15 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #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 { @@ -429,7 +429,7 @@ inline void Clause::strengthen(Lit p) //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/mtl/Alg.h b/src/prop/bvminisat/mtl/Alg.h index 5918b2f4c..0b173eb08 100644 --- a/src/prop/bvminisat/mtl/Alg.h +++ b/src/prop/bvminisat/mtl/Alg.h @@ -24,7 +24,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "base/check.h" #include "prop/bvminisat/mtl/Vec.h" -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { //================================================================================================= @@ -81,7 +81,7 @@ template<class T> 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 diff --git a/src/prop/bvminisat/mtl/Alloc.h b/src/prop/bvminisat/mtl/Alloc.h index 8a03caa69..582db74f1 100644 --- a/src/prop/bvminisat/mtl/Alloc.h +++ b/src/prop/bvminisat/mtl/Alloc.h @@ -25,7 +25,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/bvminisat/mtl/Vec.h" #include "prop/bvminisat/mtl/XAlloc.h" -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { //================================================================================================= @@ -148,7 +148,7 @@ RegionAllocator<T>::alloc(int size) //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/mtl/Heap.h b/src/prop/bvminisat/mtl/Heap.h index 38b47bc7f..7b04a5091 100644 --- a/src/prop/bvminisat/mtl/Heap.h +++ b/src/prop/bvminisat/mtl/Heap.h @@ -24,7 +24,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "base/check.h" #include "prop/bvminisat/mtl/Vec.h" -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { //================================================================================================= @@ -155,8 +155,7 @@ class Heap { //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ - +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/mtl/Map.h b/src/prop/bvminisat/mtl/Map.h index 919149fa9..fd64fc751 100644 --- a/src/prop/bvminisat/mtl/Map.h +++ b/src/prop/bvminisat/mtl/Map.h @@ -24,7 +24,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/bvminisat/mtl/IntTypes.h" #include "prop/bvminisat/mtl/Vec.h" -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { //================================================================================================= @@ -190,7 +190,7 @@ class Map { }; //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/mtl/Queue.h b/src/prop/bvminisat/mtl/Queue.h index 1120188f8..a72660337 100644 --- a/src/prop/bvminisat/mtl/Queue.h +++ b/src/prop/bvminisat/mtl/Queue.h @@ -24,7 +24,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "base/check.h" #include "prop/bvminisat/mtl/Vec.h" -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { //================================================================================================= @@ -85,7 +85,7 @@ public: //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/mtl/Sort.h b/src/prop/bvminisat/mtl/Sort.h index f4a10aabb..1cfa220ab 100644 --- a/src/prop/bvminisat/mtl/Sort.h +++ b/src/prop/bvminisat/mtl/Sort.h @@ -26,8 +26,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA //================================================================================================= // Some sorting algorithms for vec's - -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { template<class T> @@ -94,7 +93,7 @@ template <class T> void sort(vec<T>& v) { //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/mtl/Vec.h b/src/prop/bvminisat/mtl/Vec.h index a6e3bca4b..c918fc4a0 100644 --- a/src/prop/bvminisat/mtl/Vec.h +++ b/src/prop/bvminisat/mtl/Vec.h @@ -27,7 +27,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/bvminisat/mtl/IntTypes.h" #include "prop/bvminisat/mtl/XAlloc.h" -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { //================================================================================================= @@ -146,7 +146,7 @@ void vec<T>::clear(bool dealloc) { if (dealloc) free(data), data = NULL, cap = 0; } } //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/mtl/XAlloc.h b/src/prop/bvminisat/mtl/XAlloc.h index 9e469a6fb..1500114a2 100644 --- a/src/prop/bvminisat/mtl/XAlloc.h +++ b/src/prop/bvminisat/mtl/XAlloc.h @@ -24,7 +24,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include <errno.h> #include <stdlib.h> -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { //================================================================================================= @@ -41,8 +41,7 @@ static inline void* xrealloc(void *ptr, size_t size) } //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ - +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/simp/SimpSolver.cc b/src/prop/bvminisat/simp/SimpSolver.cc index 10f0aa03e..b4f9bd354 100644 --- a/src/prop/bvminisat/simp/SimpSolver.cc +++ b/src/prop/bvminisat/simp/SimpSolver.cc @@ -27,7 +27,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/bvminisat/mtl/Sort.h" #include "prop/bvminisat/utils/System.h" -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { //================================================================================================= @@ -48,7 +48,7 @@ static DoubleOption opt_simp_garbage_frac(_cat, "simp-gc-frac", "The fraction of //================================================================================================= // Constructor/Destructor: -SimpSolver::SimpSolver(CVC4::context::Context* context) +SimpSolver::SimpSolver(CVC5::context::Context* context) : Solver(context), grow(opt_grow), clause_lim(opt_clause_lim), @@ -57,9 +57,9 @@ SimpSolver::SimpSolver(CVC4::context::Context* context) 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), @@ -94,7 +94,7 @@ SimpSolver::SimpSolver(CVC4::context::Context* context) SimpSolver::~SimpSolver() { - // CVC4::StatisticsRegistry::unregisterStat(&total_eliminate_time); + // CVC5::StatisticsRegistry::unregisterStat(&total_eliminate_time); } @@ -644,64 +644,77 @@ void SimpSolver::extendModel() 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: @@ -795,5 +808,5 @@ void SimpSolver::garbageCollect() to.moveTo(ca); } -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 diff --git a/src/prop/bvminisat/simp/SimpSolver.h b/src/prop/bvminisat/simp/SimpSolver.h index bf23a7dff..6afdc6ba7 100644 --- a/src/prop/bvminisat/simp/SimpSolver.h +++ b/src/prop/bvminisat/simp/SimpSolver.h @@ -26,7 +26,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/bvminisat/core/Solver.h" #include "prop/bvminisat/mtl/Queue.h" -namespace CVC4 { +namespace CVC5 { namespace context { class Context; @@ -41,7 +41,7 @@ class SimpSolver : public Solver { public: // Constructor/Destructor: // - SimpSolver(CVC4::context::Context* context); + SimpSolver(CVC5::context::Context* context); ~SimpSolver(); // Problem specification: @@ -115,9 +115,9 @@ class SimpSolver : public Solver { int merges; int asymm_lits; int eliminated_vars; - // CVC4::TimerStat total_eliminate_time; + // CVC5::TimerStat total_eliminate_time; - protected: + protected: // Helper structures: // @@ -237,8 +237,7 @@ inline lbool SimpSolver::solveLimited (bool do_simp, bool turn_off_simp){ return solve_(do_simp, turn_off_simp); } //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ - +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/utils/Options.cc b/src/prop/bvminisat/utils/Options.cc index ac0964623..44c642441 100644 --- a/src/prop/bvminisat/utils/Options.cc +++ b/src/prop/bvminisat/utils/Options.cc @@ -21,7 +21,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #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) @@ -90,6 +90,5 @@ void BVMinisat::printUsageAndExit (int argc, char** argv, bool verbose) exit(0); } - -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 diff --git a/src/prop/bvminisat/utils/Options.h b/src/prop/bvminisat/utils/Options.h index 698035b7c..e7b6942bd 100644 --- a/src/prop/bvminisat/utils/Options.h +++ b/src/prop/bvminisat/utils/Options.h @@ -29,7 +29,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/bvminisat/mtl/Vec.h" #include "prop/bvminisat/utils/ParseUtils.h" -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { //================================================================================================== @@ -431,7 +431,7 @@ class BoolOption : public Option }; //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/utils/ParseUtils.h b/src/prop/bvminisat/utils/ParseUtils.h index 46f404c3e..a748651db 100644 --- a/src/prop/bvminisat/utils/ParseUtils.h +++ b/src/prop/bvminisat/utils/ParseUtils.h @@ -27,7 +27,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA //#include <zlib.h> #include <unistd.h> -namespace CVC4 { +namespace CVC5 { namespace BVMinisat { //------------------------------------------------------------------------------------------------- @@ -119,7 +119,7 @@ static bool eagerMatch(B& in, const char* str) { //================================================================================================= -} /* CVC4::BVMinisat namespace */ -} /* CVC4 namespace */ +} // namespace BVMinisat +} // namespace CVC5 #endif diff --git a/src/prop/bvminisat/utils/System.cc b/src/prop/bvminisat/utils/System.cc index aba0a5ac5..9b9f99eb5 100644 --- a/src/prop/bvminisat/utils/System.cc +++ b/src/prop/bvminisat/utils/System.cc @@ -25,7 +25,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #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 @@ -95,6 +95,5 @@ double BVMinisat::memUsed() { return 0; } #endif - -} /* CVC4::BVMinisat namespace */ +} /* CVC5::BVMinisat namespace */ } /* CVC4 namespace */ diff --git a/src/prop/bvminisat/utils/System.h b/src/prop/bvminisat/utils/System.h index 6a887bdb0..117fbfa3d 100644 --- a/src/prop/bvminisat/utils/System.h +++ b/src/prop/bvminisat/utils/System.h @@ -29,15 +29,15 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA //------------------------------------------------------------------------------------------------- -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: @@ -45,17 +45,22 @@ extern double memUsedPeak(); // Peak-memory in mega bytes (returns 0 for #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 diff --git a/src/prop/cadical.cpp b/src/prop/cadical.cpp index 6020efad1..9bad7072a 100644 --- a/src/prop/cadical.cpp +++ b/src/prop/cadical.cpp @@ -20,7 +20,7 @@ #include "base/check.h" -namespace CVC4 { +namespace CVC5 { namespace prop { using CadicalLit = int; @@ -200,6 +200,6 @@ CadicalSolver::Statistics::~Statistics() { } } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4_USE_CADICAL diff --git a/src/prop/cadical.h b/src/prop/cadical.h index dfd761e2e..c49aa8d03 100644 --- a/src/prop/cadical.h +++ b/src/prop/cadical.h @@ -26,7 +26,7 @@ #include <cadical.hpp> -namespace CVC4 { +namespace CVC5 { namespace prop { class CadicalSolver : public SatSolver @@ -103,7 +103,7 @@ class CadicalSolver : public SatSolver }; } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4_USE_CADICAL #endif // CVC4__PROP__CADICAL_H diff --git a/src/prop/cnf_stream.cpp b/src/prop/cnf_stream.cpp index 8cd4da505..bd23bad94 100644 --- a/src/prop/cnf_stream.cpp +++ b/src/prop/cnf_stream.cpp @@ -37,7 +37,7 @@ #include "theory/theory.h" #include "theory/theory_engine.h" -namespace CVC4 { +namespace CVC5 { namespace prop { CnfStream::CnfStream(SatSolver* satSolver, @@ -787,5 +787,5 @@ void CnfStream::convertAndAssert(TNode node, bool negated) } } -}/* CVC4::prop namespace */ -}/* CVC4 namespace */ +} // namespace prop +} // namespace CVC5 diff --git a/src/prop/cnf_stream.h b/src/prop/cnf_stream.h index 1a900a524..af86da746 100644 --- a/src/prop/cnf_stream.h +++ b/src/prop/cnf_stream.h @@ -34,7 +34,7 @@ #include "prop/registrar.h" #include "prop/sat_solver_types.h" -namespace CVC4 { +namespace CVC5 { class OutputManager; @@ -318,6 +318,6 @@ class CnfStream { }; /* class CnfStream */ } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PROP__CNF_STREAM_H */ diff --git a/src/prop/cryptominisat.cpp b/src/prop/cryptominisat.cpp index d81429d44..91fc12c6c 100644 --- a/src/prop/cryptominisat.cpp +++ b/src/prop/cryptominisat.cpp @@ -22,7 +22,7 @@ #include <cryptominisat5/cryptominisat.h> -namespace CVC4 { +namespace CVC5 { namespace prop { using CMSatVar = unsigned; @@ -244,5 +244,5 @@ CryptoMinisatSolver::Statistics::~Statistics() { } } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/prop/cryptominisat.h b/src/prop/cryptominisat.h index 3bb443cfc..fb118619c 100644 --- a/src/prop/cryptominisat.h +++ b/src/prop/cryptominisat.h @@ -33,7 +33,7 @@ namespace CMSat { class SATSolver; } -namespace CVC4 { +namespace CVC5 { namespace prop { class CryptoMinisatSolver : public SatSolver @@ -106,7 +106,7 @@ class CryptoMinisatSolver : public SatSolver }; } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4_USE_CRYPTOMINISAT #endif // CVC4__PROP__CRYPTOMINISAT_H diff --git a/src/prop/kissat.cpp b/src/prop/kissat.cpp index 7ff6d76ee..ccca3a3b4 100644 --- a/src/prop/kissat.cpp +++ b/src/prop/kissat.cpp @@ -20,7 +20,7 @@ #include "base/check.h" -namespace CVC4 { +namespace CVC5 { namespace prop { using KissatLit = int32_t; @@ -173,6 +173,6 @@ KissatSolver::Statistics::~Statistics() } } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4_USE_KISSAT diff --git a/src/prop/kissat.h b/src/prop/kissat.h index 65088e39e..7bfcbac68 100644 --- a/src/prop/kissat.h +++ b/src/prop/kissat.h @@ -28,7 +28,7 @@ extern "C" { #include <kissat/kissat.h> } -namespace CVC4 { +namespace CVC5 { namespace prop { class KissatSolver : public SatSolver @@ -97,7 +97,7 @@ class KissatSolver : public SatSolver }; } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4_USE_KISSAT #endif // CVC4__PROP__KISSAT_H diff --git a/src/prop/minisat/core/Dimacs.h b/src/prop/minisat/core/Dimacs.h index e4728f6b6..b48044457 100644 --- a/src/prop/minisat/core/Dimacs.h +++ b/src/prop/minisat/core/Dimacs.h @@ -26,7 +26,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/minisat/utils/ParseUtils.h" #include "prop/minisat/core/SolverTypes.h" -namespace CVC4 { +namespace CVC5 { namespace Minisat { //================================================================================================= @@ -86,6 +86,6 @@ static void parse_DIMACS(gzFile input_stream, Solver& S) { //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/minisat/core/Solver.cc b/src/prop/minisat/core/Solver.cc index 8c27e2bdd..9dbcada15 100644 --- a/src/prop/minisat/core/Solver.cc +++ b/src/prop/minisat/core/Solver.cc @@ -39,9 +39,9 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #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 { @@ -83,7 +83,7 @@ static inline void dtviewPropagationHeaderHelper(size_t level) // 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), ' ') @@ -95,7 +95,7 @@ static inline void dtviewBoolPropagationHelper(size_t level, // 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), ' ') @@ -148,9 +148,9 @@ class ScopedBool //================================================================================================= // 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), @@ -548,7 +548,7 @@ bool Solver::addClause_(vec<Lit>& ps, bool removable, ClauseId& id) ProofManager::getCnfProof()->registerConvertedClause(id); } ProofManager::getSatProof()->finalizeProof( - CVC4::Minisat::CRef_Lazy); + CVC5::Minisat::CRef_Lazy); } if (isProofEnabled()) { @@ -648,7 +648,7 @@ bool Solver::addClause_(vec<Lit>& ps, bool removable, ClauseId& id) id = ProofManager::getSatProof()->storeUnitConflict( ca[confl][0], LEARNT); ProofManager::getSatProof()->finalizeProof( - CVC4::Minisat::CRef_Lazy); + CVC5::Minisat::CRef_Lazy); } else { @@ -1030,7 +1030,7 @@ int Solver::analyze(CRef confl, vec<Lit>& out_learnt, int& out_btlevel) 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++) @@ -1073,7 +1073,7 @@ int Solver::analyze(CRef confl, vec<Lit>& out_learnt, int& out_btlevel) } } } - Trace("pf::sat") << CVC4::pop; + Trace("pf::sat") << CVC5::pop; // Select next clause to look at: while (!seen[var(trail[index--])]); @@ -1326,7 +1326,7 @@ CRef Solver::propagate(TheoryCheckType type) // 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(); @@ -1350,9 +1350,9 @@ CRef Solver::propagate(TheoryCheckType type) 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(); @@ -1439,7 +1439,7 @@ void Solver::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); } @@ -2145,7 +2145,7 @@ void Solver::pop() --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()); @@ -2167,7 +2167,7 @@ void Solver::pop() // 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 @@ -2347,7 +2347,7 @@ CRef Solver::updateLemmas() { 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 @@ -2397,5 +2397,5 @@ std::shared_ptr<ProofNode> Solver::getProof() bool Solver::isProofEnabled() const { return d_pfManager != nullptr; } -} /* CVC4::Minisat namespace */ -} /* CVC4 namespace */ +} // namespace Minisat +} // namespace CVC5 diff --git a/src/prop/minisat/core/Solver.h b/src/prop/minisat/core/Solver.h index df2f9b967..53f7a828c 100644 --- a/src/prop/minisat/core/Solver.h +++ b/src/prop/minisat/core/Solver.h @@ -38,17 +38,16 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #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 { //================================================================================================= @@ -57,12 +56,12 @@ 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; @@ -74,10 +73,10 @@ public: 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; @@ -89,7 +88,7 @@ public: 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 */ @@ -106,7 +105,7 @@ public: 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; @@ -135,9 +134,9 @@ public: // 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(); @@ -154,7 +153,7 @@ public: 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(); @@ -438,7 +437,9 @@ protected: 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) @@ -664,7 +665,7 @@ inline void Solver::toDimacs (const char* file, Lit p, Lit q, Lit r){ ve //================================================================================================= -} /* CVC4::Minisat namespace */ -} /* CVC4 namespace */ +} // namespace Minisat +} // namespace CVC5 #endif diff --git a/src/prop/minisat/core/SolverTypes.h b/src/prop/minisat/core/SolverTypes.h index f2d2860c8..4d9dd682d 100644 --- a/src/prop/minisat/core/SolverTypes.h +++ b/src/prop/minisat/core/SolverTypes.h @@ -31,15 +31,15 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #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 { //================================================================================================= @@ -182,11 +182,10 @@ inline std::ostream& operator <<(std::ostream& out, Minisat::lbool val) { return out; } -} /* namespace CVC4::Minisat */ -} /* namespace CVC4 */ +} // namespace Minisat +} // namespace CVC5 - -namespace CVC4 { +namespace CVC5 { namespace Minisat{ //================================================================================================= @@ -323,7 +322,7 @@ class ClauseAllocator : public RegionAllocator<uint32_t> void reloc(CRef& cr, ClauseAllocator& to, - CVC4::TSatProof<Solver>* proof = NULL); + CVC5::TSatProof<Solver>* proof = NULL); // Implementation moved to Solver.cc. }; @@ -501,6 +500,6 @@ inline void Clause::strengthen(Lit p) //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/minisat/minisat.cpp b/src/prop/minisat/minisat.cpp index 694c73e5e..e95677d57 100644 --- a/src/prop/minisat/minisat.cpp +++ b/src/prop/minisat/minisat.cpp @@ -25,7 +25,7 @@ #include "proof/sat_proof.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace prop { //// DPllMinisatSatSolver @@ -300,20 +300,21 @@ void MinisatSatSolver::Statistics::init(Minisat::SimpSolver* minisat){ 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 diff --git a/src/prop/minisat/minisat.h b/src/prop/minisat/minisat.h index 472ded34e..7dfeb6aa2 100644 --- a/src/prop/minisat/minisat.h +++ b/src/prop/minisat/minisat.h @@ -20,7 +20,7 @@ #include "prop/minisat/simp/SimpSolver.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace prop { class MinisatSatSolver : public CDCLTSatSolverInterface @@ -40,7 +40,7 @@ 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; @@ -118,5 +118,5 @@ class MinisatSatSolver : public CDCLTSatSolverInterface }; /* class MinisatSatSolver */ -}/* CVC4::prop namespace */ -}/* CVC4 namespace */ +} // namespace prop +} // namespace CVC5 diff --git a/src/prop/minisat/mtl/Alg.h b/src/prop/minisat/mtl/Alg.h index 2f8a86c3b..37bc4b7b6 100644 --- a/src/prop/minisat/mtl/Alg.h +++ b/src/prop/minisat/mtl/Alg.h @@ -24,7 +24,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "base/check.h" #include "prop/minisat/mtl/Vec.h" -namespace CVC4 { +namespace CVC5 { namespace Minisat { //================================================================================================= @@ -82,6 +82,6 @@ static inline void append(const vec<T>& from, vec<T>& to){ copy(from, to, true); //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/minisat/mtl/Alloc.h b/src/prop/minisat/mtl/Alloc.h index 98e59e7bf..850aaeb73 100644 --- a/src/prop/minisat/mtl/Alloc.h +++ b/src/prop/minisat/mtl/Alloc.h @@ -25,7 +25,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/minisat/mtl/Vec.h" #include "prop/minisat/mtl/XAlloc.h" -namespace CVC4 { +namespace CVC5 { namespace Minisat { //================================================================================================= @@ -149,6 +149,6 @@ RegionAllocator<T>::alloc(int size) //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/minisat/mtl/Heap.h b/src/prop/minisat/mtl/Heap.h index 1e64f6ba5..e2ad1513f 100644 --- a/src/prop/minisat/mtl/Heap.h +++ b/src/prop/minisat/mtl/Heap.h @@ -24,7 +24,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "base/check.h" #include "prop/minisat/mtl/Vec.h" -namespace CVC4 { +namespace CVC5 { namespace Minisat { //================================================================================================= @@ -156,6 +156,6 @@ class Heap { //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/minisat/mtl/Map.h b/src/prop/minisat/mtl/Map.h index bf299d55d..2efed4433 100644 --- a/src/prop/minisat/mtl/Map.h +++ b/src/prop/minisat/mtl/Map.h @@ -24,7 +24,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/minisat/mtl/IntTypes.h" #include "prop/minisat/mtl/Vec.h" -namespace CVC4 { +namespace CVC5 { namespace Minisat { //================================================================================================= @@ -191,6 +191,6 @@ class Map { //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/minisat/mtl/Queue.h b/src/prop/minisat/mtl/Queue.h index 242bc9388..ef30591bf 100644 --- a/src/prop/minisat/mtl/Queue.h +++ b/src/prop/minisat/mtl/Queue.h @@ -24,7 +24,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "base/check.h" #include "prop/minisat/mtl/Vec.h" -namespace CVC4 { +namespace CVC5 { namespace Minisat { //================================================================================================= @@ -86,6 +86,6 @@ public: //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/minisat/mtl/Sort.h b/src/prop/minisat/mtl/Sort.h index 2c3454aa3..7cf393847 100644 --- a/src/prop/minisat/mtl/Sort.h +++ b/src/prop/minisat/mtl/Sort.h @@ -26,8 +26,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA //================================================================================================= // Some sorting algorithms for vec's - -namespace CVC4 { +namespace CVC5 { namespace Minisat { template<class T> @@ -95,6 +94,6 @@ template <class T> void sort(vec<T>& v) { //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/minisat/mtl/Vec.h b/src/prop/minisat/mtl/Vec.h index 08e40e8bc..e17e320d2 100644 --- a/src/prop/minisat/mtl/Vec.h +++ b/src/prop/minisat/mtl/Vec.h @@ -27,7 +27,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/minisat/mtl/IntTypes.h" #include "prop/minisat/mtl/XAlloc.h" -namespace CVC4 { +namespace CVC5 { namespace Minisat { //================================================================================================= @@ -147,6 +147,6 @@ void vec<T>::clear(bool dealloc) { //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/minisat/mtl/XAlloc.h b/src/prop/minisat/mtl/XAlloc.h index f1221f94f..6bd8c02e8 100644 --- a/src/prop/minisat/mtl/XAlloc.h +++ b/src/prop/minisat/mtl/XAlloc.h @@ -24,7 +24,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include <errno.h> #include <stdlib.h> -namespace CVC4 { +namespace CVC5 { namespace Minisat { //================================================================================================= @@ -42,6 +42,6 @@ static inline void* xrealloc(void *ptr, size_t size) //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/minisat/simp/SimpSolver.cc b/src/prop/minisat/simp/SimpSolver.cc index 7051134eb..52162776b 100644 --- a/src/prop/minisat/simp/SimpSolver.cc +++ b/src/prop/minisat/simp/SimpSolver.cc @@ -27,8 +27,8 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #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: @@ -48,9 +48,9 @@ static DoubleOption opt_simp_garbage_frac(_cat, "simp-gc-frac", "The fraction of //================================================================================================= // 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), diff --git a/src/prop/minisat/simp/SimpSolver.h b/src/prop/minisat/simp/SimpSolver.h index f553746e6..6c8a87d5e 100644 --- a/src/prop/minisat/simp/SimpSolver.h +++ b/src/prop/minisat/simp/SimpSolver.h @@ -27,13 +27,13 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #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 { //================================================================================================= @@ -42,9 +42,9 @@ class SimpSolver : public Solver { 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(); @@ -270,7 +270,7 @@ inline lbool SimpSolver::solve (Lit p, Lit q, Lit r, bool do_simp, bool t } //================================================================================================= -} /* CVC4::Minisat namespace */ -} /* CVC4 namespace */ + } // namespace Minisat + } // namespace CVC5 #endif diff --git a/src/prop/minisat/utils/Options.h b/src/prop/minisat/utils/Options.h index 9bddd2b23..f37b6305e 100644 --- a/src/prop/minisat/utils/Options.h +++ b/src/prop/minisat/utils/Options.h @@ -29,7 +29,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "prop/minisat/mtl/Vec.h" #include "prop/minisat/utils/ParseUtils.h" -namespace CVC4 { +namespace CVC5 { namespace Minisat { //================================================================================================== @@ -432,6 +432,6 @@ class BoolOption : public Option //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/minisat/utils/ParseUtils.h b/src/prop/minisat/utils/ParseUtils.h index 128205967..27e454d00 100644 --- a/src/prop/minisat/utils/ParseUtils.h +++ b/src/prop/minisat/utils/ParseUtils.h @@ -27,7 +27,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA //#include <zlib.h> #include <unistd.h> -namespace CVC4 { +namespace CVC5 { namespace Minisat { //------------------------------------------------------------------------------------------------- @@ -120,6 +120,6 @@ static bool eagerMatch(B& in, const char* str) { //================================================================================================= } -} +} // namespace CVC5 #endif diff --git a/src/prop/proof_cnf_stream.cpp b/src/prop/proof_cnf_stream.cpp index 014063f30..ab5c59dd1 100644 --- a/src/prop/proof_cnf_stream.cpp +++ b/src/prop/proof_cnf_stream.cpp @@ -18,7 +18,7 @@ #include "prop/minisat/minisat.h" #include "theory/builtin/proof_checker.h" -namespace CVC4 { +namespace CVC5 { namespace prop { ProofCnfStream::ProofCnfStream(context::UserContext* u, @@ -1012,4 +1012,4 @@ SatLiteral ProofCnfStream::handleIte(TNode node) } } // namespace prop -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/prop/proof_cnf_stream.h b/src/prop/proof_cnf_stream.h index 6f9261278..7c97a2e8e 100644 --- a/src/prop/proof_cnf_stream.h +++ b/src/prop/proof_cnf_stream.h @@ -27,7 +27,7 @@ #include "theory/eager_proof_generator.h" #include "theory/theory_proof_step_buffer.h" -namespace CVC4 { +namespace CVC5 { namespace prop { class SatProofManager; @@ -170,6 +170,6 @@ class ProofCnfStream : public ProofGenerator }; } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/prop/proof_post_processor.cpp b/src/prop/proof_post_processor.cpp index 44a30ccc6..7f075ab37 100644 --- a/src/prop/proof_post_processor.cpp +++ b/src/prop/proof_post_processor.cpp @@ -17,7 +17,7 @@ #include "theory/builtin/proof_checker.h" -namespace CVC4 { +namespace CVC5 { namespace prop { ProofPostprocessCallback::ProofPostprocessCallback( @@ -105,4 +105,4 @@ void ProofPostproccess::process(std::shared_ptr<ProofNode> pf) } } // namespace prop -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/prop/proof_post_processor.h b/src/prop/proof_post_processor.h index 9a8894eef..c74cb540f 100644 --- a/src/prop/proof_post_processor.h +++ b/src/prop/proof_post_processor.h @@ -23,7 +23,7 @@ #include "expr/proof_node_updater.h" #include "prop/proof_cnf_stream.h" -namespace CVC4 { +namespace CVC5 { namespace prop { @@ -107,6 +107,6 @@ class ProofPostproccess }; } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/prop/prop_engine.cpp b/src/prop/prop_engine.cpp index 3f53433ae..9032dbb75 100644 --- a/src/prop/prop_engine.cpp +++ b/src/prop/prop_engine.cpp @@ -42,7 +42,7 @@ #include "util/resource_manager.h" #include "util/result.h" -namespace CVC4 { +namespace CVC5 { namespace prop { /** Keeps a boolean flag scoped */ @@ -616,4 +616,4 @@ std::shared_ptr<ProofNode> PropEngine::getProof() bool PropEngine::isProofEnabled() const { return d_pfCnfStream != nullptr; } } // namespace prop -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/prop/prop_engine.h b/src/prop/prop_engine.h index fe5d94122..1145961a1 100644 --- a/src/prop/prop_engine.h +++ b/src/prop/prop_engine.h @@ -27,7 +27,7 @@ #include "theory/trust_node.h" #include "util/result.h" -namespace CVC4 { +namespace CVC5 { class ResourceManager; class DecisionEngine; @@ -381,6 +381,6 @@ class PropEngine }; } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PROP_ENGINE_H */ diff --git a/src/prop/prop_proof_manager.cpp b/src/prop/prop_proof_manager.cpp index 399f8fd03..cb380f92d 100644 --- a/src/prop/prop_proof_manager.cpp +++ b/src/prop/prop_proof_manager.cpp @@ -19,7 +19,7 @@ #include "prop/prop_proof_manager.h" #include "prop/sat_solver.h" -namespace CVC4 { +namespace CVC5 { namespace prop { PropPfManager::PropPfManager(context::UserContext* userContext, @@ -109,4 +109,4 @@ std::shared_ptr<ProofNode> PropPfManager::getProof() } } // namespace prop -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/prop/prop_proof_manager.h b/src/prop/prop_proof_manager.h index c429936ec..d8732c11a 100644 --- a/src/prop/prop_proof_manager.h +++ b/src/prop/prop_proof_manager.h @@ -23,7 +23,7 @@ #include "prop/proof_post_processor.h" #include "prop/sat_proof_manager.h" -namespace CVC4 { +namespace CVC5 { namespace prop { @@ -92,6 +92,6 @@ class PropPfManager }; /* class PropPfManager */ } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PROP__PROOF_MANAGER_H */ diff --git a/src/prop/registrar.h b/src/prop/registrar.h index e54a5314b..d0fc0fe25 100644 --- a/src/prop/registrar.h +++ b/src/prop/registrar.h @@ -23,7 +23,7 @@ #ifndef CVC4__PROP__REGISTRAR_H #define CVC4__PROP__REGISTRAR_H -namespace CVC4 { +namespace CVC5 { namespace prop { class Registrar { @@ -39,7 +39,7 @@ public: };/* class NullRegistrar */ -}/* CVC4::prop namespace */ -}/* CVC4 namespace */ +} // namespace prop +} // namespace CVC5 #endif /* CVC4__PROP__REGISTRAR_H */ diff --git a/src/prop/sat_proof_manager.cpp b/src/prop/sat_proof_manager.cpp index 6f6209a76..a11eeaa8a 100644 --- a/src/prop/sat_proof_manager.cpp +++ b/src/prop/sat_proof_manager.cpp @@ -20,7 +20,7 @@ #include "prop/minisat/minisat.h" #include "theory/theory_proof_step_buffer.h" -namespace CVC4 { +namespace CVC5 { namespace prop { SatProofManager::SatProofManager(Minisat::Solver* solver, @@ -753,4 +753,4 @@ void SatProofManager::registerSatAssumptions(const std::vector<Node>& assumps) } } // namespace prop -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/prop/sat_proof_manager.h b/src/prop/sat_proof_manager.h index c71e7e8a3..514f0153b 100644 --- a/src/prop/sat_proof_manager.h +++ b/src/prop/sat_proof_manager.h @@ -28,7 +28,7 @@ namespace Minisat { class Solver; } -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; @@ -587,6 +587,6 @@ class SatProofManager }; /* class SatProofManager */ } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SAT_PROOF_MANAGER_H */ diff --git a/src/prop/sat_solver.h b/src/prop/sat_solver.h index 0cc20d2d2..f06171775 100644 --- a/src/prop/sat_solver.h +++ b/src/prop/sat_solver.h @@ -30,7 +30,7 @@ #include "prop/sat_solver_types.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace prop { @@ -150,7 +150,7 @@ class CDCLTSatSolverInterface : public SatSolver virtual void initialize(context::Context* context, prop::TheoryProxy* theoryProxy, - CVC4::context::UserContext* userContext, + CVC5::context::UserContext* userContext, ProofNodeManager* pnm) = 0; virtual void push() = 0; @@ -208,7 +208,7 @@ inline std::ostream& operator <<(std::ostream& out, prop::SatValue val) { return out; } -}/* CVC4::prop namespace */ -}/* CVC4 namespace */ +} // namespace prop +} // namespace CVC5 #endif /* CVC4__PROP__SAT_MODULE_H */ diff --git a/src/prop/sat_solver_factory.cpp b/src/prop/sat_solver_factory.cpp index 9fbbfb60f..1d933dce8 100644 --- a/src/prop/sat_solver_factory.cpp +++ b/src/prop/sat_solver_factory.cpp @@ -22,7 +22,7 @@ #include "prop/kissat.h" #include "prop/minisat/minisat.h" -namespace CVC4 { +namespace CVC5 { namespace prop { BVSatSolverInterface* SatSolverFactory::createMinisat( @@ -76,4 +76,4 @@ SatSolver* SatSolverFactory::createKissat(StatisticsRegistry* registry, } } // namespace prop -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/prop/sat_solver_factory.h b/src/prop/sat_solver_factory.h index ca9e1ad81..97b018e09 100644 --- a/src/prop/sat_solver_factory.h +++ b/src/prop/sat_solver_factory.h @@ -27,7 +27,7 @@ #include "prop/sat_solver.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace prop { class SatSolverFactory @@ -50,6 +50,6 @@ class SatSolverFactory }; /* class SatSolverFactory */ } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__PROP__SAT_SOLVER_FACTORY_H diff --git a/src/prop/sat_solver_types.cpp b/src/prop/sat_solver_types.cpp index 3a303852a..3380329c3 100644 --- a/src/prop/sat_solver_types.cpp +++ b/src/prop/sat_solver_types.cpp @@ -18,11 +18,11 @@ #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 diff --git a/src/prop/sat_solver_types.h b/src/prop/sat_solver_types.h index a9248fdfb..392dfb2b1 100644 --- a/src/prop/sat_solver_types.h +++ b/src/prop/sat_solver_types.h @@ -29,7 +29,7 @@ #include <unordered_set> #include <vector> -namespace CVC4 { +namespace CVC5 { namespace prop { /** @@ -235,4 +235,4 @@ enum SatSolverLifespan }; } -} +} // namespace CVC5 diff --git a/src/prop/skolem_def_manager.cpp b/src/prop/skolem_def_manager.cpp index c2a6a8462..a0819e571 100644 --- a/src/prop/skolem_def_manager.cpp +++ b/src/prop/skolem_def_manager.cpp @@ -16,7 +16,7 @@ #include "expr/attribute.h" -namespace CVC4 { +namespace CVC5 { namespace prop { SkolemDefManager::SkolemDefManager(context::Context* context, @@ -170,4 +170,4 @@ void SkolemDefManager::getSkolems( } } // namespace prop -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/prop/skolem_def_manager.h b/src/prop/skolem_def_manager.h index 9bb118356..6f4ec031f 100644 --- a/src/prop/skolem_def_manager.h +++ b/src/prop/skolem_def_manager.h @@ -26,7 +26,7 @@ #include "context/context.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace prop { /** @@ -86,6 +86,6 @@ class SkolemDefManager }; } // namespace prop -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PROP__SKOLEM_DEF_MANAGER_H */ diff --git a/src/prop/theory_proxy.cpp b/src/prop/theory_proxy.cpp index 66023cd88..ffec0c365 100644 --- a/src/prop/theory_proxy.cpp +++ b/src/prop/theory_proxy.cpp @@ -28,7 +28,7 @@ #include "theory/theory_engine.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace prop { TheoryProxy::TheoryProxy(PropEngine* propEngine, @@ -105,7 +105,7 @@ void TheoryProxy::explainPropagation(SatLiteral l, SatClause& explanation) { theory::TrustNode tte = d_theoryEngine->getExplanation(lNode); Node theoryExplanation = tte.getNode(); - if (CVC4::options::produceProofs()) + if (CVC5::options::produceProofs()) { d_propEngine->getProofCnfStream()->convertPropagation(tte); } @@ -232,5 +232,5 @@ void TheoryProxy::getSkolems(TNode node, void TheoryProxy::preRegister(Node n) { d_theoryEngine->preRegister(n); } -}/* CVC4::prop namespace */ -}/* CVC4 namespace */ +} // namespace prop +} // namespace CVC5 diff --git a/src/prop/theory_proxy.h b/src/prop/theory_proxy.h index 01d98f1b9..dedd1fa49 100644 --- a/src/prop/theory_proxy.h +++ b/src/prop/theory_proxy.h @@ -35,7 +35,7 @@ #include "theory/trust_node.h" #include "util/resource_manager.h" -namespace CVC4 { +namespace CVC5 { class DecisionEngine; class TheoryEngine; @@ -165,8 +165,8 @@ class TheoryProxy : public Registrar std::unique_ptr<SkolemDefManager> d_skdm; }; /* class TheoryProxy */ -}/* CVC4::prop namespace */ +} // namespace prop -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__PROP__SAT_H */ diff --git a/src/smt/abduction_solver.cpp b/src/smt/abduction_solver.cpp index 46410755a..cd4228eed 100644 --- a/src/smt/abduction_solver.cpp +++ b/src/smt/abduction_solver.cpp @@ -23,9 +23,9 @@ #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) {} @@ -195,4 +195,4 @@ void AbductionSolver::checkAbduct(Node a) } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/abduction_solver.h b/src/smt/abduction_solver.h index dcae290b4..c7328a9a8 100644 --- a/src/smt/abduction_solver.h +++ b/src/smt/abduction_solver.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { class SmtEngine; @@ -115,6 +115,6 @@ class AbductionSolver }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__ABDUCTION_SOLVER_H */ diff --git a/src/smt/abstract_values.cpp b/src/smt/abstract_values.cpp index 90a61f8bb..e4c7f2668 100644 --- a/src/smt/abstract_values.cpp +++ b/src/smt/abstract_values.cpp @@ -16,7 +16,7 @@ #include "options/smt_options.h" -namespace CVC4 { +namespace CVC5 { namespace smt { AbstractValues::AbstractValues(NodeManager* nm) @@ -52,4 +52,4 @@ Node AbstractValues::mkAbstractValue(TNode n) } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/abstract_values.h b/src/smt/abstract_values.h index 27d522203..be4a0c7a3 100644 --- a/src/smt/abstract_values.h +++ b/src/smt/abstract_values.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "theory/substitutions.h" -namespace CVC4 { +namespace CVC5 { namespace smt { /** @@ -75,6 +75,6 @@ class AbstractValues }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/assertions.cpp b/src/smt/assertions.cpp index 38a424731..f82d0769b 100644 --- a/src/smt/assertions.cpp +++ b/src/smt/assertions.cpp @@ -24,10 +24,10 @@ #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) @@ -243,4 +243,4 @@ bool Assertions::isProofEnabled() const } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/assertions.h b/src/smt/assertions.h index 15f1d140e..135fe8974 100644 --- a/src/smt/assertions.h +++ b/src/smt/assertions.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "preprocessing/assertion_pipeline.h" -namespace CVC4 { +namespace CVC5 { namespace smt { class AbstractValues; @@ -172,6 +172,6 @@ class Assertions }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/check_models.cpp b/src/smt/check_models.cpp index 07493d0b9..0c21002af 100644 --- a/src/smt/check_models.cpp +++ b/src/smt/check_models.cpp @@ -23,9 +23,9 @@ #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) {} @@ -148,4 +148,4 @@ void CheckModels::checkModel(Model* m, } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/check_models.h b/src/smt/check_models.h index 4843eea8d..d12a33ee5 100644 --- a/src/smt/check_models.h +++ b/src/smt/check_models.h @@ -20,7 +20,7 @@ #include "context/cdlist.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace smt { class Model; @@ -48,6 +48,6 @@ class CheckModels }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/command.cpp b/src/smt/command.cpp index 5d27c2eb8..f29b67d6d 100644 --- a/src/smt/command.cpp +++ b/src/smt/command.cpp @@ -43,7 +43,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { std::string sexprToString(api::Term sexpr) { @@ -2811,4 +2811,4 @@ void DatatypeDeclarationCommand::toStream(std::ostream& out, out, api::Sort::sortVectorToTypeNodes(d_datatypes)); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/command.h b/src/smt/command.h index 1017a74c9..6d169ce5e 100644 --- a/src/smt/command.h +++ b/src/smt/command.h @@ -31,7 +31,7 @@ #include "cvc4_export.h" #include "options/language.h" -namespace CVC4 { +namespace CVC5 { namespace api { class Solver; @@ -1509,6 +1509,6 @@ class CVC4_EXPORT DeclarationSequence : public CommandSequence OutputLanguage language = language::output::LANG_AUTO) const override; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__COMMAND_H */ diff --git a/src/smt/defined_function.h b/src/smt/defined_function.h index a5c9f8d96..7f3007975 100644 --- a/src/smt/defined_function.h +++ b/src/smt/defined_function.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace smt { /** @@ -55,6 +55,6 @@ class DefinedFunction }; /* class DefinedFunction */ } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__DEFINED_FUNCTION_H */ diff --git a/src/smt/dump.cpp b/src/smt/dump.cpp index bb0bff1d7..76973ec32 100644 --- a/src/smt/dump.cpp +++ b/src/smt/dump.cpp @@ -23,7 +23,7 @@ #include "smt/command.h" #include "smt/node_command.h" -namespace CVC4 { +namespace CVC5 { #if defined(CVC4_DUMPING) && !defined(CVC4_MUZZLE) @@ -58,12 +58,14 @@ CVC4dumpstream& CVC4dumpstream::operator<<(const NodeCommand& nc) 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()) @@ -241,4 +243,4 @@ pipe to perform on-line checking. The --dump-to option can be used to dump\n\ to a file.\n\ "; -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/smt/dump.h b/src/smt/dump.h index d8c2e5b4e..be146470a 100644 --- a/src/smt/dump.h +++ b/src/smt/dump.h @@ -21,7 +21,7 @@ #include "base/output.h" -namespace CVC4 { +namespace CVC5 { class Command; class NodeCommand; @@ -110,8 +110,8 @@ class DumpC /** The dump singleton */ extern DumpC DumpChannel; -#define Dump ::CVC4::DumpChannel +#define Dump ::CVC5::DumpChannel -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__DUMP_H */ diff --git a/src/smt/dump_manager.cpp b/src/smt/dump_manager.cpp index 81993f3d5..6b81d5594 100644 --- a/src/smt/dump_manager.cpp +++ b/src/smt/dump_manager.cpp @@ -18,7 +18,7 @@ #include "smt/dump.h" #include "smt/node_command.h" -namespace CVC4 { +namespace CVC5 { namespace smt { DumpManager::DumpManager(context::UserContext* u) @@ -72,4 +72,4 @@ void DumpManager::setPrintFuncInModel(Node f, bool p) } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/dump_manager.h b/src/smt/dump_manager.h index 1a8a6e3d0..519b93110 100644 --- a/src/smt/dump_manager.h +++ b/src/smt/dump_manager.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class NodeCommand; @@ -75,6 +75,6 @@ class DumpManager }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/env.cpp b/src/smt/env.cpp index 55afcadf7..6440c29d3 100644 --- a/src/smt/env.cpp +++ b/src/smt/env.cpp @@ -25,9 +25,9 @@ #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()), @@ -101,4 +101,4 @@ const Printer& Env::getPrinter() std::ostream& Env::getDumpOut() { return *d_options.getOut(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/env.h b/src/smt/env.h index 18f0de0b5..3ceefdd34 100644 --- a/src/smt/env.h +++ b/src/smt/env.h @@ -25,7 +25,7 @@ #include "util/statistics.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { class NodeManager; class StatisticsRegistry; @@ -182,6 +182,6 @@ class Env std::unique_ptr<ResourceManager> d_resourceManager; }; /* class Env */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__ENV_H */ diff --git a/src/smt/expand_definitions.cpp b/src/smt/expand_definitions.cpp index 62779dbba..599f57747 100644 --- a/src/smt/expand_definitions.cpp +++ b/src/smt/expand_definitions.cpp @@ -24,11 +24,11 @@ #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, @@ -367,4 +367,4 @@ void ExpandDefs::setProofNodeManager(ProofNodeManager* pnm) } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/expand_definitions.h b/src/smt/expand_definitions.h index 5f21e8f0c..035e7989d 100644 --- a/src/smt/expand_definitions.h +++ b/src/smt/expand_definitions.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; class ResourceManager; @@ -95,6 +95,6 @@ class ExpandDefs }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/interpolation_solver.cpp b/src/smt/interpolation_solver.cpp index 616014992..d14b87901 100644 --- a/src/smt/interpolation_solver.cpp +++ b/src/smt/interpolation_solver.cpp @@ -23,9 +23,9 @@ #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) @@ -136,4 +136,4 @@ void InterpolationSolver::checkInterpol(Node interpol, } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/interpolation_solver.h b/src/smt/interpolation_solver.h index e4c8faecd..1c9b65d85 100644 --- a/src/smt/interpolation_solver.h +++ b/src/smt/interpolation_solver.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { class SmtEngine; @@ -81,6 +81,6 @@ class InterpolationSolver }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__INTERPOLATION_SOLVER_H */ diff --git a/src/smt/listeners.cpp b/src/smt/listeners.cpp index 7f85e2f98..c686e4115 100644 --- a/src/smt/listeners.cpp +++ b/src/smt/listeners.cpp @@ -25,7 +25,7 @@ #include "smt/smt_engine.h" #include "smt/smt_engine_scope.h" -namespace CVC4 { +namespace CVC5 { namespace smt { ResourceOutListener::ResourceOutListener(SmtEngine& smt) : d_smt(smt) {} @@ -103,4 +103,4 @@ void SmtNodeManagerListener::nmNotifyNewSkolem(TNode n, } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/listeners.h b/src/smt/listeners.h index d3dc04ebc..1705b9126 100644 --- a/src/smt/listeners.h +++ b/src/smt/listeners.h @@ -22,7 +22,7 @@ #include "base/listener.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class OutputManager; class SmtEngine; @@ -75,6 +75,6 @@ class SmtNodeManagerListener : public NodeManagerListener }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/logic_exception.h b/src/smt/logic_exception.h index bb1d274ae..91f2d3723 100644 --- a/src/smt/logic_exception.h +++ b/src/smt/logic_exception.h @@ -24,9 +24,9 @@ #include "base/exception.h" -namespace CVC4 { +namespace CVC5 { -class LogicException : public CVC4::Exception +class LogicException : public CVC5::Exception { public: LogicException() : @@ -43,6 +43,6 @@ class LogicException : public CVC4::Exception } }; /* class LogicException */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__SMT__LOGIC_EXCEPTION_H */ diff --git a/src/smt/managed_ostreams.cpp b/src/smt/managed_ostreams.cpp index dcf90228c..6baabe0e5 100644 --- a/src/smt/managed_ostreams.cpp +++ b/src/smt/managed_ostreams.cpp @@ -24,7 +24,7 @@ #include "options/smt_options.h" #include "smt/update_ostream.h" -namespace CVC4 { +namespace CVC5 { ManagedOstream::ManagedOstream() : d_managed(NULL) {} @@ -164,4 +164,4 @@ void ManagedDiagnosticOutputChannel::addSpecialCases(OstreamOpener* opener) opener->addSpecialCase("stderr", &std::cerr); } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/smt/managed_ostreams.h b/src/smt/managed_ostreams.h index 55ca15dcb..ba56bcfa3 100644 --- a/src/smt/managed_ostreams.h +++ b/src/smt/managed_ostreams.h @@ -22,7 +22,7 @@ #include <ostream> -namespace CVC4 { +namespace CVC5 { class OstreamOpener; @@ -141,6 +141,6 @@ class ManagedDiagnosticOutputChannel : public ManagedOstream { void addSpecialCases(OstreamOpener* opener) const override; };/* class ManagedRegularOutputChannel */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__MANAGED_OSTREAMS_H */ diff --git a/src/smt/model.cpp b/src/smt/model.cpp index 93459a2b5..c1b9b7c12 100644 --- a/src/smt/model.cpp +++ b/src/smt/model.cpp @@ -23,7 +23,7 @@ #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) @@ -68,4 +68,4 @@ const std::vector<Node>& Model::getDeclaredTerms() const } } // namespace smt -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/smt/model.h b/src/smt/model.h index 063116de8..f43ba6eec 100644 --- a/src/smt/model.h +++ b/src/smt/model.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class SmtEngine; @@ -46,7 +46,7 @@ std::ostream& operator<<(std::ostream&, const Model&); */ class Model { friend std::ostream& operator<<(std::ostream&, const Model&); - friend class ::CVC4::SmtEngine; + friend class ::CVC5::SmtEngine; public: /** construct */ @@ -118,6 +118,6 @@ class Model { }; } // namespace smt -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__MODEL_H */ diff --git a/src/smt/model_blocker.cpp b/src/smt/model_blocker.cpp index 6ae09b27c..964a59b2f 100644 --- a/src/smt/model_blocker.cpp +++ b/src/smt/model_blocker.cpp @@ -21,9 +21,9 @@ #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, @@ -278,4 +278,4 @@ Node ModelBlocker::getModelBlocker(const std::vector<Node>& assertions, return blocker; } -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/smt/model_blocker.h b/src/smt/model_blocker.h index 52389480e..3ec28758f 100644 --- a/src/smt/model_blocker.h +++ b/src/smt/model_blocker.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "options/smt_options.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class TheoryModel; @@ -69,6 +69,6 @@ class ModelBlocker const std::vector<Node>& exprToBlock = std::vector<Node>()); }; /* class TheoryModelCoreBuilder */ -} // namespace CVC4 +} // namespace CVC5 #endif /* __CVC4__THEORY__MODEL_BLOCKER_H */ diff --git a/src/smt/model_core_builder.cpp b/src/smt/model_core_builder.cpp index 9bd531a1f..b68797f61 100644 --- a/src/smt/model_core_builder.cpp +++ b/src/smt/model_core_builder.cpp @@ -16,9 +16,9 @@ #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, @@ -104,4 +104,4 @@ bool ModelCoreBuilder::setModelCore(const std::vector<Node>& assertions, return false; } -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/smt/model_core_builder.h b/src/smt/model_core_builder.h index 229eaf8e9..6075b528f 100644 --- a/src/smt/model_core_builder.h +++ b/src/smt/model_core_builder.h @@ -23,7 +23,7 @@ #include "options/smt_options.h" #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { /** * A utility for building model cores. @@ -59,6 +59,6 @@ class ModelCoreBuilder options::ModelCoresMode mode); }; /* class TheoryModelCoreBuilder */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__MODEL_CORE_BUILDER_H */ diff --git a/src/smt/node_command.cpp b/src/smt/node_command.cpp index 98f73d34d..487a65ddf 100644 --- a/src/smt/node_command.cpp +++ b/src/smt/node_command.cpp @@ -20,7 +20,7 @@ #include "printer/printer.h" -namespace CVC4 { +namespace CVC5 { /* -------------------------------------------------------------------------- */ /* class NodeCommand */ @@ -158,4 +158,4 @@ NodeCommand* DefineFunctionNodeCommand::clone() const return new DefineFunctionNodeCommand(d_id, d_fun, d_formals, d_formula); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/node_command.h b/src/smt/node_command.h index faef7aca3..0820ea807 100644 --- a/src/smt/node_command.h +++ b/src/smt/node_command.h @@ -25,7 +25,7 @@ #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 @@ -142,6 +142,6 @@ class DefineFunctionNodeCommand : public NodeCommand Node d_formula; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__NODE_COMMAND_H */ diff --git a/src/smt/optimization_solver.cpp b/src/smt/optimization_solver.cpp index 1d92a5591..2143b9467 100644 --- a/src/smt/optimization_solver.cpp +++ b/src/smt/optimization_solver.cpp @@ -19,9 +19,9 @@ #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 { /** @@ -134,4 +134,4 @@ ObjectiveType Objective::getType() { return d_type; } Node Objective::getNode() { return d_node; } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/optimization_solver.h b/src/smt/optimization_solver.h index 6117b9df5..c24a4ae52 100644 --- a/src/smt/optimization_solver.h +++ b/src/smt/optimization_solver.h @@ -22,7 +22,7 @@ #include "smt/assertions.h" #include "util/result.h" -namespace CVC4 { +namespace CVC5 { class SmtEngine; @@ -114,6 +114,6 @@ class Objective }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__OPTIMIZATION_SOLVER_H */ diff --git a/src/smt/options_manager.cpp b/src/smt/options_manager.cpp index 8cab87b9f..d78435754 100644 --- a/src/smt/options_manager.cpp +++ b/src/smt/options_manager.cpp @@ -24,7 +24,7 @@ #include "smt/set_defaults.h" #include "util/resource_manager.h" -namespace CVC4 { +namespace CVC5 { namespace smt { OptionsManager::OptionsManager(Options* opts, ResourceManager* rm) @@ -143,4 +143,4 @@ void OptionsManager::finishInit(LogicInfo& logic, bool isInternalSubsolver) } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/options_manager.h b/src/smt/options_manager.h index 12a1689a1..29e222296 100644 --- a/src/smt/options_manager.h +++ b/src/smt/options_manager.h @@ -18,7 +18,7 @@ #include "options/options_listener.h" #include "smt/managed_ostreams.h" -namespace CVC4 { +namespace CVC5 { class LogicInfo; class Options; @@ -75,6 +75,6 @@ class OptionsManager : public OptionsListener }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__OPTIONS_MANAGER_H */ diff --git a/src/smt/output_manager.cpp b/src/smt/output_manager.cpp index e01d5879e..6d01643ab 100644 --- a/src/smt/output_manager.cpp +++ b/src/smt/output_manager.cpp @@ -18,7 +18,7 @@ #include "smt/smt_engine.h" -namespace CVC4 { +namespace CVC5 { OutputManager::OutputManager(SmtEngine* smt) : d_smt(smt) {} @@ -29,4 +29,4 @@ std::ostream& OutputManager::getDumpOut() const return *d_smt->getOptions().getOut(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/output_manager.h b/src/smt/output_manager.h index 88759e66d..76db5d19b 100644 --- a/src/smt/output_manager.h +++ b/src/smt/output_manager.h @@ -20,7 +20,7 @@ #include <ostream> -namespace CVC4 { +namespace CVC5 { class Printer; class SmtEngine; @@ -52,6 +52,6 @@ class OutputManager SmtEngine* d_smt; }; -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__SMT__OUTPUT_MANAGER_H diff --git a/src/smt/preprocess_proof_generator.cpp b/src/smt/preprocess_proof_generator.cpp index 9ee01b2ef..0fd3d9ce6 100644 --- a/src/smt/preprocess_proof_generator.cpp +++ b/src/smt/preprocess_proof_generator.cpp @@ -23,7 +23,7 @@ #include "options/proof_options.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace smt { PreprocessProofGenerator::PreprocessProofGenerator(ProofNodeManager* pnm, @@ -254,4 +254,4 @@ void PreprocessProofGenerator::checkEagerPedantic(PfRule r) } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/preprocess_proof_generator.h b/src/smt/preprocess_proof_generator.h index ed19549c9..338397488 100644 --- a/src/smt/preprocess_proof_generator.h +++ b/src/smt/preprocess_proof_generator.h @@ -24,7 +24,7 @@ #include "expr/proof_generator.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { class LazyCDProof; class ProofNodeManager; @@ -144,6 +144,6 @@ class PreprocessProofGenerator : public ProofGenerator }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/preprocessor.cpp b/src/smt/preprocessor.cpp index e5dd7869c..c2ebdbcd0 100644 --- a/src/smt/preprocessor.cpp +++ b/src/smt/preprocessor.cpp @@ -24,10 +24,10 @@ #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, @@ -159,4 +159,4 @@ void Preprocessor::setProofGenerator(PreprocessProofGenerator* pppg) } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/preprocessor.h b/src/smt/preprocessor.h index eadbbedc5..6bb0ef5d6 100644 --- a/src/smt/preprocessor.h +++ b/src/smt/preprocessor.h @@ -23,7 +23,7 @@ #include "smt/process_assertions.h" #include "theory/booleans/circuit_propagator.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { class PreprocessingPassContext; } @@ -128,6 +128,6 @@ class Preprocessor }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/process_assertions.cpp b/src/smt/process_assertions.cpp index 3c7d88fe8..7ff4e54b5 100644 --- a/src/smt/process_assertions.cpp +++ b/src/smt/process_assertions.cpp @@ -39,11 +39,11 @@ #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. */ @@ -462,4 +462,4 @@ void ProcessAssertions::dumpAssertions(const char* key, } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/process_assertions.h b/src/smt/process_assertions.h index f1c0aed3b..3844daafb 100644 --- a/src/smt/process_assertions.h +++ b/src/smt/process_assertions.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "util/resource_manager.h" -namespace CVC4 { +namespace CVC5 { class SmtEngine; @@ -124,6 +124,6 @@ class ProcessAssertions }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/proof_manager.cpp b/src/smt/proof_manager.cpp index 765beb9a2..d3b650612 100644 --- a/src/smt/proof_manager.cpp +++ b/src/smt/proof_manager.cpp @@ -25,7 +25,7 @@ #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) @@ -190,4 +190,4 @@ void PfManager::getAssertions(Assertions& as, } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/proof_manager.h b/src/smt/proof_manager.h index bf2078396..f0f384b7c 100644 --- a/src/smt/proof_manager.h +++ b/src/smt/proof_manager.h @@ -20,7 +20,7 @@ #include "context/cdhashmap.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class ProofChecker; class ProofNode; @@ -117,6 +117,6 @@ class PfManager }; /* class SmtEngine */ } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__PROOF_MANAGER_H */ diff --git a/src/smt/proof_post_processor.cpp b/src/smt/proof_post_processor.cpp index ff437e7e6..7e48c5c48 100644 --- a/src/smt/proof_post_processor.cpp +++ b/src/smt/proof_post_processor.cpp @@ -25,10 +25,10 @@ #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, @@ -1185,4 +1185,4 @@ void ProofPostproccess::setEliminateRule(PfRule rule) } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/proof_post_processor.h b/src/smt/proof_post_processor.h index 78c367881..3c0d1e841 100644 --- a/src/smt/proof_post_processor.h +++ b/src/smt/proof_post_processor.h @@ -25,7 +25,7 @@ #include "util/statistics_registry.h" #include "util/stats_histogram.h" -namespace CVC4 { +namespace CVC5 { class SmtEngine; @@ -303,6 +303,6 @@ class ProofPostproccess }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/quant_elim_solver.cpp b/src/smt/quant_elim_solver.cpp index ba11319d3..08b69af81 100644 --- a/src/smt/quant_elim_solver.cpp +++ b/src/smt/quant_elim_solver.cpp @@ -23,10 +23,10 @@ #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) {} @@ -130,4 +130,4 @@ Node QuantElimSolver::getQuantifierElimination(Assertions& as, } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/quant_elim_solver.h b/src/smt/quant_elim_solver.h index 9c3ee5a3f..80f67371b 100644 --- a/src/smt/quant_elim_solver.h +++ b/src/smt/quant_elim_solver.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "smt/assertions.h" -namespace CVC4 { +namespace CVC5 { namespace smt { class SmtSolver; @@ -99,6 +99,6 @@ class QuantElimSolver }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__QUANT_ELIM_SOLVER_H */ diff --git a/src/smt/set_defaults.cpp b/src/smt/set_defaults.cpp index f8476b734..dd76de313 100644 --- a/src/smt/set_defaults.cpp +++ b/src/smt/set_defaults.cpp @@ -41,9 +41,9 @@ #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) @@ -1480,4 +1480,4 @@ void setDefaults(LogicInfo& logic, bool isInternalSubsolver) } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/set_defaults.h b/src/smt/set_defaults.h index a4513c0e1..220314b0d 100644 --- a/src/smt/set_defaults.h +++ b/src/smt/set_defaults.h @@ -17,7 +17,7 @@ #include "theory/logic_info.h" -namespace CVC4 { +namespace CVC5 { namespace smt { /** @@ -36,6 +36,6 @@ namespace smt { void setDefaults(LogicInfo& logic, bool isInternalSubsolver); } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__SET_DEFAULTS_H */ diff --git a/src/smt/smt_engine.cpp b/src/smt/smt_engine.cpp index f10439156..a7e464008 100644 --- a/src/smt/smt_engine.cpp +++ b/src/smt/smt_engine.cpp @@ -72,13 +72,13 @@ #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)), @@ -505,7 +505,7 @@ bool SmtEngine::isValidGetInfoFlag(const std::string& key) const return false; } -CVC4::SExpr SmtEngine::getInfo(const std::string& key) const +CVC5::SExpr SmtEngine::getInfo(const std::string& key) const { SmtScope smts(this); @@ -2047,4 +2047,4 @@ OutputManager& SmtEngine::getOutputManager() { return d_outMgr; } theory::Rewriter* SmtEngine::getRewriter() { return d_env->getRewriter(); } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/smt/smt_engine.h b/src/smt/smt_engine.h index de3a64ff6..21250dc30 100644 --- a/src/smt/smt_engine.h +++ b/src/smt/smt_engine.h @@ -34,7 +34,7 @@ #include "util/sexpr.h" #include "util/statistics.h" -namespace CVC4 { +namespace CVC5 { template <bool ref_count> class NodeTemplate; typedef NodeTemplate<true> Node; @@ -63,7 +63,7 @@ class Solver; namespace context { class Context; class UserContext; -}/* CVC4::context namespace */ + } // namespace context /* -------------------------------------------------------------------------- */ @@ -75,7 +75,7 @@ class PreprocessingPassContext; namespace prop { class PropEngine; -}/* CVC4::prop namespace */ + } // namespace prop /* -------------------------------------------------------------------------- */ @@ -111,24 +111,23 @@ class PfManager; 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: @@ -220,7 +219,7 @@ class CVC4_EXPORT SmtEngine 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. @@ -1168,6 +1167,6 @@ class CVC4_EXPORT SmtEngine /* -------------------------------------------------------------------------- */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__SMT_ENGINE_H */ diff --git a/src/smt/smt_engine_scope.cpp b/src/smt/smt_engine_scope.cpp index 2aa96dfbb..d3dff72ce 100644 --- a/src/smt/smt_engine_scope.cpp +++ b/src/smt/smt_engine_scope.cpp @@ -22,7 +22,7 @@ #include "base/output.h" #include "smt/smt_engine.h" -namespace CVC4 { +namespace CVC5 { namespace smt { thread_local SmtEngine* s_smtEngine_current = NULL; @@ -65,5 +65,5 @@ StatisticsRegistry* SmtScope::currentStatisticsRegistry() { return s_smtEngine_current->getStatisticsRegistry(); } -}/* CVC4::smt namespace */ -}/* CVC4 namespace */ +} // namespace smt +} // namespace CVC5 diff --git a/src/smt/smt_engine_scope.h b/src/smt/smt_engine_scope.h index 746abe1df..e45679f79 100644 --- a/src/smt/smt_engine_scope.h +++ b/src/smt/smt_engine_scope.h @@ -24,7 +24,7 @@ #include "options/options.h" -namespace CVC4 { +namespace CVC5 { class ProofManager; class SmtEngine; @@ -59,8 +59,7 @@ class SmtScope : public NodeManagerScope Options::OptionsScope d_optionsScope; };/* class SmtScope */ - -}/* CVC4::smt namespace */ -}/* CVC4 namespace */ +} // namespace smt +} // namespace CVC5 #endif /* CVC4__SMT__SMT_ENGINE_SCOPE_H */ diff --git a/src/smt/smt_engine_state.cpp b/src/smt/smt_engine_state.cpp index 504709942..fcf02784f 100644 --- a/src/smt/smt_engine_state.cpp +++ b/src/smt/smt_engine_state.cpp @@ -17,7 +17,7 @@ #include "options/smt_options.h" #include "smt/smt_engine.h" -namespace CVC4 { +namespace CVC5 { namespace smt { SmtEngineState::SmtEngineState(context::Context* c, @@ -308,4 +308,4 @@ void SmtEngineState::doPendingPops() } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/smt_engine_state.h b/src/smt/smt_engine_state.h index 3c3075bf5..b5d98832f 100644 --- a/src/smt/smt_engine_state.h +++ b/src/smt/smt_engine_state.h @@ -23,7 +23,7 @@ #include "smt/smt_mode.h" #include "util/result.h" -namespace CVC4 { +namespace CVC5 { class SmtEngine; @@ -261,6 +261,6 @@ class SmtEngineState }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/smt_engine_stats.cpp b/src/smt/smt_engine_stats.cpp index 382dcba1f..1becdc8c2 100644 --- a/src/smt/smt_engine_stats.cpp +++ b/src/smt/smt_engine_stats.cpp @@ -16,7 +16,7 @@ #include "smt/smt_statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace smt { SmtEngineStatistics::SmtEngineStatistics() @@ -70,4 +70,4 @@ SmtEngineStatistics::~SmtEngineStatistics() } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/smt_engine_stats.h b/src/smt/smt_engine_stats.h index 9e3e7989e..e0923ec3e 100644 --- a/src/smt/smt_engine_stats.h +++ b/src/smt/smt_engine_stats.h @@ -20,7 +20,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace smt { struct SmtEngineStatistics @@ -60,6 +60,6 @@ struct SmtEngineStatistics }; /* struct SmtEngineStatistics */ } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__SMT_ENGINE_STATS_H */ diff --git a/src/smt/smt_mode.cpp b/src/smt/smt_mode.cpp index 49a8822dc..f25607249 100644 --- a/src/smt/smt_mode.cpp +++ b/src/smt/smt_mode.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& out, SmtMode m) { @@ -34,4 +34,4 @@ std::ostream& operator<<(std::ostream& out, SmtMode m) return out; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/smt_mode.h b/src/smt/smt_mode.h index dd8e13c72..91c35fc1f 100644 --- a/src/smt/smt_mode.h +++ b/src/smt/smt_mode.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC4 { +namespace CVC5 { /** * The mode of the solver, which is an extension of Figure 4.1 on @@ -52,6 +52,6 @@ enum class SmtMode */ std::ostream& operator<<(std::ostream& out, SmtMode m); -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt/smt_solver.cpp b/src/smt/smt_solver.cpp index 89e75d892..e8ac58fe7 100644 --- a/src/smt/smt_solver.cpp +++ b/src/smt/smt_solver.cpp @@ -27,7 +27,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace smt { SmtSolver::SmtSolver(SmtEngine& smt, @@ -287,4 +287,4 @@ theory::QuantifiersEngine* SmtSolver::getQuantifiersEngine() Preprocessor* SmtSolver::getPreprocessor() { return &d_pp; } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/smt_solver.h b/src/smt/smt_solver.h index e93cc63b8..db4871381 100644 --- a/src/smt/smt_solver.h +++ b/src/smt/smt_solver.h @@ -23,7 +23,7 @@ #include "theory/logic_info.h" #include "util/result.h" -namespace CVC4 { +namespace CVC5 { class SmtEngine; class TheoryEngine; @@ -151,6 +151,6 @@ class SmtSolver }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__SMT_SOLVER_H */ diff --git a/src/smt/smt_statistics_registry.cpp b/src/smt/smt_statistics_registry.cpp index 7757d5b1b..a916aae7b 100644 --- a/src/smt/smt_statistics_registry.cpp +++ b/src/smt/smt_statistics_registry.cpp @@ -19,10 +19,10 @@ #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 diff --git a/src/smt/smt_statistics_registry.h b/src/smt/smt_statistics_registry.h index 38ff6fcc3..31d151544 100644 --- a/src/smt/smt_statistics_registry.h +++ b/src/smt/smt_statistics_registry.h @@ -20,7 +20,7 @@ #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { /** * This returns the StatisticsRegistry attached to the currently in scope @@ -28,4 +28,4 @@ namespace CVC4 { */ StatisticsRegistry* smtStatisticsRegistry(); -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/smt/sygus_solver.cpp b/src/smt/sygus_solver.cpp index ea74f7a1e..2bb38ea98 100644 --- a/src/smt/sygus_solver.cpp +++ b/src/smt/sygus_solver.cpp @@ -29,10 +29,10 @@ #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, @@ -412,4 +412,4 @@ void SygusSolver::setSygusConjectureStale() } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/sygus_solver.h b/src/smt/sygus_solver.h index 5cdf26fce..a1ffa195d 100644 --- a/src/smt/sygus_solver.h +++ b/src/smt/sygus_solver.h @@ -23,7 +23,7 @@ #include "smt/assertions.h" #include "util/result.h" -namespace CVC4 { +namespace CVC5 { class OutputManager; @@ -189,6 +189,6 @@ class SygusSolver }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__SYGUS_SOLVER_H */ diff --git a/src/smt/term_formula_removal.cpp b/src/smt/term_formula_removal.cpp index 6202ab80c..4d726b64e 100644 --- a/src/smt/term_formula_removal.cpp +++ b/src/smt/term_formula_removal.cpp @@ -28,7 +28,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { RemoveTermFormulas::RemoveTermFormulas(context::UserContext* u, ProofNodeManager* pnm) @@ -544,4 +544,4 @@ ProofGenerator* RemoveTermFormulas::getTConvProofGenerator() bool RemoveTermFormulas::isProofEnabled() const { return d_pnm != nullptr; } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/smt/term_formula_removal.h b/src/smt/term_formula_removal.h index 22d5870b7..0f80fb8a4 100644 --- a/src/smt/term_formula_removal.h +++ b/src/smt/term_formula_removal.h @@ -28,7 +28,7 @@ #include "theory/trust_node.h" #include "util/hash.h" -namespace CVC4 { +namespace CVC5 { class LazyCDProof; class ProofNodeManager; @@ -209,4 +209,4 @@ class RemoveTermFormulas { bool isProofEnabled() const; };/* class RemoveTTE */ -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/smt/unsat_core_manager.cpp b/src/smt/unsat_core_manager.cpp index f1bc1065b..4d17c7414 100644 --- a/src/smt/unsat_core_manager.cpp +++ b/src/smt/unsat_core_manager.cpp @@ -17,7 +17,7 @@ #include "expr/proof_node_algorithm.h" #include "smt/assertions.h" -namespace CVC4 { +namespace CVC5 { namespace smt { void UnsatCoreManager::getUnsatCore(std::shared_ptr<ProofNode> pfn, @@ -89,4 +89,4 @@ void UnsatCoreManager::getRelevantInstantiations( } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/unsat_core_manager.h b/src/smt/unsat_core_manager.h index daa83ed54..92e6018df 100644 --- a/src/smt/unsat_core_manager.h +++ b/src/smt/unsat_core_manager.h @@ -21,7 +21,7 @@ #include "expr/node.h" #include "expr/proof_node.h" -namespace CVC4 { +namespace CVC5 { namespace smt { @@ -67,6 +67,6 @@ class UnsatCoreManager }; /* class UnsatCoreManager */ } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SMT__UNSAT_CORE_MANAGER_H */ diff --git a/src/smt/update_ostream.h b/src/smt/update_ostream.h index ef2ea03e4..691da984f 100644 --- a/src/smt/update_ostream.h +++ b/src/smt/update_ostream.h @@ -30,7 +30,7 @@ #include "options/set_language.h" #include "smt/dump.h" -namespace CVC4 { +namespace CVC5 { class ChannelSettings { public: @@ -116,6 +116,6 @@ class TraceOstreamUpdate : public OstreamUpdate { void set(std::ostream* setTo) override { Trace.setStream(setTo); } }; /* class TraceOstreamUpdate */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__UPDATE_OSTREAM_H */ diff --git a/src/smt/witness_form.cpp b/src/smt/witness_form.cpp index a339210c0..959a6a6c3 100644 --- a/src/smt/witness_form.cpp +++ b/src/smt/witness_form.cpp @@ -17,7 +17,7 @@ #include "expr/skolem_manager.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace smt { WitnessFormGenerator::WitnessFormGenerator(ProofNodeManager* pnm) @@ -152,4 +152,4 @@ ProofGenerator* WitnessFormGenerator::convertExistsInternal(Node exists) } } // namespace smt -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/smt/witness_form.h b/src/smt/witness_form.h index c48948ade..905b0624b 100644 --- a/src/smt/witness_form.h +++ b/src/smt/witness_form.h @@ -23,7 +23,7 @@ #include "expr/proof_generator.h" #include "expr/term_conversion_proof_generator.h" -namespace CVC4 { +namespace CVC5 { namespace smt { /** @@ -97,6 +97,6 @@ class WitnessFormGenerator : public ProofGenerator }; } // namespace smt -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/smt_util/boolean_simplification.cpp b/src/smt_util/boolean_simplification.cpp index b412a4418..01f1a6a5b 100644 --- a/src/smt_util/boolean_simplification.cpp +++ b/src/smt_util/boolean_simplification.cpp @@ -16,7 +16,7 @@ #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) @@ -61,4 +61,4 @@ bool BooleanSimplification::push_back_associative_commute_recursive( return true; }/* BooleanSimplification::push_back_associative_commute_recursive() */ -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/smt_util/boolean_simplification.h b/src/smt_util/boolean_simplification.h index 2b0af49c3..d9251baf5 100644 --- a/src/smt_util/boolean_simplification.h +++ b/src/smt_util/boolean_simplification.h @@ -25,7 +25,7 @@ #include "base/check.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { /** * A class to contain a number of useful functions for simple @@ -223,6 +223,6 @@ class BooleanSimplification { };/* class BooleanSimplification */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__BOOLEAN_SIMPLIFICATION_H */ diff --git a/src/smt_util/nary_builder.cpp b/src/smt_util/nary_builder.cpp index fa154c245..41da7e170 100644 --- a/src/smt_util/nary_builder.cpp +++ b/src/smt_util/nary_builder.cpp @@ -20,7 +20,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace util { Node NaryBuilder::mkAssoc(Kind kind, const std::vector<Node>& children) @@ -202,4 +202,4 @@ Node RePairAssocCommutativeOperators::case_other(TNode n){ } }/* util namespace */ -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/smt_util/nary_builder.h b/src/smt_util/nary_builder.h index 54fa59edb..dc8a428d0 100644 --- a/src/smt_util/nary_builder.h +++ b/src/smt_util/nary_builder.h @@ -24,7 +24,7 @@ #include "expr/node.h" -namespace CVC4{ +namespace CVC5 { namespace util { class NaryBuilder { @@ -53,4 +53,4 @@ private: };/* class RePairAssocCommutativeOperators */ }/* util namespace */ -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/theory/arith/approx_simplex.cpp b/src/theory/arith/approx_simplex.cpp index 8d98475ce..c911d03e9 100644 --- a/src/theory/arith/approx_simplex.cpp +++ b/src/theory/arith/approx_simplex.cpp @@ -36,7 +36,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -367,9 +367,9 @@ public: 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 @@ -377,7 +377,7 @@ extern "C" { #include <glpk.h> }/* extern "C" */ -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -535,14 +535,14 @@ private: 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){ @@ -559,15 +559,14 @@ bool ApproximateSimplex::enabled() { 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 { @@ -3175,9 +3174,8 @@ void ApproxGLPK::tryCut(int nid, CutInfo& cut) } } - -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 #endif /*#ifdef CVC4_USE_GLPK */ /* End GPLK implementation. */ diff --git a/src/theory/arith/approx_simplex.h b/src/theory/arith/approx_simplex.h index a9b179e31..5835c57c1 100644 --- a/src/theory/arith/approx_simplex.h +++ b/src/theory/arith/approx_simplex.h @@ -28,7 +28,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -163,7 +163,6 @@ class ApproximateSimplex{ static Integer s_defaultMaxDenom; };/* class ApproximateSimplex */ - -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/arith_ite_utils.cpp b/src/theory/arith/arith_ite_utils.cpp index fa6fd108c..42189f86a 100644 --- a/src/theory/arith/arith_ite_utils.cpp +++ b/src/theory/arith/arith_ite_utils.cpp @@ -30,7 +30,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -47,7 +47,7 @@ Node ArithIteUtils::applyReduceVariablesInItes(Node n){ } 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; @@ -455,7 +455,6 @@ bool ArithIteUtils::solveBinOr(TNode binor){ return false; } - -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/arith_ite_utils.h b/src/theory/arith/arith_ite_utils.h index e1e27884d..263ddda8e 100644 --- a/src/theory/arith/arith_ite_utils.h +++ b/src/theory/arith/arith_ite_utils.h @@ -28,7 +28,7 @@ #include "context/cdo.h" #include "context/cdinsert_hashmap.h" -namespace CVC4 { +namespace CVC5 { namespace preprocessing { namespace util { class ContainsTermITEVisitor; @@ -109,8 +109,8 @@ private: }; /* 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 */ diff --git a/src/theory/arith/arith_msum.cpp b/src/theory/arith/arith_msum.cpp index 83b8b67c2..9190dac7d 100644 --- a/src/theory/arith/arith_msum.cpp +++ b/src/theory/arith/arith_msum.cpp @@ -16,9 +16,9 @@ #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) @@ -321,5 +321,5 @@ void ArithMSum::debugPrintMonomialSum(std::map<Node, Node>& msum, const char* c) Trace(c) << std::endl; } -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/arith_msum.h b/src/theory/arith/arith_msum.h index f7470d4e0..f4a2bf824 100644 --- a/src/theory/arith/arith_msum.h +++ b/src/theory/arith/arith_msum.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** Arithmetic utilities regarding monomial sums. @@ -182,7 +182,7 @@ class ArithMSum 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 */ diff --git a/src/theory/arith/arith_preprocess.cpp b/src/theory/arith/arith_preprocess.cpp index a075c87fe..2b120c9c7 100644 --- a/src/theory/arith/arith_preprocess.cpp +++ b/src/theory/arith/arith_preprocess.cpp @@ -18,7 +18,7 @@ #include "theory/arith/inference_manager.h" #include "theory/skolem_lemma.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -80,4 +80,4 @@ bool ArithPreprocess::isReduced(TNode atom) const } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/arith_preprocess.h b/src/theory/arith/arith_preprocess.h index db0fd7d5e..45ce0c597 100644 --- a/src/theory/arith/arith_preprocess.h +++ b/src/theory/arith/arith_preprocess.h @@ -21,7 +21,7 @@ #include "theory/arith/operator_elim.h" #include "theory/logic_info.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class SkolemLemma; @@ -86,6 +86,6 @@ class ArithPreprocess } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/arith_rewriter.cpp b/src/theory/arith/arith_rewriter.cpp index 2de8cf66b..01e88b1a8 100644 --- a/src/theory/arith/arith_rewriter.cpp +++ b/src/theory/arith/arith_rewriter.cpp @@ -28,7 +28,7 @@ #include "theory/theory.h" #include "util/iand.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -228,7 +228,7 @@ RewriteResponse ArithRewriter::postRewriteTerm(TNode t){ 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(); @@ -899,6 +899,6 @@ RewriteResponse ArithRewriter::returnRewrite(TNode t, Node ret, Rewrite r) return RewriteResponse(REWRITE_AGAIN_FULL, ret); } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/arith_rewriter.h b/src/theory/arith/arith_rewriter.h index 9bf88dfe6..556a7bda7 100644 --- a/src/theory/arith/arith_rewriter.h +++ b/src/theory/arith/arith_rewriter.h @@ -23,7 +23,7 @@ #include "theory/arith/rewrites.h" #include "theory/theory_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -71,8 +71,8 @@ class ArithRewriter : public TheoryRewriter 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 */ diff --git a/src/theory/arith/arith_state.cpp b/src/theory/arith/arith_state.cpp index 1c41ecf81..bab1d6eb9 100644 --- a/src/theory/arith/arith_state.cpp +++ b/src/theory/arith/arith_state.cpp @@ -16,7 +16,7 @@ #include "theory/arith/theory_arith_private.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -35,4 +35,4 @@ bool ArithState::isInConflict() const } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/arith_state.h b/src/theory/arith/arith_state.h index ffb4a2abc..dfe2bc877 100644 --- a/src/theory/arith/arith_state.h +++ b/src/theory/arith/arith_state.h @@ -19,7 +19,7 @@ #include "theory/theory_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -52,6 +52,6 @@ class ArithState : public TheoryState } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/arith_static_learner.cpp b/src/theory/arith/arith_static_learner.cpp index b7169df1f..b0129970e 100644 --- a/src/theory/arith/arith_static_learner.cpp +++ b/src/theory/arith/arith_static_learner.cpp @@ -27,9 +27,9 @@ #include "theory/rewriter.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -271,6 +271,6 @@ void ArithStaticLearner::addBound(TNode n) { } } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/arith_static_learner.h b/src/theory/arith/arith_static_learner.h index 799d0bcee..668527c0f 100644 --- a/src/theory/arith/arith_static_learner.h +++ b/src/theory/arith/arith_static_learner.h @@ -25,7 +25,7 @@ #include "theory/arith/delta_rational.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace context { class Context; } @@ -69,8 +69,8 @@ private: };/* 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 */ diff --git a/src/theory/arith/arith_utilities.cpp b/src/theory/arith/arith_utilities.cpp index 4f1f50b7a..16c412546 100644 --- a/src/theory/arith/arith_utilities.cpp +++ b/src/theory/arith/arith_utilities.cpp @@ -16,9 +16,9 @@ #include <cmath> -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -325,4 +325,4 @@ Node negateProofLiteral(TNode n) } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/arith_utilities.h b/src/theory/arith/arith_utilities.h index 40ca7b8f6..9c0edb893 100644 --- a/src/theory/arith/arith_utilities.h +++ b/src/theory/arith/arith_utilities.h @@ -28,7 +28,7 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -342,8 +342,8 @@ Rational greatestIntLessThan(const Rational&); /** 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 */ diff --git a/src/theory/arith/arithvar.cpp b/src/theory/arith/arithvar.cpp index 59253e87c..a0c29cb84 100644 --- a/src/theory/arith/arithvar.cpp +++ b/src/theory/arith/arithvar.cpp @@ -19,7 +19,7 @@ #include <limits> #include <set> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -30,6 +30,6 @@ bool debugIsASet(const std::vector<ArithVar>& variables){ return asSet.size() == variables.size(); } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/arithvar.h b/src/theory/arith/arithvar.h index dd5ea70d9..a49797845 100644 --- a/src/theory/arith/arithvar.h +++ b/src/theory/arith/arithvar.h @@ -26,7 +26,7 @@ #include "util/index.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -39,7 +39,6 @@ typedef std::vector< ArithRatPair > ArithRatPairVec; extern bool debugIsASet(const ArithVarVec& variables); - -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/arithvar_node_map.h b/src/theory/arith/arithvar_node_map.h index f01b0c7ac..dceeeb407 100644 --- a/src/theory/arith/arithvar_node_map.h +++ b/src/theory/arith/arithvar_node_map.h @@ -27,7 +27,7 @@ #include "context/cdhashmap.h" #include "context/cdo.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -88,8 +88,8 @@ public: };/* 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 */ diff --git a/src/theory/arith/attempt_solution_simplex.cpp b/src/theory/arith/attempt_solution_simplex.cpp index e5c995971..292fccb34 100644 --- a/src/theory/arith/attempt_solution_simplex.cpp +++ b/src/theory/arith/attempt_solution_simplex.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -151,6 +151,6 @@ Result::Sat AttemptSolutionSDP::attempt(const ApproximateSimplex::Solution& sol) } } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/attempt_solution_simplex.h b/src/theory/arith/attempt_solution_simplex.h index b7266a1e2..faca0cb25 100644 --- a/src/theory/arith/attempt_solution_simplex.h +++ b/src/theory/arith/attempt_solution_simplex.h @@ -58,7 +58,7 @@ #include "theory/arith/approx_simplex.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -90,6 +90,6 @@ public: } d_statistics; };/* class AttemptSolutionSDP */ -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/bound_counts.h b/src/theory/arith/bound_counts.h index cb9053669..949828aeb 100644 --- a/src/theory/arith/bound_counts.h +++ b/src/theory/arith/bound_counts.h @@ -22,7 +22,7 @@ #include "theory/arith/arithvar.h" #include "util/dense_map.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -229,6 +229,6 @@ public: virtual void operator()(ArithVar v, const BoundsInfo& up) = 0; }; -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/bound_inference.cpp b/src/theory/arith/bound_inference.cpp index d2adc94af..126954144 100644 --- a/src/theory/arith/bound_inference.cpp +++ b/src/theory/arith/bound_inference.cpp @@ -17,7 +17,7 @@ #include "theory/arith/normal_form.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -247,4 +247,4 @@ std::map<Node, std::pair<Node,Node>> getBounds(const std::vector<Node>& assertio } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/bound_inference.h b/src/theory/arith/bound_inference.h index dc32ff179..7041777d8 100644 --- a/src/theory/arith/bound_inference.h +++ b/src/theory/arith/bound_inference.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -113,6 +113,6 @@ std::map<Node, std::pair<Node,Node>> getBounds(const std::vector<Node>& assertio } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif
\ No newline at end of file diff --git a/src/theory/arith/callbacks.cpp b/src/theory/arith/callbacks.cpp index 81f48ad00..7fe8e4934 100644 --- a/src/theory/arith/callbacks.cpp +++ b/src/theory/arith/callbacks.cpp @@ -21,7 +21,7 @@ #include "theory/arith/proof_macros.h" #include "theory/arith/theory_arith_private.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -194,6 +194,6 @@ BoundCounts BoundCountingLookup::hasBounds(ArithVar basic) const { return boundsInfo(basic).hasBounds(); } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/callbacks.h b/src/theory/arith/callbacks.h index 9f0ae1017..66004871b 100644 --- a/src/theory/arith/callbacks.h +++ b/src/theory/arith/callbacks.h @@ -24,7 +24,7 @@ #include "theory/inference_id.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { class ProofNode; @@ -197,6 +197,6 @@ public: BoundCounts hasBounds(ArithVar basic) const; }; -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/congruence_manager.cpp b/src/theory/arith/congruence_manager.cpp index f2210574b..f2e51be02 100644 --- a/src/theory/arith/congruence_manager.cpp +++ b/src/theory/arith/congruence_manager.cpp @@ -30,7 +30,7 @@ #include "theory/uf/proof_equality_engine.h" #include "options/arith_options.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -689,6 +689,6 @@ std::vector<Node> andComponents(TNode an) return a; } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/congruence_manager.h b/src/theory/arith/congruence_manager.h index 9815ad9c8..540e985f7 100644 --- a/src/theory/arith/congruence_manager.h +++ b/src/theory/arith/congruence_manager.h @@ -32,7 +32,7 @@ #include "util/dense_map.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; @@ -297,6 +297,6 @@ private: std::vector<Node> andComponents(TNode an); -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/constraint.cpp b/src/theory/arith/constraint.cpp index f2de5da6c..cc1129f50 100644 --- a/src/theory/arith/constraint.cpp +++ b/src/theory/arith/constraint.cpp @@ -32,9 +32,9 @@ using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -2426,6 +2426,6 @@ std::pair<int, int> Constraint::unateFarkasSigns(ConstraintCP ca, ConstraintCP c return make_pair(a_sgn, b_sgn); } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/constraint.h b/src/theory/arith/constraint.h index 6ac03bb82..3caa5a030 100644 --- a/src/theory/arith/constraint.h +++ b/src/theory/arith/constraint.h @@ -93,7 +93,7 @@ #include "theory/trust_node.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; @@ -1275,9 +1275,8 @@ private: }; /* ConstraintDatabase */ - -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__CONSTRAINT_H */ diff --git a/src/theory/arith/constraint_forward.h b/src/theory/arith/constraint_forward.h index 9a42b8a97..8d36df304 100644 --- a/src/theory/arith/constraint_forward.h +++ b/src/theory/arith/constraint_forward.h @@ -24,7 +24,7 @@ #include "cvc4_private.h" #include <vector> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -44,8 +44,8 @@ typedef const RationalVector* RationalVectorCP; 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 */ diff --git a/src/theory/arith/cut_log.cpp b/src/theory/arith/cut_log.cpp index 426e10956..36c8d06f1 100644 --- a/src/theory/arith/cut_log.cpp +++ b/src/theory/arith/cut_log.cpp @@ -31,7 +31,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -702,6 +702,6 @@ void DenseVector::print(ostream& out, const DenseMap<Rational>& v){ out << "]"; } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/cut_log.h b/src/theory/arith/cut_log.h index 2b67026dc..961092f6e 100644 --- a/src/theory/arith/cut_log.h +++ b/src/theory/arith/cut_log.h @@ -28,7 +28,7 @@ #include "theory/arith/constraint_forward.h" #include "util/dense_map.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -288,8 +288,6 @@ public: void printBranchInfo(std::ostream& os) const; }; - - -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/delta_rational.cpp b/src/theory/arith/delta_rational.cpp index b7f641338..7d20a1859 100644 --- a/src/theory/arith/delta_rational.cpp +++ b/src/theory/arith/delta_rational.cpp @@ -21,7 +21,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& os, const DeltaRational& dq){ return os << "(" << dq.getNoninfinitesimalPart() @@ -106,4 +106,4 @@ Integer DeltaRational::euclidianDivideRemainder(const DeltaRational& y) const } } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/theory/arith/delta_rational.h b/src/theory/arith/delta_rational.h index ce0a2cffd..e2b769b18 100644 --- a/src/theory/arith/delta_rational.h +++ b/src/theory/arith/delta_rational.h @@ -26,7 +26,7 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { class DeltaRational; @@ -46,22 +46,20 @@ class DeltaRationalException : public Exception { */ 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(); @@ -99,14 +97,14 @@ public: } 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); } @@ -129,7 +127,7 @@ public: DeltaRational operator-(const DeltaRational& a) const{ - CVC4::Rational negOne(CVC4::Integer(-1)); + CVC5::Rational negOne(CVC5::Integer(-1)); return *(this) + (a * negOne); } @@ -138,14 +136,14 @@ public: } 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); } @@ -206,7 +204,8 @@ public: return *(this); } - DeltaRational& operator*=(const CVC4::Rational& a){ + DeltaRational& operator*=(const CVC5::Rational& a) + { c *= a; k *= a; @@ -300,4 +299,4 @@ public: std::ostream& operator<<(std::ostream& os, const DeltaRational& n); -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/theory/arith/dio_solver.cpp b/src/theory/arith/dio_solver.cpp index a232464e5..51dd69650 100644 --- a/src/theory/arith/dio_solver.cpp +++ b/src/theory/arith/dio_solver.cpp @@ -24,7 +24,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -833,6 +833,6 @@ Node DioSolver::trailIndexToEquality(TrailIndex i) const { return eq; } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/dio_solver.h b/src/theory/arith/dio_solver.h index dc4711800..7892bec52 100644 --- a/src/theory/arith/dio_solver.h +++ b/src/theory/arith/dio_solver.h @@ -33,7 +33,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace context { class Context; } @@ -421,8 +421,8 @@ public: 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 */ diff --git a/src/theory/arith/dual_simplex.cpp b/src/theory/arith/dual_simplex.cpp index 5ad2f16c0..d4e26600d 100644 --- a/src/theory/arith/dual_simplex.cpp +++ b/src/theory/arith/dual_simplex.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -273,6 +273,6 @@ bool DualSimplexDecisionProcedure::searchForFeasibleSolution(uint32_t remainingI return false; } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/dual_simplex.h b/src/theory/arith/dual_simplex.h index 174a91c75..3e1bc0ee7 100644 --- a/src/theory/arith/dual_simplex.h +++ b/src/theory/arith/dual_simplex.h @@ -57,7 +57,7 @@ #include "theory/arith/simplex.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -111,6 +111,6 @@ private: } d_statistics; };/* class DualSimplexDecisionProcedure */ -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/error_set.cpp b/src/theory/arith/error_set.cpp index 9c88ccfad..142a060ec 100644 --- a/src/theory/arith/error_set.cpp +++ b/src/theory/arith/error_set.cpp @@ -22,7 +22,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -477,6 +477,6 @@ void ErrorSet::pushFocusInto(ArithVarVec& vec) const{ } } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/error_set.h b/src/theory/arith/error_set.h index 7400a229f..cdf155c6d 100644 --- a/src/theory/arith/error_set.h +++ b/src/theory/arith/error_set.h @@ -31,7 +31,7 @@ #include "util/bin_heap.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -412,6 +412,6 @@ private: Statistics d_statistics; }; -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/fc_simplex.cpp b/src/theory/arith/fc_simplex.cpp index c85c3df2a..61280d651 100644 --- a/src/theory/arith/fc_simplex.cpp +++ b/src/theory/arith/fc_simplex.cpp @@ -25,7 +25,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -859,6 +859,6 @@ const Rational& FCSimplexDecisionProcedure::focusCoefficient(ArithVar nb) const } } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/fc_simplex.h b/src/theory/arith/fc_simplex.h index 45a9b79bb..73e5ae54f 100644 --- a/src/theory/arith/fc_simplex.h +++ b/src/theory/arith/fc_simplex.h @@ -61,7 +61,7 @@ #include "util/dense_map.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -254,6 +254,6 @@ private: } d_statistics; };/* class FCSimplexDecisionProcedure */ -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/infer_bounds.cpp b/src/theory/arith/infer_bounds.cpp index 0475e2472..25494bdee 100644 --- a/src/theory/arith/infer_bounds.cpp +++ b/src/theory/arith/infer_bounds.cpp @@ -18,7 +18,7 @@ #include "theory/arith/infer_bounds.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -264,4 +264,4 @@ std::ostream& operator<<(std::ostream& os, const Algorithms a){ } /* namespace arith */ } /* namespace theory */ -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/arith/infer_bounds.h b/src/theory/arith/infer_bounds.h index 03ab8e53b..251c7cbb8 100644 --- a/src/theory/arith/infer_bounds.h +++ b/src/theory/arith/infer_bounds.h @@ -27,8 +27,7 @@ #include "util/maybe.h" #include "util/rational.h" - -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -161,4 +160,4 @@ private: } /* namespace arith */ } /* namespace theory */ -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/arith/inference_manager.cpp b/src/theory/arith/inference_manager.cpp index a281c825b..66b628302 100644 --- a/src/theory/arith/inference_manager.cpp +++ b/src/theory/arith/inference_manager.cpp @@ -19,7 +19,7 @@ #include "theory/arith/theory_arith.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -147,4 +147,4 @@ bool InferenceManager::isEntailedFalse(const SimpleTheoryLemma& lem) } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/inference_manager.h b/src/theory/arith/inference_manager.h index dd617f4a3..bf5ed7b10 100644 --- a/src/theory/arith/inference_manager.h +++ b/src/theory/arith/inference_manager.h @@ -22,7 +22,7 @@ #include "theory/inference_id.h" #include "theory/inference_manager_buffered.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -117,6 +117,6 @@ class InferenceManager : public InferenceManagerBuffered } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/kinds b/src/theory/arith/kinds index 04bdc277e..b839ccc22 100644 --- a/src/theory/arith/kinds +++ b/src/theory/arith/kinds @@ -4,13 +4,13 @@ # 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)" @@ -44,10 +44,10 @@ operator ARCCOTANGENT 1 "arc cotangent" 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 \ @@ -63,16 +63,16 @@ sort INTEGER_TYPE \ "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" @@ -82,10 +82,10 @@ operator GEQ 2 "greater than or equal, 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)" @@ -99,15 +99,15 @@ operator TO_REAL 1 "cast term to real (parameter is an integer-sorted term; this # 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>" @@ -115,11 +115,11 @@ typerule GT "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>" @@ -128,7 +128,7 @@ typerule INTS_MODULUS "SimpleTypeRule<RInteger, AInteger, 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>" @@ -150,20 +150,20 @@ typerule SQRT "SimpleTypeRule<RReal, AReal>" 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 diff --git a/src/theory/arith/linear_equality.cpp b/src/theory/arith/linear_equality.cpp index 943f3216e..28f386e2a 100644 --- a/src/theory/arith/linear_equality.cpp +++ b/src/theory/arith/linear_equality.cpp @@ -22,7 +22,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -1411,6 +1411,6 @@ void LinearEqualityModule::directlyAddToCoefficient(ArithVar row, ArithVar col, d_tableau.directlyAddToCoefficient(row, col, mult, d_trackCallback); } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/linear_equality.h b/src/theory/arith/linear_equality.h index df4e5f30e..4a923b677 100644 --- a/src/theory/arith/linear_equality.h +++ b/src/theory/arith/linear_equality.h @@ -40,7 +40,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -756,6 +756,6 @@ public: } }; -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/matrix.cpp b/src/theory/arith/matrix.cpp index fb8c02379..dd7f28228 100644 --- a/src/theory/arith/matrix.cpp +++ b/src/theory/arith/matrix.cpp @@ -18,7 +18,7 @@ #include "theory/arith/matrix.h" using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -26,6 +26,6 @@ void NoEffectCCCB::update(RowIndex ridx, ArithVar nb, int oldSgn, int currSgn) { 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 diff --git a/src/theory/arith/matrix.h b/src/theory/arith/matrix.h index 09fdc2e91..553cef7d4 100644 --- a/src/theory/arith/matrix.h +++ b/src/theory/arith/matrix.h @@ -28,7 +28,7 @@ #include "util/dense_map.h" #include "util/index.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -368,8 +368,8 @@ public: 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; @@ -997,7 +997,6 @@ protected: };/* class Matrix<T> */ -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ - +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/nl/cad/cdcac.cpp b/src/theory/arith/nl/cad/cdcac.cpp index c4ecfbbfa..7fd22fb76 100644 --- a/src/theory/arith/nl/cad/cdcac.cpp +++ b/src/theory/arith/nl/cad/cdcac.cpp @@ -29,12 +29,12 @@ namespace std { 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 { @@ -545,6 +545,6 @@ void CDCAC::pruneRedundantIntervals(std::vector<CACInterval>& intervals) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/cad/cdcac.h b/src/theory/arith/nl/cad/cdcac.h index 15230d14c..2b607ae78 100644 --- a/src/theory/arith/nl/cad/cdcac.h +++ b/src/theory/arith/nl/cad/cdcac.h @@ -31,7 +31,7 @@ #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 { @@ -210,7 +210,7 @@ class CDCAC } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/cad/cdcac_utils.cpp b/src/theory/arith/nl/cad/cdcac_utils.cpp index 24bad8d60..f40d528ff 100644 --- a/src/theory/arith/nl/cad/cdcac_utils.cpp +++ b/src/theory/arith/nl/cad/cdcac_utils.cpp @@ -20,7 +20,7 @@ #include "theory/arith/nl/cad/projections.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -370,6 +370,6 @@ void makeFinestSquareFreeBasis(CACInterval& lhs, CACInterval& rhs) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/cad/cdcac_utils.h b/src/theory/arith/nl/cad/cdcac_utils.h index dad9bbd7a..3b3a3638b 100644 --- a/src/theory/arith/nl/cad/cdcac_utils.h +++ b/src/theory/arith/nl/cad/cdcac_utils.h @@ -28,7 +28,7 @@ #include "expr/node.h" #include "theory/arith/nl/cad/projections.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -105,7 +105,7 @@ void makeFinestSquareFreeBasis(CACInterval& lhs, CACInterval& rhs); } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/cad/constraints.cpp b/src/theory/arith/nl/cad/constraints.cpp index 028a61833..1ea172d11 100644 --- a/src/theory/arith/nl/cad/constraints.cpp +++ b/src/theory/arith/nl/cad/constraints.cpp @@ -23,7 +23,7 @@ #include "theory/arith/nl/poly_conversion.h" #include "util/poly_util.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -79,6 +79,6 @@ void Constraints::sortConstraints() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/cad/constraints.h b/src/theory/arith/nl/cad/constraints.h index 42f8920c8..70c52e85c 100644 --- a/src/theory/arith/nl/cad/constraints.h +++ b/src/theory/arith/nl/cad/constraints.h @@ -28,7 +28,7 @@ #include "theory/arith/nl/poly_conversion.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -87,7 +87,7 @@ class Constraints } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/cad/projections.cpp b/src/theory/arith/nl/cad/projections.cpp index 5d72f5a2e..b9e17f844 100644 --- a/src/theory/arith/nl/cad/projections.cpp +++ b/src/theory/arith/nl/cad/projections.cpp @@ -20,7 +20,7 @@ #include "base/check.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -106,6 +106,6 @@ PolyVector projection_mccallum(const std::vector<Polynomial>& polys) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/cad/projections.h b/src/theory/arith/nl/cad/projections.h index 33267cb7a..3b8eb412f 100644 --- a/src/theory/arith/nl/cad/projections.h +++ b/src/theory/arith/nl/cad/projections.h @@ -25,7 +25,7 @@ #include <vector> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -76,7 +76,7 @@ PolyVector projectionMcCallum(const std::vector<poly::Polynomial>& polys); } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/cad/proof_checker.cpp b/src/theory/arith/nl/cad/proof_checker.cpp index 45c43e2aa..f1ab2d6a9 100644 --- a/src/theory/arith/nl/cad/proof_checker.cpp +++ b/src/theory/arith/nl/cad/proof_checker.cpp @@ -17,9 +17,9 @@ #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 { @@ -58,4 +58,4 @@ Node CADProofRuleChecker::checkInternal(PfRule id, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/cad/proof_checker.h b/src/theory/arith/nl/cad/proof_checker.h index 5ebe0c6b7..26bbcc3a9 100644 --- a/src/theory/arith/nl/cad/proof_checker.h +++ b/src/theory/arith/nl/cad/proof_checker.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "expr/proof_checker.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -53,6 +53,6 @@ class CADProofRuleChecker : public ProofRuleChecker } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__PROOF_CHECKER_H */ diff --git a/src/theory/arith/nl/cad/proof_generator.cpp b/src/theory/arith/nl/cad/proof_generator.cpp index 9f0799e7c..fe3734dce 100644 --- a/src/theory/arith/nl/cad/proof_generator.cpp +++ b/src/theory/arith/nl/cad/proof_generator.cpp @@ -19,7 +19,7 @@ #include "theory/lazy_tree_proof_generator.h" #include "theory/arith/nl/poly_conversion.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -230,6 +230,6 @@ std::ostream& operator<<(std::ostream& os, const CADProofGenerator& proof) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/cad/proof_generator.h b/src/theory/arith/nl/cad/proof_generator.h index 4709b8e59..c1bb4be1e 100644 --- a/src/theory/arith/nl/cad/proof_generator.h +++ b/src/theory/arith/nl/cad/proof_generator.h @@ -28,7 +28,7 @@ #include "theory/arith/nl/cad/cdcac_utils.h" #include "theory/lazy_tree_proof_generator.h" -namespace CVC4 { +namespace CVC5 { class ProofGenerator; @@ -144,7 +144,7 @@ std::ostream& operator<<(std::ostream& os, const CADProofGenerator& proof); } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif #endif diff --git a/src/theory/arith/nl/cad/variable_ordering.cpp b/src/theory/arith/nl/cad/variable_ordering.cpp index 958191fe1..63db35553 100644 --- a/src/theory/arith/nl/cad/variable_ordering.cpp +++ b/src/theory/arith/nl/cad/variable_ordering.cpp @@ -20,7 +20,7 @@ #include "util/poly_util.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -132,6 +132,6 @@ std::vector<poly::Variable> VariableOrdering::operator()( } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/cad/variable_ordering.h b/src/theory/arith/nl/cad/variable_ordering.h index 43e85b3cb..7fda3faa4 100644 --- a/src/theory/arith/nl/cad/variable_ordering.h +++ b/src/theory/arith/nl/cad/variable_ordering.h @@ -26,7 +26,7 @@ #include "theory/arith/nl/cad/constraints.h" #include "util/poly_util.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -65,7 +65,7 @@ std::vector<poly_utils::VariableInformation> collectInformation( } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/cad_solver.cpp b/src/theory/arith/nl/cad_solver.cpp index c72c9d48d..dc18fbdf5 100644 --- a/src/theory/arith/nl/cad_solver.cpp +++ b/src/theory/arith/nl/cad_solver.cpp @@ -20,7 +20,7 @@ #include "theory/arith/nl/nl_model.h" #include "theory/arith/nl/poly_conversion.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -212,4 +212,4 @@ bool CadSolver::constructModelIfAvailable(std::vector<Node>& assertions) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/cad_solver.h b/src/theory/arith/nl/cad_solver.h index b83398cd6..de97c48cc 100644 --- a/src/theory/arith/nl/cad_solver.h +++ b/src/theory/arith/nl/cad_solver.h @@ -22,7 +22,7 @@ #include "theory/arith/nl/cad/cdcac.h" #include "theory/arith/nl/cad/proof_checker.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; @@ -110,6 +110,6 @@ class CadSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__CAD_SOLVER_H */ diff --git a/src/theory/arith/nl/ext/constraint.cpp b/src/theory/arith/nl/ext/constraint.cpp index 9ec3b1fc1..41331d041 100644 --- a/src/theory/arith/nl/ext/constraint.cpp +++ b/src/theory/arith/nl/ext/constraint.cpp @@ -18,9 +18,9 @@ #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 { @@ -123,4 +123,4 @@ bool ConstraintDb::isMaximal(Node atom, Node x) const } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/ext/constraint.h b/src/theory/arith/nl/ext/constraint.h index d5ed7ccfd..9e6451c99 100644 --- a/src/theory/arith/nl/ext/constraint.h +++ b/src/theory/arith/nl/ext/constraint.h @@ -21,7 +21,7 @@ #include "expr/kind.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -84,6 +84,6 @@ class ConstraintDb } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__NL_SOLVER_H */ diff --git a/src/theory/arith/nl/ext/ext_state.cpp b/src/theory/arith/nl/ext/ext_state.cpp index 28373223b..fc806199e 100644 --- a/src/theory/arith/nl/ext/ext_state.cpp +++ b/src/theory/arith/nl/ext/ext_state.cpp @@ -23,8 +23,7 @@ #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 { @@ -110,4 +109,4 @@ CDProof* ExtState::getProof() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/ext/ext_state.h b/src/theory/arith/nl/ext/ext_state.h index 46ccaeb14..1d8e7ea0a 100644 --- a/src/theory/arith/nl/ext/ext_state.h +++ b/src/theory/arith/nl/ext/ext_state.h @@ -21,7 +21,7 @@ #include "expr/proof_set.h" #include "theory/arith/nl/ext/monomial.h" -namespace CVC4 { +namespace CVC5 { class CDProof; @@ -91,6 +91,6 @@ struct ExtState } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/ext/factoring_check.cpp b/src/theory/arith/nl/ext/factoring_check.cpp index 7a0da42aa..675368843 100644 --- a/src/theory/arith/nl/ext/factoring_check.cpp +++ b/src/theory/arith/nl/ext/factoring_check.cpp @@ -23,7 +23,7 @@ #include "theory/arith/nl/ext/ext_state.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -207,4 +207,4 @@ Node FactoringCheck::getFactorSkolem(Node n, CDProof* proof) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/ext/factoring_check.h b/src/theory/arith/nl/ext/factoring_check.h index 4c017d198..89c5fce30 100644 --- a/src/theory/arith/nl/ext/factoring_check.h +++ b/src/theory/arith/nl/ext/factoring_check.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class CDProof; @@ -69,6 +69,6 @@ class FactoringCheck } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/ext/monomial.cpp b/src/theory/arith/nl/ext/monomial.cpp index a0d388dca..86abed70c 100644 --- a/src/theory/arith/nl/ext/monomial.cpp +++ b/src/theory/arith/nl/ext/monomial.cpp @@ -18,9 +18,9 @@ #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 { @@ -333,4 +333,4 @@ Node MonomialDb::mkMonomialRemFactor(Node n, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/ext/monomial.h b/src/theory/arith/nl/ext/monomial.h index 19f855233..98083b996 100644 --- a/src/theory/arith/nl/ext/monomial.h +++ b/src/theory/arith/nl/ext/monomial.h @@ -20,7 +20,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -144,6 +144,6 @@ class MonomialDb } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__NL_MONOMIAL_H */ diff --git a/src/theory/arith/nl/ext/monomial_bounds_check.cpp b/src/theory/arith/nl/ext/monomial_bounds_check.cpp index f1a2f45b9..c8194bbd0 100644 --- a/src/theory/arith/nl/ext/monomial_bounds_check.cpp +++ b/src/theory/arith/nl/ext/monomial_bounds_check.cpp @@ -24,7 +24,7 @@ #include "theory/arith/nl/nl_model.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -520,4 +520,4 @@ void MonomialBoundsCheck::checkResBounds() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/ext/monomial_bounds_check.h b/src/theory/arith/nl/ext/monomial_bounds_check.h index e7ba4d861..e63dd454a 100644 --- a/src/theory/arith/nl/ext/monomial_bounds_check.h +++ b/src/theory/arith/nl/ext/monomial_bounds_check.h @@ -18,7 +18,7 @@ #include "expr/node.h" #include "theory/arith/nl/ext/constraint.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -86,6 +86,6 @@ class MonomialBoundsCheck } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/ext/monomial_check.cpp b/src/theory/arith/nl/ext/monomial_check.cpp index 7f99b876d..9fc2ba10a 100644 --- a/src/theory/arith/nl/ext/monomial_check.cpp +++ b/src/theory/arith/nl/ext/monomial_check.cpp @@ -22,7 +22,7 @@ #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 { @@ -757,4 +757,4 @@ void MonomialCheck::setMonomialFactor(Node a, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/ext/monomial_check.h b/src/theory/arith/nl/ext/monomial_check.h index a08554476..948368542 100644 --- a/src/theory/arith/nl/ext/monomial_check.h +++ b/src/theory/arith/nl/ext/monomial_check.h @@ -19,7 +19,7 @@ #include "theory/arith/nl/ext/monomial.h" #include "theory/theory_inference.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -194,6 +194,6 @@ class MonomialCheck } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/ext/proof_checker.cpp b/src/theory/arith/nl/ext/proof_checker.cpp index ca600ad55..26db3c9e0 100644 --- a/src/theory/arith/nl/ext/proof_checker.cpp +++ b/src/theory/arith/nl/ext/proof_checker.cpp @@ -18,9 +18,9 @@ #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 { @@ -158,4 +158,4 @@ Node ExtProofRuleChecker::checkInternal(PfRule id, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/ext/proof_checker.h b/src/theory/arith/nl/ext/proof_checker.h index d53b674b2..7bd4b7e38 100644 --- a/src/theory/arith/nl/ext/proof_checker.h +++ b/src/theory/arith/nl/ext/proof_checker.h @@ -21,7 +21,7 @@ #include "expr/proof_checker.h" #include "expr/proof_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -51,6 +51,6 @@ class ExtProofRuleChecker : public ProofRuleChecker } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__PROOF_CHECKER_H */ diff --git a/src/theory/arith/nl/ext/split_zero_check.cpp b/src/theory/arith/nl/ext/split_zero_check.cpp index 45f4160a0..543b6a0bd 100644 --- a/src/theory/arith/nl/ext/split_zero_check.cpp +++ b/src/theory/arith/nl/ext/split_zero_check.cpp @@ -22,7 +22,7 @@ #include "theory/arith/nl/ext/ext_state.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -57,4 +57,4 @@ void SplitZeroCheck::check() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/ext/split_zero_check.h b/src/theory/arith/nl/ext/split_zero_check.h index 030445737..316e304ff 100644 --- a/src/theory/arith/nl/ext/split_zero_check.h +++ b/src/theory/arith/nl/ext/split_zero_check.h @@ -18,7 +18,7 @@ #include "expr/node.h" #include "context/cdhashset.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -50,6 +50,6 @@ class SplitZeroCheck } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/ext/tangent_plane_check.cpp b/src/theory/arith/nl/ext/tangent_plane_check.cpp index 64ea19f3c..bdeca7a29 100644 --- a/src/theory/arith/nl/ext/tangent_plane_check.cpp +++ b/src/theory/arith/nl/ext/tangent_plane_check.cpp @@ -22,7 +22,7 @@ #include "theory/arith/nl/ext/ext_state.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -164,4 +164,4 @@ void TangentPlaneCheck::check(bool asWaitingLemmas) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/ext/tangent_plane_check.h b/src/theory/arith/nl/ext/tangent_plane_check.h index a771ae543..7d48d249b 100644 --- a/src/theory/arith/nl/ext/tangent_plane_check.h +++ b/src/theory/arith/nl/ext/tangent_plane_check.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -67,6 +67,6 @@ class TangentPlaneCheck } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/ext_theory_callback.cpp b/src/theory/arith/nl/ext_theory_callback.cpp index 214d2a51a..125fbb05a 100644 --- a/src/theory/arith/nl/ext_theory_callback.cpp +++ b/src/theory/arith/nl/ext_theory_callback.cpp @@ -17,9 +17,9 @@ #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 { @@ -129,4 +129,4 @@ bool NlExtTheoryCallback::isExtfReduced(int effort, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/ext_theory_callback.h b/src/theory/arith/nl/ext_theory_callback.h index a3dc74ec8..c747eef69 100644 --- a/src/theory/arith/nl/ext_theory_callback.h +++ b/src/theory/arith/nl/ext_theory_callback.h @@ -18,7 +18,7 @@ #include "expr/node.h" #include "theory/ext_theory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { class EqualityEngine; @@ -84,6 +84,6 @@ class NlExtTheoryCallback : public ExtTheoryCallback } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__NL__EXT_THEORY_CALLBACK_H */ diff --git a/src/theory/arith/nl/iand_solver.cpp b/src/theory/arith/nl/iand_solver.cpp index 7272bb6e3..01f4c6e15 100644 --- a/src/theory/arith/nl/iand_solver.cpp +++ b/src/theory/arith/nl/iand_solver.cpp @@ -25,9 +25,9 @@ #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 { @@ -298,4 +298,4 @@ Node IAndSolver::bitwiseLemma(Node i) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/iand_solver.h b/src/theory/arith/nl/iand_solver.h index 137d430c0..95d9632aa 100644 --- a/src/theory/arith/nl/iand_solver.h +++ b/src/theory/arith/nl/iand_solver.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "theory/arith/nl/iand_utils.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -132,6 +132,6 @@ class IAndSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__IAND_SOLVER_H */ diff --git a/src/theory/arith/nl/iand_utils.cpp b/src/theory/arith/nl/iand_utils.cpp index cb3a03aed..cd96021b0 100644 --- a/src/theory/arith/nl/iand_utils.cpp +++ b/src/theory/arith/nl/iand_utils.cpp @@ -21,7 +21,7 @@ #include "theory/arith/nl/nl_model.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -276,4 +276,4 @@ Node IAndUtils::twoToKMinusOne(unsigned k) const } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/iand_utils.h b/src/theory/arith/nl/iand_utils.h index a84fcf978..da5f8f04f 100644 --- a/src/theory/arith/nl/iand_utils.h +++ b/src/theory/arith/nl/iand_utils.h @@ -20,7 +20,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -169,6 +169,6 @@ class IAndUtils } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__IAND_TABLE_H */ diff --git a/src/theory/arith/nl/icp/candidate.cpp b/src/theory/arith/nl/icp/candidate.cpp index df894ee12..87d823018 100644 --- a/src/theory/arith/nl/icp/candidate.cpp +++ b/src/theory/arith/nl/icp/candidate.cpp @@ -23,7 +23,7 @@ #include "theory/arith/nl/icp/intersection.h" #include "theory/arith/nl/poly_conversion.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -115,6 +115,6 @@ std::ostream& operator<<(std::ostream& os, const Candidate& c) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/icp/candidate.h b/src/theory/arith/nl/icp/candidate.h index 5d8c2b2d0..d4ad11fcf 100644 --- a/src/theory/arith/nl/icp/candidate.h +++ b/src/theory/arith/nl/icp/candidate.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "theory/arith/nl/icp/intersection.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -78,7 +78,7 @@ std::ostream& operator<<(std::ostream& os, const Candidate& c); } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/icp/contraction_origins.cpp b/src/theory/arith/nl/icp/contraction_origins.cpp index a076dbdb0..c0b0cb768 100644 --- a/src/theory/arith/nl/icp/contraction_origins.cpp +++ b/src/theory/arith/nl/icp/contraction_origins.cpp @@ -14,7 +14,7 @@ #include "theory/arith/nl/icp/contraction_origins.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -117,4 +117,4 @@ inline std::ostream& operator<<(std::ostream& os, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/icp/contraction_origins.h b/src/theory/arith/nl/icp/contraction_origins.h index bef6b2848..0f22b5463 100644 --- a/src/theory/arith/nl/icp/contraction_origins.h +++ b/src/theory/arith/nl/icp/contraction_origins.h @@ -20,7 +20,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -99,6 +99,6 @@ std::ostream& operator<<(std::ostream& os, const ContractionOriginManager& com); } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/icp/icp_solver.cpp b/src/theory/arith/nl/icp/icp_solver.cpp index 5b505b070..e09264a25 100644 --- a/src/theory/arith/nl/icp/icp_solver.cpp +++ b/src/theory/arith/nl/icp/icp_solver.cpp @@ -26,7 +26,7 @@ #include "theory/rewriter.h" #include "util/poly_util.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -384,4 +384,4 @@ void ICPSolver::check() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/icp/icp_solver.h b/src/theory/arith/nl/icp/icp_solver.h index 85b2e86c6..56ec03706 100644 --- a/src/theory/arith/nl/icp/icp_solver.h +++ b/src/theory/arith/nl/icp/icp_solver.h @@ -28,7 +28,7 @@ #include "theory/arith/nl/icp/intersection.h" #include "theory/arith/nl/poly_conversion.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -153,6 +153,6 @@ class ICPSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/icp/intersection.cpp b/src/theory/arith/nl/icp/intersection.cpp index 3dc0ca815..6cdba297c 100644 --- a/src/theory/arith/nl/icp/intersection.cpp +++ b/src/theory/arith/nl/icp/intersection.cpp @@ -24,7 +24,7 @@ #include "base/output.h" #include "theory/arith/nl/poly_conversion.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -221,6 +221,6 @@ PropagationResult intersect_interval_with(poly::Interval& cur, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/icp/intersection.h b/src/theory/arith/nl/icp/intersection.h index 1670a8f68..c453f8314 100644 --- a/src/theory/arith/nl/icp/intersection.h +++ b/src/theory/arith/nl/icp/intersection.h @@ -25,7 +25,7 @@ namespace poly { class Interval; } -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -77,7 +77,7 @@ PropagationResult intersect_interval_with(poly::Interval& cur, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/icp/interval.h b/src/theory/arith/nl/icp/interval.h index ff4bbfcac..8acbfec05 100644 --- a/src/theory/arith/nl/icp/interval.h +++ b/src/theory/arith/nl/icp/interval.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -58,7 +58,7 @@ inline std::ostream& operator<<(std::ostream& os, const Interval& i) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/nl_lemma_utils.cpp b/src/theory/arith/nl/nl_lemma_utils.cpp index d7785dbc9..f3c2d70c8 100644 --- a/src/theory/arith/nl/nl_lemma_utils.cpp +++ b/src/theory/arith/nl/nl_lemma_utils.cpp @@ -17,7 +17,7 @@ #include "theory/arith/nl/nl_model.h" #include "theory/arith/nl/nonlinear_extension.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -78,4 +78,4 @@ Node ArgTrie::add(Node d, const std::vector<Node>& args) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/nl_lemma_utils.h b/src/theory/arith/nl/nl_lemma_utils.h index 6f3ef077a..71d86b08a 100644 --- a/src/theory/arith/nl/nl_lemma_utils.h +++ b/src/theory/arith/nl/nl_lemma_utils.h @@ -21,7 +21,7 @@ #include "expr/node.h" #include "theory/theory_inference.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -144,6 +144,6 @@ class ArgTrie } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__NL_LEMMA_UTILS_H */ diff --git a/src/theory/arith/nl/nl_model.cpp b/src/theory/arith/nl/nl_model.cpp index 5467c64ce..f7edefff7 100644 --- a/src/theory/arith/nl/nl_model.cpp +++ b/src/theory/arith/nl/nl_model.cpp @@ -24,9 +24,9 @@ #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 { @@ -1342,4 +1342,4 @@ void NlModel::getModelValueRepair( } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/nl_model.h b/src/theory/arith/nl/nl_model.h index cd52cb159..b2c435098 100644 --- a/src/theory/arith/nl/nl_model.h +++ b/src/theory/arith/nl/nl_model.h @@ -22,7 +22,7 @@ #include "expr/kind.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace context { class Context; @@ -329,6 +329,6 @@ class NlModel } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__NONLINEAR_EXTENSION_H */ diff --git a/src/theory/arith/nl/nonlinear_extension.cpp b/src/theory/arith/nl/nonlinear_extension.cpp index 781fb0c71..ff1962629 100644 --- a/src/theory/arith/nl/nonlinear_extension.cpp +++ b/src/theory/arith/nl/nonlinear_extension.cpp @@ -27,9 +27,9 @@ #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 { @@ -621,4 +621,4 @@ void NonlinearExtension::runStrategy(Theory::Effort effort, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/nonlinear_extension.h b/src/theory/arith/nl/nonlinear_extension.h index bc8f48c26..b6fb53651 100644 --- a/src/theory/arith/nl/nonlinear_extension.h +++ b/src/theory/arith/nl/nonlinear_extension.h @@ -41,7 +41,7 @@ #include "theory/theory.h" #include "util/result.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { class EqualityEngine; @@ -296,6 +296,6 @@ class NonlinearExtension } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__NONLINEAR_EXTENSION_H */ diff --git a/src/theory/arith/nl/poly_conversion.cpp b/src/theory/arith/nl/poly_conversion.cpp index 0dd7cc070..5738dccfc 100644 --- a/src/theory/arith/nl/poly_conversion.cpp +++ b/src/theory/arith/nl/poly_conversion.cpp @@ -23,12 +23,12 @@ #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()) @@ -54,7 +54,7 @@ poly::Variable VariableMapper::operator()(const CVC4::Node& n) 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()) @@ -62,7 +62,7 @@ CVC4::Node VariableMapper::operator()(const poly::Variable& n) 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; @@ -87,9 +87,9 @@ CVC4::Node as_cvc_upolynomial(const poly::UPolynomial& p, const CVC4::Node& var) 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()) @@ -140,14 +140,14 @@ poly::UPolynomial as_poly_upolynomial_impl(const CVC4::Node& n, 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) { @@ -195,12 +195,12 @@ poly::Polynomial as_poly_polynomial_impl(const CVC4::Node& n, } 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) { @@ -257,7 +257,7 @@ void collect_monomials(const lp_polynomial_context_t* ctx, } } // 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 @@ -274,7 +274,7 @@ CVC4::Node as_cvc_polynomial(const poly::Polynomial& p, VariableMapper& vm) 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) { @@ -803,6 +803,6 @@ poly::IntervalAssignment getBounds(VariableMapper& vm, const BoundInference& bi) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/poly_conversion.h b/src/theory/arith/nl/poly_conversion.h index 47a66d5f1..9adc9a996 100644 --- a/src/theory/arith/nl/poly_conversion.h +++ b/src/theory/arith/nl/poly_conversion.h @@ -30,7 +30,7 @@ #include "expr/node.h" #include "util/real_algebraic_number.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -42,23 +42,23 @@ namespace nl { 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. @@ -73,8 +73,8 @@ poly::UPolynomial as_poly_upolynomial(const CVC4::Node& n, * 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); @@ -87,7 +87,7 @@ poly::Polynomial as_poly_polynomial(const CVC4::Node& n, * 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 @@ -164,7 +164,7 @@ poly::IntervalAssignment getBounds(VariableMapper& vm, const BoundInference& bi) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arith/nl/stats.cpp b/src/theory/arith/nl/stats.cpp index c707dd9bc..92cebc8fc 100644 --- a/src/theory/arith/nl/stats.cpp +++ b/src/theory/arith/nl/stats.cpp @@ -16,7 +16,7 @@ #include "smt/smt_statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -38,4 +38,4 @@ NlStats::~NlStats() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/stats.h b/src/theory/arith/nl/stats.h index 94e1882b3..66157d0a3 100644 --- a/src/theory/arith/nl/stats.h +++ b/src/theory/arith/nl/stats.h @@ -19,7 +19,7 @@ #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -44,6 +44,6 @@ class NlStats } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__NL__STATS_H */ diff --git a/src/theory/arith/nl/strategy.cpp b/src/theory/arith/nl/strategy.cpp index 5d6eeea9e..af23f67f9 100644 --- a/src/theory/arith/nl/strategy.cpp +++ b/src/theory/arith/nl/strategy.cpp @@ -19,7 +19,7 @@ #include "base/check.h" #include "options/arith_options.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -173,4 +173,4 @@ StepGenerator Strategy::getStrategy() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/strategy.h b/src/theory/arith/nl/strategy.h index 3540f9ad1..9caf6322b 100644 --- a/src/theory/arith/nl/strategy.h +++ b/src/theory/arith/nl/strategy.h @@ -18,7 +18,7 @@ #include <iosfwd> #include <vector> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -173,6 +173,6 @@ class Strategy } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__NL__STRATEGY_H */ diff --git a/src/theory/arith/nl/transcendental/exponential_solver.cpp b/src/theory/arith/nl/transcendental/exponential_solver.cpp index 8b6f4484d..05849a579 100644 --- a/src/theory/arith/nl/transcendental/exponential_solver.cpp +++ b/src/theory/arith/nl/transcendental/exponential_solver.cpp @@ -28,7 +28,7 @@ #include "theory/arith/nl/transcendental/transcendental_state.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -276,4 +276,4 @@ std::pair<Node, Node> ExponentialSolver::getSecantBounds(TNode e, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/transcendental/exponential_solver.h b/src/theory/arith/nl/transcendental/exponential_solver.h index 484174d5f..8bd00c456 100644 --- a/src/theory/arith/nl/transcendental/exponential_solver.h +++ b/src/theory/arith/nl/transcendental/exponential_solver.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -108,6 +108,6 @@ class ExponentialSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */ diff --git a/src/theory/arith/nl/transcendental/proof_checker.cpp b/src/theory/arith/nl/transcendental/proof_checker.cpp index 223db8355..fe071c36a 100644 --- a/src/theory/arith/nl/transcendental/proof_checker.cpp +++ b/src/theory/arith/nl/transcendental/proof_checker.cpp @@ -19,9 +19,9 @@ #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 { @@ -402,4 +402,4 @@ Node TranscendentalProofRuleChecker::checkInternal( } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/transcendental/proof_checker.h b/src/theory/arith/nl/transcendental/proof_checker.h index b00c1811c..2a6837590 100644 --- a/src/theory/arith/nl/transcendental/proof_checker.h +++ b/src/theory/arith/nl/transcendental/proof_checker.h @@ -21,7 +21,7 @@ #include "expr/proof_checker.h" #include "expr/proof_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -53,6 +53,6 @@ class TranscendentalProofRuleChecker : public ProofRuleChecker } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__PROOF_CHECKER_H */ diff --git a/src/theory/arith/nl/transcendental/sine_solver.cpp b/src/theory/arith/nl/transcendental/sine_solver.cpp index 528e0bea2..052b6c056 100644 --- a/src/theory/arith/nl/transcendental/sine_solver.cpp +++ b/src/theory/arith/nl/transcendental/sine_solver.cpp @@ -28,7 +28,7 @@ #include "theory/arith/nl/transcendental/transcendental_state.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -484,4 +484,4 @@ std::pair<Node, Node> SineSolver::getSecantBounds(TNode e, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/transcendental/sine_solver.h b/src/theory/arith/nl/transcendental/sine_solver.h index c628559fc..c20c50f6d 100644 --- a/src/theory/arith/nl/transcendental/sine_solver.h +++ b/src/theory/arith/nl/transcendental/sine_solver.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "theory/arith/nl/transcendental/transcendental_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -175,6 +175,6 @@ class SineSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */ diff --git a/src/theory/arith/nl/transcendental/taylor_generator.cpp b/src/theory/arith/nl/transcendental/taylor_generator.cpp index ced202308..f2817344a 100644 --- a/src/theory/arith/nl/transcendental/taylor_generator.cpp +++ b/src/theory/arith/nl/transcendental/taylor_generator.cpp @@ -18,7 +18,7 @@ #include "theory/arith/nl/nl_model.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -243,4 +243,4 @@ std::pair<Node, Node> TaylorGenerator::getTfModelBounds(Node tf, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/transcendental/taylor_generator.h b/src/theory/arith/nl/transcendental/taylor_generator.h index 7cb03cd7c..b13be57f0 100644 --- a/src/theory/arith/nl/transcendental/taylor_generator.h +++ b/src/theory/arith/nl/transcendental/taylor_generator.h @@ -17,7 +17,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -118,6 +118,6 @@ class TaylorGenerator } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */ diff --git a/src/theory/arith/nl/transcendental/transcendental_solver.cpp b/src/theory/arith/nl/transcendental/transcendental_solver.cpp index f236b472a..bedfe4d3b 100644 --- a/src/theory/arith/nl/transcendental/transcendental_solver.cpp +++ b/src/theory/arith/nl/transcendental/transcendental_solver.cpp @@ -27,9 +27,9 @@ #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 { @@ -438,4 +438,4 @@ int TranscendentalSolver::regionToConcavity(Kind k, int region) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/transcendental/transcendental_solver.h b/src/theory/arith/nl/transcendental/transcendental_solver.h index 290e74322..e22bf3e64 100644 --- a/src/theory/arith/nl/transcendental/transcendental_solver.h +++ b/src/theory/arith/nl/transcendental/transcendental_solver.h @@ -22,7 +22,7 @@ #include "theory/arith/nl/transcendental/sine_solver.h" #include "theory/arith/nl/transcendental/transcendental_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -200,6 +200,6 @@ class TranscendentalSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */ diff --git a/src/theory/arith/nl/transcendental/transcendental_state.cpp b/src/theory/arith/nl/transcendental/transcendental_state.cpp index 593354794..6ab136d39 100644 --- a/src/theory/arith/nl/transcendental/transcendental_state.cpp +++ b/src/theory/arith/nl/transcendental/transcendental_state.cpp @@ -21,7 +21,7 @@ #include "theory/arith/nl/transcendental/taylor_generator.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -437,4 +437,4 @@ void TranscendentalState::doSecantLemmas(const std::pair<Node, Node>& bounds, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/nl/transcendental/transcendental_state.h b/src/theory/arith/nl/transcendental/transcendental_state.h index cd5466e89..21a60e038 100644 --- a/src/theory/arith/nl/transcendental/transcendental_state.h +++ b/src/theory/arith/nl/transcendental/transcendental_state.h @@ -21,7 +21,7 @@ #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 { @@ -278,6 +278,6 @@ struct TranscendentalState } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__NL__TRANSCENDENTAL__TRANSCENDENTAL_STATE_H */ diff --git a/src/theory/arith/normal_form.cpp b/src/theory/arith/normal_form.cpp index 537a39a77..d1ef6486e 100644 --- a/src/theory/arith/normal_form.cpp +++ b/src/theory/arith/normal_form.cpp @@ -24,7 +24,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -1412,4 +1412,4 @@ bool Polynomial::isNonlinear() const { } //namespace arith } //namespace theory -} //namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/normal_form.h b/src/theory/arith/normal_form.h index c3500e699..c4d0e2268 100644 --- a/src/theory/arith/normal_form.h +++ b/src/theory/arith/normal_form.h @@ -28,8 +28,7 @@ #include "theory/arith/delta_rational.h" #include "util/rational.h" - -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -1403,8 +1402,8 @@ public: };/* class Comparison */ -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__NORMAL_FORM_H */ diff --git a/src/theory/arith/operator_elim.cpp b/src/theory/arith/operator_elim.cpp index ee15e0f11..15e09eaa5 100644 --- a/src/theory/arith/operator_elim.cpp +++ b/src/theory/arith/operator_elim.cpp @@ -26,9 +26,9 @@ #include "theory/rewriter.h" #include "theory/theory.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -499,4 +499,4 @@ Node OperatorElim::mkWitnessTerm(Node v, } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/operator_elim.h b/src/theory/arith/operator_elim.h index 489974eac..fa09ad26b 100644 --- a/src/theory/arith/operator_elim.h +++ b/src/theory/arith/operator_elim.h @@ -21,7 +21,7 @@ #include "theory/logic_info.h" #include "theory/skolem_lemma.h" -namespace CVC4 { +namespace CVC5 { class TConvProofGenerator; @@ -142,4 +142,4 @@ class OperatorElim : public EagerProofGenerator } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/partial_model.cpp b/src/theory/arith/partial_model.cpp index 32c61e815..6e4fa6bed 100644 --- a/src/theory/arith/partial_model.cpp +++ b/src/theory/arith/partial_model.cpp @@ -22,7 +22,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -684,6 +684,6 @@ void ArithVariables::UpperBoundCleanUp::operator()(AVCPair* p){ d_pm->popUpperBound(p); } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/partial_model.h b/src/theory/arith/partial_model.h index af0fe37ec..b7a1a0efe 100644 --- a/src/theory/arith/partial_model.h +++ b/src/theory/arith/partial_model.h @@ -32,7 +32,7 @@ #include "theory/arith/constraint_forward.h" #include "theory/arith/delta_rational.h" -namespace CVC4 { +namespace CVC5 { namespace context { class Context; } @@ -412,9 +412,8 @@ private: };/* class ArithVariables */ - -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__PARTIAL_MODEL_H */ diff --git a/src/theory/arith/proof_checker.cpp b/src/theory/arith/proof_checker.cpp index c595791ab..09ef5bf34 100644 --- a/src/theory/arith/proof_checker.cpp +++ b/src/theory/arith/proof_checker.cpp @@ -23,7 +23,7 @@ #include "theory/arith/normal_form.h" #include "theory/arith/operator_elim.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -360,4 +360,4 @@ Node ArithProofRuleChecker::checkInternal(PfRule id, } } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/proof_checker.h b/src/theory/arith/proof_checker.h index 0745bdd61..5b9a50387 100644 --- a/src/theory/arith/proof_checker.h +++ b/src/theory/arith/proof_checker.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "expr/proof_checker.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -43,6 +43,6 @@ class ArithProofRuleChecker : public ProofRuleChecker } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__PROOF_CHECKER_H */ diff --git a/src/theory/arith/proof_macros.h b/src/theory/arith/proof_macros.h index d453285d6..169e4e2db 100644 --- a/src/theory/arith/proof_macros.h +++ b/src/theory/arith/proof_macros.h @@ -20,12 +20,12 @@ #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 diff --git a/src/theory/arith/rewrites.cpp b/src/theory/arith/rewrites.cpp index f2eef7013..9522ef4f4 100644 --- a/src/theory/arith/rewrites.cpp +++ b/src/theory/arith/rewrites.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -47,4 +47,4 @@ std::ostream& operator<<(std::ostream& out, Rewrite r) } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arith/rewrites.h b/src/theory/arith/rewrites.h index 6b5e8fc9f..250eacb09 100644 --- a/src/theory/arith/rewrites.h +++ b/src/theory/arith/rewrites.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -77,6 +77,6 @@ std::ostream& operator<<(std::ostream& out, Rewrite r); } // namespace arith } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARITH__REWRITES_H */ diff --git a/src/theory/arith/simplex.cpp b/src/theory/arith/simplex.cpp index 49267034c..fe6fad4d7 100644 --- a/src/theory/arith/simplex.cpp +++ b/src/theory/arith/simplex.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -278,6 +278,6 @@ SimplexDecisionProcedure::sgn_table::const_iterator SimplexDecisionProcedure::fi 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 diff --git a/src/theory/arith/simplex.h b/src/theory/arith/simplex.h index 5edfc1608..a1ee18adf 100644 --- a/src/theory/arith/simplex.h +++ b/src/theory/arith/simplex.h @@ -64,7 +64,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -219,6 +219,6 @@ protected: };/* class SimplexDecisionProcedure */ -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/simplex_update.cpp b/src/theory/arith/simplex_update.cpp index 98bf07ccf..ea868a886 100644 --- a/src/theory/arith/simplex_update.cpp +++ b/src/theory/arith/simplex_update.cpp @@ -19,7 +19,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -186,6 +186,6 @@ std::ostream& operator<<(std::ostream& out, WitnessImprovement w){ return out; } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/simplex_update.h b/src/theory/arith/simplex_update.h index f8a6bf957..833e92dd4 100644 --- a/src/theory/arith/simplex_update.h +++ b/src/theory/arith/simplex_update.h @@ -33,7 +33,7 @@ #include "theory/arith/constraint_forward.h" #include "util/maybe.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -352,6 +352,6 @@ private: std::ostream& operator<<(std::ostream& out, const UpdateInfo& up); -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/soi_simplex.cpp b/src/theory/arith/soi_simplex.cpp index eef0ede43..0efc33d02 100644 --- a/src/theory/arith/soi_simplex.cpp +++ b/src/theory/arith/soi_simplex.cpp @@ -28,7 +28,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -1022,6 +1022,6 @@ Result::Sat SumOfInfeasibilitiesSPD::sumOfInfeasibilities(){ } } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/soi_simplex.h b/src/theory/arith/soi_simplex.h index d9d11dcc5..16af7292d 100644 --- a/src/theory/arith/soi_simplex.h +++ b/src/theory/arith/soi_simplex.h @@ -60,7 +60,7 @@ #include "util/dense_map.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -240,6 +240,6 @@ private: } d_statistics; };/* class FCSimplexDecisionProcedure */ -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/tableau.cpp b/src/theory/arith/tableau.cpp index 1d57a40dd..c39b3aae7 100644 --- a/src/theory/arith/tableau.cpp +++ b/src/theory/arith/tableau.cpp @@ -19,7 +19,7 @@ #include "theory/arith/tableau.h" using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -190,6 +190,6 @@ void Tableau::printBasicRow(ArithVar basic, std::ostream& out){ printRow(basicToRowIndex(basic), out); } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/tableau.h b/src/theory/arith/tableau.h index 9ee33d7b6..0834c7f35 100644 --- a/src/theory/arith/tableau.h +++ b/src/theory/arith/tableau.h @@ -26,7 +26,7 @@ #include "util/dense_map.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -157,8 +157,6 @@ private: };/* class Tableau */ - - -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/tableau_sizes.cpp b/src/theory/arith/tableau_sizes.cpp index 4b699a019..a167cf1a8 100644 --- a/src/theory/arith/tableau_sizes.cpp +++ b/src/theory/arith/tableau_sizes.cpp @@ -19,7 +19,7 @@ #include "theory/arith/tableau_sizes.h" #include "theory/arith/tableau.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -31,6 +31,6 @@ uint32_t TableauSizes::getColumnLength(ArithVar x) const { return d_tab->getColLength(x); } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/tableau_sizes.h b/src/theory/arith/tableau_sizes.h index 16e58bb2e..3bbb5c818 100644 --- a/src/theory/arith/tableau_sizes.h +++ b/src/theory/arith/tableau_sizes.h @@ -21,7 +21,7 @@ #include "theory/arith/arithvar.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -37,7 +37,6 @@ public: uint32_t getColumnLength(ArithVar x) const; }; /* TableauSizes */ -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ - +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/theory_arith.cpp b/src/theory/arith/theory_arith.cpp index a179336af..12603ea7d 100644 --- a/src/theory/arith/theory_arith.cpp +++ b/src/theory/arith/theory_arith.cpp @@ -29,9 +29,9 @@ #include "theory/theory_model.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -311,6 +311,6 @@ eq::ProofEqEngine* TheoryArith::getProofEqEngine() return d_im.getProofEqEngine(); } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/theory_arith.h b/src/theory/arith/theory_arith.h index e0fa1b2d0..e430f6da6 100644 --- a/src/theory/arith/theory_arith.h +++ b/src/theory/arith/theory_arith.h @@ -24,7 +24,7 @@ #include "theory/arith/inference_manager.h" #include "theory/theory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { namespace nl { @@ -163,6 +163,6 @@ class TheoryArith : public Theory { };/* class TheoryArith */ -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/theory_arith_private.cpp b/src/theory/arith/theory_arith_private.cpp index b85aeb135..1e9e8ca3f 100644 --- a/src/theory/arith/theory_arith_private.cpp +++ b/src/theory/arith/theory_arith_private.cpp @@ -74,9 +74,9 @@ #include "util/statistics_registry.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -5712,6 +5712,6 @@ std::pair<Node, DeltaRational> TheoryArithPrivate::entailmentCheckSimplex(int sg // return result; // } -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/theory_arith_private.h b/src/theory/arith/theory_arith_private.h index 4b2fcf8a8..e0b7cea56 100644 --- a/src/theory/arith/theory_arith_private.h +++ b/src/theory/arith/theory_arith_private.h @@ -54,7 +54,7 @@ #include "util/result.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class EagerProofGenerator; @@ -884,6 +884,6 @@ private: Statistics d_statistics; };/* class TheoryArithPrivate */ -}/* CVC4::theory::arith namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arith +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arith/theory_arith_type_rules.h b/src/theory/arith/theory_arith_type_rules.h index fbf31e6e2..dc8885e55 100644 --- a/src/theory/arith/theory_arith_type_rules.h +++ b/src/theory/arith/theory_arith_type_rules.h @@ -19,7 +19,7 @@ #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 { @@ -157,8 +157,8 @@ class IndexedRootPredicateTypeRule } }; /* 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 */ diff --git a/src/theory/arith/type_enumerator.h b/src/theory/arith/type_enumerator.h index a9e35cdc3..a32073ad9 100644 --- a/src/theory/arith/type_enumerator.h +++ b/src/theory/arith/type_enumerator.h @@ -25,7 +25,7 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arith { @@ -100,8 +100,8 @@ class IntegerEnumerator : public TypeEnumeratorBase<IntegerEnumerator> { 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 */ diff --git a/src/theory/arrays/array_info.cpp b/src/theory/arrays/array_info.cpp index 7919892c6..64e1d81c8 100644 --- a/src/theory/arrays/array_info.cpp +++ b/src/theory/arrays/array_info.cpp @@ -19,7 +19,7 @@ #include "smt/smt_statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -517,7 +517,6 @@ void ArrayInfo::mergeInfo(const TNode a, const TNode b){ } - -}/* CVC4::theory::arrays namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arrays +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arrays/array_info.h b/src/theory/arrays/array_info.h index 174980474..405a40ead 100644 --- a/src/theory/arrays/array_info.h +++ b/src/theory/arrays/array_info.h @@ -27,7 +27,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -205,8 +205,8 @@ public: 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 */ diff --git a/src/theory/arrays/inference_manager.cpp b/src/theory/arrays/inference_manager.cpp index 02ef6bb70..f53fe8cc3 100644 --- a/src/theory/arrays/inference_manager.cpp +++ b/src/theory/arrays/inference_manager.cpp @@ -19,9 +19,9 @@ #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 { @@ -129,4 +129,4 @@ void InferenceManager::convert(PfRule& id, } // namespace arrays } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arrays/inference_manager.h b/src/theory/arrays/inference_manager.h index 0bff656d7..60336dd63 100644 --- a/src/theory/arrays/inference_manager.h +++ b/src/theory/arrays/inference_manager.h @@ -22,7 +22,7 @@ #include "theory/eager_proof_generator.h" #include "theory/theory_inference_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -71,6 +71,6 @@ class InferenceManager : public TheoryInferenceManager } // namespace arrays } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arrays/kinds b/src/theory/arrays/kinds index 629064d99..d8d4b2bae 100644 --- a/src/theory/arrays/kinds +++ b/src/theory/arrays/kinds @@ -4,25 +4,25 @@ # 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] @@ -36,10 +36,10 @@ operator EQ_RANGE 4 "equality of two arrays over an index range lower/upper" # 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)" @@ -51,19 +51,19 @@ 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 diff --git a/src/theory/arrays/proof_checker.cpp b/src/theory/arrays/proof_checker.cpp index e67ec3011..72e444d63 100644 --- a/src/theory/arrays/proof_checker.cpp +++ b/src/theory/arrays/proof_checker.cpp @@ -17,7 +17,7 @@ #include "theory/arrays/skolem_cache.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -115,4 +115,4 @@ Node ArraysProofRuleChecker::checkInternal(PfRule id, } // namespace arrays } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arrays/proof_checker.h b/src/theory/arrays/proof_checker.h index 053502788..64d5d785f 100644 --- a/src/theory/arrays/proof_checker.h +++ b/src/theory/arrays/proof_checker.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "expr/proof_checker.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -43,6 +43,6 @@ class ArraysProofRuleChecker : public ProofRuleChecker } // namespace arrays } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ARRAYS__PROOF_CHECKER_H */ diff --git a/src/theory/arrays/skolem_cache.cpp b/src/theory/arrays/skolem_cache.cpp index 2c755658a..a1f2fddc4 100644 --- a/src/theory/arrays/skolem_cache.cpp +++ b/src/theory/arrays/skolem_cache.cpp @@ -19,9 +19,9 @@ #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 { @@ -78,4 +78,4 @@ Node SkolemCache::getExtIndexVar(Node deq) } // namespace arrays } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/arrays/skolem_cache.h b/src/theory/arrays/skolem_cache.h index 7b0facd97..a95dc9a4f 100644 --- a/src/theory/arrays/skolem_cache.h +++ b/src/theory/arrays/skolem_cache.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -52,6 +52,6 @@ class SkolemCache } // namespace arrays } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/arrays/theory_arrays.cpp b/src/theory/arrays/theory_arrays.cpp index 15ccd400d..665ad8da0 100644 --- a/src/theory/arrays/theory_arrays.cpp +++ b/src/theory/arrays/theory_arrays.cpp @@ -36,7 +36,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -2269,6 +2269,6 @@ void TheoryArrays::computeRelevantTerms(std::set<Node>& termSet) } while (changed); } -}/* CVC4::theory::arrays namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arrays +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arrays/theory_arrays.h b/src/theory/arrays/theory_arrays.h index 6a723d680..a7db2db7a 100644 --- a/src/theory/arrays/theory_arrays.h +++ b/src/theory/arrays/theory_arrays.h @@ -35,7 +35,7 @@ #include "theory/uf/equality_engine.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -488,8 +488,8 @@ class TheoryArrays : public Theory { 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 */ diff --git a/src/theory/arrays/theory_arrays_rewriter.cpp b/src/theory/arrays/theory_arrays_rewriter.cpp index 5bb916968..e91844a9c 100644 --- a/src/theory/arrays/theory_arrays_rewriter.cpp +++ b/src/theory/arrays/theory_arrays_rewriter.cpp @@ -18,14 +18,14 @@ #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; @@ -44,6 +44,6 @@ void setMostFrequentValueCount(TNode store, uint64_t count) { return store.setAttribute(ArrayConstantMostFrequentValueCountAttr(), count); } -}/* CVC4::theory::arrays namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arrays +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arrays/theory_arrays_rewriter.h b/src/theory/arrays/theory_arrays_rewriter.h index 72cbdd475..114913ee7 100644 --- a/src/theory/arrays/theory_arrays_rewriter.h +++ b/src/theory/arrays/theory_arrays_rewriter.h @@ -27,7 +27,7 @@ #include "theory/theory_rewriter.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -501,8 +501,8 @@ class TheoryArraysRewriter : public TheoryRewriter }; /* 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 */ diff --git a/src/theory/arrays/theory_arrays_type_rules.h b/src/theory/arrays/theory_arrays_type_rules.h index 310d8495a..fc3340251 100644 --- a/src/theory/arrays/theory_arrays_type_rules.h +++ b/src/theory/arrays/theory_arrays_type_rules.h @@ -22,7 +22,7 @@ #include "theory/arrays/theory_arrays_rewriter.h" // for array-constant attributes #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -274,8 +274,8 @@ struct ArrayEqRangeTypeRule } }; /* 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 */ diff --git a/src/theory/arrays/type_enumerator.h b/src/theory/arrays/type_enumerator.h index f81a9b54d..4f5b981b2 100644 --- a/src/theory/arrays/type_enumerator.h +++ b/src/theory/arrays/type_enumerator.h @@ -24,7 +24,7 @@ #include "expr/kind.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -155,8 +155,8 @@ class ArrayEnumerator : public TypeEnumeratorBase<ArrayEnumerator> { };/* class ArrayEnumerator */ -}/* CVC4::theory::arrays namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arrays +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__ARRAYS__TYPE_ENUMERATOR_H */ diff --git a/src/theory/arrays/union_find.cpp b/src/theory/arrays/union_find.cpp index eeb870775..e178e9dbb 100644 --- a/src/theory/arrays/union_find.cpp +++ b/src/theory/arrays/union_find.cpp @@ -23,7 +23,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace arrays { @@ -51,6 +51,6 @@ template void UnionFind<Node, NodeHashFunction>::notify(); template void UnionFind<TNode, TNodeHashFunction>::notify(); -}/* CVC4::theory::arrays namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arrays +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/arrays/union_find.h b/src/theory/arrays/union_find.h index e6886ec11..ebe31baad 100644 --- a/src/theory/arrays/union_find.h +++ b/src/theory/arrays/union_find.h @@ -28,11 +28,11 @@ #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 { @@ -135,8 +135,8 @@ inline void UnionFind<NodeType, NodeHash>::setCanon(TNode n, TNode newParent) { } } -}/* CVC4::theory::arrays namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace arrays +} // namespace theory +} // namespace CVC5 #endif /*CVC4__THEORY__ARRAYS__UNION_FIND_H */ diff --git a/src/theory/assertion.cpp b/src/theory/assertion.cpp index c0ba30c5b..b21025314 100644 --- a/src/theory/assertion.cpp +++ b/src/theory/assertion.cpp @@ -16,12 +16,12 @@ #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 diff --git a/src/theory/assertion.h b/src/theory/assertion.h index 90fb0cfac..10f300d69 100644 --- a/src/theory/assertion.h +++ b/src/theory/assertion.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** Information about an assertion for the theories. */ @@ -47,7 +47,7 @@ struct Assertion { std::ostream& operator<<(std::ostream& out, const Assertion& a); -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__ASSERTION_H */ diff --git a/src/theory/atom_requests.cpp b/src/theory/atom_requests.cpp index 0bcd07dbd..c3305417f 100644 --- a/src/theory/atom_requests.cpp +++ b/src/theory/atom_requests.cpp @@ -17,7 +17,7 @@ #include "theory/atom_requests.h" -using namespace CVC4; +using namespace CVC5; AtomRequests::AtomRequests(context::Context* context) : d_allRequests(context) diff --git a/src/theory/atom_requests.h b/src/theory/atom_requests.h index b8a653bc3..906fec303 100644 --- a/src/theory/atom_requests.h +++ b/src/theory/atom_requests.h @@ -25,7 +25,7 @@ #include "context/cdhashset.h" #include "context/cdhashmap.h" -namespace CVC4 { +namespace CVC5 { class AtomRequests { @@ -114,8 +114,4 @@ private: }; -} - - - - +} // namespace CVC5 diff --git a/src/theory/bags/bag_solver.cpp b/src/theory/bags/bag_solver.cpp index a7a0f8796..fd80a03f7 100644 --- a/src/theory/bags/bag_solver.cpp +++ b/src/theory/bags/bag_solver.cpp @@ -24,10 +24,10 @@ #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 { @@ -212,4 +212,4 @@ void BagSolver::checkDisequalBagTerms() } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/bag_solver.h b/src/theory/bags/bag_solver.h index 914a12ae2..9d0e597dd 100644 --- a/src/theory/bags/bag_solver.h +++ b/src/theory/bags/bag_solver.h @@ -19,7 +19,7 @@ #include "theory/bags/inference_generator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -90,6 +90,6 @@ class BagSolver } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAG__SOLVER_H */ diff --git a/src/theory/bags/bags_rewriter.cpp b/src/theory/bags/bags_rewriter.cpp index 54b279e66..ccee08aab 100644 --- a/src/theory/bags/bags_rewriter.cpp +++ b/src/theory/bags/bags_rewriter.cpp @@ -16,9 +16,9 @@ #include "theory/bags/normal_form.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -503,4 +503,4 @@ BagsRewriteResponse BagsRewriter::postRewriteEqual(const TNode& n) const } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/bags_rewriter.h b/src/theory/bags/bags_rewriter.h index 6c440c512..4552ed9da 100644 --- a/src/theory/bags/bags_rewriter.h +++ b/src/theory/bags/bags_rewriter.h @@ -22,7 +22,7 @@ #include "util/statistics_registry.h" #include "util/stats_histogram.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -223,6 +223,6 @@ class BagsRewriter : public TheoryRewriter } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS__THEORY_BAGS_REWRITER_H */ diff --git a/src/theory/bags/bags_statistics.cpp b/src/theory/bags/bags_statistics.cpp index 8ec686d87..369831c70 100644 --- a/src/theory/bags/bags_statistics.cpp +++ b/src/theory/bags/bags_statistics.cpp @@ -16,7 +16,7 @@ #include "smt/smt_statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -32,4 +32,4 @@ BagsStatistics::~BagsStatistics() } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/bags_statistics.h b/src/theory/bags/bags_statistics.h index c8f7ed420..e0a1c4133 100644 --- a/src/theory/bags/bags_statistics.h +++ b/src/theory/bags/bags_statistics.h @@ -21,7 +21,7 @@ #include "util/statistics_registry.h" #include "util/stats_histogram.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -40,6 +40,6 @@ class BagsStatistics } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS_STATISTICS_H */ diff --git a/src/theory/bags/infer_info.cpp b/src/theory/bags/infer_info.cpp index d7638c89c..444597eb5 100644 --- a/src/theory/bags/infer_info.cpp +++ b/src/theory/bags/infer_info.cpp @@ -16,7 +16,7 @@ #include "theory/bags/inference_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -79,4 +79,4 @@ std::ostream& operator<<(std::ostream& out, const InferInfo& ii) } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/infer_info.h b/src/theory/bags/infer_info.h index c76f74c0c..18765bbe7 100644 --- a/src/theory/bags/infer_info.h +++ b/src/theory/bags/infer_info.h @@ -24,7 +24,7 @@ #include "theory/inference_id.h" #include "theory/theory_inference.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class TheoryInferenceManager; @@ -85,6 +85,6 @@ std::ostream& operator<<(std::ostream& out, const InferInfo& ii); } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS__INFER_INFO_H */ diff --git a/src/theory/bags/inference_generator.cpp b/src/theory/bags/inference_generator.cpp index 0d56080c4..2f6a36b9c 100644 --- a/src/theory/bags/inference_generator.cpp +++ b/src/theory/bags/inference_generator.cpp @@ -21,7 +21,7 @@ #include "theory/bags/solver_state.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -270,4 +270,4 @@ Node InferenceGenerator::getMultiplicityTerm(Node element, Node bag) } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/inference_generator.h b/src/theory/bags/inference_generator.h index bfaf5d0fc..4f0b498c2 100644 --- a/src/theory/bags/inference_generator.h +++ b/src/theory/bags/inference_generator.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "infer_info.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -188,6 +188,6 @@ class InferenceGenerator } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS__INFERENCE_GENERATOR_H */ diff --git a/src/theory/bags/inference_manager.cpp b/src/theory/bags/inference_manager.cpp index dcc5387e9..3fa425f7a 100644 --- a/src/theory/bags/inference_manager.cpp +++ b/src/theory/bags/inference_manager.cpp @@ -17,9 +17,9 @@ #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 { @@ -48,4 +48,4 @@ void InferenceManager::doPending() } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/inference_manager.h b/src/theory/bags/inference_manager.h index d74d3c189..34f6621aa 100644 --- a/src/theory/bags/inference_manager.h +++ b/src/theory/bags/inference_manager.h @@ -19,7 +19,7 @@ #include "theory/inference_manager_buffered.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -63,6 +63,6 @@ class InferenceManager : public InferenceManagerBuffered } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS__INFERENCE_MANAGER_H */ diff --git a/src/theory/bags/kinds b/src/theory/bags/kinds index f84b811e7..cd53484eb 100644 --- a/src/theory/bags/kinds +++ b/src/theory/bags/kinds @@ -5,10 +5,10 @@ # 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 @@ -16,22 +16,22 @@ properties check propagate presolve # 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 @@ -50,10 +50,10 @@ operator BAG_COUNT 2 "multiplicity of an element in a bag" 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" @@ -70,24 +70,24 @@ operator BAG_TO_SET 1 "converts a bag to a set" # 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 diff --git a/src/theory/bags/make_bag_op.cpp b/src/theory/bags/make_bag_op.cpp index 92cf49203..15e3a30c7 100644 --- a/src/theory/bags/make_bag_op.cpp +++ b/src/theory/bags/make_bag_op.cpp @@ -18,7 +18,7 @@ #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& out, const MakeBagOp& op) { @@ -46,4 +46,4 @@ bool MakeBagOp::operator==(const MakeBagOp& op) const return getType() == op.getType(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/make_bag_op.h b/src/theory/bags/make_bag_op.h index e8610e7db..4c2a3e933 100644 --- a/src/theory/bags/make_bag_op.h +++ b/src/theory/bags/make_bag_op.h @@ -19,7 +19,7 @@ #include <memory> -namespace CVC4 { +namespace CVC5 { class TypeNode; @@ -57,6 +57,6 @@ struct MakeBagOpHashFunction size_t operator()(const MakeBagOp& op) const; }; /* struct MakeBagOpHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__MAKE_BAG_OP_H */ diff --git a/src/theory/bags/normal_form.cpp b/src/theory/bags/normal_form.cpp index ad723d293..5952b66d8 100644 --- a/src/theory/bags/normal_form.cpp +++ b/src/theory/bags/normal_form.cpp @@ -16,9 +16,9 @@ #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 { @@ -674,4 +674,4 @@ Node NormalForm::evaluateToSet(TNode n) } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/normal_form.h b/src/theory/bags/normal_form.h index a779d3321..1c7f05d8e 100644 --- a/src/theory/bags/normal_form.h +++ b/src/theory/bags/normal_form.h @@ -19,7 +19,7 @@ #ifndef CVC4__THEORY__BAGS__NORMAL_FORM_H #define CVC4__THEORY__BAGS__NORMAL_FORM_H -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -192,6 +192,6 @@ class NormalForm }; } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS__NORMAL_FORM_H */ diff --git a/src/theory/bags/rewrites.cpp b/src/theory/bags/rewrites.cpp index ab2ca2901..d0299d52a 100644 --- a/src/theory/bags/rewrites.cpp +++ b/src/theory/bags/rewrites.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -79,4 +79,4 @@ std::ostream& operator<<(std::ostream& out, Rewrite r) } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/rewrites.h b/src/theory/bags/rewrites.h index 5d0b8a087..9e7bb54fa 100644 --- a/src/theory/bags/rewrites.h +++ b/src/theory/bags/rewrites.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -92,6 +92,6 @@ std::ostream& operator<<(std::ostream& out, Rewrite r); } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS__REWRITES_H */ diff --git a/src/theory/bags/solver_state.cpp b/src/theory/bags/solver_state.cpp index 4fead8ab7..4011a3fc4 100644 --- a/src/theory/bags/solver_state.cpp +++ b/src/theory/bags/solver_state.cpp @@ -20,9 +20,9 @@ #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 { @@ -136,4 +136,4 @@ void SolverState::collectDisequalBagTerms() } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/solver_state.h b/src/theory/bags/solver_state.h index d8820d8c4..e6b2a2504 100644 --- a/src/theory/bags/solver_state.h +++ b/src/theory/bags/solver_state.h @@ -21,7 +21,7 @@ #include "theory/theory_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -90,6 +90,6 @@ class SolverState : public TheoryState } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS__THEORY_SOLVER_STATE_H */ diff --git a/src/theory/bags/term_registry.cpp b/src/theory/bags/term_registry.cpp index 192fd6809..072655834 100644 --- a/src/theory/bags/term_registry.cpp +++ b/src/theory/bags/term_registry.cpp @@ -18,9 +18,9 @@ #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 { @@ -45,4 +45,4 @@ Node TermRegistry::getEmptyBag(TypeNode tn) } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/term_registry.h b/src/theory/bags/term_registry.h index 87e61a026..adf97fd5f 100644 --- a/src/theory/bags/term_registry.h +++ b/src/theory/bags/term_registry.h @@ -22,7 +22,7 @@ #include "context/cdhashmap.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -59,6 +59,6 @@ class TermRegistry } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS__TERM_REGISTRY_H */ diff --git a/src/theory/bags/theory_bags.cpp b/src/theory/bags/theory_bags.cpp index 2950739e4..f91fd40f0 100644 --- a/src/theory/bags/theory_bags.cpp +++ b/src/theory/bags/theory_bags.cpp @@ -19,9 +19,9 @@ #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 { @@ -262,4 +262,4 @@ void TheoryBags::NotifyClass::eqNotifyDisequal(TNode n1, TNode n2, TNode reason) } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/theory_bags.h b/src/theory/bags/theory_bags.h index df64c3f1c..6bd9ddc65 100644 --- a/src/theory/bags/theory_bags.h +++ b/src/theory/bags/theory_bags.h @@ -27,7 +27,7 @@ #include "theory/theory.h" #include "theory/theory_eq_notify.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -114,6 +114,6 @@ class TheoryBags : public Theory } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS__THEORY_BAGS_H */ diff --git a/src/theory/bags/theory_bags_type_enumerator.cpp b/src/theory/bags/theory_bags_type_enumerator.cpp index d9284b862..02494727c 100644 --- a/src/theory/bags/theory_bags_type_enumerator.cpp +++ b/src/theory/bags/theory_bags_type_enumerator.cpp @@ -18,7 +18,7 @@ #include "theory/rewriter.h" #include "theory_bags_type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -83,4 +83,4 @@ bool BagEnumerator::isFinished() } // namespace bags } // namespace theory -} // namespace CVC4
\ No newline at end of file +} // namespace CVC5
\ No newline at end of file diff --git a/src/theory/bags/theory_bags_type_enumerator.h b/src/theory/bags/theory_bags_type_enumerator.h index aa59a72e6..c13946388 100644 --- a/src/theory/bags/theory_bags_type_enumerator.h +++ b/src/theory/bags/theory_bags_type_enumerator.h @@ -20,7 +20,7 @@ #include "expr/type_node.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -86,6 +86,6 @@ class BagEnumerator : public TypeEnumeratorBase<BagEnumerator> } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS__TYPE_ENUMERATOR_H */
\ No newline at end of file diff --git a/src/theory/bags/theory_bags_type_rules.cpp b/src/theory/bags/theory_bags_type_rules.cpp index 5a97155fc..2acbb1e27 100644 --- a/src/theory/bags/theory_bags_type_rules.cpp +++ b/src/theory/bags/theory_bags_type_rules.cpp @@ -19,7 +19,7 @@ #include "base/check.h" #include "theory/bags/normal_form.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bags { @@ -279,4 +279,4 @@ TypeNode ToSetTypeRule::computeType(NodeManager* nodeManager, } } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bags/theory_bags_type_rules.h b/src/theory/bags/theory_bags_type_rules.h index 41e1164c2..dd93186ad 100644 --- a/src/theory/bags/theory_bags_type_rules.h +++ b/src/theory/bags/theory_bags_type_rules.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { class NodeManager; @@ -102,6 +102,6 @@ struct BagsProperties } // namespace bags } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BAGS__THEORY_BAGS_TYPE_RULES_H */ diff --git a/src/theory/booleans/circuit_propagator.cpp b/src/theory/booleans/circuit_propagator.cpp index b50ec34c7..897c86e93 100644 --- a/src/theory/booleans/circuit_propagator.cpp +++ b/src/theory/booleans/circuit_propagator.cpp @@ -31,7 +31,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace booleans { @@ -814,4 +814,4 @@ void CircuitPropagator::addProof(TNode f, std::shared_ptr<ProofNode> pf) } // namespace booleans } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/booleans/circuit_propagator.h b/src/theory/booleans/circuit_propagator.h index ba8c5782d..6caccef08 100644 --- a/src/theory/booleans/circuit_propagator.h +++ b/src/theory/booleans/circuit_propagator.h @@ -31,7 +31,7 @@ #include "expr/node.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { class ProofGenerator; class ProofNode; @@ -274,6 +274,6 @@ class CircuitPropagator } // namespace booleans } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BOOLEANS__CIRCUIT_PROPAGATOR_H */ diff --git a/src/theory/booleans/kinds b/src/theory/booleans/kinds index 9d7b3fbd6..d8009ad12 100644 --- a/src/theory/booleans/kinds +++ b/src/theory/booleans/kinds @@ -4,12 +4,12 @@ # 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 \ @@ -20,12 +20,12 @@ sort BOOLEAN_TYPE \ 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" @@ -35,13 +35,13 @@ operator OR 2: "logical or (N-ary)" 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 diff --git a/src/theory/booleans/proof_checker.cpp b/src/theory/booleans/proof_checker.cpp index 6244ff3f4..a51f238a2 100644 --- a/src/theory/booleans/proof_checker.cpp +++ b/src/theory/booleans/proof_checker.cpp @@ -16,7 +16,7 @@ #include "expr/skolem_manager.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace booleans { @@ -948,4 +948,4 @@ Node BoolProofRuleChecker::checkInternal(PfRule id, } // namespace booleans } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/booleans/proof_checker.h b/src/theory/booleans/proof_checker.h index 1d807fd90..93c3baf1e 100644 --- a/src/theory/booleans/proof_checker.h +++ b/src/theory/booleans/proof_checker.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "expr/proof_checker.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace booleans { @@ -43,6 +43,6 @@ class BoolProofRuleChecker : public ProofRuleChecker } // namespace booleans } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BOOLEANS__PROOF_CHECKER_H */ diff --git a/src/theory/booleans/proof_circuit_propagator.cpp b/src/theory/booleans/proof_circuit_propagator.cpp index aaff82933..b84cf5488 100644 --- a/src/theory/booleans/proof_circuit_propagator.cpp +++ b/src/theory/booleans/proof_circuit_propagator.cpp @@ -21,7 +21,7 @@ #include "expr/proof_node.h" #include "expr/proof_node_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace booleans { @@ -587,4 +587,4 @@ std::shared_ptr<ProofNode> ProofCircuitPropagatorForward::xorEval(bool x, } // namespace booleans } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/booleans/proof_circuit_propagator.h b/src/theory/booleans/proof_circuit_propagator.h index fa472b602..671c6e964 100644 --- a/src/theory/booleans/proof_circuit_propagator.h +++ b/src/theory/booleans/proof_circuit_propagator.h @@ -24,7 +24,7 @@ #include "expr/node.h" #include "expr/proof_rule.h" -namespace CVC4 { +namespace CVC5 { class ProofNode; class ProofNodeManager; @@ -212,6 +212,6 @@ class ProofCircuitPropagatorForward : public ProofCircuitPropagator } // namespace booleans } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/booleans/theory_bool.cpp b/src/theory/booleans/theory_bool.cpp index bdd428245..2df179e27 100644 --- a/src/theory/booleans/theory_bool.cpp +++ b/src/theory/booleans/theory_bool.cpp @@ -31,7 +31,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace booleans { @@ -80,6 +80,6 @@ Theory::PPAssertStatus TheoryBool::ppAssert( return Theory::ppAssert(tin, outSubstitutions); } -}/* CVC4::theory::booleans namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace booleans +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/booleans/theory_bool.h b/src/theory/booleans/theory_bool.h index 12c9fa72f..cbd9ec381 100644 --- a/src/theory/booleans/theory_bool.h +++ b/src/theory/booleans/theory_bool.h @@ -24,7 +24,7 @@ #include "theory/booleans/theory_bool_rewriter.h" #include "theory/theory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace booleans { @@ -51,8 +51,8 @@ class TheoryBool : public Theory { 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 */ diff --git a/src/theory/booleans/theory_bool_rewriter.cpp b/src/theory/booleans/theory_bool_rewriter.cpp index 4c15b2d8f..3cc19a520 100644 --- a/src/theory/booleans/theory_bool_rewriter.cpp +++ b/src/theory/booleans/theory_bool_rewriter.cpp @@ -21,7 +21,7 @@ #include "expr/node_value.h" #include "theory/booleans/theory_bool_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace booleans { @@ -429,6 +429,6 @@ RewriteResponse TheoryBoolRewriter::preRewrite(TNode n) { return RewriteResponse(REWRITE_DONE, n); } -}/* CVC4::theory::booleans namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace booleans +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/booleans/theory_bool_rewriter.h b/src/theory/booleans/theory_bool_rewriter.h index 7af1abc0c..4caf5c681 100644 --- a/src/theory/booleans/theory_bool_rewriter.h +++ b/src/theory/booleans/theory_bool_rewriter.h @@ -22,7 +22,7 @@ #include "theory/theory_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace booleans { @@ -34,8 +34,8 @@ class TheoryBoolRewriter : public TheoryRewriter }; /* 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 */ diff --git a/src/theory/booleans/theory_bool_type_rules.h b/src/theory/booleans/theory_bool_type_rules.h index afb5ef92e..2f59a032e 100644 --- a/src/theory/booleans/theory_bool_type_rules.h +++ b/src/theory/booleans/theory_bool_type_rules.h @@ -19,7 +19,7 @@ #ifndef CVC4__THEORY_BOOL_TYPE_RULES_H #define CVC4__THEORY_BOOL_TYPE_RULES_H -namespace CVC4 { +namespace CVC5 { namespace theory { namespace boolean { @@ -70,8 +70,8 @@ public: } };/* class IteTypeRule */ -}/* CVC4::theory::boolean namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace boolean +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY_BOOL_TYPE_RULES_H */ diff --git a/src/theory/booleans/type_enumerator.h b/src/theory/booleans/type_enumerator.h index b2aeecae0..9b6619961 100644 --- a/src/theory/booleans/type_enumerator.h +++ b/src/theory/booleans/type_enumerator.h @@ -23,7 +23,7 @@ #include "expr/type_node.h" #include "expr/kind.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace booleans { @@ -63,8 +63,8 @@ class BooleanEnumerator : public TypeEnumeratorBase<BooleanEnumerator> { 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 */ diff --git a/src/theory/builtin/kinds b/src/theory/builtin/kinds index cf68e060c..48ceaf103 100644 --- a/src/theory/builtin/kinds +++ b/src/theory/builtin/kinds @@ -196,7 +196,7 @@ # 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] @@ -240,13 +240,13 @@ # 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 \ @@ -259,33 +259,33 @@ parameterized SORT_TYPE SORT_TAG 0: "specifies types of user-declared 'uninterpr # 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" @@ -301,33 +301,33 @@ operator LAMBDA 2 "a lambda expression; first parameter is a BOUND_VAR_LIST, sec 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 diff --git a/src/theory/builtin/proof_checker.cpp b/src/theory/builtin/proof_checker.cpp index 3e0eca128..62f0f1b9a 100644 --- a/src/theory/builtin/proof_checker.cpp +++ b/src/theory/builtin/proof_checker.cpp @@ -20,9 +20,9 @@ #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) @@ -497,4 +497,4 @@ Node BuiltinProofRuleChecker::mkTheoryIdNode(TheoryId tid) } // namespace builtin } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/builtin/proof_checker.h b/src/theory/builtin/proof_checker.h index 77cb2593a..ed68f1215 100644 --- a/src/theory/builtin/proof_checker.h +++ b/src/theory/builtin/proof_checker.h @@ -22,7 +22,7 @@ #include "expr/proof_node.h" #include "theory/quantifiers/extended_rewrite.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -179,6 +179,6 @@ class BuiltinProofRuleChecker : public ProofRuleChecker } // namespace builtin } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BUILTIN__PROOF_CHECKER_H */ diff --git a/src/theory/builtin/theory_builtin.cpp b/src/theory/builtin/theory_builtin.cpp index 13162960c..83e9d3fed 100644 --- a/src/theory/builtin/theory_builtin.cpp +++ b/src/theory/builtin/theory_builtin.cpp @@ -24,7 +24,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace builtin { @@ -62,4 +62,4 @@ void TheoryBuiltin::finishInit() } // namespace builtin } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/builtin/theory_builtin.h b/src/theory/builtin/theory_builtin.h index 94a00b7e3..449282ae6 100644 --- a/src/theory/builtin/theory_builtin.h +++ b/src/theory/builtin/theory_builtin.h @@ -23,7 +23,7 @@ #include "theory/builtin/theory_builtin_rewriter.h" #include "theory/theory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace builtin { @@ -53,6 +53,6 @@ class TheoryBuiltin : public Theory } // namespace builtin } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BUILTIN__THEORY_BUILTIN_H */ diff --git a/src/theory/builtin/theory_builtin_rewriter.cpp b/src/theory/builtin/theory_builtin_rewriter.cpp index 16e454e04..16fc59a5a 100644 --- a/src/theory/builtin/theory_builtin_rewriter.cpp +++ b/src/theory/builtin/theory_builtin_rewriter.cpp @@ -23,7 +23,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace builtin { @@ -502,6 +502,6 @@ Node TheoryBuiltinRewriter::getArrayRepresentationForLambda(TNode n) return Rewriter::rewrite(anode); } -}/* CVC4::theory::builtin namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace builtin +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/builtin/theory_builtin_rewriter.h b/src/theory/builtin/theory_builtin_rewriter.h index bf84d543b..c419abdb3 100644 --- a/src/theory/builtin/theory_builtin_rewriter.h +++ b/src/theory/builtin/theory_builtin_rewriter.h @@ -22,7 +22,7 @@ #include "theory/theory_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace builtin { @@ -117,8 +117,8 @@ class TheoryBuiltinRewriter : public TheoryRewriter 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 */ diff --git a/src/theory/builtin/theory_builtin_type_rules.cpp b/src/theory/builtin/theory_builtin_type_rules.cpp index 3abdbd48f..d5a5c9ab7 100644 --- a/src/theory/builtin/theory_builtin_type_rules.cpp +++ b/src/theory/builtin/theory_builtin_type_rules.cpp @@ -18,7 +18,7 @@ #include "expr/attribute.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace builtin { @@ -47,4 +47,4 @@ Node SortProperties::mkGroundTerm(TypeNode type) } // namespace builtin } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/builtin/theory_builtin_type_rules.h b/src/theory/builtin/theory_builtin_type_rules.h index e0c68aa0f..815483507 100644 --- a/src/theory/builtin/theory_builtin_type_rules.h +++ b/src/theory/builtin/theory_builtin_type_rules.h @@ -25,7 +25,7 @@ #include <sstream> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace builtin { @@ -246,8 +246,8 @@ class FunctionProperties { } };/* 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 */ diff --git a/src/theory/builtin/type_enumerator.cpp b/src/theory/builtin/type_enumerator.cpp index 6f7082191..4dda11070 100644 --- a/src/theory/builtin/type_enumerator.cpp +++ b/src/theory/builtin/type_enumerator.cpp @@ -18,7 +18,7 @@ #include "theory/builtin/theory_builtin_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace builtin { @@ -47,6 +47,6 @@ FunctionEnumerator& FunctionEnumerator::operator++() return *this; } -} /* CVC4::theory::builtin namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace builtin +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/builtin/type_enumerator.h b/src/theory/builtin/type_enumerator.h index 7b4b09f84..50cd50dda 100644 --- a/src/theory/builtin/type_enumerator.h +++ b/src/theory/builtin/type_enumerator.h @@ -25,7 +25,7 @@ #include "theory/type_enumerator.h" #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace builtin { @@ -104,8 +104,8 @@ class FunctionEnumerator : public TypeEnumeratorBase<FunctionEnumerator> 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 */ diff --git a/src/theory/bv/abstraction.cpp b/src/theory/bv/abstraction.cpp index 3b9df3518..ee4b467b8 100644 --- a/src/theory/bv/abstraction.cpp +++ b/src/theory/bv/abstraction.cpp @@ -23,13 +23,13 @@ #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) diff --git a/src/theory/bv/abstraction.h b/src/theory/bv/abstraction.h index e22e221f2..6c36de34c 100644 --- a/src/theory/bv/abstraction.h +++ b/src/theory/bv/abstraction.h @@ -27,7 +27,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -246,6 +246,6 @@ public: } } -} +} // namespace CVC5 #endif diff --git a/src/theory/bv/bitblast/aig_bitblaster.cpp b/src/theory/bv/bitblast/aig_bitblaster.cpp index 465a8eb65..002a4f631 100644 --- a/src/theory/bv/bitblast/aig_bitblaster.cpp +++ b/src/theory/bv/bitblast/aig_bitblaster.cpp @@ -40,7 +40,7 @@ static inline int Cnf_Lit2Var(int Lit) return (Lit & 1) ? -(Lit >> 1) - 1 : (Lit >> 1) + 1; } -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -123,7 +123,7 @@ Abc_Ntk_t* AigBitblaster::currentAigNtk() { 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); } @@ -496,5 +496,5 @@ AigBitblaster::Statistics::~Statistics() { } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4_USE_ABC diff --git a/src/theory/bv/bitblast/aig_bitblaster.h b/src/theory/bv/bitblast/aig_bitblaster.h index d3326f853..3eccbd3ec 100644 --- a/src/theory/bv/bitblast/aig_bitblaster.h +++ b/src/theory/bv/bitblast/aig_bitblaster.h @@ -33,7 +33,7 @@ typedef Abc_Aig_t_ Abc_Aig_t; class Cnf_Dat_t_; typedef Cnf_Dat_t_ Cnf_Dat_t; -namespace CVC4 { +namespace CVC5 { namespace prop { class SatSolver; } @@ -121,6 +121,6 @@ class AigBitblaster : public TBitblaster<Abc_Obj_t*> } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__THEORY__BV__BITBLAST__AIG_BITBLASTER_H diff --git a/src/theory/bv/bitblast/bitblast_strategies_template.h b/src/theory/bv/bitblast/bitblast_strategies_template.h index 01eabfab5..7ae55015f 100644 --- a/src/theory/bv/bitblast/bitblast_strategies_template.h +++ b/src/theory/bv/bitblast/bitblast_strategies_template.h @@ -27,7 +27,7 @@ #include "theory/bv/theory_bv_utils.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -899,6 +899,6 @@ void DefaultRotateLeftBB (TNode node, std::vector<T>& bits, TBitblaster<T>* bb) } } -} +} // namespace CVC5 #endif diff --git a/src/theory/bv/bitblast/bitblast_utils.h b/src/theory/bv/bitblast/bitblast_utils.h index 37618bd06..e342d4410 100644 --- a/src/theory/bv/bitblast/bitblast_utils.h +++ b/src/theory/bv/bitblast/bitblast_utils.h @@ -23,7 +23,7 @@ #include <ostream> #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -267,6 +267,6 @@ T inline sLessThanBB(const std::vector<T>&a, const std::vector<T>& b, bool orEqu } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__THEORY__BV__BITBLAST__BITBLAST_UTILS_H diff --git a/src/theory/bv/bitblast/bitblaster.h b/src/theory/bv/bitblast/bitblaster.h index 738f511b6..90ea5ac2b 100644 --- a/src/theory/bv/bitblast/bitblaster.h +++ b/src/theory/bv/bitblast/bitblaster.h @@ -35,7 +35,7 @@ #include "theory/valuation.h" #include "util/resource_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -268,6 +268,6 @@ Node TBitblaster<T>::getTermModel(TNode node, bool fullModel) } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BV__BITBLAST__BITBLASTER_H */ diff --git a/src/theory/bv/bitblast/eager_bitblaster.cpp b/src/theory/bv/bitblast/eager_bitblaster.cpp index bbddf82cd..5e22262e2 100644 --- a/src/theory/bv/bitblast/eager_bitblaster.cpp +++ b/src/theory/bv/bitblast/eager_bitblaster.cpp @@ -27,7 +27,7 @@ #include "theory/bv/theory_bv.h" #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -288,4 +288,4 @@ bool EagerBitblaster::isSharedTerm(TNode node) { } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/bitblast/eager_bitblaster.h b/src/theory/bv/bitblast/eager_bitblaster.h index d66b46505..dead462b5 100644 --- a/src/theory/bv/bitblast/eager_bitblaster.h +++ b/src/theory/bv/bitblast/eager_bitblaster.h @@ -26,7 +26,7 @@ #include "prop/sat_solver.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -85,5 +85,5 @@ class BitblastingRegistrar : public prop::Registrar } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__THEORY__BV__BITBLAST__EAGER_BITBLASTER_H diff --git a/src/theory/bv/bitblast/lazy_bitblaster.cpp b/src/theory/bv/bitblast/lazy_bitblaster.cpp index 7e36f63dd..e20a6f6b5 100644 --- a/src/theory/bv/bitblast/lazy_bitblaster.cpp +++ b/src/theory/bv/bitblast/lazy_bitblaster.cpp @@ -30,7 +30,7 @@ #include "theory/rewriter.h" #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -590,4 +590,4 @@ void TLazyBitblaster::clearSolver() { } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/bitblast/lazy_bitblaster.h b/src/theory/bv/bitblast/lazy_bitblaster.h index 622369043..1a963e67d 100644 --- a/src/theory/bv/bitblast/lazy_bitblaster.h +++ b/src/theory/bv/bitblast/lazy_bitblaster.h @@ -26,7 +26,7 @@ #include "prop/bv_sat_solver_notify.h" #include "theory/bv/abstraction.h" -namespace CVC4 { +namespace CVC5 { namespace prop { class CnfStream; class NullRegistrat; @@ -176,5 +176,5 @@ class TLazyBitblaster : public TBitblaster<Node> } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__THEORY__BV__BITBLAST__LAZY_BITBLASTER_H diff --git a/src/theory/bv/bitblast/proof_bitblaster.cpp b/src/theory/bv/bitblast/proof_bitblaster.cpp index 4210c4a86..b0cf68609 100644 --- a/src/theory/bv/bitblast/proof_bitblaster.cpp +++ b/src/theory/bv/bitblast/proof_bitblaster.cpp @@ -17,7 +17,7 @@ #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -84,4 +84,4 @@ bool BBProof::collectModelValues(TheoryModel* m, } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/bitblast/proof_bitblaster.h b/src/theory/bv/bitblast/proof_bitblaster.h index 6c4c04349..894a9a916 100644 --- a/src/theory/bv/bitblast/proof_bitblaster.h +++ b/src/theory/bv/bitblast/proof_bitblaster.h @@ -18,7 +18,7 @@ #include "theory/bv/bitblast/simple_bitblaster.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -47,5 +47,5 @@ class BBProof } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/bv/bitblast/simple_bitblaster.cpp b/src/theory/bv/bitblast/simple_bitblaster.cpp index 10eac275e..76677e2db 100644 --- a/src/theory/bv/bitblast/simple_bitblaster.cpp +++ b/src/theory/bv/bitblast/simple_bitblaster.cpp @@ -17,7 +17,7 @@ #include "theory/theory_model.h" #include "theory/theory_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -155,4 +155,4 @@ bool BBSimple::isVariable(TNode node) } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/bitblast/simple_bitblaster.h b/src/theory/bv/bitblast/simple_bitblaster.h index d337dbc08..1b48f9a68 100644 --- a/src/theory/bv/bitblast/simple_bitblaster.h +++ b/src/theory/bv/bitblast/simple_bitblaster.h @@ -19,7 +19,7 @@ #include "theory/bv/bitblast/bitblaster.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -75,6 +75,6 @@ class BBSimple : public TBitblaster<Node> } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/bv/bv_eager_solver.cpp b/src/theory/bv/bv_eager_solver.cpp index e71b200c6..9c478791c 100644 --- a/src/theory/bv/bv_eager_solver.cpp +++ b/src/theory/bv/bv_eager_solver.cpp @@ -23,7 +23,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -125,4 +125,4 @@ bool EagerBitblastSolver::collectModelInfo(TheoryModel* m, bool fullModel) } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/bv_eager_solver.h b/src/theory/bv/bv_eager_solver.h index 6a1d61a3b..0fe1ed32b 100644 --- a/src/theory/bv/bv_eager_solver.h +++ b/src/theory/bv/bv_eager_solver.h @@ -23,7 +23,7 @@ #include "theory/bv/bv_solver_lazy.h" #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -60,6 +60,6 @@ class EagerBitblastSolver { } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__THEORY__BV__BV_EAGER_SOLVER_H diff --git a/src/theory/bv/bv_inequality_graph.cpp b/src/theory/bv/bv_inequality_graph.cpp index 1caae9b5e..67554525a 100644 --- a/src/theory/bv/bv_inequality_graph.cpp +++ b/src/theory/bv/bv_inequality_graph.cpp @@ -18,16 +18,15 @@ #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"; diff --git a/src/theory/bv/bv_inequality_graph.h b/src/theory/bv/bv_inequality_graph.h index be5da70b2..caa7220cf 100644 --- a/src/theory/bv/bv_inequality_graph.h +++ b/src/theory/bv/bv_inequality_graph.h @@ -29,7 +29,7 @@ #include "context/cdqueue.h" #include "context/context.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -291,6 +291,6 @@ public: } } -} +} // namespace CVC5 #endif /* CVC4__THEORY__BV__BV_INEQUALITY__GRAPH_H */ diff --git a/src/theory/bv/bv_quick_check.cpp b/src/theory/bv/bv_quick_check.cpp index 36e77b0b7..bbb2f1ca9 100644 --- a/src/theory/bv/bv_quick_check.cpp +++ b/src/theory/bv/bv_quick_check.cpp @@ -21,9 +21,9 @@ #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 { @@ -381,4 +381,4 @@ QuickXPlain::Statistics::~Statistics() { } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/bv_quick_check.h b/src/theory/bv/bv_quick_check.h index f509c3cb4..3d30d912d 100644 --- a/src/theory/bv/bv_quick_check.h +++ b/src/theory/bv/bv_quick_check.h @@ -29,7 +29,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class TheoryModel; @@ -181,6 +181,6 @@ class QuickXPlain } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__BV_QUICK_CHECK_H */ diff --git a/src/theory/bv/bv_solver.h b/src/theory/bv/bv_solver.h index d79f69e53..f08f7527a 100644 --- a/src/theory/bv/bv_solver.h +++ b/src/theory/bv/bv_solver.h @@ -21,7 +21,7 @@ #include "theory/theory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -117,6 +117,6 @@ class BVSolver } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BV__BV_SOLVER_H */ diff --git a/src/theory/bv/bv_solver_bitblast.cpp b/src/theory/bv/bv_solver_bitblast.cpp index e6dfd8286..16a99c2e4 100644 --- a/src/theory/bv/bv_solver_bitblast.cpp +++ b/src/theory/bv/bv_solver_bitblast.cpp @@ -23,7 +23,7 @@ #include "theory/bv/theory_bv_utils.h" #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -281,4 +281,4 @@ Node BVSolverBitblast::getValue(TNode node) } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/bv_solver_bitblast.h b/src/theory/bv/bv_solver_bitblast.h index d1252659a..794b9fa9b 100644 --- a/src/theory/bv/bv_solver_bitblast.h +++ b/src/theory/bv/bv_solver_bitblast.h @@ -29,7 +29,7 @@ #include "theory/bv/proof_checker.h" #include "theory/eager_proof_generator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -143,6 +143,6 @@ class BVSolverBitblast : public BVSolver } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/bv/bv_solver_lazy.cpp b/src/theory/bv/bv_solver_lazy.cpp index 9562b69c7..ed71fccbe 100644 --- a/src/theory/bv/bv_solver_lazy.cpp +++ b/src/theory/bv/bv_solver_lazy.cpp @@ -32,9 +32,9 @@ #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 { @@ -828,4 +828,4 @@ void BVSolverLazy::setConflict(Node conflict) } // namespace bv } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/bv/bv_solver_lazy.h b/src/theory/bv/bv_solver_lazy.h index 4c769fb7a..6511900eb 100644 --- a/src/theory/bv/bv_solver_lazy.h +++ b/src/theory/bv/bv_solver_lazy.h @@ -28,7 +28,7 @@ #include "theory/bv/theory_bv.h" #include "util/hash.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -229,6 +229,6 @@ class BVSolverLazy : public BVSolver } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BV__BV_SOLVER_LAZY_H */ diff --git a/src/theory/bv/bv_solver_simple.cpp b/src/theory/bv/bv_solver_simple.cpp index db89c29bb..65d46e861 100644 --- a/src/theory/bv/bv_solver_simple.cpp +++ b/src/theory/bv/bv_solver_simple.cpp @@ -20,7 +20,7 @@ #include "theory/bv/theory_bv_utils.h" #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -151,4 +151,4 @@ bool BVSolverSimple::collectModelValues(TheoryModel* m, } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/bv_solver_simple.h b/src/theory/bv/bv_solver_simple.h index a34ec98ad..1b6976abb 100644 --- a/src/theory/bv/bv_solver_simple.h +++ b/src/theory/bv/bv_solver_simple.h @@ -24,7 +24,7 @@ #include "theory/bv/proof_checker.h" #include "theory/eager_proof_generator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -81,6 +81,6 @@ class BVSolverSimple : public BVSolver } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/bv/bv_subtheory.h b/src/theory/bv/bv_subtheory.h index d4bba4c5e..e558ea7c7 100644 --- a/src/theory/bv/bv_subtheory.h +++ b/src/theory/bv/bv_subtheory.h @@ -23,7 +23,7 @@ #include "theory/uf/equality_engine.h" #include "theory/theory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { @@ -107,6 +107,6 @@ class SubtheorySolver { } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BV__BV_SUBTHEORY_H */ diff --git a/src/theory/bv/bv_subtheory_algebraic.cpp b/src/theory/bv/bv_subtheory_algebraic.cpp index 8f774e552..2343d72d1 100644 --- a/src/theory/bv/bv_subtheory_algebraic.cpp +++ b/src/theory/bv/bv_subtheory_algebraic.cpp @@ -31,12 +31,12 @@ #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 { @@ -990,6 +990,6 @@ Node mergeExplanations(TNode expl1, TNode expl2) { return mergeExplanations(expls); } -} /* namespace CVC4::theory::bv */ +} // namespace bv } /* namespace CVc4::theory */ -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/bv/bv_subtheory_algebraic.h b/src/theory/bv/bv_subtheory_algebraic.h index 71db94cf8..e7156a33e 100644 --- a/src/theory/bv/bv_subtheory_algebraic.h +++ b/src/theory/bv/bv_subtheory_algebraic.h @@ -25,7 +25,7 @@ #include "theory/bv/slicer.h" #include "theory/substitutions.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -245,4 +245,4 @@ class AlgebraicSolver : public SubtheorySolver } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/bv_subtheory_bitblast.cpp b/src/theory/bv/bv_subtheory_bitblast.cpp index 89bca151e..2d21a8f0c 100644 --- a/src/theory/bv/bv_subtheory_bitblast.cpp +++ b/src/theory/bv/bv_subtheory_bitblast.cpp @@ -27,9 +27,9 @@ #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 { @@ -276,6 +276,6 @@ void BitblastSolver::setConflict(TNode conflict) d_bv->setConflict(final_conflict); } -}/* namespace CVC4::theory::bv */ -}/* namespace CVC4::theory */ -}/* namespace CVC4 */ +} // namespace bv +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/bv/bv_subtheory_bitblast.h b/src/theory/bv/bv_subtheory_bitblast.h index ca6e53dea..f964fb995 100644 --- a/src/theory/bv/bv_subtheory_bitblast.h +++ b/src/theory/bv/bv_subtheory_bitblast.h @@ -22,7 +22,7 @@ #include "theory/bv/bv_subtheory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -83,4 +83,4 @@ class BitblastSolver : public SubtheorySolver } // namespace bv } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/bv/bv_subtheory_core.cpp b/src/theory/bv/bv_subtheory_core.cpp index bda3393e5..486adfdb7 100644 --- a/src/theory/bv/bv_subtheory_core.cpp +++ b/src/theory/bv/bv_subtheory_core.cpp @@ -25,11 +25,11 @@ #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, diff --git a/src/theory/bv/bv_subtheory_core.h b/src/theory/bv/bv_subtheory_core.h index 969ded528..700d8c4f5 100644 --- a/src/theory/bv/bv_subtheory_core.h +++ b/src/theory/bv/bv_subtheory_core.h @@ -25,7 +25,7 @@ #include "theory/bv/bv_subtheory.h" #include "theory/ext_theory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -164,4 +164,4 @@ class CoreSolver : public SubtheorySolver { } } -} +} // namespace CVC5 diff --git a/src/theory/bv/bv_subtheory_inequality.cpp b/src/theory/bv/bv_subtheory_inequality.cpp index aa3607a66..d67a5c550 100644 --- a/src/theory/bv/bv_subtheory_inequality.cpp +++ b/src/theory/bv/bv_subtheory_inequality.cpp @@ -24,11 +24,11 @@ #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"; diff --git a/src/theory/bv/bv_subtheory_inequality.h b/src/theory/bv/bv_subtheory_inequality.h index 277449026..232c8676e 100644 --- a/src/theory/bv/bv_subtheory_inequality.h +++ b/src/theory/bv/bv_subtheory_inequality.h @@ -26,7 +26,7 @@ #include "theory/bv/bv_inequality_graph.h" #include "theory/bv/bv_subtheory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -89,6 +89,6 @@ class InequalitySolver : public SubtheorySolver } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BV__BV_SUBTHEORY__INEQUALITY_H */ diff --git a/src/theory/bv/int_blaster.h b/src/theory/bv/int_blaster.h index 80f47509e..65a8b5480 100644 --- a/src/theory/bv/int_blaster.h +++ b/src/theory/bv/int_blaster.h @@ -24,7 +24,7 @@ #include "options/smt_options.h" #include "theory/arith/nl/iand_utils.h" -namespace CVC4 { +namespace CVC5 { /* ** Converts bit-vector formulas to integer formulas. @@ -349,6 +349,6 @@ class IntBlaster bool d_introduceFreshIntVars; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* __CVC4__THEORY__BV__INT_BLASTER_H */ diff --git a/src/theory/bv/kinds b/src/theory/bv/kinds index 32e0e9e85..884ee49e6 100644 --- a/src/theory/bv/kinds +++ b/src/theory/bv/kinds @@ -4,36 +4,36 @@ # 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 ------------------------------------------ @@ -99,139 +99,139 @@ operator BITVECTOR_EAGER_ATOM 1 "formula to be treated as a bv atom via eager bi ### 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 diff --git a/src/theory/bv/proof_checker.cpp b/src/theory/bv/proof_checker.cpp index 862e2034a..82f37c552 100644 --- a/src/theory/bv/proof_checker.cpp +++ b/src/theory/bv/proof_checker.cpp @@ -14,7 +14,7 @@ #include "theory/bv/proof_checker.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -50,4 +50,4 @@ Node BVProofRuleChecker::checkInternal(PfRule id, } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/proof_checker.h b/src/theory/bv/proof_checker.h index 119aa4924..efa319322 100644 --- a/src/theory/bv/proof_checker.h +++ b/src/theory/bv/proof_checker.h @@ -22,7 +22,7 @@ #include "expr/proof_node.h" #include "theory/bv/bitblast/simple_bitblaster.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -45,6 +45,6 @@ class BVProofRuleChecker : public ProofRuleChecker } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BV__PROOF_CHECKER_H */ diff --git a/src/theory/bv/slicer.cpp b/src/theory/bv/slicer.cpp index a19c18df8..e8c032a61 100644 --- a/src/theory/bv/slicer.cpp +++ b/src/theory/bv/slicer.cpp @@ -20,9 +20,9 @@ #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 { @@ -83,4 +83,4 @@ std::string Base::debugPrint() const { } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/slicer.h b/src/theory/bv/slicer.h index 49c3cfaa7..56ed0ecba 100644 --- a/src/theory/bv/slicer.h +++ b/src/theory/bv/slicer.h @@ -23,7 +23,7 @@ #include <vector> #include "util/index.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -47,10 +47,10 @@ public: } return true; } -}; +}; -}/* CVC4::theory::bv namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace bv +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__BV__SLICER_BV_H */ diff --git a/src/theory/bv/theory_bv.cpp b/src/theory/bv/theory_bv.cpp index 3d8a5d3ea..185f7ad2a 100644 --- a/src/theory/bv/theory_bv.cpp +++ b/src/theory/bv/theory_bv.cpp @@ -23,7 +23,7 @@ #include "theory/bv/theory_bv_utils.h" #include "theory/ee_setup_info.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -236,4 +236,4 @@ bool TheoryBV::applyAbstraction(const std::vector<Node>& assertions, } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/theory_bv.h b/src/theory/bv/theory_bv.h index 93e03e5ca..1608dc3cf 100644 --- a/src/theory/bv/theory_bv.h +++ b/src/theory/bv/theory_bv.h @@ -24,7 +24,7 @@ #include "theory/theory_eq_notify.h" #include "theory/theory_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -124,6 +124,6 @@ class TheoryBV : public Theory } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BV__THEORY_BV_H */ diff --git a/src/theory/bv/theory_bv_rewrite_rules.h b/src/theory/bv/theory_bv_rewrite_rules.h index 6cf1934f0..f9bd4215d 100644 --- a/src/theory/bv/theory_bv_rewrite_rules.h +++ b/src/theory/bv/theory_bv_rewrite_rules.h @@ -30,7 +30,7 @@ #include "theory/theory.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -770,4 +770,4 @@ struct FixpointRewriteStrategy { } // End namespace bv } // End namespace theory -} // End namespace CVC4 +} // End namespace CVC5 diff --git a/src/theory/bv/theory_bv_rewrite_rules_constant_evaluation.h b/src/theory/bv/theory_bv_rewrite_rules_constant_evaluation.h index 57cb5f28e..917d77637 100644 --- a/src/theory/bv/theory_bv_rewrite_rules_constant_evaluation.h +++ b/src/theory/bv/theory_bv_rewrite_rules_constant_evaluation.h @@ -22,7 +22,7 @@ #include "theory/bv/theory_bv_rewrite_rules.h" #include "theory/bv/theory_bv_utils.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -492,4 +492,4 @@ Node RewriteRule<EvalComp>::apply(TNode node) { } } -} +} // namespace CVC5 diff --git a/src/theory/bv/theory_bv_rewrite_rules_core.h b/src/theory/bv/theory_bv_rewrite_rules_core.h index c1aa034e8..c24c3ac48 100644 --- a/src/theory/bv/theory_bv_rewrite_rules_core.h +++ b/src/theory/bv/theory_bv_rewrite_rules_core.h @@ -22,7 +22,7 @@ #include "theory/bv/theory_bv_rewrite_rules.h" #include "theory/bv/theory_bv_utils.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -302,4 +302,4 @@ Node RewriteRule<ReflexivityEq>::apply(TNode node) { } } -} +} // namespace CVC5 diff --git a/src/theory/bv/theory_bv_rewrite_rules_normalization.h b/src/theory/bv/theory_bv_rewrite_rules_normalization.h index db8e588e4..cf7bc4a8f 100644 --- a/src/theory/bv/theory_bv_rewrite_rules_normalization.h +++ b/src/theory/bv/theory_bv_rewrite_rules_normalization.h @@ -27,7 +27,7 @@ #include "theory/bv/theory_bv_utils.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -1571,4 +1571,4 @@ inline Node RewriteRule<NormalizeEqPlusNeg>::apply(TNode node) } } -} +} // namespace CVC5 diff --git a/src/theory/bv/theory_bv_rewrite_rules_operator_elimination.h b/src/theory/bv/theory_bv_rewrite_rules_operator_elimination.h index 1272f303d..3750ef5b0 100644 --- a/src/theory/bv/theory_bv_rewrite_rules_operator_elimination.h +++ b/src/theory/bv/theory_bv_rewrite_rules_operator_elimination.h @@ -23,7 +23,7 @@ #include "theory/bv/theory_bv_rewrite_rules.h" #include "theory/bv/theory_bv_utils.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -788,4 +788,4 @@ inline Node RewriteRule<RedandEliminate>::apply(TNode node) } } -} +} // namespace CVC5 diff --git a/src/theory/bv/theory_bv_rewrite_rules_simplification.h b/src/theory/bv/theory_bv_rewrite_rules_simplification.h index bbf7c62e7..c6dcb9f1e 100644 --- a/src/theory/bv/theory_bv_rewrite_rules_simplification.h +++ b/src/theory/bv/theory_bv_rewrite_rules_simplification.h @@ -24,7 +24,7 @@ #include "theory/bv/theory_bv_utils.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -2257,4 +2257,4 @@ Node RewriteRule<MultSltMult>::apply(TNode node) } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/bv/theory_bv_rewriter.cpp b/src/theory/bv/theory_bv_rewriter.cpp index 614261e34..9b2d929ed 100644 --- a/src/theory/bv/theory_bv_rewriter.cpp +++ b/src/theory/bv/theory_bv_rewriter.cpp @@ -25,9 +25,9 @@ #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(); } diff --git a/src/theory/bv/theory_bv_rewriter.h b/src/theory/bv/theory_bv_rewriter.h index 9ecc25973..e6c42f117 100644 --- a/src/theory/bv/theory_bv_rewriter.h +++ b/src/theory/bv/theory_bv_rewriter.h @@ -22,7 +22,7 @@ #include "theory/theory_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -103,8 +103,8 @@ class TheoryBVRewriter : public TheoryRewriter 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 */ diff --git a/src/theory/bv/theory_bv_type_rules.h b/src/theory/bv/theory_bv_type_rules.h index 54e8c6175..54ed4579b 100644 --- a/src/theory/bv/theory_bv_type_rules.h +++ b/src/theory/bv/theory_bv_type_rules.h @@ -21,7 +21,7 @@ #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 { @@ -450,6 +450,6 @@ class BitVectorAckermanizationUremTypeRule } // namespace bv } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__BV__THEORY_BV_TYPE_RULES_H */ diff --git a/src/theory/bv/theory_bv_utils.cpp b/src/theory/bv/theory_bv_utils.cpp index 1a6b7a873..4a68e3724 100644 --- a/src/theory/bv/theory_bv_utils.cpp +++ b/src/theory/bv/theory_bv_utils.cpp @@ -21,7 +21,7 @@ #include "options/theory_options.h" #include "theory/theory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { namespace utils { @@ -508,7 +508,7 @@ Node eliminateInt2Bv(TNode node) 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 diff --git a/src/theory/bv/theory_bv_utils.h b/src/theory/bv/theory_bv_utils.h index c6c03e561..5795b5f14 100644 --- a/src/theory/bv/theory_bv_utils.h +++ b/src/theory/bv/theory_bv_utils.h @@ -25,7 +25,7 @@ #include "expr/node_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -226,4 +226,4 @@ Node eliminateInt2Bv(TNode node); } } } -} +} // namespace CVC5 diff --git a/src/theory/bv/type_enumerator.h b/src/theory/bv/type_enumerator.h index 58f8f5b80..31fe11715 100644 --- a/src/theory/bv/type_enumerator.h +++ b/src/theory/bv/type_enumerator.h @@ -26,7 +26,7 @@ #include "util/bitvector.h" #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace bv { @@ -59,8 +59,8 @@ public: 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 */ diff --git a/src/theory/care_graph.h b/src/theory/care_graph.h index 91873b03f..687378887 100644 --- a/src/theory/care_graph.h +++ b/src/theory/care_graph.h @@ -24,7 +24,7 @@ #include "expr/node.h" #include "theory/theory_id.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -60,6 +60,6 @@ struct CarePair { typedef std::set<CarePair> CareGraph; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__CARE_GRAPH_H */ diff --git a/src/theory/combination_care_graph.cpp b/src/theory/combination_care_graph.cpp index 567a16636..df757c4a9 100644 --- a/src/theory/combination_care_graph.cpp +++ b/src/theory/combination_care_graph.cpp @@ -20,7 +20,7 @@ #include "theory/model_manager.h" #include "theory/theory_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { CombinationCareGraph::CombinationCareGraph( @@ -99,4 +99,4 @@ bool CombinationCareGraph::buildModel() } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/combination_care_graph.h b/src/theory/combination_care_graph.h index 70d651e1f..a59fa154e 100644 --- a/src/theory/combination_care_graph.h +++ b/src/theory/combination_care_graph.h @@ -21,7 +21,7 @@ #include "theory/combination_engine.h" -namespace CVC4 { +namespace CVC5 { class TheoryEngine; @@ -47,6 +47,6 @@ class CombinationCareGraph : public CombinationEngine }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__COMBINATION_DISTRIBUTED__H */ diff --git a/src/theory/combination_engine.cpp b/src/theory/combination_engine.cpp index 160b56625..639a7e201 100644 --- a/src/theory/combination_engine.cpp +++ b/src/theory/combination_engine.cpp @@ -24,7 +24,7 @@ #include "theory/shared_solver_distributed.h" #include "theory/theory_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { CombinationEngine::CombinationEngine(TheoryEngine& te, @@ -118,4 +118,4 @@ void CombinationEngine::resetRound() } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/combination_engine.h b/src/theory/combination_engine.h index a6331b406..6798404e9 100644 --- a/src/theory/combination_engine.h +++ b/src/theory/combination_engine.h @@ -23,7 +23,7 @@ #include "theory/ee_manager.h" #include "theory/valuation.h" -namespace CVC4 { +namespace CVC5 { class TheoryEngine; @@ -137,6 +137,6 @@ class CombinationEngine }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__COMBINATION_DISTRIBUTED__H */ diff --git a/src/theory/datatypes/datatypes_rewriter.cpp b/src/theory/datatypes/datatypes_rewriter.cpp index dadd0d240..18332a972 100644 --- a/src/theory/datatypes/datatypes_rewriter.cpp +++ b/src/theory/datatypes/datatypes_rewriter.cpp @@ -24,10 +24,10 @@ #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 { @@ -794,6 +794,6 @@ Node DatatypesRewriter::replaceDebruijn(Node n, return n; } -} /* CVC4::theory::datatypes namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace datatypes +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/datatypes/datatypes_rewriter.h b/src/theory/datatypes/datatypes_rewriter.h index 8ad927ce4..4126a505d 100644 --- a/src/theory/datatypes/datatypes_rewriter.h +++ b/src/theory/datatypes/datatypes_rewriter.h @@ -21,7 +21,7 @@ #include "theory/theory_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace datatypes { @@ -142,8 +142,8 @@ class DatatypesRewriter : public TheoryRewriter 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 */ diff --git a/src/theory/datatypes/infer_proof_cons.cpp b/src/theory/datatypes/infer_proof_cons.cpp index b231e8fd4..d87ff15a5 100644 --- a/src/theory/datatypes/infer_proof_cons.cpp +++ b/src/theory/datatypes/infer_proof_cons.cpp @@ -20,9 +20,9 @@ #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 { @@ -275,4 +275,4 @@ std::string InferProofCons::identify() const } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/datatypes/infer_proof_cons.h b/src/theory/datatypes/infer_proof_cons.h index eeb8214e2..70fa8fad5 100644 --- a/src/theory/datatypes/infer_proof_cons.h +++ b/src/theory/datatypes/infer_proof_cons.h @@ -22,7 +22,7 @@ #include "expr/proof_generator.h" #include "theory/datatypes/inference.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; @@ -95,6 +95,6 @@ class InferProofCons : public ProofGenerator } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__DATATYPES__INFER_PROOF_CONS_H */ diff --git a/src/theory/datatypes/inference.cpp b/src/theory/datatypes/inference.cpp index 2d482deaf..9749d7a2d 100644 --- a/src/theory/datatypes/inference.cpp +++ b/src/theory/datatypes/inference.cpp @@ -19,9 +19,9 @@ #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 { @@ -80,4 +80,4 @@ Node DatatypesInference::processFact(std::vector<Node>& exp, } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/datatypes/inference.h b/src/theory/datatypes/inference.h index 9c19608c1..bff56afdc 100644 --- a/src/theory/datatypes/inference.h +++ b/src/theory/datatypes/inference.h @@ -22,7 +22,7 @@ #include "theory/theory_inference.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace datatypes { @@ -69,6 +69,6 @@ class DatatypesInference : public SimpleTheoryInternalFact } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/datatypes/inference_manager.cpp b/src/theory/datatypes/inference_manager.cpp index 1a837e73b..f4a0f45d9 100644 --- a/src/theory/datatypes/inference_manager.cpp +++ b/src/theory/datatypes/inference_manager.cpp @@ -23,9 +23,9 @@ #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 { @@ -171,4 +171,4 @@ Node InferenceManager::prepareDtInference(Node conc, } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/datatypes/inference_manager.h b/src/theory/datatypes/inference_manager.h index 83876817b..c7b20ec83 100644 --- a/src/theory/datatypes/inference_manager.h +++ b/src/theory/datatypes/inference_manager.h @@ -21,7 +21,7 @@ #include "theory/datatypes/infer_proof_cons.h" #include "theory/inference_manager_buffered.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class EagerProofGenerator; @@ -109,6 +109,6 @@ class InferenceManager : public InferenceManagerBuffered } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/datatypes/kinds b/src/theory/datatypes/kinds index f3e5be5c7..3fd59d9cb 100644 --- a/src/theory/datatypes/kinds +++ b/src/theory/datatypes/kinds @@ -4,31 +4,31 @@ # 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" @@ -39,8 +39,8 @@ parameterized APPLY_SELECTOR_TOTAL [SELECTOR_TYPE] 1 "selector application; para 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 \ @@ -52,7 +52,7 @@ well-founded 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" @@ -65,59 +65,59 @@ well-founded 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 @@ -134,21 +134,21 @@ operator MATCH 2: "match construct" 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 diff --git a/src/theory/datatypes/proof_checker.cpp b/src/theory/datatypes/proof_checker.cpp index 71352783d..f55b45541 100644 --- a/src/theory/datatypes/proof_checker.cpp +++ b/src/theory/datatypes/proof_checker.cpp @@ -18,7 +18,7 @@ #include "theory/datatypes/theory_datatypes_utils.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace datatypes { @@ -133,4 +133,4 @@ Node DatatypesProofRuleChecker::checkInternal(PfRule id, } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/datatypes/proof_checker.h b/src/theory/datatypes/proof_checker.h index 03092e3b1..a66cac8d8 100644 --- a/src/theory/datatypes/proof_checker.h +++ b/src/theory/datatypes/proof_checker.h @@ -21,7 +21,7 @@ #include "expr/proof_checker.h" #include "expr/proof_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace datatypes { @@ -44,6 +44,6 @@ class DatatypesProofRuleChecker : public ProofRuleChecker } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__DATATYPES__PROOF_CHECKER_H */ diff --git a/src/theory/datatypes/sygus_datatype_utils.cpp b/src/theory/datatypes/sygus_datatype_utils.cpp index 50202fefd..4f328619b 100644 --- a/src/theory/datatypes/sygus_datatype_utils.cpp +++ b/src/theory/datatypes/sygus_datatype_utils.cpp @@ -27,10 +27,10 @@ #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 { @@ -777,4 +777,4 @@ TypeNode substituteAndGeneralizeSygusType(TypeNode sdt, } // namespace utils } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/datatypes/sygus_datatype_utils.h b/src/theory/datatypes/sygus_datatype_utils.h index 1164c0404..e1af9250b 100644 --- a/src/theory/datatypes/sygus_datatype_utils.h +++ b/src/theory/datatypes/sygus_datatype_utils.h @@ -24,7 +24,7 @@ #include "expr/node_manager_attributes.h" #include "theory/datatypes/theory_datatypes_utils.h" -namespace CVC4 { +namespace CVC5 { namespace theory { // ----------------------- sygus datatype attributes @@ -237,6 +237,6 @@ TypeNode substituteAndGeneralizeSygusType(TypeNode sdt, } // namespace utils } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/datatypes/sygus_extension.cpp b/src/theory/datatypes/sygus_extension.cpp index fa99ca659..a53799baf 100644 --- a/src/theory/datatypes/sygus_extension.cpp +++ b/src/theory/datatypes/sygus_extension.cpp @@ -34,11 +34,11 @@ #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, diff --git a/src/theory/datatypes/sygus_extension.h b/src/theory/datatypes/sygus_extension.h index 86f15ba6d..7b49faa6d 100644 --- a/src/theory/datatypes/sygus_extension.h +++ b/src/theory/datatypes/sygus_extension.h @@ -29,7 +29,7 @@ #include "theory/quantifiers/sygus_sampler.h" #include "theory/quantifiers/term_database.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { class SynthConjecture; @@ -709,7 +709,7 @@ private: } } -} +} // namespace CVC5 #endif diff --git a/src/theory/datatypes/sygus_simple_sym.cpp b/src/theory/datatypes/sygus_simple_sym.cpp index 07f748236..ed6357244 100644 --- a/src/theory/datatypes/sygus_simple_sym.cpp +++ b/src/theory/datatypes/sygus_simple_sym.cpp @@ -18,9 +18,9 @@ #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 { @@ -584,4 +584,4 @@ int SygusSimpleSymBreak::getFirstArgOccurrence(const DTypeConstructor& c, } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/datatypes/sygus_simple_sym.h b/src/theory/datatypes/sygus_simple_sym.h index 713d1bdc2..5b5b816b7 100644 --- a/src/theory/datatypes/sygus_simple_sym.h +++ b/src/theory/datatypes/sygus_simple_sym.h @@ -20,7 +20,7 @@ #include "expr/dtype.h" #include "theory/quantifiers/sygus/term_database_sygus.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace datatypes { @@ -98,6 +98,6 @@ class SygusSimpleSymBreak } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__DATATYPES__SIMPLE_SYM_BREAK_H */ diff --git a/src/theory/datatypes/theory_datatypes.cpp b/src/theory/datatypes/theory_datatypes.cpp index 7af0686f8..48a2a8a99 100644 --- a/src/theory/datatypes/theory_datatypes.cpp +++ b/src/theory/datatypes/theory_datatypes.cpp @@ -40,10 +40,10 @@ #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 { @@ -2039,6 +2039,6 @@ std::pair<bool, Node> TheoryDatatypes::entailmentCheck(TNode lit) return make_pair(false, Node::null()); } -} /* namepsace CVC4::theory::datatypes */ -} /* namepsace CVC4::theory */ -} /* namepsace CVC4 */ +} // namespace datatypes +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/datatypes/theory_datatypes.h b/src/theory/datatypes/theory_datatypes.h index 447c4371a..03ea69fc4 100644 --- a/src/theory/datatypes/theory_datatypes.h +++ b/src/theory/datatypes/theory_datatypes.h @@ -35,7 +35,7 @@ #include "theory/uf/equality_engine.h" #include "util/hash.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace datatypes { @@ -312,8 +312,8 @@ private: 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 */ diff --git a/src/theory/datatypes/theory_datatypes_type_rules.h b/src/theory/datatypes/theory_datatypes_type_rules.h index 58bc2f09f..8084763b2 100644 --- a/src/theory/datatypes/theory_datatypes_type_rules.h +++ b/src/theory/datatypes/theory_datatypes_type_rules.h @@ -24,7 +24,7 @@ #include "expr/type_matcher.h" #include "theory/datatypes/theory_datatypes_utils.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace datatypes { @@ -626,8 +626,8 @@ class TupleProjectTypeRule } }; /* 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 */ diff --git a/src/theory/datatypes/theory_datatypes_utils.cpp b/src/theory/datatypes/theory_datatypes_utils.cpp index bd24b4910..72c032e4e 100644 --- a/src/theory/datatypes/theory_datatypes_utils.cpp +++ b/src/theory/datatypes/theory_datatypes_utils.cpp @@ -19,10 +19,10 @@ #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 { @@ -207,4 +207,4 @@ bool checkClash(Node n1, Node n2, std::vector<Node>& rew) } // namespace utils } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/datatypes/theory_datatypes_utils.h b/src/theory/datatypes/theory_datatypes_utils.h index b73d8223d..be7f5d4af 100644 --- a/src/theory/datatypes/theory_datatypes_utils.h +++ b/src/theory/datatypes/theory_datatypes_utils.h @@ -25,7 +25,7 @@ #include "expr/node.h" #include "expr/node_manager_attributes.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace datatypes { namespace utils { @@ -97,6 +97,6 @@ bool checkClash(Node n1, Node n2, std::vector<Node>& rew); } // namespace utils } // namespace datatypes } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/datatypes/tuple_project_op.cpp b/src/theory/datatypes/tuple_project_op.cpp index 397fd420f..ebc229eb4 100644 --- a/src/theory/datatypes/tuple_project_op.cpp +++ b/src/theory/datatypes/tuple_project_op.cpp @@ -18,7 +18,7 @@ #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& out, const TupleProjectOp& op) { @@ -53,4 +53,4 @@ bool TupleProjectOp::operator==(const TupleProjectOp& op) const return d_indices == op.d_indices; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/datatypes/tuple_project_op.h b/src/theory/datatypes/tuple_project_op.h index 361cf4f60..8272e7487 100644 --- a/src/theory/datatypes/tuple_project_op.h +++ b/src/theory/datatypes/tuple_project_op.h @@ -20,7 +20,7 @@ #include <ostream> #include <vector> -namespace CVC4 { +namespace CVC5 { class TypeNode; @@ -53,6 +53,6 @@ struct TupleProjectOpHashFunction size_t operator()(const TupleProjectOp& op) const; }; /* struct TupleProjectOpHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__PROJECT_OP_H */ diff --git a/src/theory/datatypes/type_enumerator.cpp b/src/theory/datatypes/type_enumerator.cpp index e0500e254..54b042307 100644 --- a/src/theory/datatypes/type_enumerator.cpp +++ b/src/theory/datatypes/type_enumerator.cpp @@ -19,7 +19,7 @@ #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; diff --git a/src/theory/datatypes/type_enumerator.h b/src/theory/datatypes/type_enumerator.h index 607036615..3d1264a80 100644 --- a/src/theory/datatypes/type_enumerator.h +++ b/src/theory/datatypes/type_enumerator.h @@ -25,7 +25,7 @@ #include "options/quantifiers_options.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace datatypes { @@ -162,8 +162,8 @@ class DatatypesEnumerator : public TypeEnumeratorBase<DatatypesEnumerator> { };/* DatatypesEnumerator */ -}/* CVC4::theory::datatypes namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace datatypes +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__DATATYPES__TYPE_ENUMERATOR_H */ diff --git a/src/theory/decision_manager.cpp b/src/theory/decision_manager.cpp index 4fb950ee1..3abbb83e7 100644 --- a/src/theory/decision_manager.cpp +++ b/src/theory/decision_manager.cpp @@ -17,9 +17,9 @@ #include "theory/rewriter.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { DecisionManager::DecisionManager(context::Context* userContext) @@ -107,4 +107,4 @@ Node DecisionManager::getNextDecisionRequest() } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/decision_manager.h b/src/theory/decision_manager.h index 327535f6e..c6e7a44a1 100644 --- a/src/theory/decision_manager.h +++ b/src/theory/decision_manager.h @@ -22,7 +22,7 @@ #include "context/cdlist.h" #include "theory/decision_strategy.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** DecisionManager @@ -141,6 +141,6 @@ class DecisionManager }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__DECISION_MANAGER__H */ diff --git a/src/theory/decision_strategy.cpp b/src/theory/decision_strategy.cpp index 8adc6fae1..b8ef264dd 100644 --- a/src/theory/decision_strategy.cpp +++ b/src/theory/decision_strategy.cpp @@ -17,9 +17,9 @@ #include "theory/rewriter.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { DecisionStrategyFmf::DecisionStrategyFmf(context::Context* satContext, @@ -147,4 +147,4 @@ Node DecisionStrategySingleton::mkLiteral(unsigned n) Node DecisionStrategySingleton::getSingleLiteral() { return d_literal; } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/decision_strategy.h b/src/theory/decision_strategy.h index 74edde7f9..e9d8b8bbc 100644 --- a/src/theory/decision_strategy.h +++ b/src/theory/decision_strategy.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "theory/valuation.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -140,6 +140,6 @@ class DecisionStrategySingleton : public DecisionStrategyFmf }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__DECISION_STRATEGY__H */ diff --git a/src/theory/eager_proof_generator.cpp b/src/theory/eager_proof_generator.cpp index 7bbdc91d3..1763969e6 100644 --- a/src/theory/eager_proof_generator.cpp +++ b/src/theory/eager_proof_generator.cpp @@ -18,7 +18,7 @@ #include "expr/proof_node.h" #include "expr/proof_node_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { EagerProofGenerator::EagerProofGenerator(ProofNodeManager* pnm, @@ -154,4 +154,4 @@ TrustNode EagerProofGenerator::mkTrustNodeSplit(Node f) std::string EagerProofGenerator::identify() const { return d_name; } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/eager_proof_generator.h b/src/theory/eager_proof_generator.h index 256dfeee9..2c94d2074 100644 --- a/src/theory/eager_proof_generator.h +++ b/src/theory/eager_proof_generator.h @@ -23,7 +23,7 @@ #include "expr/proof_rule.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { class ProofNode; class ProofNodeManager; @@ -193,6 +193,6 @@ class EagerProofGenerator : public ProofGenerator }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__PROOF_GENERATOR_H */ diff --git a/src/theory/ee_manager.cpp b/src/theory/ee_manager.cpp index 1f5560410..d2254fc6c 100644 --- a/src/theory/ee_manager.cpp +++ b/src/theory/ee_manager.cpp @@ -16,7 +16,7 @@ #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { EqEngineManager::EqEngineManager(TheoryEngine& te, SharedSolver& shs) @@ -47,4 +47,4 @@ eq::EqualityEngine* EqEngineManager::allocateEqualityEngine(EeSetupInfo& esi, } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/ee_manager.h b/src/theory/ee_manager.h index 4bcb92c38..dd400c188 100644 --- a/src/theory/ee_manager.h +++ b/src/theory/ee_manager.h @@ -24,7 +24,7 @@ #include "theory/theory.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { class TheoryEngine; @@ -95,6 +95,6 @@ class EqEngineManager }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__EE_MANAGER__H */ diff --git a/src/theory/ee_manager_distributed.cpp b/src/theory/ee_manager_distributed.cpp index 3757f153a..289725e30 100644 --- a/src/theory/ee_manager_distributed.cpp +++ b/src/theory/ee_manager_distributed.cpp @@ -19,7 +19,7 @@ #include "theory/theory_engine.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { EqEngineManagerDistributed::EqEngineManagerDistributed(TheoryEngine& te, @@ -115,4 +115,4 @@ void EqEngineManagerDistributed::MasterNotifyClass::eqNotifyNewClass(TNode t) } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/ee_manager_distributed.h b/src/theory/ee_manager_distributed.h index 26f3d9430..d7d6688fb 100644 --- a/src/theory/ee_manager_distributed.h +++ b/src/theory/ee_manager_distributed.h @@ -22,7 +22,7 @@ #include "theory/ee_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { @@ -97,6 +97,6 @@ class EqEngineManagerDistributed : public EqEngineManager }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__EE_MANAGER_DISTRIBUTED__H */ diff --git a/src/theory/ee_setup_info.h b/src/theory/ee_setup_info.h index 523252918..7859773f0 100644 --- a/src/theory/ee_setup_info.h +++ b/src/theory/ee_setup_info.h @@ -19,7 +19,7 @@ #include <string> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { @@ -55,6 +55,6 @@ struct EeSetupInfo }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__EE_SETUP_INFO__H */ diff --git a/src/theory/engine_output_channel.cpp b/src/theory/engine_output_channel.cpp index bfc85321e..40d1d59d5 100644 --- a/src/theory/engine_output_channel.cpp +++ b/src/theory/engine_output_channel.cpp @@ -18,9 +18,9 @@ #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) @@ -188,4 +188,4 @@ void EngineOutputChannel::trustedLemma(TrustNode plem, LemmaProperty p) } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/engine_output_channel.h b/src/theory/engine_output_channel.h index 0bdccab1b..115566bdc 100644 --- a/src/theory/engine_output_channel.h +++ b/src/theory/engine_output_channel.h @@ -22,7 +22,7 @@ #include "theory/theory_id.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { class TheoryEngine; @@ -108,6 +108,6 @@ class EngineOutputChannel : public theory::OutputChannel }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__ENGINE_OUTPUT_CHANNEL_H */ diff --git a/src/theory/evaluator.cpp b/src/theory/evaluator.cpp index 8cc203a09..758930859 100644 --- a/src/theory/evaluator.cpp +++ b/src/theory/evaluator.cpp @@ -22,7 +22,7 @@ #include "theory/theory.h" #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { EvalResult::EvalResult(const EvalResult& other) @@ -952,4 +952,4 @@ Node Evaluator::reconstruct( } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/evaluator.h b/src/theory/evaluator.h index 6db8a6f4b..ee76c6210 100644 --- a/src/theory/evaluator.h +++ b/src/theory/evaluator.h @@ -30,7 +30,7 @@ #include "util/rational.h" #include "util/string.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -159,6 +159,6 @@ class Evaluator }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__EVALUATOR_H */ diff --git a/src/theory/ext_theory.cpp b/src/theory/ext_theory.cpp index 0accc2341..2e39b2a35 100644 --- a/src/theory/ext_theory.cpp +++ b/src/theory/ext_theory.cpp @@ -27,7 +27,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { bool ExtTheoryCallback::getCurrentSubstitution( @@ -557,5 +557,5 @@ std::vector<Node> ExtTheory::getActive(Kind k) const void ExtTheory::clearCache() { d_gst_cache.clear(); } -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/ext_theory.h b/src/theory/ext_theory.h index f2235c6bf..3d8df356c 100644 --- a/src/theory/ext_theory.h +++ b/src/theory/ext_theory.h @@ -41,7 +41,7 @@ #include "context/context.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class OutputChannel; @@ -301,7 +301,7 @@ class ExtTheory 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 */ diff --git a/src/theory/fp/fp_converter.cpp b/src/theory/fp/fp_converter.cpp index 359079948..879cd2988 100644 --- a/src/theory/fp/fp_converter.cpp +++ b/src/theory/fp/fp_converter.cpp @@ -41,75 +41,75 @@ #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)); \ } \ } @@ -148,7 +148,7 @@ void probabilityAnnotation<traits, traits::prop>(const traits::prop &p, #define SYMFPU_NUMBER_OF_ROUNDING_MODES 5 #endif -namespace CVC4 { +namespace CVC5 { namespace theory { namespace fp { namespace symfpuSymbolic { @@ -412,8 +412,8 @@ symbolicBitVector<true> symbolicBitVector<true>::maxValue(const bwt &w) 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 <> @@ -428,8 +428,8 @@ symbolicBitVector<true> symbolicBitVector<true>::minValue(const bwt &w) 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 <> @@ -817,7 +817,7 @@ Node FpConverter::propToNode(const prop &p) const { 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; } @@ -1739,4 +1739,4 @@ Node FpConverter::getValue(Valuation &val, TNode var) } // namespace fp } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/fp/fp_converter.h b/src/theory/fp/fp_converter.h index 6623f308c..e952699a7 100644 --- a/src/theory/fp/fp_converter.h +++ b/src/theory/fp/fp_converter.h @@ -45,7 +45,7 @@ #include "theory/rewriter.h" #endif -namespace CVC4 { +namespace CVC5 { namespace theory { namespace fp { @@ -97,7 +97,7 @@ class traits 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 { @@ -352,6 +352,6 @@ class FpConverter } // namespace fp } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__FP__THEORY_FP_H */ diff --git a/src/theory/fp/kinds b/src/theory/fp/kinds index 49ed92dee..4a4d16b55 100644 --- a/src/theory/fp/kinds +++ b/src/theory/fp/kinds @@ -4,9 +4,9 @@ # 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 @@ -14,19 +14,19 @@ 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 @@ -39,272 +39,272 @@ sort ROUNDINGMODE_TYPE \ "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 diff --git a/src/theory/fp/theory_fp.cpp b/src/theory/fp/theory_fp.cpp index 3099d9aab..ea9ea902c 100644 --- a/src/theory/fp/theory_fp.cpp +++ b/src/theory/fp/theory_fp.cpp @@ -33,7 +33,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace fp { @@ -774,7 +774,7 @@ void TheoryFp::convertAndEquateTerm(TNode node) { 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; @@ -791,10 +791,11 @@ void TheoryFp::convertAndEquateTerm(TNode node) { #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 { @@ -1156,4 +1157,4 @@ void TheoryFp::NotifyClass::eqNotifyConstantTermMerge(TNode t1, TNode t2) { } // namespace fp } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/fp/theory_fp.h b/src/theory/fp/theory_fp.h index b15b5c2dd..2607a33c6 100644 --- a/src/theory/fp/theory_fp.h +++ b/src/theory/fp/theory_fp.h @@ -31,7 +31,7 @@ #include "theory/theory_state.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace fp { @@ -189,6 +189,6 @@ class TheoryFp : public Theory } // namespace fp } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__FP__THEORY_FP_H */ diff --git a/src/theory/fp/theory_fp_rewriter.cpp b/src/theory/fp/theory_fp_rewriter.cpp index 3e03bbdbe..65e27fc48 100644 --- a/src/theory/fp/theory_fp_rewriter.cpp +++ b/src/theory/fp/theory_fp_rewriter.cpp @@ -37,7 +37,7 @@ #include "theory/fp/fp_converter.h" #include "theory/fp/theory_fp_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace fp { @@ -324,8 +324,7 @@ namespace rewrite { return RewriteResponse(REWRITE_DONE, node); } -}; /* CVC4::theory::fp::rewrite */ - + }; // namespace rewrite namespace constantFold { @@ -978,8 +977,7 @@ namespace constantFold { NodeManager::currentNM()->mkConst(value)); } -}; /* CVC4::theory::fp::constantFold */ - + }; // namespace constantFold /** * Initialize the rewriter. @@ -1421,8 +1419,6 @@ TheoryFpRewriter::TheoryFpRewriter() return res; } - -}/* CVC4::theory::fp namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ - + } // namespace fp + } // namespace theory + } // namespace CVC5 diff --git a/src/theory/fp/theory_fp_rewriter.h b/src/theory/fp/theory_fp_rewriter.h index 5591246b4..bfdf90d44 100644 --- a/src/theory/fp/theory_fp_rewriter.h +++ b/src/theory/fp/theory_fp_rewriter.h @@ -22,7 +22,7 @@ #include "theory/theory_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace fp { @@ -51,8 +51,8 @@ class TheoryFpRewriter : public TheoryRewriter 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 */ diff --git a/src/theory/fp/theory_fp_type_rules.cpp b/src/theory/fp/theory_fp_type_rules.cpp index 165c9b924..6b87f8af3 100644 --- a/src/theory/fp/theory_fp_type_rules.cpp +++ b/src/theory/fp/theory_fp_type_rules.cpp @@ -18,7 +18,7 @@ #include "theory/theory.h" #include "util/roundingmode.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace fp { @@ -812,4 +812,4 @@ Cardinality CardinalityComputer::computeCardinality(TypeNode type) } // namespace fp } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/fp/theory_fp_type_rules.h b/src/theory/fp/theory_fp_type_rules.h index aef2d0a50..632ae660d 100644 --- a/src/theory/fp/theory_fp_type_rules.h +++ b/src/theory/fp/theory_fp_type_rules.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { class NodeManager; @@ -229,6 +229,6 @@ class CardinalityComputer } // namespace fp } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/fp/type_enumerator.h b/src/theory/fp/type_enumerator.h index 01145472d..535ed7c69 100644 --- a/src/theory/fp/type_enumerator.h +++ b/src/theory/fp/type_enumerator.h @@ -26,7 +26,7 @@ #include "util/bitvector.h" #include "util/floatingpoint.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace fp { @@ -120,6 +120,6 @@ class RoundingModeEnumerator } // namespace fp } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__FP__TYPE_ENUMERATOR_H */ diff --git a/src/theory/inference_id.cpp b/src/theory/inference_id.cpp index 50ede2726..f96a9e244 100644 --- a/src/theory/inference_id.cpp +++ b/src/theory/inference_id.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC4 { +namespace CVC5 { namespace theory { const char* toString(InferenceId i) @@ -357,4 +357,4 @@ std::ostream& operator<<(std::ostream& out, InferenceId i) } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/inference_id.h b/src/theory/inference_id.h index 1b57e966f..aa34d45ae 100644 --- a/src/theory/inference_id.h +++ b/src/theory/inference_id.h @@ -19,7 +19,7 @@ #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 @@ -752,6 +752,6 @@ const char* toString(InferenceId i); std::ostream& operator<<(std::ostream& out, InferenceId i); } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__INFERENCE_H */ diff --git a/src/theory/inference_manager_buffered.cpp b/src/theory/inference_manager_buffered.cpp index edd8d8446..26434f802 100644 --- a/src/theory/inference_manager_buffered.cpp +++ b/src/theory/inference_manager_buffered.cpp @@ -18,9 +18,9 @@ #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, @@ -187,4 +187,4 @@ void InferenceManagerBuffered::assertInternalFactTheoryInference( } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/inference_manager_buffered.h b/src/theory/inference_manager_buffered.h index 2772385d2..77ed1329a 100644 --- a/src/theory/inference_manager_buffered.h +++ b/src/theory/inference_manager_buffered.h @@ -21,7 +21,7 @@ #include "theory/theory_inference.h" #include "theory/theory_inference_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -174,6 +174,6 @@ class InferenceManagerBuffered : public TheoryInferenceManager }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/interrupted.h b/src/theory/interrupted.h index 76dc36e79..75c8f93a5 100644 --- a/src/theory/interrupted.h +++ b/src/theory/interrupted.h @@ -15,7 +15,7 @@ ** 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;" @@ -31,13 +31,14 @@ #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 */ diff --git a/src/theory/lazy_tree_proof_generator.cpp b/src/theory/lazy_tree_proof_generator.cpp index 3ea567979..0a466fec4 100644 --- a/src/theory/lazy_tree_proof_generator.cpp +++ b/src/theory/lazy_tree_proof_generator.cpp @@ -21,7 +21,7 @@ #include "expr/proof_node.h" #include "expr/proof_node_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { LazyTreeProofGenerator::LazyTreeProofGenerator(ProofNodeManager* pnm, @@ -142,4 +142,4 @@ std::ostream& operator<<(std::ostream& os, const LazyTreeProofGenerator& ltpg) } } // namespace theory -} // namespace CVC4
\ No newline at end of file +} // namespace CVC5
\ No newline at end of file diff --git a/src/theory/lazy_tree_proof_generator.h b/src/theory/lazy_tree_proof_generator.h index 7e97b1cc5..3c02380c1 100644 --- a/src/theory/lazy_tree_proof_generator.h +++ b/src/theory/lazy_tree_proof_generator.h @@ -23,7 +23,7 @@ #include "expr/proof_generator.h" #include "expr/proof_node_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace detail { /** @@ -217,6 +217,6 @@ class LazyTreeProofGenerator : public ProofGenerator std::ostream& operator<<(std::ostream& os, const LazyTreeProofGenerator& ltpg); } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/logic_info.cpp b/src/theory/logic_info.cpp index 7f55b4d88..841ec097e 100644 --- a/src/theory/logic_info.cpp +++ b/src/theory/logic_info.cpp @@ -27,9 +27,9 @@ #include "expr/kind.h" using namespace std; -using namespace CVC4::theory; +using namespace CVC5::theory; -namespace CVC4 { +namespace CVC5 { LogicInfo::LogicInfo() : d_logicString(""), @@ -725,4 +725,4 @@ std::ostream& operator<<(std::ostream& out, const LogicInfo& logic) { return out << logic.getLogicString(); } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/theory/logic_info.h b/src/theory/logic_info.h index 72913a0c2..fb23f4f2d 100644 --- a/src/theory/logic_info.h +++ b/src/theory/logic_info.h @@ -27,7 +27,7 @@ #include "cvc4_export.h" #include "theory/theory_id.h" -namespace CVC4 { +namespace CVC5 { /** * A LogicInfo instance describes a collection of theory modules and some @@ -291,6 +291,6 @@ public: std::ostream& operator<<(std::ostream& out, const LogicInfo& logic); -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__LOGIC_INFO_H */ diff --git a/src/theory/mkrewriter b/src/theory/mkrewriter index 871927760..9fa3c64c8 100755 --- a/src/theory/mkrewriter +++ b/src/theory/mkrewriter @@ -73,9 +73,9 @@ function theory { 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" diff --git a/src/theory/mktheorytraits b/src/theory/mktheorytraits index 1b1350abe..81e551a10 100755 --- a/src/theory/mktheorytraits +++ b/src/theory/mktheorytraits @@ -92,9 +92,9 @@ function theory { 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" diff --git a/src/theory/model_manager.cpp b/src/theory/model_manager.cpp index d77a88d67..8ca7a2c48 100644 --- a/src/theory/model_manager.cpp +++ b/src/theory/model_manager.cpp @@ -22,7 +22,7 @@ #include "theory/quantifiers/fmf/model_builder.h" #include "theory/theory_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { ModelManager::ModelManager(TheoryEngine& te, EqEngineManager& eem) @@ -239,4 +239,4 @@ void ModelManager::collectTerms(TheoryId tid, } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/model_manager.h b/src/theory/model_manager.h index 1e4c39066..4f4d06a43 100644 --- a/src/theory/model_manager.h +++ b/src/theory/model_manager.h @@ -22,7 +22,7 @@ #include "theory/ee_manager.h" #include "theory/logic_info.h" -namespace CVC4 { +namespace CVC5 { class TheoryEngine; @@ -152,6 +152,6 @@ class ModelManager }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__MODEL_MANAGER__H */ diff --git a/src/theory/model_manager_distributed.cpp b/src/theory/model_manager_distributed.cpp index 838cf0ad6..3b9c1aad4 100644 --- a/src/theory/model_manager_distributed.cpp +++ b/src/theory/model_manager_distributed.cpp @@ -18,7 +18,7 @@ #include "theory/theory_model.h" #include "theory/theory_model_builder.h" -namespace CVC4 { +namespace CVC5 { namespace theory { ModelManagerDistributed::ModelManagerDistributed(TheoryEngine& te, @@ -114,4 +114,4 @@ bool ModelManagerDistributed::finishBuildModel() const } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/model_manager_distributed.h b/src/theory/model_manager_distributed.h index d41b6fa3b..dd7cf2b78 100644 --- a/src/theory/model_manager_distributed.h +++ b/src/theory/model_manager_distributed.h @@ -20,7 +20,7 @@ #include "theory/ee_manager.h" #include "theory/model_manager.h" -namespace CVC4 { +namespace CVC5 { class TheoryEngine; @@ -56,6 +56,6 @@ class ModelManagerDistributed : public ModelManager }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__MODEL_MANAGER_DISTRIBUTED__H */ diff --git a/src/theory/output_channel.cpp b/src/theory/output_channel.cpp index 35b55ecc5..0fd475563 100644 --- a/src/theory/output_channel.cpp +++ b/src/theory/output_channel.cpp @@ -14,7 +14,7 @@ #include "theory/output_channel.h" -namespace CVC4 { +namespace CVC5 { namespace theory { LemmaProperty operator|(LemmaProperty lhs, LemmaProperty rhs) @@ -91,4 +91,4 @@ void OutputChannel::trustedLemma(TrustNode lem, LemmaProperty p) } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/output_channel.h b/src/theory/output_channel.h index 8c10a1348..16fc5a483 100644 --- a/src/theory/output_channel.h +++ b/src/theory/output_channel.h @@ -22,7 +22,7 @@ #include "theory/trust_node.h" #include "util/resource_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** Properties of lemmas */ @@ -66,7 +66,7 @@ class Theory; /** * 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 { @@ -199,6 +199,6 @@ class OutputChannel { }; /* class OutputChannel */ } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__OUTPUT_CHANNEL_H */ diff --git a/src/theory/quantifiers/alpha_equivalence.cpp b/src/theory/quantifiers/alpha_equivalence.cpp index ac52338a9..eb977960b 100644 --- a/src/theory/quantifiers/alpha_equivalence.cpp +++ b/src/theory/quantifiers/alpha_equivalence.cpp @@ -15,9 +15,9 @@ #include "theory/quantifiers/alpha_equivalence.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -110,4 +110,4 @@ Node AlphaEquivalence::reduceQuantifier(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/alpha_equivalence.h b/src/theory/quantifiers/alpha_equivalence.h index 48d667325..822b674e2 100644 --- a/src/theory/quantifiers/alpha_equivalence.h +++ b/src/theory/quantifiers/alpha_equivalence.h @@ -21,7 +21,7 @@ #include "expr/term_canonize.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -101,6 +101,6 @@ class AlphaEquivalence } } -} +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/bv_inverter.cpp b/src/theory/quantifiers/bv_inverter.cpp index d81e23056..c4bd2c083 100644 --- a/src/theory/quantifiers/bv_inverter.cpp +++ b/src/theory/quantifiers/bv_inverter.cpp @@ -22,9 +22,9 @@ #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 { @@ -442,4 +442,4 @@ Node BvInverter::solveBvLit(Node sv, } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/bv_inverter.h b/src/theory/quantifiers/bv_inverter.h index fa7d4b073..c033b26d7 100644 --- a/src/theory/quantifiers/bv_inverter.h +++ b/src/theory/quantifiers/bv_inverter.h @@ -24,7 +24,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -128,6 +128,6 @@ class BvInverter } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__BV_INVERTER_H */ diff --git a/src/theory/quantifiers/bv_inverter_utils.cpp b/src/theory/quantifiers/bv_inverter_utils.cpp index f951b29df..459c3f93f 100644 --- a/src/theory/quantifiers/bv_inverter_utils.cpp +++ b/src/theory/quantifiers/bv_inverter_utils.cpp @@ -15,9 +15,9 @@ #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 { @@ -2589,4 +2589,4 @@ Node getICBvSext(bool pol, Kind litk, unsigned idx, Node x, Node sv_t, Node t) } // namespace utils } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/bv_inverter_utils.h b/src/theory/quantifiers/bv_inverter_utils.h index af7343739..c6400bd60 100644 --- a/src/theory/quantifiers/bv_inverter_utils.h +++ b/src/theory/quantifiers/bv_inverter_utils.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace utils { @@ -68,5 +68,5 @@ Node getICBvSext(bool pol, Kind litk, unsigned idx, Node x, Node sv_t, Node t); } // namespace utils } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/candidate_rewrite_database.cpp b/src/theory/quantifiers/candidate_rewrite_database.cpp index a0b9b20f4..1319e5c38 100644 --- a/src/theory/quantifiers/candidate_rewrite_database.cpp +++ b/src/theory/quantifiers/candidate_rewrite_database.cpp @@ -24,10 +24,10 @@ #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 { @@ -294,6 +294,6 @@ void CandidateRewriteDatabase::setExtendedRewriter(ExtendedRewriter* er) d_ext_rewrite = er; } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/candidate_rewrite_database.h b/src/theory/quantifiers/candidate_rewrite_database.h index 321880dc0..396ef0d03 100644 --- a/src/theory/quantifiers/candidate_rewrite_database.h +++ b/src/theory/quantifiers/candidate_rewrite_database.h @@ -23,7 +23,7 @@ #include "theory/quantifiers/expr_miner.h" #include "theory/quantifiers/sygus_sampler.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -126,8 +126,8 @@ class CandidateRewriteDatabase : public ExprMiner 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 */ diff --git a/src/theory/quantifiers/candidate_rewrite_filter.cpp b/src/theory/quantifiers/candidate_rewrite_filter.cpp index aca65fd83..0ab85ccf7 100644 --- a/src/theory/quantifiers/candidate_rewrite_filter.cpp +++ b/src/theory/quantifiers/candidate_rewrite_filter.cpp @@ -20,9 +20,9 @@ #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 { @@ -277,4 +277,4 @@ bool CandidateRewriteFilter::notify(Node s, } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/candidate_rewrite_filter.h b/src/theory/quantifiers/candidate_rewrite_filter.h index 6df804dff..faf675bcb 100644 --- a/src/theory/quantifiers/candidate_rewrite_filter.h +++ b/src/theory/quantifiers/candidate_rewrite_filter.h @@ -25,7 +25,7 @@ #include "theory/quantifiers/sygus/term_database_sygus.h" #include "theory/quantifiers/sygus_sampler.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -171,6 +171,6 @@ class CandidateRewriteFilter } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__CANDIDATE_REWRITE_FILTER_H */ diff --git a/src/theory/quantifiers/cegqi/ceg_arith_instantiator.cpp b/src/theory/quantifiers/cegqi/ceg_arith_instantiator.cpp index b0a5688b2..29881a3a4 100644 --- a/src/theory/quantifiers/cegqi/ceg_arith_instantiator.cpp +++ b/src/theory/quantifiers/cegqi/ceg_arith_instantiator.cpp @@ -25,10 +25,10 @@ #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 { @@ -1036,4 +1036,4 @@ Node ArithInstantiator::getModelBasedProjectionValue(CegInstantiator* ci, } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/cegqi/ceg_arith_instantiator.h b/src/theory/quantifiers/cegqi/ceg_arith_instantiator.h index 00b23307e..e6cfa31c6 100644 --- a/src/theory/quantifiers/cegqi/ceg_arith_instantiator.h +++ b/src/theory/quantifiers/cegqi/ceg_arith_instantiator.h @@ -22,7 +22,7 @@ #include "theory/quantifiers/cegqi/ceg_instantiator.h" #include "theory/quantifiers/cegqi/vts_term_cache.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -209,6 +209,6 @@ class ArithInstantiator : public Instantiator } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__CEG_ARITH_INSTANTIATOR_H */ diff --git a/src/theory/quantifiers/cegqi/ceg_bv_instantiator.cpp b/src/theory/quantifiers/cegqi/ceg_bv_instantiator.cpp index 1c60058ff..2c163421e 100644 --- a/src/theory/quantifiers/cegqi/ceg_bv_instantiator.cpp +++ b/src/theory/quantifiers/cegqi/ceg_bv_instantiator.cpp @@ -23,9 +23,9 @@ #include "util/random.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -759,4 +759,4 @@ void BvInstantiatorPreprocess::collectExtracts( } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/cegqi/ceg_bv_instantiator.h b/src/theory/quantifiers/cegqi/ceg_bv_instantiator.h index 743a27af3..4bfda133e 100644 --- a/src/theory/quantifiers/cegqi/ceg_bv_instantiator.h +++ b/src/theory/quantifiers/cegqi/ceg_bv_instantiator.h @@ -21,7 +21,7 @@ #include "theory/quantifiers/bv_inverter.h" #include "theory/quantifiers/cegqi/ceg_instantiator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -209,6 +209,6 @@ class BvInstantiatorPreprocess : public InstantiatorPreprocess } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__CEG_BV_INSTANTIATOR_H */ diff --git a/src/theory/quantifiers/cegqi/ceg_bv_instantiator_utils.cpp b/src/theory/quantifiers/cegqi/ceg_bv_instantiator_utils.cpp index c0ef3561f..85faea4b1 100644 --- a/src/theory/quantifiers/cegqi/ceg_bv_instantiator_utils.cpp +++ b/src/theory/quantifiers/cegqi/ceg_bv_instantiator_utils.cpp @@ -17,9 +17,9 @@ #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 { @@ -342,4 +342,4 @@ Node normalizePvEqual( } // namespace utils } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/cegqi/ceg_bv_instantiator_utils.h b/src/theory/quantifiers/cegqi/ceg_bv_instantiator_utils.h index 13b86cff4..576d68d06 100644 --- a/src/theory/quantifiers/cegqi/ceg_bv_instantiator_utils.h +++ b/src/theory/quantifiers/cegqi/ceg_bv_instantiator_utils.h @@ -20,7 +20,7 @@ #include "expr/attribute.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -104,5 +104,5 @@ Node normalizePvEqual( } // namespace utils } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/cegqi/ceg_dt_instantiator.cpp b/src/theory/quantifiers/cegqi/ceg_dt_instantiator.cpp index c9bc63308..bb81d2790 100644 --- a/src/theory/quantifiers/cegqi/ceg_dt_instantiator.cpp +++ b/src/theory/quantifiers/cegqi/ceg_dt_instantiator.cpp @@ -20,9 +20,9 @@ #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 { @@ -180,4 +180,4 @@ Node DtInstantiator::solve_dt(Node v, Node a, Node b, Node sa, Node sb) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/cegqi/ceg_dt_instantiator.h b/src/theory/quantifiers/cegqi/ceg_dt_instantiator.h index 97cb7a4ee..c0386465d 100644 --- a/src/theory/quantifiers/cegqi/ceg_dt_instantiator.h +++ b/src/theory/quantifiers/cegqi/ceg_dt_instantiator.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "theory/quantifiers/cegqi/ceg_instantiator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -91,6 +91,6 @@ class DtInstantiator : public Instantiator } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__CEG_DT_INSTANTIATOR_H */ diff --git a/src/theory/quantifiers/cegqi/ceg_instantiator.cpp b/src/theory/quantifiers/cegqi/ceg_instantiator.cpp index 5c6a932fd..118c505fc 100644 --- a/src/theory/quantifiers/cegqi/ceg_instantiator.cpp +++ b/src/theory/quantifiers/cegqi/ceg_instantiator.cpp @@ -32,9 +32,9 @@ #include "theory/rewriter.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -1636,6 +1636,6 @@ bool Instantiator::processEqualTerm(CegInstantiator* ci, return ci->constructInstantiationInc(pv, n, pv_prop, sf); } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/cegqi/ceg_instantiator.h b/src/theory/quantifiers/cegqi/ceg_instantiator.h index 800398fb9..03161399c 100644 --- a/src/theory/quantifiers/cegqi/ceg_instantiator.h +++ b/src/theory/quantifiers/cegqi/ceg_instantiator.h @@ -23,7 +23,7 @@ #include "theory/inference_id.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -820,8 +820,8 @@ class InstantiatorPreprocess } }; -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/cegqi/inst_strategy_cegqi.cpp b/src/theory/quantifiers/cegqi/inst_strategy_cegqi.cpp index 59b4cc7bd..d6a504713 100644 --- a/src/theory/quantifiers/cegqi/inst_strategy_cegqi.cpp +++ b/src/theory/quantifiers/cegqi/inst_strategy_cegqi.cpp @@ -26,10 +26,10 @@ #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 { @@ -546,4 +546,4 @@ bool InstStrategyCegqi::processNestedQe(Node q, bool isPreregister) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/cegqi/inst_strategy_cegqi.h b/src/theory/quantifiers/cegqi/inst_strategy_cegqi.h index e0496a462..a5b79fb00 100644 --- a/src/theory/quantifiers/cegqi/inst_strategy_cegqi.h +++ b/src/theory/quantifiers/cegqi/inst_strategy_cegqi.h @@ -26,7 +26,7 @@ #include "theory/quantifiers/quant_module.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -215,6 +215,6 @@ class InstStrategyCegqi : public QuantifiersModule } } -} +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/cegqi/nested_qe.cpp b/src/theory/quantifiers/cegqi/nested_qe.cpp index 0e938ddae..9efc0ec31 100644 --- a/src/theory/quantifiers/cegqi/nested_qe.cpp +++ b/src/theory/quantifiers/cegqi/nested_qe.cpp @@ -19,7 +19,7 @@ #include "expr/subs.h" #include "theory/smt_engine_subsolver.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -152,4 +152,4 @@ Node NestedQe::doQe(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/cegqi/nested_qe.h b/src/theory/quantifiers/cegqi/nested_qe.h index 21a49424a..29df5d16b 100644 --- a/src/theory/quantifiers/cegqi/nested_qe.h +++ b/src/theory/quantifiers/cegqi/nested_qe.h @@ -23,7 +23,7 @@ #include "context/cdhashmap.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -81,6 +81,6 @@ class NestedQe } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/cegqi/vts_term_cache.cpp b/src/theory/quantifiers/cegqi/vts_term_cache.cpp index 912fee2fd..1a7431038 100644 --- a/src/theory/quantifiers/cegqi/vts_term_cache.cpp +++ b/src/theory/quantifiers/cegqi/vts_term_cache.cpp @@ -19,9 +19,9 @@ #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 { @@ -296,4 +296,4 @@ bool VtsTermCache::containsVtsInfinity(Node n, bool isFree) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/cegqi/vts_term_cache.h b/src/theory/quantifiers/cegqi/vts_term_cache.h index 4f18933ec..53c198213 100644 --- a/src/theory/quantifiers/cegqi/vts_term_cache.h +++ b/src/theory/quantifiers/cegqi/vts_term_cache.h @@ -21,7 +21,7 @@ #include "expr/attribute.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** Attribute to mark Skolems as virtual terms */ @@ -140,6 +140,6 @@ class VtsTermCache } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__CEGQI__VTS_TERM_CACHE_H */ diff --git a/src/theory/quantifiers/conjecture_generator.cpp b/src/theory/quantifiers/conjecture_generator.cpp index c095e3864..ffe06a7ad 100644 --- a/src/theory/quantifiers/conjecture_generator.cpp +++ b/src/theory/quantifiers/conjecture_generator.cpp @@ -26,13 +26,13 @@ #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; @@ -2260,4 +2260,4 @@ unsigned ConjectureGenerator::optFullCheckFrequency() { return 1; } bool ConjectureGenerator::optStatsOnly() { return false; } -} +} // namespace CVC5 diff --git a/src/theory/quantifiers/conjecture_generator.h b/src/theory/quantifiers/conjecture_generator.h index b1a1ddf2b..cc3314f82 100644 --- a/src/theory/quantifiers/conjecture_generator.h +++ b/src/theory/quantifiers/conjecture_generator.h @@ -23,7 +23,7 @@ #include "theory/quantifiers/quant_module.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -466,6 +466,6 @@ private: //information about ground equivalence classes } } -} +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/dynamic_rewrite.cpp b/src/theory/quantifiers/dynamic_rewrite.cpp index cf3f5fa2f..6e7601072 100644 --- a/src/theory/quantifiers/dynamic_rewrite.cpp +++ b/src/theory/quantifiers/dynamic_rewrite.cpp @@ -17,9 +17,9 @@ #include "theory/rewriter.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -181,6 +181,6 @@ Node DynamicRewriter::OpInternalSymTrie::getSymbol(Node n) return f; } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/dynamic_rewrite.h b/src/theory/quantifiers/dynamic_rewrite.h index e4abdbe76..79b4824b4 100644 --- a/src/theory/quantifiers/dynamic_rewrite.h +++ b/src/theory/quantifiers/dynamic_rewrite.h @@ -22,7 +22,7 @@ #include "context/cdlist.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -117,8 +117,8 @@ class DynamicRewriter 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 */ diff --git a/src/theory/quantifiers/ematching/candidate_generator.cpp b/src/theory/quantifiers/ematching/candidate_generator.cpp index 60350f882..4c9da3632 100644 --- a/src/theory/quantifiers/ematching/candidate_generator.cpp +++ b/src/theory/quantifiers/ematching/candidate_generator.cpp @@ -24,9 +24,9 @@ #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 { @@ -348,4 +348,4 @@ Node CandidateGeneratorSelector::getNextCandidate() } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/candidate_generator.h b/src/theory/quantifiers/ematching/candidate_generator.h index 45eec1d4c..b21a96225 100644 --- a/src/theory/quantifiers/ematching/candidate_generator.h +++ b/src/theory/quantifiers/ematching/candidate_generator.h @@ -20,7 +20,7 @@ #include "theory/theory.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -240,9 +240,9 @@ class CandidateGeneratorSelector : public CandidateGeneratorQE 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 */ diff --git a/src/theory/quantifiers/ematching/ho_trigger.cpp b/src/theory/quantifiers/ematching/ho_trigger.cpp index a267246a8..14f514b73 100644 --- a/src/theory/quantifiers/ematching/ho_trigger.cpp +++ b/src/theory/quantifiers/ematching/ho_trigger.cpp @@ -25,9 +25,9 @@ #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 { @@ -526,4 +526,4 @@ uint64_t HigherOrderTrigger::addHoTypeMatchPredicateLemmas() } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/ho_trigger.h b/src/theory/quantifiers/ematching/ho_trigger.h index d3489783c..66b374ea8 100644 --- a/src/theory/quantifiers/ematching/ho_trigger.h +++ b/src/theory/quantifiers/ematching/ho_trigger.h @@ -25,7 +25,7 @@ #include "theory/quantifiers/inst_match.h" #include "theory/quantifiers/ematching/trigger.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -275,6 +275,6 @@ class HigherOrderTrigger : public Trigger } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__HO_TRIGGER_H */ diff --git a/src/theory/quantifiers/ematching/im_generator.cpp b/src/theory/quantifiers/ematching/im_generator.cpp index 06d17dea4..2f415779a 100644 --- a/src/theory/quantifiers/ematching/im_generator.cpp +++ b/src/theory/quantifiers/ematching/im_generator.cpp @@ -16,9 +16,9 @@ #include "theory/quantifiers/ematching/trigger.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -36,4 +36,4 @@ bool IMGenerator::sendInstantiation(InstMatch& m, InferenceId id) } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/im_generator.h b/src/theory/quantifiers/ematching/im_generator.h index b277ec180..b0d937120 100644 --- a/src/theory/quantifiers/ematching/im_generator.h +++ b/src/theory/quantifiers/ematching/im_generator.h @@ -22,7 +22,7 @@ #include "theory/inference_id.h" #include "theory/quantifiers/inst_match.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -117,6 +117,6 @@ protected: } // namespace inst } } -} +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/ematching/inst_match_generator.cpp b/src/theory/quantifiers/ematching/inst_match_generator.cpp index 04b8a3fcf..79b6927f7 100644 --- a/src/theory/quantifiers/ematching/inst_match_generator.cpp +++ b/src/theory/quantifiers/ematching/inst_match_generator.cpp @@ -29,9 +29,9 @@ #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 { @@ -673,4 +673,4 @@ InstMatchGenerator* InstMatchGenerator::getInstMatchGenerator(Trigger* tparent, } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/inst_match_generator.h b/src/theory/quantifiers/ematching/inst_match_generator.h index 375fe73e1..32d6e38f1 100644 --- a/src/theory/quantifiers/ematching/inst_match_generator.h +++ b/src/theory/quantifiers/ematching/inst_match_generator.h @@ -22,7 +22,7 @@ #include "theory/quantifiers/inst_match.h" #include "theory/quantifiers/ematching/im_generator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -325,6 +325,6 @@ class InstMatchGenerator : public IMGenerator { } // namespace inst } } -} +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/ematching/inst_match_generator_multi.cpp b/src/theory/quantifiers/ematching/inst_match_generator_multi.cpp index fe0fa8082..6ac910e2e 100644 --- a/src/theory/quantifiers/ematching/inst_match_generator_multi.cpp +++ b/src/theory/quantifiers/ematching/inst_match_generator_multi.cpp @@ -18,9 +18,9 @@ #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 { @@ -315,4 +315,4 @@ void InstMatchGeneratorMulti::processNewInstantiations(InstMatch& m, } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/inst_match_generator_multi.h b/src/theory/quantifiers/ematching/inst_match_generator_multi.h index 1e25baea4..644a47bee 100644 --- a/src/theory/quantifiers/ematching/inst_match_generator_multi.h +++ b/src/theory/quantifiers/ematching/inst_match_generator_multi.h @@ -23,7 +23,7 @@ #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 { @@ -103,6 +103,6 @@ class InstMatchGeneratorMulti : public IMGenerator } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/ematching/inst_match_generator_multi_linear.cpp b/src/theory/quantifiers/ematching/inst_match_generator_multi_linear.cpp index 18708092a..94b7921ed 100644 --- a/src/theory/quantifiers/ematching/inst_match_generator_multi_linear.cpp +++ b/src/theory/quantifiers/ematching/inst_match_generator_multi_linear.cpp @@ -17,9 +17,9 @@ #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 { @@ -175,4 +175,4 @@ int InstMatchGeneratorMultiLinear::getNextMatch(Node q, InstMatch& m) } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/inst_match_generator_multi_linear.h b/src/theory/quantifiers/ematching/inst_match_generator_multi_linear.h index b46960400..00a372c8f 100644 --- a/src/theory/quantifiers/ematching/inst_match_generator_multi_linear.h +++ b/src/theory/quantifiers/ematching/inst_match_generator_multi_linear.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "theory/quantifiers/ematching/inst_match_generator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -85,6 +85,6 @@ class InstMatchGeneratorMultiLinear : public InstMatchGenerator } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/ematching/inst_match_generator_simple.cpp b/src/theory/quantifiers/ematching/inst_match_generator_simple.cpp index ab30b4b2d..7d7b3e1c0 100644 --- a/src/theory/quantifiers/ematching/inst_match_generator_simple.cpp +++ b/src/theory/quantifiers/ematching/inst_match_generator_simple.cpp @@ -21,9 +21,9 @@ #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 { @@ -198,4 +198,4 @@ int InstMatchGeneratorSimple::getActiveScore() } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/inst_match_generator_simple.h b/src/theory/quantifiers/ematching/inst_match_generator_simple.h index 6ae2f915b..8361628da 100644 --- a/src/theory/quantifiers/ematching/inst_match_generator_simple.h +++ b/src/theory/quantifiers/ematching/inst_match_generator_simple.h @@ -23,7 +23,7 @@ #include "expr/node_trie.h" #include "theory/quantifiers/ematching/inst_match_generator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -100,6 +100,6 @@ class InstMatchGeneratorSimple : public IMGenerator } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/ematching/inst_strategy.cpp b/src/theory/quantifiers/ematching/inst_strategy.cpp index 5e9899ec3..a56e7efeb 100644 --- a/src/theory/quantifiers/ematching/inst_strategy.cpp +++ b/src/theory/quantifiers/ematching/inst_strategy.cpp @@ -16,7 +16,7 @@ #include "theory/quantifiers/quantifiers_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -44,4 +44,4 @@ options::UserPatMode InstStrategy::getInstUserPatMode() const } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/inst_strategy.h b/src/theory/quantifiers/ematching/inst_strategy.h index 9d304368c..0537d92ce 100644 --- a/src/theory/quantifiers/ematching/inst_strategy.h +++ b/src/theory/quantifiers/ematching/inst_strategy.h @@ -22,7 +22,7 @@ #include "options/quantifiers_options.h" #include "theory/theory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -85,6 +85,6 @@ class InstStrategy } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__INSTANTIATION_ENGINE_H */ diff --git a/src/theory/quantifiers/ematching/inst_strategy_e_matching.cpp b/src/theory/quantifiers/ematching/inst_strategy_e_matching.cpp index 45d5f13a7..c62a034e4 100644 --- a/src/theory/quantifiers/ematching/inst_strategy_e_matching.cpp +++ b/src/theory/quantifiers/ematching/inst_strategy_e_matching.cpp @@ -22,10 +22,10 @@ #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 { @@ -686,6 +686,6 @@ void InstStrategyAutoGenTriggers::addUserNoPattern( Node q, Node pat ) { } } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/inst_strategy_e_matching.h b/src/theory/quantifiers/ematching/inst_strategy_e_matching.h index a17e7bbb5..bc52d605c 100644 --- a/src/theory/quantifiers/ematching/inst_strategy_e_matching.h +++ b/src/theory/quantifiers/ematching/inst_strategy_e_matching.h @@ -21,7 +21,7 @@ #include "theory/quantifiers/ematching/trigger.h" #include "theory/quantifiers/quant_relevance.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -111,7 +111,7 @@ class InstStrategyAutoGenTriggers : public InstStrategy QuantRelevance* d_quant_rel; }; /* class InstStrategyAutoGenTriggers */ } -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/ematching/inst_strategy_e_matching_user.cpp b/src/theory/quantifiers/ematching/inst_strategy_e_matching_user.cpp index a15baa5e4..4b0d619bc 100644 --- a/src/theory/quantifiers/ematching/inst_strategy_e_matching_user.cpp +++ b/src/theory/quantifiers/ematching/inst_strategy_e_matching_user.cpp @@ -18,10 +18,10 @@ #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 { @@ -175,4 +175,4 @@ void InstStrategyUserPatterns::addUserPattern(Node q, Node pat) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/inst_strategy_e_matching_user.h b/src/theory/quantifiers/ematching/inst_strategy_e_matching_user.h index 821d7de77..1bb50af7b 100644 --- a/src/theory/quantifiers/ematching/inst_strategy_e_matching_user.h +++ b/src/theory/quantifiers/ematching/inst_strategy_e_matching_user.h @@ -23,7 +23,7 @@ #include "theory/quantifiers/ematching/inst_strategy.h" #include "theory/quantifiers/ematching/trigger.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -64,6 +64,6 @@ class InstStrategyUserPatterns : public InstStrategy } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/ematching/instantiation_engine.cpp b/src/theory/quantifiers/ematching/instantiation_engine.cpp index 52bf58263..94054b8f9 100644 --- a/src/theory/quantifiers/ematching/instantiation_engine.cpp +++ b/src/theory/quantifiers/ematching/instantiation_engine.cpp @@ -23,11 +23,11 @@ #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 { @@ -272,4 +272,4 @@ bool InstantiationEngine::shouldProcess(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/instantiation_engine.h b/src/theory/quantifiers/ematching/instantiation_engine.h index c5a82d114..8dface27e 100644 --- a/src/theory/quantifiers/ematching/instantiation_engine.h +++ b/src/theory/quantifiers/ematching/instantiation_engine.h @@ -24,7 +24,7 @@ #include "theory/quantifiers/quant_module.h" #include "theory/quantifiers/quant_relevance.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -73,8 +73,8 @@ class InstantiationEngine : public QuantifiersModule { 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 */ diff --git a/src/theory/quantifiers/ematching/pattern_term_selector.cpp b/src/theory/quantifiers/ematching/pattern_term_selector.cpp index 7ab54fcfe..467ed46be 100644 --- a/src/theory/quantifiers/ematching/pattern_term_selector.cpp +++ b/src/theory/quantifiers/ematching/pattern_term_selector.cpp @@ -20,9 +20,9 @@ #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 { @@ -729,4 +729,4 @@ void PatternTermSelector::getTriggerVariables(Node n, } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/pattern_term_selector.h b/src/theory/quantifiers/ematching/pattern_term_selector.h index 9cbf4cf5e..6f26f2cec 100644 --- a/src/theory/quantifiers/ematching/pattern_term_selector.h +++ b/src/theory/quantifiers/ematching/pattern_term_selector.h @@ -23,7 +23,7 @@ #include "options/quantifiers_options.h" #include "theory/quantifiers/ematching/trigger_term_info.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -192,6 +192,6 @@ class PatternTermSelector } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/ematching/trigger.cpp b/src/theory/quantifiers/ematching/trigger.cpp index c739623bc..234940b54 100644 --- a/src/theory/quantifiers/ematching/trigger.cpp +++ b/src/theory/quantifiers/ematching/trigger.cpp @@ -32,9 +32,9 @@ #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 { @@ -229,4 +229,4 @@ void Trigger::debugPrint(const char* c) const } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/trigger.h b/src/theory/quantifiers/ematching/trigger.h index 5dd8db452..c6d3b3cd5 100644 --- a/src/theory/quantifiers/ematching/trigger.h +++ b/src/theory/quantifiers/ematching/trigger.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "theory/inference_id.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class QuantifiersEngine; @@ -219,6 +219,6 @@ class Trigger { } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__TRIGGER_H */ diff --git a/src/theory/quantifiers/ematching/trigger_database.cpp b/src/theory/quantifiers/ematching/trigger_database.cpp index fae7a10a0..327d2bba1 100644 --- a/src/theory/quantifiers/ematching/trigger_database.cpp +++ b/src/theory/quantifiers/ematching/trigger_database.cpp @@ -18,7 +18,7 @@ #include "theory/quantifiers/ematching/trigger.h" #include "theory/quantifiers/term_util.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -185,4 +185,4 @@ bool TriggerDatabase::mkTriggerTerms(Node q, } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/trigger_database.h b/src/theory/quantifiers/ematching/trigger_database.h index 21df0e536..2c28c77bc 100644 --- a/src/theory/quantifiers/ematching/trigger_database.h +++ b/src/theory/quantifiers/ematching/trigger_database.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "theory/quantifiers/ematching/trigger_trie.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -105,6 +105,6 @@ class TriggerDatabase } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__TRIGGER_DATABASE_H */ diff --git a/src/theory/quantifiers/ematching/trigger_term_info.cpp b/src/theory/quantifiers/ematching/trigger_term_info.cpp index 4bc74dd96..1f3ca0577 100644 --- a/src/theory/quantifiers/ematching/trigger_term_info.cpp +++ b/src/theory/quantifiers/ematching/trigger_term_info.cpp @@ -16,9 +16,9 @@ #include "theory/quantifiers/term_util.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -114,4 +114,4 @@ int32_t TriggerTermInfo::getTriggerWeight(Node n) } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/trigger_term_info.h b/src/theory/quantifiers/ematching/trigger_term_info.h index 5bf7e8099..603a1ab77 100644 --- a/src/theory/quantifiers/ematching/trigger_term_info.h +++ b/src/theory/quantifiers/ematching/trigger_term_info.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -124,6 +124,6 @@ class TriggerTermInfo } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/ematching/trigger_trie.cpp b/src/theory/quantifiers/ematching/trigger_trie.cpp index 04e9dabb0..c8a13d447 100644 --- a/src/theory/quantifiers/ematching/trigger_trie.cpp +++ b/src/theory/quantifiers/ematching/trigger_trie.cpp @@ -14,7 +14,7 @@ #include "theory/quantifiers/ematching/trigger_trie.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -74,4 +74,4 @@ void TriggerTrie::addTrigger(std::vector<Node>& nodes, inst::Trigger* t) } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/trigger_trie.h b/src/theory/quantifiers/ematching/trigger_trie.h index ad221ee21..355ad6c31 100644 --- a/src/theory/quantifiers/ematching/trigger_trie.h +++ b/src/theory/quantifiers/ematching/trigger_trie.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "theory/quantifiers/ematching/trigger.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -58,6 +58,6 @@ class TriggerTrie } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__TRIGGER_TRIE_H */ diff --git a/src/theory/quantifiers/ematching/var_match_generator.cpp b/src/theory/quantifiers/ematching/var_match_generator.cpp index 45c9e20d7..e2dd3f37d 100644 --- a/src/theory/quantifiers/ematching/var_match_generator.cpp +++ b/src/theory/quantifiers/ematching/var_match_generator.cpp @@ -16,9 +16,9 @@ #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 { @@ -81,4 +81,4 @@ int VarMatchGeneratorTermSubs::getNextMatch(Node q, InstMatch& m) } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/ematching/var_match_generator.h b/src/theory/quantifiers/ematching/var_match_generator.h index d85a20189..6ee179e91 100644 --- a/src/theory/quantifiers/ematching/var_match_generator.h +++ b/src/theory/quantifiers/ematching/var_match_generator.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "theory/quantifiers/ematching/inst_match_generator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace inst { @@ -53,6 +53,6 @@ class VarMatchGeneratorTermSubs : public InstMatchGenerator } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/equality_query.cpp b/src/theory/quantifiers/equality_query.cpp index 48e5682f2..7846a60bd 100644 --- a/src/theory/quantifiers/equality_query.cpp +++ b/src/theory/quantifiers/equality_query.cpp @@ -21,10 +21,10 @@ #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 { @@ -185,6 +185,6 @@ int32_t EqualityQuery::getRepScore(Node n, Node q, size_t index, TypeNode v_tn) return quantifiers::TermUtil::getTermDepth(n); } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/equality_query.h b/src/theory/quantifiers/equality_query.h index 887c54f42..d863c830b 100644 --- a/src/theory/quantifiers/equality_query.h +++ b/src/theory/quantifiers/equality_query.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "theory/quantifiers/quant_util.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -88,8 +88,8 @@ class EqualityQuery : public QuantifiersUtil 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 */ diff --git a/src/theory/quantifiers/expr_miner.cpp b/src/theory/quantifiers/expr_miner.cpp index 71d5d7a7a..20f3afe63 100644 --- a/src/theory/quantifiers/expr_miner.cpp +++ b/src/theory/quantifiers/expr_miner.cpp @@ -22,9 +22,9 @@ #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 { @@ -104,4 +104,4 @@ Result ExprMiner::doCheck(Node query) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/expr_miner.h b/src/theory/quantifiers/expr_miner.h index 67ab2b768..7046dad83 100644 --- a/src/theory/quantifiers/expr_miner.h +++ b/src/theory/quantifiers/expr_miner.h @@ -25,7 +25,7 @@ #include "smt/smt_engine.h" #include "theory/quantifiers/sygus_sampler.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -90,6 +90,6 @@ class ExprMiner } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__EXPRESSION_MINER_H */ diff --git a/src/theory/quantifiers/expr_miner_manager.cpp b/src/theory/quantifiers/expr_miner_manager.cpp index 6a77d8e45..867e6748a 100644 --- a/src/theory/quantifiers/expr_miner_manager.cpp +++ b/src/theory/quantifiers/expr_miner_manager.cpp @@ -16,7 +16,7 @@ #include "options/quantifiers_options.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -165,4 +165,4 @@ bool ExpressionMinerManager::addTerm(Node sol, std::ostream& out) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/expr_miner_manager.h b/src/theory/quantifiers/expr_miner_manager.h index eb2a01fac..6e775f586 100644 --- a/src/theory/quantifiers/expr_miner_manager.h +++ b/src/theory/quantifiers/expr_miner_manager.h @@ -24,7 +24,7 @@ #include "theory/quantifiers/solution_filter.h" #include "theory/quantifiers/sygus_sampler.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class QuantifiersEngine; @@ -118,6 +118,6 @@ class ExpressionMinerManager } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__EXPR_MINER_MANAGER_H */ diff --git a/src/theory/quantifiers/extended_rewrite.cpp b/src/theory/quantifiers/extended_rewrite.cpp index 9c6dd3964..01d573607 100644 --- a/src/theory/quantifiers/extended_rewrite.cpp +++ b/src/theory/quantifiers/extended_rewrite.cpp @@ -24,10 +24,10 @@ #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 { @@ -1724,6 +1724,6 @@ void ExtendedRewriter::debugExtendedRewrite(Node n, } } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/extended_rewrite.h b/src/theory/quantifiers/extended_rewrite.h index 0c4d0a1b3..f04f9eaae 100644 --- a/src/theory/quantifiers/extended_rewrite.h +++ b/src/theory/quantifiers/extended_rewrite.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -248,8 +248,8 @@ class ExtendedRewriter //--------------------------------------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 */ diff --git a/src/theory/quantifiers/first_order_model.cpp b/src/theory/quantifiers/first_order_model.cpp index fd84dc500..bbd6443fa 100644 --- a/src/theory/quantifiers/first_order_model.cpp +++ b/src/theory/quantifiers/first_order_model.cpp @@ -23,10 +23,10 @@ #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 { @@ -361,6 +361,6 @@ unsigned FirstOrderModel::getModelBasisArg(Node n) return n.getAttribute(ModelBasisArgAttribute()); } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/first_order_model.h b/src/theory/quantifiers/first_order_model.h index b86abd960..7a578a33a 100644 --- a/src/theory/quantifiers/first_order_model.h +++ b/src/theory/quantifiers/first_order_model.h @@ -22,7 +22,7 @@ #include "theory/theory_model.h" #include "theory/uf/theory_uf_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class QuantifiersEngine; @@ -194,8 +194,8 @@ class FirstOrderModel : public TheoryModel 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 */ diff --git a/src/theory/quantifiers/fmf/bounded_integers.cpp b/src/theory/quantifiers/fmf/bounded_integers.cpp index 9324ce36a..6044de049 100644 --- a/src/theory/quantifiers/fmf/bounded_integers.cpp +++ b/src/theory/quantifiers/fmf/bounded_integers.cpp @@ -28,11 +28,11 @@ #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, diff --git a/src/theory/quantifiers/fmf/bounded_integers.h b/src/theory/quantifiers/fmf/bounded_integers.h index 30589d40d..f2abf743a 100644 --- a/src/theory/quantifiers/fmf/bounded_integers.h +++ b/src/theory/quantifiers/fmf/bounded_integers.h @@ -26,7 +26,7 @@ #include "theory/decision_strategy.h" #include "theory/quantifiers/quant_bound_inference.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class RepSetIterator; @@ -238,6 +238,6 @@ private: } } -} +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/fmf/first_order_model_fmc.cpp b/src/theory/quantifiers/fmf/first_order_model_fmc.cpp index 9577e296b..7c9aacd76 100644 --- a/src/theory/quantifiers/fmf/first_order_model_fmc.cpp +++ b/src/theory/quantifiers/fmf/first_order_model_fmc.cpp @@ -18,9 +18,9 @@ #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 { @@ -156,4 +156,4 @@ Node FirstOrderModelFmc::getFunctionValue(Node op, const char* argPrefix) } // namespace fmcheck } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/fmf/first_order_model_fmc.h b/src/theory/quantifiers/fmf/first_order_model_fmc.h index d8ae054ad..86665aef4 100644 --- a/src/theory/quantifiers/fmf/first_order_model_fmc.h +++ b/src/theory/quantifiers/fmf/first_order_model_fmc.h @@ -19,7 +19,7 @@ #include "theory/quantifiers/first_order_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { namespace fmcheck { @@ -54,6 +54,6 @@ class FirstOrderModelFmc : public FirstOrderModel } // namespace fmcheck } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__FIRST_ORDER_MODEL_H */ diff --git a/src/theory/quantifiers/fmf/full_model_check.cpp b/src/theory/quantifiers/fmf/full_model_check.cpp index fcbd8e83f..3a7209f00 100644 --- a/src/theory/quantifiers/fmf/full_model_check.cpp +++ b/src/theory/quantifiers/fmf/full_model_check.cpp @@ -28,10 +28,10 @@ #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 { @@ -1375,4 +1375,4 @@ bool FullModelChecker::isHandled(Node q) const } // namespace fmcheck } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/fmf/full_model_check.h b/src/theory/quantifiers/fmf/full_model_check.h index 972c977e8..19ecc8ddc 100644 --- a/src/theory/quantifiers/fmf/full_model_check.h +++ b/src/theory/quantifiers/fmf/full_model_check.h @@ -20,7 +20,7 @@ #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 { @@ -184,9 +184,9 @@ protected: 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 */ diff --git a/src/theory/quantifiers/fmf/model_builder.cpp b/src/theory/quantifiers/fmf/model_builder.cpp index f30f811d5..17935f6b4 100644 --- a/src/theory/quantifiers/fmf/model_builder.cpp +++ b/src/theory/quantifiers/fmf/model_builder.cpp @@ -22,11 +22,11 @@ #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, diff --git a/src/theory/quantifiers/fmf/model_builder.h b/src/theory/quantifiers/fmf/model_builder.h index af5dee3cf..2b102c0a8 100644 --- a/src/theory/quantifiers/fmf/model_builder.h +++ b/src/theory/quantifiers/fmf/model_builder.h @@ -21,7 +21,7 @@ #include "theory/quantifiers/inst_match.h" #include "theory/theory_model_builder.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -71,8 +71,8 @@ class QModelBuilder : public TheoryEngineModelBuilder 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 */ diff --git a/src/theory/quantifiers/fmf/model_engine.cpp b/src/theory/quantifiers/fmf/model_engine.cpp index f3807aa9e..9943744f7 100644 --- a/src/theory/quantifiers/fmf/model_engine.cpp +++ b/src/theory/quantifiers/fmf/model_engine.cpp @@ -22,10 +22,10 @@ #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 { @@ -343,4 +343,4 @@ void ModelEngine::debugPrint( const char* c ){ } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/fmf/model_engine.h b/src/theory/quantifiers/fmf/model_engine.h index caafe3840..078894de6 100644 --- a/src/theory/quantifiers/fmf/model_engine.h +++ b/src/theory/quantifiers/fmf/model_engine.h @@ -21,7 +21,7 @@ #include "theory/quantifiers/quant_module.h" #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -69,8 +69,8 @@ private: 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 */ diff --git a/src/theory/quantifiers/fun_def_evaluator.cpp b/src/theory/quantifiers/fun_def_evaluator.cpp index 661d45a9f..326de79fa 100644 --- a/src/theory/quantifiers/fun_def_evaluator.cpp +++ b/src/theory/quantifiers/fun_def_evaluator.cpp @@ -19,9 +19,9 @@ #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 { @@ -252,4 +252,4 @@ bool FunDefEvaluator::hasDefinitions() const { return !d_funDefMap.empty(); } } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/fun_def_evaluator.h b/src/theory/quantifiers/fun_def_evaluator.h index d9af82f21..be4070840 100644 --- a/src/theory/quantifiers/fun_def_evaluator.h +++ b/src/theory/quantifiers/fun_def_evaluator.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "theory/evaluator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -70,6 +70,6 @@ class FunDefEvaluator } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/index_trie.cpp b/src/theory/quantifiers/index_trie.cpp index 728d51fc3..444882729 100644 --- a/src/theory/quantifiers/index_trie.cpp +++ b/src/theory/quantifiers/index_trie.cpp @@ -15,7 +15,7 @@ **/ #include "theory/quantifiers/index_trie.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -114,4 +114,4 @@ IndexTrieNode* IndexTrie::addRec(IndexTrieNode* n, } } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/index_trie.h b/src/theory/quantifiers/index_trie.h index b77095181..4ac754252 100644 --- a/src/theory/quantifiers/index_trie.h +++ b/src/theory/quantifiers/index_trie.h @@ -21,7 +21,7 @@ #include "base/check.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -106,5 +106,5 @@ class IndexTrie } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* THEORY__QUANTIFIERS__INDEX_TRIE_H */ diff --git a/src/theory/quantifiers/inst_match.cpp b/src/theory/quantifiers/inst_match.cpp index c215a1700..3db8db74e 100644 --- a/src/theory/quantifiers/inst_match.cpp +++ b/src/theory/quantifiers/inst_match.cpp @@ -16,7 +16,7 @@ #include "theory/quantifiers/quantifiers_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -101,5 +101,5 @@ bool InstMatch::set(QuantifiersState& qs, size_t i, TNode n) } } // namespace quantifiers -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/inst_match.h b/src/theory/quantifiers/inst_match.h index 6e6796bb1..9ff507917 100644 --- a/src/theory/quantifiers/inst_match.h +++ b/src/theory/quantifiers/inst_match.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -88,7 +88,7 @@ inline std::ostream& operator<<(std::ostream& out, const InstMatch& m) { } } // namespace quantifiers -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__INST_MATCH_H */ diff --git a/src/theory/quantifiers/inst_match_trie.cpp b/src/theory/quantifiers/inst_match_trie.cpp index 756550828..879eb8479 100644 --- a/src/theory/quantifiers/inst_match_trie.cpp +++ b/src/theory/quantifiers/inst_match_trie.cpp @@ -20,9 +20,9 @@ #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 { @@ -368,5 +368,5 @@ bool InstMatchTrieOrdered::existsInstMatch(quantifiers::QuantifiersState& qs, } } // namespace quantifiers -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/inst_match_trie.h b/src/theory/quantifiers/inst_match_trie.h index 5164f1820..da8858e8a 100644 --- a/src/theory/quantifiers/inst_match_trie.h +++ b/src/theory/quantifiers/inst_match_trie.h @@ -23,7 +23,7 @@ #include "context/cdo.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -223,7 +223,7 @@ class InstMatchTrieOrdered }; } // namespace quantifiers -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__INST_MATCH_TRIE_H */ diff --git a/src/theory/quantifiers/inst_strategy_enumerative.cpp b/src/theory/quantifiers/inst_strategy_enumerative.cpp index 16d92d405..c2ee94d1e 100644 --- a/src/theory/quantifiers/inst_strategy_enumerative.cpp +++ b/src/theory/quantifiers/inst_strategy_enumerative.cpp @@ -21,10 +21,10 @@ #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 { @@ -220,4 +220,4 @@ bool InstStrategyEnum::process(Node quantifier, bool fullEffort, bool isRd) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/inst_strategy_enumerative.h b/src/theory/quantifiers/inst_strategy_enumerative.h index d570e3039..05e5f7352 100644 --- a/src/theory/quantifiers/inst_strategy_enumerative.h +++ b/src/theory/quantifiers/inst_strategy_enumerative.h @@ -19,7 +19,7 @@ #include "theory/quantifiers/quant_module.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -114,8 +114,8 @@ class InstStrategyEnum : public QuantifiersModule int32_t d_fullSaturateLimit; }; /* class InstStrategyEnum */ -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/instantiate.cpp b/src/theory/quantifiers/instantiate.cpp index 21faaa13f..4f878c79b 100644 --- a/src/theory/quantifiers/instantiate.cpp +++ b/src/theory/quantifiers/instantiate.cpp @@ -33,10 +33,10 @@ #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 { @@ -758,6 +758,6 @@ Instantiate::Statistics::~Statistics() smtStatisticsRegistry()->unregisterStat(&d_inst_duplicate_ent); } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/instantiate.h b/src/theory/quantifiers/instantiate.h index 94e16b526..3fb194589 100644 --- a/src/theory/quantifiers/instantiate.h +++ b/src/theory/quantifiers/instantiate.h @@ -27,7 +27,7 @@ #include "theory/quantifiers/quant_util.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { class LazyCDProof; @@ -359,8 +359,8 @@ class Instantiate : public QuantifiersUtil 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 */ diff --git a/src/theory/quantifiers/instantiation_list.cpp b/src/theory/quantifiers/instantiation_list.cpp index f38a5f9a8..1c3a0bcac 100644 --- a/src/theory/quantifiers/instantiation_list.cpp +++ b/src/theory/quantifiers/instantiation_list.cpp @@ -17,7 +17,7 @@ #include "options/base_options.h" #include "printer/printer.h" -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& out, const InstantiationList& ilist) { @@ -31,4 +31,4 @@ std::ostream& operator<<(std::ostream& out, const SkolemList& skl) return out; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/instantiation_list.h b/src/theory/quantifiers/instantiation_list.h index 91d2e284c..da8d5c3b5 100644 --- a/src/theory/quantifiers/instantiation_list.h +++ b/src/theory/quantifiers/instantiation_list.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { /** A list of instantiations for a quantified formula */ struct InstantiationList @@ -53,6 +53,6 @@ struct SkolemList /** 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 */ diff --git a/src/theory/quantifiers/kinds b/src/theory/quantifiers/kinds index fa24275b1..6a32969e3 100644 --- a/src/theory/quantifiers/kinds +++ b/src/theory/quantifiers/kinds @@ -4,12 +4,12 @@ # 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" @@ -47,16 +47,16 @@ sort INST_PATTERN_LIST_TYPE \ # 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 diff --git a/src/theory/quantifiers/lazy_trie.cpp b/src/theory/quantifiers/lazy_trie.cpp index 3b1abb168..1b706d904 100644 --- a/src/theory/quantifiers/lazy_trie.cpp +++ b/src/theory/quantifiers/lazy_trie.cpp @@ -14,7 +14,7 @@ #include "theory/quantifiers/lazy_trie.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -154,6 +154,6 @@ void LazyTrieMulti::clear() d_rep_to_class.clear(); } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/lazy_trie.h b/src/theory/quantifiers/lazy_trie.h index de53e738c..2d92b13fd 100644 --- a/src/theory/quantifiers/lazy_trie.h +++ b/src/theory/quantifiers/lazy_trie.h @@ -17,7 +17,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -166,8 +166,8 @@ class LazyTrieMulti 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 */ diff --git a/src/theory/quantifiers/proof_checker.cpp b/src/theory/quantifiers/proof_checker.cpp index afbc9efca..572c631e1 100644 --- a/src/theory/quantifiers/proof_checker.cpp +++ b/src/theory/quantifiers/proof_checker.cpp @@ -18,9 +18,9 @@ #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 { @@ -123,4 +123,4 @@ Node QuantifiersProofRuleChecker::checkInternal( } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/proof_checker.h b/src/theory/quantifiers/proof_checker.h index 7d2f1baf1..da78daf90 100644 --- a/src/theory/quantifiers/proof_checker.h +++ b/src/theory/quantifiers/proof_checker.h @@ -21,7 +21,7 @@ #include "expr/proof_checker.h" #include "expr/proof_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -44,6 +44,6 @@ class QuantifiersProofRuleChecker : public ProofRuleChecker } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__PROOF_CHECKER_H */ diff --git a/src/theory/quantifiers/quant_bound_inference.cpp b/src/theory/quantifiers/quant_bound_inference.cpp index 45c2b5e42..6d7e2e9cd 100644 --- a/src/theory/quantifiers/quant_bound_inference.cpp +++ b/src/theory/quantifiers/quant_bound_inference.cpp @@ -17,9 +17,9 @@ #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 { @@ -127,4 +127,4 @@ bool QuantifiersBoundInference::getBoundElements( } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/quant_bound_inference.h b/src/theory/quantifiers/quant_bound_inference.h index 58b4e3db9..62ac0ea58 100644 --- a/src/theory/quantifiers/quant_bound_inference.h +++ b/src/theory/quantifiers/quant_bound_inference.h @@ -20,7 +20,7 @@ #include <vector> #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class RepSetIterator; @@ -122,6 +122,6 @@ class QuantifiersBoundInference } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__QUANT_BOUND_INFERENCE_H */ diff --git a/src/theory/quantifiers/quant_conflict_find.cpp b/src/theory/quantifiers/quant_conflict_find.cpp index c71964565..5fa617670 100644 --- a/src/theory/quantifiers/quant_conflict_find.cpp +++ b/src/theory/quantifiers/quant_conflict_find.cpp @@ -29,10 +29,10 @@ #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 { @@ -2349,6 +2349,6 @@ bool QuantConflictFind::isPropagatingInstance(Node n) const return true; } -} /* namespace CVC4::theory::quantifiers */ -} /* namespace CVC4::theory */ -} /* namespace CVC4 */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/quant_conflict_find.h b/src/theory/quantifiers/quant_conflict_find.h index 7778da4d0..ef605a48a 100644 --- a/src/theory/quantifiers/quant_conflict_find.h +++ b/src/theory/quantifiers/quant_conflict_find.h @@ -25,7 +25,7 @@ #include "expr/node_trie.h" #include "theory/quantifiers/quant_module.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -311,8 +311,8 @@ public: 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 diff --git a/src/theory/quantifiers/quant_module.cpp b/src/theory/quantifiers/quant_module.cpp index 156dd54fe..811dc8642 100644 --- a/src/theory/quantifiers/quant_module.cpp +++ b/src/theory/quantifiers/quant_module.cpp @@ -14,9 +14,9 @@ #include "theory/quantifiers/quant_module.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { QuantifiersModule::QuantifiersModule( @@ -75,4 +75,4 @@ quantifiers::QuantifiersRegistry& QuantifiersModule::getQuantifiersRegistry() } } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/quantifiers/quant_module.h b/src/theory/quantifiers/quant_module.h index fe518d61f..53fb55aa0 100644 --- a/src/theory/quantifiers/quant_module.h +++ b/src/theory/quantifiers/quant_module.h @@ -28,7 +28,7 @@ #include "theory/theory.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { class TermDb; @@ -174,6 +174,6 @@ class QuantifiersModule }; /* class QuantifiersModule */ } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANT_UTIL_H */ diff --git a/src/theory/quantifiers/quant_relevance.cpp b/src/theory/quantifiers/quant_relevance.cpp index 2a20800c2..2ce79d285 100644 --- a/src/theory/quantifiers/quant_relevance.cpp +++ b/src/theory/quantifiers/quant_relevance.cpp @@ -15,10 +15,10 @@ #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 { @@ -60,6 +60,6 @@ size_t QuantRelevance::getNumQuantifiersForSymbol(Node s) const return it->second.size(); } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/quant_relevance.h b/src/theory/quantifiers/quant_relevance.h index 66a31b58d..73b62489e 100644 --- a/src/theory/quantifiers/quant_relevance.h +++ b/src/theory/quantifiers/quant_relevance.h @@ -21,7 +21,7 @@ #include "theory/quantifiers/quant_util.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -61,8 +61,8 @@ class QuantRelevance : public QuantifiersUtil 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 */ diff --git a/src/theory/quantifiers/quant_rep_bound_ext.cpp b/src/theory/quantifiers/quant_rep_bound_ext.cpp index f29e2e224..2a70e5d4e 100644 --- a/src/theory/quantifiers/quant_rep_bound_ext.cpp +++ b/src/theory/quantifiers/quant_rep_bound_ext.cpp @@ -17,9 +17,9 @@ #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 { @@ -86,4 +86,4 @@ bool QRepBoundExt::getVariableOrder(Node owner, std::vector<unsigned>& varOrder) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/quant_rep_bound_ext.h b/src/theory/quantifiers/quant_rep_bound_ext.h index 30dbd520b..7e8f5d386 100644 --- a/src/theory/quantifiers/quant_rep_bound_ext.h +++ b/src/theory/quantifiers/quant_rep_bound_ext.h @@ -23,7 +23,7 @@ #include "theory/rep_set.h" #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -67,6 +67,6 @@ class QRepBoundExt : public RepBoundExt } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__FIRST_ORDER_MODEL_H */ diff --git a/src/theory/quantifiers/quant_split.cpp b/src/theory/quantifiers/quant_split.cpp index cb4e4d8b6..85fb291f0 100644 --- a/src/theory/quantifiers/quant_split.cpp +++ b/src/theory/quantifiers/quant_split.cpp @@ -20,9 +20,9 @@ #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 { @@ -207,4 +207,4 @@ void QuantDSplit::check(Theory::Effort e, QEffort quant_e) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/quant_split.h b/src/theory/quantifiers/quant_split.h index e7468dd34..eb85a2c28 100644 --- a/src/theory/quantifiers/quant_split.h +++ b/src/theory/quantifiers/quant_split.h @@ -20,7 +20,7 @@ #include "context/cdo.h" #include "theory/quantifiers/quant_module.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class QuantifiersEngine; @@ -73,6 +73,6 @@ class QuantDSplit : public QuantifiersModule { } } -} +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/quant_util.cpp b/src/theory/quantifiers/quant_util.cpp index 45fe078d5..841778a89 100644 --- a/src/theory/quantifiers/quant_util.cpp +++ b/src/theory/quantifiers/quant_util.cpp @@ -16,9 +16,9 @@ #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 ){ @@ -130,5 +130,5 @@ void QuantPhaseReq::getEntailPolarity( Node n, int child, bool hasPol, bool pol, } } -} /* namespace CVC4::theory */ -} /* namespace CVC4 */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/quant_util.h b/src/theory/quantifiers/quant_util.h index d536fa84d..f41f394e8 100644 --- a/src/theory/quantifiers/quant_util.h +++ b/src/theory/quantifiers/quant_util.h @@ -24,7 +24,7 @@ #include "expr/node.h" #include "theory/theory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** Quantifiers utility @@ -78,6 +78,6 @@ public: }; } -} +} // namespace CVC5 #endif /* CVC4__THEORY__QUANT_UTIL_H */ diff --git a/src/theory/quantifiers/quantifiers_attributes.cpp b/src/theory/quantifiers/quantifiers_attributes.cpp index 30b3ebcbe..8c068e06c 100644 --- a/src/theory/quantifiers/quantifiers_attributes.cpp +++ b/src/theory/quantifiers/quantifiers_attributes.cpp @@ -20,10 +20,10 @@ #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 { @@ -376,6 +376,6 @@ void QuantAttributes::setInstantiationLevelAttr(Node n, uint64_t level) } } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/quantifiers_attributes.h b/src/theory/quantifiers/quantifiers_attributes.h index ab1f7369e..4f7f1e22c 100644 --- a/src/theory/quantifiers/quantifiers_attributes.h +++ b/src/theory/quantifiers/quantifiers_attributes.h @@ -22,7 +22,7 @@ #include "expr/attribute.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** Attribute true for function definition quantifiers */ @@ -244,6 +244,6 @@ class QuantAttributes } } -} +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/quantifiers_inference_manager.cpp b/src/theory/quantifiers/quantifiers_inference_manager.cpp index b25c1aed3..687e17e4a 100644 --- a/src/theory/quantifiers/quantifiers_inference_manager.cpp +++ b/src/theory/quantifiers/quantifiers_inference_manager.cpp @@ -17,7 +17,7 @@ #include "theory/quantifiers/instantiate.h" #include "theory/quantifiers/skolemize.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -53,4 +53,4 @@ void QuantifiersInferenceManager::doPending() } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/quantifiers_inference_manager.h b/src/theory/quantifiers/quantifiers_inference_manager.h index f16f91f04..afe8dd40a 100644 --- a/src/theory/quantifiers/quantifiers_inference_manager.h +++ b/src/theory/quantifiers/quantifiers_inference_manager.h @@ -20,7 +20,7 @@ #include "theory/inference_manager_buffered.h" #include "theory/quantifiers/quantifiers_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -59,6 +59,6 @@ class QuantifiersInferenceManager : public InferenceManagerBuffered } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__QUANTIFIERS_INFERENCE_MANAGER_H */ diff --git a/src/theory/quantifiers/quantifiers_modules.cpp b/src/theory/quantifiers/quantifiers_modules.cpp index 9c8a4c7d0..e39e38ea7 100644 --- a/src/theory/quantifiers/quantifiers_modules.cpp +++ b/src/theory/quantifiers/quantifiers_modules.cpp @@ -18,7 +18,7 @@ #include "theory/quantifiers/relevant_domain.h" #include "theory/quantifiers/term_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -122,4 +122,4 @@ void QuantifiersModules::initialize(QuantifiersState& qs, } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/quantifiers_modules.h b/src/theory/quantifiers/quantifiers_modules.h index e58fcb8d5..71928502d 100644 --- a/src/theory/quantifiers/quantifiers_modules.h +++ b/src/theory/quantifiers/quantifiers_modules.h @@ -30,7 +30,7 @@ #include "theory/quantifiers/sygus/synth_engine.h" #include "theory/quantifiers/sygus_inst.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class QuantifiersEngine; @@ -45,7 +45,8 @@ namespace quantifiers { */ class QuantifiersModules { - friend class ::CVC4::theory::QuantifiersEngine; + friend class ::CVC5::theory::QuantifiersEngine; + public: QuantifiersModules(); ~QuantifiersModules(); @@ -93,6 +94,6 @@ class QuantifiersModules } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__QUANTIFIERS_MODULES_H */ diff --git a/src/theory/quantifiers/quantifiers_registry.cpp b/src/theory/quantifiers/quantifiers_registry.cpp index daaaea0ad..3cd59c834 100644 --- a/src/theory/quantifiers/quantifiers_registry.cpp +++ b/src/theory/quantifiers/quantifiers_registry.cpp @@ -18,7 +18,7 @@ #include "theory/quantifiers/quant_module.h" #include "theory/quantifiers/term_util.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -208,4 +208,4 @@ bool QuantifiersRegistry::getNameForQuant(Node q, Node& name, bool req) const } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/quantifiers_registry.h b/src/theory/quantifiers/quantifiers_registry.h index f2d3f085e..a3dffb063 100644 --- a/src/theory/quantifiers/quantifiers_registry.h +++ b/src/theory/quantifiers/quantifiers_registry.h @@ -22,7 +22,7 @@ #include "theory/quantifiers/quant_util.h" #include "theory/quantifiers/quantifiers_attributes.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class QuantifiersModule; @@ -129,6 +129,6 @@ class QuantifiersRegistry : public QuantifiersUtil } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__QUANTIFIERS_REGISTRY_H */ diff --git a/src/theory/quantifiers/quantifiers_rewriter.cpp b/src/theory/quantifiers/quantifiers_rewriter.cpp index 4b7aba7d3..d31b22f88 100644 --- a/src/theory/quantifiers/quantifiers_rewriter.cpp +++ b/src/theory/quantifiers/quantifiers_rewriter.cpp @@ -32,10 +32,10 @@ #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 { @@ -2028,6 +2028,6 @@ TrustNode QuantifiersRewriter::preprocess(Node n, bool isInst) return TrustNode::null(); } -}/* CVC4::theory::quantifiers namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/quantifiers_rewriter.h b/src/theory/quantifiers/quantifiers_rewriter.h index 3c83aef03..7bbe32da7 100644 --- a/src/theory/quantifiers/quantifiers_rewriter.h +++ b/src/theory/quantifiers/quantifiers_rewriter.h @@ -22,7 +22,7 @@ #include "theory/theory_rewriter.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -301,8 +301,8 @@ public: 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 */ diff --git a/src/theory/quantifiers/quantifiers_state.cpp b/src/theory/quantifiers/quantifiers_state.cpp index be691ae27..5e3bb3ba3 100644 --- a/src/theory/quantifiers/quantifiers_state.cpp +++ b/src/theory/quantifiers/quantifiers_state.cpp @@ -17,7 +17,7 @@ #include "options/quantifiers_options.h" #include "theory/uf/equality_engine_iterator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -160,4 +160,4 @@ QuantifiersStatistics& QuantifiersState::getStats() { return d_statistics; } } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/quantifiers_state.h b/src/theory/quantifiers/quantifiers_state.h index 6b4daec61..0f1c13659 100644 --- a/src/theory/quantifiers/quantifiers_state.h +++ b/src/theory/quantifiers/quantifiers_state.h @@ -21,7 +21,7 @@ #include "theory/theory.h" #include "theory/theory_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -86,6 +86,6 @@ class QuantifiersState : public TheoryState } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__QUANTIFIERS_STATE_H */ diff --git a/src/theory/quantifiers/quantifiers_statistics.cpp b/src/theory/quantifiers/quantifiers_statistics.cpp index 4567a6d4f..e922c7080 100644 --- a/src/theory/quantifiers/quantifiers_statistics.cpp +++ b/src/theory/quantifiers/quantifiers_statistics.cpp @@ -16,7 +16,7 @@ #include "smt/smt_statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -61,4 +61,4 @@ QuantifiersStatistics::~QuantifiersStatistics() } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/quantifiers_statistics.h b/src/theory/quantifiers/quantifiers_statistics.h index 1fa053484..9f2678796 100644 --- a/src/theory/quantifiers/quantifiers_statistics.h +++ b/src/theory/quantifiers/quantifiers_statistics.h @@ -20,7 +20,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -47,6 +47,6 @@ class QuantifiersStatistics } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__QUANTIFIERS_STATISTICS_H */ diff --git a/src/theory/quantifiers/query_generator.cpp b/src/theory/quantifiers/query_generator.cpp index 61ad4b87f..0860549ba 100644 --- a/src/theory/quantifiers/query_generator.cpp +++ b/src/theory/quantifiers/query_generator.cpp @@ -24,9 +24,9 @@ #include "util/random.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -425,4 +425,4 @@ void QueryGenerator::findQueries( } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/query_generator.h b/src/theory/quantifiers/query_generator.h index 570226f85..a847a184b 100644 --- a/src/theory/quantifiers/query_generator.h +++ b/src/theory/quantifiers/query_generator.h @@ -25,7 +25,7 @@ #include "theory/quantifiers/lazy_trie.h" #include "theory/quantifiers/sygus_sampler.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -116,6 +116,6 @@ class QueryGenerator : public ExprMiner } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS___H */ diff --git a/src/theory/quantifiers/relevant_domain.cpp b/src/theory/quantifiers/relevant_domain.cpp index 8210c5e8a..3e25f4073 100644 --- a/src/theory/quantifiers/relevant_domain.cpp +++ b/src/theory/quantifiers/relevant_domain.cpp @@ -22,9 +22,9 @@ #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 { @@ -338,4 +338,4 @@ void RelevantDomain::computeRelevantDomainLit( Node q, bool hasPol, bool pol, No } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/relevant_domain.h b/src/theory/quantifiers/relevant_domain.h index 8fbd70f3e..56b728b34 100644 --- a/src/theory/quantifiers/relevant_domain.h +++ b/src/theory/quantifiers/relevant_domain.h @@ -20,7 +20,7 @@ #include "theory/quantifiers/first_order_model.h" #include "theory/quantifiers/quant_util.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -168,9 +168,8 @@ class RelevantDomain : public QuantifiersUtil 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 */ diff --git a/src/theory/quantifiers/single_inv_partition.cpp b/src/theory/quantifiers/single_inv_partition.cpp index 72a1a2856..1dbc24280 100644 --- a/src/theory/quantifiers/single_inv_partition.cpp +++ b/src/theory/quantifiers/single_inv_partition.cpp @@ -20,11 +20,11 @@ #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 { @@ -613,6 +613,6 @@ void SingleInvocationPartition::debugPrint(const char* c) Trace(c) << std::endl; } -} /* namespace CVC4::theory::quantifiers */ -} /* namespace CVC4::theory */ -} /* namespace CVC4 */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/single_inv_partition.h b/src/theory/quantifiers/single_inv_partition.h index 6c55dc959..6feff4169 100644 --- a/src/theory/quantifiers/single_inv_partition.h +++ b/src/theory/quantifiers/single_inv_partition.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -290,8 +290,8 @@ class SingleInvocationPartition 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 */ diff --git a/src/theory/quantifiers/skolemize.cpp b/src/theory/quantifiers/skolemize.cpp index 9d6d30790..3767fac61 100644 --- a/src/theory/quantifiers/skolemize.cpp +++ b/src/theory/quantifiers/skolemize.cpp @@ -27,9 +27,9 @@ #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 { @@ -397,6 +397,6 @@ void Skolemize::getSkolemTermVectors( bool Skolemize::isProofEnabled() const { return d_epg != nullptr; } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/skolemize.h b/src/theory/quantifiers/skolemize.h index 3770cc223..d0a889ace 100644 --- a/src/theory/quantifiers/skolemize.h +++ b/src/theory/quantifiers/skolemize.h @@ -26,7 +26,7 @@ #include "theory/eager_proof_generator.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { class DTypeConstructor; @@ -155,8 +155,8 @@ class Skolemize 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 */ diff --git a/src/theory/quantifiers/solution_filter.cpp b/src/theory/quantifiers/solution_filter.cpp index c66b83170..3b00f5081 100644 --- a/src/theory/quantifiers/solution_filter.cpp +++ b/src/theory/quantifiers/solution_filter.cpp @@ -20,9 +20,9 @@ #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 { @@ -103,4 +103,4 @@ bool SolutionFilterStrength::addTerm(Node n, std::ostream& out) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/solution_filter.h b/src/theory/quantifiers/solution_filter.h index 212b3c7dd..cea5eb74e 100644 --- a/src/theory/quantifiers/solution_filter.h +++ b/src/theory/quantifiers/solution_filter.h @@ -24,7 +24,7 @@ #include "theory/quantifiers/lazy_trie.h" #include "theory/quantifiers/sygus_sampler.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -70,6 +70,6 @@ class SolutionFilterStrength : public ExprMiner } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SOLUTION_FILTER_H */ diff --git a/src/theory/quantifiers/sygus/ce_guided_single_inv.cpp b/src/theory/quantifiers/sygus/ce_guided_single_inv.cpp index c9b2559c1..0acd7e718 100644 --- a/src/theory/quantifiers/sygus/ce_guided_single_inv.cpp +++ b/src/theory/quantifiers/sygus/ce_guided_single_inv.cpp @@ -32,9 +32,9 @@ #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 { @@ -548,4 +548,4 @@ bool CegSingleInv::solveTrivial(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/ce_guided_single_inv.h b/src/theory/quantifiers/sygus/ce_guided_single_inv.h index 8a2ed3a71..e2f399ffd 100644 --- a/src/theory/quantifiers/sygus/ce_guided_single_inv.h +++ b/src/theory/quantifiers/sygus/ce_guided_single_inv.h @@ -24,7 +24,7 @@ #include "theory/quantifiers/single_inv_partition.h" #include "theory/quantifiers/sygus/sygus_stats.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -176,8 +176,8 @@ class CegSingleInv //-------------- end decomposed conjecture }; -}/* namespace CVC4::theory::quantifiers */ -}/* namespace CVC4::theory */ -}/* namespace CVC4 */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/cegis.cpp b/src/theory/quantifiers/sygus/cegis.cpp index 9022a9ba0..d980db887 100644 --- a/src/theory/quantifiers/sygus/cegis.cpp +++ b/src/theory/quantifiers/sygus/cegis.cpp @@ -24,10 +24,10 @@ #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 { @@ -704,6 +704,6 @@ bool Cegis::sampleAddRefinementLemma(const std::vector<Node>& candidates, return false; } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/cegis.h b/src/theory/quantifiers/sygus/cegis.h index 9d91a3d66..a12133d23 100644 --- a/src/theory/quantifiers/sygus/cegis.h +++ b/src/theory/quantifiers/sygus/cegis.h @@ -21,7 +21,7 @@ #include "theory/quantifiers/sygus/sygus_module.h" #include "theory/quantifiers/sygus_sampler.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -225,8 +225,8 @@ class Cegis : public SygusModule //---------------------------------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 */ diff --git a/src/theory/quantifiers/sygus/cegis_core_connective.cpp b/src/theory/quantifiers/sygus/cegis_core_connective.cpp index a21632bb3..26ad62c90 100644 --- a/src/theory/quantifiers/sygus/cegis_core_connective.cpp +++ b/src/theory/quantifiers/sygus/cegis_core_connective.cpp @@ -28,9 +28,9 @@ #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 { @@ -861,4 +861,4 @@ Node CegisCoreConnective::constructSolutionFromPool(Component& ccheck, } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/cegis_core_connective.h b/src/theory/quantifiers/sygus/cegis_core_connective.h index 5b8be444e..59bf53317 100644 --- a/src/theory/quantifiers/sygus/cegis_core_connective.h +++ b/src/theory/quantifiers/sygus/cegis_core_connective.h @@ -25,7 +25,7 @@ #include "theory/quantifiers/sygus/cegis.h" #include "util/result.h" -namespace CVC4 { +namespace CVC5 { class SmtEngine; @@ -399,6 +399,6 @@ class CegisCoreConnective : public Cegis } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_REPAIR_CONST_H */ diff --git a/src/theory/quantifiers/sygus/cegis_unif.cpp b/src/theory/quantifiers/sygus/cegis_unif.cpp index 75e4c2465..bcd9fa67a 100644 --- a/src/theory/quantifiers/sygus/cegis_unif.cpp +++ b/src/theory/quantifiers/sygus/cegis_unif.cpp @@ -21,9 +21,9 @@ #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 { @@ -686,4 +686,4 @@ void CegisUnifEnumDecisionStrategy::registerEvalPtAtSize(Node e, } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/cegis_unif.h b/src/theory/quantifiers/sygus/cegis_unif.h index e450c3fa7..e00370f2a 100644 --- a/src/theory/quantifiers/sygus/cegis_unif.h +++ b/src/theory/quantifiers/sygus/cegis_unif.h @@ -23,7 +23,7 @@ #include "theory/quantifiers/sygus/cegis.h" #include "theory/quantifiers/sygus/sygus_unif_rl.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -333,6 +333,6 @@ class CegisUnif : public Cegis } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/enum_stream_substitution.cpp b/src/theory/quantifiers/sygus/enum_stream_substitution.cpp index d4838de7a..17f2a0c16 100644 --- a/src/theory/quantifiers/sygus/enum_stream_substitution.cpp +++ b/src/theory/quantifiers/sygus/enum_stream_substitution.cpp @@ -24,9 +24,9 @@ #include <numeric> // for std::iota -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -621,4 +621,4 @@ bool EnumStreamConcrete::increment() Node EnumStreamConcrete::getCurrent() { return d_currTerm; } } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/enum_stream_substitution.h b/src/theory/quantifiers/sygus/enum_stream_substitution.h index 46b51c443..c7e4720d2 100644 --- a/src/theory/quantifiers/sygus/enum_stream_substitution.h +++ b/src/theory/quantifiers/sygus/enum_stream_substitution.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "theory/quantifiers/sygus/synth_conjecture.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -299,6 +299,6 @@ class EnumStreamConcrete : public EnumValGenerator } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/example_eval_cache.cpp b/src/theory/quantifiers/sygus/example_eval_cache.cpp index 4508e0a09..5056fb96d 100644 --- a/src/theory/quantifiers/sygus/example_eval_cache.cpp +++ b/src/theory/quantifiers/sygus/example_eval_cache.cpp @@ -17,10 +17,10 @@ #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 { @@ -119,4 +119,4 @@ void ExampleEvalCache::clearEvaluationAll() { d_exOutCache.clear(); } } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/example_eval_cache.h b/src/theory/quantifiers/sygus/example_eval_cache.h index 35adb889c..97ec38ab5 100644 --- a/src/theory/quantifiers/sygus/example_eval_cache.h +++ b/src/theory/quantifiers/sygus/example_eval_cache.h @@ -20,7 +20,7 @@ #include "expr/node_trie.h" #include "theory/quantifiers/sygus/example_infer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -160,6 +160,6 @@ class ExampleEvalCache } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/example_infer.cpp b/src/theory/quantifiers/sygus/example_infer.cpp index 7219b8f4b..12e4f073e 100644 --- a/src/theory/quantifiers/sygus/example_infer.cpp +++ b/src/theory/quantifiers/sygus/example_infer.cpp @@ -17,10 +17,10 @@ #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 { @@ -275,4 +275,4 @@ bool ExampleInfer::hasExamplesOut(Node f) const } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/example_infer.h b/src/theory/quantifiers/sygus/example_infer.h index 61c0327b7..0e5ee25ac 100644 --- a/src/theory/quantifiers/sygus/example_infer.h +++ b/src/theory/quantifiers/sygus/example_infer.h @@ -21,7 +21,7 @@ #include "theory/quantifiers/sygus/sygus_unif_io.h" #include "theory/quantifiers/sygus/term_database_sygus.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -157,6 +157,6 @@ class ExampleInfer } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/example_min_eval.cpp b/src/theory/quantifiers/sygus/example_min_eval.cpp index 22b0cb121..4cb9bd345 100644 --- a/src/theory/quantifiers/sygus/example_min_eval.cpp +++ b/src/theory/quantifiers/sygus/example_min_eval.cpp @@ -18,7 +18,7 @@ #include "expr/node_algorithm.h" #include "theory/quantifiers/sygus/term_database_sygus.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -84,4 +84,4 @@ Node EmeEvalTds::eval(TNode n, } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/example_min_eval.h b/src/theory/quantifiers/sygus/example_min_eval.h index 088036945..9af07caba 100644 --- a/src/theory/quantifiers/sygus/example_min_eval.h +++ b/src/theory/quantifiers/sygus/example_min_eval.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "expr/node_trie.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -118,6 +118,6 @@ class EmeEvalTds : public EmeEval } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/rcons_obligation_info.cpp b/src/theory/quantifiers/sygus/rcons_obligation_info.cpp index 25aac1e93..7d4a41f2d 100644 --- a/src/theory/quantifiers/sygus/rcons_obligation_info.cpp +++ b/src/theory/quantifiers/sygus/rcons_obligation_info.cpp @@ -17,7 +17,7 @@ #include "expr/node_algorithm.h" #include "theory/datatypes/sygus_datatype_utils.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -97,4 +97,4 @@ void RConsObligationInfo::printCandSols( } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/rcons_obligation_info.h b/src/theory/quantifiers/sygus/rcons_obligation_info.h index 5ebddd794..e05422b59 100644 --- a/src/theory/quantifiers/sygus/rcons_obligation_info.h +++ b/src/theory/quantifiers/sygus/rcons_obligation_info.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -145,6 +145,6 @@ class RConsObligationInfo } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__THEORY__QUANTIFIERS__RCONS_OBLIGATION_INFO_H diff --git a/src/theory/quantifiers/sygus/rcons_type_info.cpp b/src/theory/quantifiers/sygus/rcons_type_info.cpp index d24c4d25d..37b136a1c 100644 --- a/src/theory/quantifiers/sygus/rcons_type_info.cpp +++ b/src/theory/quantifiers/sygus/rcons_type_info.cpp @@ -16,7 +16,7 @@ #include "theory/datatypes/sygus_datatype_utils.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -69,4 +69,4 @@ Node RConsTypeInfo::builtinToOb(Node builtin) { return d_ob[builtin]; } } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/rcons_type_info.h b/src/theory/quantifiers/sygus/rcons_type_info.h index 432d07687..c2bce5720 100644 --- a/src/theory/quantifiers/sygus/rcons_type_info.h +++ b/src/theory/quantifiers/sygus/rcons_type_info.h @@ -19,7 +19,7 @@ #include "theory/quantifiers/sygus/sygus_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -97,6 +97,6 @@ class RConsTypeInfo } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__THEORY__QUANTIFIERS__RCONS_TYPE_INFO_H diff --git a/src/theory/quantifiers/sygus/sygus_abduct.cpp b/src/theory/quantifiers/sygus/sygus_abduct.cpp index 7bdc4ff9d..71853fc76 100644 --- a/src/theory/quantifiers/sygus/sygus_abduct.cpp +++ b/src/theory/quantifiers/sygus/sygus_abduct.cpp @@ -29,9 +29,9 @@ #include "theory/rewriter.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -187,4 +187,4 @@ Node SygusAbduct::mkAbductionConjecture(const std::string& name, } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_abduct.h b/src/theory/quantifiers/sygus/sygus_abduct.h index 85f4ff60b..ffcefd38b 100644 --- a/src/theory/quantifiers/sygus/sygus_abduct.h +++ b/src/theory/quantifiers/sygus/sygus_abduct.h @@ -21,7 +21,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -85,6 +85,6 @@ class SygusAbduct } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_ABDUCT_H */ diff --git a/src/theory/quantifiers/sygus/sygus_enumerator.cpp b/src/theory/quantifiers/sygus/sygus_enumerator.cpp index 4f870830e..c786d2668 100644 --- a/src/theory/quantifiers/sygus/sygus_enumerator.cpp +++ b/src/theory/quantifiers/sygus/sygus_enumerator.cpp @@ -24,9 +24,9 @@ #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 { @@ -1214,4 +1214,4 @@ bool SygusEnumerator::TermEnumMasterFv::increment() } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_enumerator.h b/src/theory/quantifiers/sygus/sygus_enumerator.h index cbf24ada1..a0d1c9b62 100644 --- a/src/theory/quantifiers/sygus/sygus_enumerator.h +++ b/src/theory/quantifiers/sygus/sygus_enumerator.h @@ -24,7 +24,7 @@ #include "theory/quantifiers/sygus/synth_conjecture.h" #include "theory/quantifiers/sygus/term_database_sygus.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -506,6 +506,6 @@ class SygusEnumerator : public EnumValGenerator } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_ENUMERATOR_H */ diff --git a/src/theory/quantifiers/sygus/sygus_enumerator_basic.cpp b/src/theory/quantifiers/sygus/sygus_enumerator_basic.cpp index 1b3404757..51814b07c 100644 --- a/src/theory/quantifiers/sygus/sygus_enumerator_basic.cpp +++ b/src/theory/quantifiers/sygus/sygus_enumerator_basic.cpp @@ -15,10 +15,10 @@ #include "options/datatypes_options.h" -using namespace CVC4::kind; +using namespace CVC5::kind; using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -55,4 +55,4 @@ bool EnumValGeneratorBasic::increment() } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_enumerator_basic.h b/src/theory/quantifiers/sygus/sygus_enumerator_basic.h index b6a56b6e3..c57d6f814 100644 --- a/src/theory/quantifiers/sygus/sygus_enumerator_basic.h +++ b/src/theory/quantifiers/sygus/sygus_enumerator_basic.h @@ -25,7 +25,7 @@ #include "theory/quantifiers/sygus/term_database_sygus.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -65,6 +65,6 @@ class EnumValGeneratorBasic : public EnumValGenerator } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_ENUMERATOR_BASIC_H */ diff --git a/src/theory/quantifiers/sygus/sygus_eval_unfold.cpp b/src/theory/quantifiers/sygus/sygus_eval_unfold.cpp index 92d77adff..3e87ccfc7 100644 --- a/src/theory/quantifiers/sygus/sygus_eval_unfold.cpp +++ b/src/theory/quantifiers/sygus/sygus_eval_unfold.cpp @@ -22,10 +22,10 @@ #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 { @@ -333,4 +333,4 @@ Node SygusEvalUnfold::unfold(Node en) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_eval_unfold.h b/src/theory/quantifiers/sygus/sygus_eval_unfold.h index f39092a04..d5e47edbc 100644 --- a/src/theory/quantifiers/sygus/sygus_eval_unfold.h +++ b/src/theory/quantifiers/sygus/sygus_eval_unfold.h @@ -21,7 +21,7 @@ #include "expr/node.h" #include "theory/quantifiers/sygus/sygus_invariance.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -154,6 +154,6 @@ class SygusEvalUnfold } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_EVAL_UNFOLD_H */ diff --git a/src/theory/quantifiers/sygus/sygus_explain.cpp b/src/theory/quantifiers/sygus/sygus_explain.cpp index 9025b1a51..26fab8535 100644 --- a/src/theory/quantifiers/sygus/sygus_explain.cpp +++ b/src/theory/quantifiers/sygus/sygus_explain.cpp @@ -21,10 +21,10 @@ #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 { @@ -355,6 +355,6 @@ void SygusExplain::getExplanationFor(Node n, 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 diff --git a/src/theory/quantifiers/sygus/sygus_explain.h b/src/theory/quantifiers/sygus/sygus_explain.h index 262062f14..1b1db568f 100644 --- a/src/theory/quantifiers/sygus/sygus_explain.h +++ b/src/theory/quantifiers/sygus/sygus_explain.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -239,8 +239,8 @@ class SygusExplain int& sz); }; -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_EXPLAIN_H */ diff --git a/src/theory/quantifiers/sygus/sygus_grammar_cons.cpp b/src/theory/quantifiers/sygus/sygus_grammar_cons.cpp index 7645cc237..554f587c7 100644 --- a/src/theory/quantifiers/sygus/sygus_grammar_cons.cpp +++ b/src/theory/quantifiers/sygus/sygus_grammar_cons.cpp @@ -30,9 +30,9 @@ #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 { @@ -1620,6 +1620,6 @@ bool CegGrammarConstructor::SygusDatatypeGenerator::shouldInclude(Node op) const return true; } -}/* namespace CVC4::theory::quantifiers */ -}/* namespace CVC4::theory */ -}/* namespace CVC4 */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_grammar_cons.h b/src/theory/quantifiers/sygus/sygus_grammar_cons.h index 0bd471922..a39540452 100644 --- a/src/theory/quantifiers/sygus/sygus_grammar_cons.h +++ b/src/theory/quantifiers/sygus/sygus_grammar_cons.h @@ -25,7 +25,7 @@ #include "expr/node.h" #include "expr/sygus_datatype.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -264,8 +264,8 @@ public: //---------------- end grammar construction }; -} /* namespace CVC4::theory::quantifiers */ -} /* namespace CVC4::theory */ -} /* namespace CVC4 */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/sygus_grammar_norm.cpp b/src/theory/quantifiers/sygus/sygus_grammar_norm.cpp index 964d64655..fa67e17c4 100644 --- a/src/theory/quantifiers/sygus/sygus_grammar_norm.cpp +++ b/src/theory/quantifiers/sygus/sygus_grammar_norm.cpp @@ -31,9 +31,9 @@ #include <numeric> // for std::iota -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -536,4 +536,4 @@ TypeNode SygusGrammarNorm::normalizeSygusType(TypeNode tn, Node sygus_vars) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_grammar_norm.h b/src/theory/quantifiers/sygus/sygus_grammar_norm.h index bb4bb6384..8c057d2c5 100644 --- a/src/theory/quantifiers/sygus/sygus_grammar_norm.h +++ b/src/theory/quantifiers/sygus/sygus_grammar_norm.h @@ -25,7 +25,7 @@ #include "expr/sygus_datatype.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -426,6 +426,6 @@ class SygusGrammarNorm } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/sygus_grammar_red.cpp b/src/theory/quantifiers/sygus/sygus_grammar_red.cpp index 3a4596a1e..8e6f4fbae 100644 --- a/src/theory/quantifiers/sygus/sygus_grammar_red.cpp +++ b/src/theory/quantifiers/sygus/sygus_grammar_red.cpp @@ -22,9 +22,9 @@ #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 { @@ -174,6 +174,6 @@ void SygusRedundantCons::getGenericList(TermDbSygus* tds, } } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_grammar_red.h b/src/theory/quantifiers/sygus/sygus_grammar_red.h index 565aafe28..25256a68c 100644 --- a/src/theory/quantifiers/sygus/sygus_grammar_red.h +++ b/src/theory/quantifiers/sygus/sygus_grammar_red.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -116,8 +116,8 @@ class SygusRedundantCons 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 */ diff --git a/src/theory/quantifiers/sygus/sygus_interpol.cpp b/src/theory/quantifiers/sygus/sygus_interpol.cpp index 2335a3a28..1c856ffa2 100644 --- a/src/theory/quantifiers/sygus/sygus_interpol.cpp +++ b/src/theory/quantifiers/sygus/sygus_interpol.cpp @@ -27,7 +27,7 @@ #include "theory/rewriter.h" #include "theory/smt_engine_subsolver.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -358,4 +358,4 @@ bool SygusInterpol::solveInterpolation(const std::string& name, } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_interpol.h b/src/theory/quantifiers/sygus/sygus_interpol.h index 07bdde2a8..34517b6e6 100644 --- a/src/theory/quantifiers/sygus/sygus_interpol.h +++ b/src/theory/quantifiers/sygus/sygus_interpol.h @@ -23,7 +23,7 @@ #include "expr/type_node.h" #include "smt/smt_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { /** @@ -213,6 +213,6 @@ class SygusInterpol } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_INTERPOL_H */ diff --git a/src/theory/quantifiers/sygus/sygus_invariance.cpp b/src/theory/quantifiers/sygus/sygus_invariance.cpp index 1740ecc3d..7e6c5ab6c 100644 --- a/src/theory/quantifiers/sygus/sygus_invariance.cpp +++ b/src/theory/quantifiers/sygus/sygus_invariance.cpp @@ -19,10 +19,10 @@ #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 { @@ -259,6 +259,6 @@ bool NegContainsSygusInvarianceTest::invariant(TermDbSygus* tds, return d_isUniversal; } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_invariance.h b/src/theory/quantifiers/sygus/sygus_invariance.h index 0f8c22f72..88e45df45 100644 --- a/src/theory/quantifiers/sygus/sygus_invariance.h +++ b/src/theory/quantifiers/sygus/sygus_invariance.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -296,8 +296,8 @@ class NegContainsSygusInvarianceTest : public SygusInvarianceTest 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 */ diff --git a/src/theory/quantifiers/sygus/sygus_module.cpp b/src/theory/quantifiers/sygus/sygus_module.cpp index 870363c07..8dac30c7e 100644 --- a/src/theory/quantifiers/sygus/sygus_module.cpp +++ b/src/theory/quantifiers/sygus/sygus_module.cpp @@ -14,7 +14,7 @@ #include "theory/quantifiers/sygus/sygus_module.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -25,6 +25,6 @@ SygusModule::SygusModule(QuantifiersInferenceManager& qim, { } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_module.h b/src/theory/quantifiers/sygus/sygus_module.h index 9c543c6b6..32f404005 100644 --- a/src/theory/quantifiers/sygus/sygus_module.h +++ b/src/theory/quantifiers/sygus/sygus_module.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -155,8 +155,8 @@ class SygusModule 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 */ diff --git a/src/theory/quantifiers/sygus/sygus_pbe.cpp b/src/theory/quantifiers/sygus/sygus_pbe.cpp index 170cf6fd7..25068eb7d 100644 --- a/src/theory/quantifiers/sygus/sygus_pbe.cpp +++ b/src/theory/quantifiers/sygus/sygus_pbe.cpp @@ -22,10 +22,10 @@ #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 { @@ -258,4 +258,4 @@ bool SygusPbe::constructCandidates(const std::vector<Node>& enums, } } -} +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_pbe.h b/src/theory/quantifiers/sygus/sygus_pbe.h index cbd307cab..c63dcf697 100644 --- a/src/theory/quantifiers/sygus/sygus_pbe.h +++ b/src/theory/quantifiers/sygus/sygus_pbe.h @@ -19,7 +19,7 @@ #include "theory/quantifiers/sygus/sygus_module.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -166,8 +166,8 @@ class SygusPbe : public SygusModule std::map<Node, Node> d_enum_to_candidate; }; -} /* namespace CVC4::theory::quantifiers */ -} /* namespace CVC4::theory */ -} /* namespace CVC4 */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/sygus_process_conj.cpp b/src/theory/quantifiers/sygus/sygus_process_conj.cpp index e58c209d4..dfb0a0f7c 100644 --- a/src/theory/quantifiers/sygus/sygus_process_conj.cpp +++ b/src/theory/quantifiers/sygus/sygus_process_conj.cpp @@ -22,10 +22,10 @@ #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 { @@ -802,6 +802,6 @@ void SynthConjectureProcess::getComponentVector(Kind k, } } -} /* namespace CVC4::theory::quantifiers */ -} /* namespace CVC4::theory */ -} /* namespace CVC4 */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_process_conj.h b/src/theory/quantifiers/sygus/sygus_process_conj.h index de136d546..0b07db89b 100644 --- a/src/theory/quantifiers/sygus/sygus_process_conj.h +++ b/src/theory/quantifiers/sygus/sygus_process_conj.h @@ -26,7 +26,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -356,8 +356,8 @@ class SynthConjectureProcess 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 diff --git a/src/theory/quantifiers/sygus/sygus_qe_preproc.cpp b/src/theory/quantifiers/sygus/sygus_qe_preproc.cpp index c8582cce5..72ce3f1ab 100644 --- a/src/theory/quantifiers/sygus/sygus_qe_preproc.cpp +++ b/src/theory/quantifiers/sygus/sygus_qe_preproc.cpp @@ -19,9 +19,9 @@ #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 { @@ -144,4 +144,4 @@ Node SygusQePreproc::preprocess(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_qe_preproc.h b/src/theory/quantifiers/sygus/sygus_qe_preproc.h index 4cfa8a624..49f81df02 100644 --- a/src/theory/quantifiers/sygus/sygus_qe_preproc.h +++ b/src/theory/quantifiers/sygus/sygus_qe_preproc.h @@ -17,7 +17,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -45,6 +45,6 @@ class SygusQePreproc } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS__SYGUS_QE_PREPROC_H */ diff --git a/src/theory/quantifiers/sygus/sygus_reconstruct.cpp b/src/theory/quantifiers/sygus/sygus_reconstruct.cpp index bd0f7c4dd..723d924f8 100644 --- a/src/theory/quantifiers/sygus/sygus_reconstruct.cpp +++ b/src/theory/quantifiers/sygus/sygus_reconstruct.cpp @@ -19,9 +19,9 @@ #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 { @@ -488,4 +488,4 @@ void SygusReconstruct::printPool( } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_reconstruct.h b/src/theory/quantifiers/sygus/sygus_reconstruct.h index 2d55c3f3d..0512fe643 100644 --- a/src/theory/quantifiers/sygus/sygus_reconstruct.h +++ b/src/theory/quantifiers/sygus/sygus_reconstruct.h @@ -23,7 +23,7 @@ #include "theory/quantifiers/sygus/rcons_obligation_info.h" #include "theory/quantifiers/sygus/rcons_type_info.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -307,6 +307,6 @@ class SygusReconstruct : public expr::NotifyMatch } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif // CVC4__THEORY__QUANTIFIERS__SYGUS_RECONSTRUCT_H diff --git a/src/theory/quantifiers/sygus/sygus_repair_const.cpp b/src/theory/quantifiers/sygus/sygus_repair_const.cpp index a7d352740..2d7dfc4bc 100644 --- a/src/theory/quantifiers/sygus/sygus_repair_const.cpp +++ b/src/theory/quantifiers/sygus/sygus_repair_const.cpp @@ -29,9 +29,9 @@ #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 { @@ -619,6 +619,6 @@ bool SygusRepairConst::getFitToLogicExcludeVar(LogicInfo& logic, return true; } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_repair_const.h b/src/theory/quantifiers/sygus/sygus_repair_const.h index 78c17280c..1e7eeb9fc 100644 --- a/src/theory/quantifiers/sygus/sygus_repair_const.h +++ b/src/theory/quantifiers/sygus/sygus_repair_const.h @@ -20,7 +20,7 @@ #include <unordered_set> #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class LogicInfo; @@ -207,8 +207,8 @@ class SygusRepairConst 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 */ diff --git a/src/theory/quantifiers/sygus/sygus_stats.cpp b/src/theory/quantifiers/sygus/sygus_stats.cpp index cd75a1e5e..da08ec1b5 100644 --- a/src/theory/quantifiers/sygus/sygus_stats.cpp +++ b/src/theory/quantifiers/sygus/sygus_stats.cpp @@ -17,7 +17,7 @@ #include "smt/smt_statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -60,4 +60,4 @@ SygusStatistics::~SygusStatistics() } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_stats.h b/src/theory/quantifiers/sygus/sygus_stats.h index 0824e846f..d89fa0eca 100644 --- a/src/theory/quantifiers/sygus/sygus_stats.h +++ b/src/theory/quantifiers/sygus/sygus_stats.h @@ -19,7 +19,7 @@ #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -53,6 +53,6 @@ class SygusStatistics } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/sygus_unif.cpp b/src/theory/quantifiers/sygus/sygus_unif.cpp index e590f704f..8eb13fef8 100644 --- a/src/theory/quantifiers/sygus/sygus_unif.cpp +++ b/src/theory/quantifiers/sygus/sygus_unif.cpp @@ -19,9 +19,9 @@ #include "util/random.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -134,6 +134,6 @@ void SygusUnif::print_val(const char* c, std::vector<Node>& vals, bool pol) } } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_unif.h b/src/theory/quantifiers/sygus/sygus_unif.h index ca5eb0a73..153c4603b 100644 --- a/src/theory/quantifiers/sygus/sygus_unif.h +++ b/src/theory/quantifiers/sygus/sygus_unif.h @@ -21,7 +21,7 @@ #include "expr/node.h" #include "theory/quantifiers/sygus/sygus_unif_strat.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -191,8 +191,8 @@ class SygusUnif 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 */ diff --git a/src/theory/quantifiers/sygus/sygus_unif_io.cpp b/src/theory/quantifiers/sygus/sygus_unif_io.cpp index 813aaa2b5..be24cb9e7 100644 --- a/src/theory/quantifiers/sygus/sygus_unif_io.cpp +++ b/src/theory/quantifiers/sygus/sygus_unif_io.cpp @@ -26,9 +26,9 @@ #include <math.h> -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -1675,6 +1675,6 @@ Node SygusUnifIo::constructBestConditional(Node ce, return conds[bestIndex]; } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_unif_io.h b/src/theory/quantifiers/sygus/sygus_unif_io.h index d7b0e231c..5d4f7fb7d 100644 --- a/src/theory/quantifiers/sygus/sygus_unif_io.h +++ b/src/theory/quantifiers/sygus/sygus_unif_io.h @@ -20,7 +20,7 @@ #include <map> #include "theory/quantifiers/sygus/sygus_unif.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -466,8 +466,8 @@ class SygusUnifIo : public SygusUnif 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 */ diff --git a/src/theory/quantifiers/sygus/sygus_unif_rl.cpp b/src/theory/quantifiers/sygus/sygus_unif_rl.cpp index 8859ba72b..436678aa9 100644 --- a/src/theory/quantifiers/sygus/sygus_unif_rl.cpp +++ b/src/theory/quantifiers/sygus/sygus_unif_rl.cpp @@ -24,9 +24,9 @@ #include <math.h> -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -1207,4 +1207,4 @@ Node SygusUnifRl::DecisionTreeInfo::PointSeparator::computeCond(Node cond, } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_unif_rl.h b/src/theory/quantifiers/sygus/sygus_unif_rl.h index 4c40e39db..82f2a80d2 100644 --- a/src/theory/quantifiers/sygus/sygus_unif_rl.h +++ b/src/theory/quantifiers/sygus/sygus_unif_rl.h @@ -23,7 +23,7 @@ #include "theory/quantifiers/lazy_trie.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -443,6 +443,6 @@ class SygusUnifRl : public SygusUnif } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS_UNIF_RL_H */ diff --git a/src/theory/quantifiers/sygus/sygus_unif_strat.cpp b/src/theory/quantifiers/sygus/sygus_unif_strat.cpp index 3a61c5635..5551be630 100644 --- a/src/theory/quantifiers/sygus/sygus_unif_strat.cpp +++ b/src/theory/quantifiers/sygus/sygus_unif_strat.cpp @@ -24,9 +24,9 @@ #include "theory/rewriter.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -1048,6 +1048,6 @@ void SygusUnifStrategy::indent(const char* c, int ind) } } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_unif_strat.h b/src/theory/quantifiers/sygus/sygus_unif_strat.h index a1d34ad4e..c9d6e5d96 100644 --- a/src/theory/quantifiers/sygus/sygus_unif_strat.h +++ b/src/theory/quantifiers/sygus/sygus_unif_strat.h @@ -20,7 +20,7 @@ #include <map> #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -426,8 +426,8 @@ class SygusUnifStrategy //------------------------------ 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 */ diff --git a/src/theory/quantifiers/sygus/sygus_utils.cpp b/src/theory/quantifiers/sygus/sygus_utils.cpp index 04acad0e6..ec5edd640 100644 --- a/src/theory/quantifiers/sygus/sygus_utils.cpp +++ b/src/theory/quantifiers/sygus/sygus_utils.cpp @@ -20,9 +20,9 @@ #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 { @@ -179,4 +179,4 @@ TypeNode SygusUtils::getSygusTypeForSynthFun(Node f) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/sygus_utils.h b/src/theory/quantifiers/sygus/sygus_utils.h index 41cdb85b2..2646dd1c8 100644 --- a/src/theory/quantifiers/sygus/sygus_utils.h +++ b/src/theory/quantifiers/sygus/sygus_utils.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "expr/subs.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -110,6 +110,6 @@ class SygusUtils } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS__SYGUS_UTILS_H */ diff --git a/src/theory/quantifiers/sygus/synth_conjecture.cpp b/src/theory/quantifiers/sygus/synth_conjecture.cpp index 72e69afae..0bfa73048 100644 --- a/src/theory/quantifiers/sygus/synth_conjecture.cpp +++ b/src/theory/quantifiers/sygus/synth_conjecture.cpp @@ -37,10 +37,10 @@ #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 { @@ -1353,4 +1353,4 @@ ExampleEvalCache* SynthConjecture::getExampleEvalCache(Node e) } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/synth_conjecture.h b/src/theory/quantifiers/sygus/synth_conjecture.h index efb559889..e39f65d80 100644 --- a/src/theory/quantifiers/sygus/synth_conjecture.h +++ b/src/theory/quantifiers/sygus/synth_conjecture.h @@ -32,7 +32,7 @@ #include "theory/quantifiers/sygus/sygus_stats.h" #include "theory/quantifiers/sygus/template_infer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -426,6 +426,6 @@ class SynthConjecture } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/synth_engine.cpp b/src/theory/quantifiers/sygus/synth_engine.cpp index 811730d4a..4f1a0bbbb 100644 --- a/src/theory/quantifiers/sygus/synth_engine.cpp +++ b/src/theory/quantifiers/sygus/synth_engine.cpp @@ -20,9 +20,9 @@ #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 { @@ -290,4 +290,4 @@ void SynthEngine::preregisterAssertion(Node n) } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/synth_engine.h b/src/theory/quantifiers/sygus/synth_engine.h index 813981395..30f9c181e 100644 --- a/src/theory/quantifiers/sygus/synth_engine.h +++ b/src/theory/quantifiers/sygus/synth_engine.h @@ -24,7 +24,7 @@ #include "theory/quantifiers/sygus/sygus_stats.h" #include "theory/quantifiers/sygus/synth_conjecture.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -115,6 +115,6 @@ class SynthEngine : public QuantifiersModule } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/template_infer.cpp b/src/theory/quantifiers/sygus/template_infer.cpp index 5cfc09d7c..84fcafd05 100644 --- a/src/theory/quantifiers/sygus/template_infer.cpp +++ b/src/theory/quantifiers/sygus/template_infer.cpp @@ -19,9 +19,9 @@ #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 { @@ -203,4 +203,4 @@ Node SygusTemplateInfer::getTemplateArg(Node prog) const } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/template_infer.h b/src/theory/quantifiers/sygus/template_infer.h index a00239df9..be35025bd 100644 --- a/src/theory/quantifiers/sygus/template_infer.h +++ b/src/theory/quantifiers/sygus/template_infer.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "theory/quantifiers/sygus/transition_inference.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -71,6 +71,6 @@ class SygusTemplateInfer } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/term_database_sygus.cpp b/src/theory/quantifiers/sygus/term_database_sygus.cpp index e7bbc947a..f50e222ff 100644 --- a/src/theory/quantifiers/sygus/term_database_sygus.cpp +++ b/src/theory/quantifiers/sygus/term_database_sygus.cpp @@ -30,9 +30,9 @@ #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 { @@ -1089,6 +1089,6 @@ bool TermDbSygus::isEvaluationPoint(Node n) const return true; } -}/* CVC4::theory::quantifiers namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/term_database_sygus.h b/src/theory/quantifiers/sygus/term_database_sygus.h index f2188469e..0bd0c636a 100644 --- a/src/theory/quantifiers/sygus/term_database_sygus.h +++ b/src/theory/quantifiers/sygus/term_database_sygus.h @@ -28,7 +28,7 @@ #include "theory/quantifiers/sygus/type_info.h" #include "theory/quantifiers/term_database.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -465,8 +465,8 @@ class TermDbSygus { }; -}/* CVC4::theory::quantifiers namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__TERM_DATABASE_H */ diff --git a/src/theory/quantifiers/sygus/transition_inference.cpp b/src/theory/quantifiers/sygus/transition_inference.cpp index 543d5e7f0..0b5946176 100644 --- a/src/theory/quantifiers/sygus/transition_inference.cpp +++ b/src/theory/quantifiers/sygus/transition_inference.cpp @@ -20,9 +20,9 @@ #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 { @@ -585,4 +585,4 @@ Node TransitionInference::constructFormulaTrace(DetTrace& dt) const } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/transition_inference.h b/src/theory/quantifiers/sygus/transition_inference.h index aa060de4e..aed003357 100644 --- a/src/theory/quantifiers/sygus/transition_inference.h +++ b/src/theory/quantifiers/sygus/transition_inference.h @@ -27,7 +27,7 @@ #include "theory/quantifiers/inst_match_trie.h" #include "theory/quantifiers/single_inv_partition.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -332,6 +332,6 @@ class TransitionInference } // namespace quantifiers } // namespace theory -} /* namespace CVC4 */ +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus/type_info.cpp b/src/theory/quantifiers/sygus/type_info.cpp index 9266a3f9d..19dff9936 100644 --- a/src/theory/quantifiers/sygus/type_info.cpp +++ b/src/theory/quantifiers/sygus/type_info.cpp @@ -22,9 +22,9 @@ #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 { @@ -488,4 +488,4 @@ bool SygusTypeInfo::isSubclassVarTrivial() const } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/type_info.h b/src/theory/quantifiers/sygus/type_info.h index 7b45d115b..cc78fc526 100644 --- a/src/theory/quantifiers/sygus/type_info.h +++ b/src/theory/quantifiers/sygus/type_info.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -253,6 +253,6 @@ class SygusTypeInfo } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS__TYPE_INFO_H */ diff --git a/src/theory/quantifiers/sygus/type_node_id_trie.cpp b/src/theory/quantifiers/sygus/type_node_id_trie.cpp index 93162b50e..064543af8 100644 --- a/src/theory/quantifiers/sygus/type_node_id_trie.cpp +++ b/src/theory/quantifiers/sygus/type_node_id_trie.cpp @@ -14,9 +14,9 @@ #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 { @@ -49,4 +49,4 @@ void TypeNodeIdTrie::assignIds(std::map<Node, unsigned>& assign, } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus/type_node_id_trie.h b/src/theory/quantifiers/sygus/type_node_id_trie.h index 020c8d086..a60afda23 100644 --- a/src/theory/quantifiers/sygus/type_node_id_trie.h +++ b/src/theory/quantifiers/sygus/type_node_id_trie.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -48,6 +48,6 @@ class TypeNodeIdTrie } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__SYGUS__TYPE_NODE_ID_TRIE_H */ diff --git a/src/theory/quantifiers/sygus_inst.cpp b/src/theory/quantifiers/sygus_inst.cpp index 8732f1715..0b1d91684 100644 --- a/src/theory/quantifiers/sygus_inst.cpp +++ b/src/theory/quantifiers/sygus_inst.cpp @@ -28,7 +28,7 @@ #include "theory/quantifiers/term_util.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -553,4 +553,4 @@ void SygusInst::addCeLemma(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus_inst.h b/src/theory/quantifiers/sygus_inst.h index 402846e87..08fc5ccb3 100644 --- a/src/theory/quantifiers/sygus_inst.h +++ b/src/theory/quantifiers/sygus_inst.h @@ -24,7 +24,7 @@ #include "theory/decision_strategy.h" #include "theory/quantifiers/quant_module.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class QuantifiersEngine; @@ -147,6 +147,6 @@ class SygusInst : public QuantifiersModule } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/quantifiers/sygus_sampler.cpp b/src/theory/quantifiers/sygus_sampler.cpp index ea530da67..2b89c0c7c 100644 --- a/src/theory/quantifiers/sygus_sampler.cpp +++ b/src/theory/quantifiers/sygus_sampler.cpp @@ -30,7 +30,7 @@ #include "util/random.h" #include "util/sampler.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -843,6 +843,6 @@ void SygusSampler::checkEquivalent(Node bv, Node bvr) } } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/sygus_sampler.h b/src/theory/quantifiers/sygus_sampler.h index a51f1e015..65843dc63 100644 --- a/src/theory/quantifiers/sygus_sampler.h +++ b/src/theory/quantifiers/sygus_sampler.h @@ -23,7 +23,7 @@ #include "theory/quantifiers/sygus/term_database_sygus.h" #include "theory/quantifiers/term_enumeration.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -318,8 +318,8 @@ class SygusSampler : public LazyTrieEvaluator 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 */ diff --git a/src/theory/quantifiers/term_database.cpp b/src/theory/quantifiers/term_database.cpp index 2d857a4d3..d6d7933cb 100644 --- a/src/theory/quantifiers/term_database.cpp +++ b/src/theory/quantifiers/term_database.cpp @@ -28,10 +28,10 @@ #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 { @@ -1230,6 +1230,6 @@ Node TermDb::getHoTypeMatchPredicate(TypeNode tn) return k; } -}/* CVC4::theory::quantifiers namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/term_database.h b/src/theory/quantifiers/term_database.h index bafaa8bdd..d0812d1d1 100644 --- a/src/theory/quantifiers/term_database.h +++ b/src/theory/quantifiers/term_database.h @@ -28,7 +28,7 @@ #include "theory/theory.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -420,8 +420,8 @@ class TermDb : public QuantifiersUtil { //------------------------------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 */ diff --git a/src/theory/quantifiers/term_enumeration.cpp b/src/theory/quantifiers/term_enumeration.cpp index 0b1b1cdae..2945750c1 100644 --- a/src/theory/quantifiers/term_enumeration.cpp +++ b/src/theory/quantifiers/term_enumeration.cpp @@ -16,9 +16,9 @@ #include "theory/quantifiers/quant_bound_inference.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -73,6 +73,6 @@ bool TermEnumeration::getDomain(TypeNode tn, std::vector<Node>& dom) return true; } -} /* CVC4::theory::quantifiers namespace */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/term_enumeration.h b/src/theory/quantifiers/term_enumeration.h index 9cd57bfd0..fa7eaf63e 100644 --- a/src/theory/quantifiers/term_enumeration.h +++ b/src/theory/quantifiers/term_enumeration.h @@ -24,7 +24,7 @@ #include "expr/type_node.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -69,8 +69,8 @@ class TermEnumeration 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 */ diff --git a/src/theory/quantifiers/term_registry.cpp b/src/theory/quantifiers/term_registry.cpp index 74dad6cc7..cf33f0a41 100644 --- a/src/theory/quantifiers/term_registry.cpp +++ b/src/theory/quantifiers/term_registry.cpp @@ -20,7 +20,7 @@ #include "theory/quantifiers/fmf/first_order_model_fmc.h" #include "theory/quantifiers/quantifiers_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -134,4 +134,4 @@ bool TermRegistry::useFmcModel() const { return d_useFmcModel; } } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/term_registry.h b/src/theory/quantifiers/term_registry.h index d70b7acf8..e4e4a7e9f 100644 --- a/src/theory/quantifiers/term_registry.h +++ b/src/theory/quantifiers/term_registry.h @@ -25,7 +25,7 @@ #include "theory/quantifiers/term_database.h" #include "theory/quantifiers/term_enumeration.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -99,6 +99,6 @@ class TermRegistry } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__QUANTIFIERS__TERM_REGISTRY_H */ diff --git a/src/theory/quantifiers/term_tuple_enumerator.cpp b/src/theory/quantifiers/term_tuple_enumerator.cpp index 209196110..546f6aa6c 100644 --- a/src/theory/quantifiers/term_tuple_enumerator.cpp +++ b/src/theory/quantifiers/term_tuple_enumerator.cpp @@ -31,7 +31,7 @@ #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) @@ -505,4 +505,4 @@ TermTupleEnumeratorInterface* mkTermTupleEnumeratorRd( } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/term_tuple_enumerator.h b/src/theory/quantifiers/term_tuple_enumerator.h index 28831baf5..b15ab2212 100644 --- a/src/theory/quantifiers/term_tuple_enumerator.h +++ b/src/theory/quantifiers/term_tuple_enumerator.h @@ -18,7 +18,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -94,5 +94,5 @@ TermTupleEnumeratorInterface* mkTermTupleEnumeratorRd( } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* TERM_TUPLE_ENUMERATOR_H_7640 */ diff --git a/src/theory/quantifiers/term_util.cpp b/src/theory/quantifiers/term_util.cpp index daf291d18..41e06a708 100644 --- a/src/theory/quantifiers/term_util.cpp +++ b/src/theory/quantifiers/term_util.cpp @@ -22,9 +22,9 @@ #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 { @@ -599,6 +599,6 @@ bool TermUtil::hasOffsetArg(Kind ik, int arg, int& offset, Kind& ok) return false; } -}/* CVC4::theory::quantifiers namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace quantifiers +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/quantifiers/term_util.h b/src/theory/quantifiers/term_util.h index 6fd9d32d6..1ac6ca495 100644 --- a/src/theory/quantifiers/term_util.h +++ b/src/theory/quantifiers/term_util.h @@ -22,7 +22,7 @@ #include "expr/attribute.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { // attribute for "contains instantiation constants from" @@ -204,8 +204,8 @@ public: 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 */ diff --git a/src/theory/quantifiers/theory_quantifiers.cpp b/src/theory/quantifiers/theory_quantifiers.cpp index ace7b79ff..d89abf076 100644 --- a/src/theory/quantifiers/theory_quantifiers.cpp +++ b/src/theory/quantifiers/theory_quantifiers.cpp @@ -22,10 +22,10 @@ #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 { @@ -184,4 +184,4 @@ void TheoryQuantifiers::setUserAttribute(const std::string& attr, Node n, std::v } // namespace quantifiers } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers/theory_quantifiers.h b/src/theory/quantifiers/theory_quantifiers.h index 91f12c0ed..6af0e8648 100644 --- a/src/theory/quantifiers/theory_quantifiers.h +++ b/src/theory/quantifiers/theory_quantifiers.h @@ -30,7 +30,7 @@ #include "theory/theory.h" #include "theory/valuation.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -96,8 +96,8 @@ class TheoryQuantifiers : public Theory { 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 */ diff --git a/src/theory/quantifiers/theory_quantifiers_type_rules.h b/src/theory/quantifiers/theory_quantifiers_type_rules.h index 6758cde28..e990f5320 100644 --- a/src/theory/quantifiers/theory_quantifiers_type_rules.h +++ b/src/theory/quantifiers/theory_quantifiers_type_rules.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace quantifiers { @@ -129,8 +129,8 @@ struct QuantifierInstPatternListTypeRule { } };/* 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 */ diff --git a/src/theory/quantifiers_engine.cpp b/src/theory/quantifiers_engine.cpp index fa02ae516..12942c1c4 100644 --- a/src/theory/quantifiers_engine.cpp +++ b/src/theory/quantifiers_engine.cpp @@ -37,9 +37,9 @@ #include "theory/theory_engine.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { QuantifiersEngine::QuantifiersEngine( @@ -653,4 +653,4 @@ bool QuantifiersEngine::getSynthSolutions( } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/quantifiers_engine.h b/src/theory/quantifiers_engine.h index fd24abcf9..4d4599f68 100644 --- a/src/theory/quantifiers_engine.h +++ b/src/theory/quantifiers_engine.h @@ -25,7 +25,7 @@ #include "context/cdlist.h" #include "theory/quantifiers/quant_util.h" -namespace CVC4 { +namespace CVC5 { class TheoryEngine; @@ -52,7 +52,7 @@ class TermRegistry; // 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; @@ -208,7 +208,7 @@ public: 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 */ diff --git a/src/theory/relevance_manager.cpp b/src/theory/relevance_manager.cpp index d38170563..5fda45954 100644 --- a/src/theory/relevance_manager.cpp +++ b/src/theory/relevance_manager.cpp @@ -16,9 +16,9 @@ #include <sstream> -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { RelevanceManager::RelevanceManager(context::UserContext* userContext, @@ -314,4 +314,4 @@ bool RelevanceManager::isRelevant(Node lit) } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/relevance_manager.h b/src/theory/relevance_manager.h index 3d1baffc6..eea1d2c61 100644 --- a/src/theory/relevance_manager.h +++ b/src/theory/relevance_manager.h @@ -24,7 +24,7 @@ #include "expr/node.h" #include "theory/valuation.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -149,6 +149,6 @@ class RelevanceManager }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__RELEVANCE_MANAGER__H */ diff --git a/src/theory/rep_set.cpp b/src/theory/rep_set.cpp index cad77b62b..6492ac9f0 100644 --- a/src/theory/rep_set.cpp +++ b/src/theory/rep_set.cpp @@ -18,9 +18,9 @@ #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(){ @@ -461,5 +461,5 @@ void RepSetIterator::debugPrintSmall( const char* c ){ Debug( c ) << std::endl; } -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/rep_set.h b/src/theory/rep_set.h index 55751efa3..4c7b04045 100644 --- a/src/theory/rep_set.h +++ b/src/theory/rep_set.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class QuantifiersEngine; @@ -324,7 +324,7 @@ class RepBoundExt } }; -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__REP_SET_H */ diff --git a/src/theory/rewriter.cpp b/src/theory/rewriter.cpp index 9c69915b4..9e248c8d6 100644 --- a/src/theory/rewriter.cpp +++ b/src/theory/rewriter.cpp @@ -29,7 +29,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { /** Attribute true for nodes that have been rewritten with proofs enabled */ @@ -511,5 +511,5 @@ void Rewriter::clearCaches() { rewriter->clearCachesInternal(); } -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/rewriter.h b/src/theory/rewriter.h index 9a669988b..c5a8cd45e 100644 --- a/src/theory/rewriter.h +++ b/src/theory/rewriter.h @@ -21,7 +21,7 @@ #include "expr/node.h" #include "theory/theory_rewriter.h" -namespace CVC4 { +namespace CVC5 { class TConvProofGenerator; class ProofNodeManager; @@ -231,5 +231,5 @@ class Rewriter { #endif /* CVC4_ASSERTIONS */ };/* class Rewriter */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/rewriter_attributes.h b/src/theory/rewriter_attributes.h index 49f77f0e3..83961353e 100644 --- a/src/theory/rewriter_attributes.h +++ b/src/theory/rewriter_attributes.h @@ -20,7 +20,7 @@ #include "expr/attribute.h" -namespace CVC4 { +namespace CVC5 { namespace theory { template <bool pre, theory::TheoryId theoryId> @@ -98,5 +98,5 @@ struct RewriteAttibute { } };/* struct RewriteAttribute */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/rewriter_tables_template.h b/src/theory/rewriter_tables_template.h index 0c2ecb5c9..bd9b9575e 100644 --- a/src/theory/rewriter_tables_template.h +++ b/src/theory/rewriter_tables_template.h @@ -26,7 +26,7 @@ ${rewriter_includes} -namespace CVC4 { +namespace CVC5 { namespace theory { Node Rewriter::getPreRewriteCache(theory::TheoryId theoryId, TNode node) { @@ -77,7 +77,7 @@ for (size_t i = 0; i < theory::THEORY_LAST; ++i) } void Rewriter::clearCachesInternal() { - typedef CVC4::expr::attr::AttributeUniqueId AttributeUniqueId; + typedef CVC5::expr::attr::AttributeUniqueId AttributeUniqueId; std::vector<AttributeUniqueId> preids; ${pre_rewrite_attribute_ids} @@ -94,5 +94,5 @@ void Rewriter::clearCachesInternal() { NodeManager::currentNM()->deleteAttributes(allids); } -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/sep/kinds b/src/theory/sep/kinds index 7a3fb00a4..666e3f179 100644 --- a/src/theory/sep/kinds +++ b/src/theory/sep/kinds @@ -4,13 +4,13 @@ # 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" @@ -20,11 +20,11 @@ operator SEP_STAR 2: "separation star" 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 diff --git a/src/theory/sep/theory_sep.cpp b/src/theory/sep/theory_sep.cpp index 00e3e8251..73fc565bd 100644 --- a/src/theory/sep/theory_sep.cpp +++ b/src/theory/sep/theory_sep.cpp @@ -34,9 +34,9 @@ #include "theory/valuation.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sep { @@ -1796,6 +1796,6 @@ Node TheorySep::HeapInfo::getValue( TypeNode tn ) { return curr; } -}/* CVC4::theory::sep namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace sep +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/sep/theory_sep.h b/src/theory/sep/theory_sep.h index 824fe70e9..029cbada5 100644 --- a/src/theory/sep/theory_sep.h +++ b/src/theory/sep/theory_sep.h @@ -31,7 +31,7 @@ #include "theory/uf/equality_engine.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class TheoryModel; @@ -349,8 +349,8 @@ class TheorySep : public Theory { 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 */ diff --git a/src/theory/sep/theory_sep_rewriter.cpp b/src/theory/sep/theory_sep_rewriter.cpp index 9f34fa4b2..756a82bc1 100644 --- a/src/theory/sep/theory_sep_rewriter.cpp +++ b/src/theory/sep/theory_sep_rewriter.cpp @@ -20,7 +20,7 @@ #include "theory/quantifiers/quant_util.h" #include "options/sep_options.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sep { @@ -164,6 +164,6 @@ RewriteResponse TheorySepRewriter::postRewrite(TNode node) { 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 diff --git a/src/theory/sep/theory_sep_rewriter.h b/src/theory/sep/theory_sep_rewriter.h index 745eef4ac..97124bd0d 100644 --- a/src/theory/sep/theory_sep_rewriter.h +++ b/src/theory/sep/theory_sep_rewriter.h @@ -23,7 +23,7 @@ #include "theory/theory_rewriter.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sep { @@ -47,8 +47,8 @@ class TheorySepRewriter : public TheoryRewriter 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 */ diff --git a/src/theory/sep/theory_sep_type_rules.h b/src/theory/sep/theory_sep_type_rules.h index bbaf61483..8618ce4d6 100644 --- a/src/theory/sep/theory_sep_type_rules.h +++ b/src/theory/sep/theory_sep_type_rules.h @@ -19,7 +19,7 @@ #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 { @@ -107,9 +107,8 @@ struct SepNilTypeRule { } };/* 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 */ diff --git a/src/theory/sets/cardinality_extension.cpp b/src/theory/sets/cardinality_extension.cpp index ef1b3e8d5..84e7786e8 100644 --- a/src/theory/sets/cardinality_extension.cpp +++ b/src/theory/sets/cardinality_extension.cpp @@ -25,9 +25,9 @@ #include "theory/valuation.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -1114,4 +1114,4 @@ const std::vector<Node>& CardinalityExtension::getFiniteTypeMembers( } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/sets/cardinality_extension.h b/src/theory/sets/cardinality_extension.h index c353f86b8..47fa18d5b 100644 --- a/src/theory/sets/cardinality_extension.h +++ b/src/theory/sets/cardinality_extension.h @@ -25,7 +25,7 @@ #include "theory/type_set.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -412,6 +412,6 @@ class CardinalityExtension } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/sets/inference_manager.cpp b/src/theory/sets/inference_manager.cpp index 9e16bfb97..305059797 100644 --- a/src/theory/sets/inference_manager.cpp +++ b/src/theory/sets/inference_manager.cpp @@ -18,9 +18,9 @@ #include "theory/rewriter.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -177,4 +177,4 @@ void InferenceManager::split(Node n, InferenceId id, int reqPol) } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/sets/inference_manager.h b/src/theory/sets/inference_manager.h index ce561f454..8e4614718 100644 --- a/src/theory/sets/inference_manager.h +++ b/src/theory/sets/inference_manager.h @@ -20,7 +20,7 @@ #include "theory/inference_manager_buffered.h" #include "theory/sets/solver_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -100,6 +100,6 @@ class InferenceManager : public InferenceManagerBuffered } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__SETS__INFERENCE_MANAGER_H */ diff --git a/src/theory/sets/kinds b/src/theory/sets/kinds index 57120e42e..4ef22d68c 100644 --- a/src/theory/sets/kinds +++ b/src/theory/sets/kinds @@ -5,10 +5,10 @@ # 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 @@ -16,22 +16,22 @@ properties check presolve # 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 @@ -42,10 +42,10 @@ operator SUBSET 2 "subset predicate; first parameter a subset of second 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" @@ -85,30 +85,30 @@ operator TCLOSURE 1 "set transitive closure" 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 diff --git a/src/theory/sets/normal_form.h b/src/theory/sets/normal_form.h index 4033a6b44..197f31903 100644 --- a/src/theory/sets/normal_form.h +++ b/src/theory/sets/normal_form.h @@ -19,7 +19,7 @@ #ifndef CVC4__THEORY__SETS__NORMAL_FORM_H #define CVC4__THEORY__SETS__NORMAL_FORM_H -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -158,6 +158,6 @@ class NormalForm { }; } } -} +} // namespace CVC5 #endif diff --git a/src/theory/sets/rels_utils.h b/src/theory/sets/rels_utils.h index a85e2d27c..eb3477f5a 100644 --- a/src/theory/sets/rels_utils.h +++ b/src/theory/sets/rels_utils.h @@ -21,7 +21,7 @@ #include "expr/dtype_cons.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -95,9 +95,9 @@ public: kind::APPLY_CONSTRUCTOR, dt[0].getConstructor(), a, b); } -}; -}/* CVC4::theory::sets namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +}; +} // namespace sets +} // namespace theory +} // namespace CVC5 #endif diff --git a/src/theory/sets/singleton_op.cpp b/src/theory/sets/singleton_op.cpp index 5ef863fe8..4e76d35e4 100644 --- a/src/theory/sets/singleton_op.cpp +++ b/src/theory/sets/singleton_op.cpp @@ -18,7 +18,7 @@ #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& out, const SingletonOp& op) { @@ -47,4 +47,4 @@ bool SingletonOp::operator==(const SingletonOp& op) const return getType() == op.getType(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/sets/singleton_op.h b/src/theory/sets/singleton_op.h index 7d7bb85b6..d17f8255e 100644 --- a/src/theory/sets/singleton_op.h +++ b/src/theory/sets/singleton_op.h @@ -19,7 +19,7 @@ #include <memory> -namespace CVC4 { +namespace CVC5 { class TypeNode; @@ -58,6 +58,6 @@ struct SingletonOpHashFunction size_t operator()(const SingletonOp& op) const; }; /* struct SingletonOpHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__SINGLETON_OP_H */ diff --git a/src/theory/sets/skolem_cache.cpp b/src/theory/sets/skolem_cache.cpp index 1deb28688..3c0f33caf 100644 --- a/src/theory/sets/skolem_cache.cpp +++ b/src/theory/sets/skolem_cache.cpp @@ -16,9 +16,9 @@ #include "theory/rewriter.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -61,4 +61,4 @@ bool SkolemCache::isSkolem(Node n) const } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/sets/skolem_cache.h b/src/theory/sets/skolem_cache.h index a4997baf0..42369c7a9 100644 --- a/src/theory/sets/skolem_cache.h +++ b/src/theory/sets/skolem_cache.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -78,6 +78,6 @@ class SkolemCache } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__SKOLEM_CACHE_H */ diff --git a/src/theory/sets/solver_state.cpp b/src/theory/sets/solver_state.cpp index 43f8a7d17..ff604f838 100644 --- a/src/theory/sets/solver_state.cpp +++ b/src/theory/sets/solver_state.cpp @@ -19,9 +19,9 @@ #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 { @@ -595,4 +595,4 @@ bool SolverState::merge(TNode t1, } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/sets/solver_state.h b/src/theory/sets/solver_state.h index 06ae41c9a..431aa019d 100644 --- a/src/theory/sets/solver_state.h +++ b/src/theory/sets/solver_state.h @@ -24,7 +24,7 @@ #include "theory/theory_state.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -268,6 +268,6 @@ class SolverState : public TheoryState } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__SETS__THEORY_SOLVER_STATE_H */ diff --git a/src/theory/sets/term_registry.cpp b/src/theory/sets/term_registry.cpp index e32255eab..6dc18591c 100644 --- a/src/theory/sets/term_registry.cpp +++ b/src/theory/sets/term_registry.cpp @@ -17,9 +17,9 @@ #include "expr/emptyset.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -151,4 +151,4 @@ void TermRegistry::debugPrintSet(Node s, const char* c) const } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/sets/term_registry.h b/src/theory/sets/term_registry.h index 204b14504..913473ff0 100644 --- a/src/theory/sets/term_registry.h +++ b/src/theory/sets/term_registry.h @@ -25,7 +25,7 @@ #include "theory/sets/skolem_cache.h" #include "theory/sets/solver_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -89,6 +89,6 @@ class TermRegistry } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__SETS__TERM_REGISTRY_H */ diff --git a/src/theory/sets/theory_sets.cpp b/src/theory/sets/theory_sets.cpp index f3ad57535..1530da809 100644 --- a/src/theory/sets/theory_sets.cpp +++ b/src/theory/sets/theory_sets.cpp @@ -22,9 +22,9 @@ #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 { @@ -236,6 +236,6 @@ void TheorySets::NotifyClass::eqNotifyDisequal(TNode t1, TNode t2, TNode reason) d_theory.eqNotifyDisequal(t1, t2, reason); } -}/* CVC4::theory::sets namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace sets +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/sets/theory_sets.h b/src/theory/sets/theory_sets.h index 56b0d6290..4dc5d8a0d 100644 --- a/src/theory/sets/theory_sets.h +++ b/src/theory/sets/theory_sets.h @@ -29,7 +29,7 @@ #include "theory/theory_eq_notify.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -118,8 +118,8 @@ class TheorySets : public Theory 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 */ diff --git a/src/theory/sets/theory_sets_private.cpp b/src/theory/sets/theory_sets_private.cpp index da2958c5c..285eac473 100644 --- a/src/theory/sets/theory_sets_private.cpp +++ b/src/theory/sets/theory_sets_private.cpp @@ -29,9 +29,9 @@ #include "util/result.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -1372,4 +1372,4 @@ void TheorySetsPrivate::presolve() { d_state.reset(); } } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/sets/theory_sets_private.h b/src/theory/sets/theory_sets_private.h index 329fbfc17..a822d06e7 100644 --- a/src/theory/sets/theory_sets_private.h +++ b/src/theory/sets/theory_sets_private.h @@ -31,7 +31,7 @@ #include "theory/theory.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -234,9 +234,8 @@ class TheorySetsPrivate { 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 */ diff --git a/src/theory/sets/theory_sets_rels.cpp b/src/theory/sets/theory_sets_rels.cpp index 3570aa9d8..a160e0afd 100644 --- a/src/theory/sets/theory_sets_rels.cpp +++ b/src/theory/sets/theory_sets_rels.cpp @@ -19,9 +19,9 @@ #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 { @@ -1333,4 +1333,4 @@ void TheorySetsRels::check(Theory::Effort level) } } } -} +} // namespace CVC5 diff --git a/src/theory/sets/theory_sets_rels.h b/src/theory/sets/theory_sets_rels.h index 6820c6f15..93913d4f5 100644 --- a/src/theory/sets/theory_sets_rels.h +++ b/src/theory/sets/theory_sets_rels.h @@ -28,7 +28,7 @@ #include "theory/theory.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -183,11 +183,8 @@ private: 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_ */ diff --git a/src/theory/sets/theory_sets_rewriter.cpp b/src/theory/sets/theory_sets_rewriter.cpp index 6eef046e6..935eb548d 100644 --- a/src/theory/sets/theory_sets_rewriter.cpp +++ b/src/theory/sets/theory_sets_rewriter.cpp @@ -22,9 +22,9 @@ #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 { @@ -540,6 +540,6 @@ RewriteResponse TheorySetsRewriter::preRewrite(TNode node) { return RewriteResponse(REWRITE_DONE, node); } -}/* CVC4::theory::sets namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace sets +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/sets/theory_sets_rewriter.h b/src/theory/sets/theory_sets_rewriter.h index eeecf06a7..739a5f885 100644 --- a/src/theory/sets/theory_sets_rewriter.h +++ b/src/theory/sets/theory_sets_rewriter.h @@ -21,7 +21,7 @@ #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -77,8 +77,8 @@ private: 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 */ diff --git a/src/theory/sets/theory_sets_type_enumerator.cpp b/src/theory/sets/theory_sets_type_enumerator.cpp index ceb87d8ec..30e279be7 100644 --- a/src/theory/sets/theory_sets_type_enumerator.cpp +++ b/src/theory/sets/theory_sets_type_enumerator.cpp @@ -16,7 +16,7 @@ #include "theory/sets/theory_sets_type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -130,4 +130,4 @@ bool SetEnumerator::isFinished() } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/sets/theory_sets_type_enumerator.h b/src/theory/sets/theory_sets_type_enumerator.h index 4aaf07035..32aca5f79 100644 --- a/src/theory/sets/theory_sets_type_enumerator.h +++ b/src/theory/sets/theory_sets_type_enumerator.h @@ -26,7 +26,7 @@ #include "theory/sets/normal_form.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -68,6 +68,6 @@ class SetEnumerator : public TypeEnumeratorBase<SetEnumerator> } // namespace sets } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__SETS__TYPE_ENUMERATOR_H */ diff --git a/src/theory/sets/theory_sets_type_rules.h b/src/theory/sets/theory_sets_type_rules.h index 9f7875e18..54791ac31 100644 --- a/src/theory/sets/theory_sets_type_rules.h +++ b/src/theory/sets/theory_sets_type_rules.h @@ -23,7 +23,7 @@ #include "theory/sets/normal_form.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace sets { @@ -390,7 +390,7 @@ struct JoinImageTypeRule { 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"); @@ -442,8 +442,8 @@ struct SetsProperties { } };/* 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 */ diff --git a/src/theory/shared_solver.cpp b/src/theory/shared_solver.cpp index 87625291c..816ceb31a 100644 --- a/src/theory/shared_solver.cpp +++ b/src/theory/shared_solver.cpp @@ -19,7 +19,7 @@ #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 @@ -130,4 +130,4 @@ bool SharedSolver::propagateSharedEquality(theory::TheoryId theory, bool SharedSolver::isShared(TNode t) const { return d_sharedTerms.isShared(t); } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/shared_solver.h b/src/theory/shared_solver.h index a4d08bd1b..8463e1d46 100644 --- a/src/theory/shared_solver.h +++ b/src/theory/shared_solver.h @@ -22,7 +22,7 @@ #include "theory/term_registration_visitor.h" #include "theory/valuation.h" -namespace CVC4 { +namespace CVC5 { class LogicInfo; class ProofNodeManager; @@ -134,6 +134,6 @@ class SharedSolver }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__SHARED_SOLVER__H */ diff --git a/src/theory/shared_solver_distributed.cpp b/src/theory/shared_solver_distributed.cpp index 958cfa617..70932e6a6 100644 --- a/src/theory/shared_solver_distributed.cpp +++ b/src/theory/shared_solver_distributed.cpp @@ -16,7 +16,7 @@ #include "theory/theory_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { SharedSolverDistributed::SharedSolverDistributed(TheoryEngine& te, @@ -93,4 +93,4 @@ void SharedSolverDistributed::assertSharedEquality(TNode equality, } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/shared_solver_distributed.h b/src/theory/shared_solver_distributed.h index 6c090fd09..95e23024d 100644 --- a/src/theory/shared_solver_distributed.h +++ b/src/theory/shared_solver_distributed.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "theory/shared_solver.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -59,6 +59,6 @@ class SharedSolverDistributed : public SharedSolver }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__SHARED_SOLVER_DISTRIBUTED__H */ diff --git a/src/theory/shared_terms_database.cpp b/src/theory/shared_terms_database.cpp index 4b3c1f612..e82897c98 100644 --- a/src/theory/shared_terms_database.cpp +++ b/src/theory/shared_terms_database.cpp @@ -19,9 +19,9 @@ #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, @@ -317,4 +317,4 @@ theory::TrustNode SharedTermsDatabase::explain(TNode literal) const return TrustNode::mkTrustPropExp(literal, exp, nullptr); } -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/theory/shared_terms_database.h b/src/theory/shared_terms_database.h index 2a6e5ebbf..a7bc77251 100644 --- a/src/theory/shared_terms_database.h +++ b/src/theory/shared_terms_database.h @@ -29,7 +29,7 @@ #include "theory/uf/proof_equality_engine.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { class TheoryEngine; @@ -278,4 +278,4 @@ class SharedTermsDatabase : public context::ContextNotifyObj { ProofNodeManager* d_pnm; }; -} +} // namespace CVC5 diff --git a/src/theory/skolem_lemma.cpp b/src/theory/skolem_lemma.cpp index 7c8f00dd7..1b10d3ac8 100644 --- a/src/theory/skolem_lemma.cpp +++ b/src/theory/skolem_lemma.cpp @@ -16,7 +16,7 @@ #include "expr/skolem_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { SkolemLemma::SkolemLemma(TrustNode lem, Node k) : d_lemma(lem), d_skolem(k) @@ -40,4 +40,4 @@ Node SkolemLemma::getSkolemLemmaFor(Node k) } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/skolem_lemma.h b/src/theory/skolem_lemma.h index c669b527d..c7ab08429 100644 --- a/src/theory/skolem_lemma.h +++ b/src/theory/skolem_lemma.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -59,6 +59,6 @@ class SkolemLemma }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__SKOLEM_LEMMA_H */ diff --git a/src/theory/smt_engine_subsolver.cpp b/src/theory/smt_engine_subsolver.cpp index 041ed41a1..15e9b4214 100644 --- a/src/theory/smt_engine_subsolver.cpp +++ b/src/theory/smt_engine_subsolver.cpp @@ -19,7 +19,7 @@ #include "smt/smt_engine_scope.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { // optimization: try to rewrite to constant @@ -119,4 +119,4 @@ Result checkWithSubsolver(Node query, } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/smt_engine_subsolver.h b/src/theory/smt_engine_subsolver.h index cc99e75b4..d94f9227d 100644 --- a/src/theory/smt_engine_subsolver.h +++ b/src/theory/smt_engine_subsolver.h @@ -24,7 +24,7 @@ #include "expr/node.h" #include "smt/smt_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -91,6 +91,6 @@ Result checkWithSubsolver(Node query, unsigned long timeout = 0); } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__SMT_ENGINE_SUBSOLVER_H */ diff --git a/src/theory/sort_inference.cpp b/src/theory/sort_inference.cpp index e9e788160..cad11fcf3 100644 --- a/src/theory/sort_inference.cpp +++ b/src/theory/sort_inference.cpp @@ -30,11 +30,11 @@ #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){ @@ -869,4 +869,4 @@ bool SortInference::isHandledApplyUf(Kind k) const } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/sort_inference.h b/src/theory/sort_inference.h index 822416da3..b32026256 100644 --- a/src/theory/sort_inference.h +++ b/src/theory/sort_inference.h @@ -23,7 +23,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** sort inference @@ -166,6 +166,6 @@ private: }; } // namespace theory -} +} // namespace CVC5 #endif diff --git a/src/theory/strings/arith_entail.cpp b/src/theory/strings/arith_entail.cpp index f8abc9aef..36ead8685 100644 --- a/src/theory/strings/arith_entail.cpp +++ b/src/theory/strings/arith_entail.cpp @@ -22,9 +22,9 @@ #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 { @@ -866,4 +866,4 @@ bool ArithEntail::inferZerosInSumGeq(Node x, } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/arith_entail.h b/src/theory/strings/arith_entail.h index cd933ad26..22011d51b 100644 --- a/src/theory/strings/arith_entail.h +++ b/src/theory/strings/arith_entail.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -175,6 +175,6 @@ class ArithEntail } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/strings/base_solver.cpp b/src/theory/strings/base_solver.cpp index 8a8abbf81..b9802b9a5 100644 --- a/src/theory/strings/base_solver.cpp +++ b/src/theory/strings/base_solver.cpp @@ -22,10 +22,10 @@ #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 { @@ -760,4 +760,4 @@ Node BaseSolver::TermIndex::add(TNode n, } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/base_solver.h b/src/theory/strings/base_solver.h index 76273c747..43cb63b47 100644 --- a/src/theory/strings/base_solver.h +++ b/src/theory/strings/base_solver.h @@ -26,7 +26,7 @@ #include "theory/strings/skolem_cache.h" #include "theory/strings/solver_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -243,6 +243,6 @@ class BaseSolver } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__BASE_SOLVER_H */ diff --git a/src/theory/strings/core_solver.cpp b/src/theory/strings/core_solver.cpp index 3c5bcc98d..8593a1e36 100644 --- a/src/theory/strings/core_solver.cpp +++ b/src/theory/strings/core_solver.cpp @@ -26,10 +26,10 @@ #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 { @@ -2649,6 +2649,6 @@ bool CoreSolver::processInferInfo(CoreInferInfo& cii) return true; } -}/* CVC4::theory::strings namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace strings +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/strings/core_solver.h b/src/theory/strings/core_solver.h index 94f47f6c3..53bb167c4 100644 --- a/src/theory/strings/core_solver.h +++ b/src/theory/strings/core_solver.h @@ -27,7 +27,7 @@ #include "theory/strings/solver_state.h" #include "theory/strings/term_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -523,6 +523,6 @@ class CoreSolver } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__CORE_SOLVER_H */ diff --git a/src/theory/strings/eager_solver.cpp b/src/theory/strings/eager_solver.cpp index be122f869..e2cb01408 100644 --- a/src/theory/strings/eager_solver.cpp +++ b/src/theory/strings/eager_solver.cpp @@ -16,9 +16,9 @@ #include "theory/strings/theory_strings_utils.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -148,4 +148,4 @@ void EagerSolver::notifyFact(TNode atom, } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/eager_solver.h b/src/theory/strings/eager_solver.h index b30968e0b..49545e622 100644 --- a/src/theory/strings/eager_solver.h +++ b/src/theory/strings/eager_solver.h @@ -23,7 +23,7 @@ #include "theory/strings/eqc_info.h" #include "theory/strings/solver_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -63,6 +63,6 @@ class EagerSolver } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__EAGER_SOLVER_H */ diff --git a/src/theory/strings/eqc_info.cpp b/src/theory/strings/eqc_info.cpp index 81515fc54..0bb2defb6 100644 --- a/src/theory/strings/eqc_info.cpp +++ b/src/theory/strings/eqc_info.cpp @@ -18,10 +18,10 @@ #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 { @@ -139,4 +139,4 @@ Node EqcInfo::addEndpointConst(Node t, Node c, bool isSuf) } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/eqc_info.h b/src/theory/strings/eqc_info.h index 842360f5d..a00cd49ea 100644 --- a/src/theory/strings/eqc_info.h +++ b/src/theory/strings/eqc_info.h @@ -23,7 +23,7 @@ #include "context/context.h" #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -76,6 +76,6 @@ class EqcInfo } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__EQC_INFO_H */ diff --git a/src/theory/strings/extf_solver.cpp b/src/theory/strings/extf_solver.cpp index d721abf71..ab7c1d0ac 100644 --- a/src/theory/strings/extf_solver.cpp +++ b/src/theory/strings/extf_solver.cpp @@ -20,10 +20,10 @@ #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 { @@ -724,4 +724,4 @@ bool StringsExtfCallback::getCurrentSubstitution( } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/extf_solver.h b/src/theory/strings/extf_solver.h index 10e380e94..4b63f261a 100644 --- a/src/theory/strings/extf_solver.h +++ b/src/theory/strings/extf_solver.h @@ -32,7 +32,7 @@ #include "theory/strings/strings_rewriter.h" #include "theory/strings/theory_strings_preprocess.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -227,6 +227,6 @@ class StringsExtfCallback : public ExtTheoryCallback } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__EXTF_SOLVER_H */ diff --git a/src/theory/strings/infer_info.cpp b/src/theory/strings/infer_info.cpp index 8d276d60e..5e2006f65 100644 --- a/src/theory/strings/infer_info.cpp +++ b/src/theory/strings/infer_info.cpp @@ -17,7 +17,7 @@ #include "theory/strings/inference_manager.h" #include "theory/strings/theory_strings_utils.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -90,4 +90,4 @@ std::ostream& operator<<(std::ostream& out, const InferInfo& ii) } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/infer_info.h b/src/theory/strings/infer_info.h index af415ecd9..9c228c197 100644 --- a/src/theory/strings/infer_info.h +++ b/src/theory/strings/infer_info.h @@ -25,7 +25,7 @@ #include "theory/theory_inference.h" #include "util/safe_print.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -131,6 +131,6 @@ std::ostream& operator<<(std::ostream& out, const InferInfo& ii); } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__INFER_INFO_H */ diff --git a/src/theory/strings/infer_proof_cons.cpp b/src/theory/strings/infer_proof_cons.cpp index a02566a41..c600ce31d 100644 --- a/src/theory/strings/infer_proof_cons.cpp +++ b/src/theory/strings/infer_proof_cons.cpp @@ -23,9 +23,9 @@ #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 { @@ -1042,4 +1042,4 @@ std::string InferProofCons::identify() const } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/infer_proof_cons.h b/src/theory/strings/infer_proof_cons.h index 7484959b8..7d7d7e54a 100644 --- a/src/theory/strings/infer_proof_cons.h +++ b/src/theory/strings/infer_proof_cons.h @@ -28,7 +28,7 @@ #include "theory/theory_proof_step_buffer.h" #include "theory/uf/proof_equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -130,6 +130,6 @@ class InferProofCons : public ProofGenerator } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__INFER_PROOF_CONS_H */ diff --git a/src/theory/strings/inference_manager.cpp b/src/theory/strings/inference_manager.cpp index 0d4839238..15e608ef1 100644 --- a/src/theory/strings/inference_manager.cpp +++ b/src/theory/strings/inference_manager.cpp @@ -21,10 +21,10 @@ #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 { @@ -377,4 +377,4 @@ TrustNode InferenceManager::processLemma(InferInfo& ii, LemmaProperty& p) } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/inference_manager.h b/src/theory/strings/inference_manager.h index 9fbe10637..1e57afe79 100644 --- a/src/theory/strings/inference_manager.h +++ b/src/theory/strings/inference_manager.h @@ -35,7 +35,7 @@ #include "theory/theory_inference_manager.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -271,6 +271,6 @@ class InferenceManager : public InferenceManagerBuffered } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/strings/kinds b/src/theory/strings/kinds index 427e2e4e6..6f366d6d7 100644 --- a/src/theory/strings/kinds +++ b/src/theory/strings/kinds @@ -4,11 +4,11 @@ # 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" @@ -42,7 +42,7 @@ operator STRING_REV 1 "string reverse" sort STRING_TYPE \ Cardinality::INTEGERS \ well-founded \ - "NodeManager::currentNM()->mkConst(::CVC4::String())" \ + "NodeManager::currentNM()->mkConst(::CVC5::String())" \ "util/string.h" \ "String type" @@ -54,31 +54,31 @@ sort REGEXP_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" @@ -102,17 +102,17 @@ operator REGEXP_EMPTY 0 "regexp empty" 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 @@ -128,7 +128,7 @@ typerule REGEXP_DIFF "SimpleTypeRuleVar<RRegExp, ARegExp>" 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>" @@ -141,18 +141,18 @@ typerule REGEXP_SIGMA "SimpleTypeRule<RRegExp>" ### 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 @@ -169,9 +169,9 @@ typerule STRING_TOLOWER "SimpleTypeRule<RString, AString>" ### 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 diff --git a/src/theory/strings/normal_form.cpp b/src/theory/strings/normal_form.cpp index 5cc101a9f..c139a5da7 100644 --- a/src/theory/strings/normal_form.cpp +++ b/src/theory/strings/normal_form.cpp @@ -21,9 +21,9 @@ #include "theory/strings/word.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -185,4 +185,4 @@ void NormalForm::getExplanationForPrefixEq(NormalForm& nfi, } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/normal_form.h b/src/theory/strings/normal_form.h index cadaa2c6e..65d4b3f78 100644 --- a/src/theory/strings/normal_form.h +++ b/src/theory/strings/normal_form.h @@ -21,7 +21,7 @@ #include <vector> #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -168,6 +168,6 @@ class NormalForm } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__NORMAL_FORM_H */ diff --git a/src/theory/strings/proof_checker.cpp b/src/theory/strings/proof_checker.cpp index 5cae7c69f..bf82d16ce 100644 --- a/src/theory/strings/proof_checker.cpp +++ b/src/theory/strings/proof_checker.cpp @@ -25,9 +25,9 @@ #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 { @@ -517,4 +517,4 @@ Node StringProofRuleChecker::checkInternal(PfRule id, } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/proof_checker.h b/src/theory/strings/proof_checker.h index 5f6b779c0..c55386140 100644 --- a/src/theory/strings/proof_checker.h +++ b/src/theory/strings/proof_checker.h @@ -21,7 +21,7 @@ #include "expr/proof_checker.h" #include "expr/proof_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -44,6 +44,6 @@ class StringProofRuleChecker : public ProofRuleChecker } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__PROOF_CHECKER_H */ diff --git a/src/theory/strings/regexp_elim.cpp b/src/theory/strings/regexp_elim.cpp index de67fc9bf..5dbe02230 100644 --- a/src/theory/strings/regexp_elim.cpp +++ b/src/theory/strings/regexp_elim.cpp @@ -21,9 +21,9 @@ #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 { @@ -613,4 +613,4 @@ bool RegExpElimination::isProofEnabled() const { return d_pnm != nullptr; } } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/regexp_elim.h b/src/theory/strings/regexp_elim.h index 9c9733a95..3ffa9566e 100644 --- a/src/theory/strings/regexp_elim.h +++ b/src/theory/strings/regexp_elim.h @@ -21,7 +21,7 @@ #include "theory/eager_proof_generator.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -85,6 +85,6 @@ class RegExpElimination } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__REGEXP_ELIM_H */ diff --git a/src/theory/strings/regexp_entail.cpp b/src/theory/strings/regexp_entail.cpp index 0e4d6dd8e..94c740742 100644 --- a/src/theory/strings/regexp_entail.cpp +++ b/src/theory/strings/regexp_entail.cpp @@ -19,9 +19,9 @@ #include "theory/strings/word.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -105,7 +105,7 @@ Node RegExpEntail::simpleRegexpConsume(std::vector<Node>& mchildren, 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; @@ -117,7 +117,7 @@ Node RegExpEntail::simpleRegexpConsume(std::vector<Node>& mchildren, { 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 @@ -345,7 +345,7 @@ bool RegExpEntail::isConstRegExp(TNode t) return true; } -bool RegExpEntail::testConstStringInRegExp(CVC4::String& s, +bool RegExpEntail::testConstStringInRegExp(CVC5::String& s, unsigned index_start, TNode r) { @@ -358,7 +358,7 @@ bool RegExpEntail::testConstStringInRegExp(CVC4::String& s, { 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>()); @@ -392,7 +392,7 @@ bool RegExpEntail::testConstStringInRegExp(CVC4::String& s, { 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]; @@ -457,7 +457,7 @@ bool RegExpEntail::testConstStringInRegExp(CVC4::String& s, { 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() @@ -525,7 +525,7 @@ bool RegExpEntail::testConstStringInRegExp(CVC4::String& s, 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()) @@ -534,7 +534,7 @@ bool RegExpEntail::testConstStringInRegExp(CVC4::String& s, } 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)) { @@ -563,10 +563,10 @@ bool RegExpEntail::testConstStringInRegExp(CVC4::String& s, } 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)) { @@ -761,4 +761,4 @@ bool RegExpEntail::regExpIncludes(Node r1, Node r2) } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/regexp_entail.h b/src/theory/strings/regexp_entail.h index f4359aa76..3e14d4ed0 100644 --- a/src/theory/strings/regexp_entail.h +++ b/src/theory/strings/regexp_entail.h @@ -26,7 +26,7 @@ #include "theory/theory_rewriter.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -97,7 +97,7 @@ class RegExpEntail * 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? */ @@ -127,6 +127,6 @@ class RegExpEntail } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__REGEXP_ENTAIL_H */ diff --git a/src/theory/strings/regexp_operation.cpp b/src/theory/strings/regexp_operation.cpp index ad71e98fd..5481a0c6d 100644 --- a/src/theory/strings/regexp_operation.cpp +++ b/src/theory/strings/regexp_operation.cpp @@ -25,9 +25,9 @@ #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 { @@ -36,8 +36,8 @@ RegExpOpr::RegExpOpr(SkolemCache* sc) 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( @@ -266,7 +266,8 @@ int RegExpOpr::delta( Node r, Node &exp ) { } // 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; @@ -301,8 +302,8 @@ int RegExpOpr::derivativeS( Node r, CVC4::String c, Node &retNode ) { 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; } @@ -520,7 +521,8 @@ int RegExpOpr::derivativeS( Node r, CVC4::String c, Node &retNode ) { 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; @@ -553,8 +555,8 @@ Node RegExpOpr::derivativeSingle( Node r, CVC4::String c ) { 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; } @@ -1310,7 +1312,9 @@ Node RegExpOpr::intersectInternal( Node r1, Node r2, std::map< PairNodes, Node > 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; } @@ -1613,6 +1617,6 @@ Node RegExpOpr::getExistsForRegExpConcatMem(Node mem) return eform; } -}/* CVC4::theory::strings namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace strings +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/strings/regexp_operation.h b/src/theory/strings/regexp_operation.h index 8c0cd6c14..27324d971 100644 --- a/src/theory/strings/regexp_operation.h +++ b/src/theory/strings/regexp_operation.h @@ -28,7 +28,7 @@ #include "theory/strings/skolem_cache.h" #include "util/string.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -55,7 +55,7 @@ enum RegExpConstType }; 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; @@ -171,8 +171,8 @@ class RegExpOpr { * - 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. @@ -207,8 +207,8 @@ class RegExpOpr { 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 */ diff --git a/src/theory/strings/regexp_solver.cpp b/src/theory/strings/regexp_solver.cpp index f252196d8..861f7c694 100644 --- a/src/theory/strings/regexp_solver.cpp +++ b/src/theory/strings/regexp_solver.cpp @@ -25,10 +25,10 @@ #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 { @@ -48,7 +48,7 @@ RegExpSolver::RegExpSolver(SolverState& s, 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); @@ -582,7 +582,7 @@ bool RegExpSolver::checkPDerivative( return true; } -CVC4::String RegExpSolver::getHeadConst(Node x) +CVC5::String RegExpSolver::getHeadConst(Node x) { if (x.isConst()) { @@ -606,7 +606,7 @@ bool RegExpSolver::deriveRegExp(Node x, 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) { @@ -615,7 +615,7 @@ bool RegExpSolver::deriveRegExp(Node x, 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; @@ -706,4 +706,4 @@ Node RegExpSolver::getNormalSymRegExp(Node r, std::vector<Node>& nf_exp) } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/regexp_solver.h b/src/theory/strings/regexp_solver.h index 50e58140d..d35a822a7 100644 --- a/src/theory/strings/regexp_solver.h +++ b/src/theory/strings/regexp_solver.h @@ -31,7 +31,7 @@ #include "theory/strings/solver_state.h" #include "util/string.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -137,7 +137,7 @@ class RegExpSolver 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 @@ -154,6 +154,6 @@ class RegExpSolver } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__THEORY_STRINGS_H */ diff --git a/src/theory/strings/rewrites.cpp b/src/theory/strings/rewrites.cpp index 9788bc173..cdf41d9ad 100644 --- a/src/theory/strings/rewrites.cpp +++ b/src/theory/strings/rewrites.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -224,4 +224,4 @@ std::ostream& operator<<(std::ostream& out, Rewrite r) } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/rewrites.h b/src/theory/strings/rewrites.h index 26e3629ff..af9b636cf 100644 --- a/src/theory/strings/rewrites.h +++ b/src/theory/strings/rewrites.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -239,6 +239,6 @@ std::ostream& operator<<(std::ostream& out, Rewrite r); } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__REWRITES_H */ diff --git a/src/theory/strings/sequences_rewriter.cpp b/src/theory/strings/sequences_rewriter.cpp index c54cdfb50..9cec9ad40 100644 --- a/src/theory/strings/sequences_rewriter.cpp +++ b/src/theory/strings/sequences_rewriter.cpp @@ -27,9 +27,9 @@ #include "theory/strings/word.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -1028,7 +1028,7 @@ Node SequencesRewriter::rewriteLoopRegExp(TNode node) 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++) @@ -1141,7 +1141,7 @@ Node SequencesRewriter::rewriteMembership(TNode node) 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); @@ -1571,7 +1571,7 @@ Node SequencesRewriter::rewriteSubstr(Node node) 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) { @@ -1628,7 +1628,7 @@ Node SequencesRewriter::rewriteSubstr(Node node) } } } - 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)) @@ -1858,7 +1858,7 @@ Node SequencesRewriter::rewriteUpdate(Node node) // 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 @@ -2266,7 +2266,7 @@ Node SequencesRewriter::rewriteIndexof(Node node) 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 @@ -3230,7 +3230,7 @@ Node SequencesRewriter::rewritePrefixSuffix(Node n) Node val; if (isPrefix) { - val = NodeManager::currentNM()->mkConst(::CVC4::Rational(0)); + val = NodeManager::currentNM()->mkConst(::CVC5::Rational(0)); } else { @@ -3396,4 +3396,4 @@ Node SequencesRewriter::returnRewrite(Node node, Node ret, Rewrite r) } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/sequences_rewriter.h b/src/theory/strings/sequences_rewriter.h index 9f5b002af..750589f72 100644 --- a/src/theory/strings/sequences_rewriter.h +++ b/src/theory/strings/sequences_rewriter.h @@ -26,7 +26,7 @@ #include "theory/strings/strings_entail.h" #include "theory/theory_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -296,6 +296,6 @@ class SequencesRewriter : public TheoryRewriter } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__SEQUENCES_REWRITER_H */ diff --git a/src/theory/strings/sequences_stats.cpp b/src/theory/strings/sequences_stats.cpp index c679bc414..919b950ab 100644 --- a/src/theory/strings/sequences_stats.cpp +++ b/src/theory/strings/sequences_stats.cpp @@ -16,7 +16,7 @@ #include "smt/smt_statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -63,4 +63,4 @@ SequencesStatistics::~SequencesStatistics() } } -} +} // namespace CVC5 diff --git a/src/theory/strings/sequences_stats.h b/src/theory/strings/sequences_stats.h index 1a0e94cdb..417f79046 100644 --- a/src/theory/strings/sequences_stats.h +++ b/src/theory/strings/sequences_stats.h @@ -23,7 +23,7 @@ #include "util/statistics_registry.h" #include "util/stats_histogram.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -99,6 +99,6 @@ class SequencesStatistics } } -} +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__SEQUENCES_STATS_H */ diff --git a/src/theory/strings/skolem_cache.cpp b/src/theory/strings/skolem_cache.cpp index 3ddcdbf71..5e2d8981d 100644 --- a/src/theory/strings/skolem_cache.cpp +++ b/src/theory/strings/skolem_cache.cpp @@ -23,9 +23,9 @@ #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 { @@ -291,4 +291,4 @@ Node SkolemCache::mkIndexVar(Node t) } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/skolem_cache.h b/src/theory/strings/skolem_cache.h index e4a9ef17e..b6deea6eb 100644 --- a/src/theory/strings/skolem_cache.h +++ b/src/theory/strings/skolem_cache.h @@ -24,7 +24,7 @@ #include "expr/node.h" #include "expr/skolem_manager.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -211,6 +211,6 @@ class SkolemCache } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__SKOLEM_CACHE_H */ diff --git a/src/theory/strings/solver_state.cpp b/src/theory/strings/solver_state.cpp index 456cd492b..00bb39d5c 100644 --- a/src/theory/strings/solver_state.cpp +++ b/src/theory/strings/solver_state.cpp @@ -19,10 +19,10 @@ #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 { @@ -223,4 +223,4 @@ void SolverState::separateByLength( } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/solver_state.h b/src/theory/strings/solver_state.h index e9786526c..8c5d29196 100644 --- a/src/theory/strings/solver_state.h +++ b/src/theory/strings/solver_state.h @@ -29,7 +29,7 @@ #include "theory/uf/equality_engine.h" #include "theory/valuation.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -161,6 +161,6 @@ class SolverState : public TheoryState } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__SOLVER_STATE_H */ diff --git a/src/theory/strings/strategy.cpp b/src/theory/strings/strategy.cpp index 2e2e8bc22..56c1cbe98 100644 --- a/src/theory/strings/strategy.cpp +++ b/src/theory/strings/strategy.cpp @@ -16,7 +16,7 @@ #include "options/strings_options.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -158,4 +158,4 @@ void Strategy::initializeStrategy() } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/strategy.h b/src/theory/strings/strategy.h index fde01878d..4c2e587c9 100644 --- a/src/theory/strings/strategy.h +++ b/src/theory/strings/strategy.h @@ -22,7 +22,7 @@ #include "theory/theory.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -111,6 +111,6 @@ class Strategy } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__STRATEGY_H */ diff --git a/src/theory/strings/strings_entail.cpp b/src/theory/strings/strings_entail.cpp index f4c91d39f..926a43159 100644 --- a/src/theory/strings/strings_entail.cpp +++ b/src/theory/strings/strings_entail.cpp @@ -21,9 +21,9 @@ #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 { @@ -117,7 +117,7 @@ bool StringsEntail::stripSymbolicLength(std::vector<Node>& n1, 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; @@ -139,7 +139,7 @@ bool StringsEntail::stripSymbolicLength(std::vector<Node>& n1, 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()); @@ -602,7 +602,7 @@ bool StringsEntail::stripConstantEndpoints(std::vector<Node>& n1, 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 @@ -993,4 +993,4 @@ Node StringsEntail::inferEqsFromContains(Node x, Node y) } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/strings_entail.h b/src/theory/strings/strings_entail.h index d5f4ac0d4..16643332a 100644 --- a/src/theory/strings/strings_entail.h +++ b/src/theory/strings/strings_entail.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -379,6 +379,6 @@ class StringsEntail } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__STRING_ENTAIL_H */ diff --git a/src/theory/strings/strings_fmf.cpp b/src/theory/strings/strings_fmf.cpp index 0ce83dbd0..11a743d0d 100644 --- a/src/theory/strings/strings_fmf.cpp +++ b/src/theory/strings/strings_fmf.cpp @@ -16,10 +16,10 @@ #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 { @@ -102,4 +102,4 @@ std::string StringsFmf::StringSumLengthDecisionStrategy::identify() const } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/strings_fmf.h b/src/theory/strings/strings_fmf.h index 6832da5a7..1ef610289 100644 --- a/src/theory/strings/strings_fmf.h +++ b/src/theory/strings/strings_fmf.h @@ -25,7 +25,7 @@ #include "theory/strings/term_registry.h" #include "theory/valuation.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -106,6 +106,6 @@ class StringsFmf } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__STRINGS_FMF_H */ diff --git a/src/theory/strings/strings_rewriter.cpp b/src/theory/strings/strings_rewriter.cpp index 33e7cd895..d41a86c18 100644 --- a/src/theory/strings/strings_rewriter.cpp +++ b/src/theory/strings/strings_rewriter.cpp @@ -19,9 +19,9 @@ #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 { @@ -324,4 +324,4 @@ Node StringsRewriter::rewriteStringIsDigit(Node n) } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/strings_rewriter.h b/src/theory/strings/strings_rewriter.h index 1398d4703..226a66b34 100644 --- a/src/theory/strings/strings_rewriter.h +++ b/src/theory/strings/strings_rewriter.h @@ -21,7 +21,7 @@ #include "expr/node.h" #include "theory/strings/sequences_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -103,6 +103,6 @@ class StringsRewriter : public SequencesRewriter } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__STRINGS_REWRITER_H */ diff --git a/src/theory/strings/term_registry.cpp b/src/theory/strings/term_registry.cpp index f24fe12e5..d82a2333e 100644 --- a/src/theory/strings/term_registry.cpp +++ b/src/theory/strings/term_registry.cpp @@ -24,10 +24,10 @@ #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 { @@ -618,4 +618,4 @@ void TermRegistry::removeProxyEqs(Node n, std::vector<Node>& unproc) const } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/term_registry.h b/src/theory/strings/term_registry.h index cb1b50816..2f03647fd 100644 --- a/src/theory/strings/term_registry.h +++ b/src/theory/strings/term_registry.h @@ -28,7 +28,7 @@ #include "theory/strings/solver_state.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -279,6 +279,6 @@ class TermRegistry } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__TERM_REGISTRY_H */ diff --git a/src/theory/strings/theory_strings.cpp b/src/theory/strings/theory_strings.cpp index 7a8b44625..03d93f8f4 100644 --- a/src/theory/strings/theory_strings.cpp +++ b/src/theory/strings/theory_strings.cpp @@ -29,10 +29,10 @@ #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 { @@ -1086,6 +1086,6 @@ std::string TheoryStrings::debugPrintStringsEqc() return ss.str(); } -}/* CVC4::theory::strings namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace strings +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/strings/theory_strings.h b/src/theory/strings/theory_strings.h index f35c67da6..94a96fc33 100644 --- a/src/theory/strings/theory_strings.h +++ b/src/theory/strings/theory_strings.h @@ -46,7 +46,7 @@ #include "theory/theory.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -299,8 +299,8 @@ class TheoryStrings : public Theory { 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 */ diff --git a/src/theory/strings/theory_strings_preprocess.cpp b/src/theory/strings/theory_strings_preprocess.cpp index d6fa91f34..f89ffa5fa 100644 --- a/src/theory/strings/theory_strings_preprocess.cpp +++ b/src/theory/strings/theory_strings_preprocess.cpp @@ -26,10 +26,10 @@ #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 { @@ -1026,6 +1026,6 @@ Node StringsPreprocess::mkForallInternal(Node bvl, Node body) return nm->mkNode(FORALL, bvl, body, ipl); } -}/* CVC4::theory::strings namespace */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace strings +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/strings/theory_strings_preprocess.h b/src/theory/strings/theory_strings_preprocess.h index a947c6da6..acf9edad7 100644 --- a/src/theory/strings/theory_strings_preprocess.h +++ b/src/theory/strings/theory_strings_preprocess.h @@ -27,7 +27,7 @@ #include "theory/theory.h" #include "util/hash.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -102,8 +102,8 @@ class StringsPreprocess { 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 */ diff --git a/src/theory/strings/theory_strings_type_rules.h b/src/theory/strings/theory_strings_type_rules.h index fd5d2611e..32605f0f1 100644 --- a/src/theory/strings/theory_strings_type_rules.h +++ b/src/theory/strings/theory_strings_type_rules.h @@ -22,7 +22,7 @@ #include "expr/sequence.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -424,8 +424,8 @@ struct SequenceProperties } }; /* 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 */ diff --git a/src/theory/strings/theory_strings_utils.cpp b/src/theory/strings/theory_strings_utils.cpp index 73cdf1ddb..821319df5 100644 --- a/src/theory/strings/theory_strings_utils.cpp +++ b/src/theory/strings/theory_strings_utils.cpp @@ -24,9 +24,9 @@ #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 { @@ -423,4 +423,4 @@ unsigned getLoopMinOccurrences(TNode node) } // namespace utils } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/theory_strings_utils.h b/src/theory/strings/theory_strings_utils.h index 6b53a102d..e720ce0b2 100644 --- a/src/theory/strings/theory_strings_utils.h +++ b/src/theory/strings/theory_strings_utils.h @@ -23,7 +23,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { namespace utils { @@ -220,6 +220,6 @@ unsigned getLoopMinOccurrences(TNode node); } // namespace utils } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/strings/type_enumerator.cpp b/src/theory/strings/type_enumerator.cpp index 5def8ec4b..7b89e970e 100644 --- a/src/theory/strings/type_enumerator.cpp +++ b/src/theory/strings/type_enumerator.cpp @@ -17,7 +17,7 @@ #include "theory/strings/theory_strings_utils.h" #include "util/string.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -271,4 +271,4 @@ bool SequenceEnumerator::isFinished() { return d_wenum.isFinished(); } } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/type_enumerator.h b/src/theory/strings/type_enumerator.h index 02d3e7f41..7d340be64 100644 --- a/src/theory/strings/type_enumerator.h +++ b/src/theory/strings/type_enumerator.h @@ -23,7 +23,7 @@ #include "expr/type_node.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -197,8 +197,8 @@ class SequenceEnumerator : public TypeEnumeratorBase<SequenceEnumerator> 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 */ diff --git a/src/theory/strings/word.cpp b/src/theory/strings/word.cpp index 0c743dd93..d2e809571 100644 --- a/src/theory/strings/word.cpp +++ b/src/theory/strings/word.cpp @@ -17,9 +17,9 @@ #include "expr/sequence.h" #include "util/string.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -486,4 +486,4 @@ Node Word::reverse(TNode x) } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/strings/word.h b/src/theory/strings/word.h index 1b2c94af5..090c36be3 100644 --- a/src/theory/strings/word.h +++ b/src/theory/strings/word.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace strings { @@ -165,6 +165,6 @@ class Word } // namespace strings } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/subs_minimize.cpp b/src/theory/subs_minimize.cpp index 88434cba2..b9e9e13b2 100644 --- a/src/theory/subs_minimize.cpp +++ b/src/theory/subs_minimize.cpp @@ -20,9 +20,9 @@ #include "theory/strings/word.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { SubstitutionMinimize::SubstitutionMinimize() {} @@ -466,4 +466,4 @@ bool SubstitutionMinimize::isSingularArg(Node n, Kind k, unsigned arg) } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/subs_minimize.h b/src/theory/subs_minimize.h index 018e0e11b..9275277e6 100644 --- a/src/theory/subs_minimize.h +++ b/src/theory/subs_minimize.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** SubstitutionMinimize @@ -95,6 +95,6 @@ class SubstitutionMinimize }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__SUBS_MINIMIZE_H */ diff --git a/src/theory/substitutions.cpp b/src/theory/substitutions.cpp index 3618cc0d5..bdb6d2668 100644 --- a/src/theory/substitutions.cpp +++ b/src/theory/substitutions.cpp @@ -20,7 +20,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { struct substitution_stack_element { @@ -217,10 +217,10 @@ void SubstitutionMap::print(ostream& out) const { 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 diff --git a/src/theory/substitutions.h b/src/theory/substitutions.h index 2258bb724..a925d7fab 100644 --- a/src/theory/substitutions.h +++ b/src/theory/substitutions.h @@ -30,7 +30,7 @@ #include "context/cdhashmap.h" #include "util/hash.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -175,10 +175,10 @@ inline std::ostream& operator << (std::ostream& out, const SubstitutionMap& subs 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 */ diff --git a/src/theory/term_registration_visitor.cpp b/src/theory/term_registration_visitor.cpp index 253f21d98..eab124bc5 100644 --- a/src/theory/term_registration_visitor.cpp +++ b/src/theory/term_registration_visitor.cpp @@ -20,9 +20,9 @@ #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; @@ -292,4 +292,4 @@ void SharedTermsVisitor::clear() { d_visited.clear(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/term_registration_visitor.h b/src/theory/term_registration_visitor.h index c99ed6b99..19406ea62 100644 --- a/src/theory/term_registration_visitor.h +++ b/src/theory/term_registration_visitor.h @@ -22,7 +22,7 @@ #include <unordered_map> -namespace CVC4 { +namespace CVC5 { class TheoryEngine; @@ -189,5 +189,4 @@ class SharedTermsVisitor { TNodeToTheorySetMap d_preregistered; }; - -} +} // namespace CVC5 diff --git a/src/theory/theory.cpp b/src/theory/theory.cpp index b697b004c..143bf92b8 100644 --- a/src/theory/theory.cpp +++ b/src/theory/theory.cpp @@ -39,7 +39,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { /** Default value for the uninterpreted sorts is the UF theory */ @@ -564,5 +564,5 @@ eq::EqualityEngine* Theory::getEqualityEngine() return d_equalityEngine; } -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/theory.h b/src/theory/theory.h index 1261f2ce8..1dd0c584e 100644 --- a/src/theory/theory.h +++ b/src/theory/theory.h @@ -39,7 +39,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; class TheoryEngine; @@ -58,7 +58,7 @@ class TrustSubstitutionMap; namespace eq { class EqualityEngine; -}/* CVC4::theory::eq namespace */ + } // namespace eq /** * Base class for T-solvers. Abstract DPLL(T). @@ -95,7 +95,7 @@ namespace eq { * 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. @@ -916,7 +916,8 @@ inline theory::Assertion Theory::get() { } inline std::ostream& operator<<(std::ostream& out, - const CVC4::theory::Theory& theory) { + const CVC5::theory::Theory& theory) +{ return out << theory.identify(); } @@ -934,7 +935,7 @@ inline std::ostream& operator << (std::ostream& out, theory::Theory::PPAssertSta return out; } -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__THEORY_H */ diff --git a/src/theory/theory_engine.cpp b/src/theory/theory_engine.cpp index cabd57240..e6eeaf8a5 100644 --- a/src/theory/theory_engine.cpp +++ b/src/theory/theory_engine.cpp @@ -50,9 +50,9 @@ using namespace std; -using namespace CVC4::theory; +using namespace CVC5::theory; -namespace CVC4 { +namespace CVC5 { /* -------------------------------------------------------------------------- */ @@ -65,19 +65,19 @@ namespace theory { */ #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 @@ -1894,4 +1894,4 @@ void TheoryEngine::spendResource(ResourceManager::Resource r) d_resourceManager->spendResource(r); } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/theory/theory_engine.h b/src/theory/theory_engine.h index db7cc4997..cc96c4f9d 100644 --- a/src/theory/theory_engine.h +++ b/src/theory/theory_engine.h @@ -41,7 +41,7 @@ #include "util/statistics_registry.h" #include "util/unsafe_interrupt_exception.h" -namespace CVC4 { +namespace CVC5 { class ResourceManager; class OutputManager; @@ -84,7 +84,7 @@ class SharedSolver; class DecisionManager; class RelevanceManager; -}/* CVC4::theory namespace */ +} // namespace theory namespace prop { class PropEngine; @@ -668,6 +668,6 @@ private: void checkTheoryAssertionsWithModel(bool hardFailure); };/* class TheoryEngine */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__THEORY_ENGINE_H */ diff --git a/src/theory/theory_engine_proof_generator.cpp b/src/theory/theory_engine_proof_generator.cpp index 1e5c2d723..bfe29976e 100644 --- a/src/theory/theory_engine_proof_generator.cpp +++ b/src/theory/theory_engine_proof_generator.cpp @@ -18,9 +18,9 @@ #include "expr/proof_node.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { TheoryEngineProofGenerator::TheoryEngineProofGenerator(ProofNodeManager* pnm, context::UserContext* u) @@ -128,4 +128,4 @@ std::string TheoryEngineProofGenerator::identify() const return "TheoryEngineProofGenerator"; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/theory_engine_proof_generator.h b/src/theory/theory_engine_proof_generator.h index d4b3b2919..462c40fdf 100644 --- a/src/theory/theory_engine_proof_generator.h +++ b/src/theory/theory_engine_proof_generator.h @@ -26,7 +26,7 @@ #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 @@ -75,6 +75,6 @@ class TheoryEngineProofGenerator : public ProofGenerator Node d_false; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY_ENGINE_PROOF_GENERATOR_H */ diff --git a/src/theory/theory_eq_notify.h b/src/theory/theory_eq_notify.h index d44781931..17ba7b50e 100644 --- a/src/theory/theory_eq_notify.h +++ b/src/theory/theory_eq_notify.h @@ -21,7 +21,7 @@ #include "theory/theory_inference_manager.h" #include "theory/uf/equality_engine_notify.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -77,6 +77,6 @@ class TheoryEqNotifyClass : public eq::EqualityEngineNotify }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/theory_id.cpp b/src/theory/theory_id.cpp index f0c787daf..60fb752a7 100644 --- a/src/theory/theory_id.cpp +++ b/src/theory/theory_id.cpp @@ -22,7 +22,7 @@ #include "base/check.h" #include "lib/ffs.h" -namespace CVC4 { +namespace CVC5 { namespace theory { TheoryId& operator++(TheoryId& id) @@ -162,4 +162,4 @@ std::string TheoryIdSetUtil::setToString(TheoryIdSet theorySet) } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/theory_id.h b/src/theory/theory_id.h index cca3bf2d6..685dd7864 100644 --- a/src/theory/theory_id.h +++ b/src/theory/theory_id.h @@ -22,7 +22,7 @@ #include <iosfwd> -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -106,5 +106,5 @@ class TheoryIdSetUtil }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/theory_inference.cpp b/src/theory/theory_inference.cpp index 04c095033..00217e0d6 100644 --- a/src/theory/theory_inference.cpp +++ b/src/theory/theory_inference.cpp @@ -16,9 +16,9 @@ #include "theory/theory_inference_manager.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { SimpleTheoryLemma::SimpleTheoryLemma(InferenceId id, @@ -53,4 +53,4 @@ Node SimpleTheoryInternalFact::processFact(std::vector<Node>& exp, } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/theory_inference.h b/src/theory/theory_inference.h index 0dd211f10..e356fb3c8 100644 --- a/src/theory/theory_inference.h +++ b/src/theory/theory_inference.h @@ -21,7 +21,7 @@ #include "theory/inference_id.h" #include "theory/output_channel.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class TheoryInferenceManager; @@ -118,6 +118,6 @@ class SimpleTheoryInternalFact : public TheoryInference }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/theory_inference_manager.cpp b/src/theory/theory_inference_manager.cpp index 11a889a6b..e6f7fd5eb 100644 --- a/src/theory/theory_inference_manager.cpp +++ b/src/theory/theory_inference_manager.cpp @@ -22,9 +22,9 @@ #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, @@ -517,4 +517,4 @@ void TheoryInferenceManager::safePoint(ResourceManager::Resource r) void TheoryInferenceManager::setIncomplete() { d_out.setIncomplete(); } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/theory_inference_manager.h b/src/theory/theory_inference_manager.h index dca11524b..ad92f5380 100644 --- a/src/theory/theory_inference_manager.h +++ b/src/theory/theory_inference_manager.h @@ -28,7 +28,7 @@ #include "util/statistics_registry.h" #include "util/stats_histogram.h" -namespace CVC4 { +namespace CVC5 { class ProofNodeManager; @@ -460,6 +460,6 @@ class TheoryInferenceManager }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__THEORY_INFERENCE_MANAGER_H */ diff --git a/src/theory/theory_model.cpp b/src/theory/theory_model.cpp index a5f8afec4..b20a011ae 100644 --- a/src/theory/theory_model.cpp +++ b/src/theory/theory_model.cpp @@ -22,10 +22,10 @@ #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, @@ -764,5 +764,5 @@ std::string TheoryModel::debugPrintModelEqc() const return ss.str(); } -} /* namespace CVC4::theory */ -} /* namespace CVC4 */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/theory_model.h b/src/theory/theory_model.h index 0c7f092bc..ce3ecfbc0 100644 --- a/src/theory/theory_model.h +++ b/src/theory/theory_model.h @@ -27,7 +27,7 @@ #include "theory/type_set.h" #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** Theory Model class. @@ -432,7 +432,7 @@ public: //---------------------------- end function values };/* class TheoryModel */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__THEORY_MODEL_H */ diff --git a/src/theory/theory_model_builder.cpp b/src/theory/theory_model_builder.cpp index acfd24fbc..44e3d08e3 100644 --- a/src/theory/theory_model_builder.cpp +++ b/src/theory/theory_model_builder.cpp @@ -23,10 +23,10 @@ #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( @@ -1428,5 +1428,5 @@ void TheoryEngineModelBuilder::assignFunctions(TheoryModel* m) Trace("model-builder") << "Finished assigning function values." << std::endl; } -} /* namespace CVC4::theory */ -} /* namespace CVC4 */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/theory_model_builder.h b/src/theory/theory_model_builder.h index 048b40316..cc49111d8 100644 --- a/src/theory/theory_model_builder.h +++ b/src/theory/theory_model_builder.h @@ -22,7 +22,7 @@ #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { class TheoryEngine; @@ -313,7 +313,7 @@ class TheoryEngineModelBuilder }; /* class TheoryEngineModelBuilder */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__THEORY_MODEL_BUILDER_H */ diff --git a/src/theory/theory_preprocessor.cpp b/src/theory/theory_preprocessor.cpp index a9e16f48f..f6ba13551 100644 --- a/src/theory/theory_preprocessor.cpp +++ b/src/theory/theory_preprocessor.cpp @@ -23,7 +23,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { TheoryPreprocessor::TheoryPreprocessor(TheoryEngine& engine, @@ -520,4 +520,4 @@ void TheoryPreprocessor::registerTrustedRewrite(TrustNode trn, } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/theory_preprocessor.h b/src/theory/theory_preprocessor.h index e9abccad9..21157fa52 100644 --- a/src/theory/theory_preprocessor.h +++ b/src/theory/theory_preprocessor.h @@ -29,7 +29,7 @@ #include "theory/skolem_lemma.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { class LogicInfo; class TheoryEngine; @@ -223,6 +223,6 @@ class TheoryPreprocessor }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__THEORY_PREPROCESSOR_H */ diff --git a/src/theory/theory_proof_step_buffer.cpp b/src/theory/theory_proof_step_buffer.cpp index c40f8dc74..85d2aef7a 100644 --- a/src/theory/theory_proof_step_buffer.cpp +++ b/src/theory/theory_proof_step_buffer.cpp @@ -16,9 +16,9 @@ #include "expr/proof.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { TheoryProofStepBuffer::TheoryProofStepBuffer(ProofChecker* pc) @@ -232,4 +232,4 @@ Node TheoryProofStepBuffer::elimDoubleNegLit(Node n) } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/theory_proof_step_buffer.h b/src/theory/theory_proof_step_buffer.h index 60bbc62e1..80e2c2e6a 100644 --- a/src/theory/theory_proof_step_buffer.h +++ b/src/theory/theory_proof_step_buffer.h @@ -23,7 +23,7 @@ #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 @@ -110,6 +110,6 @@ class TheoryProofStepBuffer : public ProofStepBuffer }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__THEORY_PROOF_STEP_BUFFER_H */ diff --git a/src/theory/theory_rewriter.cpp b/src/theory/theory_rewriter.cpp index 19bb6e2e5..13b6ecdd0 100644 --- a/src/theory/theory_rewriter.cpp +++ b/src/theory/theory_rewriter.cpp @@ -16,7 +16,7 @@ #include "theory/theory_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { TrustRewriteResponse::TrustRewriteResponse(RewriteStatus status, @@ -60,4 +60,4 @@ TrustNode TheoryRewriter::rewriteEqualityExtWithProof(Node node) } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/theory_rewriter.h b/src/theory/theory_rewriter.h index 83310ce07..e508477d3 100644 --- a/src/theory/theory_rewriter.h +++ b/src/theory/theory_rewriter.h @@ -22,7 +22,7 @@ #include "expr/node.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class Rewriter; @@ -140,6 +140,6 @@ class TheoryRewriter }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__THEORY_REWRITER_H */ diff --git a/src/theory/theory_state.cpp b/src/theory/theory_state.cpp index 979b95e93..d155e12a6 100644 --- a/src/theory/theory_state.cpp +++ b/src/theory/theory_state.cpp @@ -16,7 +16,7 @@ #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { TheoryState::TheoryState(context::Context* c, @@ -174,4 +174,4 @@ context::CDList<Assertion>::const_iterator TheoryState::factsEnd(TheoryId tid) Valuation& TheoryState::getValuation() { return d_valuation; } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/theory_state.h b/src/theory/theory_state.h index e946fb639..8c863144b 100644 --- a/src/theory/theory_state.h +++ b/src/theory/theory_state.h @@ -21,7 +21,7 @@ #include "expr/node.h" #include "theory/valuation.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { @@ -121,6 +121,6 @@ class TheoryState }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__SOLVER_STATE_H */ diff --git a/src/theory/theory_traits_template.h b/src/theory/theory_traits_template.h index b0951db70..e30507cf8 100644 --- a/src/theory/theory_traits_template.h +++ b/src/theory/theory_traits_template.h @@ -26,7 +26,7 @@ ${theory_includes} -namespace CVC4 { +namespace CVC5 { namespace theory { template <TheoryId theoryId> @@ -43,7 +43,7 @@ ${theory_constructors} default: Unhandled() << id; } } -};/* struct CVC4::theory::TheoryConstructor */ +}; /* struct CVC5::theory::TheoryConstructor */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/trust_node.cpp b/src/theory/trust_node.cpp index f42ad1371..7458b95e5 100644 --- a/src/theory/trust_node.cpp +++ b/src/theory/trust_node.cpp @@ -17,7 +17,7 @@ #include "expr/proof_ensure_closed.h" #include "expr/proof_generator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { const char* toString(TrustNodeKind tnk) @@ -146,4 +146,4 @@ std::ostream& operator<<(std::ostream& out, TrustNode n) } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/trust_node.h b/src/theory/trust_node.h index b376bb32a..13769dccd 100644 --- a/src/theory/trust_node.h +++ b/src/theory/trust_node.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { class ProofGenerator; class ProofNode; @@ -172,6 +172,6 @@ class TrustNode std::ostream& operator<<(std::ostream& out, TrustNode n); } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__TRUST_NODE_H */ diff --git a/src/theory/trust_substitutions.cpp b/src/theory/trust_substitutions.cpp index 367d2f5c4..a42608c31 100644 --- a/src/theory/trust_substitutions.cpp +++ b/src/theory/trust_substitutions.cpp @@ -16,7 +16,7 @@ #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { TrustSubstitutionMap::TrustSubstitutionMap(context::Context* c, @@ -246,4 +246,4 @@ Node TrustSubstitutionMap::getCurrentSubstitution() } } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/trust_substitutions.h b/src/theory/trust_substitutions.h index 223204945..20b240ce8 100644 --- a/src/theory/trust_substitutions.h +++ b/src/theory/trust_substitutions.h @@ -28,7 +28,7 @@ #include "theory/theory_proof_step_buffer.h" #include "theory/trust_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /** @@ -133,6 +133,6 @@ class TrustSubstitutionMap }; } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__TRUST_SUBSTITUTIONS_H */ diff --git a/src/theory/type_enumerator.h b/src/theory/type_enumerator.h index 5c39fdecd..f0cfacee7 100644 --- a/src/theory/type_enumerator.h +++ b/src/theory/type_enumerator.h @@ -24,7 +24,7 @@ #include "expr/node.h" #include "expr/type_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class NoMoreValuesException : public Exception { @@ -183,7 +183,7 @@ class TypeEnumerator { TypeNode getType() const { return d_te->getType(); } };/* class TypeEnumerator */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__TYPE_ENUMERATOR_H */ diff --git a/src/theory/type_enumerator_template.cpp b/src/theory/type_enumerator_template.cpp index bd8b7e0a4..803787f5e 100644 --- a/src/theory/type_enumerator_template.cpp +++ b/src/theory/type_enumerator_template.cpp @@ -25,7 +25,7 @@ ${type_enumerator_includes} using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { TypeEnumeratorInterface* TypeEnumerator::mkTypeEnumerator( @@ -46,5 +46,5 @@ TypeEnumeratorInterface* TypeEnumerator::mkTypeEnumerator( Unreachable(); } -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/type_set.cpp b/src/theory/type_set.cpp index a1ecd4ab8..6cf8814a7 100644 --- a/src/theory/type_set.cpp +++ b/src/theory/type_set.cpp @@ -14,9 +14,9 @@ #include "theory/type_set.h" using namespace std; -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { TypeSet::~TypeSet() @@ -136,5 +136,5 @@ void TypeSet::addSubTerms(TNode n, } } -} /* namespace CVC4::theory */ -} /* namespace CVC4 */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/type_set.h b/src/theory/type_set.h index 02ae7e138..3e57033ef 100644 --- a/src/theory/type_set.h +++ b/src/theory/type_set.h @@ -22,7 +22,7 @@ #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { namespace theory { /* Type set @@ -84,7 +84,7 @@ class TypeSet bool topLevel = true); }; /* class TypeSet */ -} /* CVC4::theory namespace */ -} /* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__TYPE_SET_H */ diff --git a/src/theory/uf/cardinality_extension.cpp b/src/theory/uf/cardinality_extension.cpp index b36c6eb96..eebe14226 100644 --- a/src/theory/uf/cardinality_extension.cpp +++ b/src/theory/uf/cardinality_extension.cpp @@ -28,10 +28,10 @@ #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 { @@ -1764,6 +1764,6 @@ CardinalityExtension::Statistics::~Statistics() smtStatisticsRegistry()->unregisterStat(&d_max_model_size); } -}/* CVC4::theory namespace::uf */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace uf +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/uf/cardinality_extension.h b/src/theory/uf/cardinality_extension.h index d701adfc4..85129a89b 100644 --- a/src/theory/uf/cardinality_extension.h +++ b/src/theory/uf/cardinality_extension.h @@ -23,7 +23,7 @@ #include "theory/theory.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace uf { @@ -461,8 +461,8 @@ class CardinalityExtension 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 */ diff --git a/src/theory/uf/eq_proof.cpp b/src/theory/uf/eq_proof.cpp index 3cbac95a2..fec9179f3 100644 --- a/src/theory/uf/eq_proof.cpp +++ b/src/theory/uf/eq_proof.cpp @@ -20,7 +20,7 @@ #include "expr/proof_checker.h" #include "options/uf_options.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { @@ -1438,4 +1438,4 @@ Node EqProof::addToProof( } // namespace eq } // Namespace theory -} // Namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/uf/eq_proof.h b/src/theory/uf/eq_proof.h index 2effb88a9..665731d2b 100644 --- a/src/theory/uf/eq_proof.h +++ b/src/theory/uf/eq_proof.h @@ -17,7 +17,7 @@ #include "expr/node.h" #include "theory/uf/equality_engine_types.h" -namespace CVC4 { +namespace CVC5 { class CDProof; @@ -355,4 +355,4 @@ class EqProof } // Namespace eq } // Namespace theory -} // Namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/uf/equality_engine.cpp b/src/theory/uf/equality_engine.cpp index 2d34bd547..a4bb76245 100644 --- a/src/theory/uf/equality_engine.cpp +++ b/src/theory/uf/equality_engine.cpp @@ -24,7 +24,7 @@ #include "theory/rewriter.h" #include "theory/uf/eq_proof.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { @@ -2635,4 +2635,4 @@ EqualityNodeId EqualityEngine::TriggerTermSet::getTrigger(TheoryId tag) const } // Namespace uf } // Namespace theory -} // Namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/uf/equality_engine.h b/src/theory/uf/equality_engine.h index d1c0ece95..74af68227 100644 --- a/src/theory/uf/equality_engine.h +++ b/src/theory/uf/equality_engine.h @@ -35,7 +35,7 @@ #include "theory/uf/equality_engine_types.h" #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { @@ -845,6 +845,6 @@ private: } // Namespace eq } // Namespace theory -} // Namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/uf/equality_engine_iterator.cpp b/src/theory/uf/equality_engine_iterator.cpp index 48b2552cd..c9a35f6e3 100644 --- a/src/theory/uf/equality_engine_iterator.cpp +++ b/src/theory/uf/equality_engine_iterator.cpp @@ -16,7 +16,7 @@ #include "theory/uf/equality_engine.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { @@ -132,4 +132,4 @@ bool EqClassIterator::isFinished() const { return d_current == null_id; } } // namespace eq } // Namespace theory -} // Namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/uf/equality_engine_iterator.h b/src/theory/uf/equality_engine_iterator.h index 1d1089090..33562a99e 100644 --- a/src/theory/uf/equality_engine_iterator.h +++ b/src/theory/uf/equality_engine_iterator.h @@ -20,7 +20,7 @@ #include "expr/node.h" #include "theory/uf/equality_engine_types.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { @@ -79,6 +79,6 @@ class EqClassIterator } // Namespace eq } // Namespace theory -} // Namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/uf/equality_engine_notify.h b/src/theory/uf/equality_engine_notify.h index 7904d7cf6..bd353375f 100644 --- a/src/theory/uf/equality_engine_notify.h +++ b/src/theory/uf/equality_engine_notify.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { @@ -115,6 +115,6 @@ class EqualityEngineNotifyNone : public EqualityEngineNotify } // Namespace eq } // Namespace theory -} // Namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/theory/uf/equality_engine_types.h b/src/theory/uf/equality_engine_types.h index 5714099f9..092b4bd89 100644 --- a/src/theory/uf/equality_engine_types.h +++ b/src/theory/uf/equality_engine_types.h @@ -26,7 +26,7 @@ #include "util/hash.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace eq { @@ -359,6 +359,6 @@ struct TriggerInfo { } // namespace eq } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__UF__EQUALITY_ENGINE_TYPES_H */ diff --git a/src/theory/uf/ho_extension.cpp b/src/theory/uf/ho_extension.cpp index 7984813ac..c159ff3b4 100644 --- a/src/theory/uf/ho_extension.cpp +++ b/src/theory/uf/ho_extension.cpp @@ -21,9 +21,9 @@ #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 { @@ -455,4 +455,4 @@ bool HoExtension::collectModelInfoHoTerm(Node n, TheoryModel* m) } // namespace uf } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/uf/ho_extension.h b/src/theory/uf/ho_extension.h index 90b0b67c5..3ca647f28 100644 --- a/src/theory/uf/ho_extension.h +++ b/src/theory/uf/ho_extension.h @@ -25,7 +25,7 @@ #include "theory/theory_model.h" #include "theory/theory_state.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace uf { @@ -198,6 +198,6 @@ class HoExtension } // namespace uf } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* __CVC4__THEORY__UF__HO_EXTENSION_H */ diff --git a/src/theory/uf/kinds b/src/theory/uf/kinds index 9564899fe..ab2e422ee 100644 --- a/src/theory/uf/kinds +++ b/src/theory/uf/kinds @@ -4,32 +4,32 @@ # 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 diff --git a/src/theory/uf/proof_checker.cpp b/src/theory/uf/proof_checker.cpp index 2c102c4ca..2688c0574 100644 --- a/src/theory/uf/proof_checker.cpp +++ b/src/theory/uf/proof_checker.cpp @@ -16,9 +16,9 @@ #include "theory/uf/theory_uf_rewriter.h" -using namespace CVC4::kind; +using namespace CVC5::kind; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace uf { @@ -207,4 +207,4 @@ Node UfProofRuleChecker::checkInternal(PfRule id, } // namespace uf } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/uf/proof_checker.h b/src/theory/uf/proof_checker.h index bb999dc15..502aeaa59 100644 --- a/src/theory/uf/proof_checker.h +++ b/src/theory/uf/proof_checker.h @@ -21,7 +21,7 @@ #include "expr/proof_checker.h" #include "expr/proof_node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace uf { @@ -44,6 +44,6 @@ class UfProofRuleChecker : public ProofRuleChecker } // namespace uf } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__UF__PROOF_CHECKER_H */ diff --git a/src/theory/uf/proof_equality_engine.cpp b/src/theory/uf/proof_equality_engine.cpp index 7db887b56..2837a02aa 100644 --- a/src/theory/uf/proof_equality_engine.cpp +++ b/src/theory/uf/proof_equality_engine.cpp @@ -22,9 +22,9 @@ #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 { @@ -549,4 +549,4 @@ void ProofEqEngine::explainWithProof(Node lit, } // namespace eq } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/uf/proof_equality_engine.h b/src/theory/uf/proof_equality_engine.h index adf8d2c18..5129ad1df 100644 --- a/src/theory/uf/proof_equality_engine.h +++ b/src/theory/uf/proof_equality_engine.h @@ -26,7 +26,7 @@ #include "expr/node.h" #include "theory/eager_proof_generator.h" -namespace CVC4 { +namespace CVC5 { class ProofNode; class ProofNodeManager; @@ -296,6 +296,6 @@ class ProofEqEngine : public EagerProofGenerator } // namespace eq } // namespace theory -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__THEORY__STRINGS__PROOF_MANAGER_H */ diff --git a/src/theory/uf/symmetry_breaker.cpp b/src/theory/uf/symmetry_breaker.cpp index ca7254fb6..9b25c8906 100644 --- a/src/theory/uf/symmetry_breaker.cpp +++ b/src/theory/uf/symmetry_breaker.cpp @@ -48,11 +48,11 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace uf { -using namespace ::CVC4::context; +using namespace ::CVC5::context; SymmetryBreaker::Template::Template() : d_template(), @@ -800,8 +800,8 @@ void SymmetryBreaker::insertUsedIn(Term term, const Permutation& p, set<Node>& c } } -}/* CVC4::theory::uf namespace */ -}/* CVC4::theory namespace */ +} // namespace uf +} // namespace theory std::ostream& operator<<(std::ostream& out, const theory::uf::SymmetryBreaker::Permutation& p) { out << "{"; @@ -816,4 +816,4 @@ std::ostream& operator<<(std::ostream& out, const theory::uf::SymmetryBreaker::P return out; } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/theory/uf/symmetry_breaker.h b/src/theory/uf/symmetry_breaker.h index 2a95e5bc7..8ce0c2c44 100644 --- a/src/theory/uf/symmetry_breaker.h +++ b/src/theory/uf/symmetry_breaker.h @@ -57,7 +57,7 @@ #include "util/statistics_registry.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace uf { @@ -170,11 +170,13 @@ private: };/* 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 */ diff --git a/src/theory/uf/theory_uf.cpp b/src/theory/uf/theory_uf.cpp index aaa9d60f0..29bb6ba7d 100644 --- a/src/theory/uf/theory_uf.cpp +++ b/src/theory/uf/theory_uf.cpp @@ -35,7 +35,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { namespace theory { namespace uf { @@ -691,6 +691,6 @@ bool TheoryUF::isHigherOrderType(TypeNode tn) return ret; } -} /* namespace CVC4::theory::uf */ -} /* namespace CVC4::theory */ -} /* namespace CVC4 */ +} // namespace uf +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/uf/theory_uf.h b/src/theory/uf/theory_uf.h index 8d2edaffe..97cfc1fa5 100644 --- a/src/theory/uf/theory_uf.h +++ b/src/theory/uf/theory_uf.h @@ -29,7 +29,7 @@ #include "theory/uf/symmetry_breaker.h" #include "theory/uf/theory_uf_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace uf { @@ -181,8 +181,8 @@ private: 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 */ diff --git a/src/theory/uf/theory_uf_model.cpp b/src/theory/uf/theory_uf_model.cpp index abb0c2e6c..5727d62cd 100644 --- a/src/theory/uf/theory_uf_model.cpp +++ b/src/theory/uf/theory_uf_model.cpp @@ -21,9 +21,9 @@ #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 { @@ -243,4 +243,4 @@ Node UfModelTree::getFunctionValue( const char* argPrefix, bool simplify ){ } // namespace uf } // namespace theory -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/theory/uf/theory_uf_model.h b/src/theory/uf/theory_uf_model.h index 62ec8204f..b1e0eea8f 100644 --- a/src/theory/uf/theory_uf_model.h +++ b/src/theory/uf/theory_uf_model.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC4 { +namespace CVC5 { namespace theory { class TheoryModel; @@ -114,6 +114,6 @@ public: } } -} +} // namespace CVC5 #endif diff --git a/src/theory/uf/theory_uf_rewriter.h b/src/theory/uf/theory_uf_rewriter.h index ea4f66d16..ffa0ec22f 100644 --- a/src/theory/uf/theory_uf_rewriter.h +++ b/src/theory/uf/theory_uf_rewriter.h @@ -26,7 +26,7 @@ #include "theory/substitutions.h" #include "theory/theory_rewriter.h" -namespace CVC4 { +namespace CVC5 { namespace theory { namespace uf { @@ -208,8 +208,8 @@ public: //conversion between HO_APPLY AND APPLY_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 */ diff --git a/src/theory/uf/theory_uf_type_rules.h b/src/theory/uf/theory_uf_type_rules.h index aad1ad63d..c21b36669 100644 --- a/src/theory/uf/theory_uf_type_rules.h +++ b/src/theory/uf/theory_uf_type_rules.h @@ -21,7 +21,7 @@ #include <climits> -namespace CVC4 { +namespace CVC5 { namespace theory { namespace uf { @@ -80,7 +80,7 @@ class CardinalityConstraintTypeRule { 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"); @@ -108,7 +108,7 @@ class CombinedCardinalityConstraintTypeRule { 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"); @@ -176,8 +176,8 @@ class HoApplyTypeRule { } }; /* 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 */ diff --git a/src/theory/valuation.cpp b/src/theory/valuation.cpp index e46f38a28..f77dff234 100644 --- a/src/theory/valuation.cpp +++ b/src/theory/valuation.cpp @@ -24,7 +24,7 @@ #include "theory/theory_engine.h" #include "theory/theory_model.h" -namespace CVC4 { +namespace CVC5 { namespace theory { std::ostream& operator<<(std::ostream& os, EqualityStatus s) @@ -221,5 +221,5 @@ context::CDList<Assertion>::const_iterator Valuation::factsEnd(TheoryId tid) return theory->facts_end(); } -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 diff --git a/src/theory/valuation.h b/src/theory/valuation.h index 860517451..c79c3bf9b 100644 --- a/src/theory/valuation.h +++ b/src/theory/valuation.h @@ -25,7 +25,7 @@ #include "expr/node.h" #include "options/theory_options.h" -namespace CVC4 { +namespace CVC5 { class TheoryEngine; @@ -216,7 +216,7 @@ public: context::CDList<Assertion>::const_iterator factsEnd(TheoryId tid); };/* class Valuation */ -}/* CVC4::theory namespace */ -}/* CVC4 namespace */ +} // namespace theory +} // namespace CVC5 #endif /* CVC4__THEORY__VALUATION_H */ diff --git a/src/util/abstract_value.cpp b/src/util/abstract_value.cpp index 2c82b98e9..4f6cadde4 100644 --- a/src/util/abstract_value.cpp +++ b/src/util/abstract_value.cpp @@ -24,7 +24,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& out, const AbstractValue& val) { return out << "@" << val.getIndex(); @@ -38,4 +38,4 @@ AbstractValue::AbstractValue(Integer index) : d_index(index) index.toString().c_str()); } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/util/abstract_value.h b/src/util/abstract_value.h index 5d28d355a..ddd1018a2 100644 --- a/src/util/abstract_value.h +++ b/src/util/abstract_value.h @@ -22,7 +22,7 @@ #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { class AbstractValue { @@ -61,4 +61,4 @@ struct AbstractValueHashFunction } }; /* struct AbstractValueHashFunction */ -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/util/bin_heap.h b/src/util/bin_heap.h index c51600122..40f2da045 100644 --- a/src/util/bin_heap.h +++ b/src/util/bin_heap.h @@ -29,7 +29,7 @@ #include "base/check.h" #include "base/exception.h" -namespace CVC4 { +namespace CVC5 { /** * BinaryHeap that orders its elements greatest-first (i.e., in the opposite @@ -363,6 +363,6 @@ private: 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 */ diff --git a/src/util/bitvector.cpp b/src/util/bitvector.cpp index 3d907150d..85b373886 100644 --- a/src/util/bitvector.cpp +++ b/src/util/bitvector.cpp @@ -20,7 +20,7 @@ #include "base/exception.h" -namespace CVC4 { +namespace CVC5 { unsigned BitVector::getSize() const { return d_size; } @@ -375,4 +375,4 @@ BitVector BitVector::mkMaxSigned(unsigned size) return ~BitVector::mkMinSigned(size); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/bitvector.h b/src/util/bitvector.h index c5a690c03..fbb91b8e3 100644 --- a/src/util/bitvector.h +++ b/src/util/bitvector.h @@ -25,7 +25,7 @@ #include "base/exception.h" #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { class BitVector { @@ -442,6 +442,6 @@ inline std::ostream& operator<<(std::ostream& os, const IntToBitVector& bv) return os << "[" << bv.d_size << "]"; } -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__BITVECTOR_H */ diff --git a/src/util/bool.h b/src/util/bool.h index 0dd179d6a..d1f57fcd4 100644 --- a/src/util/bool.h +++ b/src/util/bool.h @@ -19,7 +19,7 @@ #ifndef CVC4__BOOL_H #define CVC4__BOOL_H -namespace CVC4 { +namespace CVC5 { struct BoolHashFunction { inline size_t operator()(bool b) const { @@ -27,6 +27,6 @@ struct BoolHashFunction { } };/* struct BoolHashFunction */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__BOOL_H */ diff --git a/src/util/cardinality.cpp b/src/util/cardinality.cpp index 3ab44d6f8..027c3d2db 100644 --- a/src/util/cardinality.cpp +++ b/src/util/cardinality.cpp @@ -22,7 +22,7 @@ #include "base/check.h" #include "base/exception.h" -namespace CVC4 { +namespace CVC5 { const Integer Cardinality::s_unknownCard(0); const Integer Cardinality::s_intCard(-1); @@ -263,4 +263,4 @@ std::ostream& operator<<(std::ostream& out, const Cardinality& c) { return out; } -} /* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/util/cardinality.h b/src/util/cardinality.h index 6c48b44a8..2ab2fdd63 100644 --- a/src/util/cardinality.h +++ b/src/util/cardinality.h @@ -24,7 +24,7 @@ #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { /** * Representation for a Beth number, used only to construct @@ -225,6 +225,6 @@ std::ostream& operator<<(std::ostream& out, CardinalityBeth b); /** 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 */ diff --git a/src/util/dense_map.h b/src/util/dense_map.h index 7a3421281..e6fed6916 100644 --- a/src/util/dense_map.h +++ b/src/util/dense_map.h @@ -35,8 +35,7 @@ #include "base/check.h" #include "util/index.h" - -namespace CVC4 { +namespace CVC5 { template <class T> class DenseMap { @@ -339,4 +338,4 @@ public: void pop_back() { d_map.pop_back(); } }; /* class DenseMultiset */ -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/util/divisible.cpp b/src/util/divisible.cpp index b3c823e06..45b1f6c27 100644 --- a/src/util/divisible.cpp +++ b/src/util/divisible.cpp @@ -22,10 +22,10 @@ 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 diff --git a/src/util/divisible.h b/src/util/divisible.h index 2de81c52b..5b3506ee8 100644 --- a/src/util/divisible.h +++ b/src/util/divisible.h @@ -26,7 +26,7 @@ #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { /** * The structure representing the divisibility-by-k predicate. @@ -61,6 +61,6 @@ inline std::ostream& operator <<(std::ostream& os, const Divisible& d) { return os << "divisible-by-" << d.k; } -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__DIVISIBLE_H */ diff --git a/src/util/floatingpoint.cpp b/src/util/floatingpoint.cpp index 26bdb65f4..be5f6a496 100644 --- a/src/util/floatingpoint.cpp +++ b/src/util/floatingpoint.cpp @@ -28,7 +28,7 @@ /* -------------------------------------------------------------------------- */ -namespace CVC4 { +namespace CVC5 { /* -------------------------------------------------------------------------- */ @@ -512,4 +512,4 @@ std::ostream& operator<<(std::ostream& os, const FloatingPointConvertSort& fpcs) return os << "(_ to_fp " << fpcs.getSize().exponentWidth() << " " << fpcs.getSize().significandWidth() << ")"; } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/util/floatingpoint.h b/src/util/floatingpoint.h index b6c1bfb53..060d1de99 100644 --- a/src/util/floatingpoint.h +++ b/src/util/floatingpoint.h @@ -29,7 +29,7 @@ /* -------------------------------------------------------------------------- */ -namespace CVC4 { +namespace CVC5 { /* -------------------------------------------------------------------------- */ @@ -514,7 +514,7 @@ struct FloatingPointToBVHashFunction { 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 */ @@ -533,6 +533,6 @@ std::ostream& operator<<(std::ostream& os, const FloatingPointSize& fps); std::ostream& operator<<(std::ostream& os, const FloatingPointConvertSort& fpcs); -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__FLOATINGPOINT_H */ diff --git a/src/util/floatingpoint_literal_symfpu.cpp b/src/util/floatingpoint_literal_symfpu.cpp index 1d40292f7..efd3e2399 100644 --- a/src/util/floatingpoint_literal_symfpu.cpp +++ b/src/util/floatingpoint_literal_symfpu.cpp @@ -39,9 +39,9 @@ namespace symfpu { #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) \ { \ @@ -49,10 +49,10 @@ namespace symfpu { } \ } -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 @@ -60,7 +60,7 @@ CVC4_LIT_ITE_DFN(::CVC4::symfpuLiteral::traits::ubv); /* -------------------------------------------------------------------------- */ -namespace CVC4 { +namespace CVC5 { uint32_t FloatingPointLiteral::getUnpackedExponentWidth(FloatingPointSize& size) { @@ -881,11 +881,11 @@ wrappedBitVector<isSigned> wrappedBitVector<isSigned>::extract( 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 @@ -906,4 +906,4 @@ void traits::invariant(const traits::prop& p) } } // namespace symfpuLiteral -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/floatingpoint_literal_symfpu.h.in b/src/util/floatingpoint_literal_symfpu.h.in index 8857728ce..d01bf6a9d 100644 --- a/src/util/floatingpoint_literal_symfpu.h.in +++ b/src/util/floatingpoint_literal_symfpu.h.in @@ -30,7 +30,7 @@ /* -------------------------------------------------------------------------- */ -namespace CVC4 { +namespace CVC5 { class FloatingPointSize; class FloatingPointLiteral; @@ -56,8 +56,8 @@ class wrappedBitVector; 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>; @@ -106,7 +106,7 @@ struct signedToLiteralType<false> }; /** - * 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. */ @@ -159,7 +159,7 @@ class wrappedBitVector : public BitVector /** * 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 @@ -502,6 +502,6 @@ class FloatingPointLiteral /* -------------------------------------------------------------------------- */ -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/util/floatingpoint_size.cpp b/src/util/floatingpoint_size.cpp index 9b14db699..78558ab27 100644 --- a/src/util/floatingpoint_size.cpp +++ b/src/util/floatingpoint_size.cpp @@ -15,7 +15,7 @@ #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) @@ -31,4 +31,4 @@ FloatingPointSize::FloatingPointSize(const FloatingPointSize& old) Assert(validSignificandSize(d_sig_size)); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/floatingpoint_size.h b/src/util/floatingpoint_size.h index be00e0987..ed5dccc4f 100644 --- a/src/util/floatingpoint_size.h +++ b/src/util/floatingpoint_size.h @@ -16,7 +16,7 @@ #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; } @@ -92,6 +92,6 @@ struct FloatingPointSizeHashFunction | t.significandWidth()); } }; /* struct FloatingPointSizeHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/util/gmp_util.h b/src/util/gmp_util.h index bf13669d3..0ecc6485d 100644 --- a/src/util/gmp_util.h +++ b/src/util/gmp_util.h @@ -22,7 +22,7 @@ #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) { @@ -35,6 +35,6 @@ inline size_t gmpz_hash(const mpz_t toHash) { return hash; }/* gmpz_hash() */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__GMP_UTIL_H */ diff --git a/src/util/hash.h b/src/util/hash.h index 8adb4b473..066e01aad 100644 --- a/src/util/hash.h +++ b/src/util/hash.h @@ -38,7 +38,7 @@ struct hash<uint64_t> { }/* std namespace */ -namespace CVC4 { +namespace CVC5 { namespace fnv1a { @@ -64,6 +64,6 @@ struct PairHashFunction { } };/* struct PairHashFunction */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__HASH_H */ diff --git a/src/util/iand.h b/src/util/iand.h index e5f1a5af7..a50c4aeb7 100644 --- a/src/util/iand.h +++ b/src/util/iand.h @@ -22,7 +22,7 @@ #include "base/exception.h" #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { struct IntAnd { @@ -41,6 +41,6 @@ inline std::ostream& operator<<(std::ostream& os, const IntAnd& ia) return os << "[" << ia.d_size << "]"; } -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__IAND_H */ diff --git a/src/util/index.cpp b/src/util/index.cpp index f3b3df29d..7c9f3c57f 100644 --- a/src/util/index.cpp +++ b/src/util/index.cpp @@ -19,7 +19,7 @@ #include <limits> -namespace CVC4 { +namespace CVC5 { static_assert(sizeof(Index) <= sizeof(size_t), "Index cannot be larger than size_t"); @@ -34,4 +34,4 @@ static_assert(!std::numeric_limits<Index>::is_signed, * (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 diff --git a/src/util/index.h b/src/util/index.h index 6a050f4f9..1fa881eb6 100644 --- a/src/util/index.h +++ b/src/util/index.h @@ -19,11 +19,11 @@ #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 */ diff --git a/src/util/indexed_root_predicate.h b/src/util/indexed_root_predicate.h index 3c36a6a97..b201630c0 100644 --- a/src/util/indexed_root_predicate.h +++ b/src/util/indexed_root_predicate.h @@ -19,7 +19,7 @@ #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. @@ -69,6 +69,6 @@ struct IndexedRootPredicateHashFunction } }; /* struct IndexedRootPredicateHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif
\ No newline at end of file diff --git a/src/util/integer_cln_imp.cpp b/src/util/integer_cln_imp.cpp index a4035165e..0f02f03e5 100644 --- a/src/util/integer_cln_imp.cpp +++ b/src/util/integer_cln_imp.cpp @@ -28,7 +28,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { signed int Integer::s_fastSignedIntMin = -(1 << 29); signed int Integer::s_fastSignedIntMax = (1 << 29) - 1; @@ -568,4 +568,4 @@ std::ostream& operator<<(std::ostream& os, const Integer& n) { return os << n.toString(); } -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/util/integer_cln_imp.h b/src/util/integer_cln_imp.h index db1e5068f..7d7b002f2 100644 --- a/src/util/integer_cln_imp.h +++ b/src/util/integer_cln_imp.h @@ -33,13 +33,13 @@ #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: /** @@ -380,11 +380,11 @@ class CVC4_EXPORT Integer 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 */ diff --git a/src/util/integer_gmp_imp.cpp b/src/util/integer_gmp_imp.cpp index 89f6dc308..d1e0d7108 100644 --- a/src/util/integer_gmp_imp.cpp +++ b/src/util/integer_gmp_imp.cpp @@ -31,7 +31,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { Integer::Integer(const char* s, unsigned base) : d_value(s, base) @@ -483,4 +483,4 @@ const Integer& Integer::max(const Integer& a, const Integer& b) return (a >= b) ? a : b; } -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/util/integer_gmp_imp.h b/src/util/integer_gmp_imp.h index 616408b42..fa206d08f 100644 --- a/src/util/integer_gmp_imp.h +++ b/src/util/integer_gmp_imp.h @@ -27,13 +27,13 @@ #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: /** @@ -330,7 +330,7 @@ class CVC4_EXPORT Integer 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) @@ -338,6 +338,6 @@ inline std::ostream& operator<<(std::ostream& os, const Integer& n) return os << n.toString(); } -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__INTEGER_H */ diff --git a/src/util/maybe.h b/src/util/maybe.h index a74a42a17..35c0efd68 100644 --- a/src/util/maybe.h +++ b/src/util/maybe.h @@ -31,7 +31,7 @@ #include "base/exception.h" -namespace CVC4 { +namespace CVC5 { template <class T> class Maybe @@ -84,6 +84,6 @@ inline std::ostream& operator<<(std::ostream& out, const Maybe<T>& m){ return out; } -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__UTIL__MAYBE_H */ diff --git a/src/util/ostream_util.cpp b/src/util/ostream_util.cpp index dd9d3bf92..37fa0d892 100644 --- a/src/util/ostream_util.cpp +++ b/src/util/ostream_util.cpp @@ -17,7 +17,7 @@ #include <ostream> -namespace CVC4 { +namespace CVC5 { StreamFormatScope::StreamFormatScope(std::ostream& out) : d_out(out), d_format_flags(out.flags()), d_precision(out.precision()) @@ -30,4 +30,4 @@ StreamFormatScope::~StreamFormatScope() d_out.flags(d_format_flags); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/ostream_util.h b/src/util/ostream_util.h index 1f70e33ad..c5e1e2797 100644 --- a/src/util/ostream_util.h +++ b/src/util/ostream_util.h @@ -22,7 +22,7 @@ #include <ios> #include <iosfwd> -namespace CVC4 { +namespace CVC5 { // Saves the formatting of an ostream and restores the previous settings on // destruction. Example usage: @@ -44,6 +44,6 @@ class StreamFormatScope std::streamsize d_precision; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__UTIL__OSTREAM_UTIL_H */ diff --git a/src/util/poly_util.cpp b/src/util/poly_util.cpp index e9f80bf77..9dbb24872 100644 --- a/src/util/poly_util.cpp +++ b/src/util/poly_util.cpp @@ -35,7 +35,7 @@ #include "util/rational.h" #include "util/real_algebraic_number.h" -namespace CVC4 { +namespace CVC5 { namespace poly_utils { namespace { @@ -361,6 +361,6 @@ void getVariableInformation(VariableInformation& vi, } } // namespace poly_utils -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/util/poly_util.h b/src/util/poly_util.h index 203aec618..efb185932 100644 --- a/src/util/poly_util.h +++ b/src/util/poly_util.h @@ -36,7 +36,7 @@ #include <poly/polyxx.h> -namespace CVC4 { +namespace CVC5 { /** * Utilities for working with libpoly. * This namespace contains various basic conversion routines necessary for the @@ -49,28 +49,28 @@ namespace CVC4 { */ 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); @@ -91,7 +91,7 @@ poly::Rational approximateToDyadic(const poly::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. @@ -101,7 +101,7 @@ poly::AlgebraicNumber toPolyRanWithRefinement(poly::UPolynomial&& p, const Rational& upper); /** - * Constructs a CVC4::RealAlgebraicNumber, simply wrapping + * Constructs a CVC5::RealAlgebraicNumber, simply wrapping * toPolyRanWithRefinement. */ RealAlgebraicNumber toRanWithRefinement(poly::UPolynomial&& p, @@ -138,7 +138,7 @@ void getVariableInformation(VariableInformation& vi, const poly::Polynomial& poly); } // namespace poly_utils -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/util/random.cpp b/src/util/random.cpp index 9d94ff624..ab35bd389 100644 --- a/src/util/random.cpp +++ b/src/util/random.cpp @@ -21,7 +21,7 @@ #include <cfloat> #include "base/check.h" -namespace CVC4 { +namespace CVC5 { Random::Random(uint64_t seed) { setSeed(seed); } @@ -66,4 +66,4 @@ bool Random::pickWithProb(double probability) return r < p; } -} +} // namespace CVC5 diff --git a/src/util/random.h b/src/util/random.h index 31d93a643..67d4e052d 100644 --- a/src/util/random.h +++ b/src/util/random.h @@ -21,7 +21,7 @@ #ifndef CVC4__UTIL__RANDOM_H #define CVC4__UTIL__RANDOM_H -namespace CVC4 { +namespace CVC5 { class Random { @@ -69,5 +69,5 @@ class Random uint64_t d_state; }; -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/util/rational_cln_imp.cpp b/src/util/rational_cln_imp.cpp index 4d948415f..a974a6155 100644 --- a/src/util/rational_cln_imp.cpp +++ b/src/util/rational_cln_imp.cpp @@ -28,7 +28,7 @@ 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>. @@ -117,4 +117,4 @@ Maybe<Rational> Rational::fromDouble(double d) } } -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/util/rational_cln_imp.h b/src/util/rational_cln_imp.h index bd48ad851..d2c57e90d 100644 --- a/src/util/rational_cln_imp.h +++ b/src/util/rational_cln_imp.h @@ -37,7 +37,7 @@ #include "util/integer.h" #include "util/maybe.h" -namespace CVC4 { +namespace CVC5 { /** ** A multi-precision rational constant. @@ -336,11 +336,11 @@ class CVC4_EXPORT Rational 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 */ diff --git a/src/util/rational_gmp_imp.cpp b/src/util/rational_gmp_imp.cpp index 2fbe45d80..0762e17c1 100644 --- a/src/util/rational_gmp_imp.cpp +++ b/src/util/rational_gmp_imp.cpp @@ -27,7 +27,7 @@ #include "base/check.h" -namespace CVC4 { +namespace CVC5 { std::ostream& operator<<(std::ostream& os, const Rational& q){ return os << q.toString(); @@ -98,4 +98,4 @@ Maybe<Rational> Rational::fromDouble(double d) return Maybe<Rational>(); } -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/util/rational_gmp_imp.h b/src/util/rational_gmp_imp.h index 490211001..0d7569b21 100644 --- a/src/util/rational_gmp_imp.h +++ b/src/util/rational_gmp_imp.h @@ -29,7 +29,7 @@ #include "util/integer.h" #include "util/maybe.h" -namespace CVC4 { +namespace CVC5 { /** ** A multi-precision rational constant. @@ -326,11 +326,11 @@ class CVC4_EXPORT Rational 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 */ diff --git a/src/util/real_algebraic_number_poly_imp.cpp b/src/util/real_algebraic_number_poly_imp.cpp index b4730c1b1..6a8111b55 100644 --- a/src/util/real_algebraic_number_poly_imp.cpp +++ b/src/util/real_algebraic_number_poly_imp.cpp @@ -28,7 +28,7 @@ #include "base/check.h" #include "util/poly_util.h" -namespace CVC4 { +namespace CVC5 { RealAlgebraicNumber::RealAlgebraicNumber(poly::AlgebraicNumber&& an) : d_value(std::move(an)) @@ -174,4 +174,4 @@ int sgn(const RealAlgebraicNumber& ran) { return sgn(ran.getValue()); } bool isZero(const RealAlgebraicNumber& ran) { return is_zero(ran.getValue()); } bool isOne(const RealAlgebraicNumber& ran) { return is_one(ran.getValue()); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/real_algebraic_number_poly_imp.h b/src/util/real_algebraic_number_poly_imp.h index ef5ff16f1..4819e8866 100644 --- a/src/util/real_algebraic_number_poly_imp.h +++ b/src/util/real_algebraic_number_poly_imp.h @@ -26,7 +26,7 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { /** * Represents a real algebraic number based on poly::AlgebraicNumber. @@ -148,6 +148,6 @@ bool isZero(const RealAlgebraicNumber& ran); /** Check whether a real algebraic number is one. */ bool isOne(const RealAlgebraicNumber& ran); -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__REAL_ALGEBRAIC_NUMBER_H */ diff --git a/src/util/regexp.cpp b/src/util/regexp.cpp index eabafeb37..5df83b1ce 100644 --- a/src/util/regexp.cpp +++ b/src/util/regexp.cpp @@ -16,7 +16,7 @@ #include <ostream> -namespace CVC4 { +namespace CVC5 { RegExpRepeat::RegExpRepeat(uint32_t repeatAmount) : d_repeatAmount(repeatAmount) { @@ -57,4 +57,4 @@ std::ostream& operator<<(std::ostream& os, const RegExpLoop& r) return os << "[" << r.d_loopMinOcc << ".." << r.d_loopMaxOcc << "]"; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/regexp.h b/src/util/regexp.h index b08065a25..c28f121c0 100644 --- a/src/util/regexp.h +++ b/src/util/regexp.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC4 { +namespace CVC5 { struct RegExpRepeat { @@ -69,6 +69,6 @@ std::ostream& operator<<(std::ostream& os, const RegExpRepeat& bv); std::ostream& operator<<(std::ostream& os, const RegExpLoop& bv); -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__UTIL__REGEXP_H */ diff --git a/src/util/resource_manager.cpp b/src/util/resource_manager.cpp index c31300077..00395178c 100644 --- a/src/util/resource_manager.cpp +++ b/src/util/resource_manager.cpp @@ -28,7 +28,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { bool WallClockTimer::on() const { @@ -420,4 +420,4 @@ void ResourceManager::registerListener(Listener* listener) return d_listeners.push_back(listener); } -} /* namespace CVC4 */ +} // namespace CVC5 diff --git a/src/util/resource_manager.h b/src/util/resource_manager.h index a8a7edb75..3a6269e99 100644 --- a/src/util/resource_manager.h +++ b/src/util/resource_manager.h @@ -26,7 +26,7 @@ #include <memory> #include <vector> -namespace CVC4 { +namespace CVC5 { class Listener; class Options; @@ -206,6 +206,6 @@ class ResourceManager }; /* class ResourceManager */ -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__RESOURCE_MANAGER_H */ diff --git a/src/util/result.cpp b/src/util/result.cpp index 6e83953a3..f9fa94266 100644 --- a/src/util/result.cpp +++ b/src/util/result.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { Result::Result() : d_sat(SAT_UNKNOWN), @@ -374,4 +374,4 @@ void Result::toStream(std::ostream& out, OutputLanguage language) const { }; } -} /* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/util/result.h b/src/util/result.h index b5c5451ea..e2a3a268a 100644 --- a/src/util/result.h +++ b/src/util/result.h @@ -24,7 +24,7 @@ #include "options/language.h" -namespace CVC4 { +namespace CVC5 { class Result; @@ -160,6 +160,6 @@ bool operator==(enum Result::Entailment e, const Result& r); 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 */ diff --git a/src/util/roundingmode.h b/src/util/roundingmode.h index 485bbf847..e58689df6 100644 --- a/src/util/roundingmode.h +++ b/src/util/roundingmode.h @@ -18,7 +18,7 @@ #include <fenv.h> -namespace CVC4 { +namespace CVC5 { #define CVC4_NUM_ROUNDING_MODES 5 @@ -45,6 +45,6 @@ struct RoundingModeHashFunction inline size_t operator()(const RoundingMode& rm) const { return size_t(rm); } }; /* struct RoundingModeHashFunction */ -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/util/safe_print.cpp b/src/util/safe_print.cpp index adb051d70..c70119822 100644 --- a/src/util/safe_print.cpp +++ b/src/util/safe_print.cpp @@ -28,7 +28,7 @@ /* Size of buffers used */ #define BUFFER_SIZE 20 -namespace CVC4 { +namespace CVC5 { template <> void safe_print(int fd, const std::string& msg) { @@ -214,4 +214,4 @@ void safe_print_right_aligned(int fd, uint64_t i, ssize_t width) { } } -} /* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/util/safe_print.h b/src/util/safe_print.h index dd66ed41b..553f78bb7 100644 --- a/src/util/safe_print.h +++ b/src/util/safe_print.h @@ -44,7 +44,7 @@ #include "cvc4_export.h" -namespace CVC4 { +namespace CVC5 { /** * Prints arrays of chars (e.g. string literals) of length N. Safe to use in a @@ -136,6 +136,6 @@ void safe_print_hex(int fd, uint64_t i); */ void safe_print_right_aligned(int fd, uint64_t i, ssize_t width); -} /* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__SAFE_PRINT_H */ diff --git a/src/util/sampler.cpp b/src/util/sampler.cpp index 05f617aa5..a39aebc63 100644 --- a/src/util/sampler.cpp +++ b/src/util/sampler.cpp @@ -23,7 +23,7 @@ #include "util/bitvector.h" #include "util/random.h" -namespace CVC4 { +namespace CVC5 { BitVector Sampler::pickBvUniform(unsigned sz) { @@ -172,4 +172,4 @@ FloatingPoint Sampler::pickFpBiased(unsigned e, unsigned s) return FloatingPoint(e, s, bv); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/sampler.h b/src/util/sampler.h index 449ef96f9..f715536bc 100644 --- a/src/util/sampler.h +++ b/src/util/sampler.h @@ -22,7 +22,7 @@ #include "util/floatingpoint.h" -namespace CVC4 { +namespace CVC5 { class Sampler { @@ -52,6 +52,6 @@ class Sampler static constexpr double probSpecial = 0.2; }; -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__UTIL_FLOATINGPOINT_SAMPLER_H */ diff --git a/src/util/sexpr.cpp b/src/util/sexpr.cpp index 91ef8a271..3c93ef5ae 100644 --- a/src/util/sexpr.cpp +++ b/src/util/sexpr.cpp @@ -33,7 +33,7 @@ #include "util/ostream_util.h" #include "util/smt2_quote_string.h" -namespace CVC4 { +namespace CVC5 { const int PrettySExprs::s_iosIndex = std::ios_base::xalloc(); @@ -90,12 +90,14 @@ SExpr::SExpr(const SExpr& other) 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), @@ -125,12 +127,14 @@ SExpr::SExpr(unsigned long int value) 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), @@ -304,12 +308,14 @@ std::string SExpr::getValue() const { 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; } @@ -377,4 +383,4 @@ SExpr SExpr::parseListOfListOfAtoms( return SExpr(parsedListsOfAtoms); } -} /* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/util/sexpr.h b/src/util/sexpr.h index aabbf473d..f4eaca663 100644 --- a/src/util/sexpr.h +++ b/src/util/sexpr.h @@ -35,7 +35,7 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { class SExprKeyword { @@ -61,14 +61,14 @@ class CVC4_EXPORT SExpr 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); @@ -120,13 +120,13 @@ class CVC4_EXPORT SExpr * 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 @@ -211,10 +211,10 @@ class CVC4_EXPORT SExpr } 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; @@ -301,6 +301,6 @@ class CVC4_EXPORT PrettySExprs */ std::ostream& operator<<(std::ostream& out, PrettySExprs ps); -} /* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__SEXPR_H */ diff --git a/src/util/smt2_quote_string.cpp b/src/util/smt2_quote_string.cpp index e06e5dc93..7d255c6f1 100644 --- a/src/util/smt2_quote_string.cpp +++ b/src/util/smt2_quote_string.cpp @@ -19,7 +19,7 @@ #include <sstream> #include <string> -namespace CVC4 { +namespace CVC5 { /** * SMT-LIB 2 quoting for symbols @@ -43,4 +43,4 @@ std::string quoteSymbol(const std::string& s){ return s; } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/util/smt2_quote_string.h b/src/util/smt2_quote_string.h index 911faae42..b9e6592df 100644 --- a/src/util/smt2_quote_string.h +++ b/src/util/smt2_quote_string.h @@ -21,13 +21,13 @@ #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 */ diff --git a/src/util/statistics.cpp b/src/util/statistics.cpp index d824e0f21..3c7ac6731 100644 --- a/src/util/statistics.cpp +++ b/src/util/statistics.cpp @@ -20,8 +20,7 @@ #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(); @@ -131,4 +130,4 @@ SExpr StatisticsBase::getStatistic(std::string name) const { } } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/util/statistics.h b/src/util/statistics.h index 7b5400aaf..0c52cfe8e 100644 --- a/src/util/statistics.h +++ b/src/util/statistics.h @@ -29,7 +29,7 @@ #include "cvc4_export.h" #include "util/sexpr.h" -namespace CVC4 { +namespace CVC5 { class Stat; @@ -127,6 +127,6 @@ public: }; /* class Statistics */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__STATISTICS_H */ diff --git a/src/util/statistics_registry.cpp b/src/util/statistics_registry.cpp index b439daba8..bbd98ffaf 100644 --- a/src/util/statistics_registry.cpp +++ b/src/util/statistics_registry.cpp @@ -34,7 +34,7 @@ /****************************************************************************/ /* Some utility functions for timespec */ /****************************************************************************/ -namespace CVC4 { +namespace CVC5 { void StatisticsRegistry::registerStat(Stat* s) { @@ -89,4 +89,4 @@ RegisterStatistic::~RegisterStatistic() { d_reg->unregisterStat(d_stat); } -}/* CVC4 namespace */ +} // namespace CVC5 diff --git a/src/util/statistics_registry.h b/src/util/statistics_registry.h index a55aec282..b8c83436f 100644 --- a/src/util/statistics_registry.h +++ b/src/util/statistics_registry.h @@ -102,7 +102,7 @@ #include "util/statistics.h" #include "util/stats_base.h" -namespace CVC4 { +namespace CVC5 { /** A statistic that contains a SExpr. */ class SExprStat : public Stat { @@ -196,6 +196,6 @@ private: }; /* class RegisterStatistic */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__STATISTICS_REGISTRY_H */ diff --git a/src/util/stats_base.cpp b/src/util/stats_base.cpp index f55e2f5ab..758883cbe 100644 --- a/src/util/stats_base.cpp +++ b/src/util/stats_base.cpp @@ -18,7 +18,7 @@ #include "util/statistics_registry.h" -namespace CVC4 { +namespace CVC5 { Stat::Stat(const std::string& name) : d_name(name) { @@ -112,4 +112,4 @@ SExpr AverageStat::getValue() const return SExpr(Rational::fromDecimal(ss.str())); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/stats_base.h b/src/util/stats_base.h index 24a2ca560..f7d19624a 100644 --- a/src/util/stats_base.h +++ b/src/util/stats_base.h @@ -34,7 +34,7 @@ #define CVC4_USE_STATISTICS false #endif -namespace CVC4 { +namespace CVC5 { /** * The base class for all statistics. @@ -274,6 +274,6 @@ class SizeStat : public Stat const T& d_sized; }; /* class SizeStat */ -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/util/stats_histogram.h b/src/util/stats_histogram.h index 49306ba28..44d4b9e7c 100644 --- a/src/util/stats_histogram.h +++ b/src/util/stats_histogram.h @@ -24,7 +24,7 @@ #include "util/stats_base.h" -namespace CVC4 { +namespace CVC5 { /** * A histogram statistic class for integral types. @@ -123,6 +123,6 @@ class IntegralHistogramStat : public Stat int64_t d_offset; }; /* class IntegralHistogramStat */ -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/util/stats_timer.cpp b/src/util/stats_timer.cpp index 63d9914d6..6280b79e1 100644 --- a/src/util/stats_timer.cpp +++ b/src/util/stats_timer.cpp @@ -21,7 +21,7 @@ #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) @@ -101,4 +101,4 @@ CodeTimer::~CodeTimer() } } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/stats_timer.h b/src/util/stats_timer.h index 36e254795..40df52ade 100644 --- a/src/util/stats_timer.h +++ b/src/util/stats_timer.h @@ -24,7 +24,7 @@ #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; @@ -46,7 +46,7 @@ class CodeTimer; 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 @@ -108,6 +108,6 @@ private: CodeTimer& operator=(const CodeTimer& timer) = delete; }; /* class CodeTimer */ -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/util/stats_utils.cpp b/src/util/stats_utils.cpp index 893afcb4c..2a87ff439 100644 --- a/src/util/stats_utils.cpp +++ b/src/util/stats_utils.cpp @@ -23,7 +23,7 @@ #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) @@ -35,4 +35,4 @@ std::ostream& operator<<(std::ostream& os, << (dur % std::chrono::seconds(1)).count(); } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/stats_utils.h b/src/util/stats_utils.h index b38f7b641..d511539ca 100644 --- a/src/util/stats_utils.h +++ b/src/util/stats_utils.h @@ -23,7 +23,7 @@ #include "cvc4_export.h" -namespace CVC4 { +namespace CVC5 { namespace timer_stat_detail { struct duration; @@ -32,6 +32,6 @@ struct duration; std::ostream& operator<<(std::ostream& os, const timer_stat_detail::duration& dur) CVC4_EXPORT; -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/src/util/string.cpp b/src/util/string.cpp index 73a0d78ee..d1d7fadc2 100644 --- a/src/util/string.cpp +++ b/src/util/string.cpp @@ -25,7 +25,7 @@ using namespace std; -namespace CVC4 { +namespace CVC5 { static_assert(UCHAR_MAX == 255, "Unsigned char is assumed to have 256 values."); @@ -101,7 +101,7 @@ void String::addCharToInternal(unsigned char ch, std::vector<unsigned>& str) std::stringstream serr; serr << "Illegal string character: \"" << ch << "\", must use escape sequence"; - throw CVC4::Exception(serr.str()); + throw CVC5::Exception(serr.str()); } else { @@ -513,4 +513,4 @@ std::ostream &operator<<(std::ostream &os, const String &s) { return os << "\"" << s.toString() << "\""; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/string.h b/src/util/string.h index 6c620587a..a3e0245aa 100644 --- a/src/util/string.h +++ b/src/util/string.h @@ -23,7 +23,7 @@ #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { /** The CVC4 string class * @@ -46,7 +46,7 @@ class String 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 @@ -61,7 +61,7 @@ class String * 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) @@ -112,7 +112,7 @@ class String * 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 @@ -265,7 +265,8 @@ namespace strings { 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 */ @@ -274,6 +275,6 @@ struct StringHashFunction std::ostream& operator<<(std::ostream& os, const String& s); -} // namespace CVC4 +} // namespace CVC5 #endif /* CVC4__UTIL__STRING_H */ diff --git a/src/util/tuple.h b/src/util/tuple.h index d77d7bf97..571bfe797 100644 --- a/src/util/tuple.h +++ b/src/util/tuple.h @@ -23,7 +23,7 @@ #include <vector> #include <utility> -namespace CVC4 { +namespace CVC5 { class TupleUpdate { @@ -49,6 +49,6 @@ inline std::ostream& operator<<(std::ostream& out, const TupleUpdate& t) { return out << "[" << t.getIndex() << "]"; } -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__TUPLE_H */ diff --git a/src/util/unsafe_interrupt_exception.h b/src/util/unsafe_interrupt_exception.h index 29c22409c..31fe26577 100644 --- a/src/util/unsafe_interrupt_exception.h +++ b/src/util/unsafe_interrupt_exception.h @@ -21,9 +21,9 @@ #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() : @@ -40,6 +40,6 @@ class CVC4_EXPORT UnsafeInterruptException : public CVC4::Exception } }; /* class UnsafeInterruptException */ -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__UNSAFE_INTERRUPT_EXCEPTION_H */ diff --git a/src/util/utility.cpp b/src/util/utility.cpp index 6ce331fc4..480b68ff2 100644 --- a/src/util/utility.cpp +++ b/src/util/utility.cpp @@ -22,7 +22,7 @@ #include "base/check.h" -namespace CVC4 { +namespace CVC5 { std::unique_ptr<std::fstream> openTmpFile(std::string* pattern) { @@ -52,4 +52,4 @@ std::unique_ptr<std::fstream> openTmpFile(std::string* pattern) return tmpStream; } -} // namespace CVC4 +} // namespace CVC5 diff --git a/src/util/utility.h b/src/util/utility.h index 411d3a6f3..006f2072c 100644 --- a/src/util/utility.h +++ b/src/util/utility.h @@ -24,8 +24,7 @@ #include <memory> #include <string> -namespace CVC4 { - +namespace CVC5 { /** * Using std::find_if(), finds the first iterator in [first,last) @@ -78,6 +77,6 @@ void container_to_stream(std::ostream& out, */ std::unique_ptr<std::fstream> openTmpFile(std::string* pattern); -}/* CVC4 namespace */ +} // namespace CVC5 #endif /* CVC4__UTILITY_H */ diff --git a/test/api/boilerplate.cpp b/test/api/boilerplate.cpp index c98ea3ef7..1dcff036b 100644 --- a/test/api/boilerplate.cpp +++ b/test/api/boilerplate.cpp @@ -21,7 +21,7 @@ #include "api/cvc4cpp.h" -using namespace CVC4::api; +using namespace CVC5::api; using namespace std; int main() { diff --git a/test/api/issue4889.cpp b/test/api/issue4889.cpp index 032984ebc..2f4173d88 100644 --- a/test/api/issue4889.cpp +++ b/test/api/issue4889.cpp @@ -14,7 +14,7 @@ #include "api/cvc4cpp.h" -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/test/api/issue5074.cpp b/test/api/issue5074.cpp index 1a891251c..d275c3ede 100644 --- a/test/api/issue5074.cpp +++ b/test/api/issue5074.cpp @@ -14,7 +14,7 @@ #include "api/cvc4cpp.h" -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/test/api/ouroborous.cpp b/test/api/ouroborous.cpp index 7b42d6a76..fb4475ca4 100644 --- a/test/api/ouroborous.cpp +++ b/test/api/ouroborous.cpp @@ -34,9 +34,9 @@ #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(); diff --git a/test/api/reset_assertions.cpp b/test/api/reset_assertions.cpp index 6a6574398..30b03a8f8 100644 --- a/test/api/reset_assertions.cpp +++ b/test/api/reset_assertions.cpp @@ -22,7 +22,7 @@ #include "api/cvc4cpp.h" -using namespace CVC4::api; +using namespace CVC5::api; int main() { diff --git a/test/api/sep_log_api.cpp b/test/api/sep_log_api.cpp index e4288f8ed..ab373bf7c 100644 --- a/test/api/sep_log_api.cpp +++ b/test/api/sep_log_api.cpp @@ -24,7 +24,7 @@ #include "api/cvc4cpp.h" -using namespace CVC4::api; +using namespace CVC5::api; using namespace std; /** diff --git a/test/api/smt2_compliance.cpp b/test/api/smt2_compliance.cpp index 223028d4c..8604366ba 100644 --- a/test/api/smt2_compliance.cpp +++ b/test/api/smt2_compliance.cpp @@ -26,8 +26,8 @@ #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); diff --git a/test/api/two_solvers.cpp b/test/api/two_solvers.cpp index b0188353c..d0a05478c 100644 --- a/test/api/two_solvers.cpp +++ b/test/api/two_solvers.cpp @@ -19,7 +19,7 @@ #include "api/cvc4cpp.h" -using namespace CVC4::api; +using namespace CVC5::api; using namespace std; int main() { diff --git a/test/unit/api/datatype_api_black.cpp b/test/unit/api/datatype_api_black.cpp index ccc61c36a..97db622c6 100644 --- a/test/unit/api/datatype_api_black.cpp +++ b/test/unit/api/datatype_api_black.cpp @@ -16,7 +16,7 @@ #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace api; @@ -547,4 +547,4 @@ TEST_F(TestApiBlackDatatype, datatypeSpecializedCons) ASSERT_THROW(nilc.getSpecializedConstructorTerm(isort), CVC4ApiException); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/api/grammar_black.cpp b/test/unit/api/grammar_black.cpp index c816fa5a3..96ad29503 100644 --- a/test/unit/api/grammar_black.cpp +++ b/test/unit/api/grammar_black.cpp @@ -16,7 +16,7 @@ #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace api; @@ -122,4 +122,4 @@ TEST_F(TestApiBlackGrammar, addAnyVariable) ASSERT_THROW(g1.addAnyVariable(start), CVC4ApiException); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/api/op_black.cpp b/test/unit/api/op_black.cpp index 46aa9799b..2333e5719 100644 --- a/test/unit/api/op_black.cpp +++ b/test/unit/api/op_black.cpp @@ -14,7 +14,7 @@ #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace api; @@ -178,4 +178,4 @@ TEST_F(TestApiBlackOp, opScopingToString) ASSERT_EQ(bitvector_repeat_ot.toString(), op_repr); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/api/op_white.cpp b/test/unit/api/op_white.cpp index a8509ee26..49a964e9e 100644 --- a/test/unit/api/op_white.cpp +++ b/test/unit/api/op_white.cpp @@ -14,7 +14,7 @@ #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace api; @@ -32,4 +32,4 @@ TEST_F(TestApiWhiteOp, opFromKind) ASSERT_EQ(plus, d_solver.mkOp(PLUS)); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/api/result_black.cpp b/test/unit/api/result_black.cpp index a52eba2b7..f27b30431 100644 --- a/test/unit/api/result_black.cpp +++ b/test/unit/api/result_black.cpp @@ -14,7 +14,7 @@ #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace api; @@ -26,7 +26,7 @@ class TestApiBlackResult : public TestApi 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()); @@ -37,7 +37,7 @@ TEST_F(TestApiBlackResult, 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 = d_solver.checkSat(); + CVC5::api::Result res = d_solver.checkSat(); ASSERT_FALSE(res.isNull()); } @@ -46,9 +46,9 @@ TEST_F(TestApiBlackResult, eq) 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); @@ -59,7 +59,7 @@ TEST_F(TestApiBlackResult, isSat) 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()); } @@ -69,7 +69,7 @@ TEST_F(TestApiBlackResult, isUnsat) 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()); } @@ -82,7 +82,7 @@ TEST_F(TestApiBlackResult, 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()); } @@ -96,10 +96,10 @@ TEST_F(TestApiBlackResult, isEntailed) 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()); } @@ -112,10 +112,10 @@ TEST_F(TestApiBlackResult, 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 diff --git a/test/unit/api/solver_black.cpp b/test/unit/api/solver_black.cpp index ed7edf633..8f15e9017 100644 --- a/test/unit/api/solver_black.cpp +++ b/test/unit/api/solver_black.cpp @@ -16,7 +16,7 @@ #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace api; @@ -1422,7 +1422,7 @@ TEST_F(TestApiBlackSolver, getUnsatCore3) { d_solver.assertFormula(t); } - CVC4::api::Result res = d_solver.checkSat(); + CVC5::api::Result res = d_solver.checkSat(); ASSERT_TRUE(res.isUnsat()); } @@ -1533,7 +1533,7 @@ void checkSimpleSeparationConstraints(Solver* solver) 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))); @@ -2343,4 +2343,4 @@ TEST_F(TestApiBlackSolver, tupleProject) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/api/solver_white.cpp b/test/unit/api/solver_white.cpp index 84d68dbc6..66a6c70f1 100644 --- a/test/unit/api/solver_white.cpp +++ b/test/unit/api/solver_white.cpp @@ -17,7 +17,7 @@ #include "base/configuration.h" #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace api; @@ -54,4 +54,4 @@ TEST_F(TestApiWhiteSolver, getOp) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/api/sort_black.cpp b/test/unit/api/sort_black.cpp index 8e7eb00ec..f1ec0985a 100644 --- a/test/unit/api/sort_black.cpp +++ b/test/unit/api/sort_black.cpp @@ -16,7 +16,7 @@ #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace api; @@ -603,4 +603,4 @@ TEST_F(TestApiBlackSort, sortScopedToString) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/api/term_black.cpp b/test/unit/api/term_black.cpp index c087e2175..7ac1a881e 100644 --- a/test/unit/api/term_black.cpp +++ b/test/unit/api/term_black.cpp @@ -14,7 +14,7 @@ #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace api; @@ -848,4 +848,4 @@ TEST_F(TestApiBlackTerm, termScopedToString) ASSERT_EQ(x.toString(), "x"); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/api/term_white.cpp b/test/unit/api/term_white.cpp index 9906fd731..de8e94227 100644 --- a/test/unit/api/term_white.cpp +++ b/test/unit/api/term_white.cpp @@ -14,7 +14,7 @@ #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace api; @@ -81,4 +81,4 @@ TEST_F(TestApiWhiteTerm, getOp) ASSERT_EQ(tailTerm.getOp(), Op(&d_solver, APPLY_SELECTOR)); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/base/map_util_black.cpp b/test/unit/base/map_util_black.cpp index 13e842653..76238ad04 100644 --- a/test/unit/base/map_util_black.cpp +++ b/test/unit/base/map_util_black.cpp @@ -27,7 +27,7 @@ #include "context/context.h" #include "test.h" -namespace CVC4 { +namespace CVC5 { using context::CDHashMap; using context::CDInsertHashMap; @@ -63,8 +63,8 @@ class TestBaseBlackMap : public TestInternal 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")) @@ -78,8 +78,8 @@ TEST_F(TestBaseBlackMap, map) 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")) { @@ -94,8 +94,8 @@ TEST_F(TestBaseBlackMap, unordered_map) { 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")) @@ -110,8 +110,8 @@ TEST_F(TestBaseBlackMap, const_unordered_map) { 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")) { @@ -125,23 +125,23 @@ TEST_F(TestBaseBlackMap, const_unordered_map) 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) @@ -150,8 +150,8 @@ 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")) { @@ -168,8 +168,8 @@ TEST_F(TestBaseBlackMap, const_CDHashMap) 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")) { @@ -185,8 +185,8 @@ TEST_F(TestBaseBlackMap, CDInsertHashMap) 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")) { @@ -203,8 +203,8 @@ TEST_F(TestBaseBlackMap, const_CDInsertHashMap) 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"); @@ -213,4 +213,4 @@ TEST_F(TestBaseBlackMap, const_CDInsertHashMap) ASSERT_EQ(FindOrDie(map, "other"), "entry"); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/context/cdhashmap_black.cpp b/test/unit/context/cdhashmap_black.cpp index a5788a585..51d76070a 100644 --- a/test/unit/context/cdhashmap_black.cpp +++ b/test/unit/context/cdhashmap_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -21,11 +21,11 @@ #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 { @@ -203,4 +203,4 @@ TEST_F(TestContextBlackCDHashMap, insert_at_context_level_zero) ASSERT_TRUE(elements_are(map, {{3, 4}, {23, 317}})); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/context/cdhashmap_white.cpp b/test/unit/context/cdhashmap_white.cpp index 91ddc726d..06bcd8d46 100644 --- a/test/unit/context/cdhashmap_white.cpp +++ b/test/unit/context/cdhashmap_white.cpp @@ -9,16 +9,16 @@ ** 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; @@ -44,4 +44,4 @@ TEST_F(TestContextWhiteCDHashMap, unreachable_save_and_restore) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/context/cdlist_black.cpp b/test/unit/context/cdlist_black.cpp index 2339962ac..e903492ee 100644 --- a/test/unit/context/cdlist_black.cpp +++ b/test/unit/context/cdlist_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -24,7 +24,7 @@ #include "memory.h" #include "test_context.h" -namespace CVC4 { +namespace CVC5 { using namespace context; @@ -163,4 +163,4 @@ TEST_F(TestContextBlackCDList, pop_below_level_created) list.push_back(42); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/context/cdo_black.cpp b/test/unit/context/cdo_black.cpp index 16d7949e0..033e60f57 100644 --- a/test/unit/context/cdo_black.cpp +++ b/test/unit/context/cdo_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -22,7 +22,7 @@ #include "context/cdo.h" #include "test_context.h" -namespace CVC4 { +namespace CVC5 { using namespace context; @@ -48,4 +48,4 @@ TEST_F(TestContextBlackCDO, cdo) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/context/context_black.cpp b/test/unit/context/context_black.cpp index 59b723055..7ec7ef6c8 100644 --- a/test/unit/context/context_black.cpp +++ b/test/unit/context/context_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -22,7 +22,7 @@ #include "context/cdo.h" #include "test_context.h" -namespace CVC4 { +namespace CVC5 { using namespace context; @@ -241,4 +241,4 @@ TEST_F(TestContextBlack, top_scope_context_obj) #endif } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/context/context_mm_black.cpp b/test/unit/context/context_mm_black.cpp index b0259e71e..2dbec57b6 100644 --- a/test/unit/context/context_mm_black.cpp +++ b/test/unit/context/context_mm_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -21,7 +21,7 @@ #include "context/context_mm.h" #include "test.h" -namespace CVC4 { +namespace CVC5 { using namespace context; @@ -104,4 +104,4 @@ TEST_F(TestContextBlackMM, push_pop) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/context/context_white.cpp b/test/unit/context/context_white.cpp index 9d8ff84c7..6ec7ea3a1 100644 --- a/test/unit/context/context_white.cpp +++ b/test/unit/context/context_white.cpp @@ -9,16 +9,16 @@ ** 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; @@ -180,4 +180,4 @@ TEST_F(TestContextWhite, simple) ASSERT_EQ(c.d_ppContextObjPrev, &s->d_pContextObjList); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/main/interactive_shell_black.cpp b/test/unit/main/interactive_shell_black.cpp index c600e3477..0ee485fc2 100644 --- a/test/unit/main/interactive_shell_black.cpp +++ b/test/unit/main/interactive_shell_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -27,7 +27,7 @@ #include "smt/command.h" #include "test.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestMainBlackInteractiveShell : public TestInternal @@ -41,7 +41,7 @@ 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())); } @@ -80,7 +80,7 @@ class TestMainBlackInteractiveShell : public TestInternal 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; }; @@ -133,4 +133,4 @@ TEST_F(TestMainBlackInteractiveShell, repeated_empty_lines) countCommands(shell, 0, 3); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/memory.h b/test/unit/memory.h index b54bcd451..1341274dd 100644 --- a/test/unit/memory.h +++ b/test/unit/memory.h @@ -15,7 +15,7 @@ ** ** 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. @@ -53,7 +53,7 @@ # endif #endif -namespace CVC4 { +namespace CVC5 { namespace test { #ifndef CVC4_MEMORY_LIMITING_DISABLED @@ -86,9 +86,8 @@ class WithLimitedMemory { }; /* 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 diff --git a/test/unit/node/attribute_black.cpp b/test/unit/node/attribute_black.cpp index 487798e49..48f68159f 100644 --- a/test/unit/node/attribute_black.cpp +++ b/test/unit/node/attribute_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -23,7 +23,7 @@ #include "expr/node_value.h" #include "test_node.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace smt; @@ -125,4 +125,4 @@ TEST_F(TestNodeBlackAttribute, bools) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/attribute_white.cpp b/test/unit/node/attribute_white.cpp index fccb587db..75bc87893 100644 --- a/test/unit/node/attribute_white.cpp +++ b/test/unit/node/attribute_white.cpp @@ -30,7 +30,7 @@ #include "theory/theory_engine.h" #include "theory/uf/theory_uf.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace smt; @@ -445,4 +445,4 @@ TEST_F(TestNodeWhiteAttribute, attributes) ASSERT_FALSE(unnamed.hasAttribute(VarNameAttr())); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/kind_black.cpp b/test/unit/node/kind_black.cpp index a33955152..9c497f026 100644 --- a/test/unit/node/kind_black.cpp +++ b/test/unit/node/kind_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -21,7 +21,7 @@ #include "expr/kind.h" #include "test.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; @@ -87,4 +87,4 @@ TEST_F(TestNodeBlackKind, output_concat) ASSERT_EQ(act.str(), exp.str()); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/kind_map_black.cpp b/test/unit/node/kind_map_black.cpp index 8e1c45d79..85c8fb2cd 100644 --- a/test/unit/node/kind_map_black.cpp +++ b/test/unit/node/kind_map_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -21,7 +21,7 @@ #include "expr/kind_map.h" #include "test.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; @@ -45,4 +45,4 @@ TEST_F(TestNodeBlackKindMap, simple) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/node_algorithm_black.cpp b/test/unit/node/node_algorithm_black.cpp index bd243e0fd..47f66f0c3 100644 --- a/test/unit/node/node_algorithm_black.cpp +++ b/test/unit/node/node_algorithm_black.cpp @@ -25,7 +25,7 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { using namespace expr; using namespace kind; @@ -199,4 +199,4 @@ TEST_F(TestNodeBlackNodeAlgorithm, match) ASSERT_EQ(subs[x], a); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/node_black.cpp b/test/unit/node/node_black.cpp index 3c1651155..7ae8a9434 100644 --- a/test/unit/node/node_black.cpp +++ b/test/unit/node/node_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -30,7 +30,7 @@ #include "test_node.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; @@ -784,4 +784,4 @@ TEST_F(TestNodeBlackNode, node_tnode_usage) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/node_builder_black.cpp b/test/unit/node/node_builder_black.cpp index 7e38dd899..62410bcb7 100644 --- a/test/unit/node/node_builder_black.cpp +++ b/test/unit/node/node_builder_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -30,7 +30,7 @@ #define K 30u #define LARGE_K UINT_MAX / 40 -namespace CVC4 { +namespace CVC5 { using namespace kind; @@ -587,4 +587,4 @@ TEST_F(TestNodeBlackNodeBuilder, leftist_building) ASSERT_EQ(nexpected, n); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/node_manager_black.cpp b/test/unit/node/node_manager_black.cpp index a2ede3ed0..7866d87bd 100644 --- a/test/unit/node/node_manager_black.cpp +++ b/test/unit/node/node_manager_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -24,7 +24,7 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace expr; @@ -330,4 +330,4 @@ TEST_F(TestNodeBlackNodeManager, mkNode_too_many_children) #endif } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/node_manager_white.cpp b/test/unit/node/node_manager_white.cpp index daf211b78..588c39181 100644 --- a/test/unit/node/node_manager_white.cpp +++ b/test/unit/node/node_manager_white.cpp @@ -9,9 +9,9 @@ ** 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> @@ -21,9 +21,9 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { -using namespace CVC4::expr; +using namespace CVC5::expr; namespace test { @@ -81,4 +81,4 @@ TEST_F(TestNodeWhiteNodeManager, topological_sort) } } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/node_self_iterator_black.cpp b/test/unit/node/node_self_iterator_black.cpp index 34ab5f09b..0a0a877c3 100644 --- a/test/unit/node/node_self_iterator_black.cpp +++ b/test/unit/node/node_self_iterator_black.cpp @@ -9,9 +9,9 @@ ** 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" @@ -19,7 +19,7 @@ #include "expr/node_self_iterator.h" #include "test_node.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace expr; @@ -54,4 +54,4 @@ TEST_F(TestNodeBlackNodeSelfIterator, iteration) ASSERT_EQ(++i, x_and_y.end()); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/node_traversal_black.cpp b/test/unit/node/node_traversal_black.cpp index e443ff685..c54be86ac 100644 --- a/test/unit/node/node_traversal_black.cpp +++ b/test/unit/node/node_traversal_black.cpp @@ -26,7 +26,7 @@ #include "expr/node_value.h" #include "test_node.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; @@ -293,4 +293,4 @@ TEST_F(TestNodeBlackNodeTraversalPreorder, skip_if) ASSERT_EQ(actual, expected); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/node_white.cpp b/test/unit/node/node_white.cpp index 651dd1990..d914c5dc2 100644 --- a/test/unit/node/node_white.cpp +++ b/test/unit/node/node_white.cpp @@ -9,9 +9,9 @@ ** 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> @@ -19,7 +19,7 @@ #include "base/check.h" #include "test_node.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace expr; @@ -79,4 +79,4 @@ TEST_F(TestNodeWhiteNode, iterators) ASSERT_EQ(v[2], y); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/symbol_table_black.cpp b/test/unit/node/symbol_table_black.cpp index c1865eaa9..27911c34b 100644 --- a/test/unit/node/symbol_table_black.cpp +++ b/test/unit/node/symbol_table_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -24,7 +24,7 @@ #include "expr/symbol_table.h" #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace context; @@ -146,4 +146,4 @@ TEST_F(TestNodeBlackSymbolTable, bad_pop) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/type_cardinality_black.cpp b/test/unit/node/type_cardinality_black.cpp index 55936df0d..e2aeced08 100644 --- a/test/unit/node/type_cardinality_black.cpp +++ b/test/unit/node/type_cardinality_black.cpp @@ -21,7 +21,7 @@ #include "test_node.h" #include "util/cardinality.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; @@ -332,4 +332,4 @@ TEST_F(TestNodeBlackTypeCardinality, bitvectors) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/node/type_node_white.cpp b/test/unit/node/type_node_white.cpp index f364e40fc..37d80a9fa 100644 --- a/test/unit/node/type_node_white.cpp +++ b/test/unit/node/type_node_white.cpp @@ -23,7 +23,7 @@ #include "smt/smt_engine.h" #include "test_node.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace context; @@ -94,4 +94,4 @@ TEST_F(TestNodeWhiteTypeNode, sub_types) ASSERT_TRUE(bvType.getBaseType() == bvType); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/parser/parser_black.cpp b/test/unit/parser/parser_black.cpp index 87556d53d..827d7dd84 100644 --- a/test/unit/parser/parser_black.cpp +++ b/test/unit/parser/parser_black.cpp @@ -9,10 +9,10 @@ ** 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> @@ -29,7 +29,7 @@ #include "smt/command.h" #include "test.h" -namespace CVC4 { +namespace CVC5 { using namespace parser; using namespace language::input; @@ -48,7 +48,7 @@ class TestParserBlackParser : public TestInternal 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 @@ -186,7 +186,7 @@ class TestParserBlackParser : public TestInternal 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; }; @@ -392,4 +392,4 @@ TEST_F(TestParserBlackSmt2Parser, bad_exprs) #endif } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/parser/parser_builder_black.cpp b/test/unit/parser/parser_builder_black.cpp index 08b16dd07..3ebd11b83 100644 --- a/test/unit/parser/parser_builder_black.cpp +++ b/test/unit/parser/parser_builder_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -29,7 +29,7 @@ #include "parser/parser_builder.h" #include "test_api.h" -namespace CVC4 { +namespace CVC5 { using namespace parser; using namespace language::input; @@ -134,4 +134,4 @@ TEST_F(TestParseBlackParserBuilder, true_stream_input) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/preprocessing/pass_bv_gauss_white.cpp b/test/unit/preprocessing/pass_bv_gauss_white.cpp index 2bafd7f30..130d6b1cf 100644 --- a/test/unit/preprocessing/pass_bv_gauss_white.cpp +++ b/test/unit/preprocessing/pass_bv_gauss_white.cpp @@ -29,7 +29,7 @@ #include "theory/rewriter.h" #include "util/bitvector.h" -namespace CVC4 { +namespace CVC5 { using namespace preprocessing; using namespace preprocessing::passes; @@ -3099,4 +3099,4 @@ TEST_F(TestPPWhiteBVGauss, get_min_bw5b) ASSERT_EQ(BVGauss::getMinBwExpr(Rewriter::rewrite(plus7)), 17); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/preprocessing/pass_foreign_theory_rewrite_white.cpp b/test/unit/preprocessing/pass_foreign_theory_rewrite_white.cpp index 279cca59a..cbd178576 100644 --- a/test/unit/preprocessing/pass_foreign_theory_rewrite_white.cpp +++ b/test/unit/preprocessing/pass_foreign_theory_rewrite_white.cpp @@ -18,7 +18,7 @@ #include "smt/smt_engine.h" #include "test_smt.h" -namespace CVC4 { +namespace CVC5 { using namespace preprocessing::passes; @@ -47,4 +47,4 @@ TEST_F(TestPPWhiteForeignTheoryRewrite, simplify) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/printer/smt2_printer_black.cpp b/test/unit/printer/smt2_printer_black.cpp index a84105b20..2f4d6fb38 100644 --- a/test/unit/printer/smt2_printer_black.cpp +++ b/test/unit/printer/smt2_printer_black.cpp @@ -23,7 +23,7 @@ #include "smt/smt_engine.h" #include "test_smt.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; @@ -59,4 +59,4 @@ TEST_F(TestPrinterBlackSmt2, regexp_loop) checkToString(n, "((_ re.loop 1 3) (str.to_re \"x\"))"); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/prop/cnf_stream_white.cpp b/test/unit/prop/cnf_stream_white.cpp index ae41fd041..40f986d33 100644 --- a/test/unit/prop/cnf_stream_white.cpp +++ b/test/unit/prop/cnf_stream_white.cpp @@ -9,9 +9,9 @@ ** 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" @@ -28,7 +28,7 @@ #include "theory/theory.h" #include "theory/theory_engine.h" -namespace CVC4 { +namespace CVC5 { using namespace context; using namespace prop; @@ -113,7 +113,7 @@ class TestPropWhiteCnfStream : public TestSmt 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(), @@ -271,4 +271,4 @@ TEST_F(TestPropWhiteCnfStream, ensure_literal) ASSERT_TRUE(d_cnfStream->hasLiteral(a_and_b)); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/test.h b/test/unit/test.h index e42b5e8c8..1c5614488 100644 --- a/test/unit/test.h +++ b/test/unit/test.h @@ -17,7 +17,7 @@ #include "gtest/gtest.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestInternal : public ::testing::Test @@ -25,5 +25,5 @@ class TestInternal : public ::testing::Test }; } // namespace test -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/test/unit/test_api.h b/test/unit/test_api.h index 4722b63ea..033136524 100644 --- a/test/unit/test_api.h +++ b/test/unit/test_api.h @@ -18,15 +18,15 @@ #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 diff --git a/test/unit/test_context.h b/test/unit/test_context.h index ffb6d89be..024488fc4 100644 --- a/test/unit/test_context.h +++ b/test/unit/test_context.h @@ -18,16 +18,16 @@ #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 diff --git a/test/unit/test_node.h b/test/unit/test_node.h index cf343f006..1aefbae45 100644 --- a/test/unit/test_node.h +++ b/test/unit/test_node.h @@ -20,7 +20,7 @@ #include "smt/smt_engine_scope.h" #include "test.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestNode : public TestInternal @@ -45,5 +45,5 @@ class TestNode : public TestInternal }; } // namespace test -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/test/unit/test_smt.h b/test/unit/test_smt.h index e55c00e65..a6097b56c 100644 --- a/test/unit/test_smt.h +++ b/test/unit/test_smt.h @@ -29,7 +29,7 @@ #include "util/resource_manager.h" #include "util/unsafe_interrupt_exception.h" -namespace CVC4 { +namespace CVC5 { namespace test { /* -------------------------------------------------------------------------- */ @@ -99,7 +99,7 @@ inline std::ostream& operator<<(std::ostream& out, OutputChannelCallType type) } } -class DummyOutputChannel : public CVC4::theory::OutputChannel +class DummyOutputChannel : public CVC5::theory::OutputChannel { public: DummyOutputChannel() {} @@ -249,5 +249,5 @@ class DummyTheory : public theory::Theory /* -------------------------------------------------------------------------- */ } // namespace test -} // namespace CVC4 +} // namespace CVC5 #endif diff --git a/test/unit/theory/evaluator_white.cpp b/test/unit/theory/evaluator_white.cpp index ff04adef1..54976c7d7 100644 --- a/test/unit/theory/evaluator_white.cpp +++ b/test/unit/theory/evaluator_white.cpp @@ -24,7 +24,7 @@ #include "theory/rewriter.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; @@ -156,4 +156,4 @@ TEST_F(TestTheoryWhiteEvaluator, code) } } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/logic_info_white.cpp b/test/unit/theory/logic_info_white.cpp index 56dd062df..0c45cc4ed 100644 --- a/test/unit/theory/logic_info_white.cpp +++ b/test/unit/theory/logic_info_white.cpp @@ -9,9 +9,9 @@ ** 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" @@ -19,7 +19,7 @@ #include "test.h" #include "theory/logic_info.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; @@ -544,33 +544,33 @@ TEST_F(TestTheoryWhiteLogicInfo, default_logic) 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()); @@ -598,17 +598,17 @@ TEST_F(TestTheoryWhiteLogicInfo, default_logic) 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); @@ -617,7 +617,7 @@ TEST_F(TestTheoryWhiteLogicInfo, default_logic) info.arithOnlyLinear(); info.disableIntegers(); info.lock(); - if (CVC4::Configuration::isBuiltWithSymFPU()) + if (CVC5::Configuration::isBuiltWithSymFPU()) { ASSERT_EQ(info.getLogicString(), "SEP_AUFBVFPDTLRA"); } @@ -631,7 +631,7 @@ TEST_F(TestTheoryWhiteLogicInfo, default_logic) info.disableQuantifiers(); info.disableTheory(THEORY_BAGS); info.lock(); - if (CVC4::Configuration::isBuiltWithSymFPU()) + if (CVC5::Configuration::isBuiltWithSymFPU()) { ASSERT_EQ(info.getLogicString(), "QF_SEP_AUFBVFPDTLRA"); } @@ -648,7 +648,7 @@ TEST_F(TestTheoryWhiteLogicInfo, default_logic) info.enableIntegers(); info.disableReals(); info.lock(); - if (CVC4::Configuration::isBuiltWithSymFPU()) + if (CVC5::Configuration::isBuiltWithSymFPU()) { ASSERT_EQ(info.getLogicString(), "QF_SEP_AUFFPLIA"); } @@ -1371,4 +1371,4 @@ TEST_F(TestTheoryWhiteLogicInfo, comparison) gt(ufHo, "QF_UF"); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/regexp_operation_black.cpp b/test/unit/theory/regexp_operation_black.cpp index 0b6bf6500..b87701534 100644 --- a/test/unit/theory/regexp_operation_black.cpp +++ b/test/unit/theory/regexp_operation_black.cpp @@ -27,7 +27,7 @@ #include "theory/strings/regexp_operation.h" #include "theory/strings/skolem_cache.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace theory; @@ -144,4 +144,4 @@ TEST_F(TestTheoryBlackRegexpOperation, star_wildcards) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/sequences_rewriter_white.cpp b/test/unit/theory/sequences_rewriter_white.cpp index fd6e3f3c0..7a85ad13d 100644 --- a/test/unit/theory/sequences_rewriter_white.cpp +++ b/test/unit/theory/sequences_rewriter_white.cpp @@ -28,7 +28,7 @@ #include "theory/strings/strings_entail.h" #include "theory/strings/strings_rewriter.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace theory::quantifiers; @@ -85,10 +85,10 @@ TEST_F(TestTheoryWhiteSequencesRewriter, check_entail_length_one) 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)); @@ -149,8 +149,8 @@ TEST_F(TestTheoryWhiteSequencesRewriter, check_entail_with_with_assumption) 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); @@ -223,10 +223,10 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_substr) 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)); @@ -364,8 +364,8 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_concat) 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)); @@ -431,11 +431,11 @@ TEST_F(TestTheoryWhiteSequencesRewriter, length_preserve_rewrite) 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); @@ -467,12 +467,12 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_indexOf) 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)); @@ -577,12 +577,12 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace) 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); @@ -773,7 +773,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_re) 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); } @@ -790,7 +790,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_re) 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); } @@ -807,7 +807,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_re) 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); } @@ -824,7 +824,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_re) 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); } @@ -841,7 +841,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_re) 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); } @@ -858,7 +858,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_re) 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); } } @@ -893,7 +893,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_all) 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); } @@ -910,7 +910,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_all) 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); } @@ -927,7 +927,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_all) 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); } @@ -944,7 +944,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_all) 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); } @@ -961,7 +961,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_all) 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); } @@ -978,7 +978,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_replace_all) d_nodeManager->mkConst(String("")), sigStar, foo); - Node res = d_nodeManager->mkConst(::CVC4::String("")); + Node res = d_nodeManager->mkConst(::CVC5::String("")); sameNormalForm(t, res); } } @@ -988,18 +988,18 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_contains) 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); @@ -1356,9 +1356,9 @@ TEST_F(TestTheoryWhiteSequencesRewriter, infer_eqs_from_contains) { 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); @@ -1400,8 +1400,8 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_prefix_suffix) { 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); @@ -1437,11 +1437,11 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_equality_ext) 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); @@ -1726,14 +1726,14 @@ TEST_F(TestTheoryWhiteSequencesRewriter, strip_constant_endpoints) 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); @@ -1833,7 +1833,7 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_membership) 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); @@ -1908,4 +1908,4 @@ TEST_F(TestTheoryWhiteSequencesRewriter, rewrite_regexp_concat) } } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/strings_rewriter_white.cpp b/test/unit/theory/strings_rewriter_white.cpp index 93aa1667a..94bf8b581 100644 --- a/test/unit/theory/strings_rewriter_white.cpp +++ b/test/unit/theory/strings_rewriter_white.cpp @@ -24,7 +24,7 @@ #include "theory/rewriter.h" #include "theory/strings/strings_rewriter.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace theory; @@ -41,8 +41,8 @@ TEST_F(TestTheoryWhiteStringsRewriter, rewrite_leq) 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); @@ -61,4 +61,4 @@ TEST_F(TestTheoryWhiteStringsRewriter, rewrite_leq) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_arith_white.cpp b/test/unit/theory/theory_arith_white.cpp index d0ed5718e..ac992f5c9 100644 --- a/test/unit/theory/theory_arith_white.cpp +++ b/test/unit/theory/theory_arith_white.cpp @@ -24,7 +24,7 @@ #include "theory/theory_engine.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace theory::arith; @@ -122,4 +122,4 @@ TEST_F(TestTheoryWhiteArith, int_normal_form) ASSERT_EQ(Rewriter::rewrite(Rewriter::rewrite(t)), Rewriter::rewrite(t)); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_bags_normal_form_white.cpp b/test/unit/theory/theory_bags_normal_form_white.cpp index ce6dbc79a..09f5c2ae9 100644 --- a/test/unit/theory/theory_bags_normal_form_white.cpp +++ b/test/unit/theory/theory_bags_normal_form_white.cpp @@ -18,7 +18,7 @@ #include "theory/bags/normal_form.h" #include "theory/strings/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace kind; @@ -40,7 +40,7 @@ class TestTheoryWhiteBagsNormalForm : public TestSmt 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++) @@ -586,4 +586,4 @@ TEST_F(TestTheoryWhiteBagsNormalForm, to_set) ASSERT_EQ(output3, NormalForm::evaluate(input3)); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_bags_rewriter_white.cpp b/test/unit/theory/theory_bags_rewriter_white.cpp index 987f21fb5..a1cc2761a 100644 --- a/test/unit/theory/theory_bags_rewriter_white.cpp +++ b/test/unit/theory/theory_bags_rewriter_white.cpp @@ -17,7 +17,7 @@ #include "theory/bags/bags_rewriter.h" #include "theory/strings/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace kind; @@ -688,4 +688,4 @@ TEST_F(TestTheoryWhiteBagsRewriter, to_set) && response.d_status == REWRITE_AGAIN_FULL); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_bags_type_rules_white.cpp b/test/unit/theory/theory_bags_type_rules_white.cpp index 0922a22a4..830169c8b 100644 --- a/test/unit/theory/theory_bags_type_rules_white.cpp +++ b/test/unit/theory/theory_bags_type_rules_white.cpp @@ -17,7 +17,7 @@ #include "theory/bags/theory_bags_type_rules.h" #include "theory/strings/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace kind; @@ -33,7 +33,7 @@ class TestTheoryWhiteBagsTypeRule : public TestSmt 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++) @@ -110,4 +110,4 @@ TEST_F(TestTheoryWhiteBagsTypeRule, to_set_operator) ASSERT_TRUE(d_nodeManager->mkNode(BAG_TO_SET, bag).getType().isSet()); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_black.cpp b/test/unit/theory/theory_black.cpp index 096013110..ddd43a063 100644 --- a/test/unit/theory/theory_black.cpp +++ b/test/unit/theory/theory_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -23,7 +23,7 @@ #include "test_smt.h" #include "theory/rewriter.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace context; @@ -129,4 +129,4 @@ TEST_F(TestTheoryBlack, array_const) ASSERT_TRUE(arr2.isConst()); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_bv_int_blaster_white.cpp b/test/unit/theory/theory_bv_int_blaster_white.cpp index 7888ba52b..247f5428f 100644 --- a/test/unit/theory/theory_bv_int_blaster_white.cpp +++ b/test/unit/theory/theory_bv_int_blaster_white.cpp @@ -22,7 +22,7 @@ #include "theory/bv/int_blaster.h" #include "util/bitvector.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace theory; @@ -44,4 +44,4 @@ class TestTheoryWhiteBvIntblaster : public TestSmtNoFinishInit Node d_one; }; } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_bv_rewriter_white.cpp b/test/unit/theory/theory_bv_rewriter_white.cpp index 556785680..c7262117c 100644 --- a/test/unit/theory/theory_bv_rewriter_white.cpp +++ b/test/unit/theory/theory_bv_rewriter_white.cpp @@ -23,7 +23,7 @@ #include "theory/rewriter.h" #include "util/bitvector.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace theory; @@ -81,4 +81,4 @@ TEST_F(TestTheoryWhiteBvRewriter, rewrite_bv_ite) ASSERT_EQ(nr, Rewriter::rewrite(nr)); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_bv_white.cpp b/test/unit/theory/theory_bv_white.cpp index 1447670f3..020c7d0a5 100644 --- a/test/unit/theory/theory_bv_white.cpp +++ b/test/unit/theory/theory_bv_white.cpp @@ -25,7 +25,7 @@ #include "theory/theory.h" #include "theory/theory_engine.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace theory::bv; @@ -93,4 +93,4 @@ TEST_F(TestTheoryWhiteBv, mkUmulo) } } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_engine_white.cpp b/test/unit/theory/theory_engine_white.cpp index e0040e3d3..ff2f3a836 100644 --- a/test/unit/theory/theory_engine_white.cpp +++ b/test/unit/theory/theory_engine_white.cpp @@ -9,9 +9,9 @@ ** 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 @@ -33,7 +33,7 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace expr; @@ -183,4 +183,4 @@ TEST_F(TestTheoryWhiteEngine, rewrite_rules) } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_int_opt_white.cpp b/test/unit/theory/theory_int_opt_white.cpp index 81556d33a..fc20d6d73 100644 --- a/test/unit/theory/theory_int_opt_white.cpp +++ b/test/unit/theory/theory_int_opt_white.cpp @@ -15,7 +15,7 @@ #include "smt/optimization_solver.h" #include "test_smt.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace smt; @@ -136,4 +136,4 @@ TEST_F(TestTheoryWhiteIntOpt, result) std::cout << "Result is :" << r << std::endl; } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_quantifiers_bv_instantiator_white.cpp b/test/unit/theory/theory_quantifiers_bv_instantiator_white.cpp index 942986a7e..715eea5f9 100644 --- a/test/unit/theory/theory_quantifiers_bv_instantiator_white.cpp +++ b/test/unit/theory/theory_quantifiers_bv_instantiator_white.cpp @@ -24,7 +24,7 @@ #include "theory/rewriter.h" #include "util/bitvector.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace theory::bv; @@ -452,4 +452,4 @@ TEST_F(TestTheoryWhiteyQuantifiersBvInstantiator, normalizePvEqual) ASSERT_EQ(norm_axax[1], a); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_quantifiers_bv_inverter_white.cpp b/test/unit/theory/theory_quantifiers_bv_inverter_white.cpp index 7b6a73d2c..4ad3f04ef 100644 --- a/test/unit/theory/theory_quantifiers_bv_inverter_white.cpp +++ b/test/unit/theory/theory_quantifiers_bv_inverter_white.cpp @@ -20,7 +20,7 @@ #include "theory/quantifiers/bv_inverter_utils.h" #include "util/result.h" -namespace CVC4 { +namespace CVC5 { using namespace kind; using namespace theory; @@ -1611,4 +1611,4 @@ TEST_F(TestTheoryWhiteQuantifiersBvInverter, getIC_bv_sext_sgt_false) runTestSext(false, BITVECTOR_SGT); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_sets_type_enumerator_white.cpp b/test/unit/theory/theory_sets_type_enumerator_white.cpp index fdf8e3a5e..adee0c266 100644 --- a/test/unit/theory/theory_sets_type_enumerator_white.cpp +++ b/test/unit/theory/theory_sets_type_enumerator_white.cpp @@ -9,9 +9,9 @@ ** 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.) @@ -21,7 +21,7 @@ #include "test_smt.h" #include "theory/sets/theory_sets_type_enumerator.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace kind; @@ -152,4 +152,4 @@ TEST_F(TestTheoryWhiteSetsTypeEnumerator, bv) ASSERT_TRUE(setEnumerator.isFinished()); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_sets_type_rules_white.cpp b/test/unit/theory/theory_sets_type_rules_white.cpp index b6bda5564..22b0a09d6 100644 --- a/test/unit/theory/theory_sets_type_rules_white.cpp +++ b/test/unit/theory/theory_sets_type_rules_white.cpp @@ -16,9 +16,9 @@ #include "test_api.h" #include "test_node.h" -namespace CVC4 { +namespace CVC5 { -using namespace CVC4::api; +using namespace CVC5::api; namespace test { @@ -83,4 +83,4 @@ TEST_F(TestTheoryWhiteSetsTypeRuleInternal, singleton_node) ASSERT_TRUE(n.isConst()); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_strings_skolem_cache_black.cpp b/test/unit/theory/theory_strings_skolem_cache_black.cpp index 64ebe2b97..06a86b844 100644 --- a/test/unit/theory/theory_strings_skolem_cache_black.cpp +++ b/test/unit/theory/theory_strings_skolem_cache_black.cpp @@ -20,7 +20,7 @@ #include "util/rational.h" #include "util/string.h" -namespace CVC4 { +namespace CVC5 { using namespace theory::strings; @@ -59,4 +59,4 @@ TEST_F(TestTheoryBlackStringsSkolemCache, mkSkolemCached) } } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_strings_word_white.cpp b/test/unit/theory/theory_strings_word_white.cpp index 5e5c57053..03b9ed4c2 100644 --- a/test/unit/theory/theory_strings_word_white.cpp +++ b/test/unit/theory/theory_strings_word_white.cpp @@ -20,7 +20,7 @@ #include "test_node.h" #include "theory/strings/word.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace theory::strings; @@ -121,4 +121,4 @@ TEST_F(TestTheoryWhiteStringsWord, strings) ASSERT_TRUE(Word::roverlap(aaaaa, aa) == 2); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/theory_white.cpp b/test/unit/theory/theory_white.cpp index 048fac5ac..41abdd6d1 100644 --- a/test/unit/theory/theory_white.cpp +++ b/test/unit/theory/theory_white.cpp @@ -9,9 +9,9 @@ ** 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> @@ -24,7 +24,7 @@ #include "theory/theory_engine.h" #include "util/resource_manager.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace expr; @@ -109,4 +109,4 @@ TEST_F(TestTheoryWhite, outputChannel) d_outputChannel.d_callHistory.clear(); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/theory/type_enumerator_white.cpp b/test/unit/theory/type_enumerator_white.cpp index 538a608e8..2e018f9cf 100644 --- a/test/unit/theory/type_enumerator_white.cpp +++ b/test/unit/theory/type_enumerator_white.cpp @@ -9,9 +9,9 @@ ** 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.) **/ @@ -25,7 +25,7 @@ #include "test_smt.h" #include "theory/type_enumerator.h" -namespace CVC4 { +namespace CVC5 { using namespace theory; using namespace kind; @@ -332,4 +332,4 @@ TEST_F(TestTheoryWhiteTypeEnumerator, bv) ASSERT_THROW(*++te, NoMoreValuesException); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/array_store_all_white.cpp b/test/unit/util/array_store_all_white.cpp index 540fca6f2..5be00263d 100644 --- a/test/unit/util/array_store_all_white.cpp +++ b/test/unit/util/array_store_all_white.cpp @@ -9,15 +9,15 @@ ** 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 @@ -75,4 +75,4 @@ TEST_F(TestUtilWhiteArrayStoreAll, const_error) IllegalArgumentException); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/assert_white.cpp b/test/unit/util/assert_white.cpp index 0f1d5786e..a64bf275d 100644 --- a/test/unit/util/assert_white.cpp +++ b/test/unit/util/assert_white.cpp @@ -9,9 +9,9 @@ ** 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> @@ -20,7 +20,7 @@ #include "base/check.h" #include "test.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilWhite : public TestInternal @@ -86,4 +86,4 @@ TEST_F(TestUtilWhite, CheckArgument) ASSERT_THROW(CheckArgument(false, "x"), IllegalArgumentException); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/binary_heap_black.cpp b/test/unit/util/binary_heap_black.cpp index b35b8fa21..0b52b6d14 100644 --- a/test/unit/util/binary_heap_black.cpp +++ b/test/unit/util/binary_heap_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -20,7 +20,7 @@ #include "test.h" #include "util/bin_heap.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilBlackBinaryHeap : public TestInternal @@ -230,4 +230,4 @@ TEST_F(TestUtilBlackBinaryHeap, large_heap) ASSERT_TRUE(heap.empty()); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/bitvector_black.cpp b/test/unit/util/bitvector_black.cpp index 3de70cfec..b26d8a1c6 100644 --- a/test/unit/util/bitvector_black.cpp +++ b/test/unit/util/bitvector_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -19,7 +19,7 @@ #include "test.h" #include "util/bitvector.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilBlackBitVector : public TestInternal @@ -203,4 +203,4 @@ TEST_F(TestUtilBlackBitVector, static_helpers) ASSERT_EQ(BitVector::mkMaxSigned(4).toSignedInteger(), Integer(7)); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/boolean_simplification_black.cpp b/test/unit/util/boolean_simplification_black.cpp index ef5ddadd6..cce2518c4 100644 --- a/test/unit/util/boolean_simplification_black.cpp +++ b/test/unit/util/boolean_simplification_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -26,7 +26,7 @@ #include "smt_util/boolean_simplification.h" #include "test_node.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilBlackBooleanSimplification : public TestNode @@ -248,4 +248,4 @@ TEST_F(TestUtilBlackBooleanSimplification, simplifyConflict) #endif } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/cardinality_black.cpp b/test/unit/util/cardinality_black.cpp index 9f5552037..b4b6ab6a5 100644 --- a/test/unit/util/cardinality_black.cpp +++ b/test/unit/util/cardinality_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -22,7 +22,7 @@ #include "util/cardinality.h" #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilBlackCardinality : public TestInternal @@ -270,4 +270,4 @@ TEST_F(TestUtilBlackCardinality, cardinalities) ASSERT_EQ((z ^ z).getBethNumber(), 3); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/check_white.cpp b/test/unit/util/check_white.cpp index 5ee0f42c4..4985bced3 100644 --- a/test/unit/util/check_white.cpp +++ b/test/unit/util/check_white.cpp @@ -20,7 +20,7 @@ #include "base/check.h" #include "test.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilWhiteCheck : public TestInternal @@ -63,4 +63,4 @@ TEST_F(TestUtilWhiteCheck, expect_abort) ASSERT_DEATH(AlwaysAssert(false), "false"); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/configuration_black.cpp b/test/unit/util/configuration_black.cpp index 44ae8c04b..a7c5c2703 100644 --- a/test/unit/util/configuration_black.cpp +++ b/test/unit/util/configuration_black.cpp @@ -9,15 +9,15 @@ ** 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 @@ -96,4 +96,4 @@ TEST_F(TestUtilBlackConfiguration, about) Configuration::about(); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/datatype_black.cpp b/test/unit/util/datatype_black.cpp index ef24d870d..b486d91e9 100644 --- a/test/unit/util/datatype_black.cpp +++ b/test/unit/util/datatype_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -21,7 +21,7 @@ #include "expr/type_node.h" #include "test_smt.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilBlackDatatype : public TestSmt @@ -495,4 +495,4 @@ TEST_F(TestUtilBlackDatatype, parametric_DType) ASSERT_EQ(TypeNode::leastCommonTypeNode(pairIntInt, pairIntInt), pairIntInt); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/exception_black.cpp b/test/unit/util/exception_black.cpp index d6ac7af67..7216c0b8c 100644 --- a/test/unit/util/exception_black.cpp +++ b/test/unit/util/exception_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -20,14 +20,14 @@ #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; @@ -52,4 +52,4 @@ TEST_F(TestUtilBlackException, exceptions) ASSERT_EQ(s3.str(), std::string("three of 'em!")); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/floatingpoint_black.cpp b/test/unit/util/floatingpoint_black.cpp index fd27268d1..391c656f3 100644 --- a/test/unit/util/floatingpoint_black.cpp +++ b/test/unit/util/floatingpoint_black.cpp @@ -9,15 +9,15 @@ ** 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 @@ -136,4 +136,4 @@ TEST_F(TestUtilBlackFloatingPoint, makeMaxNormal) ASSERT_TRUE(mfp128.isNormal()); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/integer_black.cpp b/test/unit/util/integer_black.cpp index 29b971160..fc92fa0d2 100644 --- a/test/unit/util/integer_black.cpp +++ b/test/unit/util/integer_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -21,7 +21,7 @@ #include "test.h" #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilBlackInteger : public TestInternal @@ -564,4 +564,4 @@ TEST_F(TestUtilBlackInteger, modInverse) } } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/integer_white.cpp b/test/unit/util/integer_white.cpp index 16e606d87..3b5363dda 100644 --- a/test/unit/util/integer_white.cpp +++ b/test/unit/util/integer_white.cpp @@ -9,9 +9,9 @@ ** 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> @@ -19,7 +19,7 @@ #include "test.h" #include "util/integer.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilWhiteInteger : public TestInternal @@ -53,4 +53,4 @@ TEST_F(TestUtilWhiteInteger, construction) ASSERT_EQ(Integer(u), Integer(u)); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/output_black.cpp b/test/unit/util/output_black.cpp index 48b1d4087..f5c973849 100644 --- a/test/unit/util/output_black.cpp +++ b/test/unit/util/output_black.cpp @@ -20,7 +20,7 @@ #include "base/output.h" #include "test.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilBlackOutput : public TestInternal @@ -241,4 +241,4 @@ TEST_F(TestUtilBlackOutput, simple_print) #endif /* CVC4_MUZZLE */ } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/rational_black.cpp b/test/unit/util/rational_black.cpp index d3eaaf61e..e6dee5d55 100644 --- a/test/unit/util/rational_black.cpp +++ b/test/unit/util/rational_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -19,7 +19,7 @@ #include "test.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilBlackRational : public TestInternal @@ -44,4 +44,4 @@ TEST_F(TestUtilBlackRational, fromDecimal) ASSERT_THROW(Rational::fromDecimal("Hello, world!");, std::invalid_argument); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/rational_white.cpp b/test/unit/util/rational_white.cpp index df2dd1b17..542a43990 100644 --- a/test/unit/util/rational_white.cpp +++ b/test/unit/util/rational_white.cpp @@ -9,9 +9,9 @@ ** 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> @@ -19,7 +19,7 @@ #include "test.h" #include "util/rational.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilWhiteRational : public TestInternal @@ -416,4 +416,4 @@ TEST_F(TestUtilWhiteRational, constructrion) ASSERT_EQ(Rational(u), Rational(u)); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/real_algebraic_number_black.cpp b/test/unit/util/real_algebraic_number_black.cpp index 97bbb438c..4300b709c 100644 --- a/test/unit/util/real_algebraic_number_black.cpp +++ b/test/unit/util/real_algebraic_number_black.cpp @@ -9,15 +9,15 @@ ** 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 @@ -81,4 +81,4 @@ TEST_F(TestUtilBlackRealAlgebraicNumber, arithmetic) ASSERT_EQ(msqrt2 * sqrt2, RealAlgebraicNumber(Integer(-2))); } } // namespace test -} // namespace CVC4 +} // namespace CVC5 diff --git a/test/unit/util/stats_black.cpp b/test/unit/util/stats_black.cpp index 71cde7e5a..f8a14d9b2 100644 --- a/test/unit/util/stats_black.cpp +++ b/test/unit/util/stats_black.cpp @@ -9,9 +9,9 @@ ** 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> @@ -27,7 +27,7 @@ #include "util/stats_histogram.h" #include "util/stats_timer.h" -namespace CVC4 { +namespace CVC5 { namespace test { class TestUtilBlackStats : public TestInternal @@ -49,7 +49,7 @@ TEST_F(TestUtilBlackStats, stats) 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 @@ -161,4 +161,4 @@ TEST_F(TestUtilBlackStats, stats) #endif } } // namespace test -} // namespace CVC4 +} // namespace CVC5 |