diff options
1458 files changed, 5578 insertions, 5578 deletions
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5ba5cf444..5e682993c 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() { CVC5::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 1cbfdb031..043bbf8aa 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 CVC5::api; +using namespace cvc5::api; int main() { diff --git a/examples/api/bitvectors_and_arrays.cpp b/examples/api/bitvectors_and_arrays.cpp index 5c243e1d1..2bca1eb4c 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 CVC5::api; +using namespace cvc5::api; int main() { diff --git a/examples/api/combination.cpp b/examples/api/combination.cpp index 2651bf80f..9ea2f55ed 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 CVC5::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 c2b3bc4c4..49253e466 100644 --- a/examples/api/datatypes.cpp +++ b/examples/api/datatypes.cpp @@ -18,7 +18,7 @@ #include <cvc4/api/cvc4cpp.h> -using namespace CVC5::api; +using namespace cvc5::api; void test(Solver& slv, Sort& consListSort) { diff --git a/examples/api/extract.cpp b/examples/api/extract.cpp index a6a43a7c2..760f5d0fe 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 CVC5::api; +using namespace cvc5::api; int main() { diff --git a/examples/api/helloworld.cpp b/examples/api/helloworld.cpp index 89b0e212d..092e2a79a 100644 --- a/examples/api/helloworld.cpp +++ b/examples/api/helloworld.cpp @@ -18,7 +18,7 @@ #include <cvc4/api/cvc4cpp.h> -using namespace CVC5::api; +using namespace cvc5::api; int main() { diff --git a/examples/api/linear_arith.cpp b/examples/api/linear_arith.cpp index ca3e8a2b9..b56982daa 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 CVC5::api; +using namespace cvc5::api; int main() { diff --git a/examples/api/sequences.cpp b/examples/api/sequences.cpp index 6272b423b..3498b3275 100644 --- a/examples/api/sequences.cpp +++ b/examples/api/sequences.cpp @@ -18,7 +18,7 @@ #include <iostream> -using namespace CVC5::api; +using namespace cvc5::api; int main() { diff --git a/examples/api/sets.cpp b/examples/api/sets.cpp index cac705415..59385896c 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 CVC5::api; +using namespace cvc5::api; int main() { diff --git a/examples/api/strings.cpp b/examples/api/strings.cpp index b926395de..53352d266 100644 --- a/examples/api/strings.cpp +++ b/examples/api/strings.cpp @@ -18,7 +18,7 @@ #include <cvc4/api/cvc4cpp.h> -using namespace CVC5::api; +using namespace cvc5::api; int main() { diff --git a/examples/api/sygus-fun.cpp b/examples/api/sygus-fun.cpp index a29cdb132..be4d3e8d5 100644 --- a/examples/api/sygus-fun.cpp +++ b/examples/api/sygus-fun.cpp @@ -49,7 +49,7 @@ #include <iostream> -using namespace CVC5::api; +using namespace cvc5::api; int main() { diff --git a/examples/api/sygus-grammar.cpp b/examples/api/sygus-grammar.cpp index 6491dc0a5..61b00f6de 100644 --- a/examples/api/sygus-grammar.cpp +++ b/examples/api/sygus-grammar.cpp @@ -46,7 +46,7 @@ #include <iostream> -using namespace CVC5::api; +using namespace cvc5::api; int main() { diff --git a/examples/api/sygus-inv.cpp b/examples/api/sygus-inv.cpp index 206803eb6..56b5a0aaa 100644 --- a/examples/api/sygus-inv.cpp +++ b/examples/api/sygus-inv.cpp @@ -37,7 +37,7 @@ #include <iostream> -using namespace CVC5::api; +using namespace cvc5::api; int main() { diff --git a/examples/hashsmt/sha1_collision.cpp b/examples/hashsmt/sha1_collision.cpp index 6fa7954ea..0545ce048 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 CVC5; +using namespace cvc5; hashsmt::cvc4_uchar8 *createInput(unsigned size, std::string prefix, std::ostream& output) { hashsmt::cvc4_uchar8 *input = new hashsmt::cvc4_uchar8[size]; @@ -102,7 +102,7 @@ int main(int argc, char* argv[]) { delete[] cvc4input1; delete[] cvc4input2; } - catch (CVC5::Exception& e) + catch (cvc5::Exception& e) { cerr << e << endl; } diff --git a/examples/hashsmt/sha1_inversion.cpp b/examples/hashsmt/sha1_inversion.cpp index 957f9225e..a4acfc3c6 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 CVC5; +using namespace cvc5; int main(int argc, char* argv[]) { @@ -105,7 +105,7 @@ int main(int argc, char* argv[]) { // Checksat command output << CheckSatCommand() << endl; } - catch (CVC5::Exception& e) + catch (cvc5::Exception& e) { cerr << e << endl; } diff --git a/examples/hashsmt/word.cpp b/examples/hashsmt/word.cpp index 5fd5b7979..79b868d1c 100644 --- a/examples/hashsmt/word.cpp +++ b/examples/hashsmt/word.cpp @@ -33,8 +33,8 @@ using namespace std; using namespace hashsmt; -using namespace CVC5; -using namespace CVC5::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) { - CVC5::Options options; + cvc5::Options options; options.setInputLanguage(language::input::LANG_SMTLIB_V2); options.setOutputLanguage(language::output::LANG_SMTLIB_V2); - s_manager = new CVC5::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 << CVC5::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 4a1d142f4..f5b95ba32 100644 --- a/examples/hashsmt/word.h +++ b/examples/hashsmt/word.h @@ -35,20 +35,20 @@ namespace hashsmt { class Word { /** Expression managaer we're using for all word expressions */ - static CVC5::ExprManager* s_manager; + static cvc5::ExprManager* s_manager; protected: /** The expression of this word */ - CVC5::Expr d_expr; + cvc5::Expr d_expr; /** Get the expression manager words are using */ - static CVC5::ExprManager* em(); + static cvc5::ExprManager* em(); - Word(CVC5::Expr expr = CVC5::Expr()) : d_expr(expr) {} + Word(cvc5::Expr expr = cvc5::Expr()) : d_expr(expr) {} /** Extend the representing expression to the given size >= size() */ - CVC5::Expr extendToSize(unsigned size) const; + cvc5::Expr extendToSize(unsigned size) const; public: @@ -70,10 +70,10 @@ class Word { void print(std::ostream& out) const; - CVC5::Expr getExpr() const { return d_expr; } + cvc5::Expr getExpr() const { return d_expr; } /** Returns the comparison expression */ - CVC5::Expr operator==(const Word& b) const; + 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 daa7d920d..ba495e1fd 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 CVC5; -using namespace CVC5::parser; -using namespace CVC5::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 661747ab0..1eb4b3d4d 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 CVC5; -using namespace CVC5::parser; -using namespace CVC5::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 2a12b828e..8139a4d91 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 CVC5; -using namespace CVC5::parser; -using namespace CVC5::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 aecdf5ba2..09b0c69d8 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 CVC5; -using namespace CVC5::parser; -using namespace CVC5::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 02795dc1f..6cb51f17c 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 CVC5; -using namespace CVC5::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 1bfe9424b..afd468d5d 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 CVC5; -using namespace CVC5::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 4238e9f13..d9bd6012a 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 CVC5; -using namespace CVC5::parser; -using namespace CVC5::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 b9ced3d79..ec95b5f70 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 CVC5; -using namespace CVC5::parser; -using namespace CVC5::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 b6890e6ef..b97b86bb8 100644 --- a/examples/simple_vc_cxx.cpp +++ b/examples/simple_vc_cxx.cpp @@ -20,7 +20,7 @@ #include <iostream> -using namespace CVC5::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 e6778fa41..73dbfe34f 100644 --- a/examples/simple_vc_quant_cxx.cpp +++ b/examples/simple_vc_quant_cxx.cpp @@ -18,7 +18,7 @@ #include <iostream> -using namespace CVC5::api; +using namespace cvc5::api; int main() { Solver slv; diff --git a/examples/translator.cpp b/examples/translator.cpp index 1a9de7f80..4838e06fb 100644 --- a/examples/translator.cpp +++ b/examples/translator.cpp @@ -28,9 +28,9 @@ #include <cvc4/options/set_language.h> using namespace std; -using namespace CVC5; -using namespace CVC5::language; -using namespace CVC5::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 4686c0694..175388bf4 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() == CVC5::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() == CVC5::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 1c1b6b28c..9e55cdaf0 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 CVC5 { +namespace cvc5 { namespace api { /* -------------------------------------------------------------------------- */ @@ -87,570 +87,570 @@ struct Statistics /* -------------------------------------------------------------------------- */ /* Mapping from external (API) kind to internal kind. */ -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}, +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, 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}, + {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, 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}, + {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, CVC5::Kind::APPLY_UF}, - {CARDINALITY_CONSTRAINT, CVC5::Kind::CARDINALITY_CONSTRAINT}, - {CARDINALITY_VALUE, CVC5::Kind::CARDINALITY_VALUE}, - {HO_APPLY, CVC5::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, 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}, + {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, 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}, + {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, 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}, + {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, - CVC5::Kind::FLOATINGPOINT_TO_FP_FLOATINGPOINT}, - {FLOATINGPOINT_TO_FP_REAL, CVC5::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, - CVC5::Kind::FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR}, + cvc5::Kind::FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR}, {FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR, - 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}, + 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, CVC5::Kind::SELECT}, - {STORE, CVC5::Kind::STORE}, - {CONST_ARRAY, CVC5::Kind::STORE_ALL}, - {EQ_RANGE, CVC5::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, 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}, + {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, 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}, + {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, 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}, + {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, 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}, + {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, 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}, + {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, 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}, + {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, 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}, + {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<CVC5::Kind, Kind, CVC5::kind::KindHashFunction> +const static std::unordered_map<cvc5::Kind, Kind, cvc5::kind::KindHashFunction> s_kinds_internal{ - {CVC5::Kind::UNDEFINED_KIND, UNDEFINED_KIND}, - {CVC5::Kind::NULL_EXPR, NULL_EXPR}, + {cvc5::Kind::UNDEFINED_KIND, UNDEFINED_KIND}, + {cvc5::Kind::NULL_EXPR, NULL_EXPR}, /* Builtin --------------------------------------------------------- */ - {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}, + {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 --------------------------------------------------------- */ - {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}, + {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 -------------------------------------------------------------- */ - {CVC5::Kind::APPLY_UF, APPLY_UF}, - {CVC5::Kind::CARDINALITY_CONSTRAINT, CARDINALITY_CONSTRAINT}, - {CVC5::Kind::CARDINALITY_VALUE, CARDINALITY_VALUE}, - {CVC5::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 ------------------------------------------------------ */ - {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}, + {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 -------------------------------------------------------------- */ - {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}, + {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 -------------------------------------------------------------- */ - {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, + {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}, - {CVC5::Kind::FLOATINGPOINT_TO_FP_IEEE_BITVECTOR, + {cvc5::Kind::FLOATINGPOINT_TO_FP_IEEE_BITVECTOR, FLOATINGPOINT_TO_FP_IEEE_BITVECTOR}, - {CVC5::Kind::FLOATINGPOINT_TO_FP_FLOATINGPOINT_OP, + {cvc5::Kind::FLOATINGPOINT_TO_FP_FLOATINGPOINT_OP, FLOATINGPOINT_TO_FP_FLOATINGPOINT}, - {CVC5::Kind::FLOATINGPOINT_TO_FP_FLOATINGPOINT, + {cvc5::Kind::FLOATINGPOINT_TO_FP_FLOATINGPOINT, FLOATINGPOINT_TO_FP_FLOATINGPOINT}, - {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, + {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}, - {CVC5::Kind::FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR, + {cvc5::Kind::FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR, FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR}, - {CVC5::Kind::FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR_OP, + {cvc5::Kind::FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR_OP, FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR}, - {CVC5::Kind::FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR, + {cvc5::Kind::FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR, FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR}, - {CVC5::Kind::FLOATINGPOINT_TO_FP_GENERIC_OP, + {cvc5::Kind::FLOATINGPOINT_TO_FP_GENERIC_OP, FLOATINGPOINT_TO_FP_GENERIC}, - {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}, + {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 ---------------------------------------------------------- */ - {CVC5::Kind::SELECT, SELECT}, - {CVC5::Kind::STORE, STORE}, - {CVC5::Kind::STORE_ALL, CONST_ARRAY}, + {cvc5::Kind::SELECT, SELECT}, + {cvc5::Kind::STORE, STORE}, + {cvc5::Kind::STORE_ALL, CONST_ARRAY}, /* Datatypes ------------------------------------------------------- */ - {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}, + {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 ------------------------------------------------ */ - {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}, + {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 ------------------------------------------------------------ */ - {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}, + {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 ------------------------------------------------------------ */ - {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}, + {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 --------------------------------------------------------- */ - {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}, + {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 ----------------------------------------------------- */ - {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}, + {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}, /* ----------------------------------------------------------------- */ - {CVC5::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 CVC5::Kind (internal) to a CVC5::api::Kind (external). */ -CVC5::api::Kind intToExtKind(CVC5::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 @@ CVC5::api::Kind intToExtKind(CVC5::Kind k) return it->second; } -/** Convert a CVC5::api::Kind (external) to a CVC5::Kind (internal). */ -CVC5::Kind extToIntKind(CVC5::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 CVC5::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(CVC5::Kind k) +bool isApplyKind(cvc5::Kind k) { - return (k == CVC5::Kind::APPLY_UF || k == CVC5::Kind::APPLY_CONSTRUCTOR - || k == CVC5::Kind::APPLY_SELECTOR || k == CVC5::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(CVC5::Kind k) +bool isDefinedIntKind(cvc5::Kind k) { - return k != CVC5::Kind::UNDEFINED_KIND && k != CVC5::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 = CVC5::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 = CVC5::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" - : CVC5::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 CVC5::RecoverableModalException& e) \ + catch (const cvc5::RecoverableModalException& e) \ { \ throw CVC4ApiRecoverableException(e.getMessage()); \ } \ - catch (const CVC5::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 CVC5::Result& r) : d_result(new CVC5::Result(r)) {} +Result::Result(const cvc5::Result& r) : d_result(new cvc5::Result(r)) {} -Result::Result() : d_result(new CVC5::Result()) {} +Result::Result() : d_result(new cvc5::Result()) {} bool Result::isNull() const { - return d_result->getType() == CVC5::Result::TYPE_NONE; + return d_result->getType() == cvc5::Result::TYPE_NONE; } bool Result::isSat(void) const { - return d_result->getType() == CVC5::Result::TYPE_SAT - && d_result->isSat() == CVC5::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() == CVC5::Result::TYPE_SAT - && d_result->isSat() == CVC5::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() == CVC5::Result::TYPE_SAT - && d_result->isSat() == CVC5::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() == CVC5::Result::TYPE_ENTAILMENT - && d_result->isEntailed() == CVC5::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() == CVC5::Result::TYPE_ENTAILMENT - && d_result->isEntailed() == CVC5::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() == CVC5::Result::TYPE_ENTAILMENT - && d_result->isEntailed() == CVC5::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 { - CVC5::Result::UnknownExplanation expl = d_result->whyUnknown(); + cvc5::Result::UnknownExplanation expl = d_result->whyUnknown(); switch (expl) { - 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; + 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 CVC5::TypeNode& t) - : d_solver(slv), d_type(new CVC5::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 CVC5::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<CVC5::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<CVC5::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 CVC5::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 CVC5::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 CVC5::Node()) + : d_solver(slv), d_kind(k), d_node(new cvc5::Node()) { } -Op::Op(const Solver* slv, const Kind k, const CVC5::Node& n) - : d_solver(slv), d_kind(k), d_node(new CVC5::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) { - CVC5::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) { - CVC5::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) { - CVC5::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) { - CVC5::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) { - CVC5::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) { - CVC5::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) { - CVC5::FloatingPointToFPGeneric ext = + cvc5::FloatingPointToFPGeneric ext = d_node->getConst<FloatingPointToFPGeneric>(); indices = std::make_pair(ext.getSize().exponentWidth(), ext.getSize().significandWidth()); } else if (k == REGEXP_LOOP) { - CVC5::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 CVC5::Node()) {} +Term::Term() : d_solver(nullptr), d_node(new cvc5::Node()) {} -Term::Term(const Solver* slv, const CVC5::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 CVC5::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 - CVC5::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() == CVC5::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() == CVC5::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<CVC5::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 CVC5::Node& Term::getNode(void) const { return *d_node; } +const cvc5::Node& Term::getNode(void) const { return *d_node; } namespace detail { -const Rational& getRational(const CVC5::Node& node) +const Rational& getRational(const cvc5::Node& node) { return node.getConst<Rational>(); } -Integer getInteger(const CVC5::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() == CVC5::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() == CVC5::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() == CVC5::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<CVC5::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 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; + 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 CVC5::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 CVC5::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 CVC5::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<CVC5::DType>( - new CVC5::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; } -CVC5::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 CVC5::DTypeSelector& stor) - : d_solver(slv), d_stor(new CVC5::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 CVC5::DTypeConstructor& ctor) - : d_solver(slv), d_ctor(new CVC5::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 CVC5::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<CVC5::DTypeSelector>>& sels = + const std::vector<std::shared_ptr<cvc5::DTypeSelector>>& sels = ctor.getArgs(); - for (const std::shared_ptr<CVC5::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 CVC5::DType& dtype) - : d_solver(slv), d_dtype(new CVC5::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 CVC5::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( - CVC5::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<CVC5::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(CVC5::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( - CVC5::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, CVC5::RoundingMode, RoundingModeHashFunction> + unordered_map<RoundingMode, cvc5::RoundingMode, RoundingModeHashFunction> s_rmodes{ {ROUND_NEAREST_TIES_TO_EVEN, - 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}, + 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, - CVC5::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY}, + cvc5::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY}, }; -const static std::unordered_map<CVC5::RoundingMode, +const static std::unordered_map<cvc5::RoundingMode, RoundingMode, - CVC5::RoundingModeHashFunction> + cvc5::RoundingModeHashFunction> s_rmodes_internal{ - {CVC5::RoundingMode::ROUND_NEAREST_TIES_TO_EVEN, + {cvc5::RoundingMode::ROUND_NEAREST_TIES_TO_EVEN, ROUND_NEAREST_TIES_TO_EVEN}, - {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, + {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}, }; @@ -4097,7 +4097,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() == CVC5::kind::TYPE_CONSTANT + TypeConstant tc = tn.getKind() == cvc5::kind::TYPE_CONSTANT ? tn.getConst<TypeConstant>() : LAST_TYPE; if (is_var) @@ -4128,10 +4128,10 @@ Term Solver::mkRealFromStrHelper(const std::string& s) const //////// all checks before this line try { - CVC5::Rational r = s.find('/') != std::string::npos - ? CVC5::Rational(s) - : CVC5::Rational::fromDecimal(s); - return mkValHelper<CVC5::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) { @@ -4148,7 +4148,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<CVC5::BitVector>(CVC5::BitVector(size, val)); + return mkValHelper<cvc5::BitVector>(cvc5::BitVector(size, val)); } Term Solver::mkBVFromStrHelper(const std::string& s, uint32_t base) const @@ -4157,7 +4157,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<CVC5::BitVector>(CVC5::BitVector(s, base)); + return mkValHelper<cvc5::BitVector>(cvc5::BitVector(s, base)); } Term Solver::mkBVFromStrHelper(uint32_t size, @@ -4184,7 +4184,7 @@ Term Solver::mkBVFromStrHelper(uint32_t size, << size << " too small to hold value " << s << ")"; } - return mkValHelper<CVC5::BitVector>(CVC5::BitVector(size, val)); + return mkValHelper<cvc5::BitVector>(cvc5::BitVector(size, val)); } Term Solver::mkCharFromStrHelper(const std::string& s) const @@ -4199,7 +4199,7 @@ Term Solver::mkCharFromStrHelper(const std::string& s) const //////// all checks before this line std::vector<unsigned> cpts; cpts.push_back(val); - return mkValHelper<CVC5::String>(CVC5::String(cpts)); + return mkValHelper<cvc5::String>(cvc5::String(cpts)); } Term Solver::getValueHelper(const Term& term) const @@ -4234,14 +4234,14 @@ Term Solver::mkTermFromKind(Kind kind) const Node res; if (kind == REGEXP_EMPTY || kind == REGEXP_SIGMA) { - CVC5::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(), CVC5::kind::PI); + res = d_nodeMgr->mkNullaryOperator(d_nodeMgr->realType(), cvc5::kind::PI); } (void)res.getType(true); /* kick off type checking */ increment_term_stats(kind); @@ -4254,7 +4254,7 @@ Term Solver::mkTermHelper(Kind kind, const std::vector<Term>& children) const //////// all checks before this line std::vector<Node> echildren = Term::termVectorToNodes(children); - CVC5::Kind k = extToIntKind(kind); + cvc5::Kind k = extToIntKind(kind); Node res; if (echildren.size() > 2) { @@ -4344,7 +4344,7 @@ Term Solver::mkTermHelper(const Op& op, const std::vector<Term>& children) const return mkTermHelper(op.d_kind, children); } - const CVC5::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); @@ -4364,14 +4364,14 @@ std::vector<Sort> Solver::mkDatatypeSortsInternal( // double checks //////// all checks before this line - std::vector<CVC5::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<CVC5::TypeNode> dtypes = + std::vector<cvc5::TypeNode> dtypes = getNodeManager()->mkMutualDatatypeTypes(datatypes, utypes); std::vector<Sort> retTypes = Sort::typeNodeVectorToSorts(this, dtypes); return retTypes; @@ -4443,7 +4443,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(CVC5::Rational(1)))); + d_nodeMgr->mkConst(cvc5::Rational(1)))); } Assert(res.getSort() == sort); return res; @@ -4511,7 +4511,7 @@ void Solver::checkMkTerm(Kind kind, uint32_t nchildren) const { CVC4_API_KIND_CHECK(kind); Assert(isDefinedIntKind(extToIntKind(kind))); - const CVC5::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) @@ -4874,7 +4874,7 @@ Term Solver::mkPi() const CVC4_API_TRY_CATCH_BEGIN; //////// all checks before this line Node res = - d_nodeMgr->mkNullaryOperator(d_nodeMgr->realType(), CVC5::kind::PI); + d_nodeMgr->mkNullaryOperator(d_nodeMgr->realType(), cvc5::kind::PI); (void)res.getType(true); /* kick off type checking */ return Term(this, res); //////// @@ -4900,7 +4900,7 @@ Term Solver::mkInteger(int64_t val) const NodeManagerScope scope(getNodeManager()); CVC4_API_TRY_CATCH_BEGIN; //////// all checks before this line - Term integer = mkValHelper<CVC5::Rational>(CVC5::Rational(val)); + Term integer = mkValHelper<cvc5::Rational>(cvc5::Rational(val)); Assert(integer.getSort() == getIntegerSort()); return integer; //////// @@ -4928,7 +4928,7 @@ Term Solver::mkReal(int64_t val) const NodeManagerScope scope(getNodeManager()); CVC4_API_TRY_CATCH_BEGIN; //////// all checks before this line - Term rational = mkValHelper<CVC5::Rational>(CVC5::Rational(val)); + Term rational = mkValHelper<cvc5::Rational>(cvc5::Rational(val)); return ensureRealSort(rational); //////// CVC4_API_TRY_CATCH_END; @@ -4939,7 +4939,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<CVC5::Rational>(CVC5::Rational(num, den)); + Term rational = mkValHelper<cvc5::Rational>(cvc5::Rational(num, den)); return ensureRealSort(rational); //////// CVC4_API_TRY_CATCH_END; @@ -4951,7 +4951,7 @@ Term Solver::mkRegexpEmpty() const CVC4_API_TRY_CATCH_BEGIN; //////// all checks before this line Node res = - d_nodeMgr->mkNode(CVC5::kind::REGEXP_EMPTY, std::vector<CVC5::Node>()); + d_nodeMgr->mkNode(cvc5::kind::REGEXP_EMPTY, std::vector<cvc5::Node>()); (void)res.getType(true); /* kick off type checking */ return Term(this, res); //////// @@ -4964,7 +4964,7 @@ Term Solver::mkRegexpSigma() const CVC4_API_TRY_CATCH_BEGIN; //////// all checks before this line Node res = - d_nodeMgr->mkNode(CVC5::kind::REGEXP_SIGMA, std::vector<CVC5::Node>()); + d_nodeMgr->mkNode(cvc5::kind::REGEXP_SIGMA, std::vector<cvc5::Node>()); (void)res.getType(true); /* kick off type checking */ return Term(this, res); //////// @@ -4980,7 +4980,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<CVC5::EmptySet>(CVC5::EmptySet(*sort.d_type)); + return mkValHelper<cvc5::EmptySet>(cvc5::EmptySet(*sort.d_type)); //////// CVC4_API_TRY_CATCH_END; } @@ -4994,7 +4994,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<CVC5::EmptyBag>(CVC5::EmptyBag(*sort.d_type)); + return mkValHelper<cvc5::EmptyBag>(cvc5::EmptyBag(*sort.d_type)); //////// CVC4_API_TRY_CATCH_END; } @@ -5006,7 +5006,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, CVC5::kind::SEP_NIL); + getNodeManager()->mkNullaryOperator(*sort.d_type, cvc5::kind::SEP_NIL); (void)res.getType(true); /* kick off type checking */ return Term(this, res); //////// @@ -5018,7 +5018,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<CVC5::String>(CVC5::String(s, useEscSequences)); + return mkValHelper<cvc5::String>(cvc5::String(s, useEscSequences)); //////// CVC4_API_TRY_CATCH_END; } @@ -5028,7 +5028,7 @@ Term Solver::mkString(const unsigned char c) const NodeManagerScope scope(getNodeManager()); CVC4_API_TRY_CATCH_BEGIN; //////// all checks before this line - return mkValHelper<CVC5::String>(CVC5::String(std::string(1, c))); + return mkValHelper<cvc5::String>(cvc5::String(std::string(1, c))); //////// CVC4_API_TRY_CATCH_END; } @@ -5038,7 +5038,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<CVC5::String>(CVC5::String(s)); + return mkValHelper<cvc5::String>(cvc5::String(s)); //////// CVC4_API_TRY_CATCH_END; } @@ -5074,7 +5074,7 @@ Term Solver::mkUniverseSet(const Sort& sort) const //////// all checks before this line Node res = getNodeManager()->mkNullaryOperator(*sort.d_type, - CVC5::kind::UNIVERSE_SET); + cvc5::kind::UNIVERSE_SET); // TODO(#2771): Reenable? // (void)res->getType(true); /* kick off type checking */ return Term(this, res); @@ -5133,7 +5133,7 @@ Term Solver::mkConstArray(const Sort& sort, const Term& val) const n = n[0]; } Term res = - mkValHelper<CVC5::ArrayStoreAll>(CVC5::ArrayStoreAll(*sort.d_type, n)); + mkValHelper<cvc5::ArrayStoreAll>(cvc5::ArrayStoreAll(*sort.d_type, n)); return res; //////// CVC4_API_TRY_CATCH_END; @@ -5146,7 +5146,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<CVC5::FloatingPoint>( + return mkValHelper<cvc5::FloatingPoint>( FloatingPoint::makeInf(FloatingPointSize(exp, sig), false)); //////// CVC4_API_TRY_CATCH_END; @@ -5159,7 +5159,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<CVC5::FloatingPoint>( + return mkValHelper<cvc5::FloatingPoint>( FloatingPoint::makeInf(FloatingPointSize(exp, sig), true)); //////// CVC4_API_TRY_CATCH_END; @@ -5172,7 +5172,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<CVC5::FloatingPoint>( + return mkValHelper<cvc5::FloatingPoint>( FloatingPoint::makeNaN(FloatingPointSize(exp, sig))); //////// CVC4_API_TRY_CATCH_END; @@ -5185,7 +5185,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<CVC5::FloatingPoint>( + return mkValHelper<cvc5::FloatingPoint>( FloatingPoint::makeZero(FloatingPointSize(exp, sig), false)); //////// CVC4_API_TRY_CATCH_END; @@ -5198,7 +5198,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<CVC5::FloatingPoint>( + return mkValHelper<cvc5::FloatingPoint>( FloatingPoint::makeZero(FloatingPointSize(exp, sig), true)); //////// CVC4_API_TRY_CATCH_END; @@ -5211,7 +5211,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<CVC5::RoundingMode>(s_rmodes.at(rm)); + return mkValHelper<cvc5::RoundingMode>(s_rmodes.at(rm)); //////// CVC4_API_TRY_CATCH_END; } @@ -5222,8 +5222,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<CVC5::UninterpretedConstant>( - CVC5::UninterpretedConstant(*sort.d_type, index)); + return mkValHelper<cvc5::UninterpretedConstant>( + cvc5::UninterpretedConstant(*sort.d_type, index)); //////// CVC4_API_TRY_CATCH_END; } @@ -5234,11 +5234,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"; - CVC5::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(CVC5::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 //////// @@ -5252,7 +5252,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(CVC5::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 //////// @@ -5275,8 +5275,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<CVC5::FloatingPoint>( - CVC5::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; } @@ -5465,7 +5465,7 @@ Term Solver::mkTerm(const Op& op) const return mkTermFromKind(op.d_kind); } - const CVC5::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 */ @@ -5538,7 +5538,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<CVC5::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); @@ -5584,7 +5584,7 @@ Op Solver::mkOp(Kind kind, const std::string& arg) const { res = Op(this, kind, - *mkValHelper<CVC5::RecordUpdate>(CVC5::RecordUpdate(arg)).d_node); + *mkValHelper<cvc5::RecordUpdate>(cvc5::RecordUpdate(arg)).d_node); } else { @@ -5595,7 +5595,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<CVC5::Divisible>(CVC5::Divisible(CVC5::Integer(arg))) + *mkValHelper<cvc5::Divisible>(cvc5::Divisible(cvc5::Integer(arg))) .d_node); } return res; @@ -5614,76 +5614,76 @@ Op Solver::mkOp(Kind kind, uint32_t arg) const case DIVISIBLE: res = Op(this, kind, - *mkValHelper<CVC5::Divisible>(CVC5::Divisible(arg)).d_node); + *mkValHelper<cvc5::Divisible>(cvc5::Divisible(arg)).d_node); break; case BITVECTOR_REPEAT: res = Op(this, kind, - *mkValHelper<CVC5::BitVectorRepeat>(CVC5::BitVectorRepeat(arg)) + *mkValHelper<cvc5::BitVectorRepeat>(cvc5::BitVectorRepeat(arg)) .d_node); break; case BITVECTOR_ZERO_EXTEND: res = Op(this, kind, - *mkValHelper<CVC5::BitVectorZeroExtend>( - CVC5::BitVectorZeroExtend(arg)) + *mkValHelper<cvc5::BitVectorZeroExtend>( + cvc5::BitVectorZeroExtend(arg)) .d_node); break; case BITVECTOR_SIGN_EXTEND: res = Op(this, kind, - *mkValHelper<CVC5::BitVectorSignExtend>( - CVC5::BitVectorSignExtend(arg)) + *mkValHelper<cvc5::BitVectorSignExtend>( + cvc5::BitVectorSignExtend(arg)) .d_node); break; case BITVECTOR_ROTATE_LEFT: res = Op(this, kind, - *mkValHelper<CVC5::BitVectorRotateLeft>( - CVC5::BitVectorRotateLeft(arg)) + *mkValHelper<cvc5::BitVectorRotateLeft>( + cvc5::BitVectorRotateLeft(arg)) .d_node); break; case BITVECTOR_ROTATE_RIGHT: res = Op(this, kind, - *mkValHelper<CVC5::BitVectorRotateRight>( - CVC5::BitVectorRotateRight(arg)) + *mkValHelper<cvc5::BitVectorRotateRight>( + cvc5::BitVectorRotateRight(arg)) .d_node); break; case INT_TO_BITVECTOR: res = Op( this, kind, - *mkValHelper<CVC5::IntToBitVector>(CVC5::IntToBitVector(arg)).d_node); + *mkValHelper<cvc5::IntToBitVector>(cvc5::IntToBitVector(arg)).d_node); break; case IAND: res = - Op(this, kind, *mkValHelper<CVC5::IntAnd>(CVC5::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<CVC5::FloatingPointToUBV>(CVC5::FloatingPointToUBV(arg)) + *mkValHelper<cvc5::FloatingPointToUBV>(cvc5::FloatingPointToUBV(arg)) .d_node); break; case FLOATINGPOINT_TO_SBV: res = Op( this, kind, - *mkValHelper<CVC5::FloatingPointToSBV>(CVC5::FloatingPointToSBV(arg)) + *mkValHelper<cvc5::FloatingPointToSBV>(cvc5::FloatingPointToSBV(arg)) .d_node); break; case TUPLE_UPDATE: res = Op(this, kind, - *mkValHelper<CVC5::TupleUpdate>(CVC5::TupleUpdate(arg)).d_node); + *mkValHelper<cvc5::TupleUpdate>(cvc5::TupleUpdate(arg)).d_node); break; case REGEXP_REPEAT: res = Op(this, kind, - *mkValHelper<CVC5::RegExpRepeat>(CVC5::RegExpRepeat(arg)).d_node); + *mkValHelper<cvc5::RegExpRepeat>(cvc5::RegExpRepeat(arg)).d_node); break; default: CVC4_API_KIND_CHECK_EXPECTED(false, kind) @@ -5707,57 +5707,57 @@ Op Solver::mkOp(Kind kind, uint32_t arg1, uint32_t arg2) const case BITVECTOR_EXTRACT: res = Op(this, kind, - *mkValHelper<CVC5::BitVectorExtract>( - CVC5::BitVectorExtract(arg1, arg2)) + *mkValHelper<cvc5::BitVectorExtract>( + cvc5::BitVectorExtract(arg1, arg2)) .d_node); break; case FLOATINGPOINT_TO_FP_IEEE_BITVECTOR: res = Op(this, kind, - *mkValHelper<CVC5::FloatingPointToFPIEEEBitVector>( - CVC5::FloatingPointToFPIEEEBitVector(arg1, arg2)) + *mkValHelper<cvc5::FloatingPointToFPIEEEBitVector>( + cvc5::FloatingPointToFPIEEEBitVector(arg1, arg2)) .d_node); break; case FLOATINGPOINT_TO_FP_FLOATINGPOINT: res = Op(this, kind, - *mkValHelper<CVC5::FloatingPointToFPFloatingPoint>( - CVC5::FloatingPointToFPFloatingPoint(arg1, arg2)) + *mkValHelper<cvc5::FloatingPointToFPFloatingPoint>( + cvc5::FloatingPointToFPFloatingPoint(arg1, arg2)) .d_node); break; case FLOATINGPOINT_TO_FP_REAL: res = Op(this, kind, - *mkValHelper<CVC5::FloatingPointToFPReal>( - CVC5::FloatingPointToFPReal(arg1, arg2)) + *mkValHelper<cvc5::FloatingPointToFPReal>( + cvc5::FloatingPointToFPReal(arg1, arg2)) .d_node); break; case FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR: res = Op(this, kind, - *mkValHelper<CVC5::FloatingPointToFPSignedBitVector>( - CVC5::FloatingPointToFPSignedBitVector(arg1, arg2)) + *mkValHelper<cvc5::FloatingPointToFPSignedBitVector>( + cvc5::FloatingPointToFPSignedBitVector(arg1, arg2)) .d_node); break; case FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR: res = Op(this, kind, - *mkValHelper<CVC5::FloatingPointToFPUnsignedBitVector>( - CVC5::FloatingPointToFPUnsignedBitVector(arg1, arg2)) + *mkValHelper<cvc5::FloatingPointToFPUnsignedBitVector>( + cvc5::FloatingPointToFPUnsignedBitVector(arg1, arg2)) .d_node); break; case FLOATINGPOINT_TO_FP_GENERIC: res = Op(this, kind, - *mkValHelper<CVC5::FloatingPointToFPGeneric>( - CVC5::FloatingPointToFPGeneric(arg1, arg2)) + *mkValHelper<cvc5::FloatingPointToFPGeneric>( + cvc5::FloatingPointToFPGeneric(arg1, arg2)) .d_node); break; case REGEXP_LOOP: res = Op( this, kind, - *mkValHelper<CVC5::RegExpLoop>(CVC5::RegExpLoop(arg1, arg2)).d_node); + *mkValHelper<cvc5::RegExpLoop>(cvc5::RegExpLoop(arg1, arg2)).d_node); break; default: CVC4_API_KIND_CHECK_EXPECTED(false, kind) @@ -5782,7 +5782,7 @@ Op Solver::mkOp(Kind kind, const std::vector<uint32_t>& args) const { res = Op(this, kind, - *mkValHelper<CVC5::TupleProjectOp>(CVC5::TupleProjectOp(args)) + *mkValHelper<cvc5::TupleProjectOp>(cvc5::TupleProjectOp(args)) .d_node); } break; @@ -5823,7 +5823,7 @@ Result Solver::checkEntailed(const Term& term) const "(try --incremental)"; CVC4_API_SOLVER_CHECK_TERM(term); //////// all checks before this line - CVC5::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; @@ -5873,7 +5873,7 @@ Result Solver::checkSat(void) const << "Cannot make multiple queries unless incremental solving is enabled " "(try --incremental)"; //////// all checks before this line - CVC5::Result r = d_smtEngine->checkSat(); + cvc5::Result r = d_smtEngine->checkSat(); return Result(r); //////// CVC4_API_TRY_CATCH_END; @@ -5892,7 +5892,7 @@ Result Solver::checkSatAssuming(const Term& assumption) const "(try --incremental)"; CVC4_API_SOLVER_CHECK_TERM_WITH_SORT(assumption, getBooleanSort()); //////// all checks before this line - CVC5::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; @@ -5916,7 +5916,7 @@ Result Solver::checkSatAssuming(const std::vector<Term>& assumptions) const CVC4_API_SOLVER_CHECK_TERM(term); } std::vector<Node> eassumptions = Term::termVectorToNodes(assumptions); - CVC5::Result r = d_smtEngine->checkSat(eassumptions); + cvc5::Result r = d_smtEngine->checkSat(eassumptions); return Result(r); //////// CVC4_API_TRY_CATCH_END; @@ -6645,7 +6645,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"; - CVC5::LogicInfo logic_info(logic); + cvc5::LogicInfo logic_info(logic); //////// all checks before this line d_smtEngine->setLogic(logic_info); //////// @@ -6828,12 +6828,12 @@ Term Solver::getSynthSolution(Term term) const CVC4_API_TRY_CATCH_BEGIN; CVC4_API_SOLVER_CHECK_TERM(term); - std::map<CVC5::Node, CVC5::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<CVC5::Node, CVC5::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 @@ -6849,7 +6849,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<CVC5::Node, CVC5::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"; @@ -6860,7 +6860,7 @@ std::vector<Term> Solver::getSynthSolutions( for (size_t i = 0, n = terms.size(); i < n; ++i) { - std::map<CVC5::Node, CVC5::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()) @@ -6897,4 +6897,4 @@ Options& Solver::getOptions(void) { return d_smtEngine->getOptions(); } } // namespace api -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/api/cvc4cpp.h b/src/api/cvc4cpp.h index 99c2d1182..c446fcaf5 100644 --- a/src/api/cvc4cpp.h +++ b/src/api/cvc4cpp.h @@ -30,7 +30,7 @@ #include <unordered_set> #include <vector> -namespace CVC5 { +namespace cvc5 { template <bool ref_count> class NodeTemplate; @@ -202,14 +202,14 @@ class CVC4_EXPORT Result * @param r the internal result that is to be wrapped by this result * @return the Result */ - Result(const CVC5::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 CVC5::Result is + * Note: This is a shared_ptr rather than a unique_ptr since cvc5::Result is * not ref counted. */ - std::shared_ptr<CVC5::Result> d_result; + std::shared_ptr<cvc5::Result> d_result; }; /** @@ -240,16 +240,16 @@ class Datatype; */ class CVC4_EXPORT Sort { - 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 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; @@ -701,7 +701,7 @@ class CVC4_EXPORT Sort private: /** @return the internal wrapped TypeNode of this sort. */ - const CVC5::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); @@ -718,7 +718,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 CVC5::TypeNode& t); + Sort(const Solver* slv, const cvc5::TypeNode& t); /** * Helper for isNull checks. This prevents calling an API function with @@ -734,10 +734,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 (CVC5::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<CVC5::TypeNode> d_type; + std::shared_ptr<cvc5::TypeNode> d_type; }; /** @@ -848,7 +848,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 CVC5::Node& n); + Op(const Solver* slv, const Kind k, const cvc5::Node& n); /** * Helper for isNull checks. This prevents calling an API function with @@ -875,10 +875,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 (CVC5::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<CVC5::Node> d_node; + std::shared_ptr<cvc5::Node> d_node; }; /* -------------------------------------------------------------------------- */ @@ -890,25 +890,25 @@ class CVC4_EXPORT Op */ class CVC4_EXPORT Term { - 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 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; @@ -1117,7 +1117,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<CVC5::Node>& e, + const std::shared_ptr<cvc5::Node>& e, uint32_t p); /** @@ -1170,7 +1170,7 @@ class CVC4_EXPORT Term */ const Solver* d_solver; /** The original node to be iterated over. */ - std::shared_ptr<CVC5::Node> d_origNode; + std::shared_ptr<cvc5::Node> d_origNode; /** Keeps track of the iteration position. */ uint32_t d_pos; }; @@ -1260,10 +1260,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 CVC5::Node& n); + Term(const Solver* slv, const cvc5::Node& n); /** @return the internal wrapped Node of this term. */ - const CVC5::Node& getNode(void) const; + const cvc5::Node& getNode(void) const; /** * Helper for isNull checks. This prevents calling an API function with @@ -1286,10 +1286,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 (CVC5::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<CVC5::Node> d_node; + std::shared_ptr<cvc5::Node> d_node; }; /** @@ -1446,9 +1446,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 - * CVC5::DTypeConstructor is not ref counted. + * cvc5::DTypeConstructor is not ref counted. */ - std::shared_ptr<CVC5::DTypeConstructor> d_ctor; + std::shared_ptr<cvc5::DTypeConstructor> d_ctor; }; class Solver; @@ -1535,7 +1535,7 @@ class CVC4_EXPORT DatatypeDecl bool isCoDatatype = false); /** @return the internal wrapped Dtype of this datatype declaration. */ - CVC5::DType& getDatatype(void) const; + cvc5::DType& getDatatype(void) const; /** * Helper for isNull checks. This prevents calling an API function with @@ -1551,10 +1551,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 CVC5::DType is + * Note: This is a shared_ptr rather than a unique_ptr since cvc5::DType is * not ref counted. */ - std::shared_ptr<CVC5::DType> d_dtype; + std::shared_ptr<cvc5::DType> d_dtype; }; /** @@ -1605,7 +1605,7 @@ class CVC4_EXPORT DatatypeSelector * @param stor the internal datatype selector to be wrapped * @return the DatatypeSelector */ - DatatypeSelector(const Solver* slv, const CVC5::DTypeSelector& stor); + DatatypeSelector(const Solver* slv, const cvc5::DTypeSelector& stor); /** * Helper for isNull checks. This prevents calling an API function with @@ -1620,10 +1620,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 CVC5::DType is + * Note: This is a shared_ptr rather than a unique_ptr since cvc5::DType is * not ref counted. */ - std::shared_ptr<CVC5::DTypeSelector> d_stor; + std::shared_ptr<cvc5::DTypeSelector> d_stor; }; /** @@ -1786,7 +1786,7 @@ class CVC4_EXPORT DatatypeConstructor * @param true if this is a begin() iterator */ const_iterator(const Solver* slv, - const CVC5::DTypeConstructor& ctor, + const cvc5::DTypeConstructor& ctor, bool begin); /** @@ -1824,7 +1824,7 @@ class CVC4_EXPORT DatatypeConstructor * @param ctor the internal datatype constructor to be wrapped * @return the DatatypeConstructor */ - DatatypeConstructor(const Solver* slv, const CVC5::DTypeConstructor& ctor); + DatatypeConstructor(const Solver* slv, const cvc5::DTypeConstructor& ctor); /** * Return selector for name. @@ -1846,10 +1846,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 CVC5::DType is + * Note: This is a shared_ptr rather than a unique_ptr since cvc5::DType is * not ref counted. */ - std::shared_ptr<CVC5::DTypeConstructor> d_ctor; + std::shared_ptr<cvc5::DTypeConstructor> d_ctor; }; /* @@ -2008,7 +2008,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 CVC5::DType& dtype, bool begin); + const_iterator(const Solver* slv, const cvc5::DType& dtype, bool begin); /** * The associated solver object. @@ -2045,7 +2045,7 @@ class CVC4_EXPORT Datatype * @param dtype the internal datatype to be wrapped * @return the Datatype */ - Datatype(const Solver* slv, const CVC5::DType& dtype); + Datatype(const Solver* slv, const cvc5::DType& dtype); /** * Return constructor for name. @@ -2067,10 +2067,10 @@ class CVC4_EXPORT Datatype /** * The internal datatype wrapped by this datatype. - * Note: This is a shared_ptr rather than a unique_ptr since CVC5::DType is + * Note: This is a shared_ptr rather than a unique_ptr since cvc5::DType is * not ref counted. */ - std::shared_ptr<CVC5::DType> d_dtype; + std::shared_ptr<cvc5::DType> d_dtype; }; /** @@ -2136,9 +2136,9 @@ std::ostream& operator<<(std::ostream& out, */ class CVC4_EXPORT Grammar { - friend class CVC5::GetAbductCommand; - friend class CVC5::GetInterpolCommand; - friend class CVC5::SynthFunCommand; + friend class cvc5::GetAbductCommand; + friend class cvc5::GetInterpolCommand; + friend class cvc5::SynthFunCommand; friend class Solver; public: @@ -2323,7 +2323,7 @@ class CVC4_EXPORT Solver friend class DatatypeSelector; friend class Grammar; friend class Op; - friend class CVC5::ResetCommand; + friend class cvc5::ResetCommand; friend class Sort; friend class Term; @@ -3708,5 +3708,5 @@ class CVC4_EXPORT Solver }; } // namespace api -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/api/cvc4cppkind.h b/src/api/cvc4cppkind.h index ef2f6af74..eec90147e 100644 --- a/src/api/cvc4cppkind.h +++ b/src/api/cvc4cppkind.h @@ -21,7 +21,7 @@ #include <ostream> -namespace CVC5 { +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 - * CVC5::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 CVC5 +} // namespace cvc5 #endif diff --git a/src/api/python/cvc4.pxd b/src/api/python/cvc4.pxd index 9d69e2a15..947132a89 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 "CVC5::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 "CVC5::api": size_t operator()(const Term & t) except + -cdef extern from "api/cvc4cpp.h" namespace "CVC5::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 46bf2b45e..0c800d787 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 "CVC5::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 "CVC5::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 4aa6bfce0..3ecdb0287 100644 --- a/src/base/check.cpp +++ b/src/base/check.cpp @@ -19,7 +19,7 @@ #include <cstdlib> #include <iostream> -namespace CVC5 { +namespace cvc5 { FatalStream::FatalStream(const char* function, const char* file, int line) { @@ -209,4 +209,4 @@ AssertArgumentException::AssertArgumentException(const char* condStr, line); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/base/check.h b/src/base/check.h index 1e46ea85c..719c962bf 100644 --- a/src/base/check.h +++ b/src/base/check.h @@ -75,7 +75,7 @@ #define CVC4_FALLTHROUGH #endif -namespace CVC5 { +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 ::CVC5::IllegalArgumentException( \ + throw ::cvc5::IllegalArgumentException( \ "", \ #arg, \ __PRETTY_FUNCTION__, \ - ::CVC5::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 ::CVC5::IllegalArgumentException( \ + throw ::cvc5::IllegalArgumentException( \ #cond, \ #arg, \ __PRETTY_FUNCTION__, \ - ::CVC5::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 ::CVC5::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 CVC5 +} // namespace cvc5 #endif /* CVC4__CHECK_H */ diff --git a/src/base/configuration.cpp b/src/base/configuration.cpp index 1b8be7bf9..5dd9c2831 100644 --- a/src/base/configuration.cpp +++ b/src/base/configuration.cpp @@ -36,7 +36,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { string Configuration::getName() { return CVC4_PACKAGE_NAME; @@ -375,7 +375,7 @@ std::string Configuration::getGitId() { stringstream ss; ss << "git " << branchName << " " << string(getGitCommit()).substr(0, 8) - << (::CVC5::Configuration::hasGitModifications() ? " (with modifications)" + << (::cvc5::Configuration::hasGitModifications() ? " (with modifications)" : ""); return ss.str(); } @@ -399,4 +399,4 @@ std::string Configuration::getCompiledDateTime() { return __DATE__ " " __TIME__; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/base/configuration.h b/src/base/configuration.h index c6cf3b229..4d7a73d4c 100644 --- a/src/base/configuration.h +++ b/src/base/configuration.h @@ -25,7 +25,7 @@ #include "cvc4_export.h" -namespace CVC5 { +namespace cvc5 { /** * Represents the (static) configuration of CVC4. @@ -135,6 +135,6 @@ public: }; /* class Configuration */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONFIGURATION_H */ diff --git a/src/base/configuration_private.h b/src/base/configuration_private.h index 7de4f0e97..1ec28dc4b 100644 --- a/src/base/configuration_private.h +++ b/src/base/configuration_private.h @@ -22,7 +22,7 @@ #include "base/configuration.h" -namespace CVC5 { +namespace cvc5 { #ifdef CVC4_DEBUG # define IS_DEBUG_BUILD true @@ -182,6 +182,6 @@ namespace CVC5 { #endif /* __has_feature(thread_sanitizer) */ #endif /* defined(__has_feature) */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONFIGURATION_PRIVATE_H */ diff --git a/src/base/exception.cpp b/src/base/exception.cpp index 631f1cc35..3c5c21b46 100644 --- a/src/base/exception.cpp +++ b/src/base/exception.cpp @@ -27,7 +27,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { std::string Exception::toString() const { @@ -187,4 +187,4 @@ void IllegalArgumentException::construct(const char* header, const char* extra, delete [] buf; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/base/exception.h b/src/base/exception.h index a0ad0819c..99404b45e 100644 --- a/src/base/exception.h +++ b/src/base/exception.h @@ -25,7 +25,7 @@ #include "cvc4_export.h" -namespace CVC5 { +namespace cvc5 { class Exception : public std::exception { @@ -122,14 +122,14 @@ 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 ::CVC5::IllegalArgumentException("", "", tail); + 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 ::CVC5::IllegalArgumentException("", "", ""); + throw ::cvc5::IllegalArgumentException("", "", ""); } \ } @@ -159,6 +159,6 @@ private: static thread_local LastExceptionBuffer* s_currentBuffer; }; /* class LastExceptionBuffer */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXCEPTION_H */ diff --git a/src/base/git_versioninfo.cpp.in b/src/base/git_versioninfo.cpp.in index 333564b97..1f8c82ee8 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 ::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@; +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 b7d92e6a3..6faf7635b 100644 --- a/src/base/listener.cpp +++ b/src/base/listener.cpp @@ -16,9 +16,9 @@ #include "base/listener.h" -namespace CVC5 { +namespace cvc5 { Listener::Listener(){} Listener::~Listener(){} -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/base/listener.h b/src/base/listener.h index 0bb81e63a..58577b814 100644 --- a/src/base/listener.h +++ b/src/base/listener.h @@ -20,7 +20,7 @@ #ifndef CVC4__LISTENER_H #define CVC4__LISTENER_H -namespace CVC5 { +namespace cvc5 { /** * Listener interface class. @@ -37,6 +37,6 @@ class Listener virtual void notify() = 0; }; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__LISTENER_H */ diff --git a/src/base/map_util.h b/src/base/map_util.h index f428a9943..e13120f52 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 - ** - CVC5::context::CDHashmap - ** - CVC5::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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__BASE__MAP_UTIL_H */ diff --git a/src/base/modal_exception.h b/src/base/modal_exception.h index eab6c66b1..d00b0a877 100644 --- a/src/base/modal_exception.h +++ b/src/base/modal_exception.h @@ -24,9 +24,9 @@ #include "base/exception.h" -namespace CVC5 { +namespace cvc5 { -class ModalException : public CVC5::Exception +class ModalException : public cvc5::Exception { public: ModalException() : @@ -50,7 +50,7 @@ class ModalException : public CVC5::Exception * TODO(#1108): This exception should not be needed anymore in future versions * of the public API. */ -class RecoverableModalException : public CVC5::ModalException +class RecoverableModalException : public cvc5::ModalException { public: RecoverableModalException(const std::string& msg) : ModalException(msg) {} @@ -58,6 +58,6 @@ class RecoverableModalException : public CVC5::ModalException RecoverableModalException(const char* msg) : ModalException(msg) {} }; /* class RecoverableModalException */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__MODAL_EXCEPTION_H */ diff --git a/src/base/output.cpp b/src/base/output.cpp index 7876f0fbe..f24e0f7fb 100644 --- a/src/base/output.cpp +++ b/src/base/output.cpp @@ -20,7 +20,7 @@ using namespace std; -namespace CVC5 { +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); -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/base/output.h b/src/base/output.h index b1f15d98b..cb08736bb 100644 --- a/src/base/output.h +++ b/src/base/output.h @@ -28,7 +28,7 @@ #include "cvc4_export.h" -namespace CVC5 { +namespace cvc5 { template <class T, class U> std::ostream& operator<<(std::ostream& out, @@ -413,57 +413,57 @@ extern DumpOutC DumpOutChannel CVC4_EXPORT; #ifdef CVC4_MUZZLE #define Debug \ - ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::DebugChannel + ::cvc5::__cvc4_true() ? ::cvc5::nullCvc4Stream : ::cvc5::DebugChannel #define Warning \ - ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::WarningChannel + ::cvc5::__cvc4_true() ? ::cvc5::nullCvc4Stream : ::cvc5::WarningChannel #define WarningOnce \ - ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::WarningChannel + ::cvc5::__cvc4_true() ? ::cvc5::nullCvc4Stream : ::cvc5::WarningChannel #define CVC4Message \ - ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::MessageChannel + ::cvc5::__cvc4_true() ? ::cvc5::nullCvc4Stream : ::cvc5::MessageChannel #define Notice \ - ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::NoticeChannel + ::cvc5::__cvc4_true() ? ::cvc5::nullCvc4Stream : ::cvc5::NoticeChannel #define Chat \ - ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::ChatChannel + ::cvc5::__cvc4_true() ? ::cvc5::nullCvc4Stream : ::cvc5::ChatChannel #define Trace \ - ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::TraceChannel + ::cvc5::__cvc4_true() ? ::cvc5::nullCvc4Stream : ::cvc5::TraceChannel #define DumpOut \ - ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::DumpOutChannel + ::cvc5::__cvc4_true() ? ::cvc5::nullCvc4Stream : ::cvc5::DumpOutChannel #else /* CVC4_MUZZLE */ # if defined(CVC4_DEBUG) && defined(CVC4_TRACING) -#define Debug ::CVC5::DebugChannel +#define Debug ::cvc5::DebugChannel # else /* CVC4_DEBUG && CVC4_TRACING */ #define Debug \ - ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::DebugChannel + ::cvc5::__cvc4_true() ? ::cvc5::nullCvc4Stream : ::cvc5::DebugChannel # endif /* CVC4_DEBUG && CVC4_TRACING */ #define Warning \ - (!::CVC5::WarningChannel.isOn()) ? ::CVC5::nullCvc4Stream \ - : ::CVC5::WarningChannel + (!::cvc5::WarningChannel.isOn()) ? ::cvc5::nullCvc4Stream \ + : ::cvc5::WarningChannel #define WarningOnce \ - (!::CVC5::WarningChannel.isOn() \ - || !::CVC5::WarningChannel.warnOnce(__FILE__, __LINE__)) \ - ? ::CVC5::nullCvc4Stream \ - : ::CVC5::WarningChannel + (!::cvc5::WarningChannel.isOn() \ + || !::cvc5::WarningChannel.warnOnce(__FILE__, __LINE__)) \ + ? ::cvc5::nullCvc4Stream \ + : ::cvc5::WarningChannel #define CVC4Message \ - (!::CVC5::MessageChannel.isOn()) ? ::CVC5::nullCvc4Stream \ - : ::CVC5::MessageChannel + (!::cvc5::MessageChannel.isOn()) ? ::cvc5::nullCvc4Stream \ + : ::cvc5::MessageChannel #define Notice \ - (!::CVC5::NoticeChannel.isOn()) ? ::CVC5::nullCvc4Stream \ - : ::CVC5::NoticeChannel + (!::cvc5::NoticeChannel.isOn()) ? ::cvc5::nullCvc4Stream \ + : ::cvc5::NoticeChannel #define Chat \ - (!::CVC5::ChatChannel.isOn()) ? ::CVC5::nullCvc4Stream : ::CVC5::ChatChannel + (!::cvc5::ChatChannel.isOn()) ? ::cvc5::nullCvc4Stream : ::cvc5::ChatChannel # ifdef CVC4_TRACING -#define Trace ::CVC5::TraceChannel +#define Trace ::cvc5::TraceChannel # else /* CVC4_TRACING */ #define Trace \ - ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::TraceChannel + ::cvc5::__cvc4_true() ? ::cvc5::nullCvc4Stream : ::cvc5::TraceChannel # endif /* CVC4_TRACING */ # ifdef CVC4_DUMPING -#define DumpOut ::CVC5::DumpOutChannel +#define DumpOut ::cvc5::DumpOutChannel # else /* CVC4_DUMPING */ #define DumpOut \ - ::CVC5::__cvc4_true() ? ::CVC5::nullCvc4Stream : ::CVC5::DumpOutChannel + ::cvc5::__cvc4_true() ? ::cvc5::nullCvc4Stream : ::cvc5::DumpOutChannel # endif /* CVC4_DUMPING */ #endif /* CVC4_MUZZLE */ @@ -579,6 +579,6 @@ inline IndentedScope::IndentedScope(CVC4ostream out) {} inline IndentedScope::~IndentedScope() {} #endif /* CVC4_DEBUG && CVC4_TRACING */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__OUTPUT_H */ diff --git a/src/context/backtrackable.h b/src/context/backtrackable.h index 2d5416eab..2c4fdff41 100644 --- a/src/context/backtrackable.h +++ b/src/context/backtrackable.h @@ -23,7 +23,7 @@ #include <vector> #include "context/cdo.h" -namespace CVC5 { +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); } -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__UTIL__BACKTRACKABLE_H */ diff --git a/src/context/cddense_set.h b/src/context/cddense_set.h index 765e0f75d..095d14156 100644 --- a/src/context/cddense_set.h +++ b/src/context/cddense_set.h @@ -29,7 +29,7 @@ #include "util/index.h" -namespace CVC5 { +namespace cvc5 { namespace context { template <class CleanUp = DefaultCleanUp<Index> > @@ -97,4 +97,4 @@ public: };/* class CDDenseSet<> */ } // namespace context -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/context/cdhashmap.h b/src/context/cdhashmap.h index 165080bd1..a9f81d529 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 CVC5 { +namespace cvc5 { namespace context { // Auxiliary class: almost the same as CDO (see cdo.h) @@ -453,6 +453,6 @@ public: };/* class CDHashMap<> */ } // namespace context -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONTEXT__CDHASHMAP_H */ diff --git a/src/context/cdhashmap_forward.h b/src/context/cdhashmap_forward.h index b34981c73..b6907322c 100644 --- a/src/context/cdhashmap_forward.h +++ b/src/context/cdhashmap_forward.h @@ -30,12 +30,12 @@ /// \cond internals -namespace CVC5 { +namespace cvc5 { namespace context { template <class Key, class Data, class HashFcn = std::hash<Key> > class CDHashMap; } // namespace context -} // namespace CVC5 +} // namespace cvc5 /// \endcond diff --git a/src/context/cdhashset.h b/src/context/cdhashset.h index 418bc8bf0..1a31e6022 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 CVC5 { +namespace cvc5 { namespace context { template <class V, class HashFcn> @@ -156,6 +156,6 @@ public: };/* class CDHashSet */ } // namespace context -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONTEXT__CDHASHSET_H */ diff --git a/src/context/cdhashset_forward.h b/src/context/cdhashset_forward.h index 81154db5d..387c10ada 100644 --- a/src/context/cdhashset_forward.h +++ b/src/context/cdhashset_forward.h @@ -28,11 +28,11 @@ #include <functional> -namespace CVC5 { +namespace cvc5 { namespace context { template <class V, class HashFcn = std::hash<V> > class CDHashSet; } // namespace context -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONTEXT__CDSET_FORWARD_H */ diff --git a/src/context/cdinsert_hashmap.h b/src/context/cdinsert_hashmap.h index 6bd15c645..903acdaf0 100644 --- a/src/context/cdinsert_hashmap.h +++ b/src/context/cdinsert_hashmap.h @@ -45,7 +45,7 @@ #pragma once -namespace CVC5 { +namespace cvc5 { namespace context { @@ -407,4 +407,4 @@ class CDInsertHashMap<TNode, Data, HashFcn> : public ContextObj { }; } // namespace context -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/context/cdinsert_hashmap_forward.h b/src/context/cdinsert_hashmap_forward.h index 9729ea2f4..d636be1c1 100644 --- a/src/context/cdinsert_hashmap_forward.h +++ b/src/context/cdinsert_hashmap_forward.h @@ -28,11 +28,11 @@ #include <functional> -namespace CVC5 { +namespace cvc5 { namespace context { template <class Key, class Data, class HashFcn = std::hash<Key> > class CDInsertHashMap; } // namespace context -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONTEXT__CDINSERT_HASHMAP_FORWARD_H */ diff --git a/src/context/cdlist.h b/src/context/cdlist.h index 7174152cb..20b0f1e3d 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 CVC5 { +namespace cvc5 { namespace context { /** @@ -435,6 +435,6 @@ class CDList<T, CleanUp, ContextMemoryAllocator<T> > : public ContextObj { }; } // namespace context -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONTEXT__CDLIST_H */ diff --git a/src/context/cdlist_forward.h b/src/context/cdlist_forward.h index bd3a911af..5758b71ba 100644 --- a/src/context/cdlist_forward.h +++ b/src/context/cdlist_forward.h @@ -36,7 +36,7 @@ /// \cond internals -namespace CVC5 { +namespace cvc5 { namespace context { template <class T> @@ -51,6 +51,6 @@ class CDList; /// \endcond } // namespace context -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONTEXT__CDLIST_FORWARD_H */ diff --git a/src/context/cdmaybe.h b/src/context/cdmaybe.h index 1455ca5f0..4913c2dd5 100644 --- a/src/context/cdmaybe.h +++ b/src/context/cdmaybe.h @@ -24,7 +24,7 @@ #include "context/cdo.h" #include "context/context.h" -namespace CVC5 { +namespace cvc5 { namespace context { class CDRaised { @@ -74,4 +74,4 @@ public: };/* class CDMaybe<T> */ } // namespace context -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/context/cdo.h b/src/context/cdo.h index 79e73d38f..393b584f1 100644 --- a/src/context/cdo.h +++ b/src/context/cdo.h @@ -21,7 +21,7 @@ #include "context/context.h" -namespace CVC5 { +namespace cvc5 { namespace context { /** @@ -176,6 +176,6 @@ public: };/* class CDO */ } // namespace context -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONTEXT__CDO_H */ diff --git a/src/context/cdqueue.h b/src/context/cdqueue.h index 20d078184..12ca02754 100644 --- a/src/context/cdqueue.h +++ b/src/context/cdqueue.h @@ -28,7 +28,7 @@ #include "context/context.h" #include "context/cdlist.h" -namespace CVC5 { +namespace cvc5 { namespace context { template <class T, class CleanUp = DefaultCleanUp<T>, class Allocator = std::allocator<T> > @@ -163,6 +163,6 @@ public: };/* class CDQueue<> */ } // namespace context -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONTEXT__CDQUEUE_H */ diff --git a/src/context/cdtrail_queue.h b/src/context/cdtrail_queue.h index d9bf6d572..abdd83f99 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 CVC5 { +namespace cvc5 { namespace context { class Context; @@ -90,6 +90,6 @@ public: };/* class CDTrailQueue<> */ } // namespace context -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONTEXT__CDTRAIL_QUEUE_H */ diff --git a/src/context/context.cpp b/src/context/context.cpp index 88c783303..6dfab3de2 100644 --- a/src/context/context.cpp +++ b/src/context/context.cpp @@ -21,7 +21,7 @@ #include "base/check.h" #include "context/context.h" -namespace CVC5 { +namespace cvc5 { namespace context { @@ -388,4 +388,4 @@ void Scope::enqueueToGarbageCollect(ContextObj* obj) { } } // namespace context -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/context/context.h b/src/context/context.h index 7cf72e4d2..438d9c28a 100644 --- a/src/context/context.h +++ b/src/context/context.h @@ -29,7 +29,7 @@ #include "base/output.h" #include "context/context_mm.h" -namespace CVC5 { +namespace cvc5 { namespace context { class Context; @@ -740,6 +740,6 @@ inline void Scope::addToChain(ContextObj* pContextObj) } } // namespace context -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONTEXT__CONTEXT_H */ diff --git a/src/context/context_mm.cpp b/src/context/context_mm.cpp index 2a69bc26f..2e5f0aba4 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 CVC5 { +namespace cvc5 { namespace context { #ifndef CVC4_DEBUG_CONTEXT_MEMORY_MANAGER @@ -178,4 +178,4 @@ unsigned ContextMemoryManager::getMaxAllocationSize() #endif /* CVC4_DEBUG_CONTEXT_MEMORY_MANAGER */ } // namespace context -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/context/context_mm.h b/src/context/context_mm.h index 72c2bcd3a..cf597908a 100644 --- a/src/context/context_mm.h +++ b/src/context/context_mm.h @@ -25,7 +25,7 @@ #endif #include <vector> -namespace CVC5 { +namespace cvc5 { namespace context { #ifndef CVC4_DEBUG_CONTEXT_MEMORY_MANAGER @@ -262,6 +262,6 @@ inline bool operator!=(const ContextMemoryAllocator<T>& a1, } } // namespace context -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CONTEXT__CONTEXT_MM_H */ diff --git a/src/decision/decision_attributes.h b/src/decision/decision_attributes.h index be5987e6d..c34abd179 100644 --- a/src/decision/decision_attributes.h +++ b/src/decision/decision_attributes.h @@ -22,7 +22,7 @@ #include "options/decision_weight.h" #include "expr/attribute.h" -namespace CVC5 { +namespace cvc5 { namespace decision { namespace attr { struct DecisionWeightTag {}; @@ -31,6 +31,6 @@ namespace attr { typedef expr::Attribute<attr::DecisionWeightTag, DecisionWeight> DecisionWeightAttr; } // namespace decision -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__DECISION__DECISION_ATTRIBUTES_H */ diff --git a/src/decision/decision_engine.cpp b/src/decision/decision_engine.cpp index 3196336aa..f202037b0 100644 --- a/src/decision/decision_engine.cpp +++ b/src/decision/decision_engine.cpp @@ -24,7 +24,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { DecisionEngine::DecisionEngine(context::Context* sc, context::UserContext* uc, @@ -101,4 +101,4 @@ void DecisionEngine::addSkolemDefinition(TNode lem, TNode skolem) } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/decision/decision_engine.h b/src/decision/decision_engine.h index 7405498b5..cbb6b897d 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 CVC5::prop; -using namespace CVC5::decision; +using namespace cvc5::prop; +using namespace cvc5::decision; -namespace CVC5 { +namespace cvc5 { class DecisionEngine { @@ -160,6 +160,6 @@ class DecisionEngine { std::unique_ptr<ITEDecisionStrategy> d_enabledITEStrategy; };/* DecisionEngine class */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__DECISION__DECISION_ENGINE_H */ diff --git a/src/decision/decision_strategy.h b/src/decision/decision_strategy.h index 6a9353474..4a1828a8f 100644 --- a/src/decision/decision_strategy.h +++ b/src/decision/decision_strategy.h @@ -25,7 +25,7 @@ #include "prop/sat_solver_types.h" #include "smt/term_formula_removal.h" -namespace CVC5 { +namespace cvc5 { class DecisionEngine; @@ -66,6 +66,6 @@ public: };/* class ITEDecisionStrategy */ } // namespace decision -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__DECISION__DECISION_STRATEGY_H */ diff --git a/src/decision/justification_heuristic.cpp b/src/decision/justification_heuristic.cpp index f9f9cb7df..abe7a47a7 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 CVC5 { +namespace cvc5 { namespace decision { -JustificationHeuristic::JustificationHeuristic(CVC5::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); } -CVC5::prop::SatLiteral JustificationHeuristic::getNext(bool& stopSearch) +cvc5::prop::SatLiteral JustificationHeuristic::getNext(bool& stopSearch) { if(options::decisionThreshold() > 0) { bool stopSearchTmp = false; @@ -82,7 +82,7 @@ CVC5::prop::SatLiteral JustificationHeuristic::getNext(bool& stopSearch) return getNextThresh(stopSearch, 0); } -CVC5::prop::SatLiteral JustificationHeuristic::getNextThresh( +cvc5::prop::SatLiteral JustificationHeuristic::getNextThresh( bool& stopSearch, DecisionWeight threshold) { Trace("decision") << "JustificationHeuristic::getNextThresh(stopSearch, "<<threshold<<")" << std::endl; @@ -733,4 +733,4 @@ JustificationHeuristic::handleEmbeddedSkolems(TNode node) } } /* namespace decision */ -} // namespace CVC5
\ 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 9ec61d540..06864470e 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 CVC5 { +namespace cvc5 { namespace decision { class JustificationHeuristic : public ITEDecisionStrategy { @@ -117,7 +117,7 @@ class JustificationHeuristic : public ITEDecisionStrategy { }; public: - JustificationHeuristic(CVC5::DecisionEngine* de, + JustificationHeuristic(cvc5::DecisionEngine* de, context::UserContext* uc, context::Context* c); @@ -195,6 +195,6 @@ private: };/* class JustificationHeuristic */ }/* namespace decision */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__DECISION__JUSTIFICATION_HEURISTIC */ diff --git a/src/expr/array_store_all.cpp b/src/expr/array_store_all.cpp index d50921598..b92ba8607 100644 --- a/src/expr/array_store_all.cpp +++ b/src/expr/array_store_all.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/array_store_all.h b/src/expr/array_store_all.h index 974f456ef..65385b0c4 100644 --- a/src/expr/array_store_all.h +++ b/src/expr/array_store_all.h @@ -24,7 +24,7 @@ #include <iosfwd> #include <memory> -namespace CVC5 { +namespace cvc5 { template <bool ref_count> class NodeTemplate; @@ -69,6 +69,6 @@ struct ArrayStoreAllHashFunction size_t operator()(const ArrayStoreAll& asa) const; }; /* struct ArrayStoreAllHashFunction */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__ARRAY_STORE_ALL_H */ diff --git a/src/expr/ascription_type.cpp b/src/expr/ascription_type.cpp index 6fecb2978..83254f5a5 100644 --- a/src/expr/ascription_type.cpp +++ b/src/expr/ascription_type.cpp @@ -18,7 +18,7 @@ #include "expr/type_node.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/ascription_type.h b/src/expr/ascription_type.h index 5b0ff2b71..b216a0fa1 100644 --- a/src/expr/ascription_type.h +++ b/src/expr/ascription_type.h @@ -22,7 +22,7 @@ #include <iosfwd> #include <memory> -namespace CVC5 { +namespace cvc5 { class TypeNode; @@ -60,6 +60,6 @@ struct AscriptionTypeHashFunction /** An output routine for AscriptionTypes */ std::ostream& operator<<(std::ostream& out, AscriptionType at); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__ASCRIPTION_TYPE_H */ diff --git a/src/expr/attribute.cpp b/src/expr/attribute.cpp index fe1bff897..062f0a2d2 100644 --- a/src/expr/attribute.cpp +++ b/src/expr/attribute.cpp @@ -22,7 +22,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace expr { namespace attr { @@ -116,4 +116,4 @@ void AttributeManager::deleteAttributes(const AttrIdVec& atids) { } // namespace attr } // namespace expr -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/attribute.h b/src/expr/attribute.h index b3a3eb717..6156ccc2d 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 CVC5 { +namespace cvc5 { namespace expr { namespace attr { @@ -621,6 +621,6 @@ NodeManager::setAttribute(TypeNode n, const AttrKind&, d_attrManager->setAttribute(n.d_nv, AttrKind(), value); } -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__ATTRIBUTE_H */ diff --git a/src/expr/attribute_internals.h b/src/expr/attribute_internals.h index bbd5455be..db3e57675 100644 --- a/src/expr/attribute_internals.h +++ b/src/expr/attribute_internals.h @@ -25,7 +25,7 @@ #include <unordered_map> -namespace CVC5 { +namespace cvc5 { namespace expr { // ATTRIBUTE HASH FUNCTIONS ==================================================== @@ -512,6 +512,6 @@ const uint64_t Attribute<T, bool, context_dep>::s_id = Attribute<T, bool, context_dep>::registerAttribute(); } // namespace expr -} // namespace CVC5 +} // 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 f084baaa1..b475a700d 100644 --- a/src/expr/attribute_unique_id.h +++ b/src/expr/attribute_unique_id.h @@ -21,7 +21,7 @@ // ATTRIBUTE IDs ============================================================ -namespace CVC5 { +namespace cvc5 { namespace expr { namespace attr { @@ -59,8 +59,8 @@ public: AttrTableId getTableId() const{ return d_tableId; } uint64_t getWithinTypeId() const{ return d_withinTypeId; } -}; /* CVC5::expr::attr::AttributeUniqueId */ +}; /* cvc5::expr::attr::AttributeUniqueId */ } // namespace attr } // namespace expr -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/bound_var_manager.cpp b/src/expr/bound_var_manager.cpp index ca257d313..e97e559a8 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/bound_var_manager.h b/src/expr/bound_var_manager.h index 08705f6d2..ebd107737 100644 --- a/src/expr/bound_var_manager.h +++ b/src/expr/bound_var_manager.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { /** * Bound variable manager. @@ -98,6 +98,6 @@ class BoundVarManager std::unordered_set<Node, NodeHashFunction> d_cacheVals; }; -} // namespace CVC5 +} // 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 caf6b0841..40820ea20 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/buffered_proof_generator.h b/src/expr/buffered_proof_generator.h index db8e50274..7399b3741 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 CVC5 { +namespace cvc5 { class ProofNodeManager; class ProofStep; @@ -57,6 +57,6 @@ class BufferedProofGenerator : public ProofGenerator ProofNodeManager* d_pnm; }; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__BUFFERED_PROOF_GENERATOR_H */ diff --git a/src/expr/datatype_index.cpp b/src/expr/datatype_index.cpp index 2459c86d8..6f530529a 100644 --- a/src/expr/datatype_index.cpp +++ b/src/expr/datatype_index.cpp @@ -20,7 +20,7 @@ using namespace std; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/datatype_index.h b/src/expr/datatype_index.h index 08d33ca83..a239c387b 100644 --- a/src/expr/datatype_index.h +++ b/src/expr/datatype_index.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__DATATYPE_H */ diff --git a/src/expr/dtype.cpp b/src/expr/dtype.cpp index 35ad5ff4c..3302be018 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/dtype.h b/src/expr/dtype.h index 5b6ec4a7d..524702bdd 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 CVC5 { +namespace cvc5 { // ----------------------- datatype attributes /** @@ -696,6 +696,6 @@ struct DTypeIndexConstantHashFunction std::ostream& operator<<(std::ostream& os, const DType& dt); -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/expr/dtype_cons.cpp b/src/expr/dtype_cons.cpp index 089d41637..59b870897 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 CVC5::kind; -using namespace CVC5::theory; +using namespace cvc5::kind; +using namespace cvc5::theory; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/dtype_cons.h b/src/expr/dtype_cons.h index 245d461b0..d444d9261 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/expr/dtype_selector.cpp b/src/expr/dtype_selector.cpp index a276c3734..d6a3b4469 100644 --- a/src/expr/dtype_selector.cpp +++ b/src/expr/dtype_selector.cpp @@ -16,9 +16,9 @@ #include "options/set_language.h" -using namespace CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/dtype_selector.h b/src/expr/dtype_selector.h index 7404c0c96..d45bcf8c5 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 CVC5 { +namespace cvc5 { class DatatypeConstructorArg; class DType; @@ -90,6 +90,6 @@ class DTypeSelector std::ostream& operator<<(std::ostream& os, const DTypeSelector& arg); -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/expr/emptybag.cpp b/src/expr/emptybag.cpp index 0f7a3a73e..d45612a9c 100644 --- a/src/expr/emptybag.cpp +++ b/src/expr/emptybag.cpp @@ -18,7 +18,7 @@ #include "expr/type_node.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/emptybag.h b/src/expr/emptybag.h index 59060eaa8..f45bd9e96 100644 --- a/src/expr/emptybag.h +++ b/src/expr/emptybag.h @@ -20,7 +20,7 @@ #include <iosfwd> #include <memory> -namespace CVC5 { +namespace cvc5 { class TypeNode; @@ -58,6 +58,6 @@ struct EmptyBagHashFunction size_t operator()(const EmptyBag& es) const; }; /* struct EmptyBagHashFunction */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EMPTY_BAG_H */ diff --git a/src/expr/emptyset.cpp b/src/expr/emptyset.cpp index 4a0bd4e51..4d6604a63 100644 --- a/src/expr/emptyset.cpp +++ b/src/expr/emptyset.cpp @@ -21,7 +21,7 @@ #include "expr/type_node.h" -namespace CVC5 { +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); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/emptyset.h b/src/expr/emptyset.h index febb4e111..aa6d5e143 100644 --- a/src/expr/emptyset.h +++ b/src/expr/emptyset.h @@ -23,7 +23,7 @@ #include <iosfwd> #include <memory> -namespace CVC5 { +namespace cvc5 { class TypeNode; @@ -60,6 +60,6 @@ struct EmptySetHashFunction size_t operator()(const EmptySet& es) const; }; /* struct EmptySetHashFunction */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EMPTY_SET_H */ diff --git a/src/expr/expr_iomanip.cpp b/src/expr/expr_iomanip.cpp index 4aec28b85..4417ccb5c 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 CVC5 { +namespace cvc5 { namespace expr { const int ExprSetDepth::s_iosIndex = std::ios_base::xalloc(); @@ -123,4 +123,4 @@ std::ostream& operator<<(std::ostream& out, ExprSetDepth sd) { } } // namespace expr -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/expr_iomanip.h b/src/expr/expr_iomanip.h index c40840cd4..674d4c6fd 100644 --- a/src/expr/expr_iomanip.h +++ b/src/expr/expr_iomanip.h @@ -21,7 +21,7 @@ #include <iosfwd> -namespace CVC5 { +namespace cvc5 { namespace expr { /** @@ -173,6 +173,6 @@ std::ostream& operator<<(std::ostream& out, ExprSetDepth sd); } // namespace expr -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__EXPR_IOMANIP_H */ diff --git a/src/expr/kind_map.h b/src/expr/kind_map.h index e6f6f9ca0..0716ff4d0 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 CVC5 { +namespace cvc5 { /** A very simple bitmap for Kinds */ class KindMap @@ -51,6 +51,6 @@ class KindMap std::bitset<kind::LAST_KIND> d_bits; }; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__KIND_MAP_H */ diff --git a/src/expr/kind_template.cpp b/src/expr/kind_template.cpp index cbe979642..d9f913ddf 100644 --- a/src/expr/kind_template.cpp +++ b/src/expr/kind_template.cpp @@ -19,12 +19,12 @@ #include "expr/kind.h" -namespace CVC5 { +namespace cvc5 { namespace kind { -const char* toString(CVC5::Kind k) +const char* toString(cvc5::Kind k) { - using namespace CVC5::kind; + using namespace cvc5::kind; switch (k) { @@ -37,7 +37,7 @@ const char* toString(CVC5::Kind k) } } -std::ostream& operator<<(std::ostream& out, CVC5::Kind k) +std::ostream& operator<<(std::ostream& out, cvc5::Kind k) { out << toString(k); return out; @@ -47,7 +47,7 @@ std::ostream& operator<<(std::ostream& out, CVC5::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(::CVC5::Kind k) +bool isAssociative(::cvc5::Kind k) { switch(k) { case kind::AND: @@ -61,7 +61,7 @@ bool isAssociative(::CVC5::Kind k) } } -std::string kindToString(::CVC5::Kind k) +std::string kindToString(::cvc5::Kind k) { std::stringstream ss; ss << k; @@ -82,7 +82,7 @@ ${type_constant_descriptions} namespace theory { -TheoryId kindToTheoryId(::CVC5::Kind k) +TheoryId kindToTheoryId(::cvc5::Kind k) { switch(k) { case kind::UNDEFINED_KIND: @@ -95,7 +95,7 @@ ${kind_to_theory_id} throw IllegalArgumentException("", "k", __PRETTY_FUNCTION__, "bad kind"); } -TheoryId typeConstantToTheoryId(::CVC5::TypeConstant typeConstant) +TheoryId typeConstantToTheoryId(::cvc5::TypeConstant typeConstant) { switch (typeConstant) { @@ -107,4 +107,4 @@ ${type_constant_to_theory_id} } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/kind_template.h b/src/expr/kind_template.h index 4661cfa15..484e8c273 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 CVC5 { +namespace cvc5 { namespace kind { enum Kind_t @@ -39,7 +39,7 @@ enum Kind_t // import Kind into the "CVC4" namespace but keep the individual kind // constants under kind:: -typedef ::CVC5::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(CVC5::Kind k); +const char* toString(cvc5::Kind k); /** * Writes a kind name to a stream. @@ -61,17 +61,17 @@ const char* toString(CVC5::Kind k); * @param k The kind to write to the stream * @return The stream */ -std::ostream& operator<<(std::ostream&, CVC5::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(::CVC5::Kind k); -std::string kindToString(::CVC5::Kind k); +bool isAssociative(::cvc5::Kind k); +std::string kindToString(::cvc5::Kind k); struct KindHashFunction { - inline size_t operator()(::CVC5::Kind k) const { return k; } + inline size_t operator()(::cvc5::Kind k) const { return k; } };/* struct KindHashFunction */ } // namespace kind @@ -97,11 +97,11 @@ std::ostream& operator<<(std::ostream& out, TypeConstant typeConstant); namespace theory { -::CVC5::theory::TheoryId kindToTheoryId(::CVC5::Kind k); -::CVC5::theory::TheoryId typeConstantToTheoryId( - ::CVC5::TypeConstant typeConstant); +::cvc5::theory::TheoryId kindToTheoryId(::cvc5::Kind k); +::cvc5::theory::TheoryId typeConstantToTheoryId( + ::cvc5::TypeConstant typeConstant); } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__KIND_H */ diff --git a/src/expr/lazy_proof.cpp b/src/expr/lazy_proof.cpp index 701cc55dc..95ce1406c 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { LazyCDProof::LazyCDProof(ProofNodeManager* pnm, ProofGenerator* dpg, @@ -228,4 +228,4 @@ bool LazyCDProof::hasGenerator(Node fact) const return it != d_gens.end(); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/lazy_proof.h b/src/expr/lazy_proof.h index 5c0de5c5b..3ab0ca49e 100644 --- a/src/expr/lazy_proof.h +++ b/src/expr/lazy_proof.h @@ -19,7 +19,7 @@ #include "expr/proof.h" -namespace CVC5 { +namespace cvc5 { class ProofGenerator; class ProofNodeManager; @@ -105,6 +105,6 @@ class LazyCDProof : public CDProof ProofGenerator* getGeneratorFor(Node fact, bool& isSym); }; -} // namespace CVC5 +} // 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 3651e53e1..7f14adc38 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/lazy_proof_chain.h b/src/expr/lazy_proof_chain.h index 7482e3ca4..41488c821 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 CVC5 { +namespace cvc5 { class ProofNodeManager; @@ -148,6 +148,6 @@ class LazyCDProofChain : public ProofGenerator ProofGenerator* d_defGen; }; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__LAZY_PROOF_CHAIN_H */ diff --git a/src/expr/match_trie.cpp b/src/expr/match_trie.cpp index d3adeb50e..b014339ad 100644 --- a/src/expr/match_trie.cpp +++ b/src/expr/match_trie.cpp @@ -14,9 +14,9 @@ #include "expr/match_trie.h" -using namespace CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace expr { bool MatchTrie::getMatches(Node n, NotifyMatch* ntm) @@ -196,4 +196,4 @@ void MatchTrie::clear() } } // namespace expr -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/match_trie.h b/src/expr/match_trie.h index 45ff0c0c7..70ce549e1 100644 --- a/src/expr/match_trie.h +++ b/src/expr/match_trie.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace expr { /** A virtual class for notifications regarding matches. */ @@ -77,6 +77,6 @@ class MatchTrie }; } // namespace expr -} // namespace CVC5 +} // 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 2f147b8b4..52502cbcd 100644 --- a/src/expr/metakind_template.cpp +++ b/src/expr/metakind_template.cpp @@ -19,7 +19,7 @@ #include <iostream> -namespace CVC5 { +namespace cvc5 { namespace kind { /** @@ -52,20 +52,20 @@ ${metakind_constantMaps} namespace kind { namespace metakind { -size_t NodeValueCompare::constHash(const ::CVC5::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() << ::CVC5::expr::NodeValue::dKindToKind(nv->d_kind); +default: Unhandled() << ::cvc5::expr::NodeValue::dKindToKind(nv->d_kind); } } template <bool pool> -bool NodeValueCompare::compare(const ::CVC5::expr::NodeValue* nv1, - const ::CVC5::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; @@ -76,7 +76,7 @@ bool NodeValueCompare::compare(const ::CVC5::expr::NodeValue* nv1, switch (nv1->d_kind) { ${metakind_compares} -default: Unhandled() << ::CVC5::expr::NodeValue::dKindToKind(nv1->d_kind); +default: Unhandled() << ::cvc5::expr::NodeValue::dKindToKind(nv1->d_kind); } } @@ -84,9 +84,9 @@ default: Unhandled() << ::CVC5::expr::NodeValue::dKindToKind(nv1->d_kind); return false; } - ::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(); + ::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)) { @@ -100,19 +100,19 @@ default: Unhandled() << ::CVC5::expr::NodeValue::dKindToKind(nv1->d_kind); } template bool NodeValueCompare::compare<true>( - const ::CVC5::expr::NodeValue* nv1, const ::CVC5::expr::NodeValue* nv2); + 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); + const ::cvc5::expr::NodeValue* nv1, const ::cvc5::expr::NodeValue* nv2); void NodeValueConstPrinter::toStream(std::ostream& out, - const ::CVC5::expr::NodeValue* nv) + const ::cvc5::expr::NodeValue* nv) { Assert(nv->getMetaKind() == kind::metakind::CONSTANT); switch (nv->d_kind) { ${metakind_constPrinters} -default: Unhandled() << ::CVC5::expr::NodeValue::dKindToKind(nv->d_kind); +default: Unhandled() << ::cvc5::expr::NodeValue::dKindToKind(nv->d_kind); } } @@ -136,21 +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(::CVC5::expr::NodeValue* nv) +void deleteNodeValueConstant(::cvc5::expr::NodeValue* nv) { Assert(nv->getMetaKind() == kind::metakind::CONSTANT); switch (nv->d_kind) { ${metakind_constDeleters} -default: Unhandled() << ::CVC5::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(::CVC5::Kind k) +uint32_t getMinArityForKind(::cvc5::Kind k) { static const unsigned lbs[] = { 0, /* NULL_EXPR */ @@ -162,7 +162,7 @@ ${metakind_lbchildren} return lbs[k]; } -uint32_t getMaxArityForKind(::CVC5::Kind k) +uint32_t getMaxArityForKind(::cvc5::Kind k) { static const unsigned ubs[] = { 0, /* NULL_EXPR */ @@ -180,7 +180,7 @@ ${metakind_ubchildren} * example, since the kind of functions is just VARIABLE, it should map * VARIABLE to APPLY_UF. */ -Kind operatorToKind(::CVC5::expr::NodeValue* nv) +Kind operatorToKind(::cvc5::expr::NodeValue* nv) { if(nv->getKind() == kind::BUILTIN) { return nv->getConst<Kind>(); @@ -197,4 +197,4 @@ ${metakind_operatorKinds} } } // namespace kind -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/metakind_template.h b/src/expr/metakind_template.h index ba1b47b4a..5c78d87d3 100644 --- a/src/expr/metakind_template.h +++ b/src/expr/metakind_template.h @@ -24,7 +24,7 @@ #include "base/check.h" #include "expr/kind.h" -namespace CVC5 { +namespace cvc5 { namespace expr { class NodeValue; @@ -74,16 +74,16 @@ struct ConstantMapReverse; */ template <Kind k, bool pool> struct NodeValueConstCompare { - inline static bool compare(const ::CVC5::expr::NodeValue* x, - const ::CVC5::expr::NodeValue* y); - inline static size_t constHash(const ::CVC5::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 ::CVC5::expr::NodeValue* nv1, - const ::CVC5::expr::NodeValue* nv2); - static size_t constHash(const ::CVC5::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 */ /** @@ -104,9 +104,9 @@ enum MetaKind_t { } // namespace metakind -// import MetaKind into the "CVC5::kind" namespace but keep the +// import MetaKind into the "cvc5::kind" namespace but keep the // individual MetaKind constants under kind::metakind:: -typedef ::CVC5::kind::metakind::MetaKind_t MetaKind; +typedef ::cvc5::kind::metakind::MetaKind_t MetaKind; /** * Get the metakind for a particular kind. @@ -119,12 +119,12 @@ namespace expr { // Comparison predicate struct NodeValuePoolEq { inline bool operator()(const NodeValue* nv1, const NodeValue* nv2) const { - return ::CVC5::kind::metakind::NodeValueCompare::compare<true>(nv1, nv2); + return ::cvc5::kind::metakind::NodeValueCompare::compare<true>(nv1, nv2); } }; } // namespace expr -} // namespace CVC5 +} // namespace cvc5 #include "expr/node_value.h" @@ -134,7 +134,7 @@ ${metakind_includes} #ifdef CVC4__NODE_MANAGER_NEEDS_CONSTANT_MAP -namespace CVC5 { +namespace cvc5 { namespace expr { ${metakind_getConst_decls} @@ -145,7 +145,7 @@ namespace metakind { template <Kind k, bool pool> inline bool NodeValueConstCompare<k, pool>::compare( - const ::CVC5::expr::NodeValue* x, const ::CVC5::expr::NodeValue* y) + const ::cvc5::expr::NodeValue* x, const ::cvc5::expr::NodeValue* y) { typedef typename ConstantMapReverse<k>::T T; if(pool) { @@ -165,7 +165,7 @@ inline bool NodeValueConstCompare<k, pool>::compare( template <Kind k, bool pool> inline size_t NodeValueConstCompare<k, pool>::constHash( - const ::CVC5::expr::NodeValue* nv) + const ::cvc5::expr::NodeValue* nv) { typedef typename ConstantMapReverse<k>::T T; return nv->getConst<T>().hash(); @@ -174,7 +174,7 @@ inline size_t NodeValueConstCompare<k, pool>::constHash( ${metakind_constantMaps_decls} struct NodeValueConstPrinter { - static void toStream(std::ostream& out, const ::CVC5::expr::NodeValue* nv); + static void toStream(std::ostream& out, const ::cvc5::expr::NodeValue* nv); static void toStream(std::ostream& out, TNode n); }; @@ -187,12 +187,12 @@ struct NodeValueConstPrinter { * This doesn't support "non-inlined" NodeValues, which shouldn't need this * kind of cleanup. */ -void deleteNodeValueConstant(::CVC5::expr::NodeValue* nv); +void deleteNodeValueConstant(::cvc5::expr::NodeValue* nv); /** Return the minimum arity of the given kind. */ -uint32_t getMinArityForKind(::CVC5::Kind k); +uint32_t getMinArityForKind(::cvc5::Kind k); /** Return the maximum arity of the given kind. */ -uint32_t getMaxArityForKind(::CVC5::Kind k); +uint32_t getMaxArityForKind(::cvc5::Kind k); } // namespace metakind @@ -201,10 +201,10 @@ uint32_t getMaxArityForKind(::CVC5::Kind k); * example, since the kind of functions is just VARIABLE, it should map * VARIABLE to APPLY_UF. */ -Kind operatorToKind(::CVC5::expr::NodeValue* nv); +Kind operatorToKind(::cvc5::expr::NodeValue* nv); } // namespace kind -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__NODE_MANAGER_NEEDS_CONSTANT_MAP */ diff --git a/src/expr/mkexpr b/src/expr/mkexpr index cc5162fef..c5ff67a43 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., ::CVC5::theory::foo)" >&2 - elif ! expr "$2" : '\(::CVC5::theory::*\)' >/dev/null; then - echo "$kf:$lineno: warning: theory class not under ::CVC5::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() == ::CVC5::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 3b987746a..289789a9e 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., ::CVC5::theory::foo)" >&2 - elif ! expr "$2" : '\(::CVC5::theory::*\)' >/dev/null; then - echo "$kf:$lineno: warning: theory class not under ::CVC5::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 b88a70c71..7c0d110fb 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., ::CVC5::theory::foo)" >&2 - elif ! expr "$2" : '\(::CVC5::theory::*\)' >/dev/null; then - echo "$kf:$lineno: warning: theory class not under ::CVC5::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., ::CVC5::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., ::CVC5::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 = ::CVC5::kind::$1 }; + enum { kind = ::cvc5::kind::$1 }; };/* ConstantMap< $2 > */ template <> -struct ConstantMapReverse< ::CVC5::kind::$1 > { +struct ConstantMapReverse< ::cvc5::kind::$1 > { typedef $2 T; -};/* ConstantMapReverse< ::CVC5::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< ::CVC5::kind::$1 > { template <> $2 const& NodeValue::getConst< $2 >() const { - AssertArgument(getKind() == ::CVC5::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 fa2a8860c..90d29f1eb 100644 --- a/src/expr/node.cpp +++ b/src/expr/node.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC5 { +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; -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/node.h b/src/expr/node.h index 291c2e538..29bfaa157 100644 --- a/src/expr/node.h +++ b/src/expr/node.h @@ -41,7 +41,7 @@ #include "util/hash.h" #include "util/utility.h" -namespace CVC5 { +namespace cvc5 { class TypeNode; class NodeManager; @@ -199,10 +199,10 @@ class NodeTemplate { template <unsigned nchild_thresh> friend class NodeBuilder; - friend class ::CVC5::expr::attr::AttributeManager; - friend struct ::CVC5::expr::attr::SmtAttributes; + friend class ::cvc5::expr::attr::AttributeManager; + friend struct ::cvc5::expr::attr::SmtAttributes; - friend struct ::CVC5::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; } -} // namespace CVC5 +} // namespace cvc5 //#include "expr/attribute.h" #include "expr/node_manager.h" -namespace CVC5 { +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 CVC5::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 CVC5::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 CVC5::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 CVC5::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 CVC5::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 CVC5::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 */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__NODE_H */ diff --git a/src/expr/node_algorithm.cpp b/src/expr/node_algorithm.cpp index 318b7c85b..bcf74a944 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 CVC5 { +namespace cvc5 { namespace expr { bool hasSubterm(TNode n, TNode t, bool strict) @@ -764,4 +764,4 @@ bool match(Node x, } } // namespace expr -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/node_algorithm.h b/src/expr/node_algorithm.h index ca1ee2e39..7ae56e5ba 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 CVC5 { +namespace cvc5 { namespace expr { /** @@ -235,6 +235,6 @@ bool match(Node n1, std::unordered_map<Node, Node, NodeHashFunction>& subs); } // namespace expr -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/expr/node_builder.h b/src/expr/node_builder.h index 724e03451..eaf5b040d 100644 --- a/src/expr/node_builder.h +++ b/src/expr/node_builder.h @@ -160,14 +160,14 @@ #include <memory> #include <vector> -namespace CVC5 { +namespace cvc5 { static const unsigned default_nchild_thresh = 10; template <unsigned nchild_thresh> class NodeBuilder; class NodeManager; -} // namespace CVC5 +} // namespace cvc5 #include "base/check.h" #include "base/output.h" @@ -175,7 +175,7 @@ class NodeManager; #include "expr/metakind.h" #include "expr/node_value.h" -namespace CVC5 { +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<> */ -} // namespace CVC5 +} // 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 CVC5 { +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; } -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__NODE_BUILDER_H */ diff --git a/src/expr/node_manager.cpp b/src/expr/node_manager.cpp index 370f0fb4c..6d2d150f5 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 CVC5::expr; +using namespace cvc5::expr; -namespace CVC5 { +namespace cvc5 { thread_local NodeManager* NodeManager::s_current = NULL; @@ -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. CVC5::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 - // CVC5::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; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/node_manager.h b/src/expr/node_manager.h index aeea179d4..857bcc25f 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 CVC5 { +namespace cvc5 { namespace api { class Solver; @@ -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<CVC5::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<CVC5::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 } -} // namespace CVC5 +} // 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 CVC5 { +namespace cvc5 { // general expression-builders @@ -1577,6 +1577,6 @@ NodeClass NodeManager::mkConstInternal(const T& val) { return NodeClass(nv); } -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__NODE_MANAGER_H */ diff --git a/src/expr/node_manager_attributes.h b/src/expr/node_manager_attributes.h index b7f6319eb..c88df3cee 100644 --- a/src/expr/node_manager_attributes.h +++ b/src/expr/node_manager_attributes.h @@ -19,7 +19,7 @@ #include "expr/attribute.h" -namespace CVC5 { +namespace cvc5 { namespace expr { // Definition of an attribute for the variable name. @@ -37,4 +37,4 @@ typedef expr::Attribute<expr::attr::TypeTag, TypeNode> TypeAttr; typedef expr::Attribute<expr::attr::TypeCheckedTag, bool> TypeCheckedAttr; } // namespace expr -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/node_self_iterator.h b/src/expr/node_self_iterator.h index 831eace65..d8558de97 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 CVC5 { +namespace cvc5 { namespace expr { class NodeSelfIterator : public std::iterator<std::input_iterator_tag, Node> { @@ -123,6 +123,6 @@ inline bool NodeSelfIterator::operator!=(NodeSelfIterator i) const { } } // namespace expr -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__NODE_SELF_ITERATOR_H */ diff --git a/src/expr/node_traversal.cpp b/src/expr/node_traversal.cpp index c7d3ab3f8..01140a806 100644 --- a/src/expr/node_traversal.cpp +++ b/src/expr/node_traversal.cpp @@ -16,7 +16,7 @@ #include <functional> -namespace CVC5 { +namespace cvc5 { NodeDfsIterator::NodeDfsIterator(TNode n, VisitOrder order, @@ -156,4 +156,4 @@ NodeDfsIterator NodeDfsIterable::end() const return NodeDfsIterator(d_order); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/node_traversal.h b/src/expr/node_traversal.h index 934ec6bd8..015bcec06 100644 --- a/src/expr/node_traversal.h +++ b/src/expr/node_traversal.h @@ -23,7 +23,7 @@ #include "expr/node.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif // CVC4__EXPR__NODE_TRAVERSAL_H diff --git a/src/expr/node_trie.cpp b/src/expr/node_trie.cpp index 195011c1f..5af1cef01 100644 --- a/src/expr/node_trie.cpp +++ b/src/expr/node_trie.cpp @@ -14,7 +14,7 @@ #include "expr/node_trie.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/node_trie.h b/src/expr/node_trie.h index f765105d3..2f42b6a52 100644 --- a/src/expr/node_trie.h +++ b/src/expr/node_trie.h @@ -20,7 +20,7 @@ #include <map> #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { /** NodeTemplate trie class @@ -107,6 +107,6 @@ typedef NodeTemplateTrie<true> NodeTrie; typedef NodeTemplateTrie<false> TNodeTrie; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__NODE_TRIE_H */ diff --git a/src/expr/node_value.cpp b/src/expr/node_value.cpp index 027c15a0a..7b3e413f7 100644 --- a/src/expr/node_value.cpp +++ b/src/expr/node_value.cpp @@ -31,7 +31,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace expr { string NodeValue::toString() const { @@ -95,4 +95,4 @@ NodeValue::iterator<NodeTemplate<false> > operator+( } } // namespace expr -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/node_value.h b/src/expr/node_value.h index ecc054a75..3815ea5be 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 CVC5 { +namespace cvc5 { template <bool ref_count> class NodeTemplate; class TypeNode; @@ -45,13 +45,13 @@ namespace expr { namespace kind { namespace metakind { - template < ::CVC5::Kind k, bool pool> + template < ::cvc5::Kind k, bool pool> struct NodeValueConstCompare; struct NodeValueCompare; struct NodeValueConstPrinter; - void deleteNodeValueConstant(::CVC5::expr::NodeValue* nv); + void deleteNodeValueConstant(::cvc5::expr::NodeValue* nv); } // namespace metakind } // namespace kind @@ -63,19 +63,19 @@ namespace expr { class NodeValue { template <bool> - friend class ::CVC5::NodeTemplate; - friend class ::CVC5::TypeNode; + friend class ::cvc5::NodeTemplate; + friend class ::cvc5::TypeNode; template <unsigned nchild_thresh> - friend class ::CVC5::NodeBuilder; - friend class ::CVC5::NodeManager; + friend class ::cvc5::NodeBuilder; + friend class ::cvc5::NodeManager; template <Kind k, bool pool> - friend struct ::CVC5::kind::metakind::NodeValueConstCompare; + friend struct ::cvc5::kind::metakind::NodeValueConstCompare; - friend struct ::CVC5::kind::metakind::NodeValueCompare; - friend struct ::CVC5::kind::metakind::NodeValueConstPrinter; + friend struct ::cvc5::kind::metakind::NodeValueCompare; + friend struct ::cvc5::kind::metakind::NodeValueConstPrinter; - friend void ::CVC5::kind::metakind::deleteNodeValueConstant(NodeValue* nv); + friend void ::cvc5::kind::metakind::deleteNodeValueConstant(NodeValue* nv); friend class RefCountGuard; @@ -396,11 +396,11 @@ struct NodeValueIDEquality { inline std::ostream& operator<<(std::ostream& out, const NodeValue& nv); } // namespace expr -} // namespace CVC5 +} // namespace cvc5 #include "expr/node_manager.h" -namespace CVC5 { +namespace cvc5 { namespace expr { inline NodeValue::NodeValue(int) : @@ -497,11 +497,11 @@ inline NodeValue* NodeValue::getChild(int i) const { } } // namespace expr -} // namespace CVC5 +} // namespace cvc5 #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace expr { template <typename T> @@ -545,6 +545,6 @@ static void __attribute__((used)) debugPrintRawNodeValue(const expr::NodeValue* } #endif /* CVC4_DEBUG */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__NODE_VALUE_H */ diff --git a/src/expr/node_visitor.h b/src/expr/node_visitor.h index a3e24772a..9816e37e8 100644 --- a/src/expr/node_visitor.h +++ b/src/expr/node_visitor.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC5 { +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; -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/proof.cpp b/src/expr/proof.cpp index a55b3c69a..c0ba27a64 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/proof.h b/src/expr/proof.h index 164880cea..af859df93 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 CVC5 { +namespace cvc5 { class ProofNode; class ProofNodeManager; @@ -273,6 +273,6 @@ class CDProof : public ProofGenerator void notifyNewProof(Node expected); }; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__PROOF_MANAGER_H */ diff --git a/src/expr/proof_checker.cpp b/src/expr/proof_checker.cpp index b5955e991..ca1b96f1e 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { Node ProofRuleChecker::check(PfRule id, const std::vector<Node>& children, @@ -347,4 +347,4 @@ bool ProofChecker::isPedanticFailure(PfRule id, return false; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/proof_checker.h b/src/expr/proof_checker.h index edb0fec3a..99f9f3ec8 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 CVC5 { +namespace cvc5 { class ProofChecker; class ProofNode; @@ -202,6 +202,6 @@ class ProofChecker bool enableOutput); }; -} // namespace CVC5 +} // 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 487c52bc6..6947cfd44 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/proof_ensure_closed.h b/src/expr/proof_ensure_closed.h index 40143f814..d610147d4 100644 --- a/src/expr/proof_ensure_closed.h +++ b/src/expr/proof_ensure_closed.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__PROOF_ENSURE_CLOSED_H */ diff --git a/src/expr/proof_generator.cpp b/src/expr/proof_generator.cpp index 102435cea..a315ba2cd 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 CVC5 { +namespace cvc5 { std::ostream& operator<<(std::ostream& out, CDPOverwrite opol) { @@ -73,4 +73,4 @@ bool ProofGenerator::addProofTo(Node f, return false; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/proof_generator.h b/src/expr/proof_generator.h index 446cb2c83..76a2c9b3b 100644 --- a/src/expr/proof_generator.h +++ b/src/expr/proof_generator.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { class CDProof; class ProofNode; @@ -107,6 +107,6 @@ class ProofGenerator virtual std::string identify() const = 0; }; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__PROOF_GENERATOR_H */ diff --git a/src/expr/proof_node.cpp b/src/expr/proof_node.cpp index 923bdeacd..f7ad65844 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/proof_node.h b/src/expr/proof_node.h index 67600e2d0..13c7f2878 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 CVC5 { +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 CVC5 +} // 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 142a9b37f..f307b78b9 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 CVC5 { +namespace cvc5 { namespace expr { void getFreeAssumptions(ProofNode* pn, std::vector<Node>& assump) @@ -172,4 +172,4 @@ bool containsSubproof(ProofNode* pn, } } // namespace expr -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/proof_node_algorithm.h b/src/expr/proof_node_algorithm.h index 9266c7251..01faa8a40 100644 --- a/src/expr/proof_node_algorithm.h +++ b/src/expr/proof_node_algorithm.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { class ProofNode; @@ -70,6 +70,6 @@ bool containsSubproof(ProofNode* pn, std::unordered_set<const ProofNode*>& visited); } // namespace expr -} // namespace CVC5 +} // 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 ceb9d4eac..036c50947 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { ProofNodeManager::ProofNodeManager(ProofChecker* pc) : d_checker(pc) @@ -356,4 +356,4 @@ bool ProofNodeManager::updateNodeInternal( return true; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/proof_node_manager.h b/src/expr/proof_node_manager.h index 8e019818d..54d398545 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 CVC5 { +namespace cvc5 { class ProofChecker; class ProofNode; @@ -192,6 +192,6 @@ class ProofNodeManager bool needsCheck); }; -} // namespace CVC5 +} // 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 7468ecb5a..b53ce368d 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { ProofNodeToSExpr::ProofNodeToSExpr() { @@ -144,4 +144,4 @@ Node ProofNodeToSExpr::getOrMkNodeVariable(Node n) return var; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/proof_node_to_sexpr.h b/src/expr/proof_node_to_sexpr.h index 8da094da2..bbbde39f6 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 CVC5 { +namespace cvc5 { class ProofNode; @@ -64,6 +64,6 @@ class ProofNodeToSExpr Node getOrMkNodeVariable(Node n); }; -} // namespace CVC5 +} // 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 4c1883e93..933e5b999 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 CVC5 { +namespace cvc5 { ProofNodeUpdaterCallback::ProofNodeUpdaterCallback() {} ProofNodeUpdaterCallback::~ProofNodeUpdaterCallback() {} @@ -261,4 +261,4 @@ void ProofNodeUpdater::setDebugFreeAssumptions( d_debugFreeAssumps = true; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/proof_node_updater.h b/src/expr/proof_node_updater.h index 5a22af61a..8e30f14d2 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 CVC5 { +namespace cvc5 { class CDProof; class ProofNode; @@ -155,6 +155,6 @@ class ProofNodeUpdater bool d_autoSym; }; -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/expr/proof_rule.cpp b/src/expr/proof_rule.cpp index 1323520c3..8141a017c 100644 --- a/src/expr/proof_rule.cpp +++ b/src/expr/proof_rule.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/proof_rule.h b/src/expr/proof_rule.h index 95f97ae44..7e0fc31fe 100644 --- a/src/expr/proof_rule.h +++ b/src/expr/proof_rule.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__PROOF_RULE_H */ diff --git a/src/expr/proof_set.h b/src/expr/proof_set.h index ccfac350a..0509ed9d4 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 CVC5 { +namespace cvc5 { /** * A (context-dependent) set of proofs, which is used for memory @@ -70,6 +70,6 @@ class CDProofSet std::string d_namePrefix; }; -} // namespace CVC5 +} // 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 23f0f5997..4ecee9130 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/proof_step_buffer.h b/src/expr/proof_step_buffer.h index b78d1d605..99a7608ff 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 CVC5 { +namespace cvc5 { class ProofChecker; @@ -92,6 +92,6 @@ class ProofStepBuffer std::vector<std::pair<Node, ProofStep>> d_steps; }; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__PROOF_STEP_BUFFER_H */ diff --git a/src/expr/record.cpp b/src/expr/record.cpp index affd2615c..367315d84 100644 --- a/src/expr/record.cpp +++ b/src/expr/record.cpp @@ -19,10 +19,10 @@ #include "base/check.h" #include "base/output.h" -namespace CVC5 { +namespace cvc5 { std::ostream& operator<<(std::ostream& out, const RecordUpdate& t) { return out << "[" << t.getField() << "]"; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/record.h b/src/expr/record.h index d4b41b9b9..436b5b269 100644 --- a/src/expr/record.h +++ b/src/expr/record.h @@ -25,13 +25,13 @@ #include <utility> // Forward Declarations -namespace CVC5 { +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 CVC5 +} // namespace cvc5 -namespace CVC5 { +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>>; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__RECORD_H */ diff --git a/src/expr/sequence.cpp b/src/expr/sequence.cpp index 90b57f58d..df40c8534 100644 --- a/src/expr/sequence.cpp +++ b/src/expr/sequence.cpp @@ -22,7 +22,7 @@ using namespace std; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/sequence.h b/src/expr/sequence.h index 461adb667..e42851f58 100644 --- a/src/expr/sequence.h +++ b/src/expr/sequence.h @@ -20,7 +20,7 @@ #include <memory> #include <vector> -namespace CVC5 { +namespace cvc5 { template <bool ref_count> class NodeTemplate; @@ -36,7 +36,7 @@ class Sequence public: /** constructors for Sequence * - * Internally, a CVC5::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 CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__SEQUENCE_H */ diff --git a/src/expr/skolem_manager.cpp b/src/expr/skolem_manager.cpp index 2b04c0755..31c0b55cd 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/skolem_manager.h b/src/expr/skolem_manager.h index 1078bc11f..9955c0e15 100644 --- a/src/expr/skolem_manager.h +++ b/src/expr/skolem_manager.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { class ProofGenerator; @@ -234,6 +234,6 @@ class SkolemManager int flags = NodeManager::SKOLEM_DEFAULT); }; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__PROOF_SKOLEM_CACHE_H */ diff --git a/src/expr/subs.cpp b/src/expr/subs.cpp index 897c6fdba..c2138499b 100644 --- a/src/expr/subs.cpp +++ b/src/expr/subs.cpp @@ -18,7 +18,7 @@ #include "theory/rewriter.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/subs.h b/src/expr/subs.h index c2854bf36..fdb8e4551 100644 --- a/src/expr/subs.h +++ b/src/expr/subs.h @@ -19,7 +19,7 @@ #include <vector> #include "expr/node.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__SUBS_H */ diff --git a/src/expr/sygus_datatype.cpp b/src/expr/sygus_datatype.cpp index 352dd157a..929c8a97c 100644 --- a/src/expr/sygus_datatype.cpp +++ b/src/expr/sygus_datatype.cpp @@ -16,9 +16,9 @@ #include <sstream> -using namespace CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/sygus_datatype.h b/src/expr/sygus_datatype.h index f4635bdb3..e5d1de740 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 CVC5 { +namespace cvc5 { /** Attribute true for variables that represent any constant */ struct SygusAnyConstAttributeId @@ -134,6 +134,6 @@ class SygusDatatype DType d_dt; }; -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/expr/symbol_manager.cpp b/src/expr/symbol_manager.cpp index 1e99f4a68..9610e443d 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 CVC5::context; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { // ---------------------------------------------- SymbolManager::Implementation @@ -367,4 +367,4 @@ void SymbolManager::resetAssertions() d_symtabAllocated.resetAssertions(); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/symbol_manager.h b/src/expr/symbol_manager.h index 6795ce3b3..0a9248f78 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 CVC5 { +namespace cvc5 { /** * Symbol manager, which manages: @@ -156,6 +156,6 @@ class CVC4_EXPORT SymbolManager bool d_globalDeclarations; }; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__SYMBOL_MANAGER_H */ diff --git a/src/expr/symbol_table.cpp b/src/expr/symbol_table.cpp index 774e2bb39..1c513fea4 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 CVC5 { +namespace cvc5 { -using ::CVC5::context::CDHashMap; -using ::CVC5::context::CDHashSet; -using ::CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/expr/symbol_table.h b/src/expr/symbol_table.h index 113dea704..fbb1969dd 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 CVC5 { +namespace cvc5 { namespace api { class Solver; @@ -210,6 +210,6 @@ class CVC4_EXPORT SymbolTable std::unique_ptr<Implementation> d_implementation; }; /* class SymbolTable */ -} // namespace CVC5 +} // 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 9b099de2d..d51e07e83 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 CVC5 { +namespace cvc5 { TConvSeqProofGenerator::TConvSeqProofGenerator( ProofNodeManager* pnm, @@ -168,4 +168,4 @@ theory::TrustNode TConvSeqProofGenerator::mkTrustRewriteSequence( std::string TConvSeqProofGenerator::identify() const { return d_name; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/tconv_seq_proof_generator.h b/src/expr/tconv_seq_proof_generator.h index a5b1de101..151cd511d 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 CVC5 { +namespace cvc5 { class ProofNodeManager; @@ -115,6 +115,6 @@ class TConvSeqProofGenerator : public ProofGenerator std::string d_name; }; -} // namespace CVC5 +} // 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 97f3c2539..11a992d16 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/term_canonize.h b/src/expr/term_canonize.h index f9f0fda24..f15bb2df0 100644 --- a/src/expr/term_canonize.h +++ b/src/expr/term_canonize.h @@ -20,7 +20,7 @@ #include <map> #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace expr { /** TermCanonize @@ -100,6 +100,6 @@ class TermCanonize }; } // namespace expr -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__EXPR__TERM_CANONIZE_H */ diff --git a/src/expr/term_context.cpp b/src/expr/term_context.cpp index 56c38a17c..883fa3e08 100644 --- a/src/expr/term_context.cpp +++ b/src/expr/term_context.cpp @@ -14,7 +14,7 @@ #include "expr/term_context.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/term_context.h b/src/expr/term_context.h index 65cdbb23e..062104fc2 100644 --- a/src/expr/term_context.h +++ b/src/expr/term_context.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC5 { +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 CVC5 +} // 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 1afc599d2..564459d37 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/term_context_node.h b/src/expr/term_context_node.h index 67d747557..5af435a56 100644 --- a/src/expr/term_context_node.h +++ b/src/expr/term_context_node.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { class TCtxStack; class TermContext; @@ -74,6 +74,6 @@ class TCtxNode const TermContext* d_tctx; }; -} // namespace CVC5 +} // 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 557683498..8a0fd91c9 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/expr/term_context_stack.h b/src/expr/term_context_stack.h index 34c474a52..0042091ed 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 CVC5 { +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 CVC5 +} // 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 bfdf4d188..df4708f74 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { std::ostream& operator<<(std::ostream& out, TConvPolicy tcpol) { @@ -588,4 +588,4 @@ std::string TConvProofGenerator::toStringDebug() const return ss.str(); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/term_conversion_proof_generator.h b/src/expr/term_conversion_proof_generator.h index 734ef103e..e1f2b90e8 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 CVC5 { +namespace cvc5 { class ProofNodeManager; class TermContext; @@ -242,6 +242,6 @@ class TConvProofGenerator : public ProofGenerator std::string toStringDebug() const; }; -} // namespace CVC5 +} // 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 b502d8013..fee02de75 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 CVC5 { +namespace cvc5 { namespace expr { class TypeChecker { @@ -36,6 +36,6 @@ public: };/* class TypeChecker */ } // namespace expr -} // namespace CVC5 +} // 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 07dca77e2..d99d5e82d 100644 --- a/src/expr/type_checker_template.cpp +++ b/src/expr/type_checker_template.cpp @@ -23,7 +23,7 @@ ${typechecker_includes} -namespace CVC5 { +namespace cvc5 { namespace expr { TypeNode TypeChecker::computeType(NodeManager* nodeManager, TNode n, bool check) @@ -72,4 +72,4 @@ ${construles} }/* TypeChecker::computeIsConst */ } // namespace expr -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/type_checker_util.h b/src/expr/type_checker_util.h index 1ca23d374..207c242b8 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 CVC5 { +namespace cvc5 { namespace expr { /** Type check returns the builtin operator sort */ @@ -202,4 +202,4 @@ class SimpleTypeRuleVar }; } // namespace expr -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/type_matcher.cpp b/src/expr/type_matcher.cpp index 76d256157..9389ce4b8 100644 --- a/src/expr/type_matcher.cpp +++ b/src/expr/type_matcher.cpp @@ -14,7 +14,7 @@ #include "type_matcher.h" -namespace CVC5 { +namespace cvc5 { TypeMatcher::TypeMatcher(TypeNode dt) { @@ -125,4 +125,4 @@ void TypeMatcher::getMatches(std::vector<TypeNode>& types) const } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/type_matcher.h b/src/expr/type_matcher.h index 651054313..a75bb7b8b 100644 --- a/src/expr/type_matcher.h +++ b/src/expr/type_matcher.h @@ -21,7 +21,7 @@ #include "expr/type_node.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__MATCHER_H */ diff --git a/src/expr/type_node.cpp b/src/expr/type_node.cpp index f73bde3eb..cbade1220 100644 --- a/src/expr/type_node.cpp +++ b/src/expr/type_node.cpp @@ -25,7 +25,7 @@ using namespace std; -namespace CVC5 { +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 CVC5::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]; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/type_node.h b/src/expr/type_node.h index 7b752c3e5..98515be2a 100644 --- a/src/expr/type_node.h +++ b/src/expr/type_node.h @@ -32,7 +32,7 @@ #include "expr/metakind.h" #include "util/cardinality.h" -namespace CVC5 { +namespace cvc5 { class NodeManager; class DType; @@ -749,11 +749,11 @@ inline std::ostream& operator<<(std::ostream& out, const TypeNode& n) { typedef TypeNode::HashFunction TypeNodeHashFunction; -} // namespace CVC5 +} // namespace cvc5 #include "expr/node_manager.h" -namespace CVC5 { +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 CVC5::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 CVC5::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 CVC5::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 CVC5::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 */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__NODE_H */ diff --git a/src/expr/type_properties_template.h b/src/expr/type_properties_template.h index abf5e6173..ce2696c5b 100644 --- a/src/expr/type_properties_template.h +++ b/src/expr/type_properties_template.h @@ -29,7 +29,7 @@ ${type_properties_includes} -namespace CVC5 { +namespace cvc5 { namespace kind { /** @@ -114,6 +114,6 @@ ${type_groundterms} } /* mkGroundTerm(TypeNode) */ } // namespace kind -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__TYPE_PROPERTIES_H */ diff --git a/src/expr/uninterpreted_constant.cpp b/src/expr/uninterpreted_constant.cpp index 9d8b12264..bd934e391 100644 --- a/src/expr/uninterpreted_constant.cpp +++ b/src/expr/uninterpreted_constant.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { UninterpretedConstant::UninterpretedConstant(const TypeNode& type, Integer index) @@ -95,4 +95,4 @@ size_t UninterpretedConstantHashFunction::operator()( * IntegerHashFunction()(uc.getIndex()); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/expr/uninterpreted_constant.h b/src/expr/uninterpreted_constant.h index 00ad68212..94d7f85ed 100644 --- a/src/expr/uninterpreted_constant.h +++ b/src/expr/uninterpreted_constant.h @@ -24,7 +24,7 @@ #include "util/integer.h" -namespace CVC5 { +namespace cvc5 { class TypeNode; @@ -60,6 +60,6 @@ struct UninterpretedConstantHashFunction size_t operator()(const UninterpretedConstant& uc) const; }; /* struct UninterpretedConstantHashFunction */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__UNINTERPRETED_CONSTANT_H */ diff --git a/src/main/command_executor.cpp b/src/main/command_executor.cpp index ebe51f359..6152064be 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 CVC5 { +namespace cvc5 { namespace main { // Function to cancel any (externally-imposed) limit on CPU time. @@ -332,4 +332,4 @@ void CommandExecutor::flushOutputStreams() { } } // namespace main -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/main/command_executor.h b/src/main/command_executor.h index a2dc4a4e9..f066a27b6 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 CVC5 { +namespace cvc5 { class Command; @@ -65,9 +65,9 @@ class CommandExecutor * sequence. Eventually uses doCommandSingleton (which can be * overridden by a derived class). */ - bool doCommand(CVC5::Command* cmd); + bool doCommand(cvc5::Command* cmd); - bool doCommand(std::unique_ptr<CVC5::Command>& cmd) + bool doCommand(std::unique_ptr<cvc5::Command>& cmd) { return doCommand(cmd.get()); } @@ -101,7 +101,7 @@ class CommandExecutor protected: /** Executes treating cmd as a singleton */ - virtual bool doCommandSingleton(CVC5::Command* cmd); + virtual bool doCommandSingleton(cvc5::Command* cmd); private: CommandExecutor(); @@ -114,6 +114,6 @@ bool solverInvoke(api::Solver* solver, std::ostream* out); } // namespace main -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__MAIN__COMMAND_EXECUTOR_H */ diff --git a/src/main/driver_unified.cpp b/src/main/driver_unified.cpp index 40ed674c0..fdf6a8335 100644 --- a/src/main/driver_unified.cpp +++ b/src/main/driver_unified.cpp @@ -41,11 +41,11 @@ #include "util/result.h" using namespace std; -using namespace CVC5; -using namespace CVC5::parser; -using namespace CVC5::main; +using namespace cvc5; +using namespace cvc5::parser; +using namespace cvc5::main; -namespace CVC5 { +namespace cvc5 { namespace main { /** Global options variable */ thread_local Options* pOptions; @@ -57,7 +57,7 @@ const char* progPath; const std::string* progName; /** A pointer to the CommandExecutor (the signal handlers need it) */ -std::unique_ptr<CVC5::main::CommandExecutor> pExecutor; +std::unique_ptr<cvc5::main::CommandExecutor> pExecutor; /** The time point the binary started, accessible to signal handlers */ std::unique_ptr<TotalTimer> totalTime; @@ -73,7 +73,7 @@ TotalTimer::~TotalTimer() } } // namespace main - } // namespace CVC5 + } // namespace cvc5 void printUsage(Options& opts, bool full) { stringstream ss; @@ -175,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(&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); + 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 91b3d53b3..44fee3eb5 100644 --- a/src/main/interactive_shell.cpp +++ b/src/main/interactive_shell.cpp @@ -49,7 +49,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { using namespace parser; using namespace language; @@ -432,4 +432,4 @@ char* commandGenerator(const char* text, int state) { #endif /* HAVE_LIBEDITLINE */ -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/main/interactive_shell.h b/src/main/interactive_shell.h index 2c421d7b2..2f7f0af21 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 CVC5 { +namespace cvc5 { class Command; class Options; @@ -72,6 +72,6 @@ public: };/* class InteractiveShell */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__INTERACTIVE_SHELL_H */ diff --git a/src/main/main.cpp b/src/main/main.cpp index f880d5ee1..a17b2e7c5 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -34,9 +34,9 @@ #include "util/result.h" using namespace std; -using namespace CVC5; -using namespace CVC5::main; -using namespace CVC5::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 47312c465..6f485a1f5 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 CVC5 { +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<CVC5::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,7 +64,7 @@ extern bool segvSpin; extern thread_local Options* pOptions; /** Initialize the driver. Sets signal handlers for SIGINT and SIGSEGV. - * This can throw a CVC5::Exception. + * This can throw a cvc5::Exception. */ void cvc4_init(); @@ -72,10 +72,10 @@ void cvc4_init(); void cvc4_shutdown() noexcept; } // namespace main -} // namespace CVC5 +} // namespace cvc5 /** Actual Cvc4 driver functions **/ -int runCvc4(int argc, char* argv[], CVC5::Options&); -void printUsage(CVC5::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 a7a3a073c..ae549e9a6 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 CVC5::Exception; +using cvc5::Exception; using namespace std; -namespace CVC5 { +namespace cvc5 { namespace main { /** @@ -343,4 +343,4 @@ void cleanup() noexcept } // namespace signal_handlers } // namespace main -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/main/signal_handlers.h b/src/main/signal_handlers.h index 1312ca27d..f8fdaf7fd 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 CVC5 { +namespace cvc5 { namespace main { namespace signal_handlers { @@ -41,6 +41,6 @@ void cleanup(); } // namespace signal_handlers } // namespace main -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__MAIN__SIGNAL_HANDLERS_H */ diff --git a/src/main/time_limit.cpp b/src/main/time_limit.cpp index 7f2bc0c61..e3a95d640 100644 --- a/src/main/time_limit.cpp +++ b/src/main/time_limit.cpp @@ -58,7 +58,7 @@ #include "signal_handlers.h" -namespace CVC5 { +namespace cvc5 { namespace main { #if HAVE_SETITIMER @@ -133,4 +133,4 @@ TimeLimit install_time_limit(const Options& opts) } } // namespace main -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/main/time_limit.h b/src/main/time_limit.h index 62dc6a6a3..ce55523f1 100644 --- a/src/main/time_limit.h +++ b/src/main/time_limit.h @@ -19,7 +19,7 @@ #include "options/options.h" -namespace CVC5 { +namespace cvc5 { namespace main { /** @@ -47,6 +47,6 @@ struct TimeLimit TimeLimit install_time_limit(const Options& opts); } // namespace main -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__MAIN__TIME_LIMIT_H */ diff --git a/src/options/README b/src/options/README index 92609f433..8c41a28bb 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, CVC5::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 5c223d770..895a450a3 100644 --- a/src/options/base_handlers.h +++ b/src/options/base_handlers.h @@ -26,7 +26,7 @@ #include "options/option_exception.h" -namespace CVC5 { +namespace cvc5 { namespace options { template <template <class U> class Cmp> @@ -81,6 +81,6 @@ struct not_equal : public comparator<std::not_equal_to> { };/* struct not_equal_to */ } // namespace options -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__BASE_HANDLERS_H */ diff --git a/src/options/decision_weight.h b/src/options/decision_weight.h index 88def99e6..851efc565 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 CVC5 { +namespace cvc5 { namespace decision { typedef uint64_t DecisionWeight; } // namespace decision -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__OPTIONS__DECISION_WEIGHT_H */ diff --git a/src/options/didyoumean.cpp b/src/options/didyoumean.cpp index 02307063b..8f539cdd3 100644 --- a/src/options/didyoumean.cpp +++ b/src/options/didyoumean.cpp @@ -25,7 +25,7 @@ #include <string> #include <vector> -namespace CVC5 { +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(); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/options/didyoumean.h b/src/options/didyoumean.h index 79deeb004..e0da600b8 100644 --- a/src/options/didyoumean.h +++ b/src/options/didyoumean.h @@ -23,7 +23,7 @@ #include <string> #include <vector> -namespace CVC5 { +namespace cvc5 { class DidYouMean { public: @@ -50,4 +50,4 @@ class DidYouMean { Words d_words; }; -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/options/didyoumean_test.cpp b/src/options/didyoumean_test.cpp index 7ea8e1243..f4791db95 100644 --- a/src/options/didyoumean_test.cpp +++ b/src/options/didyoumean_test.cpp @@ -23,7 +23,7 @@ #include <iostream> using namespace std; -using namespace CVC5; +using namespace cvc5; set<string> getDebugTags(); set<string> getOptionStrings(); diff --git a/src/options/language.cpp b/src/options/language.cpp index bf8f5d7bf..8fb1ad53a 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 CVC5 { +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 CVC5::Exception(ss.str()); + throw cvc5::Exception(ss.str()); } }/* switch(language) */ }/* toInputLanguage() */ @@ -171,4 +171,4 @@ InputLanguage toInputLanguage(std::string language) { }/* toInputLanguage() */ } // namespace language -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/options/language.h b/src/options/language.h index 99ee40c28..9ed7fb4d4 100644 --- a/src/options/language.h +++ b/src/options/language.h @@ -24,7 +24,7 @@ #include "cvc4_export.h" -namespace CVC5 { +namespace cvc5 { namespace language { namespace input { @@ -177,6 +177,6 @@ InputLanguage toInputLanguage(std::string language) CVC4_EXPORT; OutputLanguage toOutputLanguage(std::string language) CVC4_EXPORT; } // namespace language -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__LANGUAGE_H */ diff --git a/src/options/module_template.cpp b/src/options/module_template.cpp index 105ab94f8..c05017c70 100644 --- a/src/options/module_template.cpp +++ b/src/options/module_template.cpp @@ -19,7 +19,7 @@ #include "base/check.h" // clang-format off -namespace CVC5 { +namespace cvc5 { ${accs}$ @@ -31,5 +31,5 @@ ${defs}$ ${modes}$ } // namespace options -} // namespace CVC5 +} // namespace cvc5 // clang-format on diff --git a/src/options/module_template.h b/src/options/module_template.h index 501e5cf43..7e4b7775d 100644 --- a/src/options/module_template.h +++ b/src/options/module_template.h @@ -27,7 +27,7 @@ ${includes}$ ${holder_spec}$ -namespace CVC5 { +namespace cvc5 { namespace options { ${modes}$ @@ -42,7 +42,7 @@ namespace options { ${inls}$ } // namespace options -} // namespace CVC5 +} // 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 03c3e63ff..850fdce80 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 CVC5 { +namespace cvc5 { OstreamOpener::OstreamOpener(const char* channelName) : d_channelName(channelName) @@ -98,4 +98,4 @@ std::string cvc4_errno_failreason() { #endif /* HAVE_STRERROR_R */ } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/options/open_ostream.h b/src/options/open_ostream.h index 4f879cd6d..22e3ca16b 100644 --- a/src/options/open_ostream.h +++ b/src/options/open_ostream.h @@ -25,7 +25,7 @@ #include <string> #include <utility> -namespace CVC5 { +namespace cvc5 { class OstreamOpener { public: @@ -55,6 +55,6 @@ class OstreamOpener { std::string cvc4_errno_failreason(); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__OPEN_OSTREAM_H */ diff --git a/src/options/option_exception.cpp b/src/options/option_exception.cpp index 997f7d84a..07a8a8e57 100644 --- a/src/options/option_exception.cpp +++ b/src/options/option_exception.cpp @@ -16,6 +16,6 @@ #include "options/option_exception.h" -namespace CVC5 { +namespace cvc5 { const std::string OptionException::s_errPrefix = "Error in option parsing: "; -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/options/option_exception.h b/src/options/option_exception.h index 6b522c30a..bfaa2a421 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 CVC5 { +namespace cvc5 { /** * Class representing an option-parsing exception such as badly-typed @@ -30,10 +30,10 @@ namespace CVC5 { * name is itself unrecognized, a UnrecognizedOptionException (a derived * class, below) should be used instead. */ -class CVC4_EXPORT OptionException : public CVC5::Exception +class CVC4_EXPORT OptionException : public cvc5::Exception { public: - OptionException(const std::string& s) : CVC5::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,22 +53,22 @@ class CVC4_EXPORT OptionException : public CVC5::Exception * Class representing an exception in option processing due to an * unrecognized or unsupported option key. */ -class UnrecognizedOptionException : public CVC5::OptionException +class UnrecognizedOptionException : public cvc5::OptionException { public: UnrecognizedOptionException() - : CVC5::OptionException( + : cvc5::OptionException( "Unrecognized informational or option key or setting") { } UnrecognizedOptionException(const std::string& msg) - : CVC5::OptionException( + : cvc5::OptionException( "Unrecognized informational or option key or setting: " + msg) { } }; /* class UnrecognizedOptionException */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__OPTION_EXCEPTION_H */ diff --git a/src/options/options.h b/src/options/options.h index 6958f350c..1c62d5a07 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 CVC5 { +namespace cvc5 { namespace api { class Solver; @@ -306,6 +306,6 @@ public: std::vector<std::string>* nonoptions); }; /* class Options */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__OPTIONS__OPTIONS_H */ diff --git a/src/options/options_handler.cpp b/src/options/options_handler.cpp index 250fd98ac..ccffd17ec 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 CVC5 { +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(&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); + 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(&CVC5::null_os); + ChatChannel.setStream(&cvc5::null_os); } else { ChatChannel.setStream(&std::cout); } if(value < 1) { - NoticeChannel.setStream(&CVC5::null_os); + NoticeChannel.setStream(&cvc5::null_os); } else { NoticeChannel.setStream(&std::cout); } if(value < 0) { - MessageChannel.setStream(&CVC5::null_os); - WarningChannel.setStream(&CVC5::null_os); + MessageChannel.setStream(&cvc5::null_os); + WarningChannel.setStream(&cvc5::null_os); } else { MessageChannel.setStream(&std::cout); WarningChannel.setStream(&std::cerr); @@ -543,4 +543,4 @@ void OptionsHandler::decreaseVerbosity(std::string option) { } } // namespace options -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/options/options_handler.h b/src/options/options_handler.h index cf59c783a..ce174d32e 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 CVC5 { +namespace cvc5 { class Options; @@ -134,6 +134,6 @@ void OptionsHandler::checkSatSolverEnabled(std::string option, T m) } } // namespace options -} // namespace CVC5 +} // 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 e8cab00c7..956cd87bf 100644 --- a/src/options/options_holder_template.h +++ b/src/options/options_holder_template.h @@ -22,7 +22,7 @@ // clang-format off ${headers_module}$ -namespace CVC5 { +namespace cvc5 { namespace options { struct OptionsHolder @@ -33,7 +33,7 @@ struct OptionsHolder }; /* struct OptionsHolder */ } // namespace options -} // namespace CVC5 +} // 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 9cbdfaf97..a5a2218b2 100644 --- a/src/options/options_listener.h +++ b/src/options/options_listener.h @@ -19,7 +19,7 @@ #include <string> -namespace CVC5 { +namespace cvc5 { class OptionsListener { @@ -32,6 +32,6 @@ class OptionsListener virtual void notifySetOption(const std::string& key) = 0; }; -} // namespace CVC5 +} // 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 d7768c6c8..1bccc283f 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 CVC5 { +namespace cvc5 { // Get accessor functions. InputLanguage Options::getInputLanguage() const { @@ -238,4 +238,4 @@ void Options::flushOut() { } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/options/options_template.cpp b/src/options/options_template.cpp index a0037d162..f158f29e6 100644 --- a/src/options/options_template.cpp +++ b/src/options/options_template.cpp @@ -64,10 +64,10 @@ ${headers_module}$ ${headers_handler}$ -using namespace CVC5; -using namespace CVC5::options; +using namespace cvc5; +using namespace cvc5::options; -namespace CVC5 { +namespace cvc5 { thread_local Options* Options::s_current = NULL; @@ -369,7 +369,7 @@ public: } // namespace options /** - * Parse argc/argv and put the result into a CVC5::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). * @@ -601,5 +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 CVC5 +} // namespace cvc5 // clang-format on diff --git a/src/options/printer_modes.cpp b/src/options/printer_modes.cpp index 7e659b14c..1ea0a3bbe 100644 --- a/src/options/printer_modes.cpp +++ b/src/options/printer_modes.cpp @@ -17,7 +17,7 @@ #include "options/printer_modes.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/options/printer_modes.h b/src/options/printer_modes.h index 7f9bcc58b..f5da12b36 100644 --- a/src/options/printer_modes.h +++ b/src/options/printer_modes.h @@ -22,7 +22,7 @@ #include <iostream> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__PRINTER__MODEL_FORMAT_H */ diff --git a/src/options/set_language.cpp b/src/options/set_language.cpp index 53dca6220..b4403f11e 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 CVC5 { +namespace cvc5 { namespace language { const int SetLanguage::s_iosIndex = std::ios_base::xalloc(); @@ -79,4 +79,4 @@ std::ostream& operator<<(std::ostream& out, SetLanguage l) { } } // namespace language -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/options/set_language.h b/src/options/set_language.h index d6b9a2da9..cebd4f65e 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 CVC5 { +namespace cvc5 { namespace language { /** @@ -91,6 +91,6 @@ private: std::ostream& operator<<(std::ostream& out, SetLanguage l) CVC4_EXPORT; } // namespace language -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__OPTIONS__SET_LANGUAGE_H */ diff --git a/src/parser/antlr_input.cpp b/src/parser/antlr_input.cpp index ac9417197..a818f4148 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 CVC5; -using namespace CVC5::parser; -using namespace CVC5::kind; +using namespace cvc5; +using namespace cvc5::parser; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace parser { // These functions exactly wrap the antlr3 source inconsistencies. @@ -582,4 +582,4 @@ void AntlrInput::setAntlr3Parser(pANTLR3_PARSER pParser) { } } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/antlr_input.h b/src/parser/antlr_input.h index de0d563ef..c7cb60af7 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 CVC5 { +namespace cvc5 { namespace parser { /** Wrapper around an ANTLR3 input stream. */ @@ -292,6 +292,6 @@ inline BitVector AntlrInput::tokenToBitvector(pANTLR3_COMMON_TOKEN number, pANTL } } // namespace parser -} // namespace CVC5 +} // 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 98c071ed3..bceaa5586 100644 --- a/src/parser/antlr_input_imports.cpp +++ b/src/parser/antlr_input_imports.cpp @@ -60,7 +60,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace parser { /// Report a recognition problem. @@ -436,4 +436,4 @@ AntlrInput::nextToken (pANTLR3_TOKEN_SOURCE toksource) } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/antlr_line_buffered_input.cpp b/src/parser/antlr_line_buffered_input.cpp index 66ebff7b3..1dd7c953c 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 CVC5 { +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)); - CVC5::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM line_buffered_input = - (CVC5::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)); - CVC5::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM line_buffered_input = - (CVC5::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(!((CVC5::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)); @@ -412,4 +412,4 @@ static pANTLR3_INPUT_STREAM antlr3CreateLineBufferedStream( } } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/antlr_line_buffered_input.h b/src/parser/antlr_line_buffered_input.h index 0699c16d0..d687550a4 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 CVC5 { +namespace cvc5 { namespace parser { typedef struct ANTLR3_LINE_BUFFERED_INPUT_STREAM { @@ -45,6 +45,6 @@ pANTLR3_INPUT_STREAM antlr3LineBufferedStreamNew(std::istream& in, LineBuffer* line_buffer); } // namespace parser -} // namespace CVC5 +} // 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 d1b0ea20b..af4ee4d41 100644 --- a/src/parser/bounded_token_buffer.cpp +++ b/src/parser/bounded_token_buffer.cpp @@ -57,7 +57,7 @@ #include "base/check.h" -namespace CVC5 { +namespace cvc5 { namespace parser { #ifdef ANTLR3_WINDOWS @@ -526,4 +526,4 @@ getSourceName (pANTLR3_INT_STREAM is) } } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/bounded_token_buffer.h b/src/parser/bounded_token_buffer.h index c6599b5af..79bfe0d40 100644 --- a/src/parser/bounded_token_buffer.h +++ b/src/parser/bounded_token_buffer.h @@ -30,7 +30,7 @@ #include <antlr3defs.h> -namespace CVC5 { +namespace cvc5 { namespace parser { #ifdef __cplusplus @@ -59,6 +59,6 @@ BoundedTokenBufferFree(pBOUNDED_TOKEN_BUFFER buffer); #endif } // namespace parser -} // namespace CVC5 +} // 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 f7f8a245f..aceff0de4 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 CVC5 { +namespace cvc5 { namespace parser { static pANTLR3_COMMON_TOKEN @@ -141,4 +141,4 @@ setInputStream (pANTLR3_TOKEN_FACTORY factory, pANTLR3_INPUT_STREAM input) } } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/bounded_token_factory.h b/src/parser/bounded_token_factory.h index 0f29bbb99..3aa347d52 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 CVC5 { +namespace cvc5 { namespace parser { #ifdef __cplusplus @@ -46,6 +46,6 @@ BoundedTokenFactoryNew(pANTLR3_INPUT_STREAM input,ANTLR3_UINT32 size); #endif } // namespace parser -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PARSER__BOUNDED_TOKEN_FACTORY_H */ diff --git a/src/parser/cvc/Cvc.g b/src/parser/cvc/Cvc.g index 2ed1a924c..0b27b45fa 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() */ -CVC5::api::Term createPrecedenceTree(Parser* parser, api::Solver* solver, - const std::vector<CVC5::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 @@ CVC5::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); - CVC5::api::Term lhs = createPrecedenceTree( + cvc5::api::Term lhs = createPrecedenceTree( parser, solver, expressions, operators, startIndex, pivot); - CVC5::api::Term rhs = createPrecedenceTree( + cvc5::api::Term rhs = createPrecedenceTree( parser, solver, expressions, operators, pivot + 1, stopIndex); if (lhs.getSort().isSet()) @@ -477,7 +477,7 @@ CVC5::api::Term createPrecedenceTree(Parser* parser, api::Solver* solver, }/* createPrecedenceTree() recursive variant */ api::Term createPrecedenceTree(Parser* parser, api::Solver* s, - const std::vector<CVC5::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 CVC5 { +namespace cvc5 { class Expr; }/* CVC4 namespace */ @@ -582,8 +582,8 @@ namespace CVC5 { }); \ }) -using namespace CVC5; -using namespace CVC5::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 CVC5::parser; * Parses an expression. * @return the parsed expression */ -parseExpr returns [CVC5::api::Term expr = CVC5::api::Term()] +parseExpr returns [cvc5::api::Term expr = cvc5::api::Term()] : formula[expr] | EOF ; @@ -620,9 +620,9 @@ parseExpr returns [CVC5::api::Term expr = CVC5::api::Term()] * Parses a command (the whole benchmark) * @return the command of the benchmark */ -parseCommand returns [CVC5::Command* cmd_return = NULL] +parseCommand returns [cvc5::Command* cmd_return = NULL] @declarations { - std::unique_ptr<CVC5::Command> cmd; + std::unique_ptr<cvc5::Command> cmd; } @after { cmd_return = cmd.release(); @@ -652,7 +652,7 @@ parseCommand returns [CVC5::Command* cmd_return = NULL] * Matches a command of the input. If a declaration, it will return an empty * command. */ -command [std::unique_ptr<CVC5::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<CVC5::Command>* cmd] } ; -typeOrVarLetDecl[CVC5::parser::DeclarationCheck check] +typeOrVarLetDecl[cvc5::parser::DeclarationCheck check] options { backtrack = true; } : letDecl | typeLetDecl[check] ; -mainCommand[std::unique_ptr<CVC5::Command>* cmd] +mainCommand[std::unique_ptr<cvc5::Command>* cmd] @init { api::Term f; api::Term sexpr; std::string id; api::Sort t; - std::vector<CVC5::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<CVC5::Command>* cmd] std::vector<api::Term> formulas; std::vector<std::vector<api::Term>> formals; std::vector<std::string> ids; - std::vector<CVC5::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[CVC5::api::Term& sexpr] +symbolicExpr[cvc5::api::Term& sexpr] @declarations { std::string s; std::vector<api::Term> children; @@ -961,13 +961,13 @@ symbolicExpr[CVC5::api::Term& sexpr] : simpleSymbolicExpr[s] { sexpr = SOLVER->mkString(PARSER_STATE->processAdHocStringEsc(s)); } | LPAREN (symbolicExpr[sexpr] { children.push_back(sexpr); } )* RPAREN - { sexpr = SOLVER->mkTerm(CVC5::api::SEXPR, children); } + { sexpr = SOLVER->mkTerm(cvc5::api::SEXPR, children); } ; /** * Match a top-level declaration. */ -toplevelDeclaration[std::unique_ptr<CVC5::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<CVC5::Command>* cmd] /** * A bound variable declaration. */ -boundVarDecl[std::vector<std::string>& ids, CVC5::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<CVC5::api::Term>& terms, - std::vector<CVC5::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<CVC5::api::Term>& terms, : boundVarDeclReturn[terms,types] ( COMMA boundVarDeclReturn[terms,types] )* ; -boundVarDeclReturn[std::vector<CVC5::api::Term>& terms, - std::vector<CVC5::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<CVC5::api::Term>& terms, * because type declarations are always top-level, except for * type-lets, which don't use this rule. */ -declareTypes[std::unique_ptr<CVC5::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<CVC5::Command>* cmd, * permitted and "cmd" is output. If topLevel is false, bound vars * are created */ -declareVariables[std::unique_ptr<CVC5::Command>* cmd, CVC5::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<CVC5::Command>* cmd, CVC5::api::Sort& t, * @param check what kinds of check to perform on the symbols */ identifierList[std::vector<std::string>& idList, - CVC5::parser::DeclarationCheck check, - CVC5::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, - CVC5::parser::DeclarationCheck check, - CVC5::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[CVC5::api::Sort& t, - CVC5::parser::DeclarationCheck check] +type[cvc5::api::Sort& t, + cvc5::parser::DeclarationCheck check] @init { api::Sort t2; bool lhs; @@ -1244,8 +1244,8 @@ type[CVC5::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[CVC5::api::Sort& t, - CVC5::parser::DeclarationCheck check] +restrictedType[cvc5::api::Sort& t, + cvc5::parser::DeclarationCheck check] @init { bool lhs; } @@ -1257,8 +1257,8 @@ restrictedType[CVC5::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[CVC5::api::Sort& t, - CVC5::parser::DeclarationCheck check, +restrictedTypePossiblyFunctionLHS[cvc5::api::Sort& t, + cvc5::parser::DeclarationCheck check, bool& lhs] @init { api::Sort t2; @@ -1369,8 +1369,8 @@ restrictedTypePossiblyFunctionLHS[CVC5::api::Sort& t, } ; -parameterization[CVC5::parser::DeclarationCheck check, - std::vector<CVC5::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[CVC5::parser::DeclarationCheck check] +typeLetDecl[cvc5::parser::DeclarationCheck check] @init { api::Sort t; std::string id; @@ -1399,11 +1399,11 @@ typeLetDecl[CVC5::parser::DeclarationCheck check] * * @return the expression representing the formula/term */ -formula[CVC5::api::Term& f] +formula[cvc5::api::Term& f] @init { Debug("parser-extra") << "formula: " << AntlrInput::tokenText(LT(1)) << std::endl; api::Term f2; - std::vector<CVC5::api::Term> expressions; + std::vector<cvc5::api::Term> expressions; std::vector<unsigned> operators; unsigned op; } @@ -1421,7 +1421,7 @@ formula[CVC5::api::Term& f] ) ; -morecomparisons[std::vector<CVC5::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[CVC5::api::Term& f] +prefixFormula[cvc5::api::Term& f] @init { std::vector<std::string> ids; std::vector<api::Term> terms; @@ -1499,7 +1499,7 @@ prefixFormula[CVC5::api::Term& f] } ; -instantiationPatterns[ CVC5::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[CVC5::api::Term& f] +comparison[cvc5::api::Term& f] @init { - std::vector<CVC5::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[CVC5::api::Term& f] +term[cvc5::api::Term& f] @init { - std::vector<CVC5::api::Term> expressions; + std::vector<cvc5::api::Term> expressions; std::vector<unsigned> operators; unsigned op; api::Sort t; @@ -1607,24 +1607,24 @@ term[CVC5::api::Term& f] * Parses just part of the array assignment (and constructs * the store terms). */ -arrayStore[CVC5::api::Term& f] +arrayStore[cvc5::api::Term& f] @init { api::Term f2, k; } : LBRACKET formula[k] RBRACKET - { f2 = MK_TERM(CVC5::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(CVC5::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[CVC5::api::Term& f] +tupleStore[cvc5::api::Term& f] @init { api::Term f2; } @@ -1654,7 +1654,7 @@ tupleStore[CVC5::api::Term& f] * Parses just part of the record assignment (and constructs * the store terms). */ -recordStore[CVC5::api::Term& f] +recordStore[cvc5::api::Term& f] @init { std::string id; api::Term f2; @@ -1680,7 +1680,7 @@ recordStore[CVC5::api::Term& f] ; /** Parses a unary minus term. */ -uminusTerm[CVC5::api::Term& f] +uminusTerm[cvc5::api::Term& f] @init { unsigned minusCount = 0; } @@ -1690,14 +1690,14 @@ uminusTerm[CVC5::api::Term& f] while (minusCount > 0) { --minusCount; - f = MK_TERM(CVC5::api::UMINUS, f); + f = MK_TERM(cvc5::api::UMINUS, f); } }; /** Parses bitvectors. Starts with binary operators @, &, and |. */ -bvBinaryOpTerm[CVC5::api::Term& f] +bvBinaryOpTerm[cvc5::api::Term& f] @init { - std::vector<CVC5::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[CVC5::api::Term& f] +bvNegTerm[cvc5::api::Term& f] /* BV neg */ : BVNEG_TOK bvNegTerm[f] { - f = f.getSort().isSet() ? MK_TERM(CVC5::api::COMPLEMENT, f) - : MK_TERM(CVC5::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[CVC5::api::Term& f] +relationBinopTerm[cvc5::api::Term& f] @init { - std::vector<CVC5::api::Term> expressions; + std::vector<cvc5::api::Term> expressions; std::vector<unsigned> operators; unsigned op; } @@ -1753,7 +1753,7 @@ relationBinopTerm[CVC5::api::Term& f] * brackets ], so we left-factor as much out as possible to make ANTLR * happy. */ -postfixTerm[CVC5::api::Term& f] +postfixTerm[cvc5::api::Term& f] @init { api::Term f2; bool extract = false, left = false; @@ -1772,7 +1772,7 @@ postfixTerm[CVC5::api::Term& f] f = SOLVER->mkTerm(SOLVER->mkOp(api::BITVECTOR_EXTRACT,k1,k2), f); } else { /* array select */ - f = MK_TERM(CVC5::api::SELECT, f, f2); + f = MK_TERM(cvc5::api::SELECT, f, f2); } } /* left- or right-shift */ @@ -1834,19 +1834,19 @@ postfixTerm[CVC5::api::Term& f] ) )* | FLOOR_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::TO_INTEGER, f); } + { f = MK_TERM(cvc5::api::TO_INTEGER, f); } | IS_INTEGER_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::IS_INTEGER, f); } + { f = MK_TERM(cvc5::api::IS_INTEGER, f); } | ABS_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::ABS, f); } + { f = MK_TERM(cvc5::api::ABS, f); } | DIVISIBLE_TOK LPAREN formula[f] COMMA n=numeral RPAREN - { f = MK_TERM(SOLVER->mkOp(CVC5::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(CVC5::api::DISTINCT, args); + : MK_TERM(cvc5::api::DISTINCT, args); } ) ( typeAscription[f, t] @@ -1856,12 +1856,12 @@ postfixTerm[CVC5::api::Term& f] )? ; -relationTerm[CVC5::api::Term& f] +relationTerm[cvc5::api::Term& f] /* relation terms */ : TRANSPOSE_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::TRANSPOSE, f); } + { f = MK_TERM(cvc5::api::TRANSPOSE, f); } | TRANSCLOSURE_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::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[CVC5::api::Term& f] f = MK_TERM(api::APPLY_CONSTRUCTOR, args); } | IDEN_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::IDEN, f); } + { f = MK_TERM(cvc5::api::IDEN, f); } | bvTerm[f] ; -bvTerm[CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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[CVC5::api::Term& f] for (unsigned i = 0; i < args.size(); ++ i) { ENSURE_BV_SIZE(k, args[i]); } - f = MK_TERM(CVC5::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[CVC5::api::Term& f] } ENSURE_BV_SIZE(k, f); ENSURE_BV_SIZE(k, f2); - f = MK_TERM(CVC5::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[CVC5::api::Term& f] } ENSURE_BV_SIZE(k, f); ENSURE_BV_SIZE(k, f2); - f = MK_TERM(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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[CVC5::api::Term& f] /* BV comparisons */ | BVLT_TOK LPAREN formula[f] COMMA formula[f2] RPAREN - { f = MK_TERM(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::api::BITVECTOR_SGE, f, f2); } + { f = MK_TERM(cvc5::api::BITVECTOR_SGE, f, f2); } | stringTerm[f] ; -stringTerm[CVC5::api::Term& f] +stringTerm[cvc5::api::Term& f] @init { api::Term f2; api::Term f3; @@ -2011,67 +2011,67 @@ stringTerm[CVC5::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(CVC5::api::STRING_CONCAT, args); } + { f = MK_TERM(cvc5::api::STRING_CONCAT, args); } | STRING_LENGTH_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::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(CVC5::api::STRING_SUFFIX, f, f2); } + { f = MK_TERM(cvc5::api::STRING_SUFFIX, f, f2); } | STRING_STOI_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::STRING_TO_INT, f); } + { f = MK_TERM(cvc5::api::STRING_TO_INT, f); } | STRING_ITOS_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::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(CVC5::api::STRING_TO_REGEXP, f); } + { f = MK_TERM(cvc5::api::STRING_TO_REGEXP, f); } | STRING_TOLOWER_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::STRING_TOLOWER, f); } + { f = MK_TERM(cvc5::api::STRING_TOLOWER, f); } | STRING_TOUPPER_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::STRING_TOUPPER, f); } + { f = MK_TERM(cvc5::api::STRING_TOUPPER, f); } | STRING_REV_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::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(CVC5::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(CVC5::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(CVC5::api::REGEXP_INTER, args); } + { f = MK_TERM(cvc5::api::REGEXP_INTER, args); } | REGEXP_STAR_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::REGEXP_STAR, f); } + { f = MK_TERM(cvc5::api::REGEXP_STAR, f); } | REGEXP_PLUS_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::REGEXP_PLUS, f); } + { f = MK_TERM(cvc5::api::REGEXP_PLUS, f); } | REGEXP_OPT_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::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(CVC5::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(CVC5::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(CVC5::api::REGEXP_COMPLEMENT, f); } + { f = MK_TERM(cvc5::api::REGEXP_COMPLEMENT, f); } | SEQ_UNIT_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::SEQ_UNIT, f); } + { f = MK_TERM(cvc5::api::SEQ_UNIT, f); } | REGEXP_EMPTY_TOK - { f = MK_TERM(CVC5::api::REGEXP_EMPTY, std::vector<api::Term>()); } + { f = MK_TERM(cvc5::api::REGEXP_EMPTY, std::vector<api::Term>()); } | REGEXP_SIGMA_TOK - { f = MK_TERM(CVC5::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[CVC5::api::Term& f] | setsTerm[f] ; -setsTerm[CVC5::api::Term& f] +setsTerm[cvc5::api::Term& f] @init { } /* Sets prefix operators */ : SETS_CARD_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::CARD, f); } + { f = MK_TERM(cvc5::api::CARD, f); } | SETS_CHOOSE_TOK LPAREN formula[f] RPAREN - { f = MK_TERM(CVC5::api::CHOOSE, f); } + { f = MK_TERM(cvc5::api::CHOOSE, f); } | simpleTerm[f] ; /** Parses a simple term. */ -simpleTerm[CVC5::api::Term& f] +simpleTerm[cvc5::api::Term& f] @init { std::string name; std::vector<api::Term> args; @@ -2234,7 +2234,7 @@ simpleTerm[CVC5::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(CVC5::api::APPLY_CONSTRUCTOR, f); + f = MK_TERM(cvc5::api::APPLY_CONSTRUCTOR, f); } } ; @@ -2243,7 +2243,7 @@ simpleTerm[CVC5::api::Term& f] * Matches a type ascription. * The f arg is the term to check (it is an input-only argument). */ -typeAscription[const CVC5::api::Term& f, CVC5::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 CVC5::api::Term& f, CVC5::api::Sort& t] /** * Matches an entry in a record literal. */ -recordEntry[std::string& name, CVC5::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[CVC5::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[CVC5::api::Term& f] THEN_TOK formula[f] { args.push_back(f); } iteElseTerm[f] { args.push_back(f); } ENDIF_TOK - { f = MK_TERM(CVC5::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[CVC5::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[CVC5::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(CVC5::api::ITE, args); } + { f = MK_TERM(cvc5::api::ITE, args); } ; /** * Parses a datatype definition */ -datatypeDef[std::vector<CVC5::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<CVC5::api::DatatypeDecl>& datatypes] /** * Parses a constructor defintion for type */ -constructorDef[CVC5::api::DatatypeDecl& type] +constructorDef[cvc5::api::DatatypeDecl& type] @init { std::string id; - std::unique_ptr<CVC5::api::DatatypeConstructorDecl> ctor; + std::unique_ptr<cvc5::api::DatatypeConstructorDecl> ctor; } : identifier[id,CHECK_UNDECLARED,SYM_SORT] { - ctor.reset(new CVC5::api::DatatypeConstructorDecl( + ctor.reset(new cvc5::api::DatatypeConstructorDecl( SOLVER->mkDatatypeConstructorDecl(id))); } ( LPAREN @@ -2345,7 +2345,7 @@ constructorDef[CVC5::api::DatatypeDecl& type] } ; -selector[std::unique_ptr<CVC5::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 [CVC5::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 3cd486981..a115fa276 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/parser/cvc/cvc.h b/src/parser/cvc/cvc.h index c36e36979..acfcc1d17 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 CVC5 { +namespace cvc5 { namespace parser { @@ -48,6 +48,6 @@ class Cvc : public Parser }; } // namespace parser -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PARSER__CVC_H */ diff --git a/src/parser/cvc/cvc_input.cpp b/src/parser/cvc/cvc_input.cpp index a4a9c27f2..f746c5f05 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 CVC5 { +namespace cvc5 { namespace parser { /* Use lookahead=3 */ @@ -73,4 +73,4 @@ pANTLR3_LEXER CvcInput::getLexer() { */ } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/cvc/cvc_input.h b/src/parser/cvc/cvc_input.h index c9862916a..82b2d652c 100644 --- a/src/parser/cvc/cvc_input.h +++ b/src/parser/cvc/cvc_input.h @@ -23,10 +23,10 @@ #include "parser/cvc/CvcLexer.h" #include "parser/cvc/CvcParser.h" -// extern void CvcParserSetAntlrParser(CVC5::parser::AntlrParser* +// extern void CvcParserSetAntlrParser(cvc5::parser::AntlrParser* // newAntlrParser); -namespace CVC5 { +namespace cvc5 { class Command; class Expr; @@ -73,6 +73,6 @@ class CvcInput : public AntlrInput { }; // class CvcInput } // namespace parser -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PARSER__CVC_INPUT_H */ diff --git a/src/parser/input.cpp b/src/parser/input.cpp index d0c71bd13..8c9519022 100644 --- a/src/parser/input.cpp +++ b/src/parser/input.cpp @@ -25,11 +25,11 @@ using namespace std; -using namespace CVC5; -using namespace CVC5::parser; -using namespace CVC5::kind; +using namespace cvc5; +using namespace cvc5::parser; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace parser { InputStreamException::InputStreamException(const std::string& msg) : @@ -80,4 +80,4 @@ Input* Input::newStringInput(InputLanguage lang, } } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/input.h b/src/parser/input.h index 2a401521c..fcaa36932 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 CVC5 { +namespace cvc5 { class Command; @@ -177,6 +177,6 @@ class CVC4_EXPORT Input }; /* class Input */ } // namespace parser -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PARSER__ANTLR_INPUT_H */ diff --git a/src/parser/line_buffer.cpp b/src/parser/line_buffer.cpp index 1675d8f99..694478d38 100644 --- a/src/parser/line_buffer.cpp +++ b/src/parser/line_buffer.cpp @@ -22,7 +22,7 @@ #include "base/check.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/parser/line_buffer.h b/src/parser/line_buffer.h index 3625ade87..a8a4e993c 100644 --- a/src/parser/line_buffer.h +++ b/src/parser/line_buffer.h @@ -25,7 +25,7 @@ #include <istream> #include <vector> -namespace CVC5 { +namespace cvc5 { namespace parser { class LineBuffer { @@ -71,6 +71,6 @@ class LineBuffer { }; } // namespace parser -} // namespace CVC5 +} // 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 04a2ef2eb..4259e328f 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 CVC5 { +namespace cvc5 { namespace parser { extern "C" { @@ -130,4 +130,4 @@ void UnmapFile(pANTLR3_INPUT_STREAM input) { }/* extern "C" */ } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/memory_mapped_input_buffer.h b/src/parser/memory_mapped_input_buffer.h index 31f15d459..96009674e 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 CVC5 { +namespace cvc5 { namespace parser { #ifdef __cplusplus @@ -37,6 +37,6 @@ MemoryMappedInputBufferNew(const std::string& filename); #endif } // namespace parser -} // namespace CVC5 +} // 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 377958ecd..0d024da61 100644 --- a/src/parser/parse_op.cpp +++ b/src/parser/parse_op.cpp @@ -14,7 +14,7 @@ #include "parser/parse_op.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/parser/parse_op.h b/src/parser/parse_op.h index 1c508a92e..1163ab6be 100644 --- a/src/parser/parse_op.h +++ b/src/parser/parse_op.h @@ -21,7 +21,7 @@ #include "api/cvc4cpp.h" -namespace CVC5 { +namespace cvc5 { /** A parsed operator * @@ -79,6 +79,6 @@ struct ParseOp std::ostream& operator<<(std::ostream& os, const ParseOp& p); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PARSER__PARSE_OP_H */ diff --git a/src/parser/parser.cpp b/src/parser/parser.cpp index a4268e74e..6725b5ec7 100644 --- a/src/parser/parser.cpp +++ b/src/parser/parser.cpp @@ -33,9 +33,9 @@ #include "smt/command.h" using namespace std; -using namespace CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace parser { Parser::Parser(api::Solver* solver, @@ -909,4 +909,4 @@ api::Term Parser::mkStringConstant(const std::string& s) } } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/parser.h b/src/parser/parser.h index 0ae63cdd1..173b98a9c 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 CVC5 { +namespace cvc5 { // Forward declarations class Command; @@ -774,6 +774,6 @@ public: }; /* class Parser */ } // namespace parser -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PARSER__PARSER_STATE_H */ diff --git a/src/parser/parser_builder.cpp b/src/parser/parser_builder.cpp index ffd993383..b0b6a03e7 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 CVC5 { +namespace cvc5 { namespace parser { ParserBuilder::ParserBuilder(api::Solver* solver, @@ -218,4 +218,4 @@ ParserBuilder& ParserBuilder::withStringInput(const std::string& input) { } } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/parser_builder.h b/src/parser/parser_builder.h index 8ec59d4b2..0575dd21d 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 CVC5 { +namespace cvc5 { namespace api { class Solver; @@ -189,6 +189,6 @@ class CVC4_EXPORT ParserBuilder }; /* class ParserBuilder */ } // namespace parser -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PARSER__PARSER_BUILDER_H */ diff --git a/src/parser/parser_exception.h b/src/parser/parser_exception.h index 1863b39cd..7fcbce213 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 CVC5 { +namespace cvc5 { namespace parser { class CVC4_EXPORT ParserException : public Exception @@ -100,6 +100,6 @@ class ParserEndOfFileException : public ParserException }; /* class ParserEndOfFileException */ } // namespace parser -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PARSER__PARSER_EXCEPTION_H */ diff --git a/src/parser/smt2/Smt2.g b/src/parser/smt2/Smt2.g index e55cbf510..6adc6275a 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 CVC5; -using namespace CVC5::parser; +using namespace cvc5; +using namespace cvc5::parser; #undef PARSER_STATE #define PARSER_STATE ((Smt2*)LEXER->super) @@ -83,7 +83,7 @@ using namespace CVC5::parser; #include "parser/parser.h" #include "smt/command.h" -namespace CVC5 { +namespace cvc5 { namespace api { class Term; @@ -113,8 +113,8 @@ namespace CVC5 { #include "util/integer.h" #include "util/rational.h" -using namespace CVC5; -using namespace CVC5::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 CVC5::parser; * @return the parsed expression, or the Null Expr if we've reached the * end of the input */ -parseExpr returns [CVC5::api::Term expr = CVC5::api::Term()] +parseExpr returns [cvc5::api::Term expr = cvc5::api::Term()] @declarations { - CVC5::api::Term expr2; + cvc5::api::Term expr2; } : term[expr, expr2] | EOF @@ -148,9 +148,9 @@ parseExpr returns [CVC5::api::Term expr = CVC5::api::Term()] * Parses a command * @return the parsed command, or NULL if we've reached the end of the input */ -parseCommand returns [CVC5::Command* cmd_return = NULL] +parseCommand returns [cvc5::Command* cmd_return = NULL] @declarations { - std::unique_ptr<CVC5::Command> cmd; + std::unique_ptr<cvc5::Command> cmd; std::string name; } @after { @@ -184,7 +184,7 @@ parseCommand returns [CVC5::Command* cmd_return = NULL] * @return the parsed SyGuS command, or NULL if we've reached the end of the * input */ -parseSygus returns [CVC5::Command* cmd_return = NULL] +parseSygus returns [cvc5::Command* cmd_return = NULL] @declarations { std::string name; } @@ -199,16 +199,16 @@ parseSygus returns [CVC5::Command* cmd_return = NULL] * Parse the internal portion of the command, ignoring the surrounding * parentheses. */ -command [std::unique_ptr<CVC5::Command>* cmd] +command [std::unique_ptr<cvc5::Command>* cmd] @declarations { std::string name; std::vector<std::string> names; - CVC5::api::Term expr, expr2; - CVC5::api::Sort t; - std::vector<CVC5::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, CVC5::api::Sort> > sortedVarNames; - std::vector<CVC5::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<CVC5::Command>* cmd] } ; -sygusCommand returns [std::unique_ptr<CVC5::Command> cmd] +sygusCommand returns [std::unique_ptr<cvc5::Command> cmd] @declarations { - CVC5::api::Term expr, expr2, fun; - CVC5::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, CVC5::api::Sort> > sortedVarNames; - std::vector<CVC5::api::Term> sygusVars; + std::vector<std::pair<std::string, cvc5::api::Sort> > sortedVarNames; + std::vector<cvc5::api::Term> sygusVars; std::string name; bool isInv; - CVC5::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<CVC5::Command> cmd] * The argument fun is a unique identifier to avoid naming clashes for the * datatypes constructed by this call. */ -sygusGrammar[CVC5::api::Grammar*& ret, - const std::vector<CVC5::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, CVC5::api::Sort>> sortedVarNames; + std::vector<std::pair<std::string, cvc5::api::Sort>> sortedVarNames; // non-terminal symbols of the grammar - std::vector<CVC5::api::Term> ntSyms; - CVC5::api::Sort t; + std::vector<cvc5::api::Term> ntSyms; + cvc5::api::Sort t; std::string name; - CVC5::api::Term e, e2; + cvc5::api::Term e, e2; unsigned dtProcessed = 0; } : @@ -710,7 +710,7 @@ sygusGrammar[CVC5::api::Grammar*& ret, } ; -setInfoInternal[std::unique_ptr<CVC5::Command>* cmd] +setInfoInternal[std::unique_ptr<cvc5::Command>* cmd] @declarations { std::string name; api::Term sexpr; @@ -721,7 +721,7 @@ setInfoInternal[std::unique_ptr<CVC5::Command>* cmd] } ; -setOptionInternal[std::unique_ptr<CVC5::Command>* cmd] +setOptionInternal[std::unique_ptr<cvc5::Command>* cmd] @init { std::string name; api::Term sexpr; @@ -738,26 +738,26 @@ setOptionInternal[std::unique_ptr<CVC5::Command>* cmd] } ; -smt25Command[std::unique_ptr<CVC5::Command>* cmd] +smt25Command[std::unique_ptr<cvc5::Command>* cmd] @declarations { std::string name; std::string fname; - CVC5::api::Term expr, expr2; - std::vector<std::pair<std::string, CVC5::api::Sort> > sortedVarNames; + cvc5::api::Term expr, expr2; + std::vector<std::pair<std::string, cvc5::api::Sort> > sortedVarNames; std::string s; - 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>>> + 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<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<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<CVC5::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<CVC5::Command>* cmd] } ; -extendedCommand[std::unique_ptr<CVC5::Command>* cmd] +extendedCommand[std::unique_ptr<cvc5::Command>* cmd] @declarations { std::vector<api::DatatypeDecl> dts; - CVC5::api::Term e, e2; - CVC5::api::Sort t, s; + cvc5::api::Term e, e2; + cvc5::api::Sort t, s; std::string name; std::vector<std::string> names; - std::vector<CVC5::api::Term> terms; + std::vector<cvc5::api::Term> terms; std::vector<api::Sort> sorts; - std::vector<std::pair<std::string, CVC5::api::Sort> > sortedVarNames; - std::unique_ptr<CVC5::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<CVC5::Command>* cmd] { PARSER_STATE->checkThatLogicIsSet(); PARSER_STATE->checkLogicAllowsFreeSorts(); - seq.reset(new CVC5::CommandSequence()); + seq.reset(new cvc5::CommandSequence()); } LPAREN_TOK ( symbol[name,CHECK_UNDECLARED,SYM_SORT] @@ -917,7 +917,7 @@ extendedCommand[std::unique_ptr<CVC5::Command>* cmd] { cmd->reset(seq.release()); } | DECLARE_FUNS_TOK { PARSER_STATE->checkThatLogicIsSet(); } - { seq.reset(new CVC5::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<CVC5::Command>* cmd] RPAREN_TOK { cmd->reset(seq.release()); } | DECLARE_PREDS_TOK { PARSER_STATE->checkThatLogicIsSet(); } - { seq.reset(new CVC5::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<CVC5::Command>* cmd] ) ; -datatypeDefCommand[bool isCo, std::unique_ptr<CVC5::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<CVC5::Command>* cmd] datatypesDef[isCo, dnames, arities, cmd] ; -datatypesDefCommand[bool isCo, std::unique_ptr<CVC5::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<CVC5::Command>* cmd] datatypesDef[bool isCo, const std::vector<std::string>& dnames, const std::vector<int>& arities, - std::unique_ptr<CVC5::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[CVC5::api::Term& sexpr] +symbolicExpr[cvc5::api::Term& sexpr] @declarations { std::string s; std::vector<api::Term> children; @@ -1248,19 +1248,19 @@ symbolicExpr[CVC5::api::Term& sexpr] { sexpr = SOLVER->mkString(PARSER_STATE->processAdHocStringEsc(s)); } | LPAREN_TOK ( symbolicExpr[sexpr] { children.push_back(sexpr); } )* RPAREN_TOK - { sexpr = SOLVER->mkTerm(CVC5::api::SEXPR, children); } + { sexpr = SOLVER->mkTerm(cvc5::api::SEXPR, children); } ; /** * Matches a term. * @return the expression representing the term. */ -term[CVC5::api::Term& expr, CVC5::api::Term& expr2] +term[cvc5::api::Term& expr, cvc5::api::Term& expr2] @init { api::Kind kind = api::NULL_EXPR; - CVC5::api::Term f; + cvc5::api::Term f; std::string name; - CVC5::api::Sort type; + cvc5::api::Sort type; ParseOp p; } : termNonVariable[expr, expr2] @@ -1278,23 +1278,23 @@ term[CVC5::api::Term& expr, CVC5::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[CVC5::api::Term& expr, CVC5::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<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::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; - CVC5::api::Term attexpr; - std::vector<CVC5::api::Term> patexprs; - std::vector<CVC5::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, CVC5::api::Term> > binders; - CVC5::api::Sort type; - CVC5::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[CVC5::api::Term& expr, CVC5::api::Term& expr2] )* RPAREN_TOK term[f3, f2] { // make the match case - std::vector<CVC5::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[CVC5::api::Term& expr, CVC5::api::Term& expr2] * expression (3), which may involve disambiguating f based on type T if it is * overloaded. */ -qualIdentifier[CVC5::ParseOp& p] +qualIdentifier[cvc5::ParseOp& p] @init { api::Kind k; std::string baseName; - CVC5::api::Term f; - CVC5::api::Sort type; + cvc5::api::Term f; + cvc5::api::Sort type; } : identifier[p] | LPAREN_TOK AS_TOK @@ -1608,10 +1608,10 @@ qualIdentifier[CVC5::ParseOp& p] * (3) An expression expr. * For examples, see documentation of qualIdentifier. */ -identifier[CVC5::ParseOp& p] +identifier[cvc5::ParseOp& p] @init { - CVC5::api::Term f; - CVC5::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[CVC5::ParseOp& p] * Matches an atomic term (a term with no subterms). * @return the expression expr representing the term or formula. */ -termAtomic[CVC5::api::Term& atomTerm] +termAtomic[cvc5::api::Term& atomTerm] @init { - CVC5::api::Sort type; - CVC5::api::Sort type2; + cvc5::api::Sort type; + cvc5::api::Sort type2; std::string s; std::vector<uint64_t> numerals; } @@ -1746,13 +1746,13 @@ termAtomic[CVC5::api::Term& atomTerm] /** * Read attribute */ -attribute[CVC5::api::Term& expr, CVC5::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; - CVC5::api::Term patexpr; - std::vector<CVC5::api::Term> patexprs; - CVC5::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[CVC5::api::Term& expr, CVC5::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 CVC5::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 CVC5::api::Term in here just to avoid allocating a fresh CVC5::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<CVC5::api::Term>& formulas, CVC5::api::Term& expr] +termList[std::vector<cvc5::api::Term>& formulas, cvc5::api::Term& expr] @declarations { - CVC5::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[CVC5::api::Kind& kind] +quantOp[cvc5::api::Kind& kind] @init { Debug("parser") << "quant: " << AntlrInput::tokenText(LT(1)) << std::endl; } @@ -1884,7 +1884,7 @@ quantOp[CVC5::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, CVC5::parser::DeclarationCheck check] +functionName[std::string& name, cvc5::parser::DeclarationCheck check] : symbol[name,check,SYM_VARIABLE] ; @@ -1892,16 +1892,16 @@ functionName[std::string& name, CVC5::parser::DeclarationCheck check] * Matches a sequence of sort symbols and fills them into the given * vector. */ -sortList[std::vector<CVC5::api::Sort>& sorts] +sortList[std::vector<cvc5::api::Sort>& sorts] @declarations { - CVC5::api::Sort t; + cvc5::api::Sort t; } : ( sortSymbol[t,CHECK_DECLARED] { sorts.push_back(t); } )* ; -nonemptySortList[std::vector<CVC5::api::Sort>& sorts] +nonemptySortList[std::vector<cvc5::api::Sort>& sorts] @declarations { - CVC5::api::Sort t; + cvc5::api::Sort t; } : ( sortSymbol[t,CHECK_DECLARED] { sorts.push_back(t); } )+ ; @@ -1910,10 +1910,10 @@ nonemptySortList[std::vector<CVC5::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, CVC5::api::Sort> >& sortedVars] +sortedVarList[std::vector<std::pair<std::string, cvc5::api::Sort> >& sortedVars] @declarations { std::string name; - CVC5::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, CVC5::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[CVC5::api::Term& expr] +boundVarList[cvc5::api::Term& expr] @declarations { - std::vector<std::pair<std::string, CVC5::api::Sort>> sortedVarNames; + std::vector<std::pair<std::string, cvc5::api::Sort>> sortedVarNames; } : LPAREN_TOK sortedVarList[sortedVarNames] RPAREN_TOK { - std::vector<CVC5::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[CVC5::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, CVC5::parser::DeclarationCheck check] +sortName[std::string& name, cvc5::parser::DeclarationCheck check] : symbol[name,check,SYM_SORT] ; -sortSymbol[CVC5::api::Sort& t, CVC5::parser::DeclarationCheck check] +sortSymbol[cvc5::api::Sort& t, cvc5::parser::DeclarationCheck check] @declarations { std::string name; - std::vector<CVC5::api::Sort> args; + std::vector<cvc5::api::Sort> args; std::vector<uint64_t> numerals; bool indexed = false; } @@ -2070,8 +2070,8 @@ sortSymbol[CVC5::api::Sort& t, CVC5::parser::DeclarationCheck check] * symbol[] rule below. */ symbolList[std::vector<std::string>& names, - CVC5::parser::DeclarationCheck check, - CVC5::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, - CVC5::parser::DeclarationCheck check, - CVC5::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<CVC5::api::DatatypeDecl>& datatypes, - std::vector< CVC5::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<CVC5::api::DatatypeDecl>& datatypes, /** * Parses a constructor defintion for type */ -constructorDef[CVC5::api::DatatypeDecl& type] +constructorDef[cvc5::api::DatatypeDecl& type] @init { std::string id; - CVC5::api::DatatypeConstructorDecl* ctor = NULL; + cvc5::api::DatatypeConstructorDecl* ctor = NULL; } : symbol[id,CHECK_NONE,SYM_VARIABLE] { @@ -2163,10 +2163,10 @@ constructorDef[CVC5::api::DatatypeDecl& type] } ; -selector[CVC5::api::DatatypeConstructorDecl& ctor] +selector[cvc5::api::DatatypeConstructorDecl& ctor] @init { std::string id; - CVC5::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 e05401da0..a1659dcc2 100644 --- a/src/parser/smt2/smt2.cpp +++ b/src/parser/smt2/smt2.cpp @@ -28,7 +28,7 @@ #undef true #undef false -namespace CVC5 { +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 -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/smt2/smt2.h b/src/parser/smt2/smt2.h index ccb6456e7..5ad508868 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 CVC5 { +namespace cvc5 { class Command; @@ -430,6 +430,6 @@ class Smt2 : public Parser }; /* class Smt2 */ } // namespace parser -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PARSER__SMT2_H */ diff --git a/src/parser/smt2/smt2_input.cpp b/src/parser/smt2/smt2_input.cpp index 3d6670469..650d97299 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 CVC5 { +namespace cvc5 { namespace parser { /* Use lookahead=2 */ @@ -68,4 +68,4 @@ api::Term Smt2Input::parseExpr() } } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/smt2/smt2_input.h b/src/parser/smt2/smt2_input.h index 0c5be3f97..1c892909e 100644 --- a/src/parser/smt2/smt2_input.h +++ b/src/parser/smt2/smt2_input.h @@ -23,10 +23,10 @@ #include "parser/smt2/Smt2Lexer.h" #include "parser/smt2/Smt2Parser.h" -// extern void Smt2ParserSetAntlrParser(CVC5::parser::AntlrParser* +// extern void Smt2ParserSetAntlrParser(cvc5::parser::AntlrParser* // newAntlrParser); -namespace CVC5 { +namespace cvc5 { class Command; class Expr; @@ -82,6 +82,6 @@ class Smt2Input : public AntlrInput { };/* class Smt2Input */ } // namespace parser -} // namespace CVC5 +} // 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 bdddd47e8..cc605b842 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 CVC5 { +namespace cvc5 { namespace parser { /* Use lookahead=2 */ @@ -69,4 +69,4 @@ api::Term SygusInput::parseExpr() } } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/smt2/sygus_input.h b/src/parser/smt2/sygus_input.h index 38497dfd2..8ad398cf9 100644 --- a/src/parser/smt2/sygus_input.h +++ b/src/parser/smt2/sygus_input.h @@ -23,10 +23,10 @@ #include "parser/smt2/Smt2Lexer.h" #include "parser/smt2/Smt2Parser.h" -// extern void Smt2ParserSetAntlrParser(CVC5::parser::AntlrParser* +// extern void Smt2ParserSetAntlrParser(cvc5::parser::AntlrParser* // newAntlrParser); -namespace CVC5 { +namespace cvc5 { class Command; class Expr; @@ -82,6 +82,6 @@ class SygusInput : public AntlrInput { };/* class SygusInput */ } // namespace parser -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PARSER__SYGUS_INPUT_H */ diff --git a/src/parser/tptp/Tptp.g b/src/parser/tptp/Tptp.g index 265784d48..030330748 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 CVC5; -using namespace CVC5::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 CVC5::parser; #include "util/integer.h" #include "util/rational.h" -using namespace CVC5; -using namespace CVC5::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 CVC5::parser; /** * Parses an expression. - * @return the parsed expression, or the Null CVC5::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 [CVC5::parser::tptp::myExpr expr] +parseExpr returns [cvc5::parser::tptp::myExpr expr] : cnfFormula[expr] | EOF ; @@ -139,9 +139,9 @@ parseExpr returns [CVC5::parser::tptp::myExpr expr] * Parses a command * @return the parsed command, or NULL if we've reached the end of the input */ -parseCommand returns [CVC5::Command* cmd = NULL] +parseCommand returns [cvc5::Command* cmd = NULL] @declarations { - CVC5::api::Term expr; + cvc5::api::Term expr; Tptp::FormulaRole fr; std::string name, inclSymbol; ParseOp p; @@ -159,7 +159,7 @@ parseCommand returns [CVC5::Command* cmd = NULL] } (COMMA_TOK anything*)? RPAREN_TOK DOT_TOK { - CVC5::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 [CVC5::Command* cmd = NULL] { PARSER_STATE->setCnf(false); PARSER_STATE->setFof(true); } fofFormula[expr] (COMMA_TOK anything*)? RPAREN_TOK DOT_TOK { - CVC5::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 [CVC5::Command* cmd = NULL] { PARSER_STATE->setCnf(false); PARSER_STATE->setFof(false); } tffFormula[expr] (COMMA_TOK anything*)? { - CVC5::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 [CVC5::Command* cmd = NULL] PARSER_STATE->parseError("Top level expression must be a formula"); } expr = p.d_expr; - CVC5::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 [CVC5::Command* cmd = NULL] { CommandSequence* seq = new CommandSequence(); // assert that all distinct constants are distinct - CVC5::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 [CVC5::Command* cmd = NULL] ; /* Parse a formula Role */ -formulaRole[CVC5::parser::Tptp::FormulaRole& role] +formulaRole[cvc5::parser::Tptp::FormulaRole& role] : LOWER_WORD { std::string r = AntlrInput::tokenText($LOWER_WORD); @@ -296,12 +296,12 @@ formulaRole[CVC5::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[CVC5::api::Term& expr] +cnfFormula[cvc5::api::Term& expr] : LPAREN_TOK cnfDisjunction[expr] RPAREN_TOK | cnfDisjunction[expr] ; -cnfDisjunction[CVC5::api::Term& expr] +cnfDisjunction[cvc5::api::Term& expr] @declarations { std::vector<api::Term> args; } @@ -313,16 +313,16 @@ cnfDisjunction[CVC5::api::Term& expr] } ; -cnfLiteral[CVC5::api::Term& expr] +cnfLiteral[cvc5::api::Term& expr] : atomicFormula[expr] | NOT_TOK atomicFormula[expr] { expr = MK_TERM(api::NOT, expr); } ; -atomicFormula[CVC5::api::Term& expr] +atomicFormula[cvc5::api::Term& expr] @declarations { - CVC5::api::Term expr2; + cvc5::api::Term expr2; std::string name; - std::vector<CVC5::api::Term> args; + std::vector<cvc5::api::Term> args; bool equal; ParseOp p; } @@ -386,11 +386,11 @@ atomicFormula[CVC5::api::Term& expr] | definedProp[expr] ; -thfAtomicFormula[CVC5::ParseOp& p] +thfAtomicFormula[cvc5::ParseOp& p] @declarations { - CVC5::api::Term expr2; + cvc5::api::Term expr2; std::string name; - std::vector<CVC5::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[CVC5::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[CVC5::api::Term& expr] +definedProp[cvc5::api::Term& expr] : TRUE_TOK { expr = SOLVER->mkTrue(); } | FALSE_TOK { expr = SOLVER->mkFalse(); } ; -definedPred[CVC5::ParseOp& p] +definedPred[cvc5::ParseOp& p] : '$less' { p.d_kind = api::LT; @@ -497,7 +497,7 @@ definedPred[CVC5::ParseOp& p] } ; -thfDefinedPred[CVC5::ParseOp& p] +thfDefinedPred[cvc5::ParseOp& p] : '$less' { p.d_kind = api::LT; @@ -561,7 +561,7 @@ thfDefinedPred[CVC5::ParseOp& p] RPAREN_TOK ; -definedFun[CVC5::ParseOp& p] +definedFun[cvc5::ParseOp& p] @declarations { bool remainder = false; } @@ -724,16 +724,16 @@ equalOp[bool& equal] | DISEQUAL_TOK { equal = false; } ; -term[CVC5::api::Term& expr] +term[cvc5::api::Term& expr] : functionTerm[expr] | conditionalTerm[expr] | simpleTerm[expr] | letTerm[expr] ; -letTerm[CVC5::api::Term& expr] +letTerm[cvc5::api::Term& expr] @declarations { - CVC5::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[CVC5::api::Term& expr] ; /* Not an application */ -simpleTerm[CVC5::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[CVC5::api::Term& expr] +thfSimpleTerm[cvc5::api::Term& expr] : NUMBER { expr = PARSER_STATE->d_tmp_expr; } | DISTINCT_OBJECT { @@ -768,9 +768,9 @@ thfSimpleTerm[CVC5::api::Term& expr] } ; -functionTerm[CVC5::api::Term& expr] +functionTerm[cvc5::api::Term& expr] @declarations { - std::vector<CVC5::api::Term> args; + std::vector<cvc5::api::Term> args; ParseOp p; } : plainTerm[expr] @@ -780,15 +780,15 @@ functionTerm[CVC5::api::Term& expr] } ; -conditionalTerm[CVC5::api::Term& expr] +conditionalTerm[cvc5::api::Term& expr] @declarations { - CVC5::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[CVC5::api::Term& expr] +plainTerm[cvc5::api::Term& expr] @declarations { std::string name; std::vector<api::Term> args; @@ -801,15 +801,15 @@ plainTerm[CVC5::api::Term& expr] } ; -arguments[std::vector<CVC5::api::Term>& args] +arguments[std::vector<cvc5::api::Term>& args] @declarations { - CVC5::api::Term expr; + cvc5::api::Term expr; } : term[expr] { args.push_back(expr); } ( COMMA_TOK term[expr] { args.push_back(expr); } )* ; -variable[CVC5::api::Term& expr] +variable[cvc5::api::Term& expr] : UPPER_WORD { std::string name = AntlrInput::tokenText($UPPER_WORD); @@ -824,13 +824,13 @@ variable[CVC5::api::Term& expr] /*******/ /* FOF */ -fofFormula[CVC5::api::Term& expr] : fofLogicFormula[expr] ; +fofFormula[cvc5::api::Term& expr] : fofLogicFormula[expr] ; -fofLogicFormula[CVC5::api::Term& expr] +fofLogicFormula[cvc5::api::Term& expr] @declarations { tptp::NonAssoc na; - std::vector< CVC5::api::Term > args; - CVC5::api::Term expr2; + std::vector< cvc5::api::Term > args; + cvc5::api::Term expr2; } : fofUnitaryFormula[expr] ( // Non-associative: <=> <~> ~& ~| @@ -870,10 +870,10 @@ fofLogicFormula[CVC5::api::Term& expr] )? ; -fofUnitaryFormula[CVC5::api::Term& expr] +fofUnitaryFormula[cvc5::api::Term& expr] @declarations { api::Kind kind; - std::vector< CVC5::api::Term > bv; + std::vector< cvc5::api::Term > bv; } : atomicFormula[expr] | LPAREN_TOK fofLogicFormula[expr] RPAREN_TOK @@ -888,14 +888,14 @@ fofUnitaryFormula[CVC5::api::Term& expr] } ; -bindvariable[CVC5::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[CVC5::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[CVC5::parser::tptp::NonAssoc& na] | REVIMPLIES_TOK { na = tptp::NA_REVIMPLIES; } ; -folQuantifier[CVC5::api::Kind& kind] +folQuantifier[cvc5::api::Kind& kind] : FORALL_TOK { kind = api::FORALL; } | EXISTS_TOK { kind = api::EXISTS; } ; @@ -912,7 +912,7 @@ folQuantifier[CVC5::api::Kind& kind] /*******/ /* THF */ -thfQuantifier[CVC5::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[CVC5::api::Kind& kind] } ; -thfAtomTyping[CVC5::Command*& cmd] +thfAtomTyping[cvc5::Command*& cmd] // for now only supports mapping types (i.e. no applied types) @declarations { - CVC5::api::Term expr; - CVC5::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[CVC5::Command*& cmd] else { // as of yet, it's undeclared - CVC5::api::Term freshExpr; + cvc5::api::Term freshExpr; if (type.isFunction()) { freshExpr = PARSER_STATE->bindVar(name, type); @@ -1003,12 +1003,12 @@ thfAtomTyping[CVC5::Command*& cmd] ) ; -thfLogicFormula[CVC5::ParseOp& p] +thfLogicFormula[cvc5::ParseOp& p] @declarations { tptp::NonAssoc na; - std::vector<CVC5::api::Term> args; + std::vector<cvc5::api::Term> args; std::vector<ParseOp> p_args; - CVC5::api::Term expr2; + cvc5::api::Term expr2; bool equal; ParseOp p1; } @@ -1194,7 +1194,7 @@ thfLogicFormula[CVC5::ParseOp& p] )? ; -thfTupleForm[std::vector<CVC5::api::Term>& args] +thfTupleForm[std::vector<cvc5::api::Term>& args] @declarations { ParseOp p; } @@ -1217,11 +1217,11 @@ thfTupleForm[std::vector<CVC5::api::Term>& args] )+ ; -thfUnitaryFormula[CVC5::ParseOp& p] +thfUnitaryFormula[cvc5::ParseOp& p] @declarations { api::Kind kind; - std::vector< CVC5::api::Term > bv; - CVC5::api::Term expr; + std::vector< cvc5::api::Term > bv; + cvc5::api::Term expr; bool equal; ParseOp p1; } @@ -1289,12 +1289,12 @@ thfUnitaryFormula[CVC5::ParseOp& p] /*******/ /* TFF */ -tffFormula[CVC5::api::Term& expr] : tffLogicFormula[expr]; +tffFormula[cvc5::api::Term& expr] : tffLogicFormula[expr]; -tffTypedAtom[CVC5::Command*& cmd] +tffTypedAtom[cvc5::Command*& cmd] @declarations { - CVC5::api::Term expr; - CVC5::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[CVC5::Command*& cmd] } } else { // as yet, it's undeclared - CVC5::api::Term aexpr = PARSER_STATE->bindVar(name, type); + cvc5::api::Term aexpr = PARSER_STATE->bindVar(name, type); cmd = new DeclareFunctionCommand(name, aexpr, type); } } ) ; -tffLogicFormula[CVC5::api::Term& expr] +tffLogicFormula[cvc5::api::Term& expr] @declarations { tptp::NonAssoc na; - std::vector< CVC5::api::Term > args; - CVC5::api::Term expr2; + std::vector< cvc5::api::Term > args; + cvc5::api::Term expr2; } : tffUnitaryFormula[expr] ( // Non Assoc <=> <~> ~& ~| @@ -1378,11 +1378,11 @@ tffLogicFormula[CVC5::api::Term& expr] )? ; -tffUnitaryFormula[CVC5::api::Term& expr] +tffUnitaryFormula[cvc5::api::Term& expr] @declarations { api::Kind kind; - std::vector< CVC5::api::Term > bv; - CVC5::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[CVC5::api::Term& expr] RPAREN_TOK ; -tffLetTermDefn[CVC5::api::Term& lhs, CVC5::api::Term& rhs] +tffLetTermDefn[cvc5::api::Term& lhs, cvc5::api::Term& rhs] @declarations { - std::vector<CVC5::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<CVC5::api::Term> & bvlist, - CVC5::api::Term& lhs, - CVC5::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<CVC5::api::Term> & bvlist, | LPAREN_TOK tffLetTermBinding[bvlist, lhs, rhs] RPAREN_TOK ; -tffLetFormulaDefn[CVC5::api::Term& lhs, CVC5::api::Term& rhs] +tffLetFormulaDefn[cvc5::api::Term& lhs, cvc5::api::Term& rhs] @declarations { - std::vector<CVC5::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<CVC5::api::Term> & bvlist, - CVC5::api::Term& lhs, - CVC5::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<CVC5::api::Term> & bvlist, | LPAREN_TOK tffLetFormulaBinding[bvlist, lhs, rhs] RPAREN_TOK ; -thfBindVariable[CVC5::api::Term& expr] +thfBindVariable[cvc5::api::Term& expr] @declarations { std::string name; - CVC5::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[CVC5::api::Term& expr] ; -tffbindvariable[CVC5::api::Term& expr] +tffbindvariable[cvc5::api::Term& expr] @declarations { - CVC5::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[CVC5::api::Term& expr] // bvlist is accumulative; it can already contain elements // on the way in, which are left undisturbed -tffVariableList[std::vector<CVC5::api::Term>& bvlist] +tffVariableList[std::vector<cvc5::api::Term>& bvlist] @declarations { - CVC5::api::Term e; + cvc5::api::Term e; } : tffbindvariable[e] { bvlist.push_back(e); } ( COMMA_TOK tffbindvariable[e] { bvlist.push_back(e); } )* ; -parseThfType[CVC5::api::Sort& type] +parseThfType[cvc5::api::Sort& type] // assumes only mapping types (arrows), no tuple type @declarations { - std::vector<CVC5::api::Sort> sorts; + std::vector<cvc5::api::Sort> sorts; } : thfType[type] { sorts.push_back(type); } ( @@ -1522,17 +1522,17 @@ parseThfType[CVC5::api::Sort& type] } ; -thfType[CVC5::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[CVC5::api::Sort & type] +parseType[cvc5::api::Sort & type] @declarations { - std::vector<CVC5::api::Sort> v; + std::vector<cvc5::api::Sort> v; } : simpleType[type] | ( simpleType[type] { v.push_back(type); } @@ -1546,7 +1546,7 @@ parseType[CVC5::api::Sort & type] ; // non-function types -simpleType[CVC5::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 e6b4969c3..136319225 100644 --- a/src/parser/tptp/tptp.cpp +++ b/src/parser/tptp/tptp.cpp @@ -28,7 +28,7 @@ #undef true #undef false -namespace CVC5 { +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 CVC5::api::Term& var : vars) + for (const cvc5::api::Term& var : vars) { if (var.hasOp()) { @@ -569,4 +569,4 @@ Command* Tptp::makeAssertCommand(FormulaRole fr, } } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/tptp/tptp.h b/src/parser/tptp/tptp.h index 318ef7f4a..b91418bd0 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 CVC5 { +namespace cvc5 { class Command; @@ -218,12 +218,12 @@ namespace tptp { * Just exists to provide the uintptr_t constructor that ANTLR * requires. */ -struct myExpr : public CVC5::api::Term +struct myExpr : public cvc5::api::Term { - 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) {} + 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 { @@ -238,6 +238,6 @@ enum NonAssoc { } // namespace tptp } // namespace parser -} // namespace CVC5 +} // 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 f3489f3fe..9e2943c47 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 CVC5 { +namespace cvc5 { namespace parser { /* Use lookahead=2 */ @@ -69,4 +69,4 @@ api::Term TptpInput::parseExpr() } } // namespace parser -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/parser/tptp/tptp_input.h b/src/parser/tptp/tptp_input.h index bfe8562fc..ff4ac590f 100644 --- a/src/parser/tptp/tptp_input.h +++ b/src/parser/tptp/tptp_input.h @@ -23,10 +23,10 @@ #include "parser/tptp/TptpLexer.h" #include "parser/tptp/TptpParser.h" -// extern void TptpParserSetAntlrParser(CVC5::parser::AntlrParser* +// extern void TptpParserSetAntlrParser(cvc5::parser::AntlrParser* // newAntlrParser); -namespace CVC5 { +namespace cvc5 { class Command; class Expr; @@ -82,6 +82,6 @@ class TptpInput : public AntlrInput { };/* class TptpInput */ } // namespace parser -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PARSER__TPTP_INPUT_H */ diff --git a/src/preprocessing/assertion_pipeline.cpp b/src/preprocessing/assertion_pipeline.cpp index ab3e950b9..92027a303 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 CVC5 { +namespace cvc5 { namespace preprocessing { AssertionPipeline::AssertionPipeline() @@ -212,4 +212,4 @@ void AssertionPipeline::conjoin(size_t i, Node n, ProofGenerator* pg) } } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/assertion_pipeline.h b/src/preprocessing/assertion_pipeline.h index 454606315..aa4ffbca2 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 CVC5 { +namespace cvc5 { class ProofGenerator; namespace smt { @@ -198,6 +198,6 @@ class AssertionPipeline }; /* class AssertionPipeline */ } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PREPROCESSING__ASSERTION_PIPELINE_H */ diff --git a/src/preprocessing/passes/ackermann.cpp b/src/preprocessing/passes/ackermann.cpp index a67861664..a19994ad9 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 CVC5; -using namespace CVC5::theory; +using namespace cvc5; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -336,4 +336,4 @@ PreprocessingPassResult Ackermann::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/ackermann.h b/src/preprocessing/passes/ackermann.h index e177b4270..14f8f713f 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -82,6 +82,6 @@ class Ackermann : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 16f06540e..12f3375b0 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -63,4 +63,4 @@ PreprocessingPassResult ApplySubsts::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/apply_substs.h b/src/preprocessing/passes/apply_substs.h index 6345f35dd..d94943dc3 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 CVC5 { +namespace cvc5 { namespace preprocessing { class PreprocessingPassContext; @@ -46,6 +46,6 @@ class ApplySubsts : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/preprocessing/passes/bool_to_bv.cpp b/src/preprocessing/passes/bool_to_bv.cpp index 042bc3e01..df8e93bc7 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { -using namespace CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/bool_to_bv.h b/src/preprocessing/passes/bool_to_bv.h index 885c57302..1245dbd34 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -121,6 +121,6 @@ class BoolToBV : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 045b4295b..b7a9e9c69 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { -using namespace CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/bv_abstraction.h b/src/preprocessing/passes/bv_abstraction.h index b16a2f973..d699b288f 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -44,6 +44,6 @@ class BvAbstraction : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 15b7662c4..54f967bfc 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -47,4 +47,4 @@ PreprocessingPassResult BvEagerAtoms::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/bv_eager_atoms.h b/src/preprocessing/passes/bv_eager_atoms.h index a3c7a424a..e0b53ad1b 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -38,6 +38,6 @@ class BvEagerAtoms : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 2ec12256a..7bd0e7715 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 CVC5; -using namespace CVC5::theory; -using namespace CVC5::theory::bv; +using namespace cvc5; +using namespace cvc5::theory; +using namespace cvc5::theory::bv; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -704,7 +704,7 @@ PreprocessingPassResult BVGauss::applyInternal( { Node a = assertions.back(); assertions.pop_back(); - CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/bv_gauss.h b/src/preprocessing/passes/bv_gauss.h index d06071867..e75b41868 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -104,6 +104,6 @@ class BVGauss : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/preprocessing/passes/bv_intro_pow2.cpp b/src/preprocessing/passes/bv_intro_pow2.cpp index c611c8af3..fb6a123dd 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { using NodeMap = std::unordered_map<Node, Node, NodeHashFunction>; -using namespace CVC5::theory; +using namespace cvc5::theory; namespace { @@ -103,4 +103,4 @@ PreprocessingPassResult BvIntroPow2::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/bv_intro_pow2.h b/src/preprocessing/passes/bv_intro_pow2.h index 98e1efc1d..c51383d2c 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -39,6 +39,6 @@ class BvIntroPow2 : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 5153f3b7f..9f219e7a4 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { using namespace std; -using namespace CVC5::theory; +using namespace cvc5::theory; BVToBool::BVToBool(PreprocessingPassContext* preprocContext) : PreprocessingPass(preprocContext, "bv-to-bool"), @@ -310,4 +310,4 @@ BVToBool::Statistics::~Statistics() } // passes } // Preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/bv_to_bool.h b/src/preprocessing/passes/bv_to_bool.h index 45fa4a5df..b6b847140 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -73,6 +73,6 @@ class BVToBool : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 f7a87d51f..510d35419 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { using namespace std; -using namespace CVC5::theory; -using namespace CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/bv_to_int.h b/src/preprocessing/passes/bv_to_int.h index bc949bff2..c0d96d462 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -285,6 +285,6 @@ class BVToInt : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 245c889d3..38519e96b 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -43,4 +43,4 @@ PreprocessingPassResult ExtRewPre::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/extended_rewriter_pass.h b/src/preprocessing/passes/extended_rewriter_pass.h index 60ab6af98..8fabecbaa 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -37,6 +37,6 @@ class ExtRewPre : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 c1a995469..307be46bf 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { -using namespace CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/foreign_theory_rewrite.h b/src/preprocessing/passes/foreign_theory_rewrite.h index e50909617..eb228ca67 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -62,6 +62,6 @@ class ForeignTheoryRewrite : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 b34df8ca3..c6ea0ee27 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 CVC5::kind; -using namespace CVC5::theory; -using namespace CVC5::theory::quantifiers; +using namespace cvc5::kind; +using namespace cvc5::theory; +using namespace cvc5::theory::quantifiers; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -466,4 +466,4 @@ void FunDefFmf::getConstraints(Node n, } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/fun_def_fmf.h b/src/preprocessing/passes/fun_def_fmf.h index 194c520ab..cb461d6e9 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -100,6 +100,6 @@ class FunDefFmf : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 60f584225..5cb5663c3 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 CVC5::kind; -using namespace CVC5::theory; +using namespace cvc5::kind; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -124,4 +124,4 @@ PreprocessingPassResult GlobalNegate::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/global_negate.h b/src/preprocessing/passes/global_negate.h index 2e9dbdcb7..263fa636b 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -48,6 +48,6 @@ class GlobalNegate : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 13a59a92d..1bf980c49 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -539,4 +539,4 @@ TypeNode HoElim::getUSort(TypeNode tn) } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/ho_elim.h b/src/preprocessing/passes/ho_elim.h index 36aa53acf..ba23a1973 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -150,6 +150,6 @@ class HoElim : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 bf59a7311..b1f8ad771 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { using namespace std; -using namespace CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/int_to_bv.h b/src/preprocessing/passes/int_to_bv.h index a6eda934f..da9d54229 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -39,6 +39,6 @@ class IntToBV : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 91b805004..cae898a7a 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { -using namespace CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/ite_removal.h b/src/preprocessing/passes/ite_removal.h index ceb9af4ac..4c4923647 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -37,6 +37,6 @@ class IteRemoval : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 8b9ad9587..0ad4f1abc 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 CVC5; -using namespace CVC5::theory; +using namespace cvc5; +using namespace cvc5::theory; -namespace CVC5 { +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 = CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/ite_simp.h b/src/preprocessing/passes/ite_simp.h index e5ab27620..abb3ec6f5 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -52,6 +52,6 @@ class ITESimp : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/preprocessing/passes/miplib_trick.cpp b/src/preprocessing/passes/miplib_trick.cpp index a810d3e19..7c246c3e1 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { using namespace std; -using namespace CVC5::theory; +using namespace cvc5::theory; namespace { @@ -667,4 +667,4 @@ MipLibTrick::Statistics::~Statistics() } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/miplib_trick.h b/src/preprocessing/passes/miplib_trick.h index 61bf40040..cad786c6b 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -57,6 +57,6 @@ class MipLibTrick : public PreprocessingPass, public NodeManagerListener } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 3bc8ff8dd..838a2a767 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { using namespace std; -using namespace CVC5::theory; +using namespace cvc5::theory; Node NlExtPurify::purifyNlTerms(TNode n, NodeMap& cache, @@ -140,4 +140,4 @@ PreprocessingPassResult NlExtPurify::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/nl_ext_purify.h b/src/preprocessing/passes/nl_ext_purify.h index c9b5c344c..2718639d6 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -51,6 +51,6 @@ class NlExtPurify : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 29e7233c0..e5b0cd39b 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 CVC5; -using namespace CVC5::theory; +using namespace cvc5; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -491,4 +491,4 @@ Node NonClausalSimp::processRewrittenLearnedLit(theory::TrustNode trn) } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/non_clausal_simp.h b/src/preprocessing/passes/non_clausal_simp.h index dfaa24a93..679a6216d 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 CVC5 { +namespace cvc5 { class LazyCDProof; class ProofNodeManager; @@ -97,6 +97,6 @@ class NonClausalSimp : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/preprocessing/passes/pseudo_boolean_processor.cpp b/src/preprocessing/passes/pseudo_boolean_processor.cpp index 5ce7338f3..510281bee 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { -using namespace CVC5::theory; -using namespace CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/pseudo_boolean_processor.h b/src/preprocessing/passes/pseudo_boolean_processor.h index 6e1b426bf..47a1eb7dc 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -110,6 +110,6 @@ class PseudoBooleanProcessor : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 b296f9c17..8251183dd 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 CVC5::theory; -using namespace CVC5::theory::quantifiers; -using namespace CVC5::kind; +using namespace cvc5::theory; +using namespace cvc5::theory::quantifiers; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -568,4 +568,4 @@ void QuantifierMacros::addMacro( Node op, Node n, std::vector< Node >& opc ) { } // passes } // preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/quantifier_macros.h b/src/preprocessing/passes/quantifier_macros.h index 51b3c7951..4b5b21a5d 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -91,6 +91,6 @@ class QuantifierMacros : public PreprocessingPass } // passes } // preprocessing -} // namespace CVC5 +} // 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 15f0fc54b..92b2c8aae 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { using namespace std; -using namespace CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/quantifiers_preprocess.h b/src/preprocessing/passes/quantifiers_preprocess.h index b9ea842cb..6aa5c58f0 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -40,6 +40,6 @@ class QuantifiersPreprocess : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 bc8ba0b79..c80d55d3d 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { using namespace std; -using namespace CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/real_to_int.h b/src/preprocessing/passes/real_to_int.h index 5579e3faf..d961f10f2 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -45,6 +45,6 @@ class RealToInt : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 35c2e9926..e5ff22d4f 100644 --- a/src/preprocessing/passes/rewrite.cpp +++ b/src/preprocessing/passes/rewrite.cpp @@ -19,11 +19,11 @@ #include "preprocessing/assertion_pipeline.h" #include "theory/rewriter.h" -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { -using namespace CVC5::theory; +using namespace cvc5::theory; Rewrite::Rewrite(PreprocessingPassContext* preprocContext) : PreprocessingPass(preprocContext, "rewrite"){}; @@ -42,4 +42,4 @@ PreprocessingPassResult Rewrite::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/rewrite.h b/src/preprocessing/passes/rewrite.h index 4848c8a98..50443c2c6 100644 --- a/src/preprocessing/passes/rewrite.h +++ b/src/preprocessing/passes/rewrite.h @@ -21,7 +21,7 @@ #include "preprocessing/preprocessing_pass.h" -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -37,7 +37,7 @@ class Rewrite : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 6100e0762..8c130768d 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { using namespace std; -using namespace CVC5::theory; +using namespace cvc5::theory; namespace { @@ -124,4 +124,4 @@ PreprocessingPassResult SepSkolemEmp::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/sep_skolem_emp.h b/src/preprocessing/passes/sep_skolem_emp.h index 11e7bec24..a5b4120cb 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -36,6 +36,6 @@ class SepSkolemEmp : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 07c5e7cc5..cb8818f96 100644 --- a/src/preprocessing/passes/sort_infer.cpp +++ b/src/preprocessing/passes/sort_infer.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -91,4 +91,4 @@ PreprocessingPassResult SortInferencePass::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/sort_infer.h b/src/preprocessing/passes/sort_infer.h index 5874b4363..167697206 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -38,6 +38,6 @@ class SortInferencePass : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 1cc2ce06f..028322c1e 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -57,4 +57,4 @@ PreprocessingPassResult StaticLearning::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/static_learning.h b/src/preprocessing/passes/static_learning.h index 67bf053f9..8f83e60b5 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -36,6 +36,6 @@ class StaticLearning : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 775a09441..ea12010b0 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 CVC5::theory; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -57,4 +57,4 @@ PreprocessingPassResult StringsEagerPp::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/strings_eager_pp.h b/src/preprocessing/passes/strings_eager_pp.h index 3af59766c..b4058a659 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -39,6 +39,6 @@ class StringsEagerPp : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 f05afe54f..a0d4ed91e 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 CVC5::kind; -using namespace CVC5::theory; +using namespace cvc5::kind; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -345,4 +345,4 @@ bool SygusInference::solveSygus(const std::vector<Node>& assertions, } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/sygus_inference.h b/src/preprocessing/passes/sygus_inference.h index b31e5ca7c..094788adc 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -63,6 +63,6 @@ class SygusInference : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 7213dc8a8..b2333b30e 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -474,4 +474,4 @@ PreprocessingPassResult SynthRewRulesPass::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/synth_rew_rules.h b/src/preprocessing/passes/synth_rew_rules.h index eb52688e7..016395029 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -71,6 +71,6 @@ class SynthRewRulesPass : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 7112dd50f..8e79a7b09 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { -using namespace CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/theory_preprocess.h b/src/preprocessing/passes/theory_preprocess.h index bd450840e..cc74792d1 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -37,6 +37,6 @@ class TheoryPreprocess : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 c70458b91..c5a73f89b 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 CVC5::theory; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -116,4 +116,4 @@ theory::TrustNode TheoryRewriteEq::rewriteAssertion(TNode n) } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/theory_rewrite_eq.h b/src/preprocessing/passes/theory_rewrite_eq.h index 626efe8e3..f6651d39c 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { @@ -51,6 +51,6 @@ class TheoryRewriteEq : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // 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 502889dd3..9a9aaa366 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace passes { using namespace std; -using namespace CVC5::theory; +using namespace cvc5::theory; UnconstrainedSimplifier::UnconstrainedSimplifier( PreprocessingPassContext* preprocContext) @@ -880,4 +880,4 @@ PreprocessingPassResult UnconstrainedSimplifier::applyInternal( } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/passes/unconstrained_simplifier.h b/src/preprocessing/passes/unconstrained_simplifier.h index da368de51..5416abf51 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 CVC5 { +namespace cvc5 { namespace context { class Context; } @@ -72,6 +72,6 @@ class UnconstrainedSimplifier : public PreprocessingPass } // namespace passes } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/preprocessing/preprocessing_pass.cpp b/src/preprocessing/preprocessing_pass.cpp index 127b22758..f9effecba 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 CVC5 { +namespace cvc5 { namespace preprocessing { PreprocessingPassResult PreprocessingPass::apply( @@ -70,4 +70,4 @@ PreprocessingPass::~PreprocessingPass() { } } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/preprocessing_pass.h b/src/preprocessing/preprocessing_pass.h index f112d5f54..7f65129f8 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 CVC5 { +namespace cvc5 { namespace preprocessing { class AssertionPipeline; @@ -81,6 +81,6 @@ class PreprocessingPass { }; } // namespace preprocessing -} // namespace CVC5 +} // 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 3c64ce301..fdcbbb466 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 CVC5 { +namespace cvc5 { namespace preprocessing { PreprocessingPassContext::PreprocessingPassContext( @@ -61,4 +61,4 @@ ProofNodeManager* PreprocessingPassContext::getProofNodeManager() } } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/preprocessing_pass_context.h b/src/preprocessing/preprocessing_pass_context.h index 93563e3a2..17f049748 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 CVC5 { +namespace cvc5 { class SmtEngine; class TheoryEngine; namespace theory::booleans { @@ -106,6 +106,6 @@ class PreprocessingPassContext }; // class PreprocessingPassContext } // namespace preprocessing -} // namespace CVC5 +} // 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 a46ce0205..b9434e63f 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 CVC5 { +namespace cvc5 { namespace preprocessing { -using namespace CVC5::preprocessing::passes; +using namespace cvc5::preprocessing::passes; PreprocessingPassRegistry& PreprocessingPassRegistry::getInstance() { @@ -158,4 +158,4 @@ PreprocessingPassRegistry::PreprocessingPassRegistry() } } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/preprocessing_pass_registry.h b/src/preprocessing/preprocessing_pass_registry.h index 4843b810b..bd9e724da 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 CVC5 { +namespace cvc5 { namespace preprocessing { class PreprocessingPass; @@ -94,6 +94,6 @@ class PreprocessingPassRegistry { }; // class PreprocessingPassRegistry } // namespace preprocessing -} // namespace CVC5 +} // 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 2b215f9b4..a3ad701a8 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace util { @@ -1909,4 +1909,4 @@ ITECareSimplifier::CareSetPtr ITECareSimplifier::CareSetPtr::mkNew( } // namespace util } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/preprocessing/util/ite_utilities.h b/src/preprocessing/util/ite_utilities.h index ff58bbacf..059bac45c 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 CVC5 { +namespace cvc5 { namespace preprocessing { class AssertionPipeline; @@ -417,6 +417,6 @@ class ITECareSimplifier } // namespace util } // namespace preprocessing -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/printer/ast/ast_printer.cpp b/src/printer/ast/ast_printer.cpp index 5d3fb1adc..c0ceb1c7f 100644 --- a/src/printer/ast/ast_printer.cpp +++ b/src/printer/ast/ast_printer.cpp @@ -29,7 +29,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace printer { namespace ast { @@ -475,4 +475,4 @@ static bool tryToStream(std::ostream& out, const CommandStatus* s) } // namespace ast } // namespace printer -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/printer/ast/ast_printer.h b/src/printer/ast/ast_printer.h index 985cf9872..7d24aa0fe 100644 --- a/src/printer/ast/ast_printer.h +++ b/src/printer/ast/ast_printer.h @@ -23,17 +23,17 @@ #include "printer/printer.h" -namespace CVC5 { +namespace cvc5 { class LetBinding; namespace printer { namespace ast { -class AstPrinter : public CVC5::Printer +class AstPrinter : public cvc5::Printer { public: - using CVC5::Printer::toStream; + using cvc5::Printer::toStream; void toStream(std::ostream& out, TNode n, int toDepth, @@ -196,6 +196,6 @@ class AstPrinter : public CVC5::Printer } // namespace ast } // namespace printer -} // namespace CVC5 +} // 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 867bc204a..1556ee74d 100644 --- a/src/printer/cvc/cvc_printer.cpp +++ b/src/printer/cvc/cvc_printer.cpp @@ -42,7 +42,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace printer { namespace cvc { @@ -1614,4 +1614,4 @@ void CvcPrinter::toStreamNodeWithLetify(std::ostream& out, } // namespace cvc } // namespace printer -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/printer/cvc/cvc_printer.h b/src/printer/cvc/cvc_printer.h index 2b240568e..f7458c3f5 100644 --- a/src/printer/cvc/cvc_printer.h +++ b/src/printer/cvc/cvc_printer.h @@ -23,17 +23,17 @@ #include "printer/printer.h" -namespace CVC5 { +namespace cvc5 { class LetBinding; namespace printer { namespace cvc { -class CvcPrinter : public CVC5::Printer +class CvcPrinter : public cvc5::Printer { public: - using CVC5::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 CVC5::Printer } // namespace cvc } // namespace printer -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PRINTER__CVC_PRINTER_H */ diff --git a/src/printer/let_binding.cpp b/src/printer/let_binding.cpp index 638503c1a..c8b227a97 100644 --- a/src/printer/let_binding.cpp +++ b/src/printer/let_binding.cpp @@ -16,7 +16,7 @@ #include <sstream> -namespace CVC5 { +namespace cvc5 { LetBinding::LetBinding(uint32_t thresh) : d_thresh(thresh), @@ -212,4 +212,4 @@ void LetBinding::convertCountToLet() } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/printer/let_binding.h b/src/printer/let_binding.h index 9eaeb039a..b0560a025 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 CVC5 { +namespace cvc5 { /** * A flexible let binding class. This class provides functionalities for @@ -157,6 +157,6 @@ class LetBinding NodeIdMap d_letMap; }; -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/printer/printer.cpp b/src/printer/printer.cpp index c4236d711..46e92b095 100644 --- a/src/printer/printer.cpp +++ b/src/printer/printer.cpp @@ -30,13 +30,13 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { unique_ptr<Printer> Printer::d_printers[language::output::LANG_MAX]; unique_ptr<Printer> Printer::makePrinter(OutputLanguage lang) { - using namespace CVC5::language::output; + using namespace cvc5::language::output; switch(lang) { case LANG_SMTLIB_V2_6: @@ -459,4 +459,4 @@ void Printer::toStreamCmdDeclarationSequence( printUnknownCommand(out, "sequence"); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/printer/printer.h b/src/printer/printer.h index 02ffdc939..65b4a7ccb 100644 --- a/src/printer/printer.h +++ b/src/printer/printer.h @@ -26,7 +26,7 @@ #include "smt/model.h" #include "util/result.h" -namespace CVC5 { +namespace cvc5 { class Command; class CommandStatus; @@ -308,6 +308,6 @@ class Printer }; /* class Printer */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PRINTER__PRINTER_H */ diff --git a/src/printer/smt2/smt2_printer.cpp b/src/printer/smt2/smt2_printer.cpp index 7e80baebc..a2a45de81 100644 --- a/src/printer/smt2/smt2_printer.cpp +++ b/src/printer/smt2/smt2_printer.cpp @@ -46,7 +46,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace printer { namespace smt2 { @@ -292,7 +292,7 @@ void Smt2Printer::toStream(std::ostream& out, } else { - out << CVC5::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 << CVC5::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 << CVC5::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 CVC5::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 << CVC5::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 " << CVC5::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 " << CVC5::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 " << CVC5::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 << "(" << CVC5::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 << "(" << CVC5::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 ") - << CVC5::quoteSymbol(sym.str()) << ' '; + << cvc5::quoteSymbol(sym.str()) << ' '; out << '('; if (!vars.empty()) { @@ -2139,4 +2139,4 @@ static bool tryToStream(std::ostream& out, const CommandStatus* s, Variant v) } // namespace smt2 } // namespace printer -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/printer/smt2/smt2_printer.h b/src/printer/smt2/smt2_printer.h index a997f789a..a3ab9721c 100644 --- a/src/printer/smt2/smt2_printer.h +++ b/src/printer/smt2/smt2_printer.h @@ -21,7 +21,7 @@ #include "printer/printer.h" -namespace CVC5 { +namespace cvc5 { class LetBinding; @@ -35,11 +35,11 @@ enum Variant // support for the string standard }; /* enum Variant */ -class Smt2Printer : public CVC5::Printer +class Smt2Printer : public cvc5::Printer { public: Smt2Printer(Variant variant = no_variant) : d_variant(variant) {} - using CVC5::Printer::toStream; + using cvc5::Printer::toStream; void toStream(std::ostream& out, TNode n, int toDepth, @@ -275,6 +275,6 @@ class Smt2Printer : public CVC5::Printer } // namespace smt2 } // namespace printer -} // namespace CVC5 +} // 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 c740f7b76..687ad1a61 100644 --- a/src/printer/tptp/tptp_printer.cpp +++ b/src/printer/tptp/tptp_printer.cpp @@ -30,7 +30,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace printer { namespace tptp { @@ -99,4 +99,4 @@ void TptpPrinter::toStream(std::ostream& out, const UnsatCore& core) const } // namespace tptp } // namespace printer -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/printer/tptp/tptp_printer.h b/src/printer/tptp/tptp_printer.h index ea538a245..c59e18ae2 100644 --- a/src/printer/tptp/tptp_printer.h +++ b/src/printer/tptp/tptp_printer.h @@ -23,14 +23,14 @@ #include "printer/printer.h" -namespace CVC5 { +namespace cvc5 { namespace printer { namespace tptp { -class TptpPrinter : public CVC5::Printer +class TptpPrinter : public cvc5::Printer { public: - using CVC5::Printer::toStream; + using cvc5::Printer::toStream; void toStream(std::ostream& out, TNode n, int toDepth, @@ -64,6 +64,6 @@ class TptpPrinter : public CVC5::Printer } // namespace tptp } // namespace printer -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PRINTER__TPTP_PRINTER_H */ diff --git a/src/proof/clause_id.h b/src/proof/clause_id.h index 6f3caaf19..7ce8a384a 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 CVC5 { +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); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PROOF__CLAUSE_ID_H */ diff --git a/src/proof/cnf_proof.cpp b/src/proof/cnf_proof.cpp index dc1a6dd61..fbe87c267 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 CVC5 { +namespace cvc5 { CnfProof::CnfProof(prop::CnfStream* stream, context::Context* ctx, @@ -113,4 +113,4 @@ bool CnfProof::getCurrentAssertionKind() return d_currentAssertionStack.back().second; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/proof/cnf_proof.h b/src/proof/cnf_proof.h index 1319b83d6..88eb885aa 100644 --- a/src/proof/cnf_proof.h +++ b/src/proof/cnf_proof.h @@ -28,7 +28,7 @@ #include "proof/clause_id.h" #include "proof/proof_manager.h" -namespace CVC5 { +namespace cvc5 { namespace prop { class CnfStream; } // namespace prop @@ -46,7 +46,7 @@ typedef std::unordered_set<Node, NodeHashFunction> NodeSet; class CnfProof { protected: - CVC5::prop::CnfStream* d_cnfStream; + cvc5::prop::CnfStream* d_cnfStream; /** Map from ClauseId to the assertion that lead to adding this clause **/ ClauseIdToNode d_clauseToAssertion; @@ -67,7 +67,7 @@ protected: std::string d_name; public: - CnfProof(CVC5::prop::CnfStream* cnfStream, + CnfProof(cvc5::prop::CnfStream* cnfStream, context::Context* ctx, const std::string& name); ~CnfProof(); @@ -95,6 +95,6 @@ public: Node getAssertionForClause(ClauseId clause); };/* class CnfProof */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CNF_PROOF_H */ diff --git a/src/proof/dot/dot_printer.cpp b/src/proof/dot/dot_printer.cpp index 8ecec8484..c2e8bd863 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 CVC5 { +namespace cvc5 { namespace proof { void DotPrinter::cleanQuotes(std::string& s) @@ -91,4 +91,4 @@ void DotPrinter::ruleArguments(std::ostringstream& currentArguments, } } // namespace proof -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/proof/dot/dot_printer.h b/src/proof/dot/dot_printer.h index 173495780..3bcc1cd73 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 CVC5 { +namespace cvc5 { namespace proof { class DotPrinter @@ -69,6 +69,6 @@ class DotPrinter }; } // namespace proof -} // namespace CVC5 +} // namespace cvc5 #endif
\ No newline at end of file diff --git a/src/proof/proof_manager.cpp b/src/proof/proof_manager.cpp index 8b3dfd17a..d9fd9c37a 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 CVC5 { +namespace cvc5 { ProofManager::ProofManager(context::Context* context) : d_context(context), @@ -217,4 +217,4 @@ void ProofManager::addUnsatCore(Node formula) d_outputCoreFormulas.insert(formula); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/proof/proof_manager.h b/src/proof/proof_manager.h index b303b996f..b6e6c1b2c 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 CVC5 { +namespace cvc5 { // forward declarations namespace Minisat { @@ -42,11 +42,11 @@ namespace prop { class SmtEngine; template <class Solver> class TSatProof; -typedef TSatProof<CVC5::Minisat::Solver> CoreSatProof; +typedef TSatProof<cvc5::Minisat::Solver> CoreSatProof; class CnfProof; -typedef TSatProof<CVC5::Minisat::Solver> CoreSatProof; +typedef TSatProof<cvc5::Minisat::Solver> CoreSatProof; namespace prop { typedef uint64_t SatVariable; @@ -81,7 +81,7 @@ public: // initialization void initSatProof(Minisat::Solver* solver); - void initCnfProof(CVC5::prop::CnfStream* cnfStream, context::Context* ctx); + void initCnfProof(cvc5::prop::CnfStream* cnfStream, context::Context* ctx); // getting various proofs static CoreSatProof* getSatProof(); @@ -120,6 +120,6 @@ private: };/* class ProofManager */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PROOF_MANAGER_H */ diff --git a/src/proof/sat_proof.h b/src/proof/sat_proof.h index 298b82624..a66ca2d00 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 CVC5 { +namespace cvc5 { class CnfProof; -} // namespace CVC5 +} // namespace cvc5 -namespace CVC5 { +namespace cvc5 { /** * Helper debugging functions */ @@ -369,6 +369,6 @@ template <class Solver> void toSatClause(const typename Solver::TClause& minisat_cl, prop::SatClause& sat_cl); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SAT__PROOF_H */ diff --git a/src/proof/sat_proof_implementation.h b/src/proof/sat_proof_implementation.h index 6049c4876..c2bbf6f11 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 CVC5 { +namespace cvc5 { template <class Solver> void printLit(typename Solver::TLit l) { @@ -1040,12 +1040,12 @@ TSatProof<Solver>::Statistics::~Statistics() { smtStatisticsRegistry()->unregisterStat(&d_usedClauseGlue); } -inline std::ostream& operator<<(std::ostream& out, CVC5::ClauseKind k) +inline std::ostream& operator<<(std::ostream& out, cvc5::ClauseKind k) { switch (k) { - case CVC5::INPUT: out << "INPUT"; break; - case CVC5::THEORY_LEMMA: out << "THEORY_LEMMA"; break; - case CVC5::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) << "]"; } @@ -1053,6 +1053,6 @@ inline std::ostream& operator<<(std::ostream& out, CVC5::ClauseKind k) return out; } -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SAT__PROOF_IMPLEMENTATION_H */ diff --git a/src/proof/unsat_core.cpp b/src/proof/unsat_core.cpp index 2415daf98..e13db65d0 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 CVC5 { +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; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/proof/unsat_core.h b/src/proof/unsat_core.h index 46dd7bf69..7d7688347 100644 --- a/src/proof/unsat_core.h +++ b/src/proof/unsat_core.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC5 { +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); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__UNSAT_CORE_H */ diff --git a/src/prop/README.minisat b/src/prop/README.minisat index 081e79191..b3e101a88 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 CVC5::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 1645a096a..fe95e7adb 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 CVC5 { +namespace cvc5 { namespace prop { class BVSatSolverNotify { @@ -45,6 +45,6 @@ public: };/* class BVSatSolverInterface::Notify */ } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/bvminisat.cpp b/src/prop/bvminisat/bvminisat.cpp index fb764631f..ba1a7fc3b 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 CVC5 { +namespace cvc5 { namespace prop { BVMinisatSatSolver::BVMinisatSatSolver(StatisticsRegistry* registry, context::Context* mainSatContext, const std::string& name) @@ -298,4 +298,4 @@ void BVMinisatSatSolver::Statistics::init(BVMinisat::SimpSolver* minisat){ } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/bvminisat/bvminisat.h b/src/prop/bvminisat/bvminisat.h index 2a099ad21..1bc0eb237 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 CVC5 { +namespace cvc5 { namespace prop { class BVMinisatSatSolver : public BVSatSolverInterface, @@ -148,4 +148,4 @@ public: }; } // namespace prop -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/bvminisat/core/Dimacs.h b/src/prop/bvminisat/core/Dimacs.h index be82fb557..a660391f7 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 CVC5 { +namespace cvc5 { namespace BVMinisat { //================================================================================================= @@ -86,6 +86,6 @@ static void parse_DIMACS(gzFile input_stream, Solver& S) { //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/core/Solver.cc b/src/prop/bvminisat/core/Solver.cc index d7dc3f6d4..d154b5e7f 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 CVC5 { +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(CVC5::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 (!CVC5::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 CVC5::theory::Interrupted& e) + catch (const cvc5::theory::Interrupted& e) { // do some clean-up and rethrow cancelUntil(assumptions.size()); @@ -1418,4 +1418,4 @@ bool Solver::withinBudget(ResourceManager::Resource r) const } } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/bvminisat/core/Solver.h b/src/prop/bvminisat/core/Solver.h index 6386c33fa..3bd43f889 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 CVC5 { +namespace cvc5 { namespace BVMinisat { class Solver; @@ -80,7 +80,7 @@ private: Notify* d_notify; /** Cvc4 context */ - CVC5::context::Context* c; + cvc5::context::Context* c; /** True constant */ Var varTrue; @@ -92,7 +92,7 @@ public: // Constructor/Destructor: // - Solver(CVC5::context::Context* c); + Solver(cvc5::context::Context* c); virtual ~Solver(); void setNotify(Notify* toNotify); @@ -534,6 +534,6 @@ inline void Solver::toDimacs (const char* file, Lit p, Lit q, Lit r){ ve //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/core/SolverTypes.h b/src/prop/bvminisat/core/SolverTypes.h index 96022efbf..fd0e86116 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 CVC5 { +namespace cvc5 { namespace BVMinisat { class Solver; } template <class Solver> class TSatProof; -} // namespace CVC5 +} // namespace cvc5 -namespace CVC5 { +namespace cvc5 { namespace BVMinisat { @@ -430,6 +430,6 @@ inline void Clause::strengthen(Lit p) //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/mtl/Alg.h b/src/prop/bvminisat/mtl/Alg.h index 0b173eb08..ae72ca878 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 CVC5 { +namespace cvc5 { namespace BVMinisat { //================================================================================================= @@ -82,6 +82,6 @@ static inline void append(const vec<T>& from, vec<T>& to){ copy(from, to, true); //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/mtl/Alloc.h b/src/prop/bvminisat/mtl/Alloc.h index 582db74f1..2697f13b9 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 CVC5 { +namespace cvc5 { namespace BVMinisat { //================================================================================================= @@ -149,6 +149,6 @@ RegionAllocator<T>::alloc(int size) //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/mtl/Heap.h b/src/prop/bvminisat/mtl/Heap.h index 7b04a5091..73c1f07d2 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 CVC5 { +namespace cvc5 { namespace BVMinisat { //================================================================================================= @@ -156,6 +156,6 @@ class Heap { //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/mtl/Map.h b/src/prop/bvminisat/mtl/Map.h index fd64fc751..2d5db2561 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 CVC5 { +namespace cvc5 { namespace BVMinisat { //================================================================================================= @@ -191,6 +191,6 @@ class Map { //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/mtl/Queue.h b/src/prop/bvminisat/mtl/Queue.h index a72660337..8407fd7ee 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 CVC5 { +namespace cvc5 { namespace BVMinisat { //================================================================================================= @@ -86,6 +86,6 @@ public: //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/mtl/Sort.h b/src/prop/bvminisat/mtl/Sort.h index 1cfa220ab..30b3b5396 100644 --- a/src/prop/bvminisat/mtl/Sort.h +++ b/src/prop/bvminisat/mtl/Sort.h @@ -26,7 +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 CVC5 { +namespace cvc5 { namespace BVMinisat { template<class T> @@ -94,6 +94,6 @@ template <class T> void sort(vec<T>& v) { //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/mtl/Vec.h b/src/prop/bvminisat/mtl/Vec.h index c918fc4a0..047a89991 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 CVC5 { +namespace cvc5 { namespace BVMinisat { //================================================================================================= @@ -147,6 +147,6 @@ void vec<T>::clear(bool dealloc) { //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/mtl/XAlloc.h b/src/prop/bvminisat/mtl/XAlloc.h index 1500114a2..581915d36 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 CVC5 { +namespace cvc5 { namespace BVMinisat { //================================================================================================= @@ -42,6 +42,6 @@ static inline void* xrealloc(void *ptr, size_t size) //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/simp/SimpSolver.cc b/src/prop/bvminisat/simp/SimpSolver.cc index b4f9bd354..96ab5b526 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 CVC5 { +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(CVC5::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(CVC5::context::Context* context) use_asymm(opt_use_asymm), use_rcheck(opt_use_rcheck), use_elim(opt_use_elim - && CVC5::options::bitblastMode() - == CVC5::options::BitblastMode::EAGER - && !CVC5::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(CVC5::context::Context* context) SimpSolver::~SimpSolver() { - // CVC5::StatisticsRegistry::unregisterStat(&total_eliminate_time); + // cvc5::StatisticsRegistry::unregisterStat(&total_eliminate_time); } @@ -644,7 +644,7 @@ void SimpSolver::extendModel() bool SimpSolver::eliminate(bool turn_off_elim) { - // CVC5::TimerStat::CodeTimer codeTimer(total_eliminate_time); + // cvc5::TimerStat::CodeTimer codeTimer(total_eliminate_time); if (!simplify()) return false; @@ -809,4 +809,4 @@ void SimpSolver::garbageCollect() } } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/bvminisat/simp/SimpSolver.h b/src/prop/bvminisat/simp/SimpSolver.h index 6afdc6ba7..b103243d3 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 CVC5 { +namespace cvc5 { namespace context { class Context; @@ -41,7 +41,7 @@ class SimpSolver : public Solver { public: // Constructor/Destructor: // - SimpSolver(CVC5::context::Context* context); + SimpSolver(cvc5::context::Context* context); ~SimpSolver(); // Problem specification: @@ -115,7 +115,7 @@ class SimpSolver : public Solver { int merges; int asymm_lits; int eliminated_vars; - // CVC5::TimerStat total_eliminate_time; + // cvc5::TimerStat total_eliminate_time; protected: @@ -238,6 +238,6 @@ inline lbool SimpSolver::solveLimited (bool do_simp, bool turn_off_simp){ //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/utils/Options.cc b/src/prop/bvminisat/utils/Options.cc index 44c642441..0b05d5cf6 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 CVC5 { +namespace cvc5 { namespace BVMinisat { void BVMinisat::parseOptions(int& argc, char** argv, bool strict) @@ -91,4 +91,4 @@ void BVMinisat::printUsageAndExit (int argc, char** argv, bool verbose) } } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/bvminisat/utils/Options.h b/src/prop/bvminisat/utils/Options.h index e7b6942bd..033ffb64f 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 CVC5 { +namespace cvc5 { namespace BVMinisat { //================================================================================================== @@ -432,6 +432,6 @@ class BoolOption : public Option //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/utils/ParseUtils.h b/src/prop/bvminisat/utils/ParseUtils.h index a748651db..d69856ebb 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 CVC5 { +namespace cvc5 { namespace BVMinisat { //------------------------------------------------------------------------------------------------- @@ -120,6 +120,6 @@ static bool eagerMatch(B& in, const char* str) { //================================================================================================= } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/bvminisat/utils/System.cc b/src/prop/bvminisat/utils/System.cc index 9b9f99eb5..606fc5cbe 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 CVC5 { +namespace cvc5 { namespace BVMinisat { // TODO: split the memory reading functions into two: one for reading high-watermark of RSS, and @@ -95,5 +95,5 @@ double BVMinisat::memUsed() { return 0; } #endif -} /* CVC5::BVMinisat namespace */ +} /* cvc5::BVMinisat namespace */ } /* CVC4 namespace */ diff --git a/src/prop/bvminisat/utils/System.h b/src/prop/bvminisat/utils/System.h index 117fbfa3d..c805c232a 100644 --- a/src/prop/bvminisat/utils/System.h +++ b/src/prop/bvminisat/utils/System.h @@ -29,7 +29,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA //------------------------------------------------------------------------------------------------- -namespace CVC5 { +namespace cvc5 { namespace BVMinisat { static inline double cpuTime(void); // CPU-time in seconds. @@ -37,7 +37,7 @@ extern double memUsed(); // Memory in mega bytes (returns 0 for unsup extern double memUsedPeak(); // Peak-memory in mega bytes (returns 0 for unsupported architectures). } // namespace BVMinisat -} // namespace CVC5 +} // namespace cvc5 //------------------------------------------------------------------------------------------------- // Implementation of inline functions: @@ -45,7 +45,7 @@ extern double memUsedPeak(); // Peak-memory in mega bytes (returns 0 for #if defined(_MSC_VER) || defined(__MINGW32__) #include <time.h> -static inline double CVC5::BVMinisat::cpuTime(void) +static inline double cvc5::BVMinisat::cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; } @@ -55,7 +55,7 @@ static inline double CVC5::BVMinisat::cpuTime(void) #include <sys/resource.h> #include <unistd.h> -static inline double CVC5::BVMinisat::cpuTime(void) +static inline double cvc5::BVMinisat::cpuTime(void) { struct rusage ru; getrusage(RUSAGE_SELF, &ru); diff --git a/src/prop/cadical.cpp b/src/prop/cadical.cpp index 9bad7072a..cac015904 100644 --- a/src/prop/cadical.cpp +++ b/src/prop/cadical.cpp @@ -20,7 +20,7 @@ #include "base/check.h" -namespace CVC5 { +namespace cvc5 { namespace prop { using CadicalLit = int; @@ -200,6 +200,6 @@ CadicalSolver::Statistics::~Statistics() { } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif // CVC4_USE_CADICAL diff --git a/src/prop/cadical.h b/src/prop/cadical.h index c49aa8d03..910e5def5 100644 --- a/src/prop/cadical.h +++ b/src/prop/cadical.h @@ -26,7 +26,7 @@ #include <cadical.hpp> -namespace CVC5 { +namespace cvc5 { namespace prop { class CadicalSolver : public SatSolver @@ -103,7 +103,7 @@ class CadicalSolver : public SatSolver }; } // namespace prop -} // namespace CVC5 +} // 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 bd23bad94..1caea7bb7 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 CVC5 { +namespace cvc5 { namespace prop { CnfStream::CnfStream(SatSolver* satSolver, @@ -788,4 +788,4 @@ void CnfStream::convertAndAssert(TNode node, bool negated) } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/cnf_stream.h b/src/prop/cnf_stream.h index af86da746..b39423d71 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 CVC5 { +namespace cvc5 { class OutputManager; @@ -318,6 +318,6 @@ class CnfStream { }; /* class CnfStream */ } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PROP__CNF_STREAM_H */ diff --git a/src/prop/cryptominisat.cpp b/src/prop/cryptominisat.cpp index 91fc12c6c..ce5e4e2b0 100644 --- a/src/prop/cryptominisat.cpp +++ b/src/prop/cryptominisat.cpp @@ -22,7 +22,7 @@ #include <cryptominisat5/cryptominisat.h> -namespace CVC5 { +namespace cvc5 { namespace prop { using CMSatVar = unsigned; @@ -244,5 +244,5 @@ CryptoMinisatSolver::Statistics::~Statistics() { } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/cryptominisat.h b/src/prop/cryptominisat.h index fb118619c..65e1196f3 100644 --- a/src/prop/cryptominisat.h +++ b/src/prop/cryptominisat.h @@ -33,7 +33,7 @@ namespace CMSat { class SATSolver; } -namespace CVC5 { +namespace cvc5 { namespace prop { class CryptoMinisatSolver : public SatSolver @@ -106,7 +106,7 @@ class CryptoMinisatSolver : public SatSolver }; } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif // CVC4_USE_CRYPTOMINISAT #endif // CVC4__PROP__CRYPTOMINISAT_H diff --git a/src/prop/kissat.cpp b/src/prop/kissat.cpp index ccca3a3b4..10b7b07de 100644 --- a/src/prop/kissat.cpp +++ b/src/prop/kissat.cpp @@ -20,7 +20,7 @@ #include "base/check.h" -namespace CVC5 { +namespace cvc5 { namespace prop { using KissatLit = int32_t; @@ -173,6 +173,6 @@ KissatSolver::Statistics::~Statistics() } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif // CVC4_USE_KISSAT diff --git a/src/prop/kissat.h b/src/prop/kissat.h index 7bfcbac68..6984a7e50 100644 --- a/src/prop/kissat.h +++ b/src/prop/kissat.h @@ -28,7 +28,7 @@ extern "C" { #include <kissat/kissat.h> } -namespace CVC5 { +namespace cvc5 { namespace prop { class KissatSolver : public SatSolver @@ -97,7 +97,7 @@ class KissatSolver : public SatSolver }; } // namespace prop -} // namespace CVC5 +} // 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 b48044457..02182fde3 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 CVC5 { +namespace cvc5 { namespace Minisat { //================================================================================================= @@ -86,6 +86,6 @@ static void parse_DIMACS(gzFile input_stream, Solver& S) { //================================================================================================= } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/core/Solver.cc b/src/prop/minisat/core/Solver.cc index 9dbcada15..cd3ae5edf 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 CVC5::prop; +using namespace cvc5::prop; -namespace CVC5 { +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, - CVC5::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, - CVC5::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(CVC5::prop::TheoryProxy* proxy, - CVC5::context::Context* context, - CVC5::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( - CVC5::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( - CVC5::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") << CVC5::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") << CVC5::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(CVC5::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(CVC5::theory::Theory::EFFORT_FULL); + theoryCheck(cvc5::theory::Theory::EFFORT_FULL); } else { - theoryCheck(CVC5::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(CVC5::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" - << CVC5::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") << CVC5::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, - CVC5::TSatProof<Solver>* proof) + cvc5::TSatProof<Solver>* proof) { Debug("minisat") << "ClauseAllocator::reloc: cr " << cr << std::endl; // FIXME what is this CRef_lazy @@ -2398,4 +2398,4 @@ std::shared_ptr<ProofNode> Solver::getProof() bool Solver::isProofEnabled() const { return d_pfManager != nullptr; } } // namespace Minisat -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/minisat/core/Solver.h b/src/prop/minisat/core/Solver.h index 53f7a828c..9da0e2f89 100644 --- a/src/prop/minisat/core/Solver.h +++ b/src/prop/minisat/core/Solver.h @@ -38,16 +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 CVC5 { +namespace cvc5 { template <class Solver> class TSatProof; namespace prop { class PropEngine; class TheoryProxy; } // namespace prop -} // namespace CVC5 +} // namespace cvc5 -namespace CVC5 { +namespace cvc5 { namespace Minisat { //================================================================================================= @@ -56,10 +56,10 @@ namespace Minisat { class Solver { /** The only two CVC4 entry points to the private solver data */ - friend class CVC5::prop::PropEngine; - friend class CVC5::prop::TheoryProxy; - friend class CVC5::prop::SatProofManager; - friend class CVC5::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: static CRef TCRef_Undef; @@ -73,10 +73,10 @@ class Solver { protected: /** The pointer to the proxy that provides interfaces to the SMT engine */ - CVC5::prop::TheoryProxy* d_proxy; + cvc5::prop::TheoryProxy* d_proxy; /** The context from the SMT solver */ - CVC5::context::Context* d_context; + cvc5::context::Context* d_context; /** The current assertion level (user) */ int assertionLevel; @@ -88,7 +88,7 @@ class Solver { Var varFalse; /** The resolution proof manager */ - std::unique_ptr<CVC5::prop::SatProofManager> d_pfManager; + std::unique_ptr<cvc5::prop::SatProofManager> d_pfManager; public: /** Returns the current user assertion level */ @@ -105,7 +105,7 @@ class Solver { vec<bool> lemmas_removable; /** Nodes being converted to CNF */ - std::vector<CVC5::Node> lemmas_cnf_assertion; + std::vector<cvc5::Node> lemmas_cnf_assertion; /** Do a another check if FULL_EFFORT was the last one */ bool recheck; @@ -134,9 +134,9 @@ public: // Constructor/Destructor: // - Solver(CVC5::prop::TheoryProxy* proxy, - CVC5::context::Context* context, - CVC5::context::UserContext* userContext, + Solver(cvc5::prop::TheoryProxy* proxy, + cvc5::context::Context* context, + cvc5::context::UserContext* userContext, ProofNodeManager* pnm, bool enableIncremental = false); virtual ~Solver(); @@ -153,7 +153,7 @@ public: Var falseVar() const { return varFalse; } /** Retrive the SAT proof manager */ - CVC5::prop::SatProofManager* getProofManager(); + cvc5::prop::SatProofManager* getProofManager(); /** Retrive the refutation proof */ std::shared_ptr<ProofNode> getProof(); @@ -438,7 +438,7 @@ protected: CRef propagateBool (); // Perform Boolean propagation. Returns possibly conflicting clause. void propagateTheory (); // Perform Theory propagation. void theoryCheck( - CVC5::theory::Theory::Effort + 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. @@ -666,6 +666,6 @@ inline void Solver::toDimacs (const char* file, Lit p, Lit q, Lit r){ ve //================================================================================================= } // namespace Minisat -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/core/SolverTypes.h b/src/prop/minisat/core/SolverTypes.h index 4d9dd682d..c3f4279cb 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 CVC5 { +namespace cvc5 { namespace Minisat { class Solver; } template <class Solver> class TSatProof; -} // namespace CVC5 +} // namespace cvc5 -namespace CVC5 { +namespace cvc5 { namespace Minisat { //================================================================================================= @@ -183,9 +183,9 @@ inline std::ostream& operator <<(std::ostream& out, Minisat::lbool val) { } } // namespace Minisat -} // namespace CVC5 +} // namespace cvc5 -namespace CVC5 { +namespace cvc5 { namespace Minisat{ //================================================================================================= @@ -322,7 +322,7 @@ class ClauseAllocator : public RegionAllocator<uint32_t> void reloc(CRef& cr, ClauseAllocator& to, - CVC5::TSatProof<Solver>* proof = NULL); + cvc5::TSatProof<Solver>* proof = NULL); // Implementation moved to Solver.cc. }; @@ -500,6 +500,6 @@ inline void Clause::strengthen(Lit p) //================================================================================================= } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/minisat.cpp b/src/prop/minisat/minisat.cpp index e95677d57..07b345eda 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 CVC5 { +namespace cvc5 { namespace prop { //// DPllMinisatSatSolver @@ -301,20 +301,20 @@ void MinisatSatSolver::Statistics::init(Minisat::SimpSolver* minisat){ } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 -namespace CVC5 { +namespace cvc5 { template <> -prop::SatLiteral toSatLiteral<CVC5::Minisat::Solver>(Minisat::Solver::TLit lit) +prop::SatLiteral toSatLiteral<cvc5::Minisat::Solver>(Minisat::Solver::TLit lit) { return prop::MinisatSatSolver::toSatLiteral(lit); } template <> -void toSatClause<CVC5::Minisat::Solver>( - const CVC5::Minisat::Solver::TClause& minisat_cl, prop::SatClause& sat_cl) +void toSatClause<cvc5::Minisat::Solver>( + const cvc5::Minisat::Solver::TClause& minisat_cl, prop::SatClause& sat_cl) { prop::MinisatSatSolver::toSatClause(minisat_cl, sat_cl); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/minisat/minisat.h b/src/prop/minisat/minisat.h index 7dfeb6aa2..0a36b6297 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 CVC5 { +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, - CVC5::context::UserContext* userContext, + cvc5::context::UserContext* userContext, ProofNodeManager* pnm) override; ClauseId addClause(SatClause& clause, bool removable) override; @@ -119,4 +119,4 @@ class MinisatSatSolver : public CDCLTSatSolverInterface }; /* class MinisatSatSolver */ } // namespace prop -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/minisat/mtl/Alg.h b/src/prop/minisat/mtl/Alg.h index 37bc4b7b6..69b782da9 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 CVC5 { +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 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/mtl/Alloc.h b/src/prop/minisat/mtl/Alloc.h index 850aaeb73..f6e6d64b2 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 CVC5 { +namespace cvc5 { namespace Minisat { //================================================================================================= @@ -149,6 +149,6 @@ RegionAllocator<T>::alloc(int size) //================================================================================================= } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/mtl/Heap.h b/src/prop/minisat/mtl/Heap.h index e2ad1513f..7a88c874d 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 CVC5 { +namespace cvc5 { namespace Minisat { //================================================================================================= @@ -156,6 +156,6 @@ class Heap { //================================================================================================= } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/mtl/Map.h b/src/prop/minisat/mtl/Map.h index 2efed4433..1c48f3962 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 CVC5 { +namespace cvc5 { namespace Minisat { //================================================================================================= @@ -191,6 +191,6 @@ class Map { //================================================================================================= } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/mtl/Queue.h b/src/prop/minisat/mtl/Queue.h index ef30591bf..cdbc22600 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 CVC5 { +namespace cvc5 { namespace Minisat { //================================================================================================= @@ -86,6 +86,6 @@ public: //================================================================================================= } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/mtl/Sort.h b/src/prop/minisat/mtl/Sort.h index 7cf393847..2b9550d48 100644 --- a/src/prop/minisat/mtl/Sort.h +++ b/src/prop/minisat/mtl/Sort.h @@ -26,7 +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 CVC5 { +namespace cvc5 { namespace Minisat { template<class T> @@ -94,6 +94,6 @@ template <class T> void sort(vec<T>& v) { //================================================================================================= } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/mtl/Vec.h b/src/prop/minisat/mtl/Vec.h index e17e320d2..5410981f9 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 CVC5 { +namespace cvc5 { namespace Minisat { //================================================================================================= @@ -147,6 +147,6 @@ void vec<T>::clear(bool dealloc) { //================================================================================================= } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/mtl/XAlloc.h b/src/prop/minisat/mtl/XAlloc.h index 6bd8c02e8..300dbb16b 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 CVC5 { +namespace cvc5 { namespace Minisat { //================================================================================================= @@ -42,6 +42,6 @@ static inline void* xrealloc(void *ptr, size_t size) //================================================================================================= } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/simp/SimpSolver.cc b/src/prop/minisat/simp/SimpSolver.cc index 52162776b..e29c1032a 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 CVC5; -using namespace CVC5::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(CVC5::prop::TheoryProxy* proxy, - CVC5::context::Context* context, - CVC5::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 6c8a87d5e..63a5a93fd 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 CVC5 { +namespace cvc5 { namespace prop { class TheoryProxy; } -} // namespace CVC5 +} // namespace cvc5 -namespace CVC5 { +namespace cvc5 { namespace Minisat { //================================================================================================= @@ -42,9 +42,9 @@ class SimpSolver : public Solver { public: // Constructor/Destructor: // - SimpSolver(CVC5::prop::TheoryProxy* proxy, - CVC5::context::Context* context, - CVC5::context::UserContext* userContext, + SimpSolver(cvc5::prop::TheoryProxy* proxy, + cvc5::context::Context* context, + cvc5::context::UserContext* userContext, ProofNodeManager* pnm, bool enableIncremental = false); ~SimpSolver(); @@ -271,6 +271,6 @@ inline lbool SimpSolver::solve (Lit p, Lit q, Lit r, bool do_simp, bool t //================================================================================================= } // namespace Minisat - } // namespace CVC5 + } // namespace cvc5 #endif diff --git a/src/prop/minisat/utils/Options.h b/src/prop/minisat/utils/Options.h index f37b6305e..22e4cd6ee 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 CVC5 { +namespace cvc5 { namespace Minisat { //================================================================================================== @@ -432,6 +432,6 @@ class BoolOption : public Option //================================================================================================= } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/minisat/utils/ParseUtils.h b/src/prop/minisat/utils/ParseUtils.h index 27e454d00..ae8783e96 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 CVC5 { +namespace cvc5 { namespace Minisat { //------------------------------------------------------------------------------------------------- @@ -120,6 +120,6 @@ static bool eagerMatch(B& in, const char* str) { //================================================================================================= } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/proof_cnf_stream.cpp b/src/prop/proof_cnf_stream.cpp index ab5c59dd1..76421db9b 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 CVC5 { +namespace cvc5 { namespace prop { ProofCnfStream::ProofCnfStream(context::UserContext* u, @@ -1012,4 +1012,4 @@ SatLiteral ProofCnfStream::handleIte(TNode node) } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/proof_cnf_stream.h b/src/prop/proof_cnf_stream.h index 7c97a2e8e..fcca2cb34 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 CVC5 { +namespace cvc5 { namespace prop { class SatProofManager; @@ -170,6 +170,6 @@ class ProofCnfStream : public ProofGenerator }; } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/proof_post_processor.cpp b/src/prop/proof_post_processor.cpp index 7f075ab37..6b31e6053 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 CVC5 { +namespace cvc5 { namespace prop { ProofPostprocessCallback::ProofPostprocessCallback( @@ -105,4 +105,4 @@ void ProofPostproccess::process(std::shared_ptr<ProofNode> pf) } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/proof_post_processor.h b/src/prop/proof_post_processor.h index c74cb540f..363970117 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 CVC5 { +namespace cvc5 { namespace prop { @@ -107,6 +107,6 @@ class ProofPostproccess }; } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/prop/prop_engine.cpp b/src/prop/prop_engine.cpp index 9032dbb75..efe599106 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/prop/prop_engine.h b/src/prop/prop_engine.h index 1145961a1..a01668913 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 CVC5 { +namespace cvc5 { class ResourceManager; class DecisionEngine; @@ -381,6 +381,6 @@ class PropEngine }; } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PROP_ENGINE_H */ diff --git a/src/prop/prop_proof_manager.cpp b/src/prop/prop_proof_manager.cpp index cb380f92d..08c13fe5f 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 CVC5 { +namespace cvc5 { namespace prop { PropPfManager::PropPfManager(context::UserContext* userContext, @@ -109,4 +109,4 @@ std::shared_ptr<ProofNode> PropPfManager::getProof() } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/prop_proof_manager.h b/src/prop/prop_proof_manager.h index d8732c11a..9a080edc1 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 CVC5 { +namespace cvc5 { namespace prop { @@ -92,6 +92,6 @@ class PropPfManager }; /* class PropPfManager */ } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PROP__PROOF_MANAGER_H */ diff --git a/src/prop/registrar.h b/src/prop/registrar.h index d0fc0fe25..ae085b573 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 CVC5 { +namespace cvc5 { namespace prop { class Registrar { @@ -40,6 +40,6 @@ public: };/* class NullRegistrar */ } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PROP__REGISTRAR_H */ diff --git a/src/prop/sat_proof_manager.cpp b/src/prop/sat_proof_manager.cpp index a11eeaa8a..da9354c2f 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 CVC5 { +namespace cvc5 { namespace prop { SatProofManager::SatProofManager(Minisat::Solver* solver, @@ -753,4 +753,4 @@ void SatProofManager::registerSatAssumptions(const std::vector<Node>& assumps) } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/sat_proof_manager.h b/src/prop/sat_proof_manager.h index 514f0153b..4d45ce3b7 100644 --- a/src/prop/sat_proof_manager.h +++ b/src/prop/sat_proof_manager.h @@ -28,7 +28,7 @@ namespace Minisat { class Solver; } -namespace CVC5 { +namespace cvc5 { class ProofNodeManager; @@ -587,6 +587,6 @@ class SatProofManager }; /* class SatProofManager */ } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SAT_PROOF_MANAGER_H */ diff --git a/src/prop/sat_solver.h b/src/prop/sat_solver.h index f06171775..1f59a7bd6 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 CVC5 { +namespace cvc5 { namespace prop { @@ -150,7 +150,7 @@ class CDCLTSatSolverInterface : public SatSolver virtual void initialize(context::Context* context, prop::TheoryProxy* theoryProxy, - CVC5::context::UserContext* userContext, + cvc5::context::UserContext* userContext, ProofNodeManager* pnm) = 0; virtual void push() = 0; @@ -209,6 +209,6 @@ inline std::ostream& operator <<(std::ostream& out, prop::SatValue val) { } } // namespace prop -} // namespace CVC5 +} // 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 1d933dce8..117210431 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 CVC5 { +namespace cvc5 { namespace prop { BVSatSolverInterface* SatSolverFactory::createMinisat( @@ -76,4 +76,4 @@ SatSolver* SatSolverFactory::createKissat(StatisticsRegistry* registry, } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/sat_solver_factory.h b/src/prop/sat_solver_factory.h index 97b018e09..71e28ac39 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 CVC5 { +namespace cvc5 { namespace prop { class SatSolverFactory @@ -50,6 +50,6 @@ class SatSolverFactory }; /* class SatSolverFactory */ } // namespace prop -} // namespace CVC5 +} // 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 3380329c3..13494221e 100644 --- a/src/prop/sat_solver_types.cpp +++ b/src/prop/sat_solver_types.cpp @@ -18,11 +18,11 @@ #include <algorithm> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/prop/sat_solver_types.h b/src/prop/sat_solver_types.h index 392dfb2b1..0ab0cba53 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 CVC5 { +namespace cvc5 { namespace prop { /** @@ -235,4 +235,4 @@ enum SatSolverLifespan }; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/skolem_def_manager.cpp b/src/prop/skolem_def_manager.cpp index a0819e571..dbc640d8c 100644 --- a/src/prop/skolem_def_manager.cpp +++ b/src/prop/skolem_def_manager.cpp @@ -16,7 +16,7 @@ #include "expr/attribute.h" -namespace CVC5 { +namespace cvc5 { namespace prop { SkolemDefManager::SkolemDefManager(context::Context* context, @@ -170,4 +170,4 @@ void SkolemDefManager::getSkolems( } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/skolem_def_manager.h b/src/prop/skolem_def_manager.h index 6f4ec031f..11b726c2a 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 CVC5 { +namespace cvc5 { namespace prop { /** @@ -86,6 +86,6 @@ class SkolemDefManager }; } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PROP__SKOLEM_DEF_MANAGER_H */ diff --git a/src/prop/theory_proxy.cpp b/src/prop/theory_proxy.cpp index ffec0c365..4a95591b4 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 CVC5 { +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 (CVC5::options::produceProofs()) + if (cvc5::options::produceProofs()) { d_propEngine->getProofCnfStream()->convertPropagation(tte); } @@ -233,4 +233,4 @@ void TheoryProxy::getSkolems(TNode node, void TheoryProxy::preRegister(Node n) { d_theoryEngine->preRegister(n); } } // namespace prop -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/prop/theory_proxy.h b/src/prop/theory_proxy.h index dedd1fa49..3b21bde58 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 CVC5 { +namespace cvc5 { class DecisionEngine; class TheoryEngine; @@ -167,6 +167,6 @@ class TheoryProxy : public Registrar } // namespace prop -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PROP__SAT_H */ diff --git a/src/smt/abduction_solver.cpp b/src/smt/abduction_solver.cpp index cd4228eed..804a93401 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 CVC5::theory; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace smt { AbductionSolver::AbductionSolver(SmtEngine* parent) : d_parent(parent) {} @@ -195,4 +195,4 @@ void AbductionSolver::checkAbduct(Node a) } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/abduction_solver.h b/src/smt/abduction_solver.h index c7328a9a8..03b300a7a 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 CVC5 { +namespace cvc5 { class SmtEngine; @@ -115,6 +115,6 @@ class AbductionSolver }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__ABDUCTION_SOLVER_H */ diff --git a/src/smt/abstract_values.cpp b/src/smt/abstract_values.cpp index e4c7f2668..fc978d39b 100644 --- a/src/smt/abstract_values.cpp +++ b/src/smt/abstract_values.cpp @@ -16,7 +16,7 @@ #include "options/smt_options.h" -namespace CVC5 { +namespace cvc5 { namespace smt { AbstractValues::AbstractValues(NodeManager* nm) @@ -52,4 +52,4 @@ Node AbstractValues::mkAbstractValue(TNode n) } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/abstract_values.h b/src/smt/abstract_values.h index be4a0c7a3..5a7ce7ba1 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 CVC5 { +namespace cvc5 { namespace smt { /** @@ -75,6 +75,6 @@ class AbstractValues }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/assertions.cpp b/src/smt/assertions.cpp index f82d0769b..07d072751 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 CVC5::theory; -using namespace CVC5::kind; +using namespace cvc5::theory; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace smt { Assertions::Assertions(context::UserContext* u, AbstractValues& absv) @@ -243,4 +243,4 @@ bool Assertions::isProofEnabled() const } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/assertions.h b/src/smt/assertions.h index 135fe8974..687c9b742 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 CVC5 { +namespace cvc5 { namespace smt { class AbstractValues; @@ -172,6 +172,6 @@ class Assertions }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/check_models.cpp b/src/smt/check_models.cpp index 0c21002af..b84bc3e64 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 CVC5::theory; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace smt { CheckModels::CheckModels(SmtSolver& s) : d_smt(s) {} @@ -148,4 +148,4 @@ void CheckModels::checkModel(Model* m, } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/check_models.h b/src/smt/check_models.h index d12a33ee5..2d9f4cf1b 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 CVC5 { +namespace cvc5 { namespace smt { class Model; @@ -48,6 +48,6 @@ class CheckModels }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/command.cpp b/src/smt/command.cpp index 6d9b1a5ec..e4b179cf4 100644 --- a/src/smt/command.cpp +++ b/src/smt/command.cpp @@ -43,7 +43,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { std::string sexprToString(api::Term sexpr) { @@ -2819,4 +2819,4 @@ void DatatypeDeclarationCommand::toStream(std::ostream& out, out, api::Sort::sortVectorToTypeNodes(d_datatypes)); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/command.h b/src/smt/command.h index 6d169ce5e..2d13a2246 100644 --- a/src/smt/command.h +++ b/src/smt/command.h @@ -31,7 +31,7 @@ #include "cvc4_export.h" #include "options/language.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__COMMAND_H */ diff --git a/src/smt/defined_function.h b/src/smt/defined_function.h index 7f3007975..2a7332297 100644 --- a/src/smt/defined_function.h +++ b/src/smt/defined_function.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace smt { /** @@ -55,6 +55,6 @@ class DefinedFunction }; /* class DefinedFunction */ } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__DEFINED_FUNCTION_H */ diff --git a/src/smt/dump.cpp b/src/smt/dump.cpp index 76973ec32..e00ed907f 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 CVC5 { +namespace cvc5 { #if defined(CVC4_DUMPING) && !defined(CVC4_MUZZLE) @@ -58,13 +58,13 @@ CVC4dumpstream& CVC4dumpstream::operator<<(const NodeCommand& nc) DumpC DumpChannel; std::ostream& DumpC::setStream(std::ostream* os) { - ::CVC5::DumpOutChannel.setStream(os); + ::cvc5::DumpOutChannel.setStream(os); return *os; } -std::ostream& DumpC::getStream() { return ::CVC5::DumpOutChannel.getStream(); } +std::ostream& DumpC::getStream() { return ::cvc5::DumpOutChannel.getStream(); } std::ostream* DumpC::getStreamPointer() { - return ::CVC5::DumpOutChannel.getStreamPointer(); + return ::cvc5::DumpOutChannel.getStreamPointer(); } void DumpC::setDumpFromString(const std::string& optarg) { @@ -243,4 +243,4 @@ pipe to perform on-line checking. The --dump-to option can be used to dump\n\ to a file.\n\ "; -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/dump.h b/src/smt/dump.h index be146470a..e4fe15aa7 100644 --- a/src/smt/dump.h +++ b/src/smt/dump.h @@ -21,7 +21,7 @@ #include "base/output.h" -namespace CVC5 { +namespace cvc5 { class Command; class NodeCommand; @@ -110,8 +110,8 @@ class DumpC /** The dump singleton */ extern DumpC DumpChannel; -#define Dump ::CVC5::DumpChannel +#define Dump ::cvc5::DumpChannel -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__DUMP_H */ diff --git a/src/smt/dump_manager.cpp b/src/smt/dump_manager.cpp index 6b81d5594..4b7f0b056 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 CVC5 { +namespace cvc5 { namespace smt { DumpManager::DumpManager(context::UserContext* u) @@ -72,4 +72,4 @@ void DumpManager::setPrintFuncInModel(Node f, bool p) } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/dump_manager.h b/src/smt/dump_manager.h index 519b93110..c1bd7e898 100644 --- a/src/smt/dump_manager.h +++ b/src/smt/dump_manager.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { class NodeCommand; @@ -75,6 +75,6 @@ class DumpManager }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/env.cpp b/src/smt/env.cpp index 6440c29d3..fc19299d4 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 CVC5::smt; +using namespace cvc5::smt; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/smt/env.h b/src/smt/env.h index 3ceefdd34..79377206a 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 CVC5 { +namespace cvc5 { class NodeManager; class StatisticsRegistry; @@ -182,6 +182,6 @@ class Env std::unique_ptr<ResourceManager> d_resourceManager; }; /* class Env */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__ENV_H */ diff --git a/src/smt/expand_definitions.cpp b/src/smt/expand_definitions.cpp index 599f57747..85a2732c9 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 CVC5::preprocessing; -using namespace CVC5::theory; -using namespace CVC5::kind; +using namespace cvc5::preprocessing; +using namespace cvc5::theory; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace smt { ExpandDefs::ExpandDefs(SmtEngine& smt, @@ -367,4 +367,4 @@ void ExpandDefs::setProofNodeManager(ProofNodeManager* pnm) } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/expand_definitions.h b/src/smt/expand_definitions.h index 035e7989d..7d99445d5 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 CVC5 { +namespace cvc5 { class ProofNodeManager; class ResourceManager; @@ -95,6 +95,6 @@ class ExpandDefs }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/interpolation_solver.cpp b/src/smt/interpolation_solver.cpp index d14b87901..7b75ea2ed 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 CVC5::theory; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace smt { InterpolationSolver::InterpolationSolver(SmtEngine* parent) : d_parent(parent) @@ -136,4 +136,4 @@ void InterpolationSolver::checkInterpol(Node interpol, } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/interpolation_solver.h b/src/smt/interpolation_solver.h index 1c9b65d85..bae777a16 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 CVC5 { +namespace cvc5 { class SmtEngine; @@ -81,6 +81,6 @@ class InterpolationSolver }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__INTERPOLATION_SOLVER_H */ diff --git a/src/smt/listeners.cpp b/src/smt/listeners.cpp index c686e4115..e322531a7 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 CVC5 { +namespace cvc5 { namespace smt { ResourceOutListener::ResourceOutListener(SmtEngine& smt) : d_smt(smt) {} @@ -103,4 +103,4 @@ void SmtNodeManagerListener::nmNotifyNewSkolem(TNode n, } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/listeners.h b/src/smt/listeners.h index 1705b9126..6857f7e6b 100644 --- a/src/smt/listeners.h +++ b/src/smt/listeners.h @@ -22,7 +22,7 @@ #include "base/listener.h" #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { class OutputManager; class SmtEngine; @@ -75,6 +75,6 @@ class SmtNodeManagerListener : public NodeManagerListener }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/logic_exception.h b/src/smt/logic_exception.h index 91f2d3723..0809d83e8 100644 --- a/src/smt/logic_exception.h +++ b/src/smt/logic_exception.h @@ -24,9 +24,9 @@ #include "base/exception.h" -namespace CVC5 { +namespace cvc5 { -class LogicException : public CVC5::Exception +class LogicException : public cvc5::Exception { public: LogicException() : @@ -43,6 +43,6 @@ class LogicException : public CVC5::Exception } }; /* class LogicException */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__LOGIC_EXCEPTION_H */ diff --git a/src/smt/managed_ostreams.cpp b/src/smt/managed_ostreams.cpp index 6baabe0e5..09b454cf2 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 CVC5 { +namespace cvc5 { ManagedOstream::ManagedOstream() : d_managed(NULL) {} @@ -164,4 +164,4 @@ void ManagedDiagnosticOutputChannel::addSpecialCases(OstreamOpener* opener) opener->addSpecialCase("stderr", &std::cerr); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/managed_ostreams.h b/src/smt/managed_ostreams.h index ba56bcfa3..f79eecc23 100644 --- a/src/smt/managed_ostreams.h +++ b/src/smt/managed_ostreams.h @@ -22,7 +22,7 @@ #include <ostream> -namespace CVC5 { +namespace cvc5 { class OstreamOpener; @@ -141,6 +141,6 @@ class ManagedDiagnosticOutputChannel : public ManagedOstream { void addSpecialCases(OstreamOpener* opener) const override; };/* class ManagedRegularOutputChannel */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__MANAGED_OSTREAMS_H */ diff --git a/src/smt/model.cpp b/src/smt/model.cpp index c1b9b7c12..a3742b652 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 CVC5 { +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 -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/model.h b/src/smt/model.h index f43ba6eec..5eb1e45a4 100644 --- a/src/smt/model.h +++ b/src/smt/model.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC5 { +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 ::CVC5::SmtEngine; + friend class ::cvc5::SmtEngine; public: /** construct */ @@ -118,6 +118,6 @@ class Model { }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__MODEL_H */ diff --git a/src/smt/model_blocker.cpp b/src/smt/model_blocker.cpp index 964a59b2f..64769a2ad 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/smt/model_blocker.h b/src/smt/model_blocker.h index 3ec28758f..6d03a64c6 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 CVC5 { +namespace cvc5 { namespace theory { class TheoryModel; @@ -69,6 +69,6 @@ class ModelBlocker const std::vector<Node>& exprToBlock = std::vector<Node>()); }; /* class TheoryModelCoreBuilder */ -} // namespace CVC5 +} // 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 b68797f61..f16c93e62 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/smt/model_core_builder.h b/src/smt/model_core_builder.h index 6075b528f..38a9e51ed 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 CVC5 { +namespace cvc5 { /** * A utility for building model cores. @@ -59,6 +59,6 @@ class ModelCoreBuilder options::ModelCoresMode mode); }; /* class TheoryModelCoreBuilder */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__MODEL_CORE_BUILDER_H */ diff --git a/src/smt/node_command.cpp b/src/smt/node_command.cpp index 487a65ddf..61d380b72 100644 --- a/src/smt/node_command.cpp +++ b/src/smt/node_command.cpp @@ -20,7 +20,7 @@ #include "printer/printer.h" -namespace CVC5 { +namespace cvc5 { /* -------------------------------------------------------------------------- */ /* class NodeCommand */ @@ -158,4 +158,4 @@ NodeCommand* DefineFunctionNodeCommand::clone() const return new DefineFunctionNodeCommand(d_id, d_fun, d_formals, d_formula); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/node_command.h b/src/smt/node_command.h index 0820ea807..9ba2b316d 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__NODE_COMMAND_H */ diff --git a/src/smt/optimization_solver.cpp b/src/smt/optimization_solver.cpp index 2143b9467..ae1ce7057 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 CVC5::theory; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace smt { /** @@ -134,4 +134,4 @@ ObjectiveType Objective::getType() { return d_type; } Node Objective::getNode() { return d_node; } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/optimization_solver.h b/src/smt/optimization_solver.h index c24a4ae52..b79a4a823 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 CVC5 { +namespace cvc5 { class SmtEngine; @@ -114,6 +114,6 @@ class Objective }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__OPTIMIZATION_SOLVER_H */ diff --git a/src/smt/options_manager.cpp b/src/smt/options_manager.cpp index d78435754..0a7a0c54a 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 CVC5 { +namespace cvc5 { namespace smt { OptionsManager::OptionsManager(Options* opts, ResourceManager* rm) @@ -143,4 +143,4 @@ void OptionsManager::finishInit(LogicInfo& logic, bool isInternalSubsolver) } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/options_manager.h b/src/smt/options_manager.h index 29e222296..62ad37eb0 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 CVC5 { +namespace cvc5 { class LogicInfo; class Options; @@ -75,6 +75,6 @@ class OptionsManager : public OptionsListener }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__OPTIONS_MANAGER_H */ diff --git a/src/smt/output_manager.cpp b/src/smt/output_manager.cpp index 6d01643ab..a01c7a6a9 100644 --- a/src/smt/output_manager.cpp +++ b/src/smt/output_manager.cpp @@ -18,7 +18,7 @@ #include "smt/smt_engine.h" -namespace CVC5 { +namespace cvc5 { OutputManager::OutputManager(SmtEngine* smt) : d_smt(smt) {} @@ -29,4 +29,4 @@ std::ostream& OutputManager::getDumpOut() const return *d_smt->getOptions().getOut(); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/output_manager.h b/src/smt/output_manager.h index 76db5d19b..de21dc2b5 100644 --- a/src/smt/output_manager.h +++ b/src/smt/output_manager.h @@ -20,7 +20,7 @@ #include <ostream> -namespace CVC5 { +namespace cvc5 { class Printer; class SmtEngine; @@ -52,6 +52,6 @@ class OutputManager SmtEngine* d_smt; }; -} // namespace CVC5 +} // 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 0fd3d9ce6..016f60cfc 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 CVC5 { +namespace cvc5 { namespace smt { PreprocessProofGenerator::PreprocessProofGenerator(ProofNodeManager* pnm, @@ -254,4 +254,4 @@ void PreprocessProofGenerator::checkEagerPedantic(PfRule r) } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/preprocess_proof_generator.h b/src/smt/preprocess_proof_generator.h index 338397488..8e3882b2a 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 CVC5 { +namespace cvc5 { class LazyCDProof; class ProofNodeManager; @@ -144,6 +144,6 @@ class PreprocessProofGenerator : public ProofGenerator }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/preprocessor.cpp b/src/smt/preprocessor.cpp index c2ebdbcd0..9f1f71bd7 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 CVC5::theory; -using namespace CVC5::kind; +using namespace cvc5::theory; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace smt { Preprocessor::Preprocessor(SmtEngine& smt, @@ -159,4 +159,4 @@ void Preprocessor::setProofGenerator(PreprocessProofGenerator* pppg) } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/preprocessor.h b/src/smt/preprocessor.h index 6bb0ef5d6..0d307d734 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 CVC5 { +namespace cvc5 { namespace preprocessing { class PreprocessingPassContext; } @@ -128,6 +128,6 @@ class Preprocessor }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/process_assertions.cpp b/src/smt/process_assertions.cpp index 7ff4e54b5..29651211c 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 CVC5::preprocessing; -using namespace CVC5::theory; -using namespace CVC5::kind; +using namespace cvc5::preprocessing; +using namespace cvc5::theory; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/smt/process_assertions.h b/src/smt/process_assertions.h index 3844daafb..0409e181b 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 CVC5 { +namespace cvc5 { class SmtEngine; @@ -124,6 +124,6 @@ class ProcessAssertions }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/proof_manager.cpp b/src/smt/proof_manager.cpp index d3b650612..5b938ab64 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 CVC5 { +namespace cvc5 { namespace smt { PfManager::PfManager(context::UserContext* u, SmtEngine* smte) @@ -190,4 +190,4 @@ void PfManager::getAssertions(Assertions& as, } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/proof_manager.h b/src/smt/proof_manager.h index f0f384b7c..e1177ca83 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 CVC5 { +namespace cvc5 { class ProofChecker; class ProofNode; @@ -117,6 +117,6 @@ class PfManager }; /* class SmtEngine */ } // namespace smt -} // namespace CVC5 +} // 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 7e48c5c48..dedb686c3 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 CVC5::kind; -using namespace CVC5::theory; +using namespace cvc5::kind; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace smt { ProofPostprocessCallback::ProofPostprocessCallback(ProofNodeManager* pnm, @@ -1185,4 +1185,4 @@ void ProofPostproccess::setEliminateRule(PfRule rule) } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/proof_post_processor.h b/src/smt/proof_post_processor.h index 3c0d1e841..9f3e7e55b 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 CVC5 { +namespace cvc5 { class SmtEngine; @@ -303,6 +303,6 @@ class ProofPostproccess }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/quant_elim_solver.cpp b/src/smt/quant_elim_solver.cpp index 08b69af81..ddc20ee8d 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 CVC5::theory; -using namespace CVC5::kind; +using namespace cvc5::theory; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace smt { QuantElimSolver::QuantElimSolver(SmtSolver& sms) : d_smtSolver(sms) {} @@ -130,4 +130,4 @@ Node QuantElimSolver::getQuantifierElimination(Assertions& as, } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/quant_elim_solver.h b/src/smt/quant_elim_solver.h index 80f67371b..e59d6c7ff 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 CVC5 { +namespace cvc5 { namespace smt { class SmtSolver; @@ -99,6 +99,6 @@ class QuantElimSolver }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__QUANT_ELIM_SOLVER_H */ diff --git a/src/smt/set_defaults.cpp b/src/smt/set_defaults.cpp index dd76de313..5fed0d664 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 CVC5::theory; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { namespace smt { void setDefaults(LogicInfo& logic, bool isInternalSubsolver) @@ -1480,4 +1480,4 @@ void setDefaults(LogicInfo& logic, bool isInternalSubsolver) } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/set_defaults.h b/src/smt/set_defaults.h index 220314b0d..eb7cc3910 100644 --- a/src/smt/set_defaults.h +++ b/src/smt/set_defaults.h @@ -17,7 +17,7 @@ #include "theory/logic_info.h" -namespace CVC5 { +namespace cvc5 { namespace smt { /** @@ -36,6 +36,6 @@ namespace smt { void setDefaults(LogicInfo& logic, bool isInternalSubsolver); } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__SET_DEFAULTS_H */ diff --git a/src/smt/smt_engine.cpp b/src/smt/smt_engine.cpp index db67af2f0..724c5d48f 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 CVC5::smt; -using namespace CVC5::preprocessing; -using namespace CVC5::prop; -using namespace CVC5::context; -using namespace CVC5::theory; +using namespace cvc5::smt; +using namespace cvc5::preprocessing; +using namespace cvc5::prop; +using namespace cvc5::context; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { SmtEngine::SmtEngine(NodeManager* nm, Options* optr) : d_env(new Env(nm)), @@ -503,7 +503,7 @@ bool SmtEngine::isValidGetInfoFlag(const std::string& key) const return false; } -CVC5::SExpr SmtEngine::getInfo(const std::string& key) const +cvc5::SExpr SmtEngine::getInfo(const std::string& key) const { SmtScope smts(this); @@ -2027,4 +2027,4 @@ OutputManager& SmtEngine::getOutputManager() { return d_outMgr; } theory::Rewriter* SmtEngine::getRewriter() { return d_env->getRewriter(); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/smt_engine.h b/src/smt/smt_engine.h index dd23ac949..909c1cc50 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 CVC5 { +namespace cvc5 { template <bool ref_count> class NodeTemplate; typedef NodeTemplate<true> Node; @@ -124,10 +124,10 @@ namespace theory { class CVC4_EXPORT SmtEngine { - friend class ::CVC5::api::Solver; - friend class ::CVC5::smt::SmtEngineState; - friend class ::CVC5::smt::SmtScope; - friend class ::CVC5::LogicRequest; + friend class ::cvc5::api::Solver; + friend class ::cvc5::smt::SmtEngineState; + friend class ::cvc5::smt::SmtScope; + friend class ::cvc5::LogicRequest; /* ....................................................................... */ public: @@ -219,7 +219,7 @@ class CVC4_EXPORT SmtEngine bool isValidGetInfoFlag(const std::string& key) const; /** Query information about the SMT environment. */ - CVC5::SExpr getInfo(const std::string& key) const; + cvc5::SExpr getInfo(const std::string& key) const; /** * Set an aspect of the current SMT execution environment. @@ -1154,6 +1154,6 @@ class CVC4_EXPORT SmtEngine /* -------------------------------------------------------------------------- */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT_ENGINE_H */ diff --git a/src/smt/smt_engine_scope.cpp b/src/smt/smt_engine_scope.cpp index d3dff72ce..cbb6a9679 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 CVC5 { +namespace cvc5 { namespace smt { thread_local SmtEngine* s_smtEngine_current = NULL; @@ -66,4 +66,4 @@ StatisticsRegistry* SmtScope::currentStatisticsRegistry() { } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/smt_engine_scope.h b/src/smt/smt_engine_scope.h index e45679f79..8bb010cec 100644 --- a/src/smt/smt_engine_scope.h +++ b/src/smt/smt_engine_scope.h @@ -24,7 +24,7 @@ #include "options/options.h" -namespace CVC5 { +namespace cvc5 { class ProofManager; class SmtEngine; @@ -60,6 +60,6 @@ class SmtScope : public NodeManagerScope };/* class SmtScope */ } // namespace smt -} // namespace CVC5 +} // 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 fcf02784f..b33f1e13c 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 CVC5 { +namespace cvc5 { namespace smt { SmtEngineState::SmtEngineState(context::Context* c, @@ -308,4 +308,4 @@ void SmtEngineState::doPendingPops() } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/smt_engine_state.h b/src/smt/smt_engine_state.h index b5d98832f..b90778b67 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 CVC5 { +namespace cvc5 { class SmtEngine; @@ -261,6 +261,6 @@ class SmtEngineState }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/smt_engine_stats.cpp b/src/smt/smt_engine_stats.cpp index 1becdc8c2..b0de2d8b3 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 CVC5 { +namespace cvc5 { namespace smt { SmtEngineStatistics::SmtEngineStatistics() @@ -70,4 +70,4 @@ SmtEngineStatistics::~SmtEngineStatistics() } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/smt_engine_stats.h b/src/smt/smt_engine_stats.h index e0923ec3e..4ec06e99b 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 CVC5 { +namespace cvc5 { namespace smt { struct SmtEngineStatistics @@ -60,6 +60,6 @@ struct SmtEngineStatistics }; /* struct SmtEngineStatistics */ } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__SMT_ENGINE_STATS_H */ diff --git a/src/smt/smt_mode.cpp b/src/smt/smt_mode.cpp index f25607249..db21e53c4 100644 --- a/src/smt/smt_mode.cpp +++ b/src/smt/smt_mode.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/smt/smt_mode.h b/src/smt/smt_mode.h index 91c35fc1f..ce8babc2b 100644 --- a/src/smt/smt_mode.h +++ b/src/smt/smt_mode.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/smt/smt_solver.cpp b/src/smt/smt_solver.cpp index e8ac58fe7..3f663726c 100644 --- a/src/smt/smt_solver.cpp +++ b/src/smt/smt_solver.cpp @@ -27,7 +27,7 @@ using namespace std; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/smt/smt_solver.h b/src/smt/smt_solver.h index db4871381..7d9d06ad9 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 CVC5 { +namespace cvc5 { class SmtEngine; class TheoryEngine; @@ -151,6 +151,6 @@ class SmtSolver }; } // namespace smt -} // namespace CVC5 +} // 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 a916aae7b..dd5ed470c 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 CVC5 { +namespace cvc5 { StatisticsRegistry* smtStatisticsRegistry() { return smt::SmtScope::currentStatisticsRegistry(); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/smt_statistics_registry.h b/src/smt/smt_statistics_registry.h index 31d151544..97bdde703 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 CVC5 { +namespace cvc5 { /** * This returns the StatisticsRegistry attached to the currently in scope @@ -28,4 +28,4 @@ namespace CVC5 { */ StatisticsRegistry* smtStatisticsRegistry(); -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/sygus_solver.cpp b/src/smt/sygus_solver.cpp index 2bb38ea98..27e16ccc6 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 CVC5::theory; -using namespace CVC5::kind; +using namespace cvc5::theory; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace smt { SygusSolver::SygusSolver(SmtSolver& sms, @@ -412,4 +412,4 @@ void SygusSolver::setSygusConjectureStale() } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/sygus_solver.h b/src/smt/sygus_solver.h index a1ffa195d..ffce2ff06 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 CVC5 { +namespace cvc5 { class OutputManager; @@ -189,6 +189,6 @@ class SygusSolver }; } // namespace smt -} // namespace CVC5 +} // 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 4d726b64e..262c46870 100644 --- a/src/smt/term_formula_removal.cpp +++ b/src/smt/term_formula_removal.cpp @@ -28,7 +28,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { RemoveTermFormulas::RemoveTermFormulas(context::UserContext* u, ProofNodeManager* pnm) @@ -544,4 +544,4 @@ ProofGenerator* RemoveTermFormulas::getTConvProofGenerator() bool RemoveTermFormulas::isProofEnabled() const { return d_pnm != nullptr; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/term_formula_removal.h b/src/smt/term_formula_removal.h index 0f80fb8a4..d2d3bf6fd 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 CVC5 { +namespace cvc5 { class LazyCDProof; class ProofNodeManager; @@ -209,4 +209,4 @@ class RemoveTermFormulas { bool isProofEnabled() const; };/* class RemoveTTE */ -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/unsat_core_manager.cpp b/src/smt/unsat_core_manager.cpp index 4d17c7414..976e7ea6c 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 CVC5 { +namespace cvc5 { namespace smt { void UnsatCoreManager::getUnsatCore(std::shared_ptr<ProofNode> pfn, @@ -89,4 +89,4 @@ void UnsatCoreManager::getRelevantInstantiations( } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/unsat_core_manager.h b/src/smt/unsat_core_manager.h index 92e6018df..c41638222 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 CVC5 { +namespace cvc5 { namespace smt { @@ -67,6 +67,6 @@ class UnsatCoreManager }; /* class UnsatCoreManager */ } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SMT__UNSAT_CORE_MANAGER_H */ diff --git a/src/smt/update_ostream.h b/src/smt/update_ostream.h index 691da984f..c8f5d639b 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 CVC5 { +namespace cvc5 { class ChannelSettings { public: @@ -116,6 +116,6 @@ class TraceOstreamUpdate : public OstreamUpdate { void set(std::ostream* setTo) override { Trace.setStream(setTo); } }; /* class TraceOstreamUpdate */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__UPDATE_OSTREAM_H */ diff --git a/src/smt/witness_form.cpp b/src/smt/witness_form.cpp index 959a6a6c3..2ae39a664 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 CVC5 { +namespace cvc5 { namespace smt { WitnessFormGenerator::WitnessFormGenerator(ProofNodeManager* pnm) @@ -152,4 +152,4 @@ ProofGenerator* WitnessFormGenerator::convertExistsInternal(Node exists) } } // namespace smt -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt/witness_form.h b/src/smt/witness_form.h index 905b0624b..e30f165e5 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 CVC5 { +namespace cvc5 { namespace smt { /** @@ -97,6 +97,6 @@ class WitnessFormGenerator : public ProofGenerator }; } // namespace smt -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/smt_util/boolean_simplification.cpp b/src/smt_util/boolean_simplification.cpp index 01f1a6a5b..6bfbede92 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 CVC5 { +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() */ -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt_util/boolean_simplification.h b/src/smt_util/boolean_simplification.h index d9251baf5..de53e539c 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 CVC5 { +namespace cvc5 { /** * A class to contain a number of useful functions for simple @@ -223,6 +223,6 @@ class BooleanSimplification { };/* class BooleanSimplification */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__BOOLEAN_SIMPLIFICATION_H */ diff --git a/src/smt_util/nary_builder.cpp b/src/smt_util/nary_builder.cpp index 41da7e170..efff058c5 100644 --- a/src/smt_util/nary_builder.cpp +++ b/src/smt_util/nary_builder.cpp @@ -20,7 +20,7 @@ using namespace std; -namespace CVC5 { +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 */ -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/smt_util/nary_builder.h b/src/smt_util/nary_builder.h index dc8a428d0..6fdc541ca 100644 --- a/src/smt_util/nary_builder.h +++ b/src/smt_util/nary_builder.h @@ -24,7 +24,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace util { class NaryBuilder { @@ -53,4 +53,4 @@ private: };/* class RePairAssocCommutativeOperators */ }/* util namespace */ -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/approx_simplex.cpp b/src/theory/arith/approx_simplex.cpp index c911d03e9..8e75f6850 100644 --- a/src/theory/arith/approx_simplex.cpp +++ b/src/theory/arith/approx_simplex.cpp @@ -36,7 +36,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -369,7 +369,7 @@ public: } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -537,12 +537,12 @@ int ApproxGLPK::s_verbosity = 0; } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /*#ifdef CVC4_USE_GLPK */ /* End the declaration of GLPK specific code. */ /* Begin GPLK/NOGLPK Glue code. */ -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { ApproximateSimplex* ApproximateSimplex::mkApproximateSimplexSolver(const ArithVariables& vars, TreeLog& l, ApproximateStatistics& s){ @@ -561,12 +561,12 @@ bool ApproximateSimplex::enabled() { } } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 /* End GPLK/NOGLPK Glue code. */ /* Begin GPLK implementation. */ #ifdef CVC4_USE_GLPK -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -3176,6 +3176,6 @@ void ApproxGLPK::tryCut(int nid, CutInfo& cut) } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 5835c57c1..787effc94 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -165,4 +165,4 @@ class ApproximateSimplex{ } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/arith_ite_utils.cpp b/src/theory/arith/arith_ite_utils.cpp index 42189f86a..4c991dba3 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -47,7 +47,7 @@ Node ArithIteUtils::applyReduceVariablesInItes(Node n){ } Node ArithIteUtils::reduceVariablesInItes(Node n){ - using namespace CVC5::kind; + using namespace cvc5::kind; if(d_reduceVar.find(n) != d_reduceVar.end()){ Node res = d_reduceVar[n]; return res.isNull() ? n : res; @@ -457,4 +457,4 @@ bool ArithIteUtils::solveBinOr(TNode binor){ } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/arith_ite_utils.h b/src/theory/arith/arith_ite_utils.h index 263ddda8e..3e548f42d 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 CVC5 { +namespace cvc5 { namespace preprocessing { namespace util { class ContainsTermITEVisitor; @@ -111,6 +111,6 @@ private: } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 9190dac7d..a2ae138fd 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { bool ArithMSum::getMonomial(Node n, Node& c, Node& v) @@ -322,4 +322,4 @@ void ArithMSum::debugPrintMonomialSum(std::map<Node, Node>& msum, const char* c) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/arith_msum.h b/src/theory/arith/arith_msum.h index f4a2bf824..7854e0d3b 100644 --- a/src/theory/arith/arith_msum.h +++ b/src/theory/arith/arith_msum.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { /** Arithmetic utilities regarding monomial sums. @@ -183,6 +183,6 @@ class ArithMSum }; } // namespace theory -} // namespace CVC5 +} // 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 2b120c9c7..e57b6c57f 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -80,4 +80,4 @@ bool ArithPreprocess::isReduced(TNode atom) const } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/arith_preprocess.h b/src/theory/arith/arith_preprocess.h index 45ce0c597..663c09abe 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 CVC5 { +namespace cvc5 { namespace theory { class SkolemLemma; @@ -86,6 +86,6 @@ class ArithPreprocess } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/arith_rewriter.cpp b/src/theory/arith/arith_rewriter.cpp index 01e88b1a8..87aba7b45 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 CVC5 { +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()){ - CVC5::Rational r(expr::NodeValue::MAX_CHILDREN); + cvc5::Rational r(expr::NodeValue::MAX_CHILDREN); if (exp <= r) { unsigned num = exp.getNumerator().toUnsignedInt(); @@ -901,4 +901,4 @@ RewriteResponse ArithRewriter::returnRewrite(TNode t, Node ret, Rewrite r) } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/arith_rewriter.h b/src/theory/arith/arith_rewriter.h index 556a7bda7..803f8c8a8 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -73,6 +73,6 @@ class ArithRewriter : public TheoryRewriter } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 bab1d6eb9..f4be43b06 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -35,4 +35,4 @@ bool ArithState::isInConflict() const } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/arith_state.h b/src/theory/arith/arith_state.h index dfe2bc877..05b09a5a2 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -52,6 +52,6 @@ class ArithState : public TheoryState } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/arith_static_learner.cpp b/src/theory/arith/arith_static_learner.cpp index b0129970e..9c764ac7a 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -273,4 +273,4 @@ void ArithStaticLearner::addBound(TNode n) { } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/arith_static_learner.h b/src/theory/arith/arith_static_learner.h index 668527c0f..73810dedd 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 CVC5 { +namespace cvc5 { namespace context { class Context; } @@ -71,6 +71,6 @@ private: } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 16c412546..abffcc3d3 100644 --- a/src/theory/arith/arith_utilities.cpp +++ b/src/theory/arith/arith_utilities.cpp @@ -16,9 +16,9 @@ #include <cmath> -using namespace CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -325,4 +325,4 @@ Node negateProofLiteral(TNode n) } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/arith_utilities.h b/src/theory/arith/arith_utilities.h index 9c0edb893..852550917 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -344,6 +344,6 @@ Node negateProofLiteral(TNode n); } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__ARITH__ARITH_UTILITIES_H */ diff --git a/src/theory/arith/arithvar.cpp b/src/theory/arith/arithvar.cpp index a0c29cb84..b2db30f82 100644 --- a/src/theory/arith/arithvar.cpp +++ b/src/theory/arith/arithvar.cpp @@ -19,7 +19,7 @@ #include <limits> #include <set> -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -32,4 +32,4 @@ bool debugIsASet(const std::vector<ArithVar>& variables){ } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/arithvar.h b/src/theory/arith/arithvar.h index a49797845..959db4b0d 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -41,4 +41,4 @@ extern bool debugIsASet(const ArithVarVec& variables); } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/arithvar_node_map.h b/src/theory/arith/arithvar_node_map.h index dceeeb407..6764e8e0b 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -90,6 +90,6 @@ public: } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 292fccb34..d0f69b7a3 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -153,4 +153,4 @@ Result::Sat AttemptSolutionSDP::attempt(const ApproximateSimplex::Solution& sol) } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/attempt_solution_simplex.h b/src/theory/arith/attempt_solution_simplex.h index faca0cb25..411bf776e 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -92,4 +92,4 @@ public: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/bound_counts.h b/src/theory/arith/bound_counts.h index 949828aeb..9caa965ac 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -231,4 +231,4 @@ public: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/bound_inference.cpp b/src/theory/arith/bound_inference.cpp index 126954144..a3357c1d9 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/bound_inference.h b/src/theory/arith/bound_inference.h index 7041777d8..fc5e68cff 100644 --- a/src/theory/arith/bound_inference.h +++ b/src/theory/arith/bound_inference.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif
\ No newline at end of file diff --git a/src/theory/arith/callbacks.cpp b/src/theory/arith/callbacks.cpp index 7fe8e4934..b2c48163f 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -196,4 +196,4 @@ BoundCounts BoundCountingLookup::hasBounds(ArithVar basic) const { } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/callbacks.h b/src/theory/arith/callbacks.h index 66004871b..539b7f70d 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 CVC5 { +namespace cvc5 { class ProofNode; @@ -199,4 +199,4 @@ public: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/congruence_manager.cpp b/src/theory/arith/congruence_manager.cpp index f2e51be02..ea597468d 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -691,4 +691,4 @@ std::vector<Node> andComponents(TNode an) } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/congruence_manager.h b/src/theory/arith/congruence_manager.h index 540e985f7..055d5ddbb 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 CVC5 { +namespace cvc5 { class ProofNodeManager; @@ -299,4 +299,4 @@ std::vector<Node> andComponents(TNode an); } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/constraint.cpp b/src/theory/arith/constraint.cpp index cc1129f50..baa9b1ebb 100644 --- a/src/theory/arith/constraint.cpp +++ b/src/theory/arith/constraint.cpp @@ -32,9 +32,9 @@ using namespace std; -using namespace CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -2428,4 +2428,4 @@ std::pair<int, int> Constraint::unateFarkasSigns(ConstraintCP ca, ConstraintCP c } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/constraint.h b/src/theory/arith/constraint.h index 3caa5a030..d00f16c90 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 CVC5 { +namespace cvc5 { class ProofNodeManager; @@ -1277,6 +1277,6 @@ private: } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 8d36df304..146ffd607 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -46,6 +46,6 @@ static const RationalVectorP RationalVectorPSentinel = NULL; } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 36c8d06f1..faf2fddbe 100644 --- a/src/theory/arith/cut_log.cpp +++ b/src/theory/arith/cut_log.cpp @@ -31,7 +31,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -704,4 +704,4 @@ void DenseVector::print(ostream& out, const DenseMap<Rational>& v){ } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/cut_log.h b/src/theory/arith/cut_log.h index 961092f6e..3ab0bb6bf 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -290,4 +290,4 @@ public: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/delta_rational.cpp b/src/theory/arith/delta_rational.cpp index 7d20a1859..e93b0315e 100644 --- a/src/theory/arith/delta_rational.cpp +++ b/src/theory/arith/delta_rational.cpp @@ -21,7 +21,7 @@ using namespace std; -namespace CVC5 { +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 } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/delta_rational.h b/src/theory/arith/delta_rational.h index e2b769b18..cd01f9c1a 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 CVC5 { +namespace cvc5 { class DeltaRational; @@ -46,20 +46,20 @@ class DeltaRationalException : public Exception { */ class DeltaRational { private: - CVC5::Rational c; - CVC5::Rational k; + cvc5::Rational c; + cvc5::Rational k; public: DeltaRational() : c(0,1), k(0,1) {} - DeltaRational(const CVC5::Rational& base) : c(base), k(0, 1) {} - DeltaRational(const CVC5::Rational& base, const CVC5::Rational& coeff) + DeltaRational(const cvc5::Rational& base) : c(base), k(0, 1) {} + DeltaRational(const cvc5::Rational& base, const cvc5::Rational& coeff) : c(base), k(coeff) { } - const CVC5::Rational& getInfinitesimalPart() const { return k; } + const cvc5::Rational& getInfinitesimalPart() const { return k; } - const CVC5::Rational& getNoninfinitesimalPart() const { return c; } + const cvc5::Rational& getNoninfinitesimalPart() const { return c; } int sgn() const { int s = getNoninfinitesimalPart().sgn(); @@ -97,14 +97,14 @@ public: } DeltaRational operator+(const DeltaRational& other) const{ - CVC5::Rational tmpC = c + other.c; - CVC5::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{ - CVC5::Rational tmpC = a * c; - CVC5::Rational tmpK = a * k; + cvc5::Rational tmpC = a * c; + cvc5::Rational tmpK = a * k; return DeltaRational(tmpC, tmpK); } @@ -127,7 +127,7 @@ public: DeltaRational operator-(const DeltaRational& a) const{ - CVC5::Rational negOne(CVC5::Integer(-1)); + cvc5::Rational negOne(cvc5::Integer(-1)); return *(this) + (a * negOne); } @@ -136,14 +136,14 @@ public: } DeltaRational operator/(const Rational& a) const{ - CVC5::Rational tmpC = c / a; - CVC5::Rational tmpK = k / a; + cvc5::Rational tmpC = c / a; + cvc5::Rational tmpK = k / a; return DeltaRational(tmpC, tmpK); } DeltaRational operator/(const Integer& a) const{ - CVC5::Rational tmpC = c / a; - CVC5::Rational tmpK = k / a; + cvc5::Rational tmpC = c / a; + cvc5::Rational tmpK = k / a; return DeltaRational(tmpC, tmpK); } @@ -204,7 +204,7 @@ public: return *(this); } - DeltaRational& operator*=(const CVC5::Rational& a) + DeltaRational& operator*=(const cvc5::Rational& a) { c *= a; k *= a; @@ -299,4 +299,4 @@ public: std::ostream& operator<<(std::ostream& os, const DeltaRational& n); -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/dio_solver.cpp b/src/theory/arith/dio_solver.cpp index 51dd69650..6e069cdf6 100644 --- a/src/theory/arith/dio_solver.cpp +++ b/src/theory/arith/dio_solver.cpp @@ -24,7 +24,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -835,4 +835,4 @@ Node DioSolver::trailIndexToEquality(TrailIndex i) const { } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/dio_solver.h b/src/theory/arith/dio_solver.h index 7892bec52..9b3106036 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 CVC5 { +namespace cvc5 { namespace context { class Context; } @@ -423,6 +423,6 @@ public: } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 d4e26600d..52dd20779 100644 --- a/src/theory/arith/dual_simplex.cpp +++ b/src/theory/arith/dual_simplex.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -275,4 +275,4 @@ bool DualSimplexDecisionProcedure::searchForFeasibleSolution(uint32_t remainingI } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/dual_simplex.h b/src/theory/arith/dual_simplex.h index 3e1bc0ee7..a0a727a0a 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -113,4 +113,4 @@ private: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/error_set.cpp b/src/theory/arith/error_set.cpp index 142a060ec..b8c20104b 100644 --- a/src/theory/arith/error_set.cpp +++ b/src/theory/arith/error_set.cpp @@ -22,7 +22,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -479,4 +479,4 @@ void ErrorSet::pushFocusInto(ArithVarVec& vec) const{ } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/error_set.h b/src/theory/arith/error_set.h index cdf155c6d..4788d2697 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -414,4 +414,4 @@ private: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/fc_simplex.cpp b/src/theory/arith/fc_simplex.cpp index 61280d651..9d7711361 100644 --- a/src/theory/arith/fc_simplex.cpp +++ b/src/theory/arith/fc_simplex.cpp @@ -25,7 +25,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -861,4 +861,4 @@ const Rational& FCSimplexDecisionProcedure::focusCoefficient(ArithVar nb) const } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/fc_simplex.h b/src/theory/arith/fc_simplex.h index 73e5ae54f..2b303ffa2 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -256,4 +256,4 @@ private: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/infer_bounds.cpp b/src/theory/arith/infer_bounds.cpp index 25494bdee..a8b6374cc 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -264,4 +264,4 @@ std::ostream& operator<<(std::ostream& os, const Algorithms a){ } /* namespace arith */ } /* namespace theory */ -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/infer_bounds.h b/src/theory/arith/infer_bounds.h index 251c7cbb8..27bc611b3 100644 --- a/src/theory/arith/infer_bounds.h +++ b/src/theory/arith/infer_bounds.h @@ -27,7 +27,7 @@ #include "util/maybe.h" #include "util/rational.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -160,4 +160,4 @@ private: } /* namespace arith */ } /* namespace theory */ -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/inference_manager.cpp b/src/theory/arith/inference_manager.cpp index 66b628302..732111f97 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -147,4 +147,4 @@ bool InferenceManager::isEntailedFalse(const SimpleTheoryLemma& lem) } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/inference_manager.h b/src/theory/arith/inference_manager.h index bf5ed7b10..a5b200f8b 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -117,6 +117,6 @@ class InferenceManager : public InferenceManagerBuffered } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/kinds b/src/theory/arith/kinds index b839ccc22..f9f88cddf 100644 --- a/src/theory/arith/kinds +++ b/src/theory/arith/kinds @@ -4,13 +4,13 @@ # src/theory/builtin/kinds. # -theory THEORY_ARITH ::CVC5::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 ::CVC5::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 \ - ::CVC5::Divisible \ - ::CVC5::DivisibleHashFunction \ + ::cvc5::Divisible \ + ::cvc5::DivisibleHashFunction \ "util/divisible.h" \ - "operator for the divisibility-by-k predicate; payload is an instance of the CVC5::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 \ - ::CVC5::Rational \ - ::CVC5::RationalHashFunction \ + ::cvc5::Rational \ + ::cvc5::RationalHashFunction \ "util/rational.h" \ - "a multiple-precision rational constant; payload is an instance of the CVC5::Rational class" + "a multiple-precision rational constant; payload is an instance of the cvc5::Rational class" enumerator REAL_TYPE \ - "::CVC5::theory::arith::RationalEnumerator" \ + "::cvc5::theory::arith::RationalEnumerator" \ "theory/arith/type_enumerator.h" enumerator INTEGER_TYPE \ - "::CVC5::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 \ - ::CVC5::IndexedRootPredicate \ - ::CVC5::IndexedRootPredicateHashFunction \ + ::cvc5::IndexedRootPredicate \ + ::cvc5::IndexedRootPredicateHashFunction \ "util/indexed_root_predicate.h" \ - "operator for the indexed root predicate; payload is an instance of the CVC5::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 ::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 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 ::CVC5::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 ::CVC5::theory::arith::IndexedRootPredicateTypeRule +typerule INDEXED_ROOT_PREDICATE ::cvc5::theory::arith::IndexedRootPredicateTypeRule -typerule TO_REAL ::CVC5::theory::arith::ArithOperatorTypeRule -typerule CAST_TO_REAL ::CVC5::theory::arith::ArithOperatorTypeRule -typerule TO_INTEGER ::CVC5::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 ::CVC5::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 ::CVC5::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 \ - ::CVC5::IntAnd \ - "::CVC5::UnsignedHashFunction< ::CVC5::IntAnd >" \ + ::cvc5::IntAnd \ + "::cvc5::UnsignedHashFunction< ::cvc5::IntAnd >" \ "util/iand.h" \ - "operator for integer AND; payload is an instance of the CVC5::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 ::CVC5::theory::arith::IAndOpTypeRule -typerule IAND ::CVC5::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 28f386e2a..95c833707 100644 --- a/src/theory/arith/linear_equality.cpp +++ b/src/theory/arith/linear_equality.cpp @@ -22,7 +22,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -1413,4 +1413,4 @@ void LinearEqualityModule::directlyAddToCoefficient(ArithVar row, ArithVar col, } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/linear_equality.h b/src/theory/arith/linear_equality.h index 4a923b677..4f50853c9 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -758,4 +758,4 @@ public: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/matrix.cpp b/src/theory/arith/matrix.cpp index dd7f28228..f2ecc8e4c 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -28,4 +28,4 @@ bool NoEffectCCCB::canUseRow(RowIndex ridx) const { return false; } } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/matrix.h b/src/theory/arith/matrix.h index 553cef7d4..855f56d1f 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -368,8 +368,8 @@ public: typedef MatrixEntry<T> Entry; protected: - typedef CVC5::theory::arith::RowVector<T> RowVectorT; - typedef CVC5::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; @@ -999,4 +999,4 @@ protected: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/cad/cdcac.cpp b/src/theory/arith/nl/cad/cdcac.cpp index 7fd22fb76..c9f3ce3da 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) { - CVC5::container_to_stream(os, v); + cvc5::container_to_stream(os, v); return os; } } // namespace std -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/cad/cdcac.h b/src/theory/arith/nl/cad/cdcac.h index 2b607ae78..338f54da2 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -210,7 +210,7 @@ class CDCAC } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/cad/cdcac_utils.cpp b/src/theory/arith/nl/cad/cdcac_utils.cpp index f40d528ff..999e491f6 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/cad/cdcac_utils.h b/src/theory/arith/nl/cad/cdcac_utils.h index 3b3a3638b..607a2226f 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/cad/constraints.cpp b/src/theory/arith/nl/cad/constraints.cpp index 1ea172d11..75d1cb723 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -79,6 +79,6 @@ void Constraints::sortConstraints() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/cad/constraints.h b/src/theory/arith/nl/cad/constraints.h index 70c52e85c..e9e59c40b 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -87,7 +87,7 @@ class Constraints } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/cad/projections.cpp b/src/theory/arith/nl/cad/projections.cpp index b9e17f844..1bac0c160 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/cad/projections.h b/src/theory/arith/nl/cad/projections.h index 3b8eb412f..94bdfc3ef 100644 --- a/src/theory/arith/nl/cad/projections.h +++ b/src/theory/arith/nl/cad/projections.h @@ -25,7 +25,7 @@ #include <vector> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/cad/proof_checker.cpp b/src/theory/arith/nl/cad/proof_checker.cpp index f1ab2d6a9..3cd8fe98e 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -58,4 +58,4 @@ Node CADProofRuleChecker::checkInternal(PfRule id, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/cad/proof_checker.h b/src/theory/arith/nl/cad/proof_checker.h index 26bbcc3a9..9100762b7 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -53,6 +53,6 @@ class CADProofRuleChecker : public ProofRuleChecker } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 fe3734dce..73e19aa28 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/cad/proof_generator.h b/src/theory/arith/nl/cad/proof_generator.h index c1bb4be1e..76a72f9c5 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 CVC5 { +namespace cvc5 { class ProofGenerator; @@ -144,7 +144,7 @@ std::ostream& operator<<(std::ostream& os, const CADProofGenerator& proof); } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 63db35553..7ebbc90dd 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/cad/variable_ordering.h b/src/theory/arith/nl/cad/variable_ordering.h index 7fda3faa4..0ab585197 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/cad_solver.cpp b/src/theory/arith/nl/cad_solver.cpp index dc18fbdf5..1cf9cbc54 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/cad_solver.h b/src/theory/arith/nl/cad_solver.h index de97c48cc..620679735 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 CVC5 { +namespace cvc5 { class ProofNodeManager; @@ -110,6 +110,6 @@ class CadSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 41331d041..688bab86d 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/ext/constraint.h b/src/theory/arith/nl/ext/constraint.h index 9e6451c99..a96949a1e 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -84,6 +84,6 @@ class ConstraintDb } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 fc806199e..e20224207 100644 --- a/src/theory/arith/nl/ext/ext_state.cpp +++ b/src/theory/arith/nl/ext/ext_state.cpp @@ -23,7 +23,7 @@ #include "theory/arith/nl/nl_model.h" #include "theory/arith/nl/nl_lemma_utils.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -109,4 +109,4 @@ CDProof* ExtState::getProof() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/ext/ext_state.h b/src/theory/arith/nl/ext/ext_state.h index 1d8e7ea0a..2d20e1557 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 CVC5 { +namespace cvc5 { class CDProof; @@ -91,6 +91,6 @@ struct ExtState } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/ext/factoring_check.cpp b/src/theory/arith/nl/ext/factoring_check.cpp index 675368843..09e1d4f10 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/ext/factoring_check.h b/src/theory/arith/nl/ext/factoring_check.h index 89c5fce30..08154cb98 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 CVC5 { +namespace cvc5 { class CDProof; @@ -69,6 +69,6 @@ class FactoringCheck } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/ext/monomial.cpp b/src/theory/arith/nl/ext/monomial.cpp index 86abed70c..784c07691 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -333,4 +333,4 @@ Node MonomialDb::mkMonomialRemFactor(Node n, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/ext/monomial.h b/src/theory/arith/nl/ext/monomial.h index 98083b996..6646e4a73 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -144,6 +144,6 @@ class MonomialDb } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 c8194bbd0..344218148 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -520,4 +520,4 @@ void MonomialBoundsCheck::checkResBounds() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 e63dd454a..a19c61e64 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -86,6 +86,6 @@ class MonomialBoundsCheck } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/ext/monomial_check.cpp b/src/theory/arith/nl/ext/monomial_check.cpp index 9fc2ba10a..a30d4aff9 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -757,4 +757,4 @@ void MonomialCheck::setMonomialFactor(Node a, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/ext/monomial_check.h b/src/theory/arith/nl/ext/monomial_check.h index 948368542..f242182b4 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -194,6 +194,6 @@ class MonomialCheck } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/ext/proof_checker.cpp b/src/theory/arith/nl/ext/proof_checker.cpp index 26db3c9e0..b6c4572f5 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -158,4 +158,4 @@ Node ExtProofRuleChecker::checkInternal(PfRule id, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/ext/proof_checker.h b/src/theory/arith/nl/ext/proof_checker.h index 7bd4b7e38..90518fc08 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -51,6 +51,6 @@ class ExtProofRuleChecker : public ProofRuleChecker } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 543b6a0bd..7392d45f4 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -57,4 +57,4 @@ void SplitZeroCheck::check() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 316e304ff..04148bd19 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -50,6 +50,6 @@ class SplitZeroCheck } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 bdeca7a29..711bc9816 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -164,4 +164,4 @@ void TangentPlaneCheck::check(bool asWaitingLemmas) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 7d48d249b..b5159e721 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -67,6 +67,6 @@ class TangentPlaneCheck } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/ext_theory_callback.cpp b/src/theory/arith/nl/ext_theory_callback.cpp index 125fbb05a..72848ac89 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -129,4 +129,4 @@ bool NlExtTheoryCallback::isExtfReduced(int effort, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/ext_theory_callback.h b/src/theory/arith/nl/ext_theory_callback.h index c747eef69..0e0e1411b 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 CVC5 { +namespace cvc5 { namespace theory { namespace eq { class EqualityEngine; @@ -84,6 +84,6 @@ class NlExtTheoryCallback : public ExtTheoryCallback } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 01f4c6e15..0e339857b 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -298,4 +298,4 @@ Node IAndSolver::bitwiseLemma(Node i) } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/iand_solver.h b/src/theory/arith/nl/iand_solver.h index 95d9632aa..2b7f90e9b 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -132,6 +132,6 @@ class IAndSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 cd96021b0..e08068b7e 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/iand_utils.h b/src/theory/arith/nl/iand_utils.h index da5f8f04f..60c3cbe13 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -169,6 +169,6 @@ class IAndUtils } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 87d823018..31b7b085b 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/icp/candidate.h b/src/theory/arith/nl/icp/candidate.h index d4ad11fcf..4bcbf3e85 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/icp/contraction_origins.cpp b/src/theory/arith/nl/icp/contraction_origins.cpp index c0b0cb768..acf499a21 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/icp/contraction_origins.h b/src/theory/arith/nl/icp/contraction_origins.h index 0f22b5463..dfddbce78 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/icp/icp_solver.cpp b/src/theory/arith/nl/icp/icp_solver.cpp index e09264a25..2f6cdf220 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -384,4 +384,4 @@ void ICPSolver::check() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/icp/icp_solver.h b/src/theory/arith/nl/icp/icp_solver.h index 56ec03706..11fd9ac1b 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -153,6 +153,6 @@ class ICPSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/icp/intersection.cpp b/src/theory/arith/nl/icp/intersection.cpp index 6cdba297c..e0e93e1dd 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/icp/intersection.h b/src/theory/arith/nl/icp/intersection.h index c453f8314..dd4afadfc 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/icp/interval.h b/src/theory/arith/nl/icp/interval.h index 8acbfec05..981355e4a 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/nl_lemma_utils.cpp b/src/theory/arith/nl/nl_lemma_utils.cpp index f3c2d70c8..9740e1b46 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/nl_lemma_utils.h b/src/theory/arith/nl/nl_lemma_utils.h index 71d86b08a..32fe763b4 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -144,6 +144,6 @@ class ArgTrie } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 f7edefff7..882cd12a4 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -1342,4 +1342,4 @@ void NlModel::getModelValueRepair( } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/nl_model.h b/src/theory/arith/nl/nl_model.h index b2c435098..9da8738b6 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 CVC5 { +namespace cvc5 { namespace context { class Context; @@ -329,6 +329,6 @@ class NlModel } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 3c46e1652..03563006b 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -622,4 +622,4 @@ void NonlinearExtension::runStrategy(Theory::Effort effort, } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/nonlinear_extension.h b/src/theory/arith/nl/nonlinear_extension.h index b6fb53651..722741d7d 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 CVC5 { +namespace cvc5 { namespace theory { namespace eq { class EqualityEngine; @@ -296,6 +296,6 @@ class NonlinearExtension } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 5738dccfc..c7b549655 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { -poly::Variable VariableMapper::operator()(const CVC5::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 CVC5::Node& n) return it->second; } -CVC5::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 @@ CVC5::Node VariableMapper::operator()(const poly::Variable& n) return it->second; } -CVC5::Node as_cvc_upolynomial(const poly::UPolynomial& p, const CVC5::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 @@ CVC5::Node as_cvc_upolynomial(const poly::UPolynomial& p, const CVC5::Node& var) return res; } -poly::UPolynomial as_poly_upolynomial_impl(const CVC5::Node& n, +poly::UPolynomial as_poly_upolynomial_impl(const cvc5::Node& n, poly::Integer& denominator, - const CVC5::Node& var) + const cvc5::Node& var) { denominator = poly::Integer(1); if (n.isVar()) @@ -140,14 +140,14 @@ poly::UPolynomial as_poly_upolynomial_impl(const CVC5::Node& n, return poly::UPolynomial(); } -poly::UPolynomial as_poly_upolynomial(const CVC5::Node& n, - const CVC5::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 CVC5::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 CVC5::Node& n, } return poly::Polynomial(); } -poly::Polynomial as_poly_polynomial(const CVC5::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 CVC5::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 -CVC5::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 @@ CVC5::Node as_cvc_polynomial(const poly::Polynomial& p, VariableMapper& vm) return cmd.d_nm->mkNode(Kind::PLUS, cmd.d_terms); } -poly::SignCondition normalize_kind(CVC5::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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/poly_conversion.h b/src/theory/arith/nl/poly_conversion.h index 9adc9a996..9aef0db18 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -42,23 +42,23 @@ namespace nl { struct VariableMapper { /** A mapping from CVC4 variables to poly variables. */ - std::map<CVC5::Node, poly::Variable> mVarCVCpoly; + std::map<cvc5::Node, poly::Variable> mVarCVCpoly; /** A mapping from poly variables to CVC4 variables. */ - std::map<poly::Variable, CVC5::Node> mVarpolyCVC; + std::map<poly::Variable, cvc5::Node> mVarpolyCVC; /** Retrieves the according poly variable. */ - poly::Variable operator()(const CVC5::Node& n); + poly::Variable operator()(const cvc5::Node& n); /** Retrieves the according CVC4 variable. */ - CVC5::Node operator()(const poly::Variable& n); + cvc5::Node operator()(const poly::Variable& n); }; -/** Convert a poly univariate polynomial to a CVC5::Node. */ -CVC5::Node as_cvc_upolynomial(const poly::UPolynomial& p, - const CVC5::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 CVC5::Node to a poly univariate polynomial. */ -poly::UPolynomial as_poly_upolynomial(const CVC5::Node& n, - const CVC5::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 CVC5::Node& n, * in the context of ICP) the second overload provides the denominator in the * third argument. */ -poly::Polynomial as_poly_polynomial(const CVC5::Node& n, VariableMapper& vm); -poly::Polynomial as_poly_polynomial(const CVC5::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 CVC5::Node& n, * multiplications with one or use NONLINEAR_MULT where regular MULT may be * sufficient), so it may be sensible to rewrite it afterwards. */ -CVC5::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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arith/nl/stats.cpp b/src/theory/arith/nl/stats.cpp index 92cebc8fc..33a73ddd7 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -38,4 +38,4 @@ NlStats::~NlStats() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/stats.h b/src/theory/arith/nl/stats.h index 66157d0a3..66f41375b 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -44,6 +44,6 @@ class NlStats } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 af23f67f9..4df53b103 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -173,4 +173,4 @@ StepGenerator Strategy::getStrategy() } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/strategy.h b/src/theory/arith/nl/strategy.h index 9caf6322b..139db7459 100644 --- a/src/theory/arith/nl/strategy.h +++ b/src/theory/arith/nl/strategy.h @@ -18,7 +18,7 @@ #include <iosfwd> #include <vector> -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -173,6 +173,6 @@ class Strategy } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 05849a579..5e2358b68 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/transcendental/exponential_solver.h b/src/theory/arith/nl/transcendental/exponential_solver.h index 8bd00c456..c5eb45728 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -108,6 +108,6 @@ class ExponentialSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 fe071c36a..4fc85666a 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -402,4 +402,4 @@ Node TranscendentalProofRuleChecker::checkInternal( } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/transcendental/proof_checker.h b/src/theory/arith/nl/transcendental/proof_checker.h index 2a6837590..a4c8b55cb 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -53,6 +53,6 @@ class TranscendentalProofRuleChecker : public ProofRuleChecker } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 052b6c056..c8c375096 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/transcendental/sine_solver.h b/src/theory/arith/nl/transcendental/sine_solver.h index c20c50f6d..b85d0dc48 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -175,6 +175,6 @@ class SineSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 f2817344a..5a9e87b7f 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/transcendental/taylor_generator.h b/src/theory/arith/nl/transcendental/taylor_generator.h index b13be57f0..8b7f5340d 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -118,6 +118,6 @@ class TaylorGenerator } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 bedfe4d3b..ed5ab4255 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/transcendental/transcendental_solver.h b/src/theory/arith/nl/transcendental/transcendental_solver.h index e22bf3e64..c3d098e03 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -200,6 +200,6 @@ class TranscendentalSolver } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 6ab136d39..e662c017e 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/nl/transcendental/transcendental_state.h b/src/theory/arith/nl/transcendental/transcendental_state.h index 21a60e038..a55071ef1 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 CVC5 { +namespace cvc5 { class CDProof; namespace theory { namespace arith { @@ -278,6 +278,6 @@ struct TranscendentalState } // namespace nl } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 d1ef6486e..b872b4309 100644 --- a/src/theory/arith/normal_form.cpp +++ b/src/theory/arith/normal_form.cpp @@ -24,7 +24,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -1412,4 +1412,4 @@ bool Polynomial::isNonlinear() const { } //namespace arith } //namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/normal_form.h b/src/theory/arith/normal_form.h index c4d0e2268..7b9002d82 100644 --- a/src/theory/arith/normal_form.h +++ b/src/theory/arith/normal_form.h @@ -28,7 +28,7 @@ #include "theory/arith/delta_rational.h" #include "util/rational.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -1404,6 +1404,6 @@ public: } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 15e09eaa5..600724f33 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -499,4 +499,4 @@ Node OperatorElim::mkWitnessTerm(Node v, } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/operator_elim.h b/src/theory/arith/operator_elim.h index fa09ad26b..1b2f7190e 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 CVC5 { +namespace cvc5 { class TConvProofGenerator; @@ -142,4 +142,4 @@ class OperatorElim : public EagerProofGenerator } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/partial_model.cpp b/src/theory/arith/partial_model.cpp index 6e4fa6bed..fe3408a43 100644 --- a/src/theory/arith/partial_model.cpp +++ b/src/theory/arith/partial_model.cpp @@ -22,7 +22,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -686,4 +686,4 @@ void ArithVariables::UpperBoundCleanUp::operator()(AVCPair* p){ } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/partial_model.h b/src/theory/arith/partial_model.h index b7a1a0efe..30a684e47 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 CVC5 { +namespace cvc5 { namespace context { class Context; } @@ -414,6 +414,6 @@ private: } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 09ef5bf34..23f141535 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -360,4 +360,4 @@ Node ArithProofRuleChecker::checkInternal(PfRule id, } } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/proof_checker.h b/src/theory/arith/proof_checker.h index 5b9a50387..ca4fdfb6d 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -43,6 +43,6 @@ class ArithProofRuleChecker : public ProofRuleChecker } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 169e4e2db..a02738fd3 100644 --- a/src/theory/arith/proof_macros.h +++ b/src/theory/arith/proof_macros.h @@ -21,11 +21,11 @@ #include "options/smt_options.h" #define ARITH_PROOF(x) \ - if (CVC5::options::produceProofs()) \ + if (cvc5::options::produceProofs()) \ { \ x; \ } -#define ARITH_NULLPROOF(x) (CVC5::options::produceProofs()) ? x : NULL -#define ARITH_PROOF_ON() CVC5::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 9522ef4f4..d095b4a20 100644 --- a/src/theory/arith/rewrites.cpp +++ b/src/theory/arith/rewrites.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -47,4 +47,4 @@ std::ostream& operator<<(std::ostream& out, Rewrite r) } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/rewrites.h b/src/theory/arith/rewrites.h index 250eacb09..e7a44f27e 100644 --- a/src/theory/arith/rewrites.h +++ b/src/theory/arith/rewrites.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -77,6 +77,6 @@ std::ostream& operator<<(std::ostream& out, Rewrite r); } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__ARITH__REWRITES_H */ diff --git a/src/theory/arith/simplex.cpp b/src/theory/arith/simplex.cpp index fe6fad4d7..f599cdf40 100644 --- a/src/theory/arith/simplex.cpp +++ b/src/theory/arith/simplex.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -280,4 +280,4 @@ SimplexDecisionProcedure::sgn_table::const_iterator SimplexDecisionProcedure::fi } } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/simplex.h b/src/theory/arith/simplex.h index a1ee18adf..d826f0ba3 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -221,4 +221,4 @@ protected: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/simplex_update.cpp b/src/theory/arith/simplex_update.cpp index ea868a886..81723f7c2 100644 --- a/src/theory/arith/simplex_update.cpp +++ b/src/theory/arith/simplex_update.cpp @@ -19,7 +19,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -188,4 +188,4 @@ std::ostream& operator<<(std::ostream& out, WitnessImprovement w){ } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/simplex_update.h b/src/theory/arith/simplex_update.h index 833e92dd4..8310d3783 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -354,4 +354,4 @@ std::ostream& operator<<(std::ostream& out, const UpdateInfo& up); } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/soi_simplex.cpp b/src/theory/arith/soi_simplex.cpp index 0efc33d02..d7cfd28c1 100644 --- a/src/theory/arith/soi_simplex.cpp +++ b/src/theory/arith/soi_simplex.cpp @@ -28,7 +28,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -1024,4 +1024,4 @@ Result::Sat SumOfInfeasibilitiesSPD::sumOfInfeasibilities(){ } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/soi_simplex.h b/src/theory/arith/soi_simplex.h index 16af7292d..605d23767 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -242,4 +242,4 @@ private: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/tableau.cpp b/src/theory/arith/tableau.cpp index c39b3aae7..2d389b0f5 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -192,4 +192,4 @@ void Tableau::printBasicRow(ArithVar basic, std::ostream& out){ } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/tableau.h b/src/theory/arith/tableau.h index 0834c7f35..6c597aa66 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -159,4 +159,4 @@ private: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/tableau_sizes.cpp b/src/theory/arith/tableau_sizes.cpp index a167cf1a8..b0f2ab9a8 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -33,4 +33,4 @@ uint32_t TableauSizes::getColumnLength(ArithVar x) const { } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/tableau_sizes.h b/src/theory/arith/tableau_sizes.h index 3bbb5c818..969620db1 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -39,4 +39,4 @@ public: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/theory_arith.cpp b/src/theory/arith/theory_arith.cpp index 12603ea7d..577aa0e6c 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -313,4 +313,4 @@ eq::ProofEqEngine* TheoryArith::getProofEqEngine() } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/theory_arith.h b/src/theory/arith/theory_arith.h index e430f6da6..40abe21e0 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { namespace nl { @@ -165,4 +165,4 @@ class TheoryArith : public Theory { } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/theory_arith_private.cpp b/src/theory/arith/theory_arith_private.cpp index 1e9e8ca3f..b11bff768 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -5714,4 +5714,4 @@ std::pair<Node, DeltaRational> TheoryArithPrivate::entailmentCheckSimplex(int sg } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/theory_arith_private.h b/src/theory/arith/theory_arith_private.h index e0b7cea56..929f40b56 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 CVC5 { +namespace cvc5 { namespace theory { class EagerProofGenerator; @@ -886,4 +886,4 @@ private: } // namespace arith } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arith/theory_arith_type_rules.h b/src/theory/arith/theory_arith_type_rules.h index dc8885e55..e192270ff 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -159,6 +159,6 @@ class IndexedRootPredicateTypeRule } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 a32073ad9..9b3f4535b 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 CVC5 { +namespace cvc5 { namespace theory { namespace arith { @@ -102,6 +102,6 @@ class IntegerEnumerator : public TypeEnumeratorBase<IntegerEnumerator> { } // namespace arith } // namespace theory -} // namespace CVC5 +} // 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 64e1d81c8..d88345f10 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 CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -519,4 +519,4 @@ void ArrayInfo::mergeInfo(const TNode a, const TNode b){ } // namespace arrays } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arrays/array_info.h b/src/theory/arrays/array_info.h index 405a40ead..1a1cf441b 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 CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -207,6 +207,6 @@ public: } // namespace arrays } // namespace theory -} // namespace CVC5 +} // 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 f53fe8cc3..c414a901f 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -129,4 +129,4 @@ void InferenceManager::convert(PfRule& id, } // namespace arrays } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arrays/inference_manager.h b/src/theory/arrays/inference_manager.h index 60336dd63..58b2b37bc 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 CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -71,6 +71,6 @@ class InferenceManager : public TheoryInferenceManager } // namespace arrays } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arrays/kinds b/src/theory/arrays/kinds index d8d4b2bae..e39f30c6e 100644 --- a/src/theory/arrays/kinds +++ b/src/theory/arrays/kinds @@ -4,25 +4,25 @@ # src/theory/builtin/kinds. # -theory THEORY_ARRAYS ::CVC5::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 ::CVC5::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 \ - "::CVC5::theory::arrays::ArraysProperties::computeCardinality(%TYPE%)" \ + "::cvc5::theory::arrays::ArraysProperties::computeCardinality(%TYPE%)" \ "theory/arrays/theory_arrays_type_rules.h" well-founded ARRAY_TYPE \ - "::CVC5::theory::arrays::ArraysProperties::isWellFounded(%TYPE%)" \ - "::CVC5::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 \ - "::CVC5::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 \ - ::CVC5::ArrayStoreAll \ - ::CVC5::ArrayStoreAllHashFunction \ + ::cvc5::ArrayStoreAll \ + ::cvc5::ArrayStoreAllHashFunction \ "expr/array_store_all.h" \ - "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)" + "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 ::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 +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 ::CVC5::theory::arrays::ArrayPartialSelectTypeRule -typerule PARTIAL_SELECT_1 ::CVC5::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 ::CVC5::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 72e444d63..643de0d71 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 CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -115,4 +115,4 @@ Node ArraysProofRuleChecker::checkInternal(PfRule id, } // namespace arrays } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arrays/proof_checker.h b/src/theory/arrays/proof_checker.h index 64d5d785f..b62f929a3 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 CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -43,6 +43,6 @@ class ArraysProofRuleChecker : public ProofRuleChecker } // namespace arrays } // namespace theory -} // namespace CVC5 +} // 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 a1f2fddc4..a76f616a9 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -78,4 +78,4 @@ Node SkolemCache::getExtIndexVar(Node deq) } // namespace arrays } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arrays/skolem_cache.h b/src/theory/arrays/skolem_cache.h index a95dc9a4f..fbd547079 100644 --- a/src/theory/arrays/skolem_cache.h +++ b/src/theory/arrays/skolem_cache.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -52,6 +52,6 @@ class SkolemCache } // namespace arrays } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/arrays/theory_arrays.cpp b/src/theory/arrays/theory_arrays.cpp index 665ad8da0..543d9833c 100644 --- a/src/theory/arrays/theory_arrays.cpp +++ b/src/theory/arrays/theory_arrays.cpp @@ -36,7 +36,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -2271,4 +2271,4 @@ void TheoryArrays::computeRelevantTerms(std::set<Node>& termSet) } // namespace arrays } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arrays/theory_arrays.h b/src/theory/arrays/theory_arrays.h index a7db2db7a..e61c76089 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 CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -490,6 +490,6 @@ class TheoryArrays : public Theory { } // namespace arrays } // namespace theory -} // namespace CVC5 +} // 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 e91844a9c..497ccac21 100644 --- a/src/theory/arrays/theory_arrays_rewriter.cpp +++ b/src/theory/arrays/theory_arrays_rewriter.cpp @@ -18,7 +18,7 @@ #include "expr/attribute.h" #include "theory/arrays/theory_arrays_rewriter.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -46,4 +46,4 @@ void setMostFrequentValueCount(TNode store, uint64_t count) { } // namespace arrays } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arrays/theory_arrays_rewriter.h b/src/theory/arrays/theory_arrays_rewriter.h index 114913ee7..2d8da6929 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 CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -503,6 +503,6 @@ class TheoryArraysRewriter : public TheoryRewriter } // namespace arrays } // namespace theory -} // namespace CVC5 +} // 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 fc3340251..5637639de 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 CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -276,6 +276,6 @@ struct ArrayEqRangeTypeRule } // namespace arrays } // namespace theory -} // namespace CVC5 +} // 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 4f5b981b2..715a3f7a5 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 CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -157,6 +157,6 @@ class ArrayEnumerator : public TypeEnumeratorBase<ArrayEnumerator> { } // namespace arrays } // namespace theory -} // namespace CVC5 +} // 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 e178e9dbb..ac8f92b80 100644 --- a/src/theory/arrays/union_find.cpp +++ b/src/theory/arrays/union_find.cpp @@ -23,7 +23,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace arrays { @@ -53,4 +53,4 @@ template void UnionFind<TNode, TNodeHashFunction>::notify(); } // namespace arrays } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/arrays/union_find.h b/src/theory/arrays/union_find.h index ebe31baad..6285e0e9b 100644 --- a/src/theory/arrays/union_find.h +++ b/src/theory/arrays/union_find.h @@ -28,7 +28,7 @@ #include "expr/node.h" #include "context/cdo.h" -namespace CVC5 { +namespace cvc5 { namespace context { class Context; @@ -137,6 +137,6 @@ inline void UnionFind<NodeType, NodeHash>::setCanon(TNode n, TNode newParent) { } // namespace arrays } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /*CVC4__THEORY__ARRAYS__UNION_FIND_H */ diff --git a/src/theory/assertion.cpp b/src/theory/assertion.cpp index b21025314..17806738c 100644 --- a/src/theory/assertion.cpp +++ b/src/theory/assertion.cpp @@ -16,7 +16,7 @@ #include "theory/assertion.h" -namespace CVC5 { +namespace cvc5 { namespace theory { std::ostream& operator<<(std::ostream& out, const Assertion& a) { @@ -24,4 +24,4 @@ std::ostream& operator<<(std::ostream& out, const Assertion& a) { } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/assertion.h b/src/theory/assertion.h index 10f300d69..4971dee00 100644 --- a/src/theory/assertion.h +++ b/src/theory/assertion.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { /** Information about an assertion for the theories. */ @@ -48,6 +48,6 @@ struct Assertion { std::ostream& operator<<(std::ostream& out, const Assertion& a); } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__ASSERTION_H */ diff --git a/src/theory/atom_requests.cpp b/src/theory/atom_requests.cpp index c3305417f..96b83bbe5 100644 --- a/src/theory/atom_requests.cpp +++ b/src/theory/atom_requests.cpp @@ -17,7 +17,7 @@ #include "theory/atom_requests.h" -using namespace CVC5; +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 906fec303..a6b50dd72 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 CVC5 { +namespace cvc5 { class AtomRequests { @@ -114,4 +114,4 @@ private: }; -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/bag_solver.cpp b/src/theory/bags/bag_solver.cpp index fd80a03f7..478ce58cd 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 CVC5::context; -using namespace CVC5::kind; +using namespace cvc5::context; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -212,4 +212,4 @@ void BagSolver::checkDisequalBagTerms() } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/bag_solver.h b/src/theory/bags/bag_solver.h index 9d0e597dd..5cd7ed338 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -90,6 +90,6 @@ class BagSolver } // namespace bags } // namespace theory -} // namespace CVC5 +} // 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 ccee08aab..f4670f8be 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -503,4 +503,4 @@ BagsRewriteResponse BagsRewriter::postRewriteEqual(const TNode& n) const } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/bags_rewriter.h b/src/theory/bags/bags_rewriter.h index 4552ed9da..bc66d7efa 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -223,6 +223,6 @@ class BagsRewriter : public TheoryRewriter } // namespace bags } // namespace theory -} // namespace CVC5 +} // 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 369831c70..6c88ffb43 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -32,4 +32,4 @@ BagsStatistics::~BagsStatistics() } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/bags_statistics.h b/src/theory/bags/bags_statistics.h index e0a1c4133..ac60fbc3e 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -40,6 +40,6 @@ class BagsStatistics } // namespace bags } // namespace theory -} // namespace CVC5 +} // 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 444597eb5..c0fac0753 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -79,4 +79,4 @@ std::ostream& operator<<(std::ostream& out, const InferInfo& ii) } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/infer_info.h b/src/theory/bags/infer_info.h index 18765bbe7..508c49fe5 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 CVC5 { +namespace cvc5 { namespace theory { class TheoryInferenceManager; @@ -85,6 +85,6 @@ std::ostream& operator<<(std::ostream& out, const InferInfo& ii); } // namespace bags } // namespace theory -} // namespace CVC5 +} // 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 2f6a36b9c..57a306820 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -270,4 +270,4 @@ Node InferenceGenerator::getMultiplicityTerm(Node element, Node bag) } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/inference_generator.h b/src/theory/bags/inference_generator.h index 4f0b498c2..baa391f38 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -188,6 +188,6 @@ class InferenceGenerator } // namespace bags } // namespace theory -} // namespace CVC5 +} // 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 3fa425f7a..422fb53d0 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -48,4 +48,4 @@ void InferenceManager::doPending() } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/inference_manager.h b/src/theory/bags/inference_manager.h index 34f6621aa..68d923889 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -63,6 +63,6 @@ class InferenceManager : public InferenceManagerBuffered } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__BAGS__INFERENCE_MANAGER_H */ diff --git a/src/theory/bags/kinds b/src/theory/bags/kinds index dd8eacfb5..038e7dd7f 100644 --- a/src/theory/bags/kinds +++ b/src/theory/bags/kinds @@ -5,10 +5,10 @@ # theory THEORY_BAGS \ - ::CVC5::theory::bags::TheoryBags \ + ::cvc5::theory::bags::TheoryBags \ "theory/bags/theory_bags.h" typechecker "theory/bags/theory_bags_type_rules.h" -rewriter ::CVC5::theory::bags::BagsRewriter \ +rewriter ::cvc5::theory::bags::BagsRewriter \ "theory/bags/bags_rewriter.h" properties parametric @@ -16,22 +16,22 @@ properties check presolve # constants constant EMPTYBAG \ - ::CVC5::EmptyBag \ - ::CVC5::EmptyBagHashFunction \ + ::cvc5::EmptyBag \ + ::cvc5::EmptyBagHashFunction \ "expr/emptybag.h" \ - "the empty bag constant; payload is an instance of the CVC5::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 \ - "::CVC5::theory::bags::BagsProperties::computeCardinality(%TYPE%)" \ + "::cvc5::theory::bags::BagsProperties::computeCardinality(%TYPE%)" \ "theory/bags/theory_bags_type_rules.h" well-founded BAG_TYPE \ - "::CVC5::theory::bags::BagsProperties::isWellFounded(%TYPE%)" \ - "::CVC5::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 \ - "::CVC5::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 \ - ::CVC5::MakeBagOp \ - ::CVC5::MakeBagOpHashFunction \ + ::cvc5::MakeBagOp \ + ::cvc5::MakeBagOpHashFunction \ "theory/bags/make_bag_op.h" \ - "operator for MK_BAG; payload is an instance of the CVC5::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 ::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 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 ::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 +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 ::CVC5::theory::bags::BinaryOperatorTypeRule -construle MK_BAG ::CVC5::theory::bags::MkBagTypeRule +construle UNION_DISJOINT ::cvc5::theory::bags::BinaryOperatorTypeRule +construle MK_BAG ::cvc5::theory::bags::MkBagTypeRule endtheory diff --git a/src/theory/bags/make_bag_op.cpp b/src/theory/bags/make_bag_op.cpp index 15e3a30c7..168379390 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/make_bag_op.h b/src/theory/bags/make_bag_op.h index 4c2a3e933..44b105225 100644 --- a/src/theory/bags/make_bag_op.h +++ b/src/theory/bags/make_bag_op.h @@ -19,7 +19,7 @@ #include <memory> -namespace CVC5 { +namespace cvc5 { class TypeNode; @@ -57,6 +57,6 @@ struct MakeBagOpHashFunction size_t operator()(const MakeBagOp& op) const; }; /* struct MakeBagOpHashFunction */ -} // namespace CVC5 +} // 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 5952b66d8..1773346f0 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -674,4 +674,4 @@ Node NormalForm::evaluateToSet(TNode n) } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/normal_form.h b/src/theory/bags/normal_form.h index 1c7f05d8e..5b5591133 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -192,6 +192,6 @@ class NormalForm }; } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__BAGS__NORMAL_FORM_H */ diff --git a/src/theory/bags/rewrites.cpp b/src/theory/bags/rewrites.cpp index d0299d52a..4d6929346 100644 --- a/src/theory/bags/rewrites.cpp +++ b/src/theory/bags/rewrites.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -79,4 +79,4 @@ std::ostream& operator<<(std::ostream& out, Rewrite r) } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/rewrites.h b/src/theory/bags/rewrites.h index 9e7bb54fa..aa49c71fb 100644 --- a/src/theory/bags/rewrites.h +++ b/src/theory/bags/rewrites.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -92,6 +92,6 @@ std::ostream& operator<<(std::ostream& out, Rewrite r); } // namespace bags } // namespace theory -} // namespace CVC5 +} // 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 4011a3fc4..aa714a61b 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -136,4 +136,4 @@ void SolverState::collectDisequalBagTerms() } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/solver_state.h b/src/theory/bags/solver_state.h index e6b2a2504..e7c09db8f 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -90,6 +90,6 @@ class SolverState : public TheoryState } // namespace bags } // namespace theory -} // namespace CVC5 +} // 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 072655834..dd3820c82 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -45,4 +45,4 @@ Node TermRegistry::getEmptyBag(TypeNode tn) } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/term_registry.h b/src/theory/bags/term_registry.h index adf97fd5f..ab519b100 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -59,6 +59,6 @@ class TermRegistry } // namespace bags } // namespace theory -} // namespace CVC5 +} // 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 f91fd40f0..bea83ce40 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/theory_bags.h b/src/theory/bags/theory_bags.h index 6bd9ddc65..7bb6111bd 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -114,6 +114,6 @@ class TheoryBags : public Theory } // namespace bags } // namespace theory -} // namespace CVC5 +} // 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 02494727c..f34d304fb 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -83,4 +83,4 @@ bool BagEnumerator::isFinished() } // namespace bags } // namespace theory -} // namespace CVC5
\ 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 c13946388..bdf57213d 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -86,6 +86,6 @@ class BagEnumerator : public TypeEnumeratorBase<BagEnumerator> } // namespace bags } // namespace theory -} // namespace CVC5 +} // 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 2acbb1e27..f198d68e9 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 CVC5 { +namespace cvc5 { namespace theory { namespace bags { @@ -279,4 +279,4 @@ TypeNode ToSetTypeRule::computeType(NodeManager* nodeManager, } } // namespace bags } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bags/theory_bags_type_rules.h b/src/theory/bags/theory_bags_type_rules.h index dd93186ad..f48001c5e 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 CVC5 { +namespace cvc5 { class NodeManager; @@ -102,6 +102,6 @@ struct BagsProperties } // namespace bags } // namespace theory -} // namespace CVC5 +} // 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 897c86e93..aa400a750 100644 --- a/src/theory/booleans/circuit_propagator.cpp +++ b/src/theory/booleans/circuit_propagator.cpp @@ -31,7 +31,7 @@ using namespace std; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/booleans/circuit_propagator.h b/src/theory/booleans/circuit_propagator.h index 6caccef08..72c5da1b3 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 CVC5 { +namespace cvc5 { class ProofGenerator; class ProofNode; @@ -274,6 +274,6 @@ class CircuitPropagator } // namespace booleans } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__BOOLEANS__CIRCUIT_PROPAGATOR_H */ diff --git a/src/theory/booleans/kinds b/src/theory/booleans/kinds index d8009ad12..6560cdd1a 100644 --- a/src/theory/booleans/kinds +++ b/src/theory/booleans/kinds @@ -4,12 +4,12 @@ # src/theory/builtin/kinds. # -theory THEORY_BOOL ::CVC5::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 ::CVC5::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 \ - ::CVC5::BoolHashFunction \ + ::cvc5::BoolHashFunction \ "util/bool.h" \ "truth and falsity; payload is a (C++) bool" enumerator BOOLEAN_TYPE \ - "::CVC5::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 ::CVC5::theory::boolean::BooleanTypeRule +typerule CONST_BOOLEAN ::cvc5::theory::boolean::BooleanTypeRule -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 +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 a51f238a2..d6600f14d 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 CVC5 { +namespace cvc5 { namespace theory { namespace booleans { @@ -948,4 +948,4 @@ Node BoolProofRuleChecker::checkInternal(PfRule id, } // namespace booleans } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/booleans/proof_checker.h b/src/theory/booleans/proof_checker.h index 93c3baf1e..da7ad0039 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 CVC5 { +namespace cvc5 { namespace theory { namespace booleans { @@ -43,6 +43,6 @@ class BoolProofRuleChecker : public ProofRuleChecker } // namespace booleans } // namespace theory -} // namespace CVC5 +} // 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 b84cf5488..9b3c6de10 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 CVC5 { +namespace cvc5 { namespace theory { namespace booleans { @@ -587,4 +587,4 @@ std::shared_ptr<ProofNode> ProofCircuitPropagatorForward::xorEval(bool x, } // namespace booleans } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/booleans/proof_circuit_propagator.h b/src/theory/booleans/proof_circuit_propagator.h index 671c6e964..5a643f7aa 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 CVC5 { +namespace cvc5 { class ProofNode; class ProofNodeManager; @@ -212,6 +212,6 @@ class ProofCircuitPropagatorForward : public ProofCircuitPropagator } // namespace booleans } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/booleans/theory_bool.cpp b/src/theory/booleans/theory_bool.cpp index 2df179e27..74279f43c 100644 --- a/src/theory/booleans/theory_bool.cpp +++ b/src/theory/booleans/theory_bool.cpp @@ -31,7 +31,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace booleans { @@ -82,4 +82,4 @@ Theory::PPAssertStatus TheoryBool::ppAssert( } // namespace booleans } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/booleans/theory_bool.h b/src/theory/booleans/theory_bool.h index cbd9ec381..05b169c24 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 CVC5 { +namespace cvc5 { namespace theory { namespace booleans { @@ -53,6 +53,6 @@ class TheoryBool : public Theory { } // namespace booleans } // namespace theory -} // namespace CVC5 +} // 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 3cc19a520..f1e002735 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 CVC5 { +namespace cvc5 { namespace theory { namespace booleans { @@ -431,4 +431,4 @@ RewriteResponse TheoryBoolRewriter::preRewrite(TNode n) { } // namespace booleans } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/booleans/theory_bool_rewriter.h b/src/theory/booleans/theory_bool_rewriter.h index 4caf5c681..5c1625f6d 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 CVC5 { +namespace cvc5 { namespace theory { namespace booleans { @@ -36,6 +36,6 @@ class TheoryBoolRewriter : public TheoryRewriter } // namespace booleans } // namespace theory -} // namespace CVC5 +} // 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 2f59a032e..af6618fa2 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 CVC5 { +namespace cvc5 { namespace theory { namespace boolean { @@ -72,6 +72,6 @@ public: } // namespace boolean } // namespace theory -} // namespace CVC5 +} // 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 9b6619961..c07290d31 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 CVC5 { +namespace cvc5 { namespace theory { namespace booleans { @@ -65,6 +65,6 @@ class BooleanEnumerator : public TypeEnumeratorBase<BooleanEnumerator> { } // namespace booleans } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__BOOLEANS__TYPE_ENUMERATOR_H */ diff --git a/src/theory/builtin/kinds b/src/theory/builtin/kinds index 48ceaf103..e2f69f19d 100644 --- a/src/theory/builtin/kinds +++ b/src/theory/builtin/kinds @@ -196,7 +196,7 @@ # is with your type checker: # # cardinality MY_TYPE \ -# ::CVC5::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 ::CVC5::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 ::CVC5::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 \ - "::CVC5::theory::builtin::SortProperties::isWellFounded(%TYPE%)" \ - "::CVC5::theory::builtin::SortProperties::mkGroundTerm(%TYPE%)" + "::cvc5::theory::builtin::SortProperties::isWellFounded(%TYPE%)" \ + "::cvc5::theory::builtin::SortProperties::mkGroundTerm(%TYPE%)" constant UNINTERPRETED_CONSTANT \ - ::CVC5::UninterpretedConstant \ - ::CVC5::UninterpretedConstantHashFunction \ + ::cvc5::UninterpretedConstant \ + ::cvc5::UninterpretedConstantHashFunction \ "expr/uninterpreted_constant.h" \ - "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 + "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 \ - ::CVC5::theory::builtin::UninterpretedSortEnumerator \ + ::cvc5::theory::builtin::UninterpretedSortEnumerator \ "theory/builtin/type_enumerator.h" constant ABSTRACT_VALUE \ - ::CVC5::AbstractValue \ - ::CVC5::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 CVC5::AbstractValue class (used in models)" -typerule ABSTRACT_VALUE ::CVC5::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 \ - ::CVC5::Kind \ - ::CVC5::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 \ - ::CVC5::TypeConstant \ - ::CVC5::TypeConstantHashFunction \ + ::cvc5::TypeConstant \ + ::cvc5::TypeConstantHashFunction \ "expr/kind.h" \ "a representation for basic types" operator FUNCTION_TYPE 2: "a function type" cardinality FUNCTION_TYPE \ - "::CVC5::theory::builtin::FunctionProperties::computeCardinality(%TYPE%)" \ + "::cvc5::theory::builtin::FunctionProperties::computeCardinality(%TYPE%)" \ "theory/builtin/theory_builtin_type_rules.h" well-founded FUNCTION_TYPE \ - "::CVC5::theory::builtin::FunctionProperties::isWellFounded(%TYPE%)" \ - "::CVC5::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 \ - ::CVC5::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 ::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 +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 ::CVC5::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 62f0f1b9a..36a29f88a 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { const char* toString(MethodId id) @@ -497,4 +497,4 @@ Node BuiltinProofRuleChecker::mkTheoryIdNode(TheoryId tid) } // namespace builtin } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/builtin/proof_checker.h b/src/theory/builtin/proof_checker.h index ed68f1215..f80434068 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 CVC5 { +namespace cvc5 { namespace theory { /** @@ -179,6 +179,6 @@ class BuiltinProofRuleChecker : public ProofRuleChecker } // namespace builtin } // namespace theory -} // namespace CVC5 +} // 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 83e9d3fed..bd0374675 100644 --- a/src/theory/builtin/theory_builtin.cpp +++ b/src/theory/builtin/theory_builtin.cpp @@ -24,7 +24,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace builtin { @@ -62,4 +62,4 @@ void TheoryBuiltin::finishInit() } // namespace builtin } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/builtin/theory_builtin.h b/src/theory/builtin/theory_builtin.h index 449282ae6..b4de83c02 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 CVC5 { +namespace cvc5 { namespace theory { namespace builtin { @@ -53,6 +53,6 @@ class TheoryBuiltin : public Theory } // namespace builtin } // namespace theory -} // namespace CVC5 +} // 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 16fc59a5a..d76bd51dd 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 CVC5 { +namespace cvc5 { namespace theory { namespace builtin { @@ -504,4 +504,4 @@ Node TheoryBuiltinRewriter::getArrayRepresentationForLambda(TNode n) } // namespace builtin } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/builtin/theory_builtin_rewriter.h b/src/theory/builtin/theory_builtin_rewriter.h index c419abdb3..7625aa846 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 CVC5 { +namespace cvc5 { namespace theory { namespace builtin { @@ -119,6 +119,6 @@ class TheoryBuiltinRewriter : public TheoryRewriter } // namespace builtin } // namespace theory -} // namespace CVC5 +} // 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 d5a5c9ab7..c5ea17847 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 CVC5 { +namespace cvc5 { namespace theory { namespace builtin { @@ -47,4 +47,4 @@ Node SortProperties::mkGroundTerm(TypeNode type) } // namespace builtin } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/builtin/theory_builtin_type_rules.h b/src/theory/builtin/theory_builtin_type_rules.h index 815483507..2c474aaee 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 CVC5 { +namespace cvc5 { namespace theory { namespace builtin { @@ -248,6 +248,6 @@ class FunctionProperties { } // namespace builtin } // namespace theory -} // namespace CVC5 +} // 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 4dda11070..2434bc521 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 CVC5 { +namespace cvc5 { namespace theory { namespace builtin { @@ -49,4 +49,4 @@ FunctionEnumerator& FunctionEnumerator::operator++() } // namespace builtin } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/builtin/type_enumerator.h b/src/theory/builtin/type_enumerator.h index 50cd50dda..7c14bb14c 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 CVC5 { +namespace cvc5 { namespace theory { namespace builtin { @@ -106,6 +106,6 @@ class FunctionEnumerator : public TypeEnumeratorBase<FunctionEnumerator> } // namespace builtin } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__BUILTIN_TYPE_ENUMERATOR_H */ diff --git a/src/theory/bv/abstraction.cpp b/src/theory/bv/abstraction.cpp index ee4b467b8..62c458723 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 CVC5; -using namespace CVC5::theory; -using namespace CVC5::theory::bv; -using namespace CVC5::context; +using namespace cvc5; +using namespace cvc5::theory; +using namespace cvc5::theory::bv; +using namespace cvc5::context; using namespace std; -using namespace CVC5::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 6c36de34c..182b29c19 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -246,6 +246,6 @@ public: } } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/bv/bitblast/aig_bitblaster.cpp b/src/theory/bv/bitblast/aig_bitblaster.cpp index 002a4f631..fb5adb54c 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 CVC5 { +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[] = "CVC5::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 CVC5 +} // 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 3eccbd3ec..002ca71ec 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 CVC5 { +namespace cvc5 { namespace prop { class SatSolver; } @@ -121,6 +121,6 @@ class AigBitblaster : public TBitblaster<Abc_Obj_t*> } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 7ae55015f..72b079321 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -899,6 +899,6 @@ void DefaultRotateLeftBB (TNode node, std::vector<T>& bits, TBitblaster<T>* bb) } } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/bv/bitblast/bitblast_utils.h b/src/theory/bv/bitblast/bitblast_utils.h index e342d4410..461d7fcaf 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 CVC5 { +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 CVC5 +} // 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 90ea5ac2b..311d44c94 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -268,6 +268,6 @@ Node TBitblaster<T>::getTermModel(TNode node, bool fullModel) } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 5e22262e2..41fadd8b0 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -288,4 +288,4 @@ bool EagerBitblaster::isSharedTerm(TNode node) { } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bitblast/eager_bitblaster.h b/src/theory/bv/bitblast/eager_bitblaster.h index dead462b5..87699df40 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -85,5 +85,5 @@ class BitblastingRegistrar : public prop::Registrar } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 e20a6f6b5..a5d3e9bb6 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -590,4 +590,4 @@ void TLazyBitblaster::clearSolver() { } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bitblast/lazy_bitblaster.h b/src/theory/bv/bitblast/lazy_bitblaster.h index 1a963e67d..91995b56b 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 CVC5 { +namespace cvc5 { namespace prop { class CnfStream; class NullRegistrat; @@ -176,5 +176,5 @@ class TLazyBitblaster : public TBitblaster<Node> } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 b0cf68609..a441e769e 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -84,4 +84,4 @@ bool BBProof::collectModelValues(TheoryModel* m, } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bitblast/proof_bitblaster.h b/src/theory/bv/bitblast/proof_bitblaster.h index 894a9a916..4983b485e 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -47,5 +47,5 @@ class BBProof } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/bv/bitblast/simple_bitblaster.cpp b/src/theory/bv/bitblast/simple_bitblaster.cpp index 76677e2db..05227ed09 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -155,4 +155,4 @@ bool BBSimple::isVariable(TNode node) } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bitblast/simple_bitblaster.h b/src/theory/bv/bitblast/simple_bitblaster.h index 1b48f9a68..300b93b53 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -75,6 +75,6 @@ class BBSimple : public TBitblaster<Node> } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/bv/bv_eager_solver.cpp b/src/theory/bv/bv_eager_solver.cpp index 9c478791c..97df17c58 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -125,4 +125,4 @@ bool EagerBitblastSolver::collectModelInfo(TheoryModel* m, bool fullModel) } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bv_eager_solver.h b/src/theory/bv/bv_eager_solver.h index 0fe1ed32b..17e6c50e7 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -60,6 +60,6 @@ class EagerBitblastSolver { } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 67554525a..27063ea7a 100644 --- a/src/theory/bv/bv_inequality_graph.cpp +++ b/src/theory/bv/bv_inequality_graph.cpp @@ -18,15 +18,15 @@ #include "theory/bv/theory_bv_utils.h" using namespace std; -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; +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 caa7220cf..3e856b789 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -291,6 +291,6 @@ public: } } -} // namespace CVC5 +} // 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 bbb2f1ca9..983a61eb5 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 CVC5::prop; +using namespace cvc5::prop; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -381,4 +381,4 @@ QuickXPlain::Statistics::~Statistics() { } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bv_quick_check.h b/src/theory/bv/bv_quick_check.h index 3d30d912d..7dbd01dcd 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 CVC5 { +namespace cvc5 { namespace theory { class TheoryModel; @@ -181,6 +181,6 @@ class QuickXPlain } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 f08f7527a..faa285b97 100644 --- a/src/theory/bv/bv_solver.h +++ b/src/theory/bv/bv_solver.h @@ -21,7 +21,7 @@ #include "theory/theory.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -117,6 +117,6 @@ class BVSolver } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 16a99c2e4..125cb243f 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -281,4 +281,4 @@ Node BVSolverBitblast::getValue(TNode node) } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bv_solver_bitblast.h b/src/theory/bv/bv_solver_bitblast.h index 794b9fa9b..86a75e0aa 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -143,6 +143,6 @@ class BVSolverBitblast : public BVSolver } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/bv/bv_solver_lazy.cpp b/src/theory/bv/bv_solver_lazy.cpp index ed71fccbe..00190233c 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 CVC5::theory::bv::utils; +using namespace cvc5::theory::bv::utils; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -828,4 +828,4 @@ void BVSolverLazy::setConflict(Node conflict) } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bv_solver_lazy.h b/src/theory/bv/bv_solver_lazy.h index 6511900eb..ea647346e 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -229,6 +229,6 @@ class BVSolverLazy : public BVSolver } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 65d46e861..c96e8d0bc 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -151,4 +151,4 @@ bool BVSolverSimple::collectModelValues(TheoryModel* m, } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bv_solver_simple.h b/src/theory/bv/bv_solver_simple.h index 1b6976abb..8983bddb2 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -81,6 +81,6 @@ class BVSolverSimple : public BVSolver } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/bv/bv_subtheory.h b/src/theory/bv/bv_subtheory.h index e558ea7c7..dec4614d3 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 CVC5 { +namespace cvc5 { namespace theory { @@ -107,6 +107,6 @@ class SubtheorySolver { } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 2343d72d1..c025dab5d 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 CVC5::context; -using namespace CVC5::prop; -using namespace CVC5::theory::bv::utils; +using namespace cvc5::context; +using namespace cvc5::prop; +using namespace cvc5::theory::bv::utils; using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -992,4 +992,4 @@ Node mergeExplanations(TNode expl1, TNode expl2) { } // namespace bv } /* namespace CVc4::theory */ -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bv_subtheory_algebraic.h b/src/theory/bv/bv_subtheory_algebraic.h index e7156a33e..01209331f 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -245,4 +245,4 @@ class AlgebraicSolver : public SubtheorySolver } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bv_subtheory_bitblast.cpp b/src/theory/bv/bv_subtheory_bitblast.cpp index 2d21a8f0c..f67f11e42 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 CVC5::context; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -278,4 +278,4 @@ void BitblastSolver::setConflict(TNode conflict) } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bv_subtheory_bitblast.h b/src/theory/bv/bv_subtheory_bitblast.h index f964fb995..2a6930184 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -83,4 +83,4 @@ class BitblastSolver : public SubtheorySolver } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bv_subtheory_core.cpp b/src/theory/bv/bv_subtheory_core.cpp index 486adfdb7..4f89eff71 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 CVC5; -using namespace CVC5::context; -using namespace CVC5::theory; -using namespace CVC5::theory::bv; -using namespace CVC5::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 700d8c4f5..042f2e73c 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -164,4 +164,4 @@ class CoreSolver : public SubtheorySolver { } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/bv_subtheory_inequality.cpp b/src/theory/bv/bv_subtheory_inequality.cpp index d67a5c550..c95d5e2dd 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 CVC5; -using namespace CVC5::context; -using namespace CVC5::theory; -using namespace CVC5::theory::bv; -using namespace CVC5::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 232c8676e..dc585b49b 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -89,6 +89,6 @@ class InequalitySolver : public SubtheorySolver } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 65a8b5480..b76fc1cb7 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 CVC5 { +namespace cvc5 { /* ** Converts bit-vector formulas to integer formulas. @@ -349,6 +349,6 @@ class IntBlaster bool d_introduceFreshIntVars; }; -} // namespace CVC5 +} // namespace cvc5 #endif /* __CVC4__THEORY__BV__INT_BLASTER_H */ diff --git a/src/theory/bv/kinds b/src/theory/bv/kinds index 884ee49e6..3a1032bc3 100644 --- a/src/theory/bv/kinds +++ b/src/theory/bv/kinds @@ -4,36 +4,36 @@ # src/theory/builtin/kinds. # -theory THEORY_BV ::CVC5::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 ::CVC5::theory::bv::TheoryBVRewriter "theory/bv/theory_bv_rewriter.h" +rewriter ::cvc5::theory::bv::TheoryBVRewriter "theory/bv/theory_bv_rewriter.h" constant BITVECTOR_TYPE \ - ::CVC5::BitVectorSize \ - "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorSize >" \ + ::cvc5::BitVectorSize \ + "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorSize >" \ "util/bitvector.h" \ "bit-vector type" cardinality BITVECTOR_TYPE \ - "::CVC5::theory::bv::CardinalityComputer::computeCardinality(%TYPE%)" \ + "::cvc5::theory::bv::CardinalityComputer::computeCardinality(%TYPE%)" \ "theory/bv/theory_bv_type_rules.h" constant CONST_BITVECTOR \ - ::CVC5::BitVector \ - ::CVC5::BitVectorHashFunction \ + ::cvc5::BitVector \ + ::cvc5::BitVectorHashFunction \ "util/bitvector.h" \ - "a fixed-width bit-vector constant; payload is an instance of the CVC5::BitVector class" + "a fixed-width bit-vector constant; payload is an instance of the cvc5::BitVector class" enumerator BITVECTOR_TYPE \ - "::CVC5::theory::bv::BitVectorEnumerator" \ + "::cvc5::theory::bv::BitVectorEnumerator" \ "theory/bv/type_enumerator.h" well-founded BITVECTOR_TYPE \ true \ - "(*CVC5::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 \ - ::CVC5::BitVectorBitOf \ - ::CVC5::BitVectorBitOfHashFunction \ + ::cvc5::BitVectorBitOf \ + ::cvc5::BitVectorBitOfHashFunction \ "util/bitvector.h" \ - "operator for the bit-vector boolean bit extract; payload is an instance of the CVC5::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 \ - ::CVC5::BitVectorExtract \ - ::CVC5::BitVectorExtractHashFunction \ + ::cvc5::BitVectorExtract \ + ::cvc5::BitVectorExtractHashFunction \ "util/bitvector.h" \ - "operator for the bit-vector extract; payload is an instance of the CVC5::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 \ - ::CVC5::BitVectorRepeat \ - "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorRepeat >" \ + ::cvc5::BitVectorRepeat \ + "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorRepeat >" \ "util/bitvector.h" \ - "operator for the bit-vector repeat; payload is an instance of the CVC5::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 \ - ::CVC5::BitVectorRotateLeft \ - "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorRotateLeft >" \ + ::cvc5::BitVectorRotateLeft \ + "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorRotateLeft >" \ "util/bitvector.h" \ - "operator for the bit-vector rotate left; payload is an instance of the CVC5::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 \ - ::CVC5::BitVectorRotateRight \ - "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorRotateRight >" \ + ::cvc5::BitVectorRotateRight \ + "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorRotateRight >" \ "util/bitvector.h" \ - "operator for the bit-vector rotate right; payload is an instance of the CVC5::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 \ - ::CVC5::BitVectorSignExtend \ - "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorSignExtend >" \ + ::cvc5::BitVectorSignExtend \ + "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorSignExtend >" \ "util/bitvector.h" \ - "operator for the bit-vector sign-extend; payload is an instance of the CVC5::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 \ - ::CVC5::BitVectorZeroExtend \ - "::CVC5::UnsignedHashFunction< ::CVC5::BitVectorZeroExtend >" \ + ::cvc5::BitVectorZeroExtend \ + "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorZeroExtend >" \ "util/bitvector.h" \ - "operator for the bit-vector zero-extend; payload is an instance of the CVC5::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 \ - ::CVC5::IntToBitVector \ - "::CVC5::UnsignedHashFunction< ::CVC5::IntToBitVector >" \ + ::cvc5::IntToBitVector \ + "::cvc5::UnsignedHashFunction< ::cvc5::IntToBitVector >" \ "util/bitvector.h" \ - "operator for the integer conversion to bit-vector; payload is an instance of the CVC5::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 ::CVC5::theory::bv::BitVectorConstantTypeRule +typerule CONST_BITVECTOR ::cvc5::theory::bv::BitVectorConstantTypeRule ## concatentation kind -typerule BITVECTOR_CONCAT ::CVC5::theory::bv::BitVectorConcatTypeRule +typerule BITVECTOR_CONCAT ::cvc5::theory::bv::BitVectorConcatTypeRule ## bit-wise kinds -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 +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 ::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 +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 ::CVC5::theory::bv::BitVectorFixedWidthTypeRule -typerule BITVECTOR_LSHR ::CVC5::theory::bv::BitVectorFixedWidthTypeRule -typerule BITVECTOR_SHL ::CVC5::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 ::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 +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 ::CVC5::theory::bv::BitVectorBVPredTypeRule -typerule BITVECTOR_SLTBV ::CVC5::theory::bv::BitVectorBVPredTypeRule +typerule BITVECTOR_ULTBV ::cvc5::theory::bv::BitVectorBVPredTypeRule +typerule BITVECTOR_SLTBV ::cvc5::theory::bv::BitVectorBVPredTypeRule ## if-then-else kind -typerule BITVECTOR_ITE ::CVC5::theory::bv::BitVectorITETypeRule +typerule BITVECTOR_ITE ::cvc5::theory::bv::BitVectorITETypeRule ## reduction kinds -typerule BITVECTOR_REDAND ::CVC5::theory::bv::BitVectorUnaryPredicateTypeRule -typerule BITVECTOR_REDOR ::CVC5::theory::bv::BitVectorUnaryPredicateTypeRule +typerule BITVECTOR_REDAND ::cvc5::theory::bv::BitVectorUnaryPredicateTypeRule +typerule BITVECTOR_REDOR ::cvc5::theory::bv::BitVectorUnaryPredicateTypeRule ## conversion kinds -typerule BITVECTOR_TO_NAT ::CVC5::theory::bv::BitVectorConversionTypeRule +typerule BITVECTOR_TO_NAT ::cvc5::theory::bv::BitVectorConversionTypeRule ## internal kinds -typerule BITVECTOR_ACKERMANNIZE_UDIV ::CVC5::theory::bv::BitVectorAckermanizationUdivTypeRule -typerule BITVECTOR_ACKERMANNIZE_UREM ::CVC5::theory::bv::BitVectorAckermanizationUremTypeRule -typerule BITVECTOR_EAGER_ATOM ::CVC5::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 ::CVC5::theory::bv::BitVectorBitOfTypeRule +typerule BITVECTOR_BITOF ::cvc5::theory::bv::BitVectorBitOfTypeRule typerule BITVECTOR_EXTRACT_OP "SimpleTypeRule<RBuiltinOperator>" -typerule BITVECTOR_EXTRACT ::CVC5::theory::bv::BitVectorExtractTypeRule +typerule BITVECTOR_EXTRACT ::cvc5::theory::bv::BitVectorExtractTypeRule typerule BITVECTOR_REPEAT_OP "SimpleTypeRule<RBuiltinOperator>" -typerule BITVECTOR_REPEAT ::CVC5::theory::bv::BitVectorRepeatTypeRule +typerule BITVECTOR_REPEAT ::cvc5::theory::bv::BitVectorRepeatTypeRule typerule BITVECTOR_ROTATE_LEFT_OP "SimpleTypeRule<RBuiltinOperator>" -typerule BITVECTOR_ROTATE_LEFT ::CVC5::theory::bv::BitVectorFixedWidthTypeRule +typerule BITVECTOR_ROTATE_LEFT ::cvc5::theory::bv::BitVectorFixedWidthTypeRule typerule BITVECTOR_ROTATE_RIGHT_OP "SimpleTypeRule<RBuiltinOperator>" -typerule BITVECTOR_ROTATE_RIGHT ::CVC5::theory::bv::BitVectorFixedWidthTypeRule +typerule BITVECTOR_ROTATE_RIGHT ::cvc5::theory::bv::BitVectorFixedWidthTypeRule typerule BITVECTOR_SIGN_EXTEND_OP "SimpleTypeRule<RBuiltinOperator>" -typerule BITVECTOR_SIGN_EXTEND ::CVC5::theory::bv::BitVectorExtendTypeRule +typerule BITVECTOR_SIGN_EXTEND ::cvc5::theory::bv::BitVectorExtendTypeRule typerule BITVECTOR_ZERO_EXTEND_OP "SimpleTypeRule<RBuiltinOperator>" -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 +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 82f37c552..e7ecc0f48 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -50,4 +50,4 @@ Node BVProofRuleChecker::checkInternal(PfRule id, } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/proof_checker.h b/src/theory/bv/proof_checker.h index efa319322..b328600df 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -45,6 +45,6 @@ class BVProofRuleChecker : public ProofRuleChecker } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__BV__PROOF_CHECKER_H */ diff --git a/src/theory/bv/slicer.cpp b/src/theory/bv/slicer.cpp index e8c032a61..75357b76c 100644 --- a/src/theory/bv/slicer.cpp +++ b/src/theory/bv/slicer.cpp @@ -22,7 +22,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -83,4 +83,4 @@ std::string Base::debugPrint() const { } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/slicer.h b/src/theory/bv/slicer.h index 56ed0ecba..55a64d92b 100644 --- a/src/theory/bv/slicer.h +++ b/src/theory/bv/slicer.h @@ -23,7 +23,7 @@ #include <vector> #include "util/index.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -51,6 +51,6 @@ public: } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 185f7ad2a..8f9f88ea2 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -236,4 +236,4 @@ bool TheoryBV::applyAbstraction(const std::vector<Node>& assertions, } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/theory_bv.h b/src/theory/bv/theory_bv.h index 1608dc3cf..c9ddaad11 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -124,6 +124,6 @@ class TheoryBV : public Theory } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 f9bd4215d..e92ed5543 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -770,4 +770,4 @@ struct FixpointRewriteStrategy { } // End namespace bv } // End namespace theory -} // End namespace CVC5 +} // 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 917d77637..5b25eb45d 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -492,4 +492,4 @@ Node RewriteRule<EvalComp>::apply(TNode node) { } } -} // namespace CVC5 +} // 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 c24c3ac48..7060b68a9 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -302,4 +302,4 @@ Node RewriteRule<ReflexivityEq>::apply(TNode node) { } } -} // namespace CVC5 +} // 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 cf7bc4a8f..4872f8070 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -1571,4 +1571,4 @@ inline Node RewriteRule<NormalizeEqPlusNeg>::apply(TNode node) } } -} // namespace CVC5 +} // 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 3750ef5b0..3244ebb6e 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -788,4 +788,4 @@ inline Node RewriteRule<RedandEliminate>::apply(TNode node) } } -} // namespace CVC5 +} // 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 c6dcb9f1e..2e99cc467 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -2257,4 +2257,4 @@ Node RewriteRule<MultSltMult>::apply(TNode node) } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/theory_bv_rewriter.cpp b/src/theory/bv/theory_bv_rewriter.cpp index 9b2d929ed..142afbb3f 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 CVC5; -using namespace CVC5::theory; -using namespace CVC5::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 e6c42f117..0be333ef0 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -105,6 +105,6 @@ class TheoryBVRewriter : public TheoryRewriter } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 54ed4579b..4de7eed6d 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -450,6 +450,6 @@ class BitVectorAckermanizationUremTypeRule } // namespace bv } // namespace theory -} // namespace CVC5 +} // 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 4a68e3724..c2a7f05b6 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { namespace utils { @@ -511,4 +511,4 @@ Node eliminateInt2Bv(TNode node) } // namespace utils } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/theory_bv_utils.h b/src/theory/bv/theory_bv_utils.h index 5795b5f14..04258d441 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -226,4 +226,4 @@ Node eliminateInt2Bv(TNode node); } } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/bv/type_enumerator.h b/src/theory/bv/type_enumerator.h index 31fe11715..826b61d6b 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 CVC5 { +namespace cvc5 { namespace theory { namespace bv { @@ -61,6 +61,6 @@ public: } // namespace bv } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__BV__TYPE_ENUMERATOR_H */ diff --git a/src/theory/care_graph.h b/src/theory/care_graph.h index 687378887..c87cafcbd 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 CVC5 { +namespace cvc5 { namespace theory { /** @@ -60,6 +60,6 @@ struct CarePair { typedef std::set<CarePair> CareGraph; } // namespace theory -} // namespace CVC5 +} // 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 df757c4a9..4fab0c580 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 CVC5 { +namespace cvc5 { namespace theory { CombinationCareGraph::CombinationCareGraph( @@ -99,4 +99,4 @@ bool CombinationCareGraph::buildModel() } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/combination_care_graph.h b/src/theory/combination_care_graph.h index a59fa154e..9d40ed05f 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 CVC5 { +namespace cvc5 { class TheoryEngine; @@ -47,6 +47,6 @@ class CombinationCareGraph : public CombinationEngine }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__COMBINATION_DISTRIBUTED__H */ diff --git a/src/theory/combination_engine.cpp b/src/theory/combination_engine.cpp index 639a7e201..a5402633d 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 CVC5 { +namespace cvc5 { namespace theory { CombinationEngine::CombinationEngine(TheoryEngine& te, @@ -118,4 +118,4 @@ void CombinationEngine::resetRound() } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/combination_engine.h b/src/theory/combination_engine.h index 6798404e9..3fd74f630 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 CVC5 { +namespace cvc5 { class TheoryEngine; @@ -137,6 +137,6 @@ class CombinationEngine }; } // namespace theory -} // namespace CVC5 +} // 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 18332a972..0c190c776 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 CVC5; -using namespace CVC5::kind; +using namespace cvc5; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -796,4 +796,4 @@ Node DatatypesRewriter::replaceDebruijn(Node n, } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/datatypes/datatypes_rewriter.h b/src/theory/datatypes/datatypes_rewriter.h index 4126a505d..705fabdca 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 CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -144,6 +144,6 @@ class DatatypesRewriter : public TheoryRewriter } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // 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 d87ff15a5..e629ee2ff 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -275,4 +275,4 @@ std::string InferProofCons::identify() const } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/datatypes/infer_proof_cons.h b/src/theory/datatypes/infer_proof_cons.h index 70fa8fad5..362996f76 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 CVC5 { +namespace cvc5 { class ProofNodeManager; @@ -95,6 +95,6 @@ class InferProofCons : public ProofGenerator } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // 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 9749d7a2d..2f598598a 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -80,4 +80,4 @@ Node DatatypesInference::processFact(std::vector<Node>& exp, } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/datatypes/inference.h b/src/theory/datatypes/inference.h index bff56afdc..d60fb26f0 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 CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -69,6 +69,6 @@ class DatatypesInference : public SimpleTheoryInternalFact } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/datatypes/inference_manager.cpp b/src/theory/datatypes/inference_manager.cpp index f4a0f45d9..51d9a27ed 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -171,4 +171,4 @@ Node InferenceManager::prepareDtInference(Node conc, } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/datatypes/inference_manager.h b/src/theory/datatypes/inference_manager.h index c7b20ec83..912b44477 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 CVC5 { +namespace cvc5 { namespace theory { class EagerProofGenerator; @@ -109,6 +109,6 @@ class InferenceManager : public InferenceManagerBuffered } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/datatypes/kinds b/src/theory/datatypes/kinds index 3fd59d9cb..ab4c3bf6b 100644 --- a/src/theory/datatypes/kinds +++ b/src/theory/datatypes/kinds @@ -4,31 +4,31 @@ # src/theory/builtin/kinds. # -theory THEORY_DATATYPES ::CVC5::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 ::CVC5::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 \ - "::CVC5::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 \ - "::CVC5::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 \ - "::CVC5::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 \ - ::CVC5::DatatypeIndexConstant \ - "::CVC5::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 \ - "::CVC5::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 \ - "::CVC5::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 \ - ::CVC5::AscriptionType \ - ::CVC5::AscriptionTypeHashFunction \ + ::cvc5::AscriptionType \ + ::cvc5::AscriptionTypeHashFunction \ "expr/ascription_type.h" \ - "a type parameter for type ascription; payload is an instance of the CVC5::AscriptionType class" + "a type parameter for type ascription; payload is an instance of the cvc5::AscriptionType class" -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 +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 ::CVC5::theory::datatypes::DatatypeConstructorTypeRule +construle APPLY_CONSTRUCTOR ::cvc5::theory::datatypes::DatatypeConstructorTypeRule constant TUPLE_UPDATE_OP \ - ::CVC5::TupleUpdate \ - ::CVC5::TupleUpdateHashFunction \ + ::cvc5::TupleUpdate \ + ::cvc5::TupleUpdateHashFunction \ "util/tuple.h" \ - "operator for a tuple update; payload is an instance of the CVC5::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 ::CVC5::theory::datatypes::TupleUpdateOpTypeRule -typerule TUPLE_UPDATE ::CVC5::theory::datatypes::TupleUpdateTypeRule +typerule TUPLE_UPDATE_OP ::cvc5::theory::datatypes::TupleUpdateOpTypeRule +typerule TUPLE_UPDATE ::cvc5::theory::datatypes::TupleUpdateTypeRule constant RECORD_UPDATE_OP \ - ::CVC5::RecordUpdate \ - ::CVC5::RecordUpdateHashFunction \ + ::cvc5::RecordUpdate \ + ::cvc5::RecordUpdateHashFunction \ "expr/record.h" \ - "operator for a record update; payload is an instance CVC5::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 ::CVC5::theory::datatypes::RecordUpdateOpTypeRule -typerule RECORD_UPDATE ::CVC5::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 ::CVC5::theory::datatypes::DtSizeTypeRule +typerule DT_SIZE ::cvc5::theory::datatypes::DtSizeTypeRule operator DT_HEIGHT_BOUND 2 "datatypes height bound" -typerule DT_HEIGHT_BOUND ::CVC5::theory::datatypes::DtBoundTypeRule +typerule DT_HEIGHT_BOUND ::cvc5::theory::datatypes::DtBoundTypeRule operator DT_SIZE_BOUND 2 "datatypes height bound" -typerule DT_SIZE_BOUND ::CVC5::theory::datatypes::DtBoundTypeRule +typerule DT_SIZE_BOUND ::cvc5::theory::datatypes::DtBoundTypeRule operator DT_SYGUS_BOUND 2 "datatypes sygus bound" -typerule DT_SYGUS_BOUND ::CVC5::theory::datatypes::DtSygusBoundTypeRule +typerule DT_SYGUS_BOUND ::cvc5::theory::datatypes::DtSygusBoundTypeRule operator DT_SYGUS_EVAL 1: "datatypes sygus evaluation function" -typerule DT_SYGUS_EVAL ::CVC5::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 ::CVC5::theory::datatypes::MatchTypeRule -typerule MATCH_CASE ::CVC5::theory::datatypes::MatchCaseTypeRule -typerule MATCH_BIND_CASE ::CVC5::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 \ - ::CVC5::TupleProjectOp \ - ::CVC5::TupleProjectOpHashFunction \ + ::cvc5::TupleProjectOp \ + ::cvc5::TupleProjectOpHashFunction \ "theory/datatypes/tuple_project_op.h" \ - "operator for TUPLE_PROJECT; payload is an instance of the CVC5::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 ::CVC5::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 f55b45541..06a94aa47 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 CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -133,4 +133,4 @@ Node DatatypesProofRuleChecker::checkInternal(PfRule id, } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/datatypes/proof_checker.h b/src/theory/datatypes/proof_checker.h index a66cac8d8..a52bbafb0 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 CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -44,6 +44,6 @@ class DatatypesProofRuleChecker : public ProofRuleChecker } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // 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 4f328619b..114608e05 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 CVC5; -using namespace CVC5::kind; +using namespace cvc5; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { namespace utils { @@ -777,4 +777,4 @@ TypeNode substituteAndGeneralizeSygusType(TypeNode sdt, } // namespace utils } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/datatypes/sygus_datatype_utils.h b/src/theory/datatypes/sygus_datatype_utils.h index e1af9250b..7aa308aea 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 CVC5 { +namespace cvc5 { namespace theory { // ----------------------- sygus datatype attributes @@ -237,6 +237,6 @@ TypeNode substituteAndGeneralizeSygusType(TypeNode sdt, } // namespace utils } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/datatypes/sygus_extension.cpp b/src/theory/datatypes/sygus_extension.cpp index a53799baf..14c004bda 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 CVC5; -using namespace CVC5::kind; -using namespace CVC5::context; -using namespace CVC5::theory; -using namespace CVC5::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 7b49faa6d..157929ee6 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { class SynthConjecture; @@ -709,7 +709,7 @@ private: } } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/datatypes/sygus_simple_sym.cpp b/src/theory/datatypes/sygus_simple_sym.cpp index ed6357244..81a9b7444 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -584,4 +584,4 @@ int SygusSimpleSymBreak::getFirstArgOccurrence(const DTypeConstructor& c, } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/datatypes/sygus_simple_sym.h b/src/theory/datatypes/sygus_simple_sym.h index 5b5b816b7..be90aa9ff 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 CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -98,6 +98,6 @@ class SygusSimpleSymBreak } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // 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 48a2a8a99..9d231f07d 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -2041,4 +2041,4 @@ std::pair<bool, Node> TheoryDatatypes::entailmentCheck(TNode lit) } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/datatypes/theory_datatypes.h b/src/theory/datatypes/theory_datatypes.h index 03ea69fc4..34e865a50 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 CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -314,6 +314,6 @@ private: } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // 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 8084763b2..68269b61c 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 CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -628,6 +628,6 @@ class TupleProjectTypeRule } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // 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 72c032e4e..a18b5fdb5 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 CVC5; -using namespace CVC5::kind; +using namespace cvc5; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/datatypes/theory_datatypes_utils.h b/src/theory/datatypes/theory_datatypes_utils.h index be7f5d4af..c79364dab 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/datatypes/tuple_project_op.cpp b/src/theory/datatypes/tuple_project_op.cpp index ebc229eb4..0bab99d21 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/datatypes/tuple_project_op.h b/src/theory/datatypes/tuple_project_op.h index 8272e7487..9e9e2dad4 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 CVC5 { +namespace cvc5 { class TypeNode; @@ -53,6 +53,6 @@ struct TupleProjectOpHashFunction size_t operator()(const TupleProjectOp& op) const; }; /* struct TupleProjectOpHashFunction */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__PROJECT_OP_H */ diff --git a/src/theory/datatypes/type_enumerator.cpp b/src/theory/datatypes/type_enumerator.cpp index 54b042307..769446fd2 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 CVC5; +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 3d1264a80..5d9a3a9b1 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 CVC5 { +namespace cvc5 { namespace theory { namespace datatypes { @@ -164,6 +164,6 @@ class DatatypesEnumerator : public TypeEnumeratorBase<DatatypesEnumerator> { } // namespace datatypes } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__DATATYPES__TYPE_ENUMERATOR_H */ diff --git a/src/theory/decision_manager.cpp b/src/theory/decision_manager.cpp index 3abbb83e7..c249c9e89 100644 --- a/src/theory/decision_manager.cpp +++ b/src/theory/decision_manager.cpp @@ -17,9 +17,9 @@ #include "theory/rewriter.h" -using namespace CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { DecisionManager::DecisionManager(context::Context* userContext) @@ -107,4 +107,4 @@ Node DecisionManager::getNextDecisionRequest() } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/decision_manager.h b/src/theory/decision_manager.h index c6e7a44a1..910375370 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 CVC5 { +namespace cvc5 { namespace theory { /** DecisionManager @@ -141,6 +141,6 @@ class DecisionManager }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__DECISION_MANAGER__H */ diff --git a/src/theory/decision_strategy.cpp b/src/theory/decision_strategy.cpp index b8ef264dd..0ce2372b2 100644 --- a/src/theory/decision_strategy.cpp +++ b/src/theory/decision_strategy.cpp @@ -17,9 +17,9 @@ #include "theory/rewriter.h" -using namespace CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/decision_strategy.h b/src/theory/decision_strategy.h index e9d8b8bbc..9046dd6ce 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 CVC5 { +namespace cvc5 { namespace theory { /** @@ -140,6 +140,6 @@ class DecisionStrategySingleton : public DecisionStrategyFmf }; } // namespace theory -} // namespace CVC5 +} // 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 1763969e6..112f7ea7b 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/eager_proof_generator.h b/src/theory/eager_proof_generator.h index 2c94d2074..5cc0fde35 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 CVC5 { +namespace cvc5 { class ProofNode; class ProofNodeManager; @@ -193,6 +193,6 @@ class EagerProofGenerator : public ProofGenerator }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__PROOF_GENERATOR_H */ diff --git a/src/theory/ee_manager.cpp b/src/theory/ee_manager.cpp index d2254fc6c..ec08c8669 100644 --- a/src/theory/ee_manager.cpp +++ b/src/theory/ee_manager.cpp @@ -16,7 +16,7 @@ #include "theory/theory_model.h" -namespace CVC5 { +namespace cvc5 { namespace theory { EqEngineManager::EqEngineManager(TheoryEngine& te, SharedSolver& shs) @@ -47,4 +47,4 @@ eq::EqualityEngine* EqEngineManager::allocateEqualityEngine(EeSetupInfo& esi, } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/ee_manager.h b/src/theory/ee_manager.h index dd400c188..ad922bf80 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 CVC5 { +namespace cvc5 { class TheoryEngine; @@ -95,6 +95,6 @@ class EqEngineManager }; } // namespace theory -} // namespace CVC5 +} // 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 289725e30..0619b58b3 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 CVC5 { +namespace cvc5 { namespace theory { EqEngineManagerDistributed::EqEngineManagerDistributed(TheoryEngine& te, @@ -115,4 +115,4 @@ void EqEngineManagerDistributed::MasterNotifyClass::eqNotifyNewClass(TNode t) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/ee_manager_distributed.h b/src/theory/ee_manager_distributed.h index d7d6688fb..48bbfd073 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 CVC5 { +namespace cvc5 { namespace theory { namespace eq { @@ -97,6 +97,6 @@ class EqEngineManagerDistributed : public EqEngineManager }; } // namespace theory -} // namespace CVC5 +} // 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 7859773f0..b2167115a 100644 --- a/src/theory/ee_setup_info.h +++ b/src/theory/ee_setup_info.h @@ -19,7 +19,7 @@ #include <string> -namespace CVC5 { +namespace cvc5 { namespace theory { namespace eq { @@ -55,6 +55,6 @@ struct EeSetupInfo }; } // namespace theory -} // namespace CVC5 +} // 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 40d1d59d5..0597bb3ea 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { EngineOutputChannel::Statistics::Statistics(theory::TheoryId theory) @@ -188,4 +188,4 @@ void EngineOutputChannel::trustedLemma(TrustNode plem, LemmaProperty p) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/engine_output_channel.h b/src/theory/engine_output_channel.h index 115566bdc..8b497547b 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 CVC5 { +namespace cvc5 { class TheoryEngine; @@ -108,6 +108,6 @@ class EngineOutputChannel : public theory::OutputChannel }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__ENGINE_OUTPUT_CHANNEL_H */ diff --git a/src/theory/evaluator.cpp b/src/theory/evaluator.cpp index 758930859..156e23093 100644 --- a/src/theory/evaluator.cpp +++ b/src/theory/evaluator.cpp @@ -22,7 +22,7 @@ #include "theory/theory.h" #include "util/integer.h" -namespace CVC5 { +namespace cvc5 { namespace theory { EvalResult::EvalResult(const EvalResult& other) @@ -952,4 +952,4 @@ Node Evaluator::reconstruct( } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/evaluator.h b/src/theory/evaluator.h index ee76c6210..ad6eedb0f 100644 --- a/src/theory/evaluator.h +++ b/src/theory/evaluator.h @@ -30,7 +30,7 @@ #include "util/rational.h" #include "util/string.h" -namespace CVC5 { +namespace cvc5 { namespace theory { /** @@ -159,6 +159,6 @@ class Evaluator }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__EVALUATOR_H */ diff --git a/src/theory/ext_theory.cpp b/src/theory/ext_theory.cpp index 2e39b2a35..80fafe92c 100644 --- a/src/theory/ext_theory.cpp +++ b/src/theory/ext_theory.cpp @@ -27,7 +27,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { bool ExtTheoryCallback::getCurrentSubstitution( @@ -558,4 +558,4 @@ std::vector<Node> ExtTheory::getActive(Kind k) const void ExtTheory::clearCache() { d_gst_cache.clear(); } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/ext_theory.h b/src/theory/ext_theory.h index 3d8df356c..b44f2b852 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 CVC5 { +namespace cvc5 { namespace theory { class OutputChannel; @@ -302,6 +302,6 @@ class ExtTheory }; } // namespace theory -} // namespace CVC5 +} // 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 879cd2988..3b5a115c8 100644 --- a/src/theory/fp/fp_converter.cpp +++ b/src/theory/fp/fp_converter.cpp @@ -41,7 +41,7 @@ #ifdef CVC4_USE_SYMFPU namespace symfpu { -using namespace ::CVC5::theory::fp::symfpuSymbolic; +using namespace ::cvc5::theory::fp::symfpuSymbolic; #define CVC4_SYM_ITE_DFN(T) \ template <> \ @@ -51,65 +51,65 @@ using namespace ::CVC5::theory::fp::symfpuSymbolic; const T& _l, \ const T& _r) \ { \ - ::CVC5::NodeManager* nm = ::CVC5::NodeManager::currentNM(); \ + ::cvc5::NodeManager* nm = ::cvc5::NodeManager::currentNM(); \ \ - ::CVC5::Node cond = _cond; \ - ::CVC5::Node l = _l; \ - ::CVC5::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(::CVC5::BitVector(1U, 1U))) ? l : r; \ + return (cond == nm->mkConst(::cvc5::BitVector(1U, 1U))) ? l : r; \ } \ else \ { \ - if (l.getKind() == ::CVC5::kind::BITVECTOR_ITE) \ + if (l.getKind() == ::cvc5::kind::BITVECTOR_ITE) \ { \ if (l[1] == r) \ { \ return nm->mkNode( \ - ::CVC5::kind::BITVECTOR_ITE, \ - nm->mkNode(::CVC5::kind::BITVECTOR_AND, \ + ::cvc5::kind::BITVECTOR_ITE, \ + nm->mkNode(::cvc5::kind::BITVECTOR_AND, \ cond, \ - nm->mkNode(::CVC5::kind::BITVECTOR_NOT, l[0])), \ + nm->mkNode(::cvc5::kind::BITVECTOR_NOT, l[0])), \ l[2], \ r); \ } \ else if (l[2] == r) \ { \ return nm->mkNode( \ - ::CVC5::kind::BITVECTOR_ITE, \ - nm->mkNode(::CVC5::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() == ::CVC5::kind::BITVECTOR_ITE) \ + else if (r.getKind() == ::cvc5::kind::BITVECTOR_ITE) \ { \ if (r[1] == l) \ { \ return nm->mkNode( \ - ::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])), \ + ::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( \ - ::CVC5::kind::BITVECTOR_ITE, \ - nm->mkNode(::CVC5::kind::BITVECTOR_AND, \ - nm->mkNode(::CVC5::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(::CVC5::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 CVC5 { +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>(::CVC5::NodeManager::currentNM()->mkNode( - ::CVC5::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>(::CVC5::NodeManager::currentNM()->mkNode( - ::CVC5::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(::CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/theory/fp/fp_converter.h b/src/theory/fp/fp_converter.h index e952699a7..f25ce0822 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 CVC5 { +namespace cvc5 { namespace theory { namespace fp { @@ -97,7 +97,7 @@ class traits typedef traits::bwt bwt; /** - * Wrap the CVC5::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 CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__FP__THEORY_FP_H */ diff --git a/src/theory/fp/kinds b/src/theory/fp/kinds index 4a4d16b55..d67738a63 100644 --- a/src/theory/fp/kinds +++ b/src/theory/fp/kinds @@ -4,9 +4,9 @@ # src/theory/builtin/kinds. # -theory THEORY_FP ::CVC5::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 ::CVC5::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 \ - ::CVC5::FloatingPoint \ - ::CVC5::FloatingPointHashFunction \ + ::cvc5::FloatingPoint \ + ::cvc5::FloatingPointHashFunction \ "util/floatingpoint.h" \ "a floating-point literal" -typerule CONST_FLOATINGPOINT ::CVC5::theory::fp::FloatingPointConstantTypeRule +typerule CONST_FLOATINGPOINT ::cvc5::theory::fp::FloatingPointConstantTypeRule constant CONST_ROUNDINGMODE \ - ::CVC5::RoundingMode \ - ::CVC5::RoundingModeHashFunction \ + ::cvc5::RoundingMode \ + ::cvc5::RoundingModeHashFunction \ "util/floatingpoint.h" \ "a floating-point rounding mode" -typerule CONST_ROUNDINGMODE ::CVC5::theory::fp::RoundingModeConstantTypeRule +typerule CONST_ROUNDINGMODE ::cvc5::theory::fp::RoundingModeConstantTypeRule @@ -39,272 +39,272 @@ sort ROUNDINGMODE_TYPE \ "floating-point rounding mode" enumerator ROUNDINGMODE_TYPE \ - "::CVC5::theory::fp::RoundingModeEnumerator" \ + "::cvc5::theory::fp::RoundingModeEnumerator" \ "theory/fp/type_enumerator.h" constant FLOATINGPOINT_TYPE \ - ::CVC5::FloatingPointSize \ - ::CVC5::FloatingPointSizeHashFunction \ + ::cvc5::FloatingPointSize \ + ::cvc5::FloatingPointSizeHashFunction \ "util/floatingpoint.h" \ "floating-point type" cardinality FLOATINGPOINT_TYPE \ - "::CVC5::theory::fp::CardinalityComputer::computeCardinality(%TYPE%)" \ + "::cvc5::theory::fp::CardinalityComputer::computeCardinality(%TYPE%)" \ "theory/fp/theory_fp_type_rules.h" enumerator FLOATINGPOINT_TYPE \ - "::CVC5::theory::fp::FloatingPointEnumerator" \ + "::cvc5::theory::fp::FloatingPointEnumerator" \ "theory/fp/type_enumerator.h" well-founded FLOATINGPOINT_TYPE \ true \ - "(*CVC5::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 ::CVC5::theory::fp::FloatingPointFPTypeRule +typerule FLOATINGPOINT_FP ::cvc5::theory::fp::FloatingPointFPTypeRule operator FLOATINGPOINT_EQ 2: "floating-point equality" -typerule FLOATINGPOINT_EQ ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_EQ ::cvc5::theory::fp::FloatingPointTestTypeRule operator FLOATINGPOINT_ABS 1 "floating-point absolute value" -typerule FLOATINGPOINT_ABS ::CVC5::theory::fp::FloatingPointOperationTypeRule +typerule FLOATINGPOINT_ABS ::cvc5::theory::fp::FloatingPointOperationTypeRule operator FLOATINGPOINT_NEG 1 "floating-point negation" -typerule FLOATINGPOINT_NEG ::CVC5::theory::fp::FloatingPointOperationTypeRule +typerule FLOATINGPOINT_NEG ::cvc5::theory::fp::FloatingPointOperationTypeRule operator FLOATINGPOINT_PLUS 3 "floating-point addition" -typerule FLOATINGPOINT_PLUS ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule +typerule FLOATINGPOINT_PLUS ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule operator FLOATINGPOINT_SUB 3 "floating-point sutraction" -typerule FLOATINGPOINT_SUB ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule +typerule FLOATINGPOINT_SUB ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule operator FLOATINGPOINT_MULT 3 "floating-point multiply" -typerule FLOATINGPOINT_MULT ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule +typerule FLOATINGPOINT_MULT ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule operator FLOATINGPOINT_DIV 3 "floating-point division" -typerule FLOATINGPOINT_DIV ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule +typerule FLOATINGPOINT_DIV ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule operator FLOATINGPOINT_FMA 4 "floating-point fused multiply and add" -typerule FLOATINGPOINT_FMA ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule +typerule FLOATINGPOINT_FMA ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule operator FLOATINGPOINT_SQRT 2 "floating-point square root" -typerule FLOATINGPOINT_SQRT ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule +typerule FLOATINGPOINT_SQRT ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule operator FLOATINGPOINT_REM 2 "floating-point remainder" -typerule FLOATINGPOINT_REM ::CVC5::theory::fp::FloatingPointOperationTypeRule +typerule FLOATINGPOINT_REM ::cvc5::theory::fp::FloatingPointOperationTypeRule operator FLOATINGPOINT_RTI 2 "floating-point round to integral" -typerule FLOATINGPOINT_RTI ::CVC5::theory::fp::FloatingPointRoundingOperationTypeRule +typerule FLOATINGPOINT_RTI ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule operator FLOATINGPOINT_MIN 2 "floating-point minimum" -typerule FLOATINGPOINT_MIN ::CVC5::theory::fp::FloatingPointOperationTypeRule +typerule FLOATINGPOINT_MIN ::cvc5::theory::fp::FloatingPointOperationTypeRule operator FLOATINGPOINT_MAX 2 "floating-point maximum" -typerule FLOATINGPOINT_MAX ::CVC5::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 ::CVC5::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 ::CVC5::theory::fp::FloatingPointPartialOperationTypeRule +typerule FLOATINGPOINT_MAX_TOTAL ::cvc5::theory::fp::FloatingPointPartialOperationTypeRule operator FLOATINGPOINT_LEQ 2: "floating-point less than or equal" -typerule FLOATINGPOINT_LEQ ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_LEQ ::cvc5::theory::fp::FloatingPointTestTypeRule operator FLOATINGPOINT_LT 2: "floating-point less than" -typerule FLOATINGPOINT_LT ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_LT ::cvc5::theory::fp::FloatingPointTestTypeRule operator FLOATINGPOINT_GEQ 2: "floating-point greater than or equal" -typerule FLOATINGPOINT_GEQ ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_GEQ ::cvc5::theory::fp::FloatingPointTestTypeRule operator FLOATINGPOINT_GT 2: "floating-point greater than" -typerule FLOATINGPOINT_GT ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_GT ::cvc5::theory::fp::FloatingPointTestTypeRule operator FLOATINGPOINT_ISN 1 "floating-point is normal" -typerule FLOATINGPOINT_ISN ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_ISN ::cvc5::theory::fp::FloatingPointTestTypeRule operator FLOATINGPOINT_ISSN 1 "floating-point is sub-normal" -typerule FLOATINGPOINT_ISSN ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_ISSN ::cvc5::theory::fp::FloatingPointTestTypeRule operator FLOATINGPOINT_ISZ 1 "floating-point is zero" -typerule FLOATINGPOINT_ISZ ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_ISZ ::cvc5::theory::fp::FloatingPointTestTypeRule operator FLOATINGPOINT_ISINF 1 "floating-point is infinite" -typerule FLOATINGPOINT_ISINF ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_ISINF ::cvc5::theory::fp::FloatingPointTestTypeRule operator FLOATINGPOINT_ISNAN 1 "floating-point is NaN" -typerule FLOATINGPOINT_ISNAN ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_ISNAN ::cvc5::theory::fp::FloatingPointTestTypeRule operator FLOATINGPOINT_ISNEG 1 "floating-point is negative" -typerule FLOATINGPOINT_ISNEG ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_ISNEG ::cvc5::theory::fp::FloatingPointTestTypeRule operator FLOATINGPOINT_ISPOS 1 "floating-point is positive" -typerule FLOATINGPOINT_ISPOS ::CVC5::theory::fp::FloatingPointTestTypeRule +typerule FLOATINGPOINT_ISPOS ::cvc5::theory::fp::FloatingPointTestTypeRule constant FLOATINGPOINT_TO_FP_IEEE_BITVECTOR_OP \ - ::CVC5::FloatingPointToFPIEEEBitVector \ - "::CVC5::FloatingPointConvertSortHashFunction<0x1>" \ + ::cvc5::FloatingPointToFPIEEEBitVector \ + "::cvc5::FloatingPointConvertSortHashFunction<0x1>" \ "util/floatingpoint.h" \ "operator for to_fp from bit vector" -typerule FLOATINGPOINT_TO_FP_IEEE_BITVECTOR_OP ::CVC5::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 ::CVC5::theory::fp::FloatingPointToFPIEEEBitVectorTypeRule +typerule FLOATINGPOINT_TO_FP_IEEE_BITVECTOR ::cvc5::theory::fp::FloatingPointToFPIEEEBitVectorTypeRule constant FLOATINGPOINT_TO_FP_FLOATINGPOINT_OP \ - ::CVC5::FloatingPointToFPFloatingPoint \ - "::CVC5::FloatingPointConvertSortHashFunction<0x2>" \ + ::cvc5::FloatingPointToFPFloatingPoint \ + "::cvc5::FloatingPointConvertSortHashFunction<0x2>" \ "util/floatingpoint.h" \ "operator for to_fp from floating point" -typerule FLOATINGPOINT_TO_FP_FLOATINGPOINT_OP ::CVC5::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 ::CVC5::theory::fp::FloatingPointToFPFloatingPointTypeRule +typerule FLOATINGPOINT_TO_FP_FLOATINGPOINT ::cvc5::theory::fp::FloatingPointToFPFloatingPointTypeRule constant FLOATINGPOINT_TO_FP_REAL_OP \ - ::CVC5::FloatingPointToFPReal \ - "::CVC5::FloatingPointConvertSortHashFunction<0x4>" \ + ::cvc5::FloatingPointToFPReal \ + "::cvc5::FloatingPointConvertSortHashFunction<0x4>" \ "util/floatingpoint.h" \ "operator for to_fp from real" -typerule FLOATINGPOINT_TO_FP_REAL_OP ::CVC5::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 ::CVC5::theory::fp::FloatingPointToFPRealTypeRule +typerule FLOATINGPOINT_TO_FP_REAL ::cvc5::theory::fp::FloatingPointToFPRealTypeRule constant FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR_OP \ - ::CVC5::FloatingPointToFPSignedBitVector \ - "::CVC5::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 ::CVC5::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 ::CVC5::theory::fp::FloatingPointToFPSignedBitVectorTypeRule +typerule FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR ::cvc5::theory::fp::FloatingPointToFPSignedBitVectorTypeRule constant FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR_OP \ - ::CVC5::FloatingPointToFPUnsignedBitVector \ - "::CVC5::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 ::CVC5::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 ::CVC5::theory::fp::FloatingPointToFPUnsignedBitVectorTypeRule +typerule FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR ::cvc5::theory::fp::FloatingPointToFPUnsignedBitVectorTypeRule constant FLOATINGPOINT_TO_FP_GENERIC_OP \ - ::CVC5::FloatingPointToFPGeneric \ - "::CVC5::FloatingPointConvertSortHashFunction<0x11>" \ + ::cvc5::FloatingPointToFPGeneric \ + "::cvc5::FloatingPointConvertSortHashFunction<0x11>" \ "util/floatingpoint.h" \ "operator for a generic to_fp" -typerule FLOATINGPOINT_TO_FP_GENERIC_OP ::CVC5::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 ::CVC5::theory::fp::FloatingPointToFPGenericTypeRule +typerule FLOATINGPOINT_TO_FP_GENERIC ::cvc5::theory::fp::FloatingPointToFPGenericTypeRule constant FLOATINGPOINT_TO_UBV_OP \ - ::CVC5::FloatingPointToUBV \ - "::CVC5::FloatingPointToBVHashFunction<0x1>" \ + ::cvc5::FloatingPointToUBV \ + "::cvc5::FloatingPointToBVHashFunction<0x1>" \ "util/floatingpoint.h" \ "operator for to_ubv" -typerule FLOATINGPOINT_TO_UBV_OP ::CVC5::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 ::CVC5::theory::fp::FloatingPointToUBVTypeRule +typerule FLOATINGPOINT_TO_UBV ::cvc5::theory::fp::FloatingPointToUBVTypeRule constant FLOATINGPOINT_TO_UBV_TOTAL_OP \ - ::CVC5::FloatingPointToUBVTotal \ - "::CVC5::FloatingPointToBVHashFunction<0x4>" \ + ::cvc5::FloatingPointToUBVTotal \ + "::cvc5::FloatingPointToBVHashFunction<0x4>" \ "util/floatingpoint.h" \ "operator for to_ubv_total" -typerule FLOATINGPOINT_TO_UBV_TOTAL_OP ::CVC5::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 ::CVC5::theory::fp::FloatingPointToUBVTotalTypeRule +typerule FLOATINGPOINT_TO_UBV_TOTAL ::cvc5::theory::fp::FloatingPointToUBVTotalTypeRule constant FLOATINGPOINT_TO_SBV_OP \ - ::CVC5::FloatingPointToSBV \ - "::CVC5::FloatingPointToBVHashFunction<0x2>" \ + ::cvc5::FloatingPointToSBV \ + "::cvc5::FloatingPointToBVHashFunction<0x2>" \ "util/floatingpoint.h" \ "operator for to_sbv" -typerule FLOATINGPOINT_TO_SBV_OP ::CVC5::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 ::CVC5::theory::fp::FloatingPointToSBVTypeRule +typerule FLOATINGPOINT_TO_SBV ::cvc5::theory::fp::FloatingPointToSBVTypeRule constant FLOATINGPOINT_TO_SBV_TOTAL_OP \ - ::CVC5::FloatingPointToSBVTotal \ - "::CVC5::FloatingPointToBVHashFunction<0x8>" \ + ::cvc5::FloatingPointToSBVTotal \ + "::cvc5::FloatingPointToBVHashFunction<0x8>" \ "util/floatingpoint.h" \ "operator for to_sbv_total" -typerule FLOATINGPOINT_TO_SBV_TOTAL_OP ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::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 ea9ea902c..38444c7af 100644 --- a/src/theory/fp/theory_fp.cpp +++ b/src/theory/fp/theory_fp.cpp @@ -33,7 +33,7 @@ using namespace std; -namespace CVC5 { +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(::CVC5::BitVector(1U, 1U)))); + nm->mkNode(kind::EQUAL, addA, nm->mkConst(::cvc5::BitVector(1U, 1U)))); #endif ++oldAdditionalAssertions; @@ -795,7 +795,7 @@ void TheoryFp::convertAndEquateTerm(TNode node) { kind::EQUAL, node, nm->mkNode( - kind::EQUAL, converted, nm->mkConst(::CVC5::BitVector(1U, 1U))))); + kind::EQUAL, converted, nm->mkConst(::cvc5::BitVector(1U, 1U))))); #endif } else { @@ -1157,4 +1157,4 @@ void TheoryFp::NotifyClass::eqNotifyConstantTermMerge(TNode t1, TNode t2) { } // namespace fp } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/fp/theory_fp.h b/src/theory/fp/theory_fp.h index 2607a33c6..87c63a231 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 CVC5 { +namespace cvc5 { namespace theory { namespace fp { @@ -189,6 +189,6 @@ class TheoryFp : public Theory } // namespace fp } // namespace theory -} // namespace CVC5 +} // 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 65e27fc48..d84c553de 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 CVC5 { +namespace cvc5 { namespace theory { namespace fp { @@ -1421,4 +1421,4 @@ TheoryFpRewriter::TheoryFpRewriter() } // namespace fp } // namespace theory - } // namespace CVC5 + } // namespace cvc5 diff --git a/src/theory/fp/theory_fp_rewriter.h b/src/theory/fp/theory_fp_rewriter.h index bfdf90d44..52d22f3d3 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 CVC5 { +namespace cvc5 { namespace theory { namespace fp { @@ -53,6 +53,6 @@ class TheoryFpRewriter : public TheoryRewriter } // namespace fp } // namespace theory -} // namespace CVC5 +} // 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 6b87f8af3..d7060ad98 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 CVC5 { +namespace cvc5 { namespace theory { namespace fp { @@ -812,4 +812,4 @@ Cardinality CardinalityComputer::computeCardinality(TypeNode type) } // namespace fp } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/fp/theory_fp_type_rules.h b/src/theory/fp/theory_fp_type_rules.h index 632ae660d..0002b2abf 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 CVC5 { +namespace cvc5 { class NodeManager; @@ -229,6 +229,6 @@ class CardinalityComputer } // namespace fp } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/fp/type_enumerator.h b/src/theory/fp/type_enumerator.h index 535ed7c69..73946ce5a 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 CVC5 { +namespace cvc5 { namespace theory { namespace fp { @@ -120,6 +120,6 @@ class RoundingModeEnumerator } // namespace fp } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__FP__TYPE_ENUMERATOR_H */ diff --git a/src/theory/inference_id.cpp b/src/theory/inference_id.cpp index f96a9e244..8b35f5645 100644 --- a/src/theory/inference_id.cpp +++ b/src/theory/inference_id.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC5 { +namespace cvc5 { namespace theory { const char* toString(InferenceId i) @@ -357,4 +357,4 @@ std::ostream& operator<<(std::ostream& out, InferenceId i) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/inference_id.h b/src/theory/inference_id.h index aa34d45ae..89957ded6 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__INFERENCE_H */ diff --git a/src/theory/inference_manager_buffered.cpp b/src/theory/inference_manager_buffered.cpp index 26434f802..023098fe1 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { InferenceManagerBuffered::InferenceManagerBuffered(Theory& t, @@ -187,4 +187,4 @@ void InferenceManagerBuffered::assertInternalFactTheoryInference( } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/inference_manager_buffered.h b/src/theory/inference_manager_buffered.h index 77ed1329a..b5888efd6 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 CVC5 { +namespace cvc5 { namespace theory { /** @@ -174,6 +174,6 @@ class InferenceManagerBuffered : public TheoryInferenceManager }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/interrupted.h b/src/theory/interrupted.h index 75c8f93a5..c928f2faf 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 CVC5::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,14 +31,14 @@ #include "base/exception.h" -namespace CVC5 { +namespace cvc5 { namespace theory { -class Interrupted : public CVC5::Exception +class Interrupted : public cvc5::Exception { }; /* class Interrupted */ } // namespace theory -} // namespace CVC5 +} // 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 0a466fec4..aad3dd28a 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 CVC5 { +namespace cvc5 { namespace theory { LazyTreeProofGenerator::LazyTreeProofGenerator(ProofNodeManager* pnm, @@ -142,4 +142,4 @@ std::ostream& operator<<(std::ostream& os, const LazyTreeProofGenerator& ltpg) } } // namespace theory -} // namespace CVC5
\ 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 3c02380c1..ef235ff1a 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/logic_info.cpp b/src/theory/logic_info.cpp index 841ec097e..6863a2833 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 CVC5::theory; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { LogicInfo::LogicInfo() : d_logicString(""), @@ -725,4 +725,4 @@ std::ostream& operator<<(std::ostream& out, const LogicInfo& logic) { return out << logic.getLogicString(); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/logic_info.h b/src/theory/logic_info.h index fb23f4f2d..c4221040b 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 CVC5 { +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); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__LOGIC_INFO_H */ diff --git a/src/theory/mkrewriter b/src/theory/mkrewriter index 9fa3c64c8..c447350dd 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., ::CVC5::theory::foo)" >&2 - elif ! expr "$2" : '\(::CVC5::theory::*\)' >/dev/null; then - echo "$kf:$lineno: warning: theory class not under ::CVC5::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 b2c6e1ef2..b303c3b4b 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., ::CVC5::theory::foo)" >&2 - elif ! expr "$2" : '\(::CVC5::theory::*\)' >/dev/null; then - echo "$kf:$lineno: warning: theory class not under ::CVC5::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 8ca7a2c48..3a8d7ab0e 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 CVC5 { +namespace cvc5 { namespace theory { ModelManager::ModelManager(TheoryEngine& te, EqEngineManager& eem) @@ -239,4 +239,4 @@ void ModelManager::collectTerms(TheoryId tid, } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/model_manager.h b/src/theory/model_manager.h index 4f4d06a43..db3ea4ecf 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 CVC5 { +namespace cvc5 { class TheoryEngine; @@ -152,6 +152,6 @@ class ModelManager }; } // namespace theory -} // namespace CVC5 +} // 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 3b9c1aad4..61279ee11 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 CVC5 { +namespace cvc5 { namespace theory { ModelManagerDistributed::ModelManagerDistributed(TheoryEngine& te, @@ -114,4 +114,4 @@ bool ModelManagerDistributed::finishBuildModel() const } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/model_manager_distributed.h b/src/theory/model_manager_distributed.h index dd7cf2b78..04c146278 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 CVC5 { +namespace cvc5 { class TheoryEngine; @@ -56,6 +56,6 @@ class ModelManagerDistributed : public ModelManager }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__MODEL_MANAGER_DISTRIBUTED__H */ diff --git a/src/theory/output_channel.cpp b/src/theory/output_channel.cpp index 0fd475563..8f8898ce3 100644 --- a/src/theory/output_channel.cpp +++ b/src/theory/output_channel.cpp @@ -14,7 +14,7 @@ #include "theory/output_channel.h" -namespace CVC5 { +namespace cvc5 { namespace theory { LemmaProperty operator|(LemmaProperty lhs, LemmaProperty rhs) @@ -91,4 +91,4 @@ void OutputChannel::trustedLemma(TrustNode lem, LemmaProperty p) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/output_channel.h b/src/theory/output_channel.h index 16fc5a483..b86a4d647 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 CVC5 { +namespace cvc5 { namespace theory { /** Properties of lemmas */ @@ -66,7 +66,7 @@ class Theory; /** * Generic "theory output channel" interface. * - * All methods can throw unrecoverable CVC5::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 CVC5 +} // 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 eb977960b..3832508dd 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -110,4 +110,4 @@ Node AlphaEquivalence::reduceQuantifier(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/alpha_equivalence.h b/src/theory/quantifiers/alpha_equivalence.h index 822b674e2..03047c93b 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -101,6 +101,6 @@ class AlphaEquivalence } } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/bv_inverter.cpp b/src/theory/quantifiers/bv_inverter.cpp index c4bd2c083..014e46925 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -442,4 +442,4 @@ Node BvInverter::solveBvLit(Node sv, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/bv_inverter.h b/src/theory/quantifiers/bv_inverter.h index c033b26d7..a187cd36a 100644 --- a/src/theory/quantifiers/bv_inverter.h +++ b/src/theory/quantifiers/bv_inverter.h @@ -24,7 +24,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -128,6 +128,6 @@ class BvInverter } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 459c3f93f..e53e64a94 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/bv_inverter_utils.h b/src/theory/quantifiers/bv_inverter_utils.h index c6400bd60..823855d1b 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/candidate_rewrite_database.cpp b/src/theory/quantifiers/candidate_rewrite_database.cpp index 1319e5c38..526469ef2 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -296,4 +296,4 @@ void CandidateRewriteDatabase::setExtendedRewriter(ExtendedRewriter* er) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/candidate_rewrite_database.h b/src/theory/quantifiers/candidate_rewrite_database.h index 396ef0d03..45333bc76 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -128,6 +128,6 @@ class CandidateRewriteDatabase : public ExprMiner } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 0ab85ccf7..7ada36dc2 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -277,4 +277,4 @@ bool CandidateRewriteFilter::notify(Node s, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/candidate_rewrite_filter.h b/src/theory/quantifiers/candidate_rewrite_filter.h index faf675bcb..aa31c7845 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -171,6 +171,6 @@ class CandidateRewriteFilter } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 29881a3a4..2a7a95b65 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -1036,4 +1036,4 @@ Node ArithInstantiator::getModelBasedProjectionValue(CegInstantiator* ci, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/cegqi/ceg_arith_instantiator.h b/src/theory/quantifiers/cegqi/ceg_arith_instantiator.h index e6cfa31c6..a81f5f180 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -209,6 +209,6 @@ class ArithInstantiator : public Instantiator } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 2c163421e..bdd6d26ab 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -759,4 +759,4 @@ void BvInstantiatorPreprocess::collectExtracts( } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/cegqi/ceg_bv_instantiator.h b/src/theory/quantifiers/cegqi/ceg_bv_instantiator.h index 4bfda133e..9914428ef 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -209,6 +209,6 @@ class BvInstantiatorPreprocess : public InstantiatorPreprocess } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 85faea4b1..030258113 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace utils { @@ -342,4 +342,4 @@ Node normalizePvEqual( } // namespace utils } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 576d68d06..ac68dc4d5 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -104,5 +104,5 @@ Node normalizePvEqual( } // namespace utils } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/cegqi/ceg_dt_instantiator.cpp b/src/theory/quantifiers/cegqi/ceg_dt_instantiator.cpp index bb81d2790..672ed990a 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/cegqi/ceg_dt_instantiator.h b/src/theory/quantifiers/cegqi/ceg_dt_instantiator.h index c0386465d..27bf560cb 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -91,6 +91,6 @@ class DtInstantiator : public Instantiator } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 118c505fc..b9d70768b 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -1638,4 +1638,4 @@ bool Instantiator::processEqualTerm(CegInstantiator* ci, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/cegqi/ceg_instantiator.h b/src/theory/quantifiers/cegqi/ceg_instantiator.h index 03161399c..986874266 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -822,6 +822,6 @@ class InstantiatorPreprocess } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/cegqi/inst_strategy_cegqi.cpp b/src/theory/quantifiers/cegqi/inst_strategy_cegqi.cpp index d6a504713..5e3a64325 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -546,4 +546,4 @@ bool InstStrategyCegqi::processNestedQe(Node q, bool isPreregister) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/cegqi/inst_strategy_cegqi.h b/src/theory/quantifiers/cegqi/inst_strategy_cegqi.h index a5b79fb00..6d4ee047f 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -215,6 +215,6 @@ class InstStrategyCegqi : public QuantifiersModule } } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/cegqi/nested_qe.cpp b/src/theory/quantifiers/cegqi/nested_qe.cpp index 9efc0ec31..d5fabbbd9 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -152,4 +152,4 @@ Node NestedQe::doQe(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/cegqi/nested_qe.h b/src/theory/quantifiers/cegqi/nested_qe.h index 29df5d16b..e0cccb9c9 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -81,6 +81,6 @@ class NestedQe } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/cegqi/vts_term_cache.cpp b/src/theory/quantifiers/cegqi/vts_term_cache.cpp index 1a7431038..1974e7c7c 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -296,4 +296,4 @@ bool VtsTermCache::containsVtsInfinity(Node n, bool isFree) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/cegqi/vts_term_cache.h b/src/theory/quantifiers/cegqi/vts_term_cache.h index 53c198213..d56684d43 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 CVC5 { +namespace cvc5 { namespace theory { /** Attribute to mark Skolems as virtual terms */ @@ -140,6 +140,6 @@ class VtsTermCache } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 ffe06a7ad..41d881f2c 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 CVC5; -using namespace CVC5::kind; -using namespace CVC5::theory; -using namespace CVC5::theory::quantifiers; +using namespace cvc5; +using namespace cvc5::kind; +using namespace cvc5::theory; +using namespace cvc5::theory::quantifiers; using namespace std; -namespace CVC5 { +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 +} // namespace cvc5 diff --git a/src/theory/quantifiers/conjecture_generator.h b/src/theory/quantifiers/conjecture_generator.h index cc3314f82..db609a521 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -466,6 +466,6 @@ private: //information about ground equivalence classes } } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/dynamic_rewrite.cpp b/src/theory/quantifiers/dynamic_rewrite.cpp index 6e7601072..fe712e01e 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -183,4 +183,4 @@ Node DynamicRewriter::OpInternalSymTrie::getSymbol(Node n) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/dynamic_rewrite.h b/src/theory/quantifiers/dynamic_rewrite.h index 79b4824b4..9fce59796 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -119,6 +119,6 @@ class DynamicRewriter } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 4c9da3632..a3708bdfe 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -348,4 +348,4 @@ Node CandidateGeneratorSelector::getNextCandidate() } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/candidate_generator.h b/src/theory/quantifiers/ematching/candidate_generator.h index b21a96225..0de57f02f 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -243,6 +243,6 @@ class CandidateGeneratorSelector : public CandidateGeneratorQE } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 14f514b73..5a00d41ca 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -526,4 +526,4 @@ uint64_t HigherOrderTrigger::addHoTypeMatchPredicateLemmas() } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/ho_trigger.h b/src/theory/quantifiers/ematching/ho_trigger.h index 66b374ea8..12c91be63 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -275,6 +275,6 @@ class HigherOrderTrigger : public Trigger } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 2f415779a..9f24faf68 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/im_generator.h b/src/theory/quantifiers/ematching/im_generator.h index b0d937120..222e3c078 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -117,6 +117,6 @@ protected: } // namespace inst } } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/ematching/inst_match_generator.cpp b/src/theory/quantifiers/ematching/inst_match_generator.cpp index 79b6927f7..94e356418 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -673,4 +673,4 @@ InstMatchGenerator* InstMatchGenerator::getInstMatchGenerator(Trigger* tparent, } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/inst_match_generator.h b/src/theory/quantifiers/ematching/inst_match_generator.h index 32d6e38f1..7b440035f 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -325,6 +325,6 @@ class InstMatchGenerator : public IMGenerator { } // namespace inst } } -} // namespace CVC5 +} // 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 6ac910e2e..6677a162f 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -315,4 +315,4 @@ void InstMatchGeneratorMulti::processNewInstantiations(InstMatch& m, } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 644a47bee..309aa2640 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -103,6 +103,6 @@ class InstMatchGeneratorMulti : public IMGenerator } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 94b7921ed..8289ea841 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // 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 00a372c8f..4d4339bac 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -85,6 +85,6 @@ class InstMatchGeneratorMultiLinear : public InstMatchGenerator } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 7d7b3e1c0..b6af066f8 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -198,4 +198,4 @@ int InstMatchGeneratorSimple::getActiveScore() } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 8361628da..ccc650044 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -100,6 +100,6 @@ class InstMatchGeneratorSimple : public IMGenerator } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/ematching/inst_strategy.cpp b/src/theory/quantifiers/ematching/inst_strategy.cpp index a56e7efeb..ad269ac31 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -44,4 +44,4 @@ options::UserPatMode InstStrategy::getInstUserPatMode() const } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/inst_strategy.h b/src/theory/quantifiers/ematching/inst_strategy.h index 0537d92ce..1ce62f170 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -85,6 +85,6 @@ class InstStrategy } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 c62a034e4..d298f994d 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 CVC5::kind; -using namespace CVC5::theory::quantifiers::inst; +using namespace cvc5::kind; +using namespace cvc5::theory::quantifiers::inst; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -688,4 +688,4 @@ void InstStrategyAutoGenTriggers::addUserNoPattern( Node q, Node pat ) { } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 bc52d605c..2c765e194 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -112,6 +112,6 @@ class InstStrategyAutoGenTriggers : public InstStrategy }; /* class InstStrategyAutoGenTriggers */ } } // namespace theory -} // namespace CVC5 +} // 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 4b0d619bc..12ad77ef2 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 CVC5::kind; -using namespace CVC5::theory::quantifiers::inst; +using namespace cvc5::kind; +using namespace cvc5::theory::quantifiers::inst; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -175,4 +175,4 @@ void InstStrategyUserPatterns::addUserPattern(Node q, Node pat) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 1bb50af7b..ed247b89a 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -64,6 +64,6 @@ class InstStrategyUserPatterns : public InstStrategy } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/ematching/instantiation_engine.cpp b/src/theory/quantifiers/ematching/instantiation_engine.cpp index 94054b8f9..86abb4986 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 CVC5::kind; -using namespace CVC5::context; -using namespace CVC5::theory::quantifiers::inst; +using namespace cvc5::kind; +using namespace cvc5::context; +using namespace cvc5::theory::quantifiers::inst; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -272,4 +272,4 @@ bool InstantiationEngine::shouldProcess(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/instantiation_engine.h b/src/theory/quantifiers/ematching/instantiation_engine.h index 8dface27e..bd7388afb 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -75,6 +75,6 @@ class InstantiationEngine : public QuantifiersModule { } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 467ed46be..fb5bd49a3 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -729,4 +729,4 @@ void PatternTermSelector::getTriggerVariables(Node n, } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/pattern_term_selector.h b/src/theory/quantifiers/ematching/pattern_term_selector.h index 6f26f2cec..5ac6c1da3 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -192,6 +192,6 @@ class PatternTermSelector } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/ematching/trigger.cpp b/src/theory/quantifiers/ematching/trigger.cpp index 234940b54..dd0af2e18 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/trigger.h b/src/theory/quantifiers/ematching/trigger.h index c6d3b3cd5..e2ad00561 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 CVC5 { +namespace cvc5 { namespace theory { class QuantifiersEngine; @@ -219,6 +219,6 @@ class Trigger { } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 327d2bba1..fa8d2ff52 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -185,4 +185,4 @@ bool TriggerDatabase::mkTriggerTerms(Node q, } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/trigger_database.h b/src/theory/quantifiers/ematching/trigger_database.h index 2c28c77bc..9cebb6173 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -105,6 +105,6 @@ class TriggerDatabase } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 1f3ca0577..984e825f0 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/trigger_term_info.h b/src/theory/quantifiers/ematching/trigger_term_info.h index 603a1ab77..c70257e08 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -124,6 +124,6 @@ class TriggerTermInfo } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/ematching/trigger_trie.cpp b/src/theory/quantifiers/ematching/trigger_trie.cpp index c8a13d447..7ca925b53 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/trigger_trie.h b/src/theory/quantifiers/ematching/trigger_trie.h index 355ad6c31..fe16e3c0f 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -58,6 +58,6 @@ class TriggerTrie } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 e2dd3f37d..63a9cceae 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/ematching/var_match_generator.h b/src/theory/quantifiers/ematching/var_match_generator.h index 6ee179e91..87c4d1e32 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace inst { @@ -53,6 +53,6 @@ class VarMatchGeneratorTermSubs : public InstMatchGenerator } // namespace inst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/equality_query.cpp b/src/theory/quantifiers/equality_query.cpp index 7846a60bd..77b402843 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -187,4 +187,4 @@ int32_t EqualityQuery::getRepScore(Node n, Node q, size_t index, TypeNode v_tn) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/equality_query.h b/src/theory/quantifiers/equality_query.h index d863c830b..988291ed5 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -90,6 +90,6 @@ class EqualityQuery : public QuantifiersUtil } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 20f3afe63..b21252358 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -104,4 +104,4 @@ Result ExprMiner::doCheck(Node query) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/expr_miner.h b/src/theory/quantifiers/expr_miner.h index 7046dad83..37d0de6f8 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -90,6 +90,6 @@ class ExprMiner } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 867e6748a..b84968adf 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -165,4 +165,4 @@ bool ExpressionMinerManager::addTerm(Node sol, std::ostream& out) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/expr_miner_manager.h b/src/theory/quantifiers/expr_miner_manager.h index 6e775f586..d33c9902c 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 CVC5 { +namespace cvc5 { namespace theory { class QuantifiersEngine; @@ -118,6 +118,6 @@ class ExpressionMinerManager } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 01d573607..092041b15 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 CVC5::kind; +using namespace cvc5::kind; using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -1726,4 +1726,4 @@ void ExtendedRewriter::debugExtendedRewrite(Node n, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/extended_rewrite.h b/src/theory/quantifiers/extended_rewrite.h index f04f9eaae..0d6ece71e 100644 --- a/src/theory/quantifiers/extended_rewrite.h +++ b/src/theory/quantifiers/extended_rewrite.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -250,6 +250,6 @@ class ExtendedRewriter } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 bbd6443fa..eb1e4e96a 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -363,4 +363,4 @@ unsigned FirstOrderModel::getModelBasisArg(Node n) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/first_order_model.h b/src/theory/quantifiers/first_order_model.h index 7a578a33a..ec3b6dd7a 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 CVC5 { +namespace cvc5 { namespace theory { class QuantifiersEngine; @@ -196,6 +196,6 @@ class FirstOrderModel : public TheoryModel } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 6044de049..efa3dd160 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 CVC5; +using namespace cvc5; using namespace std; -using namespace CVC5::theory; -using namespace CVC5::theory::quantifiers; -using namespace CVC5::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 f2abf743a..fc6fac92a 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 CVC5 { +namespace cvc5 { namespace theory { class RepSetIterator; @@ -238,6 +238,6 @@ private: } } -} // namespace CVC5 +} // 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 7c9aacd76..515d9fe58 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // 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 86665aef4..d858e24f6 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace fmcheck { @@ -54,6 +54,6 @@ class FirstOrderModelFmc : public FirstOrderModel } // namespace fmcheck } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 3a7209f00..7dbc10f57 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/fmf/full_model_check.h b/src/theory/quantifiers/fmf/full_model_check.h index 19ecc8ddc..586bde226 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { namespace fmcheck { @@ -187,6 +187,6 @@ protected: } // namespace fmcheck } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 17935f6b4..27eed53f2 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 CVC5; -using namespace CVC5::kind; -using namespace CVC5::context; -using namespace CVC5::theory; -using namespace CVC5::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 2b102c0a8..4a95a8a73 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -73,6 +73,6 @@ class QModelBuilder : public TheoryEngineModelBuilder } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 9943744f7..1c46e425d 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -343,4 +343,4 @@ void ModelEngine::debugPrint( const char* c ){ } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/fmf/model_engine.h b/src/theory/quantifiers/fmf/model_engine.h index 078894de6..2547f2831 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -71,6 +71,6 @@ private: } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 326de79fa..9a3d465d5 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -252,4 +252,4 @@ bool FunDefEvaluator::hasDefinitions() const { return !d_funDefMap.empty(); } } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/fun_def_evaluator.h b/src/theory/quantifiers/fun_def_evaluator.h index be4070840..fcc30948d 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -70,6 +70,6 @@ class FunDefEvaluator } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/index_trie.cpp b/src/theory/quantifiers/index_trie.cpp index 444882729..8c00efb0e 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -114,4 +114,4 @@ IndexTrieNode* IndexTrie::addRec(IndexTrieNode* n, } } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/index_trie.h b/src/theory/quantifiers/index_trie.h index 4ac754252..2c968e107 100644 --- a/src/theory/quantifiers/index_trie.h +++ b/src/theory/quantifiers/index_trie.h @@ -21,7 +21,7 @@ #include "base/check.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -106,5 +106,5 @@ class IndexTrie } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 3db8db74e..c2f65ea93 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -102,4 +102,4 @@ bool InstMatch::set(QuantifiersState& qs, size_t i, TNode n) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/inst_match.h b/src/theory/quantifiers/inst_match.h index 9ff507917..e5e8f97cd 100644 --- a/src/theory/quantifiers/inst_match.h +++ b/src/theory/quantifiers/inst_match.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -89,6 +89,6 @@ inline std::ostream& operator<<(std::ostream& out, const InstMatch& m) { } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 879eb8479..347fe45af 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 CVC5::context; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -369,4 +369,4 @@ bool InstMatchTrieOrdered::existsInstMatch(quantifiers::QuantifiersState& qs, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/inst_match_trie.h b/src/theory/quantifiers/inst_match_trie.h index da8858e8a..ca878c888 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -224,6 +224,6 @@ class InstMatchTrieOrdered } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 c2ee94d1e..3e560acaa 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -220,4 +220,4 @@ bool InstStrategyEnum::process(Node quantifier, bool fullEffort, bool isRd) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/inst_strategy_enumerative.h b/src/theory/quantifiers/inst_strategy_enumerative.h index 05e5f7352..7b5cb8e0e 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -116,6 +116,6 @@ class InstStrategyEnum : public QuantifiersModule } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/instantiate.cpp b/src/theory/quantifiers/instantiate.cpp index 4f878c79b..62376bff6 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -760,4 +760,4 @@ Instantiate::Statistics::~Statistics() } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/instantiate.h b/src/theory/quantifiers/instantiate.h index 3fb194589..b3c056506 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 CVC5 { +namespace cvc5 { class LazyCDProof; @@ -361,6 +361,6 @@ class Instantiate : public QuantifiersUtil } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 1c3a0bcac..78bfdf9a4 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/instantiation_list.h b/src/theory/quantifiers/instantiation_list.h index da8d5c3b5..86dfa0081 100644 --- a/src/theory/quantifiers/instantiation_list.h +++ b/src/theory/quantifiers/instantiation_list.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__QUANTIFIERS__INSTANTIATION_LIST_H */ diff --git a/src/theory/quantifiers/kinds b/src/theory/quantifiers/kinds index 6a32969e3..4561226e1 100644 --- a/src/theory/quantifiers/kinds +++ b/src/theory/quantifiers/kinds @@ -4,12 +4,12 @@ # src/theory/builtin/kinds. # -theory THEORY_QUANTIFIERS ::CVC5::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 ::CVC5::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 ::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 +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 1b706d904..06d1798d5 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -156,4 +156,4 @@ void LazyTrieMulti::clear() } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/lazy_trie.h b/src/theory/quantifiers/lazy_trie.h index 2d92b13fd..d4437ae75 100644 --- a/src/theory/quantifiers/lazy_trie.h +++ b/src/theory/quantifiers/lazy_trie.h @@ -17,7 +17,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -168,6 +168,6 @@ class LazyTrieMulti } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 572c631e1..4be66a703 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -123,4 +123,4 @@ Node QuantifiersProofRuleChecker::checkInternal( } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/proof_checker.h b/src/theory/quantifiers/proof_checker.h index da78daf90..39e933149 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -44,6 +44,6 @@ class QuantifiersProofRuleChecker : public ProofRuleChecker } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 6d7e2e9cd..609bc66a4 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -127,4 +127,4 @@ bool QuantifiersBoundInference::getBoundElements( } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quant_bound_inference.h b/src/theory/quantifiers/quant_bound_inference.h index 62ac0ea58..7c15d5146 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 CVC5 { +namespace cvc5 { namespace theory { class RepSetIterator; @@ -122,6 +122,6 @@ class QuantifiersBoundInference } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 5fa617670..94b2f001e 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 CVC5::kind; +using namespace cvc5::kind; using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -2351,4 +2351,4 @@ bool QuantConflictFind::isPropagatingInstance(Node n) const } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quant_conflict_find.h b/src/theory/quantifiers/quant_conflict_find.h index ef605a48a..93e6075a8 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -313,6 +313,6 @@ std::ostream& operator<<(std::ostream& os, const QuantConflictFind::Effort& e); } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/quant_module.cpp b/src/theory/quantifiers/quant_module.cpp index 811dc8642..2c74b3557 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { QuantifiersModule::QuantifiersModule( @@ -75,4 +75,4 @@ quantifiers::QuantifiersRegistry& QuantifiersModule::getQuantifiersRegistry() } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quant_module.h b/src/theory/quantifiers/quant_module.h index 53fb55aa0..e6d5eee76 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { class TermDb; @@ -174,6 +174,6 @@ class QuantifiersModule }; /* class QuantifiersModule */ } // namespace theory -} // namespace CVC5 +} // 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 2ce79d285..f6a96cda2 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -62,4 +62,4 @@ size_t QuantRelevance::getNumQuantifiersForSymbol(Node s) const } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quant_relevance.h b/src/theory/quantifiers/quant_relevance.h index 73b62489e..e6a178c73 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -63,6 +63,6 @@ class QuantRelevance : public QuantifiersUtil } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 2a70e5d4e..383091e33 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -86,4 +86,4 @@ bool QRepBoundExt::getVariableOrder(Node owner, std::vector<unsigned>& varOrder) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quant_rep_bound_ext.h b/src/theory/quantifiers/quant_rep_bound_ext.h index 7e8f5d386..6fe0faefa 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -67,6 +67,6 @@ class QRepBoundExt : public RepBoundExt } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 85fb291f0..00a8ff08f 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -207,4 +207,4 @@ void QuantDSplit::check(Theory::Effort e, QEffort quant_e) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quant_split.h b/src/theory/quantifiers/quant_split.h index eb85a2c28..ee961cbbc 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 CVC5 { +namespace cvc5 { namespace theory { class QuantifiersEngine; @@ -73,6 +73,6 @@ class QuantDSplit : public QuantifiersModule { } } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/quant_util.cpp b/src/theory/quantifiers/quant_util.cpp index 841778a89..cbf29065c 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { QuantPhaseReq::QuantPhaseReq( Node n, bool computeEq ){ @@ -131,4 +131,4 @@ void QuantPhaseReq::getEntailPolarity( Node n, int child, bool hasPol, bool pol, } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quant_util.h b/src/theory/quantifiers/quant_util.h index f41f394e8..7cd89c7d8 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 CVC5 { +namespace cvc5 { namespace theory { /** Quantifiers utility @@ -78,6 +78,6 @@ public: }; } -} // namespace CVC5 +} // 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 8c068e06c..d53ed74be 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -378,4 +378,4 @@ void QuantAttributes::setInstantiationLevelAttr(Node n, uint64_t level) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quantifiers_attributes.h b/src/theory/quantifiers/quantifiers_attributes.h index 4f7f1e22c..2fb294abe 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 CVC5 { +namespace cvc5 { namespace theory { /** Attribute true for function definition quantifiers */ @@ -244,6 +244,6 @@ class QuantAttributes } } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/quantifiers_inference_manager.cpp b/src/theory/quantifiers/quantifiers_inference_manager.cpp index 687e17e4a..ff3087b63 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -53,4 +53,4 @@ void QuantifiersInferenceManager::doPending() } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quantifiers_inference_manager.h b/src/theory/quantifiers/quantifiers_inference_manager.h index afe8dd40a..b468e0478 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -59,6 +59,6 @@ class QuantifiersInferenceManager : public InferenceManagerBuffered } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 e39e38ea7..049e72edf 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -122,4 +122,4 @@ void QuantifiersModules::initialize(QuantifiersState& qs, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quantifiers_modules.h b/src/theory/quantifiers/quantifiers_modules.h index 71928502d..c52da79a7 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 CVC5 { +namespace cvc5 { namespace theory { class QuantifiersEngine; @@ -45,7 +45,7 @@ namespace quantifiers { */ class QuantifiersModules { - friend class ::CVC5::theory::QuantifiersEngine; + friend class ::cvc5::theory::QuantifiersEngine; public: QuantifiersModules(); @@ -94,6 +94,6 @@ class QuantifiersModules } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 3cd59c834..58edc72bd 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quantifiers_registry.h b/src/theory/quantifiers/quantifiers_registry.h index a3dffb063..383934c15 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 CVC5 { +namespace cvc5 { namespace theory { class QuantifiersModule; @@ -129,6 +129,6 @@ class QuantifiersRegistry : public QuantifiersUtil } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 d31b22f88..2c91df7a7 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -2030,4 +2030,4 @@ TrustNode QuantifiersRewriter::preprocess(Node n, bool isInst) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quantifiers_rewriter.h b/src/theory/quantifiers/quantifiers_rewriter.h index 7bbe32da7..5ea8352d0 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -303,6 +303,6 @@ public: } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 5e3bb3ba3..927369442 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -160,4 +160,4 @@ QuantifiersStatistics& QuantifiersState::getStats() { return d_statistics; } } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quantifiers_state.h b/src/theory/quantifiers/quantifiers_state.h index 0f1c13659..623d52289 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -86,6 +86,6 @@ class QuantifiersState : public TheoryState } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 e922c7080..720ae2ee0 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -61,4 +61,4 @@ QuantifiersStatistics::~QuantifiersStatistics() } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/quantifiers_statistics.h b/src/theory/quantifiers/quantifiers_statistics.h index 9f2678796..9eccf3ce6 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -47,6 +47,6 @@ class QuantifiersStatistics } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 0860549ba..6abb8bbec 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -425,4 +425,4 @@ void QueryGenerator::findQueries( } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/query_generator.h b/src/theory/quantifiers/query_generator.h index a847a184b..cf10b42da 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -116,6 +116,6 @@ class QueryGenerator : public ExprMiner } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__QUANTIFIERS___H */ diff --git a/src/theory/quantifiers/relevant_domain.cpp b/src/theory/quantifiers/relevant_domain.cpp index 3e25f4073..6fb27bec4 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/relevant_domain.h b/src/theory/quantifiers/relevant_domain.h index 56b728b34..807e4c4a2 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -170,6 +170,6 @@ class RelevantDomain : public QuantifiersUtil } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 1dbc24280..2fe173763 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 CVC5; -using namespace CVC5::kind; +using namespace cvc5; +using namespace cvc5::kind; using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -615,4 +615,4 @@ void SingleInvocationPartition::debugPrint(const char* c) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/single_inv_partition.h b/src/theory/quantifiers/single_inv_partition.h index 6feff4169..604c711ad 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -292,6 +292,6 @@ class SingleInvocationPartition } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 3767fac61..2a19824ac 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -399,4 +399,4 @@ bool Skolemize::isProofEnabled() const { return d_epg != nullptr; } } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/skolemize.h b/src/theory/quantifiers/skolemize.h index d0a889ace..4c4d770f3 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 CVC5 { +namespace cvc5 { class DTypeConstructor; @@ -157,6 +157,6 @@ class Skolemize } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 3b00f5081..d7556be40 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -103,4 +103,4 @@ bool SolutionFilterStrength::addTerm(Node n, std::ostream& out) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/solution_filter.h b/src/theory/quantifiers/solution_filter.h index cea5eb74e..bf3d9bddc 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -70,6 +70,6 @@ class SolutionFilterStrength : public ExprMiner } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 0acd7e718..5e9f2d591 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -548,4 +548,4 @@ bool CegSingleInv::solveTrivial(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 e2f399ffd..ca83bf973 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -178,6 +178,6 @@ class CegSingleInv } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/cegis.cpp b/src/theory/quantifiers/sygus/cegis.cpp index d980db887..52adc1972 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -706,4 +706,4 @@ bool Cegis::sampleAddRefinementLemma(const std::vector<Node>& candidates, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/cegis.h b/src/theory/quantifiers/sygus/cegis.h index a12133d23..f728d3d7e 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -227,6 +227,6 @@ class Cegis : public SygusModule } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 26ad62c90..6e47c2d89 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -861,4 +861,4 @@ Node CegisCoreConnective::constructSolutionFromPool(Component& ccheck, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/cegis_core_connective.h b/src/theory/quantifiers/sygus/cegis_core_connective.h index 59bf53317..2abce835a 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 CVC5 { +namespace cvc5 { class SmtEngine; @@ -399,6 +399,6 @@ class CegisCoreConnective : public Cegis } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 bcd9fa67a..9a5c6146d 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -686,4 +686,4 @@ void CegisUnifEnumDecisionStrategy::registerEvalPtAtSize(Node e, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/cegis_unif.h b/src/theory/quantifiers/sygus/cegis_unif.h index e00370f2a..a543bfda0 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -333,6 +333,6 @@ class CegisUnif : public Cegis } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/enum_stream_substitution.cpp b/src/theory/quantifiers/sygus/enum_stream_substitution.cpp index 17f2a0c16..2bf8b4611 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -621,4 +621,4 @@ bool EnumStreamConcrete::increment() Node EnumStreamConcrete::getCurrent() { return d_currTerm; } } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/enum_stream_substitution.h b/src/theory/quantifiers/sygus/enum_stream_substitution.h index c7e4720d2..a72481a38 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -299,6 +299,6 @@ class EnumStreamConcrete : public EnumValGenerator } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/example_eval_cache.cpp b/src/theory/quantifiers/sygus/example_eval_cache.cpp index 5056fb96d..aea6cb9ef 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 CVC5; -using namespace CVC5::kind; +using namespace cvc5; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -119,4 +119,4 @@ void ExampleEvalCache::clearEvaluationAll() { d_exOutCache.clear(); } } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/example_eval_cache.h b/src/theory/quantifiers/sygus/example_eval_cache.h index 97ec38ab5..1a70369a5 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -160,6 +160,6 @@ class ExampleEvalCache } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/example_infer.cpp b/src/theory/quantifiers/sygus/example_infer.cpp index 12e4f073e..9dc99cab1 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 CVC5; -using namespace CVC5::kind; +using namespace cvc5; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -275,4 +275,4 @@ bool ExampleInfer::hasExamplesOut(Node f) const } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/example_infer.h b/src/theory/quantifiers/sygus/example_infer.h index 0e5ee25ac..dd2bf8a0a 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -157,6 +157,6 @@ class ExampleInfer } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/example_min_eval.cpp b/src/theory/quantifiers/sygus/example_min_eval.cpp index 4cb9bd345..5b3ccec4f 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -84,4 +84,4 @@ Node EmeEvalTds::eval(TNode n, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/example_min_eval.h b/src/theory/quantifiers/sygus/example_min_eval.h index 9af07caba..2105faf2b 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -118,6 +118,6 @@ class EmeEvalTds : public EmeEval } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/rcons_obligation_info.cpp b/src/theory/quantifiers/sygus/rcons_obligation_info.cpp index 7d4a41f2d..6db446dbb 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -97,4 +97,4 @@ void RConsObligationInfo::printCandSols( } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/rcons_obligation_info.h b/src/theory/quantifiers/sygus/rcons_obligation_info.h index e05422b59..3bded2a90 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -145,6 +145,6 @@ class RConsObligationInfo } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 37b136a1c..97ae4878d 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -69,4 +69,4 @@ Node RConsTypeInfo::builtinToOb(Node builtin) { return d_ob[builtin]; } } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/rcons_type_info.h b/src/theory/quantifiers/sygus/rcons_type_info.h index c2bce5720..974897023 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -97,6 +97,6 @@ class RConsTypeInfo } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 71853fc76..8df45320f 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -187,4 +187,4 @@ Node SygusAbduct::mkAbductionConjecture(const std::string& name, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_abduct.h b/src/theory/quantifiers/sygus/sygus_abduct.h index ffcefd38b..634a9a4bd 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -85,6 +85,6 @@ class SygusAbduct } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 c786d2668..82d0c6c62 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -1214,4 +1214,4 @@ bool SygusEnumerator::TermEnumMasterFv::increment() } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_enumerator.h b/src/theory/quantifiers/sygus/sygus_enumerator.h index a0d1c9b62..f1ef115f8 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -506,6 +506,6 @@ class SygusEnumerator : public EnumValGenerator } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 51814b07c..e9f41c916 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 CVC5::kind; +using namespace cvc5::kind; using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -55,4 +55,4 @@ bool EnumValGeneratorBasic::increment() } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_enumerator_basic.h b/src/theory/quantifiers/sygus/sygus_enumerator_basic.h index c57d6f814..1f489eafc 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -65,6 +65,6 @@ class EnumValGeneratorBasic : public EnumValGenerator } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 3e87ccfc7..5dbd7655f 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -333,4 +333,4 @@ Node SygusEvalUnfold::unfold(Node en) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_eval_unfold.h b/src/theory/quantifiers/sygus/sygus_eval_unfold.h index d5e47edbc..628f01c40 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -154,6 +154,6 @@ class SygusEvalUnfold } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 26fab8535..95acce626 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 CVC5::kind; +using namespace cvc5::kind; using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -357,4 +357,4 @@ void SygusExplain::getExplanationFor(Node n, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_explain.h b/src/theory/quantifiers/sygus/sygus_explain.h index 1b1db568f..477857794 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -241,6 +241,6 @@ class SygusExplain } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 554f587c7..1c96b1346 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -1622,4 +1622,4 @@ bool CegGrammarConstructor::SygusDatatypeGenerator::shouldInclude(Node op) const } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_grammar_cons.h b/src/theory/quantifiers/sygus/sygus_grammar_cons.h index a39540452..56f469fef 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 CVC5 { +namespace cvc5 { namespace theory { /** @@ -266,6 +266,6 @@ public: } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/sygus_grammar_norm.cpp b/src/theory/quantifiers/sygus/sygus_grammar_norm.cpp index fa67e17c4..8a2ad109d 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -536,4 +536,4 @@ TypeNode SygusGrammarNorm::normalizeSygusType(TypeNode tn, Node sygus_vars) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_grammar_norm.h b/src/theory/quantifiers/sygus/sygus_grammar_norm.h index 8c057d2c5..eda34a251 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -426,6 +426,6 @@ class SygusGrammarNorm } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/sygus_grammar_red.cpp b/src/theory/quantifiers/sygus/sygus_grammar_red.cpp index 8e6f4fbae..a8ada94ed 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -176,4 +176,4 @@ void SygusRedundantCons::getGenericList(TermDbSygus* tds, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_grammar_red.h b/src/theory/quantifiers/sygus/sygus_grammar_red.h index 25256a68c..2144102e0 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -118,6 +118,6 @@ class SygusRedundantCons } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 1c856ffa2..fe286d15c 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -358,4 +358,4 @@ bool SygusInterpol::solveInterpolation(const std::string& name, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_interpol.h b/src/theory/quantifiers/sygus/sygus_interpol.h index 34517b6e6..c63d096b8 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { /** @@ -213,6 +213,6 @@ class SygusInterpol } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 7e6c5ab6c..22ef38b0d 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 CVC5::kind; +using namespace cvc5::kind; using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -261,4 +261,4 @@ bool NegContainsSygusInvarianceTest::invariant(TermDbSygus* tds, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_invariance.h b/src/theory/quantifiers/sygus/sygus_invariance.h index 88e45df45..df2e189e3 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -298,6 +298,6 @@ class NegContainsSygusInvarianceTest : public SygusInvarianceTest } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 8dac30c7e..3f2bea9cb 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -27,4 +27,4 @@ SygusModule::SygusModule(QuantifiersInferenceManager& qim, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_module.h b/src/theory/quantifiers/sygus/sygus_module.h index 32f404005..90460eeed 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -157,6 +157,6 @@ class SygusModule } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 25068eb7d..b54b1c940 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 CVC5; -using namespace CVC5::kind; +using namespace cvc5; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -258,4 +258,4 @@ bool SygusPbe::constructCandidates(const std::vector<Node>& enums, } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_pbe.h b/src/theory/quantifiers/sygus/sygus_pbe.h index c63dcf697..a56a22838 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -168,6 +168,6 @@ class SygusPbe : public SygusModule } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/sygus_process_conj.cpp b/src/theory/quantifiers/sygus/sygus_process_conj.cpp index dfb0a0f7c..822d19f29 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 CVC5::kind; +using namespace cvc5::kind; using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -804,4 +804,4 @@ void SynthConjectureProcess::getComponentVector(Kind k, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_process_conj.h b/src/theory/quantifiers/sygus/sygus_process_conj.h index 0b07db89b..6f6e25d0c 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -358,6 +358,6 @@ class SynthConjectureProcess } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/sygus_qe_preproc.cpp b/src/theory/quantifiers/sygus/sygus_qe_preproc.cpp index 72ce3f1ab..1b3a52db8 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -144,4 +144,4 @@ Node SygusQePreproc::preprocess(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_qe_preproc.h b/src/theory/quantifiers/sygus/sygus_qe_preproc.h index 49f81df02..26bbf2f92 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -45,6 +45,6 @@ class SygusQePreproc } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 723d924f8..55e8c922d 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -488,4 +488,4 @@ void SygusReconstruct::printPool( } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_reconstruct.h b/src/theory/quantifiers/sygus/sygus_reconstruct.h index 0512fe643..1f9037a26 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -307,6 +307,6 @@ class SygusReconstruct : public expr::NotifyMatch } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 2d7dfc4bc..179798222 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -621,4 +621,4 @@ bool SygusRepairConst::getFitToLogicExcludeVar(LogicInfo& logic, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_repair_const.h b/src/theory/quantifiers/sygus/sygus_repair_const.h index 1e7eeb9fc..b79fa4177 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 CVC5 { +namespace cvc5 { class LogicInfo; @@ -209,6 +209,6 @@ class SygusRepairConst } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 da08ec1b5..11dec3e61 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -60,4 +60,4 @@ SygusStatistics::~SygusStatistics() } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_stats.h b/src/theory/quantifiers/sygus/sygus_stats.h index d89fa0eca..7a8ae8ce9 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -53,6 +53,6 @@ class SygusStatistics } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/sygus_unif.cpp b/src/theory/quantifiers/sygus/sygus_unif.cpp index 8eb13fef8..2d72b4fab 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -136,4 +136,4 @@ void SygusUnif::print_val(const char* c, std::vector<Node>& vals, bool pol) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_unif.h b/src/theory/quantifiers/sygus/sygus_unif.h index 153c4603b..1ed81194a 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -193,6 +193,6 @@ class SygusUnif } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 be24cb9e7..9dfac1d68 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -1677,4 +1677,4 @@ Node SygusUnifIo::constructBestConditional(Node ce, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_unif_io.h b/src/theory/quantifiers/sygus/sygus_unif_io.h index 5d4f7fb7d..825e5741d 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -468,6 +468,6 @@ class SygusUnifIo : public SygusUnif } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 436678aa9..c3cff70d9 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -1207,4 +1207,4 @@ Node SygusUnifRl::DecisionTreeInfo::PointSeparator::computeCond(Node cond, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_unif_rl.h b/src/theory/quantifiers/sygus/sygus_unif_rl.h index 82f2a80d2..51c49cbef 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -443,6 +443,6 @@ class SygusUnifRl : public SygusUnif } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 5551be630..24bcb1eab 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -1050,4 +1050,4 @@ void SygusUnifStrategy::indent(const char* c, int ind) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_unif_strat.h b/src/theory/quantifiers/sygus/sygus_unif_strat.h index c9d6e5d96..2508fdc9b 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -428,6 +428,6 @@ class SygusUnifStrategy } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 ec5edd640..6c14aaa80 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -179,4 +179,4 @@ TypeNode SygusUtils::getSygusTypeForSynthFun(Node f) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/sygus_utils.h b/src/theory/quantifiers/sygus/sygus_utils.h index 2646dd1c8..0ec497789 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -110,6 +110,6 @@ class SygusUtils } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 0bfa73048..f7566e7a2 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 CVC5::kind; +using namespace cvc5::kind; using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -1353,4 +1353,4 @@ ExampleEvalCache* SynthConjecture::getExampleEvalCache(Node e) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/synth_conjecture.h b/src/theory/quantifiers/sygus/synth_conjecture.h index e39f65d80..7fd1ae4b3 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -426,6 +426,6 @@ class SynthConjecture } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/synth_engine.cpp b/src/theory/quantifiers/sygus/synth_engine.cpp index 4f1a0bbbb..3d5406f27 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -290,4 +290,4 @@ void SynthEngine::preregisterAssertion(Node n) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/synth_engine.h b/src/theory/quantifiers/sygus/synth_engine.h index 30f9c181e..a5fde8476 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -115,6 +115,6 @@ class SynthEngine : public QuantifiersModule } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/template_infer.cpp b/src/theory/quantifiers/sygus/template_infer.cpp index 84fcafd05..875b25370 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -203,4 +203,4 @@ Node SygusTemplateInfer::getTemplateArg(Node prog) const } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/template_infer.h b/src/theory/quantifiers/sygus/template_infer.h index be35025bd..1ab97b651 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -71,6 +71,6 @@ class SygusTemplateInfer } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/term_database_sygus.cpp b/src/theory/quantifiers/sygus/term_database_sygus.cpp index f50e222ff..34a81467a 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -1091,4 +1091,4 @@ bool TermDbSygus::isEvaluationPoint(Node n) const } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/term_database_sygus.h b/src/theory/quantifiers/sygus/term_database_sygus.h index 0bd0c636a..fb7e38ff8 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -467,6 +467,6 @@ class TermDbSygus { } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 0b5946176..7ee2f2ec6 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -585,4 +585,4 @@ Node TransitionInference::constructFormulaTrace(DetTrace& dt) const } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/transition_inference.h b/src/theory/quantifiers/sygus/transition_inference.h index aed003357..8ddc1a320 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -332,6 +332,6 @@ class TransitionInference } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus/type_info.cpp b/src/theory/quantifiers/sygus/type_info.cpp index 19dff9936..fdc8ca6a3 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -488,4 +488,4 @@ bool SygusTypeInfo::isSubclassVarTrivial() const } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus/type_info.h b/src/theory/quantifiers/sygus/type_info.h index cc78fc526..79413a03c 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -253,6 +253,6 @@ class SygusTypeInfo } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 064543af8..a2c7b264d 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -49,4 +49,4 @@ void TypeNodeIdTrie::assignIds(std::map<Node, unsigned>& assign, } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 a60afda23..6311cbabe 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -48,6 +48,6 @@ class TypeNodeIdTrie } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 0b1d91684..81dc5cecb 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -553,4 +553,4 @@ void SygusInst::addCeLemma(Node q) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus_inst.h b/src/theory/quantifiers/sygus_inst.h index 08fc5ccb3..35b66437b 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 CVC5 { +namespace cvc5 { namespace theory { class QuantifiersEngine; @@ -147,6 +147,6 @@ class SygusInst : public QuantifiersModule } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/quantifiers/sygus_sampler.cpp b/src/theory/quantifiers/sygus_sampler.cpp index 2b89c0c7c..5c7797a1a 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -845,4 +845,4 @@ void SygusSampler::checkEquivalent(Node bv, Node bvr) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/sygus_sampler.h b/src/theory/quantifiers/sygus_sampler.h index 65843dc63..7350f4845 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -320,6 +320,6 @@ class SygusSampler : public LazyTrieEvaluator } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 d6d7933cb..64c2fda76 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -1232,4 +1232,4 @@ Node TermDb::getHoTypeMatchPredicate(TypeNode tn) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/term_database.h b/src/theory/quantifiers/term_database.h index d0812d1d1..2077b3d2d 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -422,6 +422,6 @@ class TermDb : public QuantifiersUtil { } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 2945750c1..a13a19a77 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -75,4 +75,4 @@ bool TermEnumeration::getDomain(TypeNode tn, std::vector<Node>& dom) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/term_enumeration.h b/src/theory/quantifiers/term_enumeration.h index fa7eaf63e..bd545ff50 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -71,6 +71,6 @@ class TermEnumeration } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 cf33f0a41..8317271f9 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -134,4 +134,4 @@ bool TermRegistry::useFmcModel() const { return d_useFmcModel; } } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/term_registry.h b/src/theory/quantifiers/term_registry.h index e4e4a7e9f..79070fae8 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -99,6 +99,6 @@ class TermRegistry } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 546f6aa6c..e4e63787e 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/term_tuple_enumerator.h b/src/theory/quantifiers/term_tuple_enumerator.h index b15ab2212..4d6eb52f8 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -94,5 +94,5 @@ TermTupleEnumeratorInterface* mkTermTupleEnumeratorRd( } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 41e06a708..8b1c1aa30 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -601,4 +601,4 @@ bool TermUtil::hasOffsetArg(Kind ik, int arg, int& offset, Kind& ok) } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/term_util.h b/src/theory/quantifiers/term_util.h index 1ac6ca495..d8a881e2e 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 CVC5 { +namespace cvc5 { namespace theory { // attribute for "contains instantiation constants from" @@ -206,6 +206,6 @@ public: } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 d89abf076..c3c3fe7b6 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers/theory_quantifiers.h b/src/theory/quantifiers/theory_quantifiers.h index 6af0e8648..21c30390c 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -98,6 +98,6 @@ class TheoryQuantifiers : public Theory { } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 e990f5320..53c077930 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 CVC5 { +namespace cvc5 { namespace theory { namespace quantifiers { @@ -131,6 +131,6 @@ struct QuantifierInstPatternListTypeRule { } // namespace quantifiers } // namespace theory -} // namespace CVC5 +} // 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 12942c1c4..0bcf1d19c 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { QuantifiersEngine::QuantifiersEngine( @@ -653,4 +653,4 @@ bool QuantifiersEngine::getSynthSolutions( } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/quantifiers_engine.h b/src/theory/quantifiers_engine.h index 4d4599f68..101dd03e7 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 CVC5 { +namespace cvc5 { class TheoryEngine; @@ -52,7 +52,7 @@ class TermRegistry; // TODO: organize this more/review this, github issue #1163 class QuantifiersEngine { - friend class ::CVC5::TheoryEngine; + friend class ::cvc5::TheoryEngine; typedef context::CDHashMap< Node, bool, NodeHashFunction > BoolMap; typedef context::CDHashSet<Node, NodeHashFunction> NodeSet; @@ -209,6 +209,6 @@ public: };/* class QuantifiersEngine */ } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__QUANTIFIERS_ENGINE_H */ diff --git a/src/theory/relevance_manager.cpp b/src/theory/relevance_manager.cpp index 5fda45954..b00d9af68 100644 --- a/src/theory/relevance_manager.cpp +++ b/src/theory/relevance_manager.cpp @@ -16,9 +16,9 @@ #include <sstream> -using namespace CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { RelevanceManager::RelevanceManager(context::UserContext* userContext, @@ -314,4 +314,4 @@ bool RelevanceManager::isRelevant(Node lit) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/relevance_manager.h b/src/theory/relevance_manager.h index eea1d2c61..0a00e8c6b 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 CVC5 { +namespace cvc5 { namespace theory { /** @@ -149,6 +149,6 @@ class RelevanceManager }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__RELEVANCE_MANAGER__H */ diff --git a/src/theory/rep_set.cpp b/src/theory/rep_set.cpp index 6492ac9f0..8ca7ba283 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { void RepSet::clear(){ @@ -462,4 +462,4 @@ void RepSetIterator::debugPrintSmall( const char* c ){ } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/rep_set.h b/src/theory/rep_set.h index 4c7b04045..89128f0fd 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 CVC5 { +namespace cvc5 { namespace theory { class QuantifiersEngine; @@ -325,6 +325,6 @@ class RepBoundExt }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__REP_SET_H */ diff --git a/src/theory/rewriter.cpp b/src/theory/rewriter.cpp index 9e248c8d6..1d9620dab 100644 --- a/src/theory/rewriter.cpp +++ b/src/theory/rewriter.cpp @@ -29,7 +29,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { /** Attribute true for nodes that have been rewritten with proofs enabled */ @@ -512,4 +512,4 @@ void Rewriter::clearCaches() { } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/rewriter.h b/src/theory/rewriter.h index c5a8cd45e..94057aa54 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 CVC5 { +namespace cvc5 { class TConvProofGenerator; class ProofNodeManager; @@ -232,4 +232,4 @@ class Rewriter { };/* class Rewriter */ } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/rewriter_attributes.h b/src/theory/rewriter_attributes.h index 83961353e..19116c020 100644 --- a/src/theory/rewriter_attributes.h +++ b/src/theory/rewriter_attributes.h @@ -20,7 +20,7 @@ #include "expr/attribute.h" -namespace CVC5 { +namespace cvc5 { namespace theory { template <bool pre, theory::TheoryId theoryId> @@ -99,4 +99,4 @@ struct RewriteAttibute { };/* struct RewriteAttribute */ } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/rewriter_tables_template.h b/src/theory/rewriter_tables_template.h index bd9b9575e..020ac1af6 100644 --- a/src/theory/rewriter_tables_template.h +++ b/src/theory/rewriter_tables_template.h @@ -26,7 +26,7 @@ ${rewriter_includes} -namespace CVC5 { +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 CVC5::expr::attr::AttributeUniqueId AttributeUniqueId; + typedef cvc5::expr::attr::AttributeUniqueId AttributeUniqueId; std::vector<AttributeUniqueId> preids; ${pre_rewrite_attribute_ids} @@ -95,4 +95,4 @@ void Rewriter::clearCachesInternal() { } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sep/kinds b/src/theory/sep/kinds index 666e3f179..17dfed893 100644 --- a/src/theory/sep/kinds +++ b/src/theory/sep/kinds @@ -4,13 +4,13 @@ # src/theory/builtin/kinds. # -theory THEORY_SEP ::CVC5::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 ::CVC5::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 ::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 +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 73fc565bd..ab9b1b08d 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace sep { @@ -1798,4 +1798,4 @@ Node TheorySep::HeapInfo::getValue( TypeNode tn ) { } // namespace sep } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sep/theory_sep.h b/src/theory/sep/theory_sep.h index 029cbada5..d52a3bca5 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 CVC5 { +namespace cvc5 { namespace theory { class TheoryModel; @@ -351,6 +351,6 @@ class TheorySep : public Theory { } // namespace sep } // namespace theory -} // namespace CVC5 +} // 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 756a82bc1..d7cebd465 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 CVC5 { +namespace cvc5 { namespace theory { namespace sep { @@ -166,4 +166,4 @@ RewriteResponse TheorySepRewriter::postRewrite(TNode node) { } // namespace sep } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sep/theory_sep_rewriter.h b/src/theory/sep/theory_sep_rewriter.h index 97124bd0d..2ee969fc2 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 CVC5 { +namespace cvc5 { namespace theory { namespace sep { @@ -49,6 +49,6 @@ class TheorySepRewriter : public TheoryRewriter } // namespace sep } // namespace theory -} // namespace CVC5 +} // 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 8618ce4d6..a83f036c1 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 CVC5 { +namespace cvc5 { namespace theory { namespace sep { @@ -109,6 +109,6 @@ struct SepNilTypeRule { } // namespace sep } // namespace theory -} // namespace CVC5 +} // 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 84e7786e8..b67df285d 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -1114,4 +1114,4 @@ const std::vector<Node>& CardinalityExtension::getFiniteTypeMembers( } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sets/cardinality_extension.h b/src/theory/sets/cardinality_extension.h index 47fa18d5b..c354f3f3a 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -412,6 +412,6 @@ class CardinalityExtension } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/sets/inference_manager.cpp b/src/theory/sets/inference_manager.cpp index 305059797..2523512cc 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -177,4 +177,4 @@ void InferenceManager::split(Node n, InferenceId id, int reqPol) } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sets/inference_manager.h b/src/theory/sets/inference_manager.h index 8e4614718..90d2ce12a 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -100,6 +100,6 @@ class InferenceManager : public InferenceManagerBuffered } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__SETS__INFERENCE_MANAGER_H */ diff --git a/src/theory/sets/kinds b/src/theory/sets/kinds index 4ef22d68c..564779f6a 100644 --- a/src/theory/sets/kinds +++ b/src/theory/sets/kinds @@ -5,10 +5,10 @@ # theory THEORY_SETS \ - ::CVC5::theory::sets::TheorySets \ + ::cvc5::theory::sets::TheorySets \ "theory/sets/theory_sets.h" typechecker "theory/sets/theory_sets_type_rules.h" -rewriter ::CVC5::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 \ - ::CVC5::EmptySet \ - ::CVC5::EmptySetHashFunction \ + ::cvc5::EmptySet \ + ::cvc5::EmptySetHashFunction \ "expr/emptyset.h" \ - "the empty set constant; payload is an instance of the CVC5::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 \ - "::CVC5::theory::sets::SetsProperties::computeCardinality(%TYPE%)" \ + "::cvc5::theory::sets::SetsProperties::computeCardinality(%TYPE%)" \ "theory/sets/theory_sets_type_rules.h" well-founded SET_TYPE \ - "::CVC5::theory::sets::SetsProperties::isWellFounded(%TYPE%)" \ - "::CVC5::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 \ - "::CVC5::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 \ - ::CVC5::SingletonOp \ - ::CVC5::SingletonOpHashFunction \ + ::cvc5::SingletonOp \ + ::cvc5::SingletonOpHashFunction \ "theory/sets/singleton_op.h" \ - "operator for singletons; payload is an instance of the CVC5::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 ::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 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 ::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 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 ::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 +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 ::CVC5::theory::sets::SetsBinaryOperatorTypeRule -construle SINGLETON ::CVC5::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 197f31903..c0f02da7d 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -158,6 +158,6 @@ class NormalForm { }; } } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/sets/rels_utils.h b/src/theory/sets/rels_utils.h index eb3477f5a..545e3c08c 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -98,6 +98,6 @@ public: }; } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/sets/singleton_op.cpp b/src/theory/sets/singleton_op.cpp index 4e76d35e4..0fc411788 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/sets/singleton_op.h b/src/theory/sets/singleton_op.h index d17f8255e..7e338e518 100644 --- a/src/theory/sets/singleton_op.h +++ b/src/theory/sets/singleton_op.h @@ -19,7 +19,7 @@ #include <memory> -namespace CVC5 { +namespace cvc5 { class TypeNode; @@ -58,6 +58,6 @@ struct SingletonOpHashFunction size_t operator()(const SingletonOp& op) const; }; /* struct SingletonOpHashFunction */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SINGLETON_OP_H */ diff --git a/src/theory/sets/skolem_cache.cpp b/src/theory/sets/skolem_cache.cpp index 3c0f33caf..c18e9406d 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -61,4 +61,4 @@ bool SkolemCache::isSkolem(Node n) const } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sets/skolem_cache.h b/src/theory/sets/skolem_cache.h index 42369c7a9..17e4bda71 100644 --- a/src/theory/sets/skolem_cache.h +++ b/src/theory/sets/skolem_cache.h @@ -22,7 +22,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -78,6 +78,6 @@ class SkolemCache } // namespace sets } // namespace theory -} // namespace CVC5 +} // 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 ff604f838..31f0d4aa3 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -595,4 +595,4 @@ bool SolverState::merge(TNode t1, } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sets/solver_state.h b/src/theory/sets/solver_state.h index 431aa019d..cbbb53d88 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -268,6 +268,6 @@ class SolverState : public TheoryState } // namespace sets } // namespace theory -} // namespace CVC5 +} // 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 6dc18591c..a093840f7 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -151,4 +151,4 @@ void TermRegistry::debugPrintSet(Node s, const char* c) const } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sets/term_registry.h b/src/theory/sets/term_registry.h index 913473ff0..3d1035c75 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -89,6 +89,6 @@ class TermRegistry } // namespace sets } // namespace theory -} // namespace CVC5 +} // 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 1530da809..bd682ca57 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -238,4 +238,4 @@ void TheorySets::NotifyClass::eqNotifyDisequal(TNode t1, TNode t2, TNode reason) } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sets/theory_sets.h b/src/theory/sets/theory_sets.h index 4dc5d8a0d..16829bc6d 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -120,6 +120,6 @@ class TheorySets : public Theory } // namespace sets } // namespace theory -} // namespace CVC5 +} // 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 285eac473..8d005c6fe 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -1372,4 +1372,4 @@ void TheorySetsPrivate::presolve() { d_state.reset(); } } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sets/theory_sets_private.h b/src/theory/sets/theory_sets_private.h index a822d06e7..c2f266971 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -236,6 +236,6 @@ class TheorySetsPrivate { } // namespace sets } // namespace theory -} // namespace CVC5 +} // 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 a160e0afd..6609e4923 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -1333,4 +1333,4 @@ void TheorySetsRels::check(Theory::Effort level) } } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sets/theory_sets_rels.h b/src/theory/sets/theory_sets_rels.h index 93913d4f5..badf14bd0 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -185,6 +185,6 @@ private: } // namespace sets } // namespace theory -} // namespace CVC5 +} // 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 935eb548d..9007cc250 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -542,4 +542,4 @@ RewriteResponse TheorySetsRewriter::preRewrite(TNode node) { } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sets/theory_sets_rewriter.h b/src/theory/sets/theory_sets_rewriter.h index 739a5f885..501a58430 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -79,6 +79,6 @@ private: } // namespace sets } // namespace theory -} // namespace CVC5 +} // 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 30e279be7..87fcd2d8f 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -130,4 +130,4 @@ bool SetEnumerator::isFinished() } // namespace sets } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sets/theory_sets_type_enumerator.h b/src/theory/sets/theory_sets_type_enumerator.h index 32aca5f79..006afc964 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -68,6 +68,6 @@ class SetEnumerator : public TypeEnumeratorBase<SetEnumerator> } // namespace sets } // namespace theory -} // namespace CVC5 +} // 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 54791ac31..ab82ba710 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 CVC5 { +namespace cvc5 { namespace theory { namespace sets { @@ -390,7 +390,7 @@ struct JoinImageTypeRule { throw TypeCheckingExceptionPrivate( n, " JoinImage cardinality constraint must be a constant"); } - CVC5::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"); @@ -444,6 +444,6 @@ struct SetsProperties { } // namespace sets } // namespace theory -} // namespace CVC5 +} // 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 816ceb31a..3e8eb305c 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/shared_solver.h b/src/theory/shared_solver.h index 8463e1d46..7c6fb23a3 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 CVC5 { +namespace cvc5 { class LogicInfo; class ProofNodeManager; @@ -134,6 +134,6 @@ class SharedSolver }; } // namespace theory -} // namespace CVC5 +} // 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 70932e6a6..aecf1fc73 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 CVC5 { +namespace cvc5 { namespace theory { SharedSolverDistributed::SharedSolverDistributed(TheoryEngine& te, @@ -93,4 +93,4 @@ void SharedSolverDistributed::assertSharedEquality(TNode equality, } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/shared_solver_distributed.h b/src/theory/shared_solver_distributed.h index 95e23024d..49e4974ca 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 CVC5 { +namespace cvc5 { namespace theory { /** @@ -59,6 +59,6 @@ class SharedSolverDistributed : public SharedSolver }; } // namespace theory -} // namespace CVC5 +} // 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 e82897c98..890269ce2 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 CVC5::theory; +using namespace cvc5::theory; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/shared_terms_database.h b/src/theory/shared_terms_database.h index a7bc77251..6cb955c09 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 CVC5 { +namespace cvc5 { class TheoryEngine; @@ -278,4 +278,4 @@ class SharedTermsDatabase : public context::ContextNotifyObj { ProofNodeManager* d_pnm; }; -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/skolem_lemma.cpp b/src/theory/skolem_lemma.cpp index 1b10d3ac8..c8125129f 100644 --- a/src/theory/skolem_lemma.cpp +++ b/src/theory/skolem_lemma.cpp @@ -16,7 +16,7 @@ #include "expr/skolem_manager.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/skolem_lemma.h b/src/theory/skolem_lemma.h index c7ab08429..d67f71cf6 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 CVC5 { +namespace cvc5 { namespace theory { /** @@ -59,6 +59,6 @@ class SkolemLemma }; } // namespace theory -} // namespace CVC5 +} // 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 15e9b4214..a6202a74f 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 CVC5 { +namespace cvc5 { namespace theory { // optimization: try to rewrite to constant @@ -119,4 +119,4 @@ Result checkWithSubsolver(Node query, } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/smt_engine_subsolver.h b/src/theory/smt_engine_subsolver.h index d94f9227d..100ea2de9 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 CVC5 { +namespace cvc5 { namespace theory { /** @@ -91,6 +91,6 @@ Result checkWithSubsolver(Node query, unsigned long timeout = 0); } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__SMT_ENGINE_SUBSOLVER_H */ diff --git a/src/theory/sort_inference.cpp b/src/theory/sort_inference.cpp index cad11fcf3..fb3551e9a 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 CVC5; -using namespace CVC5::kind; +using namespace cvc5; +using namespace cvc5::kind; using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { void SortInference::UnionFind::print(const char * c){ @@ -869,4 +869,4 @@ bool SortInference::isHandledApplyUf(Kind k) const } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/sort_inference.h b/src/theory/sort_inference.h index b32026256..cb80df221 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 CVC5 { +namespace cvc5 { namespace theory { /** sort inference @@ -166,6 +166,6 @@ private: }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/strings/arith_entail.cpp b/src/theory/strings/arith_entail.cpp index 36ead8685..a1b2c487f 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -866,4 +866,4 @@ bool ArithEntail::inferZerosInSumGeq(Node x, } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/arith_entail.h b/src/theory/strings/arith_entail.h index 22011d51b..1726dac0b 100644 --- a/src/theory/strings/arith_entail.h +++ b/src/theory/strings/arith_entail.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -175,6 +175,6 @@ class ArithEntail } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/strings/base_solver.cpp b/src/theory/strings/base_solver.cpp index b9802b9a5..4cf8c897e 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 CVC5::context; -using namespace CVC5::kind; +using namespace cvc5::context; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -760,4 +760,4 @@ Node BaseSolver::TermIndex::add(TNode n, } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/base_solver.h b/src/theory/strings/base_solver.h index 43cb63b47..4ad5c3dec 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -243,6 +243,6 @@ class BaseSolver } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 8593a1e36..6a461cb7a 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 CVC5::context; -using namespace CVC5::kind; +using namespace cvc5::context; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -2651,4 +2651,4 @@ bool CoreSolver::processInferInfo(CoreInferInfo& cii) } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/core_solver.h b/src/theory/strings/core_solver.h index 53bb167c4..7392659c5 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -523,6 +523,6 @@ class CoreSolver } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 e2cb01408..3d23a95a0 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -148,4 +148,4 @@ void EagerSolver::notifyFact(TNode atom, } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/eager_solver.h b/src/theory/strings/eager_solver.h index 49545e622..1d4682c49 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -63,6 +63,6 @@ class EagerSolver } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 0bb2defb6..be2d402a1 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 CVC5::context; -using namespace CVC5::kind; +using namespace cvc5::context; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -139,4 +139,4 @@ Node EqcInfo::addEndpointConst(Node t, Node c, bool isSuf) } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/eqc_info.h b/src/theory/strings/eqc_info.h index a00cd49ea..23d566ef1 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -76,6 +76,6 @@ class EqcInfo } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 ab7c1d0ac..39bcb8f53 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 CVC5::context; -using namespace CVC5::kind; +using namespace cvc5::context; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -724,4 +724,4 @@ bool StringsExtfCallback::getCurrentSubstitution( } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/extf_solver.h b/src/theory/strings/extf_solver.h index 4b63f261a..3cfe2309c 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -227,6 +227,6 @@ class StringsExtfCallback : public ExtTheoryCallback } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 5e2006f65..bce30096f 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -90,4 +90,4 @@ std::ostream& operator<<(std::ostream& out, const InferInfo& ii) } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/infer_info.h b/src/theory/strings/infer_info.h index 9c228c197..45a5da2d6 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -131,6 +131,6 @@ std::ostream& operator<<(std::ostream& out, const InferInfo& ii); } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 c600ce31d..3005fcd19 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -1042,4 +1042,4 @@ std::string InferProofCons::identify() const } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/infer_proof_cons.h b/src/theory/strings/infer_proof_cons.h index 7d7d7e54a..677ba2e22 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -130,6 +130,6 @@ class InferProofCons : public ProofGenerator } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 15e608ef1..ff3803b7e 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 CVC5::context; -using namespace CVC5::kind; +using namespace cvc5::context; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -377,4 +377,4 @@ TrustNode InferenceManager::processLemma(InferInfo& ii, LemmaProperty& p) } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/inference_manager.h b/src/theory/strings/inference_manager.h index 1e57afe79..cb5560f2b 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -271,6 +271,6 @@ class InferenceManager : public InferenceManagerBuffered } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/strings/kinds b/src/theory/strings/kinds index 6f366d6d7..33e94d3e6 100644 --- a/src/theory/strings/kinds +++ b/src/theory/strings/kinds @@ -4,11 +4,11 @@ # src/theory/builtin/kinds. # -theory THEORY_STRINGS ::CVC5::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 ::CVC5::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(::CVC5::String())" \ + "NodeManager::currentNM()->mkConst(::cvc5::String())" \ "util/string.h" \ "String type" @@ -54,31 +54,31 @@ sort REGEXP_TYPE \ "RegExp type" enumerator STRING_TYPE \ - "::CVC5::theory::strings::StringEnumerator" \ + "::cvc5::theory::strings::StringEnumerator" \ "theory/strings/type_enumerator.h" constant CONST_STRING \ - ::CVC5::String \ - ::CVC5::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 \ - "::CVC5::theory::strings::SequenceProperties::computeCardinality(%TYPE%)" \ + "::cvc5::theory::strings::SequenceProperties::computeCardinality(%TYPE%)" \ "theory/strings/theory_strings_type_rules.h" well-founded SEQUENCE_TYPE \ - "::CVC5::theory::strings::SequenceProperties::isWellFounded(%TYPE%)" \ - "::CVC5::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 \ - "::CVC5::theory::strings::SequenceEnumerator" \ + "::cvc5::theory::strings::SequenceEnumerator" \ "theory/strings/type_enumerator.h" constant CONST_SEQUENCE \ - ::CVC5::Sequence \ - ::CVC5::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 \ - ::CVC5::RegExpRepeat \ - ::CVC5::RegExpRepeatHashFunction \ + ::cvc5::RegExpRepeat \ + ::cvc5::RegExpRepeatHashFunction \ "util/regexp.h" \ - "operator for regular expression repeat; payload is an instance of the CVC5::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 \ - ::CVC5::RegExpLoop \ - ::CVC5::RegExpLoopHashFunction \ + ::cvc5::RegExpLoop \ + ::cvc5::RegExpLoopHashFunction \ "util/regexp.h" \ - "operator for regular expression loop; payload is an instance of the CVC5::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 ::CVC5::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 ::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 +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 ::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 +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 c139a5da7..ed111b4ac 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -185,4 +185,4 @@ void NormalForm::getExplanationForPrefixEq(NormalForm& nfi, } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/normal_form.h b/src/theory/strings/normal_form.h index 65d4b3f78..fda691844 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -168,6 +168,6 @@ class NormalForm } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 bf82d16ce..236607840 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -517,4 +517,4 @@ Node StringProofRuleChecker::checkInternal(PfRule id, } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/proof_checker.h b/src/theory/strings/proof_checker.h index c55386140..ab971f62f 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -44,6 +44,6 @@ class StringProofRuleChecker : public ProofRuleChecker } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 5dbe02230..4493d6c6c 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -613,4 +613,4 @@ bool RegExpElimination::isProofEnabled() const { return d_pnm != nullptr; } } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/regexp_elim.h b/src/theory/strings/regexp_elim.h index 3ffa9566e..f43aacdcd 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -85,6 +85,6 @@ class RegExpElimination } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 94c740742..cc4027aad 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -105,7 +105,7 @@ Node RegExpEntail::simpleRegexpConsume(std::vector<Node>& mchildren, else if (xc.isConst()) { // check for constants - CVC5::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()); - CVC5::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(CVC5::String& s, +bool RegExpEntail::testConstStringInRegExp(cvc5::String& s, unsigned index_start, TNode r) { @@ -358,7 +358,7 @@ bool RegExpEntail::testConstStringInRegExp(CVC5::String& s, { case STRING_TO_REGEXP: { - CVC5::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(CVC5::String& s, { for (vec_k[i] = vec_k[i] + 1; vec_k[i] <= left; ++vec_k[i]) { - CVC5::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(CVC5::String& s, { for (unsigned i = s.size() - index_start; i > 0; --i) { - CVC5::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(CVC5::String& s, uint32_t u = r[2].getConst<Rational>().getNumerator().toUnsignedInt(); for (unsigned len = s.size() - index_start; len >= 1; len--) { - CVC5::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(CVC5::String& s, } else { - Node num2 = nm->mkConst(CVC5::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(CVC5::String& s, } for (unsigned len = 1; len <= s.size() - index_start; len++) { - CVC5::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(CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/regexp_entail.h b/src/theory/strings/regexp_entail.h index 3e14d4ed0..fcad7e2ab 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 CVC5 { +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(CVC5::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 CVC5 +} // 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 5481a0c6d..1bb85ee81 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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(::CVC5::Rational(0))), - d_one(NodeManager::currentNM()->mkConst(::CVC5::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,7 @@ int RegExpOpr::delta( Node r, Node &exp ) { } // 0-unknown, 1-yes, 2-no -int RegExpOpr::derivativeS(Node r, CVC5::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; @@ -302,8 +302,8 @@ int RegExpOpr::derivativeS(Node r, CVC5::String c, Node& retNode) break; } case kind::REGEXP_RANGE: { - CVC5::String a = r[0].getConst<String>(); - CVC5::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; } @@ -521,7 +521,7 @@ int RegExpOpr::derivativeS(Node r, CVC5::String c, Node& retNode) return ret; } -Node RegExpOpr::derivativeSingle(Node r, CVC5::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; @@ -555,8 +555,8 @@ Node RegExpOpr::derivativeSingle(Node r, CVC5::String c) break; } case kind::REGEXP_RANGE: { - CVC5::String a = r[0].getConst<String>(); - CVC5::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; } @@ -1314,7 +1314,7 @@ Node RegExpOpr::intersectInternal( Node r1, Node r2, std::map< PairNodes, Node > std::map< PairNodes, Node > cache2(cache); cache2[p] = NodeManager::currentNM()->mkNode( kind::REGEXP_RV, - NodeManager::currentNM()->mkConst(CVC5::Rational(cnt))); + NodeManager::currentNM()->mkConst(cvc5::Rational(cnt))); rt = intersectInternal(r1l, r2l, cache2, cnt+1); cacheX[ pp ] = rt; } @@ -1619,4 +1619,4 @@ Node RegExpOpr::getExistsForRegExpConcatMem(Node mem) } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/regexp_operation.h b/src/theory/strings/regexp_operation.h index 27324d971..b660e5c49 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -55,7 +55,7 @@ enum RegExpConstType }; class RegExpOpr { - typedef std::pair<Node, CVC5::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, CVC5::String c, Node& retNode); - Node derivativeSingle(Node r, CVC5::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. @@ -209,6 +209,6 @@ class RegExpOpr { } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 861f7c694..2d4404c10 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 CVC5::context; -using namespace CVC5::kind; +using namespace cvc5::context; +using namespace cvc5::kind; -namespace CVC5 { +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(::CVC5::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; } -CVC5::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; - CVC5::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) { - CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/regexp_solver.h b/src/theory/strings/regexp_solver.h index d35a822a7..440d0fcb7 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 CVC5 { +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); - CVC5::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 CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__STRINGS__THEORY_STRINGS_H */ diff --git a/src/theory/strings/rewrites.cpp b/src/theory/strings/rewrites.cpp index cdf41d9ad..41b972514 100644 --- a/src/theory/strings/rewrites.cpp +++ b/src/theory/strings/rewrites.cpp @@ -16,7 +16,7 @@ #include <iostream> -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -224,4 +224,4 @@ std::ostream& operator<<(std::ostream& out, Rewrite r) } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/rewrites.h b/src/theory/strings/rewrites.h index af9b636cf..37ef61bee 100644 --- a/src/theory/strings/rewrites.h +++ b/src/theory/strings/rewrites.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -239,6 +239,6 @@ std::ostream& operator<<(std::ostream& out, Rewrite r); } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 9cec9ad40..302f7dc0b 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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(); - CVC5::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] - CVC5::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]; - CVC5::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(CVC5::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()) { - CVC5::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()) { - CVC5::Rational rMaxInt(CVC5::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(::CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/sequences_rewriter.h b/src/theory/strings/sequences_rewriter.h index 750589f72..eda8bc1df 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -296,6 +296,6 @@ class SequencesRewriter : public TheoryRewriter } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 919b950ab..e0d14f93e 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -63,4 +63,4 @@ SequencesStatistics::~SequencesStatistics() } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/sequences_stats.h b/src/theory/strings/sequences_stats.h index 417f79046..5bd48e877 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -99,6 +99,6 @@ class SequencesStatistics } } -} // namespace CVC5 +} // 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 5e2d8981d..ad36b8edd 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -291,4 +291,4 @@ Node SkolemCache::mkIndexVar(Node t) } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/skolem_cache.h b/src/theory/strings/skolem_cache.h index b6deea6eb..5c5fc8d57 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -211,6 +211,6 @@ class SkolemCache } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 00bb39d5c..39fe6dd11 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 CVC5::context; -using namespace CVC5::kind; +using namespace cvc5::context; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -223,4 +223,4 @@ void SolverState::separateByLength( } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/solver_state.h b/src/theory/strings/solver_state.h index 8c5d29196..e54a5e7b1 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -161,6 +161,6 @@ class SolverState : public TheoryState } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__STRINGS__SOLVER_STATE_H */ diff --git a/src/theory/strings/strategy.cpp b/src/theory/strings/strategy.cpp index 56c1cbe98..54f8e43f8 100644 --- a/src/theory/strings/strategy.cpp +++ b/src/theory/strings/strategy.cpp @@ -16,7 +16,7 @@ #include "options/strings_options.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -158,4 +158,4 @@ void Strategy::initializeStrategy() } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/strategy.h b/src/theory/strings/strategy.h index 4c2e587c9..1eb2fe902 100644 --- a/src/theory/strings/strategy.h +++ b/src/theory/strings/strategy.h @@ -22,7 +22,7 @@ #include "theory/theory.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -111,6 +111,6 @@ class Strategy } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 926a43159..62ba41743 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +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(CVC5::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(CVC5::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 - CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/strings_entail.h b/src/theory/strings/strings_entail.h index 16643332a..cce0bf05b 100644 --- a/src/theory/strings/strings_entail.h +++ b/src/theory/strings/strings_entail.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -379,6 +379,6 @@ class StringsEntail } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 11a743d0d..e543f173c 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 CVC5::context; -using namespace CVC5::kind; +using namespace cvc5::context; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -102,4 +102,4 @@ std::string StringsFmf::StringSumLengthDecisionStrategy::identify() const } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/strings_fmf.h b/src/theory/strings/strings_fmf.h index 1ef610289..a2496dec3 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -106,6 +106,6 @@ class StringsFmf } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 d41a86c18..1a7ca7f6a 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -324,4 +324,4 @@ Node StringsRewriter::rewriteStringIsDigit(Node n) } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/strings_rewriter.h b/src/theory/strings/strings_rewriter.h index 226a66b34..e7ad40d51 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -103,6 +103,6 @@ class StringsRewriter : public SequencesRewriter } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 d82a2333e..4f5c09b5e 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 CVC5::context; -using namespace CVC5::kind; +using namespace cvc5::context; +using namespace cvc5::kind; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/term_registry.h b/src/theory/strings/term_registry.h index 2f03647fd..1eb000e09 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -279,6 +279,6 @@ class TermRegistry } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 03d93f8f4..5bd92267e 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 CVC5::context; -using namespace CVC5::kind; +using namespace cvc5::context; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -1088,4 +1088,4 @@ std::string TheoryStrings::debugPrintStringsEqc() } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/theory_strings.h b/src/theory/strings/theory_strings.h index 94a96fc33..e1fc20d29 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -301,6 +301,6 @@ class TheoryStrings : public Theory { } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 f89ffa5fa..8deba50ca 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 CVC5; -using namespace CVC5::kind; +using namespace cvc5; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -1028,4 +1028,4 @@ Node StringsPreprocess::mkForallInternal(Node bvl, Node body) } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/theory_strings_preprocess.h b/src/theory/strings/theory_strings_preprocess.h index acf9edad7..7c8c4308c 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -104,6 +104,6 @@ class StringsPreprocess { } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 32605f0f1..0892af4de 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -426,6 +426,6 @@ struct SequenceProperties } // namespace strings } // namespace theory -} // namespace CVC5 +} // 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 821319df5..510214e0f 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { namespace utils { @@ -423,4 +423,4 @@ unsigned getLoopMinOccurrences(TNode node) } // namespace utils } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/theory_strings_utils.h b/src/theory/strings/theory_strings_utils.h index e720ce0b2..e3c85d562 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { namespace utils { @@ -220,6 +220,6 @@ unsigned getLoopMinOccurrences(TNode node); } // namespace utils } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/strings/type_enumerator.cpp b/src/theory/strings/type_enumerator.cpp index 7b89e970e..146cf434f 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -271,4 +271,4 @@ bool SequenceEnumerator::isFinished() { return d_wenum.isFinished(); } } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/type_enumerator.h b/src/theory/strings/type_enumerator.h index 7d340be64..644fe1092 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -199,6 +199,6 @@ class SequenceEnumerator : public TypeEnumeratorBase<SequenceEnumerator> } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__STRINGS__TYPE_ENUMERATOR_H */ diff --git a/src/theory/strings/word.cpp b/src/theory/strings/word.cpp index d2e809571..612acb80a 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -486,4 +486,4 @@ Node Word::reverse(TNode x) } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/strings/word.h b/src/theory/strings/word.h index 090c36be3..6cf073cc1 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 CVC5 { +namespace cvc5 { namespace theory { namespace strings { @@ -165,6 +165,6 @@ class Word } // namespace strings } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/subs_minimize.cpp b/src/theory/subs_minimize.cpp index b9e9e13b2..a61f2d49c 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { SubstitutionMinimize::SubstitutionMinimize() {} @@ -466,4 +466,4 @@ bool SubstitutionMinimize::isSingularArg(Node n, Kind k, unsigned arg) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/subs_minimize.h b/src/theory/subs_minimize.h index 9275277e6..026cd441f 100644 --- a/src/theory/subs_minimize.h +++ b/src/theory/subs_minimize.h @@ -21,7 +21,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { namespace theory { /** SubstitutionMinimize @@ -95,6 +95,6 @@ class SubstitutionMinimize }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__SUBS_MINIMIZE_H */ diff --git a/src/theory/substitutions.cpp b/src/theory/substitutions.cpp index bdb6d2668..7a4516996 100644 --- a/src/theory/substitutions.cpp +++ b/src/theory/substitutions.cpp @@ -20,7 +20,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { struct substitution_stack_element { @@ -223,4 +223,4 @@ std::ostream& operator<<(std::ostream& out, const theory::SubstitutionMap::itera return out << "[CDMap-iterator]"; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/substitutions.h b/src/theory/substitutions.h index a925d7fab..96cc37b29 100644 --- a/src/theory/substitutions.h +++ b/src/theory/substitutions.h @@ -30,7 +30,7 @@ #include "context/cdhashmap.h" #include "util/hash.h" -namespace CVC5 { +namespace cvc5 { namespace theory { /** @@ -179,6 +179,6 @@ inline std::ostream& operator << (std::ostream& out, const SubstitutionMap& subs std::ostream& operator<<(std::ostream& out, const theory::SubstitutionMap::iterator& i); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__SUBSTITUTIONS_H */ diff --git a/src/theory/term_registration_visitor.cpp b/src/theory/term_registration_visitor.cpp index eab124bc5..eb2305d32 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 CVC5::theory; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { std::string PreRegisterVisitor::toString() const { std::stringstream ss; @@ -292,4 +292,4 @@ void SharedTermsVisitor::clear() { d_visited.clear(); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/term_registration_visitor.h b/src/theory/term_registration_visitor.h index 19406ea62..593af791b 100644 --- a/src/theory/term_registration_visitor.h +++ b/src/theory/term_registration_visitor.h @@ -22,7 +22,7 @@ #include <unordered_map> -namespace CVC5 { +namespace cvc5 { class TheoryEngine; @@ -189,4 +189,4 @@ class SharedTermsVisitor { TNodeToTheorySetMap d_preregistered; }; -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory.cpp b/src/theory/theory.cpp index 143bf92b8..c15652eef 100644 --- a/src/theory/theory.cpp +++ b/src/theory/theory.cpp @@ -39,7 +39,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { /** Default value for the uninterpreted sorts is the UF theory */ @@ -565,4 +565,4 @@ eq::EqualityEngine* Theory::getEqualityEngine() } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory.h b/src/theory/theory.h index 1dd0c584e..4b06a5fa8 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 CVC5 { +namespace cvc5 { class ProofNodeManager; class TheoryEngine; @@ -95,7 +95,7 @@ namespace eq { * after the quantifiers engine and model objects have been set up. */ class Theory { - friend class ::CVC5::TheoryEngine; + friend class ::cvc5::TheoryEngine; private: // Disallow default construction, copy, assignment. @@ -916,7 +916,7 @@ inline theory::Assertion Theory::get() { } inline std::ostream& operator<<(std::ostream& out, - const CVC5::theory::Theory& theory) + const cvc5::theory::Theory& theory) { return out << theory.identify(); } @@ -936,6 +936,6 @@ inline std::ostream& operator << (std::ostream& out, theory::Theory::PPAssertSta } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__THEORY_H */ diff --git a/src/theory/theory_engine.cpp b/src/theory/theory_engine.cpp index e6eeaf8a5..6271f0afb 100644 --- a/src/theory/theory_engine.cpp +++ b/src/theory/theory_engine.cpp @@ -50,9 +50,9 @@ using namespace std; -using namespace CVC5::theory; +using namespace cvc5::theory; -namespace CVC5 { +namespace cvc5 { /* -------------------------------------------------------------------------- */ @@ -65,19 +65,19 @@ namespace theory { */ #define CVC4_FOR_EACH_THEORY \ - 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) + 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); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory_engine.h b/src/theory/theory_engine.h index cc96c4f9d..7b91191f9 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 CVC5 { +namespace cvc5 { class ResourceManager; class OutputManager; @@ -668,6 +668,6 @@ private: void checkTheoryAssertionsWithModel(bool hardFailure); };/* class TheoryEngine */ -} // namespace CVC5 +} // 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 bfe29976e..5d8ffdb8a 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { TheoryEngineProofGenerator::TheoryEngineProofGenerator(ProofNodeManager* pnm, context::UserContext* u) @@ -128,4 +128,4 @@ std::string TheoryEngineProofGenerator::identify() const return "TheoryEngineProofGenerator"; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory_engine_proof_generator.h b/src/theory/theory_engine_proof_generator.h index 462c40fdf..f42f8d868 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 CVC5 { +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 CVC5 +} // 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 17ba7b50e..40aa07f3b 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 CVC5 { +namespace cvc5 { namespace theory { /** @@ -77,6 +77,6 @@ class TheoryEqNotifyClass : public eq::EqualityEngineNotify }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/theory_id.cpp b/src/theory/theory_id.cpp index 60fb752a7..e12096582 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 CVC5 { +namespace cvc5 { namespace theory { TheoryId& operator++(TheoryId& id) @@ -162,4 +162,4 @@ std::string TheoryIdSetUtil::setToString(TheoryIdSet theorySet) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory_id.h b/src/theory/theory_id.h index 685dd7864..d923413d5 100644 --- a/src/theory/theory_id.h +++ b/src/theory/theory_id.h @@ -22,7 +22,7 @@ #include <iosfwd> -namespace CVC5 { +namespace cvc5 { namespace theory { /** @@ -106,5 +106,5 @@ class TheoryIdSetUtil }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/theory_inference.cpp b/src/theory/theory_inference.cpp index 00217e0d6..e265c62a8 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { SimpleTheoryLemma::SimpleTheoryLemma(InferenceId id, @@ -53,4 +53,4 @@ Node SimpleTheoryInternalFact::processFact(std::vector<Node>& exp, } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory_inference.h b/src/theory/theory_inference.h index e356fb3c8..0be1c3d83 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 CVC5 { +namespace cvc5 { namespace theory { class TheoryInferenceManager; @@ -118,6 +118,6 @@ class SimpleTheoryInternalFact : public TheoryInference }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/theory_inference_manager.cpp b/src/theory/theory_inference_manager.cpp index 031570318..e7c89e703 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { TheoryInferenceManager::TheoryInferenceManager(Theory& t, @@ -520,4 +520,4 @@ void TheoryInferenceManager::safePoint(ResourceManager::Resource r) void TheoryInferenceManager::setIncomplete() { d_out.setIncomplete(); } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory_inference_manager.h b/src/theory/theory_inference_manager.h index 063b9a008..e911fb41e 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 CVC5 { +namespace cvc5 { class ProofNodeManager; @@ -461,6 +461,6 @@ class TheoryInferenceManager }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__THEORY_INFERENCE_MANAGER_H */ diff --git a/src/theory/theory_model.cpp b/src/theory/theory_model.cpp index b20a011ae..814aa7ee4 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { TheoryModel::TheoryModel(context::Context* c, @@ -765,4 +765,4 @@ std::string TheoryModel::debugPrintModelEqc() const } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory_model.h b/src/theory/theory_model.h index ce3ecfbc0..7e7439867 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 CVC5 { +namespace cvc5 { namespace theory { /** Theory Model class. @@ -433,6 +433,6 @@ public: };/* class TheoryModel */ } // namespace theory -} // namespace CVC5 +} // 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 44e3d08e3..a8dd647f0 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { void TheoryEngineModelBuilder::Assigner::initialize( @@ -1429,4 +1429,4 @@ void TheoryEngineModelBuilder::assignFunctions(TheoryModel* m) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory_model_builder.h b/src/theory/theory_model_builder.h index cc49111d8..b73693681 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 CVC5 { +namespace cvc5 { class TheoryEngine; @@ -314,6 +314,6 @@ class TheoryEngineModelBuilder }; /* class TheoryEngineModelBuilder */ } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__THEORY_MODEL_BUILDER_H */ diff --git a/src/theory/theory_preprocessor.cpp b/src/theory/theory_preprocessor.cpp index f6ba13551..78a4e6526 100644 --- a/src/theory/theory_preprocessor.cpp +++ b/src/theory/theory_preprocessor.cpp @@ -23,7 +23,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { TheoryPreprocessor::TheoryPreprocessor(TheoryEngine& engine, @@ -520,4 +520,4 @@ void TheoryPreprocessor::registerTrustedRewrite(TrustNode trn, } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory_preprocessor.h b/src/theory/theory_preprocessor.h index 21157fa52..5d8ef253c 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 CVC5 { +namespace cvc5 { class LogicInfo; class TheoryEngine; @@ -223,6 +223,6 @@ class TheoryPreprocessor }; } // namespace theory -} // namespace CVC5 +} // 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 85d2aef7a..bcb446b86 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { TheoryProofStepBuffer::TheoryProofStepBuffer(ProofChecker* pc) @@ -232,4 +232,4 @@ Node TheoryProofStepBuffer::elimDoubleNegLit(Node n) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory_proof_step_buffer.h b/src/theory/theory_proof_step_buffer.h index 80e2c2e6a..0015af105 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 CVC5 { +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 CVC5 +} // 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 13b6ecdd0..6f7531140 100644 --- a/src/theory/theory_rewriter.cpp +++ b/src/theory/theory_rewriter.cpp @@ -16,7 +16,7 @@ #include "theory/theory_rewriter.h" -namespace CVC5 { +namespace cvc5 { namespace theory { TrustRewriteResponse::TrustRewriteResponse(RewriteStatus status, @@ -60,4 +60,4 @@ TrustNode TheoryRewriter::rewriteEqualityExtWithProof(Node node) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/theory_rewriter.h b/src/theory/theory_rewriter.h index e508477d3..1617997a4 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 CVC5 { +namespace cvc5 { namespace theory { class Rewriter; @@ -140,6 +140,6 @@ class TheoryRewriter }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__THEORY_REWRITER_H */ diff --git a/src/theory/theory_state.cpp b/src/theory/theory_state.cpp index d155e12a6..958a76d28 100644 --- a/src/theory/theory_state.cpp +++ b/src/theory/theory_state.cpp @@ -16,7 +16,7 @@ #include "theory/uf/equality_engine.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/theory/theory_state.h b/src/theory/theory_state.h index 8c863144b..14776761e 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 CVC5 { +namespace cvc5 { namespace theory { namespace eq { @@ -121,6 +121,6 @@ class TheoryState }; } // namespace theory -} // namespace CVC5 +} // 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 e30507cf8..f7ec9aac2 100644 --- a/src/theory/theory_traits_template.h +++ b/src/theory/theory_traits_template.h @@ -26,7 +26,7 @@ ${theory_includes} -namespace CVC5 { +namespace cvc5 { namespace theory { template <TheoryId theoryId> @@ -43,7 +43,7 @@ ${theory_constructors} default: Unhandled() << id; } } -}; /* struct CVC5::theory::TheoryConstructor */ +}; /* struct cvc5::theory::TheoryConstructor */ } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/trust_node.cpp b/src/theory/trust_node.cpp index 7458b95e5..5a3c9e080 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 CVC5 { +namespace cvc5 { namespace theory { const char* toString(TrustNodeKind tnk) @@ -146,4 +146,4 @@ std::ostream& operator<<(std::ostream& out, TrustNode n) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/trust_node.h b/src/theory/trust_node.h index 13769dccd..c53496730 100644 --- a/src/theory/trust_node.h +++ b/src/theory/trust_node.h @@ -19,7 +19,7 @@ #include "expr/node.h" -namespace CVC5 { +namespace cvc5 { class ProofGenerator; class ProofNode; @@ -172,6 +172,6 @@ class TrustNode std::ostream& operator<<(std::ostream& out, TrustNode n); } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__TRUST_NODE_H */ diff --git a/src/theory/trust_substitutions.cpp b/src/theory/trust_substitutions.cpp index a42608c31..fe28645ba 100644 --- a/src/theory/trust_substitutions.cpp +++ b/src/theory/trust_substitutions.cpp @@ -16,7 +16,7 @@ #include "theory/rewriter.h" -namespace CVC5 { +namespace cvc5 { namespace theory { TrustSubstitutionMap::TrustSubstitutionMap(context::Context* c, @@ -246,4 +246,4 @@ Node TrustSubstitutionMap::getCurrentSubstitution() } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/trust_substitutions.h b/src/theory/trust_substitutions.h index 20b240ce8..f90e5623f 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 CVC5 { +namespace cvc5 { namespace theory { /** @@ -133,6 +133,6 @@ class TrustSubstitutionMap }; } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__TRUST_SUBSTITUTIONS_H */ diff --git a/src/theory/type_enumerator.h b/src/theory/type_enumerator.h index f0cfacee7..a80702c36 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 CVC5 { +namespace cvc5 { namespace theory { class NoMoreValuesException : public Exception { @@ -184,6 +184,6 @@ class TypeEnumerator { };/* class TypeEnumerator */ } // namespace theory -} // namespace CVC5 +} // 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 803787f5e..310b42b30 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 CVC5 { +namespace cvc5 { namespace theory { TypeEnumeratorInterface* TypeEnumerator::mkTypeEnumerator( @@ -47,4 +47,4 @@ TypeEnumeratorInterface* TypeEnumerator::mkTypeEnumerator( } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/type_set.cpp b/src/theory/type_set.cpp index 6cf8814a7..8f0fcf551 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { TypeSet::~TypeSet() @@ -137,4 +137,4 @@ void TypeSet::addSubTerms(TNode n, } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/type_set.h b/src/theory/type_set.h index 3e57033ef..0949a026b 100644 --- a/src/theory/type_set.h +++ b/src/theory/type_set.h @@ -22,7 +22,7 @@ #include "theory/type_enumerator.h" -namespace CVC5 { +namespace cvc5 { namespace theory { /* Type set @@ -85,6 +85,6 @@ class TypeSet }; /* class TypeSet */ } // namespace theory -} // namespace CVC5 +} // 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 eebe14226..6b3b5ba0e 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 CVC5::kind; -using namespace CVC5::context; +using namespace cvc5::kind; +using namespace cvc5::context; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -1766,4 +1766,4 @@ CardinalityExtension::Statistics::~Statistics() } // namespace uf } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/uf/cardinality_extension.h b/src/theory/uf/cardinality_extension.h index 85129a89b..66f0d8d1d 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 CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -463,6 +463,6 @@ class CardinalityExtension } // namespace uf } // namespace theory -} // namespace CVC5 +} // 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 fec9179f3..25f5a3faa 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 CVC5 { +namespace cvc5 { namespace theory { namespace eq { @@ -1438,4 +1438,4 @@ Node EqProof::addToProof( } // namespace eq } // Namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/uf/eq_proof.h b/src/theory/uf/eq_proof.h index 665731d2b..0578ce270 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 CVC5 { +namespace cvc5 { class CDProof; @@ -355,4 +355,4 @@ class EqProof } // Namespace eq } // Namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/uf/equality_engine.cpp b/src/theory/uf/equality_engine.cpp index a4bb76245..8f006d8ff 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 CVC5 { +namespace cvc5 { namespace theory { namespace eq { @@ -2635,4 +2635,4 @@ EqualityNodeId EqualityEngine::TriggerTermSet::getTrigger(TheoryId tag) const } // Namespace uf } // Namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/uf/equality_engine.h b/src/theory/uf/equality_engine.h index 74af68227..464e1d07a 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 CVC5 { +namespace cvc5 { namespace theory { namespace eq { @@ -845,6 +845,6 @@ private: } // Namespace eq } // Namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/uf/equality_engine_iterator.cpp b/src/theory/uf/equality_engine_iterator.cpp index c9a35f6e3..4be4f5462 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 CVC5 { +namespace cvc5 { namespace theory { namespace eq { @@ -132,4 +132,4 @@ bool EqClassIterator::isFinished() const { return d_current == null_id; } } // namespace eq } // Namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/uf/equality_engine_iterator.h b/src/theory/uf/equality_engine_iterator.h index 33562a99e..12dfea34a 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 CVC5 { +namespace cvc5 { namespace theory { namespace eq { @@ -79,6 +79,6 @@ class EqClassIterator } // Namespace eq } // Namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/uf/equality_engine_notify.h b/src/theory/uf/equality_engine_notify.h index bd353375f..4187c067f 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 CVC5 { +namespace cvc5 { namespace theory { namespace eq { @@ -115,6 +115,6 @@ class EqualityEngineNotifyNone : public EqualityEngineNotify } // Namespace eq } // Namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/uf/equality_engine_types.h b/src/theory/uf/equality_engine_types.h index 092b4bd89..030c3b998 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 CVC5 { +namespace cvc5 { namespace theory { namespace eq { @@ -359,6 +359,6 @@ struct TriggerInfo { } // namespace eq } // namespace theory -} // namespace CVC5 +} // 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 c159ff3b4..75965e2c9 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -455,4 +455,4 @@ bool HoExtension::collectModelInfoHoTerm(Node n, TheoryModel* m) } // namespace uf } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/uf/ho_extension.h b/src/theory/uf/ho_extension.h index 3ca647f28..d703feb88 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 CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -198,6 +198,6 @@ class HoExtension } // namespace uf } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* __CVC4__THEORY__UF__HO_EXTENSION_H */ diff --git a/src/theory/uf/kinds b/src/theory/uf/kinds index ab2e422ee..e4b946105 100644 --- a/src/theory/uf/kinds +++ b/src/theory/uf/kinds @@ -4,32 +4,32 @@ # src/theory/builtin/kinds. # -theory THEORY_UF ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::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 ::CVC5::theory::uf::CardinalityValueTypeRule +typerule CARDINALITY_VALUE ::cvc5::theory::uf::CardinalityValueTypeRule operator HO_APPLY 2 "higher-order (partial) function application" -typerule HO_APPLY ::CVC5::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 2688c0574..cc1630b98 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -207,4 +207,4 @@ Node UfProofRuleChecker::checkInternal(PfRule id, } // namespace uf } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/uf/proof_checker.h b/src/theory/uf/proof_checker.h index 502aeaa59..011b2868d 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 CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -44,6 +44,6 @@ class UfProofRuleChecker : public ProofRuleChecker } // namespace uf } // namespace theory -} // namespace CVC5 +} // 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 2837a02aa..5292f754f 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace eq { @@ -549,4 +549,4 @@ void ProofEqEngine::explainWithProof(Node lit, } // namespace eq } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/uf/proof_equality_engine.h b/src/theory/uf/proof_equality_engine.h index 5129ad1df..ca0b58b5d 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 CVC5 { +namespace cvc5 { class ProofNode; class ProofNodeManager; @@ -296,6 +296,6 @@ class ProofEqEngine : public EagerProofGenerator } // namespace eq } // namespace theory -} // namespace CVC5 +} // 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 9b25c8906..558838bd8 100644 --- a/src/theory/uf/symmetry_breaker.cpp +++ b/src/theory/uf/symmetry_breaker.cpp @@ -48,11 +48,11 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace uf { -using namespace ::CVC5::context; +using namespace ::cvc5::context; SymmetryBreaker::Template::Template() : d_template(), @@ -816,4 +816,4 @@ std::ostream& operator<<(std::ostream& out, const theory::uf::SymmetryBreaker::P return out; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/uf/symmetry_breaker.h b/src/theory/uf/symmetry_breaker.h index 8ce0c2c44..b4ea3640d 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 CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -175,8 +175,8 @@ private: std::ostream& operator<<( std::ostream& out, - const ::CVC5::theory::uf::SymmetryBreaker::Permutation& p); + const ::cvc5::theory::uf::SymmetryBreaker::Permutation& p); -} // namespace CVC5 +} // 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 29bb6ba7d..f3c0a0ba0 100644 --- a/src/theory/uf/theory_uf.cpp +++ b/src/theory/uf/theory_uf.cpp @@ -35,7 +35,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -693,4 +693,4 @@ bool TheoryUF::isHigherOrderType(TypeNode tn) } // namespace uf } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/uf/theory_uf.h b/src/theory/uf/theory_uf.h index 97cfc1fa5..f6f4b3ee9 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 CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -183,6 +183,6 @@ private: } // namespace uf } // namespace theory -} // namespace CVC5 +} // 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 5727d62cd..f43543fce 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 CVC5::kind; +using namespace cvc5::kind; -namespace CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -243,4 +243,4 @@ Node UfModelTree::getFunctionValue( const char* argPrefix, bool simplify ){ } // namespace uf } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/uf/theory_uf_model.h b/src/theory/uf/theory_uf_model.h index b1e0eea8f..949586976 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 CVC5 { +namespace cvc5 { namespace theory { class TheoryModel; @@ -114,6 +114,6 @@ public: } } -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/theory/uf/theory_uf_rewriter.h b/src/theory/uf/theory_uf_rewriter.h index ffa0ec22f..60a394126 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 CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -210,6 +210,6 @@ public: //conversion between HO_APPLY AND APPLY_UF } // namespace uf } // namespace theory -} // namespace CVC5 +} // 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 c21b36669..8493c8a38 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 CVC5 { +namespace cvc5 { namespace theory { namespace uf { @@ -80,7 +80,7 @@ class CardinalityConstraintTypeRule { throw TypeCheckingExceptionPrivate( n, "cardinality constraint must be a constant"); } - CVC5::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"); } - CVC5::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"); @@ -178,6 +178,6 @@ class HoApplyTypeRule { } // namespace uf } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__UF__THEORY_UF_TYPE_RULES_H */ diff --git a/src/theory/valuation.cpp b/src/theory/valuation.cpp index f77dff234..9dad48a04 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 CVC5 { +namespace cvc5 { namespace theory { std::ostream& operator<<(std::ostream& os, EqualityStatus s) @@ -222,4 +222,4 @@ context::CDList<Assertion>::const_iterator Valuation::factsEnd(TheoryId tid) } } // namespace theory -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/theory/valuation.h b/src/theory/valuation.h index c79c3bf9b..ce4e95247 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 CVC5 { +namespace cvc5 { class TheoryEngine; @@ -217,6 +217,6 @@ public: };/* class Valuation */ } // namespace theory -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__THEORY__VALUATION_H */ diff --git a/src/util/abstract_value.cpp b/src/util/abstract_value.cpp index 4f6cadde4..1f8802d22 100644 --- a/src/util/abstract_value.cpp +++ b/src/util/abstract_value.cpp @@ -24,7 +24,7 @@ using namespace std; -namespace CVC5 { +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()); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/abstract_value.h b/src/util/abstract_value.h index ddd1018a2..f933cafdf 100644 --- a/src/util/abstract_value.h +++ b/src/util/abstract_value.h @@ -22,7 +22,7 @@ #include "util/integer.h" -namespace CVC5 { +namespace cvc5 { class AbstractValue { @@ -61,4 +61,4 @@ struct AbstractValueHashFunction } }; /* struct AbstractValueHashFunction */ -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/bin_heap.h b/src/util/bin_heap.h index 40f2da045..4306cd731 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 CVC5 { +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; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__BIN_HEAP_H */ diff --git a/src/util/bitvector.cpp b/src/util/bitvector.cpp index 85b373886..210d03891 100644 --- a/src/util/bitvector.cpp +++ b/src/util/bitvector.cpp @@ -20,7 +20,7 @@ #include "base/exception.h" -namespace CVC5 { +namespace cvc5 { unsigned BitVector::getSize() const { return d_size; } @@ -375,4 +375,4 @@ BitVector BitVector::mkMaxSigned(unsigned size) return ~BitVector::mkMinSigned(size); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/bitvector.h b/src/util/bitvector.h index fbb91b8e3..12908166d 100644 --- a/src/util/bitvector.h +++ b/src/util/bitvector.h @@ -25,7 +25,7 @@ #include "base/exception.h" #include "util/integer.h" -namespace CVC5 { +namespace cvc5 { class BitVector { @@ -442,6 +442,6 @@ inline std::ostream& operator<<(std::ostream& os, const IntToBitVector& bv) return os << "[" << bv.d_size << "]"; } -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__BITVECTOR_H */ diff --git a/src/util/bool.h b/src/util/bool.h index d1f57fcd4..01d97a43a 100644 --- a/src/util/bool.h +++ b/src/util/bool.h @@ -19,7 +19,7 @@ #ifndef CVC4__BOOL_H #define CVC4__BOOL_H -namespace CVC5 { +namespace cvc5 { struct BoolHashFunction { inline size_t operator()(bool b) const { @@ -27,6 +27,6 @@ struct BoolHashFunction { } };/* struct BoolHashFunction */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__BOOL_H */ diff --git a/src/util/cardinality.cpp b/src/util/cardinality.cpp index 027c3d2db..acbb26b19 100644 --- a/src/util/cardinality.cpp +++ b/src/util/cardinality.cpp @@ -22,7 +22,7 @@ #include "base/check.h" #include "base/exception.h" -namespace CVC5 { +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; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/cardinality.h b/src/util/cardinality.h index 2ab2fdd63..f188a8c8c 100644 --- a/src/util/cardinality.h +++ b/src/util/cardinality.h @@ -24,7 +24,7 @@ #include "util/integer.h" -namespace CVC5 { +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); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__CARDINALITY_H */ diff --git a/src/util/dense_map.h b/src/util/dense_map.h index e6fed6916..f3b0372b2 100644 --- a/src/util/dense_map.h +++ b/src/util/dense_map.h @@ -35,7 +35,7 @@ #include "base/check.h" #include "util/index.h" -namespace CVC5 { +namespace cvc5 { template <class T> class DenseMap { @@ -338,4 +338,4 @@ public: void pop_back() { d_map.pop_back(); } }; /* class DenseMultiset */ -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/divisible.cpp b/src/util/divisible.cpp index 45b1f6c27..d8c099923 100644 --- a/src/util/divisible.cpp +++ b/src/util/divisible.cpp @@ -22,10 +22,10 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { Divisible::Divisible(const Integer& n) : k(n) { PrettyCheckArgument(n > 0, n, "Divisible predicate must be constructed over positive N"); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/divisible.h b/src/util/divisible.h index 5b3506ee8..95934a52a 100644 --- a/src/util/divisible.h +++ b/src/util/divisible.h @@ -26,7 +26,7 @@ #include "util/integer.h" -namespace CVC5 { +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; } -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__DIVISIBLE_H */ diff --git a/src/util/floatingpoint.cpp b/src/util/floatingpoint.cpp index be5f6a496..a9d404103 100644 --- a/src/util/floatingpoint.cpp +++ b/src/util/floatingpoint.cpp @@ -28,7 +28,7 @@ /* -------------------------------------------------------------------------- */ -namespace CVC5 { +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() << ")"; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/floatingpoint.h b/src/util/floatingpoint.h index 060d1de99..e038959a0 100644 --- a/src/util/floatingpoint.h +++ b/src/util/floatingpoint.h @@ -29,7 +29,7 @@ /* -------------------------------------------------------------------------- */ -namespace CVC5 { +namespace cvc5 { /* -------------------------------------------------------------------------- */ @@ -514,7 +514,7 @@ struct FloatingPointToBVHashFunction { inline size_t operator()(const FloatingPointToBV& fptbv) const { - UnsignedHashFunction< ::CVC5::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 CVC5 +} // namespace cvc5 #endif /* CVC4__FLOATINGPOINT_H */ diff --git a/src/util/floatingpoint_literal_symfpu.cpp b/src/util/floatingpoint_literal_symfpu.cpp index efd3e2399..666c3438d 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<::CVC5::symfpuLiteral::CVC4Prop, T> \ + struct ite<::cvc5::symfpuLiteral::CVC4Prop, T> \ { \ - static const T& iteOp(const ::CVC5::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(::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); +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(::CVC5::symfpuLiteral::traits::ubv); /* -------------------------------------------------------------------------- */ -namespace CVC5 { +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 ::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; }; +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 CVC5 +} // namespace cvc5 diff --git a/src/util/floatingpoint_literal_symfpu.h.in b/src/util/floatingpoint_literal_symfpu.h.in index d01bf6a9d..c4352c080 100644 --- a/src/util/floatingpoint_literal_symfpu.h.in +++ b/src/util/floatingpoint_literal_symfpu.h.in @@ -30,7 +30,7 @@ /* -------------------------------------------------------------------------- */ -namespace CVC5 { +namespace cvc5 { class FloatingPointSize; class FloatingPointLiteral; @@ -56,8 +56,8 @@ class wrappedBitVector; using CVC4BitWidth = uint32_t; using CVC4Prop = bool; -using CVC4RM = ::CVC5::RoundingMode; -using CVC4FPSize = ::CVC5::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 CVC5::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 - * CVC5::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 CVC5 +} // namespace cvc5 #endif diff --git a/src/util/floatingpoint_size.cpp b/src/util/floatingpoint_size.cpp index 78558ab27..cf7aea524 100644 --- a/src/util/floatingpoint_size.cpp +++ b/src/util/floatingpoint_size.cpp @@ -15,7 +15,7 @@ #include "base/check.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/util/floatingpoint_size.h b/src/util/floatingpoint_size.h index ed5dccc4f..8350ffaec 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 CVC5 { +namespace cvc5 { // Inline these! inline bool validExponentSize(uint32_t e) { return e >= 2; } @@ -92,6 +92,6 @@ struct FloatingPointSizeHashFunction | t.significandWidth()); } }; /* struct FloatingPointSizeHashFunction */ -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/util/gmp_util.h b/src/util/gmp_util.h index 0ecc6485d..0b08f4f38 100644 --- a/src/util/gmp_util.h +++ b/src/util/gmp_util.h @@ -22,7 +22,7 @@ #include <gmpxx.h> -namespace CVC5 { +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() */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__GMP_UTIL_H */ diff --git a/src/util/hash.h b/src/util/hash.h index 066e01aad..6ba4534d1 100644 --- a/src/util/hash.h +++ b/src/util/hash.h @@ -38,7 +38,7 @@ struct hash<uint64_t> { }/* std namespace */ -namespace CVC5 { +namespace cvc5 { namespace fnv1a { @@ -64,6 +64,6 @@ struct PairHashFunction { } };/* struct PairHashFunction */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__HASH_H */ diff --git a/src/util/iand.h b/src/util/iand.h index a50c4aeb7..e1a42b11b 100644 --- a/src/util/iand.h +++ b/src/util/iand.h @@ -22,7 +22,7 @@ #include "base/exception.h" #include "util/integer.h" -namespace CVC5 { +namespace cvc5 { struct IntAnd { @@ -41,6 +41,6 @@ inline std::ostream& operator<<(std::ostream& os, const IntAnd& ia) return os << "[" << ia.d_size << "]"; } -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__IAND_H */ diff --git a/src/util/index.cpp b/src/util/index.cpp index 7c9f3c57f..ffb49f943 100644 --- a/src/util/index.cpp +++ b/src/util/index.cpp @@ -19,7 +19,7 @@ #include <limits> -namespace CVC5 { +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. */ -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/index.h b/src/util/index.h index 1fa881eb6..6da0d8602 100644 --- a/src/util/index.h +++ b/src/util/index.h @@ -19,11 +19,11 @@ #ifndef CVC4__INDEX_H #define CVC4__INDEX_H -namespace CVC5 { +namespace cvc5 { /** Index is a standardized unsigned integer used for efficient indexing. */ using Index = uint32_t; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__INDEX_H */ diff --git a/src/util/indexed_root_predicate.h b/src/util/indexed_root_predicate.h index b201630c0..a35ecaa12 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 CVC5 { +namespace cvc5 { /** * The structure representing the index of a root predicate. @@ -69,6 +69,6 @@ struct IndexedRootPredicateHashFunction } }; /* struct IndexedRootPredicateHashFunction */ -} // namespace CVC5 +} // 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 0f02f03e5..3b70a98bf 100644 --- a/src/util/integer_cln_imp.cpp +++ b/src/util/integer_cln_imp.cpp @@ -28,7 +28,7 @@ using namespace std; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/util/integer_cln_imp.h b/src/util/integer_cln_imp.h index 7d7b002f2..d3d9faf56 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 CVC5 { +namespace cvc5 { class Rational; class CVC4_EXPORT Integer { - friend class CVC5::Rational; + friend class cvc5::Rational; public: /** @@ -380,11 +380,11 @@ class CVC4_EXPORT Integer struct IntegerHashFunction { - size_t operator()(const CVC5::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 CVC5 +} // namespace cvc5 #endif /* CVC4__INTEGER_H */ diff --git a/src/util/integer_gmp_imp.cpp b/src/util/integer_gmp_imp.cpp index d1e0d7108..399b7bbbe 100644 --- a/src/util/integer_gmp_imp.cpp +++ b/src/util/integer_gmp_imp.cpp @@ -31,7 +31,7 @@ using namespace std; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/util/integer_gmp_imp.h b/src/util/integer_gmp_imp.h index fa206d08f..0d129ef45 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 CVC5 { +namespace cvc5 { class Rational; class CVC4_EXPORT Integer { - friend class CVC5::Rational; + friend class cvc5::Rational; public: /** @@ -330,7 +330,7 @@ class CVC4_EXPORT Integer struct IntegerHashFunction { - inline size_t operator()(const CVC5::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 CVC5 +} // namespace cvc5 #endif /* CVC4__INTEGER_H */ diff --git a/src/util/maybe.h b/src/util/maybe.h index 35c0efd68..688073b8c 100644 --- a/src/util/maybe.h +++ b/src/util/maybe.h @@ -31,7 +31,7 @@ #include "base/exception.h" -namespace CVC5 { +namespace cvc5 { template <class T> class Maybe @@ -84,6 +84,6 @@ inline std::ostream& operator<<(std::ostream& out, const Maybe<T>& m){ return out; } -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__UTIL__MAYBE_H */ diff --git a/src/util/ostream_util.cpp b/src/util/ostream_util.cpp index 37fa0d892..8a3b2b47b 100644 --- a/src/util/ostream_util.cpp +++ b/src/util/ostream_util.cpp @@ -17,7 +17,7 @@ #include <ostream> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/util/ostream_util.h b/src/util/ostream_util.h index c5e1e2797..ab61faaca 100644 --- a/src/util/ostream_util.h +++ b/src/util/ostream_util.h @@ -22,7 +22,7 @@ #include <ios> #include <iosfwd> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__UTIL__OSTREAM_UTIL_H */ diff --git a/src/util/poly_util.cpp b/src/util/poly_util.cpp index 9dbb24872..7cb8baae3 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 CVC5 { +namespace cvc5 { namespace poly_utils { namespace { @@ -361,6 +361,6 @@ void getVariableInformation(VariableInformation& vi, } } // namespace poly_utils -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/util/poly_util.h b/src/util/poly_util.h index efb185932..217f7c774 100644 --- a/src/util/poly_util.h +++ b/src/util/poly_util.h @@ -36,7 +36,7 @@ #include <poly/polyxx.h> -namespace CVC5 { +namespace cvc5 { /** * Utilities for working with libpoly. * This namespace contains various basic conversion routines necessary for the @@ -49,28 +49,28 @@ namespace CVC5 { */ namespace poly_utils { -/** Converts a poly::Integer to a CVC5::Integer. */ +/** Converts a poly::Integer to a cvc5::Integer. */ Integer toInteger(const poly::Integer& i); -/** Converts a poly::Integer to a CVC5::Rational. */ +/** Converts a poly::Integer to a cvc5::Rational. */ Rational toRational(const poly::Integer& r); -/** Converts a poly::Rational to a CVC5::Rational. */ +/** Converts a poly::Rational to a cvc5::Rational. */ Rational toRational(const poly::Rational& r); -/** Converts a poly::DyadicRational to a CVC5::Rational. */ +/** Converts a poly::DyadicRational to a cvc5::Rational. */ Rational toRational(const poly::DyadicRational& dr); -/** Converts a poly::Value to a CVC5::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 CVC5::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 CVC5::Integer to a poly::Integer. */ +/** Converts a cvc5::Integer to a poly::Integer. */ poly::Integer toInteger(const Integer& i); -/** Converts a vector of CVC5::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 CVC5::Rational to a poly::Rational. */ +/** Converts a cvc5::Rational to a poly::Rational. */ poly::Rational toRational(const Rational& r); /** - * Converts a CVC5::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 - * CVC5::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 CVC5::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 CVC5 +} // namespace cvc5 #endif diff --git a/src/util/random.cpp b/src/util/random.cpp index ab35bd389..feac8d5b6 100644 --- a/src/util/random.cpp +++ b/src/util/random.cpp @@ -21,7 +21,7 @@ #include <cfloat> #include "base/check.h" -namespace CVC5 { +namespace cvc5 { Random::Random(uint64_t seed) { setSeed(seed); } @@ -66,4 +66,4 @@ bool Random::pickWithProb(double probability) return r < p; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/random.h b/src/util/random.h index 67d4e052d..738f5c510 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 CVC5 { +namespace cvc5 { class Random { @@ -69,5 +69,5 @@ class Random uint64_t d_state; }; -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/util/rational_cln_imp.cpp b/src/util/rational_cln_imp.cpp index a974a6155..b12fd8d28 100644 --- a/src/util/rational_cln_imp.cpp +++ b/src/util/rational_cln_imp.cpp @@ -28,7 +28,7 @@ using namespace std; -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/util/rational_cln_imp.h b/src/util/rational_cln_imp.h index d2c57e90d..d62694868 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 CVC5 { +namespace cvc5 { /** ** A multi-precision rational constant. @@ -336,11 +336,11 @@ class CVC4_EXPORT Rational struct RationalHashFunction { - inline size_t operator()(const CVC5::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 CVC5 +} // namespace cvc5 #endif /* CVC4__RATIONAL_H */ diff --git a/src/util/rational_gmp_imp.cpp b/src/util/rational_gmp_imp.cpp index 0762e17c1..69a2fa2dd 100644 --- a/src/util/rational_gmp_imp.cpp +++ b/src/util/rational_gmp_imp.cpp @@ -27,7 +27,7 @@ #include "base/check.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/util/rational_gmp_imp.h b/src/util/rational_gmp_imp.h index 0d7569b21..2bfc2a5b9 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 CVC5 { +namespace cvc5 { /** ** A multi-precision rational constant. @@ -326,11 +326,11 @@ class CVC4_EXPORT Rational struct RationalHashFunction { - inline size_t operator()(const CVC5::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 CVC5 +} // 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 6a8111b55..5c7dd9468 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/util/real_algebraic_number_poly_imp.h b/src/util/real_algebraic_number_poly_imp.h index 4819e8866..b376a236a 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 CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__REAL_ALGEBRAIC_NUMBER_H */ diff --git a/src/util/regexp.cpp b/src/util/regexp.cpp index 5df83b1ce..ef08da6fa 100644 --- a/src/util/regexp.cpp +++ b/src/util/regexp.cpp @@ -16,7 +16,7 @@ #include <ostream> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/util/regexp.h b/src/util/regexp.h index c28f121c0..0f929ff9e 100644 --- a/src/util/regexp.h +++ b/src/util/regexp.h @@ -19,7 +19,7 @@ #include <iosfwd> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif /* CVC4__UTIL__REGEXP_H */ diff --git a/src/util/resource_manager.cpp b/src/util/resource_manager.cpp index 00395178c..a982c5e1d 100644 --- a/src/util/resource_manager.cpp +++ b/src/util/resource_manager.cpp @@ -28,7 +28,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { bool WallClockTimer::on() const { @@ -420,4 +420,4 @@ void ResourceManager::registerListener(Listener* listener) return d_listeners.push_back(listener); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/resource_manager.h b/src/util/resource_manager.h index 3a6269e99..64a94cdc9 100644 --- a/src/util/resource_manager.h +++ b/src/util/resource_manager.h @@ -26,7 +26,7 @@ #include <memory> #include <vector> -namespace CVC5 { +namespace cvc5 { class Listener; class Options; @@ -206,6 +206,6 @@ class ResourceManager }; /* class ResourceManager */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__RESOURCE_MANAGER_H */ diff --git a/src/util/result.cpp b/src/util/result.cpp index f9fa94266..32a7e5895 100644 --- a/src/util/result.cpp +++ b/src/util/result.cpp @@ -26,7 +26,7 @@ using namespace std; -namespace CVC5 { +namespace cvc5 { Result::Result() : d_sat(SAT_UNKNOWN), @@ -374,4 +374,4 @@ void Result::toStream(std::ostream& out, OutputLanguage language) const { }; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/result.h b/src/util/result.h index e2a3a268a..9fdd61792 100644 --- a/src/util/result.h +++ b/src/util/result.h @@ -24,7 +24,7 @@ #include "options/language.h" -namespace CVC5 { +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); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__RESULT_H */ diff --git a/src/util/roundingmode.h b/src/util/roundingmode.h index e58689df6..2acc5a457 100644 --- a/src/util/roundingmode.h +++ b/src/util/roundingmode.h @@ -18,7 +18,7 @@ #include <fenv.h> -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/util/safe_print.cpp b/src/util/safe_print.cpp index c70119822..ce4f529a4 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 CVC5 { +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) { } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/safe_print.h b/src/util/safe_print.h index 553f78bb7..ca844ef73 100644 --- a/src/util/safe_print.h +++ b/src/util/safe_print.h @@ -44,7 +44,7 @@ #include "cvc4_export.h" -namespace CVC5 { +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); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SAFE_PRINT_H */ diff --git a/src/util/sampler.cpp b/src/util/sampler.cpp index a39aebc63..5351a6175 100644 --- a/src/util/sampler.cpp +++ b/src/util/sampler.cpp @@ -23,7 +23,7 @@ #include "util/bitvector.h" #include "util/random.h" -namespace CVC5 { +namespace cvc5 { BitVector Sampler::pickBvUniform(unsigned sz) { @@ -172,4 +172,4 @@ FloatingPoint Sampler::pickFpBiased(unsigned e, unsigned s) return FloatingPoint(e, s, bv); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/sampler.h b/src/util/sampler.h index f715536bc..19ed68c0f 100644 --- a/src/util/sampler.h +++ b/src/util/sampler.h @@ -22,7 +22,7 @@ #include "util/floatingpoint.h" -namespace CVC5 { +namespace cvc5 { class Sampler { @@ -52,6 +52,6 @@ class Sampler static constexpr double probSpecial = 0.2; }; -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__UTIL_FLOATINGPOINT_SAMPLER_H */ diff --git a/src/util/sexpr.cpp b/src/util/sexpr.cpp index 3c93ef5ae..85dd038bb 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 CVC5 { +namespace cvc5 { const int PrettySExprs::s_iosIndex = std::ios_base::xalloc(); @@ -90,7 +90,7 @@ SExpr::SExpr(const SExpr& other) Assert((d_children == NULL) == isAtom()); } -SExpr::SExpr(const CVC5::Integer& value) +SExpr::SExpr(const cvc5::Integer& value) : d_sexprType(SEXPR_INTEGER), d_integerValue(value), d_rationalValue(0), @@ -127,7 +127,7 @@ SExpr::SExpr(unsigned long int value) d_stringValue(""), d_children(NULL) {} -SExpr::SExpr(const CVC5::Rational& value) +SExpr::SExpr(const cvc5::Rational& value) : d_sexprType(SEXPR_RATIONAL), d_integerValue(0), d_rationalValue(value), @@ -308,13 +308,13 @@ std::string SExpr::getValue() const { return std::string(); } -const CVC5::Integer& SExpr::getIntegerValue() const +const cvc5::Integer& SExpr::getIntegerValue() const { PrettyCheckArgument(isInteger(), this); return d_integerValue; } -const CVC5::Rational& SExpr::getRationalValue() const +const cvc5::Rational& SExpr::getRationalValue() const { PrettyCheckArgument(isRational(), this); return d_rationalValue; @@ -383,4 +383,4 @@ SExpr SExpr::parseListOfListOfAtoms( return SExpr(parsedListsOfAtoms); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/sexpr.h b/src/util/sexpr.h index f4eaca663..3fcd398f7 100644 --- a/src/util/sexpr.h +++ b/src/util/sexpr.h @@ -35,7 +35,7 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC5 { +namespace cvc5 { class SExprKeyword { @@ -61,14 +61,14 @@ class CVC4_EXPORT SExpr SExpr& operator=(const SExpr& other); ~SExpr(); - SExpr(const CVC5::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 CVC5::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 CVC5::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 CVC5::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. */ - CVC5::Integer d_integerValue; + cvc5::Integer d_integerValue; /** The value of an atomic rational-valued S-expression. */ - CVC5::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); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__SEXPR_H */ diff --git a/src/util/smt2_quote_string.cpp b/src/util/smt2_quote_string.cpp index 7d255c6f1..c4e01acc4 100644 --- a/src/util/smt2_quote_string.cpp +++ b/src/util/smt2_quote_string.cpp @@ -19,7 +19,7 @@ #include <sstream> #include <string> -namespace CVC5 { +namespace cvc5 { /** * SMT-LIB 2 quoting for symbols @@ -43,4 +43,4 @@ std::string quoteSymbol(const std::string& s){ return s; } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/smt2_quote_string.h b/src/util/smt2_quote_string.h index b9e6592df..be2546053 100644 --- a/src/util/smt2_quote_string.h +++ b/src/util/smt2_quote_string.h @@ -21,13 +21,13 @@ #include <string> -namespace CVC5 { +namespace cvc5 { /** * SMT-LIB 2 quoting for symbols */ std::string quoteSymbol(const std::string& s); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__UTIL__SMT2_QUOTE_STRING_H */ diff --git a/src/util/statistics.cpp b/src/util/statistics.cpp index 3c7ac6731..494a70e6c 100644 --- a/src/util/statistics.cpp +++ b/src/util/statistics.cpp @@ -20,7 +20,7 @@ #include "util/safe_print.h" #include "util/statistics_registry.h" // for details about class Stat -namespace CVC5 { +namespace cvc5 { bool StatisticsBase::StatCmp::operator()(const Stat* s1, const Stat* s2) const { return s1->getName() < s2->getName(); @@ -130,4 +130,4 @@ SExpr StatisticsBase::getStatistic(std::string name) const { } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/statistics.h b/src/util/statistics.h index 0c52cfe8e..8989cb60d 100644 --- a/src/util/statistics.h +++ b/src/util/statistics.h @@ -29,7 +29,7 @@ #include "cvc4_export.h" #include "util/sexpr.h" -namespace CVC5 { +namespace cvc5 { class Stat; @@ -127,6 +127,6 @@ public: }; /* class Statistics */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__STATISTICS_H */ diff --git a/src/util/statistics_registry.cpp b/src/util/statistics_registry.cpp index bbd98ffaf..f9e05e68f 100644 --- a/src/util/statistics_registry.cpp +++ b/src/util/statistics_registry.cpp @@ -34,7 +34,7 @@ /****************************************************************************/ /* Some utility functions for timespec */ /****************************************************************************/ -namespace CVC5 { +namespace cvc5 { void StatisticsRegistry::registerStat(Stat* s) { @@ -89,4 +89,4 @@ RegisterStatistic::~RegisterStatistic() { d_reg->unregisterStat(d_stat); } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/statistics_registry.h b/src/util/statistics_registry.h index b8c83436f..44f40d5d3 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 CVC5 { +namespace cvc5 { /** A statistic that contains a SExpr. */ class SExprStat : public Stat { @@ -196,6 +196,6 @@ private: }; /* class RegisterStatistic */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__STATISTICS_REGISTRY_H */ diff --git a/src/util/stats_base.cpp b/src/util/stats_base.cpp index 758883cbe..3ae50cd51 100644 --- a/src/util/stats_base.cpp +++ b/src/util/stats_base.cpp @@ -18,7 +18,7 @@ #include "util/statistics_registry.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/util/stats_base.h b/src/util/stats_base.h index f7d19624a..e59e6e57c 100644 --- a/src/util/stats_base.h +++ b/src/util/stats_base.h @@ -34,7 +34,7 @@ #define CVC4_USE_STATISTICS false #endif -namespace CVC5 { +namespace cvc5 { /** * The base class for all statistics. @@ -274,6 +274,6 @@ class SizeStat : public Stat const T& d_sized; }; /* class SizeStat */ -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/util/stats_histogram.h b/src/util/stats_histogram.h index 44d4b9e7c..5a8f21fe8 100644 --- a/src/util/stats_histogram.h +++ b/src/util/stats_histogram.h @@ -24,7 +24,7 @@ #include "util/stats_base.h" -namespace CVC5 { +namespace cvc5 { /** * A histogram statistic class for integral types. @@ -123,6 +123,6 @@ class IntegralHistogramStat : public Stat int64_t d_offset; }; /* class IntegralHistogramStat */ -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/src/util/stats_timer.cpp b/src/util/stats_timer.cpp index 6280b79e1..fa513b0b4 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 CVC5 { +namespace cvc5 { template <> void safe_print(int fd, const timer_stat_detail::duration& t) @@ -101,4 +101,4 @@ CodeTimer::~CodeTimer() } } -} // namespace CVC5 +} // namespace cvc5 diff --git a/src/util/stats_timer.h b/src/util/stats_timer.h index 40df52ade..92ea87b59 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 CVC5 { +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 CVC5::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 CVC5 +} // namespace cvc5 #endif diff --git a/src/util/stats_utils.cpp b/src/util/stats_utils.cpp index 2a87ff439..7908e0912 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/util/stats_utils.h b/src/util/stats_utils.h index d511539ca..001a4cf82 100644 --- a/src/util/stats_utils.h +++ b/src/util/stats_utils.h @@ -23,7 +23,7 @@ #include "cvc4_export.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 #endif diff --git a/src/util/string.cpp b/src/util/string.cpp index d1d7fadc2..ec13956f4 100644 --- a/src/util/string.cpp +++ b/src/util/string.cpp @@ -25,7 +25,7 @@ using namespace std; -namespace CVC5 { +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 CVC5::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 CVC5 +} // namespace cvc5 diff --git a/src/util/string.h b/src/util/string.h index a3e0245aa..6fc23f124 100644 --- a/src/util/string.h +++ b/src/util/string.h @@ -23,7 +23,7 @@ #include "util/rational.h" -namespace CVC5 { +namespace cvc5 { /** The CVC4 string class * @@ -46,7 +46,7 @@ class String static inline unsigned num_codes() { return 196608; } /** constructors for String * - * Internally, a CVC5::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 - * CVC5::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 - * CVC5::String( s ).toString() = s. + * cvc5::String( s ).toString() = s. */ std::string toString(bool useEscSequences = false) const; /* toWString @@ -265,7 +265,7 @@ namespace strings { struct StringHashFunction { - size_t operator()(const ::CVC5::String& s) const + size_t operator()(const ::cvc5::String& s) const { return std::hash<std::string>()(s.toString()); } @@ -275,6 +275,6 @@ struct StringHashFunction std::ostream& operator<<(std::ostream& os, const String& s); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__UTIL__STRING_H */ diff --git a/src/util/tuple.h b/src/util/tuple.h index 571bfe797..5a3693691 100644 --- a/src/util/tuple.h +++ b/src/util/tuple.h @@ -23,7 +23,7 @@ #include <vector> #include <utility> -namespace CVC5 { +namespace cvc5 { class TupleUpdate { @@ -49,6 +49,6 @@ inline std::ostream& operator<<(std::ostream& out, const TupleUpdate& t) { return out << "[" << t.getIndex() << "]"; } -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__TUPLE_H */ diff --git a/src/util/unsafe_interrupt_exception.h b/src/util/unsafe_interrupt_exception.h index 31fe26577..39817620d 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 CVC5 { +namespace cvc5 { -class CVC4_EXPORT UnsafeInterruptException : public CVC5::Exception +class CVC4_EXPORT UnsafeInterruptException : public cvc5::Exception { public: UnsafeInterruptException() : @@ -40,6 +40,6 @@ class CVC4_EXPORT UnsafeInterruptException : public CVC5::Exception } }; /* class UnsafeInterruptException */ -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__UNSAFE_INTERRUPT_EXCEPTION_H */ diff --git a/src/util/utility.cpp b/src/util/utility.cpp index 480b68ff2..b07f046bf 100644 --- a/src/util/utility.cpp +++ b/src/util/utility.cpp @@ -22,7 +22,7 @@ #include "base/check.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/src/util/utility.h b/src/util/utility.h index 006f2072c..133e51025 100644 --- a/src/util/utility.h +++ b/src/util/utility.h @@ -24,7 +24,7 @@ #include <memory> #include <string> -namespace CVC5 { +namespace cvc5 { /** * Using std::find_if(), finds the first iterator in [first,last) @@ -77,6 +77,6 @@ void container_to_stream(std::ostream& out, */ std::unique_ptr<std::fstream> openTmpFile(std::string* pattern); -} // namespace CVC5 +} // namespace cvc5 #endif /* CVC4__UTILITY_H */ diff --git a/test/api/boilerplate.cpp b/test/api/boilerplate.cpp index 1dcff036b..cc71a48ae 100644 --- a/test/api/boilerplate.cpp +++ b/test/api/boilerplate.cpp @@ -21,7 +21,7 @@ #include "api/cvc4cpp.h" -using namespace CVC5::api; +using namespace cvc5::api; using namespace std; int main() { diff --git a/test/api/issue4889.cpp b/test/api/issue4889.cpp index 2f4173d88..2b57781b6 100644 --- a/test/api/issue4889.cpp +++ b/test/api/issue4889.cpp @@ -14,7 +14,7 @@ #include "api/cvc4cpp.h" -using namespace CVC5::api; +using namespace cvc5::api; int main() { diff --git a/test/api/issue5074.cpp b/test/api/issue5074.cpp index d275c3ede..ab58797ee 100644 --- a/test/api/issue5074.cpp +++ b/test/api/issue5074.cpp @@ -14,7 +14,7 @@ #include "api/cvc4cpp.h" -using namespace CVC5::api; +using namespace cvc5::api; int main() { diff --git a/test/api/ouroborous.cpp b/test/api/ouroborous.cpp index fb4475ca4..8686cbeb1 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 CVC5; -using namespace CVC5::parser; -using namespace CVC5::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 30b03a8f8..46941e36d 100644 --- a/test/api/reset_assertions.cpp +++ b/test/api/reset_assertions.cpp @@ -22,7 +22,7 @@ #include "api/cvc4cpp.h" -using namespace CVC5::api; +using namespace cvc5::api; int main() { diff --git a/test/api/sep_log_api.cpp b/test/api/sep_log_api.cpp index ab373bf7c..8599a36e1 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 CVC5::api; +using namespace cvc5::api; using namespace std; /** diff --git a/test/api/smt2_compliance.cpp b/test/api/smt2_compliance.cpp index 8604366ba..0510e59db 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 CVC5; -using namespace CVC5::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 d0a05478c..d28f0ceb5 100644 --- a/test/api/two_solvers.cpp +++ b/test/api/two_solvers.cpp @@ -19,7 +19,7 @@ #include "api/cvc4cpp.h" -using namespace CVC5::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 97db622c6..190816921 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 CVC5 { +namespace cvc5 { using namespace api; @@ -547,4 +547,4 @@ TEST_F(TestApiBlackDatatype, datatypeSpecializedCons) ASSERT_THROW(nilc.getSpecializedConstructorTerm(isort), CVC4ApiException); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/api/grammar_black.cpp b/test/unit/api/grammar_black.cpp index 96ad29503..9c1f750b8 100644 --- a/test/unit/api/grammar_black.cpp +++ b/test/unit/api/grammar_black.cpp @@ -16,7 +16,7 @@ #include "test_api.h" -namespace CVC5 { +namespace cvc5 { using namespace api; @@ -122,4 +122,4 @@ TEST_F(TestApiBlackGrammar, addAnyVariable) ASSERT_THROW(g1.addAnyVariable(start), CVC4ApiException); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/api/op_black.cpp b/test/unit/api/op_black.cpp index 2333e5719..0e6626ec5 100644 --- a/test/unit/api/op_black.cpp +++ b/test/unit/api/op_black.cpp @@ -14,7 +14,7 @@ #include "test_api.h" -namespace CVC5 { +namespace cvc5 { using namespace api; @@ -178,4 +178,4 @@ TEST_F(TestApiBlackOp, opScopingToString) ASSERT_EQ(bitvector_repeat_ot.toString(), op_repr); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/api/op_white.cpp b/test/unit/api/op_white.cpp index 49a964e9e..909aafcbb 100644 --- a/test/unit/api/op_white.cpp +++ b/test/unit/api/op_white.cpp @@ -14,7 +14,7 @@ #include "test_api.h" -namespace CVC5 { +namespace cvc5 { using namespace api; @@ -32,4 +32,4 @@ TEST_F(TestApiWhiteOp, opFromKind) ASSERT_EQ(plus, d_solver.mkOp(PLUS)); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/api/result_black.cpp b/test/unit/api/result_black.cpp index f27b30431..ac4542c59 100644 --- a/test/unit/api/result_black.cpp +++ b/test/unit/api/result_black.cpp @@ -14,7 +14,7 @@ #include "test_api.h" -namespace CVC5 { +namespace cvc5 { using namespace api; @@ -26,7 +26,7 @@ class TestApiBlackResult : public TestApi TEST_F(TestApiBlackResult, isNull) { - CVC5::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)); - CVC5::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)); - CVC5::api::Result res; - CVC5::api::Result res2 = d_solver.checkSat(); - CVC5::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)); - CVC5::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()); - CVC5::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()); - CVC5::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); - CVC5::api::Result entailed = d_solver.checkEntailed(a); + cvc5::api::Result entailed = d_solver.checkEntailed(a); ASSERT_TRUE(entailed.isEntailed()); ASSERT_FALSE(entailed.isEntailmentUnknown()); - CVC5::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()); - CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/api/solver_black.cpp b/test/unit/api/solver_black.cpp index 8f15e9017..fef06fa88 100644 --- a/test/unit/api/solver_black.cpp +++ b/test/unit/api/solver_black.cpp @@ -16,7 +16,7 @@ #include "test_api.h" -namespace CVC5 { +namespace cvc5 { using namespace api; @@ -1422,7 +1422,7 @@ TEST_F(TestApiBlackSolver, getUnsatCore3) { d_solver.assertFormula(t); } - CVC5::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(CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/api/solver_white.cpp b/test/unit/api/solver_white.cpp index 66a6c70f1..25878f22d 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 CVC5 { +namespace cvc5 { using namespace api; @@ -54,4 +54,4 @@ TEST_F(TestApiWhiteSolver, getOp) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/api/sort_black.cpp b/test/unit/api/sort_black.cpp index f1ec0985a..e0507e749 100644 --- a/test/unit/api/sort_black.cpp +++ b/test/unit/api/sort_black.cpp @@ -16,7 +16,7 @@ #include "test_api.h" -namespace CVC5 { +namespace cvc5 { using namespace api; @@ -603,4 +603,4 @@ TEST_F(TestApiBlackSort, sortScopedToString) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/api/term_black.cpp b/test/unit/api/term_black.cpp index 7ac1a881e..117b15394 100644 --- a/test/unit/api/term_black.cpp +++ b/test/unit/api/term_black.cpp @@ -14,7 +14,7 @@ #include "test_api.h" -namespace CVC5 { +namespace cvc5 { using namespace api; @@ -848,4 +848,4 @@ TEST_F(TestApiBlackTerm, termScopedToString) ASSERT_EQ(x.toString(), "x"); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/api/term_white.cpp b/test/unit/api/term_white.cpp index de8e94227..e7b7a9cd6 100644 --- a/test/unit/api/term_white.cpp +++ b/test/unit/api/term_white.cpp @@ -14,7 +14,7 @@ #include "test_api.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/base/map_util_black.cpp b/test/unit/base/map_util_black.cpp index 76238ad04..3ba866f30 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 CVC5 { +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(CVC5::ContainsKey(map, "key")); - ASSERT_FALSE(CVC5::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(CVC5::ContainsKey(map, "key")); - ASSERT_FALSE(CVC5::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(CVC5::ContainsKey(map, "key")); - ASSERT_FALSE(CVC5::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(CVC5::ContainsKey(map, "key")); - ASSERT_FALSE(CVC5::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(CVC5::ContainsKey(set, "entry")); - ASSERT_FALSE(CVC5::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(CVC5::ContainsKey(const_set, "entry")); - ASSERT_FALSE(CVC5::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(CVC5::ContainsKey(set, "entry")); - ASSERT_FALSE(CVC5::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(CVC5::ContainsKey(const_set, "entry")); - ASSERT_FALSE(CVC5::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(CVC5::ContainsKey(map, "key")); - ASSERT_FALSE(CVC5::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(CVC5::ContainsKey(map, "key")); - ASSERT_FALSE(CVC5::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(CVC5::ContainsKey(map, "key")); - ASSERT_FALSE(CVC5::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(CVC5::ContainsKey(map, "key")); - ASSERT_FALSE(CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/context/cdhashmap_black.cpp b/test/unit/context/cdhashmap_black.cpp index 51d76070a..fbeae85b5 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 CVC5::context::CDMap<>. + ** \brief Black box testing of cvc5::context::CDMap<>. ** - ** Black box testing of CVC5::context::CDMap<>. + ** Black box testing of cvc5::context::CDMap<>. **/ #include <map> @@ -21,11 +21,11 @@ #include "context/cdlist.h" #include "test_context.h" -namespace CVC5 { +namespace cvc5 { namespace test { -using CVC5::context::CDHashMap; -using CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/context/cdhashmap_white.cpp b/test/unit/context/cdhashmap_white.cpp index 06bcd8d46..72e437250 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 CVC5::context::CDMap<>. + ** \brief White box testing of cvc5::context::CDMap<>. ** - ** White box testing of CVC5::context::CDMap<>. + ** White box testing of cvc5::context::CDMap<>. **/ #include "base/check.h" #include "context/cdhashmap.h" #include "test_context.h" -namespace CVC5 { +namespace cvc5 { using namespace context; @@ -44,4 +44,4 @@ TEST_F(TestContextWhiteCDHashMap, unreachable_save_and_restore) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/context/cdlist_black.cpp b/test/unit/context/cdlist_black.cpp index e903492ee..a3241d058 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 CVC5::context::CDList<>. + ** \brief Black box testing of cvc5::context::CDList<>. ** - ** Black box testing of CVC5::context::CDList<>. + ** Black box testing of cvc5::context::CDList<>. **/ #include <limits.h> @@ -24,7 +24,7 @@ #include "memory.h" #include "test_context.h" -namespace CVC5 { +namespace cvc5 { using namespace context; @@ -163,4 +163,4 @@ TEST_F(TestContextBlackCDList, pop_below_level_created) list.push_back(42); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/context/cdo_black.cpp b/test/unit/context/cdo_black.cpp index 033e60f57..c4e9b8dd5 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 CVC5::context::CDO<>. + ** \brief Black box testing of cvc5::context::CDO<>. ** - ** Black box testing of CVC5::context::CDO<>. + ** Black box testing of cvc5::context::CDO<>. **/ #include <iostream> @@ -22,7 +22,7 @@ #include "context/cdo.h" #include "test_context.h" -namespace CVC5 { +namespace cvc5 { using namespace context; @@ -48,4 +48,4 @@ TEST_F(TestContextBlackCDO, cdo) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/context/context_black.cpp b/test/unit/context/context_black.cpp index 7ec7ef6c8..0ad830162 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 CVC5::context::Context. + ** \brief Black box testing of cvc5::context::Context. ** - ** Black box testing of CVC5::context::Context. + ** Black box testing of cvc5::context::Context. **/ #include <iostream> @@ -22,7 +22,7 @@ #include "context/cdo.h" #include "test_context.h" -namespace CVC5 { +namespace cvc5 { using namespace context; @@ -241,4 +241,4 @@ TEST_F(TestContextBlack, top_scope_context_obj) #endif } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/context/context_mm_black.cpp b/test/unit/context/context_mm_black.cpp index 2dbec57b6..0f031ef5b 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 CVC5::context::ContextMemoryManager. + ** \brief Black box testing of cvc5::context::ContextMemoryManager. ** - ** Black box testing of CVC5::context::ContextMemoryManager. + ** Black box testing of cvc5::context::ContextMemoryManager. **/ #include <cstring> @@ -21,7 +21,7 @@ #include "context/context_mm.h" #include "test.h" -namespace CVC5 { +namespace cvc5 { using namespace context; @@ -104,4 +104,4 @@ TEST_F(TestContextBlackMM, push_pop) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/context/context_white.cpp b/test/unit/context/context_white.cpp index 6ec7ea3a1..7bda5d2da 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 CVC5::context::Context. + ** \brief White box testing of cvc5::context::Context. ** - ** White box testing of CVC5::context::Context. + ** White box testing of cvc5::context::Context. **/ #include "base/check.h" #include "context/cdo.h" #include "test_context.h" -namespace CVC5 { +namespace cvc5 { using namespace context; @@ -180,4 +180,4 @@ TEST_F(TestContextWhite, simple) ASSERT_EQ(c.d_ppContextObjPrev, &s->d_pContextObjList); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/main/interactive_shell_black.cpp b/test/unit/main/interactive_shell_black.cpp index 0ee485fc2..7ab337c09 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 CVC5::InteractiveShell. + ** \brief Black box testing of cvc5::InteractiveShell. ** - ** Black box testing of CVC5::InteractiveShell. + ** Black box testing of cvc5::InteractiveShell. **/ #include <sstream> @@ -27,7 +27,7 @@ #include "smt/command.h" #include "test.h" -namespace CVC5 { +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 CVC5::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<CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/memory.h b/test/unit/memory.h index 1341274dd..f9bdd7851 100644 --- a/test/unit/memory.h +++ b/test/unit/memory.h @@ -15,7 +15,7 @@ ** ** Use it like this (for example): ** - ** CVC5::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 CVC5 { +namespace cvc5 { namespace test { #ifndef CVC4_MEMORY_LIMITING_DISABLED @@ -87,7 +87,7 @@ class WithLimitedMemory { #endif } // namespace test -} // namespace CVC5 +} // 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 48f68159f..880bb85e4 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 CVC5::Attribute. + ** \brief Black box testing of cvc5::Attribute. ** - ** Black box testing of CVC5::Attribute. + ** Black box testing of cvc5::Attribute. **/ #include <sstream> @@ -23,7 +23,7 @@ #include "expr/node_value.h" #include "test_node.h" -namespace CVC5 { +namespace cvc5 { using namespace kind; using namespace smt; @@ -125,4 +125,4 @@ TEST_F(TestNodeBlackAttribute, bools) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/attribute_white.cpp b/test/unit/node/attribute_white.cpp index 75bc87893..59d9500c7 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 CVC5 { +namespace cvc5 { using namespace kind; using namespace smt; @@ -445,4 +445,4 @@ TEST_F(TestNodeWhiteAttribute, attributes) ASSERT_FALSE(unnamed.hasAttribute(VarNameAttr())); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/kind_black.cpp b/test/unit/node/kind_black.cpp index 9c497f026..defc3aa6f 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 CVC5::Kind. + ** \brief Black box testing of cvc5::Kind. ** - ** Black box testing of CVC5::Kind. + ** Black box testing of cvc5::Kind. **/ #include <iostream> @@ -21,7 +21,7 @@ #include "expr/kind.h" #include "test.h" -namespace CVC5 { +namespace cvc5 { using namespace kind; @@ -87,4 +87,4 @@ TEST_F(TestNodeBlackKind, output_concat) ASSERT_EQ(act.str(), exp.str()); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/kind_map_black.cpp b/test/unit/node/kind_map_black.cpp index 85c8fb2cd..7da3e5715 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 CVC5::KindMap + ** \brief Black box testing of cvc5::KindMap ** - ** Black box testing of CVC5::KindMap. + ** Black box testing of cvc5::KindMap. **/ #include <iostream> @@ -21,7 +21,7 @@ #include "expr/kind_map.h" #include "test.h" -namespace CVC5 { +namespace cvc5 { using namespace kind; @@ -45,4 +45,4 @@ TEST_F(TestNodeBlackKindMap, simple) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/node_algorithm_black.cpp b/test/unit/node/node_algorithm_black.cpp index 47f66f0c3..b9cac2169 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 CVC5 { +namespace cvc5 { using namespace expr; using namespace kind; @@ -199,4 +199,4 @@ TEST_F(TestNodeBlackNodeAlgorithm, match) ASSERT_EQ(subs[x], a); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/node_black.cpp b/test/unit/node/node_black.cpp index 7ae8a9434..5177ff453 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 CVC5::Node. + ** \brief Black box testing of cvc5::Node. ** - ** Black box testing of CVC5::Node. + ** Black box testing of cvc5::Node. **/ #include <algorithm> @@ -30,7 +30,7 @@ #include "test_node.h" #include "theory/rewriter.h" -namespace CVC5 { +namespace cvc5 { using namespace kind; @@ -784,4 +784,4 @@ TEST_F(TestNodeBlackNode, node_tnode_usage) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/node_builder_black.cpp b/test/unit/node/node_builder_black.cpp index 62410bcb7..39c5552df 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 CVC5::NodeBuilder. + ** \brief Black box testing of cvc5::NodeBuilder. ** - ** Black box testing of CVC5::NodeBuilder. + ** Black box testing of cvc5::NodeBuilder. **/ #include <limits.h> @@ -30,7 +30,7 @@ #define K 30u #define LARGE_K UINT_MAX / 40 -namespace CVC5 { +namespace cvc5 { using namespace kind; @@ -587,4 +587,4 @@ TEST_F(TestNodeBlackNodeBuilder, leftist_building) ASSERT_EQ(nexpected, n); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/node_manager_black.cpp b/test/unit/node/node_manager_black.cpp index 7866d87bd..5d21ff734 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 CVC5::NodeManager. + ** \brief Black box testing of cvc5::NodeManager. ** - ** Black box testing of CVC5::NodeManager. + ** Black box testing of cvc5::NodeManager. **/ #include <string> @@ -24,7 +24,7 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC5 { +namespace cvc5 { using namespace kind; using namespace expr; @@ -330,4 +330,4 @@ TEST_F(TestNodeBlackNodeManager, mkNode_too_many_children) #endif } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/node_manager_white.cpp b/test/unit/node/node_manager_white.cpp index 588c39181..dcdbc074f 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 CVC5::NodeManager. + ** \brief White box testing of cvc5::NodeManager. ** - ** White box testing of CVC5::NodeManager. + ** White box testing of cvc5::NodeManager. **/ #include <string> @@ -21,9 +21,9 @@ #include "util/integer.h" #include "util/rational.h" -namespace CVC5 { +namespace cvc5 { -using namespace CVC5::expr; +using namespace cvc5::expr; namespace test { @@ -81,4 +81,4 @@ TEST_F(TestNodeWhiteNodeManager, topological_sort) } } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/node_self_iterator_black.cpp b/test/unit/node/node_self_iterator_black.cpp index 0a0a877c3..43eebcda9 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 CVC5::expr::NodeSelfIterator + ** \brief Black box testing of cvc5::expr::NodeSelfIterator ** - ** Black box testing of CVC5::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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/node/node_traversal_black.cpp b/test/unit/node/node_traversal_black.cpp index c54be86ac..8366b1a63 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 CVC5 { +namespace cvc5 { using namespace kind; @@ -293,4 +293,4 @@ TEST_F(TestNodeBlackNodeTraversalPreorder, skip_if) ASSERT_EQ(actual, expected); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/node_white.cpp b/test/unit/node/node_white.cpp index d914c5dc2..20de9d3e4 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 CVC5::Node. + ** \brief White box testing of cvc5::Node. ** - ** White box testing of CVC5::Node. + ** White box testing of cvc5::Node. **/ #include <string> @@ -19,7 +19,7 @@ #include "base/check.h" #include "test_node.h" -namespace CVC5 { +namespace cvc5 { using namespace kind; using namespace expr; @@ -79,4 +79,4 @@ TEST_F(TestNodeWhiteNode, iterators) ASSERT_EQ(v[2], y); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/symbol_table_black.cpp b/test/unit/node/symbol_table_black.cpp index 27911c34b..7b01b520d 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 CVC5::SymbolTable + ** \brief Black box testing of cvc5::SymbolTable ** - ** Black box testing of CVC5::SymbolTable. + ** Black box testing of cvc5::SymbolTable. **/ #include <sstream> @@ -24,7 +24,7 @@ #include "expr/symbol_table.h" #include "test_api.h" -namespace CVC5 { +namespace cvc5 { using namespace kind; using namespace context; @@ -146,4 +146,4 @@ TEST_F(TestNodeBlackSymbolTable, bad_pop) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/type_cardinality_black.cpp b/test/unit/node/type_cardinality_black.cpp index e2aeced08..f0ee99a7d 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 CVC5 { +namespace cvc5 { using namespace kind; @@ -332,4 +332,4 @@ TEST_F(TestNodeBlackTypeCardinality, bitvectors) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/node/type_node_white.cpp b/test/unit/node/type_node_white.cpp index 37d80a9fa..c6f862e03 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/parser/parser_black.cpp b/test/unit/parser/parser_black.cpp index 827d7dd84..3c6d8b820 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 CVC5::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 CVC5::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 CVC5 { +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 CVC5::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<CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/parser/parser_builder_black.cpp b/test/unit/parser/parser_builder_black.cpp index 3ebd11b83..a83932b2f 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 CVC5::parser::ParserBuilder. + ** \brief Black box testing of cvc5::parser::ParserBuilder. ** - ** Black box testing of CVC5::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 CVC5 { +namespace cvc5 { using namespace parser; using namespace language::input; @@ -134,4 +134,4 @@ TEST_F(TestParseBlackParserBuilder, true_stream_input) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/preprocessing/pass_bv_gauss_white.cpp b/test/unit/preprocessing/pass_bv_gauss_white.cpp index 130d6b1cf..d313e01c7 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 CVC5 { +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 CVC5 +} // 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 cbd178576..662a53777 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 CVC5 { +namespace cvc5 { using namespace preprocessing::passes; @@ -47,4 +47,4 @@ TEST_F(TestPPWhiteForeignTheoryRewrite, simplify) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/printer/smt2_printer_black.cpp b/test/unit/printer/smt2_printer_black.cpp index 2f4d6fb38..03ab95083 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/prop/cnf_stream_white.cpp b/test/unit/prop/cnf_stream_white.cpp index 40f986d33..0529f209c 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 CVC5::prop::CnfStream. + ** \brief White box testing of cvc5::prop::CnfStream. ** - ** White box testing of CVC5::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 CVC5 { +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 CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/test.h b/test/unit/test.h index 1c5614488..11cefc66b 100644 --- a/test/unit/test.h +++ b/test/unit/test.h @@ -17,7 +17,7 @@ #include "gtest/gtest.h" -namespace CVC5 { +namespace cvc5 { namespace test { class TestInternal : public ::testing::Test @@ -25,5 +25,5 @@ class TestInternal : public ::testing::Test }; } // namespace test -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/test/unit/test_api.h b/test/unit/test_api.h index 033136524..7ad2e1e5c 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 CVC5 { +namespace cvc5 { namespace test { class TestApi : public ::testing::Test { protected: - CVC5::api::Solver d_solver; + cvc5::api::Solver d_solver; }; } // namespace test -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/test/unit/test_context.h b/test/unit/test_context.h index 024488fc4..0f21b2898 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 CVC5 { +namespace cvc5 { namespace test { class TestContext : public TestInternal { protected: - void SetUp() override { d_context.reset(new CVC5::context::Context()); } - std::unique_ptr<CVC5::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 CVC5 +} // namespace cvc5 #endif diff --git a/test/unit/test_node.h b/test/unit/test_node.h index 1aefbae45..359cc0b6f 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 CVC5 { +namespace cvc5 { namespace test { class TestNode : public TestInternal @@ -45,5 +45,5 @@ class TestNode : public TestInternal }; } // namespace test -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/test/unit/test_smt.h b/test/unit/test_smt.h index a6097b56c..a26e039e4 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 CVC5 { +namespace cvc5 { namespace test { /* -------------------------------------------------------------------------- */ @@ -99,7 +99,7 @@ inline std::ostream& operator<<(std::ostream& out, OutputChannelCallType type) } } -class DummyOutputChannel : public CVC5::theory::OutputChannel +class DummyOutputChannel : public cvc5::theory::OutputChannel { public: DummyOutputChannel() {} @@ -249,5 +249,5 @@ class DummyTheory : public theory::Theory /* -------------------------------------------------------------------------- */ } // namespace test -} // namespace CVC5 +} // namespace cvc5 #endif diff --git a/test/unit/theory/evaluator_white.cpp b/test/unit/theory/evaluator_white.cpp index 54976c7d7..2afaf3a48 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 CVC5 { +namespace cvc5 { using namespace theory; @@ -156,4 +156,4 @@ TEST_F(TestTheoryWhiteEvaluator, code) } } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/logic_info_white.cpp b/test/unit/theory/logic_info_white.cpp index 0c45cc4ed..5c18b7c98 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 CVC5::LogicInfo class + ** \brief Unit testing for cvc5::LogicInfo class ** - ** Unit testing for CVC5::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 CVC5 { +namespace cvc5 { using namespace theory; @@ -544,33 +544,33 @@ TEST_F(TestTheoryWhiteLogicInfo, default_logic) LogicInfo info; ASSERT_FALSE(info.isLocked()); - ASSERT_THROW(info.getLogicString(), CVC5::IllegalArgumentException); + ASSERT_THROW(info.getLogicString(), cvc5::IllegalArgumentException); ASSERT_THROW(info.isTheoryEnabled(THEORY_BUILTIN), - CVC5::IllegalArgumentException); + cvc5::IllegalArgumentException); ASSERT_THROW(info.isTheoryEnabled(THEORY_BOOL), - CVC5::IllegalArgumentException); - ASSERT_THROW(info.isTheoryEnabled(THEORY_UF), CVC5::IllegalArgumentException); + cvc5::IllegalArgumentException); + ASSERT_THROW(info.isTheoryEnabled(THEORY_UF), cvc5::IllegalArgumentException); ASSERT_THROW(info.isTheoryEnabled(THEORY_ARITH), - CVC5::IllegalArgumentException); + cvc5::IllegalArgumentException); ASSERT_THROW(info.isTheoryEnabled(THEORY_ARRAYS), - CVC5::IllegalArgumentException); - ASSERT_THROW(info.isTheoryEnabled(THEORY_BV), CVC5::IllegalArgumentException); + cvc5::IllegalArgumentException); + ASSERT_THROW(info.isTheoryEnabled(THEORY_BV), cvc5::IllegalArgumentException); ASSERT_THROW(info.isTheoryEnabled(THEORY_DATATYPES), - CVC5::IllegalArgumentException); + cvc5::IllegalArgumentException); ASSERT_THROW(info.isTheoryEnabled(THEORY_QUANTIFIERS), - 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); + 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(), 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.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), - CVC5::IllegalArgumentException); - ASSERT_THROW(info.enableIntegers(), CVC5::IllegalArgumentException); - ASSERT_THROW(info.disableReals(), CVC5::IllegalArgumentException); + cvc5::IllegalArgumentException); + ASSERT_THROW(info.enableIntegers(), cvc5::IllegalArgumentException); + ASSERT_THROW(info.disableReals(), cvc5::IllegalArgumentException); ASSERT_THROW(info.disableTheory(THEORY_ARITH), - CVC5::IllegalArgumentException); - ASSERT_THROW(info.disableTheory(THEORY_UF), CVC5::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 (CVC5::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 (CVC5::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 (CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/regexp_operation_black.cpp b/test/unit/theory/regexp_operation_black.cpp index b87701534..ed432ca2f 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 CVC5 { +namespace cvc5 { using namespace kind; using namespace theory; @@ -144,4 +144,4 @@ TEST_F(TestTheoryBlackRegexpOperation, star_wildcards) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/sequences_rewriter_white.cpp b/test/unit/theory/sequences_rewriter_white.cpp index 7a85ad13d..a1512d7de 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 CVC5 { +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(::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 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(::CVC5::String("")); - Node a = d_nodeManager->mkConst(::CVC5::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(::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 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(::CVC5::String("")); - Node a = d_nodeManager->mkConst(::CVC5::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(::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 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(::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 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(::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 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(::CVC5::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(::CVC5::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(::CVC5::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(::CVC5::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(::CVC5::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(::CVC5::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(::CVC5::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(::CVC5::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(::CVC5::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(::CVC5::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(::CVC5::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(::CVC5::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(::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 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(::CVC5::String("")); - Node a = d_nodeManager->mkConst(::CVC5::String("A")); - Node b = d_nodeManager->mkConst(::CVC5::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(::CVC5::String("")); - Node a = d_nodeManager->mkConst(::CVC5::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(::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 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(::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 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(::CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/strings_rewriter_white.cpp b/test/unit/theory/strings_rewriter_white.cpp index 94bf8b581..13ee14306 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 CVC5 { +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(::CVC5::String("A")); - Node bc = d_nodeManager->mkConst(::CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/theory_arith_white.cpp b/test/unit/theory/theory_arith_white.cpp index ac992f5c9..27ce7158a 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 CVC5 { +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 CVC5 +} // 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 09f5c2ae9..88a1412a7 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 CVC5 { +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); - CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/theory_bags_rewriter_white.cpp b/test/unit/theory/theory_bags_rewriter_white.cpp index a1cc2761a..586afd8b5 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 CVC5 { +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 CVC5 +} // 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 830169c8b..2948c2e9e 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 CVC5 { +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); - CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/theory_black.cpp b/test/unit/theory/theory_black.cpp index ddd43a063..de3cdaf4d 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 CVC5::theory + ** \brief Black box testing of cvc5::theory ** - ** Black box testing of CVC5::theory + ** Black box testing of cvc5::theory **/ #include <sstream> @@ -23,7 +23,7 @@ #include "test_smt.h" #include "theory/rewriter.h" -namespace CVC5 { +namespace cvc5 { using namespace kind; using namespace context; @@ -129,4 +129,4 @@ TEST_F(TestTheoryBlack, array_const) ASSERT_TRUE(arr2.isConst()); } } // namespace test -} // namespace CVC5 +} // 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 247f5428f..df1c3755b 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 CVC5 { +namespace cvc5 { using namespace kind; using namespace theory; @@ -44,4 +44,4 @@ class TestTheoryWhiteBvIntblaster : public TestSmtNoFinishInit Node d_one; }; } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/theory_bv_rewriter_white.cpp b/test/unit/theory/theory_bv_rewriter_white.cpp index c7262117c..e0c2dad04 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/theory_bv_white.cpp b/test/unit/theory/theory_bv_white.cpp index 020c7d0a5..bcd91f9b8 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 CVC5 { +namespace cvc5 { using namespace theory; using namespace theory::bv; @@ -93,4 +93,4 @@ TEST_F(TestTheoryWhiteBv, mkUmulo) } } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/theory_engine_white.cpp b/test/unit/theory/theory_engine_white.cpp index ff2f3a836..57741b98d 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 CVC5::theory::Theory. + ** \brief White box testing of cvc5::theory::Theory. ** - ** White box testing of CVC5::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 CVC5 { +namespace cvc5 { using namespace theory; using namespace expr; @@ -183,4 +183,4 @@ TEST_F(TestTheoryWhiteEngine, rewrite_rules) } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/theory_int_opt_white.cpp b/test/unit/theory/theory_int_opt_white.cpp index fc20d6d73..6111c2640 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 CVC5 { +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 CVC5 +} // 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 715eea5f9..19968cbdd 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 CVC5 { +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 CVC5 +} // 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 4ad3f04ef..64ba39e7f 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 CVC5 { +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 CVC5 +} // 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 adee0c266..f20cf50d2 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 CVC5::theory::sets::SetsTypeEnumerator + ** \brief White box testing of cvc5::theory::sets::SetsTypeEnumerator ** - ** White box testing of CVC5::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 CVC5 { +namespace cvc5 { using namespace theory; using namespace kind; @@ -152,4 +152,4 @@ TEST_F(TestTheoryWhiteSetsTypeEnumerator, bv) ASSERT_TRUE(setEnumerator.isFinished()); } } // namespace test -} // namespace CVC5 +} // 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 22b0a09d6..899a75ae9 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 CVC5 { +namespace cvc5 { -using namespace CVC5::api; +using namespace cvc5::api; namespace test { @@ -83,4 +83,4 @@ TEST_F(TestTheoryWhiteSetsTypeRuleInternal, singleton_node) ASSERT_TRUE(n.isConst()); } } // namespace test -} // namespace CVC5 +} // 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 06a86b844..33543cc42 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 CVC5 { +namespace cvc5 { using namespace theory::strings; @@ -59,4 +59,4 @@ TEST_F(TestTheoryBlackStringsSkolemCache, mkSkolemCached) } } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/theory_strings_word_white.cpp b/test/unit/theory/theory_strings_word_white.cpp index 03b9ed4c2..1ea73c0cc 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/theory_white.cpp b/test/unit/theory/theory_white.cpp index 41abdd6d1..cb6e5ebfe 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 CVC5::theory::Theory. + ** \brief Black box testing of cvc5::theory::Theory. ** - ** Black box testing of CVC5::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 CVC5 { +namespace cvc5 { using namespace theory; using namespace expr; @@ -109,4 +109,4 @@ TEST_F(TestTheoryWhite, outputChannel) d_outputChannel.d_callHistory.clear(); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/theory/type_enumerator_white.cpp b/test/unit/theory/type_enumerator_white.cpp index 2e018f9cf..6cab15b27 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 CVC5::theory::TypeEnumerator + ** \brief White box testing of cvc5::theory::TypeEnumerator ** - ** White box testing of CVC5::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 CVC5 { +namespace cvc5 { using namespace theory; using namespace kind; @@ -332,4 +332,4 @@ TEST_F(TestTheoryWhiteTypeEnumerator, bv) ASSERT_THROW(*++te, NoMoreValuesException); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/util/array_store_all_white.cpp b/test/unit/util/array_store_all_white.cpp index 5be00263d..b82807835 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 CVC5::ArrayStoreAll + ** \brief Black box testing of cvc5::ArrayStoreAll ** - ** Black box testing of CVC5::ArrayStoreAll. + ** Black box testing of cvc5::ArrayStoreAll. **/ #include "expr/array_store_all.h" #include "test_smt.h" -namespace CVC5 { +namespace cvc5 { namespace test { class TestUtilWhiteArrayStoreAll : public TestSmt @@ -75,4 +75,4 @@ TEST_F(TestUtilWhiteArrayStoreAll, const_error) IllegalArgumentException); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/util/assert_white.cpp b/test/unit/util/assert_white.cpp index a64bf275d..bab612b62 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 CVC5::Configuration. + ** \brief White box testing of cvc5::Configuration. ** - ** White box testing of CVC5::Configuration. + ** White box testing of cvc5::Configuration. **/ #include <cstring> @@ -20,7 +20,7 @@ #include "base/check.h" #include "test.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/util/binary_heap_black.cpp b/test/unit/util/binary_heap_black.cpp index 0b52b6d14..c00aeaeb2 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 CVC5::BinaryHeap + ** \brief Black box testing of cvc5::BinaryHeap ** - ** Black box testing of CVC5::BinaryHeap. + ** Black box testing of cvc5::BinaryHeap. **/ #include <iostream> @@ -20,7 +20,7 @@ #include "test.h" #include "util/bin_heap.h" -namespace CVC5 { +namespace cvc5 { namespace test { class TestUtilBlackBinaryHeap : public TestInternal @@ -230,4 +230,4 @@ TEST_F(TestUtilBlackBinaryHeap, large_heap) ASSERT_TRUE(heap.empty()); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/util/bitvector_black.cpp b/test/unit/util/bitvector_black.cpp index b26d8a1c6..61dfa8101 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 CVC5::BitVector + ** \brief Black box testing of cvc5::BitVector ** - ** Black box testing of CVC5::BitVector. + ** Black box testing of cvc5::BitVector. **/ #include <sstream> @@ -19,7 +19,7 @@ #include "test.h" #include "util/bitvector.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/util/boolean_simplification_black.cpp b/test/unit/util/boolean_simplification_black.cpp index cce2518c4..baacbce5a 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 CVC5::BooleanSimplification + ** \brief Black box testing of cvc5::BooleanSimplification ** - ** Black box testing of CVC5::BooleanSimplification. + ** Black box testing of cvc5::BooleanSimplification. **/ #include <algorithm> @@ -26,7 +26,7 @@ #include "smt_util/boolean_simplification.h" #include "test_node.h" -namespace CVC5 { +namespace cvc5 { namespace test { class TestUtilBlackBooleanSimplification : public TestNode @@ -248,4 +248,4 @@ TEST_F(TestUtilBlackBooleanSimplification, simplifyConflict) #endif } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/util/cardinality_black.cpp b/test/unit/util/cardinality_black.cpp index b4b6ab6a5..f4b2f3ac4 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 CVC5::Cardinality + ** \brief Public-box testing of cvc5::Cardinality ** - ** Public-box testing of CVC5::Cardinality. + ** Public-box testing of cvc5::Cardinality. **/ #include <sstream> @@ -22,7 +22,7 @@ #include "util/cardinality.h" #include "util/integer.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/util/check_white.cpp b/test/unit/util/check_white.cpp index 4985bced3..4909e3a58 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 CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/util/configuration_black.cpp b/test/unit/util/configuration_black.cpp index a7c5c2703..35bfd4d78 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 CVC5::Configuration. + ** \brief Black box testing of cvc5::Configuration. ** - ** Black box testing of CVC5::Configuration. + ** Black box testing of cvc5::Configuration. **/ #include "base/configuration.h" #include "test.h" -namespace CVC5 { +namespace cvc5 { namespace test { class TestUtilBlackConfiguration : public TestInternal @@ -96,4 +96,4 @@ TEST_F(TestUtilBlackConfiguration, about) Configuration::about(); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/util/datatype_black.cpp b/test/unit/util/datatype_black.cpp index b486d91e9..37cfe0cfa 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 CVC5::DType + ** \brief Black box testing of cvc5::DType ** - ** Black box testing of CVC5::DType. + ** Black box testing of cvc5::DType. **/ #include <sstream> @@ -21,7 +21,7 @@ #include "expr/type_node.h" #include "test_smt.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/util/exception_black.cpp b/test/unit/util/exception_black.cpp index 7216c0b8c..2884dbfb8 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 CVC5::Exception. + ** \brief Black box testing of cvc5::Exception. ** - ** Black box testing of CVC5::Exception. + ** Black box testing of cvc5::Exception. **/ #include <iostream> @@ -20,14 +20,14 @@ #include "base/exception.h" #include "test.h" -namespace CVC5 { +namespace cvc5 { namespace test { class TestUtilBlackException : public TestInternal { }; -// CVC5::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 CVC5 +} // namespace cvc5 diff --git a/test/unit/util/floatingpoint_black.cpp b/test/unit/util/floatingpoint_black.cpp index 391c656f3..0fe48928f 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 CVC5::FloatingPoint. + ** \brief Black box testing of cvc5::FloatingPoint. ** - ** Black box testing of CVC5::FloatingPoint. + ** Black box testing of cvc5::FloatingPoint. **/ #include "test.h" #include "util/floatingpoint.h" -namespace CVC5 { +namespace cvc5 { namespace test { class TestUtilBlackFloatingPoint : public TestInternal @@ -136,4 +136,4 @@ TEST_F(TestUtilBlackFloatingPoint, makeMaxNormal) ASSERT_TRUE(mfp128.isNormal()); } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/util/integer_black.cpp b/test/unit/util/integer_black.cpp index fc92fa0d2..1a3e75256 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 CVC5::Integer. + ** \brief Black box testing of cvc5::Integer. ** - ** Black box testing of CVC5::Integer. + ** Black box testing of cvc5::Integer. **/ #include <limits> @@ -21,7 +21,7 @@ #include "test.h" #include "util/integer.h" -namespace CVC5 { +namespace cvc5 { namespace test { class TestUtilBlackInteger : public TestInternal @@ -564,4 +564,4 @@ TEST_F(TestUtilBlackInteger, modInverse) } } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/util/integer_white.cpp b/test/unit/util/integer_white.cpp index 3b5363dda..117f82195 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 CVC5::Integer. + ** \brief White box testing of cvc5::Integer. ** - ** White box testing of CVC5::Integer. + ** White box testing of cvc5::Integer. **/ #include <sstream> @@ -19,7 +19,7 @@ #include "test.h" #include "util/integer.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/util/output_black.cpp b/test/unit/util/output_black.cpp index f5c973849..e951dd114 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 CVC5 { +namespace cvc5 { namespace test { class TestUtilBlackOutput : public TestInternal @@ -241,4 +241,4 @@ TEST_F(TestUtilBlackOutput, simple_print) #endif /* CVC4_MUZZLE */ } } // namespace test -} // namespace CVC5 +} // namespace cvc5 diff --git a/test/unit/util/rational_black.cpp b/test/unit/util/rational_black.cpp index e6dee5d55..d3b116d26 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 CVC5::Rational. + ** \brief Black box testing of cvc5::Rational. ** - ** Black box testing of CVC5::Rational. + ** Black box testing of cvc5::Rational. **/ #include <sstream> @@ -19,7 +19,7 @@ #include "test.h" #include "util/rational.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/util/rational_white.cpp b/test/unit/util/rational_white.cpp index 542a43990..c5b52e3c8 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 CVC5::Rational. + ** \brief White box testing of cvc5::Rational. ** - ** White box testing of CVC5::Rational. + ** White box testing of cvc5::Rational. **/ #include <sstream> @@ -19,7 +19,7 @@ #include "test.h" #include "util/rational.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/util/real_algebraic_number_black.cpp b/test/unit/util/real_algebraic_number_black.cpp index 4300b709c..507be5ea0 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 CVC5::RealAlgebraicNumber. + ** \brief Black box testing of cvc5::RealAlgebraicNumber. ** - ** Black box testing of CVC5::RealAlgebraicNumber. + ** Black box testing of cvc5::RealAlgebraicNumber. **/ #include "test.h" #include "util/real_algebraic_number.h" -namespace CVC5 { +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 CVC5 +} // namespace cvc5 diff --git a/test/unit/util/stats_black.cpp b/test/unit/util/stats_black.cpp index f8a14d9b2..2ee64ab33 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 CVC5::Stat and associated classes + ** \brief Black box testing of cvc5::Stat and associated classes ** - ** Black box testing of CVC5::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 CVC5 { +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<CVC5::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 CVC5 +} // namespace cvc5 |