The public cvc5 API now lives in the cvc5 namespace. All internal parts were moved into the (new) internal namespace.
The final hierarchy will be as follows:
cvc5
~~ public API
::context
::internal
::parser
::main
After this PR it will be:
cvc5
~~ public API
::internal
::context
::main
::parser
run: |
if [[ "${{ inputs.check-install }}" != "true" ]]; then exit 0; fi
make -j${{ env.num_proc }} install
- echo -e "#include <cvc5/cvc5.h>\nint main() { cvc5::api::Solver s; return 0; }" > /tmp/test.cpp
+ echo -e "#include <cvc5/cvc5.h>\nint main() { cvc5::Solver s; return 0; }" > /tmp/test.cpp
g++ -std=c++17 /tmp/test.cpp -I install/include -L install/lib -lcvc5
working-directory: ${{ inputs.build-dir }}
#include <iostream>
using namespace std;
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include <iostream>
using namespace std;
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include <iostream>
using namespace std;
-using namespace cvc5::api;
+using namespace cvc5;
void prefixPrintGetValue(Solver& slv, Term t, int level = 0)
{
#include <iostream>
-using namespace cvc5::api;
+using namespace cvc5;
void test(Solver& slv, Sort& consListSort)
{
#include <iostream>
using namespace std;
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include <cassert>
using namespace std;
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include <iostream>
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include <cvc5/cvc5.h>
using namespace std;
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include <iostream>
#include <numeric>
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include <iostream>
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include <iostream>
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include <iostream>
using namespace std;
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include <iostream>
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include "utils.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include "utils.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include "utils.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include <cvc5/cvc5.h>
using namespace std;
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
* @param body the function body
* @return a string version of define-fun
*/
-std::string defineFunToString(const cvc5::api::Term& f,
- const std::vector<cvc5::api::Term> params,
- const cvc5::api::Term body)
+std::string defineFunToString(const cvc5::Term& f,
+ const std::vector<cvc5::Term> params,
+ const cvc5::Term body)
{
-
- cvc5::api::Sort sort = f.getSort();
+ cvc5::Sort sort = f.getSort();
if (sort.isFunction())
{
sort = sort.getFunctionCodomainSort();
return ss.str();
}
-void printSynthSolutions(const std::vector<cvc5::api::Term>& terms,
- const std::vector<cvc5::api::Term>& sols)
+void printSynthSolutions(const std::vector<cvc5::Term>& terms,
+ const std::vector<cvc5::Term>& sols)
{
std::cout << '(' << std::endl;
for (size_t i = 0, n = terms.size(); i < n; ++i)
{
- std::vector<cvc5::api::Term> params;
- cvc5::api::Term body;
- if (sols[i].getKind() == cvc5::api::LAMBDA)
+ std::vector<cvc5::Term> params;
+ cvc5::Term body;
+ if (sols[i].getKind() == cvc5::LAMBDA)
{
params.insert(params.end(), sols[i][0].begin(), sols[i][0].end());
body = sols[i][1];
* @param terms the terms for which the synthesis solutions were retrieved
* @param sols the synthesis solutions of the given terms
*/
-void printSynthSolutions(const std::vector<cvc5::api::Term>& terms,
- const std::vector<cvc5::api::Term>& sols);
+void printSynthSolutions(const std::vector<cvc5::Term>& terms,
+ const std::vector<cvc5::Term>& sols);
#endif // CVC5__UTILS_H
// Create the expression manager
Options options;
options.setInputLanguage(language::input::LANG_SMTLIB_V2);
- std::unique_ptr<api::Solver> solver =
- std::unique_ptr<api::Solver>(new api::Solver(&options));
+ std::unique_ptr<Solver> solver =
+ std::unique_ptr<Solver>(new Solver(&options));
cout << language::SetLanguage(language::output::LANG_SMTLIB_V2)
<< expr::ExprSetDepth(-1);
// Create the expression manager
Options options;
options.setInputLanguage(language::input::LANG_SMTLIB_V2);
- std::unique_ptr<api::Solver> solver =
- std::unique_ptr<api::Solver>(new api::Solver(&options));
+ std::unique_ptr<Solver> solver =
+ std::unique_ptr<Solver>(new Solver(&options));
// Create the parser
ParserBuilder parserBuilder(solver.get(), input, options);
Options options;
options.setInputLanguage(language::input::LANG_SMTLIB_V2);
options.setOutputLanguage(language::output::LANG_SMTLIB_V2);
- std::unique_ptr<api::Solver> solver =
- std::unique_ptr<api::Solver>(new api::Solver(&options));
+ std::unique_ptr<Solver> solver =
+ std::unique_ptr<Solver>(new Solver(&options));
cout << expr::ExprDag(0) << expr::ExprSetDepth(-1);
// Create the expression manager
Options options;
options.setInputLanguage(language::input::LANG_SMTLIB_V2);
- std::unique_ptr<api::Solver> solver =
- std::unique_ptr<api::Solver>(new api::Solver(&options));
+ std::unique_ptr<Solver> solver =
+ std::unique_ptr<Solver>(new Solver(&options));
// Create the parser
ParserBuilder parserBuilder(solver.get(), input, options);
// Create the expression manager
Options options;
options.setInputLanguage(language::input::LANG_SMTLIB_V2);
- std::unique_ptr<api::Solver> solver =
- std::unique_ptr<api::Solver>(new api::Solver(&options));
+ std::unique_ptr<Solver> solver =
+ std::unique_ptr<Solver>(new Solver(&options));
// Create the parser
ParserBuilder parserBuilder(solver.get(), input, options);
// Create the expression manager
Options options;
options.setInputLanguage(language::input::LANG_SMTLIB_V2);
- std::unique_ptr<api::Solver> solver =
- std::unique_ptr<api::Solver>(new api::Solver(&options));
+ std::unique_ptr<Solver> solver =
+ std::unique_ptr<Solver>(new Solver(&options));
// Create the parser
ParserBuilder parserBuilder(solver.get(), input, options);
// Create the expression manager
Options options;
options.setInputLanguage(language::input::LANG_SMTLIB_V2);
- std::unique_ptr<api::Solver> solver =
- std::unique_ptr<api::Solver>(new api::Solver(&options));
+ std::unique_ptr<Solver> solver =
+ std::unique_ptr<Solver>(new Solver(&options));
// Create the parser
ParserBuilder parserBuilder(solver.get(), input, options);
options.setInputLanguage(language::input::LANG_SMTLIB_V2);
cout << language::SetLanguage(language::output::LANG_SMTLIB_V2);
// cout << Expr::dag(0);
- std::unique_ptr<api::Solver> solver =
- std::unique_ptr<api::Solver>(new api::Solver(&options));
+ std::unique_ptr<Solver> solver =
+ std::unique_ptr<Solver>(new Solver(&options));
Mapper m(solver->getExprManager());
#include <iostream>
-using namespace cvc5::api;
+using namespace cvc5;
int main() {
Solver slv;
#include <iostream>
-using namespace cvc5::api;
+using namespace cvc5;
int main() {
Solver slv;
Options opts;
opts.setInputLanguage(fromLang);
ExprManager exprMgr(opts);
- std::unique_ptr<api::Solver> solver =
- std::unique_ptr<api::Solver>(new api::Solver(&opts));
+ std::unique_ptr<Solver> solver = std::unique_ptr<Solver>(new Solver(&opts));
ParserBuilder parserBuilder(solver.get(), filename, opts);
if(!strcmp(filename, "-")) {
parserBuilder.withFilename("<stdin>");
#include "util/utility.h"
namespace cvc5 {
-namespace api {
/* -------------------------------------------------------------------------- */
/* APIStatistics */
struct APIStatistics
{
- HistogramStat<TypeConstant> d_consts;
- HistogramStat<TypeConstant> d_vars;
- HistogramStat<Kind> d_terms;
+ internal::HistogramStat<internal::TypeConstant> d_consts;
+ internal::HistogramStat<internal::TypeConstant> d_vars;
+ internal::HistogramStat<Kind> d_terms;
};
/* -------------------------------------------------------------------------- */
}
/* Mapping from external (API) kind to internal kind. */
-const static std::unordered_map<Kind, std::pair<cvc5::Kind, std::string>>
+const static std::unordered_map<Kind, std::pair<internal::Kind, std::string>>
s_kinds{
- KIND_ENUM(INTERNAL_KIND, cvc5::Kind::UNDEFINED_KIND),
- KIND_ENUM(UNDEFINED_KIND, cvc5::Kind::UNDEFINED_KIND),
- KIND_ENUM(NULL_TERM, cvc5::Kind::NULL_EXPR),
+ KIND_ENUM(INTERNAL_KIND, internal::Kind::UNDEFINED_KIND),
+ KIND_ENUM(UNDEFINED_KIND, internal::Kind::UNDEFINED_KIND),
+ KIND_ENUM(NULL_TERM, internal::Kind::NULL_EXPR),
/* Builtin ---------------------------------------------------------- */
KIND_ENUM(UNINTERPRETED_SORT_VALUE,
- cvc5::Kind::UNINTERPRETED_SORT_VALUE),
- KIND_ENUM(EQUAL, cvc5::Kind::EQUAL),
- KIND_ENUM(DISTINCT, cvc5::Kind::DISTINCT),
- KIND_ENUM(CONSTANT, cvc5::Kind::VARIABLE),
- KIND_ENUM(VARIABLE, cvc5::Kind::BOUND_VARIABLE),
- KIND_ENUM(SEXPR, cvc5::Kind::SEXPR),
- KIND_ENUM(LAMBDA, cvc5::Kind::LAMBDA),
- KIND_ENUM(WITNESS, cvc5::Kind::WITNESS),
+ internal::Kind::UNINTERPRETED_SORT_VALUE),
+ KIND_ENUM(EQUAL, internal::Kind::EQUAL),
+ KIND_ENUM(DISTINCT, internal::Kind::DISTINCT),
+ KIND_ENUM(CONSTANT, internal::Kind::VARIABLE),
+ KIND_ENUM(VARIABLE, internal::Kind::BOUND_VARIABLE),
+ KIND_ENUM(SEXPR, internal::Kind::SEXPR),
+ KIND_ENUM(LAMBDA, internal::Kind::LAMBDA),
+ KIND_ENUM(WITNESS, internal::Kind::WITNESS),
/* Boolean ---------------------------------------------------------- */
- KIND_ENUM(CONST_BOOLEAN, cvc5::Kind::CONST_BOOLEAN),
- KIND_ENUM(NOT, cvc5::Kind::NOT),
- KIND_ENUM(AND, cvc5::Kind::AND),
- KIND_ENUM(IMPLIES, cvc5::Kind::IMPLIES),
- KIND_ENUM(OR, cvc5::Kind::OR),
- KIND_ENUM(XOR, cvc5::Kind::XOR),
- KIND_ENUM(ITE, cvc5::Kind::ITE),
+ KIND_ENUM(CONST_BOOLEAN, internal::Kind::CONST_BOOLEAN),
+ KIND_ENUM(NOT, internal::Kind::NOT),
+ KIND_ENUM(AND, internal::Kind::AND),
+ KIND_ENUM(IMPLIES, internal::Kind::IMPLIES),
+ KIND_ENUM(OR, internal::Kind::OR),
+ KIND_ENUM(XOR, internal::Kind::XOR),
+ KIND_ENUM(ITE, internal::Kind::ITE),
/* UF --------------------------------------------------------------- */
- KIND_ENUM(APPLY_UF, cvc5::Kind::APPLY_UF),
- KIND_ENUM(CARDINALITY_CONSTRAINT, cvc5::Kind::CARDINALITY_CONSTRAINT),
- KIND_ENUM(HO_APPLY, cvc5::Kind::HO_APPLY),
+ KIND_ENUM(APPLY_UF, internal::Kind::APPLY_UF),
+ KIND_ENUM(CARDINALITY_CONSTRAINT,
+ internal::Kind::CARDINALITY_CONSTRAINT),
+ KIND_ENUM(HO_APPLY, internal::Kind::HO_APPLY),
/* Arithmetic ------------------------------------------------------- */
- KIND_ENUM(ADD, cvc5::Kind::ADD),
- KIND_ENUM(MULT, cvc5::Kind::MULT),
- KIND_ENUM(IAND, cvc5::Kind::IAND),
- KIND_ENUM(POW2, cvc5::Kind::POW2),
- KIND_ENUM(SUB, cvc5::Kind::SUB),
- KIND_ENUM(NEG, cvc5::Kind::NEG),
- KIND_ENUM(DIVISION, cvc5::Kind::DIVISION),
- KIND_ENUM(INTS_DIVISION, cvc5::Kind::INTS_DIVISION),
- KIND_ENUM(INTS_MODULUS, cvc5::Kind::INTS_MODULUS),
- KIND_ENUM(ABS, cvc5::Kind::ABS),
- KIND_ENUM(DIVISIBLE, cvc5::Kind::DIVISIBLE),
- KIND_ENUM(POW, cvc5::Kind::POW),
- KIND_ENUM(EXPONENTIAL, cvc5::Kind::EXPONENTIAL),
- KIND_ENUM(SINE, cvc5::Kind::SINE),
- KIND_ENUM(COSINE, cvc5::Kind::COSINE),
- KIND_ENUM(TANGENT, cvc5::Kind::TANGENT),
- KIND_ENUM(COSECANT, cvc5::Kind::COSECANT),
- KIND_ENUM(SECANT, cvc5::Kind::SECANT),
- KIND_ENUM(COTANGENT, cvc5::Kind::COTANGENT),
- KIND_ENUM(ARCSINE, cvc5::Kind::ARCSINE),
- KIND_ENUM(ARCCOSINE, cvc5::Kind::ARCCOSINE),
- KIND_ENUM(ARCTANGENT, cvc5::Kind::ARCTANGENT),
- KIND_ENUM(ARCCOSECANT, cvc5::Kind::ARCCOSECANT),
- KIND_ENUM(ARCSECANT, cvc5::Kind::ARCSECANT),
- KIND_ENUM(ARCCOTANGENT, cvc5::Kind::ARCCOTANGENT),
- KIND_ENUM(SQRT, cvc5::Kind::SQRT),
- KIND_ENUM(CONST_RATIONAL, cvc5::Kind::CONST_RATIONAL),
- KIND_ENUM(LT, cvc5::Kind::LT),
- KIND_ENUM(LEQ, cvc5::Kind::LEQ),
- KIND_ENUM(GT, cvc5::Kind::GT),
- KIND_ENUM(GEQ, cvc5::Kind::GEQ),
- KIND_ENUM(IS_INTEGER, cvc5::Kind::IS_INTEGER),
- KIND_ENUM(TO_INTEGER, cvc5::Kind::TO_INTEGER),
- KIND_ENUM(TO_REAL, cvc5::Kind::TO_REAL),
- KIND_ENUM(PI, cvc5::Kind::PI),
+ KIND_ENUM(ADD, internal::Kind::ADD),
+ KIND_ENUM(MULT, internal::Kind::MULT),
+ KIND_ENUM(IAND, internal::Kind::IAND),
+ KIND_ENUM(POW2, internal::Kind::POW2),
+ KIND_ENUM(SUB, internal::Kind::SUB),
+ KIND_ENUM(NEG, internal::Kind::NEG),
+ KIND_ENUM(DIVISION, internal::Kind::DIVISION),
+ KIND_ENUM(INTS_DIVISION, internal::Kind::INTS_DIVISION),
+ KIND_ENUM(INTS_MODULUS, internal::Kind::INTS_MODULUS),
+ KIND_ENUM(ABS, internal::Kind::ABS),
+ KIND_ENUM(DIVISIBLE, internal::Kind::DIVISIBLE),
+ KIND_ENUM(POW, internal::Kind::POW),
+ KIND_ENUM(EXPONENTIAL, internal::Kind::EXPONENTIAL),
+ KIND_ENUM(SINE, internal::Kind::SINE),
+ KIND_ENUM(COSINE, internal::Kind::COSINE),
+ KIND_ENUM(TANGENT, internal::Kind::TANGENT),
+ KIND_ENUM(COSECANT, internal::Kind::COSECANT),
+ KIND_ENUM(SECANT, internal::Kind::SECANT),
+ KIND_ENUM(COTANGENT, internal::Kind::COTANGENT),
+ KIND_ENUM(ARCSINE, internal::Kind::ARCSINE),
+ KIND_ENUM(ARCCOSINE, internal::Kind::ARCCOSINE),
+ KIND_ENUM(ARCTANGENT, internal::Kind::ARCTANGENT),
+ KIND_ENUM(ARCCOSECANT, internal::Kind::ARCCOSECANT),
+ KIND_ENUM(ARCSECANT, internal::Kind::ARCSECANT),
+ KIND_ENUM(ARCCOTANGENT, internal::Kind::ARCCOTANGENT),
+ KIND_ENUM(SQRT, internal::Kind::SQRT),
+ KIND_ENUM(CONST_RATIONAL, internal::Kind::CONST_RATIONAL),
+ KIND_ENUM(LT, internal::Kind::LT),
+ KIND_ENUM(LEQ, internal::Kind::LEQ),
+ KIND_ENUM(GT, internal::Kind::GT),
+ KIND_ENUM(GEQ, internal::Kind::GEQ),
+ KIND_ENUM(IS_INTEGER, internal::Kind::IS_INTEGER),
+ KIND_ENUM(TO_INTEGER, internal::Kind::TO_INTEGER),
+ KIND_ENUM(TO_REAL, internal::Kind::TO_REAL),
+ KIND_ENUM(PI, internal::Kind::PI),
/* BV --------------------------------------------------------------- */
- KIND_ENUM(CONST_BITVECTOR, cvc5::Kind::CONST_BITVECTOR),
- KIND_ENUM(BITVECTOR_CONCAT, cvc5::Kind::BITVECTOR_CONCAT),
- KIND_ENUM(BITVECTOR_AND, cvc5::Kind::BITVECTOR_AND),
- KIND_ENUM(BITVECTOR_OR, cvc5::Kind::BITVECTOR_OR),
- KIND_ENUM(BITVECTOR_XOR, cvc5::Kind::BITVECTOR_XOR),
- KIND_ENUM(BITVECTOR_NOT, cvc5::Kind::BITVECTOR_NOT),
- KIND_ENUM(BITVECTOR_NAND, cvc5::Kind::BITVECTOR_NAND),
- KIND_ENUM(BITVECTOR_NOR, cvc5::Kind::BITVECTOR_NOR),
- KIND_ENUM(BITVECTOR_XNOR, cvc5::Kind::BITVECTOR_XNOR),
- KIND_ENUM(BITVECTOR_COMP, cvc5::Kind::BITVECTOR_COMP),
- KIND_ENUM(BITVECTOR_MULT, cvc5::Kind::BITVECTOR_MULT),
- KIND_ENUM(BITVECTOR_ADD, cvc5::Kind::BITVECTOR_ADD),
- KIND_ENUM(BITVECTOR_SUB, cvc5::Kind::BITVECTOR_SUB),
- KIND_ENUM(BITVECTOR_NEG, cvc5::Kind::BITVECTOR_NEG),
- KIND_ENUM(BITVECTOR_UDIV, cvc5::Kind::BITVECTOR_UDIV),
- KIND_ENUM(BITVECTOR_UREM, cvc5::Kind::BITVECTOR_UREM),
- KIND_ENUM(BITVECTOR_SDIV, cvc5::Kind::BITVECTOR_SDIV),
- KIND_ENUM(BITVECTOR_SREM, cvc5::Kind::BITVECTOR_SREM),
- KIND_ENUM(BITVECTOR_SMOD, cvc5::Kind::BITVECTOR_SMOD),
- KIND_ENUM(BITVECTOR_SHL, cvc5::Kind::BITVECTOR_SHL),
- KIND_ENUM(BITVECTOR_LSHR, cvc5::Kind::BITVECTOR_LSHR),
- KIND_ENUM(BITVECTOR_ASHR, cvc5::Kind::BITVECTOR_ASHR),
- KIND_ENUM(BITVECTOR_ULT, cvc5::Kind::BITVECTOR_ULT),
- KIND_ENUM(BITVECTOR_ULE, cvc5::Kind::BITVECTOR_ULE),
- KIND_ENUM(BITVECTOR_UGT, cvc5::Kind::BITVECTOR_UGT),
- KIND_ENUM(BITVECTOR_UGE, cvc5::Kind::BITVECTOR_UGE),
- KIND_ENUM(BITVECTOR_SLT, cvc5::Kind::BITVECTOR_SLT),
- KIND_ENUM(BITVECTOR_SLE, cvc5::Kind::BITVECTOR_SLE),
- KIND_ENUM(BITVECTOR_SGT, cvc5::Kind::BITVECTOR_SGT),
- KIND_ENUM(BITVECTOR_SGE, cvc5::Kind::BITVECTOR_SGE),
- KIND_ENUM(BITVECTOR_ULTBV, cvc5::Kind::BITVECTOR_ULTBV),
- KIND_ENUM(BITVECTOR_SLTBV, cvc5::Kind::BITVECTOR_SLTBV),
- KIND_ENUM(BITVECTOR_ITE, cvc5::Kind::BITVECTOR_ITE),
- KIND_ENUM(BITVECTOR_REDOR, cvc5::Kind::BITVECTOR_REDOR),
- KIND_ENUM(BITVECTOR_REDAND, cvc5::Kind::BITVECTOR_REDAND),
- KIND_ENUM(BITVECTOR_EXTRACT, cvc5::Kind::BITVECTOR_EXTRACT),
- KIND_ENUM(BITVECTOR_REPEAT, cvc5::Kind::BITVECTOR_REPEAT),
- KIND_ENUM(BITVECTOR_ZERO_EXTEND, cvc5::Kind::BITVECTOR_ZERO_EXTEND),
- KIND_ENUM(BITVECTOR_SIGN_EXTEND, cvc5::Kind::BITVECTOR_SIGN_EXTEND),
- KIND_ENUM(BITVECTOR_ROTATE_LEFT, cvc5::Kind::BITVECTOR_ROTATE_LEFT),
- KIND_ENUM(BITVECTOR_ROTATE_RIGHT, cvc5::Kind::BITVECTOR_ROTATE_RIGHT),
- KIND_ENUM(INT_TO_BITVECTOR, cvc5::Kind::INT_TO_BITVECTOR),
- KIND_ENUM(BITVECTOR_TO_NAT, cvc5::Kind::BITVECTOR_TO_NAT),
+ KIND_ENUM(CONST_BITVECTOR, internal::Kind::CONST_BITVECTOR),
+ KIND_ENUM(BITVECTOR_CONCAT, internal::Kind::BITVECTOR_CONCAT),
+ KIND_ENUM(BITVECTOR_AND, internal::Kind::BITVECTOR_AND),
+ KIND_ENUM(BITVECTOR_OR, internal::Kind::BITVECTOR_OR),
+ KIND_ENUM(BITVECTOR_XOR, internal::Kind::BITVECTOR_XOR),
+ KIND_ENUM(BITVECTOR_NOT, internal::Kind::BITVECTOR_NOT),
+ KIND_ENUM(BITVECTOR_NAND, internal::Kind::BITVECTOR_NAND),
+ KIND_ENUM(BITVECTOR_NOR, internal::Kind::BITVECTOR_NOR),
+ KIND_ENUM(BITVECTOR_XNOR, internal::Kind::BITVECTOR_XNOR),
+ KIND_ENUM(BITVECTOR_COMP, internal::Kind::BITVECTOR_COMP),
+ KIND_ENUM(BITVECTOR_MULT, internal::Kind::BITVECTOR_MULT),
+ KIND_ENUM(BITVECTOR_ADD, internal::Kind::BITVECTOR_ADD),
+ KIND_ENUM(BITVECTOR_SUB, internal::Kind::BITVECTOR_SUB),
+ KIND_ENUM(BITVECTOR_NEG, internal::Kind::BITVECTOR_NEG),
+ KIND_ENUM(BITVECTOR_UDIV, internal::Kind::BITVECTOR_UDIV),
+ KIND_ENUM(BITVECTOR_UREM, internal::Kind::BITVECTOR_UREM),
+ KIND_ENUM(BITVECTOR_SDIV, internal::Kind::BITVECTOR_SDIV),
+ KIND_ENUM(BITVECTOR_SREM, internal::Kind::BITVECTOR_SREM),
+ KIND_ENUM(BITVECTOR_SMOD, internal::Kind::BITVECTOR_SMOD),
+ KIND_ENUM(BITVECTOR_SHL, internal::Kind::BITVECTOR_SHL),
+ KIND_ENUM(BITVECTOR_LSHR, internal::Kind::BITVECTOR_LSHR),
+ KIND_ENUM(BITVECTOR_ASHR, internal::Kind::BITVECTOR_ASHR),
+ KIND_ENUM(BITVECTOR_ULT, internal::Kind::BITVECTOR_ULT),
+ KIND_ENUM(BITVECTOR_ULE, internal::Kind::BITVECTOR_ULE),
+ KIND_ENUM(BITVECTOR_UGT, internal::Kind::BITVECTOR_UGT),
+ KIND_ENUM(BITVECTOR_UGE, internal::Kind::BITVECTOR_UGE),
+ KIND_ENUM(BITVECTOR_SLT, internal::Kind::BITVECTOR_SLT),
+ KIND_ENUM(BITVECTOR_SLE, internal::Kind::BITVECTOR_SLE),
+ KIND_ENUM(BITVECTOR_SGT, internal::Kind::BITVECTOR_SGT),
+ KIND_ENUM(BITVECTOR_SGE, internal::Kind::BITVECTOR_SGE),
+ KIND_ENUM(BITVECTOR_ULTBV, internal::Kind::BITVECTOR_ULTBV),
+ KIND_ENUM(BITVECTOR_SLTBV, internal::Kind::BITVECTOR_SLTBV),
+ KIND_ENUM(BITVECTOR_ITE, internal::Kind::BITVECTOR_ITE),
+ KIND_ENUM(BITVECTOR_REDOR, internal::Kind::BITVECTOR_REDOR),
+ KIND_ENUM(BITVECTOR_REDAND, internal::Kind::BITVECTOR_REDAND),
+ KIND_ENUM(BITVECTOR_EXTRACT, internal::Kind::BITVECTOR_EXTRACT),
+ KIND_ENUM(BITVECTOR_REPEAT, internal::Kind::BITVECTOR_REPEAT),
+ KIND_ENUM(BITVECTOR_ZERO_EXTEND, internal::Kind::BITVECTOR_ZERO_EXTEND),
+ KIND_ENUM(BITVECTOR_SIGN_EXTEND, internal::Kind::BITVECTOR_SIGN_EXTEND),
+ KIND_ENUM(BITVECTOR_ROTATE_LEFT, internal::Kind::BITVECTOR_ROTATE_LEFT),
+ KIND_ENUM(BITVECTOR_ROTATE_RIGHT,
+ internal::Kind::BITVECTOR_ROTATE_RIGHT),
+ KIND_ENUM(INT_TO_BITVECTOR, internal::Kind::INT_TO_BITVECTOR),
+ KIND_ENUM(BITVECTOR_TO_NAT, internal::Kind::BITVECTOR_TO_NAT),
/* FP --------------------------------------------------------------- */
- KIND_ENUM(CONST_FLOATINGPOINT, cvc5::Kind::CONST_FLOATINGPOINT),
- KIND_ENUM(CONST_ROUNDINGMODE, cvc5::Kind::CONST_ROUNDINGMODE),
- KIND_ENUM(FLOATINGPOINT_FP, cvc5::Kind::FLOATINGPOINT_FP),
- KIND_ENUM(FLOATINGPOINT_EQ, cvc5::Kind::FLOATINGPOINT_EQ),
- KIND_ENUM(FLOATINGPOINT_ABS, cvc5::Kind::FLOATINGPOINT_ABS),
- KIND_ENUM(FLOATINGPOINT_NEG, cvc5::Kind::FLOATINGPOINT_NEG),
- KIND_ENUM(FLOATINGPOINT_ADD, cvc5::Kind::FLOATINGPOINT_ADD),
- KIND_ENUM(FLOATINGPOINT_SUB, cvc5::Kind::FLOATINGPOINT_SUB),
- KIND_ENUM(FLOATINGPOINT_MULT, cvc5::Kind::FLOATINGPOINT_MULT),
- KIND_ENUM(FLOATINGPOINT_DIV, cvc5::Kind::FLOATINGPOINT_DIV),
- KIND_ENUM(FLOATINGPOINT_FMA, cvc5::Kind::FLOATINGPOINT_FMA),
- KIND_ENUM(FLOATINGPOINT_SQRT, cvc5::Kind::FLOATINGPOINT_SQRT),
- KIND_ENUM(FLOATINGPOINT_REM, cvc5::Kind::FLOATINGPOINT_REM),
- KIND_ENUM(FLOATINGPOINT_RTI, cvc5::Kind::FLOATINGPOINT_RTI),
- KIND_ENUM(FLOATINGPOINT_MIN, cvc5::Kind::FLOATINGPOINT_MIN),
- KIND_ENUM(FLOATINGPOINT_MAX, cvc5::Kind::FLOATINGPOINT_MAX),
- KIND_ENUM(FLOATINGPOINT_LEQ, cvc5::Kind::FLOATINGPOINT_LEQ),
- KIND_ENUM(FLOATINGPOINT_LT, cvc5::Kind::FLOATINGPOINT_LT),
- KIND_ENUM(FLOATINGPOINT_GEQ, cvc5::Kind::FLOATINGPOINT_GEQ),
- KIND_ENUM(FLOATINGPOINT_GT, cvc5::Kind::FLOATINGPOINT_GT),
- KIND_ENUM(FLOATINGPOINT_IS_NORMAL, cvc5::Kind::FLOATINGPOINT_IS_NORMAL),
+ KIND_ENUM(CONST_FLOATINGPOINT, internal::Kind::CONST_FLOATINGPOINT),
+ KIND_ENUM(CONST_ROUNDINGMODE, internal::Kind::CONST_ROUNDINGMODE),
+ KIND_ENUM(FLOATINGPOINT_FP, internal::Kind::FLOATINGPOINT_FP),
+ KIND_ENUM(FLOATINGPOINT_EQ, internal::Kind::FLOATINGPOINT_EQ),
+ KIND_ENUM(FLOATINGPOINT_ABS, internal::Kind::FLOATINGPOINT_ABS),
+ KIND_ENUM(FLOATINGPOINT_NEG, internal::Kind::FLOATINGPOINT_NEG),
+ KIND_ENUM(FLOATINGPOINT_ADD, internal::Kind::FLOATINGPOINT_ADD),
+ KIND_ENUM(FLOATINGPOINT_SUB, internal::Kind::FLOATINGPOINT_SUB),
+ KIND_ENUM(FLOATINGPOINT_MULT, internal::Kind::FLOATINGPOINT_MULT),
+ KIND_ENUM(FLOATINGPOINT_DIV, internal::Kind::FLOATINGPOINT_DIV),
+ KIND_ENUM(FLOATINGPOINT_FMA, internal::Kind::FLOATINGPOINT_FMA),
+ KIND_ENUM(FLOATINGPOINT_SQRT, internal::Kind::FLOATINGPOINT_SQRT),
+ KIND_ENUM(FLOATINGPOINT_REM, internal::Kind::FLOATINGPOINT_REM),
+ KIND_ENUM(FLOATINGPOINT_RTI, internal::Kind::FLOATINGPOINT_RTI),
+ KIND_ENUM(FLOATINGPOINT_MIN, internal::Kind::FLOATINGPOINT_MIN),
+ KIND_ENUM(FLOATINGPOINT_MAX, internal::Kind::FLOATINGPOINT_MAX),
+ KIND_ENUM(FLOATINGPOINT_LEQ, internal::Kind::FLOATINGPOINT_LEQ),
+ KIND_ENUM(FLOATINGPOINT_LT, internal::Kind::FLOATINGPOINT_LT),
+ KIND_ENUM(FLOATINGPOINT_GEQ, internal::Kind::FLOATINGPOINT_GEQ),
+ KIND_ENUM(FLOATINGPOINT_GT, internal::Kind::FLOATINGPOINT_GT),
+ KIND_ENUM(FLOATINGPOINT_IS_NORMAL,
+ internal::Kind::FLOATINGPOINT_IS_NORMAL),
KIND_ENUM(FLOATINGPOINT_IS_SUBNORMAL,
- cvc5::Kind::FLOATINGPOINT_IS_SUBNORMAL),
- KIND_ENUM(FLOATINGPOINT_IS_ZERO, cvc5::Kind::FLOATINGPOINT_IS_ZERO),
- KIND_ENUM(FLOATINGPOINT_IS_INF, cvc5::Kind::FLOATINGPOINT_IS_INF),
- KIND_ENUM(FLOATINGPOINT_IS_NAN, cvc5::Kind::FLOATINGPOINT_IS_NAN),
- KIND_ENUM(FLOATINGPOINT_IS_NEG, cvc5::Kind::FLOATINGPOINT_IS_NEG),
- KIND_ENUM(FLOATINGPOINT_IS_POS, cvc5::Kind::FLOATINGPOINT_IS_POS),
+ internal::Kind::FLOATINGPOINT_IS_SUBNORMAL),
+ KIND_ENUM(FLOATINGPOINT_IS_ZERO, internal::Kind::FLOATINGPOINT_IS_ZERO),
+ KIND_ENUM(FLOATINGPOINT_IS_INF, internal::Kind::FLOATINGPOINT_IS_INF),
+ KIND_ENUM(FLOATINGPOINT_IS_NAN, internal::Kind::FLOATINGPOINT_IS_NAN),
+ KIND_ENUM(FLOATINGPOINT_IS_NEG, internal::Kind::FLOATINGPOINT_IS_NEG),
+ KIND_ENUM(FLOATINGPOINT_IS_POS, internal::Kind::FLOATINGPOINT_IS_POS),
KIND_ENUM(FLOATINGPOINT_TO_FP_FROM_FP,
- cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_FP),
+ internal::Kind::FLOATINGPOINT_TO_FP_FROM_FP),
KIND_ENUM(FLOATINGPOINT_TO_FP_FROM_IEEE_BV,
- cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV),
+ internal::Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV),
KIND_ENUM(FLOATINGPOINT_TO_FP_FROM_REAL,
- cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_REAL),
+ internal::Kind::FLOATINGPOINT_TO_FP_FROM_REAL),
KIND_ENUM(FLOATINGPOINT_TO_FP_FROM_SBV,
- cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_SBV),
+ internal::Kind::FLOATINGPOINT_TO_FP_FROM_SBV),
KIND_ENUM(FLOATINGPOINT_TO_FP_FROM_UBV,
- cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_UBV),
- KIND_ENUM(FLOATINGPOINT_TO_UBV, cvc5::Kind::FLOATINGPOINT_TO_UBV),
- KIND_ENUM(FLOATINGPOINT_TO_SBV, cvc5::Kind::FLOATINGPOINT_TO_SBV),
- KIND_ENUM(FLOATINGPOINT_TO_REAL, cvc5::Kind::FLOATINGPOINT_TO_REAL),
+ internal::Kind::FLOATINGPOINT_TO_FP_FROM_UBV),
+ KIND_ENUM(FLOATINGPOINT_TO_UBV, internal::Kind::FLOATINGPOINT_TO_UBV),
+ KIND_ENUM(FLOATINGPOINT_TO_SBV, internal::Kind::FLOATINGPOINT_TO_SBV),
+ KIND_ENUM(FLOATINGPOINT_TO_REAL, internal::Kind::FLOATINGPOINT_TO_REAL),
/* Arrays ----------------------------------------------------------- */
- KIND_ENUM(SELECT, cvc5::Kind::SELECT),
- KIND_ENUM(STORE, cvc5::Kind::STORE),
- KIND_ENUM(CONST_ARRAY, cvc5::Kind::STORE_ALL),
- KIND_ENUM(EQ_RANGE, cvc5::Kind::EQ_RANGE),
+ KIND_ENUM(SELECT, internal::Kind::SELECT),
+ KIND_ENUM(STORE, internal::Kind::STORE),
+ KIND_ENUM(CONST_ARRAY, internal::Kind::STORE_ALL),
+ KIND_ENUM(EQ_RANGE, internal::Kind::EQ_RANGE),
/* Datatypes -------------------------------------------------------- */
- KIND_ENUM(APPLY_SELECTOR, cvc5::Kind::APPLY_SELECTOR),
- KIND_ENUM(APPLY_CONSTRUCTOR, cvc5::Kind::APPLY_CONSTRUCTOR),
- KIND_ENUM(APPLY_TESTER, cvc5::Kind::APPLY_TESTER),
- KIND_ENUM(APPLY_UPDATER, cvc5::Kind::APPLY_UPDATER),
- KIND_ENUM(DT_SIZE, cvc5::Kind::DT_SIZE),
- KIND_ENUM(MATCH, cvc5::Kind::MATCH),
- KIND_ENUM(MATCH_CASE, cvc5::Kind::MATCH_CASE),
- KIND_ENUM(MATCH_BIND_CASE, cvc5::Kind::MATCH_BIND_CASE),
- KIND_ENUM(TUPLE_PROJECT, cvc5::Kind::TUPLE_PROJECT),
+ KIND_ENUM(APPLY_SELECTOR, internal::Kind::APPLY_SELECTOR),
+ KIND_ENUM(APPLY_CONSTRUCTOR, internal::Kind::APPLY_CONSTRUCTOR),
+ KIND_ENUM(APPLY_TESTER, internal::Kind::APPLY_TESTER),
+ KIND_ENUM(APPLY_UPDATER, internal::Kind::APPLY_UPDATER),
+ KIND_ENUM(DT_SIZE, internal::Kind::DT_SIZE),
+ KIND_ENUM(MATCH, internal::Kind::MATCH),
+ KIND_ENUM(MATCH_CASE, internal::Kind::MATCH_CASE),
+ KIND_ENUM(MATCH_BIND_CASE, internal::Kind::MATCH_BIND_CASE),
+ KIND_ENUM(TUPLE_PROJECT, internal::Kind::TUPLE_PROJECT),
/* Separation Logic ------------------------------------------------- */
- KIND_ENUM(SEP_NIL, cvc5::Kind::SEP_NIL),
- KIND_ENUM(SEP_EMP, cvc5::Kind::SEP_EMP),
- KIND_ENUM(SEP_PTO, cvc5::Kind::SEP_PTO),
- KIND_ENUM(SEP_STAR, cvc5::Kind::SEP_STAR),
- KIND_ENUM(SEP_WAND, cvc5::Kind::SEP_WAND),
+ KIND_ENUM(SEP_NIL, internal::Kind::SEP_NIL),
+ KIND_ENUM(SEP_EMP, internal::Kind::SEP_EMP),
+ KIND_ENUM(SEP_PTO, internal::Kind::SEP_PTO),
+ KIND_ENUM(SEP_STAR, internal::Kind::SEP_STAR),
+ KIND_ENUM(SEP_WAND, internal::Kind::SEP_WAND),
/* Sets ------------------------------------------------------------- */
- KIND_ENUM(SET_EMPTY, cvc5::Kind::SET_EMPTY),
- KIND_ENUM(SET_UNION, cvc5::Kind::SET_UNION),
- KIND_ENUM(SET_INTER, cvc5::Kind::SET_INTER),
- KIND_ENUM(SET_MINUS, cvc5::Kind::SET_MINUS),
- KIND_ENUM(SET_SUBSET, cvc5::Kind::SET_SUBSET),
- KIND_ENUM(SET_MEMBER, cvc5::Kind::SET_MEMBER),
- KIND_ENUM(SET_SINGLETON, cvc5::Kind::SET_SINGLETON),
- KIND_ENUM(SET_INSERT, cvc5::Kind::SET_INSERT),
- KIND_ENUM(SET_CARD, cvc5::Kind::SET_CARD),
- KIND_ENUM(SET_COMPLEMENT, cvc5::Kind::SET_COMPLEMENT),
- KIND_ENUM(SET_UNIVERSE, cvc5::Kind::SET_UNIVERSE),
- KIND_ENUM(SET_COMPREHENSION, cvc5::Kind::SET_COMPREHENSION),
- KIND_ENUM(SET_CHOOSE, cvc5::Kind::SET_CHOOSE),
- KIND_ENUM(SET_IS_SINGLETON, cvc5::Kind::SET_IS_SINGLETON),
- KIND_ENUM(SET_MAP, cvc5::Kind::SET_MAP),
+ KIND_ENUM(SET_EMPTY, internal::Kind::SET_EMPTY),
+ KIND_ENUM(SET_UNION, internal::Kind::SET_UNION),
+ KIND_ENUM(SET_INTER, internal::Kind::SET_INTER),
+ KIND_ENUM(SET_MINUS, internal::Kind::SET_MINUS),
+ KIND_ENUM(SET_SUBSET, internal::Kind::SET_SUBSET),
+ KIND_ENUM(SET_MEMBER, internal::Kind::SET_MEMBER),
+ KIND_ENUM(SET_SINGLETON, internal::Kind::SET_SINGLETON),
+ KIND_ENUM(SET_INSERT, internal::Kind::SET_INSERT),
+ KIND_ENUM(SET_CARD, internal::Kind::SET_CARD),
+ KIND_ENUM(SET_COMPLEMENT, internal::Kind::SET_COMPLEMENT),
+ KIND_ENUM(SET_UNIVERSE, internal::Kind::SET_UNIVERSE),
+ KIND_ENUM(SET_COMPREHENSION, internal::Kind::SET_COMPREHENSION),
+ KIND_ENUM(SET_CHOOSE, internal::Kind::SET_CHOOSE),
+ KIND_ENUM(SET_IS_SINGLETON, internal::Kind::SET_IS_SINGLETON),
+ KIND_ENUM(SET_MAP, internal::Kind::SET_MAP),
/* Relations -------------------------------------------------------- */
- KIND_ENUM(RELATION_JOIN, cvc5::Kind::RELATION_JOIN),
- KIND_ENUM(RELATION_PRODUCT, cvc5::Kind::RELATION_PRODUCT),
- KIND_ENUM(RELATION_TRANSPOSE, cvc5::Kind::RELATION_TRANSPOSE),
- KIND_ENUM(RELATION_TCLOSURE, cvc5::Kind::RELATION_TCLOSURE),
- KIND_ENUM(RELATION_JOIN_IMAGE, cvc5::Kind::RELATION_JOIN_IMAGE),
- KIND_ENUM(RELATION_IDEN, cvc5::Kind::RELATION_IDEN),
+ KIND_ENUM(RELATION_JOIN, internal::Kind::RELATION_JOIN),
+ KIND_ENUM(RELATION_PRODUCT, internal::Kind::RELATION_PRODUCT),
+ KIND_ENUM(RELATION_TRANSPOSE, internal::Kind::RELATION_TRANSPOSE),
+ KIND_ENUM(RELATION_TCLOSURE, internal::Kind::RELATION_TCLOSURE),
+ KIND_ENUM(RELATION_JOIN_IMAGE, internal::Kind::RELATION_JOIN_IMAGE),
+ KIND_ENUM(RELATION_IDEN, internal::Kind::RELATION_IDEN),
/* Bags ------------------------------------------------------------- */
- KIND_ENUM(BAG_UNION_MAX, cvc5::Kind::BAG_UNION_MAX),
- KIND_ENUM(BAG_UNION_DISJOINT, cvc5::Kind::BAG_UNION_DISJOINT),
- KIND_ENUM(BAG_INTER_MIN, cvc5::Kind::BAG_INTER_MIN),
- KIND_ENUM(BAG_DIFFERENCE_SUBTRACT, cvc5::Kind::BAG_DIFFERENCE_SUBTRACT),
- KIND_ENUM(BAG_DIFFERENCE_REMOVE, cvc5::Kind::BAG_DIFFERENCE_REMOVE),
- KIND_ENUM(BAG_SUBBAG, cvc5::Kind::BAG_SUBBAG),
- KIND_ENUM(BAG_COUNT, cvc5::Kind::BAG_COUNT),
- KIND_ENUM(BAG_MEMBER, cvc5::Kind::BAG_MEMBER),
- KIND_ENUM(BAG_DUPLICATE_REMOVAL, cvc5::Kind::BAG_DUPLICATE_REMOVAL),
- KIND_ENUM(BAG_MAKE, cvc5::Kind::BAG_MAKE),
- KIND_ENUM(BAG_EMPTY, cvc5::Kind::BAG_EMPTY),
- KIND_ENUM(BAG_CARD, cvc5::Kind::BAG_CARD),
- KIND_ENUM(BAG_CHOOSE, cvc5::Kind::BAG_CHOOSE),
- KIND_ENUM(BAG_IS_SINGLETON, cvc5::Kind::BAG_IS_SINGLETON),
- KIND_ENUM(BAG_FROM_SET, cvc5::Kind::BAG_FROM_SET),
- KIND_ENUM(BAG_TO_SET, cvc5::Kind::BAG_TO_SET),
- KIND_ENUM(BAG_MAP, cvc5::Kind::BAG_MAP),
- KIND_ENUM(BAG_FILTER, cvc5::Kind::BAG_FILTER),
- KIND_ENUM(BAG_FOLD, cvc5::Kind::BAG_FOLD),
- KIND_ENUM(TABLE_PRODUCT, cvc5::Kind::TABLE_PRODUCT),
+ KIND_ENUM(BAG_UNION_MAX, internal::Kind::BAG_UNION_MAX),
+ KIND_ENUM(BAG_UNION_DISJOINT, internal::Kind::BAG_UNION_DISJOINT),
+ KIND_ENUM(BAG_INTER_MIN, internal::Kind::BAG_INTER_MIN),
+ KIND_ENUM(BAG_DIFFERENCE_SUBTRACT,
+ internal::Kind::BAG_DIFFERENCE_SUBTRACT),
+ KIND_ENUM(BAG_DIFFERENCE_REMOVE, internal::Kind::BAG_DIFFERENCE_REMOVE),
+ KIND_ENUM(BAG_SUBBAG, internal::Kind::BAG_SUBBAG),
+ KIND_ENUM(BAG_COUNT, internal::Kind::BAG_COUNT),
+ KIND_ENUM(BAG_MEMBER, internal::Kind::BAG_MEMBER),
+ KIND_ENUM(BAG_DUPLICATE_REMOVAL, internal::Kind::BAG_DUPLICATE_REMOVAL),
+ KIND_ENUM(BAG_MAKE, internal::Kind::BAG_MAKE),
+ KIND_ENUM(BAG_EMPTY, internal::Kind::BAG_EMPTY),
+ KIND_ENUM(BAG_CARD, internal::Kind::BAG_CARD),
+ KIND_ENUM(BAG_CHOOSE, internal::Kind::BAG_CHOOSE),
+ KIND_ENUM(BAG_IS_SINGLETON, internal::Kind::BAG_IS_SINGLETON),
+ KIND_ENUM(BAG_FROM_SET, internal::Kind::BAG_FROM_SET),
+ KIND_ENUM(BAG_TO_SET, internal::Kind::BAG_TO_SET),
+ KIND_ENUM(BAG_MAP, internal::Kind::BAG_MAP),
+ KIND_ENUM(BAG_FILTER, internal::Kind::BAG_FILTER),
+ KIND_ENUM(BAG_FOLD, internal::Kind::BAG_FOLD),
+ KIND_ENUM(TABLE_PRODUCT, internal::Kind::TABLE_PRODUCT),
/* Strings ---------------------------------------------------------- */
- KIND_ENUM(STRING_CONCAT, cvc5::Kind::STRING_CONCAT),
- KIND_ENUM(STRING_IN_REGEXP, cvc5::Kind::STRING_IN_REGEXP),
- KIND_ENUM(STRING_LENGTH, cvc5::Kind::STRING_LENGTH),
- KIND_ENUM(STRING_SUBSTR, cvc5::Kind::STRING_SUBSTR),
- KIND_ENUM(STRING_UPDATE, cvc5::Kind::STRING_UPDATE),
- KIND_ENUM(STRING_CHARAT, cvc5::Kind::STRING_CHARAT),
- KIND_ENUM(STRING_CONTAINS, cvc5::Kind::STRING_CONTAINS),
- KIND_ENUM(STRING_INDEXOF, cvc5::Kind::STRING_INDEXOF),
- KIND_ENUM(STRING_INDEXOF_RE, cvc5::Kind::STRING_INDEXOF_RE),
- KIND_ENUM(STRING_REPLACE, cvc5::Kind::STRING_REPLACE),
- KIND_ENUM(STRING_REPLACE_ALL, cvc5::Kind::STRING_REPLACE_ALL),
- KIND_ENUM(STRING_REPLACE_RE, cvc5::Kind::STRING_REPLACE_RE),
- KIND_ENUM(STRING_REPLACE_RE_ALL, cvc5::Kind::STRING_REPLACE_RE_ALL),
- KIND_ENUM(STRING_TO_LOWER, cvc5::Kind::STRING_TO_LOWER),
- KIND_ENUM(STRING_TO_UPPER, cvc5::Kind::STRING_TO_UPPER),
- KIND_ENUM(STRING_REV, cvc5::Kind::STRING_REV),
- KIND_ENUM(STRING_FROM_CODE, cvc5::Kind::STRING_FROM_CODE),
- KIND_ENUM(STRING_TO_CODE, cvc5::Kind::STRING_TO_CODE),
- KIND_ENUM(STRING_LT, cvc5::Kind::STRING_LT),
- KIND_ENUM(STRING_LEQ, cvc5::Kind::STRING_LEQ),
- KIND_ENUM(STRING_PREFIX, cvc5::Kind::STRING_PREFIX),
- KIND_ENUM(STRING_SUFFIX, cvc5::Kind::STRING_SUFFIX),
- KIND_ENUM(STRING_IS_DIGIT, cvc5::Kind::STRING_IS_DIGIT),
- KIND_ENUM(STRING_FROM_INT, cvc5::Kind::STRING_ITOS),
- KIND_ENUM(STRING_TO_INT, cvc5::Kind::STRING_STOI),
- KIND_ENUM(CONST_STRING, cvc5::Kind::CONST_STRING),
- KIND_ENUM(STRING_TO_REGEXP, cvc5::Kind::STRING_TO_REGEXP),
- KIND_ENUM(REGEXP_CONCAT, cvc5::Kind::REGEXP_CONCAT),
- KIND_ENUM(REGEXP_UNION, cvc5::Kind::REGEXP_UNION),
- KIND_ENUM(REGEXP_INTER, cvc5::Kind::REGEXP_INTER),
- KIND_ENUM(REGEXP_DIFF, cvc5::Kind::REGEXP_DIFF),
- KIND_ENUM(REGEXP_STAR, cvc5::Kind::REGEXP_STAR),
- KIND_ENUM(REGEXP_PLUS, cvc5::Kind::REGEXP_PLUS),
- KIND_ENUM(REGEXP_OPT, cvc5::Kind::REGEXP_OPT),
- KIND_ENUM(REGEXP_RANGE, cvc5::Kind::REGEXP_RANGE),
- KIND_ENUM(REGEXP_REPEAT, cvc5::Kind::REGEXP_REPEAT),
- KIND_ENUM(REGEXP_LOOP, cvc5::Kind::REGEXP_LOOP),
- KIND_ENUM(REGEXP_NONE, cvc5::Kind::REGEXP_NONE),
- KIND_ENUM(REGEXP_ALL, cvc5::Kind::REGEXP_ALL),
- KIND_ENUM(REGEXP_ALLCHAR, cvc5::Kind::REGEXP_ALLCHAR),
- KIND_ENUM(REGEXP_COMPLEMENT, cvc5::Kind::REGEXP_COMPLEMENT),
+ KIND_ENUM(STRING_CONCAT, internal::Kind::STRING_CONCAT),
+ KIND_ENUM(STRING_IN_REGEXP, internal::Kind::STRING_IN_REGEXP),
+ KIND_ENUM(STRING_LENGTH, internal::Kind::STRING_LENGTH),
+ KIND_ENUM(STRING_SUBSTR, internal::Kind::STRING_SUBSTR),
+ KIND_ENUM(STRING_UPDATE, internal::Kind::STRING_UPDATE),
+ KIND_ENUM(STRING_CHARAT, internal::Kind::STRING_CHARAT),
+ KIND_ENUM(STRING_CONTAINS, internal::Kind::STRING_CONTAINS),
+ KIND_ENUM(STRING_INDEXOF, internal::Kind::STRING_INDEXOF),
+ KIND_ENUM(STRING_INDEXOF_RE, internal::Kind::STRING_INDEXOF_RE),
+ KIND_ENUM(STRING_REPLACE, internal::Kind::STRING_REPLACE),
+ KIND_ENUM(STRING_REPLACE_ALL, internal::Kind::STRING_REPLACE_ALL),
+ KIND_ENUM(STRING_REPLACE_RE, internal::Kind::STRING_REPLACE_RE),
+ KIND_ENUM(STRING_REPLACE_RE_ALL, internal::Kind::STRING_REPLACE_RE_ALL),
+ KIND_ENUM(STRING_TO_LOWER, internal::Kind::STRING_TO_LOWER),
+ KIND_ENUM(STRING_TO_UPPER, internal::Kind::STRING_TO_UPPER),
+ KIND_ENUM(STRING_REV, internal::Kind::STRING_REV),
+ KIND_ENUM(STRING_FROM_CODE, internal::Kind::STRING_FROM_CODE),
+ KIND_ENUM(STRING_TO_CODE, internal::Kind::STRING_TO_CODE),
+ KIND_ENUM(STRING_LT, internal::Kind::STRING_LT),
+ KIND_ENUM(STRING_LEQ, internal::Kind::STRING_LEQ),
+ KIND_ENUM(STRING_PREFIX, internal::Kind::STRING_PREFIX),
+ KIND_ENUM(STRING_SUFFIX, internal::Kind::STRING_SUFFIX),
+ KIND_ENUM(STRING_IS_DIGIT, internal::Kind::STRING_IS_DIGIT),
+ KIND_ENUM(STRING_FROM_INT, internal::Kind::STRING_ITOS),
+ KIND_ENUM(STRING_TO_INT, internal::Kind::STRING_STOI),
+ KIND_ENUM(CONST_STRING, internal::Kind::CONST_STRING),
+ KIND_ENUM(STRING_TO_REGEXP, internal::Kind::STRING_TO_REGEXP),
+ KIND_ENUM(REGEXP_CONCAT, internal::Kind::REGEXP_CONCAT),
+ KIND_ENUM(REGEXP_UNION, internal::Kind::REGEXP_UNION),
+ KIND_ENUM(REGEXP_INTER, internal::Kind::REGEXP_INTER),
+ KIND_ENUM(REGEXP_DIFF, internal::Kind::REGEXP_DIFF),
+ KIND_ENUM(REGEXP_STAR, internal::Kind::REGEXP_STAR),
+ KIND_ENUM(REGEXP_PLUS, internal::Kind::REGEXP_PLUS),
+ KIND_ENUM(REGEXP_OPT, internal::Kind::REGEXP_OPT),
+ KIND_ENUM(REGEXP_RANGE, internal::Kind::REGEXP_RANGE),
+ KIND_ENUM(REGEXP_REPEAT, internal::Kind::REGEXP_REPEAT),
+ KIND_ENUM(REGEXP_LOOP, internal::Kind::REGEXP_LOOP),
+ KIND_ENUM(REGEXP_NONE, internal::Kind::REGEXP_NONE),
+ KIND_ENUM(REGEXP_ALL, internal::Kind::REGEXP_ALL),
+ KIND_ENUM(REGEXP_ALLCHAR, internal::Kind::REGEXP_ALLCHAR),
+ KIND_ENUM(REGEXP_COMPLEMENT, internal::Kind::REGEXP_COMPLEMENT),
// maps to the same kind as the string versions
- KIND_ENUM(SEQ_CONCAT, cvc5::Kind::STRING_CONCAT),
- KIND_ENUM(SEQ_LENGTH, cvc5::Kind::STRING_LENGTH),
- KIND_ENUM(SEQ_EXTRACT, cvc5::Kind::STRING_SUBSTR),
- KIND_ENUM(SEQ_UPDATE, cvc5::Kind::STRING_UPDATE),
- KIND_ENUM(SEQ_AT, cvc5::Kind::STRING_CHARAT),
- KIND_ENUM(SEQ_CONTAINS, cvc5::Kind::STRING_CONTAINS),
- KIND_ENUM(SEQ_INDEXOF, cvc5::Kind::STRING_INDEXOF),
- KIND_ENUM(SEQ_REPLACE, cvc5::Kind::STRING_REPLACE),
- KIND_ENUM(SEQ_REPLACE_ALL, cvc5::Kind::STRING_REPLACE_ALL),
- KIND_ENUM(SEQ_REV, cvc5::Kind::STRING_REV),
- KIND_ENUM(SEQ_PREFIX, cvc5::Kind::STRING_PREFIX),
- KIND_ENUM(SEQ_SUFFIX, cvc5::Kind::STRING_SUFFIX),
- KIND_ENUM(CONST_SEQUENCE, cvc5::Kind::CONST_SEQUENCE),
- KIND_ENUM(SEQ_UNIT, cvc5::Kind::SEQ_UNIT),
- KIND_ENUM(SEQ_NTH, cvc5::Kind::SEQ_NTH),
+ KIND_ENUM(SEQ_CONCAT, internal::Kind::STRING_CONCAT),
+ KIND_ENUM(SEQ_LENGTH, internal::Kind::STRING_LENGTH),
+ KIND_ENUM(SEQ_EXTRACT, internal::Kind::STRING_SUBSTR),
+ KIND_ENUM(SEQ_UPDATE, internal::Kind::STRING_UPDATE),
+ KIND_ENUM(SEQ_AT, internal::Kind::STRING_CHARAT),
+ KIND_ENUM(SEQ_CONTAINS, internal::Kind::STRING_CONTAINS),
+ KIND_ENUM(SEQ_INDEXOF, internal::Kind::STRING_INDEXOF),
+ KIND_ENUM(SEQ_REPLACE, internal::Kind::STRING_REPLACE),
+ KIND_ENUM(SEQ_REPLACE_ALL, internal::Kind::STRING_REPLACE_ALL),
+ KIND_ENUM(SEQ_REV, internal::Kind::STRING_REV),
+ KIND_ENUM(SEQ_PREFIX, internal::Kind::STRING_PREFIX),
+ KIND_ENUM(SEQ_SUFFIX, internal::Kind::STRING_SUFFIX),
+ KIND_ENUM(CONST_SEQUENCE, internal::Kind::CONST_SEQUENCE),
+ KIND_ENUM(SEQ_UNIT, internal::Kind::SEQ_UNIT),
+ KIND_ENUM(SEQ_NTH, internal::Kind::SEQ_NTH),
/* Quantifiers ------------------------------------------------------ */
- KIND_ENUM(FORALL, cvc5::Kind::FORALL),
- KIND_ENUM(EXISTS, cvc5::Kind::EXISTS),
- KIND_ENUM(VARIABLE_LIST, cvc5::Kind::BOUND_VAR_LIST),
- KIND_ENUM(INST_PATTERN, cvc5::Kind::INST_PATTERN),
- KIND_ENUM(INST_NO_PATTERN, cvc5::Kind::INST_NO_PATTERN),
- KIND_ENUM(INST_POOL, cvc5::Kind::INST_POOL),
- KIND_ENUM(INST_ADD_TO_POOL, cvc5::Kind::INST_ADD_TO_POOL),
- KIND_ENUM(SKOLEM_ADD_TO_POOL, cvc5::Kind::SKOLEM_ADD_TO_POOL),
- KIND_ENUM(INST_ATTRIBUTE, cvc5::Kind::INST_ATTRIBUTE),
- KIND_ENUM(INST_PATTERN_LIST, cvc5::Kind::INST_PATTERN_LIST),
- KIND_ENUM(LAST_KIND, cvc5::Kind::LAST_KIND),
+ KIND_ENUM(FORALL, internal::Kind::FORALL),
+ KIND_ENUM(EXISTS, internal::Kind::EXISTS),
+ KIND_ENUM(VARIABLE_LIST, internal::Kind::BOUND_VAR_LIST),
+ KIND_ENUM(INST_PATTERN, internal::Kind::INST_PATTERN),
+ KIND_ENUM(INST_NO_PATTERN, internal::Kind::INST_NO_PATTERN),
+ KIND_ENUM(INST_POOL, internal::Kind::INST_POOL),
+ KIND_ENUM(INST_ADD_TO_POOL, internal::Kind::INST_ADD_TO_POOL),
+ KIND_ENUM(SKOLEM_ADD_TO_POOL, internal::Kind::SKOLEM_ADD_TO_POOL),
+ KIND_ENUM(INST_ATTRIBUTE, internal::Kind::INST_ATTRIBUTE),
+ KIND_ENUM(INST_PATTERN_LIST, internal::Kind::INST_PATTERN_LIST),
+ KIND_ENUM(LAST_KIND, internal::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<internal::Kind,
+ Kind,
+ internal::kind::KindHashFunction>
s_kinds_internal{
- {cvc5::Kind::UNDEFINED_KIND, UNDEFINED_KIND},
- {cvc5::Kind::NULL_EXPR, NULL_TERM},
+ {internal::Kind::UNDEFINED_KIND, UNDEFINED_KIND},
+ {internal::Kind::NULL_EXPR, NULL_TERM},
/* Builtin --------------------------------------------------------- */
- {cvc5::Kind::UNINTERPRETED_SORT_VALUE, UNINTERPRETED_SORT_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},
+ {internal::Kind::UNINTERPRETED_SORT_VALUE, UNINTERPRETED_SORT_VALUE},
+ {internal::Kind::EQUAL, EQUAL},
+ {internal::Kind::DISTINCT, DISTINCT},
+ {internal::Kind::VARIABLE, CONSTANT},
+ {internal::Kind::BOUND_VARIABLE, VARIABLE},
+ {internal::Kind::SEXPR, SEXPR},
+ {internal::Kind::LAMBDA, LAMBDA},
+ {internal::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},
+ {internal::Kind::CONST_BOOLEAN, CONST_BOOLEAN},
+ {internal::Kind::NOT, NOT},
+ {internal::Kind::AND, AND},
+ {internal::Kind::IMPLIES, IMPLIES},
+ {internal::Kind::OR, OR},
+ {internal::Kind::XOR, XOR},
+ {internal::Kind::ITE, ITE},
/* UF -------------------------------------------------------------- */
- {cvc5::Kind::APPLY_UF, APPLY_UF},
- {cvc5::Kind::CARDINALITY_CONSTRAINT, CARDINALITY_CONSTRAINT},
- {cvc5::Kind::HO_APPLY, HO_APPLY},
+ {internal::Kind::APPLY_UF, APPLY_UF},
+ {internal::Kind::CARDINALITY_CONSTRAINT, CARDINALITY_CONSTRAINT},
+ {internal::Kind::HO_APPLY, HO_APPLY},
/* Arithmetic ------------------------------------------------------ */
- {cvc5::Kind::ADD, ADD},
- {cvc5::Kind::MULT, MULT},
- {cvc5::Kind::IAND, IAND},
- {cvc5::Kind::POW2, POW2},
- {cvc5::Kind::SUB, SUB},
- {cvc5::Kind::NEG, NEG},
- {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::IAND_OP, IAND},
+ {internal::Kind::ADD, ADD},
+ {internal::Kind::MULT, MULT},
+ {internal::Kind::IAND, IAND},
+ {internal::Kind::POW2, POW2},
+ {internal::Kind::SUB, SUB},
+ {internal::Kind::NEG, NEG},
+ {internal::Kind::DIVISION, DIVISION},
+ {internal::Kind::DIVISION_TOTAL, INTERNAL_KIND},
+ {internal::Kind::INTS_DIVISION, INTS_DIVISION},
+ {internal::Kind::INTS_DIVISION_TOTAL, INTERNAL_KIND},
+ {internal::Kind::INTS_MODULUS, INTS_MODULUS},
+ {internal::Kind::INTS_MODULUS_TOTAL, INTERNAL_KIND},
+ {internal::Kind::ABS, ABS},
+ {internal::Kind::DIVISIBLE, DIVISIBLE},
+ {internal::Kind::POW, POW},
+ {internal::Kind::EXPONENTIAL, EXPONENTIAL},
+ {internal::Kind::SINE, SINE},
+ {internal::Kind::COSINE, COSINE},
+ {internal::Kind::TANGENT, TANGENT},
+ {internal::Kind::COSECANT, COSECANT},
+ {internal::Kind::SECANT, SECANT},
+ {internal::Kind::COTANGENT, COTANGENT},
+ {internal::Kind::ARCSINE, ARCSINE},
+ {internal::Kind::ARCCOSINE, ARCCOSINE},
+ {internal::Kind::ARCTANGENT, ARCTANGENT},
+ {internal::Kind::ARCCOSECANT, ARCCOSECANT},
+ {internal::Kind::ARCSECANT, ARCSECANT},
+ {internal::Kind::ARCCOTANGENT, ARCCOTANGENT},
+ {internal::Kind::SQRT, SQRT},
+ {internal::Kind::DIVISIBLE_OP, DIVISIBLE},
+ {internal::Kind::CONST_RATIONAL, CONST_RATIONAL},
+ {internal::Kind::LT, LT},
+ {internal::Kind::LEQ, LEQ},
+ {internal::Kind::GT, GT},
+ {internal::Kind::GEQ, GEQ},
+ {internal::Kind::IS_INTEGER, IS_INTEGER},
+ {internal::Kind::TO_INTEGER, TO_INTEGER},
+ {internal::Kind::TO_REAL, TO_REAL},
+ {internal::Kind::PI, PI},
+ {internal::Kind::IAND_OP, IAND},
/* 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_ADD, BITVECTOR_ADD},
- {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},
+ {internal::Kind::CONST_BITVECTOR, CONST_BITVECTOR},
+ {internal::Kind::BITVECTOR_CONCAT, BITVECTOR_CONCAT},
+ {internal::Kind::BITVECTOR_AND, BITVECTOR_AND},
+ {internal::Kind::BITVECTOR_OR, BITVECTOR_OR},
+ {internal::Kind::BITVECTOR_XOR, BITVECTOR_XOR},
+ {internal::Kind::BITVECTOR_NOT, BITVECTOR_NOT},
+ {internal::Kind::BITVECTOR_NAND, BITVECTOR_NAND},
+ {internal::Kind::BITVECTOR_NOR, BITVECTOR_NOR},
+ {internal::Kind::BITVECTOR_XNOR, BITVECTOR_XNOR},
+ {internal::Kind::BITVECTOR_COMP, BITVECTOR_COMP},
+ {internal::Kind::BITVECTOR_MULT, BITVECTOR_MULT},
+ {internal::Kind::BITVECTOR_ADD, BITVECTOR_ADD},
+ {internal::Kind::BITVECTOR_SUB, BITVECTOR_SUB},
+ {internal::Kind::BITVECTOR_NEG, BITVECTOR_NEG},
+ {internal::Kind::BITVECTOR_UDIV, BITVECTOR_UDIV},
+ {internal::Kind::BITVECTOR_UREM, BITVECTOR_UREM},
+ {internal::Kind::BITVECTOR_SDIV, BITVECTOR_SDIV},
+ {internal::Kind::BITVECTOR_SREM, BITVECTOR_SREM},
+ {internal::Kind::BITVECTOR_SMOD, BITVECTOR_SMOD},
+ {internal::Kind::BITVECTOR_SHL, BITVECTOR_SHL},
+ {internal::Kind::BITVECTOR_LSHR, BITVECTOR_LSHR},
+ {internal::Kind::BITVECTOR_ASHR, BITVECTOR_ASHR},
+ {internal::Kind::BITVECTOR_ULT, BITVECTOR_ULT},
+ {internal::Kind::BITVECTOR_ULE, BITVECTOR_ULE},
+ {internal::Kind::BITVECTOR_UGT, BITVECTOR_UGT},
+ {internal::Kind::BITVECTOR_UGE, BITVECTOR_UGE},
+ {internal::Kind::BITVECTOR_SLT, BITVECTOR_SLT},
+ {internal::Kind::BITVECTOR_SLE, BITVECTOR_SLE},
+ {internal::Kind::BITVECTOR_SGT, BITVECTOR_SGT},
+ {internal::Kind::BITVECTOR_SGE, BITVECTOR_SGE},
+ {internal::Kind::BITVECTOR_ULTBV, BITVECTOR_ULTBV},
+ {internal::Kind::BITVECTOR_SLTBV, BITVECTOR_SLTBV},
+ {internal::Kind::BITVECTOR_ITE, BITVECTOR_ITE},
+ {internal::Kind::BITVECTOR_REDOR, BITVECTOR_REDOR},
+ {internal::Kind::BITVECTOR_REDAND, BITVECTOR_REDAND},
+ {internal::Kind::BITVECTOR_EXTRACT_OP, BITVECTOR_EXTRACT},
+ {internal::Kind::BITVECTOR_REPEAT_OP, BITVECTOR_REPEAT},
+ {internal::Kind::BITVECTOR_ZERO_EXTEND_OP, BITVECTOR_ZERO_EXTEND},
+ {internal::Kind::BITVECTOR_SIGN_EXTEND_OP, BITVECTOR_SIGN_EXTEND},
+ {internal::Kind::BITVECTOR_ROTATE_LEFT_OP, BITVECTOR_ROTATE_LEFT},
+ {internal::Kind::BITVECTOR_ROTATE_RIGHT_OP, BITVECTOR_ROTATE_RIGHT},
+ {internal::Kind::BITVECTOR_EXTRACT, BITVECTOR_EXTRACT},
+ {internal::Kind::BITVECTOR_REPEAT, BITVECTOR_REPEAT},
+ {internal::Kind::BITVECTOR_ZERO_EXTEND, BITVECTOR_ZERO_EXTEND},
+ {internal::Kind::BITVECTOR_SIGN_EXTEND, BITVECTOR_SIGN_EXTEND},
+ {internal::Kind::BITVECTOR_ROTATE_LEFT, BITVECTOR_ROTATE_LEFT},
+ {internal::Kind::BITVECTOR_ROTATE_RIGHT, BITVECTOR_ROTATE_RIGHT},
+ {internal::Kind::INT_TO_BITVECTOR_OP, INT_TO_BITVECTOR},
+ {internal::Kind::INT_TO_BITVECTOR, INT_TO_BITVECTOR},
+ {internal::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_ADD, FLOATINGPOINT_ADD},
- {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_IS_NORMAL, FLOATINGPOINT_IS_NORMAL},
- {cvc5::Kind::FLOATINGPOINT_IS_SUBNORMAL, FLOATINGPOINT_IS_SUBNORMAL},
- {cvc5::Kind::FLOATINGPOINT_IS_ZERO, FLOATINGPOINT_IS_ZERO},
- {cvc5::Kind::FLOATINGPOINT_IS_INF, FLOATINGPOINT_IS_INF},
- {cvc5::Kind::FLOATINGPOINT_IS_NAN, FLOATINGPOINT_IS_NAN},
- {cvc5::Kind::FLOATINGPOINT_IS_NEG, FLOATINGPOINT_IS_NEG},
- {cvc5::Kind::FLOATINGPOINT_IS_POS, FLOATINGPOINT_IS_POS},
- {cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV_OP,
+ {internal::Kind::CONST_FLOATINGPOINT, CONST_FLOATINGPOINT},
+ {internal::Kind::CONST_ROUNDINGMODE, CONST_ROUNDINGMODE},
+ {internal::Kind::FLOATINGPOINT_FP, FLOATINGPOINT_FP},
+ {internal::Kind::FLOATINGPOINT_EQ, FLOATINGPOINT_EQ},
+ {internal::Kind::FLOATINGPOINT_ABS, FLOATINGPOINT_ABS},
+ {internal::Kind::FLOATINGPOINT_NEG, FLOATINGPOINT_NEG},
+ {internal::Kind::FLOATINGPOINT_ADD, FLOATINGPOINT_ADD},
+ {internal::Kind::FLOATINGPOINT_SUB, FLOATINGPOINT_SUB},
+ {internal::Kind::FLOATINGPOINT_MULT, FLOATINGPOINT_MULT},
+ {internal::Kind::FLOATINGPOINT_DIV, FLOATINGPOINT_DIV},
+ {internal::Kind::FLOATINGPOINT_FMA, FLOATINGPOINT_FMA},
+ {internal::Kind::FLOATINGPOINT_SQRT, FLOATINGPOINT_SQRT},
+ {internal::Kind::FLOATINGPOINT_REM, FLOATINGPOINT_REM},
+ {internal::Kind::FLOATINGPOINT_RTI, FLOATINGPOINT_RTI},
+ {internal::Kind::FLOATINGPOINT_MIN, FLOATINGPOINT_MIN},
+ {internal::Kind::FLOATINGPOINT_MAX, FLOATINGPOINT_MAX},
+ {internal::Kind::FLOATINGPOINT_LEQ, FLOATINGPOINT_LEQ},
+ {internal::Kind::FLOATINGPOINT_LT, FLOATINGPOINT_LT},
+ {internal::Kind::FLOATINGPOINT_GEQ, FLOATINGPOINT_GEQ},
+ {internal::Kind::FLOATINGPOINT_GT, FLOATINGPOINT_GT},
+ {internal::Kind::FLOATINGPOINT_IS_NORMAL, FLOATINGPOINT_IS_NORMAL},
+ {internal::Kind::FLOATINGPOINT_IS_SUBNORMAL,
+ FLOATINGPOINT_IS_SUBNORMAL},
+ {internal::Kind::FLOATINGPOINT_IS_ZERO, FLOATINGPOINT_IS_ZERO},
+ {internal::Kind::FLOATINGPOINT_IS_INF, FLOATINGPOINT_IS_INF},
+ {internal::Kind::FLOATINGPOINT_IS_NAN, FLOATINGPOINT_IS_NAN},
+ {internal::Kind::FLOATINGPOINT_IS_NEG, FLOATINGPOINT_IS_NEG},
+ {internal::Kind::FLOATINGPOINT_IS_POS, FLOATINGPOINT_IS_POS},
+ {internal::Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV_OP,
FLOATINGPOINT_TO_FP_FROM_IEEE_BV},
- {cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV,
+ {internal::Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV,
FLOATINGPOINT_TO_FP_FROM_IEEE_BV},
- {cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_FP_OP,
+ {internal::Kind::FLOATINGPOINT_TO_FP_FROM_FP_OP,
FLOATINGPOINT_TO_FP_FROM_FP},
- {cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_FP, FLOATINGPOINT_TO_FP_FROM_FP},
- {cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_REAL_OP,
+ {internal::Kind::FLOATINGPOINT_TO_FP_FROM_FP,
+ FLOATINGPOINT_TO_FP_FROM_FP},
+ {internal::Kind::FLOATINGPOINT_TO_FP_FROM_REAL_OP,
FLOATINGPOINT_TO_FP_FROM_REAL},
- {cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_REAL,
+ {internal::Kind::FLOATINGPOINT_TO_FP_FROM_REAL,
FLOATINGPOINT_TO_FP_FROM_REAL},
- {cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_SBV_OP,
+ {internal::Kind::FLOATINGPOINT_TO_FP_FROM_SBV_OP,
FLOATINGPOINT_TO_FP_FROM_SBV},
- {cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_SBV,
+ {internal::Kind::FLOATINGPOINT_TO_FP_FROM_SBV,
FLOATINGPOINT_TO_FP_FROM_SBV},
- {cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_UBV_OP,
+ {internal::Kind::FLOATINGPOINT_TO_FP_FROM_UBV_OP,
FLOATINGPOINT_TO_FP_FROM_UBV},
- {cvc5::Kind::FLOATINGPOINT_TO_FP_FROM_UBV,
+ {internal::Kind::FLOATINGPOINT_TO_FP_FROM_UBV,
FLOATINGPOINT_TO_FP_FROM_UBV},
- {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},
+ {internal::Kind::FLOATINGPOINT_TO_UBV_OP, FLOATINGPOINT_TO_UBV},
+ {internal::Kind::FLOATINGPOINT_TO_UBV, FLOATINGPOINT_TO_UBV},
+ {internal::Kind::FLOATINGPOINT_TO_UBV_TOTAL_OP, INTERNAL_KIND},
+ {internal::Kind::FLOATINGPOINT_TO_UBV_TOTAL, INTERNAL_KIND},
+ {internal::Kind::FLOATINGPOINT_TO_SBV_OP, FLOATINGPOINT_TO_SBV},
+ {internal::Kind::FLOATINGPOINT_TO_SBV, FLOATINGPOINT_TO_SBV},
+ {internal::Kind::FLOATINGPOINT_TO_SBV_TOTAL_OP, INTERNAL_KIND},
+ {internal::Kind::FLOATINGPOINT_TO_SBV_TOTAL, INTERNAL_KIND},
+ {internal::Kind::FLOATINGPOINT_TO_REAL, FLOATINGPOINT_TO_REAL},
+ {internal::Kind::FLOATINGPOINT_TO_REAL_TOTAL, INTERNAL_KIND},
/* Arrays ---------------------------------------------------------- */
- {cvc5::Kind::SELECT, SELECT},
- {cvc5::Kind::STORE, STORE},
- {cvc5::Kind::STORE_ALL, CONST_ARRAY},
+ {internal::Kind::SELECT, SELECT},
+ {internal::Kind::STORE, STORE},
+ {internal::Kind::STORE_ALL, CONST_ARRAY},
/* Datatypes ------------------------------------------------------- */
- {cvc5::Kind::APPLY_SELECTOR, APPLY_SELECTOR},
- {cvc5::Kind::APPLY_CONSTRUCTOR, APPLY_CONSTRUCTOR},
- {cvc5::Kind::APPLY_TESTER, APPLY_TESTER},
- {cvc5::Kind::APPLY_UPDATER, APPLY_UPDATER},
- {cvc5::Kind::DT_SIZE, DT_SIZE},
- {cvc5::Kind::MATCH, MATCH},
- {cvc5::Kind::MATCH_CASE, MATCH_CASE},
- {cvc5::Kind::MATCH_BIND_CASE, MATCH_BIND_CASE},
- {cvc5::Kind::TUPLE_PROJECT, TUPLE_PROJECT},
- {cvc5::Kind::TUPLE_PROJECT_OP, TUPLE_PROJECT},
+ {internal::Kind::APPLY_SELECTOR, APPLY_SELECTOR},
+ {internal::Kind::APPLY_CONSTRUCTOR, APPLY_CONSTRUCTOR},
+ {internal::Kind::APPLY_TESTER, APPLY_TESTER},
+ {internal::Kind::APPLY_UPDATER, APPLY_UPDATER},
+ {internal::Kind::DT_SIZE, DT_SIZE},
+ {internal::Kind::MATCH, MATCH},
+ {internal::Kind::MATCH_CASE, MATCH_CASE},
+ {internal::Kind::MATCH_BIND_CASE, MATCH_BIND_CASE},
+ {internal::Kind::TUPLE_PROJECT, TUPLE_PROJECT},
+ {internal::Kind::TUPLE_PROJECT_OP, 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},
+ {internal::Kind::SEP_NIL, SEP_NIL},
+ {internal::Kind::SEP_EMP, SEP_EMP},
+ {internal::Kind::SEP_PTO, SEP_PTO},
+ {internal::Kind::SEP_STAR, SEP_STAR},
+ {internal::Kind::SEP_WAND, SEP_WAND},
/* Sets ------------------------------------------------------------ */
- {cvc5::Kind::SET_EMPTY, SET_EMPTY},
- {cvc5::Kind::SET_UNION, SET_UNION},
- {cvc5::Kind::SET_INTER, SET_INTER},
- {cvc5::Kind::SET_MINUS, SET_MINUS},
- {cvc5::Kind::SET_SUBSET, SET_SUBSET},
- {cvc5::Kind::SET_MEMBER, SET_MEMBER},
- {cvc5::Kind::SET_SINGLETON, SET_SINGLETON},
- {cvc5::Kind::SET_INSERT, SET_INSERT},
- {cvc5::Kind::SET_CARD, SET_CARD},
- {cvc5::Kind::SET_COMPLEMENT, SET_COMPLEMENT},
- {cvc5::Kind::SET_UNIVERSE, SET_UNIVERSE},
- {cvc5::Kind::SET_COMPREHENSION, SET_COMPREHENSION},
- {cvc5::Kind::SET_CHOOSE, SET_CHOOSE},
- {cvc5::Kind::SET_IS_SINGLETON, SET_IS_SINGLETON},
- {cvc5::Kind::SET_MAP, SET_MAP},
+ {internal::Kind::SET_EMPTY, SET_EMPTY},
+ {internal::Kind::SET_UNION, SET_UNION},
+ {internal::Kind::SET_INTER, SET_INTER},
+ {internal::Kind::SET_MINUS, SET_MINUS},
+ {internal::Kind::SET_SUBSET, SET_SUBSET},
+ {internal::Kind::SET_MEMBER, SET_MEMBER},
+ {internal::Kind::SET_SINGLETON, SET_SINGLETON},
+ {internal::Kind::SET_INSERT, SET_INSERT},
+ {internal::Kind::SET_CARD, SET_CARD},
+ {internal::Kind::SET_COMPLEMENT, SET_COMPLEMENT},
+ {internal::Kind::SET_UNIVERSE, SET_UNIVERSE},
+ {internal::Kind::SET_COMPREHENSION, SET_COMPREHENSION},
+ {internal::Kind::SET_CHOOSE, SET_CHOOSE},
+ {internal::Kind::SET_IS_SINGLETON, SET_IS_SINGLETON},
+ {internal::Kind::SET_MAP, SET_MAP},
/* Relations ------------------------------------------------------- */
- {cvc5::Kind::RELATION_JOIN, RELATION_JOIN},
- {cvc5::Kind::RELATION_PRODUCT, RELATION_PRODUCT},
- {cvc5::Kind::RELATION_TRANSPOSE, RELATION_TRANSPOSE},
- {cvc5::Kind::RELATION_TCLOSURE, RELATION_TCLOSURE},
- {cvc5::Kind::RELATION_JOIN_IMAGE, RELATION_JOIN_IMAGE},
- {cvc5::Kind::RELATION_IDEN, RELATION_IDEN},
+ {internal::Kind::RELATION_JOIN, RELATION_JOIN},
+ {internal::Kind::RELATION_PRODUCT, RELATION_PRODUCT},
+ {internal::Kind::RELATION_TRANSPOSE, RELATION_TRANSPOSE},
+ {internal::Kind::RELATION_TCLOSURE, RELATION_TCLOSURE},
+ {internal::Kind::RELATION_JOIN_IMAGE, RELATION_JOIN_IMAGE},
+ {internal::Kind::RELATION_IDEN, RELATION_IDEN},
/* Bags ------------------------------------------------------------ */
- {cvc5::Kind::BAG_UNION_MAX, BAG_UNION_MAX},
- {cvc5::Kind::BAG_UNION_DISJOINT, BAG_UNION_DISJOINT},
- {cvc5::Kind::BAG_INTER_MIN, BAG_INTER_MIN},
- {cvc5::Kind::BAG_DIFFERENCE_SUBTRACT, BAG_DIFFERENCE_SUBTRACT},
- {cvc5::Kind::BAG_DIFFERENCE_REMOVE, BAG_DIFFERENCE_REMOVE},
- {cvc5::Kind::BAG_SUBBAG, BAG_SUBBAG},
- {cvc5::Kind::BAG_COUNT, BAG_COUNT},
- {cvc5::Kind::BAG_MEMBER, BAG_MEMBER},
- {cvc5::Kind::BAG_DUPLICATE_REMOVAL, BAG_DUPLICATE_REMOVAL},
- {cvc5::Kind::BAG_MAKE, BAG_MAKE},
- {cvc5::Kind::BAG_EMPTY, BAG_EMPTY},
- {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::BAG_MAP, BAG_MAP},
- {cvc5::Kind::BAG_FILTER, BAG_FILTER},
- {cvc5::Kind::BAG_FOLD, BAG_FOLD},
- {cvc5::Kind::TABLE_PRODUCT, TABLE_PRODUCT},
+ {internal::Kind::BAG_UNION_MAX, BAG_UNION_MAX},
+ {internal::Kind::BAG_UNION_DISJOINT, BAG_UNION_DISJOINT},
+ {internal::Kind::BAG_INTER_MIN, BAG_INTER_MIN},
+ {internal::Kind::BAG_DIFFERENCE_SUBTRACT, BAG_DIFFERENCE_SUBTRACT},
+ {internal::Kind::BAG_DIFFERENCE_REMOVE, BAG_DIFFERENCE_REMOVE},
+ {internal::Kind::BAG_SUBBAG, BAG_SUBBAG},
+ {internal::Kind::BAG_COUNT, BAG_COUNT},
+ {internal::Kind::BAG_MEMBER, BAG_MEMBER},
+ {internal::Kind::BAG_DUPLICATE_REMOVAL, BAG_DUPLICATE_REMOVAL},
+ {internal::Kind::BAG_MAKE, BAG_MAKE},
+ {internal::Kind::BAG_EMPTY, BAG_EMPTY},
+ {internal::Kind::BAG_CARD, BAG_CARD},
+ {internal::Kind::BAG_CHOOSE, BAG_CHOOSE},
+ {internal::Kind::BAG_IS_SINGLETON, BAG_IS_SINGLETON},
+ {internal::Kind::BAG_FROM_SET, BAG_FROM_SET},
+ {internal::Kind::BAG_TO_SET, BAG_TO_SET},
+ {internal::Kind::BAG_MAP, BAG_MAP},
+ {internal::Kind::BAG_FILTER, BAG_FILTER},
+ {internal::Kind::BAG_FOLD, BAG_FOLD},
+ {internal::Kind::TABLE_PRODUCT, TABLE_PRODUCT},
/* 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_CONTAINS, STRING_CONTAINS},
- {cvc5::Kind::STRING_INDEXOF, STRING_INDEXOF},
- {cvc5::Kind::STRING_INDEXOF_RE, STRING_INDEXOF_RE},
- {cvc5::Kind::STRING_REPLACE, STRING_REPLACE},
- {cvc5::Kind::STRING_REPLACE_ALL, STRING_REPLACE_ALL},
- {cvc5::Kind::STRING_REPLACE_RE, STRING_REPLACE_RE},
- {cvc5::Kind::STRING_REPLACE_RE_ALL, STRING_REPLACE_RE_ALL},
- {cvc5::Kind::STRING_TO_LOWER, STRING_TO_LOWER},
- {cvc5::Kind::STRING_TO_UPPER, STRING_TO_UPPER},
- {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_NONE, REGEXP_NONE},
- {cvc5::Kind::REGEXP_ALL, REGEXP_ALL},
- {cvc5::Kind::REGEXP_ALLCHAR, REGEXP_ALLCHAR},
- {cvc5::Kind::REGEXP_COMPLEMENT, REGEXP_COMPLEMENT},
- {cvc5::Kind::CONST_SEQUENCE, CONST_SEQUENCE},
- {cvc5::Kind::SEQ_UNIT, SEQ_UNIT},
- {cvc5::Kind::SEQ_NTH, SEQ_NTH},
+ {internal::Kind::STRING_CONCAT, STRING_CONCAT},
+ {internal::Kind::STRING_IN_REGEXP, STRING_IN_REGEXP},
+ {internal::Kind::STRING_LENGTH, STRING_LENGTH},
+ {internal::Kind::STRING_SUBSTR, STRING_SUBSTR},
+ {internal::Kind::STRING_UPDATE, STRING_UPDATE},
+ {internal::Kind::STRING_CHARAT, STRING_CHARAT},
+ {internal::Kind::STRING_CONTAINS, STRING_CONTAINS},
+ {internal::Kind::STRING_INDEXOF, STRING_INDEXOF},
+ {internal::Kind::STRING_INDEXOF_RE, STRING_INDEXOF_RE},
+ {internal::Kind::STRING_REPLACE, STRING_REPLACE},
+ {internal::Kind::STRING_REPLACE_ALL, STRING_REPLACE_ALL},
+ {internal::Kind::STRING_REPLACE_RE, STRING_REPLACE_RE},
+ {internal::Kind::STRING_REPLACE_RE_ALL, STRING_REPLACE_RE_ALL},
+ {internal::Kind::STRING_TO_LOWER, STRING_TO_LOWER},
+ {internal::Kind::STRING_TO_UPPER, STRING_TO_UPPER},
+ {internal::Kind::STRING_REV, STRING_REV},
+ {internal::Kind::STRING_FROM_CODE, STRING_FROM_CODE},
+ {internal::Kind::STRING_TO_CODE, STRING_TO_CODE},
+ {internal::Kind::STRING_LT, STRING_LT},
+ {internal::Kind::STRING_LEQ, STRING_LEQ},
+ {internal::Kind::STRING_PREFIX, STRING_PREFIX},
+ {internal::Kind::STRING_SUFFIX, STRING_SUFFIX},
+ {internal::Kind::STRING_IS_DIGIT, STRING_IS_DIGIT},
+ {internal::Kind::STRING_ITOS, STRING_FROM_INT},
+ {internal::Kind::STRING_STOI, STRING_TO_INT},
+ {internal::Kind::CONST_STRING, CONST_STRING},
+ {internal::Kind::STRING_TO_REGEXP, STRING_TO_REGEXP},
+ {internal::Kind::REGEXP_CONCAT, REGEXP_CONCAT},
+ {internal::Kind::REGEXP_UNION, REGEXP_UNION},
+ {internal::Kind::REGEXP_INTER, REGEXP_INTER},
+ {internal::Kind::REGEXP_DIFF, REGEXP_DIFF},
+ {internal::Kind::REGEXP_STAR, REGEXP_STAR},
+ {internal::Kind::REGEXP_PLUS, REGEXP_PLUS},
+ {internal::Kind::REGEXP_OPT, REGEXP_OPT},
+ {internal::Kind::REGEXP_RANGE, REGEXP_RANGE},
+ {internal::Kind::REGEXP_REPEAT, REGEXP_REPEAT},
+ {internal::Kind::REGEXP_REPEAT_OP, REGEXP_REPEAT},
+ {internal::Kind::REGEXP_LOOP, REGEXP_LOOP},
+ {internal::Kind::REGEXP_LOOP_OP, REGEXP_LOOP},
+ {internal::Kind::REGEXP_NONE, REGEXP_NONE},
+ {internal::Kind::REGEXP_ALL, REGEXP_ALL},
+ {internal::Kind::REGEXP_ALLCHAR, REGEXP_ALLCHAR},
+ {internal::Kind::REGEXP_COMPLEMENT, REGEXP_COMPLEMENT},
+ {internal::Kind::CONST_SEQUENCE, CONST_SEQUENCE},
+ {internal::Kind::SEQ_UNIT, SEQ_UNIT},
+ {internal::Kind::SEQ_NTH, SEQ_NTH},
/* Quantifiers ----------------------------------------------------- */
- {cvc5::Kind::FORALL, FORALL},
- {cvc5::Kind::EXISTS, EXISTS},
- {cvc5::Kind::BOUND_VAR_LIST, VARIABLE_LIST},
- {cvc5::Kind::INST_PATTERN, INST_PATTERN},
- {cvc5::Kind::INST_NO_PATTERN, INST_NO_PATTERN},
- {cvc5::Kind::INST_POOL, INST_POOL},
- {cvc5::Kind::INST_ADD_TO_POOL, INST_ADD_TO_POOL},
- {cvc5::Kind::SKOLEM_ADD_TO_POOL, SKOLEM_ADD_TO_POOL},
- {cvc5::Kind::INST_ATTRIBUTE, INST_ATTRIBUTE},
- {cvc5::Kind::INST_PATTERN_LIST, INST_PATTERN_LIST},
+ {internal::Kind::FORALL, FORALL},
+ {internal::Kind::EXISTS, EXISTS},
+ {internal::Kind::BOUND_VAR_LIST, VARIABLE_LIST},
+ {internal::Kind::INST_PATTERN, INST_PATTERN},
+ {internal::Kind::INST_NO_PATTERN, INST_NO_PATTERN},
+ {internal::Kind::INST_POOL, INST_POOL},
+ {internal::Kind::INST_ADD_TO_POOL, INST_ADD_TO_POOL},
+ {internal::Kind::SKOLEM_ADD_TO_POOL, SKOLEM_ADD_TO_POOL},
+ {internal::Kind::INST_ATTRIBUTE, INST_ATTRIBUTE},
+ {internal::Kind::INST_PATTERN_LIST, INST_PATTERN_LIST},
/* ----------------------------------------------------------------- */
- {cvc5::Kind::LAST_KIND, LAST_KIND},
+ {internal::Kind::LAST_KIND, LAST_KIND},
};
/* Set of kinds for indexed operators */
/* Rounding Mode for Floating Points */
/* -------------------------------------------------------------------------- */
-const static std::unordered_map<RoundingMode, cvc5::RoundingMode> 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},
- {ROUND_NEAREST_TIES_TO_AWAY,
- cvc5::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY},
-};
+const static std::unordered_map<RoundingMode, cvc5::internal::RoundingMode>
+ s_rmodes{
+ {ROUND_NEAREST_TIES_TO_EVEN,
+ cvc5::internal::RoundingMode::ROUND_NEAREST_TIES_TO_EVEN},
+ {ROUND_TOWARD_POSITIVE,
+ cvc5::internal::RoundingMode::ROUND_TOWARD_POSITIVE},
+ {ROUND_TOWARD_NEGATIVE,
+ cvc5::internal::RoundingMode::ROUND_TOWARD_NEGATIVE},
+ {ROUND_TOWARD_ZERO, cvc5::internal::RoundingMode::ROUND_TOWARD_ZERO},
+ {ROUND_NEAREST_TIES_TO_AWAY,
+ cvc5::internal::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY},
+ };
-const static std::unordered_map<cvc5::RoundingMode, RoundingMode>
+const static std::unordered_map<cvc5::internal::RoundingMode, RoundingMode>
s_rmodes_internal{
- {cvc5::RoundingMode::ROUND_NEAREST_TIES_TO_EVEN,
+ {cvc5::internal::RoundingMode::ROUND_NEAREST_TIES_TO_EVEN,
ROUND_NEAREST_TIES_TO_EVEN},
- {cvc5::RoundingMode::ROUND_TOWARD_POSITIVE, ROUND_TOWARD_POSITIVE},
- {cvc5::RoundingMode::ROUND_TOWARD_NEGATIVE, ROUND_TOWARD_NEGATIVE},
- {cvc5::RoundingMode::ROUND_TOWARD_ZERO, ROUND_TOWARD_ZERO},
- {cvc5::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY,
+ {cvc5::internal::RoundingMode::ROUND_TOWARD_POSITIVE,
+ ROUND_TOWARD_POSITIVE},
+ {cvc5::internal::RoundingMode::ROUND_TOWARD_NEGATIVE,
+ ROUND_TOWARD_NEGATIVE},
+ {cvc5::internal::RoundingMode::ROUND_TOWARD_ZERO, ROUND_TOWARD_ZERO},
+ {cvc5::internal::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY,
ROUND_NEAREST_TIES_TO_AWAY},
};
namespace {
-/** Convert a cvc5::Kind (internal) to a cvc5::api::Kind (external). */
-cvc5::api::Kind intToExtKind(cvc5::Kind k)
+/** Convert a internal::Kind (internal) to a cvc5::Kind (external).
+ */
+cvc5::Kind intToExtKind(internal::Kind k)
{
- auto it = api::s_kinds_internal.find(k);
- if (it == api::s_kinds_internal.end())
+ auto it = s_kinds_internal.find(k);
+ if (it == s_kinds_internal.end())
{
- return api::INTERNAL_KIND;
+ return INTERNAL_KIND;
}
return it->second;
}
-/** Convert a cvc5::api::Kind (external) to a cvc5::Kind (internal). */
-cvc5::Kind extToIntKind(cvc5::api::Kind k)
+/** Convert a cvc5::Kind (external) to a internal::Kind (internal).
+ */
+internal::Kind extToIntKind(cvc5::Kind k)
{
- auto it = api::s_kinds.find(k);
- if (it == api::s_kinds.end())
+ auto it = s_kinds.find(k);
+ if (it == s_kinds.end())
{
- return cvc5::Kind::UNDEFINED_KIND;
+ return internal::Kind::UNDEFINED_KIND;
}
return it->second.first;
}
* as datatype constructors/selectors/testers as terms
* but interally they are not
*/
-bool isApplyKind(cvc5::Kind k)
+bool isApplyKind(internal::Kind k)
{
- return (k == cvc5::Kind::APPLY_UF || k == cvc5::Kind::APPLY_CONSTRUCTOR
- || k == cvc5::Kind::APPLY_SELECTOR || k == cvc5::Kind::APPLY_TESTER
- || k == cvc5::Kind::APPLY_UPDATER);
+ return (k == internal::Kind::APPLY_UF
+ || k == internal::Kind::APPLY_CONSTRUCTOR
+ || k == internal::Kind::APPLY_SELECTOR
+ || k == internal::Kind::APPLY_TESTER
+ || k == internal::Kind::APPLY_UPDATER);
}
#ifdef CVC5_ASSERTIONS
/** Return true if given kind is a defined internal kind. */
-bool isDefinedIntKind(cvc5::Kind k)
+bool isDefinedIntKind(internal::Kind k)
{
- return k != cvc5::Kind::UNDEFINED_KIND && k != cvc5::Kind::LAST_KIND;
+ return k != internal::Kind::UNDEFINED_KIND && k != internal::Kind::LAST_KIND;
}
#endif
{
Assert(isDefinedKind(k));
Assert(isDefinedIntKind(extToIntKind(k)));
- uint32_t min = cvc5::kind::metakind::getMinArityForKind(extToIntKind(k));
+ uint32_t min = internal::kind::metakind::getMinArityForKind(extToIntKind(k));
// At the API level, we treat functions/constructors/selectors/testers as
// normal terms instead of making them part of the operator
{
Assert(isDefinedKind(k));
Assert(isDefinedIntKind(extToIntKind(k)));
- uint32_t max = cvc5::kind::metakind::getMaxArityForKind(extToIntKind(k));
+ uint32_t max = internal::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
#define CVC5_API_TRY_CATCH_BEGIN \
try \
{
-#define CVC5_API_TRY_CATCH_END \
- } \
- catch (const OptionException& e) \
- { \
- throw CVC5ApiOptionException(e.getMessage()); \
- } \
- catch (const cvc5::RecoverableModalException& e) \
- { \
- throw CVC5ApiRecoverableException(e.getMessage()); \
- } \
- catch (const cvc5::Exception& e) { throw CVC5ApiException(e.getMessage()); } \
+#define CVC5_API_TRY_CATCH_END \
+ } \
+ catch (const internal::OptionException& e) \
+ { \
+ throw CVC5ApiOptionException(e.getMessage()); \
+ } \
+ catch (const internal::RecoverableModalException& e) \
+ { \
+ throw CVC5ApiRecoverableException(e.getMessage()); \
+ } \
+ catch (const internal::Exception& e) \
+ { \
+ throw CVC5ApiException(e.getMessage()); \
+ } \
catch (const std::invalid_argument& e) { throw CVC5ApiException(e.what()); }
} // namespace
/* Result */
/* -------------------------------------------------------------------------- */
-Result::Result(const cvc5::Result& r) : d_result(new cvc5::Result(r)) {}
+Result::Result(const internal::Result& r) : d_result(new internal::Result(r)) {}
-Result::Result() : d_result(new cvc5::Result()) {}
+Result::Result() : d_result(new internal::Result()) {}
bool Result::isNull() const
{
- return d_result->getStatus() == cvc5::Result::NONE;
+ return d_result->getStatus() == internal::Result::NONE;
}
bool Result::isSat(void) const
{
- return d_result->getStatus() == cvc5::Result::SAT;
+ return d_result->getStatus() == internal::Result::SAT;
}
bool Result::isUnsat(void) const
{
- return d_result->getStatus() == cvc5::Result::UNSAT;
+ return d_result->getStatus() == internal::Result::UNSAT;
}
bool Result::isUnknown(void) const
{
- return d_result->getStatus() == cvc5::Result::UNKNOWN;
+ return d_result->getStatus() == internal::Result::UNKNOWN;
}
bool Result::operator==(const Result& r) const
Result::UnknownExplanation Result::getUnknownExplanation(void) const
{
- cvc5::Result::UnknownExplanation expl = d_result->getUnknownExplanation();
+ internal::Result::UnknownExplanation expl = d_result->getUnknownExplanation();
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 internal::Result::REQUIRES_FULL_CHECK: return REQUIRES_FULL_CHECK;
+ case internal::Result::INCOMPLETE: return INCOMPLETE;
+ case internal::Result::TIMEOUT: return TIMEOUT;
+ case internal::Result::RESOURCEOUT: return RESOURCEOUT;
+ case internal::Result::MEMOUT: return MEMOUT;
+ case internal::Result::INTERRUPTED: return INTERRUPTED;
+ case internal::Result::NO_STATUS: return NO_STATUS;
+ case internal::Result::UNSUPPORTED: return UNSUPPORTED;
+ case internal::Result::OTHER: return OTHER;
default: return UNKNOWN_REASON;
}
return UNKNOWN_REASON;
/* SynthResult */
/* -------------------------------------------------------------------------- */
-SynthResult::SynthResult(const cvc5::SynthResult& r)
- : d_result(new cvc5::SynthResult(r))
+SynthResult::SynthResult(const internal::SynthResult& r)
+ : d_result(new internal::SynthResult(r))
{
}
-SynthResult::SynthResult() : d_result(new cvc5::SynthResult()) {}
+SynthResult::SynthResult() : d_result(new internal::SynthResult()) {}
bool SynthResult::isNull() const
{
- return d_result->getStatus() == cvc5::SynthResult::NONE;
+ return d_result->getStatus() == internal::SynthResult::NONE;
}
bool SynthResult::hasSolution(void) const
{
- return d_result->getStatus() == cvc5::SynthResult::SOLUTION;
+ return d_result->getStatus() == internal::SynthResult::SOLUTION;
}
bool SynthResult::hasNoSolution() const
{
- return d_result->getStatus() == cvc5::SynthResult::NO_SOLUTION;
+ return d_result->getStatus() == internal::SynthResult::NO_SOLUTION;
}
bool SynthResult::isUnknown() const
{
- return d_result->getStatus() == cvc5::SynthResult::UNKNOWN;
+ return d_result->getStatus() == internal::SynthResult::UNKNOWN;
}
std::string SynthResult::toString(void) const { return d_result->toString(); }
-std::ostream& operator<<(std::ostream& out, const SynthResult& sr)
+std::ostream& operator<<(std::ostream& out, const internal::SynthResult& sr)
{
out << sr.toString();
return out;
/* 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 internal::TypeNode& t)
+ : d_solver(slv), d_type(new internal::TypeNode(t))
{
}
-Sort::Sort() : d_solver(nullptr), d_type(new cvc5::TypeNode()) {}
+Sort::Sort() : d_solver(nullptr), d_type(new internal::TypeNode()) {}
Sort::~Sort()
{
}
}
-std::set<TypeNode> Sort::sortSetToTypeNodes(const std::set<Sort>& sorts)
+std::set<internal::TypeNode> Sort::sortSetToTypeNodes(
+ const std::set<Sort>& sorts)
{
- std::set<TypeNode> types;
+ std::set<internal::TypeNode> types;
for (const Sort& s : sorts)
{
types.insert(s.getTypeNode());
return types;
}
-std::vector<TypeNode> Sort::sortVectorToTypeNodes(
+std::vector<internal::TypeNode> Sort::sortVectorToTypeNodes(
const std::vector<Sort>& sorts)
{
- std::vector<TypeNode> typeNodes;
+ std::vector<internal::TypeNode> typeNodes;
for (const Sort& sort : sorts)
{
typeNodes.push_back(sort.getTypeNode());
}
std::vector<Sort> Sort::typeNodeVectorToSorts(
- const Solver* slv, const std::vector<TypeNode>& types)
+ const Solver* slv, const std::vector<internal::TypeNode>& types)
{
std::vector<Sort> sorts;
for (size_t i = 0, tsize = types.size(); i < tsize; i++)
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_type->hasAttribute(expr::VarNameAttr());
+ return d_type->hasAttribute(internal::expr::VarNameAttr());
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
- CVC5_API_CHECK(d_type->hasAttribute(expr::VarNameAttr()))
+ CVC5_API_CHECK(d_type->hasAttribute(internal::expr::VarNameAttr()))
<< "Invalid call to '" << __PRETTY_FUNCTION__
<< "', expected the sort to have a symbol.";
//////// all checks before this line
- return d_type->getAttribute(expr::VarNameAttr());
+ return d_type->getAttribute(internal::expr::VarNameAttr());
////////
CVC5_API_TRY_CATCH_END;
}
|| d_type->getSortConstructorArity() == params.size())
<< "Arity mismatch for instantiated sort constructor";
//////// all checks before this line
- std::vector<cvc5::TypeNode> tparams = sortVectorToTypeNodes(params);
+ std::vector<internal::TypeNode> tparams = sortVectorToTypeNodes(params);
if (d_type->isDatatype())
{
return Sort(d_solver, d_type->instantiateParametricDatatype(tparams));
CVC5_API_CHECK_SORTS(replacements);
//////// all checks before this line
- std::vector<cvc5::TypeNode> tSorts = sortVectorToTypeNodes(sorts),
- tReplacements =
- sortVectorToTypeNodes(replacements);
+ std::vector<internal::TypeNode> tSorts = sortVectorToTypeNodes(sorts),
+ tReplacements =
+ sortVectorToTypeNodes(replacements);
return Sort(d_solver,
d_type->substitute(tSorts.begin(),
tSorts.end(),
CVC5_API_TRY_CATCH_END;
}
-const cvc5::TypeNode& Sort::getTypeNode(void) const { return *d_type; }
+const internal::TypeNode& Sort::getTypeNode(void) const { return *d_type; }
/* Constructor sort ------------------------------------------------------- */
/* Op */
/* -------------------------------------------------------------------------- */
-Op::Op() : d_solver(nullptr), d_kind(NULL_TERM), d_node(new cvc5::Node()) {}
+Op::Op() : d_solver(nullptr), d_kind(NULL_TERM), d_node(new internal::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 internal::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 internal::Node& n)
+ : d_solver(slv), d_kind(k), d_node(new internal::Node(n))
{
}
case FLOATINGPOINT_TO_FP_FROM_UBV: size = 2; break;
case REGEXP_LOOP: size = 2; break;
case TUPLE_PROJECT:
- size = d_node->getConst<TupleProjectOp>().getIndices().size();
+ size = d_node->getConst<internal::TupleProjectOp>().getIndices().size();
break;
default: CVC5_API_CHECK(false) << "Unhandled kind " << kindToString(k);
}
case DIVISIBLE:
{
t = d_solver->mkRationalValHelper(
- Rational(d_node->getConst<Divisible>().k));
+ internal::Rational(d_node->getConst<internal::Divisible>().k));
break;
}
case BITVECTOR_REPEAT:
{
t = d_solver->mkRationalValHelper(
- d_node->getConst<BitVectorRepeat>().d_repeatAmount);
+ d_node->getConst<internal::BitVectorRepeat>().d_repeatAmount);
break;
}
case BITVECTOR_ZERO_EXTEND:
{
t = d_solver->mkRationalValHelper(
- d_node->getConst<BitVectorZeroExtend>().d_zeroExtendAmount);
+ d_node->getConst<internal::BitVectorZeroExtend>().d_zeroExtendAmount);
break;
}
case BITVECTOR_SIGN_EXTEND:
{
t = d_solver->mkRationalValHelper(
- d_node->getConst<BitVectorSignExtend>().d_signExtendAmount);
+ d_node->getConst<internal::BitVectorSignExtend>().d_signExtendAmount);
break;
}
case BITVECTOR_ROTATE_LEFT:
{
t = d_solver->mkRationalValHelper(
- d_node->getConst<BitVectorRotateLeft>().d_rotateLeftAmount);
+ d_node->getConst<internal::BitVectorRotateLeft>().d_rotateLeftAmount);
break;
}
case BITVECTOR_ROTATE_RIGHT:
{
t = d_solver->mkRationalValHelper(
- d_node->getConst<BitVectorRotateRight>().d_rotateRightAmount);
+ d_node->getConst<internal::BitVectorRotateRight>()
+ .d_rotateRightAmount);
break;
}
case INT_TO_BITVECTOR:
{
t = d_solver->mkRationalValHelper(
- d_node->getConst<IntToBitVector>().d_size);
+ d_node->getConst<internal::IntToBitVector>().d_size);
break;
}
case IAND:
{
- t = d_solver->mkRationalValHelper(d_node->getConst<IntAnd>().d_size);
+ t = d_solver->mkRationalValHelper(
+ d_node->getConst<internal::IntAnd>().d_size);
break;
}
case FLOATINGPOINT_TO_UBV:
{
t = d_solver->mkRationalValHelper(
- d_node->getConst<FloatingPointToUBV>().d_bv_size.d_size);
+ d_node->getConst<internal::FloatingPointToUBV>().d_bv_size.d_size);
break;
}
case FLOATINGPOINT_TO_SBV:
{
t = d_solver->mkRationalValHelper(
- d_node->getConst<FloatingPointToSBV>().d_bv_size.d_size);
+ d_node->getConst<internal::FloatingPointToSBV>().d_bv_size.d_size);
break;
}
case REGEXP_REPEAT:
{
t = d_solver->mkRationalValHelper(
- d_node->getConst<RegExpRepeat>().d_repeatAmount);
+ d_node->getConst<internal::RegExpRepeat>().d_repeatAmount);
break;
}
case BITVECTOR_EXTRACT:
{
- cvc5::BitVectorExtract ext = d_node->getConst<BitVectorExtract>();
+ internal::BitVectorExtract ext =
+ d_node->getConst<internal::BitVectorExtract>();
t = index == 0 ? d_solver->mkRationalValHelper(ext.d_high)
: d_solver->mkRationalValHelper(ext.d_low);
break;
}
case FLOATINGPOINT_TO_FP_FROM_IEEE_BV:
{
- cvc5::FloatingPointToFPIEEEBitVector ext =
- d_node->getConst<FloatingPointToFPIEEEBitVector>();
+ internal::FloatingPointToFPIEEEBitVector ext =
+ d_node->getConst<internal::FloatingPointToFPIEEEBitVector>();
t = index == 0
? d_solver->mkRationalValHelper(ext.getSize().exponentWidth())
}
case FLOATINGPOINT_TO_FP_FROM_FP:
{
- cvc5::FloatingPointToFPFloatingPoint ext =
- d_node->getConst<FloatingPointToFPFloatingPoint>();
+ internal::FloatingPointToFPFloatingPoint ext =
+ d_node->getConst<internal::FloatingPointToFPFloatingPoint>();
t = index == 0
? d_solver->mkRationalValHelper(ext.getSize().exponentWidth())
: d_solver->mkRationalValHelper(ext.getSize().significandWidth());
}
case FLOATINGPOINT_TO_FP_FROM_REAL:
{
- cvc5::FloatingPointToFPReal ext =
- d_node->getConst<FloatingPointToFPReal>();
+ internal::FloatingPointToFPReal ext =
+ d_node->getConst<internal::FloatingPointToFPReal>();
t = index == 0
? d_solver->mkRationalValHelper(ext.getSize().exponentWidth())
}
case FLOATINGPOINT_TO_FP_FROM_SBV:
{
- cvc5::FloatingPointToFPSignedBitVector ext =
- d_node->getConst<FloatingPointToFPSignedBitVector>();
+ internal::FloatingPointToFPSignedBitVector ext =
+ d_node->getConst<internal::FloatingPointToFPSignedBitVector>();
t = index == 0
? d_solver->mkRationalValHelper(ext.getSize().exponentWidth())
: d_solver->mkRationalValHelper(ext.getSize().significandWidth());
}
case FLOATINGPOINT_TO_FP_FROM_UBV:
{
- cvc5::FloatingPointToFPUnsignedBitVector ext =
- d_node->getConst<FloatingPointToFPUnsignedBitVector>();
+ internal::FloatingPointToFPUnsignedBitVector ext =
+ d_node->getConst<internal::FloatingPointToFPUnsignedBitVector>();
t = index == 0
? d_solver->mkRationalValHelper(ext.getSize().exponentWidth())
: d_solver->mkRationalValHelper(ext.getSize().significandWidth());
}
case REGEXP_LOOP:
{
- cvc5::RegExpLoop ext = d_node->getConst<RegExpLoop>();
+ internal::RegExpLoop ext = d_node->getConst<internal::RegExpLoop>();
t = index == 0 ? d_solver->mkRationalValHelper(ext.d_loopMinOcc)
: d_solver->mkRationalValHelper(ext.d_loopMaxOcc);
case TUPLE_PROJECT:
{
const std::vector<uint32_t>& projectionIndices =
- d_node->getConst<TupleProjectOp>().getIndices();
+ d_node->getConst<internal::TupleProjectOp>().getIndices();
t = d_solver->mkRationalValHelper(projectionIndices[index]);
break;
}
/* Term */
/* -------------------------------------------------------------------------- */
-Term::Term() : d_solver(nullptr), d_node(new cvc5::Node()) {}
+Term::Term() : d_solver(nullptr), d_node(new internal::Node()) {}
-Term::Term(const Solver* slv, const cvc5::Node& n) : d_solver(slv)
+Term::Term(const Solver* slv, const internal::Node& n) : d_solver(slv)
{
- d_node.reset(new cvc5::Node(n));
+ d_node.reset(new internal::Node(n));
}
Term::~Term()
CVC5_API_CHECK(term.getSort() == replacement.getSort())
<< "Expecting terms of the same sort in substitute";
//////// all checks before this line
- return Term(
- d_solver,
- d_node->substitute(TNode(*term.d_node), TNode(*replacement.d_node)));
+ return Term(d_solver,
+ d_node->substitute(internal::TNode(*term.d_node),
+ internal::TNode(*replacement.d_node)));
////////
CVC5_API_TRY_CATCH_END;
}
<< "Expecting vectors of the same arity in substitute";
CVC5_API_TERM_CHECK_TERMS_WITH_TERMS_SORT_EQUAL_TO(terms, replacements);
//////// all checks before this line
- std::vector<Node> nodes = Term::termVectorToNodes(terms);
- std::vector<Node> nodeReplacements = Term::termVectorToNodes(replacements);
+ std::vector<internal::Node> nodes = Term::termVectorToNodes(terms);
+ std::vector<internal::Node> nodeReplacements =
+ Term::termVectorToNodes(replacements);
return Term(d_solver,
d_node->substitute(nodes.begin(),
nodes.end(),
{
return Op(d_solver, intToExtKind(d_node->getKind()));
}
- else if (d_node->getMetaKind() == kind::metakind::PARAMETERIZED)
+ else if (d_node->getMetaKind() == internal::kind::metakind::PARAMETERIZED)
{
// it's an indexed operator
// so we should return the indexed op
- cvc5::Node op = d_node->getOperator();
+ internal::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
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->hasAttribute(expr::VarNameAttr());
+ return d_node->hasAttribute(internal::expr::VarNameAttr());
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
- CVC5_API_CHECK(d_node->hasAttribute(expr::VarNameAttr()))
+ CVC5_API_CHECK(d_node->hasAttribute(internal::expr::VarNameAttr()))
<< "Invalid call to '" << __PRETTY_FUNCTION__
<< "', expected the term to have a symbol.";
//////// all checks before this line
- return d_node->getAttribute(expr::VarNameAttr());
+ return d_node->getAttribute(internal::expr::VarNameAttr());
////////
CVC5_API_TRY_CATCH_END;
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- Node res = d_node->notNode();
+ internal::Node res = d_node->notNode();
(void)res.getType(true); /* kick off type checking */
return Term(d_solver, res);
////////
CVC5_API_CHECK_NOT_NULL;
CVC5_API_CHECK_TERM(t);
//////// all checks before this line
- Node res = d_node->andNode(*t.d_node);
+ internal::Node res = d_node->andNode(*t.d_node);
(void)res.getType(true); /* kick off type checking */
return Term(d_solver, res);
////////
CVC5_API_CHECK_NOT_NULL;
CVC5_API_CHECK_TERM(t);
//////// all checks before this line
- Node res = d_node->orNode(*t.d_node);
+ internal::Node res = d_node->orNode(*t.d_node);
(void)res.getType(true); /* kick off type checking */
return Term(d_solver, res);
////////
CVC5_API_CHECK_NOT_NULL;
CVC5_API_CHECK_TERM(t);
//////// all checks before this line
- Node res = d_node->xorNode(*t.d_node);
+ internal::Node res = d_node->xorNode(*t.d_node);
(void)res.getType(true); /* kick off type checking */
return Term(d_solver, res);
////////
CVC5_API_CHECK_NOT_NULL;
CVC5_API_CHECK_TERM(t);
//////// all checks before this line
- Node res = d_node->eqNode(*t.d_node);
+ internal::Node res = d_node->eqNode(*t.d_node);
(void)res.getType(true); /* kick off type checking */
return Term(d_solver, res);
////////
CVC5_API_CHECK_NOT_NULL;
CVC5_API_CHECK_TERM(t);
//////// all checks before this line
- Node res = d_node->impNode(*t.d_node);
+ internal::Node res = d_node->impNode(*t.d_node);
(void)res.getType(true); /* kick off type checking */
return Term(d_solver, res);
////////
CVC5_API_CHECK_TERM(then_t);
CVC5_API_CHECK_TERM(else_t);
//////// all checks before this line
- Node res = d_node->iteNode(*then_t.d_node, *else_t.d_node);
+ internal::Node res = d_node->iteNode(*then_t.d_node, *else_t.d_node);
(void)res.getType(true); /* kick off type checking */
return Term(d_solver, res);
////////
}
Term::const_iterator::const_iterator(const Solver* slv,
- const std::shared_ptr<cvc5::Node>& n,
+ const std::shared_ptr<internal::Node>& n,
uint32_t p)
: d_solver(slv), d_origNode(n), d_pos(p)
{
return Term::const_iterator(d_solver, d_node, endpos);
}
-const cvc5::Node& Term::getNode(void) const { return *d_node; }
+const internal::Node& Term::getNode(void) const { return *d_node; }
namespace detail {
-const Rational& getRational(const cvc5::Node& node)
+const internal::Rational& getRational(const internal::Node& node)
{
switch (node.getKind())
{
- case cvc5::Kind::CAST_TO_REAL: return node[0].getConst<Rational>();
- case cvc5::Kind::CONST_RATIONAL: return node.getConst<Rational>();
+ case internal::Kind::CAST_TO_REAL:
+ return node[0].getConst<internal::Rational>();
+ case internal::Kind::CONST_RATIONAL:
+ return node.getConst<internal::Rational>();
default:
CVC5_API_CHECK(false) << "Node is not a rational.";
- return node.getConst<Rational>();
+ return node.getConst<internal::Rational>();
}
}
-Integer getInteger(const cvc5::Node& node)
+internal::Integer getInteger(const internal::Node& node)
{
- return node.getConst<Rational>().getNumerator();
+ return node.getConst<internal::Rational>().getNumerator();
}
template <typename T>
-bool checkIntegerBounds(const Integer& i)
+bool checkIntegerBounds(const internal::Integer& i)
{
return i >= std::numeric_limits<T>::min()
&& i <= std::numeric_limits<T>::max();
}
-bool checkReal32Bounds(const Rational& r)
+bool checkReal32Bounds(const internal::Rational& r)
{
return checkIntegerBounds<std::int32_t>(r.getNumerator())
&& checkIntegerBounds<std::uint32_t>(r.getDenominator());
}
-bool checkReal64Bounds(const Rational& r)
+bool checkReal64Bounds(const internal::Rational& r)
{
return checkIntegerBounds<std::int64_t>(r.getNumerator())
&& checkIntegerBounds<std::uint64_t>(r.getDenominator());
}
-bool isReal(const Node& node)
+bool isReal(const internal::Node& node)
{
- return node.getKind() == cvc5::Kind::CONST_RATIONAL
- || node.getKind() == cvc5::Kind::CAST_TO_REAL;
+ return node.getKind() == internal::Kind::CONST_RATIONAL
+ || node.getKind() == internal::Kind::CAST_TO_REAL;
}
-bool isReal32(const Node& node)
+bool isReal32(const internal::Node& node)
{
return isReal(node) && checkReal32Bounds(getRational(node));
}
-bool isReal64(const Node& node)
+bool isReal64(const internal::Node& node)
{
return isReal(node) && checkReal64Bounds(getRational(node));
}
-bool isInteger(const Node& node)
+bool isInteger(const internal::Node& node)
{
- return node.getKind() == cvc5::Kind::CONST_RATIONAL
- && node.getConst<Rational>().isIntegral();
+ return node.getKind() == internal::Kind::CONST_RATIONAL
+ && node.getConst<internal::Rational>().isIntegral();
}
-bool isInt32(const Node& node)
+bool isInt32(const internal::Node& node)
{
return isInteger(node) && checkIntegerBounds<std::int32_t>(getInteger(node));
}
-bool isUInt32(const Node& node)
+bool isUInt32(const internal::Node& node)
{
return isInteger(node) && checkIntegerBounds<std::uint32_t>(getInteger(node));
}
-bool isInt64(const Node& node)
+bool isInt64(const internal::Node& node)
{
return isInteger(node) && checkIntegerBounds<std::int64_t>(getInteger(node));
}
-bool isUInt64(const Node& node)
+bool isUInt64(const internal::Node& node)
{
return isInteger(node) && checkIntegerBounds<std::uint64_t>(getInteger(node));
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- const Rational& r = detail::getRational(*d_node);
+ const internal::Rational& r = detail::getRational(*d_node);
return static_cast<int32_t>(r.sgn());
////////
CVC5_API_TRY_CATCH_END;
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == cvc5::Kind::CONST_STRING;
+ return d_node->getKind() == internal::Kind::CONST_STRING;
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
- CVC5_API_ARG_CHECK_EXPECTED(d_node->getKind() == cvc5::Kind::CONST_STRING,
+ CVC5_API_ARG_CHECK_EXPECTED(d_node->getKind() == internal::Kind::CONST_STRING,
*d_node)
<< "Term to be a string value when calling getStringValue()";
//////// all checks before this line
- return d_node->getConst<cvc5::String>().toWString();
+ return d_node->getConst<internal::String>().toWString();
////////
CVC5_API_TRY_CATCH_END;
}
-std::vector<Node> Term::termVectorToNodes(const std::vector<Term>& terms)
+std::vector<internal::Node> Term::termVectorToNodes(
+ const std::vector<Term>& terms)
{
- std::vector<Node> res;
+ std::vector<internal::Node> res;
for (const Term& t : terms)
{
res.push_back(t.getNode());
return res;
}
-std::vector<Term> Term::nodeVectorToTerms(const Solver* slv,
- const std::vector<Node>& nodes)
+std::vector<Term> Term::nodeVectorToTerms(
+ const Solver* slv, const std::vector<internal::Node>& nodes)
{
std::vector<Term> res;
- for (const Node& n : nodes)
+ for (const internal::Node& n : nodes)
{
res.push_back(Term(slv, n));
}
CVC5_API_ARG_CHECK_EXPECTED(detail::isReal32(*d_node), *d_node)
<< "Term to be a 32-bit rational value when calling getReal32Value()";
//////// all checks before this line
- const Rational& r = detail::getRational(*d_node);
+ const internal::Rational& r = detail::getRational(*d_node);
return std::make_pair(r.getNumerator().getSignedInt(),
r.getDenominator().getUnsignedInt());
////////
CVC5_API_ARG_CHECK_EXPECTED(detail::isReal64(*d_node), *d_node)
<< "Term to be a 64-bit rational value when calling getReal64Value()";
//////// all checks before this line
- const Rational& r = detail::getRational(*d_node);
+ const internal::Rational& r = detail::getRational(*d_node);
return std::make_pair(r.getNumerator().getSigned64(),
r.getDenominator().getUnsigned64());
////////
CVC5_API_ARG_CHECK_EXPECTED(detail::isReal(*d_node), *d_node)
<< "Term to be a rational value when calling getRealValue()";
//////// all checks before this line
- const Rational& rat = detail::getRational(*d_node);
+ const internal::Rational& rat = detail::getRational(*d_node);
std::string res = rat.toString();
if (rat.isIntegral())
{
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == cvc5::Kind::STORE_ALL;
+ return d_node->getKind() == internal::Kind::STORE_ALL;
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
- CVC5_API_ARG_CHECK_EXPECTED(d_node->getKind() == cvc5::Kind::STORE_ALL,
+ CVC5_API_ARG_CHECK_EXPECTED(d_node->getKind() == internal::Kind::STORE_ALL,
*d_node)
<< "Term to be a constant array when calling getConstArrayBase()";
//////// all checks before this line
- const auto& ar = d_node->getConst<ArrayStoreAll>();
+ const auto& ar = d_node->getConst<internal::ArrayStoreAll>();
return Term(d_solver, ar.getValue());
////////
CVC5_API_TRY_CATCH_END;
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == cvc5::Kind::CONST_BOOLEAN;
+ return d_node->getKind() == internal::Kind::CONST_BOOLEAN;
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
- CVC5_API_ARG_CHECK_EXPECTED(d_node->getKind() == cvc5::Kind::CONST_BOOLEAN,
- *d_node)
+ CVC5_API_ARG_CHECK_EXPECTED(
+ d_node->getKind() == internal::Kind::CONST_BOOLEAN, *d_node)
<< "Term to be a Boolean value when calling getBooleanValue()";
//////// all checks before this line
return d_node->getConst<bool>();
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == cvc5::Kind::CONST_BITVECTOR;
+ return d_node->getKind() == internal::Kind::CONST_BITVECTOR;
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
- CVC5_API_ARG_CHECK_EXPECTED(d_node->getKind() == cvc5::Kind::CONST_BITVECTOR,
- *d_node)
+ CVC5_API_ARG_CHECK_EXPECTED(
+ d_node->getKind() == internal::Kind::CONST_BITVECTOR, *d_node)
<< "Term to be a bit-vector value when calling getBitVectorValue()";
//////// all checks before this line
- return d_node->getConst<BitVector>().toString(base);
+ return d_node->getConst<internal::BitVector>().toString(base);
////////
CVC5_API_TRY_CATCH_END;
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == cvc5::Kind::UNINTERPRETED_SORT_VALUE;
+ return d_node->getKind() == internal::Kind::UNINTERPRETED_SORT_VALUE;
////////
CVC5_API_TRY_CATCH_END;
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
CVC5_API_ARG_CHECK_EXPECTED(
- d_node->getKind() == cvc5::Kind::UNINTERPRETED_SORT_VALUE, *d_node)
+ d_node->getKind() == internal::Kind::UNINTERPRETED_SORT_VALUE, *d_node)
<< "Term to be an abstract value when calling "
"getUninterpretedSortValue()";
//////// all checks before this line
std::stringstream ss;
- ss << d_node->getConst<UninterpretedSortValue>();
+ ss << d_node->getConst<internal::UninterpretedSortValue>();
return ss.str();
////////
CVC5_API_TRY_CATCH_END;
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == cvc5::Kind::APPLY_CONSTRUCTOR && d_node->isConst()
- && d_node->getType().getDType().isTuple();
+ return d_node->getKind() == internal::Kind::APPLY_CONSTRUCTOR
+ && d_node->isConst() && d_node->getType().getDType().isTuple();
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
- CVC5_API_ARG_CHECK_EXPECTED(d_node->getKind() == cvc5::Kind::APPLY_CONSTRUCTOR
- && d_node->isConst()
- && d_node->getType().getDType().isTuple(),
- *d_node)
+ CVC5_API_ARG_CHECK_EXPECTED(
+ d_node->getKind() == internal::Kind::APPLY_CONSTRUCTOR
+ && d_node->isConst() && d_node->getType().getDType().isTuple(),
+ *d_node)
<< "Term to be a tuple value when calling getTupleValue()";
//////// all checks before this line
std::vector<Term> res;
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == cvc5::Kind::CONST_ROUNDINGMODE;
+ return d_node->getKind() == internal::Kind::CONST_ROUNDINGMODE;
////////
CVC5_API_TRY_CATCH_END;
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
CVC5_API_ARG_CHECK_EXPECTED(
- d_node->getKind() == cvc5::Kind::CONST_ROUNDINGMODE, *d_node)
+ d_node->getKind() == internal::Kind::CONST_ROUNDINGMODE, *d_node)
<< "Term to be a floating-point rounding mode value when calling "
"getRoundingModeValue()";
//////// all checks before this line
- return s_rmodes_internal.at(d_node->getConst<cvc5::RoundingMode>());
+ return s_rmodes_internal.at(d_node->getConst<cvc5::internal::RoundingMode>());
////////
CVC5_API_TRY_CATCH_END;
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- if (d_node->getKind() == cvc5::Kind::CONST_FLOATINGPOINT)
+ if (d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT)
{
- const auto& fp = d_node->getConst<FloatingPoint>();
+ const auto& fp = d_node->getConst<internal::FloatingPoint>();
return fp.isZero() && fp.isPositive();
}
return false;
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- if (d_node->getKind() == cvc5::Kind::CONST_FLOATINGPOINT)
+ if (d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT)
{
- const auto& fp = d_node->getConst<FloatingPoint>();
+ const auto& fp = d_node->getConst<internal::FloatingPoint>();
return fp.isZero() && fp.isNegative();
}
return false;
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- if (d_node->getKind() == cvc5::Kind::CONST_FLOATINGPOINT)
+ if (d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT)
{
- const auto& fp = d_node->getConst<FloatingPoint>();
+ const auto& fp = d_node->getConst<internal::FloatingPoint>();
return fp.isInfinite() && fp.isPositive();
}
return false;
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- if (d_node->getKind() == cvc5::Kind::CONST_FLOATINGPOINT)
+ if (d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT)
{
- const auto& fp = d_node->getConst<FloatingPoint>();
+ const auto& fp = d_node->getConst<internal::FloatingPoint>();
return fp.isInfinite() && fp.isNegative();
}
return false;
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == cvc5::Kind::CONST_FLOATINGPOINT
- && d_node->getConst<FloatingPoint>().isNaN();
+ return d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT
+ && d_node->getConst<internal::FloatingPoint>().isNaN();
////////
CVC5_API_TRY_CATCH_END;
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == cvc5::Kind::CONST_FLOATINGPOINT;
+ return d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT;
////////
CVC5_API_TRY_CATCH_END;
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
CVC5_API_ARG_CHECK_EXPECTED(
- d_node->getKind() == cvc5::Kind::CONST_FLOATINGPOINT, *d_node)
+ d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT, *d_node)
<< "Term to be a floating-point value when calling "
"getFloatingPointValue()";
//////// all checks before this line
- const auto& fp = d_node->getConst<FloatingPoint>();
+ const auto& fp = d_node->getConst<internal::FloatingPoint>();
return std::make_tuple(fp.getSize().exponentWidth(),
fp.getSize().significandWidth(),
d_solver->mkValHelper(fp.pack()));
}
void Term::collectSet(std::set<Term>& set,
- const cvc5::Node& node,
+ const internal::Node& node,
const Solver* slv)
{
// We asserted that node has a set type, and node.isConst()
// Thus, node only contains of SET_EMPTY, SET_UNION and SET_SINGLETON.
switch (node.getKind())
{
- case cvc5::Kind::SET_EMPTY: break;
- case cvc5::Kind::SET_SINGLETON: set.emplace(Term(slv, node[0])); break;
- case cvc5::Kind::SET_UNION:
+ case internal::Kind::SET_EMPTY: break;
+ case internal::Kind::SET_SINGLETON: set.emplace(Term(slv, node[0])); break;
+ case internal::Kind::SET_UNION:
{
for (const auto& sub : node)
{
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == cvc5::Kind::CONST_SEQUENCE;
+ return d_node->getKind() == internal::Kind::CONST_SEQUENCE;
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
- CVC5_API_ARG_CHECK_EXPECTED(d_node->getKind() == cvc5::Kind::CONST_SEQUENCE,
- *d_node)
+ CVC5_API_ARG_CHECK_EXPECTED(
+ d_node->getKind() == internal::Kind::CONST_SEQUENCE, *d_node)
<< "Term to be a sequence value when calling getSequenceValue()";
//////// all checks before this line
std::vector<Term> res;
- const Sequence& seq = d_node->getConst<Sequence>();
+ const internal::Sequence& seq = d_node->getConst<internal::Sequence>();
for (const auto& node: seq.getVec())
{
res.emplace_back(Term(d_solver, node));
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
//////// all checks before this line
- return d_node->getKind() == cvc5::Kind::CARDINALITY_CONSTRAINT;
+ return d_node->getKind() == internal::Kind::CARDINALITY_CONSTRAINT;
////////
CVC5_API_TRY_CATCH_END;
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK_NOT_NULL;
CVC5_API_ARG_CHECK_EXPECTED(
- d_node->getKind() == cvc5::Kind::CARDINALITY_CONSTRAINT, *d_node)
+ d_node->getKind() == internal::Kind::CARDINALITY_CONSTRAINT, *d_node)
<< "Term to be a cardinality constraint when calling "
"getCardinalityConstraint()";
// this should never happen since we restrict what the user can create
- CVC5_API_ARG_CHECK_EXPECTED(detail::checkIntegerBounds<std::uint32_t>(
- d_node->getOperator()
- .getConst<CardinalityConstraint>()
- .getUpperBound()),
- *d_node)
+ CVC5_API_ARG_CHECK_EXPECTED(
+ detail::checkIntegerBounds<std::uint32_t>(
+ d_node->getOperator()
+ .getConst<internal::CardinalityConstraint>()
+ .getUpperBound()),
+ *d_node)
<< "Upper bound for cardinality constraint does not fit uint32_t";
//////// all checks before this line
- const CardinalityConstraint& cc =
- d_node->getOperator().getConst<CardinalityConstraint>();
+ const internal::CardinalityConstraint& cc =
+ d_node->getOperator().getConst<internal::CardinalityConstraint>();
return std::make_pair(Sort(d_solver, cc.getType()),
cc.getUpperBound().getUnsignedInt());
////////
std::ostream& operator<<(std::ostream& out, const std::vector<Term>& vector)
{
- container_to_stream(out, vector);
+ internal::container_to_stream(out, vector);
return out;
}
std::ostream& operator<<(std::ostream& out, const std::set<Term>& set)
{
- container_to_stream(out, set);
+ internal::container_to_stream(out, set);
return out;
}
std::ostream& operator<<(std::ostream& out,
const std::unordered_set<Term>& unordered_set)
{
- container_to_stream(out, unordered_set);
+ internal::container_to_stream(out, unordered_set);
return out;
}
template <typename V>
std::ostream& operator<<(std::ostream& out, const std::map<Term, V>& map)
{
- container_to_stream(out, map);
+ internal::container_to_stream(out, map);
return out;
}
std::ostream& operator<<(std::ostream& out,
const std::unordered_map<Term, V>& unordered_map)
{
- container_to_stream(out, unordered_map);
+ internal::container_to_stream(out, unordered_map);
return out;
}
{
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_CONTAINS: return SEQ_CONTAINS;
- case cvc5::Kind::STRING_INDEXOF: return SEQ_INDEXOF;
- case cvc5::Kind::STRING_REPLACE: return SEQ_REPLACE;
- case cvc5::Kind::STRING_REPLACE_ALL: 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 internal::Kind::STRING_CONCAT: return SEQ_CONCAT;
+ case internal::Kind::STRING_LENGTH: return SEQ_LENGTH;
+ case internal::Kind::STRING_SUBSTR: return SEQ_EXTRACT;
+ case internal::Kind::STRING_UPDATE: return SEQ_UPDATE;
+ case internal::Kind::STRING_CHARAT: return SEQ_AT;
+ case internal::Kind::STRING_CONTAINS: return SEQ_CONTAINS;
+ case internal::Kind::STRING_INDEXOF: return SEQ_INDEXOF;
+ case internal::Kind::STRING_REPLACE: return SEQ_REPLACE;
+ case internal::Kind::STRING_REPLACE_ALL: return SEQ_REPLACE_ALL;
+ case internal::Kind::STRING_REV: return SEQ_REV;
+ case internal::Kind::STRING_PREFIX: return SEQ_PREFIX;
+ case internal::Kind::STRING_SUFFIX: return SEQ_SUFFIX;
default:
// fall through to conversion below
break;
bool Term::isCastedReal() const
{
- if (d_node->getKind() == kind::CAST_TO_REAL)
+ if (d_node->getKind() == internal::kind::CAST_TO_REAL)
{
return (*d_node)[0].isConst() && (*d_node)[0].getType().isInteger();
}
DatatypeConstructorDecl::DatatypeConstructorDecl(const Solver* slv,
const std::string& name)
- : d_solver(slv), d_ctor(new cvc5::DTypeConstructor(name))
+ : d_solver(slv), d_ctor(new internal::DTypeConstructor(name))
{
}
DatatypeConstructorDecl::~DatatypeConstructorDecl()
std::ostream& operator<<(std::ostream& out,
const std::vector<DatatypeConstructorDecl>& vector)
{
- container_to_stream(out, vector);
+ internal::container_to_stream(out, vector);
return out;
}
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 internal::DType(name, isCoDatatype))
{
}
const Sort& param,
bool isCoDatatype)
: d_solver(slv),
- d_dtype(new cvc5::DType(
- name, std::vector<TypeNode>{*param.d_type}, isCoDatatype))
+ d_dtype(new internal::DType(
+ name, std::vector<internal::TypeNode>{*param.d_type}, isCoDatatype))
{
}
bool isCoDatatype)
: d_solver(slv)
{
- std::vector<TypeNode> tparams = Sort::sortVectorToTypeNodes(params);
- d_dtype = std::shared_ptr<cvc5::DType>(
- new cvc5::DType(name, tparams, isCoDatatype));
+ std::vector<internal::TypeNode> tparams = Sort::sortVectorToTypeNodes(params);
+ d_dtype = std::shared_ptr<internal::DType>(
+ new internal::DType(name, tparams, isCoDatatype));
}
bool DatatypeDecl::isNullHelper() const { return !d_dtype; }
return out;
}
-cvc5::DType& DatatypeDecl::getDatatype(void) const { return *d_dtype; }
+internal::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 internal::DTypeSelector& stor)
+ : d_solver(slv), d_stor(new internal::DTypeSelector(stor))
{
CVC5_API_CHECK(d_stor->isResolved()) << "Expected resolved datatype selector";
}
}
DatatypeConstructor::DatatypeConstructor(const Solver* slv,
- const cvc5::DTypeConstructor& ctor)
- : d_solver(slv), d_ctor(new cvc5::DTypeConstructor(ctor))
+ const internal::DTypeConstructor& ctor)
+ : d_solver(slv), d_ctor(new internal::DTypeConstructor(ctor))
{
CVC5_API_CHECK(d_ctor->isResolved())
<< "Expected resolved datatype constructor";
<< "Cannot get specialized constructor type for non-datatype type "
<< retSort;
//////// all checks before this line
- Node ret = d_ctor->getInstantiatedConstructor(*retSort.d_type);
+ internal::Node ret = d_ctor->getInstantiatedConstructor(*retSort.d_type);
(void)ret.getType(true); /* kick off type checking */
// apply type ascription to the operator
- Term sctor = api::Term(d_solver, ret);
+ Term sctor = Term(d_solver, ret);
return sctor;
////////
CVC5_API_TRY_CATCH_END;
}
DatatypeConstructor::const_iterator::const_iterator(
- const Solver* slv, const cvc5::DTypeConstructor& ctor, bool begin)
+ const Solver* slv, const internal::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<internal::DTypeSelector>>& sels =
ctor.getArgs();
- for (const std::shared_ptr<cvc5::DTypeSelector>& s : sels)
+ for (const std::shared_ptr<internal::DTypeSelector>& s : sels)
{
/* Can not use emplace_back here since constructor is private. */
d_stors.push_back(DatatypeSelector(d_solver, *s.get()));
/* Datatype ----------------------------------------------------------------- */
-Datatype::Datatype(const Solver* slv, const cvc5::DType& dtype)
- : d_solver(slv), d_dtype(new cvc5::DType(dtype))
+Datatype::Datatype(const Solver* slv, const internal::DType& dtype)
+ : d_solver(slv), d_dtype(new internal::DType(dtype))
{
CVC5_API_CHECK(d_dtype->isResolved()) << "Expected resolved datatype";
}
CVC5_API_CHECK_NOT_NULL;
CVC5_API_CHECK(isParametric()) << "Expected parametric datatype";
//////// all checks before this line
- std::vector<cvc5::TypeNode> params = d_dtype->getParameters();
+ std::vector<internal::TypeNode> params = d_dtype->getParameters();
return Sort::typeNodeVectorToSorts(d_solver, params);
////////
CVC5_API_TRY_CATCH_END;
}
Datatype::const_iterator::const_iterator(const Solver* slv,
- const cvc5::DType& dtype,
+ const internal::DType& dtype,
bool begin)
: d_solver(slv), d_int_ctors(&dtype.getConstructors())
{
- const std::vector<std::shared_ptr<DTypeConstructor>>& cons =
+ const std::vector<std::shared_ptr<internal::DTypeConstructor>>& cons =
dtype.getConstructors();
- for (const std::shared_ptr<DTypeConstructor>& c : cons)
+ for (const std::shared_ptr<internal::DTypeConstructor>& c : cons)
{
/* Can not use emplace_back here since constructor is private. */
d_ctors.push_back(DatatypeConstructor(d_solver, *c.get()));
if (!d_sygusVars.empty())
{
- bvl = Term(
- d_solver,
- d_solver->getNodeManager()->mkNode(
- cvc5::kind::BOUND_VAR_LIST, Term::termVectorToNodes(d_sygusVars)));
+ bvl = Term(d_solver,
+ d_solver->getNodeManager()->mkNode(
+ internal::kind::BOUND_VAR_LIST,
+ Term::termVectorToNodes(d_sygusVars)));
}
std::unordered_map<Term, Sort> ntsToUnres(d_ntSyms.size());
Sort(d_solver, d_solver->getNodeManager()->mkSort(ntsymbol.toString()));
}
- std::vector<cvc5::DType> datatypes;
- std::set<TypeNode> unresTypes;
+ std::vector<internal::DType> datatypes;
+ std::set<internal::TypeNode> unresTypes;
datatypes.reserve(d_ntSyms.size());
}
bool aci = d_allowConst.find(ntSym) != d_allowConst.end();
- TypeNode btt = ntSym.d_node->getType();
+ internal::TypeNode btt = ntSym.d_node->getType();
dtDecl.d_dtype->setSygus(btt, *bvl.d_node, aci, false);
// We can be in a case where the only rule specified was (Variable T)
unresTypes.insert(*ntsToUnres[ntSym].d_type);
}
- std::vector<TypeNode> datatypeTypes =
+ std::vector<internal::TypeNode> datatypeTypes =
d_solver->getNodeManager()->mkMutualDatatypeTypes(
- datatypes, unresTypes, NodeManager::DATATYPE_FLAG_PLACEHOLDER);
+ datatypes,
+ unresTypes,
+ internal::NodeManager::DATATYPE_FLAG_PLACEHOLDER);
// return is the first datatype
return Sort(d_solver, datatypeTypes[0]);
{
Term lbvl =
Term(d_solver,
- d_solver->getNodeManager()->mkNode(cvc5::kind::BOUND_VAR_LIST,
+ d_solver->getNodeManager()->mkNode(internal::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));
+ internal::kind::LAMBDA, *lbvl.d_node, *op.d_node));
}
- std::vector<TypeNode> cargst = Sort::sortVectorToTypeNodes(cargs);
+ std::vector<internal::TypeNode> cargst = Sort::sortVectorToTypeNodes(cargs);
dt.d_dtype->addSygusConstructor(*op.d_node, ssCName.str(), cargst);
////////
CVC5_API_TRY_CATCH_END;
return term;
}
- Node nret;
+ internal::Node nret;
- if (term.d_node->getMetaKind() == kind::metakind::PARAMETERIZED)
+ if (term.d_node->getMetaKind() == internal::kind::metakind::PARAMETERIZED)
{
// it's an indexed operator so we should provide the op
- NodeBuilder nb(term.d_node->getKind());
+ internal::NodeBuilder nb(term.d_node->getKind());
nb << term.d_node->getOperator();
nb.append(Term::termVectorToNodes(pchildren));
nret = nb.constructNode();
{
std::stringstream ss;
ss << v;
- std::vector<TypeNode> cargs;
+ std::vector<internal::TypeNode> cargs;
dt.d_dtype->addSygusConstructor(*v.d_node, ss.str(), cargs);
}
}
bool Grammar::containsFreeVariables(const Term& rule) const
{
// we allow the argument list and non-terminal symbols to be in scope
- std::unordered_set<TNode> scope;
+ std::unordered_set<internal::TNode> scope;
for (const Term& sygusVar : d_sygusVars)
{
scope.emplace(*ntsymbol.d_node);
}
- return expr::hasFreeVariablesScope(*rule.d_node, scope);
+ return internal::expr::hasFreeVariablesScope(*rule.d_node, scope);
}
std::ostream& operator<<(std::ostream& out, const Grammar& grammar)
struct Stat::StatData
{
- cvc5::StatExportData data;
+ internal::StatExportData data;
template <typename T>
StatData(T&& t) : data(std::forward<T>(t))
{
std::ostream& operator<<(std::ostream& os, const Stat& sv)
{
- return cvc5::detail::print(os, sv.d_data->data);
+ return internal::detail::print(os, sv.d_data->data);
}
Statistics::BaseType::const_reference Statistics::iterator::operator*() const
return iterator(d_stats.end(), d_stats, false, false);
}
-Statistics::Statistics(const StatisticsRegistry& reg)
+Statistics::Statistics(const internal::StatisticsRegistry& reg)
{
for (const auto& svp : reg)
{
/* Solver */
/* -------------------------------------------------------------------------- */
-Solver::Solver(std::unique_ptr<Options>&& original)
+Solver::Solver(std::unique_ptr<internal::Options>&& original)
{
- d_nodeMgr = NodeManager::currentNM();
+ d_nodeMgr = internal::NodeManager::currentNM();
d_nodeMgr->init();
d_originalOptions = std::move(original);
- d_slv.reset(new SolverEngine(d_nodeMgr, d_originalOptions.get()));
+ d_slv.reset(new internal::SolverEngine(d_nodeMgr, d_originalOptions.get()));
d_slv->setSolver(this);
- d_rng.reset(new Random(d_slv->getOptions().driver.seed));
+ d_rng.reset(new internal::Random(d_slv->getOptions().driver.seed));
resetStatistics();
}
-Solver::Solver() : Solver(std::make_unique<Options>()) {}
+Solver::Solver() : Solver(std::make_unique<internal::Options>()) {}
Solver::~Solver() {}
/* Helpers and private functions */
/* -------------------------------------------------------------------------- */
-NodeManager* Solver::getNodeManager(void) const { return d_nodeMgr; }
+internal::NodeManager* Solver::getNodeManager(void) const { return d_nodeMgr; }
void Solver::increment_term_stats(Kind kind) const
{
- if constexpr (configuration::isStatisticsBuild())
+ if constexpr (internal::configuration::isStatisticsBuild())
{
d_stats->d_terms << kind;
}
void Solver::increment_vars_consts_stats(const Sort& sort, bool is_var) const
{
- if constexpr (configuration::isStatisticsBuild())
+ if constexpr (internal::configuration::isStatisticsBuild())
{
- const TypeNode tn = sort.getTypeNode();
- TypeConstant tc = tn.getKind() == cvc5::kind::TYPE_CONSTANT
- ? tn.getConst<TypeConstant>()
- : LAST_TYPE;
+ const internal::TypeNode tn = sort.getTypeNode();
+ internal::TypeConstant tc = tn.getKind() == internal::kind::TYPE_CONSTANT
+ ? tn.getConst<internal::TypeConstant>()
+ : internal::LAST_TYPE;
if (is_var)
{
d_stats->d_vars << tc;
Op Solver::mkOpHelper(Kind kind, const T& t) const
{
//////// all checks before this line
- Node res = getNodeManager()->mkConst(t);
+ internal::Node res = getNodeManager()->mkConst(t);
static_cast<void>(res.getType(true)); /* kick off type checking */
return Op(this, kind, res);
}
Term Solver::mkValHelper(const T& t) const
{
//////// all checks before this line
- Node res = getNodeManager()->mkConst(t);
+ internal::Node res = getNodeManager()->mkConst(t);
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
}
-Term Solver::mkRationalValHelper(const Rational& r, bool isInt) const
+Term Solver::mkRationalValHelper(const internal::Rational& r, bool isInt) const
{
//////// all checks before this line
- NodeManager* nm = getNodeManager();
- Node res = isInt ? nm->mkConstInt(r) : nm->mkConstReal(r);
+ internal::NodeManager* nm = getNodeManager();
+ internal::Node res = isInt ? nm->mkConstInt(r) : nm->mkConstReal(r);
(void)res.getType(true); /* kick off type checking */
- api::Term t = Term(this, res);
+ Term t = Term(this, res);
// NOTE: this block will be eliminated when arithmetic subtyping is eliminated
if (!isInt)
{
//////// all checks before this line
try
{
- cvc5::Rational r = s.find('/') != std::string::npos
- ? cvc5::Rational(s)
- : cvc5::Rational::fromDecimal(s);
+ internal::Rational r = s.find('/') != std::string::npos
+ ? internal::Rational(s)
+ : internal::Rational::fromDecimal(s);
return mkRationalValHelper(r, isInt);
}
catch (const std::invalid_argument& e)
{
CVC5_API_ARG_CHECK_EXPECTED(size > 0, size) << "a bit-width > 0";
//////// all checks before this line
- return mkValHelper(cvc5::BitVector(size, val));
+ return mkValHelper(internal::BitVector(size, val));
}
Term Solver::mkBVFromStrHelper(uint32_t size,
<< "base 2, 10, or 16";
//////// all checks before this line
- Integer val(s, base);
+ internal::Integer val(s, base);
if (val.strictlyNegative())
{
- CVC5_API_CHECK(val >= -Integer(2).pow(size - 1))
+ CVC5_API_CHECK(val >= -internal::Integer(2).pow(size - 1))
<< "Overflow in bitvector construction (specified bitvector size "
<< size << " too small to hold value " << s << ")";
}
<< "Overflow in bitvector construction (specified bitvector size "
<< size << " too small to hold value " << s << ")";
}
- return mkValHelper(cvc5::BitVector(size, val));
+ return mkValHelper(internal::BitVector(size, val));
}
Term Solver::getValueHelper(const Term& term) const
// Note: Term is checked in the caller to avoid double checks
bool wasShadow = false;
bool freeOrShadowedVar =
- expr::hasFreeOrShadowedVar(term.getNode(), wasShadow);
+ internal::expr::hasFreeOrShadowedVar(term.getNode(), wasShadow);
CVC5_API_RECOVERABLE_CHECK(!freeOrShadowedVar)
<< "Cannot get value of term containing "
<< (wasShadow ? "shadowed" : "free") << " variables";
//////// all checks before this line
- Node value = d_slv->getValue(*term.d_node);
+ internal::Node value = d_slv->getValue(*term.d_node);
Term res = Term(this, value);
// May need to wrap in real cast so that user know this is a real.
- TypeNode tn = (*term.d_node).getType();
+ internal::TypeNode tn = (*term.d_node).getType();
if (!tn.isInteger() && value.getType().isInteger())
{
return ensureRealSort(res);
{
// Note: Sorts are checked in the caller to avoid double checks
//////// all checks before this line
- std::vector<TypeNode> typeNodes = Sort::sortVectorToTypeNodes(sorts);
+ std::vector<internal::TypeNode> typeNodes =
+ Sort::sortVectorToTypeNodes(sorts);
return Sort(this, getNodeManager()->mkTupleType(typeNodes));
}
kind)
<< "PI, REGEXP_NONE, REGEXP_ALL, REGEXP_ALLCHAR or SEP_EMP";
//////// all checks before this line
- Node res;
- cvc5::Kind k = extToIntKind(kind);
+ internal::Node res;
+ internal::Kind k = extToIntKind(kind);
if (kind == REGEXP_NONE || kind == REGEXP_ALL || kind == REGEXP_ALLCHAR)
{
Assert(isDefinedIntKind(k));
- res = d_nodeMgr->mkNode(k, std::vector<Node>());
+ res = d_nodeMgr->mkNode(k, std::vector<internal::Node>());
}
else if (kind == SEP_EMP)
{
{
return mkTermFromKind(kind);
}
- std::vector<Node> echildren = Term::termVectorToNodes(children);
- cvc5::Kind k = extToIntKind(kind);
- Node res;
+ std::vector<internal::Node> echildren = Term::termVectorToNodes(children);
+ internal::Kind k = extToIntKind(kind);
+ internal::Node res;
if (echildren.size() > 2)
{
if (kind == INTS_DIVISION || kind == XOR || kind == SUB || kind == DIVISION
// "chainable", but cvc5 internally only supports 2 args
res = d_nodeMgr->mkChain(k, echildren);
}
- else if (kind::isAssociative(k))
+ else if (internal::kind::isAssociative(k))
{
// mkAssociative has special treatment for associative operators with lots
// of children
res = d_nodeMgr->mkNode(k, echildren);
}
}
- else if (kind::isAssociative(k))
+ else if (internal::kind::isAssociative(k))
{
// associative case, same as above
checkMkTerm(kind, children.size());
{
// default case, same as above
checkMkTerm(kind, children.size());
- if (kind == api::SET_SINGLETON)
+ if (kind == SET_SINGLETON)
{
// the type of the term is the same as the type of the internal node
// see Term::getSort()
- TypeNode type = children[0].d_node->getType();
+ internal::TypeNode type = children[0].d_node->getType();
// Internally NodeManager::mkSingleton needs a type argument
// to construct a singleton, since there is no difference between
// integers and reals (both are Rationals).
// element type can be used safely here.
res = getNodeManager()->mkSingleton(type, *children[0].d_node);
}
- else if (kind == api::BAG_MAKE)
+ else if (kind == BAG_MAKE)
{
// the type of the term is the same as the type of the internal node
// see Term::getSort()
- TypeNode type = children[0].d_node->getType();
+ internal::TypeNode type = children[0].d_node->getType();
// Internally NodeManager::mkBag needs a type argument
// to construct a bag, since there is no difference between
// integers and reals (both are Rationals).
res = getNodeManager()->mkBag(
type, *children[0].d_node, *children[1].d_node);
}
- else if (kind == api::SEQ_UNIT)
+ else if (kind == SEQ_UNIT)
{
// the type of the term is the same as the type of the internal node
// see Term::getSort()
- TypeNode type = children[0].d_node->getType();
+ internal::TypeNode type = children[0].d_node->getType();
res = getNodeManager()->mkSeqUnit(type, *children[0].d_node);
}
else
checkMkTerm(op.d_kind, children.size());
//////// all checks before this line
- const cvc5::Kind int_kind = extToIntKind(op.d_kind);
- std::vector<Node> echildren = Term::termVectorToNodes(children);
+ const internal::Kind int_kind = extToIntKind(op.d_kind);
+ std::vector<internal::Node> echildren = Term::termVectorToNodes(children);
- NodeBuilder nb(int_kind);
+ internal::NodeBuilder nb(int_kind);
nb << *op.d_node;
nb.append(echildren);
- Node res = nb.constructNode();
+ internal::Node res = nb.constructNode();
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
// double checks
//////// all checks before this line
- std::vector<cvc5::DType> datatypes;
+ std::vector<internal::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::set<internal::TypeNode> utypes =
+ Sort::sortSetToTypeNodes(unresolvedSorts);
+ std::vector<internal::TypeNode> dtypes =
getNodeManager()->mkMutualDatatypeTypes(datatypes, utypes);
std::vector<Sort> retTypes = Sort::typeNodeVectorToSorts(this, dtypes);
return retTypes;
{
// Note: boundVars, sort and grammar are checked in the caller to avoid
// double checks.
- std::vector<TypeNode> varTypes;
+ std::vector<internal::TypeNode> varTypes;
for (const auto& bv : boundVars)
{
if (grammar)
}
//////// all checks before this line
- TypeNode funType = varTypes.empty() ? *sort.d_type
- : getNodeManager()->mkFunctionType(
- varTypes, *sort.d_type);
+ internal::TypeNode funType =
+ varTypes.empty()
+ ? *sort.d_type
+ : getNodeManager()->mkFunctionType(varTypes, *sort.d_type);
- Node fun = getNodeManager()->mkBoundVar(symbol, funType);
+ internal::Node fun = getNodeManager()->mkBoundVar(symbol, funType);
(void)fun.getType(true); /* kick off type checking */
- std::vector<Node> bvns = Term::termVectorToNodes(boundVars);
+ std::vector<internal::Node> bvns = Term::termVectorToNodes(boundVars);
d_slv->declareSynthFun(
fun,
// constructors. We do this cast using division with 1. This has the
// advantage wrt using TO_REAL since (constant) division is always included
// in the theory.
- res = Term(this,
- d_nodeMgr->mkNode(extToIntKind(DIVISION),
- *res.d_node,
- d_nodeMgr->mkConst(kind::CONST_RATIONAL,
- cvc5::Rational(1))));
+ res = Term(
+ this,
+ d_nodeMgr->mkNode(extToIntKind(DIVISION),
+ *res.d_node,
+ d_nodeMgr->mkConst(internal::kind::CONST_RATIONAL,
+ internal::Rational(1))));
}
Assert(res.getSort() == sort);
return res;
//////// all checks before this line
if (t.getSort() == getIntegerSort())
{
- Node n = getNodeManager()->mkNode(kind::CAST_TO_REAL, *t.d_node);
+ internal::Node n =
+ getNodeManager()->mkNode(internal::kind::CAST_TO_REAL, *t.d_node);
return Term(this, n);
}
return t;
if (d_slv->getOptions().expr.wellFormedChecking)
{
bool wasShadow = false;
- if (expr::hasFreeOrShadowedVar(*t.d_node, wasShadow))
+ if (internal::expr::hasFreeOrShadowedVar(*t.d_node, wasShadow))
{
std::stringstream se;
se << "Cannot process term with " << (wasShadow ? "shadowed" : "free")
void Solver::resetStatistics()
{
- if constexpr (configuration::isStatisticsBuild())
+ if constexpr (internal::configuration::isStatisticsBuild())
{
d_stats.reset(new APIStatistics{
- d_slv->getStatisticsRegistry().registerHistogram<TypeConstant>(
- "api::CONSTANT"),
- d_slv->getStatisticsRegistry().registerHistogram<TypeConstant>(
- "api::VARIABLE"),
- d_slv->getStatisticsRegistry().registerHistogram<Kind>("api::TERM"),
+ d_slv->getStatisticsRegistry()
+ .registerHistogram<internal::TypeConstant>("cvc5::CONSTANT"),
+ d_slv->getStatisticsRegistry()
+ .registerHistogram<internal::TypeConstant>("cvc5::VARIABLE"),
+ d_slv->getStatisticsRegistry().registerHistogram<Kind>("cvc5::TERM"),
});
}
}
{
CVC5_API_KIND_CHECK(kind);
Assert(isDefinedIntKind(extToIntKind(kind)));
- const cvc5::kind::MetaKind mk = kind::metaKindOf(extToIntKind(kind));
- CVC5_API_KIND_CHECK_EXPECTED(
- mk == kind::metakind::PARAMETERIZED || mk == kind::metakind::OPERATOR,
- kind)
+ const internal::kind::MetaKind mk =
+ internal::kind::metaKindOf(extToIntKind(kind));
+ CVC5_API_KIND_CHECK_EXPECTED(mk == internal::kind::metakind::PARAMETERIZED
+ || mk == internal::kind::metakind::OPERATOR,
+ kind)
<< "Only operator-style terms are created with mkTerm(), "
"to create variables, constants and values see mkVar(), mkConst() "
"and the respective theory-specific functions to create values, "
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return Sort(this, TypeNode());
+ return Sort(this, internal::TypeNode());
////////
CVC5_API_TRY_CATCH_END;
}
CVC5_API_SOLVER_CHECK_DOMAIN_SORTS(sorts);
CVC5_API_SOLVER_CHECK_CODOMAIN_SORT(codomain);
//////// all checks before this line
- std::vector<TypeNode> argTypes = Sort::sortVectorToTypeNodes(sorts);
+ std::vector<internal::TypeNode> argTypes = Sort::sortVectorToTypeNodes(sorts);
return Sort(this,
getNodeManager()->mkFunctionType(argTypes, *codomain.d_type));
////////
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return Sort(
- this,
- getNodeManager()->mkSort(symbol, NodeManager::SORT_FLAG_PLACEHOLDER));
+ return Sort(this,
+ getNodeManager()->mkSort(
+ symbol, internal::NodeManager::SORT_FLAG_PLACEHOLDER));
////////
CVC5_API_TRY_CATCH_END;
}
const std::vector<std::pair<std::string, Sort>>& fields) const
{
CVC5_API_TRY_CATCH_BEGIN;
- std::vector<std::pair<std::string, TypeNode>> f;
+ std::vector<std::pair<std::string, internal::TypeNode>> f;
for (size_t i = 0, size = fields.size(); i < size; ++i)
{
const auto& p = fields[i];
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- Node res =
- d_nodeMgr->mkNullaryOperator(d_nodeMgr->realType(), cvc5::kind::PI);
+ internal::Node res =
+ d_nodeMgr->mkNullaryOperator(d_nodeMgr->realType(), internal::kind::PI);
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
////////
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- Term integer = mkRationalValHelper(cvc5::Rational(val));
+ Term integer = mkRationalValHelper(internal::Rational(val));
Assert(integer.getSort() == getIntegerSort());
return integer;
////////
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkRationalValHelper(cvc5::Rational(val), false);
+ return mkRationalValHelper(internal::Rational(val), false);
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkRationalValHelper(cvc5::Rational(num, den), false);
+ return mkRationalValHelper(internal::Rational(num, den), false);
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- Node res =
- d_nodeMgr->mkNode(cvc5::kind::REGEXP_ALL, std::vector<cvc5::Node>());
+ internal::Node res = d_nodeMgr->mkNode(internal::kind::REGEXP_ALL,
+ std::vector<internal::Node>());
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
////////
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- Node res =
- d_nodeMgr->mkNode(cvc5::kind::REGEXP_NONE, std::vector<cvc5::Node>());
+ internal::Node res = d_nodeMgr->mkNode(internal::kind::REGEXP_NONE,
+ std::vector<internal::Node>());
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
////////
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- Node res =
- d_nodeMgr->mkNode(cvc5::kind::REGEXP_ALLCHAR, std::vector<cvc5::Node>());
+ internal::Node res = d_nodeMgr->mkNode(internal::kind::REGEXP_ALLCHAR,
+ std::vector<internal::Node>());
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
////////
CVC5_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(*sort.d_type));
+ return mkValHelper(internal::EmptySet(*sort.d_type));
////////
CVC5_API_TRY_CATCH_END;
}
CVC5_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(*sort.d_type));
+ return mkValHelper(internal::EmptyBag(*sort.d_type));
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- Node res = getNodeManager()->mkNullaryOperator(d_nodeMgr->booleanType(),
- cvc5::Kind::SEP_EMP);
+ internal::Node res = getNodeManager()->mkNullaryOperator(
+ d_nodeMgr->booleanType(), internal::Kind::SEP_EMP);
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
////////
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_SOLVER_CHECK_SORT(sort);
//////// all checks before this line
- Node res =
- getNodeManager()->mkNullaryOperator(*sort.d_type, cvc5::kind::SEP_NIL);
+ internal::Node res = getNodeManager()->mkNullaryOperator(
+ *sort.d_type, internal::kind::SEP_NIL);
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
////////
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkValHelper(cvc5::String(s, useEscSequences));
+ return mkValHelper(internal::String(s, useEscSequences));
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkValHelper(cvc5::String(s));
+ return mkValHelper(internal::String(s));
////////
CVC5_API_TRY_CATCH_END;
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_SOLVER_CHECK_SORT(sort);
//////// all checks before this line
- std::vector<Node> seq;
- Node res = d_nodeMgr->mkConst(Sequence(*sort.d_type, seq));
+ std::vector<internal::Node> seq;
+ internal::Node res =
+ d_nodeMgr->mkConst(internal::Sequence(*sort.d_type, seq));
return Term(this, res);
////////
CVC5_API_TRY_CATCH_END;
CVC5_API_SOLVER_CHECK_SORT(sort);
//////// all checks before this line
- Node res = getNodeManager()->mkNullaryOperator(*sort.d_type,
- cvc5::kind::SET_UNIVERSE);
+ internal::Node res = getNodeManager()->mkNullaryOperator(
+ *sort.d_type, internal::kind::SET_UNIVERSE);
// TODO(#2771): Reenable?
// (void)res->getType(true); /* kick off type checking */
return Term(this, res);
//////// all checks before this line
// handle the special case of (CAST_TO_REAL n) where n is an integer
- Node n = *val.d_node;
+ internal::Node n = *val.d_node;
if (val.isCastedReal())
{
// this is safe because the constant array stores its type
n = n[0];
}
- Term res = mkValHelper(cvc5::ArrayStoreAll(*sort.d_type, n));
+ Term res = mkValHelper(internal::ArrayStoreAll(*sort.d_type, n));
return res;
////////
CVC5_API_TRY_CATCH_END;
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkValHelper(
- FloatingPoint::makeInf(FloatingPointSize(exp, sig), false));
+ return mkValHelper(internal::FloatingPoint::makeInf(
+ internal::FloatingPointSize(exp, sig), false));
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkValHelper(FloatingPoint::makeInf(FloatingPointSize(exp, sig), true));
+ return mkValHelper(internal::FloatingPoint::makeInf(
+ internal::FloatingPointSize(exp, sig), true));
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkValHelper(FloatingPoint::makeNaN(FloatingPointSize(exp, sig)));
+ return mkValHelper(
+ internal::FloatingPoint::makeNaN(internal::FloatingPointSize(exp, sig)));
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkValHelper(
- FloatingPoint::makeZero(FloatingPointSize(exp, sig), false));
+ return mkValHelper(internal::FloatingPoint::makeZero(
+ internal::FloatingPointSize(exp, sig), false));
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return mkValHelper(
- FloatingPoint::makeZero(FloatingPointSize(exp, sig), true));
+ return mkValHelper(internal::FloatingPoint::makeZero(
+ internal::FloatingPointSize(exp, sig), true));
////////
CVC5_API_TRY_CATCH_END;
}
val.d_node->getType().isBitVector() && val.d_node->isConst(), val)
<< "bit-vector constant";
//////// all checks before this line
- return mkValHelper(
- cvc5::FloatingPoint(exp, sig, val.d_node->getConst<BitVector>()));
+ return mkValHelper(internal::FloatingPoint(
+ exp, sig, val.d_node->getConst<internal::BitVector>()));
////////
CVC5_API_TRY_CATCH_END;
}
<< "an uninterpreted sort";
CVC5_API_ARG_CHECK_EXPECTED(upperBound > 0, upperBound) << "a value > 0";
//////// all checks before this line
- Node cco =
- d_nodeMgr->mkConst(cvc5::CardinalityConstraint(*sort.d_type, upperBound));
- Node cc = d_nodeMgr->mkNode(cvc5::Kind::CARDINALITY_CONSTRAINT, cco);
+ internal::Node cco = d_nodeMgr->mkConst(
+ internal::CardinalityConstraint(*sort.d_type, upperBound));
+ internal::Node cc =
+ d_nodeMgr->mkNode(internal::Kind::CARDINALITY_CONSTRAINT, cco);
return Term(this, cc);
////////
CVC5_API_TRY_CATCH_END;
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_SOLVER_CHECK_SORT(sort);
//////// all checks before this line
- Node res = d_nodeMgr->mkVar(symbol, *sort.d_type);
+ internal::Node res = d_nodeMgr->mkVar(symbol, *sort.d_type);
(void)res.getType(true); /* kick off type checking */
increment_vars_consts_stats(sort, false);
return Term(this, res);
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_SOLVER_CHECK_SORT(sort);
//////// all checks before this line
- Node res = d_nodeMgr->mkVar(*sort.d_type);
+ internal::Node res = d_nodeMgr->mkVar(*sort.d_type);
(void)res.getType(true); /* kick off type checking */
increment_vars_consts_stats(sort, false);
return Term(this, res);
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_SOLVER_CHECK_SORT(sort);
//////// all checks before this line
- Node res = symbol.empty() ? d_nodeMgr->mkBoundVar(*sort.d_type)
- : d_nodeMgr->mkBoundVar(symbol, *sort.d_type);
+ internal::Node res = symbol.empty()
+ ? d_nodeMgr->mkBoundVar(*sort.d_type)
+ : d_nodeMgr->mkBoundVar(symbol, *sort.d_type);
(void)res.getType(true); /* kick off type checking */
increment_vars_consts_stats(sort, true);
return Term(this, res);
CVC5_API_SOLVER_CHECK_SORTS(sorts);
CVC5_API_SOLVER_CHECK_TERMS(terms);
//////// all checks before this line
- std::vector<cvc5::Node> args;
+ std::vector<internal::Node> args;
for (size_t i = 0, size = sorts.size(); i < size; i++)
{
args.push_back(*(ensureTermSort(terms[i], sorts[i])).d_node);
Sort s = mkTupleSortHelper(sorts);
Datatype dt = s.getDatatype();
- NodeBuilder nb(extToIntKind(APPLY_CONSTRUCTOR));
+ internal::NodeBuilder nb(extToIntKind(APPLY_CONSTRUCTOR));
nb << *dt[0].getConstructorTerm().d_node;
nb.append(args);
- Node res = nb.constructNode();
+ internal::Node res = nb.constructNode();
(void)res.getType(true); /* kick off type checking */
return Term(this, res);
////////
{
case BITVECTOR_EXTRACT:
CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
- res = mkOpHelper(kind, cvc5::BitVectorExtract(args[0], args[1]));
+ res = mkOpHelper(kind, internal::BitVectorExtract(args[0], args[1]));
break;
case BITVECTOR_REPEAT:
CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
- res = mkOpHelper(kind, cvc5::BitVectorRepeat(args[0]));
+ res = mkOpHelper(kind, internal::BitVectorRepeat(args[0]));
break;
case BITVECTOR_ROTATE_LEFT:
CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
- res = mkOpHelper(kind, cvc5::BitVectorRotateLeft(args[0]));
+ res = mkOpHelper(kind, internal::BitVectorRotateLeft(args[0]));
break;
case BITVECTOR_ROTATE_RIGHT:
CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
- res = mkOpHelper(kind, cvc5::BitVectorRotateRight(args[0]));
+ res = mkOpHelper(kind, internal::BitVectorRotateRight(args[0]));
break;
case BITVECTOR_SIGN_EXTEND:
CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
- res = mkOpHelper(kind, cvc5::BitVectorSignExtend(args[0]));
+ res = mkOpHelper(kind, internal::BitVectorSignExtend(args[0]));
break;
case BITVECTOR_ZERO_EXTEND:
CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
- res = mkOpHelper(kind, cvc5::BitVectorZeroExtend(args[0]));
+ res = mkOpHelper(kind, internal::BitVectorZeroExtend(args[0]));
break;
case DIVISIBLE:
CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
- res = mkOpHelper(kind, cvc5::Divisible(args[0]));
+ res = mkOpHelper(kind, internal::Divisible(args[0]));
break;
case FLOATINGPOINT_TO_SBV:
CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
- res = mkOpHelper(kind, cvc5::FloatingPointToSBV(args[0]));
+ res = mkOpHelper(kind, internal::FloatingPointToSBV(args[0]));
break;
case FLOATINGPOINT_TO_UBV:
CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
- res = mkOpHelper(kind, cvc5::FloatingPointToUBV(args[0]));
+ res = mkOpHelper(kind, internal::FloatingPointToUBV(args[0]));
break;
case FLOATINGPOINT_TO_FP_FROM_IEEE_BV:
CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
- res = mkOpHelper(kind,
- cvc5::FloatingPointToFPIEEEBitVector(args[0], args[1]));
+ res = mkOpHelper(
+ kind, internal::FloatingPointToFPIEEEBitVector(args[0], args[1]));
break;
case FLOATINGPOINT_TO_FP_FROM_FP:
CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
- res = mkOpHelper(kind,
- cvc5::FloatingPointToFPFloatingPoint(args[0], args[1]));
+ res = mkOpHelper(
+ kind, internal::FloatingPointToFPFloatingPoint(args[0], args[1]));
break;
case FLOATINGPOINT_TO_FP_FROM_REAL:
CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
- res = mkOpHelper(kind, cvc5::FloatingPointToFPReal(args[0], args[1]));
+ res = mkOpHelper(kind, internal::FloatingPointToFPReal(args[0], args[1]));
break;
case FLOATINGPOINT_TO_FP_FROM_SBV:
CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
res = mkOpHelper(
- kind, cvc5::FloatingPointToFPSignedBitVector(args[0], args[1]));
+ kind, internal::FloatingPointToFPSignedBitVector(args[0], args[1]));
break;
case FLOATINGPOINT_TO_FP_FROM_UBV:
CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
res = mkOpHelper(
- kind, cvc5::FloatingPointToFPUnsignedBitVector(args[0], args[1]));
+ kind, internal::FloatingPointToFPUnsignedBitVector(args[0], args[1]));
break;
case IAND:
CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
- res = mkOpHelper(kind, cvc5::IntAnd(args[0]));
+ res = mkOpHelper(kind, internal::IntAnd(args[0]));
break;
case INT_TO_BITVECTOR:
CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
- res = mkOpHelper(kind, cvc5::IntToBitVector(args[0]));
+ res = mkOpHelper(kind, internal::IntToBitVector(args[0]));
break;
case REGEXP_REPEAT:
CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
- res = mkOpHelper(kind, cvc5::RegExpRepeat(args[0]));
+ res = mkOpHelper(kind, internal::RegExpRepeat(args[0]));
break;
case REGEXP_LOOP:
CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
- res = mkOpHelper(kind, cvc5::RegExpLoop(args[0], args[1]));
+ res = mkOpHelper(kind, internal::RegExpLoop(args[0], args[1]));
break;
case TUPLE_PROJECT:
- res = mkOpHelper(kind, cvc5::TupleProjectOp(args));
+ res = mkOpHelper(kind, internal::TupleProjectOp(args));
break;
default:
if (nargs == 0)
* as invalid. */
CVC5_API_ARG_CHECK_EXPECTED(arg != ".", arg)
<< "a string representing an integer, real or rational value.";
- res = mkOpHelper(kind, cvc5::Divisible(cvc5::Integer(arg)));
+ res = mkOpHelper(kind, internal::Divisible(internal::Integer(arg)));
return res;
////////
CVC5_API_TRY_CATCH_END;
{
CVC5_API_SOLVER_CHECK_TERM(term);
}
- std::vector<Node> eassumptions = Term::termVectorToNodes(assumptions);
+ std::vector<internal::Node> eassumptions =
+ Term::termVectorToNodes(assumptions);
return d_slv->checkSat(eassumptions);
////////
CVC5_API_TRY_CATCH_END;
CVC5_API_SOLVER_CHECK_CODOMAIN_SORT(sort);
//////// all checks before this line
- TypeNode type = *sort.d_type;
+ internal::TypeNode type = *sort.d_type;
if (!sorts.empty())
{
- std::vector<TypeNode> types = Sort::sortVectorToTypeNodes(sorts);
+ std::vector<internal::TypeNode> types = Sort::sortVectorToTypeNodes(sorts);
type = getNodeManager()->mkFunctionType(types, type);
}
return Term(this, d_nodeMgr->mkVar(symbol, type));
CVC5_API_CHECK(d_slv->getUserLogicInfo().isQuantified())
<< "recursive function definitions require a logic with quantifiers";
- CVC5_API_CHECK(d_slv->getUserLogicInfo().isTheoryEnabled(theory::THEORY_UF))
+ CVC5_API_CHECK(
+ d_slv->getUserLogicInfo().isTheoryEnabled(internal::theory::THEORY_UF))
<< "recursive function definitions require a logic with uninterpreted "
"functions";
CVC5_API_CHECK(d_slv->getUserLogicInfo().isQuantified())
<< "recursive function definitions require a logic with quantifiers";
- CVC5_API_CHECK(d_slv->getUserLogicInfo().isTheoryEnabled(theory::THEORY_UF))
+ CVC5_API_CHECK(
+ d_slv->getUserLogicInfo().isTheoryEnabled(internal::theory::THEORY_UF))
<< "recursive function definitions require a logic with uninterpreted "
"functions";
}
//////// all checks before this line
- std::vector<Node> ebound_vars = Term::termVectorToNodes(bound_vars);
+ std::vector<internal::Node> ebound_vars = Term::termVectorToNodes(bound_vars);
d_slv->defineFunctionRec(*fun.d_node, ebound_vars, *term.d_node, global);
return fun;
////////
CVC5_API_CHECK(d_slv->getUserLogicInfo().isQuantified())
<< "recursive function definitions require a logic with quantifiers";
- CVC5_API_CHECK(d_slv->getUserLogicInfo().isTheoryEnabled(theory::THEORY_UF))
+ CVC5_API_CHECK(
+ d_slv->getUserLogicInfo().isTheoryEnabled(internal::theory::THEORY_UF))
<< "recursive function definitions require a logic with uninterpreted "
"functions";
CVC5_API_SOLVER_CHECK_TERMS(funs);
}
}
//////// all checks before this line
- std::vector<Node> efuns = Term::termVectorToNodes(funs);
- std::vector<std::vector<Node>> ebound_vars;
+ std::vector<internal::Node> efuns = Term::termVectorToNodes(funs);
+ std::vector<std::vector<internal::Node>> ebound_vars;
for (const auto& v : bound_vars)
{
ebound_vars.push_back(Term::termVectorToNodes(v));
}
- std::vector<Node> nodes = Term::termVectorToNodes(terms);
+ std::vector<internal::Node> nodes = Term::termVectorToNodes(terms);
d_slv->defineFunctionsRec(efuns, ebound_vars, nodes, global);
////////
CVC5_API_TRY_CATCH_END;
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- std::vector<Node> assertions = d_slv->getAssertions();
+ std::vector<internal::Node> assertions = d_slv->getAssertions();
/* Can not use
* return std::vector<Term>(assertions.begin(), assertions.end());
* here since constructor is private */
{
return d_slv->getOption(option);
}
- catch (OptionException& e)
+ catch (internal::OptionException& e)
{
throw CVC5ApiUnsupportedException(e.getMessage());
}
}
if (!oi.aliases.empty())
{
- container_to_stream(os, oi.aliases, ", ", "", ", ");
+ internal::container_to_stream(os, oi.aliases, ", ", "", ", ");
}
auto printNum = [&os](const std::string& type, const auto& vi) {
os << " | " << type << " | " << vi.currentValue << " | default "
[&os](const OptionInfo::ModeInfo& vi) {
os << " | mode | " << vi.currentValue << " | default "
<< vi.defaultValue << " | modes: ";
- container_to_stream(os, vi.modes, "", "", ", ");
+ internal::container_to_stream(os, vi.modes, "", "", ", ");
},
},
oi.valueInfo);
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- return options::getNames();
+ return internal::options::getNames();
////////
CVC5_API_TRY_CATCH_END;
}
{
CVC5_API_TRY_CATCH_BEGIN;
//////// all checks before this line
- auto info = options::getInfo(d_slv->getOptions(), option);
+ auto info = internal::options::getInfo(d_slv->getOptions(), option);
CVC5_API_CHECK(info.name != "")
<< "Querying invalid or unknown option " << option;
return std::visit(
overloaded{
- [&info](const options::OptionInfo::VoidInfo& vi) {
+ [&info](const internal::options::OptionInfo::VoidInfo& vi) {
return OptionInfo{info.name,
info.aliases,
info.setByUser,
OptionInfo::VoidInfo{}};
},
- [&info](const options::OptionInfo::ValueInfo<bool>& vi) {
+ [&info](const internal::options::OptionInfo::ValueInfo<bool>& vi) {
return OptionInfo{
info.name,
info.aliases,
info.setByUser,
OptionInfo::ValueInfo<bool>{vi.defaultValue, vi.currentValue}};
},
- [&info](const options::OptionInfo::ValueInfo<std::string>& vi) {
+ [&info](
+ const internal::options::OptionInfo::ValueInfo<std::string>& vi) {
return OptionInfo{info.name,
info.aliases,
info.setByUser,
OptionInfo::ValueInfo<std::string>{
vi.defaultValue, vi.currentValue}};
},
- [&info](const options::OptionInfo::NumberInfo<int64_t>& vi) {
+ [&info](
+ const internal::options::OptionInfo::NumberInfo<int64_t>& vi) {
return OptionInfo{
info.name,
info.aliases,
OptionInfo::NumberInfo<int64_t>{
vi.defaultValue, vi.currentValue, vi.minimum, vi.maximum}};
},
- [&info](const options::OptionInfo::NumberInfo<uint64_t>& vi) {
+ [&info](
+ const internal::options::OptionInfo::NumberInfo<uint64_t>& vi) {
return OptionInfo{
info.name,
info.aliases,
OptionInfo::NumberInfo<uint64_t>{
vi.defaultValue, vi.currentValue, vi.minimum, vi.maximum}};
},
- [&info](const options::OptionInfo::NumberInfo<double>& vi) {
+ [&info](const internal::options::OptionInfo::NumberInfo<double>& vi) {
return OptionInfo{
info.name,
info.aliases,
OptionInfo::NumberInfo<double>{
vi.defaultValue, vi.currentValue, vi.minimum, vi.maximum}};
},
- [&info](const options::OptionInfo::ModeInfo& vi) {
+ [&info](const internal::options::OptionInfo::ModeInfo& vi) {
return OptionInfo{info.name,
info.aliases,
info.setByUser,
CVC5_API_CHECK(d_slv->getOptions().smt.unsatAssumptions)
<< "Cannot get unsat assumptions unless explicitly enabled "
"(try --produce-unsat-assumptions)";
- CVC5_API_CHECK(d_slv->getSmtMode() == SmtMode::UNSAT)
+ CVC5_API_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT)
<< "Cannot get unsat assumptions unless in unsat mode.";
//////// all checks before this line
- std::vector<Node> uassumptions = d_slv->getUnsatAssumptions();
+ std::vector<internal::Node> uassumptions = d_slv->getUnsatAssumptions();
/* Can not use
* return std::vector<Term>(uassumptions.begin(), uassumptions.end());
* here since constructor is private */
std::vector<Term> res;
- for (const Node& n : uassumptions)
+ for (const internal::Node& n : uassumptions)
{
res.push_back(Term(this, n));
}
CVC5_API_CHECK(d_slv->getOptions().smt.unsatCores)
<< "Cannot get unsat core unless explicitly enabled "
"(try --produce-unsat-cores)";
- CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == SmtMode::UNSAT)
+ CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT)
<< "Cannot get unsat core unless in unsat mode.";
//////// all checks before this line
- UnsatCore core = d_slv->getUnsatCore();
+ internal::UnsatCore core = d_slv->getUnsatCore();
/* Can not use
* return std::vector<Term>(core.begin(), core.end());
* here since constructor is private */
std::vector<Term> res;
- for (const Node& e : core)
+ for (const internal::Node& e : core)
{
res.push_back(Term(this, e));
}
std::map<Term, Term> Solver::getDifficulty() const
{
CVC5_API_TRY_CATCH_BEGIN;
- CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == SmtMode::UNSAT
- || d_slv->getSmtMode() == SmtMode::SAT
- || d_slv->getSmtMode() == SmtMode::SAT_UNKNOWN)
+ CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT
+ || d_slv->getSmtMode() == internal::SmtMode::SAT
+ || d_slv->getSmtMode()
+ == internal::SmtMode::SAT_UNKNOWN)
<< "Cannot get difficulty unless after a UNSAT, SAT or UNKNOWN response.";
//////// all checks before this line
std::map<Term, Term> res;
- std::map<Node, Node> dmap;
+ std::map<internal::Node, internal::Node> dmap;
d_slv->getDifficultyMap(dmap);
- for (const std::pair<const Node, Node>& d : dmap)
+ for (const std::pair<const internal::Node, internal::Node>& d : dmap)
{
res[Term(this, d.first)] = Term(this, d.second);
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK(d_slv->getOptions().smt.produceProofs)
<< "Cannot get proof unless proofs are enabled (try --produce-proofs)";
- CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == SmtMode::UNSAT)
+ CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT)
<< "Cannot get proof unless in unsat mode.";
return d_slv->getProof();
CVC5_API_TRY_CATCH_END;
CVC5_API_CHECK(d_slv->getOptions().smt.produceLearnedLiterals)
<< "Cannot get learned literals unless enabled (try "
"--produce-learned-literals)";
- CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == SmtMode::UNSAT
- || d_slv->getSmtMode() == SmtMode::SAT
- || d_slv->getSmtMode() == SmtMode::SAT_UNKNOWN)
+ CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT
+ || d_slv->getSmtMode() == internal::SmtMode::SAT
+ || d_slv->getSmtMode()
+ == internal::SmtMode::SAT_UNKNOWN)
<< "Cannot get learned literals unless after a UNSAT, SAT or UNKNOWN "
"response.";
//////// all checks before this line
- std::vector<Node> lits = d_slv->getLearnedLiterals();
+ std::vector<internal::Node> lits = d_slv->getLearnedLiterals();
return Term::nodeVectorToTerms(this, lits);
////////
CVC5_API_TRY_CATCH_END;
"getModelDomainElements.";
//////// all checks before this line
std::vector<Term> res;
- std::vector<Node> elements = d_slv->getModelDomainElements(s.getTypeNode());
- for (const Node& n : elements)
+ std::vector<internal::Node> elements =
+ d_slv->getModelDomainElements(s.getTypeNode());
+ for (const internal::Node& n : elements)
{
res.push_back(Term(this, n));
}
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_SOLVER_CHECK_SORT(locSort);
CVC5_API_SOLVER_CHECK_SORT(dataSort);
- CVC5_API_CHECK(d_slv->getLogicInfo().isTheoryEnabled(theory::THEORY_SEP))
+ CVC5_API_CHECK(
+ d_slv->getLogicInfo().isTheoryEnabled(internal::theory::THEORY_SEP))
<< "Cannot obtain separation logic expressions if not using the "
"separation logic theory.";
//////// all checks before this line
Term Solver::getValueSepHeap() const
{
CVC5_API_TRY_CATCH_BEGIN;
- CVC5_API_CHECK(d_slv->getLogicInfo().isTheoryEnabled(theory::THEORY_SEP))
+ CVC5_API_CHECK(
+ d_slv->getLogicInfo().isTheoryEnabled(internal::theory::THEORY_SEP))
<< "Cannot obtain separation logic expressions if not using the "
"separation logic theory.";
CVC5_API_CHECK(d_slv->getOptions().smt.produceModels)
Term Solver::getValueSepNil() const
{
CVC5_API_TRY_CATCH_BEGIN;
- CVC5_API_CHECK(d_slv->getLogicInfo().isTheoryEnabled(theory::THEORY_SEP))
+ CVC5_API_CHECK(
+ d_slv->getLogicInfo().isTheoryEnabled(internal::theory::THEORY_SEP))
<< "Cannot obtain separation logic expressions if not using the "
"separation logic theory.";
CVC5_API_CHECK(d_slv->getOptions().smt.produceModels)
CVC5_API_SOLVER_CHECK_SORT(sort);
CVC5_API_SOLVER_CHECK_TERMS(initValue);
//////// all checks before this line
- TypeNode setType = getNodeManager()->mkSetType(*sort.d_type);
- Node pool = getNodeManager()->mkBoundVar(symbol, setType);
- std::vector<Node> initv = Term::termVectorToNodes(initValue);
+ internal::TypeNode setType = getNodeManager()->mkSetType(*sort.d_type);
+ internal::Node pool = getNodeManager()->mkBoundVar(symbol, setType);
+ std::vector<internal::Node> initv = Term::termVectorToNodes(initValue);
d_slv->declarePool(pool, initv);
return Term(this, pool);
////////
<< "Cannot get interpolant unless interpolants are enabled (try "
"--produce-interpolants)";
//////// all checks before this line
- TypeNode nullType;
- Node result = d_slv->getInterpolant(*conj.d_node, nullType);
+ internal::TypeNode nullType;
+ internal::Node result = d_slv->getInterpolant(*conj.d_node, nullType);
return Term(this, result);
////////
CVC5_API_TRY_CATCH_END;
<< "Cannot get interpolant unless interpolants are enabled (try "
"--produce-interpolants)";
//////// all checks before this line
- Node result = d_slv->getInterpolant(*conj.d_node, *grammar.resolve().d_type);
+ internal::Node result =
+ d_slv->getInterpolant(*conj.d_node, *grammar.resolve().d_type);
return Term(this, result);
////////
CVC5_API_TRY_CATCH_END;
<< "Cannot get next interpolant when not solving incrementally (try "
"--incremental)";
//////// all checks before this line
- Node result = d_slv->getInterpolantNext();
+ internal::Node result = d_slv->getInterpolantNext();
return Term(this, result);
////////
CVC5_API_TRY_CATCH_END;
CVC5_API_CHECK(d_slv->getOptions().smt.produceAbducts)
<< "Cannot get abduct unless abducts are enabled (try --produce-abducts)";
//////// all checks before this line
- TypeNode nullType;
- Node result = d_slv->getAbduct(*conj.d_node, nullType);
+ internal::TypeNode nullType;
+ internal::Node result = d_slv->getAbduct(*conj.d_node, nullType);
return Term(this, result);
////////
CVC5_API_TRY_CATCH_END;
CVC5_API_CHECK(d_slv->getOptions().smt.produceAbducts)
<< "Cannot get abduct unless abducts are enabled (try --produce-abducts)";
//////// all checks before this line
- Node result = d_slv->getAbduct(*conj.d_node, *grammar.resolve().d_type);
+ internal::Node result =
+ d_slv->getAbduct(*conj.d_node, *grammar.resolve().d_type);
return Term(this, result);
////////
CVC5_API_TRY_CATCH_END;
<< "Cannot get next abduct when not solving incrementally (try "
"--incremental)";
//////// all checks before this line
- Node result = d_slv->getAbductNext();
+ internal::Node result = d_slv->getAbductNext();
return Term(this, result);
////////
CVC5_API_TRY_CATCH_END;
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_CHECK(!d_slv->isFullyInited())
<< "Invalid call to 'setLogic', solver is already fully initialized";
- cvc5::LogicInfo logic_info(logic);
+ internal::LogicInfo logic_info(logic);
//////// all checks before this line
d_slv->setLogic(logic_info);
////////
const std::string& value) const
{
CVC5_API_TRY_CATCH_BEGIN;
- std::vector<std::string> options = options::getNames();
+ std::vector<std::string> options = internal::options::getNames();
CVC5_API_UNSUPPORTED_CHECK(
option.find("command-verbosity") != std::string::npos
|| std::find(options.cbegin(), options.cend(), option) != options.cend())
CVC5_API_CHECK(d_slv->getOptions().quantifiers.sygus)
<< "Cannot call declareSygusVar unless sygus is enabled (use --sygus)";
//////// all checks before this line
- Node res = getNodeManager()->mkBoundVar(symbol, *sort.d_type);
+ internal::Node res = getNodeManager()->mkBoundVar(symbol, *sort.d_type);
(void)res.getType(true); /* kick off type checking */
d_slv->declareSygusVar(res);
CVC5_API_ARG_CHECK_EXPECTED(inv.d_node->getType().isFunction(), inv)
<< "a function";
- TypeNode invType = inv.d_node->getType();
+ internal::TypeNode invType = inv.d_node->getType();
CVC5_API_ARG_CHECK_EXPECTED(invType.getRangeType().isBoolean(), inv)
<< "boolean range";
<< "Cannot addSygusInvConstraint unless sygus is enabled (use --sygus)";
//////// all checks before this line
- const std::vector<TypeNode>& invArgTypes = invType.getArgTypes();
+ const std::vector<internal::TypeNode>& invArgTypes = invType.getArgTypes();
- std::vector<TypeNode> expectedTypes;
+ std::vector<internal::TypeNode> expectedTypes;
expectedTypes.reserve(2 * invArgTypes.size() + 1);
for (size_t i = 0, n = invArgTypes.size(); i < 2 * n; i += 2)
}
expectedTypes.push_back(invType.getRangeType());
- TypeNode expectedTransType = getNodeManager()->mkFunctionType(expectedTypes);
+ internal::TypeNode expectedTransType =
+ getNodeManager()->mkFunctionType(expectedTypes);
CVC5_API_CHECK(trans.d_node->getType() == expectedTransType)
<< "Expected trans's sort to be " << invType;
CVC5_API_TRY_CATCH_BEGIN;
CVC5_API_SOLVER_CHECK_TERM(term);
- std::map<cvc5::Node, cvc5::Node> map;
+ std::map<internal::Node, internal::Node> map;
CVC5_API_CHECK(d_slv->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<internal::Node, internal::Node>::const_iterator it =
+ map.find(*term.d_node);
CVC5_API_CHECK(it != map.cend()) << "Synth solution not found for given term";
//////// all checks before this line
CVC5_API_ARG_SIZE_CHECK_EXPECTED(!terms.empty(), terms) << "non-empty vector";
CVC5_API_SOLVER_CHECK_TERMS(terms);
- std::map<cvc5::Node, cvc5::Node> map;
+ std::map<internal::Node, internal::Node> map;
CVC5_API_CHECK(d_slv->getSynthSolutions(map))
<< "The solver is not in a state immediately preceded by a "
"successful call to checkSynth";
for (size_t i = 0, n = terms.size(); i < n; ++i)
{
- std::map<cvc5::Node, cvc5::Node>::const_iterator it =
+ std::map<internal::Node, internal::Node>::const_iterator it =
map.find(*terms[i].d_node);
CVC5_API_CHECK(it != map.cend())
{
return d_slv->getEnv().isOutputOn(tag);
}
- catch (const cvc5::Exception& e)
+ catch (const internal::Exception& e)
{
throw CVC5ApiException("Invalid output tag " + tag);
}
{
return d_slv->getEnv().output(tag);
}
- catch (const cvc5::Exception& e)
+ catch (const internal::Exception& e)
{
throw CVC5ApiException("Invalid output tag " + tag);
}
}
-} // namespace api
-
} // namespace cvc5
namespace std {
-size_t hash<cvc5::api::Kind>::operator()(cvc5::api::Kind k) const
+size_t hash<cvc5::Kind>::operator()(cvc5::Kind k) const
{
return static_cast<size_t>(k);
}
-size_t hash<cvc5::api::Op>::operator()(const cvc5::api::Op& t) const
+size_t hash<cvc5::Op>::operator()(const cvc5::Op& t) const
{
if (t.isIndexedHelper())
{
- return std::hash<cvc5::Node>()(*t.d_node);
+ return std::hash<cvc5::internal::Node>()(*t.d_node);
}
else
{
- return std::hash<cvc5::api::Kind>()(t.d_kind);
+ return std::hash<cvc5::Kind>()(t.d_kind);
}
}
-size_t std::hash<cvc5::api::Sort>::operator()(const cvc5::api::Sort& s) const
+size_t std::hash<cvc5::Sort>::operator()(const cvc5::Sort& s) const
{
- return std::hash<cvc5::TypeNode>()(*s.d_type);
+ return std::hash<cvc5::internal::TypeNode>()(*s.d_type);
}
-size_t std::hash<cvc5::api::Term>::operator()(const cvc5::api::Term& t) const
+size_t std::hash<cvc5::Term>::operator()(const cvc5::Term& t) const
{
- return std::hash<cvc5::Node>()(*t.d_node);
+ return std::hash<cvc5::internal::Node>()(*t.d_node);
}
} // namespace std
namespace cvc5 {
+class Command;
+
+namespace internal {
+
#ifndef DOXYGEN_SKIP
template <bool ref_count>
class NodeTemplate;
typedef NodeTemplate<true> Node;
#endif
-class Command;
class DType;
class DTypeConstructor;
class DTypeSelector;
namespace main {
class CommandExecutor;
-}
-
-namespace api {
+} // namespace main
+} // namespace internal
class Solver;
class Statistics;
* @param r the internal result that is to be wrapped by this result
* @return the Result
*/
- Result(const cvc5::Result& r);
+ Result(const internal::Result& r);
/**
* The internal result wrapped by this result.
*
* @note This is a ``std::shared_ptr`` rather than a ``std::unique_ptr``
- * since ``cvc5::Result`` is not ref counted.
+ * since ``internal::Result`` is not ref counted.
*/
- std::shared_ptr<cvc5::Result> d_result;
+ std::shared_ptr<internal::Result> d_result;
};
/**
* result
* @return the SynthResult
*/
- SynthResult(const cvc5::SynthResult& r);
+ SynthResult(const internal::SynthResult& r);
/**
* The internal result wrapped by this result.
*
* @note This is a `std::shared_ptr` rather than a `std::unique_ptr`
- * since `cvc5::SynthResult` is not ref counted.
+ * since `internal::SynthResult` is not ref counted.
*/
- std::shared_ptr<cvc5::SynthResult> d_result;
+ std::shared_ptr<internal::SynthResult> d_result;
};
/**
private:
/** @return the internal wrapped TypeNode of this sort. */
- const cvc5::TypeNode& getTypeNode(void) const;
+ const internal::TypeNode& getTypeNode(void) const;
/** Helper to convert a set of Sorts to internal TypeNodes. */
- std::set<TypeNode> static sortSetToTypeNodes(const std::set<Sort>& sorts);
+ std::set<internal::TypeNode> static sortSetToTypeNodes(
+ const std::set<Sort>& sorts);
/** Helper to convert a vector of Sorts to internal TypeNodes. */
- std::vector<TypeNode> static sortVectorToTypeNodes(
+ std::vector<internal::TypeNode> static sortVectorToTypeNodes(
const std::vector<Sort>& sorts);
/** Helper to convert a vector of internal TypeNodes to Sorts. */
std::vector<Sort> static typeNodeVectorToSorts(
- const Solver* slv, const std::vector<TypeNode>& types);
+ const Solver* slv, const std::vector<internal::TypeNode>& types);
/**
* Constructor.
* @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 internal::TypeNode& t);
/**
* Helper for isNull checks. This prevents calling an API function with
* The internal type wrapped by this sort.
*
* @note This is a ``std::shared_ptr`` rather than a ``std::unique_ptr`` to
- * avoid overhead due to memory allocation (``cvc5::Type`` is already
- * ref counted, so this could be a ``std::unique_ptr`` instead).
+ * avoid overhead due to memory allocation (``internal::Type`` is
+ * already ref counted, so this could be a ``std::unique_ptr`` instead).
*/
- std::shared_ptr<cvc5::TypeNode> d_type;
+ std::shared_ptr<internal::TypeNode> d_type;
};
/**
*/
std::ostream& operator<<(std::ostream& out, const Sort& s) CVC5_EXPORT;
-} // namespace api
} // namespace cvc5
namespace std {
* Hash function for Sorts.
*/
template <>
-struct CVC5_EXPORT hash<cvc5::api::Sort>
+struct CVC5_EXPORT hash<cvc5::Sort>
{
- size_t operator()(const cvc5::api::Sort& s) const;
+ size_t operator()(const cvc5::Sort& s) const;
};
} // namespace std
-namespace cvc5::api {
+namespace cvc5 {
/* -------------------------------------------------------------------------- */
/* Op */
/* -------------------------------------------------------------------------- */
-class Term;
-
/**
* A cvc5 operator.
* An operator is a term that represents certain operators, instantiated
* @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 internal::Node& n);
/**
* Helper for isNull checks. This prevents calling an API function with
* The internal node wrapped by this operator.
*
* @note This is a ``std::shared_ptr`` rather than a ``std::unique_ptr`` to
- * avoid overhead due to memory allocation (``cvc5::Node`` is already
- * ref counted, so this could be a ``std::unique_ptr`` instead).
+ * avoid overhead due to memory allocation (``internal::Node`` is
+ * already ref counted, so this could be a ``std::unique_ptr`` instead).
*/
- std::shared_ptr<cvc5::Node> d_node;
+ std::shared_ptr<internal::Node> d_node;
};
/**
*/
std::ostream& operator<<(std::ostream& out, const Op& t) CVC5_EXPORT;
-} // namespace cvc5::api
+} // namespace cvc5
namespace std {
/**
* Hash function for Ops.
*/
template <>
-struct CVC5_EXPORT hash<cvc5::api::Op>
+struct CVC5_EXPORT hash<cvc5::Op>
{
- size_t operator()(const cvc5::api::Op& t) const;
+ size_t operator()(const cvc5::Op& t) const;
};
} // namespace std
-namespace cvc5::api {
+namespace cvc5 {
/* -------------------------------------------------------------------------- */
/* 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<internal::Node>& e,
uint32_t p);
/**
*/
const Solver* d_solver;
/** The original node to be iterated over. */
- std::shared_ptr<cvc5::Node> d_origNode;
+ std::shared_ptr<internal::Node> d_origNode;
/** Keeps track of the iteration position. */
uint32_t d_pos;
};
private:
/** Helper to convert a vector of Terms to internal Nodes. */
- std::vector<Node> static termVectorToNodes(const std::vector<Term>& terms);
+ std::vector<internal::Node> static termVectorToNodes(
+ const std::vector<Term>& terms);
/** Helper to convert a vector of internal Nodes to Terms. */
- std::vector<Term> static nodeVectorToTerms(const Solver* slv,
- const std::vector<Node>& nodes);
+ std::vector<Term> static nodeVectorToTerms(
+ const Solver* slv, const std::vector<internal::Node>& nodes);
/** Helper method to collect all elements of a set. */
static void collectSet(std::set<Term>& set,
- const cvc5::Node& node,
+ const internal::Node& node,
const Solver* slv);
/** Helper method to collect all elements of a sequence. */
static void collectSequence(std::vector<Term>& seq,
- const cvc5::Node& node,
+ const internal::Node& node,
const Solver* slv);
/**
* @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 internal::Node& n);
/** @return the internal wrapped Node of this term. */
- const cvc5::Node& getNode(void) const;
+ const internal::Node& getNode(void) const;
/**
* Helper for isNull checks. This prevents calling an API function with
/**
* The internal node wrapped by this term.
* @note This is a ``std::shared_ptr`` rather than a ``std::unique_ptr`` to
- * avoid overhead due to memory allocation (``cvc5::Node`` is already
- * ref counted, so this could be a ``std::unique_ptr`` instead).
+ * avoid overhead due to memory allocation (``internal::Node`` is
+ * already ref counted, so this could be a ``std::unique_ptr`` instead).
*/
- std::shared_ptr<cvc5::Node> d_node;
+ std::shared_ptr<internal::Node> d_node;
};
/**
const std::unordered_map<Term, V>& unordered_map)
CVC5_EXPORT;
-} // namespace cvc5::api
+} // namespace cvc5
namespace std {
/**
* Hash function for Terms.
*/
template <>
-struct CVC5_EXPORT hash<cvc5::api::Term>
+struct CVC5_EXPORT hash<cvc5::Term>
{
- size_t operator()(const cvc5::api::Term& t) const;
+ size_t operator()(const cvc5::Term& t) const;
};
} // namespace std
-namespace cvc5::api {
+namespace cvc5 {
/* -------------------------------------------------------------------------- */
/* Datatypes */
* The internal (intermediate) datatype constructor wrapped by this
* datatype constructor declaration.
* @note This is a ``std::shared_ptr`` rather than a ``std::unique_ptr``
- * since ``cvc5::DTypeConstructor`` is not ref counted.
+ * since ``internal::DTypeConstructor`` is not ref counted.
*/
- std::shared_ptr<cvc5::DTypeConstructor> d_ctor;
+ std::shared_ptr<internal::DTypeConstructor> d_ctor;
};
class Solver;
bool isCoDatatype = false);
/** @return the internal wrapped Dtype of this datatype declaration. */
- cvc5::DType& getDatatype(void) const;
+ internal::DType& getDatatype(void) const;
/**
* Helper for isNull checks. This prevents calling an API function with
* The internal (intermediate) datatype wrapped by this datatype
* declaration.
* @note This is a ``std::shared_ptr`` rather than a ``std::unique_ptr``
- * since ``cvc5::DType`` is not ref counted.
+ * since ``internal::DType`` is not ref counted.
*/
- std::shared_ptr<cvc5::DType> d_dtype;
+ std::shared_ptr<internal::DType> d_dtype;
};
/**
* @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 internal::DTypeSelector& stor);
/**
* Helper for isNull checks. This prevents calling an API function with
/**
* The internal datatype selector wrapped by this datatype selector.
* @note This is a ``std::shared_ptr`` rather than a ``std::unique_ptr``
- * since ``cvc5::DType`` is not ref counted.
+ * since ``internal::DType`` is not ref counted.
*/
- std::shared_ptr<cvc5::DTypeSelector> d_stor;
+ std::shared_ptr<internal::DTypeSelector> d_stor;
};
/**
* @param begin true if this is a begin() iterator
*/
const_iterator(const Solver* slv,
- const cvc5::DTypeConstructor& ctor,
+ const internal::DTypeConstructor& ctor,
bool begin);
/**
* @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 internal::DTypeConstructor& ctor);
/**
* Return selector for name.
/**
* The internal datatype constructor wrapped by this datatype constructor.
* @note This is a ``std::shared_ptr`` rather than a ``std::unique_ptr``
- * since ``cvc5::DType`` is not ref counted.
+ * since ``internal::DType`` is not ref counted.
*/
- std::shared_ptr<cvc5::DTypeConstructor> d_ctor;
+ std::shared_ptr<internal::DTypeConstructor> d_ctor;
};
/**
* @param dtype the internal datatype to iterate over
* @param begin true if this is a begin() iterator
*/
- const_iterator(const Solver* slv, const cvc5::DType& dtype, bool begin);
+ const_iterator(const Solver* slv, const internal::DType& dtype, bool begin);
/**
* The associated solver object.
* @param dtype the internal datatype to be wrapped
* @return the Datatype
*/
- Datatype(const Solver* slv, const cvc5::DType& dtype);
+ Datatype(const Solver* slv, const internal::DType& dtype);
/**
* Return constructor for name.
/**
* The internal datatype wrapped by this datatype.
* @note This is a ``std::shared_ptr`` rather than a ``std::unique_ptr``
- * since ``cvc5::DType`` is not ref counted.
+ * since ``internal::DType`` is not ref counted.
*/
- std::shared_ptr<cvc5::DType> d_dtype;
+ std::shared_ptr<internal::DType> d_dtype;
};
/**
iterator end() const;
private:
- Statistics(const StatisticsRegistry& reg);
+ Statistics(const internal::StatisticsRegistry& reg);
/** Internal data */
BaseType d_stats;
};
friend class Grammar;
friend class Op;
friend class cvc5::Command;
- friend class cvc5::main::CommandExecutor;
+ friend class internal::main::CommandExecutor;
friend class Sort;
friend class Term;
* Constructs a solver with the given original options. This should only be
* used internally when the Solver is reset.
*/
- Solver(std::unique_ptr<Options>&& original);
+ Solver(std::unique_ptr<internal::Options>&& original);
public:
/* .................................................................... */
* - #INT_TO_BITVECTOR
* - #TUPLE_PROJECT
*
- * See cvc5::api::Kind for a description of the parameters.
+ * See cvc5::Kind for a description of the parameters.
* @param kind the kind of the operator
* @param args the arguments (indices) of the operator
*
- * @note If ``args`` is empty, the Op simply wraps the cvc5::api::Kind. The
+ * @note If ``args`` is empty, the Op simply wraps the cvc5::Kind. The
* Kind can be used in Solver::mkTerm directly without creating an Op
* first.
*/
/**
* Create operator of kind:
* - DIVISIBLE (to support arbitrary precision integers)
- * See cvc5::api::Kind for a description of the parameters.
+ * See cvc5::Kind for a description of the parameters.
* @param kind the kind of the operator
* @param arg the string argument to this operator
*/
private:
/** @return the node manager of this solver */
- NodeManager* getNodeManager(void) const;
+ internal::NodeManager* getNodeManager(void) const;
/** Reset the API statistics */
void resetStatistics();
template <typename T>
Term mkValHelper(const T& t) const;
/** Helper for making rational values. */
- Term mkRationalValHelper(const Rational& r, bool isInt = true) const;
+ Term mkRationalValHelper(const internal::Rational& r,
+ bool isInt = true) const;
/** Helper for mkReal functions that take a string as argument. */
Term mkRealOrIntegerFromStrHelper(const std::string& s,
bool isInt = true) const;
void increment_vars_consts_stats(const Sort& sort, bool is_var) const;
/** Keep a copy of the original option settings (for resets). */
- std::unique_ptr<Options> d_originalOptions;
+ std::unique_ptr<internal::Options> d_originalOptions;
/** The node manager of this solver. */
- NodeManager* d_nodeMgr;
+ internal::NodeManager* d_nodeMgr;
/** The statistics collected on the Api level. */
std::unique_ptr<APIStatistics> d_stats;
/** The SMT engine of this solver. */
- std::unique_ptr<SolverEngine> d_slv;
+ std::unique_ptr<internal::SolverEngine> d_slv;
/** The random number generator of this solver. */
- std::unique_ptr<Random> d_rng;
+ std::unique_ptr<internal::Random> d_rng;
};
-} // namespace cvc5::api
+} // namespace cvc5
#endif
#define CVC5__API__CHECKS_H
namespace cvc5 {
-namespace api {
/* -------------------------------------------------------------------------- */
/* Basic check macros. */
*/
#define CVC5_API_CHECK(cond) \
CVC5_PREDICT_TRUE(cond) \
- ? (void)0 : OstreamVoider() & CVC5ApiExceptionStream().ostream()
+ ? (void)0 \
+ : cvc5::internal::OstreamVoider() & CVC5ApiExceptionStream().ostream()
/**
* The base check macro for throwing recoverable exceptions.
*/
#define CVC5_API_RECOVERABLE_CHECK(cond) \
CVC5_PREDICT_TRUE(cond) \
- ? (void)0 : OstreamVoider() & CVC5ApiRecoverableExceptionStream().ostream()
+ ? (void)0 \
+ : cvc5::internal::OstreamVoider() \
+ & CVC5ApiRecoverableExceptionStream().ostream()
/**
* The base check macro for throwing unsupported exceptions.
*/
#define CVC5_API_UNSUPPORTED_CHECK(cond) \
CVC5_PREDICT_TRUE(cond) \
- ? (void)0 : OstreamVoider() & CVC5ApiUnsupportedExceptionStream().ostream()
+ ? (void)0 \
+ : cvc5::internal::OstreamVoider() \
+ & CVC5ApiUnsupportedExceptionStream().ostream()
/* -------------------------------------------------------------------------- */
/* Not null checks. */
#define CVC5_API_KIND_CHECK_EXPECTED(cond, kind) \
CVC5_PREDICT_TRUE(cond) \
? (void)0 \
- : OstreamVoider() \
+ : cvc5::internal::OstreamVoider() \
& CVC5ApiExceptionStream().ostream() \
<< "Invalid kind '" << kindToString(kind) << "', expected "
#define CVC5_API_ARG_CHECK_EXPECTED(cond, arg) \
CVC5_PREDICT_TRUE(cond) \
? (void)0 \
- : OstreamVoider() \
+ : cvc5::internal::OstreamVoider() \
& CVC5ApiExceptionStream().ostream() \
<< "Invalid argument '" << arg << "' for '" << #arg \
<< "', expected "
#define CVC5_API_RECOVERABLE_ARG_CHECK_EXPECTED(cond, arg) \
CVC5_PREDICT_TRUE(cond) \
? (void)0 \
- : OstreamVoider() \
+ : cvc5::internal::OstreamVoider() \
& CVC5ApiRecoverableExceptionStream().ostream() \
<< "Invalid argument '" << arg << "' for '" << #arg \
<< "', expected "
#define CVC5_API_ARG_SIZE_CHECK_EXPECTED(cond, arg) \
CVC5_PREDICT_TRUE(cond) \
? (void)0 \
- : OstreamVoider() \
+ : cvc5::internal::OstreamVoider() \
& CVC5ApiExceptionStream().ostream() \
<< "Invalid size of argument '" << #arg << "', expected "
#define CVC5_API_ARG_AT_INDEX_CHECK_EXPECTED(cond, what, args, idx) \
CVC5_PREDICT_TRUE(cond) \
? (void)0 \
- : OstreamVoider() \
+ : cvc5::internal::OstreamVoider() \
& CVC5ApiExceptionStream().ostream() \
<< "Invalid " << (what) << " in '" << #args << "' at index " \
<< (idx) << ", expected "
this == bv.d_solver, "bound variable", bound_vars, i) \
<< "a term associated with this solver object"; \
CVC5_API_ARG_AT_INDEX_CHECK_EXPECTED( \
- bv.d_node->getKind() == cvc5::Kind::BOUND_VARIABLE, \
+ bv.d_node->getKind() == cvc5::internal::Kind::BOUND_VARIABLE, \
"bound variable", \
bound_vars, \
i) \
this == bv.d_solver, "bound variable", bound_vars, i) \
<< "a term associated with this solver object"; \
CVC5_API_ARG_AT_INDEX_CHECK_EXPECTED( \
- bv.d_node->getKind() == cvc5::Kind::BOUND_VARIABLE, \
+ bv.d_node->getKind() == cvc5::internal::Kind::BOUND_VARIABLE, \
"bound variable", \
bound_vars, \
i) \
<< "Invalid number of indices for operator " << kind << ". Expected " \
<< expected << " but got " << nargs << "."
-} // namespace api
} // namespace cvc5
#endif
#include <ostream>
-namespace cvc5::api {
+namespace cvc5 {
/* -------------------------------------------------------------------------- */
/* Kind */
*
* \internal
*
- * Note that the API type `cvc5::api::Kind` roughly corresponds to
- * `cvc5::Kind`, but is a different type. It hides internal kinds that should
+ * Note that the API type `cvc5::Kind` roughly corresponds to
+ * `cvc5::internal::Kind`, but is a different type. It hides internal kinds that should
* not be exported to the API, and maps all kinds that we want to export to its
- * corresponding internal kinds. The underlying type of `cvc5::api::Kind` must
+ * corresponding internal kinds. The underlying type of `cvc5::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
+ * depends on the size of `cvc5::internal::Kind` (`NodeValue::NBITS_KIND`, currently 10
* bits, see expr/node_value.h).
*/
enum Kind : int32_t
*/
std::ostream& operator<<(std::ostream& out, Kind k) CVC5_EXPORT;
-} // namespace cvc5::api
+} // namespace cvc5
namespace std {
/**
* Hash function for Kinds.
*/
-template<>
-struct CVC5_EXPORT hash<cvc5::api::Kind>
+template <>
+struct CVC5_EXPORT hash<cvc5::Kind>
{
/**
* Hashes a Kind to a size_t.
*/
- size_t operator()(cvc5::api::Kind k) const;
+ size_t operator()(cvc5::Kind k) const;
};
}
#ifndef CVC5__API__CVC5_TYPES_H
#define CVC5__API__CVC5_TYPES_H
-namespace cvc5::api {
+namespace cvc5 {
/**
* Rounding modes for floating-point numbers.
ROUND_NEAREST_TIES_TO_AWAY,
};
-} // namespace cvc5::api
+} // namespace cvc5
namespace cvc5::modes {
install_jar_exports(
TARGETS cvc5jar
- NAMESPACE cvc5::
+ NAMESPACE cvc5::internal::
FILE cvc5JavaTargets.cmake
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/cvc5
)
r"\buint32_t\b": "int",
r"\buint64_t\b": "long",
r"\bunsigned char\b": "byte",
- r"cvc5::api::": "cvc5.",
+ r"cvc5::": "cvc5.",
r"Term::Term\(\)": "Solver.getNullTerm()",
r"Solver::": "Solver.",
r"std::vector<int>": "int[]",
def gen_java(parser: EnumParser, path):
for namespace in parser.namespaces:
for enum in namespace.enums:
- subnamespace = namespace.name.split('::')[1]
+ subnamespace = namespace.name.split('::')[-1]
+ # Workaround to make it work without moving the java files. Will be
+ # done in a subsequent PR by Andres
+ if subnamespace == 'cvc5':
+ subnamespace = 'api'
filedir = os.path.join(path, subnamespace)
if not os.path.exists(filedir):
os.mkdir(filedir)
#include "api_utilities.h"
#include "io_github_cvc5_api_Datatype.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_Datatype
#include "api_utilities.h"
#include "io_github_cvc5_api_DatatypeConstructor.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_DatatypeConstructor
#include "api_utilities.h"
#include "io_github_cvc5_api_DatatypeConstructorDecl.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_DatatypeConstructorDecl
#include "api_utilities.h"
#include "io_github_cvc5_api_DatatypeDecl.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_DatatypeDecl
#include "api_utilities.h"
#include "io_github_cvc5_api_DatatypeSelector.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_DatatypeSelector
#include "api_utilities.h"
#include "io_github_cvc5_api_Grammar.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_Grammar
#include "api_utilities.h"
#include "io_github_cvc5_api_Op.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_Op
#include "api_utilities.h"
#include "io_github_cvc5_api_OptionInfo.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_OptionInfo
#include "api_utilities.h"
#include "io_github_cvc5_api_Result.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_Result
#include "api_utilities.h"
#include "io_github_cvc5_api_Solver.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_Solver
#include "api_utilities.h"
#include "io_github_cvc5_api_Sort.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_Sort
#include "api_utilities.h"
#include "io_github_cvc5_api_Stat.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_Stat
#include "api_utilities.h"
#include "io_github_cvc5_api_Statistics.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_Statistics
#include "api_utilities.h"
#include "io_github_cvc5_api_SynthResult.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_SynthResult
#include "api_utilities.h"
#include "io_github_cvc5_api_Term.h"
-using namespace cvc5::api;
+using namespace cvc5;
/*
* Class: io_github_cvc5_api_Term
pass
-cdef extern from "api/cpp/cvc5.h" namespace "cvc5::api":
+cdef extern from "api/cpp/cvc5.h" namespace "cvc5":
cdef cppclass Datatype:
Datatype() except +
DatatypeConstructor operator[](size_t idx) except +
bint holds "std::holds_alternative"[T](OptionInfo.OptionInfoVariant v) except +
T getVariant "std::get"[T](OptionInfo.OptionInfoVariant v) except +
-cdef extern from "api/cpp/cvc5.h" namespace "cvc5::api":
+cdef extern from "api/cpp/cvc5.h" namespace "cvc5":
cdef cppclass Result:
Result() except+
bint isNull() except +
bint isUnknown() except +
string toString() except +
- cdef extern from "api/cpp/cvc5.h" namespace "cvc5::api::Result":
+ cdef extern from "api/cpp/cvc5.h" namespace "cvc5::Result":
cdef cppclass UnknownExplanation:
pass
size_t operator()(const Term & t) except +
-cdef extern from "api/cpp/cvc5.h" namespace "cvc5::api::Result::UnknownExplanation":
+cdef extern from "api/cpp/cvc5.h" namespace "cvc5::Result::UnknownExplanation":
cdef UnknownExplanation REQUIRES_FULL_CHECK
cdef UnknownExplanation INCOMPLETE
cdef UnknownExplanation TIMEOUT
cdef class Datatype:
"""
A cvc5 datatype.
- Wrapper class for :cpp:class:`cvc5::api::Datatype`.
+ Wrapper class for :cpp:class:`cvc5::Datatype`.
"""
cdef c_Datatype cd
cdef Solver solver
def getConstructorTerm(self, str name):
"""
:param name: the name of the constructor.
- :return: the term representing the datatype constructor with the given name (see :cpp:func:`Datatype::getConstructorTerm() <cvc5::api::Datatype::getConstructorTerm>`).
+ :return: the term representing the datatype constructor with the given name (see :cpp:func:`Datatype::getConstructorTerm() <cvc5::Datatype::getConstructorTerm>`).
"""
cdef Term term = Term(self.solver)
term.cterm = self.cd.getConstructorTerm(name.encode())
return self.cd.isFinite()
def isWellFounded(self):
- """:return: True if this datatype is well-founded (see :cpp:func:`Datatype::isWellFounded() <cvc5::api::Datatype::isWellFounded>`)."""
+ """:return: True if this datatype is well-founded (see :cpp:func:`Datatype::isWellFounded() <cvc5::Datatype::isWellFounded>`)."""
return self.cd.isWellFounded()
def isNull(self):
cdef class DatatypeConstructor:
"""
A cvc5 datatype constructor.
- Wrapper class for :cpp:class:`cvc5::api::DatatypeConstructor`.
+ Wrapper class for :cpp:class:`cvc5::DatatypeConstructor`.
"""
cdef c_DatatypeConstructor cdc
cdef Solver solver
"""
Specialized method for parametric datatypes (see
:cpp:func:`DatatypeConstructor::getInstantiatedConstructorTerm()
- <cvc5::api::DatatypeConstructor::getInstantiatedConstructorTerm>`).
+ <cvc5::DatatypeConstructor::getInstantiatedConstructorTerm>`).
.. warning:: This method is experimental and may change in future
versions.
cdef class DatatypeConstructorDecl:
"""
A cvc5 datatype constructor declaration.
- Wrapper class for :cpp:class:`cvc5::api::DatatypeConstructorDecl`.
+ Wrapper class for :cpp:class:`cvc5::DatatypeConstructorDecl`.
"""
cdef c_DatatypeConstructorDecl cddc
cdef Solver solver
cdef class DatatypeDecl:
"""
A cvc5 datatype declaration.
- Wrapper class for :cpp:class:`cvc5::api::DatatypeDecl`.
+ Wrapper class for :cpp:class:`cvc5::DatatypeDecl`.
"""
cdef c_DatatypeDecl cdd
cdef Solver solver
cdef class DatatypeSelector:
"""
A cvc5 datatype selector.
- Wrapper class for :cpp:class:`cvc5::api::DatatypeSelector`.
+ Wrapper class for :cpp:class:`cvc5::DatatypeSelector`.
"""
cdef c_DatatypeSelector cds
cdef Solver solver
An operator is a term that represents certain operators,
instantiated with its required parameters, e.g.,
a term of kind :cpp:enumerator:`BITVECTOR_EXTRACT`.
- Wrapper class for :cpp:class:`cvc5::api::Op`.
+ Wrapper class for :cpp:class:`cvc5::Op`.
"""
cdef c_Op cop
cdef Solver solver
cdef class Grammar:
"""
A Sygus Grammar.
- Wrapper class for :cpp:class:`cvc5::api::Grammar`.
+ Wrapper class for :cpp:class:`cvc5::Grammar`.
"""
cdef c_Grammar cgrammar
cdef Solver solver
cdef class Result:
"""
Encapsulation of a three-valued solver result, with explanations.
- Wrapper class for :cpp:class:`cvc5::api::Result`.
+ Wrapper class for :cpp:class:`cvc5::Result`.
"""
cdef c_Result cr
def __cinit__(self):
def isNull(self):
"""
:return: True if Result is empty, i.e., a nullary Result, and not an actual result returned from a
- :cpp:func:`Solver::checkSat() <cvc5::api::Solver::checkSat>` (and friends) query.
+ :cpp:func:`Solver::checkSat() <cvc5::Solver::checkSat>` (and friends) query.
"""
return self.cr.isNull()
def isSat(self):
"""
- :return: True if query was a satisfiable :cpp:func:`Solver::checkSat() <cvc5::api::Solver::checkSat>` or :cpp:func:`Solver::checkSatAssuming() <cvc5::api::Solver::checkSatAssuming>` query.
+ :return: True if query was a satisfiable :cpp:func:`Solver::checkSat() <cvc5::Solver::checkSat>` or :cpp:func:`Solver::checkSatAssuming() <cvc5::Solver::checkSatAssuming>` query.
"""
return self.cr.isSat()
def isUnsat(self):
"""
- :return: True if query was an usatisfiable :cpp:func:`Solver::checkSat() <cvc5::api::Solver::checkSat>` or :cpp:func:`Solver::checkSatAssuming() <cvc5::api::Solver::checkSatAssuming>` query.
+ :return: True if query was an usatisfiable :cpp:func:`Solver::checkSat() <cvc5::Solver::checkSat>` or :cpp:func:`Solver::checkSatAssuming() <cvc5::Solver::checkSatAssuming>` query.
"""
return self.cr.isUnsat()
def isUnknown(self):
"""
- :return: True if query was a :cpp:func:`Solver::checkSat() <cvc5::api::Solver::checkSat>` or :cpp:func:`Solver::checkSatAssuming() <cvc5::api::Solver::checkSatAssuming>` query and cvc5 was not able to determine (un)satisfiability.
+ :return: True if query was a :cpp:func:`Solver::checkSat() <cvc5::Solver::checkSat>` or :cpp:func:`Solver::checkSatAssuming() <cvc5::Solver::checkSatAssuming>` query and cvc5 was not able to determine (un)satisfiability.
"""
return self.cr.isUnknown()
cdef class UnknownExplanation:
"""
- Wrapper class for :cpp:enum:`cvc5::api::Result::UnknownExplanation`.
+ Wrapper class for :cpp:enum:`cvc5::Result::UnknownExplanation`.
"""
cdef c_UnknownExplanation cue
cdef str name
cdef class Solver:
- """Wrapper class for :cpp:class:`cvc5::api::Solver`."""
+ """Wrapper class for :cpp:class:`cvc5::Solver`."""
cdef c_Solver* csolver
def __cinit__(self):
cdef class Statistics:
"""
The cvc5 Statistics.
- Wrapper class for :cpp:class:`cvc5::api::Statistics`.
+ Wrapper class for :cpp:class:`cvc5::Statistics`.
Obtain a single statistic value using ``stats["name"]`` and a dictionary
with all (visible) statistics using ``stats.get(internal=False, defaulted=False)``.
"""
return self.__stat_to_dict(self.cstats.get(name.encode()))
def get(self, bint internal = False, bint defaulted = False):
- """Get all statistics. See :cpp:class:`cvc5::api::Statistics::begin()` for more information."""
+ """Get all statistics. See :cpp:class:`cvc5::Statistics::begin()` for more information."""
cdef c_Statistics.iterator it = self.cstats.begin(internal, defaulted)
cdef pair[string,c_Stat]* s
res = {}
cdef class Term:
"""
A cvc5 Term.
- Wrapper class for :cpp:class:`cvc5::api::Term`.
+ Wrapper class for :cpp:class:`cvc5::Term`.
"""
cdef c_Term cterm
cdef Solver solver
(singleton c1) ... (union (singleton c_{n-1}) (singleton c_n))))
where ``c1 ... cn`` are values ordered by id such that
- ``c1 > ... > cn`` (see also :cpp:func:`cvc5::api::Term::operator>()`).
+ ``c1 > ... > cn`` (see also :cpp:func:`cvc5::Term::operator>()`).
.. note::
A universe set term ``(kind SET_UNIVERSE)`` is not considered to be
#include <cstdlib>
#include <iostream>
-namespace cvc5 {
+namespace cvc5::internal {
FatalStream::FatalStream(const char* function, const char* file, int line)
{
line);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/exception.h"
#include "cvc5_export.h"
-namespace cvc5 {
+namespace cvc5::internal {
// Implementation notes:
// To understand FatalStream and OStreamVoider, it is useful to understand
// }
// }
#define CVC5_FATAL() \
- FatalStream(__PRETTY_FUNCTION__, __FILE__, __LINE__).stream()
+ internal::FatalStream(__PRETTY_FUNCTION__, __FILE__, __LINE__).stream()
/* GCC <= 9.2 ignores CVC5_NO_RETURN of ~FatalStream() if
* used in template classes (e.g., CDHashMap::save()). As a workaround we
// inserted into.
#define CVC5_FATAL_IF(cond, function, file, line) \
CVC5_PREDICT_FALSE(!(cond)) \
- ? (void)0 : OstreamVoider() & FatalStream(function, file, line).stream()
+ ? (void)0 \
+ : cvc5::internal::OstreamVoider() \
+ & cvc5::internal::FatalStream(function, file, line).stream()
// If `cond` is false, log an error message and abort()'s the process.
// Otherwise, does nothing. This leaves a hanging std::ostream& that can be
#define InternalError() CVC5_FATAL() << "Internal error detected "
#define IllegalArgument(arg, msg...) \
- throw ::cvc5::IllegalArgumentException( \
+ throw ::cvc5::internal::IllegalArgumentException( \
"", \
#arg, \
__PRETTY_FUNCTION__, \
- ::cvc5::IllegalArgumentException::formatVariadic(msg).c_str());
+ ::cvc5::internal::IllegalArgumentException::formatVariadic(msg).c_str());
// This cannot use check argument directly as this forces
// CheckArgument to use a va_list. This is unsupported in Swig.
#define PrettyCheckArgument(cond, arg, msg...) \
{ \
if (__builtin_expect((!(cond)), false)) \
{ \
- throw ::cvc5::IllegalArgumentException( \
+ throw ::cvc5::internal::IllegalArgumentException( \
#cond, \
#arg, \
__PRETTY_FUNCTION__, \
- ::cvc5::IllegalArgumentException::formatVariadic(msg).c_str()); \
+ ::cvc5::internal::IllegalArgumentException::formatVariadic(msg).c_str()); \
} \
} while (0)
#define AlwaysAssertArgument(cond, arg, msg...) \
{ \
if (__builtin_expect((!(cond)), false)) \
{ \
- throw ::cvc5::AssertArgumentException( \
+ throw ::cvc5::internal::AssertArgumentException( \
#cond, #arg, __PRETTY_FUNCTION__, __FILE__, __LINE__, ##msg); \
} \
} while (0)
cond, arg, msg...) /*__builtin_expect( ( cond ), true )*/
#endif /* CVC5_ASSERTIONS */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CHECK_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
string Configuration::getName() { return CVC5_PACKAGE_NAME; }
return __DATE__ " " __TIME__;
}
-} // namespace cvc5
+} // namespace cvc5::internal
* about the cvc5 library.
*
* Eventually, the configuration methods will all be migrated to the
- * cvc5::configuration namespace below. This is cleaner and avoids a gcc/10.1.0
+ * cvc5::internal::configuration namespace below. This is cleaner and avoids a gcc/10.1.0
* bug. See https://github.com/cvc5/cvc5/pull/7898 for details.
*/
#include "cvc5_export.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace configuration {
static constexpr bool isStatisticsBuild()
}; /* class Configuration */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONFIGURATION_H */
#include "base/configuration.h"
-namespace cvc5 {
+namespace cvc5::internal {
#ifdef CVC5_DEBUG
# define IS_DEBUG_BUILD true
#endif /* __has_feature(thread_sanitizer) */
#endif /* defined(__has_feature) */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONFIGURATION_PRIVATE_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
std::string Exception::toString() const
{
delete [] buf;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "cvc5_export.h"
-namespace cvc5 {
+namespace cvc5::internal {
class CVC5_EXPORT Exception : public std::exception
{
const char* tail CVC5_UNUSED)
{
if(__builtin_expect( ( !cond ), false )) {
- throw ::cvc5::IllegalArgumentException("", "", tail);
+ throw ::cvc5::internal::IllegalArgumentException("", "", tail);
}
}
template <class T>
inline void CheckArgument(bool cond, const T& arg CVC5_UNUSED)
{
if(__builtin_expect( ( !cond ), false )) {
- throw ::cvc5::IllegalArgumentException("", "", "");
+ throw ::cvc5::internal::IllegalArgumentException("", "", "");
}
}
static thread_local LastExceptionBuffer* s_currentBuffer;
}; /* class LastExceptionBuffer */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXCEPTION_H */
#include "base/listener.h"
-namespace cvc5 {
+namespace cvc5::internal {
Listener::Listener(){}
Listener::~Listener(){}
-} // namespace cvc5
+} // namespace cvc5::internal
#ifndef CVC5__LISTENER_H
#define CVC5__LISTENER_H
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Listener interface class.
virtual void notify() = 0;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__LISTENER_H */
* Supports:
* - std::map
* - std::unordered_map
- * - cvc5::context::CDHashmap
- * - cvc5::context::CDInsertHashmap
+ * - cvc5::internal::context::CDHashmap
+ * - cvc5::internal::context::CDInsertHashmap
* The ContainsKey function is also compatible with std::[unordered_]set.
*
* Currently implemented classes of functions:
#include "base/check.h"
-namespace cvc5 {
+namespace cvc5::internal {
// Returns true if the `map` contains the `key`.
//
return (*it).second;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__BASE__MAP_UTIL_H */
#include "base/exception.h"
-namespace cvc5 {
+namespace cvc5::internal {
-class ModalException : public cvc5::Exception
+class ModalException : public cvc5::internal::Exception
{
public:
ModalException() :
* 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::internal::ModalException
{
public:
RecoverableModalException(const std::string& msg) : ModalException(msg) {}
RecoverableModalException(const char* msg) : ModalException(msg) {}
}; /* class RecoverableModalException */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__MODAL_EXCEPTION_H */
#include <iostream>
-namespace cvc5 {
+namespace cvc5::internal {
/* Definitions of the declared globals from output.h... */
WarningC WarningChannel(&std::cerr);
TraceC TraceChannel(&std::cout);
-} // namespace cvc5
+} // namespace cvc5::internal
#include "cvc5_export.h"
-namespace cvc5 {
+namespace cvc5::internal {
template <class T, class U>
std::ostream& operator<<(std::ostream& out, const std::pair<T, U>& p) {
#ifdef CVC5_MUZZLE
#define Warning \
- ::cvc5::__cvc5_true() ? ::cvc5::nullStream : ::cvc5::WarningChannel
+ ::cvc5::internal::__cvc5_true() ? ::cvc5::internal::nullStream : ::cvc5::internal::WarningChannel
#define WarningOnce \
- ::cvc5::__cvc5_true() ? ::cvc5::nullStream : ::cvc5::WarningChannel
-#define TraceIsOn ::cvc5::__cvc5_true() ? false : ::cvc5::TraceChannel.isOn
-#define Trace(tag) ::cvc5::__cvc5_true() ? ::cvc5::nullStream : ::cvc5::TraceChannel()
+ ::cvc5::internal::__cvc5_true() ? ::cvc5::internal::nullStream : ::cvc5::internal::WarningChannel
+#define TraceIsOn ::cvc5::internal::__cvc5_true() ? false : ::cvc5::internal::TraceChannel.isOn
+#define Trace(tag) ::cvc5::internal::__cvc5_true() ? ::cvc5::internal::nullStream : ::cvc5::internal::TraceChannel()
#else /* CVC5_MUZZLE */
#define Warning \
- (!::cvc5::WarningChannel.isOn()) ? ::cvc5::nullStream : ::cvc5::WarningChannel
+ (!::cvc5::internal::WarningChannel.isOn()) ? ::cvc5::internal::nullStream : ::cvc5::internal::WarningChannel
#define WarningOnce \
- (!::cvc5::WarningChannel.isOn() \
- || !::cvc5::WarningChannel.warnOnce(__FILE__, __LINE__)) \
- ? ::cvc5::nullStream \
- : ::cvc5::WarningChannel
+ (!::cvc5::internal::WarningChannel.isOn() \
+ || !::cvc5::internal::WarningChannel.warnOnce(__FILE__, __LINE__)) \
+ ? ::cvc5::internal::nullStream \
+ : ::cvc5::internal::WarningChannel
#ifdef CVC5_TRACING
-#define TraceIsOn ::cvc5::TraceChannel.isOn
-#define Trace(tag) !::cvc5::TraceChannel.isOn(tag) ? ::cvc5::nullStream : ::cvc5::TraceChannel()
+#define TraceIsOn ::cvc5::internal::TraceChannel.isOn
+#define Trace(tag) !::cvc5::internal::TraceChannel.isOn(tag) ? ::cvc5::internal::nullStream : ::cvc5::internal::TraceChannel()
#else /* CVC5_TRACING */
-#define TraceIsOn ::cvc5::__cvc5_true() ? false : ::cvc5::TraceChannel.isOn
-#define Trace(tag) ::cvc5::__cvc5_true() ? ::cvc5::nullStream : ::cvc5::TraceChannel()
+#define TraceIsOn ::cvc5::internal::__cvc5_true() ? false : ::cvc5::internal::TraceChannel.isOn
+#define Trace(tag) ::cvc5::internal::__cvc5_true() ? ::cvc5::internal::nullStream : ::cvc5::internal::TraceChannel()
#endif /* CVC5_TRACING */
#endif /* CVC5_MUZZLE */
inline ~IndentedScope() { d_out << pop; }
}; /* class IndentedScope */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__OUTPUT_H */
#include "base/configuration.h"
-const bool ::cvc5::Configuration::GIT_BUILD = @GIT_BUILD@;
-const bool ::cvc5::Configuration::CVC5_IS_RELEASE = @CVC5_IS_RELEASE@;
-const char* const ::cvc5::Configuration::CVC5_VERSION = "@CVC5_VERSION@";
-const char* const ::cvc5::Configuration::CVC5_FULL_VERSION = "@CVC5_FULL_VERSION@";
-const char* const ::cvc5::Configuration::CVC5_GIT_INFO = "@CVC5_GIT_INFO@";
+const bool ::cvc5::internal::Configuration::GIT_BUILD = @GIT_BUILD@;
+const bool ::cvc5::internal::Configuration::CVC5_IS_RELEASE = @CVC5_IS_RELEASE@;
+const char* const ::cvc5::internal::Configuration::CVC5_VERSION = "@CVC5_VERSION@";
+const char* const ::cvc5::internal::Configuration::CVC5_FULL_VERSION = "@CVC5_FULL_VERSION@";
+const char* const ::cvc5::internal::Configuration::CVC5_GIT_INFO = "@CVC5_GIT_INFO@";
#include "context/cdhashmap_forward.h"
#include "context/context.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
// Auxiliary class: almost the same as CDO (see cdo.h)
}; /* class CDHashMap<> */
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONTEXT__CDHASHMAP_H */
/// \cond internals
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
template <class Key, class Data, class HashFcn = std::hash<Key> >
class CDHashMap;
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
/// \endcond
#include "context/cdinsert_hashmap.h"
#include "context/context.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
template <class V, class HashFcn = std::hash<V>>
}; /* class CDHashSet */
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONTEXT__CDHASHSET_H */
#include <functional>
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
template <class V, class HashFcn = std::hash<V> >
class CDHashSet;
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONTEXT__CDSET_FORWARD_H */
#pragma once
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
};
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#include <functional>
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
template <class Key, class Data, class HashFcn = std::hash<Key> >
class CDInsertHashMap;
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONTEXT__CDINSERT_HASHMAP_FORWARD_H */
#include "context/context.h"
#include "context/context_mm.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
/**
};
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONTEXT__CDLIST_H */
/// \cond internals
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
template <class T>
/// \endcond
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONTEXT__CDLIST_FORWARD_H */
#include "context/cdo.h"
#include "context/context.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
class CDRaised {
};/* class CDMaybe<T> */
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/context.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
/**
};/* class CDO */
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONTEXT__CDO_H */
#include "context/context.h"
#include "context/cdlist.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
template <class T, class CleanUp = DefaultCleanUp<T>, class Allocator = std::allocator<T> >
};/* class CDQueue<> */
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONTEXT__CDQUEUE_H */
#include "context/cdlist.h"
#include "context/cdo.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
class Context;
};/* class CDTrailQueue<> */
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONTEXT__CDTRAIL_QUEUE_H */
#include "base/check.h"
#include "context/context.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
}
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/output.h"
#include "context/context_mm.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
class Context;
}
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONTEXT__CONTEXT_H */
#include "base/output.h"
#include "context/context_mm.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
#ifndef CVC5_DEBUG_CONTEXT_MEMORY_MANAGER
#endif /* CVC5_DEBUG_CONTEXT_MEMORY_MANAGER */
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <vector>
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
#ifndef CVC5_DEBUG_CONTEXT_MEMORY_MANAGER
}
} // namespace context
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CONTEXT__CONTEXT_MM_H */
#include "decision/assertion_list.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
const char* toString(DecisionStatus s)
}
} // namespace decision
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/cdo.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
/**
};
} // namespace decision
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__DECISION__ASSERTION_LIST_H */
#include "util/resource_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
DecisionEngine::DecisionEngine(Env& env)
}
} // namespace decision
-} // namespace cvc5
+} // namespace cvc5::internal
#include "prop/sat_solver_types.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
class DecisionEngine : protected EnvObj
};
} // namespace decision
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__DECISION__DECISION_ENGINE_H */
#include "prop/skolem_def_manager.h"
-using namespace cvc5::kind;
-using namespace cvc5::prop;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::prop;
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
JustificationStrategy::JustificationStrategy(Env& env)
}
} // namespace decision
-} // namespace cvc5
+} // namespace cvc5::internal
#include "prop/sat_solver.h"
#include "prop/sat_solver_types.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
/**
};
} // namespace decision
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__DECISION__JUSTIFICATION_STRATEGY_H */
#include "decision/justify_info.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
JustifyInfo::JustifyInfo(context::Context* c)
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "prop/sat_solver_types.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
/** A pair indicating a node and its desired value */
};
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__DECISION__JUSTIFY_INFO_H */
#include "decision/justify_stack.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
JustifyStack::JustifyStack(context::Context* c)
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "decision/justify_info.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
/**
};
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__DECISION__JUSTIFY_INFO_H */
#include "smt/smt_statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
JustifyStatistics::JustifyStatistics()
JustifyStatistics::~JustifyStatistics() {}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace decision {
class JustifyStatistics
};
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__DECISION__JUSTIFY_STATS_H */
#include "expr/node.h"
-namespace cvc5::expr::algorithm {
+namespace cvc5::internal::expr::algorithm {
/**
* Flatten a node into a vector of its (direct or indirect) children.
return NodeManager::currentNM()->mkNode(t.getKind(), children);
}
-} // namespace cvc5::expr
+} // namespace cvc5::internal::expr
#endif
#include "expr/annotation_elim_node_converter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
AnnotationElimNodeConverter::AnnotationElimNodeConverter() {}
return n;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/node_converter.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* This converts a node into one that does not involve annotations for
Node postConvert(Node n) override;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
ArrayStoreAll::ArrayStoreAll(const TypeNode& type, const Node& value)
: d_type(), d_value()
* std::hash<Node>()(asa.getValue());
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
#include <memory>
-namespace cvc5 {
+namespace cvc5::internal {
template <bool ref_count>
class NodeTemplate;
size_t operator()(const ArrayStoreAll& asa) const;
}; /* struct ArrayStoreAllHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__ARRAY_STORE_ALL_H */
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
AscriptionType::AscriptionType(TypeNode t) : d_type(new TypeNode(t)) {}
return out;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
#include <memory>
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
/** An output routine for AscriptionTypes */
std::ostream& operator<<(std::ostream& out, AscriptionType at);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__ASCRIPTION_TYPE_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
namespace attr {
} // namespace attr
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/attribute_internals.h"
#undef CVC5_ATTRIBUTE_H__INCLUDING__ATTRIBUTE_INTERNALS_H
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
namespace attr {
d_attrManager->setAttribute(n.d_nv, AttrKind(), value);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__ATTRIBUTE_H */
#include <unordered_map>
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
// ATTRIBUTE HASH FUNCTIONS ====================================================
Attribute<T, bool>::registerAttribute();
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__ATTRIBUTE_INTERNALS_H */
// ATTRIBUTE IDs ============================================================
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
namespace attr {
AttrTableId getTableId() const{ return d_tableId; }
uint64_t getWithinTypeId() const{ return d_withinTypeId; }
-}; /* cvc5::expr::attr::AttributeUniqueId */
+}; /* cvc5::internal::expr::attr::AttributeUniqueId */
} // namespace attr
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_manager_attributes.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
BoundVarManager::BoundVarManager() : d_keepCacheVals(false) {}
return getCacheValue(cv, getCacheValue(i));
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Bound variable manager.
std::unordered_set<Node> d_cacheVals;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__BOUND_VAR_MANAGER_H */
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
CardinalityConstraint::CardinalityConstraint(const TypeNode& type,
const Integer& ub)
return cc.getUpperBound().hash();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
#include "util/hash.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
size_t operator()(const CombinedCardinalityConstraint& cc) const;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
CodatatypeBoundVariable::CodatatypeBoundVariable(const TypeNode& type,
Integer index)
* IntegerHashFunction()(cbv.getIndex());
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
size_t operator()(const CodatatypeBoundVariable& cbv) const;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__UNINTERPRETED_CONSTANT_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
DatatypeIndexConstant::DatatypeIndexConstant(uint32_t index) : d_index(index) {}
std::ostream& operator<<(std::ostream& out, const DatatypeIndexConstant& dic)
return IntegerHashFunction()(dic.getIndex());
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
/* stores an index to Datatype residing in NodeManager */
class DatatypeIndexConstant
size_t operator()(const DatatypeIndexConstant& dic) const;
}; /* struct DatatypeIndexConstantHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__DATATYPE_H */
#include "expr/type_matcher.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
DType::DType(std::string name, bool isCo)
: d_name(name),
return out << "index_" << dic.getIndex();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "util/cardinality.h"
-namespace cvc5 {
+namespace cvc5::internal {
// ----------------------- datatype attributes
/**
std::ostream& operator<<(std::ostream& os, const DType& dt);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/type_matcher.h"
#include "options/datatypes_options.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
DTypeConstructor::DTypeConstructor(std::string name,
unsigned weight)
return os;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "util/cardinality_class.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* The Node-level representation of a constructor for a datatype, which
std::ostream& operator<<(std::ostream& os, const DTypeConstructor& ctor);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/dtype_selector.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
DTypeSelector::DTypeSelector(std::string name, Node selector, Node updater)
: d_name(name), d_selector(selector), d_updater(updater), d_resolved(false)
return os;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class DatatypeConstructorArg;
class DType;
std::ostream& operator<<(std::ostream& os, const DTypeSelector& arg);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& out, const EmptyBag& asa)
{
bool EmptyBag::operator>(const EmptyBag& es) const { return !(*this <= es); }
bool EmptyBag::operator>=(const EmptyBag& es) const { return !(*this < es); }
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
#include <memory>
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
size_t operator()(const EmptyBag& es) const;
}; /* struct EmptyBagHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EMPTY_BAG_H */
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& out, const EmptySet& asa) {
return out << "emptyset(" << asa.getType() << ')';
bool EmptySet::operator>(const EmptySet& es) const { return !(*this <= es); }
bool EmptySet::operator>=(const EmptySet& es) const { return !(*this < es); }
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
#include <memory>
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
size_t operator()(const EmptySet& es) const;
}; /* struct EmptySetHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EMPTY_SET_H */
#include "base/check.h"
#include "expr/kind.h"
-namespace cvc5 {
+namespace cvc5::internal {
/** A very simple bitmap for Kinds */
class KindMap
std::bitset<kind::LAST_KIND> d_bits;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__KIND_MAP_H */
#include "expr/kind.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace kind {
-const char* toString(cvc5::Kind k)
+const char* toString(cvc5::internal::Kind k)
{
- using namespace cvc5::kind;
+ using namespace cvc5::internal::kind;
switch (k)
{
}
}
-std::ostream& operator<<(std::ostream& out, cvc5::Kind k)
+std::ostream& operator<<(std::ostream& out, cvc5::internal::Kind k)
{
out << toString(k);
return out;
* decide whether it's safe to modify big expressions by changing the grouping of
* the arguments. */
/* TODO: This could be generated. */
-bool isAssociative(::cvc5::Kind k)
+bool isAssociative(::cvc5::internal::Kind k)
{
switch(k) {
case kind::AND:
}
}
-std::string kindToString(::cvc5::Kind k) { return toString(k); }
+std::string kindToString(::cvc5::internal::Kind k) { return toString(k); }
} // namespace kind
namespace theory {
-TheoryId kindToTheoryId(::cvc5::Kind k)
+TheoryId kindToTheoryId(::cvc5::internal::Kind k)
{
switch (k)
{
throw IllegalArgumentException("", "k", __PRETTY_FUNCTION__, "bad kind");
}
-TheoryId typeConstantToTheoryId(::cvc5::TypeConstant typeConstant)
+TheoryId typeConstantToTheoryId(::cvc5::internal::TypeConstant typeConstant)
{
switch (typeConstant)
{
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/exception.h"
#include "theory/theory_id.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace kind {
enum Kind_t
// import Kind into the "cvc5" namespace but keep the individual kind
// constants under kind::
-typedef ::cvc5::kind::Kind_t Kind;
+typedef ::cvc5::internal::kind::Kind_t Kind;
namespace kind {
* @param k The kind
* @return The name of the kind
*/
-const char* toString(cvc5::Kind k);
+const char* toString(cvc5::internal::Kind k);
/**
* Writes a kind name to a stream.
* @param k The kind to write to the stream
* @return The stream
*/
-std::ostream& operator<<(std::ostream&, cvc5::Kind);
+std::ostream& operator<<(std::ostream&, cvc5::internal::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::internal::Kind k);
+std::string kindToString(::cvc5::internal::Kind k);
struct KindHashFunction
{
- inline size_t operator()(::cvc5::Kind k) const { return k; }
+ inline size_t operator()(::cvc5::internal::Kind k) const { return k; }
}; /* struct KindHashFunction */
} // namespace kind
namespace theory {
-::cvc5::theory::TheoryId kindToTheoryId(::cvc5::Kind k);
-::cvc5::theory::TheoryId typeConstantToTheoryId(
- ::cvc5::TypeConstant typeConstant);
+::cvc5::internal::theory::TheoryId kindToTheoryId(::cvc5::internal::Kind k);
+::cvc5::internal::theory::TheoryId typeConstantToTheoryId(
+ ::cvc5::internal::TypeConstant typeConstant);
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__KIND_H */
#include "expr/match_trie.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
bool MatchTrie::getMatches(Node n, NotifyMatch* ntm)
}
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
/** A virtual class for notifications regarding matches. */
};
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__CANDIDATE_REWRITE_FILTER_H */
${metakind_includes}
// clang-format off
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
// clang-format off
template <Kind k, class T, bool pool>
struct NodeValueConstCompare
{
- static bool compare(const ::cvc5::expr::NodeValue* x,
- const ::cvc5::expr::NodeValue* y)
+ static bool compare(const ::cvc5::internal::expr::NodeValue* x,
+ const ::cvc5::internal::expr::NodeValue* y)
{
if (pool)
{
return x->getConst<T>() == y->getConst<T>();
}
- static size_t constHash(const ::cvc5::expr::NodeValue* nv)
+ static size_t constHash(const ::cvc5::internal::expr::NodeValue* nv)
{
return nv->getConst<T>().hash();
}
};
-size_t NodeValueCompare::constHash(const ::cvc5::expr::NodeValue* nv)
+size_t NodeValueCompare::constHash(const ::cvc5::internal::expr::NodeValue* nv)
{
Assert(nv->getMetaKind() == kind::metakind::CONSTANT);
// clang-format off
${metakind_constHashes}
// clang-format on
-default: Unhandled() << ::cvc5::expr::NodeValue::dKindToKind(nv->d_kind);
+default: Unhandled() << ::cvc5::internal::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::internal::expr::NodeValue* nv1,
+ const ::cvc5::internal::expr::NodeValue* nv2)
{
if(nv1->d_kind != nv2->d_kind) {
return false;
// clang-format off
${metakind_compares}
// clang-format on
-default: Unhandled() << ::cvc5::expr::NodeValue::dKindToKind(nv1->d_kind);
+default: Unhandled() << ::cvc5::internal::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::internal::expr::NodeValue::const_nv_iterator i = nv1->nv_begin();
+ ::cvc5::internal::expr::NodeValue::const_nv_iterator j = nv2->nv_begin();
+ ::cvc5::internal::expr::NodeValue::const_nv_iterator i_end = nv1->nv_end();
while(i != i_end) {
if((*i) != (*j)) {
}
template bool NodeValueCompare::compare<true>(
- const ::cvc5::expr::NodeValue* nv1, const ::cvc5::expr::NodeValue* nv2);
+ const ::cvc5::internal::expr::NodeValue* nv1, const ::cvc5::internal::expr::NodeValue* nv2);
template bool NodeValueCompare::compare<false>(
- const ::cvc5::expr::NodeValue* nv1, const ::cvc5::expr::NodeValue* nv2);
+ const ::cvc5::internal::expr::NodeValue* nv1, const ::cvc5::internal::expr::NodeValue* nv2);
void nodeValueConstantToStream(std::ostream& out,
- const ::cvc5::expr::NodeValue* nv)
+ const ::cvc5::internal::expr::NodeValue* nv)
{
Assert(nv->getMetaKind() == kind::metakind::CONSTANT);
// clang-format off
${metakind_constPrinters}
// clang-format on
-default: Unhandled() << ::cvc5::expr::NodeValue::dKindToKind(nv->d_kind);
+default: Unhandled() << ::cvc5::internal::expr::NodeValue::dKindToKind(nv->d_kind);
}
}
* This doesn't support "non-inlined" NodeValues, which shouldn't need this
* kind of cleanup.
*/
-void deleteNodeValueConstant(::cvc5::expr::NodeValue* nv)
+void deleteNodeValueConstant(::cvc5::internal::expr::NodeValue* nv)
{
Assert(nv->getMetaKind() == kind::metakind::CONSTANT);
// clang-format off
${metakind_constDeleters}
// clang-format on
-default: Unhandled() << ::cvc5::expr::NodeValue::dKindToKind(nv->d_kind);
+default: Unhandled() << ::cvc5::internal::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::internal::Kind k)
{
static const unsigned lbs[] = {
0, /* NULL_EXPR */
return lbs[k];
}
-uint32_t getMaxArityForKind(::cvc5::Kind k)
+uint32_t getMaxArityForKind(::cvc5::internal::Kind k)
{
static const unsigned ubs[] = {
0, /* NULL_EXPR */
* example, since the kind of functions is just VARIABLE, it should map
* VARIABLE to APPLY_UF.
*/
-Kind operatorToKind(::cvc5::expr::NodeValue* nv)
+Kind operatorToKind(::cvc5::internal::expr::NodeValue* nv)
{
if(nv->getKind() == kind::BUILTIN) {
return nv->getConst<Kind>();
}
} // namespace kind
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/check.h"
#include "expr/kind.h"
-namespace cvc5 {
+namespace cvc5::internal {
// clang-format off
${metakind_fwd_decls}
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::internal::expr::NodeValue* nv1,
+ const ::cvc5::internal::expr::NodeValue* nv2);
+ static size_t constHash(const ::cvc5::internal::expr::NodeValue* nv);
};/* struct NodeValueCompare */
/**
* @param nv the node value representing a constant node
*/
void nodeValueConstantToStream(std::ostream& out,
- const ::cvc5::expr::NodeValue* nv);
+ const ::cvc5::internal::expr::NodeValue* nv);
/**
* Cleanup to be performed when a NodeValue zombie is collected, and
* This doesn't support "non-inlined" NodeValues, which shouldn't need this
* kind of cleanup.
*/
-void deleteNodeValueConstant(::cvc5::expr::NodeValue* nv);
+void deleteNodeValueConstant(::cvc5::internal::expr::NodeValue* nv);
/** Return the minimum arity of the given kind. */
-uint32_t getMinArityForKind(::cvc5::Kind k);
+uint32_t getMinArityForKind(::cvc5::internal::Kind k);
/** Return the maximum arity of the given kind. */
-uint32_t getMaxArityForKind(::cvc5::Kind k);
+uint32_t getMaxArityForKind(::cvc5::internal::Kind k);
} // namespace metakind
-// import MetaKind into the "cvc5::kind" namespace but keep the
+// import MetaKind into the "cvc5::internal::kind" namespace but keep the
// individual MetaKind constants under kind::metakind::
-typedef ::cvc5::kind::metakind::MetaKind_t MetaKind;
+typedef ::cvc5::internal::kind::metakind::MetaKind_t MetaKind;
/**
* Get the metakind for a particular kind.
* 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::internal::expr::NodeValue* nv);
} // namespace kind
struct NodeValuePoolEq {
bool operator()(const NodeValue* nv1, const NodeValue* nv2) const
{
- return ::cvc5::kind::metakind::NodeValueCompare::compare<true>(nv1, nv2);
+ return ::cvc5::internal::kind::metakind::NodeValueCompare::compare<true>(nv1, nv2);
}
};
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__KIND__METAKIND_H */
echo "$kf:$lineno: error: \"theory\" directive missing class or header argument" >&2
exit 1
elif ! expr "$2" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::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::internal::theory::foo)" >&2
+ elif ! expr "$2" : '\(::cvc5::internal::theory::*\)' >/dev/null; then
+ echo "$kf:$lineno: warning: theory class not under ::cvc5::internal::theory namespace" >&2
fi
}
"
getConst_implementations="${getConst_implementations}
template <> $2 const & Expr::getConst() const {
- PrettyCheckArgument(getKind() == ::cvc5::kind::$1, *this, \"Improper kind for getConst<$2>()\");
+ PrettyCheckArgument(getKind() == ::cvc5::internal::kind::$1, *this, \"Improper kind for getConst<$2>()\");
return d_node->getConst< $2 >();
}
"
echo "$kf:$lineno: error: \"theory\" directive missing class or header argument" >&2
exit 1
elif ! expr "$2" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::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::internal::theory::foo)" >&2
+ elif ! expr "$2" : '\(::cvc5::internal::theory::*\)' >/dev/null; then
+ echo "$kf:$lineno: warning: theory class not under ::cvc5::internal::theory namespace" >&2
fi
theory_id="$1"
echo "$kf:$lineno: error: \"theory\" directive missing class or header argument" >&2
exit 1
elif ! expr "$2" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class \`$1' isn't fully-qualified (e.g., ::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::internal::theory::foo)" >&2
+ elif ! expr "$2" : '\(::cvc5::internal::theory::*\)' >/dev/null; then
+ echo "$kf:$lineno: warning: theory class not under ::cvc5::internal::theory namespace" >&2
fi
theory_class=$1
check_theory_seen
if ! expr "$4" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: constant $1 hasher \`$4' isn't fully-qualified (e.g., ::cvc5::RationalHashFunction)" >&2
+ echo "$kf:$lineno: warning: constant $1 hasher \`$4' isn't fully-qualified (e.g., ::cvc5::internal::RationalHashFunction)" >&2
fi
if [[ "$3" =~ '+'$ ]]; then
template <>
${class} const& NodeValue::getConst< ${class} >() const {
- AssertArgument(getKind() == ::cvc5::kind::$1, *this,
+ AssertArgument(getKind() == ::cvc5::internal::kind::$1, *this,
\"Improper kind for getConst<${class}>()\");
// To support non-inlined CONSTANT-kinded NodeValues (those that are
// \"constructed\" when initially checking them against the NodeManager
template<>
Node NodeManager::mkConst<${class}>(const ${class}& val)
{
- return mkConstInternal<Node, ${class}>(::cvc5::kind::$1, val);
+ return mkConstInternal<Node, ${class}>(::cvc5::internal::kind::$1, val);
}
template<>
TypeNode NodeManager::mkTypeConst<${class}>(const ${class}& val)
{
- return mkConstInternal<TypeNode, ${class}>(::cvc5::kind::$1, val);
+ return mkConstInternal<TypeNode, ${class}>(::cvc5::internal::kind::$1, val);
}
"
metakind_mkConst="${metakind_mkConst}
#include <sstream>
#include "expr/nary_term_util.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
class NaryMatchFrame
}
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/match_trie.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
/**
};
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__CANDIDATE_REWRITE_FILTER_H */
#include "util/regexp.h"
#include "util/string.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
struct IsListTag
}
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
/** Mark variable as list */
const std::vector<Node>& subs);
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC4__EXPR__NARY_TERM_UTIL__H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
TypeCheckingExceptionPrivate::TypeCheckingExceptionPrivate(TNode node,
std::string message)
template bool NodeTemplate<true>::isConst() const;
template bool NodeTemplate<false>::isConst() const;
-} // namespace cvc5
+} // namespace cvc5::internal
namespace std {
-size_t hash<cvc5::Node>::operator()(const cvc5::Node& node) const
+size_t hash<cvc5::internal::Node>::operator()(const cvc5::internal::Node& node) const
{
return node.getId();
}
-size_t hash<cvc5::TNode>::operator()(const cvc5::TNode& node) const
+size_t hash<cvc5::internal::TNode>::operator()(const cvc5::internal::TNode& node) const
{
return node.getId();
}
#include "util/hash.h"
#include "util/utility.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
class NodeManager;
*/
typedef NodeTemplate<false> TNode;
-} // namespace cvc5
+} // namespace cvc5::internal
namespace std {
template <>
-struct hash<cvc5::Node>
+struct hash<cvc5::internal::Node>
{
- size_t operator()(const cvc5::Node& node) const;
+ size_t operator()(const cvc5::internal::Node& node) const;
};
template <>
-struct hash<cvc5::TNode>
+struct hash<cvc5::internal::TNode>
{
- size_t operator()(const cvc5::TNode& node) const;
+ size_t operator()(const cvc5::internal::TNode& node) const;
};
} // namespace std
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
class NodeValue;
friend class NodeBuilder;
- friend class ::cvc5::expr::attr::AttributeManager;
- friend struct ::cvc5::expr::attr::SmtAttributes;
+ friend class ::cvc5::internal::expr::attr::AttributeManager;
+ friend struct ::cvc5::internal::expr::attr::SmtAttributes;
/**
* Assigns the expression value and does reference counting. No assumptions
return out;
}
-} // namespace cvc5
+} // namespace cvc5::internal
//#include "expr/attribute.h"
#include "expr/node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
using TNodePairHashFunction =
PairHashFunction<TNode, TNode, std::hash<TNode>, std::hash<TNode>>;
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__NODE_H */
#include "expr/attribute.h"
#include "expr/dtype.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
bool hasSubterm(TNode n, TNode t, bool strict)
}
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
/**
bool isBooleanConnective(TNode cur);
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <memory>
-namespace cvc5 {
+namespace cvc5::internal {
NodeBuilder::NodeBuilder()
: d_nv(&d_inlineNv),
return out << *nb.d_nv;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_value.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class NodeManager;
// isn't yet a Node..
std::ostream& operator<<(std::ostream& out, const NodeBuilder& nb);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__NODE_BUILDER_H */
#include "expr/attribute.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
NodeConverter::NodeConverter(bool forceIdem) : d_forceIdem(forceIdem) {}
}
bool NodeConverter::shouldTraverse(Node n) { return true; }
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A node converter for terms and types. Implements term/type traversals,
bool d_forceIdem;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/attribute.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
// Definition of an attribute for the variable name.
typedef expr::Attribute<expr::attr::TypeCheckedTag, bool> TypeCheckedAttr;
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
// clang-format off
using namespace std;
-using namespace cvc5::expr;
+using namespace cvc5::internal::expr;
-namespace cvc5 {
+namespace cvc5::internal {
namespace {
{
// 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::internal::Rational, since it has a gmp internal
// representation that mallocs memory and should be cleaned
// up. (This won't delete a pointer value if used as a
// constant, but then, you should probably use a smart-pointer
<< "malformed selector in datatype post-resolution";
// This next one's a "hard" check, performed in non-debug builds
// as well; the other ones should all be guaranteed by the
- // cvc5::DType class, but this actually needs to be checked.
+ // cvc5::internal::DType class, but this actually needs to be checked.
if (!selectorType.getRangeType().isFirstClass())
{
throw Exception(
return mkNode(Kind::REAL_ALGEBRAIC_NUMBER, inner);
}
-} // namespace cvc5
+} // namespace cvc5::internal
namespace cvc5 {
-using Record = std::vector<std::pair<std::string, TypeNode>>;
-
-namespace api {
class Solver;
-}
+
+namespace internal {
+
+using Record = std::vector<std::pair<std::string, TypeNode>>;
class ResourceManager;
class SkolemManager;
class NodeManager
{
- friend class api::Solver;
+ friend class cvc5::Solver;
friend class expr::NodeValue;
friend class expr::TypeChecker;
friend class SkolemManager;
/**
* 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::internal::Kind>() will yield k.
*/
TNode operatorOf(Kind k);
* ADD, are APPLYs of a ADD operator to arguments. This array
* holds the set of operators for these things. A ADD operator is
* a Node with kind "BUILTIN", and if you call
- * plusOperator->getConst<cvc5::Kind>(), you get kind::ADD back.
+ * plusOperator->getConst<cvc5::internal::Kind>(), you get kind::ADD back.
*/
Node d_operators[kind::LAST_KIND];
${metakind_mkConstDelete}
// clang-format off
-} // namespace cvc5
+} // namespace cvc5::internal
+}
#endif /* CVC5__NODE_MANAGER_H */
#include "base/check.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
class NodeSelfIterator {
}
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__NODE_SELF_ITERATOR_H */
#include <functional>
-namespace cvc5 {
+namespace cvc5::internal {
NodeDfsIterator::NodeDfsIterator(TNode n,
VisitOrder order,
return NodeDfsIterator(d_order);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Enum that represents an order in which nodes are visited.
std::function<bool(TNode)> d_skipIf;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5__EXPR__NODE_TRAVERSAL_H
#include "expr/node_trie.h"
-namespace cvc5 {
+namespace cvc5::internal {
template <bool ref_count>
NodeTemplate<ref_count> NodeTemplateTrie<ref_count>::existsTerm(
template void NodeTemplateTrie<true>::debugPrint(const char* c,
unsigned depth) const;
-} // namespace cvc5
+} // namespace cvc5::internal
#include <map>
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/** NodeTemplate trie class
*
/** Non-reference-counted version of the above data structure */
typedef NodeTemplateTrie<false> TNodeTrie;
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__NODE_TRIE_H */
#include "expr/node_trie_algorithm.h"
-namespace cvc5 {
+namespace cvc5::internal {
void nodeTriePathPairProcess(const TNodeTrie* t,
size_t arity,
} while (!visit.empty());
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_trie.h"
-namespace cvc5 {
+namespace cvc5::internal {
/** A virtual base class for the algorithm below. */
class NodeTriePathPairProcessCallback
size_t n,
NodeTriePathPairProcessCallback& ntpc);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__NODE_TRIE_ALGORITHM_H */
* A node value.
*
* The actual node implementation.
- * Instances of this class are generally referenced through cvc5::Node rather
- * than by pointer. Note that cvc5::Node maintains the reference count on
+ * Instances of this class are generally referenced through cvc5::internal::Node rather
+ * than by pointer. Note that cvc5::internal::Node maintains the reference count on
* NodeValue instances.
*/
#include "expr/node_value.h"
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
string NodeValue::toString() const {
}
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
* A node value.
*
* The actual node implementation.
- * Instances of this class are generally referenced through cvc5::Node rather
- * than by pointer. Note that cvc5::Node maintains the reference count on
+ * Instances of this class are generally referenced through cvc5::internal::Node rather
+ * than by pointer. Note that cvc5::internal::Node maintains the reference count on
* NodeValue instances.
*/
#include "expr/metakind.h"
#include "options/language.h"
-namespace cvc5 {
+namespace cvc5::internal {
template <bool ref_count> class NodeTemplate;
class TypeNode;
namespace kind {
namespace metakind {
- template < ::cvc5::Kind k, class T, bool pool>
+ template < ::cvc5::internal::Kind k, class T, bool pool>
struct NodeValueConstCompare;
struct NodeValueCompare;
class NodeValue
{
template <bool>
- friend class ::cvc5::NodeTemplate;
- friend class ::cvc5::TypeNode;
- friend class ::cvc5::NodeBuilder;
- friend class ::cvc5::NodeManager;
+ friend class ::cvc5::internal::NodeTemplate;
+ friend class ::cvc5::internal::TypeNode;
+ friend class ::cvc5::internal::NodeBuilder;
+ friend class ::cvc5::internal::NodeManager;
template <Kind k, class T, bool pool>
friend struct kind::metakind::NodeValueConstCompare;
}
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__NODE_VALUE_H */
#include "cvc5_private.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Traverses the nodes reverse-topologically (children before parents),
template <typename Visitor>
thread_local bool NodeVisitor<Visitor>::s_inRun = false;
-} // namespace cvc5
+} // namespace cvc5::internal
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
Sequence::Sequence(const TypeNode& t, const std::vector<Node>& s)
: d_type(new TypeNode(t)), d_seq(s)
return static_cast<size_t>(ret);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <memory>
#include <vector>
-namespace cvc5 {
+namespace cvc5::internal {
template <bool ref_count>
class NodeTemplate;
public:
/** constructors for Sequence
*
- * Internally, a cvc5::Sequence is represented by a vector of Nodes (d_seq),
+ * Internally, a cvc5::internal::Sequence is represented by a vector of Nodes (d_seq),
* where each Node in this vector must be a constant.
*/
Sequence() = default;
std::ostream& operator<<(std::ostream& os, const Sequence& s);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__SEQUENCE_H */
#include "expr/node_algorithm.h"
#include "expr/node_manager_attributes.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
// Attributes are global maps from Nodes to data. Thus, note that these could
// be implemented as internal maps in SkolemManager.
return n;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofGenerator;
int flags = SKOLEM_DEFAULT);
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__PROOF_SKOLEM_CACHE_H */
#include "expr/skolem_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
bool Subs::empty() const { return d_vars.empty(); }
return out;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Helper substitution class. Stores a substitution in parallel vectors
*/
std::ostream& operator<<(std::ostream& out, const Subs& s);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__SUBS_H */
#include "expr/subtype_elim_node_converter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
SubtypeElimNodeConverter::SubtypeElimNodeConverter() {}
return n;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_converter.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* This converts a node into one that does not involve (arithmetic) subtyping.
static bool isRealTypeStrict(TypeNode tn);
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <sstream>
#include "expr/skolem_manager.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
SygusDatatype::SygusDatatype(const std::string& name) : d_dt(DType(name)) {}
bool SygusDatatype::isInitialized() const { return d_dt.isSygus(); }
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/** Attribute true for variables that represent any constant */
struct SygusAnyConstAttributeId
DType d_dt;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "context/cdlist.h"
#include "context/cdo.h"
-using namespace cvc5::context;
+using namespace cvc5::internal::context;
namespace cvc5 {
class SymbolManager::Implementation
{
- using TermStringMap = CDHashMap<api::Term, std::string, std::hash<api::Term>>;
- using TermSet = CDHashSet<api::Term, std::hash<api::Term>>;
- using SortList = CDList<api::Sort>;
- using TermList = CDList<api::Term>;
+ using TermStringMap =
+ CDHashMap<cvc5::Term, std::string, std::hash<cvc5::Term>>;
+ using TermSet = CDHashSet<cvc5::Term, std::hash<cvc5::Term>>;
+ using SortList = CDList<cvc5::Sort>;
+ using TermList = CDList<cvc5::Term>;
public:
Implementation()
~Implementation() { d_context.pop(); }
/** set expression name */
- NamingResult setExpressionName(api::Term t,
+ NamingResult setExpressionName(cvc5::Term t,
const std::string& name,
bool isAssertion = false);
/** get expression name */
- bool getExpressionName(api::Term t,
+ bool getExpressionName(cvc5::Term t,
std::string& name,
bool isAssertion = false) const;
/** get expression names */
- void getExpressionNames(const std::vector<api::Term>& ts,
+ void getExpressionNames(const std::vector<cvc5::Term>& ts,
std::vector<std::string>& names,
bool areAssertions = false) const;
/** get expression names */
- std::map<api::Term, std::string> getExpressionNames(bool areAssertions) const;
+ std::map<cvc5::Term, std::string> getExpressionNames(
+ bool areAssertions) const;
/** get model declare sorts */
- std::vector<api::Sort> getModelDeclareSorts() const;
+ std::vector<cvc5::Sort> getModelDeclareSorts() const;
/** get model declare terms */
- std::vector<api::Term> getModelDeclareTerms() const;
+ std::vector<cvc5::Term> getModelDeclareTerms() const;
/** get functions to synthesize */
- std::vector<api::Term> getFunctionsToSynthesize() const;
+ std::vector<cvc5::Term> getFunctionsToSynthesize() const;
/** Add declared sort to the list of model declarations. */
- void addModelDeclarationSort(api::Sort s);
+ void addModelDeclarationSort(cvc5::Sort s);
/** Add declared term to the list of model declarations. */
- void addModelDeclarationTerm(api::Term t);
+ void addModelDeclarationTerm(cvc5::Term t);
/** Add function to the list of functions to synthesize. */
- void addFunctionToSynthesize(api::Term t);
+ void addFunctionToSynthesize(cvc5::Term t);
/** reset */
void reset();
/** reset assertions */
};
NamingResult SymbolManager::Implementation::setExpressionName(
- api::Term t, const std::string& name, bool isAssertion)
+ cvc5::Term t, const std::string& name, bool isAssertion)
{
Trace("sym-manager") << "SymbolManager: set expression name: " << t << " -> "
<< name << ", isAssertion=" << isAssertion << std::endl;
return NamingResult::SUCCESS;
}
-bool SymbolManager::Implementation::getExpressionName(api::Term t,
+bool SymbolManager::Implementation::getExpressionName(cvc5::Term t,
std::string& name,
bool isAssertion) const
{
}
void SymbolManager::Implementation::getExpressionNames(
- const std::vector<api::Term>& ts,
+ const std::vector<cvc5::Term>& ts,
std::vector<std::string>& names,
bool areAssertions) const
{
- for (const api::Term& t : ts)
+ for (const cvc5::Term& t : ts)
{
std::string name;
if (getExpressionName(t, name, areAssertions))
}
}
-std::map<api::Term, std::string>
+std::map<cvc5::Term, std::string>
SymbolManager::Implementation::getExpressionNames(bool areAssertions) const
{
- std::map<api::Term, std::string> emap;
+ std::map<cvc5::Term, std::string> emap;
for (TermStringMap::const_iterator it = d_names.begin(),
itend = d_names.end();
it != itend;
++it)
{
- api::Term t = (*it).first;
+ cvc5::Term t = (*it).first;
if (areAssertions && d_namedAsserts.find(t) == d_namedAsserts.end())
{
continue;
return emap;
}
-std::vector<api::Sort> SymbolManager::Implementation::getModelDeclareSorts()
+std::vector<cvc5::Sort> SymbolManager::Implementation::getModelDeclareSorts()
const
{
- std::vector<api::Sort> declareSorts(d_declareSorts.begin(),
- d_declareSorts.end());
+ std::vector<cvc5::Sort> declareSorts(d_declareSorts.begin(),
+ d_declareSorts.end());
return declareSorts;
}
-std::vector<api::Term> SymbolManager::Implementation::getModelDeclareTerms()
+std::vector<cvc5::Term> SymbolManager::Implementation::getModelDeclareTerms()
const
{
- std::vector<api::Term> declareTerms(d_declareTerms.begin(),
- d_declareTerms.end());
+ std::vector<cvc5::Term> declareTerms(d_declareTerms.begin(),
+ d_declareTerms.end());
return declareTerms;
}
-std::vector<api::Term> SymbolManager::Implementation::getFunctionsToSynthesize()
- const
+std::vector<cvc5::Term>
+SymbolManager::Implementation::getFunctionsToSynthesize() const
{
- return std::vector<api::Term>(d_funToSynth.begin(), d_funToSynth.end());
+ return std::vector<cvc5::Term>(d_funToSynth.begin(), d_funToSynth.end());
}
-void SymbolManager::Implementation::addModelDeclarationSort(api::Sort s)
+void SymbolManager::Implementation::addModelDeclarationSort(cvc5::Sort s)
{
Trace("sym-manager") << "SymbolManager: addModelDeclarationSort " << s
<< std::endl;
d_declareSorts.push_back(s);
}
-void SymbolManager::Implementation::addModelDeclarationTerm(api::Term t)
+void SymbolManager::Implementation::addModelDeclarationTerm(cvc5::Term t)
{
Trace("sym-manager") << "SymbolManager: addModelDeclarationTerm " << t
<< std::endl;
d_declareTerms.push_back(t);
}
-void SymbolManager::Implementation::addFunctionToSynthesize(api::Term f)
+void SymbolManager::Implementation::addFunctionToSynthesize(cvc5::Term f)
{
Trace("sym-manager") << "SymbolManager: addFunctionToSynthesize " << f
<< std::endl;
Trace("sym-manager") << "SymbolManager: popScope" << std::endl;
if (d_context.getLevel() == 0)
{
- throw ScopeException();
+ throw internal::ScopeException();
}
d_context.pop();
Trace("sym-manager-debug")
// ---------------------------------------------- SymbolManager
-SymbolManager::SymbolManager(api::Solver* s)
+SymbolManager::SymbolManager(cvc5::Solver* s)
: d_solver(s),
d_implementation(new SymbolManager::Implementation()),
d_globalDeclarations(false)
SymbolManager::~SymbolManager() {}
-SymbolTable* SymbolManager::getSymbolTable() { return &d_symtabAllocated; }
+internal::SymbolTable* SymbolManager::getSymbolTable()
+{
+ return &d_symtabAllocated;
+}
-NamingResult SymbolManager::setExpressionName(api::Term t,
+NamingResult SymbolManager::setExpressionName(cvc5::Term t,
const std::string& name,
bool isAssertion)
{
return d_implementation->setExpressionName(t, name, isAssertion);
}
-bool SymbolManager::getExpressionName(api::Term t,
+bool SymbolManager::getExpressionName(cvc5::Term t,
std::string& name,
bool isAssertion) const
{
return d_implementation->getExpressionName(t, name, isAssertion);
}
-void SymbolManager::getExpressionNames(const std::vector<api::Term>& ts,
+void SymbolManager::getExpressionNames(const std::vector<cvc5::Term>& ts,
std::vector<std::string>& names,
bool areAssertions) const
{
return d_implementation->getExpressionNames(ts, names, areAssertions);
}
-std::map<api::Term, std::string> SymbolManager::getExpressionNames(
+std::map<cvc5::Term, std::string> SymbolManager::getExpressionNames(
bool areAssertions) const
{
return d_implementation->getExpressionNames(areAssertions);
}
-std::vector<api::Sort> SymbolManager::getModelDeclareSorts() const
+std::vector<cvc5::Sort> SymbolManager::getModelDeclareSorts() const
{
return d_implementation->getModelDeclareSorts();
}
-std::vector<api::Term> SymbolManager::getModelDeclareTerms() const
+std::vector<cvc5::Term> SymbolManager::getModelDeclareTerms() const
{
return d_implementation->getModelDeclareTerms();
}
-std::vector<api::Term> SymbolManager::getFunctionsToSynthesize() const
+std::vector<cvc5::Term> SymbolManager::getFunctionsToSynthesize() const
{
return d_implementation->getFunctionsToSynthesize();
}
-void SymbolManager::addModelDeclarationSort(api::Sort s)
+void SymbolManager::addModelDeclarationSort(cvc5::Sort s)
{
d_implementation->addModelDeclarationSort(s);
}
-void SymbolManager::addModelDeclarationTerm(api::Term t)
+void SymbolManager::addModelDeclarationTerm(cvc5::Term t)
{
d_implementation->addModelDeclarationTerm(t);
}
-void SymbolManager::addFunctionToSynthesize(api::Term f)
+void SymbolManager::addFunctionToSynthesize(cvc5::Term f)
{
d_implementation->addFunctionToSynthesize(f);
}
class CVC5_EXPORT SymbolManager
{
public:
- SymbolManager(api::Solver* s);
+ SymbolManager(cvc5::Solver* s);
~SymbolManager();
/** Get the underlying symbol table */
- SymbolTable* getSymbolTable();
+ internal::SymbolTable* getSymbolTable();
//---------------------------- named expressions
/** Set name of term t to name
*
* @return true if the name was set. This method may return false if t
* already has a name.
*/
- NamingResult setExpressionName(api::Term t,
+ NamingResult setExpressionName(cvc5::Term t,
const std::string& name,
bool isAssertion = false);
/** Get name for term t
* @return true if t has a name. If so, name is updated to that name.
* Otherwise, name is unchanged.
*/
- bool getExpressionName(api::Term t,
+ bool getExpressionName(cvc5::Term t,
std::string& name,
bool isAssertion = false) const;
/**
* @param names The name list
* @param areAssertions Whether we only wish to include assertion names
*/
- void getExpressionNames(const std::vector<api::Term>& ts,
+ void getExpressionNames(const std::vector<cvc5::Term>& ts,
std::vector<std::string>& names,
bool areAssertions = false) const;
/**
* @param areAssertions Whether we only wish to include assertion names
* @return the mapping containing all expression names.
*/
- std::map<api::Term, std::string> getExpressionNames(
+ std::map<cvc5::Term, std::string> getExpressionNames(
bool areAssertions = false) const;
/**
* @return The sorts we have declared that should be printed in the model.
*/
- std::vector<api::Sort> getModelDeclareSorts() const;
+ std::vector<cvc5::Sort> getModelDeclareSorts() const;
/**
* @return The terms we have declared that should be printed in the model.
*/
- std::vector<api::Term> getModelDeclareTerms() const;
+ std::vector<cvc5::Term> getModelDeclareTerms() const;
/**
* @return The functions we have declared that should be printed in a response
* to check-synth.
*/
- std::vector<api::Term> getFunctionsToSynthesize() const;
+ std::vector<cvc5::Term> getFunctionsToSynthesize() const;
/**
* Add declared sort to the list of model declarations.
*/
- void addModelDeclarationSort(api::Sort s);
+ void addModelDeclarationSort(cvc5::Sort s);
/**
* Add declared term to the list of model declarations.
*/
- void addModelDeclarationTerm(api::Term t);
+ void addModelDeclarationTerm(cvc5::Term t);
/**
* Add a function to synthesize. This ensures the solution for f is printed
* in a successful response to check-synth.
*/
- void addFunctionToSynthesize(api::Term f);
+ void addFunctionToSynthesize(cvc5::Term f);
//---------------------------- end named expressions
/**
private:
/** The API Solver object. */
- api::Solver* d_solver;
+ cvc5::Solver* d_solver;
/**
* The declaration scope that is "owned" by this symbol manager.
*/
- SymbolTable d_symtabAllocated;
+ internal::SymbolTable d_symtabAllocated;
/** The implementation of the symbol manager */
class Implementation;
std::unique_ptr<Implementation> d_implementation;
#include "context/cdhashset.h"
#include "context/context.h"
-namespace cvc5 {
+namespace cvc5::internal {
-using ::cvc5::context::CDHashMap;
-using ::cvc5::context::CDHashSet;
-using ::cvc5::context::Context;
+using ::cvc5::internal::context::CDHashMap;
+using ::cvc5::internal::context::CDHashSet;
+using ::cvc5::internal::context::Context;
using ::std::copy;
using ::std::endl;
using ::std::ostream_iterator;
public:
OverloadedTypeTrie(Context* c, bool allowFunVariants = false)
: d_overloaded_symbols(
- new (true) CDHashSet<api::Term, std::hash<api::Term>>(c)),
+ new (true) CDHashSet<cvc5::Term, std::hash<cvc5::Term>>(c)),
d_allowFunctionVariants(allowFunVariants)
{
}
~OverloadedTypeTrie() { d_overloaded_symbols->deleteSelf(); }
/** is this function overloaded? */
- bool isOverloadedFunction(api::Term fun) const;
+ bool isOverloadedFunction(cvc5::Term fun) const;
/** Get overloaded constant for type.
* If possible, it returns a defined symbol with name
* that has type t. Otherwise returns null expression.
*/
- api::Term getOverloadedConstantForType(const std::string& name,
- api::Sort t) const;
+ cvc5::Term getOverloadedConstantForType(const std::string& name,
+ cvc5::Sort t) const;
/**
* If possible, returns a defined function for a name
* and a vector of expected argument types. Otherwise returns
* null expression.
*/
- api::Term getOverloadedFunctionForTypes(
- const std::string& name, const std::vector<api::Sort>& argTypes) const;
+ cvc5::Term getOverloadedFunctionForTypes(
+ const std::string& name, const std::vector<cvc5::Sort>& argTypes) const;
/** called when obj is bound to name, and prev_bound_obj was already bound to
* name Returns false if the binding is invalid.
*/
- bool bind(const string& name, api::Term prev_bound_obj, api::Term obj);
+ bool bind(const string& name, cvc5::Term prev_bound_obj, cvc5::Term obj);
private:
/** Marks expression obj with name as overloaded.
* These are put in the same place in the trie but do not have identical type,
* hence we return false.
*/
- bool markOverloaded(const string& name, api::Term obj);
+ bool markOverloaded(const string& name, cvc5::Term obj);
/** the null expression */
- api::Term d_nullTerm;
+ cvc5::Term d_nullTerm;
// The (context-independent) trie storing that maps expected argument
// vectors to symbols. All expressions stored in d_symbols are only
// interpreted as active if they also appear in the context-dependent
class TypeArgTrie {
public:
// children of this node
- std::map<api::Sort, TypeArgTrie> d_children;
+ std::map<cvc5::Sort, TypeArgTrie> d_children;
// symbols at this node
- std::map<api::Sort, api::Term> d_symbols;
+ std::map<cvc5::Sort, cvc5::Term> d_symbols;
};
/** for each string with operator overloading, this stores the data structure
* above. */
std::unordered_map<std::string, TypeArgTrie> d_overload_type_arg_trie;
/** The set of overloaded symbols. */
- CDHashSet<api::Term, std::hash<api::Term>>* d_overloaded_symbols;
+ CDHashSet<cvc5::Term, std::hash<cvc5::Term>>* d_overloaded_symbols;
/** allow function variants
* This is true if we allow overloading (non-constant) functions that expect
* the same argument types.
* if reqUnique=true.
* Otherwise, it returns the null expression.
*/
- api::Term getOverloadedFunctionAt(const TypeArgTrie* tat,
- bool reqUnique = true) const;
+ cvc5::Term getOverloadedFunctionAt(const TypeArgTrie* tat,
+ bool reqUnique = true) const;
};
-bool OverloadedTypeTrie::isOverloadedFunction(api::Term fun) const
+bool OverloadedTypeTrie::isOverloadedFunction(cvc5::Term fun) const
{
return d_overloaded_symbols->find(fun) != d_overloaded_symbols->end();
}
-api::Term OverloadedTypeTrie::getOverloadedConstantForType(
- const std::string& name, api::Sort t) const
+cvc5::Term OverloadedTypeTrie::getOverloadedConstantForType(
+ const std::string& name, cvc5::Sort t) const
{
std::unordered_map<std::string, TypeArgTrie>::const_iterator it =
d_overload_type_arg_trie.find(name);
if (it != d_overload_type_arg_trie.end()) {
- std::map<api::Sort, api::Term>::const_iterator its =
+ std::map<cvc5::Sort, cvc5::Term>::const_iterator its =
it->second.d_symbols.find(t);
if (its != it->second.d_symbols.end()) {
- api::Term expr = its->second;
+ cvc5::Term expr = its->second;
// must be an active symbol
if (isOverloadedFunction(expr)) {
return expr;
return d_nullTerm;
}
-api::Term OverloadedTypeTrie::getOverloadedFunctionForTypes(
- const std::string& name, const std::vector<api::Sort>& argTypes) const
+cvc5::Term OverloadedTypeTrie::getOverloadedFunctionForTypes(
+ const std::string& name, const std::vector<cvc5::Sort>& argTypes) const
{
std::unordered_map<std::string, TypeArgTrie>::const_iterator it =
d_overload_type_arg_trie.find(name);
if (it != d_overload_type_arg_trie.end()) {
const TypeArgTrie* tat = &it->second;
for (unsigned i = 0; i < argTypes.size(); i++) {
- std::map<api::Sort, TypeArgTrie>::const_iterator itc =
+ std::map<cvc5::Sort, TypeArgTrie>::const_iterator itc =
tat->d_children.find(argTypes[i]);
if (itc != tat->d_children.end()) {
tat = &itc->second;
}
bool OverloadedTypeTrie::bind(const string& name,
- api::Term prev_bound_obj,
- api::Term obj)
+ cvc5::Term prev_bound_obj,
+ cvc5::Term obj)
{
bool retprev = true;
if (!isOverloadedFunction(prev_bound_obj)) {
return retprev && retobj;
}
-bool OverloadedTypeTrie::markOverloaded(const string& name, api::Term obj)
+bool OverloadedTypeTrie::markOverloaded(const string& name, cvc5::Term obj)
{
Trace("parser-overloading") << "Overloaded function : " << name;
Trace("parser-overloading") << " with type " << obj.getSort() << std::endl;
// get the argument types
- api::Sort t = obj.getSort();
- api::Sort rangeType = t;
- std::vector<api::Sort> argTypes;
+ cvc5::Sort t = obj.getSort();
+ cvc5::Sort rangeType = t;
+ std::vector<cvc5::Sort> argTypes;
if (t.isFunction())
{
argTypes = t.getFunctionDomainSorts();
if (d_allowFunctionVariants || argTypes.empty())
{
// they are allowed, check for redefinition
- std::map<api::Sort, api::Term>::iterator it =
+ std::map<cvc5::Sort, cvc5::Term>::iterator it =
tat->d_symbols.find(rangeType);
if (it != tat->d_symbols.end())
{
- api::Term prev_obj = it->second;
+ cvc5::Term prev_obj = it->second;
// if there is already an active function with the same name and expects
// the same argument types and has the same return type, we reject the
// re-declaration here.
else
{
// they are not allowed, we cannot have any function defined here.
- api::Term existingFun = getOverloadedFunctionAt(tat, false);
+ cvc5::Term existingFun = getOverloadedFunctionAt(tat, false);
if (!existingFun.isNull())
{
return false;
return true;
}
-api::Term OverloadedTypeTrie::getOverloadedFunctionAt(
+cvc5::Term OverloadedTypeTrie::getOverloadedFunctionAt(
const OverloadedTypeTrie::TypeArgTrie* tat, bool reqUnique) const
{
- api::Term retExpr;
- for (std::map<api::Sort, api::Term>::const_iterator its =
+ cvc5::Term retExpr;
+ for (std::map<cvc5::Sort, cvc5::Term>::const_iterator its =
tat->d_symbols.begin();
its != tat->d_symbols.end();
++its)
{
- api::Term expr = its->second;
+ cvc5::Term expr = its->second;
if (isOverloadedFunction(expr))
{
if (retExpr.isNull())
~Implementation() {}
- bool bind(const string& name, api::Term obj, bool doOverload);
- void bindType(const string& name, api::Sort t);
+ bool bind(const string& name, cvc5::Term obj, bool doOverload);
+ void bindType(const string& name, cvc5::Sort t);
void bindType(const string& name,
- const vector<api::Sort>& params,
- api::Sort t);
+ const vector<cvc5::Sort>& params,
+ cvc5::Sort t);
bool isBound(const string& name) const;
bool isBoundType(const string& name) const;
- api::Term lookup(const string& name) const;
- api::Sort lookupType(const string& name) const;
- api::Sort lookupType(const string& name,
- const vector<api::Sort>& params) const;
+ cvc5::Term lookup(const string& name) const;
+ cvc5::Sort lookupType(const string& name) const;
+ cvc5::Sort lookupType(const string& name,
+ const vector<cvc5::Sort>& params) const;
size_t lookupArity(const string& name);
void popScope();
void pushScope();
void resetAssertions();
//------------------------ operator overloading
/** implementation of function from header */
- bool isOverloadedFunction(api::Term fun) const;
+ bool isOverloadedFunction(cvc5::Term fun) const;
/** implementation of function from header */
- api::Term getOverloadedConstantForType(const std::string& name,
- api::Sort t) const;
+ cvc5::Term getOverloadedConstantForType(const std::string& name,
+ cvc5::Sort t) const;
/** implementation of function from header */
- api::Term getOverloadedFunctionForTypes(
- const std::string& name, const std::vector<api::Sort>& argTypes) const;
+ cvc5::Term getOverloadedFunctionForTypes(
+ const std::string& name, const std::vector<cvc5::Sort>& argTypes) const;
//------------------------ end operator overloading
private:
/** The context manager for the scope maps. */
Context d_context;
/** A map for expressions. */
- CDHashMap<string, api::Term> d_exprMap;
+ CDHashMap<string, cvc5::Term> d_exprMap;
/** A map for types. */
- using TypeMap = CDHashMap<string, std::pair<vector<api::Sort>, api::Sort>>;
+ using TypeMap = CDHashMap<string, std::pair<vector<cvc5::Sort>, cvc5::Sort>>;
TypeMap d_typeMap;
//------------------------ operator overloading
// the null expression
- api::Term d_nullTerm;
+ cvc5::Term d_nullTerm;
// overloaded type trie, stores all information regarding overloading
OverloadedTypeTrie d_overload_trie;
/** bind with overloading
* allowed. If a symbol is previously bound to that name, it marks both as
* overloaded. Returns false if the binding was invalid.
*/
- bool bindWithOverloading(const string& name, api::Term obj);
+ bool bindWithOverloading(const string& name, cvc5::Term obj);
//------------------------ end operator overloading
}; /* SymbolTable::Implementation */
bool SymbolTable::Implementation::bind(const string& name,
- api::Term obj,
+ cvc5::Term obj,
bool doOverload)
{
- PrettyCheckArgument(!obj.isNull(), obj, "cannot bind to a null api::Term");
+ PrettyCheckArgument(!obj.isNull(), obj, "cannot bind to a null cvc5::Term");
Trace("sym-table") << "SymbolTable: bind " << name
<< ", doOverload=" << doOverload << std::endl;
if (doOverload) {
return d_exprMap.find(name) != d_exprMap.end();
}
-api::Term SymbolTable::Implementation::lookup(const string& name) const
+cvc5::Term SymbolTable::Implementation::lookup(const string& name) const
{
Assert(isBound(name));
- api::Term expr = (*d_exprMap.find(name)).second;
+ cvc5::Term expr = (*d_exprMap.find(name)).second;
if (isOverloadedFunction(expr)) {
return d_nullTerm;
} else {
}
}
-void SymbolTable::Implementation::bindType(const string& name, api::Sort t)
+void SymbolTable::Implementation::bindType(const string& name, cvc5::Sort t)
{
- d_typeMap.insert(name, make_pair(vector<api::Sort>(), t));
+ d_typeMap.insert(name, make_pair(vector<cvc5::Sort>(), t));
}
void SymbolTable::Implementation::bindType(const string& name,
- const vector<api::Sort>& params,
- api::Sort t)
+ const vector<cvc5::Sort>& params,
+ cvc5::Sort t)
{
if (TraceIsOn("sort")) {
Trace("sort") << "bindType(" << name << ", [";
if (params.size() > 0) {
copy(params.begin(),
params.end() - 1,
- ostream_iterator<api::Sort>(Trace("sort"), ", "));
+ ostream_iterator<cvc5::Sort>(Trace("sort"), ", "));
Trace("sort") << params.back();
}
Trace("sort") << "], " << t << ")" << endl;
return d_typeMap.find(name) != d_typeMap.end();
}
-api::Sort SymbolTable::Implementation::lookupType(const string& name) const
+cvc5::Sort SymbolTable::Implementation::lookupType(const string& name) const
{
- std::pair<std::vector<api::Sort>, api::Sort> p =
+ std::pair<std::vector<cvc5::Sort>, cvc5::Sort> p =
(*d_typeMap.find(name)).second;
PrettyCheckArgument(p.first.size() == 0, name,
"type constructor arity is wrong: "
return p.second;
}
-api::Sort SymbolTable::Implementation::lookupType(
- const string& name, const vector<api::Sort>& params) const
+cvc5::Sort SymbolTable::Implementation::lookupType(
+ const string& name, const vector<cvc5::Sort>& params) const
{
- std::pair<std::vector<api::Sort>, api::Sort> p =
+ std::pair<std::vector<cvc5::Sort>, cvc5::Sort> p =
(*d_typeMap.find(name)).second;
PrettyCheckArgument(p.first.size() == params.size(), params,
"type constructor arity is wrong: "
Trace("sort") << "have formals [";
copy(p.first.begin(),
p.first.end() - 1,
- ostream_iterator<api::Sort>(Trace("sort"), ", "));
+ ostream_iterator<cvc5::Sort>(Trace("sort"), ", "));
Trace("sort") << p.first.back() << "]" << std::endl << "parameters [";
copy(params.begin(),
params.end() - 1,
- ostream_iterator<api::Sort>(Trace("sort"), ", "));
+ ostream_iterator<cvc5::Sort>(Trace("sort"), ", "));
Trace("sort") << params.back() << "]" << endl
<< "type ctor " << name << std::endl
<< "type is " << p.second << std::endl;
}
- api::Sort instantiation = isSortConstructor
- ? p.second.instantiate(params)
- : p.second.substitute(p.first, params);
+ cvc5::Sort instantiation = isSortConstructor
+ ? p.second.instantiate(params)
+ : p.second.substitute(p.first, params);
Trace("sort") << "instance is " << instantiation << std::endl;
}
size_t SymbolTable::Implementation::lookupArity(const string& name) {
- std::pair<std::vector<api::Sort>, api::Sort> p =
+ std::pair<std::vector<cvc5::Sort>, cvc5::Sort> p =
(*d_typeMap.find(name)).second;
return p.first.size();
}
d_context.push();
}
-bool SymbolTable::Implementation::isOverloadedFunction(api::Term fun) const
+bool SymbolTable::Implementation::isOverloadedFunction(cvc5::Term fun) const
{
return d_overload_trie.isOverloadedFunction(fun);
}
-api::Term SymbolTable::Implementation::getOverloadedConstantForType(
- const std::string& name, api::Sort t) const
+cvc5::Term SymbolTable::Implementation::getOverloadedConstantForType(
+ const std::string& name, cvc5::Sort t) const
{
return d_overload_trie.getOverloadedConstantForType(name, t);
}
-api::Term SymbolTable::Implementation::getOverloadedFunctionForTypes(
- const std::string& name, const std::vector<api::Sort>& argTypes) const
+cvc5::Term SymbolTable::Implementation::getOverloadedFunctionForTypes(
+ const std::string& name, const std::vector<cvc5::Sort>& argTypes) const
{
return d_overload_trie.getOverloadedFunctionForTypes(name, argTypes);
}
bool SymbolTable::Implementation::bindWithOverloading(const string& name,
- api::Term obj)
+ cvc5::Term obj)
{
- CDHashMap<string, api::Term>::const_iterator it = d_exprMap.find(name);
+ CDHashMap<string, cvc5::Term>::const_iterator it = d_exprMap.find(name);
if (it != d_exprMap.end())
{
- const api::Term& prev_bound_obj = (*it).second;
+ const cvc5::Term& prev_bound_obj = (*it).second;
if (prev_bound_obj != obj) {
return d_overload_trie.bind(name, prev_bound_obj, obj);
}
return true;
}
-bool SymbolTable::isOverloadedFunction(api::Term fun) const
+bool SymbolTable::isOverloadedFunction(cvc5::Term fun) const
{
return d_implementation->isOverloadedFunction(fun);
}
-api::Term SymbolTable::getOverloadedConstantForType(const std::string& name,
- api::Sort t) const
+cvc5::Term SymbolTable::getOverloadedConstantForType(const std::string& name,
+ cvc5::Sort t) const
{
return d_implementation->getOverloadedConstantForType(name, t);
}
-api::Term SymbolTable::getOverloadedFunctionForTypes(
- const std::string& name, const std::vector<api::Sort>& argTypes) const
+cvc5::Term SymbolTable::getOverloadedFunctionForTypes(
+ const std::string& name, const std::vector<cvc5::Sort>& argTypes) const
{
return d_implementation->getOverloadedFunctionForTypes(name, argTypes);
}
}
SymbolTable::~SymbolTable() {}
-bool SymbolTable::bind(const string& name,
- api::Term obj,
- bool doOverload)
+bool SymbolTable::bind(const string& name, cvc5::Term obj, bool doOverload)
{
return d_implementation->bind(name, obj, doOverload);
}
-void SymbolTable::bindType(const string& name, api::Sort t)
+void SymbolTable::bindType(const string& name, cvc5::Sort t)
{
d_implementation->bindType(name, t);
}
void SymbolTable::bindType(const string& name,
- const vector<api::Sort>& params,
- api::Sort t)
+ const vector<cvc5::Sort>& params,
+ cvc5::Sort t)
{
d_implementation->bindType(name, params, t);
}
{
return d_implementation->isBoundType(name);
}
-api::Term SymbolTable::lookup(const string& name) const
+cvc5::Term SymbolTable::lookup(const string& name) const
{
return d_implementation->lookup(name);
}
-api::Sort SymbolTable::lookupType(const string& name) const
+cvc5::Sort SymbolTable::lookupType(const string& name) const
{
return d_implementation->lookupType(name);
}
-api::Sort SymbolTable::lookupType(const string& name,
- const vector<api::Sort>& params) const
+cvc5::Sort SymbolTable::lookupType(const string& name,
+ const vector<cvc5::Sort>& params) const
{
return d_implementation->lookupType(name, params);
}
void SymbolTable::reset() { d_implementation->reset(); }
void SymbolTable::resetAssertions() { d_implementation->resetAssertions(); }
-} // namespace cvc5
+} // namespace cvc5::internal
#include "cvc5_export.h"
namespace cvc5 {
-
-namespace api {
class Solver;
class Sort;
class Term;
-} // namespace api
+} // namespace cvc5
+
+namespace cvc5::internal {
class CVC5_EXPORT ScopeException : public Exception
{
*
* Returns false if the binding was invalid.
*/
- bool bind(const std::string& name,
- api::Term obj,
- bool doOverload = false);
+ bool bind(const std::string& name, cvc5::Term obj, bool doOverload = false);
/**
* Bind a type to a name in the current scope. If <code>name</code>
* @param name an identifier
* @param t the type to bind to <code>name</code>
*/
- void bindType(const std::string& name, api::Sort t);
+ void bindType(const std::string& name, cvc5::Sort t);
/**
* Bind a type to a name in the current scope. If <code>name</code>
* @param t the type to bind to <code>name</code>
*/
void bindType(const std::string& name,
- const std::vector<api::Sort>& params,
- api::Sort t);
+ const std::vector<cvc5::Sort>& params,
+ cvc5::Sort t);
/**
* Check whether a name is bound to an expression with bind().
* It returns the null expression if there is not a unique expression bound to
* <code>name</code> in the current scope (i.e. if there is not exactly one).
*/
- api::Term lookup(const std::string& name) const;
+ cvc5::Term lookup(const std::string& name) const;
/**
* Lookup a bound type.
* @param name the type identifier to lookup
* @returns the type bound to <code>name</code> in the current scope.
*/
- api::Sort lookupType(const std::string& name) const;
+ cvc5::Sort lookupType(const std::string& name) const;
/**
* Lookup a bound parameterized type.
* @returns the type bound to <code>name(<i>params</i>)</code> in
* the current scope.
*/
- api::Sort lookupType(const std::string& name,
- const std::vector<api::Sort>& params) const;
+ cvc5::Sort lookupType(const std::string& name,
+ const std::vector<cvc5::Sort>& params) const;
/**
* Lookup the arity of a bound parameterized type.
//------------------------ operator overloading
/** is this function overloaded? */
- bool isOverloadedFunction(api::Term fun) const;
+ bool isOverloadedFunction(cvc5::Term fun) const;
/** Get overloaded constant for type.
* If possible, it returns the defined symbol with name
* that has type t. Otherwise returns null expression.
*/
- api::Term getOverloadedConstantForType(const std::string& name,
- api::Sort t) const;
+ cvc5::Term getOverloadedConstantForType(const std::string& name,
+ cvc5::Sort t) const;
/**
* If possible, returns the unique defined function for a name
* no functions with name and expected argTypes, or alternatively there is
* more than one function with name and expected argTypes.
*/
- api::Term getOverloadedFunctionForTypes(
- const std::string& name, const std::vector<api::Sort>& argTypes) const;
+ cvc5::Term getOverloadedFunctionForTypes(
+ const std::string& name, const std::vector<cvc5::Sort>& argTypes) const;
//------------------------ end operator overloading
private:
std::unique_ptr<Implementation> d_implementation;
}; /* class SymbolTable */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SYMBOL_TABLE_H */
// TODO #1216: move the code in this include
#include "theory/quantifiers/term_util.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
TermCanonize::TermCanonize(TypeClassCallback* tcc)
}
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#include <map>
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
/**
};
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__TERM_CANONIZE_H */
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
uint32_t TermContext::computeValueOp(TNode t, uint32_t tval) const
{
return theory::Theory::isLeafOf(t, d_theoryId) ? 1 : tval;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/theory_id.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* This is an abstract class for computing "term context identifiers". A term
theory::TheoryId d_theoryId;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__TERM_CONVERSION_PROOF_GENERATOR_H */
#include "expr/term_context.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
TCtxNode::TCtxNode(Node n, const TermContext* tctx)
: d_node(n), d_val(tctx->initialValue()), d_tctx(tctx)
return h[0];
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TCtxStack;
class TermContext;
const TermContext* d_tctx;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__TERM_CONVERSION_PROOF_GENERATOR_H */
#include "expr/term_context.h"
-namespace cvc5 {
+namespace cvc5::internal {
TCtxStack::TCtxStack(const TermContext* tctx) : d_tctx(tctx) {}
return TCtxNode(curr.first, curr.second, d_tctx);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/term_context_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A stack for term-context-sensitive terms. Its main advantage is that
const TermContext* d_tctx;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__TERM_CONTEXT_STACK_H */
#ifndef CVC5__EXPR__TYPE_CHECKER_H
#define CVC5__EXPR__TYPE_CHECKER_H
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
class TypeChecker {
};/* class TypeChecker */
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__TYPE_CHECKER_H */
${typechecker_includes}
// clang-format on
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
TypeNode TypeChecker::computeType(NodeManager* nodeManager, TNode n, bool check)
}/* TypeChecker::computeIsConst */
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_manager.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
/** Type check returns the builtin operator sort */
};
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/dtype.h"
-namespace cvc5 {
+namespace cvc5::internal {
TypeMatcher::TypeMatcher(TypeNode dt)
{
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* This class is used for inferring the parameters of an instantiated
void addTypes(const std::vector<TypeNode>& types);
}; /* class TypeMatcher */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__MATCHER_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
TypeNode TypeNode::s_null( &expr::NodeValue::null() );
return (*this)[getNumChildren() - 1];
}
-} // namespace cvc5
+} // namespace cvc5::internal
namespace std {
-size_t hash<cvc5::TypeNode>::operator()(const cvc5::TypeNode& tn) const
+size_t hash<cvc5::internal::TypeNode>::operator()(const cvc5::internal::TypeNode& tn) const
{
return tn.getId();
}
#include "expr/node_value.h"
#include "util/cardinality_class.h"
-namespace cvc5 {
+namespace cvc5::internal {
class NodeManager;
class Cardinality;
return out;
}
-} // namespace cvc5
+} // namespace cvc5::internal
namespace std {
template <>
-struct hash<cvc5::TypeNode>
+struct hash<cvc5::internal::TypeNode>
{
- size_t operator()(const cvc5::TypeNode& tn) const;
+ size_t operator()(const cvc5::internal::TypeNode& tn) const;
};
} // namespace std
#include "expr/node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
inline TypeNode
TypeNode::substitute(const TypeNode& type,
return getConst<FloatingPointSize>().significandWidth();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__NODE_H */
#include "expr/type_properties.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace kind {
Node mkGroundTerm(TypeConstant tc)
}
} // namespace kind
-} // namespace cvc5
+} // namespace cvc5::internal
${type_properties_includes}
// clang-format on
-namespace cvc5 {
+namespace cvc5::internal {
namespace kind {
/**
Node mkGroundTerm(TypeNode typeNode);
} // namespace kind
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__TYPE_PROPERTIES_H */
#include "expr/variadic_trie.h"
-namespace cvc5 {
+namespace cvc5::internal {
bool VariadicTrie::add(Node n, const std::vector<Node>& i)
{
return false;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A trie that stores data at undetermined depth. Storing data at
bool hasSubset(const std::vector<Node>& is) const;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__EXPR__VARIADIC_TRIE_H */
#include "smt/command.h"
#include "smt/solver_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace main {
// Function to cancel any (externally-imposed) limit on CPU time.
#endif /* ! __WIN32__ */
}
-CommandExecutor::CommandExecutor(std::unique_ptr<api::Solver>& solver)
- : d_solver(solver),
- d_symman(new SymbolManager(d_solver.get())),
- d_result()
+CommandExecutor::CommandExecutor(std::unique_ptr<cvc5::Solver>& solver)
+ : d_solver(solver), d_symman(new SymbolManager(d_solver.get())), d_result()
{
}
CommandExecutor::~CommandExecutor()
bool status = solverInvoke(
d_solver.get(), d_symman.get(), cmd, d_solver->getDriverOptions().out());
- api::Result res;
+ cvc5::Result res;
const CheckSatCommand* cs = dynamic_cast<const CheckSatCommand*>(cmd);
if(cs != nullptr) {
d_result = res = cs->getResult();
if (d_solver->getOptionInfo("dump-models").boolValue()
&& (isResultSat
|| (res.isUnknown()
- && res.getUnknownExplanation() == api::Result::INCOMPLETE)))
+ && res.getUnknownExplanation() == cvc5::Result::INCOMPLETE)))
{
getterCommands.emplace_back(new GetModelCommand());
}
return status;
}
-bool solverInvoke(api::Solver* solver,
+bool solverInvoke(cvc5::Solver* solver,
SymbolManager* sm,
Command* cmd,
std::ostream& out)
}
} // namespace main
-} // namespace cvc5
+} // namespace cvc5::internal
class Command;
+namespace internal {
+
namespace main {
class CommandExecutor
* The solver object, which is allocated by this class and is used for
* executing most commands (e.g. check-sat).
*/
- std::unique_ptr<api::Solver>& d_solver;
+ std::unique_ptr<cvc5::Solver>& d_solver;
/**
* The symbol manager, which is allocated by this class. This manages
* all things related to definitions of symbols and their impact on behaviors
*/
std::unique_ptr<SymbolManager> d_symman;
- api::Result d_result;
+ cvc5::Result d_result;
public:
- CommandExecutor(std::unique_ptr<api::Solver>& solver);
+ CommandExecutor(std::unique_ptr<cvc5::Solver>& solver);
virtual ~CommandExecutor();
}
/** Get a pointer to the solver object owned by this CommandExecutor. */
- api::Solver* getSolver() { return d_solver.get(); }
+ cvc5::Solver* getSolver() { return d_solver.get(); }
/** Get a pointer to the symbol manager owned by this CommandExecutor */
SymbolManager* getSymbolManager() { return d_symman.get(); }
- api::Result getResult() const { return d_result; }
+ cvc5::Result getResult() const { return d_result; }
void reset();
/** Store the current options as the original options */
}; /* class CommandExecutor */
-bool solverInvoke(api::Solver* solver,
+bool solverInvoke(cvc5::Solver* solver,
SymbolManager* sm,
Command* cmd,
std::ostream& out);
} // namespace main
+} // namespace internal
} // namespace cvc5
#endif /* CVC5__MAIN__COMMAND_EXECUTOR_H */
#include "util/result.h"
using namespace std;
-using namespace cvc5;
+using namespace cvc5::internal;
using namespace cvc5::parser;
-using namespace cvc5::main;
+using namespace cvc5::internal::main;
-namespace cvc5 {
+namespace cvc5::internal {
namespace main {
/** Full argv[0] */
std::string progName;
/** A pointer to the CommandExecutor (the signal handlers need it) */
-std::unique_ptr<cvc5::main::CommandExecutor> pExecutor;
+std::unique_ptr<cvc5::internal::main::CommandExecutor> pExecutor;
} // namespace main
-} // namespace cvc5
+} // namespace cvc5::internal
-int runCvc5(int argc, char* argv[], std::unique_ptr<api::Solver>& solver)
+int runCvc5(int argc, char* argv[], std::unique_ptr<cvc5::Solver>& solver)
{
// Initialize the signal handlers
signal_handlers::install();
// Create the command executor to execute the parsed commands
pExecutor = std::make_unique<CommandExecutor>(solver);
- api::DriverOptions dopts = solver->getDriverOptions();
+ cvc5::DriverOptions dopts = solver->getDriverOptions();
// Parse the options
std::vector<string> filenames = main::parse(*solver, argc, argv, progName);
// Determine which messages to show based on smtcomp_mode and verbosity
if(Configuration::isMuzzledBuild()) {
- TraceChannel.setStream(&cvc5::null_os);
- WarningChannel.setStream(&cvc5::null_os);
+ TraceChannel.setStream(&cvc5::internal::null_os);
+ WarningChannel.setStream(&cvc5::internal::null_os);
}
int returnValue = 0;
solver->setInfo("filename", filenameStr);
// Parse and execute commands until we are done
- std::unique_ptr<Command> cmd;
+ std::unique_ptr<cvc5::Command> cmd;
bool status = true;
if (solver->getOptionInfo("interactive").boolValue() && inputFromStdin)
{
while (status)
{
if (interrupted) {
- dopts.out() << CommandInterrupted();
+ dopts.out() << cvc5::CommandInterrupted();
pExecutor->reset();
break;
}
break;
}
- if(dynamic_cast<QuitCommand*>(cmd.get()) != nullptr) {
+ if (dynamic_cast<cvc5::QuitCommand*>(cmd.get()) != nullptr)
+ {
break;
}
}
}
- api::Result result;
+ cvc5::Result result;
if(status) {
result = pExecutor->getResult();
returnValue = 0;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
-using namespace parser;
+using namespace cvc5::parser;
using namespace language;
const string InteractiveShell::INPUT_FILENAME = "<shell>";
#endif /* HAVE_LIBEDITLINE */
-InteractiveShell::InteractiveShell(api::Solver* solver,
+InteractiveShell::InteractiveShell(Solver* solver,
SymbolManager* sm,
std::istream& in,
std::ostream& out)
#endif /* HAVE_LIBEDITLINE */
-} // namespace cvc5
+} // namespace cvc5::internal
namespace cvc5 {
-class Command;
-
-namespace api {
class Solver;
-}
+
+class SymbolManager;
namespace parser {
class Parser;
} // namespace parser
-class SymbolManager;
-
-class InteractiveShell
-{
- public:
- InteractiveShell(api::Solver* solver,
- SymbolManager* sm,
- std::istream& in,
- std::ostream& out);
-
- /**
- * Close out the interactive session.
- */
- ~InteractiveShell();
-
- /**
- * Read a command from the interactive shell. This will read as
- * many lines as necessary to parse a well-formed command.
- */
- Command* readCommand();
-
- /**
- * Return the internal parser being used.
- */
- parser::Parser* getParser() { return d_parser.get(); }
-
- private:
- api::Solver* d_solver;
- std::istream& d_in;
- std::ostream& d_out;
- std::unique_ptr<parser::Parser> d_parser;
- bool d_quit;
- bool d_usingEditline;
-
- std::string d_historyFilename;
-
- static const std::string INPUT_FILENAME;
- static const unsigned s_historyLimit = 500;
-};/* class InteractiveShell */
-
-} // namespace cvc5
+ class Command;
+
+ namespace internal {
+
+ class InteractiveShell
+ {
+ public:
+ InteractiveShell(Solver* solver,
+ SymbolManager* sm,
+ std::istream& in,
+ std::ostream& out);
+
+ /**
+ * Close out the interactive session.
+ */
+ ~InteractiveShell();
+
+ /**
+ * Read a command from the interactive shell. This will read as
+ * many lines as necessary to parse a well-formed command.
+ */
+ Command* readCommand();
+
+ /**
+ * Return the internal parser being used.
+ */
+ parser::Parser* getParser() { return d_parser.get(); }
+
+ private:
+ Solver* d_solver;
+ std::istream& d_in;
+ std::ostream& d_out;
+ std::unique_ptr<parser::Parser> d_parser;
+ bool d_quit;
+ bool d_usingEditline;
+
+ std::string d_historyFilename;
+
+ static const std::string INPUT_FILENAME;
+ static const unsigned s_historyLimit = 500;
+ }; /* class InteractiveShell */
+
+ } // namespace internal
+ } // namespace cvc5
#endif /* CVC5__INTERACTIVE_SHELL_H */
#include "main/command_executor.h"
#include "options/option_exception.h"
-using namespace cvc5;
+using namespace cvc5::internal;
/**
* cvc5's main() routine is just an exception-safe wrapper around runCvc5.
*/
int main(int argc, char* argv[])
{
- std::unique_ptr<api::Solver> solver = std::make_unique<api::Solver>();
+ std::unique_ptr<cvc5::Solver> solver = std::make_unique<cvc5::Solver>();
try
{
return runCvc5(argc, argv, solver);
}
- catch (cvc5::api::CVC5ApiOptionException& e)
+ catch (cvc5::CVC5ApiOptionException& e)
{
#ifdef CVC5_COMPETITION_MODE
solver->getDriverOptions().out() << "unknown" << std::endl;
#ifndef CVC5__MAIN__MAIN_H
#define CVC5__MAIN__MAIN_H
-namespace cvc5 {
+namespace cvc5::internal {
namespace main {
class CommandExecutor;
extern 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::internal::main::CommandExecutor> pExecutor;
/**
* If true, will not spin on segfault even when CVC5_DEBUG is on.
extern bool segvSpin;
} // namespace main
-} // namespace cvc5
+} // namespace cvc5::internal
/** Actual cvc5 driver functions **/
-int runCvc5(int argc, char* argv[], std::unique_ptr<cvc5::api::Solver>&);
+int runCvc5(int argc, char* argv[], std::unique_ptr<cvc5::Solver>&);
#endif /* CVC5__MAIN__MAIN_H */
#include "api/cpp/cvc5.h"
-namespace cvc5::main {
+namespace cvc5::internal::main {
/**
* Print overall command-line option usage message to the given output stream
*
* Preconditions: options and argv must be non-null.
*/
-std::vector<std::string> parse(api::Solver& solver,
+std::vector<std::string> parse(cvc5::Solver& solver,
int argc,
char* argv[],
std::string& binaryName);
-} // namespace cvc5::options
+} // namespace cvc5::internal::options
#endif
#include <iostream>
#include <limits>
-namespace cvc5::main {
+namespace cvc5::internal::main {
// clang-format off
static const std::string commonOptionsDescription =
optionName.substr(0, optionName.find('=')));
}
-void parseInternal(api::Solver& solver,
+void parseInternal(cvc5::Solver& solver,
int argc,
char* argv[],
std::vector<std::string>& nonoptions)
}
/**
- * Parse argc/argv and put the result into a cvc5::Options.
+ * Parse argc/argv and put the result into a cvc5::internal::Options.
* The return value is what's left of the command line (that is, the
* non-option arguments).
*
* Throws OptionException on failures.
*/
-std::vector<std::string> parse(api::Solver& solver,
+std::vector<std::string> parse(cvc5::Solver& solver,
int argc,
char* argv[],
std::string& binaryName)
return nonoptions;
}
-} // namespace cvc5::options
+} // namespace cvc5::internal::options
#include "main/main.h"
#include "util/safe_print.h"
-using cvc5::Exception;
+using cvc5::internal::Exception;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace main {
/**
} // namespace signal_handlers
} // namespace main
-} // namespace cvc5
+} // namespace cvc5::internal
#ifndef CVC5__MAIN__SIGNAL_HANDLERS_H
#define CVC5__MAIN__SIGNAL_HANDLERS_H
-namespace cvc5 {
+namespace cvc5::internal {
namespace main {
namespace signal_handlers {
} // namespace signal_handlers
} // namespace main
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__MAIN__SIGNAL_HANDLERS_H */
#include "base/exception.h"
#include "signal_handlers.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace main {
#if HAVE_SETITIMER
}
} // namespace main
-} // namespace cvc5
+} // namespace cvc5::internal
#include <cstdint>
-namespace cvc5 {
+namespace cvc5::internal {
namespace main {
/**
TimeLimit install_time_limit(uint64_t ms);
} // namespace main
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__MAIN__TIME_LIMIT_H */
#include "smt/solver_engine.h"
#include "util/bitvector.h"
-using namespace cvc5::smt;
-namespace cvc5::omt {
+using namespace cvc5::internal::smt;
+namespace cvc5::internal::omt {
OMTOptimizerBitVector::OMTOptimizerBitVector(bool isSigned)
: d_isSigned(isSigned)
return OptimizationResult(lastSatResult, value);
}
-} // namespace cvc5::omt
+} // namespace cvc5::internal::omt
#include "omt/omt_optimizer.h"
-namespace cvc5::omt {
+namespace cvc5::internal::omt {
/**
* Optimizer for BitVector type
bool d_isSigned;
};
-} // namespace cvc5::omt
+} // namespace cvc5::internal::omt
#endif /* CVC5__OMT__BITVECTOR_OPTIMIZER_H */
#include "options/smt_options.h"
#include "smt/solver_engine.h"
-using namespace cvc5::smt;
-namespace cvc5::omt {
+using namespace cvc5::internal::smt;
+namespace cvc5::internal::omt {
OptimizationResult OMTOptimizerInteger::optimize(SolverEngine* optChecker,
TNode target,
return this->optimize(optChecker, target, false);
}
-} // namespace cvc5::omt
+} // namespace cvc5::internal::omt
#include "omt/omt_optimizer.h"
-namespace cvc5::omt {
+namespace cvc5::internal::omt {
/**
* Optimizer for Integer type
bool isMinimize);
};
-} // namespace cvc5::omt
+} // namespace cvc5::internal::omt
#endif /* CVC5__OMT__INTEGER_OPTIMIZER_H */
#include "omt/bitvector_optimizer.h"
#include "omt/integer_optimizer.h"
-using namespace cvc5::theory;
-using namespace cvc5::smt;
-namespace cvc5::omt {
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::smt;
+namespace cvc5::internal::omt {
bool OMTOptimizer::nodeSupportsOptimization(TNode node)
{
Unreachable();
}
-} // namespace cvc5::omt
+} // namespace cvc5::internal::omt
#include "smt/optimization_solver.h"
-namespace cvc5::omt {
+namespace cvc5::internal::omt {
/**
* The base class for optimizers of individual CVC type
TNode target) = 0;
};
-} // namespace cvc5::omt
+} // namespace cvc5::internal::omt
#endif /* CVC5__OMT__OMT_OPTIMIZER_H */
#include <iostream>
using namespace std;
-using namespace cvc5;
+using namespace cvc5::internal;
set<string> getDebugTags();
set<string> getOptionStrings();
#include <iomanip>
#include <iostream>
-namespace cvc5::options::ioutils {
+namespace cvc5::internal::options::ioutils {
namespace {
template <typename T>
}
Scope::~Scope() { apply(d_ios, d_dagThresh, d_nodeDepth, d_outputLang); }
-} // namespace cvc5::options::ioutils
+} // namespace cvc5::internal::options::ioutils
* streams), `apply*()` will set the given values on the given object while
* `get*()` retrieves the specified option.
*/
-namespace cvc5::options::ioutils {
+namespace cvc5::internal::options::ioutils {
/** Set the default dag threshold */
void setDefaultDagThresh(int64_t value);
/** Set the default node depth */
/** The stored output language */
Language d_outputLang;
};
-} // namespace cvc5::options::ioutils
+} // namespace cvc5::internal::options::ioutils
#endif /* CVC5__OPTIONS__IO_UTILS_H */
#include "options/option_exception.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& out, Language lang)
{
}
} // namespace language
-} // namespace cvc5
+} // namespace cvc5::internal
#include "cvc5_export.h"
-namespace cvc5 {
+namespace cvc5::internal {
enum class Language
{
Language toLanguage(const std::string& language) CVC5_EXPORT;
} // namespace language
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__LANGUAGE_H */
#include "options/option_exception.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::string cvc5_errno_failreason()
{
return false;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <memory>
#include <ostream>
-namespace cvc5 {
+namespace cvc5::internal {
namespace detail {
/*
bool specialCases(const std::string& value) override final;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__OPTIONS__MANAGED_STREAMS_H */
#include "base/check.h"
#include "options/option_exception.h"
-namespace cvc5::options {
+namespace cvc5::internal::options {
// clang-format off
${modes_impl}$
// clang-format on
-} // namespace cvc5::options
+} // namespace cvc5::internal::options
${includes}$
// clang-format on
-namespace cvc5::options {
+namespace cvc5::internal::options {
// clang-format off
${modes_decl}$
${wrapper_functions}$
// clang-format on
-} // namespace cvc5::options
+} // namespace cvc5::internal::options
#endif /* CVC5__OPTIONS__${id_cap}$_H */
#include "options/option_exception.h"
-namespace cvc5 {
+namespace cvc5::internal {
const std::string OptionException::s_errPrefix = "Error in option parsing: ";
-} // namespace cvc5
+} // namespace cvc5::internal
#include "cvc5_export.h"
#include "base/exception.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Class representing an option-parsing exception such as badly-typed
* or missing arguments, arguments out of bounds, etc.
*/
-class CVC5_EXPORT OptionException : public cvc5::Exception
+class CVC5_EXPORT OptionException : public cvc5::internal::Exception
{
public:
- OptionException(const std::string& s) : cvc5::Exception(s_errPrefix + s) {}
+ OptionException(const std::string& s) : cvc5::internal::Exception(s_errPrefix + s) {}
/**
* Get the error message without the prefix that is automatically added for
static const std::string s_errPrefix;
}; /* class OptionException */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__OPTION_EXCEPTION_H */
#include "smt/command.h"
#include "util/didyoumean.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace options {
// helper functions
void OptionsHandler::setVerbosity(const std::string& flag, int value)
{
if(Configuration::isMuzzledBuild()) {
- TraceChannel.setStream(&cvc5::null_os);
- WarningChannel.setStream(&cvc5::null_os);
+ TraceChannel.setStream(&cvc5::internal::null_os);
+ WarningChannel.setStream(&cvc5::internal::null_os);
} else {
if(value < 0) {
- WarningChannel.setStream(&cvc5::null_os);
+ WarningChannel.setStream(&cvc5::internal::null_os);
} else {
WarningChannel.setStream(&std::cerr);
}
void OptionsHandler::setPrintSuccess(const std::string& flag, bool value)
{
- TraceChannel.getStream() << Command::printsuccess(value);
- Warning.getStream() << Command::printsuccess(value);
- *d_options->base.out << Command::printsuccess(value);
+ TraceChannel.getStream() << cvc5::Command::printsuccess(value);
+ Warning.getStream() << cvc5::Command::printsuccess(value);
+ *d_options->base.out << cvc5::Command::printsuccess(value);
}
void OptionsHandler::setResourceWeight(const std::string& flag,
}
} // namespace options
-} // namespace cvc5
+} // namespace cvc5::internal
#include "options/option_exception.h"
#include "options/quantifiers_options.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Options;
}; /* class OptionHandler */
} // namespace options
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__OPTIONS__OPTIONS_HANDLER_H */
#include <string>
-namespace cvc5 {
+namespace cvc5::internal {
class OptionsListener
{
virtual void notifySetOption(const std::string& key) = 0;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__OPTIONS__OPTION_LISTENER_H */
#include "cvc5_export.h"
#include "options/options.h"
-namespace cvc5::options {
+namespace cvc5::internal::options {
/**
* Get a (sorted) list of all option names that are available.
*/
OptionInfo getInfo(const Options& opts, const std::string& name) CVC5_EXPORT;
-} // namespace cvc5::options
+} // namespace cvc5::internal::options
#endif
#include <iostream>
#include <limits>
-namespace cvc5::options
+namespace cvc5::internal::options
{
// Contains the default option handlers (i.e. parsers)
namespace handlers {
#undef DO_SEMANTIC_CHECKS_BY_DEFAULT
-} // namespace cvc5::options
+} // namespace cvc5::internal::options
${headers_module}$
// clang-format on
-namespace cvc5
+namespace cvc5::internal
{
thread_local Options* Options::s_current = nullptr;
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "cvc5_export.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace options {
class OptionsHandler;
// clang-format off
}; /* class Options */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__OPTIONS__OPTIONS_H */
#include "parser/tptp/tptp_input.h"
using namespace std;
-using namespace cvc5;
-using namespace cvc5::parser;
namespace cvc5 {
namespace parser {
namespace parser {
-class InputStreamException : public Exception
+class InputStreamException : public internal::Exception
{
public:
InputStreamException(const std::string& msg);
/** Parse an expression from the input by invoking the
* implementation-specific parsing method. Returns a null
- * <code>api::Term</code> if there is no expression there to parse.
+ * <code>cvc5::Term</code> if there is no expression there to parse.
*
* @throws ParserException if an error is encountered during parsing.
*/
- virtual api::Term parseExpr() = 0;
+ virtual cvc5::Term parseExpr() = 0;
/** Set the Parser object for this input. */
virtual void setParser(Parser& parser) = 0;
{
out << " :op " << p.d_op;
}
- if (p.d_kind != api::NULL_TERM)
+ if (p.d_kind != cvc5::NULL_TERM)
{
out << " :kind " << p.d_kind;
}
*/
struct ParseOp
{
- ParseOp(api::Kind k = api::NULL_TERM) : d_kind(k) {}
+ ParseOp(cvc5::Kind k = cvc5::NULL_TERM) : d_kind(k) {}
/** The kind associated with the parsed operator, if it exists */
- api::Kind d_kind;
+ cvc5::Kind d_kind;
/** The name associated with the parsed operator, if it exists */
std::string d_name;
/** The expression associated with the parsed operator, if it exists */
- api::Term d_expr;
+ cvc5::Term d_expr;
/** The type associated with the parsed operator, if it exists */
- api::Sort d_type;
+ cvc5::Sort d_type;
/** The operator associated with the parsed operator, if it exists */
- api::Op d_op;
+ cvc5::Op d_op;
/**
- * The indices if the operator is indexed, but api::Op is the null operator.
+ * The indices if the operator is indexed, but cvc5::Op is the null operator.
* This is the case for operator symbols that cannot be resolved to a kind
* without parsing the arguments. This is currently only the case for
* `to_fp`.
namespace cvc5 {
namespace parser {
-Parser::Parser(api::Solver* solver,
+Parser::Parser(cvc5::Solver* solver,
SymbolManager* sm,
bool strictMode,
bool parseOnly)
d_commandQueue.clear();
}
-api::Solver* Parser::getSolver() const { return d_solver; }
+cvc5::Solver* Parser::getSolver() const { return d_solver; }
-api::Term Parser::getSymbol(const std::string& name, SymbolType type)
+cvc5::Term Parser::getSymbol(const std::string& name, SymbolType type)
{
checkDeclaration(name, CHECK_DECLARED, type);
Assert(isDeclared(name, type));
d_forcedLogic = logic;
}
-api::Term Parser::getVariable(const std::string& name)
+cvc5::Term Parser::getVariable(const std::string& name)
{
return getSymbol(name, SYM_VARIABLE);
}
-api::Term Parser::getFunction(const std::string& name)
+cvc5::Term Parser::getFunction(const std::string& name)
{
return getSymbol(name, SYM_VARIABLE);
}
-api::Term Parser::getExpressionForName(const std::string& name)
+cvc5::Term Parser::getExpressionForName(const std::string& name)
{
- api::Sort t;
+ cvc5::Sort t;
return getExpressionForNameAndType(name, t);
}
-api::Term Parser::getExpressionForNameAndType(const std::string& name,
- api::Sort t)
+cvc5::Term Parser::getExpressionForNameAndType(const std::string& name,
+ cvc5::Sort t)
{
Assert(isDeclared(name));
// first check if the variable is declared and not overloaded
- api::Term expr = getVariable(name);
+ cvc5::Term expr = getVariable(name);
if(expr.isNull()) {
// the variable is overloaded, try with type if the type exists
if(!t.isNull()) {
}
// now, post-process the expression
Assert(!expr.isNull());
- api::Sort te = expr.getSort();
+ cvc5::Sort te = expr.getSort();
if (te.isConstructor() && te.getConstructorArity() == 0)
{
// nullary constructors have APPLY_CONSTRUCTOR kind with no children
- expr = d_solver->mkTerm(api::APPLY_CONSTRUCTOR, {expr});
+ expr = d_solver->mkTerm(cvc5::APPLY_CONSTRUCTOR, {expr});
}
return expr;
}
-bool Parser::getTesterName(api::Term cons, std::string& name) { return false; }
+bool Parser::getTesterName(cvc5::Term cons, std::string& name) { return false; }
-api::Kind Parser::getKindForFunction(api::Term fun)
+cvc5::Kind Parser::getKindForFunction(cvc5::Term fun)
{
- api::Sort t = fun.getSort();
+ cvc5::Sort t = fun.getSort();
if (t.isFunction())
{
- return api::APPLY_UF;
+ return cvc5::APPLY_UF;
}
else if (t.isConstructor())
{
- return api::APPLY_CONSTRUCTOR;
+ return cvc5::APPLY_CONSTRUCTOR;
}
else if (t.isSelector())
{
- return api::APPLY_SELECTOR;
+ return cvc5::APPLY_SELECTOR;
}
else if (t.isTester())
{
- return api::APPLY_TESTER;
+ return cvc5::APPLY_TESTER;
}
else if (t.isUpdater())
{
- return api::APPLY_UPDATER;
+ return cvc5::APPLY_UPDATER;
}
- return api::UNDEFINED_KIND;
+ return cvc5::UNDEFINED_KIND;
}
-api::Sort Parser::getSort(const std::string& name)
+cvc5::Sort Parser::getSort(const std::string& name)
{
checkDeclaration(name, CHECK_DECLARED, SYM_SORT);
Assert(isDeclared(name, SYM_SORT));
- api::Sort t = d_symtab->lookupType(name);
+ cvc5::Sort t = d_symtab->lookupType(name);
return t;
}
-api::Sort Parser::getSort(const std::string& name,
- const std::vector<api::Sort>& params)
+cvc5::Sort Parser::getSort(const std::string& name,
+ const std::vector<cvc5::Sort>& params)
{
checkDeclaration(name, CHECK_DECLARED, SYM_SORT);
Assert(isDeclared(name, SYM_SORT));
- api::Sort t = d_symtab->lookupType(name, params);
+ cvc5::Sort t = d_symtab->lookupType(name, params);
return t;
}
/* Returns true if name is bound to a boolean variable. */
bool Parser::isBoolean(const std::string& name) {
- api::Term expr = getVariable(name);
+ cvc5::Term expr = getVariable(name);
return !expr.isNull() && expr.getSort().isBoolean();
}
-bool Parser::isFunctionLike(api::Term fun)
+bool Parser::isFunctionLike(cvc5::Term fun)
{
if(fun.isNull()) {
return false;
}
- api::Sort type = fun.getSort();
+ cvc5::Sort type = fun.getSort();
return type.isFunction() || type.isConstructor() || type.isTester() ||
type.isSelector();
}
/* Returns true if name is bound to a function returning boolean. */
bool Parser::isPredicate(const std::string& name) {
- api::Term expr = getVariable(name);
+ cvc5::Term expr = getVariable(name);
return !expr.isNull() && expr.getSort().isPredicate();
}
-api::Term Parser::bindVar(const std::string& name,
- const api::Sort& type,
- bool doOverload)
+cvc5::Term Parser::bindVar(const std::string& name,
+ const cvc5::Sort& type,
+ bool doOverload)
{
Trace("parser") << "bindVar(" << name << ", " << type << ")" << std::endl;
- api::Term expr = d_solver->mkConst(type, name);
+ cvc5::Term expr = d_solver->mkConst(type, name);
defineVar(name, expr, doOverload);
return expr;
}
-api::Term Parser::bindBoundVar(const std::string& name, const api::Sort& type)
+cvc5::Term Parser::bindBoundVar(const std::string& name, const cvc5::Sort& type)
{
Trace("parser") << "bindBoundVar(" << name << ", " << type << ")"
<< std::endl;
- api::Term expr = d_solver->mkVar(type, name);
+ cvc5::Term expr = d_solver->mkVar(type, name);
defineVar(name, expr);
return expr;
}
-std::vector<api::Term> Parser::bindBoundVars(
- std::vector<std::pair<std::string, api::Sort> >& sortedVarNames)
+std::vector<cvc5::Term> Parser::bindBoundVars(
+ std::vector<std::pair<std::string, cvc5::Sort> >& sortedVarNames)
{
- std::vector<api::Term> vars;
- for (std::pair<std::string, api::Sort>& i : sortedVarNames)
+ std::vector<cvc5::Term> vars;
+ for (std::pair<std::string, cvc5::Sort>& i : sortedVarNames)
{
vars.push_back(bindBoundVar(i.first, i.second));
}
return vars;
}
-std::vector<api::Term> Parser::bindVars(const std::vector<std::string> names,
- const api::Sort& type,
- bool doOverload)
+std::vector<cvc5::Term> Parser::bindVars(const std::vector<std::string> names,
+ const cvc5::Sort& type,
+ bool doOverload)
{
- std::vector<api::Term> vars;
+ std::vector<cvc5::Term> vars;
for (unsigned i = 0; i < names.size(); ++i) {
vars.push_back(bindVar(names[i], type, doOverload));
}
return vars;
}
-std::vector<api::Term> Parser::bindBoundVars(
- const std::vector<std::string> names, const api::Sort& type)
+std::vector<cvc5::Term> Parser::bindBoundVars(
+ const std::vector<std::string> names, const cvc5::Sort& type)
{
- std::vector<api::Term> vars;
+ std::vector<cvc5::Term> vars;
for (unsigned i = 0; i < names.size(); ++i) {
vars.push_back(bindBoundVar(names[i], type));
}
}
void Parser::defineVar(const std::string& name,
- const api::Term& val,
+ const cvc5::Term& val,
bool doOverload)
{
Trace("parser") << "defineVar( " << name << " := " << val << ")" << std::endl;
}
void Parser::defineType(const std::string& name,
- const api::Sort& type,
+ const cvc5::Sort& type,
bool skipExisting)
{
if (skipExisting && isDeclared(name, SYM_SORT))
}
void Parser::defineType(const std::string& name,
- const std::vector<api::Sort>& params,
- const api::Sort& type)
+ const std::vector<cvc5::Sort>& params,
+ const cvc5::Sort& type)
{
d_symtab->bindType(name, params, type);
Assert(isDeclared(name, SYM_SORT));
}
void Parser::defineParameterizedType(const std::string& name,
- const std::vector<api::Sort>& params,
- const api::Sort& type)
+ const std::vector<cvc5::Sort>& params,
+ const cvc5::Sort& type)
{
if (TraceIsOn("parser")) {
Trace("parser") << "defineParameterizedType(" << name << ", "
if (params.size() > 0) {
copy(params.begin(),
params.end() - 1,
- ostream_iterator<api::Sort>(Trace("parser"), ", "));
+ ostream_iterator<cvc5::Sort>(Trace("parser"), ", "));
Trace("parser") << params.back();
}
Trace("parser") << "], " << type << ")" << std::endl;
defineType(name, params, type);
}
-api::Sort Parser::mkSort(const std::string& name)
+cvc5::Sort Parser::mkSort(const std::string& name)
{
Trace("parser") << "newSort(" << name << ")" << std::endl;
- api::Sort type = d_solver->mkUninterpretedSort(name);
+ cvc5::Sort type = d_solver->mkUninterpretedSort(name);
defineType(name, type);
return type;
}
-api::Sort Parser::mkSortConstructor(const std::string& name, size_t arity)
+cvc5::Sort Parser::mkSortConstructor(const std::string& name, size_t arity)
{
Trace("parser") << "newSortConstructor(" << name << ", " << arity << ")"
<< std::endl;
- api::Sort type = d_solver->mkUninterpretedSortConstructorSort(name, arity);
- defineType(name, vector<api::Sort>(arity), type);
+ cvc5::Sort type = d_solver->mkUninterpretedSortConstructorSort(name, arity);
+ defineType(name, vector<cvc5::Sort>(arity), type);
return type;
}
-api::Sort Parser::mkUnresolvedType(const std::string& name)
+cvc5::Sort Parser::mkUnresolvedType(const std::string& name)
{
- api::Sort unresolved = d_solver->mkUninterpretedSort(name);
+ cvc5::Sort unresolved = d_solver->mkUninterpretedSort(name);
defineType(name, unresolved);
d_unresolved.insert(unresolved);
return unresolved;
}
-api::Sort Parser::mkUnresolvedTypeConstructor(const std::string& name,
- size_t arity)
+cvc5::Sort Parser::mkUnresolvedTypeConstructor(const std::string& name,
+ size_t arity)
{
- api::Sort unresolved =
+ cvc5::Sort unresolved =
d_solver->mkUninterpretedSortConstructorSort(name, arity);
- defineType(name, vector<api::Sort>(arity), unresolved);
+ defineType(name, vector<cvc5::Sort>(arity), unresolved);
d_unresolved.insert(unresolved);
return unresolved;
}
-api::Sort Parser::mkUnresolvedTypeConstructor(
- const std::string& name, const std::vector<api::Sort>& params)
+cvc5::Sort Parser::mkUnresolvedTypeConstructor(
+ const std::string& name, const std::vector<cvc5::Sort>& params)
{
Trace("parser") << "newSortConstructor(P)(" << name << ", " << params.size()
<< ")" << std::endl;
- api::Sort unresolved =
+ cvc5::Sort unresolved =
d_solver->mkUninterpretedSortConstructorSort(name, params.size());
defineType(name, params, unresolved);
- api::Sort t = getSort(name, params);
+ cvc5::Sort t = getSort(name, params);
d_unresolved.insert(unresolved);
return unresolved;
}
-api::Sort Parser::mkUnresolvedType(const std::string& name, size_t arity)
+cvc5::Sort Parser::mkUnresolvedType(const std::string& name, size_t arity)
{
if (arity == 0)
{
return d_unresolved.find(getSort(name)) != d_unresolved.end();
}
-std::vector<api::Sort> Parser::bindMutualDatatypeTypes(
- std::vector<api::DatatypeDecl>& datatypes, bool doOverload)
+std::vector<cvc5::Sort> Parser::bindMutualDatatypeTypes(
+ std::vector<cvc5::DatatypeDecl>& datatypes, bool doOverload)
{
try {
- std::vector<api::Sort> types =
+ std::vector<cvc5::Sort> types =
d_solver->mkDatatypeSorts(datatypes, d_unresolved);
Assert(datatypes.size() == types.size());
for (unsigned i = 0; i < datatypes.size(); ++i) {
- api::Sort t = types[i];
- const api::Datatype& dt = t.getDatatype();
+ cvc5::Sort t = types[i];
+ const cvc5::Datatype& dt = t.getDatatype();
const std::string& name = dt.getName();
Trace("parser-idt") << "define " << name << " as " << t << std::endl;
if (isDeclared(name, SYM_SORT)) {
}
if (dt.isParametric())
{
- std::vector<api::Sort> paramTypes = dt.getParameters();
+ std::vector<cvc5::Sort> paramTypes = dt.getParameters();
defineType(name, paramTypes, t);
}
else
std::unordered_set< std::string > selNames;
for (size_t j = 0, ncons = dt.getNumConstructors(); j < ncons; j++)
{
- const api::DatatypeConstructor& ctor = dt[j];
- api::Term constructor = ctor.getConstructorTerm();
+ const cvc5::DatatypeConstructor& ctor = dt[j];
+ cvc5::Term constructor = ctor.getConstructorTerm();
Trace("parser-idt") << "+ define " << constructor << std::endl;
string constructorName = ctor.getName();
if(consNames.find(constructorName)==consNames.end()) {
std::string testerName;
if (getTesterName(constructor, testerName))
{
- api::Term tester = ctor.getTesterTerm();
+ cvc5::Term tester = ctor.getTesterTerm();
Trace("parser-idt") << "+ define " << testerName << std::endl;
if (!doOverload)
{
}
for (size_t k = 0, nargs = ctor.getNumSelectors(); k < nargs; k++)
{
- const api::DatatypeSelector& sel = ctor[k];
- api::Term selector = sel.getSelectorTerm();
+ const cvc5::DatatypeSelector& sel = ctor[k];
+ cvc5::Term selector = sel.getSelectorTerm();
Trace("parser-idt") << "+++ define " << selector << std::endl;
string selectorName = sel.getName();
if(selNames.find(selectorName)==selNames.end()) {
// throw exception if any datatype is not well-founded
for (unsigned i = 0; i < datatypes.size(); ++i) {
- const api::Datatype& dt = types[i].getDatatype();
+ const cvc5::Datatype& dt = types[i].getDatatype();
if (!dt.isCodatatype() && !dt.isWellFounded()) {
throw ParserException(dt.getName() + " is not well-founded");
}
}
return types;
- } catch (IllegalArgumentException& ie) {
+ }
+ catch (internal::IllegalArgumentException& ie)
+ {
throw ParserException(ie.getMessage());
}
}
-api::Sort Parser::mkFlatFunctionType(std::vector<api::Sort>& sorts,
- api::Sort range,
- std::vector<api::Term>& flattenVars)
+cvc5::Sort Parser::mkFlatFunctionType(std::vector<cvc5::Sort>& sorts,
+ cvc5::Sort range,
+ std::vector<cvc5::Term>& flattenVars)
{
if (range.isFunction())
{
- std::vector<api::Sort> domainTypes = range.getFunctionDomainSorts();
+ std::vector<cvc5::Sort> domainTypes = range.getFunctionDomainSorts();
for (unsigned i = 0, size = domainTypes.size(); i < size; i++)
{
sorts.push_back(domainTypes[i]);
// the introduced variable is internal (not parsable)
std::stringstream ss;
ss << "__flatten_var_" << i;
- api::Term v = d_solver->mkVar(domainTypes[i], ss.str());
+ cvc5::Term v = d_solver->mkVar(domainTypes[i], ss.str());
flattenVars.push_back(v);
}
range = range.getFunctionCodomainSort();
return d_solver->mkFunctionSort(sorts, range);
}
-api::Sort Parser::mkFlatFunctionType(std::vector<api::Sort>& sorts,
- api::Sort range)
+cvc5::Sort Parser::mkFlatFunctionType(std::vector<cvc5::Sort>& sorts,
+ cvc5::Sort range)
{
if (sorts.empty())
{
if (TraceIsOn("parser"))
{
Trace("parser") << "mkFlatFunctionType: range " << range << " and domains ";
- for (api::Sort t : sorts)
+ for (cvc5::Sort t : sorts)
{
Trace("parser") << " " << t;
}
}
while (range.isFunction())
{
- std::vector<api::Sort> domainTypes = range.getFunctionDomainSorts();
+ std::vector<cvc5::Sort> domainTypes = range.getFunctionDomainSorts();
sorts.insert(sorts.end(), domainTypes.begin(), domainTypes.end());
range = range.getFunctionCodomainSort();
}
return d_solver->mkFunctionSort(sorts, range);
}
-api::Term Parser::mkHoApply(api::Term expr, const std::vector<api::Term>& args)
+cvc5::Term Parser::mkHoApply(cvc5::Term expr,
+ const std::vector<cvc5::Term>& args)
{
for (unsigned i = 0; i < args.size(); i++)
{
- expr = d_solver->mkTerm(api::HO_APPLY, {expr, args[i]});
+ expr = d_solver->mkTerm(cvc5::HO_APPLY, {expr, args[i]});
}
return expr;
}
-api::Term Parser::applyTypeAscription(api::Term t, api::Sort s)
+cvc5::Term Parser::applyTypeAscription(cvc5::Term t, cvc5::Sort s)
{
- api::Kind k = t.getKind();
- if (k == api::SET_EMPTY)
+ cvc5::Kind k = t.getKind();
+ if (k == cvc5::SET_EMPTY)
{
t = d_solver->mkEmptySet(s);
}
- else if (k == api::BAG_EMPTY)
+ else if (k == cvc5::BAG_EMPTY)
{
t = d_solver->mkEmptyBag(s);
}
- else if (k == api::CONST_SEQUENCE)
+ else if (k == cvc5::CONST_SEQUENCE)
{
if (!s.isSequence())
{
}
t = d_solver->mkEmptySequence(s.getSequenceElementSort());
}
- else if (k == api::SET_UNIVERSE)
+ else if (k == cvc5::SET_UNIVERSE)
{
t = d_solver->mkUniverseSet(s);
}
- else if (k == api::SEP_NIL)
+ else if (k == cvc5::SEP_NIL)
{
t = d_solver->mkSepNil(s);
}
- else if (k == api::APPLY_CONSTRUCTOR)
+ else if (k == cvc5::APPLY_CONSTRUCTOR)
{
- std::vector<api::Term> children(t.begin(), t.end());
+ std::vector<cvc5::Term> children(t.begin(), t.end());
// apply type ascription to the operator and reconstruct
children[0] = applyTypeAscription(children[0], s);
- t = d_solver->mkTerm(api::APPLY_CONSTRUCTOR, children);
+ t = d_solver->mkTerm(cvc5::APPLY_CONSTRUCTOR, children);
}
// !!! temporary until datatypes are refactored in the new API
- api::Sort etype = t.getSort();
+ cvc5::Sort etype = t.getSort();
if (etype.isConstructor())
{
// Type ascriptions only have an effect on the node structure if this is a
// parametric datatype.
// get the datatype that t belongs to
- api::Sort etyped = etype.getConstructorCodomainSort();
- api::Datatype d = etyped.getDatatype();
+ cvc5::Sort etyped = etype.getConstructorCodomainSort();
+ cvc5::Datatype d = etyped.getDatatype();
// Note that we check whether the datatype is parametric, and not whether
// etyped is a parametric datatype, since e.g. the smt2 parser constructs
// an arbitrary instantitated constructor term before it is resolved.
if (d.isParametric())
{
// lookup by name
- api::DatatypeConstructor dc = d.getConstructor(t.toString());
+ cvc5::DatatypeConstructor dc = d.getConstructor(t.toString());
// ask the constructor for the specialized constructor term
t = dc.getInstantiatedConstructorTerm(s);
}
// Otherwise, check that the type is correct. Type ascriptions in SMT-LIB 2.6
// referred to the range of function sorts. Note that this is only a check
// and does not impact the returned term.
- api::Sort checkSort = t.getSort();
+ cvc5::Sort checkSort = t.getSort();
if (checkSort.isFunction())
{
checkSort = checkSort.getFunctionCodomainSort();
}
}
-void Parser::checkFunctionLike(api::Term fun)
+void Parser::checkFunctionLike(cvc5::Term fun)
{
if (d_checksEnabled && !isFunctionLike(fun)) {
stringstream ss;
}
}
-void Parser::addOperator(api::Kind kind) { d_logicOperators.insert(kind); }
+void Parser::addOperator(cvc5::Kind kind) { d_logicOperators.insert(kind); }
void Parser::preemptCommand(Command* cmd) { d_commandQueue.push_back(cmd); }
Command* Parser::nextCommand()
return cmd;
}
-api::Term Parser::nextExpression()
+cvc5::Term Parser::nextExpression()
{
Trace("parser") << "nextExpression()" << std::endl;
- api::Term result;
+ cvc5::Term result;
if (!done()) {
try {
result = d_input->parseExpr();
// we must bind all relevant uninterpreted constants, which coincide with
// the set of uninterpreted constants that are printed in the definition
// of a model.
- std::vector<api::Sort> declareSorts = d_symman->getModelDeclareSorts();
+ std::vector<cvc5::Sort> declareSorts = d_symman->getModelDeclareSorts();
Trace("parser") << "Push get value scope, with " << declareSorts.size()
<< " declared sorts" << std::endl;
- for (const api::Sort& s : declareSorts)
+ for (const cvc5::Sort& s : declareSorts)
{
- std::vector<api::Term> elements = d_solver->getModelDomainElements(s);
- for (const api::Term& e : elements)
+ std::vector<cvc5::Term> elements = d_solver->getModelDomainElements(s);
+ for (const cvc5::Term& e : elements)
{
defineVar(e.getUninterpretedSortValue(), e);
}
return res;
}
-api::Term Parser::mkStringConstant(const std::string& s)
+cvc5::Term Parser::mkStringConstant(const std::string& s)
{
if (d_solver->getOption("input-language") == "LANG_SMTLIB_V2_6")
{
return d_solver->mkString(str);
}
-api::Term Parser::mkCharConstant(const std::string& s)
+cvc5::Term Parser::mkCharConstant(const std::string& s)
{
Assert(s.find_first_not_of("0123456789abcdefABCDEF", 0) == std::string::npos
&& s.size() <= 5 && s.size() > 0)
/**
* This current symbol table used by this parser, from symbol manager.
*/
- SymbolTable* d_symtab;
+ internal::SymbolTable* d_symtab;
/**
* The level of the assertions in the declaration scope. Things declared
std::string d_forcedLogic;
/** The set of operators available in the current logic. */
- std::set<api::Kind> d_logicOperators;
+ std::set<cvc5::Kind> d_logicOperators;
/** The set of attributes already warned about. */
std::set<std::string> d_attributesWarnedAbout;
* depend on mkMutualDatatypeTypes() to check everything and clear
* this out.
*/
- std::set<api::Sort> d_unresolved;
+ std::set<cvc5::Sort> d_unresolved;
/**
* "Preemption commands": extra commands implied by subterms that
/** Lookup a symbol in the given namespace (as specified by the type).
* Only returns a symbol if it is not overloaded, returns null otherwise.
*/
- api::Term getSymbol(const std::string& var_name, SymbolType type);
+ cvc5::Term getSymbol(const std::string& var_name, SymbolType type);
protected:
/** The API Solver object. */
- api::Solver* d_solver;
+ cvc5::Solver* d_solver;
/**
* Create a parser state.
* need not be performed, like those about unimplemented features, @see
* unimplementedFeature())
*/
- Parser(api::Solver* solver,
+ Parser(cvc5::Solver* solver,
SymbolManager* sm,
bool strictMode = false,
bool parseOnly = false);
virtual ~Parser();
/** Get the associated solver. */
- api::Solver* getSolver() const;
+ cvc5::Solver* getSolver() const;
/** Get the associated input. */
Input* getInput() const { return d_input.get(); }
/** Get unresolved sorts */
- inline std::set<api::Sort>& getUnresolvedSorts() { return d_unresolved; }
+ inline std::set<cvc5::Sort>& getUnresolvedSorts() { return d_unresolved; }
/** Deletes and replaces the current parser input. */
void setInput(Input* input) {
* @return the variable expression
* Only returns a variable if its name is not overloaded, returns null otherwise.
*/
- api::Term getVariable(const std::string& name);
+ cvc5::Term getVariable(const std::string& name);
/**
* Gets the function currently bound to name.
* @return the variable expression
* Only returns a function if its name is not overloaded, returns null otherwise.
*/
- api::Term getFunction(const std::string& name);
+ cvc5::Term getFunction(const std::string& name);
/**
* Returns the expression that name should be interpreted as, based on the current binding.
* a nullary constructor or a defined function.
* Only returns an expression if its name is not overloaded, returns null otherwise.
*/
- virtual api::Term getExpressionForName(const std::string& name);
+ virtual cvc5::Term getExpressionForName(const std::string& name);
/**
* Returns the expression that name should be interpreted as, based on the
*
* This is the same as above but where the name has been type cast to t.
*/
- virtual api::Term getExpressionForNameAndType(const std::string& name,
- api::Sort t);
+ virtual cvc5::Term getExpressionForNameAndType(const std::string& name,
+ cvc5::Sort t);
/**
* If this method returns true, then name is updated with the tester name
* the above syntax if strict mode is disabled.
* - In cvc, the syntax for testers is "is_cons".
*/
- virtual bool getTesterName(api::Term cons, std::string& name);
+ virtual bool getTesterName(cvc5::Term cons, std::string& name);
/**
* Returns the kind that should be used for applications of expression fun.
* APPLY_UF if fun has function type,
* APPLY_CONSTRUCTOR if fun has constructor type.
*/
- api::Kind getKindForFunction(api::Term fun);
+ cvc5::Kind getKindForFunction(cvc5::Term fun);
/**
* Returns a sort, given a name.
* @param sort_name the name to look up
*/
- api::Sort getSort(const std::string& sort_name);
+ cvc5::Sort getSort(const std::string& sort_name);
/**
* Returns a (parameterized) sort, given a name and args.
*/
- api::Sort getSort(const std::string& sort_name,
- const std::vector<api::Sort>& params);
+ cvc5::Sort getSort(const std::string& sort_name,
+ const std::vector<cvc5::Sort>& params);
/**
* Returns arity of a (parameterized) sort, given a name and args.
* @throws ParserException if checks are enabled and fun is not
* a function
*/
- void checkFunctionLike(api::Term fun);
+ void checkFunctionLike(cvc5::Term fun);
/** Create a new cvc5 variable expression of the given type.
*
* else if doOverload is false, the existing expression is shadowed by the
* new expression.
*/
- api::Term bindVar(const std::string& name,
- const api::Sort& type,
- bool doOverload = false);
+ cvc5::Term bindVar(const std::string& name,
+ const cvc5::Sort& type,
+ bool doOverload = false);
/**
* Create a set of new cvc5 variable expressions of the given type.
* else if doOverload is false, the existing expression is shadowed by the
* new expression.
*/
- std::vector<api::Term> bindVars(const std::vector<std::string> names,
- const api::Sort& type,
- bool doOverload = false);
+ std::vector<cvc5::Term> bindVars(const std::vector<std::string> names,
+ const cvc5::Sort& type,
+ bool doOverload = false);
/**
* Create a new cvc5 bound variable expression of the given type. This binds
* the symbol name to that variable in the current scope.
*/
- api::Term bindBoundVar(const std::string& name, const api::Sort& type);
+ cvc5::Term bindBoundVar(const std::string& name, const cvc5::Sort& type);
/**
* Create a new cvc5 bound variable expressions of the given names and types.
* Like the method above, this binds these names to those variables in the
* current scope.
*/
- std::vector<api::Term> bindBoundVars(
- std::vector<std::pair<std::string, api::Sort> >& sortedVarNames);
+ std::vector<cvc5::Term> bindBoundVars(
+ std::vector<std::pair<std::string, cvc5::Sort> >& sortedVarNames);
/**
* Create a set of new cvc5 bound variable expressions of the given type.
* else if doOverload is false, the existing expression is shadowed by the
* new expression.
*/
- std::vector<api::Term> bindBoundVars(const std::vector<std::string> names,
- const api::Sort& type);
+ std::vector<cvc5::Term> bindBoundVars(const std::vector<std::string> names,
+ const cvc5::Sort& type);
/** Create a new variable definition (e.g., from a let binding).
* If a symbol with name already exists,
* new expression.
*/
void defineVar(const std::string& name,
- const api::Term& val,
+ const cvc5::Term& val,
bool doOverload = false);
/**
* the definition is the exact same as the existing one.
*/
void defineType(const std::string& name,
- const api::Sort& type,
+ const cvc5::Sort& type,
bool skipExisting = false);
/**
* @param type The type that should be associated with the name
*/
void defineType(const std::string& name,
- const std::vector<api::Sort>& params,
- const api::Sort& type);
+ const std::vector<cvc5::Sort>& params,
+ const cvc5::Sort& type);
/** Create a new type definition (e.g., from an SMT-LIBv2 define-sort). */
void defineParameterizedType(const std::string& name,
- const std::vector<api::Sort>& params,
- const api::Sort& type);
+ const std::vector<cvc5::Sort>& params,
+ const cvc5::Sort& type);
/**
* Creates a new sort with the given name.
*/
- api::Sort mkSort(const std::string& name);
+ cvc5::Sort mkSort(const std::string& name);
/**
* Creates a new sort constructor with the given name and arity.
*/
- api::Sort mkSortConstructor(const std::string& name, size_t arity);
+ cvc5::Sort mkSortConstructor(const std::string& name, size_t arity);
/**
* Creates a new "unresolved type," used only during parsing.
*/
- api::Sort mkUnresolvedType(const std::string& name);
+ cvc5::Sort mkUnresolvedType(const std::string& name);
/**
* Creates a new unresolved (parameterized) type constructor of the given
* arity.
*/
- api::Sort mkUnresolvedTypeConstructor(const std::string& name, size_t arity);
+ cvc5::Sort mkUnresolvedTypeConstructor(const std::string& name, size_t arity);
/**
* Creates a new unresolved (parameterized) type constructor given the type
* parameters.
*/
- api::Sort mkUnresolvedTypeConstructor(const std::string& name,
- const std::vector<api::Sort>& params);
+ cvc5::Sort mkUnresolvedTypeConstructor(const std::string& name,
+ const std::vector<cvc5::Sort>& params);
/**
* Creates a new unresolved (parameterized) type constructor of the given
* arity. Calls either mkUnresolvedType or mkUnresolvedTypeConstructor
* depending on the arity.
*/
- api::Sort mkUnresolvedType(const std::string& name, size_t arity);
+ cvc5::Sort mkUnresolvedType(const std::string& name, size_t arity);
/**
* Returns true IFF name is an unresolved type.
* doOverload is false, the existing expression is shadowed by the new
* expression.
*/
- std::vector<api::Sort> bindMutualDatatypeTypes(
- std::vector<api::DatatypeDecl>& datatypes, bool doOverload = false);
+ std::vector<cvc5::Sort> bindMutualDatatypeTypes(
+ std::vector<cvc5::DatatypeDecl>& datatypes, bool doOverload = false);
/** make flat function type
*
* where @ is (higher-order) application. In this example, z is added to
* flattenVars.
*/
- api::Sort mkFlatFunctionType(std::vector<api::Sort>& sorts,
- api::Sort range,
- std::vector<api::Term>& flattenVars);
+ cvc5::Sort mkFlatFunctionType(std::vector<cvc5::Sort>& sorts,
+ cvc5::Sort range,
+ std::vector<cvc5::Term>& flattenVars);
/** make flat function type
*
* This is used when the arguments of the function are not important (for
* instance, if we are only using this type in a declare-fun).
*/
- api::Sort mkFlatFunctionType(std::vector<api::Sort>& sorts, api::Sort range);
+ cvc5::Sort mkFlatFunctionType(std::vector<cvc5::Sort>& sorts,
+ cvc5::Sort range);
/** make higher-order apply
*
* for each i where 0 <= i < args.size(). If expr is not of this
* type, the expression returned by this method will not be well typed.
*/
- api::Term mkHoApply(api::Term expr, const std::vector<api::Term>& args);
+ cvc5::Term mkHoApply(cvc5::Term expr, const std::vector<cvc5::Term>& args);
/** Apply type ascription
*
* @param s The sort to ascribe
* @return Term t with sort s ascribed.
*/
- api::Term applyTypeAscription(api::Term t, api::Sort s);
+ cvc5::Term applyTypeAscription(cvc5::Term t, cvc5::Sort s);
/**
* Add an operator to the current legal set.
*
* @param kind the built-in operator to add
*/
- void addOperator(api::Kind kind);
+ void addOperator(cvc5::Kind kind);
/**
* Preempt the next returned command with other ones; used to
* Currently this means its type is either a function, constructor, tester, or
* selector.
*/
- bool isFunctionLike(api::Term fun);
+ bool isFunctionLike(cvc5::Term fun);
/** Is the symbol bound to a predicate? */
bool isPredicate(const std::string& name);
Command* nextCommand();
/** Parse and return the next expression. */
- api::Term nextExpression();
+ cvc5::Term nextExpression();
/** Issue a warning to the user. */
void warning(const std::string& msg) { d_input->warning(msg); }
//------------------------ operator overloading
/** is this function overloaded? */
- bool isOverloadedFunction(api::Term fun)
+ bool isOverloadedFunction(cvc5::Term fun)
{
return d_symtab->isOverloadedFunction(fun);
}
* If possible, it returns a defined symbol with name
* that has type t. Otherwise returns null expression.
*/
- api::Term getOverloadedConstantForType(const std::string& name, api::Sort t)
+ cvc5::Term getOverloadedConstantForType(const std::string& name, cvc5::Sort t)
{
return d_symtab->getOverloadedConstantForType(name, t);
}
* and a vector of expected argument types. Otherwise returns
* null expression.
*/
- api::Term getOverloadedFunctionForTypes(const std::string& name,
- std::vector<api::Sort>& argTypes)
+ cvc5::Term getOverloadedFunctionForTypes(const std::string& name,
+ std::vector<cvc5::Sort>& argTypes)
{
return d_symtab->getOverloadedFunctionForTypes(name, argTypes);
}
* SMT-LIB 2.6 or higher), or otherwise calling the solver to construct
* the string.
*/
- api::Term mkStringConstant(const std::string& s);
+ cvc5::Term mkStringConstant(const std::string& s);
/**
* Make string constant from a single character in hex representation
* This makes the string constant based on the character from the strings,
* represented as a hexadecimal code point.
*/
- api::Term mkCharConstant(const std::string& s);
+ cvc5::Term mkCharConstant(const std::string& s);
/** ad-hoc string escaping
*
namespace cvc5 {
namespace parser {
-ParserBuilder::ParserBuilder(api::Solver* solver,
+ParserBuilder::ParserBuilder(cvc5::Solver* solver,
SymbolManager* sm,
bool useOptions)
: d_solver(solver), d_symman(sm)
}
}
-void ParserBuilder::init(api::Solver* solver, SymbolManager* sm)
+void ParserBuilder::init(cvc5::Solver* solver, SymbolManager* sm)
{
d_lang = "LANG_AUTO";
d_solver = solver;
auto info = d_solver->getOptionInfo("force-logic");
if (info.setByUser)
{
- LogicInfo tmp(info.stringValue());
+ internal::LogicInfo tmp(info.stringValue());
retval = retval.withForcedLogic(tmp.getLogicString());
}
return retval;
namespace cvc5 {
-namespace api {
class Solver;
-}
class Options;
class SymbolManager;
std::string d_lang;
/** The API Solver object. */
- api::Solver* d_solver;
+ cvc5::Solver* d_solver;
/** The symbol manager */
SymbolManager* d_symman;
std::string d_forcedLogic;
/** Initialize this parser builder */
- void init(api::Solver* solver, SymbolManager* sm);
+ void init(cvc5::Solver* solver, SymbolManager* sm);
public:
/** Create a parser builder using the given Solver and filename. */
- ParserBuilder(api::Solver* solver, SymbolManager* sm, bool useOptions);
+ ParserBuilder(cvc5::Solver* solver, SymbolManager* sm, bool useOptions);
/** Build the parser, using the current settings. */
Parser* build();
namespace cvc5 {
namespace parser {
-class CVC5_EXPORT ParserException : public Exception
+class CVC5_EXPORT ParserException : public internal::Exception
{
public:
// Constructors
namespace cvc5 {
- namespace api {
- class Term;
- class Sort;
- }
-
+class Term;
+class Sort;
+
}/* cvc5 namespace */
}/* @parser::includes */
* @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::Term expr = cvc5::Term()]
@declarations {
- cvc5::api::Term expr2;
+ cvc5::Term expr2;
}
: term[expr, expr2]
| EOF
@declarations {
std::string name;
std::vector<std::string> names;
- 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;
+ cvc5::Term expr, expr2;
+ cvc5::Sort t;
+ std::vector<cvc5::Term> terms;
+ std::vector<cvc5::Sort> sorts;
+ std::vector<std::pair<std::string, cvc5::Sort> > sortedVarNames;
+ std::vector<cvc5::Term> flattenVars;
}
: /* set the logic */
SET_LOGIC_TOK symbol[name,CHECK_NONE,SYM_SORT]
<< "' arity=" << n << std::endl;
unsigned arity = AntlrInput::tokenToUnsigned(n);
if(arity == 0) {
- api::Sort type = PARSER_STATE->mkSort(name);
+ cvc5::Sort type = PARSER_STATE->mkSort(name);
cmd->reset(new DeclareSortCommand(name, 0, type));
} else {
- api::Sort type = PARSER_STATE->mkSortConstructor(name, arity);
+ cvc5::Sort type = PARSER_STATE->mkSortConstructor(name, arity);
cmd->reset(new DeclareSortCommand(name, arity, type));
}
}
}
else
{
- api::Term func =
+ cvc5::Term func =
PARSER_STATE->bindVar(name, t, true);
cmd->reset(new DeclareFunctionCommand(name, func, t));
}
Trace("parser") << "define fun: '" << name << "'" << std::endl;
if( sortedVarNames.size() > 0 ) {
sorts.reserve(sortedVarNames.size());
- for(std::vector<std::pair<std::string, api::Sort> >::const_iterator i =
+ for(std::vector<std::pair<std::string, cvc5::Sort> >::const_iterator i =
sortedVarNames.begin(), iend = sortedVarNames.end();
i != iend;
++i) {
if (PARSER_STATE->lastNamedTerm().first == expr)
{
// set the expression name, if there was a named term
- std::pair<api::Term, std::string> namedTerm =
+ std::pair<cvc5::Term, std::string> namedTerm =
PARSER_STATE->lastNamedTerm();
SYM_MAN->setExpressionName(namedTerm.first, namedTerm.second, true);
}
sygusCommand returns [std::unique_ptr<cvc5::Command> cmd]
@declarations {
- cvc5::api::Term expr, expr2, fun;
- cvc5::api::Sort t, range;
+ cvc5::Term expr, expr2, fun;
+ cvc5::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::Sort> > sortedVarNames;
+ std::vector<cvc5::Term> sygusVars;
std::string name;
bool isAssume;
bool isInv;
- cvc5::api::Grammar* grammar = nullptr;
+ cvc5::Grammar* grammar = nullptr;
}
: /* declare-var */
DECLARE_VAR_TOK { PARSER_STATE->checkThatLogicIsSet(); }
{ PARSER_STATE->checkUserSymbol(name); }
sortSymbol[t,CHECK_DECLARED]
{
- api::Term var = SOLVER->declareSygusVar(t, name);
+ cvc5::Term var = SOLVER->declareSygusVar(t, name);
PARSER_STATE->defineVar(name, var);
cmd.reset(new DeclareSygusVarCommand(name, var, t));
}
* 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::Grammar*& ret,
+ const std::vector<cvc5::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::Sort>> sortedVarNames;
// non-terminal symbols of the grammar
- std::vector<cvc5::api::Term> ntSyms;
- cvc5::api::Sort t;
+ std::vector<cvc5::Term> ntSyms;
+ cvc5::Sort t;
std::string name;
- cvc5::api::Term e, e2;
+ cvc5::Term e, e2;
unsigned dtProcessed = 0;
}
:
{
// non-terminal symbols in the pre-declaration are locally scoped
PARSER_STATE->pushScope();
- for (std::pair<std::string, api::Sort>& i : sortedVarNames)
+ for (std::pair<std::string, cvc5::Sort>& i : sortedVarNames)
{
PARSER_STATE->checkDeclaration(name, CHECK_UNDECLARED, SYM_SORT);
// make the non-terminal symbol, which will be parsed as an ordinary
// free variable.
- api::Term nts = PARSER_STATE->bindBoundVar(i.first, i.second);
+ cvc5::Term nts = PARSER_STATE->bindBoundVar(i.first, i.second);
ntSyms.push_back(nts);
}
ret = PARSER_STATE->mkGrammar(sygusVars, ntSyms);
setInfoInternal[std::unique_ptr<cvc5::Command>* cmd]
@declarations {
std::string name;
- api::Term sexpr;
+ cvc5::Term sexpr;
}
: keyword[name] symbolicExpr[sexpr]
{ cmd->reset(new SetInfoCommand(name.c_str() + 1, sexprToString(sexpr))); }
setOptionInternal[std::unique_ptr<cvc5::Command>* cmd]
@init {
std::string name;
- api::Term sexpr;
+ cvc5::Term sexpr;
}
: keyword[name] symbolicExpr[sexpr]
{ cmd->reset(new SetOptionCommand(name.c_str() + 1, sexprToString(sexpr)));
@declarations {
std::string name;
std::string fname;
- cvc5::api::Term expr, expr2;
- std::vector<std::pair<std::string, cvc5::api::Sort> > sortedVarNames;
+ cvc5::Term expr, expr2;
+ std::vector<std::pair<std::string, cvc5::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::Sort t;
+ cvc5::Term func;
+ std::vector<cvc5::Term> bvs;
+ std::vector<std::vector<std::pair<std::string, cvc5::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::vector<std::vector<cvc5::Term>> flattenVarsList;
+ std::vector<std::vector<cvc5::Term>> formals;
+ std::vector<cvc5::Term> funcs;
+ std::vector<cvc5::Term> func_defs;
+ cvc5::Term aexpr;
std::unique_ptr<cvc5::CommandSequence> seq;
- std::vector<api::Sort> sorts;
- std::vector<cvc5::api::Term> flattenVars;
+ std::vector<cvc5::Sort> sorts;
+ std::vector<cvc5::Term> flattenVars;
}
/* declare-const */
: DECLARE_CONST_TOK { PARSER_STATE->checkThatLogicIsSet(); }
PARSER_STATE->parseError("declare-const is not allowed in sygus "
"version 2.0");
}
- api::Term c =
+ cvc5::Term c =
PARSER_STATE->bindVar(name, t, true);
cmd->reset(new DeclareFunctionCommand(name, c, t)); }
extendedCommand[std::unique_ptr<cvc5::Command>* cmd]
@declarations {
- std::vector<api::DatatypeDecl> dts;
- cvc5::api::Term e, e2;
- cvc5::api::Sort t, s;
+ std::vector<cvc5::DatatypeDecl> dts;
+ cvc5::Term e, e2;
+ cvc5::Sort t, s;
std::string name;
std::vector<std::string> names;
- std::vector<cvc5::api::Term> terms;
- std::vector<api::Sort> sorts;
- std::vector<std::pair<std::string, cvc5::api::Sort> > sortedVarNames;
+ std::vector<cvc5::Term> terms;
+ std::vector<cvc5::Sort> sorts;
+ std::vector<std::pair<std::string, cvc5::Sort> > sortedVarNames;
std::unique_ptr<cvc5::CommandSequence> seq;
- api::Grammar* g = nullptr;
+ cvc5::Grammar* g = nullptr;
}
/* Extended SMT-LIB set of commands syntax, not permitted in
* --smtlib2 compliance mode. */
LPAREN_TOK
( symbol[name,CHECK_UNDECLARED,SYM_SORT]
{ PARSER_STATE->checkUserSymbol(name);
- api::Sort type = PARSER_STATE->mkSort(name);
+ cvc5::Sort type = PARSER_STATE->mkSort(name);
seq->addCommand(new DeclareSortCommand(name, 0, type));
}
)+
( LPAREN_TOK symbol[name,CHECK_UNDECLARED,SYM_VARIABLE]
{ PARSER_STATE->checkUserSymbol(name); }
nonemptySortList[sorts] RPAREN_TOK
- { api::Sort tt;
+ { cvc5::Sort tt;
if(sorts.size() > 1) {
PARSER_STATE->checkLogicAllowsFunctions();
// must flatten
- api::Sort range = sorts.back();
+ cvc5::Sort range = sorts.back();
sorts.pop_back();
tt = PARSER_STATE->mkFlatFunctionType(sorts, range);
} else {
tt = sorts[0];
}
// allow overloading
- api::Term func =
+ cvc5::Term func =
PARSER_STATE->bindVar(name, tt, true);
seq->addCommand(new DeclareFunctionCommand(name, func, tt));
sorts.clear();
t = SOLVER->mkFunctionSort(sorts, t);
}
// allow overloading
- api::Term func =
+ cvc5::Term func =
PARSER_STATE->bindVar(name, t, true);
seq->addCommand(new DeclareFunctionCommand(name, func, t));
sorts.clear();
{ terms.push_back( e ); }
)* RPAREN_TOK
{ Trace("parser") << "declare pool: '" << name << "'" << std::endl;
- api::Term pool = SOLVER->declarePool(name, t, terms);
+ cvc5::Term pool = SOLVER->declarePool(name, t, terms);
PARSER_STATE->defineVar(name, pool);
cmd->reset(new DeclarePoolCommand(name, pool, t, terms));
}
datatypeDefCommand[bool isCo, std::unique_ptr<cvc5::Command>* cmd]
@declarations {
- std::vector<api::DatatypeDecl> dts;
+ std::vector<cvc5::DatatypeDecl> dts;
std::string name;
std::vector<std::string> dnames;
std::vector<int> arities;
datatypesDefCommand[bool isCo, std::unique_ptr<cvc5::Command>* cmd]
@declarations {
- std::vector<api::DatatypeDecl> dts;
+ std::vector<cvc5::DatatypeDecl> dts;
std::string name;
std::vector<std::string> dnames;
std::vector<int> arities;
const std::vector<int>& arities,
std::unique_ptr<cvc5::Command>* cmd]
@declarations {
- std::vector<api::DatatypeDecl> dts;
+ std::vector<cvc5::DatatypeDecl> dts;
std::string name;
- std::vector<api::Sort> params;
+ std::vector<cvc5::Sort> params;
}
: { PARSER_STATE->pushScope();
// Declare the datatypes that are currently being defined as unresolved
| KEYWORD { s = AntlrInput::tokenText($KEYWORD); }
;
-symbolicExpr[cvc5::api::Term& sexpr]
+symbolicExpr[cvc5::Term& sexpr]
@declarations {
std::string s;
- std::vector<api::Term> children;
+ std::vector<cvc5::Term> children;
}
: simpleSymbolicExpr[s]
{ 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::SEXPR, children); }
;
/**
* Matches a term.
* @return the expression representing the term.
*/
-term[cvc5::api::Term& expr, cvc5::api::Term& expr2]
+term[cvc5::Term& expr, cvc5::Term& expr2]
@init {
- api::Kind kind = api::NULL_TERM;
- cvc5::api::Term f;
+ cvc5::Kind kind = cvc5::NULL_TERM;
+ cvc5::Term f;
std::string name;
- cvc5::api::Sort type;
+ cvc5::Sort type;
ParseOp p;
}
: termNonVariable[expr, expr2]
* @return the expression expr representing the term or formula, and expr2, an
* optional annotation for expr (for instance, for attributed expressions).
*/
-termNonVariable[cvc5::api::Term& expr, cvc5::api::Term& expr2]
+termNonVariable[cvc5::Term& expr, cvc5::Term& expr2]
@init {
Trace("parser") << "term: " << AntlrInput::tokenText(LT(1)) << std::endl;
- api::Kind kind = api::NULL_TERM;
+ cvc5::Kind kind = cvc5::NULL_TERM;
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::Term> args;
+ std::vector< std::pair<std::string, cvc5::Sort> > sortedVarNames;
+ cvc5::Term bvl;
+ cvc5::Term f, f2, f3;
std::string attr;
- cvc5::api::Term attexpr;
- std::vector<cvc5::api::Term> patexprs;
- std::vector<cvc5::api::Term> matchcases;
+ cvc5::Term attexpr;
+ std::vector<cvc5::Term> patexprs;
+ std::vector<cvc5::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;
- api::Term atomTerm;
+ std::vector< std::pair<std::string, cvc5::Term> > binders;
+ cvc5::Sort type;
+ cvc5::Sort type2;
+ cvc5::Term atomTerm;
ParseOp p;
- std::vector<api::Sort> argTypes;
+ std::vector<cvc5::Sort> argTypes;
}
: LPAREN_TOK quantOp[kind]
{
- if (!PARSER_STATE->isTheoryEnabled(theory::THEORY_QUANTIFIERS))
+ if (!PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_QUANTIFIERS))
{
PARSER_STATE->parseError("Quantifier used in non-quantified logic.");
}
term[f, f2] { args.push_back(f); }
term[f, f2] {
args.push_back(f);
- expr = MK_TERM(api::SET_COMPREHENSION, args);
+ expr = MK_TERM(cvc5::SET_COMPREHENSION, args);
}
RPAREN_TOK
| LPAREN_TOK qualIdentifier[p]
}
binders.push_back(std::make_pair(name, expr)); } )+
{ // now implement these bindings
- for (const std::pair<std::string, api::Term>& binder : binders)
+ for (const std::pair<std::string, cvc5::Term>& binder : binders)
{
{
PARSER_STATE->defineVar(binder.first, binder.second);
{
PARSER_STATE->parseError("Pattern must be application of a constructor or a variable.");
}
- api::Datatype dt = type.getConstructorCodomainSort().getDatatype();
+ cvc5::Datatype dt = type.getConstructorCodomainSort().getDatatype();
if (dt.isParametric())
{
// lookup constructor by name
- api::DatatypeConstructor dc = dt.getConstructor(f.toString());
- api::Term scons = dc.getInstantiatedConstructorTerm(expr.getSort());
+ cvc5::DatatypeConstructor dc = dt.getConstructor(f.toString());
+ cvc5::Term scons = dc.getInstantiatedConstructorTerm(expr.getSort());
// take the type of the specialized constructor instead
type = scons.getSort();
}
PARSER_STATE->parseError("Too many arguments for pattern.");
}
//make of proper type
- api::Term arg = PARSER_STATE->bindBoundVar(name, argTypes[args.size()]);
+ cvc5::Term arg = PARSER_STATE->bindBoundVar(name, argTypes[args.size()]);
args.push_back( arg );
}
)*
RPAREN_TOK term[f3, f2] {
// make the match case
- std::vector<cvc5::api::Term> cargs;
+ std::vector<cvc5::Term> cargs;
cargs.push_back(f);
cargs.insert(cargs.end(),args.begin(),args.end());
- api::Term c = MK_TERM(api::APPLY_CONSTRUCTOR,cargs);
- api::Term bvla = MK_TERM(api::VARIABLE_LIST,args);
- api::Term mc = MK_TERM(api::MATCH_BIND_CASE, bvla, c, f3);
+ cvc5::Term c = MK_TERM(cvc5::APPLY_CONSTRUCTOR,cargs);
+ cvc5::Term bvla = MK_TERM(cvc5::VARIABLE_LIST,args);
+ cvc5::Term mc = MK_TERM(cvc5::MATCH_BIND_CASE, bvla, c, f3);
matchcases.push_back(mc);
// now, pop the scope
PARSER_STATE->popScope();
PARSER_STATE->parseError("Must apply constructors of arity greater than 0 to arguments in pattern.");
}
// make nullary constructor application
- f = MK_TERM(api::APPLY_CONSTRUCTOR, f);
+ f = MK_TERM(cvc5::APPLY_CONSTRUCTOR, f);
}
else
{
}
}
term[f3, f2] {
- api::Term mc;
- if (f.getKind() == api::VARIABLE)
+ cvc5::Term mc;
+ if (f.getKind() == cvc5::VARIABLE)
{
- api::Term bvlf = MK_TERM(api::VARIABLE_LIST, f);
- mc = MK_TERM(api::MATCH_BIND_CASE, bvlf, f, f3);
+ cvc5::Term bvlf = MK_TERM(cvc5::VARIABLE_LIST, f);
+ mc = MK_TERM(cvc5::MATCH_BIND_CASE, bvlf, f, f3);
}
else
{
- mc = MK_TERM(api::MATCH_CASE, f, f3);
+ mc = MK_TERM(cvc5::MATCH_CASE, f, f3);
}
matchcases.push_back(mc);
}
{
PARSER_STATE->parseError("Must have at least one case in match.");
}
- std::vector<api::Term> mchildren;
+ std::vector<cvc5::Term> mchildren;
mchildren.push_back(expr);
mchildren.insert(mchildren.end(), matchcases.begin(), matchcases.end());
- expr = MK_TERM(api::MATCH, mchildren);
+ expr = MK_TERM(cvc5::MATCH, mchildren);
}
/* attributed expressions */
)+ RPAREN_TOK
{
if(! patexprs.empty()) {
- if( !f2.isNull() && f2.getKind()==api::INST_PATTERN_LIST ){
+ if( !f2.isNull() && f2.getKind()==cvc5::INST_PATTERN_LIST ){
for( size_t i=0; i<f2.getNumChildren(); i++ ){
patexprs.push_back( f2[i] );
}
}
- expr2 = MK_TERM(api::INST_PATTERN_LIST, patexprs);
+ expr2 = MK_TERM(cvc5::INST_PATTERN_LIST, patexprs);
} else {
expr2 = f2;
}
args.push_back(bvl);
args.push_back(f);
PARSER_STATE->popScope();
- expr = MK_TERM(api::LAMBDA, args);
+ expr = MK_TERM(cvc5::LAMBDA, args);
}
| LPAREN_TOK TUPLE_CONST_TOK termList[args,expr] RPAREN_TOK
{
- std::vector<api::Sort> sorts;
- std::vector<api::Term> terms;
- for (const api::Term& arg : args)
+ std::vector<cvc5::Sort> sorts;
+ std::vector<cvc5::Term> terms;
+ for (const cvc5::Term& arg : args)
{
sorts.emplace_back(arg.getSort());
terms.emplace_back(arg);
| LPAREN_TOK TUPLE_PROJECT_TOK term[expr,expr2] RPAREN_TOK
{
std::vector<uint32_t> indices;
- api::Op op = SOLVER->mkOp(api::TUPLE_PROJECT, indices);
+ cvc5::Op op = SOLVER->mkOp(cvc5::TUPLE_PROJECT, indices);
expr = SOLVER->mkTerm(op, {expr});
}
| /* an atomic term (a term with no subterms) */
* - For indexed functions like testers (_ is C) and bitvector extract
* (_ extract n m), we return (3) for the appropriate operator.
* - For tuple selectors (_ tuple_select n) and updaters (_ tuple_update n), we
- * return (1) and (3). api::Kind is set to APPLY_SELECTOR or APPLY_UPDATER
+ * return (1) and (3). cvc5::Kind is set to APPLY_SELECTOR or APPLY_UPDATER
* respectively, and expr is set to n, which is to be interpreted by the
* caller as the n^th generic tuple selector or updater. We do this since there
* is no AST expression representing generic tuple select, and we do not have
*/
qualIdentifier[cvc5::ParseOp& p]
@init {
- api::Kind k;
+ cvc5::Kind k;
std::string baseName;
- cvc5::api::Term f;
- cvc5::api::Sort type;
+ cvc5::Term f;
+ cvc5::Sort type;
}
: identifier[p]
| LPAREN_TOK AS_TOK
( CONST_TOK sortSymbol[type, CHECK_DECLARED]
{
- p.d_kind = api::CONST_ARRAY;
+ p.d_kind = cvc5::CONST_ARRAY;
PARSER_STATE->parseOpApplyTypeAscription(p, type);
}
| identifier[p]
*/
identifier[cvc5::ParseOp& p]
@init {
- cvc5::api::Term f;
- cvc5::api::Term f2;
+ cvc5::Term f;
+ cvc5::Term f2;
std::vector<uint32_t> numerals;
}
: functionName[p.d_name, CHECK_NONE]
| LPAREN_TOK INDEX_TOK
( TESTER_TOK term[f, f2]
{
- if (f.getKind() == api::APPLY_CONSTRUCTOR && f.getNumChildren() == 1)
+ if (f.getKind() == cvc5::APPLY_CONSTRUCTOR && f.getNumChildren() == 1)
{
// for nullary constructors, must get the operator
f = f[0];
"Bad syntax for (_ is X), X must be a constructor.");
}
// get the datatype that f belongs to
- api::Sort sf = f.getSort().getConstructorCodomainSort();
- api::Datatype d = sf.getDatatype();
+ cvc5::Sort sf = f.getSort().getConstructorCodomainSort();
+ cvc5::Datatype d = sf.getDatatype();
// lookup by name
- api::DatatypeConstructor dc = d.getConstructor(f.toString());
+ cvc5::DatatypeConstructor dc = d.getConstructor(f.toString());
p.d_expr = dc.getTesterTerm();
}
| UPDATE_TOK term[f, f2]
}
std::string sname = f.toString();
// get the datatype that f belongs to
- api::Sort sf = f.getSort().getSelectorDomainSort();
- api::Datatype d = sf.getDatatype();
+ cvc5::Sort sf = f.getSort().getSelectorDomainSort();
+ cvc5::Datatype d = sf.getDatatype();
// find the selector
- api::DatatypeSelector ds = d.getSelector(f.toString());
+ cvc5::DatatypeSelector ds = d.getSelector(f.toString());
// get the updater term
p.d_expr = ds.getUpdaterTerm();
}
{
// we adopt a special syntax (_ tuple_project i_1 ... i_n) where
// i_1, ..., i_n are numerals
- p.d_kind = api::TUPLE_PROJECT;
- p.d_op = SOLVER->mkOp(api::TUPLE_PROJECT, numerals);
+ p.d_kind = cvc5::TUPLE_PROJECT;
+ p.d_op = SOLVER->mkOp(cvc5::TUPLE_PROJECT, numerals);
}
| sym=SIMPLE_SYMBOL nonemptyNumeralList[numerals]
{
std::string opName = AntlrInput::tokenText($sym);
- api::Kind k = PARSER_STATE->getIndexedOpKind(opName);
- if (k == api::UNDEFINED_KIND)
+ cvc5::Kind k = PARSER_STATE->getIndexedOpKind(opName);
+ if (k == cvc5::UNDEFINED_KIND)
{
// We don't know which kind to use until we know the type of the
// arguments
p.d_name = opName;
p.d_indices = numerals;
- p.d_kind = api::UNDEFINED_KIND;
+ p.d_kind = cvc5::UNDEFINED_KIND;
}
- else if (k == api::APPLY_SELECTOR || k == api::APPLY_UPDATER)
+ else if (k == cvc5::APPLY_SELECTOR || k == cvc5::APPLY_UPDATER)
{
// we adopt a special syntax (_ tuple_select n) and (_ tuple_update n)
// for tuple selectors and updaters
* 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::Term& atomTerm]
@init {
- cvc5::api::Sort t;
+ cvc5::Sort t;
std::string s;
std::vector<uint32_t> numerals;
}
// Empty tuple constant
| TUPLE_CONST_TOK
{
- atomTerm = SOLVER->mkTuple(std::vector<api::Sort>(),
- std::vector<api::Term>());
+ atomTerm = SOLVER->mkTuple(std::vector<cvc5::Sort>(),
+ std::vector<cvc5::Term>());
}
;
/**
* Read attribute
*/
-attribute[cvc5::api::Term& expr, cvc5::api::Term& retExpr]
+attribute[cvc5::Term& expr, cvc5::Term& retExpr]
@init {
- api::Term sexpr;
+ cvc5::Term sexpr;
std::string s;
- cvc5::api::Term patexpr;
- std::vector<cvc5::api::Term> patexprs;
- cvc5::api::Term e2;
+ cvc5::Term patexpr;
+ std::vector<cvc5::Term> patexprs;
+ cvc5::Term e2;
bool hasValue = false;
- api::Kind k;
+ cvc5::Kind k;
}
: KEYWORD ( simpleSymbolicExprNoKeyword[s] { hasValue = true; } )?
{
PARSER_STATE->attributeNotSupported(AntlrInput::tokenText($KEYWORD));
}
- | ( ATTRIBUTE_PATTERN_TOK { k = api::INST_PATTERN; } |
- ATTRIBUTE_POOL_TOK { k = api::INST_POOL; } |
- ATTRIBUTE_INST_ADD_TO_POOL_TOK { k = api::INST_ADD_TO_POOL; } |
- ATTRIBUTE_SKOLEM_ADD_TO_POOL_TOK{ k = api::SKOLEM_ADD_TO_POOL; }
+ | ( ATTRIBUTE_PATTERN_TOK { k = cvc5::INST_PATTERN; } |
+ ATTRIBUTE_POOL_TOK { k = cvc5::INST_POOL; } |
+ ATTRIBUTE_INST_ADD_TO_POOL_TOK { k = cvc5::INST_ADD_TO_POOL; } |
+ ATTRIBUTE_SKOLEM_ADD_TO_POOL_TOK{ k = cvc5::SKOLEM_ADD_TO_POOL; }
)
LPAREN_TOK
( term[patexpr, e2]
}
| ATTRIBUTE_NO_PATTERN_TOK term[patexpr, e2]
{
- retExpr = MK_TERM(api::INST_NO_PATTERN, patexpr);
+ retExpr = MK_TERM(cvc5::INST_NO_PATTERN, patexpr);
}
| tok=( ATTRIBUTE_INST_LEVEL ) INTEGER_LITERAL
{
std::stringstream sIntLit;
sIntLit << $INTEGER_LITERAL;
- api::Term keyword = SOLVER->mkString("quant-inst-max-level");
- api::Term n = SOLVER->mkInteger(sIntLit.str());
- retExpr = MK_TERM(api::INST_ATTRIBUTE, keyword, n);
+ cvc5::Term keyword = SOLVER->mkString("quant-inst-max-level");
+ cvc5::Term n = SOLVER->mkInteger(sIntLit.str());
+ retExpr = MK_TERM(cvc5::INST_ATTRIBUTE, keyword, n);
}
| tok=( ATTRIBUTE_QUANTIFIER_ID_TOK ) symbol[s,CHECK_UNDECLARED,SYM_VARIABLE]
{
- api::Term keyword = SOLVER->mkString("qid");
+ cvc5::Term keyword = SOLVER->mkString("qid");
// must create a variable whose name is the name of the quantified
// formula, not a string.
- api::Term name = SOLVER->mkConst(SOLVER->getBooleanSort(), s);
- retExpr = MK_TERM(api::INST_ATTRIBUTE, keyword, name);
+ cvc5::Term name = SOLVER->mkConst(SOLVER->getBooleanSort(), s);
+ retExpr = MK_TERM(cvc5::INST_ATTRIBUTE, keyword, name);
}
| ATTRIBUTE_NAMED_TOK symbol[s,CHECK_UNDECLARED,SYM_VARIABLE]
{
* 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::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::Term in here just to avoid allocating a fresh cvc5::Term every
* time through this rule. */
-termList[std::vector<cvc5::api::Term>& formulas, cvc5::api::Term& expr]
+termList[std::vector<cvc5::Term>& formulas, cvc5::Term& expr]
@declarations {
- cvc5::api::Term expr2;
+ cvc5::Term expr2;
}
: ( term[expr, expr2] { formulas.push_back(expr); } )+
;
}
;
-quantOp[cvc5::api::Kind& kind]
+quantOp[cvc5::Kind& kind]
@init {
Trace("parser") << "quant: " << AntlrInput::tokenText(LT(1)) << std::endl;
}
- : EXISTS_TOK { $kind = api::EXISTS; }
- | FORALL_TOK { $kind = api::FORALL; }
+ : EXISTS_TOK { $kind = cvc5::EXISTS; }
+ | FORALL_TOK { $kind = cvc5::FORALL; }
;
/**
* Matches a sequence of sort symbols and fills them into the given
* vector.
*/
-sortList[std::vector<cvc5::api::Sort>& sorts]
+sortList[std::vector<cvc5::Sort>& sorts]
@declarations {
- cvc5::api::Sort t;
+ cvc5::Sort t;
}
: ( sortSymbol[t,CHECK_DECLARED] { sorts.push_back(t); } )*
;
-nonemptySortList[std::vector<cvc5::api::Sort>& sorts]
+nonemptySortList[std::vector<cvc5::Sort>& sorts]
@declarations {
- cvc5::api::Sort t;
+ cvc5::Sort t;
}
: ( sortSymbol[t,CHECK_DECLARED] { sorts.push_back(t); } )+
;
* Matches a sequence of (variable,sort) symbol pairs and fills them
* into the given vector.
*/
-sortedVarList[std::vector<std::pair<std::string, cvc5::api::Sort> >& sortedVars]
+sortedVarList[std::vector<std::pair<std::string, cvc5::Sort> >& sortedVars]
@declarations {
std::string name;
- cvc5::api::Sort t;
+ cvc5::Sort t;
}
: ( LPAREN_TOK symbol[name,CHECK_NONE,SYM_VARIABLE]
sortSymbol[t,CHECK_DECLARED] RPAREN_TOK
* Matches a sequence of (variable, sort) symbol pairs, registers them as bound
* variables, and returns a term corresponding to the list of pairs.
*/
-boundVarList[cvc5::api::Term& expr]
+boundVarList[cvc5::Term& expr]
@declarations {
- std::vector<std::pair<std::string, cvc5::api::Sort>> sortedVarNames;
+ std::vector<std::pair<std::string, cvc5::Sort>> sortedVarNames;
}
: LPAREN_TOK sortedVarList[sortedVarNames] RPAREN_TOK
{
- std::vector<cvc5::api::Term> args =
+ std::vector<cvc5::Term> args =
PARSER_STATE->bindBoundVars(sortedVarNames);
- expr = MK_TERM(api::VARIABLE_LIST, args);
+ expr = MK_TERM(cvc5::VARIABLE_LIST, args);
}
;
: symbol[name,check,SYM_SORT]
;
-sortSymbol[cvc5::api::Sort& t, cvc5::parser::DeclarationCheck check]
+sortSymbol[cvc5::Sort& t, cvc5::parser::DeclarationCheck check]
@declarations {
std::string name;
- std::vector<cvc5::api::Sort> args;
+ std::vector<cvc5::Sort> args;
std::vector<uint32_t> numerals;
bool indexed = false;
}
if( numerals.size() != 2 ) {
PARSER_STATE->parseError("Illegal floating-point type.");
}
- if(!validExponentSize(numerals[0])) {
+ if(!internal::validExponentSize(numerals[0])) {
PARSER_STATE->parseError("Illegal floating-point exponent size");
}
- if(!validSignificandSize(numerals[1])) {
+ if(!internal::validSignificandSize(numerals[1])) {
PARSER_STATE->parseError("Illegal floating-point significand size");
}
t = SOLVER->mkFloatingPointSort(numerals[0],numerals[1]);
PARSER_STATE->parseError("Extra parentheses around sort name not "
"permitted in SMT-LIB");
} else if(name == "Array" &&
- PARSER_STATE->isTheoryEnabled(theory::THEORY_ARRAYS) ) {
+ PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_ARRAYS) ) {
if(args.size() != 2) {
PARSER_STATE->parseError("Illegal array type.");
}
t = SOLVER->mkArraySort( args[0], args[1] );
} else if(name == "Set" &&
- PARSER_STATE->isTheoryEnabled(theory::THEORY_SETS) ) {
+ PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_SETS) ) {
if(args.size() != 1) {
PARSER_STATE->parseError("Illegal set type.");
}
t = SOLVER->mkSetSort( args[0] );
}
else if(name == "Bag" &&
- PARSER_STATE->isTheoryEnabled(theory::THEORY_BAGS) ) {
+ PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_BAGS) ) {
if(args.size() != 1) {
PARSER_STATE->parseError("Illegal bag type.");
}
t = SOLVER->mkBagSort( args[0] );
}
else if(name == "Seq" && !PARSER_STATE->strictModeEnabled() &&
- PARSER_STATE->isTheoryEnabled(theory::THEORY_STRINGS) ) {
+ PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_STRINGS) ) {
if(args.size() != 1) {
PARSER_STATE->parseError("Illegal sequence type.");
}
PARSER_STATE->parseError("Arrow types must have at least 2 arguments");
}
//flatten the type
- api::Sort rangeType = args.back();
+ cvc5::Sort rangeType = args.back();
args.pop_back();
t = PARSER_STATE->mkFlatFunctionType( args, rangeType );
}
/**
* 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::DatatypeDecl>& datatypes,
+ std::vector< cvc5::Sort >& params]
@init {
std::string id;
}
/**
* Parses a constructor defintion for type
*/
-constructorDef[cvc5::api::DatatypeDecl& type]
+constructorDef[cvc5::DatatypeDecl& type]
@init {
std::string id;
- cvc5::api::DatatypeConstructorDecl* ctor = NULL;
+ cvc5::DatatypeConstructorDecl* ctor = NULL;
}
: symbol[id,CHECK_NONE,SYM_VARIABLE]
{
- ctor = new api::DatatypeConstructorDecl(
+ ctor = new cvc5::DatatypeConstructorDecl(
SOLVER->mkDatatypeConstructorDecl(id));
}
( LPAREN_TOK selector[*ctor] RPAREN_TOK )*
}
;
-selector[cvc5::api::DatatypeConstructorDecl& ctor]
+selector[cvc5::DatatypeConstructorDecl& ctor]
@init {
std::string id;
- cvc5::api::Sort t, t2;
+ cvc5::Sort t, t2;
}
: symbol[id,CHECK_NONE,SYM_SORT] sortSymbol[t,CHECK_NONE]
{
DECLARE_CODATATYPES_2_5_TOK : { !( PARSER_STATE->v2_6() || PARSER_STATE->sygus() ) }?'declare-codatatypes';
DECLARE_CODATATYPES_TOK : { PARSER_STATE->v2_6() || PARSER_STATE->sygus() }?'declare-codatatypes';
PAR_TOK : { PARSER_STATE->v2_6() || PARSER_STATE->sygus() }?'par';
-SET_COMPREHENSION_TOK : { PARSER_STATE->isTheoryEnabled(theory::THEORY_SETS) }?'set.comprehension';
-TESTER_TOK : { ( PARSER_STATE->v2_6() || PARSER_STATE->sygus() ) && PARSER_STATE->isTheoryEnabled(theory::THEORY_DATATYPES) }?'is';
-UPDATE_TOK : { ( PARSER_STATE->v2_6() || PARSER_STATE->sygus() ) && PARSER_STATE->isTheoryEnabled(theory::THEORY_DATATYPES) }?'update';
-MATCH_TOK : { ( PARSER_STATE->v2_6() || PARSER_STATE->sygus() ) && PARSER_STATE->isTheoryEnabled(theory::THEORY_DATATYPES) }?'match';
+SET_COMPREHENSION_TOK : { PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_SETS) }?'set.comprehension';
+TESTER_TOK : { ( PARSER_STATE->v2_6() || PARSER_STATE->sygus() ) && PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_DATATYPES) }?'is';
+UPDATE_TOK : { ( PARSER_STATE->v2_6() || PARSER_STATE->sygus() ) && PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_DATATYPES) }?'update';
+MATCH_TOK : { ( PARSER_STATE->v2_6() || PARSER_STATE->sygus() ) && PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_DATATYPES) }?'match';
GET_MODEL_TOK : 'get-model';
BLOCK_MODEL_TOK : 'block-model';
BLOCK_MODEL_VALUES_TOK : 'block-model-values';
EXISTS_TOK : 'exists';
FORALL_TOK : 'forall';
-CHAR_TOK : { PARSER_STATE->isTheoryEnabled(theory::THEORY_STRINGS) }? 'char';
-TUPLE_CONST_TOK: { PARSER_STATE->isTheoryEnabled(theory::THEORY_DATATYPES) }? 'tuple';
-TUPLE_PROJECT_TOK: { PARSER_STATE->isTheoryEnabled(theory::THEORY_DATATYPES) }? 'tuple_project';
+CHAR_TOK : { PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_STRINGS) }? 'char';
+TUPLE_CONST_TOK: { PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_DATATYPES) }? 'tuple';
+TUPLE_PROJECT_TOK: { PARSER_STATE->isTheoryEnabled(internal::theory::THEORY_DATATYPES) }? 'tuple_project';
FMF_CARD_TOK: { !PARSER_STATE->strictModeEnabled() && PARSER_STATE->hasCardinalityConstraints() }? 'fmf.card';
HO_ARROW_TOK : { PARSER_STATE->isHoEnabled() }? '->';
namespace cvc5 {
namespace parser {
-Smt2::Smt2(api::Solver* solver,
+Smt2::Smt2(cvc5::Solver* solver,
SymbolManager* sm,
bool strictMode,
bool parseOnly)
Smt2::~Smt2() {}
void Smt2::addArithmeticOperators() {
- addOperator(api::ADD, "+");
- addOperator(api::SUB, "-");
- // api::SUB is converted to api::NEG if there is only a single operand
- Parser::addOperator(api::NEG);
- addOperator(api::MULT, "*");
- addOperator(api::LT, "<");
- addOperator(api::LEQ, "<=");
- addOperator(api::GT, ">");
- addOperator(api::GEQ, ">=");
+ addOperator(cvc5::ADD, "+");
+ addOperator(cvc5::SUB, "-");
+ // cvc5::SUB is converted to cvc5::NEG if there is only a single operand
+ Parser::addOperator(cvc5::NEG);
+ addOperator(cvc5::MULT, "*");
+ addOperator(cvc5::LT, "<");
+ addOperator(cvc5::LEQ, "<=");
+ addOperator(cvc5::GT, ">");
+ addOperator(cvc5::GEQ, ">=");
if (!strictModeEnabled())
{
// NOTE: this operator is non-standard
- addOperator(api::POW, "^");
+ addOperator(cvc5::POW, "^");
}
}
void Smt2::addTranscendentalOperators()
{
- addOperator(api::EXPONENTIAL, "exp");
- addOperator(api::SINE, "sin");
- addOperator(api::COSINE, "cos");
- addOperator(api::TANGENT, "tan");
- addOperator(api::COSECANT, "csc");
- addOperator(api::SECANT, "sec");
- addOperator(api::COTANGENT, "cot");
- addOperator(api::ARCSINE, "arcsin");
- addOperator(api::ARCCOSINE, "arccos");
- addOperator(api::ARCTANGENT, "arctan");
- addOperator(api::ARCCOSECANT, "arccsc");
- addOperator(api::ARCSECANT, "arcsec");
- addOperator(api::ARCCOTANGENT, "arccot");
- addOperator(api::SQRT, "sqrt");
+ addOperator(cvc5::EXPONENTIAL, "exp");
+ addOperator(cvc5::SINE, "sin");
+ addOperator(cvc5::COSINE, "cos");
+ addOperator(cvc5::TANGENT, "tan");
+ addOperator(cvc5::COSECANT, "csc");
+ addOperator(cvc5::SECANT, "sec");
+ addOperator(cvc5::COTANGENT, "cot");
+ addOperator(cvc5::ARCSINE, "arcsin");
+ addOperator(cvc5::ARCCOSINE, "arccos");
+ addOperator(cvc5::ARCTANGENT, "arctan");
+ addOperator(cvc5::ARCCOSECANT, "arccsc");
+ addOperator(cvc5::ARCSECANT, "arcsec");
+ addOperator(cvc5::ARCCOTANGENT, "arccot");
+ addOperator(cvc5::SQRT, "sqrt");
}
void Smt2::addQuantifiersOperators()
}
void Smt2::addBitvectorOperators() {
- addOperator(api::BITVECTOR_CONCAT, "concat");
- addOperator(api::BITVECTOR_NOT, "bvnot");
- addOperator(api::BITVECTOR_AND, "bvand");
- addOperator(api::BITVECTOR_OR, "bvor");
- addOperator(api::BITVECTOR_NEG, "bvneg");
- addOperator(api::BITVECTOR_ADD, "bvadd");
- addOperator(api::BITVECTOR_MULT, "bvmul");
- addOperator(api::BITVECTOR_UDIV, "bvudiv");
- addOperator(api::BITVECTOR_UREM, "bvurem");
- addOperator(api::BITVECTOR_SHL, "bvshl");
- addOperator(api::BITVECTOR_LSHR, "bvlshr");
- addOperator(api::BITVECTOR_ULT, "bvult");
- addOperator(api::BITVECTOR_NAND, "bvnand");
- addOperator(api::BITVECTOR_NOR, "bvnor");
- addOperator(api::BITVECTOR_XOR, "bvxor");
- addOperator(api::BITVECTOR_XNOR, "bvxnor");
- addOperator(api::BITVECTOR_COMP, "bvcomp");
- addOperator(api::BITVECTOR_SUB, "bvsub");
- addOperator(api::BITVECTOR_SDIV, "bvsdiv");
- addOperator(api::BITVECTOR_SREM, "bvsrem");
- addOperator(api::BITVECTOR_SMOD, "bvsmod");
- addOperator(api::BITVECTOR_ASHR, "bvashr");
- addOperator(api::BITVECTOR_ULE, "bvule");
- addOperator(api::BITVECTOR_UGT, "bvugt");
- addOperator(api::BITVECTOR_UGE, "bvuge");
- addOperator(api::BITVECTOR_SLT, "bvslt");
- addOperator(api::BITVECTOR_SLE, "bvsle");
- addOperator(api::BITVECTOR_SGT, "bvsgt");
- addOperator(api::BITVECTOR_SGE, "bvsge");
- addOperator(api::BITVECTOR_REDOR, "bvredor");
- addOperator(api::BITVECTOR_REDAND, "bvredand");
-
- addIndexedOperator(api::BITVECTOR_EXTRACT, "extract");
- addIndexedOperator(api::BITVECTOR_REPEAT, "repeat");
- addIndexedOperator(api::BITVECTOR_ZERO_EXTEND, "zero_extend");
- addIndexedOperator(api::BITVECTOR_SIGN_EXTEND, "sign_extend");
- addIndexedOperator(api::BITVECTOR_ROTATE_LEFT, "rotate_left");
- addIndexedOperator(api::BITVECTOR_ROTATE_RIGHT, "rotate_right");
+ addOperator(cvc5::BITVECTOR_CONCAT, "concat");
+ addOperator(cvc5::BITVECTOR_NOT, "bvnot");
+ addOperator(cvc5::BITVECTOR_AND, "bvand");
+ addOperator(cvc5::BITVECTOR_OR, "bvor");
+ addOperator(cvc5::BITVECTOR_NEG, "bvneg");
+ addOperator(cvc5::BITVECTOR_ADD, "bvadd");
+ addOperator(cvc5::BITVECTOR_MULT, "bvmul");
+ addOperator(cvc5::BITVECTOR_UDIV, "bvudiv");
+ addOperator(cvc5::BITVECTOR_UREM, "bvurem");
+ addOperator(cvc5::BITVECTOR_SHL, "bvshl");
+ addOperator(cvc5::BITVECTOR_LSHR, "bvlshr");
+ addOperator(cvc5::BITVECTOR_ULT, "bvult");
+ addOperator(cvc5::BITVECTOR_NAND, "bvnand");
+ addOperator(cvc5::BITVECTOR_NOR, "bvnor");
+ addOperator(cvc5::BITVECTOR_XOR, "bvxor");
+ addOperator(cvc5::BITVECTOR_XNOR, "bvxnor");
+ addOperator(cvc5::BITVECTOR_COMP, "bvcomp");
+ addOperator(cvc5::BITVECTOR_SUB, "bvsub");
+ addOperator(cvc5::BITVECTOR_SDIV, "bvsdiv");
+ addOperator(cvc5::BITVECTOR_SREM, "bvsrem");
+ addOperator(cvc5::BITVECTOR_SMOD, "bvsmod");
+ addOperator(cvc5::BITVECTOR_ASHR, "bvashr");
+ addOperator(cvc5::BITVECTOR_ULE, "bvule");
+ addOperator(cvc5::BITVECTOR_UGT, "bvugt");
+ addOperator(cvc5::BITVECTOR_UGE, "bvuge");
+ addOperator(cvc5::BITVECTOR_SLT, "bvslt");
+ addOperator(cvc5::BITVECTOR_SLE, "bvsle");
+ addOperator(cvc5::BITVECTOR_SGT, "bvsgt");
+ addOperator(cvc5::BITVECTOR_SGE, "bvsge");
+ addOperator(cvc5::BITVECTOR_REDOR, "bvredor");
+ addOperator(cvc5::BITVECTOR_REDAND, "bvredand");
+
+ addIndexedOperator(cvc5::BITVECTOR_EXTRACT, "extract");
+ addIndexedOperator(cvc5::BITVECTOR_REPEAT, "repeat");
+ addIndexedOperator(cvc5::BITVECTOR_ZERO_EXTEND, "zero_extend");
+ addIndexedOperator(cvc5::BITVECTOR_SIGN_EXTEND, "sign_extend");
+ addIndexedOperator(cvc5::BITVECTOR_ROTATE_LEFT, "rotate_left");
+ addIndexedOperator(cvc5::BITVECTOR_ROTATE_RIGHT, "rotate_right");
}
void Smt2::addDatatypesOperators()
{
- Parser::addOperator(api::APPLY_CONSTRUCTOR);
- Parser::addOperator(api::APPLY_TESTER);
- Parser::addOperator(api::APPLY_SELECTOR);
+ Parser::addOperator(cvc5::APPLY_CONSTRUCTOR);
+ Parser::addOperator(cvc5::APPLY_TESTER);
+ Parser::addOperator(cvc5::APPLY_SELECTOR);
if (!strictModeEnabled())
{
- Parser::addOperator(api::APPLY_UPDATER);
- addOperator(api::DT_SIZE, "dt.size");
+ Parser::addOperator(cvc5::APPLY_UPDATER);
+ addOperator(cvc5::DT_SIZE, "dt.size");
// Notice that tuple operators, we use the generic APPLY_SELECTOR and
// APPLY_UPDATER kinds. These are processed based on the context
// in which they are parsed, e.g. when parsing identifiers.
- addIndexedOperator(api::APPLY_SELECTOR, "tuple_select");
- addIndexedOperator(api::APPLY_UPDATER, "tuple_update");
+ addIndexedOperator(cvc5::APPLY_SELECTOR, "tuple_select");
+ addIndexedOperator(cvc5::APPLY_UPDATER, "tuple_update");
}
}
void Smt2::addStringOperators() {
defineVar("re.all", getSolver()->mkRegexpAll());
- addOperator(api::STRING_CONCAT, "str.++");
- addOperator(api::STRING_LENGTH, "str.len");
- addOperator(api::STRING_SUBSTR, "str.substr");
- addOperator(api::STRING_CONTAINS, "str.contains");
- addOperator(api::STRING_CHARAT, "str.at");
- addOperator(api::STRING_INDEXOF, "str.indexof");
- addOperator(api::STRING_REPLACE, "str.replace");
- addOperator(api::STRING_PREFIX, "str.prefixof");
- addOperator(api::STRING_SUFFIX, "str.suffixof");
- addOperator(api::STRING_FROM_CODE, "str.from_code");
- addOperator(api::STRING_IS_DIGIT, "str.is_digit");
- addOperator(api::STRING_REPLACE_RE, "str.replace_re");
- addOperator(api::STRING_REPLACE_RE_ALL, "str.replace_re_all");
+ addOperator(cvc5::STRING_CONCAT, "str.++");
+ addOperator(cvc5::STRING_LENGTH, "str.len");
+ addOperator(cvc5::STRING_SUBSTR, "str.substr");
+ addOperator(cvc5::STRING_CONTAINS, "str.contains");
+ addOperator(cvc5::STRING_CHARAT, "str.at");
+ addOperator(cvc5::STRING_INDEXOF, "str.indexof");
+ addOperator(cvc5::STRING_REPLACE, "str.replace");
+ addOperator(cvc5::STRING_PREFIX, "str.prefixof");
+ addOperator(cvc5::STRING_SUFFIX, "str.suffixof");
+ addOperator(cvc5::STRING_FROM_CODE, "str.from_code");
+ addOperator(cvc5::STRING_IS_DIGIT, "str.is_digit");
+ addOperator(cvc5::STRING_REPLACE_RE, "str.replace_re");
+ addOperator(cvc5::STRING_REPLACE_RE_ALL, "str.replace_re_all");
if (!strictModeEnabled())
{
- addOperator(api::STRING_INDEXOF_RE, "str.indexof_re");
- addOperator(api::STRING_UPDATE, "str.update");
- addOperator(api::STRING_TO_LOWER, "str.to_lower");
- addOperator(api::STRING_TO_UPPER, "str.to_upper");
- addOperator(api::STRING_REV, "str.rev");
+ addOperator(cvc5::STRING_INDEXOF_RE, "str.indexof_re");
+ addOperator(cvc5::STRING_UPDATE, "str.update");
+ addOperator(cvc5::STRING_TO_LOWER, "str.to_lower");
+ addOperator(cvc5::STRING_TO_UPPER, "str.to_upper");
+ addOperator(cvc5::STRING_REV, "str.rev");
// sequence versions
- addOperator(api::SEQ_CONCAT, "seq.++");
- addOperator(api::SEQ_LENGTH, "seq.len");
- addOperator(api::SEQ_EXTRACT, "seq.extract");
- addOperator(api::SEQ_UPDATE, "seq.update");
- addOperator(api::SEQ_AT, "seq.at");
- addOperator(api::SEQ_CONTAINS, "seq.contains");
- addOperator(api::SEQ_INDEXOF, "seq.indexof");
- addOperator(api::SEQ_REPLACE, "seq.replace");
- addOperator(api::SEQ_PREFIX, "seq.prefixof");
- addOperator(api::SEQ_SUFFIX, "seq.suffixof");
- addOperator(api::SEQ_REV, "seq.rev");
- addOperator(api::SEQ_REPLACE_ALL, "seq.replace_all");
- addOperator(api::SEQ_UNIT, "seq.unit");
- addOperator(api::SEQ_NTH, "seq.nth");
+ addOperator(cvc5::SEQ_CONCAT, "seq.++");
+ addOperator(cvc5::SEQ_LENGTH, "seq.len");
+ addOperator(cvc5::SEQ_EXTRACT, "seq.extract");
+ addOperator(cvc5::SEQ_UPDATE, "seq.update");
+ addOperator(cvc5::SEQ_AT, "seq.at");
+ addOperator(cvc5::SEQ_CONTAINS, "seq.contains");
+ addOperator(cvc5::SEQ_INDEXOF, "seq.indexof");
+ addOperator(cvc5::SEQ_REPLACE, "seq.replace");
+ addOperator(cvc5::SEQ_PREFIX, "seq.prefixof");
+ addOperator(cvc5::SEQ_SUFFIX, "seq.suffixof");
+ addOperator(cvc5::SEQ_REV, "seq.rev");
+ addOperator(cvc5::SEQ_REPLACE_ALL, "seq.replace_all");
+ addOperator(cvc5::SEQ_UNIT, "seq.unit");
+ addOperator(cvc5::SEQ_NTH, "seq.nth");
}
- addOperator(api::STRING_FROM_INT, "str.from_int");
- addOperator(api::STRING_TO_INT, "str.to_int");
- addOperator(api::STRING_IN_REGEXP, "str.in_re");
- addOperator(api::STRING_TO_REGEXP, "str.to_re");
- addOperator(api::STRING_TO_CODE, "str.to_code");
- addOperator(api::STRING_REPLACE_ALL, "str.replace_all");
-
- addOperator(api::REGEXP_CONCAT, "re.++");
- addOperator(api::REGEXP_UNION, "re.union");
- addOperator(api::REGEXP_INTER, "re.inter");
- addOperator(api::REGEXP_STAR, "re.*");
- addOperator(api::REGEXP_PLUS, "re.+");
- addOperator(api::REGEXP_OPT, "re.opt");
- addIndexedOperator(api::REGEXP_REPEAT, "re.^");
- addIndexedOperator(api::REGEXP_LOOP, "re.loop");
- addOperator(api::REGEXP_RANGE, "re.range");
- addOperator(api::REGEXP_COMPLEMENT, "re.comp");
- addOperator(api::REGEXP_DIFF, "re.diff");
- addOperator(api::STRING_LT, "str.<");
- addOperator(api::STRING_LEQ, "str.<=");
+ addOperator(cvc5::STRING_FROM_INT, "str.from_int");
+ addOperator(cvc5::STRING_TO_INT, "str.to_int");
+ addOperator(cvc5::STRING_IN_REGEXP, "str.in_re");
+ addOperator(cvc5::STRING_TO_REGEXP, "str.to_re");
+ addOperator(cvc5::STRING_TO_CODE, "str.to_code");
+ addOperator(cvc5::STRING_REPLACE_ALL, "str.replace_all");
+
+ addOperator(cvc5::REGEXP_CONCAT, "re.++");
+ addOperator(cvc5::REGEXP_UNION, "re.union");
+ addOperator(cvc5::REGEXP_INTER, "re.inter");
+ addOperator(cvc5::REGEXP_STAR, "re.*");
+ addOperator(cvc5::REGEXP_PLUS, "re.+");
+ addOperator(cvc5::REGEXP_OPT, "re.opt");
+ addIndexedOperator(cvc5::REGEXP_REPEAT, "re.^");
+ addIndexedOperator(cvc5::REGEXP_LOOP, "re.loop");
+ addOperator(cvc5::REGEXP_RANGE, "re.range");
+ addOperator(cvc5::REGEXP_COMPLEMENT, "re.comp");
+ addOperator(cvc5::REGEXP_DIFF, "re.diff");
+ addOperator(cvc5::STRING_LT, "str.<");
+ addOperator(cvc5::STRING_LEQ, "str.<=");
}
void Smt2::addFloatingPointOperators() {
- addOperator(api::FLOATINGPOINT_FP, "fp");
- addOperator(api::FLOATINGPOINT_EQ, "fp.eq");
- addOperator(api::FLOATINGPOINT_ABS, "fp.abs");
- addOperator(api::FLOATINGPOINT_NEG, "fp.neg");
- addOperator(api::FLOATINGPOINT_ADD, "fp.add");
- addOperator(api::FLOATINGPOINT_SUB, "fp.sub");
- addOperator(api::FLOATINGPOINT_MULT, "fp.mul");
- addOperator(api::FLOATINGPOINT_DIV, "fp.div");
- addOperator(api::FLOATINGPOINT_FMA, "fp.fma");
- addOperator(api::FLOATINGPOINT_SQRT, "fp.sqrt");
- addOperator(api::FLOATINGPOINT_REM, "fp.rem");
- addOperator(api::FLOATINGPOINT_RTI, "fp.roundToIntegral");
- addOperator(api::FLOATINGPOINT_MIN, "fp.min");
- addOperator(api::FLOATINGPOINT_MAX, "fp.max");
- addOperator(api::FLOATINGPOINT_LEQ, "fp.leq");
- addOperator(api::FLOATINGPOINT_LT, "fp.lt");
- addOperator(api::FLOATINGPOINT_GEQ, "fp.geq");
- addOperator(api::FLOATINGPOINT_GT, "fp.gt");
- addOperator(api::FLOATINGPOINT_IS_NORMAL, "fp.isNormal");
- addOperator(api::FLOATINGPOINT_IS_SUBNORMAL, "fp.isSubnormal");
- addOperator(api::FLOATINGPOINT_IS_ZERO, "fp.isZero");
- addOperator(api::FLOATINGPOINT_IS_INF, "fp.isInfinite");
- addOperator(api::FLOATINGPOINT_IS_NAN, "fp.isNaN");
- addOperator(api::FLOATINGPOINT_IS_NEG, "fp.isNegative");
- addOperator(api::FLOATINGPOINT_IS_POS, "fp.isPositive");
- addOperator(api::FLOATINGPOINT_TO_REAL, "fp.to_real");
-
- addIndexedOperator(api::UNDEFINED_KIND, "to_fp");
- addIndexedOperator(api::FLOATINGPOINT_TO_FP_FROM_UBV, "to_fp_unsigned");
- addIndexedOperator(api::FLOATINGPOINT_TO_UBV, "fp.to_ubv");
- addIndexedOperator(api::FLOATINGPOINT_TO_SBV, "fp.to_sbv");
+ addOperator(cvc5::FLOATINGPOINT_FP, "fp");
+ addOperator(cvc5::FLOATINGPOINT_EQ, "fp.eq");
+ addOperator(cvc5::FLOATINGPOINT_ABS, "fp.abs");
+ addOperator(cvc5::FLOATINGPOINT_NEG, "fp.neg");
+ addOperator(cvc5::FLOATINGPOINT_ADD, "fp.add");
+ addOperator(cvc5::FLOATINGPOINT_SUB, "fp.sub");
+ addOperator(cvc5::FLOATINGPOINT_MULT, "fp.mul");
+ addOperator(cvc5::FLOATINGPOINT_DIV, "fp.div");
+ addOperator(cvc5::FLOATINGPOINT_FMA, "fp.fma");
+ addOperator(cvc5::FLOATINGPOINT_SQRT, "fp.sqrt");
+ addOperator(cvc5::FLOATINGPOINT_REM, "fp.rem");
+ addOperator(cvc5::FLOATINGPOINT_RTI, "fp.roundToIntegral");
+ addOperator(cvc5::FLOATINGPOINT_MIN, "fp.min");
+ addOperator(cvc5::FLOATINGPOINT_MAX, "fp.max");
+ addOperator(cvc5::FLOATINGPOINT_LEQ, "fp.leq");
+ addOperator(cvc5::FLOATINGPOINT_LT, "fp.lt");
+ addOperator(cvc5::FLOATINGPOINT_GEQ, "fp.geq");
+ addOperator(cvc5::FLOATINGPOINT_GT, "fp.gt");
+ addOperator(cvc5::FLOATINGPOINT_IS_NORMAL, "fp.isNormal");
+ addOperator(cvc5::FLOATINGPOINT_IS_SUBNORMAL, "fp.isSubnormal");
+ addOperator(cvc5::FLOATINGPOINT_IS_ZERO, "fp.isZero");
+ addOperator(cvc5::FLOATINGPOINT_IS_INF, "fp.isInfinite");
+ addOperator(cvc5::FLOATINGPOINT_IS_NAN, "fp.isNaN");
+ addOperator(cvc5::FLOATINGPOINT_IS_NEG, "fp.isNegative");
+ addOperator(cvc5::FLOATINGPOINT_IS_POS, "fp.isPositive");
+ addOperator(cvc5::FLOATINGPOINT_TO_REAL, "fp.to_real");
+
+ addIndexedOperator(cvc5::UNDEFINED_KIND, "to_fp");
+ addIndexedOperator(cvc5::FLOATINGPOINT_TO_FP_FROM_UBV, "to_fp_unsigned");
+ addIndexedOperator(cvc5::FLOATINGPOINT_TO_UBV, "fp.to_ubv");
+ addIndexedOperator(cvc5::FLOATINGPOINT_TO_SBV, "fp.to_sbv");
if (!strictModeEnabled())
{
- addIndexedOperator(api::FLOATINGPOINT_TO_FP_FROM_IEEE_BV, "to_fp_bv");
- addIndexedOperator(api::FLOATINGPOINT_TO_FP_FROM_FP, "to_fp_fp");
- addIndexedOperator(api::FLOATINGPOINT_TO_FP_FROM_REAL, "to_fp_real");
- addIndexedOperator(api::FLOATINGPOINT_TO_FP_FROM_SBV, "to_fp_signed");
+ addIndexedOperator(cvc5::FLOATINGPOINT_TO_FP_FROM_IEEE_BV, "to_fp_bv");
+ addIndexedOperator(cvc5::FLOATINGPOINT_TO_FP_FROM_FP, "to_fp_fp");
+ addIndexedOperator(cvc5::FLOATINGPOINT_TO_FP_FROM_REAL, "to_fp_real");
+ addIndexedOperator(cvc5::FLOATINGPOINT_TO_FP_FROM_SBV, "to_fp_signed");
}
}
// the Boolean sort is a placeholder here since we don't have type info
// without type annotation
defineVar("sep.nil", d_solver->mkSepNil(d_solver->getBooleanSort()));
- addOperator(api::SEP_STAR, "sep");
- addOperator(api::SEP_PTO, "pto");
- addOperator(api::SEP_WAND, "wand");
- Parser::addOperator(api::SEP_STAR);
- Parser::addOperator(api::SEP_PTO);
- Parser::addOperator(api::SEP_WAND);
+ addOperator(cvc5::SEP_STAR, "sep");
+ addOperator(cvc5::SEP_PTO, "pto");
+ addOperator(cvc5::SEP_WAND, "wand");
+ Parser::addOperator(cvc5::SEP_STAR);
+ Parser::addOperator(cvc5::SEP_PTO);
+ Parser::addOperator(cvc5::SEP_WAND);
}
void Smt2::addCoreSymbols()
defineType("Bool", d_solver->getBooleanSort(), true);
defineVar("true", d_solver->mkTrue(), true);
defineVar("false", d_solver->mkFalse(), true);
- addOperator(api::AND, "and");
- addOperator(api::DISTINCT, "distinct");
- addOperator(api::EQUAL, "=");
- addOperator(api::IMPLIES, "=>");
- addOperator(api::ITE, "ite");
- addOperator(api::NOT, "not");
- addOperator(api::OR, "or");
- addOperator(api::XOR, "xor");
+ addOperator(cvc5::AND, "and");
+ addOperator(cvc5::DISTINCT, "distinct");
+ addOperator(cvc5::EQUAL, "=");
+ addOperator(cvc5::IMPLIES, "=>");
+ addOperator(cvc5::ITE, "ite");
+ addOperator(cvc5::NOT, "not");
+ addOperator(cvc5::OR, "or");
+ addOperator(cvc5::XOR, "xor");
}
-void Smt2::addOperator(api::Kind kind, const std::string& name)
+void Smt2::addOperator(cvc5::Kind kind, const std::string& name)
{
Trace("parser") << "Smt2::addOperator( " << kind << ", " << name << " )"
<< std::endl;
d_operatorKindMap[name] = kind;
}
-void Smt2::addIndexedOperator(api::Kind tKind,
- const std::string& name)
+void Smt2::addIndexedOperator(cvc5::Kind tKind, const std::string& name)
{
Parser::addOperator(tKind);
d_indexedOpKindMap[name] = tKind;
return d_indexedOpKindMap.find(name) != d_indexedOpKindMap.end();
}
-api::Kind Smt2::getOperatorKind(const std::string& name) const
+cvc5::Kind Smt2::getOperatorKind(const std::string& name) const
{
// precondition: isOperatorEnabled(name)
return d_operatorKindMap.find(name)->second;
return d_operatorKindMap.find(name) != d_operatorKindMap.end();
}
-bool Smt2::isTheoryEnabled(theory::TheoryId theory) const
+bool Smt2::isTheoryEnabled(internal::theory::TheoryId theory) const
{
return d_logic.isTheoryEnabled(theory);
}
return d_logicSet;
}
-bool Smt2::getTesterName(api::Term cons, std::string& name)
+bool Smt2::getTesterName(cvc5::Term cons, std::string& name)
{
if ((v2_6() || sygus()) && strictModeEnabled())
{
return true;
}
-api::Term Smt2::mkIndexedConstant(const std::string& name,
- const std::vector<uint32_t>& numerals)
+cvc5::Term Smt2::mkIndexedConstant(const std::string& name,
+ const std::vector<uint32_t>& numerals)
{
- if (d_logic.isTheoryEnabled(theory::THEORY_FP))
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_FP))
{
if (name == "+oo")
{
}
}
- if (d_logic.isTheoryEnabled(theory::THEORY_BV) && name.find("bv") == 0)
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_BV)
+ && name.find("bv") == 0)
{
std::string bvStr = name.substr(2);
return d_solver->mkBitVector(numerals[0], bvStr, 10);
// NOTE: Theory parametric constants go here
parseError(std::string("Unknown indexed literal `") + name + "'");
- return api::Term();
+ return cvc5::Term();
}
-api::Kind Smt2::getIndexedOpKind(const std::string& name)
+cvc5::Kind Smt2::getIndexedOpKind(const std::string& name)
{
const auto& kIt = d_indexedOpKindMap.find(name);
if (kIt != d_indexedOpKindMap.end())
return (*kIt).second;
}
parseError(std::string("Unknown indexed function `") + name + "'");
- return api::UNDEFINED_KIND;
+ return cvc5::UNDEFINED_KIND;
}
-api::Term Smt2::bindDefineFunRec(
+cvc5::Term Smt2::bindDefineFunRec(
const std::string& fname,
- const std::vector<std::pair<std::string, api::Sort>>& sortedVarNames,
- api::Sort t,
- std::vector<api::Term>& flattenVars)
+ const std::vector<std::pair<std::string, cvc5::Sort>>& sortedVarNames,
+ cvc5::Sort t,
+ std::vector<cvc5::Term>& flattenVars)
{
- std::vector<api::Sort> sorts;
- for (const std::pair<std::string, api::Sort>& svn : sortedVarNames)
+ std::vector<cvc5::Sort> sorts;
+ for (const std::pair<std::string, cvc5::Sort>& svn : sortedVarNames)
{
sorts.push_back(svn.second);
}
// make the flattened function type, add bound variables
// to flattenVars if the defined function was given a function return type.
- api::Sort ft = mkFlatFunctionType(sorts, t, flattenVars);
+ cvc5::Sort ft = mkFlatFunctionType(sorts, t, flattenVars);
// allow overloading
return bindVar(fname, ft, true);
}
void Smt2::pushDefineFunRecScope(
- const std::vector<std::pair<std::string, api::Sort>>& sortedVarNames,
- api::Term func,
- const std::vector<api::Term>& flattenVars,
- std::vector<api::Term>& bvs)
+ const std::vector<std::pair<std::string, cvc5::Sort>>& sortedVarNames,
+ cvc5::Term func,
+ const std::vector<cvc5::Term>& flattenVars,
+ std::vector<cvc5::Term>& bvs)
{
pushScope();
// bound variables are those that are explicitly named in the preamble
// of the define-fun(s)-rec command, we define them here
- for (const std::pair<std::string, api::Sort>& svn : sortedVarNames)
+ for (const std::pair<std::string, cvc5::Sort>& svn : sortedVarNames)
{
- api::Term v = bindBoundVar(svn.first, svn.second);
+ cvc5::Term v = bindBoundVar(svn.first, svn.second);
bvs.push_back(v);
}
void Smt2::reset() {
d_logicSet = false;
d_seenSetLogic = false;
- d_logic = LogicInfo();
+ d_logic = internal::LogicInfo();
d_operatorKindMap.clear();
- d_lastNamedTerm = std::pair<api::Term, std::string>();
+ d_lastNamedTerm = std::pair<cvc5::Term, std::string>();
}
std::unique_ptr<Command> Smt2::invConstraint(
"arguments.");
}
- std::vector<api::Term> terms;
+ std::vector<cvc5::Term> terms;
for (const std::string& name : names)
{
if (!isDeclared(name))
// Core theory belongs to every logic
addCoreSymbols();
- if(d_logic.isTheoryEnabled(theory::THEORY_UF)) {
- Parser::addOperator(api::APPLY_UF);
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_UF))
+ {
+ Parser::addOperator(cvc5::APPLY_UF);
}
if (d_logic.isHigherOrder())
{
- addOperator(api::HO_APPLY, "@");
+ addOperator(cvc5::HO_APPLY, "@");
}
- if(d_logic.isTheoryEnabled(theory::THEORY_ARITH)) {
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_ARITH))
+ {
if(d_logic.areIntegersUsed()) {
defineType("Int", d_solver->getIntegerSort(), true);
addArithmeticOperators();
if (!strictModeEnabled() || !d_logic.isLinear())
{
- addOperator(api::INTS_DIVISION, "div");
- addOperator(api::INTS_MODULUS, "mod");
- addOperator(api::ABS, "abs");
+ addOperator(cvc5::INTS_DIVISION, "div");
+ addOperator(cvc5::INTS_MODULUS, "mod");
+ addOperator(cvc5::ABS, "abs");
}
- addIndexedOperator(api::DIVISIBLE, "divisible");
+ addIndexedOperator(cvc5::DIVISIBLE, "divisible");
}
if (d_logic.areRealsUsed())
{
defineType("Real", d_solver->getRealSort(), true);
addArithmeticOperators();
- addOperator(api::DIVISION, "/");
+ addOperator(cvc5::DIVISION, "/");
if (!strictModeEnabled())
{
- addOperator(api::ABS, "abs");
+ addOperator(cvc5::ABS, "abs");
}
}
if (d_logic.areIntegersUsed() && d_logic.areRealsUsed())
{
- addOperator(api::TO_INTEGER, "to_int");
- addOperator(api::IS_INTEGER, "is_int");
- addOperator(api::TO_REAL, "to_real");
+ addOperator(cvc5::TO_INTEGER, "to_int");
+ addOperator(cvc5::IS_INTEGER, "is_int");
+ addOperator(cvc5::TO_REAL, "to_real");
}
if (d_logic.areTranscendentalsUsed())
if (!strictModeEnabled())
{
// integer version of AND
- addIndexedOperator(api::IAND, "iand");
+ addIndexedOperator(cvc5::IAND, "iand");
// pow2
- addOperator(api::POW2, "int.pow2");
+ addOperator(cvc5::POW2, "int.pow2");
}
}
- if(d_logic.isTheoryEnabled(theory::THEORY_ARRAYS)) {
- addOperator(api::SELECT, "select");
- addOperator(api::STORE, "store");
- addOperator(api::EQ_RANGE, "eqrange");
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_ARRAYS))
+ {
+ addOperator(cvc5::SELECT, "select");
+ addOperator(cvc5::STORE, "store");
+ addOperator(cvc5::EQ_RANGE, "eqrange");
}
- if(d_logic.isTheoryEnabled(theory::THEORY_BV)) {
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_BV))
+ {
addBitvectorOperators();
- if (!strictModeEnabled() && d_logic.isTheoryEnabled(theory::THEORY_ARITH)
+ if (!strictModeEnabled()
+ && d_logic.isTheoryEnabled(internal::theory::THEORY_ARITH)
&& d_logic.areIntegersUsed())
{
// Conversions between bit-vectors and integers
- addOperator(api::BITVECTOR_TO_NAT, "bv2nat");
- addIndexedOperator(api::INT_TO_BITVECTOR, "int2bv");
+ addOperator(cvc5::BITVECTOR_TO_NAT, "bv2nat");
+ addIndexedOperator(cvc5::INT_TO_BITVECTOR, "int2bv");
}
}
- if(d_logic.isTheoryEnabled(theory::THEORY_DATATYPES)) {
- const std::vector<api::Sort> types;
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_DATATYPES))
+ {
+ const std::vector<cvc5::Sort> types;
defineType("Tuple", d_solver->mkTupleSort(types), true);
addDatatypesOperators();
}
- if(d_logic.isTheoryEnabled(theory::THEORY_SETS)) {
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_SETS))
+ {
defineVar("set.empty", d_solver->mkEmptySet(d_solver->getNullSort()));
// the Boolean sort is a placeholder here since we don't have type info
// without type annotation
defineVar("set.universe",
d_solver->mkUniverseSet(d_solver->getBooleanSort()));
- addOperator(api::SET_UNION, "set.union");
- addOperator(api::SET_INTER, "set.inter");
- addOperator(api::SET_MINUS, "set.minus");
- addOperator(api::SET_SUBSET, "set.subset");
- addOperator(api::SET_MEMBER, "set.member");
- addOperator(api::SET_SINGLETON, "set.singleton");
- addOperator(api::SET_INSERT, "set.insert");
- addOperator(api::SET_CARD, "set.card");
- addOperator(api::SET_COMPLEMENT, "set.complement");
- addOperator(api::SET_CHOOSE, "set.choose");
- addOperator(api::SET_IS_SINGLETON, "set.is_singleton");
- addOperator(api::SET_MAP, "set.map");
- addOperator(api::RELATION_JOIN, "rel.join");
- addOperator(api::RELATION_PRODUCT, "rel.product");
- addOperator(api::RELATION_TRANSPOSE, "rel.transpose");
- addOperator(api::RELATION_TCLOSURE, "rel.tclosure");
- addOperator(api::RELATION_JOIN_IMAGE, "rel.join_image");
- addOperator(api::RELATION_IDEN, "rel.iden");
+ addOperator(cvc5::SET_UNION, "set.union");
+ addOperator(cvc5::SET_INTER, "set.inter");
+ addOperator(cvc5::SET_MINUS, "set.minus");
+ addOperator(cvc5::SET_SUBSET, "set.subset");
+ addOperator(cvc5::SET_MEMBER, "set.member");
+ addOperator(cvc5::SET_SINGLETON, "set.singleton");
+ addOperator(cvc5::SET_INSERT, "set.insert");
+ addOperator(cvc5::SET_CARD, "set.card");
+ addOperator(cvc5::SET_COMPLEMENT, "set.complement");
+ addOperator(cvc5::SET_CHOOSE, "set.choose");
+ addOperator(cvc5::SET_IS_SINGLETON, "set.is_singleton");
+ addOperator(cvc5::SET_MAP, "set.map");
+ addOperator(cvc5::RELATION_JOIN, "rel.join");
+ addOperator(cvc5::RELATION_PRODUCT, "rel.product");
+ addOperator(cvc5::RELATION_TRANSPOSE, "rel.transpose");
+ addOperator(cvc5::RELATION_TCLOSURE, "rel.tclosure");
+ addOperator(cvc5::RELATION_JOIN_IMAGE, "rel.join_image");
+ addOperator(cvc5::RELATION_IDEN, "rel.iden");
}
- if (d_logic.isTheoryEnabled(theory::THEORY_BAGS))
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_BAGS))
{
defineVar("bag.empty", d_solver->mkEmptyBag(d_solver->getNullSort()));
- addOperator(api::BAG_UNION_MAX, "bag.union_max");
- addOperator(api::BAG_UNION_DISJOINT, "bag.union_disjoint");
- addOperator(api::BAG_INTER_MIN, "bag.inter_min");
- addOperator(api::BAG_DIFFERENCE_SUBTRACT, "bag.difference_subtract");
- addOperator(api::BAG_DIFFERENCE_REMOVE, "bag.difference_remove");
- addOperator(api::BAG_SUBBAG, "bag.subbag");
- addOperator(api::BAG_COUNT, "bag.count");
- addOperator(api::BAG_MEMBER, "bag.member");
- addOperator(api::BAG_DUPLICATE_REMOVAL, "bag.duplicate_removal");
- addOperator(api::BAG_MAKE, "bag");
- addOperator(api::BAG_CARD, "bag.card");
- addOperator(api::BAG_CHOOSE, "bag.choose");
- addOperator(api::BAG_IS_SINGLETON, "bag.is_singleton");
- addOperator(api::BAG_FROM_SET, "bag.from_set");
- addOperator(api::BAG_TO_SET, "bag.to_set");
- addOperator(api::BAG_MAP, "bag.map");
- addOperator(api::BAG_FILTER, "bag.filter");
- addOperator(api::BAG_FOLD, "bag.fold");
- addOperator(api::TABLE_PRODUCT, "table.product");
+ addOperator(cvc5::BAG_UNION_MAX, "bag.union_max");
+ addOperator(cvc5::BAG_UNION_DISJOINT, "bag.union_disjoint");
+ addOperator(cvc5::BAG_INTER_MIN, "bag.inter_min");
+ addOperator(cvc5::BAG_DIFFERENCE_SUBTRACT, "bag.difference_subtract");
+ addOperator(cvc5::BAG_DIFFERENCE_REMOVE, "bag.difference_remove");
+ addOperator(cvc5::BAG_SUBBAG, "bag.subbag");
+ addOperator(cvc5::BAG_COUNT, "bag.count");
+ addOperator(cvc5::BAG_MEMBER, "bag.member");
+ addOperator(cvc5::BAG_DUPLICATE_REMOVAL, "bag.duplicate_removal");
+ addOperator(cvc5::BAG_MAKE, "bag");
+ addOperator(cvc5::BAG_CARD, "bag.card");
+ addOperator(cvc5::BAG_CHOOSE, "bag.choose");
+ addOperator(cvc5::BAG_IS_SINGLETON, "bag.is_singleton");
+ addOperator(cvc5::BAG_FROM_SET, "bag.from_set");
+ addOperator(cvc5::BAG_TO_SET, "bag.to_set");
+ addOperator(cvc5::BAG_MAP, "bag.map");
+ addOperator(cvc5::BAG_FILTER, "bag.filter");
+ addOperator(cvc5::BAG_FOLD, "bag.fold");
+ addOperator(cvc5::TABLE_PRODUCT, "table.product");
}
- if(d_logic.isTheoryEnabled(theory::THEORY_STRINGS)) {
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_STRINGS))
+ {
defineType("String", d_solver->getStringSort(), true);
defineType("RegLan", d_solver->getRegExpSort(), true);
defineType("Int", d_solver->getIntegerSort(), true);
addQuantifiersOperators();
}
- if (d_logic.isTheoryEnabled(theory::THEORY_FP)) {
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_FP))
+ {
defineType("RoundingMode", d_solver->getRoundingModeSort(), true);
defineType("Float16", d_solver->mkFloatingPointSort(5, 11), true);
defineType("Float32", d_solver->mkFloatingPointSort(8, 24), true);
defineType("Float64", d_solver->mkFloatingPointSort(11, 53), true);
defineType("Float128", d_solver->mkFloatingPointSort(15, 113), true);
- defineVar("RNE", d_solver->mkRoundingMode(api::ROUND_NEAREST_TIES_TO_EVEN));
+ defineVar("RNE",
+ d_solver->mkRoundingMode(cvc5::ROUND_NEAREST_TIES_TO_EVEN));
defineVar("roundNearestTiesToEven",
- d_solver->mkRoundingMode(api::ROUND_NEAREST_TIES_TO_EVEN));
- defineVar("RNA", d_solver->mkRoundingMode(api::ROUND_NEAREST_TIES_TO_AWAY));
+ d_solver->mkRoundingMode(cvc5::ROUND_NEAREST_TIES_TO_EVEN));
+ defineVar("RNA",
+ d_solver->mkRoundingMode(cvc5::ROUND_NEAREST_TIES_TO_AWAY));
defineVar("roundNearestTiesToAway",
- d_solver->mkRoundingMode(api::ROUND_NEAREST_TIES_TO_AWAY));
- defineVar("RTP", d_solver->mkRoundingMode(api::ROUND_TOWARD_POSITIVE));
+ d_solver->mkRoundingMode(cvc5::ROUND_NEAREST_TIES_TO_AWAY));
+ defineVar("RTP", d_solver->mkRoundingMode(cvc5::ROUND_TOWARD_POSITIVE));
defineVar("roundTowardPositive",
- d_solver->mkRoundingMode(api::ROUND_TOWARD_POSITIVE));
- defineVar("RTN", d_solver->mkRoundingMode(api::ROUND_TOWARD_NEGATIVE));
+ d_solver->mkRoundingMode(cvc5::ROUND_TOWARD_POSITIVE));
+ defineVar("RTN", d_solver->mkRoundingMode(cvc5::ROUND_TOWARD_NEGATIVE));
defineVar("roundTowardNegative",
- d_solver->mkRoundingMode(api::ROUND_TOWARD_NEGATIVE));
- defineVar("RTZ", d_solver->mkRoundingMode(api::ROUND_TOWARD_ZERO));
+ d_solver->mkRoundingMode(cvc5::ROUND_TOWARD_NEGATIVE));
+ defineVar("RTZ", d_solver->mkRoundingMode(cvc5::ROUND_TOWARD_ZERO));
defineVar("roundTowardZero",
- d_solver->mkRoundingMode(api::ROUND_TOWARD_ZERO));
+ d_solver->mkRoundingMode(cvc5::ROUND_TOWARD_ZERO));
addFloatingPointOperators();
}
- if (d_logic.isTheoryEnabled(theory::THEORY_SEP))
+ if (d_logic.isTheoryEnabled(internal::theory::THEORY_SEP))
{
addSepOperators();
}
return cmd;
} /* Smt2::setLogic() */
-api::Grammar* Smt2::mkGrammar(const std::vector<api::Term>& boundVars,
- const std::vector<api::Term>& ntSymbols)
+cvc5::Grammar* Smt2::mkGrammar(const std::vector<cvc5::Term>& boundVars,
+ const std::vector<cvc5::Term>& ntSymbols)
{
d_allocGrammars.emplace_back(
- new api::Grammar(d_solver->mkSygusGrammar(boundVars, ntSymbols)));
+ new cvc5::Grammar(d_solver->mkSygusGrammar(boundVars, ntSymbols)));
return d_allocGrammars.back().get();
}
void Smt2::checkLogicAllowsFreeSorts()
{
- if (!d_logic.isTheoryEnabled(theory::THEORY_UF)
- && !d_logic.isTheoryEnabled(theory::THEORY_ARRAYS)
- && !d_logic.isTheoryEnabled(theory::THEORY_DATATYPES)
- && !d_logic.isTheoryEnabled(theory::THEORY_SETS)
- && !d_logic.isTheoryEnabled(theory::THEORY_BAGS))
+ if (!d_logic.isTheoryEnabled(internal::theory::THEORY_UF)
+ && !d_logic.isTheoryEnabled(internal::theory::THEORY_ARRAYS)
+ && !d_logic.isTheoryEnabled(internal::theory::THEORY_DATATYPES)
+ && !d_logic.isTheoryEnabled(internal::theory::THEORY_SETS)
+ && !d_logic.isTheoryEnabled(internal::theory::THEORY_BAGS))
{
parseErrorLogic("Free sort symbols not allowed in ");
}
void Smt2::checkLogicAllowsFunctions()
{
- if (!d_logic.isTheoryEnabled(theory::THEORY_UF) && !isHoEnabled())
+ if (!d_logic.isTheoryEnabled(internal::theory::THEORY_UF) && !isHoEnabled())
{
parseError(
"Functions (of non-zero arity) cannot "
&& name.find_first_not_of("0123456789", 1) == std::string::npos;
}
-void Smt2::parseOpApplyTypeAscription(ParseOp& p, api::Sort type)
+void Smt2::parseOpApplyTypeAscription(ParseOp& p, cvc5::Sort type)
{
Trace("parser") << "parseOpApplyTypeAscription : " << p << " " << type
<< std::endl;
// (as const (Array T1 T2))
- if (p.d_kind == api::CONST_ARRAY)
+ if (p.d_kind == cvc5::CONST_ARRAY)
{
if (!type.isArray())
{
p.d_expr = applyTypeAscription(p.d_expr, type);
}
-api::Term Smt2::parseOpToExpr(ParseOp& p)
+cvc5::Term Smt2::parseOpToExpr(ParseOp& p)
{
Trace("parser") << "parseOpToExpr: " << p << std::endl;
- api::Term expr;
- if (p.d_kind != api::NULL_TERM || !p.d_type.isNull())
+ cvc5::Term expr;
+ if (p.d_kind != cvc5::NULL_TERM || !p.d_type.isNull())
{
parseError(
"Bad syntax for qualified identifier operator in term position.");
return expr;
}
-api::Term Smt2::applyParseOp(ParseOp& p, std::vector<api::Term>& args)
+cvc5::Term Smt2::applyParseOp(ParseOp& p, std::vector<cvc5::Term>& args)
{
bool isBuiltinOperator = false;
// the builtin kind of the overall return expression
- api::Kind kind = api::NULL_TERM;
+ cvc5::Kind kind = cvc5::NULL_TERM;
// First phase: process the operator
if (TraceIsOn("parser"))
{
Trace("parser") << "applyParseOp: " << p << " to:" << std::endl;
- for (std::vector<api::Term>::iterator i = args.begin(); i != args.end();
+ for (std::vector<cvc5::Term>::iterator i = args.begin(); i != args.end();
++i)
{
Trace("parser") << "++ " << *i << std::endl;
}
}
- api::Op op;
- if (p.d_kind == api::UNDEFINED_KIND && isIndexedOperatorEnabled(p.d_name))
+ cvc5::Op op;
+ if (p.d_kind == cvc5::UNDEFINED_KIND && isIndexedOperatorEnabled(p.d_name))
{
// Resolve indexed symbols that cannot be resolved without knowing the type
// of the arguments. This is currently limited to `to_fp`.
size_t nchildren = args.size();
if (nchildren == 1)
{
- kind = api::FLOATINGPOINT_TO_FP_FROM_IEEE_BV;
+ kind = cvc5::FLOATINGPOINT_TO_FP_FROM_IEEE_BV;
op = d_solver->mkOp(kind, p.d_indices);
}
else if (nchildren > 2)
}
else
{
- api::Sort t = args[1].getSort();
+ cvc5::Sort t = args[1].getSort();
if (t.isFloatingPoint())
{
- kind = api::FLOATINGPOINT_TO_FP_FROM_FP;
+ kind = cvc5::FLOATINGPOINT_TO_FP_FROM_FP;
op = d_solver->mkOp(kind, p.d_indices);
}
else if (t.isInteger() || t.isReal())
{
- kind = api::FLOATINGPOINT_TO_FP_FROM_REAL;
+ kind = cvc5::FLOATINGPOINT_TO_FP_FROM_REAL;
op = d_solver->mkOp(kind, p.d_indices);
}
else
{
- kind = api::FLOATINGPOINT_TO_FP_FROM_SBV;
+ kind = cvc5::FLOATINGPOINT_TO_FP_FROM_SBV;
op = d_solver->mkOp(kind, p.d_indices);
}
}
}
- else if (p.d_kind != api::NULL_TERM)
+ else if (p.d_kind != cvc5::NULL_TERM)
{
// It is a special case, e.g. tuple_select or array constant specification.
// We have to wait until the arguments are parsed to resolve it.
else if (!p.d_expr.isNull())
{
// An explicit operator, e.g. an apply function
- api::Kind fkind = getKindForFunction(p.d_expr);
- if (fkind != api::UNDEFINED_KIND)
+ cvc5::Kind fkind = getKindForFunction(p.d_expr);
+ if (fkind != cvc5::UNDEFINED_KIND)
{
// Some operators may require a specific kind.
// Testers are handled differently than other indexed operators,
{
// A non-built-in function application, get the expression
checkDeclaration(p.d_name, CHECK_DECLARED, SYM_VARIABLE);
- api::Term v = getVariable(p.d_name);
+ cvc5::Term v = getVariable(p.d_name);
if (!v.isNull())
{
checkFunctionLike(v);
// Could not find the expression. It may be an overloaded symbol,
// in which case we may find it after knowing the types of its
// arguments.
- std::vector<api::Sort> argTypes;
- for (std::vector<api::Term>::iterator i = args.begin(); i != args.end();
+ std::vector<cvc5::Sort> argTypes;
+ for (std::vector<cvc5::Term>::iterator i = args.begin();
+ i != args.end();
++i)
{
argTypes.push_back((*i).getSort());
}
- api::Term fop = getOverloadedFunctionForTypes(p.d_name, argTypes);
+ cvc5::Term fop = getOverloadedFunctionForTypes(p.d_name, argTypes);
if (!fop.isNull())
{
checkFunctionLike(fop);
}
}
// handle special cases
- if (p.d_kind == api::CONST_ARRAY && !p.d_type.isNull())
+ if (p.d_kind == cvc5::CONST_ARRAY && !p.d_type.isNull())
{
if (args.size() != 1)
{
parseError("Too many arguments to array constant.");
}
- api::Term constVal = args[0];
+ cvc5::Term constVal = args[0];
if (p.d_type.getArrayElementSort() != constVal.getSort())
{
<< "computed const type: " << constVal.getSort();
parseError(ss.str());
}
- api::Term ret = d_solver->mkConstArray(p.d_type, constVal);
+ cvc5::Term ret = d_solver->mkConstArray(p.d_type, constVal);
Trace("parser") << "applyParseOp: return store all " << ret << std::endl;
return ret;
}
- else if ((p.d_kind == api::APPLY_SELECTOR || p.d_kind == api::APPLY_UPDATER)
+ else if ((p.d_kind == cvc5::APPLY_SELECTOR || p.d_kind == cvc5::APPLY_UPDATER)
&& !p.d_expr.isNull())
{
// tuple selector case
"index of tuple select or update is larger than size of uint64_t");
}
uint64_t n = p.d_expr.getUInt64Value();
- if (args.size() != (p.d_kind == api::APPLY_SELECTOR ? 1 : 2))
+ if (args.size() != (p.d_kind == cvc5::APPLY_SELECTOR ? 1 : 2))
{
parseError("wrong number of arguments for tuple select or update");
}
- api::Sort t = args[0].getSort();
+ cvc5::Sort t = args[0].getSort();
if (!t.isTuple())
{
parseError("tuple select or update applied to non-tuple");
ss << "tuple is of length " << length << "; cannot access index " << n;
parseError(ss.str());
}
- const api::Datatype& dt = t.getDatatype();
- api::Term ret;
- if (p.d_kind == api::APPLY_SELECTOR)
+ const cvc5::Datatype& dt = t.getDatatype();
+ cvc5::Term ret;
+ if (p.d_kind == cvc5::APPLY_SELECTOR)
{
- ret = d_solver->mkTerm(api::APPLY_SELECTOR,
+ ret = d_solver->mkTerm(cvc5::APPLY_SELECTOR,
{dt[0][n].getSelectorTerm(), args[0]});
}
else
{
- ret = d_solver->mkTerm(api::APPLY_UPDATER,
+ ret = d_solver->mkTerm(cvc5::APPLY_UPDATER,
{dt[0][n].getUpdaterTerm(), args[0], args[1]});
}
Trace("parser") << "applyParseOp: return selector " << ret << std::endl;
return ret;
}
- else if (p.d_kind == api::TUPLE_PROJECT)
+ else if (p.d_kind == cvc5::TUPLE_PROJECT)
{
- api::Term ret = d_solver->mkTerm(p.d_op, args);
+ cvc5::Term ret = d_solver->mkTerm(p.d_op, args);
Trace("parser") << "applyParseOp: return projection " << ret << std::endl;
return ret;
}
- else if (p.d_kind != api::NULL_TERM)
+ else if (p.d_kind != cvc5::NULL_TERM)
{
// it should not have an expression or type specified at this point
if (!p.d_expr.isNull() || !p.d_type.isNull())
}
else if (isBuiltinOperator)
{
- if (!isHoEnabled() && (kind == api::EQUAL || kind == api::DISTINCT))
+ if (!isHoEnabled() && (kind == cvc5::EQUAL || kind == cvc5::DISTINCT))
{
// need hol if these operators are applied over function args
- for (std::vector<api::Term>::iterator i = args.begin(); i != args.end();
+ for (std::vector<cvc5::Term>::iterator i = args.begin(); i != args.end();
++i)
{
if ((*i).getSort().isFunction())
}
}
}
- if (!strictModeEnabled() && (kind == api::AND || kind == api::OR)
+ if (!strictModeEnabled() && (kind == cvc5::AND || kind == cvc5::OR)
&& args.size() == 1)
{
// Unary AND/OR can be replaced with the argument.
Trace("parser") << "applyParseOp: return unary " << args[0] << std::endl;
return args[0];
}
- else if (kind == api::SUB && args.size() == 1)
+ else if (kind == cvc5::SUB && args.size() == 1)
{
if (isConstInt(args[0]) && args[0].getRealOrIntegerValueSign() > 0)
{
// (- n) denotes a negative value
std::stringstream suminus;
suminus << "-" << args[0].getIntegerValue();
- api::Term ret = d_solver->mkInteger(suminus.str());
+ cvc5::Term ret = d_solver->mkInteger(suminus.str());
Trace("parser") << "applyParseOp: return negative constant " << ret
<< std::endl;
return ret;
}
- api::Term ret = d_solver->mkTerm(api::NEG, {args[0]});
+ cvc5::Term ret = d_solver->mkTerm(cvc5::NEG, {args[0]});
Trace("parser") << "applyParseOp: return uminus " << ret << std::endl;
return ret;
}
- else if (kind == api::DIVISION && args.size() == 2 && isConstInt(args[0])
+ else if (kind == cvc5::DIVISION && args.size() == 2 && isConstInt(args[0])
&& isConstInt(args[1]) && args[1].getRealOrIntegerValueSign() > 0)
{
// (/ m n) or (/ (- m) n) denote values in reals
std::stringstream sdiv;
sdiv << args[0].getIntegerValue() << "/" << args[1].getIntegerValue();
- api::Term ret = d_solver->mkReal(sdiv.str());
+ cvc5::Term ret = d_solver->mkReal(sdiv.str());
Trace("parser") << "applyParseOp: return rational constant " << ret
<< std::endl;
return ret;
}
- if (kind == api::SET_SINGLETON && args.size() == 1)
+ if (kind == cvc5::SET_SINGLETON && args.size() == 1)
{
- api::Term ret = d_solver->mkTerm(api::SET_SINGLETON, {args[0]});
+ cvc5::Term ret = d_solver->mkTerm(cvc5::SET_SINGLETON, {args[0]});
Trace("parser") << "applyParseOp: return set.singleton " << ret
<< std::endl;
return ret;
}
- else if (kind == api::CARDINALITY_CONSTRAINT)
+ else if (kind == cvc5::CARDINALITY_CONSTRAINT)
{
if (args.size() != 2)
{
parseError("Incorrect arguments for cardinality constraint");
}
- api::Sort sort = args[0].getSort();
+ cvc5::Sort sort = args[0].getSort();
if (!sort.isUninterpretedSort())
{
parseError("Expected uninterpreted sort for cardinality constraint");
}
uint64_t ubound = args[1].getUInt32Value();
- api::Term ret = d_solver->mkCardinalityConstraint(sort, ubound);
+ cvc5::Term ret = d_solver->mkCardinalityConstraint(sort, ubound);
return ret;
}
- api::Term ret = d_solver->mkTerm(kind, args);
+ cvc5::Term ret = d_solver->mkTerm(kind, args);
Trace("parser") << "applyParseOp: return default builtin " << ret
<< std::endl;
return ret;
if (args.size() >= 2)
{
// may be partially applied function, in this case we use HO_APPLY
- api::Sort argt = args[0].getSort();
+ cvc5::Sort argt = args[0].getSort();
if (argt.isFunction())
{
unsigned arity = argt.getFunctionArity();
Trace("parser") << "Partial application of " << args[0];
Trace("parser") << " : #argTypes = " << arity;
Trace("parser") << ", #args = " << args.size() - 1 << std::endl;
- api::Term ret = d_solver->mkTerm(api::HO_APPLY, args);
+ cvc5::Term ret = d_solver->mkTerm(cvc5::HO_APPLY, args);
Trace("parser") << "applyParseOp: return curry higher order " << ret
<< std::endl;
// must curry the partial application
}
if (!op.isNull())
{
- api::Term ret = d_solver->mkTerm(op, args);
+ cvc5::Term ret = d_solver->mkTerm(op, args);
Trace("parser") << "applyParseOp: return op : " << ret << std::endl;
return ret;
}
- if (kind == api::NULL_TERM)
+ if (kind == cvc5::NULL_TERM)
{
// should never happen in the new API
parseError("do not know how to process parse op");
}
Trace("parser") << "Try default term construction for kind " << kind
<< " #args = " << args.size() << "..." << std::endl;
- api::Term ret = d_solver->mkTerm(kind, args);
+ cvc5::Term ret = d_solver->mkTerm(kind, args);
Trace("parser") << "applyParseOp: return : " << ret << std::endl;
return ret;
}
-void Smt2::notifyNamedExpression(api::Term& expr, std::string name)
+void Smt2::notifyNamedExpression(cvc5::Term& expr, std::string name)
{
checkUserSymbol(name);
// remember the expression name in the symbol manager
setLastNamedTerm(expr, name);
}
-api::Term Smt2::mkAnd(const std::vector<api::Term>& es) const
+cvc5::Term Smt2::mkAnd(const std::vector<cvc5::Term>& es) const
{
if (es.size() == 0)
{
{
return es[0];
}
- return d_solver->mkTerm(api::AND, es);
+ return d_solver->mkTerm(cvc5::AND, es);
}
-bool Smt2::isConstInt(const api::Term& t)
+bool Smt2::isConstInt(const cvc5::Term& t)
{
- api::Kind k = t.getKind();
+ cvc5::Kind k = t.getKind();
// !!! Note when arithmetic subtyping is eliminated, this will update to
// CONST_INTEGER.
- return k == api::CONST_RATIONAL && t.getSort().isInteger();
+ return k == cvc5::CONST_RATIONAL && t.getSort().isInteger();
}
} // namespace parser
namespace cvc5 {
class Command;
-
-namespace api {
class Solver;
-}
namespace parser {
/** Have we seen a set-logic command yet? */
bool d_seenSetLogic;
- LogicInfo d_logic;
- std::unordered_map<std::string, api::Kind> d_operatorKindMap;
+ internal::LogicInfo d_logic;
+ std::unordered_map<std::string, cvc5::Kind> d_operatorKindMap;
/**
* Maps indexed symbols to the kind of the operator (e.g. "extract" to
* BITVECTOR_EXTRACT).
*/
- std::unordered_map<std::string, api::Kind> d_indexedOpKindMap;
- std::pair<api::Term, std::string> d_lastNamedTerm;
+ std::unordered_map<std::string, cvc5::Kind> d_indexedOpKindMap;
+ std::pair<cvc5::Term, std::string> d_lastNamedTerm;
/**
* A list of sygus grammar objects. We keep track of them here to ensure that
* they don't get deleted before the commands using them get invoked.
*/
- std::vector<std::unique_ptr<api::Grammar>> d_allocGrammars;
+ std::vector<std::unique_ptr<cvc5::Grammar>> d_allocGrammars;
protected:
- Smt2(api::Solver* solver,
+ Smt2(cvc5::Solver* solver,
SymbolManager* sm,
bool strictMode = false,
bool parseOnly = false);
*/
void addCoreSymbols();
- void addOperator(api::Kind k, const std::string& name);
+ void addOperator(cvc5::Kind k, const std::string& name);
/**
* Registers an indexed function symbol.
* be`UNDEFINED_KIND`.
* @param name The name of the symbol (e.g. "extract")
*/
- void addIndexedOperator(api::Kind tKind,
- const std::string& name);
+ void addIndexedOperator(cvc5::Kind tKind, const std::string& name);
/**
* Checks whether an indexed operator is enabled. All indexed operators in
* the current logic are considered to be enabled. This includes operators
*/
bool isIndexedOperatorEnabled(const std::string& name) const;
- api::Kind getOperatorKind(const std::string& name) const;
+ cvc5::Kind getOperatorKind(const std::string& name) const;
bool isOperatorEnabled(const std::string& name) const;
- bool isTheoryEnabled(theory::TheoryId theory) const;
+ bool isTheoryEnabled(internal::theory::TheoryId theory) const;
/**
* Checks if higher-order support is enabled.
* @return The term corresponding to the constant or a parse error if name is
* not valid.
*/
- api::Term mkIndexedConstant(const std::string& name,
- const std::vector<uint32_t>& numerals);
+ cvc5::Term mkIndexedConstant(const std::string& name,
+ const std::vector<uint32_t>& numerals);
/**
* Creates an indexed operator kind, e.g. BITVECTOR_EXTRACT for "extract".
* @return The kind corresponding to the indexed operator or a parse
* error if the name is not valid.
*/
- api::Kind getIndexedOpKind(const std::string& name);
+ cvc5::Kind getIndexedOpKind(const std::string& name);
/**
* If we are in a version < 2.6, this updates name to the tester name of cons,
* e.g. "is-cons".
*/
- bool getTesterName(api::Term cons, std::string& name) override;
+ bool getTesterName(cvc5::Term cons, std::string& name) override;
/** Make function defined by a define-fun(s)-rec command.
*
* added to flattenVars in this function if the function is given a function
* range type.
*/
- api::Term bindDefineFunRec(
+ cvc5::Term bindDefineFunRec(
const std::string& fname,
- const std::vector<std::pair<std::string, api::Sort>>& sortedVarNames,
- api::Sort t,
- std::vector<api::Term>& flattenVars);
+ const std::vector<std::pair<std::string, cvc5::Sort>>& sortedVarNames,
+ cvc5::Sort t,
+ std::vector<cvc5::Term>& flattenVars);
/** Push scope for define-fun-rec
*
* that defined this definition and stores it in bvs.
*/
void pushDefineFunRecScope(
- const std::vector<std::pair<std::string, api::Sort>>& sortedVarNames,
- api::Term func,
- const std::vector<api::Term>& flattenVars,
- std::vector<api::Term>& bvs);
+ const std::vector<std::pair<std::string, cvc5::Sort>>& sortedVarNames,
+ cvc5::Term func,
+ const std::vector<cvc5::Term>& flattenVars,
+ std::vector<cvc5::Term>& bvs);
void reset() override;
/**
* Get the logic.
*/
- const LogicInfo& getLogic() const { return d_logic; }
+ const internal::LogicInfo& getLogic() const { return d_logic; }
/**
* Create a Sygus grammar.
* @param ntSymbols the pre-declaration of the non-terminal symbols
* @return a pointer to the grammar
*/
- api::Grammar* mkGrammar(const std::vector<api::Term>& boundVars,
- const std::vector<api::Term>& ntSymbols);
+ cvc5::Grammar* mkGrammar(const std::vector<cvc5::Term>& boundVars,
+ const std::vector<cvc5::Term>& ntSymbols);
/**
* Are we using smtlib 2.6 or above? If exact=true, then this method returns
void includeFile(const std::string& filename);
- void setLastNamedTerm(api::Term e, std::string name)
+ void setLastNamedTerm(cvc5::Term e, std::string name)
{
d_lastNamedTerm = std::make_pair(e, name);
}
void clearLastNamedTerm()
{
- d_lastNamedTerm = std::make_pair(api::Term(), "");
+ d_lastNamedTerm = std::make_pair(cvc5::Term(), "");
}
- std::pair<api::Term, std::string> lastNamedTerm() { return d_lastNamedTerm; }
+ std::pair<cvc5::Term, std::string> lastNamedTerm() { return d_lastNamedTerm; }
/** Does name denote an abstract value? (of the form '@n' for numeral n). */
bool isAbstractValue(const std::string& name);
* Abstract values are used for processing get-value calls. The argument
* name should be such that isUninterpretedSortValue(name) is true.
*/
- api::Term mkUninterpretedSortValue(const std::string& name);
+ cvc5::Term mkUninterpretedSortValue(const std::string& name);
/**
* Smt2 parser provides its own checkDeclaration, which does the
* Notify that expression expr was given name std::string via a :named
* attribute.
*/
- void notifyNamedExpression(api::Term& expr, std::string name);
+ void notifyNamedExpression(cvc5::Term& expr, std::string name);
// Throw a ParserException with msg appended with the current logic.
inline void parseErrorLogic(const std::string& msg)
* - If p's expression field is set, then we leave p unchanged, check if
* that expression has the given type and throw a parse error otherwise.
*/
- void parseOpApplyTypeAscription(ParseOp& p, api::Sort type);
+ void parseOpApplyTypeAscription(ParseOp& p, cvc5::Sort type);
/**
* This converts a ParseOp to expression, assuming it is a standalone term.
*
* of this class.
* In other cases, a parse error is thrown.
*/
- api::Term parseOpToExpr(ParseOp& p);
+ cvc5::Term parseOpToExpr(ParseOp& p);
/**
* Apply parse operator to list of arguments, and return the resulting
* expression.
* - If the overall expression is a partial application, then we process this
* as a chain of HO_APPLY terms.
*/
- api::Term applyParseOp(ParseOp& p, std::vector<api::Term>& args);
+ cvc5::Term applyParseOp(ParseOp& p, std::vector<cvc5::Term>& args);
//------------------------- end processing parse operators
private:
* @return True if `es` is empty, `e` if `es` consists of a single element
* `e`, the conjunction of expressions otherwise.
*/
- api::Term mkAnd(const std::vector<api::Term>& es) const;
+ cvc5::Term mkAnd(const std::vector<cvc5::Term>& es) const;
/**
* Is term t a constant integer?
*/
- static bool isConstInt(const api::Term& t);
+ static bool isConstInt(const cvc5::Term& t);
}; /* class Smt2 */
} // namespace parser
return d_pSmt2Parser->parseCommand(d_pSmt2Parser);
}
-api::Term Smt2Input::parseExpr()
+cvc5::Term Smt2Input::parseExpr()
{
return d_pSmt2Parser->parseExpr(d_pSmt2Parser);
}
*
* @throws ParserException if an error is encountered during parsing.
*/
- api::Term parseExpr() override;
+ cvc5::Term parseExpr() override;
};/* class Smt2Input */
return d_pSmt2Parser->parseSygus(d_pSmt2Parser);
}
-api::Term SygusInput::parseExpr()
+cvc5::Term SygusInput::parseExpr()
{
return d_pSmt2Parser->parseExpr(d_pSmt2Parser);
}
/**
* Parse an expression from the input. Returns a null
- * <code>api::Term</code> if there is no expression there to parse.
+ * <code>cvc5::Term</code> if there is no expression there to parse.
*
* @throws ParserException if an error is encountered during parsing.
*/
- api::Term parseExpr() override;
+ cvc5::Term parseExpr() override;
};/* class SygusInput */
/**
* 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::Term if we've reached
* the end of the input
*/
parseExpr returns [cvc5::parser::tptp::myExpr expr]
*/
parseCommand returns [cvc5::Command* cmd = NULL]
@declarations {
- cvc5::api::Term expr;
+ cvc5::Term expr;
Tptp::FormulaRole fr;
std::string name, inclSymbol;
ParseOp p;
PARSER_STATE->pushScope(); }
cnfFormula[expr]
{ PARSER_STATE->popScope();
- std::vector<api::Term> bvl = PARSER_STATE->getFreeVar();
+ std::vector<cvc5::Term> bvl = PARSER_STATE->getFreeVar();
if(!bvl.empty()) {
- expr = MK_TERM(api::FORALL,MK_TERM(api::VARIABLE_LIST,bvl),expr);
+ expr = MK_TERM(cvc5::FORALL,MK_TERM(cvc5::VARIABLE_LIST,bvl),expr);
};
}
(COMMA_TOK anything*)? RPAREN_TOK DOT_TOK
{
- cvc5::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr, expr);
+ cvc5::Term aexpr = PARSER_STATE->getAssertionExpr(fr, expr);
if( !aexpr.isNull() ){
// set the expression name (e.g. used with unsat core printing)
SYM_MAN->setExpressionName(aexpr, name, true);
{ PARSER_STATE->setCnf(false); PARSER_STATE->setFof(true); }
fofFormula[expr] (COMMA_TOK anything*)? RPAREN_TOK DOT_TOK
{
- cvc5::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr,expr);
+ cvc5::Term aexpr = PARSER_STATE->getAssertionExpr(fr,expr);
if( !aexpr.isNull() ){
// set the expression name (e.g. used with unsat core printing)
SYM_MAN->setExpressionName(aexpr, name, true);
{ PARSER_STATE->setCnf(false); PARSER_STATE->setFof(false); }
tffFormula[expr] (COMMA_TOK anything*)?
{
- cvc5::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr,expr);
+ cvc5::Term aexpr = PARSER_STATE->getAssertionExpr(fr,expr);
if( !aexpr.isNull() ){
// set the expression name (e.g. used with unsat core printing)
SYM_MAN->setExpressionName(aexpr, name, true);
PARSER_STATE->parseError("Top level expression must be a formula");
}
expr = p.d_expr;
- cvc5::api::Term aexpr = PARSER_STATE->getAssertionExpr(fr, expr);
+ cvc5::Term aexpr = PARSER_STATE->getAssertionExpr(fr, expr);
if (!aexpr.isNull())
{
// set the expression name (e.g. used with unsat core printing)
{
CommandSequence* seq = new CommandSequence();
// assert that all distinct constants are distinct
- cvc5::api::Term aexpr = PARSER_STATE->getAssertionDistinctConstants();
+ cvc5::Term aexpr = PARSER_STATE->getAssertionDistinctConstants();
if( !aexpr.isNull() )
{
seq->addCommand(new AssertCommand(aexpr));
/* 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::Term& expr]
: LPAREN_TOK cnfDisjunction[expr] RPAREN_TOK
| cnfDisjunction[expr]
;
-cnfDisjunction[cvc5::api::Term& expr]
+cnfDisjunction[cvc5::Term& expr]
@declarations {
- std::vector<api::Term> args;
+ std::vector<cvc5::Term> args;
}
: cnfLiteral[expr] { args.push_back(expr); }
( OR_TOK cnfLiteral[expr] { args.push_back(expr); } )*
{ if(args.size() > 1) {
- expr = MK_TERM(api::OR, args);
+ expr = MK_TERM(cvc5::OR, args);
} // else its already in the expr
}
;
-cnfLiteral[cvc5::api::Term& expr]
+cnfLiteral[cvc5::Term& expr]
: atomicFormula[expr]
- | NOT_TOK atomicFormula[expr] { expr = MK_TERM(api::NOT, expr); }
+ | NOT_TOK atomicFormula[expr] { expr = MK_TERM(cvc5::NOT, expr); }
;
-atomicFormula[cvc5::api::Term& expr]
+atomicFormula[cvc5::Term& expr]
@declarations {
- cvc5::api::Term expr2;
+ cvc5::Term expr2;
std::string name;
- std::vector<cvc5::api::Term> args;
+ std::vector<cvc5::Term> args;
bool equal;
ParseOp p;
}
args.clear();
args.push_back(expr);
args.push_back(expr2);
- ParseOp p1(api::EQUAL);
+ ParseOp p1(cvc5::EQUAL);
expr = PARSER_STATE->applyParseOp(p1, args);
if (!equal)
{
- expr = MK_TERM(api::NOT, expr);
+ expr = MK_TERM(cvc5::NOT, expr);
}
}
| { // predicate
args.clear();
args.push_back(expr);
args.push_back(expr2);
- ParseOp p1(api::EQUAL);
+ ParseOp p1(cvc5::EQUAL);
expr = PARSER_STATE->applyParseOp(p1, args);
if (!equal)
{
- expr = MK_TERM(api::NOT, expr);
+ expr = MK_TERM(cvc5::NOT, expr);
}
}
)
{ // equality/disequality between terms
args.push_back(expr);
args.push_back(expr2);
- p.d_kind = api::EQUAL;
+ p.d_kind = cvc5::EQUAL;
expr = PARSER_STATE->applyParseOp(p, args);
if (!equal)
{
- expr = MK_TERM(api::NOT, expr);
+ expr = MK_TERM(cvc5::NOT, expr);
}
}
)?
thfAtomicFormula[cvc5::ParseOp& p]
@declarations {
- cvc5::api::Term expr2;
+ cvc5::Term expr2;
std::string name;
- std::vector<cvc5::api::Term> args;
+ std::vector<cvc5::Term> args;
bool equal;
}
: atomicWord[p.d_name] (LPAREN_TOK arguments[args] RPAREN_TOK)?
args.clear();
args.push_back(p.d_expr);
args.push_back(expr2);
- ParseOp p1(api::EQUAL);
+ ParseOp p1(cvc5::EQUAL);
p.d_expr = PARSER_STATE->applyParseOp(p1, args);
if (!equal)
{
- p.d_expr = MK_TERM(api::NOT, p.d_expr);
+ p.d_expr = MK_TERM(cvc5::NOT, p.d_expr);
}
}
)?
//%----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::Term& expr]
: TRUE_TOK { expr = SOLVER->mkTrue(); }
| FALSE_TOK { expr = SOLVER->mkFalse(); }
;
definedPred[cvc5::ParseOp& p]
: '$less'
{
- p.d_kind = api::LT;
+ p.d_kind = cvc5::LT;
}
| '$lesseq'
{
- p.d_kind = api::LEQ;
+ p.d_kind = cvc5::LEQ;
}
| '$greater'
{
- p.d_kind = api::GT;
+ p.d_kind = cvc5::GT;
}
| '$greatereq'
{
- p.d_kind = api::GEQ;
+ p.d_kind = cvc5::GEQ;
}
| '$is_rat'
// a real n is a rational if there exists q,r integers such that
// to_real(q) = n*to_real(r),
// where r is non-zero.
{
- api::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
- api::Term q = SOLVER->mkVar(SOLVER->getIntegerSort(), "Q");
- api::Term qr = MK_TERM(api::TO_REAL, q);
- api::Term r = SOLVER->mkVar(SOLVER->getIntegerSort(), "R");
- api::Term rr = MK_TERM(api::TO_REAL, r);
- api::Term body =
- MK_TERM(api::AND,
- MK_TERM(api::NOT,
- MK_TERM(api::EQUAL, r, SOLVER->mkInteger(0))),
- MK_TERM(api::EQUAL, qr, MK_TERM(api::MULT, n, rr)));
- api::Term bvl = MK_TERM(api::VARIABLE_LIST, q, r);
- body = MK_TERM(api::EXISTS, bvl, body);
- api::Term lbvl = MK_TERM(api::VARIABLE_LIST, n);
- p.d_kind = api::LAMBDA;
- p.d_expr = MK_TERM(api::LAMBDA, lbvl, body);
+ cvc5::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
+ cvc5::Term q = SOLVER->mkVar(SOLVER->getIntegerSort(), "Q");
+ cvc5::Term qr = MK_TERM(cvc5::TO_REAL, q);
+ cvc5::Term r = SOLVER->mkVar(SOLVER->getIntegerSort(), "R");
+ cvc5::Term rr = MK_TERM(cvc5::TO_REAL, r);
+ cvc5::Term body =
+ MK_TERM(cvc5::AND,
+ MK_TERM(cvc5::NOT,
+ MK_TERM(cvc5::EQUAL, r, SOLVER->mkInteger(0))),
+ MK_TERM(cvc5::EQUAL, qr, MK_TERM(cvc5::MULT, n, rr)));
+ cvc5::Term bvl = MK_TERM(cvc5::VARIABLE_LIST, q, r);
+ body = MK_TERM(cvc5::EXISTS, bvl, body);
+ cvc5::Term lbvl = MK_TERM(cvc5::VARIABLE_LIST, n);
+ p.d_kind = cvc5::LAMBDA;
+ p.d_expr = MK_TERM(cvc5::LAMBDA, lbvl, body);
}
| '$is_int'
{
- p.d_kind = api::IS_INTEGER;
+ p.d_kind = cvc5::IS_INTEGER;
}
| '$distinct'
{
- p.d_kind = api::DISTINCT;
+ p.d_kind = cvc5::DISTINCT;
}
| AND_TOK
{
- p.d_kind = api::AND;
+ p.d_kind = cvc5::AND;
}
| IMPLIES_TOK
{
- p.d_kind = api::IMPLIES;
+ p.d_kind = cvc5::IMPLIES;
}
| OR_TOK
{
- p.d_kind = api::OR;
+ p.d_kind = cvc5::OR;
}
;
thfDefinedPred[cvc5::ParseOp& p]
: '$less'
{
- p.d_kind = api::LT;
+ p.d_kind = cvc5::LT;
}
| '$lesseq'
{
- p.d_kind = api::LEQ;
+ p.d_kind = cvc5::LEQ;
}
| '$greater'
{
- p.d_kind = api::GT;
+ p.d_kind = cvc5::GT;
}
| '$greatereq'
{
- p.d_kind = api::GEQ;
+ p.d_kind = cvc5::GEQ;
}
| '$is_rat'
// a real n is a rational if there exists q,r integers such that
// to_real(q) = n*to_real(r),
// where r is non-zero.
{
- api::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
- api::Term q = SOLVER->mkVar(SOLVER->getIntegerSort(), "Q");
- api::Term qr = MK_TERM(api::TO_REAL, q);
- api::Term r = SOLVER->mkVar(SOLVER->getIntegerSort(), "R");
- api::Term rr = MK_TERM(api::TO_REAL, r);
- api::Term body = MK_TERM(
- api::AND,
- MK_TERM(api::NOT,
- MK_TERM(api::EQUAL, r, SOLVER->mkInteger(0))),
- MK_TERM(api::EQUAL, qr, MK_TERM(api::MULT, n, rr)));
- api::Term bvl = MK_TERM(api::VARIABLE_LIST, q, r);
- body = MK_TERM(api::EXISTS, bvl, body);
- api::Term lbvl = MK_TERM(api::VARIABLE_LIST, n);
- p.d_kind = api::LAMBDA;
- p.d_expr = MK_TERM(api::LAMBDA, lbvl, body);
+ cvc5::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
+ cvc5::Term q = SOLVER->mkVar(SOLVER->getIntegerSort(), "Q");
+ cvc5::Term qr = MK_TERM(cvc5::TO_REAL, q);
+ cvc5::Term r = SOLVER->mkVar(SOLVER->getIntegerSort(), "R");
+ cvc5::Term rr = MK_TERM(cvc5::TO_REAL, r);
+ cvc5::Term body = MK_TERM(
+ cvc5::AND,
+ MK_TERM(cvc5::NOT,
+ MK_TERM(cvc5::EQUAL, r, SOLVER->mkInteger(0))),
+ MK_TERM(cvc5::EQUAL, qr, MK_TERM(cvc5::MULT, n, rr)));
+ cvc5::Term bvl = MK_TERM(cvc5::VARIABLE_LIST, q, r);
+ body = MK_TERM(cvc5::EXISTS, bvl, body);
+ cvc5::Term lbvl = MK_TERM(cvc5::VARIABLE_LIST, n);
+ p.d_kind = cvc5::LAMBDA;
+ p.d_expr = MK_TERM(cvc5::LAMBDA, lbvl, body);
}
| '$is_int'
{
- p.d_kind = api::IS_INTEGER;
+ p.d_kind = cvc5::IS_INTEGER;
}
| '$distinct'
{
- p.d_kind = api::DISTINCT;
+ p.d_kind = cvc5::DISTINCT;
}
| LPAREN_TOK
(
AND_TOK
{
- p.d_kind = api::AND;
+ p.d_kind = cvc5::AND;
}
| OR_TOK
{
- p.d_kind = api::OR;
+ p.d_kind = cvc5::OR;
}
| IMPLIES_TOK
{
- p.d_kind = api::IMPLIES;
+ p.d_kind = cvc5::IMPLIES;
}
)
RPAREN_TOK
}
: '$uminus'
{
- p.d_kind = api::NEG;
+ p.d_kind = cvc5::NEG;
}
| '$sum'
{
- p.d_kind = api::ADD;
+ p.d_kind = cvc5::ADD;
}
| '$difference'
{
- p.d_kind = api::SUB;
+ p.d_kind = cvc5::SUB;
}
| '$product'
{
- p.d_kind = api::MULT;
+ p.d_kind = cvc5::MULT;
}
| '$quotient'
{
- p.d_kind = api::DIVISION;
+ p.d_kind = cvc5::DIVISION;
}
| ( '$quotient_e' { remainder = false; }
| '$remainder_e' { remainder = true; }
)
{
- api::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
- api::Term d = SOLVER->mkVar(SOLVER->getRealSort(), "D");
- api::Term formals = MK_TERM(api::VARIABLE_LIST, n, d);
- api::Term expr = MK_TERM(api::DIVISION, n, d);
- expr = MK_TERM(api::ITE,
- MK_TERM(api::GEQ, d, SOLVER->mkReal(0)),
- MK_TERM(api::TO_INTEGER, expr),
- MK_TERM(api::NEG,
- MK_TERM(api::TO_INTEGER,
- MK_TERM(api::NEG, expr))));
+ cvc5::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
+ cvc5::Term d = SOLVER->mkVar(SOLVER->getRealSort(), "D");
+ cvc5::Term formals = MK_TERM(cvc5::VARIABLE_LIST, n, d);
+ cvc5::Term expr = MK_TERM(cvc5::DIVISION, n, d);
+ expr = MK_TERM(cvc5::ITE,
+ MK_TERM(cvc5::GEQ, d, SOLVER->mkReal(0)),
+ MK_TERM(cvc5::TO_INTEGER, expr),
+ MK_TERM(cvc5::NEG,
+ MK_TERM(cvc5::TO_INTEGER,
+ MK_TERM(cvc5::NEG, expr))));
if (remainder)
{
expr = MK_TERM(
- api::TO_INTEGER,
- MK_TERM(api::SUB, n, MK_TERM(api::MULT, expr, d)));
+ cvc5::TO_INTEGER,
+ MK_TERM(cvc5::SUB, n, MK_TERM(cvc5::MULT, expr, d)));
}
- p.d_kind = api::LAMBDA;
- p.d_expr = MK_TERM(api::LAMBDA, formals, expr);
+ p.d_kind = cvc5::LAMBDA;
+ p.d_expr = MK_TERM(cvc5::LAMBDA, formals, expr);
}
| ( '$quotient_t' { remainder = false; }
| '$remainder_t' { remainder = true; }
)
{
- api::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
- api::Term d = SOLVER->mkVar(SOLVER->getRealSort(), "D");
- api::Term formals = MK_TERM(api::VARIABLE_LIST, n, d);
- api::Term expr = MK_TERM(api::DIVISION, n, d);
- expr = MK_TERM(api::ITE,
- MK_TERM(api::GEQ, expr, SOLVER->mkReal(0)),
- MK_TERM(api::TO_INTEGER, expr),
- MK_TERM(api::NEG,
- MK_TERM(api::TO_INTEGER,
- MK_TERM(api::NEG, expr))));
+ cvc5::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
+ cvc5::Term d = SOLVER->mkVar(SOLVER->getRealSort(), "D");
+ cvc5::Term formals = MK_TERM(cvc5::VARIABLE_LIST, n, d);
+ cvc5::Term expr = MK_TERM(cvc5::DIVISION, n, d);
+ expr = MK_TERM(cvc5::ITE,
+ MK_TERM(cvc5::GEQ, expr, SOLVER->mkReal(0)),
+ MK_TERM(cvc5::TO_INTEGER, expr),
+ MK_TERM(cvc5::NEG,
+ MK_TERM(cvc5::TO_INTEGER,
+ MK_TERM(cvc5::NEG, expr))));
if (remainder)
{
expr = MK_TERM(
- api::TO_INTEGER,
- MK_TERM(api::SUB, n, MK_TERM(api::MULT, expr, d)));
+ cvc5::TO_INTEGER,
+ MK_TERM(cvc5::SUB, n, MK_TERM(cvc5::MULT, expr, d)));
}
- p.d_kind = api::LAMBDA;
- p.d_expr = MK_TERM(api::LAMBDA, formals, expr);
+ p.d_kind = cvc5::LAMBDA;
+ p.d_expr = MK_TERM(cvc5::LAMBDA, formals, expr);
}
| ( '$quotient_f' { remainder = false; }
| '$remainder_f' { remainder = true; }
)
{
- api::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
- api::Term d = SOLVER->mkVar(SOLVER->getRealSort(), "D");
- api::Term formals = MK_TERM(api::VARIABLE_LIST, n, d);
- api::Term expr = MK_TERM(api::DIVISION, n, d);
- expr = MK_TERM(api::TO_INTEGER, expr);
+ cvc5::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
+ cvc5::Term d = SOLVER->mkVar(SOLVER->getRealSort(), "D");
+ cvc5::Term formals = MK_TERM(cvc5::VARIABLE_LIST, n, d);
+ cvc5::Term expr = MK_TERM(cvc5::DIVISION, n, d);
+ expr = MK_TERM(cvc5::TO_INTEGER, expr);
if (remainder)
{
- expr = MK_TERM(api::TO_INTEGER,
- MK_TERM(api::SUB, n, MK_TERM(api::MULT, expr, d)));
+ expr = MK_TERM(cvc5::TO_INTEGER,
+ MK_TERM(cvc5::SUB, n, MK_TERM(cvc5::MULT, expr, d)));
}
- p.d_kind = api::LAMBDA;
- p.d_expr = MK_TERM(api::LAMBDA, formals, expr);
+ p.d_kind = cvc5::LAMBDA;
+ p.d_expr = MK_TERM(cvc5::LAMBDA, formals, expr);
}
| '$floor'
{
- p.d_kind = api::TO_INTEGER;
+ p.d_kind = cvc5::TO_INTEGER;
}
| '$ceiling'
{
- api::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
- api::Term formals = MK_TERM(api::VARIABLE_LIST, n);
- api::Term expr = MK_TERM(api::NEG,
- MK_TERM(api::TO_INTEGER, MK_TERM(api::NEG, n)));
- p.d_kind = api::LAMBDA;
- p.d_expr = MK_TERM(api::LAMBDA, formals, expr);
+ cvc5::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
+ cvc5::Term formals = MK_TERM(cvc5::VARIABLE_LIST, n);
+ cvc5::Term expr = MK_TERM(cvc5::NEG,
+ MK_TERM(cvc5::TO_INTEGER, MK_TERM(cvc5::NEG, n)));
+ p.d_kind = cvc5::LAMBDA;
+ p.d_expr = MK_TERM(cvc5::LAMBDA, formals, expr);
}
| '$truncate'
{
- api::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
- api::Term formals = MK_TERM(api::VARIABLE_LIST, n);
- api::Term expr =
- MK_TERM(api::ITE,
- MK_TERM(api::GEQ, n, SOLVER->mkReal(0)),
- MK_TERM(api::TO_INTEGER, n),
- MK_TERM(api::NEG,
- MK_TERM(api::TO_INTEGER, MK_TERM(api::NEG, n))));
- p.d_kind = api::LAMBDA;
- p.d_expr = MK_TERM(api::LAMBDA, formals, expr);
+ cvc5::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
+ cvc5::Term formals = MK_TERM(cvc5::VARIABLE_LIST, n);
+ cvc5::Term expr =
+ MK_TERM(cvc5::ITE,
+ MK_TERM(cvc5::GEQ, n, SOLVER->mkReal(0)),
+ MK_TERM(cvc5::TO_INTEGER, n),
+ MK_TERM(cvc5::NEG,
+ MK_TERM(cvc5::TO_INTEGER, MK_TERM(cvc5::NEG, n))));
+ p.d_kind = cvc5::LAMBDA;
+ p.d_expr = MK_TERM(cvc5::LAMBDA, formals, expr);
}
| '$round'
{
- api::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
- api::Term formals = MK_TERM(api::VARIABLE_LIST, n);
- api::Term decPart = MK_TERM(api::SUB, n, MK_TERM(api::TO_INTEGER, n));
- api::Term expr = MK_TERM(
- api::ITE,
- MK_TERM(api::LT, decPart, SOLVER->mkReal(1, 2)),
+ cvc5::Term n = SOLVER->mkVar(SOLVER->getRealSort(), "N");
+ cvc5::Term formals = MK_TERM(cvc5::VARIABLE_LIST, n);
+ cvc5::Term decPart = MK_TERM(cvc5::SUB, n, MK_TERM(cvc5::TO_INTEGER, n));
+ cvc5::Term expr = MK_TERM(
+ cvc5::ITE,
+ MK_TERM(cvc5::LT, decPart, SOLVER->mkReal(1, 2)),
// if decPart < 0.5, round down
- MK_TERM(api::TO_INTEGER, n),
- MK_TERM(api::ITE,
- MK_TERM(api::GT, decPart, SOLVER->mkReal(1, 2)),
+ MK_TERM(cvc5::TO_INTEGER, n),
+ MK_TERM(cvc5::ITE,
+ MK_TERM(cvc5::GT, decPart, SOLVER->mkReal(1, 2)),
// if decPart > 0.5, round up
- MK_TERM(api::TO_INTEGER,
- MK_TERM(api::ADD, n, SOLVER->mkReal(1))),
+ MK_TERM(cvc5::TO_INTEGER,
+ MK_TERM(cvc5::ADD, n, SOLVER->mkReal(1))),
// if decPart == 0.5, round to nearest even integer:
// result is: to_int(n/2 + .5) * 2
- MK_TERM(api::MULT,
- MK_TERM(api::TO_INTEGER,
- MK_TERM(api::ADD,
- MK_TERM(api::DIVISION,
+ MK_TERM(cvc5::MULT,
+ MK_TERM(cvc5::TO_INTEGER,
+ MK_TERM(cvc5::ADD,
+ MK_TERM(cvc5::DIVISION,
n,
SOLVER->mkReal(2)),
SOLVER->mkReal(1, 2))),
SOLVER->mkInteger(2))));
- p.d_kind = api::LAMBDA;
- p.d_expr = MK_TERM(api::LAMBDA, formals, expr);
+ p.d_kind = cvc5::LAMBDA;
+ p.d_expr = MK_TERM(cvc5::LAMBDA, formals, expr);
}
| '$to_int'
{
- p.d_kind = api::TO_INTEGER;
+ p.d_kind = cvc5::TO_INTEGER;
}
| '$to_rat'
{
- p.d_kind = api::TO_REAL;
+ p.d_kind = cvc5::TO_REAL;
}
| '$to_real'
{
- p.d_kind = api::TO_REAL;
+ p.d_kind = cvc5::TO_REAL;
}
;
| DISEQUAL_TOK { equal = false; }
;
-term[cvc5::api::Term& expr]
+term[cvc5::Term& expr]
: functionTerm[expr]
| conditionalTerm[expr]
| simpleTerm[expr]
| letTerm[expr]
;
-letTerm[cvc5::api::Term& expr]
+letTerm[cvc5::Term& expr]
@declarations {
- cvc5::api::Term lhs, rhs;
+ cvc5::Term lhs, rhs;
}
: '$let_ft' LPAREN_TOK { PARSER_STATE->pushScope(); }
tffLetFormulaDefn[lhs, rhs] COMMA_TOK
;
/* Not an application */
-simpleTerm[cvc5::api::Term& expr]
+simpleTerm[cvc5::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::Term& expr]
: NUMBER { expr = PARSER_STATE->d_tmp_expr; }
| DISTINCT_OBJECT
{
}
;
-functionTerm[cvc5::api::Term& expr]
+functionTerm[cvc5::Term& expr]
@declarations {
- std::vector<cvc5::api::Term> args;
+ std::vector<cvc5::Term> args;
ParseOp p;
}
: plainTerm[expr]
}
;
-conditionalTerm[cvc5::api::Term& expr]
+conditionalTerm[cvc5::Term& expr]
@declarations {
- cvc5::api::Term expr2, expr3;
+ cvc5::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); }
+ { expr = MK_TERM(cvc5::ITE, expr, expr2, expr3); }
;
-plainTerm[cvc5::api::Term& expr]
+plainTerm[cvc5::Term& expr]
@declarations {
std::string name;
- std::vector<api::Term> args;
+ std::vector<cvc5::Term> args;
ParseOp p;
}
: atomicWord[p.d_name] (LPAREN_TOK arguments[args] RPAREN_TOK)?
}
;
-arguments[std::vector<cvc5::api::Term>& args]
+arguments[std::vector<cvc5::Term>& args]
@declarations {
- cvc5::api::Term expr;
+ cvc5::Term expr;
}
:
term[expr] { args.push_back(expr); } ( COMMA_TOK term[expr] { args.push_back(expr); } )*
;
-variable[cvc5::api::Term& expr]
+variable[cvc5::Term& expr]
: UPPER_WORD
{
std::string name = AntlrInput::tokenText($UPPER_WORD);
/*******/
/* FOF */
-fofFormula[cvc5::api::Term& expr] : fofLogicFormula[expr] ;
+fofFormula[cvc5::Term& expr] : fofLogicFormula[expr] ;
-fofLogicFormula[cvc5::api::Term& expr]
+fofLogicFormula[cvc5::Term& expr]
@declarations {
tptp::NonAssoc na;
- std::vector< cvc5::api::Term > args;
- cvc5::api::Term expr2;
+ std::vector< cvc5::Term > args;
+ cvc5::Term expr2;
}
: fofUnitaryFormula[expr]
( // Non-associative: <=> <~> ~& ~|
( fofBinaryNonAssoc[na] fofUnitaryFormula[expr2]
{ switch(na) {
case tptp::NA_IFF:
- expr = MK_TERM(api::EQUAL,expr,expr2);
+ expr = MK_TERM(cvc5::EQUAL,expr,expr2);
break;
case tptp::NA_REVIFF:
- expr = MK_TERM(api::XOR,expr,expr2);
+ expr = MK_TERM(cvc5::XOR,expr,expr2);
break;
case tptp::NA_IMPLIES:
- expr = MK_TERM(api::IMPLIES,expr,expr2);
+ expr = MK_TERM(cvc5::IMPLIES,expr,expr2);
break;
case tptp::NA_REVIMPLIES:
- expr = MK_TERM(api::IMPLIES,expr2,expr);
+ expr = MK_TERM(cvc5::IMPLIES,expr2,expr);
break;
case tptp::NA_REVOR:
- expr = MK_TERM(api::NOT,MK_TERM(api::OR,expr,expr2));
+ expr = MK_TERM(cvc5::NOT,MK_TERM(cvc5::OR,expr,expr2));
break;
case tptp::NA_REVAND:
- expr = MK_TERM(api::NOT,MK_TERM(api::AND,expr,expr2));
+ expr = MK_TERM(cvc5::NOT,MK_TERM(cvc5::AND,expr,expr2));
break;
}
}
| // N-ary and &
( { args.push_back(expr); }
( AND_TOK fofUnitaryFormula[expr] { args.push_back(expr); } )+
- { expr = MK_TERM(api::AND, args); }
+ { expr = MK_TERM(cvc5::AND, args); }
)
| // N-ary or |
( { args.push_back(expr); }
( OR_TOK fofUnitaryFormula[expr] { args.push_back(expr); } )+
- { expr = MK_TERM(api::OR, args); }
+ { expr = MK_TERM(cvc5::OR, args); }
)
)?
;
-fofUnitaryFormula[cvc5::api::Term& expr]
+fofUnitaryFormula[cvc5::Term& expr]
@declarations {
- api::Kind kind;
- std::vector< cvc5::api::Term > bv;
+ cvc5::Kind kind;
+ std::vector< cvc5::Term > bv;
}
: atomicFormula[expr]
| LPAREN_TOK fofLogicFormula[expr] RPAREN_TOK
- | NOT_TOK fofUnitaryFormula[expr] { expr = MK_TERM(api::NOT,expr); }
+ | NOT_TOK fofUnitaryFormula[expr] { expr = MK_TERM(cvc5::NOT,expr); }
| // Quantified
folQuantifier[kind] LBRACK_TOK {PARSER_STATE->pushScope();}
( bindvariable[expr] { bv.push_back(expr); }
( COMMA_TOK bindvariable[expr] { bv.push_back(expr); } )* ) RBRACK_TOK
COLON_TOK fofUnitaryFormula[expr]
{ PARSER_STATE->popScope();
- expr = MK_TERM(kind, MK_TERM(api::VARIABLE_LIST, bv), expr);
+ expr = MK_TERM(kind, MK_TERM(cvc5::VARIABLE_LIST, bv), expr);
}
;
-bindvariable[cvc5::api::Term& expr]
+bindvariable[cvc5::Term& expr]
: UPPER_WORD
{ std::string name = AntlrInput::tokenText($UPPER_WORD);
expr = PARSER_STATE->bindBoundVar(name, PARSER_STATE->d_unsorted);
| REVIMPLIES_TOK { na = tptp::NA_REVIMPLIES; }
;
-folQuantifier[cvc5::api::Kind& kind]
- : FORALL_TOK { kind = api::FORALL; }
- | EXISTS_TOK { kind = api::EXISTS; }
+folQuantifier[cvc5::Kind& kind]
+ : FORALL_TOK { kind = cvc5::FORALL; }
+ | EXISTS_TOK { kind = cvc5::EXISTS; }
;
/*******/
/* THF */
-thfQuantifier[cvc5::api::Kind& kind]
- : FORALL_TOK { kind = api::FORALL; }
- | EXISTS_TOK { kind = api::EXISTS; }
- | LAMBDA_TOK { kind = api::LAMBDA; }
+thfQuantifier[cvc5::Kind& kind]
+ : FORALL_TOK { kind = cvc5::FORALL; }
+ | EXISTS_TOK { kind = cvc5::EXISTS; }
+ | LAMBDA_TOK { kind = cvc5::LAMBDA; }
| CHOICE_TOK
{
UNSUPPORTED("Choice operator");
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::Term expr;
+ cvc5::Sort type;
std::string name;
}
: LPAREN_TOK thfAtomTyping[cmd] RPAREN_TOK
else
{
// as yet, it's undeclared
- api::Sort atype = PARSER_STATE->mkSort(name);
+ cvc5::Sort atype = PARSER_STATE->mkSort(name);
cmd = new DeclareSortCommand(name, 0, atype);
}
}
else
{
// as of yet, it's undeclared
- cvc5::api::Term freshExpr;
+ cvc5::Term freshExpr;
if (type.isFunction())
{
freshExpr = PARSER_STATE->bindVar(name, type);
thfLogicFormula[cvc5::ParseOp& p]
@declarations {
tptp::NonAssoc na;
- std::vector<cvc5::api::Term> args;
+ std::vector<cvc5::Term> args;
std::vector<ParseOp> p_args;
- cvc5::api::Term expr2;
+ cvc5::Term expr2;
bool equal;
ParseOp p1;
}
}
args.push_back(p.d_expr);
args.push_back(p1.d_expr);
- p.d_expr = MK_TERM(api::EQUAL, args);
+ p.d_expr = MK_TERM(cvc5::EQUAL, args);
if (!equal)
{
- p.d_expr = MK_TERM(api::NOT, p.d_expr);
+ p.d_expr = MK_TERM(cvc5::NOT, p.d_expr);
}
}
| // Non-associative: <=> <~> ~& ~|
switch (na)
{
case tptp::NA_IFF:
- p.d_expr = MK_TERM(api::EQUAL, p.d_expr, p1.d_expr);
+ p.d_expr = MK_TERM(cvc5::EQUAL, p.d_expr, p1.d_expr);
break;
case tptp::NA_REVIFF:
- p.d_expr = MK_TERM(api::XOR, p.d_expr, p1.d_expr);
+ p.d_expr = MK_TERM(cvc5::XOR, p.d_expr, p1.d_expr);
break;
case tptp::NA_IMPLIES:
- p.d_expr = MK_TERM(api::IMPLIES, p.d_expr, p1.d_expr);
+ p.d_expr = MK_TERM(cvc5::IMPLIES, p.d_expr, p1.d_expr);
break;
case tptp::NA_REVIMPLIES:
- p.d_expr = MK_TERM(api::IMPLIES, p1.d_expr, p.d_expr);
+ p.d_expr = MK_TERM(cvc5::IMPLIES, p1.d_expr, p.d_expr);
break;
case tptp::NA_REVOR:
p.d_expr =
- MK_TERM(api::NOT, MK_TERM(api::OR, p.d_expr, p1.d_expr));
+ MK_TERM(cvc5::NOT, MK_TERM(cvc5::OR, p.d_expr, p1.d_expr));
break;
case tptp::NA_REVAND:
p.d_expr =
- MK_TERM(api::NOT, MK_TERM(api::AND, p.d_expr, p1.d_expr));
+ MK_TERM(cvc5::NOT, MK_TERM(cvc5::AND, p.d_expr, p1.d_expr));
break;
}
}
}
)+
{
- p.d_expr = MK_TERM(api::AND, args);
+ p.d_expr = MK_TERM(cvc5::AND, args);
}
)
| // N-ary or |
}
)+
{
- p.d_expr = MK_TERM(api::OR, args);
+ p.d_expr = MK_TERM(cvc5::OR, args);
}
)
| // N-ary @ |
}
for (unsigned i = 0, size = args.size(); i < size; ++i)
{
- p.d_expr = MK_TERM(api::HO_APPLY, p.d_expr, args[i]);
+ p.d_expr = MK_TERM(cvc5::HO_APPLY, p.d_expr, args[i]);
}
}
}
)?
;
-thfTupleForm[std::vector<cvc5::api::Term>& args]
+thfTupleForm[std::vector<cvc5::Term>& args]
@declarations {
ParseOp p;
}
thfUnitaryFormula[cvc5::ParseOp& p]
@declarations {
- api::Kind kind;
- std::vector< cvc5::api::Term > bv;
- cvc5::api::Term expr;
+ cvc5::Kind kind;
+ std::vector< cvc5::Term > bv;
+ cvc5::Term expr;
bool equal;
ParseOp p1;
}
RPAREN_TOK
| NOT_TOK
{
- p.d_kind = api::NOT;
+ p.d_kind = cvc5::NOT;
}
(
thfUnitaryFormula[p1]
{
PARSER_STATE->parseError("NOT must be applied to a formula");
}
- std::vector<api::Term> args{p1.d_expr};
+ std::vector<cvc5::Term> args{p1.d_expr};
p.d_expr = PARSER_STATE->applyParseOp(p, args);
}
)?
// see documentation of mkFlatFunctionType for how it's done
//
// flatten body via flattening its type
- std::vector<api::Sort> sorts;
- std::vector<api::Term> flattenVars;
+ std::vector<cvc5::Sort> sorts;
+ std::vector<cvc5::Term> flattenVars;
PARSER_STATE->mkFlatFunctionType(sorts, expr.getSort(), flattenVars);
if (!flattenVars.empty())
{
// add variables to VARIABLE_LIST
bv.insert(bv.end(), flattenVars.begin(), flattenVars.end());
}
- p.d_expr = MK_TERM(p.d_kind, MK_TERM(api::VARIABLE_LIST, bv), expr);
+ p.d_expr = MK_TERM(p.d_kind, MK_TERM(cvc5::VARIABLE_LIST, bv), expr);
}
;
/*******/
/* TFF */
-tffFormula[cvc5::api::Term& expr] : tffLogicFormula[expr];
+tffFormula[cvc5::Term& expr] : tffLogicFormula[expr];
tffTypedAtom[cvc5::Command*& cmd]
@declarations {
- cvc5::api::Term expr;
- cvc5::api::Sort type;
+ cvc5::Term expr;
+ cvc5::Sort type;
std::string name;
}
: LPAREN_TOK tffTypedAtom[cmd] RPAREN_TOK
PARSER_STATE->parseError("Symbol `" + name + "' previously declared as a constant; cannot also be a sort");
} else {
// as yet, it's undeclared
- api::Sort atype = PARSER_STATE->mkSort(name);
+ cvc5::Sort atype = PARSER_STATE->mkSort(name);
cmd = new DeclareSortCommand(name, 0, atype);
}
}
}
} else {
// as yet, it's undeclared
- cvc5::api::Term aexpr = PARSER_STATE->bindVar(name, type);
+ cvc5::Term aexpr = PARSER_STATE->bindVar(name, type);
cmd = new DeclareFunctionCommand(name, aexpr, type);
}
}
)
;
-tffLogicFormula[cvc5::api::Term& expr]
+tffLogicFormula[cvc5::Term& expr]
@declarations {
tptp::NonAssoc na;
- std::vector< cvc5::api::Term > args;
- cvc5::api::Term expr2;
+ std::vector< cvc5::Term > args;
+ cvc5::Term expr2;
}
: tffUnitaryFormula[expr]
( // Non Assoc <=> <~> ~& ~|
( fofBinaryNonAssoc[na] tffUnitaryFormula[expr2]
{ switch(na) {
case tptp::NA_IFF:
- expr = MK_TERM(api::EQUAL,expr,expr2);
+ expr = MK_TERM(cvc5::EQUAL,expr,expr2);
break;
case tptp::NA_REVIFF:
- expr = MK_TERM(api::XOR,expr,expr2);
+ expr = MK_TERM(cvc5::XOR,expr,expr2);
break;
case tptp::NA_IMPLIES:
- expr = MK_TERM(api::IMPLIES,expr,expr2);
+ expr = MK_TERM(cvc5::IMPLIES,expr,expr2);
break;
case tptp::NA_REVIMPLIES:
- expr = MK_TERM(api::IMPLIES,expr2,expr);
+ expr = MK_TERM(cvc5::IMPLIES,expr2,expr);
break;
case tptp::NA_REVOR:
- expr = MK_TERM(api::NOT,MK_TERM(api::OR,expr,expr2));
+ expr = MK_TERM(cvc5::NOT,MK_TERM(cvc5::OR,expr,expr2));
break;
case tptp::NA_REVAND:
- expr = MK_TERM(api::NOT,MK_TERM(api::AND,expr,expr2));
+ expr = MK_TERM(cvc5::NOT,MK_TERM(cvc5::AND,expr,expr2));
break;
}
}
| // And &
( { args.push_back(expr); }
( AND_TOK tffUnitaryFormula[expr] { args.push_back(expr); } )+
- { expr = MK_TERM(api::AND,args); }
+ { expr = MK_TERM(cvc5::AND,args); }
)
| // Or |
( { args.push_back(expr); }
( OR_TOK tffUnitaryFormula[expr] { args.push_back(expr); } )+
- { expr = MK_TERM(api::OR,args); }
+ { expr = MK_TERM(cvc5::OR,args); }
)
)?
;
-tffUnitaryFormula[cvc5::api::Term& expr]
+tffUnitaryFormula[cvc5::Term& expr]
@declarations {
- api::Kind kind;
- std::vector< cvc5::api::Term > bv;
- cvc5::api::Term lhs, rhs;
+ cvc5::Kind kind;
+ std::vector< cvc5::Term > bv;
+ cvc5::Term lhs, rhs;
}
: atomicFormula[expr]
| LPAREN_TOK tffLogicFormula[expr] RPAREN_TOK
- | NOT_TOK tffUnitaryFormula[expr] { expr = MK_TERM(api::NOT,expr); }
+ | NOT_TOK tffUnitaryFormula[expr] { expr = MK_TERM(cvc5::NOT,expr); }
| // Quantified
folQuantifier[kind] LBRACK_TOK {PARSER_STATE->pushScope();}
( tffbindvariable[expr] { bv.push_back(expr); }
( COMMA_TOK tffbindvariable[expr] { bv.push_back(expr); } )* ) RBRACK_TOK
COLON_TOK tffUnitaryFormula[expr]
{ PARSER_STATE->popScope();
- expr = MK_TERM(kind, MK_TERM(api::VARIABLE_LIST, bv), expr);
+ expr = MK_TERM(kind, MK_TERM(cvc5::VARIABLE_LIST, bv), expr);
}
| '$ite_f' LPAREN_TOK tffLogicFormula[expr] COMMA_TOK tffLogicFormula[lhs] COMMA_TOK tffLogicFormula[rhs] RPAREN_TOK
- { expr = MK_TERM(api::ITE, expr, lhs, rhs); }
+ { expr = MK_TERM(cvc5::ITE, expr, lhs, rhs); }
| '$let_tf' LPAREN_TOK { PARSER_STATE->pushScope(); }
tffLetTermDefn[lhs, rhs] COMMA_TOK
tffFormula[expr]
RPAREN_TOK
;
-tffLetTermDefn[cvc5::api::Term& lhs, cvc5::api::Term& rhs]
+tffLetTermDefn[cvc5::Term& lhs, cvc5::Term& rhs]
@declarations {
- std::vector<cvc5::api::Term> bvlist;
+ std::vector<cvc5::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::Term> & bvlist,
+ cvc5::Term& lhs,
+ cvc5::Term& rhs]
: term[lhs] EQUAL_TOK term[rhs]
{
PARSER_STATE->checkLetBinding(bvlist, lhs, rhs, false);
- std::vector<api::Term> lchildren(++lhs.begin(), lhs.end());
- rhs = MK_TERM(api::LAMBDA, MK_TERM(api::VARIABLE_LIST, lchildren), rhs);
+ std::vector<cvc5::Term> lchildren(++lhs.begin(), lhs.end());
+ rhs = MK_TERM(cvc5::LAMBDA, MK_TERM(cvc5::VARIABLE_LIST, lchildren), rhs);
// since lhs is always APPLY_UF (otherwise we'd have had a parser error in
// checkLetBinding) the function to be replaced is always the first
// argument. Note that the way in which lchildren is built above is also
| LPAREN_TOK tffLetTermBinding[bvlist, lhs, rhs] RPAREN_TOK
;
-tffLetFormulaDefn[cvc5::api::Term& lhs, cvc5::api::Term& rhs]
+tffLetFormulaDefn[cvc5::Term& lhs, cvc5::Term& rhs]
@declarations {
- std::vector<cvc5::api::Term> bvlist;
+ std::vector<cvc5::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::Term> & bvlist,
+ cvc5::Term& lhs,
+ cvc5::Term& rhs]
: atomicFormula[lhs] IFF_TOK tffUnitaryFormula[rhs]
{
PARSER_STATE->checkLetBinding(bvlist, lhs, rhs, true);
- std::vector<api::Term> lchildren(++lhs.begin(), lhs.end());
- rhs = MK_TERM(api::LAMBDA, MK_TERM(api::VARIABLE_LIST, lchildren), rhs);
+ std::vector<cvc5::Term> lchildren(++lhs.begin(), lhs.end());
+ rhs = MK_TERM(cvc5::LAMBDA, MK_TERM(cvc5::VARIABLE_LIST, lchildren), rhs);
// since lhs is always APPLY_UF (otherwise we'd have had a parser error in
// checkLetBinding) the function to be replaced is always the first
// argument. Note that the way in which lchildren is built above is also
| LPAREN_TOK tffLetFormulaBinding[bvlist, lhs, rhs] RPAREN_TOK
;
-thfBindVariable[cvc5::api::Term& expr]
+thfBindVariable[cvc5::Term& expr]
@declarations {
std::string name;
- cvc5::api::Sort type = PARSER_STATE->d_unsorted;
+ cvc5::Sort type = PARSER_STATE->d_unsorted;
}
: UPPER_WORD
{ name = AntlrInput::tokenText($UPPER_WORD); }
;
-tffbindvariable[cvc5::api::Term& expr]
+tffbindvariable[cvc5::Term& expr]
@declarations {
- cvc5::api::Sort type = PARSER_STATE->d_unsorted;
+ cvc5::Sort type = PARSER_STATE->d_unsorted;
}
: UPPER_WORD
( COLON_TOK parseType[type] )?
// bvlist is accumulative; it can already contain elements
// on the way in, which are left undisturbed
-tffVariableList[std::vector<cvc5::api::Term>& bvlist]
+tffVariableList[std::vector<cvc5::Term>& bvlist]
@declarations {
- cvc5::api::Term e;
+ cvc5::Term e;
}
: tffbindvariable[e] { bvlist.push_back(e); }
( COMMA_TOK tffbindvariable[e] { bvlist.push_back(e); } )*
;
-parseThfType[cvc5::api::Sort& type]
+parseThfType[cvc5::Sort& type]
// assumes only mapping types (arrows), no tuple type
@declarations {
- std::vector<cvc5::api::Sort> sorts;
+ std::vector<cvc5::Sort> sorts;
}
: thfType[type] { sorts.push_back(type); }
(
}
else
{
- api::Sort range = sorts.back();
+ cvc5::Sort range = sorts.back();
sorts.pop_back();
type = PARSER_STATE->mkFlatFunctionType(sorts, range);
}
}
;
-thfType[cvc5::api::Sort& type]
+thfType[cvc5::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::Sort & type]
@declarations
{
- std::vector<cvc5::api::Sort> v;
+ std::vector<cvc5::Sort> v;
}
: simpleType[type]
| ( simpleType[type] { v.push_back(type); }
;
// non-function types
-simpleType[cvc5::api::Sort& type]
+simpleType[cvc5::Sort& type]
@declarations {
std::string name;
}
namespace cvc5 {
namespace parser {
-Tptp::Tptp(api::Solver* solver,
+Tptp::Tptp(cvc5::Solver* solver,
SymbolManager* sm,
bool strictMode,
bool parseOnly)
defineType("Bool", d_solver->getBooleanSort());
defineVar("$true", d_solver->mkTrue());
defineVar("$false", d_solver->mkFalse());
- addOperator(api::AND);
- addOperator(api::EQUAL);
- addOperator(api::IMPLIES);
- // addOperator(api::ITE); //only for tff thf
- addOperator(api::NOT);
- addOperator(api::OR);
- addOperator(api::XOR);
- addOperator(api::APPLY_UF);
+ addOperator(cvc5::AND);
+ addOperator(cvc5::EQUAL);
+ addOperator(cvc5::IMPLIES);
+ // addOperator(cvc5::ITE); //only for tff thf
+ addOperator(cvc5::NOT);
+ addOperator(cvc5::OR);
+ addOperator(cvc5::XOR);
+ addOperator(cvc5::APPLY_UF);
//Add quantifiers?
break;
}
}
-void Tptp::checkLetBinding(const std::vector<api::Term>& bvlist,
- api::Term lhs,
- api::Term rhs,
+void Tptp::checkLetBinding(const std::vector<cvc5::Term>& bvlist,
+ cvc5::Term lhs,
+ cvc5::Term rhs,
bool formula)
{
- if (lhs.getKind() != api::APPLY_UF)
+ if (lhs.getKind() != cvc5::APPLY_UF)
{
parseError("malformed let: LHS must be a flat function application");
}
- const std::multiset<api::Term> vars{lhs.begin(), lhs.end()};
+ const std::multiset<cvc5::Term> vars{lhs.begin(), lhs.end()};
if (formula && !lhs.getSort().isBoolean())
{
parseError("malformed let: LHS must be formula");
}
- for (const cvc5::api::Term& var : vars)
+ for (const cvc5::Term& var : vars)
{
if (var.hasOp())
{
}
// ensure all let-bound variables appear on the LHS, and appear only once
- for (const api::Term& bound_var : bvlist)
+ for (const cvc5::Term& bound_var : bvlist)
{
const size_t count = vars.count(bound_var);
if (count == 0) {
}
}
-api::Term Tptp::parseOpToExpr(ParseOp& p)
+cvc5::Term Tptp::parseOpToExpr(ParseOp& p)
{
- api::Term expr;
+ cvc5::Term expr;
if (!p.d_expr.isNull())
{
return p.d_expr;
}
// if it has a kind, it's a builtin one and this function should not have been
// called
- Assert(p.d_kind == api::NULL_TERM);
+ Assert(p.d_kind == cvc5::NULL_TERM);
expr = isTptpDeclared(p.d_name);
if (expr.isNull())
{
- api::Sort t =
+ cvc5::Sort t =
p.d_type == d_solver->getBooleanSort() ? p.d_type : d_unsorted;
expr = bindVar(p.d_name, t); // must define at level zero
d_auxSymbolTable[p.d_name] = expr;
return expr;
}
-api::Term Tptp::isTptpDeclared(const std::string& name)
+cvc5::Term Tptp::isTptpDeclared(const std::string& name)
{
if (isDeclared(name))
{ // already appeared
return getVariable(name);
}
- std::unordered_map<std::string, api::Term>::iterator it =
+ std::unordered_map<std::string, cvc5::Term>::iterator it =
d_auxSymbolTable.find(name);
if (it != d_auxSymbolTable.end())
{
return it->second;
}
// otherwise null
- return api::Term();
+ return cvc5::Term();
}
-api::Term Tptp::applyParseOp(ParseOp& p, std::vector<api::Term>& args)
+cvc5::Term Tptp::applyParseOp(ParseOp& p, std::vector<cvc5::Term>& args)
{
if (TraceIsOn("parser"))
{
Trace("parser") << "applyParseOp: " << p << " to:" << std::endl;
- for (std::vector<api::Term>::iterator i = args.begin(); i != args.end();
+ for (std::vector<cvc5::Term>::iterator i = args.begin(); i != args.end();
++i)
{
Trace("parser") << "++ " << *i << std::endl;
// this happens with some arithmetic kinds, which are wrapped around
// lambdas.
args.insert(args.begin(), p.d_expr);
- return d_solver->mkTerm(api::APPLY_UF, args);
+ return d_solver->mkTerm(cvc5::APPLY_UF, args);
}
bool isBuiltinKind = false;
// the builtin kind of the overall return expression
- api::Kind kind = api::NULL_TERM;
+ cvc5::Kind kind = cvc5::NULL_TERM;
// First phase: piece operator together
- if (p.d_kind == api::NULL_TERM)
+ if (p.d_kind == cvc5::NULL_TERM)
{
// A non-built-in function application, get the expression
- api::Term v = isTptpDeclared(p.d_name);
+ cvc5::Term v = isTptpDeclared(p.d_name);
if (v.isNull())
{
- std::vector<api::Sort> sorts(args.size(), d_unsorted);
- api::Sort t =
+ std::vector<cvc5::Sort> sorts(args.size(), d_unsorted);
+ cvc5::Sort t =
p.d_type == d_solver->getBooleanSort() ? p.d_type : d_unsorted;
t = d_solver->mkFunctionSort(sorts, t);
v = bindVar(p.d_name, t); // must define at level zero
kind = p.d_kind;
isBuiltinKind = true;
}
- Assert(kind != api::NULL_TERM);
+ Assert(kind != cvc5::NULL_TERM);
// Second phase: apply parse op to the arguments
if (isBuiltinKind)
{
- if (!hol() && (kind == api::EQUAL || kind == api::DISTINCT))
+ if (!hol() && (kind == cvc5::EQUAL || kind == cvc5::DISTINCT))
{
// need hol if these operators are applied over function args
- for (std::vector<api::Term>::iterator i = args.begin(); i != args.end();
+ for (std::vector<cvc5::Term>::iterator i = args.begin(); i != args.end();
++i)
{
if ((*i).getSort().isFunction())
}
}
}
- if (!strictModeEnabled() && (kind == api::AND || kind == api::OR)
+ if (!strictModeEnabled() && (kind == cvc5::AND || kind == cvc5::OR)
&& args.size() == 1)
{
// Unary AND/OR can be replaced with the argument.
return args[0];
}
- if (kind == api::SUB && args.size() == 1)
+ if (kind == cvc5::SUB && args.size() == 1)
{
- return d_solver->mkTerm(api::NEG, {args[0]});
+ return d_solver->mkTerm(cvc5::NEG, {args[0]});
}
- if (kind == api::TO_REAL)
+ if (kind == cvc5::TO_REAL)
{
// If the type is real, this is a no-op. We require this special
// case in the TPTP parser since TO_REAL is designed to match the
// SMT-LIB operator, meaning it can only be applied to integers, whereas
// the TPTP to_real / to_rat do not have the same semantics.
- api::Sort s = args[0].getSort();
+ cvc5::Sort s = args[0].getSort();
if (s.isReal())
{
return args[0];
// check if partially applied function, in this case we use HO_APPLY
if (args.size() >= 2)
{
- api::Sort argt = args[0].getSort();
+ cvc5::Sort argt = args[0].getSort();
if (argt.isFunction())
{
unsigned arity = argt.getFunctionArity();
Trace("parser") << " : #argTypes = " << arity;
Trace("parser") << ", #args = " << args.size() - 1 << std::endl;
// must curry the partial application
- return d_solver->mkTerm(api::HO_APPLY, args);
+ return d_solver->mkTerm(cvc5::HO_APPLY, args);
}
}
}
return d_solver->mkTerm(kind, args);
}
-api::Term Tptp::mkDecimal(
+cvc5::Term Tptp::mkDecimal(
std::string& snum, std::string& sden, bool pos, size_t exp, bool posE)
{
// the numerator and the denominator
preemptCommand(new SetBenchmarkLogicCommand(logic));
}
-void Tptp::addFreeVar(api::Term var)
+void Tptp::addFreeVar(cvc5::Term var)
{
Assert(cnf());
d_freeVar.push_back(var);
}
-std::vector<api::Term> Tptp::getFreeVar()
+std::vector<cvc5::Term> Tptp::getFreeVar()
{
Assert(cnf());
- std::vector<api::Term> r;
+ std::vector<cvc5::Term> r;
r.swap(d_freeVar);
return r;
}
-api::Term Tptp::convertRatToUnsorted(api::Term expr)
+cvc5::Term Tptp::convertRatToUnsorted(cvc5::Term expr)
{
// Create the conversion function If they doesn't exists
if (d_rtu_op.isNull()) {
- api::Sort t;
+ cvc5::Sort t;
// Conversion from rational to unsorted
t = d_solver->mkFunctionSort(d_solver->getRealSort(), d_unsorted);
d_rtu_op = d_solver->mkConst(t, "$$rtu");
// Add the inverse in order to show that over the elements that
// appear in the problem there is a bijection between unsorted and
// rational
- api::Term ret = d_solver->mkTerm(api::APPLY_UF, {d_rtu_op, expr});
+ cvc5::Term ret = d_solver->mkTerm(cvc5::APPLY_UF, {d_rtu_op, expr});
if (d_r_converted.find(expr) == d_r_converted.end()) {
d_r_converted.insert(expr);
- api::Term eq = d_solver->mkTerm(
- api::EQUAL, {expr, d_solver->mkTerm(api::APPLY_UF, {d_utr_op, ret})});
+ cvc5::Term eq = d_solver->mkTerm(
+ cvc5::EQUAL, {expr, d_solver->mkTerm(cvc5::APPLY_UF, {d_utr_op, ret})});
preemptCommand(new AssertCommand(eq));
}
- return api::Term(ret);
+ return cvc5::Term(ret);
}
-api::Term Tptp::convertStrToUnsorted(std::string str)
+cvc5::Term Tptp::convertStrToUnsorted(std::string str)
{
- api::Term& e = d_distinct_objects[str];
+ cvc5::Term& e = d_distinct_objects[str];
if (e.isNull())
{
e = d_solver->mkConst(d_unsorted, str);
return e;
}
-api::Term Tptp::mkLambdaWrapper(api::Kind k, api::Sort argType)
+cvc5::Term Tptp::mkLambdaWrapper(cvc5::Kind k, cvc5::Sort argType)
{
Trace("parser") << "mkLambdaWrapper: kind " << k << " and type " << argType
<< "\n";
- std::vector<api::Term> lvars;
- std::vector<api::Sort> domainTypes = argType.getFunctionDomainSorts();
+ std::vector<cvc5::Term> lvars;
+ std::vector<cvc5::Sort> domainTypes = argType.getFunctionDomainSorts();
for (unsigned i = 0, size = domainTypes.size(); i < size; ++i)
{
// the introduced variable is internal (not parsable)
std::stringstream ss;
ss << "_lvar_" << i;
- api::Term v = d_solver->mkVar(domainTypes[i], ss.str());
+ cvc5::Term v = d_solver->mkVar(domainTypes[i], ss.str());
lvars.push_back(v);
}
// apply body of lambda to variables
- api::Term wrapper =
- d_solver->mkTerm(api::LAMBDA,
- {d_solver->mkTerm(api::VARIABLE_LIST, lvars),
+ cvc5::Term wrapper =
+ d_solver->mkTerm(cvc5::LAMBDA,
+ {d_solver->mkTerm(cvc5::VARIABLE_LIST, lvars),
d_solver->mkTerm(k, lvars)});
return wrapper;
}
-api::Term Tptp::getAssertionExpr(FormulaRole fr, api::Term expr)
+cvc5::Term Tptp::getAssertionExpr(FormulaRole fr, cvc5::Term expr)
{
switch (fr) {
case FR_AXIOM:
return expr;
case FR_CONJECTURE:
// it should be negated when asserted
- return d_solver->mkTerm(api::NOT, {expr});
+ return d_solver->mkTerm(cvc5::NOT, {expr});
case FR_UNKNOWN:
case FR_FI_DOMAIN:
case FR_FI_FUNCTORS:
return d_nullExpr;
}
-api::Term Tptp::getAssertionDistinctConstants()
+cvc5::Term Tptp::getAssertionDistinctConstants()
{
- std::vector<api::Term> constants;
- for (std::pair<const std::string, api::Term>& cs : d_distinct_objects)
+ std::vector<cvc5::Term> constants;
+ for (std::pair<const std::string, cvc5::Term>& cs : d_distinct_objects)
{
constants.push_back(cs.second);
}
if (constants.size() > 1)
{
- return d_solver->mkTerm(api::DISTINCT, constants);
+ return d_solver->mkTerm(cvc5::DISTINCT, constants);
}
return d_nullExpr;
}
-Command* Tptp::makeAssertCommand(FormulaRole fr, api::Term expr, bool cnf)
+Command* Tptp::makeAssertCommand(FormulaRole fr, cvc5::Term expr, bool cnf)
{
// For SZS ontology compliance.
// if we're in cnf() though, conjectures don't result in "Theorem" or
namespace cvc5 {
class Command;
-
-namespace api {
class Solver;
-}
namespace parser {
void forceLogic(const std::string& logic) override;
- void addFreeVar(api::Term var);
- std::vector<api::Term> getFreeVar();
+ void addFreeVar(cvc5::Term var);
+ std::vector<cvc5::Term> getFreeVar();
- api::Term convertRatToUnsorted(api::Term expr);
+ cvc5::Term convertRatToUnsorted(cvc5::Term expr);
/**
* Returns a free constant corresponding to the string str. We ensure that
* these constants are one-to-one with str. We assert that all these free
* constants are pairwise distinct before issuing satisfiability queries.
*/
- api::Term convertStrToUnsorted(std::string str);
+ cvc5::Term convertStrToUnsorted(std::string str);
// CNF and FOF are unsorted so we define this common type.
- // This is also the api::Sort of $i in TFF.
- api::Sort d_unsorted;
+ // This is also the cvc5::Sort of $i in TFF.
+ cvc5::Sort d_unsorted;
enum Theory {
THEORY_CORE,
bool hasConjecture() const { return d_hasConjecture; }
protected:
- Tptp(api::Solver* solver,
+ Tptp(cvc5::Solver* solver,
SymbolManager* sm,
bool strictMode = false,
bool parseOnly = false);
* expression
* (lambda x1:t1,...,xn:tn . (k x1 ... xn)) : t
*/
- api::Term mkLambdaWrapper(api::Kind k, api::Sort argType);
+ cvc5::Term mkLambdaWrapper(cvc5::Kind k, cvc5::Sort argType);
/** get assertion expression, based on the formula role.
* expr should have Boolean type.
* This returns the expression that should be asserted, given the formula role fr.
* For example, if the role is "conjecture", then the return value is the negation of expr.
*/
- api::Term getAssertionExpr(FormulaRole fr, api::Term expr);
+ cvc5::Term getAssertionExpr(FormulaRole fr, cvc5::Term expr);
/** get assertion for distinct constants
*
* are the distinct constants introduced by this parser (see
* convertStrToUnsorted) if n>1, or null otherwise.
*/
- api::Term getAssertionDistinctConstants();
+ cvc5::Term getAssertionDistinctConstants();
/** returns the appropriate AssertCommand, given a role, expression expr to
* assert, and information about the assertion. The assertion expr is
* getAssertionExpr above). This may set a flag in the parser to mark
* that we have asserted a conjecture.
*/
- Command* makeAssertCommand(FormulaRole fr, api::Term expr, bool cnf);
+ Command* makeAssertCommand(FormulaRole fr, cvc5::Term expr, bool cnf);
/** Ugly hack because I don't know how to return an expression from a
token */
- api::Term d_tmp_expr;
+ cvc5::Term d_tmp_expr;
/** Push a new stream in the lexer. When EOF is reached the previous stream
is reused */
void includeFile(std::string fileName);
/** Check a TPTP let binding for well-formedness. */
- void checkLetBinding(const std::vector<api::Term>& bvlist,
- api::Term lhs,
- api::Term rhs,
+ void checkLetBinding(const std::vector<cvc5::Term>& bvlist,
+ cvc5::Term lhs,
+ cvc5::Term rhs,
bool formula);
/**
* This converts a ParseOp to expression, assuming it is a standalone term.
* There are three cases in TPTP: either p already has an expression, in which
* case this function just returns it, or p has just a name or a builtin kind.
*/
- api::Term parseOpToExpr(ParseOp& p);
+ cvc5::Term parseOpToExpr(ParseOp& p);
/**
* Apply parse operator to list of arguments, and return the resulting
* expression.
* been previously declared, which leads to a more convoluted processing than
* what is necessary in parsing SMT-LIB.
*/
- api::Term applyParseOp(ParseOp& p, std::vector<api::Term>& args);
+ cvc5::Term applyParseOp(ParseOp& p, std::vector<cvc5::Term>& args);
/**
* Make decimal, returns a real corresponding to string ( snum "." sden ),
* negated if pos is false, having exponent exp, negated exponent if posE is
* false.
*/
- api::Term mkDecimal(
+ cvc5::Term mkDecimal(
std::string& snum, std::string& sden, bool pos, size_t exp, bool posE);
private:
void addArithmeticOperators();
/** is the name declared, if so, return the term for that name */
- api::Term isTptpDeclared(const std::string& name);
+ cvc5::Term isTptpDeclared(const std::string& name);
// In CNF variable are implicitly binded
// d_freevar collect them
- std::vector<api::Term> d_freeVar;
- api::Term d_rtu_op;
- api::Term d_stu_op;
- api::Term d_utr_op;
- api::Term d_uts_op;
+ std::vector<cvc5::Term> d_freeVar;
+ cvc5::Term d_rtu_op;
+ cvc5::Term d_stu_op;
+ cvc5::Term d_utr_op;
+ cvc5::Term d_uts_op;
// The set of expression that already have a bridge
- std::unordered_set<api::Term> d_r_converted;
- std::unordered_map<std::string, api::Term> d_distinct_objects;
+ std::unordered_set<cvc5::Term> d_r_converted;
+ std::unordered_map<std::string, cvc5::Term> d_distinct_objects;
/**
* TPTP automatically declares symbols as they are parsed inline. This
* requires using an auxiliary symbol table for such symbols. This must be
* independent of the main symbol table which is aware of quantifier
* scopes.
*/
- std::unordered_map<std::string, api::Term> d_auxSymbolTable;
+ std::unordered_map<std::string, cvc5::Term> d_auxSymbolTable;
std::vector< pANTLR3_INPUT_STREAM > d_in_created;
std::string d_tptpDir;
// the null expression
- api::Term d_nullExpr;
+ cvc5::Term d_nullExpr;
// hack to make output SZS ontology-compliant
bool d_hasConjecture;
* Just exists to provide the uintptr_t constructor that ANTLR
* requires.
*/
-struct myExpr : public cvc5::api::Term
+struct myExpr : public cvc5::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::Term() {}
+ myExpr(void*) : cvc5::Term() {}
+ myExpr(const cvc5::Term& e) : cvc5::Term(e) {}
+ myExpr(const myExpr& e) : cvc5::Term(e) {}
}; /* struct myExpr*/
enum NonAssoc {
return d_pTptpParser->parseCommand(d_pTptpParser);
}
-api::Term TptpInput::parseExpr()
+cvc5::Term TptpInput::parseExpr()
{
return d_pTptpParser->parseExpr(d_pTptpParser);
}
/**
* Parse an expression from the input. Returns a null
- * <code>api::Term</code> if there is no expression there to parse.
+ * <code>cvc5::Term</code> if there is no expression there to parse.
*
* @throws ParserException if an error is encountered during parsing.
*/
- api::Term parseExpr() override;
+ cvc5::Term parseExpr() override;
};/* class TptpInput */
#include "smt/preprocess_proof_generator.h"
#include "theory/builtin/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
AssertionPipeline::AssertionPipeline(Env& env)
}
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/trust_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofGenerator;
namespace smt {
}; /* class AssertionPipeline */
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__ASSERTION_PIPELINE_H */
#include "theory/rewriter.h"
#include "theory/trust_substitutions.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
LearnedLiteralManager::LearnedLiteralManager(Env& env)
}
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
/**
};
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__LEARNED_LITERAL_MANAGER_H */
#include "preprocessing/assertion_pipeline.h"
#include "preprocessing/preprocessing_pass_context.h"
-using namespace cvc5;
-using namespace cvc5::theory;
+using namespace cvc5::internal;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/logic_info.h"
#include "theory/substitutions.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__ACKERMANN_H */
#include "smt/env.h"
#include "theory/substitutions.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
class PreprocessingPassContext;
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
BoolToBV::BoolToBV(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "bool-to-bv"),
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__BOOL_TO_BV_H */
#include "theory/theory_engine.h"
#include "theory/theory_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__BV_EAGER_ATOMS_H */
#include "theory/rewriter.h"
#include "util/bitvector.h"
-using namespace cvc5;
-using namespace cvc5::theory;
-using namespace cvc5::theory::bv;
+using namespace cvc5::internal;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::theory::bv;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
{
Node a = assertions.back();
assertions.pop_back();
- cvc5::Kind k = a.getKind();
+ cvc5::internal::Kind k = a.getKind();
if (k == kind::AND)
{
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "preprocessing/preprocessing_pass_context.h"
#include "theory/bv/theory_bv_utils.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
using NodeMap = std::unordered_map<Node, Node>;
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
BvIntroPow2::BvIntroPow2(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "bv-intro-pow2"){};
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__BV_INTRO_POW2_H */
#include "theory/rewriter.h"
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
BVToBool::BVToBool(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "bv-to-bool"),
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__BV_TO_BOOL_H */
#include "theory/bv/theory_bv_rewrite_rules_simplification.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace cvc5::theory;
-using namespace cvc5::theory::bv;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::theory::bv;
BVToInt::BVToInt(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "bv-to-int"),
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass_context.h"
#include "theory/bv/int_blaster.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* __CVC5__PREPROCESSING__PASSES__BV_TO_INT_H */
#include "preprocessing/assertion_pipeline.h"
#include "preprocessing/preprocessing_pass_context.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__EXTENDED_REWRITER_PASS_H */
#include "theory/rewriter.h"
#include "theory/strings/arith_entail.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
ForeignTheoryRewriter::ForeignTheoryRewriter(Env& env)
: EnvObj(env), d_cache(userContext())
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__FOREIGN_THEORY_REWRITE_H */
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::theory;
-using namespace cvc5::theory::quantifiers;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::theory::quantifiers;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__SYGUS_INFERENCE_H_ */
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::theory;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING_PASSES__GLOBAL_NEGATE_H */
#include "theory/rewriter.h"
#include "theory/uf/theory_uf_rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* __CVC5__PREPROCESSING__PASSES__HO_ELIM_PASS_H */
#include "util/bitvector.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
namespace {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__INT_TO_BV_H */
#include "theory/rewriter.h"
#include "theory/theory_preprocessor.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
// TODO (project #42): note this preprocessing pass is deprecated
IteRemoval::IteRemoval(PreprocessingPassContext* preprocContext)
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5__PREPROCESSING__PASSES__ITE_REMOVAL_H
#include "theory/theory_engine.h"
using namespace std;
-using namespace cvc5;
-using namespace cvc5::theory;
+using namespace cvc5::internal;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/util/ite_utilities.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::theory;
-using namespace cvc5::kind;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__LEARNED_REWRITE_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::theory;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__MIPLIB_TRICK_H */
#include "preprocessing/assertion_pipeline.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
Node NlExtPurify::purifyNlTerms(TNode n,
NodeMap& cache,
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__NL_EXT_PURIFY_H */
#include "theory/theory_model.h"
#include "theory/trust_substitutions.h"
-using namespace cvc5;
-using namespace cvc5::theory;
+using namespace cvc5::internal;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
#include "proof/trust_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class LazyCDProof;
class ProofNodeManager;
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/normal_form.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
-using namespace cvc5::theory;
-using namespace cvc5::theory::arith;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::theory::arith;
PseudoBooleanProcessor::PseudoBooleanProcessor(
PreprocessingPassContext* preprocContext)
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/substitutions.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5__PREPROCESSING__PASSES__PSEUDO_BOOLEAN_PROCESSOR_H
#include "theory/quantifiers/quantifiers_preprocess.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
QuantifiersPreprocess::QuantifiersPreprocess(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "quantifiers-preprocess"){};
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__QUANTIFIERS_PREPROCESS_H */
#include "theory/theory_model.h"
#include "util/rational.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__REAL_TO_INT_H */
#include "preprocessing/assertion_pipeline.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
Rewrite::Rewrite(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "rewrite"){};
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__REWRITE_H */
#include "theory/theory.h"
#include "theory/theory_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
using namespace std;
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
namespace {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__SEP_SKOLEM_EMP_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__SORT_INFERENCE_PASS_H_ */
#include "theory/rewriter.h"
#include "theory/theory_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/cdhashset.h"
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__STATIC_LEARNING_H */
#include "theory/rewriter.h"
#include "theory/strings/theory_strings_preprocess.h"
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__STRINGS_EAGER_PP_H */
#include "theory/smt_engine_subsolver.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::theory;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__SYGUS_INFERENCE_H_ */
#include "theory/quantifiers/term_util.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__SYNTH_REW_RULES_H */
#include "theory/rewriter.h"
#include "theory/theory_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
TheoryPreprocess::TheoryPreprocess(PreprocessingPassContext* preprocContext)
: PreprocessingPass(preprocContext, "theory-preprocess"){};
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__THEORY_PREPROCESS_H */
#include "preprocessing/preprocessing_pass_context.h"
#include "theory/theory_engine.h"
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/preprocessing_pass.h"
#include "proof/trust_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PASSES__THEORY_REWRITE_EQ_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::theory;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace passes {
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/substitutions.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
class Context;
}
} // namespace passes
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "smt/solver_engine_scope.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
PreprocessingPassResult PreprocessingPass::apply(
PreprocessingPass::~PreprocessingPass() { Assert(smt::solverEngineInScope()); }
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
class AssertionPipeline;
};
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PREPROCESSING_PASS_H */
#include "theory/theory_engine.h"
#include "theory/theory_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
PreprocessingPassContext::PreprocessingPassContext(
}
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/trust_substitutions.h"
#include "util/resource_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
class TheoryEngine;
}; // class PreprocessingPassContext
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PREPROCESSING_PASS_CONTEXT_H */
#include "preprocessing/passes/unconstrained_simplifier.h"
#include "preprocessing/preprocessing_pass.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
-using namespace cvc5::preprocessing::passes;
+using namespace cvc5::internal::preprocessing::passes;
PreprocessingPassRegistry& PreprocessingPassRegistry::getInstance()
{
}
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include <string>
#include <unordered_map>
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
class PreprocessingPass;
}; // class PreprocessingPassRegistry
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PREPROCESSING__PREPROCESSING_PASS_REGISTRY_H */
#include "util/rational.h"
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace util {
} // namespace util
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/hash.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
} // namespace util
} // namespace preprocessing
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace printer {
namespace ast {
}/* AstPrinter::toStream(TNode) */
template <class T>
-static bool tryToStream(std::ostream& out, const Command* c);
+static bool tryToStream(std::ostream& out, const cvc5::Command* c);
template <class T>
-static bool tryToStream(std::ostream& out, const CommandStatus* s);
+static bool tryToStream(std::ostream& out, const cvc5::CommandStatus* s);
-void AstPrinter::toStream(std::ostream& out, const CommandStatus* s) const
+void AstPrinter::toStream(std::ostream& out, const cvc5::CommandStatus* s) const
{
- if(tryToStream<CommandSuccess>(out, s) ||
- tryToStream<CommandFailure>(out, s) ||
- tryToStream<CommandUnsupported>(out, s) ||
- tryToStream<CommandInterrupted>(out, s)) {
+ if (tryToStream<cvc5::CommandSuccess>(out, s)
+ || tryToStream<cvc5::CommandFailure>(out, s)
+ || tryToStream<cvc5::CommandUnsupported>(out, s)
+ || tryToStream<cvc5::CommandInterrupted>(out, s))
+ {
return;
}
- out << "ERROR: don't know how to print a CommandStatus of class: "
+ out << "ERROR: don't know how to print a cvc5::CommandStatus of class: "
<< typeid(*s).name() << endl;
-}/* AstPrinter::toStream(CommandStatus*) */
+} /* AstPrinter::toStream(cvc5::CommandStatus*) */
void AstPrinter::toStream(std::ostream& out, const smt::Model& m) const
{
void AstPrinter::toStreamCmdEmpty(std::ostream& out,
const std::string& name) const
{
- out << "EmptyCommand(" << name << ')' << std::endl;
+ out << "Emptycvc5::Command(" << name << ')' << std::endl;
}
void AstPrinter::toStreamCmdEcho(std::ostream& out,
const std::string& output) const
{
- out << "EchoCommand(" << output << ')' << std::endl;
+ out << "Echocvc5::Command(" << output << ')' << std::endl;
}
void AstPrinter::toStreamCmdAssert(std::ostream& out, Node n) const
}
void AstPrinter::toStreamCmdDeclarationSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const
+ std::ostream& out, const std::vector<cvc5::Command*>& sequence) const
{
out << "DeclarationSequence[" << endl;
- for (CommandSequence::const_iterator i = sequence.cbegin();
+ for (cvc5::CommandSequence::const_iterator i = sequence.cbegin();
i != sequence.cend();
++i)
{
}
void AstPrinter::toStreamCmdCommandSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const
+ std::ostream& out, const std::vector<cvc5::Command*>& sequence) const
{
- out << "CommandSequence[" << endl;
- for (CommandSequence::const_iterator i = sequence.cbegin();
+ out << "cvc5::CommandSequence[" << endl;
+ for (cvc5::CommandSequence::const_iterator i = sequence.cbegin();
i != sequence.cend();
++i)
{
void AstPrinter::toStreamCmdDatatypeDeclaration(
std::ostream& out, const std::vector<TypeNode>& datatypes) const
{
- out << "DatatypeDeclarationCommand([";
+ out << "DatatypeDeclarationcvc5::Command([";
for (const TypeNode& t : datatypes)
{
out << t << ";" << endl;
}
template <class T>
-static bool tryToStream(std::ostream& out, const Command* c)
+static bool tryToStream(std::ostream& out, const cvc5::Command* c)
{
if(typeid(*c) == typeid(T)) {
toStream(out, dynamic_cast<const T*>(c));
return false;
}
-static void toStream(std::ostream& out, const CommandSuccess* s)
+static void toStream(std::ostream& out, const cvc5::CommandSuccess* s)
{
- if(Command::printsuccess::getPrintSuccess(out)) {
+ if (cvc5::Command::printsuccess::getPrintSuccess(out))
+ {
out << "OK" << endl;
}
}
-static void toStream(std::ostream& out, const CommandInterrupted* s)
+static void toStream(std::ostream& out, const cvc5::CommandInterrupted* s)
{
out << "INTERRUPTED" << endl;
}
-static void toStream(std::ostream& out, const CommandUnsupported* s)
+static void toStream(std::ostream& out, const cvc5::CommandUnsupported* s)
{
out << "UNSUPPORTED" << endl;
}
-static void toStream(std::ostream& out, const CommandFailure* s)
+static void toStream(std::ostream& out, const cvc5::CommandFailure* s)
{
out << s->getMessage() << endl;
}
template <class T>
-static bool tryToStream(std::ostream& out, const CommandStatus* s)
+static bool tryToStream(std::ostream& out, const cvc5::CommandStatus* s)
{
if(typeid(*s) == typeid(T)) {
toStream(out, dynamic_cast<const T*>(s));
} // namespace ast
} // namespace printer
-} // namespace cvc5
+} // namespace cvc5::internal
#include "printer/printer.h"
-namespace cvc5 {
+namespace cvc5::internal {
class LetBinding;
namespace printer {
namespace ast {
-class AstPrinter : public cvc5::Printer
+class AstPrinter : public cvc5::internal::Printer
{
public:
- using cvc5::Printer::toStream;
+ using cvc5::internal::Printer::toStream;
void toStream(std::ostream& out,
TNode n,
int toDepth,
size_t dag) const override;
- void toStream(std::ostream& out, const CommandStatus* s) const override;
+ void toStream(std::ostream& out, const cvc5::CommandStatus* s) const override;
void toStream(std::ostream& out, const smt::Model& m) const override;
/** Print empty command */
/** Print command sequence command */
void toStreamCmdCommandSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const override;
+ std::ostream& out,
+ const std::vector<cvc5::Command*>& sequence) const override;
/** Print declaration sequence command */
void toStreamCmdDeclarationSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const override;
+ std::ostream& out,
+ const std::vector<cvc5::Command*>& sequence) const override;
private:
void toStream(std::ostream& out,
} // namespace ast
} // namespace printer
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PRINTER__AST_PRINTER_H */
#include <sstream>
-namespace cvc5 {
+namespace cvc5::internal {
LetBinding::LetBinding(uint32_t thresh)
: d_thresh(thresh),
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/cdlist.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A flexible let binding class. This class provides functionalities for
NodeIdMap d_letMap;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
unique_ptr<Printer>
Printer::d_printers[static_cast<size_t>(Language::LANG_MAX)];
}
void Printer::toStreamCmdCommandSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const
+ std::ostream& out, const std::vector<cvc5::Command*>& sequence) const
{
printUnknownCommand(out, "sequence");
}
void Printer::toStreamCmdDeclarationSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const
+ std::ostream& out, const std::vector<cvc5::Command*>& sequence) const
{
printUnknownCommand(out, "sequence");
}
-} // namespace cvc5
+} // namespace cvc5::internal
class Command;
class CommandStatus;
+
+namespace internal {
+
class UnsatCore;
struct InstantiationList;
struct SkolemList;
/** Print command sequence command */
virtual void toStreamCmdCommandSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const;
+ std::ostream& out, const std::vector<cvc5::Command*>& sequence) const;
/** Print declaration sequence command */
virtual void toStreamCmdDeclarationSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const;
+ std::ostream& out, const std::vector<cvc5::Command*>& sequence) const;
protected:
/** Derived classes can construct, but no one else. */
}; /* class Printer */
+} // namespace internal
} // namespace cvc5
#endif /* CVC5__PRINTER__PRINTER_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace printer {
namespace smt2 {
}
else
{
- out << cvc5::quoteSymbol(dt.getName());
+ out << cvc5::internal::quoteSymbol(dt.getName());
}
break;
}
out << '(';
}
if(n.getAttribute(expr::VarNameAttr(), name)) {
- out << cvc5::quoteSymbol(name);
+ out << cvc5::internal::quoteSymbol(name);
}
if(n.getNumChildren() != 0) {
for(unsigned i = 0; i < n.getNumChildren(); ++i) {
// abstract value
std::string s;
n.getAttribute(expr::VarNameAttr(), s);
- out << "(as @" << cvc5::quoteSymbol(s) << " " << n.getType() << ")";
+ out << "(as @" << cvc5::internal::quoteSymbol(s) << " " << n.getType() << ")";
return;
}
else if (n.isVar())
string s;
if (n.getAttribute(expr::VarNameAttr(), s))
{
- out << cvc5::quoteSymbol(s);
+ out << cvc5::internal::quoteSymbol(s);
}
else
{
Kind k = n.getKind();
if (n.getNumChildren() > 0 && n[0].getType().isSequence())
{
- // this method parallels api::Term::getKind
+ // this method parallels cvc5::Term::getKind
switch (k)
{
case kind::STRING_CONCAT: return "seq.concat";
}
template <class T>
-static bool tryToStream(std::ostream& out, const Command* c);
+static bool tryToStream(std::ostream& out, const cvc5::Command* c);
template <class T>
-static bool tryToStream(std::ostream& out, const Command* c, Variant v);
+static bool tryToStream(std::ostream& out, const cvc5::Command* c, Variant v);
template <class T>
-static bool tryToStream(std::ostream& out, const CommandStatus* s, Variant v);
+static bool tryToStream(std::ostream& out,
+ const cvc5::CommandStatus* s,
+ Variant v);
-void Smt2Printer::toStream(std::ostream& out, const CommandStatus* s) const
+void Smt2Printer::toStream(std::ostream& out,
+ const cvc5::CommandStatus* s) const
{
- if (tryToStream<CommandSuccess>(out, s, d_variant) ||
- tryToStream<CommandFailure>(out, s, d_variant) ||
- tryToStream<CommandRecoverableFailure>(out, s, d_variant) ||
- tryToStream<CommandUnsupported>(out, s, d_variant) ||
- tryToStream<CommandInterrupted>(out, s, d_variant)) {
+ if (tryToStream<cvc5::CommandSuccess>(out, s, d_variant)
+ || tryToStream<cvc5::CommandFailure>(out, s, d_variant)
+ || tryToStream<cvc5::CommandRecoverableFailure>(out, s, d_variant)
+ || tryToStream<cvc5::CommandUnsupported>(out, s, d_variant)
+ || tryToStream<cvc5::CommandInterrupted>(out, s, d_variant))
+ {
return;
}
- out << "ERROR: don't know how to print a CommandStatus of class: "
+ out << "ERROR: don't know how to print a cvc5::CommandStatus of class: "
<< typeid(*s).name() << endl;
-}/* Smt2Printer::toStream(CommandStatus*) */
+} /* Smt2Printer::toStream(cvc5::CommandStatus*) */
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::internal::quoteSymbol(cn) << std::endl;
}
}
else
}
void Smt2Printer::toStreamCmdCommandSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const
+ std::ostream& out, const std::vector<cvc5::Command*>& sequence) const
{
- for (Command* i : sequence)
+ for (cvc5::Command* i : sequence)
{
out << *i;
}
}
void Smt2Printer::toStreamCmdDeclarationSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const
+ std::ostream& out, const std::vector<cvc5::Command*>& sequence) const
{
toStreamCmdCommandSequence(out, sequence);
}
const std::string& id,
TypeNode type) const
{
- out << "(declare-fun " << cvc5::quoteSymbol(id) << " (";
+ out << "(declare-fun " << cvc5::internal::quoteSymbol(id) << " (";
if (type.isFunction())
{
const vector<TypeNode> argTypes = type.getArgTypes();
TypeNode type,
const std::vector<Node>& initValue) const
{
- out << "(declare-pool " << cvc5::quoteSymbol(id) << ' ' << type << " (";
+ out << "(declare-pool " << cvc5::internal::quoteSymbol(id) << ' ' << type << " (";
for (size_t i = 0, n = initValue.size(); i < n; ++i)
{
if (i != 0) {
TypeNode range,
Node formula) const
{
- out << "(define-fun " << cvc5::quoteSymbol(id) << " (";
+ out << "(define-fun " << cvc5::internal::quoteSymbol(id) << " (";
if (!formals.empty())
{
vector<Node>::const_iterator i = formals.cbegin();
const std::vector<TypeNode>& params,
TypeNode t) const
{
- out << "(define-sort " << cvc5::quoteSymbol(id) << " (";
+ out << "(define-sort " << cvc5::internal::quoteSymbol(id) << " (";
if (params.size() > 0)
{
copy(
{
out << " ";
}
- out << "(" << cvc5::quoteSymbol(cons.getName());
+ out << "(" << cvc5::internal::quoteSymbol(cons.getName());
for (size_t j = 0, nargs = cons.getNumArgs(); j < nargs; j++)
{
const DTypeSelector& arg = cons[j];
{
Assert(t.isDatatype());
const DType& d = t.getDType();
- out << "(" << cvc5::quoteSymbol(d.getName());
+ out << "(" << cvc5::internal::quoteSymbol(d.getName());
out << " " << d.getNumParameters() << ")";
}
out << ") (";
void Smt2Printer::toStreamCmdEcho(std::ostream& out,
const std::string& output) const
{
- out << "(echo " << cvc5::quoteString(output) << ')' << std::endl;
+ out << "(echo " << cvc5::internal::quoteString(output) << ')' << std::endl;
}
/*
Node conj,
TypeNode sygusType) const
{
- out << "(get-interpolant " << cvc5::quoteSymbol(name) << ' ' << conj;
+ out << "(get-interpolant " << cvc5::internal::quoteSymbol(name) << ' ' << conj;
if (!sygusType.isNull())
{
out << ' ' << sygusGrammarString(sygusType);
*/
template <class T>
-static bool tryToStream(std::ostream& out, const Command* c)
+static bool tryToStream(std::ostream& out, const cvc5::Command* c)
{
if(typeid(*c) == typeid(T)) {
toStream(out, dynamic_cast<const T*>(c));
}
template <class T>
-static bool tryToStream(std::ostream& out, const Command* c, Variant v)
+static bool tryToStream(std::ostream& out, const cvc5::Command* c, Variant v)
{
if(typeid(*c) == typeid(T)) {
toStream(out, dynamic_cast<const T*>(c), v);
return false;
}
-static void toStream(std::ostream& out, const CommandSuccess* s, Variant v)
+static void toStream(std::ostream& out,
+ const cvc5::CommandSuccess* s,
+ Variant v)
{
- if(Command::printsuccess::getPrintSuccess(out)) {
+ if (cvc5::Command::printsuccess::getPrintSuccess(out))
+ {
out << "success" << endl;
}
}
-static void toStream(std::ostream& out, const CommandInterrupted* s, Variant v)
+static void toStream(std::ostream& out,
+ const cvc5::CommandInterrupted* s,
+ Variant v)
{
out << "interrupted" << endl;
}
-static void toStream(std::ostream& out, const CommandUnsupported* s, Variant v)
+static void toStream(std::ostream& out,
+ const cvc5::CommandUnsupported* s,
+ Variant v)
{
#ifdef CVC5_COMPETITION_MODE
// if in competition mode, lie and say we're ok
static void errorToStream(std::ostream& out, std::string message, Variant v)
{
- out << "(error " << cvc5::quoteString(message) << ')' << endl;
+ out << "(error " << cvc5::internal::quoteString(message) << ')' << endl;
}
-static void toStream(std::ostream& out, const CommandFailure* s, Variant v) {
+static void toStream(std::ostream& out,
+ const cvc5::CommandFailure* s,
+ Variant v)
+{
errorToStream(out, s->getMessage(), v);
}
-static void toStream(std::ostream& out, const CommandRecoverableFailure* s,
- Variant v) {
+static void toStream(std::ostream& out,
+ const cvc5::CommandRecoverableFailure* s,
+ Variant v)
+{
errorToStream(out, s->getMessage(), v);
}
template <class T>
-static bool tryToStream(std::ostream& out, const CommandStatus* s, Variant v)
+static bool tryToStream(std::ostream& out,
+ const cvc5::CommandStatus* s,
+ Variant v)
{
if(typeid(*s) == typeid(T)) {
toStream(out, dynamic_cast<const T*>(s), v);
} // namespace smt2
} // namespace printer
-} // namespace cvc5
+} // namespace cvc5::internal
#include "printer/printer.h"
-namespace cvc5 {
+namespace cvc5::internal {
class LetBinding;
// support for the string standard
}; /* enum Variant */
-class Smt2Printer : public cvc5::Printer
+class Smt2Printer : public cvc5::internal::Printer
{
public:
Smt2Printer(Variant variant = no_variant) : d_variant(variant) {}
- using cvc5::Printer::toStream;
+ using cvc5::internal::Printer::toStream;
void toStream(std::ostream& out,
TNode n,
int toDepth,
size_t dag) const override;
- void toStream(std::ostream& out, const CommandStatus* s) const override;
+ void toStream(std::ostream& out, const cvc5::CommandStatus* s) const override;
void toStream(std::ostream& out, const smt::Model& m) const override;
/**
* Writes the unsat core to the stream out.
/** Print command sequence command */
void toStreamCmdCommandSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const override;
+ std::ostream& out,
+ const std::vector<cvc5::Command*>& sequence) const override;
/** Print declaration sequence command */
void toStreamCmdDeclarationSequence(
- std::ostream& out, const std::vector<Command*>& sequence) const override;
+ std::ostream& out,
+ const std::vector<cvc5::Command*>& sequence) const override;
/**
* Get the string for a kind k, which returns how the kind k is printed in
} // namespace smt2
} // namespace printer
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PRINTER__SMT2_PRINTER_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace printer {
namespace tptp {
} // namespace tptp
} // namespace printer
-} // namespace cvc5
+} // namespace cvc5::internal
#include "printer/printer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace printer {
namespace tptp {
-class TptpPrinter : public cvc5::Printer
+class TptpPrinter : public cvc5::internal::Printer
{
public:
- using cvc5::Printer::toStream;
+ using cvc5::internal::Printer::toStream;
void toStream(std::ostream& out,
TNode n,
int toDepth,
} // namespace tptp
} // namespace printer
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PRINTER__TPTP_PRINTER_H */
#include "expr/node_algorithm.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
AletheNodeConverter::AletheNodeConverter() {}
bool AletheNodeConverter::shouldTraverse(Node n) { return expr::hasClosure(n); }
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/node_converter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
/**
};
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/alethe/alethe_nosubtype_node_converter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
Node AletheNoSubtypeNodeConverter::postConvert(Node n)
}
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/node_converter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
/**
};
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/builtin/proof_checker.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/alethe/alethe_proof_rule.h"
#include "proof/proof_node_updater.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/alethe/alethe_proof_rule.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC4__PROOF__ALETHE_PROOF_PRINTER_H */
#include "proof/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC4__PROOF__ALETHE_PROOF_RULE_H */
#include "proof/proof_node.h"
#include "proof/proof_node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
AnnotationProofGenerator::AnnotationProofGenerator(ProofNodeManager* pnm,
context::Context* c,
std::string AnnotationProofGenerator::identify() const { return d_name; }
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_generator.h"
#include "proof/trust_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
NodeProofNodeMap d_proofs;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__ANNOTATION_PROOF_GENERATOR_H */
#include "proof/proof_node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
AssumptionProofGenerator::AssumptionProofGenerator(ProofNodeManager* pnm)
: d_pnm(pnm)
return "AssumptionProofGenerator";
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
ProofNodeManager* d_pnm;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__ASSUMPTION_PROOF_GENERATOR_H */
#include "proof/proof.h"
#include "proof/proof_node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
BufferedProofGenerator::BufferedProofGenerator(context::Context* c,
ProofNodeManager* pnm)
return true;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/cdhashmap.h"
#include "proof/proof_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
class ProofStep;
ProofNodeManager* d_pnm;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__BUFFERED_PROOF_GENERATOR_H */
#ifndef CVC5__PROOF__CLAUSE_ID_H
#define CVC5__PROOF__CLAUSE_ID_H
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A ClauseId is a shared identifier between the proofs module and the sat
const ClauseId ClauseIdUndef(-2);
const ClauseId ClauseIdError(-3);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__CLAUSE_ID_H */
#include "proof/proof_node.h"
#include "proof/proof_node_algorithm.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& out, TConvPolicy tcpol)
{
return ss.str();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/lazy_proof.h"
#include "proof/proof_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
class TermContext;
std::string toStringDebug() const;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__CONV_PROOF_GENERATOR_H */
#include "proof/proof_node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
TConvSeqProofGenerator::TConvSeqProofGenerator(
ProofNodeManager* pnm,
std::string TConvSeqProofGenerator::identify() const { return d_name; }
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_generator.h"
#include "proof/trust_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
std::string d_name;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__CONV_SEQ_PROOF_GENERATOR_H */
#include "proof/proof_node_manager.h"
#include "theory/builtin/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
DotPrinter::DotPrinter()
}
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "printer/let_binding.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
class DotPrinter
};
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/proof_node.h"
#include "proof/proof_node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
EagerProofGenerator::EagerProofGenerator(ProofNodeManager* pnm,
context::Context* c,
std::string EagerProofGenerator::identify() const { return d_name; }
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_rule.h"
#include "proof/trust_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNode;
class ProofNodeManager;
NodeProofNodeMap d_proofs;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__PROOF_GENERATOR_H */
#include "proof/proof_node.h"
#include "proof/proof_node_manager.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
LazyCDProof::LazyCDProof(ProofNodeManager* pnm,
ProofGenerator* dpg,
return it != d_gens.end();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/cdhashset.h"
#include "proof/proof.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofGenerator;
class ProofNodeManager;
ProofNodeSet d_allVisited;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__LAZY_PROOF_H */
#include "proof/proof_node_algorithm.h"
#include "proof/proof_node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
LazyCDProofChain::LazyCDProofChain(ProofNodeManager* pnm,
bool cyclic,
std::string LazyCDProofChain::identify() const { return d_name; }
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
std::string d_name;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__LAZY_PROOF_CHAIN_H */
#include "proof/proof_node.h"
#include "proof/proof_node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
LazyTreeProofGenerator::LazyTreeProofGenerator(ProofNodeManager* pnm,
const std::string& name)
return os;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_generator.h"
#include "proof/proof_node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace detail {
/**
* A single node in the proof tree created by the LazyTreeProofGenerator.
*/
std::ostream& operator<<(std::ostream& os, const LazyTreeProofGenerator& ltpg);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/lfsc/lfsc_list_sc_node_converter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
LfscListScNodeConverter::LfscListScNodeConverter(
}
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_converter.h"
#include "proof/lfsc/lfsc_node_converter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
/**
};
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/regexp.h"
#include "util/string.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
LfscNodeConverter::LfscNodeConverter()
}
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_converter.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
/**
};
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/proof_node_manager.h"
#include "proof/proof_node_updater.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
LfscProofPostprocessCallback::LfscProofPostprocessCallback(
}
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/lfsc/lfsc_util.h"
#include "proof/proof_node_updater.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofChecker;
};
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/lfsc/lfsc_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
LfscPrintChannelOut::LfscPrintChannelOut(std::ostream& out) : d_out(out) {}
}
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/lfsc/lfsc_util.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
/**
};
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/lfsc/lfsc_list_sc_node_converter.h"
#include "proof/lfsc/lfsc_print_channel.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
LfscPrinter::LfscPrinter(LfscNodeConverter& ltp)
}
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/print_expr.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
class LfscPrintChannel;
};
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/proof_checker.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
const char* toString(LfscRule id)
}
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_letify.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
/**
};
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/proof_checker.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
const char* toString(MethodId id)
{
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Identifiers for rewriters and substitutions, which we abstractly
MethodId ida,
MethodId idr);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__METHOD_ID_H */
#include "proof/print_expr.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
PExprStream::PExprStream(std::vector<PExpr>& stream, Node tt, Node ff)
}
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
/**
};
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/proof_node.h"
#include "proof/proof_node_manager.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
CDProof::CDProof(ProofNodeManager* pnm,
context::Context* c,
std::string CDProof::identify() const { return d_name; }
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_generator.h"
#include "proof/proof_step_buffer.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNode;
class ProofNodeManager;
void notifyNewProof(Node expected);
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__PROOF_MANAGER_H */
#include "smt/smt_statistics_registry.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
Node ProofRuleChecker::check(PfRule id,
const std::vector<Node>& children,
return false;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_rule.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofChecker;
class ProofNode;
bool enableOutput);
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__PROOF_CHECKER_H */
#include "proof/proof_node.h"
#include "proof/proof_node_algorithm.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Ensure closed with respect to assumptions, internal version, which
ensureClosedWrtInternal(Node::null(), nullptr, pn, assumps, c, ctx, false);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofGenerator;
class ProofNode;
const std::vector<Node>& assumps,
const char* c,
const char* ctx);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__PROOF_ENSURE_CLOSED_H */
#include "proof/proof_node.h"
#include "proof/proof_node_algorithm.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& out, CDPOverwrite opol)
{
return false;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class CDProof;
class ProofNode;
virtual std::string identify() const = 0;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__PROOF_GENERATOR_H */
#include "proof/proof_letify.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
bool ProofLetifyTraverseCallback::shouldTraverse(const ProofNode* pn)
}
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace proof {
/**
};
} // namespace proof
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/proof_node_algorithm.h"
#include "proof/proof_node_to_sexpr.h"
-namespace cvc5 {
+namespace cvc5::internal {
ProofNode::ProofNode(PfRule id,
const std::vector<std::shared_ptr<ProofNode>>& children,
return static_cast<size_t>(ret);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_rule.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
class ProofNode;
*/
std::ostream& operator<<(std::ostream& out, const ProofNode& pn);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__PROOF_NODE_H */
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace expr {
void getFreeAssumptions(ProofNode* pn, std::vector<Node>& assump)
}
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNode;
const std::vector<Node>& args);
} // namespace expr
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__PROOF_NODE_ALGORITHM_H */
#include "proof/proof_node_algorithm.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
ProofNodeManager::ProofNodeManager(const Options& opts,
theory::Rewriter* rr,
return true;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_rule.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofChecker;
class ProofNode;
bool needsCheck);
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__PROOF_NODE_H */
#include "proof/proof_node.h"
#include "theory/builtin/proof_checker.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
ProofNodeToSExpr::ProofNodeToSExpr()
{
return ArgFormat::DEFAULT;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_id.h"
#include "theory/theory_id.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNode;
ArgFormat getArgumentFormat(const ProofNode* pn, size_t i);
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__PROOF_RULE_H */
#include "proof/proof_node_algorithm.h"
#include "proof/proof_node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
ProofNodeUpdaterCallback::ProofNodeUpdaterCallback() {}
ProofNodeUpdaterCallback::~ProofNodeUpdaterCallback() {}
d_debugFreeAssumps = true;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class CDProof;
class ProofNode;
bool d_autoSym;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <iostream>
-namespace cvc5 {
+namespace cvc5::internal {
const char* toString(PfRule id)
{
return static_cast<size_t>(id);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
/**
* \verbatim embed:rst:leading-asterisk
* theory, including the theory of equality.
*
* The "core rules" include two distinguished rules which have special status:
- * (1) :cpp:enumerator:`ASSUME <cvc5::PfRule::ASSUME>`, which represents an open
- * leaf in a proof; and (2) :cpp:enumerator:`SCOPE <cvc5::PfRule::SCOPE>`, which
+ * (1) :cpp:enumerator:`ASSUME <cvc5::internal::PfRule::ASSUME>`, which represents an open
+ * leaf in a proof; and (2) :cpp:enumerator:`SCOPE <cvc5::internal::PfRule::SCOPE>`, which
* encloses a scope (a subproof) with a set of scoped assumptions. The core rules additionally correspond to
* generic operations that are done internally on nodes, e.g. calling
* Rewriter::rewrite.
* open leaf in a proof that is not (yet) justified. An assume leaf is
* analogous to a free variable in a term, where we say "F is a free
* assumption in proof P" if it contains an application of F that is not
- * bound by :cpp:enumerator:`SCOPE <cvc5::PfRule::SCOPE>` (see below).
+ * bound by :cpp:enumerator:`SCOPE <cvc5::internal::PfRule::SCOPE>` (see below).
* \endverbatim
*/
ASSUME,
* \dots F_n}{\neg (F_1 \land \dots \land F_n)}{if $F=\bot$}
*
* This rule has a dual purpose with :cpp:enumerator:`ASSUME
- * <cvc5::PfRule::ASSUME>`. It is a way to close assumptions in a proof. We
+ * <cvc5::internal::PfRule::ASSUME>`. It is a way to close assumptions in a proof. We
* require that :math:`F_1 \dots F_n` are free assumptions in P and say that
* :math:`F_1 \dots F_n` are not free in ``(SCOPE P)``. In other words, they
* are bound by this application. For example, the proof node:
* where :math:`ids` and :math:`idr` are method identifiers.
*
* We rewrite only on the Skolem form of :math:`F`, similar to
- * :cpp:enumerator:`MACRO_SR_EQ_INTRO <cvc5::PfRule::MACRO_SR_EQ_INTRO>`.
+ * :cpp:enumerator:`MACRO_SR_EQ_INTRO <cvc5::internal::PfRule::MACRO_SR_EQ_INTRO>`.
* \endverbatim
*/
MACRO_SR_PRED_ELIM,
* \texttt{Rewriter::rewrite}(\texttt{toOriginal}(G'))` where :math:`F'` and
* :math:`G'` are the result of each side of the equation above. Here,
* original forms are used in a similar manner to
- * :cpp:enumerator:`MACRO_SR_PRED_INTRO <cvc5::PfRule::MACRO_SR_PRED_INTRO>`
+ * :cpp:enumerator:`MACRO_SR_PRED_INTRO <cvc5::internal::PfRule::MACRO_SR_PRED_INTRO>`
* above. \endverbatim
*/
MACRO_SR_PRED_TRANSFORM,
* where
*
* - let :math:`C_1 \dots C_n` be nodes viewed as clauses, as defined in
- * :cpp:enumerator:`RESOLUTION <cvc5::PfRule::RESOLUTION>`
+ * :cpp:enumerator:`RESOLUTION <cvc5::internal::PfRule::RESOLUTION>`
* - let :math:`C_1 \diamond{L,\mathit{pol}} C_2` represent the resolution of
* :math:`C_1` with :math:`C_2` with pivot :math:`L` and polarity
* :math:`pol`, as defined in
- * :cpp:enumerator:`RESOLUTION <cvc5::PfRule::RESOLUTION>`
+ * :cpp:enumerator:`RESOLUTION <cvc5::internal::PfRule::RESOLUTION>`
* - let :math:`C_1'` be equal, in its set representation, to :math:`C_1`,
* - for each :math:`i > 1`, let :math:`C_i'` be equal, it its set
* representation, to :math:`C_{i-1} \diamond{L_{i-1},\mathit{pol}_{i-1}}
* **Boolean -- N-ary Resolution + Factoring + Reordering unchecked**
*
* Same as :cpp:enumerator:`MACRO_RESOLUTION
- * <cvc5::PfRule::MACRO_RESOLUTION>`, but not checked by the internal proof
+ * <cvc5::internal::PfRule::MACRO_RESOLUTION>`, but not checked by the internal proof
* checker. \endverbatim
*/
MACRO_RESOLUTION_TRUST,
* \inferrule{F_1, (F_1 = F_2) \mid -}{F_2}
*
* Note this can optionally be seen as a macro for
- * :cpp:enumerator:`EQUIV_ELIM1 <cvc5::PfRule::EQUIV_ELIM1>` +
- * :cpp:enumerator:`RESOLUTION <cvc5::PfRule::RESOLUTION>`.
+ * :cpp:enumerator:`EQUIV_ELIM1 <cvc5::internal::PfRule::EQUIV_ELIM1>` +
+ * :cpp:enumerator:`RESOLUTION <cvc5::internal::PfRule::RESOLUTION>`.
* \endverbatim
*/
EQ_RESOLVE,
* \inferrule{F_1, (F_1 \rightarrow F_2) \mid -}{F_2}
*
* Note this can optionally be seen as a macro for
- * :cpp:enumerator:`IMPLIES_ELIM <cvc5::PfRule::IMPLIES_ELIM>` +
- * :cpp:enumerator:`RESOLUTION <cvc5::PfRule::RESOLUTION>`.
+ * :cpp:enumerator:`IMPLIES_ELIM <cvc5::internal::PfRule::IMPLIES_ELIM>` +
+ * :cpp:enumerator:`RESOLUTION <cvc5::internal::PfRule::RESOLUTION>`.
* \endverbatim
*/
MODUS_PONENS,
* **Arithmetic -- Coverings -- Recursive interval**
*
* See :cpp:enumerator:`ARITH_NL_COVERING_DIRECT
- * <cvc5::PfRule::ARITH_NL_COVERING_DIRECT>` for the necessary definitions.
+ * <cvc5::internal::PfRule::ARITH_NL_COVERING_DIRECT>` for the necessary definitions.
*
* .. math::
* \inferrule{\texttt{Cell}, \texttt{Covering} \mid -}{\bot}
size_t operator()(PfRule id) const;
}; /* struct PfRuleHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__PROOF_RULE_H */
#include "context/context.h"
#include "proof/proof_node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A (context-dependent) set of proofs, which is used for memory
std::string d_namePrefix;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__LAZY_PROOF_SET_H */
#include "proof/proof.h"
#include "proof/proof_checker.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
ProofStep::ProofStep() : d_rule(PfRule::UNKNOWN) {}
ProofStep::ProofStep(PfRule r,
d_allSteps.clear();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_rule.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofChecker;
std::unordered_set<Node> d_allSteps;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__PROOF_STEP_BUFFER_H */
#include "proof/proof.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
TheoryProofStepBuffer::TheoryProofStepBuffer(ProofChecker* pc,
bool ensureUnique,
return n;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_step_buffer.h"
#include "theory/builtin/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Class used to speculatively try and buffer a set of proof steps before
* sending them to a proof object, extended with theory-specfic proof rule
Node elimDoubleNegLit(Node n);
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__THEORY_PROOF_STEP_BUFFER_H */
#include "proof/proof_ensure_closed.h"
#include "proof/proof_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
const char* toString(TrustNodeKind tnk)
{
return out;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofGenerator;
class ProofNode;
*/
std::ostream& operator<<(std::ostream& out, TrustNode n);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROOF__TRUST_NODE_H */
#include "printer/printer.h"
#include "smt/solver_engine_scope.h"
-namespace cvc5 {
+namespace cvc5::internal {
UnsatCore::UnsatCore(const std::vector<Node>& core)
: d_useNames(false), d_core(core), d_names()
return out;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* An unsat core, which can optionally be initialized as a list of names
/** Print the unsat core to stream out */
std::ostream& operator<<(std::ostream& out, const UnsatCore& core);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__UNSAT_CORE_H */
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::internal::MiniSat
namespace. The build process has been modified. Other parts have
been modified to serve cvc5's purposes.
#include "util/resource_manager.h"
#include "util/statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
using CadicalLit = int;
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include <cadical.hpp>
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
class CadicalSolver : public SatSolver
};
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5__PROP__CADICAL_H
#include "theory/theory.h"
#include "theory/theory_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
CnfStream::CnfStream(Env& env,
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include "prop/sat_solver_types.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
}; /* class CnfStream */
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROP__CNF_STREAM_H */
#include "util/resource_manager.h"
#include "util/statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
using CMSatVar = unsigned;
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
class SATSolver;
}
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
class CryptoMinisatSolver : public SatSolver
};
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5_USE_CRYPTOMINISAT
#endif // CVC5__PROP__CRYPTOMINISAT_H
#include "base/check.h"
#include "util/statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
using KissatLit = int32_t;
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5_USE_KISSAT
#include <kissat/kissat.h>
}
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
class KissatSolver : public SatSolver
};
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5_USE_KISSAT
#endif // CVC5__PROP__KISSAT_H
#include "prop/minisat/utils/ParseUtils.h"
#include "prop/minisat/core/SolverTypes.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "prop/minisat/mtl/Sort.h"
#include "prop/theory_proxy.h"
-using namespace cvc5::prop;
+using namespace cvc5::internal::prop;
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
namespace {
// Writes to Trace macro for propagation tracing
static inline void dtviewBoolPropagationHelper(size_t level,
Lit& l,
- cvc5::prop::TheoryProxy* proxy,
+ cvc5::internal::prop::TheoryProxy* proxy,
bool incremental)
{
Trace("dtview::prop") << std::string(level + 1 - (incremental ? 1 : 0), ' ')
// Writes to Trace macro for conflict tracing
static inline void dtviewPropConflictHelper(size_t level,
Clause& confl,
- cvc5::prop::TheoryProxy* proxy,
+ cvc5::internal::prop::TheoryProxy* proxy,
bool incremental)
{
Trace("dtview::conflict")
// Constructor/Destructor:
Solver::Solver(Env& env,
- cvc5::prop::TheoryProxy* proxy,
- cvc5::context::Context* context,
- cvc5::context::UserContext* userContext,
+ cvc5::internal::prop::TheoryProxy* proxy,
+ cvc5::internal::context::Context* context,
+ cvc5::internal::context::UserContext* userContext,
ProofNodeManager* pnm,
bool enableIncremental)
: EnvObj(env),
Trace("pf::sat") << "\n";
}
- Trace("pf::sat") << cvc5::push;
+ Trace("pf::sat") << cvc5::internal::push;
for (int j = (p == lit_Undef) ? 0 : 1, size = ca[confl].size();
j < size;
j++)
}
}
}
- Trace("pf::sat") << cvc5::pop;
+ Trace("pf::sat") << cvc5::internal::pop;
// Select next clause to look at:
while (!seen[var(trail[index--])]);
// theory propagation
if (type == CHECK_FINAL) {
// Do the theory check
- theoryCheck(cvc5::theory::Theory::EFFORT_FULL);
+ theoryCheck(cvc5::internal::theory::Theory::EFFORT_FULL);
// Pick up the theory propagated literals (there could be some,
// if new lemmas are added)
propagateTheory();
if (confl == CRef_Undef && type != CHECK_WITHOUT_THEORY) {
// Do the theory check
if (type == CHECK_FINAL_FAKE) {
- theoryCheck(cvc5::theory::Theory::EFFORT_FULL);
+ theoryCheck(cvc5::internal::theory::Theory::EFFORT_FULL);
} else {
- theoryCheck(cvc5::theory::Theory::EFFORT_STANDARD);
+ theoryCheck(cvc5::internal::theory::Theory::EFFORT_STANDARD);
}
// Pick up the theory propagated literals
propagateTheory();
|
| Note: the propagation queue might be NOT empty
|________________________________________________________________________________________________@*/
-void Solver::theoryCheck(cvc5::theory::Theory::Effort effort)
+void Solver::theoryCheck(cvc5::internal::theory::Theory::Effort effort)
{
d_proxy->theoryCheck(effort);
}
--assertionLevel;
Trace("minisat") << "in user pop, decreasing assertion level to "
<< assertionLevel << "\n"
- << cvc5::push;
+ << cvc5::internal::push;
while (true) {
Trace("minisat") << "== unassigning " << trail.last() << std::endl;
Var x = var(trail.last());
// Remove the clauses
removeClausesAboveLevel(clauses_persistent, assertionLevel);
removeClausesAboveLevel(clauses_removable, assertionLevel);
- Trace("minisat") << cvc5::pop;
+ Trace("minisat") << cvc5::internal::pop;
// Pop the SAT context to notify everyone
d_context->pop(); // SAT context for cvc5
}
} // namespace Minisat
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "util/resource_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
class PropEngine;
class TheoryProxy;
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//=================================================================================================
class Solver : protected EnvObj
{
/** The only two cvc5 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::internal::prop::PropEngine;
+ friend class cvc5::internal::prop::TheoryProxy;
+ friend class cvc5::internal::prop::SatProofManager;
public:
static CRef TCRef_Undef;
protected:
/** The pointer to the proxy that provides interfaces to the SMT engine */
- cvc5::prop::TheoryProxy* d_proxy;
+ cvc5::internal::prop::TheoryProxy* d_proxy;
/** The contexts from the SMT solver */
- cvc5::context::Context* d_context;
+ cvc5::internal::context::Context* d_context;
/** The current assertion level (user) */
int assertionLevel;
Var varFalse;
/** The resolution proof manager */
- std::unique_ptr<cvc5::prop::SatProofManager> d_pfManager;
+ std::unique_ptr<cvc5::internal::prop::SatProofManager> d_pfManager;
public:
/** Returns the current user assertion level */
// Constructor/Destructor:
//
Solver(Env& env,
- cvc5::prop::TheoryProxy* proxy,
- cvc5::context::Context* context,
- cvc5::context::UserContext* userContext,
+ cvc5::internal::prop::TheoryProxy* proxy,
+ cvc5::internal::context::Context* context,
+ cvc5::internal::context::UserContext* userContext,
ProofNodeManager* pnm,
bool enableIncremental = false);
virtual ~Solver();
Var falseVar() const { return varFalse; }
/** Retrive the SAT proof manager */
- cvc5::prop::SatProofManager* getProofManager();
+ cvc5::internal::prop::SatProofManager* getProofManager();
/** Retrive the refutation proof */
std::shared_ptr<ProofNode> getProof();
CRef propagateBool (); // Perform Boolean propagation. Returns possibly conflicting clause.
void propagateTheory (); // Perform Theory propagation.
void theoryCheck(
- cvc5::theory::Theory::Effort
+ cvc5::internal::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.
//=================================================================================================
} // namespace Minisat
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "prop/minisat/mtl/Map.h"
#include "prop/minisat/mtl/Vec.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
class Solver;
}
} // namespace Minisat
-} // namespace cvc5
+} // namespace cvc5::internal
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat{
//=================================================================================================
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "prop/minisat/simp/SimpSolver.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
//// DPllMinisatSatSolver
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
-namespace cvc5 {
+namespace cvc5::internal {
template <>
-prop::SatLiteral toSatLiteral<cvc5::Minisat::Solver>(Minisat::Solver::TLit lit)
+prop::SatLiteral toSatLiteral<cvc5::internal::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::internal::Minisat::Solver>(
+ const cvc5::internal::Minisat::Solver::TClause& minisat_cl, prop::SatClause& sat_cl)
{
prop::MinisatSatSolver::toSatClause(minisat_cl, sat_cl);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "util/statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
template <class Solver>
prop::SatLiteral toSatLiteral(typename Solver::TLit lit);
static void toSatClause (const Minisat::Clause& clause, SatClause& sat_clause);
void initialize(context::Context* context,
TheoryProxy* theoryProxy,
- cvc5::context::UserContext* userContext,
+ cvc5::internal::context::UserContext* userContext,
ProofNodeManager* pnm) override;
ClauseId addClause(SatClause& clause, bool removable) override;
}; /* class MinisatSatSolver */
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/check.h"
#include "prop/minisat/mtl/Vec.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "prop/minisat/mtl/Vec.h"
#include "prop/minisat/mtl/XAlloc.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "base/check.h"
#include "prop/minisat/mtl/Vec.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "prop/minisat/mtl/IntTypes.h"
#include "prop/minisat/mtl/Vec.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "base/check.h"
#include "prop/minisat/mtl/Vec.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
//=================================================================================================
// Some sorting algorithms for vec's
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
template<class T>
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "prop/minisat/mtl/IntTypes.h"
#include "prop/minisat/mtl/XAlloc.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <errno.h>
#include <stdlib.h>
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//=================================================================================================
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "prop/minisat/mtl/Sort.h"
#include "prop/minisat/utils/System.h"
-using namespace cvc5;
-using namespace cvc5::Minisat;
+using namespace cvc5::internal;
+using namespace cvc5::internal::Minisat;
//=================================================================================================
// Options:
// Constructor/Destructor:
SimpSolver::SimpSolver(Env& env,
- cvc5::prop::TheoryProxy* proxy,
- cvc5::context::Context* context,
- cvc5::context::UserContext* userContext,
+ cvc5::internal::prop::TheoryProxy* proxy,
+ cvc5::internal::context::Context* context,
+ cvc5::internal::context::UserContext* userContext,
ProofNodeManager* pnm,
bool enableIncremental)
: Solver(env, proxy, context, userContext, pnm, enableIncremental),
#include "prop/minisat/core/Solver.h"
#include "prop/minisat/mtl/Queue.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
class TheoryProxy;
}
-} // namespace cvc5
+} // namespace cvc5::internal
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//=================================================================================================
// Constructor/Destructor:
//
SimpSolver(Env& env,
- cvc5::prop::TheoryProxy* proxy,
- cvc5::context::Context* context,
- cvc5::context::UserContext* userContext,
+ cvc5::internal::prop::TheoryProxy* proxy,
+ cvc5::internal::context::Context* context,
+ cvc5::internal::context::UserContext* userContext,
ProofNodeManager* pnm,
bool enableIncremental = false);
~SimpSolver();
//=================================================================================================
} // namespace Minisat
- } // namespace cvc5
+ } // namespace cvc5::internal
#endif
#include "prop/minisat/mtl/Vec.h"
#include "prop/minisat/utils/ParseUtils.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//==================================================================================================
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
//#include <zlib.h>
#include <unistd.h>
-namespace cvc5 {
+namespace cvc5::internal {
namespace Minisat {
//-------------------------------------------------------------------------------------------------
//=================================================================================================
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
OptimizedClausesManager::OptimizedClausesManager(
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
/**
};
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROP__OPT_CLAUSES_MANAGER_H */
#include "theory/builtin/proof_checker.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
ProofCnfStream::ProofCnfStream(Env& env,
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include "prop/sat_proof_manager.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
class SatProofManager;
};
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/builtin/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
ProofPostprocessCallback::ProofPostprocessCallback(
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_node_updater.h"
#include "prop/proof_cnf_stream.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
};
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/resource_manager.h"
#include "util/result.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
/** Keeps a boolean flag scoped */
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/skolem_lemma.h"
#include "util/result.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ResourceManager;
class ProofNodeManager;
};
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROP_ENGINE_H */
#include "prop/prop_proof_manager.h"
#include "prop/sat_solver.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
PropPfManager::PropPfManager(context::UserContext* userContext,
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include "prop/proof_post_processor.h"
#include "prop/sat_proof_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
}; /* class PropPfManager */
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROP__PROOF_MANAGER_H */
#ifndef CVC5__PROP__REGISTRAR_H
#define CVC5__PROP__REGISTRAR_H
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
class Registrar {
};/* class NullRegistrar */
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROP__REGISTRAR_H */
#include "prop/cnf_stream.h"
#include "prop/minisat/minisat.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
SatProofManager::SatProofManager(Env& env,
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
class Solver;
}
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
}; /* class SatProofManager */
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SAT_PROOF_MANAGER_H */
#include "prop/sat_solver_types.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
virtual void initialize(context::Context* context,
prop::TheoryProxy* theoryProxy,
- cvc5::context::UserContext* userContext,
+ cvc5::internal::context::UserContext* userContext,
ProofNodeManager* pnm) = 0;
virtual void push() = 0;
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROP__SAT_MODULE_H */
#include "prop/kissat.h"
#include "prop/minisat/minisat.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
MinisatSatSolver* SatSolverFactory::createCDCLTMinisat(
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include "prop/sat_solver.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
class SatSolverFactory
}; /* class SatSolverFactory */
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5__PROP__SAT_SOLVER_FACTORY_H
#include <algorithm>
-namespace cvc5 {
+namespace cvc5::internal {
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::internal
#include "cvc5_private.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
/**
};
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "prop/skolem_def_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
SkolemDefManager::SkolemDefManager(context::Context* context,
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/context.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
/**
};
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROP__SKOLEM_DEF_MANAGER_H */
#include "theory/theory_engine.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
TheoryProxy::TheoryProxy(Env& env,
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_preprocessor.h"
#include "util/resource_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
class TheoryEngine;
}; /* class TheoryProxy */
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "smt/smt_statistics_registry.h"
#include "theory/trust_substitutions.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
ZeroLevelLearner::ZeroLevelLearner(Env& env, PropEngine* propEngine)
}
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace prop {
class PropEngine;
}; /* class ZeroLevelLearner */
} // namespace prop
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/smt_engine_subsolver.h"
#include "theory/trust_substitutions.h"
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
AbductionSolver::AbductionSolver(Env& env) : EnvObj(env) {}
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class SolverEngine;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__ABDUCTION_SOLVER_H */
#include "expr/skolem_manager.h"
#include "options/smt_options.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
AbstractValues::AbstractValues(NodeManager* nm)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/substitutions.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
/**
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "smt/solver_engine.h"
#include "theory/trust_substitutions.h"
-using namespace cvc5::theory;
-using namespace cvc5::kind;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
Assertions::Assertions(Env& env, AbstractValues& absv)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "preprocessing/assertion_pipeline.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
class AbstractValues;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/theory_engine.h"
#include "theory/theory_model.h"
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
CheckModels::CheckModels(Env& e) : EnvObj(e) {}
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class TheoryModel;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
namespace cvc5 {
-std::string sexprToString(api::Term sexpr)
+using namespace internal;
+
+std::string sexprToString(cvc5::Term sexpr)
{
// if sexpr is a constant string, return the stored constant string. We don't
// call Term::toString as its result depends on the output language.
}
// if sexpr is not a spec constant, make sure it is an array of sub-sexprs
- Assert(sexpr.getKind() == api::SEXPR);
+ Assert(sexpr.getKind() == cvc5::SEXPR);
std::stringstream ss;
auto it = sexpr.begin();
&& dynamic_cast<const CommandInterrupted*>(d_commandStatus) != NULL;
}
-void Command::invoke(api::Solver* solver, SymbolManager* sm, std::ostream& out)
+void Command::invoke(cvc5::Solver* solver, SymbolManager* sm, std::ostream& out)
{
invoke(solver, sm);
if (!(isMuted() && ok()))
}
}
-void Command::resetSolver(api::Solver* solver)
+void Command::resetSolver(cvc5::Solver* solver)
{
std::unique_ptr<Options> opts = std::make_unique<Options>();
opts->copyValues(*solver->d_originalOptions);
// CommandExecutor such that this reconstruction can be done within the
// CommandExecutor, who actually owns the solver.
solver->~Solver();
- new (solver) api::Solver(std::move(opts));
+ new (solver) cvc5::Solver(std::move(opts));
}
-Node Command::termToNode(const api::Term& term) { return term.getNode(); }
+Node Command::termToNode(const cvc5::Term& term) { return term.getNode(); }
std::vector<Node> Command::termVectorToNodes(
- const std::vector<api::Term>& terms)
+ const std::vector<cvc5::Term>& terms)
{
- return api::Term::termVectorToNodes(terms);
+ return cvc5::Term::termVectorToNodes(terms);
}
-TypeNode Command::sortToTypeNode(const api::Sort& sort)
+TypeNode Command::sortToTypeNode(const cvc5::Sort& sort)
{
return sort.getTypeNode();
}
std::vector<TypeNode> Command::sortVectorToTypeNodes(
- const std::vector<api::Sort>& sorts)
+ const std::vector<cvc5::Sort>& sorts)
{
- return api::Sort::sortVectorToTypeNodes(sorts);
+ return cvc5::Sort::sortVectorToTypeNodes(sorts);
}
-TypeNode Command::grammarToTypeNode(api::Grammar* grammar)
+TypeNode Command::grammarToTypeNode(cvc5::Grammar* grammar)
{
return grammar == nullptr ? TypeNode::null()
: sortToTypeNode(grammar->resolve());
EmptyCommand::EmptyCommand(std::string name) : d_name(name) {}
std::string EmptyCommand::getName() const { return d_name; }
-void EmptyCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void EmptyCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
/* empty commands have no implementation */
d_commandStatus = CommandSuccess::instance();
std::string EchoCommand::getOutput() const { return d_output; }
-void EchoCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void EchoCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
/* we don't have an output stream here, nothing to do */
d_commandStatus = CommandSuccess::instance();
}
-void EchoCommand::invoke(api::Solver* solver,
+void EchoCommand::invoke(cvc5::Solver* solver,
SymbolManager* sm,
std::ostream& out)
{
- out << cvc5::quoteString(d_output) << std::endl;
+ out << cvc5::internal::quoteString(d_output) << std::endl;
Trace("dtview::command") << "* ~COMMAND: echo |" << d_output << "|~"
<< std::endl;
d_commandStatus = CommandSuccess::instance();
/* class AssertCommand */
/* -------------------------------------------------------------------------- */
-AssertCommand::AssertCommand(const api::Term& t) : d_term(t) {}
+AssertCommand::AssertCommand(const cvc5::Term& t) : d_term(t) {}
-api::Term AssertCommand::getTerm() const { return d_term; }
-void AssertCommand::invoke(api::Solver* solver, SymbolManager* sm)
+cvc5::Term AssertCommand::getTerm() const { return d_term; }
+void AssertCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
/* class PushCommand */
/* -------------------------------------------------------------------------- */
-void PushCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void PushCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
/* class PopCommand */
/* -------------------------------------------------------------------------- */
-void PopCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void PopCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
CheckSatCommand::CheckSatCommand() {}
-void CheckSatCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void CheckSatCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
Trace("dtview::command") << "* ~COMMAND: " << getCommandName() << "~"
<< std::endl;
}
}
-api::Result CheckSatCommand::getResult() const { return d_result; }
+cvc5::Result CheckSatCommand::getResult() const { return d_result; }
void CheckSatCommand::printResult(std::ostream& out) const
{
/* class CheckSatAssumingCommand */
/* -------------------------------------------------------------------------- */
-CheckSatAssumingCommand::CheckSatAssumingCommand(api::Term term)
+CheckSatAssumingCommand::CheckSatAssumingCommand(cvc5::Term term)
: d_terms({term})
{
}
CheckSatAssumingCommand::CheckSatAssumingCommand(
- const std::vector<api::Term>& terms)
+ const std::vector<cvc5::Term>& terms)
: d_terms(terms)
{
}
-const std::vector<api::Term>& CheckSatAssumingCommand::getTerms() const
+const std::vector<cvc5::Term>& CheckSatAssumingCommand::getTerms() const
{
return d_terms;
}
-void CheckSatAssumingCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void CheckSatAssumingCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
Trace("dtview::command") << "* ~COMMAND: (check-sat-assuming ( " << d_terms
<< " )~" << std::endl;
}
}
-api::Result CheckSatAssumingCommand::getResult() const
+cvc5::Result CheckSatAssumingCommand::getResult() const
{
Trace("dtview::command") << "* ~RESULT: " << d_result << "~" << std::endl;
return d_result;
/* -------------------------------------------------------------------------- */
DeclareSygusVarCommand::DeclareSygusVarCommand(const std::string& id,
- api::Term var,
- api::Sort sort)
+ cvc5::Term var,
+ cvc5::Sort sort)
: DeclarationDefinitionCommand(id), d_var(var), d_sort(sort)
{
}
-api::Term DeclareSygusVarCommand::getVar() const { return d_var; }
-api::Sort DeclareSygusVarCommand::getSort() const { return d_sort; }
+cvc5::Term DeclareSygusVarCommand::getVar() const { return d_var; }
+cvc5::Sort DeclareSygusVarCommand::getSort() const { return d_sort; }
-void DeclareSygusVarCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void DeclareSygusVarCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
d_commandStatus = CommandSuccess::instance();
}
/* -------------------------------------------------------------------------- */
SynthFunCommand::SynthFunCommand(const std::string& id,
- api::Term fun,
- const std::vector<api::Term>& vars,
- api::Sort sort,
+ cvc5::Term fun,
+ const std::vector<cvc5::Term>& vars,
+ cvc5::Sort sort,
bool isInv,
- api::Grammar* g)
+ cvc5::Grammar* g)
: DeclarationDefinitionCommand(id),
d_fun(fun),
d_vars(vars),
{
}
-api::Term SynthFunCommand::getFunction() const { return d_fun; }
+cvc5::Term SynthFunCommand::getFunction() const { return d_fun; }
-const std::vector<api::Term>& SynthFunCommand::getVars() const
+const std::vector<cvc5::Term>& SynthFunCommand::getVars() const
{
return d_vars;
}
-api::Sort SynthFunCommand::getSort() const { return d_sort; }
+cvc5::Sort SynthFunCommand::getSort() const { return d_sort; }
bool SynthFunCommand::isInv() const { return d_isInv; }
-const api::Grammar* SynthFunCommand::getGrammar() const { return d_grammar; }
+const cvc5::Grammar* SynthFunCommand::getGrammar() const { return d_grammar; }
-void SynthFunCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void SynthFunCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
sm->addFunctionToSynthesize(d_fun);
d_commandStatus = CommandSuccess::instance();
/* class SygusConstraintCommand */
/* -------------------------------------------------------------------------- */
-SygusConstraintCommand::SygusConstraintCommand(const api::Term& t,
+SygusConstraintCommand::SygusConstraintCommand(const cvc5::Term& t,
bool isAssume)
: d_term(t), d_isAssume(isAssume)
{
}
-void SygusConstraintCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void SygusConstraintCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
}
}
-api::Term SygusConstraintCommand::getTerm() const { return d_term; }
+cvc5::Term SygusConstraintCommand::getTerm() const { return d_term; }
Command* SygusConstraintCommand::clone() const
{
/* -------------------------------------------------------------------------- */
SygusInvConstraintCommand::SygusInvConstraintCommand(
- const std::vector<api::Term>& predicates)
+ const std::vector<cvc5::Term>& predicates)
: d_predicates(predicates)
{
}
-SygusInvConstraintCommand::SygusInvConstraintCommand(const api::Term& inv,
- const api::Term& pre,
- const api::Term& trans,
- const api::Term& post)
- : SygusInvConstraintCommand(std::vector<api::Term>{inv, pre, trans, post})
+SygusInvConstraintCommand::SygusInvConstraintCommand(const cvc5::Term& inv,
+ const cvc5::Term& pre,
+ const cvc5::Term& trans,
+ const cvc5::Term& post)
+ : SygusInvConstraintCommand(std::vector<cvc5::Term>{inv, pre, trans, post})
{
}
-void SygusInvConstraintCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void SygusInvConstraintCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
}
}
-const std::vector<api::Term>& SygusInvConstraintCommand::getPredicates() const
+const std::vector<cvc5::Term>& SygusInvConstraintCommand::getPredicates() const
{
return d_predicates;
}
/* class CheckSynthCommand */
/* -------------------------------------------------------------------------- */
-void CheckSynthCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void CheckSynthCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
if (d_result.hasSolution()
&& options::sygusOut() != options::SygusSolutionOutMode::STATUS)
{
- std::vector<api::Term> synthFuns = sm->getFunctionsToSynthesize();
+ std::vector<cvc5::Term> synthFuns = sm->getFunctionsToSynthesize();
d_solution << "(" << std::endl;
Printer* p = Printer::getPrinter(Language::LANG_SYGUS_V2);
- for (api::Term& f : synthFuns)
+ for (cvc5::Term& f : synthFuns)
{
- api::Term sol = solver->getSynthSolution(f);
- std::vector<api::Term> formals;
- if (sol.getKind() == api::LAMBDA)
+ cvc5::Term sol = solver->getSynthSolution(f);
+ std::vector<cvc5::Term> formals;
+ if (sol.getKind() == cvc5::LAMBDA)
{
formals.insert(formals.end(), sol[0].begin(), sol[0].end());
sol = sol[1];
}
- api::Sort rangeSort = f.getSort();
+ cvc5::Sort rangeSort = f.getSort();
if (rangeSort.isFunction())
{
rangeSort = rangeSort.getFunctionCodomainSort();
}
}
-api::SynthResult CheckSynthCommand::getResult() const { return d_result; }
+cvc5::SynthResult CheckSynthCommand::getResult() const { return d_result; }
void CheckSynthCommand::printResult(std::ostream& out) const
{
if (!ok())
/* class ResetCommand */
/* -------------------------------------------------------------------------- */
-void ResetCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void ResetCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
/* class ResetAssertionsCommand */
/* -------------------------------------------------------------------------- */
-void ResetAssertionsCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void ResetAssertionsCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
/* class QuitCommand */
/* -------------------------------------------------------------------------- */
-void QuitCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void QuitCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
d_commandStatus = CommandSuccess::instance();
}
}
void CommandSequence::clear() { d_commandSequence.clear(); }
-void CommandSequence::invoke(api::Solver* solver, SymbolManager* sm)
+void CommandSequence::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
for (; d_index < d_commandSequence.size(); ++d_index)
{
d_commandStatus = CommandSuccess::instance();
}
-void CommandSequence::invoke(api::Solver* solver,
+void CommandSequence::invoke(cvc5::Solver* solver,
SymbolManager* sm,
std::ostream& out)
{
/* -------------------------------------------------------------------------- */
DeclareFunctionCommand::DeclareFunctionCommand(const std::string& id,
- api::Term func,
- api::Sort sort)
+ cvc5::Term func,
+ cvc5::Sort sort)
: DeclarationDefinitionCommand(id), d_func(func), d_sort(sort)
{
}
-api::Term DeclareFunctionCommand::getFunction() const { return d_func; }
-api::Sort DeclareFunctionCommand::getSort() const { return d_sort; }
+cvc5::Term DeclareFunctionCommand::getFunction() const { return d_func; }
+cvc5::Sort DeclareFunctionCommand::getSort() const { return d_sort; }
-void DeclareFunctionCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void DeclareFunctionCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
// mark that it will be printed in the model
sm->addModelDeclarationTerm(d_func);
/* -------------------------------------------------------------------------- */
DeclarePoolCommand::DeclarePoolCommand(const std::string& id,
- api::Term func,
- api::Sort sort,
- const std::vector<api::Term>& initValue)
+ cvc5::Term func,
+ cvc5::Sort sort,
+ const std::vector<cvc5::Term>& initValue)
: DeclarationDefinitionCommand(id),
d_func(func),
d_sort(sort),
{
}
-api::Term DeclarePoolCommand::getFunction() const { return d_func; }
-api::Sort DeclarePoolCommand::getSort() const { return d_sort; }
-const std::vector<api::Term>& DeclarePoolCommand::getInitialValue() const
+cvc5::Term DeclarePoolCommand::getFunction() const { return d_func; }
+cvc5::Sort DeclarePoolCommand::getSort() const { return d_sort; }
+const std::vector<cvc5::Term>& DeclarePoolCommand::getInitialValue() const
{
return d_initValue;
}
-void DeclarePoolCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void DeclarePoolCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
// Notice that the pool is already declared by the parser so that it the
// symbol is bound eagerly. This is analogous to DeclareSygusVarCommand.
DeclareSortCommand::DeclareSortCommand(const std::string& id,
size_t arity,
- api::Sort sort)
+ cvc5::Sort sort)
: DeclarationDefinitionCommand(id), d_arity(arity), d_sort(sort)
{
}
size_t DeclareSortCommand::getArity() const { return d_arity; }
-api::Sort DeclareSortCommand::getSort() const { return d_sort; }
-void DeclareSortCommand::invoke(api::Solver* solver, SymbolManager* sm)
+cvc5::Sort DeclareSortCommand::getSort() const { return d_sort; }
+void DeclareSortCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
// mark that it will be printed in the model, if it is an uninterpreted
// sort (arity 0)
/* class DefineSortCommand */
/* -------------------------------------------------------------------------- */
-DefineSortCommand::DefineSortCommand(const std::string& id, api::Sort sort)
+DefineSortCommand::DefineSortCommand(const std::string& id, cvc5::Sort sort)
: DeclarationDefinitionCommand(id), d_params(), d_sort(sort)
{
}
DefineSortCommand::DefineSortCommand(const std::string& id,
- const std::vector<api::Sort>& params,
- api::Sort sort)
+ const std::vector<cvc5::Sort>& params,
+ cvc5::Sort sort)
: DeclarationDefinitionCommand(id), d_params(params), d_sort(sort)
{
}
-const std::vector<api::Sort>& DefineSortCommand::getParameters() const
+const std::vector<cvc5::Sort>& DefineSortCommand::getParameters() const
{
return d_params;
}
-api::Sort DefineSortCommand::getSort() const { return d_sort; }
-void DefineSortCommand::invoke(api::Solver* solver, SymbolManager* sm)
+cvc5::Sort DefineSortCommand::getSort() const { return d_sort; }
+void DefineSortCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
d_commandStatus = CommandSuccess::instance();
}
/* -------------------------------------------------------------------------- */
DefineFunctionCommand::DefineFunctionCommand(const std::string& id,
- api::Sort sort,
- api::Term formula)
+ cvc5::Sort sort,
+ cvc5::Term formula)
: DeclarationDefinitionCommand(id),
d_formals(),
d_sort(sort),
DefineFunctionCommand::DefineFunctionCommand(
const std::string& id,
- const std::vector<api::Term>& formals,
- api::Sort sort,
- api::Term formula)
+ const std::vector<cvc5::Term>& formals,
+ cvc5::Sort sort,
+ cvc5::Term formula)
: DeclarationDefinitionCommand(id),
d_formals(formals),
d_sort(sort),
{
}
-const std::vector<api::Term>& DefineFunctionCommand::getFormals() const
+const std::vector<cvc5::Term>& DefineFunctionCommand::getFormals() const
{
return d_formals;
}
-api::Sort DefineFunctionCommand::getSort() const { return d_sort; }
+cvc5::Sort DefineFunctionCommand::getSort() const { return d_sort; }
-api::Term DefineFunctionCommand::getFormula() const { return d_formula; }
+cvc5::Term DefineFunctionCommand::getFormula() const { return d_formula; }
-void DefineFunctionCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void DefineFunctionCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
bool global = sm->getGlobalDeclarations();
- api::Term fun =
+ cvc5::Term fun =
solver->defineFun(d_symbol, d_formals, d_sort, d_formula, global);
sm->getSymbolTable()->bind(d_symbol, fun, global);
d_commandStatus = CommandSuccess::instance();
/* -------------------------------------------------------------------------- */
DefineFunctionRecCommand::DefineFunctionRecCommand(
- api::Term func, const std::vector<api::Term>& formals, api::Term formula)
+ cvc5::Term func, const std::vector<cvc5::Term>& formals, cvc5::Term formula)
{
d_funcs.push_back(func);
d_formals.push_back(formals);
}
DefineFunctionRecCommand::DefineFunctionRecCommand(
- const std::vector<api::Term>& funcs,
- const std::vector<std::vector<api::Term>>& formals,
- const std::vector<api::Term>& formulas)
+ const std::vector<cvc5::Term>& funcs,
+ const std::vector<std::vector<cvc5::Term>>& formals,
+ const std::vector<cvc5::Term>& formulas)
: d_funcs(funcs), d_formals(formals), d_formulas(formulas)
{
}
-const std::vector<api::Term>& DefineFunctionRecCommand::getFunctions() const
+const std::vector<cvc5::Term>& DefineFunctionRecCommand::getFunctions() const
{
return d_funcs;
}
-const std::vector<std::vector<api::Term>>&
+const std::vector<std::vector<cvc5::Term>>&
DefineFunctionRecCommand::getFormals() const
{
return d_formals;
}
-const std::vector<api::Term>& DefineFunctionRecCommand::getFormulas() const
+const std::vector<cvc5::Term>& DefineFunctionRecCommand::getFormulas() const
{
return d_formulas;
}
-void DefineFunctionRecCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void DefineFunctionRecCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
{
std::vector<std::vector<Node>> formals;
formals.reserve(d_formals.size());
- for (const std::vector<api::Term>& formal : d_formals)
+ for (const std::vector<cvc5::Term>& formal : d_formals)
{
formals.push_back(termVectorToNodes(formal));
}
/* -------------------------------------------------------------------------- */
/* class DeclareHeapCommand */
/* -------------------------------------------------------------------------- */
-DeclareHeapCommand::DeclareHeapCommand(api::Sort locSort, api::Sort dataSort)
+DeclareHeapCommand::DeclareHeapCommand(cvc5::Sort locSort, cvc5::Sort dataSort)
: d_locSort(locSort), d_dataSort(dataSort)
{
}
-api::Sort DeclareHeapCommand::getLocationSort() const { return d_locSort; }
-api::Sort DeclareHeapCommand::getDataSort() const { return d_dataSort; }
+cvc5::Sort DeclareHeapCommand::getLocationSort() const { return d_locSort; }
+cvc5::Sort DeclareHeapCommand::getDataSort() const { return d_dataSort; }
-void DeclareHeapCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void DeclareHeapCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
solver->declareSepHeap(d_locSort, d_dataSort);
}
/* class SimplifyCommand */
/* -------------------------------------------------------------------------- */
-SimplifyCommand::SimplifyCommand(api::Term term) : d_term(term) {}
-api::Term SimplifyCommand::getTerm() const { return d_term; }
-void SimplifyCommand::invoke(api::Solver* solver, SymbolManager* sm)
+SimplifyCommand::SimplifyCommand(cvc5::Term term) : d_term(term) {}
+cvc5::Term SimplifyCommand::getTerm() const { return d_term; }
+void SimplifyCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
}
}
-api::Term SimplifyCommand::getResult() const { return d_result; }
+cvc5::Term SimplifyCommand::getResult() const { return d_result; }
void SimplifyCommand::printResult(std::ostream& out) const
{
if (!ok())
/* class GetValueCommand */
/* -------------------------------------------------------------------------- */
-GetValueCommand::GetValueCommand(api::Term term) : d_terms()
+GetValueCommand::GetValueCommand(cvc5::Term term) : d_terms()
{
d_terms.push_back(term);
}
-GetValueCommand::GetValueCommand(const std::vector<api::Term>& terms)
+GetValueCommand::GetValueCommand(const std::vector<cvc5::Term>& terms)
: d_terms(terms)
{
PrettyCheckArgument(
terms.size() >= 1, terms, "cannot get-value of an empty set of terms");
}
-const std::vector<api::Term>& GetValueCommand::getTerms() const
+const std::vector<cvc5::Term>& GetValueCommand::getTerms() const
{
return d_terms;
}
-void GetValueCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetValueCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
- std::vector<api::Term> result = solver->getValue(d_terms);
+ std::vector<cvc5::Term> result = solver->getValue(d_terms);
Assert(result.size() == d_terms.size());
for (int i = 0, size = d_terms.size(); i < size; i++)
{
- api::Term request = d_terms[i];
- api::Term value = result[i];
- result[i] = solver->mkTerm(api::SEXPR, {request, value});
+ cvc5::Term request = d_terms[i];
+ cvc5::Term value = result[i];
+ result[i] = solver->mkTerm(cvc5::SEXPR, {request, value});
}
- d_result = solver->mkTerm(api::SEXPR, {result});
+ d_result = solver->mkTerm(cvc5::SEXPR, {result});
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.what());
}
}
}
-api::Term GetValueCommand::getResult() const { return d_result; }
+cvc5::Term GetValueCommand::getResult() const { return d_result; }
void GetValueCommand::printResult(std::ostream& out) const
{
if (!ok())
/* -------------------------------------------------------------------------- */
GetAssignmentCommand::GetAssignmentCommand() {}
-void GetAssignmentCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetAssignmentCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
- std::map<api::Term, std::string> enames = sm->getExpressionNames();
- std::vector<api::Term> terms;
+ std::map<cvc5::Term, std::string> enames = sm->getExpressionNames();
+ std::vector<cvc5::Term> terms;
std::vector<std::string> names;
- for (const std::pair<const api::Term, std::string>& e : enames)
+ for (const std::pair<const cvc5::Term, std::string>& e : enames)
{
terms.push_back(e.first);
names.push_back(e.second);
}
// Must use vector version of getValue to ensure error is thrown regardless
// of whether terms is empty.
- std::vector<api::Term> values = solver->getValue(terms);
+ std::vector<cvc5::Term> values = solver->getValue(terms);
Assert(values.size() == names.size());
- std::vector<api::Term> sexprs;
+ std::vector<cvc5::Term> sexprs;
for (size_t i = 0, nterms = terms.size(); i < nterms; i++)
{
// Treat the expression name as a variable name as opposed to a string
// constant to avoid printing double quotes around the name.
- api::Term name = solver->mkVar(solver->getBooleanSort(), names[i]);
- sexprs.push_back(solver->mkTerm(api::SEXPR, {name, values[i]}));
+ cvc5::Term name = solver->mkVar(solver->getBooleanSort(), names[i]);
+ sexprs.push_back(solver->mkTerm(cvc5::SEXPR, {name, values[i]}));
}
- d_result = solver->mkTerm(api::SEXPR, sexprs);
+ d_result = solver->mkTerm(cvc5::SEXPR, sexprs);
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.what());
}
}
}
-api::Term GetAssignmentCommand::getResult() const { return d_result; }
+cvc5::Term GetAssignmentCommand::getResult() const { return d_result; }
void GetAssignmentCommand::printResult(std::ostream& out) const
{
if (!ok())
/* -------------------------------------------------------------------------- */
GetModelCommand::GetModelCommand() {}
-void GetModelCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetModelCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
- std::vector<api::Sort> declareSorts = sm->getModelDeclareSorts();
- std::vector<api::Term> declareTerms = sm->getModelDeclareTerms();
+ std::vector<cvc5::Sort> declareSorts = sm->getModelDeclareSorts();
+ std::vector<cvc5::Term> declareTerms = sm->getModelDeclareTerms();
d_result = solver->getModel(declareSorts, declareTerms);
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.what());
}
/* -------------------------------------------------------------------------- */
BlockModelCommand::BlockModelCommand() {}
-void BlockModelCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void BlockModelCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
solver->blockModel();
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.what());
}
/* -------------------------------------------------------------------------- */
BlockModelValuesCommand::BlockModelValuesCommand(
- const std::vector<api::Term>& terms)
+ const std::vector<cvc5::Term>& terms)
: d_terms(terms)
{
PrettyCheckArgument(terms.size() >= 1,
"cannot block-model-values of an empty set of terms");
}
-const std::vector<api::Term>& BlockModelValuesCommand::getTerms() const
+const std::vector<cvc5::Term>& BlockModelValuesCommand::getTerms() const
{
return d_terms;
}
-void BlockModelValuesCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void BlockModelValuesCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
solver->blockModelValues(d_terms);
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.what());
}
/* -------------------------------------------------------------------------- */
GetProofCommand::GetProofCommand() {}
-void GetProofCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetProofCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
d_result = solver->getProof();
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.what());
}
/* -------------------------------------------------------------------------- */
GetInstantiationsCommand::GetInstantiationsCommand() : d_solver(nullptr) {}
-bool GetInstantiationsCommand::isEnabled(api::Solver* solver,
- const api::Result& res)
+bool GetInstantiationsCommand::isEnabled(cvc5::Solver* solver,
+ const cvc5::Result& res)
{
return (res.isSat()
|| (res.isUnknown()
- && res.getUnknownExplanation() == api::Result::INCOMPLETE))
+ && res.getUnknownExplanation() == cvc5::Result::INCOMPLETE))
|| res.isUnsat();
}
-void GetInstantiationsCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetInstantiationsCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
/* -------------------------------------------------------------------------- */
GetInterpolantCommand::GetInterpolantCommand(const std::string& name,
- api::Term conj)
+ Term conj)
: d_name(name), d_conj(conj), d_sygus_grammar(nullptr)
{
}
GetInterpolantCommand::GetInterpolantCommand(const std::string& name,
- api::Term conj,
- api::Grammar* g)
+ Term conj,
+ Grammar* g)
: d_name(name), d_conj(conj), d_sygus_grammar(g)
{
}
-api::Term GetInterpolantCommand::getConjecture() const { return d_conj; }
+Term GetInterpolantCommand::getConjecture() const { return d_conj; }
-const api::Grammar* GetInterpolantCommand::getGrammar() const
+const Grammar* GetInterpolantCommand::getGrammar() const
{
return d_sygus_grammar;
}
-api::Term GetInterpolantCommand::getResult() const { return d_result; }
+Term GetInterpolantCommand::getResult() const { return d_result; }
-void GetInterpolantCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetInterpolantCommand::invoke(Solver* solver, SymbolManager* sm)
{
try
{
GetInterpolantNextCommand::GetInterpolantNextCommand() {}
-api::Term GetInterpolantNextCommand::getResult() const { return d_result; }
+Term GetInterpolantNextCommand::getResult() const { return d_result; }
-void GetInterpolantNextCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetInterpolantNextCommand::invoke(Solver* solver, SymbolManager* sm)
{
try
{
/* class GetAbductCommand */
/* -------------------------------------------------------------------------- */
-GetAbductCommand::GetAbductCommand(const std::string& name, api::Term conj)
+GetAbductCommand::GetAbductCommand(const std::string& name, cvc5::Term conj)
: d_name(name), d_conj(conj), d_sygus_grammar(nullptr)
{
}
GetAbductCommand::GetAbductCommand(const std::string& name,
- api::Term conj,
- api::Grammar* g)
+ cvc5::Term conj,
+ cvc5::Grammar* g)
: d_name(name), d_conj(conj), d_sygus_grammar(g)
{
}
-api::Term GetAbductCommand::getConjecture() const { return d_conj; }
+cvc5::Term GetAbductCommand::getConjecture() const { return d_conj; }
-const api::Grammar* GetAbductCommand::getGrammar() const
+const cvc5::Grammar* GetAbductCommand::getGrammar() const
{
return d_sygus_grammar;
}
std::string GetAbductCommand::getAbductName() const { return d_name; }
-api::Term GetAbductCommand::getResult() const { return d_result; }
+cvc5::Term GetAbductCommand::getResult() const { return d_result; }
-void GetAbductCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetAbductCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
GetAbductNextCommand::GetAbductNextCommand() {}
-api::Term GetAbductNextCommand::getResult() const { return d_result; }
+cvc5::Term GetAbductNextCommand::getResult() const { return d_result; }
-void GetAbductNextCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetAbductNextCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
{
}
GetQuantifierEliminationCommand::GetQuantifierEliminationCommand(
- const api::Term& term, bool doFull)
+ const cvc5::Term& term, bool doFull)
: d_term(term), d_doFull(doFull)
{
}
-api::Term GetQuantifierEliminationCommand::getTerm() const { return d_term; }
+cvc5::Term GetQuantifierEliminationCommand::getTerm() const { return d_term; }
bool GetQuantifierEliminationCommand::getDoFull() const { return d_doFull; }
-void GetQuantifierEliminationCommand::invoke(api::Solver* solver,
+void GetQuantifierEliminationCommand::invoke(cvc5::Solver* solver,
SymbolManager* sm)
{
try
}
}
-api::Term GetQuantifierEliminationCommand::getResult() const
+cvc5::Term GetQuantifierEliminationCommand::getResult() const
{
return d_result;
}
GetUnsatAssumptionsCommand::GetUnsatAssumptionsCommand() {}
-void GetUnsatAssumptionsCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetUnsatAssumptionsCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
d_result = solver->getUnsatAssumptions();
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.what());
}
}
}
-std::vector<api::Term> GetUnsatAssumptionsCommand::getResult() const
+std::vector<cvc5::Term> GetUnsatAssumptionsCommand::getResult() const
{
return d_result;
}
/* -------------------------------------------------------------------------- */
GetUnsatCoreCommand::GetUnsatCoreCommand() : d_sm(nullptr) {}
-void GetUnsatCoreCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetUnsatCoreCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.what());
}
}
}
-const std::vector<api::Term>& GetUnsatCoreCommand::getUnsatCore() const
+const std::vector<cvc5::Term>& GetUnsatCoreCommand::getUnsatCore() const
{
// of course, this will be empty if the command hasn't been invoked yet
return d_result;
/* -------------------------------------------------------------------------- */
GetDifficultyCommand::GetDifficultyCommand() : d_sm(nullptr) {}
-void GetDifficultyCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetDifficultyCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.what());
}
else
{
out << "(" << std::endl;
- for (const std::pair<const api::Term, api::Term>& d : d_result)
+ for (const std::pair<const cvc5::Term, cvc5::Term>& d : d_result)
{
out << "(";
// use name if it has one
}
}
-const std::map<api::Term, api::Term>& GetDifficultyCommand::getDifficultyMap()
+const std::map<cvc5::Term, cvc5::Term>& GetDifficultyCommand::getDifficultyMap()
const
{
return d_result;
/* -------------------------------------------------------------------------- */
GetLearnedLiteralsCommand::GetLearnedLiteralsCommand() {}
-void GetLearnedLiteralsCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetLearnedLiteralsCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.what());
}
else
{
out << "(" << std::endl;
- for (const api::Term& lit : d_result)
+ for (const cvc5::Term& lit : d_result)
{
out << lit << std::endl;
}
}
}
-const std::vector<api::Term>& GetLearnedLiteralsCommand::getLearnedLiterals()
+const std::vector<cvc5::Term>& GetLearnedLiteralsCommand::getLearnedLiterals()
const
{
return d_result;
/* -------------------------------------------------------------------------- */
GetAssertionsCommand::GetAssertionsCommand() {}
-void GetAssertionsCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetAssertionsCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
stringstream ss;
- const vector<api::Term> v = solver->getAssertions();
+ const vector<cvc5::Term> v = solver->getAssertions();
ss << "(\n";
- copy(v.begin(), v.end(), ostream_iterator<api::Term>(ss, "\n"));
+ copy(v.begin(), v.end(), ostream_iterator<cvc5::Term>(ss, "\n"));
ss << ")\n";
d_result = ss.str();
d_commandStatus = CommandSuccess::instance();
}
std::string SetBenchmarkLogicCommand::getLogic() const { return d_logic; }
-void SetBenchmarkLogicCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void SetBenchmarkLogicCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
const std::string& SetInfoCommand::getFlag() const { return d_flag; }
const std::string& SetInfoCommand::getValue() const { return d_value; }
-void SetInfoCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void SetInfoCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
solver->setInfo(d_flag, d_value);
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiUnsupportedException&)
+ catch (cvc5::CVC5ApiUnsupportedException&)
{
// As per SMT-LIB spec, silently accept unknown set-info keys
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.getMessage());
}
GetInfoCommand::GetInfoCommand(std::string flag) : d_flag(flag) {}
std::string GetInfoCommand::getFlag() const { return d_flag; }
-void GetInfoCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetInfoCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
- std::vector<api::Term> v;
+ std::vector<cvc5::Term> v;
v.push_back(solver->mkString(":" + d_flag));
v.push_back(solver->mkString(solver->getInfo(d_flag)));
- d_result = sexprToString(solver->mkTerm(api::SEXPR, {v}));
+ d_result = sexprToString(solver->mkTerm(cvc5::SEXPR, {v}));
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiUnsupportedException&)
+ catch (cvc5::CVC5ApiUnsupportedException&)
{
d_commandStatus = new CommandUnsupported();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.getMessage());
}
const std::string& SetOptionCommand::getFlag() const { return d_flag; }
const std::string& SetOptionCommand::getValue() const { return d_value; }
-void SetOptionCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void SetOptionCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
solver->setOption(d_flag, d_value);
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiUnsupportedException&)
+ catch (cvc5::CVC5ApiUnsupportedException&)
{
d_commandStatus = new CommandUnsupported();
}
- catch (api::CVC5ApiRecoverableException& e)
+ catch (cvc5::CVC5ApiRecoverableException& e)
{
d_commandStatus = new CommandRecoverableFailure(e.getMessage());
}
GetOptionCommand::GetOptionCommand(std::string flag) : d_flag(flag) {}
std::string GetOptionCommand::getFlag() const { return d_flag; }
-void GetOptionCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void GetOptionCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
try
{
d_result = solver->getOption(d_flag);
d_commandStatus = CommandSuccess::instance();
}
- catch (api::CVC5ApiUnsupportedException&)
+ catch (cvc5::CVC5ApiUnsupportedException&)
{
d_commandStatus = new CommandUnsupported();
}
/* -------------------------------------------------------------------------- */
DatatypeDeclarationCommand::DatatypeDeclarationCommand(
- const api::Sort& datatype)
+ const cvc5::Sort& datatype)
: d_datatypes()
{
d_datatypes.push_back(datatype);
}
DatatypeDeclarationCommand::DatatypeDeclarationCommand(
- const std::vector<api::Sort>& datatypes)
+ const std::vector<cvc5::Sort>& datatypes)
: d_datatypes(datatypes)
{
}
-const std::vector<api::Sort>& DatatypeDeclarationCommand::getDatatypes() const
+const std::vector<cvc5::Sort>& DatatypeDeclarationCommand::getDatatypes() const
{
return d_datatypes;
}
-void DatatypeDeclarationCommand::invoke(api::Solver* solver, SymbolManager* sm)
+void DatatypeDeclarationCommand::invoke(cvc5::Solver* solver, SymbolManager* sm)
{
d_commandStatus = CommandSuccess::instance();
}
namespace cvc5 {
-namespace api {
class Solver;
class Term;
-} // namespace api
class SymbolManager;
class Command;
* @param sexpr the symbolic expression to convert
* @return the symbolic expression as string
*/
-std::string sexprToString(api::Term sexpr) CVC5_EXPORT;
+std::string sexprToString(cvc5::Term sexpr) CVC5_EXPORT;
std::ostream& operator<<(std::ostream&, const Command&) CVC5_EXPORT;
std::ostream& operator<<(std::ostream&, const Command*) CVC5_EXPORT;
public:
virtual ~CommandStatus() {}
- void toStream(std::ostream& out,
- Language language = Language::LANG_AUTO) const;
+ void toStream(
+ std::ostream& out,
+ internal::Language language = internal::Language::LANG_AUTO) const;
virtual CommandStatus& clone() const = 0;
}; /* class CommandStatus */
/**
* Invoke the command on the solver and symbol manager sm.
*/
- virtual void invoke(api::Solver* solver, SymbolManager* sm) = 0;
+ virtual void invoke(cvc5::Solver* solver, SymbolManager* sm) = 0;
/**
* Same as above, and prints the result to output stream out.
*/
- virtual void invoke(api::Solver* solver,
+ virtual void invoke(cvc5::Solver* solver,
SymbolManager* sm,
std::ostream& out);
- virtual void toStream(std::ostream& out,
- int toDepth = -1,
- size_t dag = 1,
- Language language = Language::LANG_AUTO) const = 0;
+ virtual void toStream(
+ std::ostream& out,
+ int toDepth = -1,
+ size_t dag = 1,
+ internal::Language language = internal::Language::LANG_AUTO) const = 0;
std::string toString() const;
* Reset the given solver in-place (keep the object at the same memory
* location).
*/
- static void resetSolver(api::Solver* solver);
+ static void resetSolver(cvc5::Solver* solver);
protected:
// These methods rely on Command being a friend of classes in the API.
// Subclasses of command should use these methods for conversions,
// which is currently necessary for e.g. printing commands.
- /** Helper to convert a Term to an internal Node */
- static Node termToNode(const api::Term& term);
+ /** Helper to convert a Term to an internal internal::Node */
+ static internal::Node termToNode(const cvc5::Term& term);
/** Helper to convert a vector of Terms to internal Nodes. */
- static std::vector<Node> termVectorToNodes(
- const std::vector<api::Term>& terms);
- /** Helper to convert a Sort to an internal TypeNode */
- static TypeNode sortToTypeNode(const api::Sort& sort);
+ static std::vector<internal::Node> termVectorToNodes(
+ const std::vector<cvc5::Term>& terms);
+ /** Helper to convert a Sort to an internal internal::TypeNode */
+ static internal::TypeNode sortToTypeNode(const cvc5::Sort& sort);
/** Helper to convert a vector of Sorts to internal TypeNodes. */
- static std::vector<TypeNode> sortVectorToTypeNodes(
- const std::vector<api::Sort>& sorts);
- /** Helper to convert a Grammar to an internal TypeNode */
- static TypeNode grammarToTypeNode(api::Grammar* grammar);
+ static std::vector<internal::TypeNode> sortVectorToTypeNodes(
+ const std::vector<cvc5::Sort>& sorts);
+ /** Helper to convert a Grammar to an internal internal::TypeNode */
+ static internal::TypeNode grammarToTypeNode(cvc5::Grammar* grammar);
}; /* class Command */
/**
public:
EmptyCommand(std::string name = "");
std::string getName() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
std::string d_name;
std::string getOutput() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
- void invoke(api::Solver* solver,
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver,
SymbolManager* sm,
std::ostream& out) override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
std::string d_output;
class CVC5_EXPORT AssertCommand : public Command
{
protected:
- api::Term d_term;
+ cvc5::Term d_term;
public:
- AssertCommand(const api::Term& t);
+ AssertCommand(const cvc5::Term& t);
- api::Term getTerm() const;
+ cvc5::Term getTerm() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class AssertCommand */
class CVC5_EXPORT PushCommand : public Command
{
public:
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class PushCommand */
class CVC5_EXPORT PopCommand : public Command
{
public:
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class PopCommand */
class CVC5_EXPORT DeclarationDefinitionCommand : public Command
public:
DeclarationDefinitionCommand(const std::string& id);
- void invoke(api::Solver* solver, SymbolManager* sm) override = 0;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override = 0;
std::string getSymbol() const;
}; /* class DeclarationDefinitionCommand */
class CVC5_EXPORT DeclareFunctionCommand : public DeclarationDefinitionCommand
{
protected:
- api::Term d_func;
- api::Sort d_sort;
+ cvc5::Term d_func;
+ cvc5::Sort d_sort;
public:
- DeclareFunctionCommand(const std::string& id, api::Term func, api::Sort sort);
- api::Term getFunction() const;
- api::Sort getSort() const;
+ DeclareFunctionCommand(const std::string& id,
+ cvc5::Term func,
+ cvc5::Sort sort);
+ cvc5::Term getFunction() const;
+ cvc5::Sort getSort() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class DeclareFunctionCommand */
class CVC5_EXPORT DeclarePoolCommand : public DeclarationDefinitionCommand
{
protected:
- api::Term d_func;
- api::Sort d_sort;
- std::vector<api::Term> d_initValue;
+ cvc5::Term d_func;
+ cvc5::Sort d_sort;
+ std::vector<cvc5::Term> d_initValue;
public:
DeclarePoolCommand(const std::string& id,
- api::Term func,
- api::Sort sort,
- const std::vector<api::Term>& initValue);
- api::Term getFunction() const;
- api::Sort getSort() const;
- const std::vector<api::Term>& getInitialValue() const;
-
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ cvc5::Term func,
+ cvc5::Sort sort,
+ const std::vector<cvc5::Term>& initValue);
+ cvc5::Term getFunction() const;
+ cvc5::Sort getSort() const;
+ const std::vector<cvc5::Term>& getInitialValue() const;
+
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class DeclarePoolCommand */
class CVC5_EXPORT DeclareSortCommand : public DeclarationDefinitionCommand
{
protected:
size_t d_arity;
- api::Sort d_sort;
+ cvc5::Sort d_sort;
public:
- DeclareSortCommand(const std::string& id, size_t arity, api::Sort sort);
+ DeclareSortCommand(const std::string& id, size_t arity, cvc5::Sort sort);
size_t getArity() const;
- api::Sort getSort() const;
+ cvc5::Sort getSort() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class DeclareSortCommand */
class CVC5_EXPORT DefineSortCommand : public DeclarationDefinitionCommand
{
protected:
- std::vector<api::Sort> d_params;
- api::Sort d_sort;
+ std::vector<cvc5::Sort> d_params;
+ cvc5::Sort d_sort;
public:
- DefineSortCommand(const std::string& id, api::Sort sort);
+ DefineSortCommand(const std::string& id, cvc5::Sort sort);
DefineSortCommand(const std::string& id,
- const std::vector<api::Sort>& params,
- api::Sort sort);
+ const std::vector<cvc5::Sort>& params,
+ cvc5::Sort sort);
- const std::vector<api::Sort>& getParameters() const;
- api::Sort getSort() const;
+ const std::vector<cvc5::Sort>& getParameters() const;
+ cvc5::Sort getSort() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class DefineSortCommand */
class CVC5_EXPORT DefineFunctionCommand : public DeclarationDefinitionCommand
{
public:
DefineFunctionCommand(const std::string& id,
- api::Sort sort,
- api::Term formula);
+ cvc5::Sort sort,
+ cvc5::Term formula);
DefineFunctionCommand(const std::string& id,
- const std::vector<api::Term>& formals,
- api::Sort sort,
- api::Term formula);
+ const std::vector<cvc5::Term>& formals,
+ cvc5::Sort sort,
+ cvc5::Term formula);
- const std::vector<api::Term>& getFormals() const;
- api::Sort getSort() const;
- api::Term getFormula() const;
+ const std::vector<cvc5::Term>& getFormals() const;
+ cvc5::Sort getSort() const;
+ cvc5::Term getFormula() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** The formal arguments for the function we are defining */
- std::vector<api::Term> d_formals;
+ std::vector<cvc5::Term> d_formals;
/** The co-domain sort of the function we are defining */
- api::Sort d_sort;
+ cvc5::Sort d_sort;
/** The formula corresponding to the body of the function we are defining */
- api::Term d_formula;
+ cvc5::Term d_formula;
}; /* class DefineFunctionCommand */
/**
class CVC5_EXPORT DefineFunctionRecCommand : public Command
{
public:
- DefineFunctionRecCommand(api::Term func,
- const std::vector<api::Term>& formals,
- api::Term formula);
- DefineFunctionRecCommand(const std::vector<api::Term>& funcs,
- const std::vector<std::vector<api::Term> >& formals,
- const std::vector<api::Term>& formula);
-
- const std::vector<api::Term>& getFunctions() const;
- const std::vector<std::vector<api::Term> >& getFormals() const;
- const std::vector<api::Term>& getFormulas() const;
-
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ DefineFunctionRecCommand(cvc5::Term func,
+ const std::vector<cvc5::Term>& formals,
+ cvc5::Term formula);
+ DefineFunctionRecCommand(const std::vector<cvc5::Term>& funcs,
+ const std::vector<std::vector<cvc5::Term> >& formals,
+ const std::vector<cvc5::Term>& formula);
+
+ const std::vector<cvc5::Term>& getFunctions() const;
+ const std::vector<std::vector<cvc5::Term> >& getFormals() const;
+ const std::vector<cvc5::Term>& getFormulas() const;
+
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** functions we are defining */
- std::vector<api::Term> d_funcs;
+ std::vector<cvc5::Term> d_funcs;
/** formal arguments for each of the functions we are defining */
- std::vector<std::vector<api::Term> > d_formals;
+ std::vector<std::vector<cvc5::Term> > d_formals;
/** formulas corresponding to the bodies of the functions we are defining */
- std::vector<api::Term> d_formulas;
+ std::vector<cvc5::Term> d_formulas;
}; /* class DefineFunctionRecCommand */
/**
class CVC5_EXPORT DeclareHeapCommand : public Command
{
public:
- DeclareHeapCommand(api::Sort locSort, api::Sort dataSort);
- api::Sort getLocationSort() const;
- api::Sort getDataSort() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ DeclareHeapCommand(cvc5::Sort locSort, cvc5::Sort dataSort);
+ cvc5::Sort getLocationSort() const;
+ cvc5::Sort getDataSort() const;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** The location sort */
- api::Sort d_locSort;
+ cvc5::Sort d_locSort;
/** The data sort */
- api::Sort d_dataSort;
+ cvc5::Sort d_dataSort;
};
/**
{
public:
CheckSatCommand();
- api::Result getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ cvc5::Result getResult() const;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
private:
- api::Result d_result;
+ cvc5::Result d_result;
}; /* class CheckSatCommand */
/**
class CVC5_EXPORT CheckSatAssumingCommand : public Command
{
public:
- CheckSatAssumingCommand(api::Term term);
- CheckSatAssumingCommand(const std::vector<api::Term>& terms);
+ CheckSatAssumingCommand(cvc5::Term term);
+ CheckSatAssumingCommand(const std::vector<cvc5::Term>& terms);
- const std::vector<api::Term>& getTerms() const;
- api::Result getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ const std::vector<cvc5::Term>& getTerms() const;
+ cvc5::Result getResult() const;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
private:
- std::vector<api::Term> d_terms;
- api::Result d_result;
+ std::vector<cvc5::Term> d_terms;
+ cvc5::Result d_result;
}; /* class CheckSatAssumingCommand */
class CVC5_EXPORT QueryCommand : public Command
{
protected:
- api::Term d_term;
- api::Result d_result;
+ cvc5::Term d_term;
+ cvc5::Result d_result;
public:
- QueryCommand(const api::Term& t);
+ QueryCommand(const cvc5::Term& t);
- api::Term getTerm() const;
- api::Result getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ cvc5::Term getTerm() const;
+ cvc5::Result getResult() const;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class QueryCommand */
/* ------------------- sygus commands ------------------ */
class CVC5_EXPORT DeclareSygusVarCommand : public DeclarationDefinitionCommand
{
public:
- DeclareSygusVarCommand(const std::string& id, api::Term var, api::Sort sort);
+ DeclareSygusVarCommand(const std::string& id,
+ cvc5::Term var,
+ cvc5::Sort sort);
/** returns the declared variable */
- api::Term getVar() const;
+ cvc5::Term getVar() const;
/** returns the declared variable's sort */
- api::Sort getSort() const;
+ cvc5::Sort getSort() const;
/** invokes this command
*
* The declared sygus variable is communicated to the SMT engine in case a
* synthesis conjecture is built later on.
*/
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
/** creates a copy of this command */
Command* clone() const override;
/** returns this command's name */
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** the declared variable */
- api::Term d_var;
+ cvc5::Term d_var;
/** the declared variable's sort */
- api::Sort d_sort;
+ cvc5::Sort d_sort;
};
/** Declares a sygus function-to-synthesize
{
public:
SynthFunCommand(const std::string& id,
- api::Term fun,
- const std::vector<api::Term>& vars,
- api::Sort sort,
+ cvc5::Term fun,
+ const std::vector<cvc5::Term>& vars,
+ cvc5::Sort sort,
bool isInv,
- api::Grammar* g);
+ cvc5::Grammar* g);
/** returns the function-to-synthesize */
- api::Term getFunction() const;
+ cvc5::Term getFunction() const;
/** returns the input variables of the function-to-synthesize */
- const std::vector<api::Term>& getVars() const;
+ const std::vector<cvc5::Term>& getVars() const;
/** returns the sygus sort of the function-to-synthesize */
- api::Sort getSort() const;
+ cvc5::Sort getSort() const;
/** returns whether the function-to-synthesize should be an invariant */
bool isInv() const;
/** Get the sygus grammar given for the synth fun command */
- const api::Grammar* getGrammar() const;
+ const cvc5::Grammar* getGrammar() const;
/** invokes this command
*
* The declared function-to-synthesize is communicated to the SMT engine in
* case a synthesis conjecture is built later on.
*/
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
/** creates a copy of this command */
Command* clone() const override;
/** returns this command's name */
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** the function-to-synthesize */
- api::Term d_fun;
+ cvc5::Term d_fun;
/** the input variables of the function-to-synthesize */
- std::vector<api::Term> d_vars;
+ std::vector<cvc5::Term> d_vars;
/** sort of the function-to-synthesize */
- api::Sort d_sort;
+ cvc5::Sort d_sort;
/** whether the function-to-synthesize should be an invariant */
bool d_isInv;
/** optional grammar for the possible values of the function-to-sytnhesize */
- api::Grammar* d_grammar;
+ cvc5::Grammar* d_grammar;
};
/** Declares a sygus constraint */
class CVC5_EXPORT SygusConstraintCommand : public Command
{
public:
- SygusConstraintCommand(const api::Term& t, bool isAssume = false);
+ SygusConstraintCommand(const cvc5::Term& t, bool isAssume = false);
/** returns the declared constraint */
- api::Term getTerm() const;
+ cvc5::Term getTerm() const;
/** invokes this command
*
* The declared constraint is communicated to the SMT engine in case a
* synthesis conjecture is built later on.
*/
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
/** creates a copy of this command */
Command* clone() const override;
/** returns this command's name */
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** the declared constraint */
- api::Term d_term;
+ cvc5::Term d_term;
/** true if this is a sygus assumption */
bool d_isAssume;
};
class CVC5_EXPORT SygusInvConstraintCommand : public Command
{
public:
- SygusInvConstraintCommand(const std::vector<api::Term>& predicates);
- SygusInvConstraintCommand(const api::Term& inv,
- const api::Term& pre,
- const api::Term& trans,
- const api::Term& post);
+ SygusInvConstraintCommand(const std::vector<cvc5::Term>& predicates);
+ SygusInvConstraintCommand(const cvc5::Term& inv,
+ const cvc5::Term& pre,
+ const cvc5::Term& trans,
+ const cvc5::Term& post);
/** returns the place holder predicates */
- const std::vector<api::Term>& getPredicates() const;
+ const std::vector<cvc5::Term>& getPredicates() const;
/** invokes this command
*
* The place holders are communicated to the SMT engine and the actual
* invariant constraint is built, in case an actual synthesis conjecture is
* built later on.
*/
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
/** creates a copy of this command */
Command* clone() const override;
/** returns this command's name */
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** the place holder predicates with which to build the actual constraint
* (i.e. the invariant, precondition, transition relation and postcondition)
*/
- std::vector<api::Term> d_predicates;
+ std::vector<cvc5::Term> d_predicates;
};
/** Declares a synthesis conjecture */
public:
CheckSynthCommand(bool isNext = false) : d_isNext(isNext){};
/** returns the result of the check-synth call */
- api::SynthResult getResult() const;
+ cvc5::SynthResult getResult() const;
/** prints the result of the check-synth-call */
void printResult(std::ostream& out) const override;
/** invokes this command
* and then perform a satisfiability check, whose result is stored in
* d_result.
*/
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
/** creates a copy of this command */
Command* clone() const override;
/** returns this command's name */
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** Whether this is a check-synth-next call */
bool d_isNext;
/** result of the check-synth call */
- api::SynthResult d_result;
+ cvc5::SynthResult d_result;
/** string stream that stores the output of the solution */
std::stringstream d_solution;
};
class CVC5_EXPORT SimplifyCommand : public Command
{
protected:
- api::Term d_term;
- api::Term d_result;
+ cvc5::Term d_term;
+ cvc5::Term d_result;
public:
- SimplifyCommand(api::Term term);
+ SimplifyCommand(cvc5::Term term);
- api::Term getTerm() const;
- api::Term getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ cvc5::Term getTerm() const;
+ cvc5::Term getResult() const;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class SimplifyCommand */
class CVC5_EXPORT GetValueCommand : public Command
{
protected:
- std::vector<api::Term> d_terms;
- api::Term d_result;
+ std::vector<cvc5::Term> d_terms;
+ cvc5::Term d_result;
public:
- GetValueCommand(api::Term term);
- GetValueCommand(const std::vector<api::Term>& terms);
+ GetValueCommand(cvc5::Term term);
+ GetValueCommand(const std::vector<cvc5::Term>& terms);
- const std::vector<api::Term>& getTerms() const;
- api::Term getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ const std::vector<cvc5::Term>& getTerms() const;
+ cvc5::Term getResult() const;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class GetValueCommand */
class CVC5_EXPORT GetAssignmentCommand : public Command
{
protected:
- api::Term d_result;
+ cvc5::Term d_result;
public:
GetAssignmentCommand();
- api::Term getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ cvc5::Term getResult() const;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class GetAssignmentCommand */
class CVC5_EXPORT GetModelCommand : public Command
{
public:
GetModelCommand();
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** Result of printing the model */
public:
BlockModelCommand();
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class BlockModelCommand */
/** The command to block model values. */
class CVC5_EXPORT BlockModelValuesCommand : public Command
{
public:
- BlockModelValuesCommand(const std::vector<api::Term>& terms);
+ BlockModelValuesCommand(const std::vector<cvc5::Term>& terms);
- const std::vector<api::Term>& getTerms() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ const std::vector<cvc5::Term>& getTerms() const;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** The terms we are blocking */
- std::vector<api::Term> d_terms;
+ std::vector<cvc5::Term> d_terms;
}; /* class BlockModelValuesCommand */
class CVC5_EXPORT GetProofCommand : public Command
public:
GetProofCommand();
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
private:
/** the result of the getProof call */
public:
GetInstantiationsCommand();
- static bool isEnabled(api::Solver* solver, const api::Result& res);
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ static bool isEnabled(cvc5::Solver* solver, const cvc5::Result& res);
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
- api::Solver* d_solver;
+ cvc5::Solver* d_solver;
}; /* class GetInstantiationsCommand */
/** The command (get-interpolant s B (G)?)
class CVC5_EXPORT GetInterpolantCommand : public Command
{
public:
- GetInterpolantCommand(const std::string& name, api::Term conj);
+ GetInterpolantCommand(const std::string& name, Term conj);
/** The argument g is the grammar of the interpolation query */
GetInterpolantCommand(const std::string& name,
- api::Term conj,
- api::Grammar* g);
+ Term conj,
+ Grammar* g);
/** Get the conjecture of the interpolation query */
- api::Term getConjecture() const;
+ cvc5::Term getConjecture() const;
/** Get the sygus grammar given for the interpolation query */
- const api::Grammar* getGrammar() const;
+ const cvc5::Grammar* getGrammar() const;
/** Get the result of the query, which is the solution to the interpolation
* query. */
- api::Term getResult() const;
+ cvc5::Term getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** The name of the interpolation predicate */
std::string d_name;
/** The conjecture of the interpolation query */
- api::Term d_conj;
+ cvc5::Term d_conj;
/** The (optional) grammar of the interpolation query */
- api::Grammar* d_sygus_grammar;
+ cvc5::Grammar* d_sygus_grammar;
/** the return expression of the command */
- api::Term d_result;
+ cvc5::Term d_result;
}; /* class GetInterpolCommand */
/** The command (get-interpolant-next) */
* Get the result of the query, which is the solution to the interpolation
* query.
*/
- api::Term getResult() const;
+ cvc5::Term getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** The name of the interpolation predicate */
std::string d_name;
/** the return expression of the command */
- api::Term d_result;
+ cvc5::Term d_result;
};
/** The command (get-abduct s B (G)?)
class CVC5_EXPORT GetAbductCommand : public Command
{
public:
- GetAbductCommand(const std::string& name, api::Term conj);
- GetAbductCommand(const std::string& name, api::Term conj, api::Grammar* g);
+ GetAbductCommand(const std::string& name, cvc5::Term conj);
+ GetAbductCommand(const std::string& name, cvc5::Term conj, cvc5::Grammar* g);
/** Get the conjecture of the abduction query */
- api::Term getConjecture() const;
+ cvc5::Term getConjecture() const;
/** Get the grammar given for the abduction query */
- const api::Grammar* getGrammar() const;
+ const cvc5::Grammar* getGrammar() const;
/** Get the name of the abduction predicate for the abduction query */
std::string getAbductName() const;
/** Get the result of the query, which is the solution to the abduction query.
*/
- api::Term getResult() const;
+ cvc5::Term getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** The name of the abduction predicate */
std::string d_name;
/** The conjecture of the abduction query */
- api::Term d_conj;
+ cvc5::Term d_conj;
/** The (optional) grammar of the abduction query */
- api::Grammar* d_sygus_grammar;
+ cvc5::Grammar* d_sygus_grammar;
/** the return expression of the command */
- api::Term d_result;
+ cvc5::Term d_result;
}; /* class GetAbductCommand */
/** The command (get-abduct-next) */
/**
* Get the result of the query, which is the solution to the abduction query.
*/
- api::Term getResult() const;
+ cvc5::Term getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** The name of the abduction predicate */
std::string d_name;
/** the return expression of the command */
- api::Term d_result;
+ cvc5::Term d_result;
};
class CVC5_EXPORT GetQuantifierEliminationCommand : public Command
{
protected:
- api::Term d_term;
+ cvc5::Term d_term;
bool d_doFull;
- api::Term d_result;
+ cvc5::Term d_result;
public:
GetQuantifierEliminationCommand();
- GetQuantifierEliminationCommand(const api::Term& term, bool doFull);
+ GetQuantifierEliminationCommand(const cvc5::Term& term, bool doFull);
- api::Term getTerm() const;
+ cvc5::Term getTerm() const;
bool getDoFull() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
- api::Term getResult() const;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
+ cvc5::Term getResult() const;
void printResult(std::ostream& out) const override;
Command* clone() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class GetQuantifierEliminationCommand */
class CVC5_EXPORT GetUnsatAssumptionsCommand : public Command
{
public:
GetUnsatAssumptionsCommand();
- void invoke(api::Solver* solver, SymbolManager* sm) override;
- std::vector<api::Term> getResult() const;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
+ std::vector<cvc5::Term> getResult() const;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
- std::vector<api::Term> d_result;
+ std::vector<cvc5::Term> d_result;
}; /* class GetUnsatAssumptionsCommand */
class CVC5_EXPORT GetUnsatCoreCommand : public Command
{
public:
GetUnsatCoreCommand();
- const std::vector<api::Term>& getUnsatCore() const;
+ const std::vector<cvc5::Term>& getUnsatCore() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** The symbol manager we were invoked with */
SymbolManager* d_sm;
/** the result of the unsat core call */
- std::vector<api::Term> d_result;
+ std::vector<cvc5::Term> d_result;
}; /* class GetUnsatCoreCommand */
class CVC5_EXPORT GetDifficultyCommand : public Command
{
public:
GetDifficultyCommand();
- const std::map<api::Term, api::Term>& getDifficultyMap() const;
+ const std::map<cvc5::Term, cvc5::Term>& getDifficultyMap() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** The symbol manager we were invoked with */
SymbolManager* d_sm;
/** the result of the get difficulty call */
- std::map<api::Term, api::Term> d_result;
+ std::map<cvc5::Term, cvc5::Term> d_result;
};
class CVC5_EXPORT GetLearnedLiteralsCommand : public Command
{
public:
GetLearnedLiteralsCommand();
- const std::vector<api::Term>& getLearnedLiterals() const;
+ const std::vector<cvc5::Term>& getLearnedLiterals() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
protected:
/** the result of the get learned literals call */
- std::vector<api::Term> d_result;
+ std::vector<cvc5::Term> d_result;
};
class CVC5_EXPORT GetAssertionsCommand : public Command
public:
GetAssertionsCommand();
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
std::string getResult() const;
void printResult(std::ostream& out) const override;
Command* clone() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class GetAssertionsCommand */
class CVC5_EXPORT SetBenchmarkLogicCommand : public Command
SetBenchmarkLogicCommand(std::string logic);
std::string getLogic() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class SetBenchmarkLogicCommand */
class CVC5_EXPORT SetInfoCommand : public Command
const std::string& getFlag() const;
const std::string& getValue() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class SetInfoCommand */
class CVC5_EXPORT GetInfoCommand : public Command
std::string getFlag() const;
std::string getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class GetInfoCommand */
class CVC5_EXPORT SetOptionCommand : public Command
const std::string& getFlag() const;
const std::string& getValue() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class SetOptionCommand */
class CVC5_EXPORT GetOptionCommand : public Command
std::string getFlag() const;
std::string getResult() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
void printResult(std::ostream& out) const override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class GetOptionCommand */
class CVC5_EXPORT DatatypeDeclarationCommand : public Command
{
private:
- std::vector<api::Sort> d_datatypes;
+ std::vector<cvc5::Sort> d_datatypes;
public:
- DatatypeDeclarationCommand(const api::Sort& datatype);
+ DatatypeDeclarationCommand(const cvc5::Sort& datatype);
- DatatypeDeclarationCommand(const std::vector<api::Sort>& datatypes);
- const std::vector<api::Sort>& getDatatypes() const;
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ DatatypeDeclarationCommand(const std::vector<cvc5::Sort>& datatypes);
+ const std::vector<cvc5::Sort>& getDatatypes() const;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class DatatypeDeclarationCommand */
class CVC5_EXPORT ResetCommand : public Command
{
public:
ResetCommand() {}
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class ResetCommand */
class CVC5_EXPORT ResetAssertionsCommand : public Command
{
public:
ResetAssertionsCommand() {}
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class ResetAssertionsCommand */
class CVC5_EXPORT QuitCommand : public Command
{
public:
QuitCommand() {}
- void invoke(api::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
Command* clone() const override;
std::string getCommandName() const override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class QuitCommand */
class CVC5_EXPORT CommandSequence : public Command
void addCommand(Command* cmd);
void clear();
- void invoke(api::Solver* solver, SymbolManager* sm) override;
- void invoke(api::Solver* solver,
+ void invoke(cvc5::Solver* solver, SymbolManager* sm) override;
+ void invoke(cvc5::Solver* solver,
SymbolManager* sm,
std::ostream& out) override;
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
}; /* class CommandSequence */
class CVC5_EXPORT DeclarationSequence : public CommandSequence
void toStream(std::ostream& out,
int toDepth = -1,
size_t dag = 1,
- Language language = Language::LANG_AUTO) const override;
+ internal::Language language =
+ internal::Language::LANG_AUTO) const override;
};
} // namespace cvc5
#include "smt/env.h"
#include "util/rational.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
DifficultyPostprocessCallback::DifficultyPostprocessCallback()
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_node_updater.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
/**
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/resource_manager.h"
#include "util/statistics_registry.h"
-using namespace cvc5::smt;
+using namespace cvc5::internal::smt;
-namespace cvc5 {
+namespace cvc5::internal {
Env::Env(NodeManager* nm, const Options* opts)
: d_context(new context::Context()),
{
return *d_options.base.out;
}
- return cvc5::null_os;
+ return cvc5::internal::null_os;
}
bool Env::isVerboseOn(int64_t level) const
{
return *d_options.base.err;
}
- return cvc5::null_os;
+ return cvc5::internal::null_os;
}
std::ostream& Env::warning() const
node, d_options.theory.theoryOfMode, d_uninterpretedSortOwner);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_id.h"
#include "util/statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
class NodeManager;
class StatisticsRegistry;
/**
* Return the output stream for the given output tag (as a string). If the
* output tag is enabled, this returns the output stream from the `out`
- * option. Otherwise, a null stream (`cvc5::null_os`) is returned.
+ * option. Otherwise, a null stream (`cvc5::internal::null_os`) is returned.
*/
std::ostream& output(const std::string& tag) const;
/**
* Return the output stream for the given output tag. If the output tag is
* enabled, this returns the output stream from the `out` option. Otherwise,
- * a null stream (`cvc5::null_os`) is returned. The user of this method needs
+ * a null stream (`cvc5::internal::null_os`) is returned. The user of this method needs
* to make sure that a proper S-expression is printed.
*/
std::ostream& output(OutputTag tag) const;
/**
* Return the output stream for the given verbosity level. If the verbosity
* level is enabled, this returns the output stream from the `err` option.
- * Otherwise, a null stream (`cvc5::null_os`) is returned.
+ * Otherwise, a null stream (`cvc5::internal::null_os`) is returned.
*/
std::ostream& verbose(int64_t level) const;
*/
Options d_options;
/**
- * A pointer to the original options object as stored in the api::Solver.
+ * A pointer to the original options object as stored in the cvc5::Solver.
* The referenced objects holds the options as initially parsed before being
* changed, e.g., by setDefaults().
*/
theory::TheoryId d_uninterpretedSortOwner;
}; /* class Env */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__ENV_H */
#include "smt/env.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
EnvObj::EnvObj(Env& env) : d_env(env) {}
std::ostream& EnvObj::warning() const { return verbose(0); }
-} // namespace cvc5
+} // namespace cvc5::internal
#include <memory>
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
class LogicInfo;
Env& d_env;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/theory.h"
#include "util/resource_manager.h"
-using namespace cvc5::preprocessing;
-using namespace cvc5::theory;
-using namespace cvc5::kind;
+using namespace cvc5::internal::preprocessing;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
ExpandDefs::ExpandDefs(Env& env) : EnvObj(env), d_tpg(nullptr) {}
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/trust_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
class TConvProofGenerator;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/smt_engine_subsolver.h"
#include "theory/trust_substitutions.h"
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
InterpolationSolver::InterpolationSolver(Env& env) : EnvObj(env) {}
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__INTERPOLATION_SOLVER_H */
#include "smt/solver_engine.h"
#include "smt/solver_engine_scope.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
ResourceOutListener::ResourceOutListener(SolverEngine& slv) : d_slv(slv) {}
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/listener.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class OutputManager;
class SolverEngine;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "base/exception.h"
-namespace cvc5 {
+namespace cvc5::internal {
-class LogicException : public cvc5::Exception
+class LogicException : public cvc5::internal::Exception
{
public:
LogicException() :
}
}; /* class LogicException */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__LOGIC_EXCEPTION_H */
#include "options/io_utils.h"
#include "printer/printer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
Model::Model(bool isKnownSat, const std::string& inputName)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
class Model;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__MODEL_H */
#include "theory/rewriter.h"
#include "theory/theory_model.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
ModelBlocker::ModelBlocker(Env& e) : EnvObj(e) {}
return blocker;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "options/smt_options.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class TheoryModel;
const std::vector<Node>& exprToBlock = std::vector<Node>());
}; /* class TheoryModelCoreBuilder */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* __CVC5__THEORY__MODEL_BLOCKER_H */
#include "theory/subs_minimize.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
ModelCoreBuilder::ModelCoreBuilder(Env& env) : EnvObj(env) {}
return false;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/theory_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A utility for building model cores.
options::ModelCoresMode mode);
}; /* class TheoryModelCoreBuilder */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__MODEL_CORE_BUILDER_H */
#include "smt/solver_engine.h"
#include "theory/smt_engine_subsolver.h"
-using namespace cvc5::theory;
-using namespace cvc5::omt;
-namespace cvc5 {
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::omt;
+namespace cvc5::internal {
namespace smt {
std::ostream& operator<<(std::ostream& out, const OptimizationResult& result)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "util/result.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
class SolverEngine;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__OPTIMIZATION_SOLVER_H */
#include "smt/env.h"
#include "theory/quantifiers/extended_rewrite.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
PreprocessProofGenerator::PreprocessProofGenerator(
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/trust_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class LazyCDProof;
class ProofNodeManager;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::theory;
-using namespace cvc5::kind;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
Preprocessor::Preprocessor(Env& env,
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/process_assertions.h"
#include "theory/booleans/circuit_propagator.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TheoryEngine;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/node_algorithm.h"
#include "printer/printer.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
void PrintBenchmark::printAssertions(std::ostream& out,
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Printer;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__PRINT_BENCHMARK_H */
#include "theory/theory_engine.h"
using namespace std;
-using namespace cvc5::preprocessing;
-using namespace cvc5::theory;
-using namespace cvc5::kind;
+using namespace cvc5::internal::preprocessing;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
/** Useful for counting the number of recursive calls. */
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "util/resource_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
class AssertionPipeline;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/builtin/proof_checker.h"
#include "theory/theory_id.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
ProofFinalCallback::ProofFinalCallback(ProofNodeManager* pnm)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_id.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
/** Final callback class, for stats and pedantic checking */
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "smt/preprocess_proof_generator.h"
#include "smt/proof_post_processor.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
PfManager::PfManager(Env& env)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofChecker;
class ProofNode;
}; /* class SolverEngine */
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__PROOF_MANAGER_H */
#include "theory/theory.h"
#include "util/rational.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
ProofPostprocessCallback::ProofPostprocessCallback(Env& env,
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_id.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace rewriter {
class RewriteDb;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/string.h"
#include "expr/subtype_elim_node_converter.h"
-using namespace cvc5::theory;
-using namespace cvc5::kind;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
QuantElimSolver::QuantElimSolver(Env& env, SmtSolver& sms)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/assertions.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
class SmtSolver;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__QUANT_ELIM_SOLVER_H */
#include "smt/logic_exception.h"
#include "theory/theory.h"
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
SetDefaults::SetDefaults(Env& env, bool isInternalSubsolver)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/logic_info.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
/**
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__SET_DEFAULTS_H */
#include <iostream>
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& out, SmtMode m)
{
return out;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
/**
* The mode of the solver, which is an extension of Figure 4.1 on
*/
std::ostream& operator<<(std::ostream& out, SmtMode m);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
SmtSolver::SmtSolver(Env& env,
Preprocessor* SmtSolver::getPreprocessor() { return &d_pp; }
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/logic_info.h"
#include "util/result.h"
-namespace cvc5 {
+namespace cvc5::internal {
class SolverEngine;
class Env;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__SMT_SOLVER_H */
#include "smt/solver_engine_scope.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
StatisticsRegistry& smtStatisticsRegistry()
{
return smt::SolverEngineScope::currentStatisticsRegistry();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/statistics_registry.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* This returns the StatisticsRegistry attached to the currently in scope
*/
StatisticsRegistry& smtStatisticsRegistry();
-} // namespace cvc5
+} // namespace cvc5::internal
#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::internal::smt;
+using namespace cvc5::internal::preprocessing;
+using namespace cvc5::internal::prop;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
SolverEngine::SolverEngine(NodeManager* nm, const Options* optr)
: d_env(new Env(nm, optr)),
theory::Rewriter* SolverEngine::getRewriter() { return d_env->getRewriter(); }
-} // namespace cvc5
+} // namespace cvc5::internal
namespace cvc5 {
+class Solver;
+
+namespace internal {
+
template <bool ref_count>
class NodeTemplate;
typedef NodeTemplate<true> Node;
/* -------------------------------------------------------------------------- */
-namespace api {
-class Solver;
-} // namespace api
-
/* -------------------------------------------------------------------------- */
namespace context {
class CVC5_EXPORT SolverEngine
{
- friend class ::cvc5::api::Solver;
- friend class ::cvc5::smt::SolverEngineState;
- friend class ::cvc5::smt::SolverEngineScope;
+ friend class cvc5::Solver;
+ friend class smt::SolverEngineState;
+ friend class smt::SolverEngineScope;
/* ....................................................................... */
public:
SolverEngine& operator=(const SolverEngine&) = delete;
/** Set solver instance that owns this SolverEngine. */
- void setSolver(api::Solver* solver) { d_solver = solver; }
+ void setSolver(cvc5::Solver* solver) { d_solver = solver; }
/** Get a pointer to the (new) PfManager owned by this SolverEngine. */
smt::PfManager* getPfManager() { return d_pfManager.get(); };
/* Members -------------------------------------------------------------- */
/** Solver instance that owns this SolverEngine instance. */
- api::Solver* d_solver = nullptr;
+ cvc5::Solver* d_solver = nullptr;
/**
* The environment object, which contains all utilities that are globally
/* -------------------------------------------------------------------------- */
+} // namespace internal
} // namespace cvc5
#endif /* CVC5__SMT_ENGINE_H */
#include "base/output.h"
#include "smt/solver_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
thread_local SolverEngine* s_slvEngine_current = nullptr;
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_manager.h"
#include "options/options.h"
-namespace cvc5 {
+namespace cvc5::internal {
class SolverEngine;
class StatisticsRegistry;
}; /* class SolverEngineScope */
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__SMT_ENGINE_SCOPE_H */
#include "smt/env.h"
#include "smt/solver_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
SolverEngineState::SolverEngineState(Env& env, SolverEngine& slv)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/result.h"
#include "util/synth_result.h"
-namespace cvc5 {
+namespace cvc5::internal {
class SolverEngine;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "smt/smt_statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
SolverEngineStatistics::SolverEngineStatistics(const std::string& name)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
struct SolverEngineStatistics
}; /* struct SolverEngineStatistics */
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__SMT_ENGINE_STATS_H */
#include "theory/rewriter.h"
#include "theory/smt_engine_subsolver.h"
-using namespace cvc5::theory;
-using namespace cvc5::kind;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
SygusSolver::SygusSolver(Env& env, SmtSolver& sms)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "util/synth_result.h"
-namespace cvc5 {
+namespace cvc5::internal {
class SolverEngine;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__SYGUS_SOLVER_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
RemoveTermFormulas::RemoveTermFormulas(Env& env)
: EnvObj(env),
bool RemoveTermFormulas::isProofEnabled() const { return d_tpg != nullptr; }
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/skolem_lemma.h"
#include "util/hash.h"
-namespace cvc5 {
+namespace cvc5::internal {
class LazyCDProof;
class ProofNodeManager;
bool isProofEnabled() const;
}; /* class RemoveTTE */
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_node_algorithm.h"
#include "smt/assertions.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
void UnsatCoreManager::getUnsatCore(std::shared_ptr<ProofNode> pfn,
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_node.h"
#include "theory/quantifiers/instantiation_list.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
}; /* class UnsatCoreManager */
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SMT__UNSAT_CORE_MANAGER_H */
#include "smt/env.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace smt {
WitnessFormGenerator::WitnessFormGenerator(Env& env)
}
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof.h"
#include "proof/proof_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
};
} // namespace smt
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "smt_util/boolean_simplification.h"
-namespace cvc5 {
+namespace cvc5::internal {
bool BooleanSimplification::push_back_associative_commute_recursive(
Node n, std::vector<Node>& buffer, Kind k, Kind notK, bool negateNode)
return true;
}/* BooleanSimplification::push_back_associative_commute_recursive() */
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/check.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A class to contain a number of useful functions for simple
};/* class BooleanSimplification */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__BOOLEAN_SIMPLIFICATION_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
/* Begin the declaration of GLPK specific code. */
#ifdef CVC5_USE_GLPK
#include <glpk.h>
}/* extern "C" */
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /*#ifdef CVC5_USE_GLPK */
/* End the declaration of GLPK specific code. */
/* Begin GPLK/NOGLPK Glue code. */
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
ApproximateSimplex* ApproximateSimplex::mkApproximateSimplexSolver(const ArithVariables& vars, TreeLog& l, ApproximateStatistics& s){
}
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
/* End GPLK/NOGLPK Glue code. */
/* Begin GPLK implementation. */
#ifdef CVC5_USE_GLPK
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /*#ifdef CVC5_USE_GLPK */
/* End GPLK implementation. */
#include "util/rational.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "util/real_algebraic_number.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
const std::map<Node, Node>& model);
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
}
Node ArithIteUtils::reduceVariablesInItes(Node n){
- using namespace cvc5::kind;
+ using namespace cvc5::internal::kind;
if(d_reduceVar.find(n) != d_reduceVar.end()){
Node res = d_reduceVar[n];
return res.isNull() ? n : res;
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace preprocessing {
namespace util {
class ContainsTermITEVisitor;
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__ARITH_ITE_UTILS_H */
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
bool ArithMSum::getMonomial(Node n, Node& c, Node& v)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/** Arithmetic utilities regarding monomial sums.
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__MSUM_H */
#include "theory/arith/arith_poly_norm.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__POLY_NORM_H */
#include "theory/arith/inference_manager.h"
#include "theory/skolem_lemma.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/operator_elim.h"
#include "theory/logic_info.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class SkolemLemma;
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/iand.h"
#include "util/real_algebraic_number.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
NodeManager::currentNM()->mkConstRealOrInt(
t.getType(), Rational(1)));
}else if(exp.sgn() > 0 && exp.isIntegral()){
- cvc5::Rational r(expr::NodeValue::MAX_CHILDREN);
+ cvc5::internal::Rational r(expr::NodeValue::MAX_CHILDREN);
if (exp <= r)
{
unsigned num = exp.getNumerator().toUnsignedInt();
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/rewrites.h"
#include "theory/theory_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__ARITH_REWRITER_H */
#include "theory/arith/theory_arith_private.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/delta_rational.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
class Context;
}
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__ARITH_STATIC_LEARNER_H */
#include <cmath>
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__ARITH_UTILITIES_H */
#include <limits>
#include <set>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/index.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/cdhashmap.h"
#include "context/cdo.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__ARITHVAR_NODE_MAP_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/simplex.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/arithvar.h"
#include "util/dense_map.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/normal_form.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "theory/theory.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/pp_rewrite_eq.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/proof_node.h"
#include "theory/arith/theory_arith_private.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_id.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNode;
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/uf/equality_engine.h"
#include "theory/uf/proof_equality_engine.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/dense_map.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
class EagerProofGenerator;
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/delta_rational.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
class EagerProofGenerator;
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__CONSTRAINT_H */
#include "cvc5_private.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__CONSTRAINT_FORWARD_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/constraint_forward.h"
#include "util/dense_map.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& os, const DeltaRational& dq){
return os << "(" << dq.getNoninfinitesimalPart()
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
class DeltaRational;
*/
class DeltaRational {
private:
- cvc5::Rational c;
- cvc5::Rational k;
+ cvc5::internal::Rational c;
+ cvc5::internal::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::internal::Rational& base) : c(base), k(0, 1) {}
+ DeltaRational(const cvc5::internal::Rational& base, const cvc5::internal::Rational& coeff)
: c(base), k(coeff)
{
}
- const cvc5::Rational& getInfinitesimalPart() const { return k; }
+ const cvc5::internal::Rational& getInfinitesimalPart() const { return k; }
- const cvc5::Rational& getNoninfinitesimalPart() const { return c; }
+ const cvc5::internal::Rational& getNoninfinitesimalPart() const { return c; }
int sgn() const {
int s = getNoninfinitesimalPart().sgn();
}
DeltaRational operator+(const DeltaRational& other) const{
- cvc5::Rational tmpC = c + other.c;
- cvc5::Rational tmpK = k + other.k;
+ cvc5::internal::Rational tmpC = c + other.c;
+ cvc5::internal::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::internal::Rational tmpC = a * c;
+ cvc5::internal::Rational tmpK = a * k;
return DeltaRational(tmpC, tmpK);
}
DeltaRational operator-(const DeltaRational& a) const{
- cvc5::Rational negOne(cvc5::Integer(-1));
+ cvc5::internal::Rational negOne(cvc5::internal::Integer(-1));
return *(this) + (a * negOne);
}
}
DeltaRational operator/(const Rational& a) const{
- cvc5::Rational tmpC = c / a;
- cvc5::Rational tmpK = k / a;
+ cvc5::internal::Rational tmpC = c / a;
+ cvc5::internal::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::internal::Rational tmpC = c / a;
+ cvc5::internal::Rational tmpK = k / a;
return DeltaRational(tmpC, tmpK);
}
return *(this);
}
- DeltaRational& operator*=(const cvc5::Rational& a)
+ DeltaRational& operator*=(const cvc5::internal::Rational& a)
{
c *= a;
k *= a;
std::ostream& operator<<(std::ostream& os, const DeltaRational& n);
-} // namespace cvc5
+} // namespace cvc5::internal
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
class Context;
}
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__DIO_SOLVER_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/simplex.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/inference_manager.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/ee_setup_info.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/bin_heap.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/dense_map.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/infer_bounds.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} /* namespace arith */
} /* namespace theory */
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} /* namespace arith */
} /* namespace theory */
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/theory_arith.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_id.h"
#include "theory/inference_manager_buffered.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
# src/theory/builtin/kinds.
#
-theory THEORY_ARITH ::cvc5::theory::arith::TheoryArith "theory/arith/theory_arith.h"
+theory THEORY_ARITH ::cvc5::internal::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::internal::theory::arith::ArithRewriter "theory/arith/arith_rewriter.h"
operator ADD 2: "arithmetic addition (N-ary)"
operator MULT 2: "arithmetic multiplication (N-ary)"
constant DIVISIBLE_OP \
struct \
Divisible \
- ::cvc5::DivisibleHashFunction \
+ ::cvc5::internal::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::internal::Divisible class"
sort REAL_TYPE \
Cardinality::REALS \
constant CONST_RATIONAL \
class \
Rational+ \
- ::cvc5::RationalHashFunction \
+ ::cvc5::internal::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::internal::Rational class"
constant CONST_INTEGER \
class \
Rational+ \
- ::cvc5::RationalHashFunction \
+ ::cvc5::internal::RationalHashFunction \
"util/rational.h" \
- "a multiple-precision integer constant; payload is an instance of the cvc5::Rational class"
+ "a multiple-precision integer constant; payload is an instance of the cvc5::internal::Rational class"
constant REAL_ALGEBRAIC_NUMBER_OP \
class \
RealAlgebraicNumber+ \
- ::cvc5::RealAlgebraicNumberHashFunction \
+ ::cvc5::internal::RealAlgebraicNumberHashFunction \
"util/real_algebraic_number.h" \
- "a real algebraic number constant; payload is an instance of the cvc5::RealAlgebraicNumber class"
-parameterized REAL_ALGEBRAIC_NUMBER REAL_ALGEBRAIC_NUMBER_OP 0 "a real algebraic number constant; payload is an instance of the cvc5::RealAlgebraicNumber class"
+ "a real algebraic number constant; payload is an instance of the cvc5::internal::RealAlgebraicNumber class"
+parameterized REAL_ALGEBRAIC_NUMBER REAL_ALGEBRAIC_NUMBER_OP 0 "a real algebraic number constant; payload is an instance of the cvc5::internal::RealAlgebraicNumber class"
enumerator REAL_TYPE \
- "::cvc5::theory::arith::RationalEnumerator" \
+ "::cvc5::internal::theory::arith::RationalEnumerator" \
"theory/arith/type_enumerator.h"
enumerator INTEGER_TYPE \
- "::cvc5::theory::arith::IntegerEnumerator" \
+ "::cvc5::internal::theory::arith::IntegerEnumerator" \
"theory/arith/type_enumerator.h"
operator LT 2 "less than, x < y"
constant INDEXED_ROOT_PREDICATE_OP \
struct \
IndexedRootPredicate \
- ::cvc5::IndexedRootPredicateHashFunction \
+ ::cvc5::internal::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::internal::IndexedRootPredicate class"
parameterized INDEXED_ROOT_PREDICATE INDEXED_ROOT_PREDICATE_OP 2 "indexed root predicate; first parameter is a INDEXED_ROOT_PREDICATE_OP, second is a real variable compared to zero, third is a polynomial"
operator IS_INTEGER 1 "term-is-integer predicate (parameter is a real-sorted term)"
# This way, we avoid having 2 nested TO_REAL nodess as a result of Solver::mkTerm(TO_REAL, Solver::mkReal(int val))
operator CAST_TO_REAL 1 "cast term to real same as TO_REAL, but it is used internally, whereas TO_REAL is accessible in the API"
-typerule ADD ::cvc5::theory::arith::ArithOperatorTypeRule
-typerule MULT ::cvc5::theory::arith::ArithOperatorTypeRule
-typerule NONLINEAR_MULT ::cvc5::theory::arith::ArithOperatorTypeRule
-typerule SUB ::cvc5::theory::arith::ArithOperatorTypeRule
-typerule NEG ::cvc5::theory::arith::ArithOperatorTypeRule
-typerule DIVISION ::cvc5::theory::arith::ArithOperatorTypeRule
-typerule POW ::cvc5::theory::arith::ArithOperatorTypeRule
+typerule ADD ::cvc5::internal::theory::arith::ArithOperatorTypeRule
+typerule MULT ::cvc5::internal::theory::arith::ArithOperatorTypeRule
+typerule NONLINEAR_MULT ::cvc5::internal::theory::arith::ArithOperatorTypeRule
+typerule SUB ::cvc5::internal::theory::arith::ArithOperatorTypeRule
+typerule NEG ::cvc5::internal::theory::arith::ArithOperatorTypeRule
+typerule DIVISION ::cvc5::internal::theory::arith::ArithOperatorTypeRule
+typerule POW ::cvc5::internal::theory::arith::ArithOperatorTypeRule
-typerule CONST_RATIONAL ::cvc5::theory::arith::ArithConstantTypeRule
-typerule CONST_INTEGER ::cvc5::theory::arith::ArithConstantTypeRule
+typerule CONST_RATIONAL ::cvc5::internal::theory::arith::ArithConstantTypeRule
+typerule CONST_INTEGER ::cvc5::internal::theory::arith::ArithConstantTypeRule
-typerule REAL_ALGEBRAIC_NUMBER_OP ::cvc5::theory::arith::ArithRealAlgebraicNumberOpTypeRule
-typerule REAL_ALGEBRAIC_NUMBER ::cvc5::theory::arith::ArithRealAlgebraicNumberTypeRule
+typerule REAL_ALGEBRAIC_NUMBER_OP ::cvc5::internal::theory::arith::ArithRealAlgebraicNumberOpTypeRule
+typerule REAL_ALGEBRAIC_NUMBER ::cvc5::internal::theory::arith::ArithRealAlgebraicNumberTypeRule
-typerule LT ::cvc5::theory::arith::ArithRelationTypeRule
-typerule LEQ ::cvc5::theory::arith::ArithRelationTypeRule
-typerule GT ::cvc5::theory::arith::ArithRelationTypeRule
-typerule GEQ ::cvc5::theory::arith::ArithRelationTypeRule
+typerule LT ::cvc5::internal::theory::arith::ArithRelationTypeRule
+typerule LEQ ::cvc5::internal::theory::arith::ArithRelationTypeRule
+typerule GT ::cvc5::internal::theory::arith::ArithRelationTypeRule
+typerule GEQ ::cvc5::internal::theory::arith::ArithRelationTypeRule
typerule INDEXED_ROOT_PREDICATE_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule INDEXED_ROOT_PREDICATE ::cvc5::theory::arith::IndexedRootPredicateTypeRule
+typerule INDEXED_ROOT_PREDICATE ::cvc5::internal::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::internal::theory::arith::ArithOperatorTypeRule
+typerule CAST_TO_REAL ::cvc5::internal::theory::arith::ArithOperatorTypeRule
+typerule TO_INTEGER ::cvc5::internal::theory::arith::ArithOperatorTypeRule
typerule IS_INTEGER "SimpleTypeRule<RBool, AReal>"
-typerule ABS ::cvc5::theory::arith::ArithOperatorTypeRule
+typerule ABS ::cvc5::internal::theory::arith::ArithOperatorTypeRule
typerule INTS_DIVISION "SimpleTypeRule<RInteger, AInteger, AInteger>"
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::internal::theory::arith::ArithOperatorTypeRule
typerule INTS_DIVISION_TOTAL "SimpleTypeRule<RInteger, AInteger, AInteger>"
typerule INTS_MODULUS_TOTAL "SimpleTypeRule<RInteger, AInteger, AInteger>"
nullaryoperator PI "pi"
-typerule PI ::cvc5::theory::arith::RealNullaryOperatorTypeRule
+typerule PI ::cvc5::internal::theory::arith::RealNullaryOperatorTypeRule
# Integer AND, which is parameterized by a (positive) bitwidth k.
# ((_ iand k) i1 i2) is equivalent to:
constant IAND_OP \
struct \
IntAnd \
- "::cvc5::UnsignedHashFunction< ::cvc5::IntAnd >" \
+ "::cvc5::internal::UnsignedHashFunction< ::cvc5::internal::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::internal::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::internal::theory::arith::IAndOpTypeRule
+typerule IAND ::cvc5::internal::theory::arith::IAndTypeRule
endtheory
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/tableau.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/matrix.h"
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/dense_map.h"
#include "util/index.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
typedef MatrixEntry<T> Entry;
protected:
- typedef cvc5::theory::arith::RowVector<T> RowVectorT;
- typedef cvc5::theory::arith::ColumnVector<T> ColumnVectorT;
+ typedef cvc5::internal::theory::arith::RowVector<T> RowVectorT;
+ typedef cvc5::internal::theory::arith::ColumnVector<T> ColumnVectorT;
public:
typedef typename RowVectorT::const_iterator RowIterator;
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/nl/nl_model.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
namespace std {
/** Generic streaming operator for std::vector. */
template <typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v)
{
- cvc5::container_to_stream(os, v);
+ cvc5::internal::container_to_stream(os, v);
return os;
}
} // namespace std
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/nl/coverings/proof_generator.h"
#include "theory/arith/nl/coverings/variable_ordering.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/nl/coverings/projections.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/node.h"
#include "theory/arith/nl/coverings/projections.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#ifdef CVC5_POLY_IMP
#ifdef CVC5_USE_COCOA
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#endif
#include "base/output.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#endif
#include "theory/arith/nl/poly_conversion.h"
#include "util/poly_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/nl/poly_conversion.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/nl/coverings/cocoa_converter.h"
-namespace cvc5::theory::arith::nl::coverings {
+namespace cvc5::internal::theory::arith::nl::coverings {
struct LazardEvaluationStats
{
return combined;
}
-} // namespace cvc5::theory::arith::nl::coverings
+} // namespace cvc5::internal::theory::arith::nl::coverings
#else
-namespace cvc5::theory::arith::nl::coverings {
+namespace cvc5::internal::theory::arith::nl::coverings {
/**
* Do a very simple wrapper around the regular poly::infeasible_regions.
return poly::infeasible_regions(q, d_state->d_assignment, sc);
}
-} // namespace cvc5::theory::arith::nl::coverings
+} // namespace cvc5::internal::theory::arith::nl::coverings
#endif
#endif
#include <memory>
-namespace cvc5::theory::arith::nl::coverings {
+namespace cvc5::internal::theory::arith::nl::coverings {
struct LazardEvaluationState;
/**
std::unique_ptr<LazardEvaluationState> d_state;
};
-} // namespace cvc5::theory::arith::nl::coverings
+} // namespace cvc5::internal::theory::arith::nl::coverings
#endif
#endif
#include "base/check.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <vector>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/sequence.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__PROOF_CHECKER_H */
#include "theory/arith/nl/poly_conversion.h"
#include "util/indexed_root_predicate.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "proof/proof_set.h"
#include "theory/arith/nl/coverings/cdcac_utils.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofGenerator;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#endif
#include "util/poly_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/nl/coverings/constraints.h"
#include "util/poly_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/inference_id.h"
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/nl/coverings/proof_checker.h"
#include "theory/arith/nl/equality_substitution.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__COVERINGS_SOLVER_H */
#include "smt/env.h"
#include "theory/arith/arith_utilities.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/substitutions.h"
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__NL__EQUALITY_SUBSTITUTION_H */
#include "theory/arith/arith_utilities.h"
#include "theory/arith/nl/ext/monomial.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/kind.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__NL_SOLVER_H */
#include "theory/arith/nl/nl_model.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env.h"
#include "theory/arith/nl/ext/monomial.h"
-namespace cvc5 {
+namespace cvc5::internal {
class CDProof;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class CDProof;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/nl/nl_lemma_utils.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__NL_MONOMIAL_H */
#include "theory/arith/nl/nl_model.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/arith/nl/ext/constraint.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/nl/nl_model.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/nl/ext/monomial.h"
#include "theory/theory_inference.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/arith_utilities.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_checker.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__PROOF_CHECKER_H */
#include "theory/arith/nl/nl_model.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/arith_utilities.h"
#include "theory/uf/equality_engine.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/ext_theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
class EqualityEngine;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__NL__EXT_THEORY_CALLBACK_H */
#include "util/bitvector.h"
#include "util/iand.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/arith/nl/iand_utils.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__IAND_SOLVER_H */
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__IAND_TABLE_H */
#include "theory/arith/nl/icp/intersection.h"
#include "theory/arith/nl/poly_conversion.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/node.h"
#include "theory/arith/nl/icp/intersection.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/nl/icp/contraction_origins.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "util/poly_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/nl/icp/intersection.h"
#include "theory/arith/nl/poly_conversion.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "base/output.h"
#include "theory/arith/nl/poly_conversion.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
class Interval;
}
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/nl/nl_model.h"
#include "theory/arith/nl/nonlinear_extension.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/theory_inference.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__NL_LEMMA_UTILS_H */
#include "theory/theory_model.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/subs.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
class Context;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__NONLINEAR_EXTENSION_H */
#include "theory/theory_model.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "util/result.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
class EqualityEngine;
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__NONLINEAR_EXTENSION_H */
#include "theory/arith/bound_inference.h"
#include "util/poly_util.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
-poly::Variable VariableMapper::operator()(const cvc5::Node& n)
+poly::Variable VariableMapper::operator()(const cvc5::internal::Node& n)
{
auto it = mVarCVCpoly.find(n);
if (it == mVarCVCpoly.end())
return it->second;
}
-cvc5::Node VariableMapper::operator()(const poly::Variable& n)
+cvc5::internal::Node VariableMapper::operator()(const poly::Variable& n)
{
auto it = mVarpolyCVC.find(n);
Assert(it != mVarpolyCVC.end())
return it->second;
}
-cvc5::Node as_cvc_upolynomial(const poly::UPolynomial& p, const cvc5::Node& var)
+cvc5::internal::Node as_cvc_upolynomial(const poly::UPolynomial& p, const cvc5::internal::Node& var)
{
Trace("poly::conversion")
<< "Converting " << p << " over " << var << std::endl;
return res;
}
-poly::UPolynomial as_poly_upolynomial_impl(const cvc5::Node& n,
+poly::UPolynomial as_poly_upolynomial_impl(const cvc5::internal::Node& n,
poly::Integer& denominator,
- const cvc5::Node& var)
+ const cvc5::internal::Node& var)
{
denominator = poly::Integer(1);
if (n.isVar())
return poly::UPolynomial();
}
-poly::UPolynomial as_poly_upolynomial(const cvc5::Node& n,
- const cvc5::Node& var)
+poly::UPolynomial as_poly_upolynomial(const cvc5::internal::Node& n,
+ const cvc5::internal::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::internal::Node& n,
poly::Integer& denominator,
VariableMapper& vm)
{
}
return poly::Polynomial();
}
-poly::Polynomial as_poly_polynomial(const cvc5::Node& n, VariableMapper& vm)
+poly::Polynomial as_poly_polynomial(const cvc5::internal::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::internal::Node& n,
VariableMapper& vm,
poly::Rational& denominator)
{
}
} // namespace
-cvc5::Node as_cvc_polynomial(const poly::Polynomial& p, VariableMapper& vm)
+cvc5::internal::Node as_cvc_polynomial(const poly::Polynomial& p, VariableMapper& vm)
{
CollectMonomialData cmd(vm);
// Do the actual conversion
return cmd.d_nm->mkNode(Kind::ADD, cmd.d_terms);
}
-poly::SignCondition normalize_kind(cvc5::Kind kind,
+poly::SignCondition normalize_kind(cvc5::internal::Kind kind,
bool negated,
poly::Polynomial& lhs)
{
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/node.h"
#include "util/real_algebraic_number.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
struct VariableMapper
{
/** A mapping from cvc5 variables to poly variables. */
- std::map<cvc5::Node, poly::Variable> mVarCVCpoly;
+ std::map<cvc5::internal::Node, poly::Variable> mVarCVCpoly;
/** A mapping from poly variables to cvc5 variables. */
- std::map<poly::Variable, cvc5::Node> mVarpolyCVC;
+ std::map<poly::Variable, cvc5::internal::Node> mVarpolyCVC;
/** Retrieves the according poly variable. */
- poly::Variable operator()(const cvc5::Node& n);
+ poly::Variable operator()(const cvc5::internal::Node& n);
/** Retrieves the according cvc5 variable. */
- cvc5::Node operator()(const poly::Variable& n);
+ cvc5::internal::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::internal::Node. */
+cvc5::internal::Node as_cvc_upolynomial(const poly::UPolynomial& p,
+ const cvc5::internal::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::internal::Node to a poly univariate polynomial. */
+poly::UPolynomial as_poly_upolynomial(const cvc5::internal::Node& n,
+ const cvc5::internal::Node& var);
/**
* Constructs a polynomial from the given node.
* in the context of ICP) the second overload provides the denominator in the
* third argument.
*/
-poly::Polynomial as_poly_polynomial(const cvc5::Node& n, VariableMapper& vm);
-poly::Polynomial as_poly_polynomial(const cvc5::Node& n,
+poly::Polynomial as_poly_polynomial(const cvc5::internal::Node& n, VariableMapper& vm);
+poly::Polynomial as_poly_polynomial(const cvc5::internal::Node& n,
VariableMapper& vm,
poly::Rational& denominator);
* multiplications with one or use NONLINEAR_MULT where regular MULT may be
* sufficient), so it may be sensible to rewrite it afterwards.
*/
-cvc5::Node as_cvc_polynomial(const poly::Polynomial& p, VariableMapper& vm);
+cvc5::internal::Node as_cvc_polynomial(const poly::Polynomial& p, VariableMapper& vm);
/**
* Constructs a constraints (a polynomial and a sign condition) from the given
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "util/bitvector.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__POW2_SOLVER_H */
#include "smt/smt_statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__NL__STATS_H */
#include "base/check.h"
#include "options/arith_options.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "options/options.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__NL__STRATEGY_H */
#include "theory/arith/nl/transcendental/transcendental_state.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */
#include "theory/arith/nl/transcendental/taylor_generator.h"
#include "theory/evaluator.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_checker.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__PROOF_CHECKER_H */
#include "theory/arith/nl/transcendental/transcendental_state.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/arith/nl/transcendental/transcendental_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */
#include "theory/evaluator.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */
#include "theory/arith/nl/transcendental/taylor_generator.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/nl/transcendental/sine_solver.h"
#include "theory/arith/nl/transcendental/transcendental_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__TRANSCENDENTAL_SOLVER_H */
#include "theory/arith/nl/transcendental/taylor_generator.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/nl/transcendental/proof_checker.h"
#include "theory/arith/nl/transcendental/taylor_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
class CDProof;
namespace theory {
namespace arith {
} // namespace nl
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__NL__TRANSCENDENTAL__TRANSCENDENTAL_STATE_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} //namespace arith
} //namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/delta_rational.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__NORMAL_FORM_H */
#include "theory/rewriter.h"
#include "theory/theory.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/logic_info.h"
#include "theory/skolem_lemma.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TConvProofGenerator;
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/constraint_forward.h"
#include "theory/arith/delta_rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
class Context;
}
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__PARTIAL_MODEL_H */
#include "theory/builtin/proof_checker.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_node_manager.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/normal_form.h"
#include "theory/arith/operator_elim.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
}
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__PROOF_CHECKER_H */
#include "theory/arith/rewriter/ordering.h"
#include "util/real_algebraic_number.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace rewriter {
} // namespace rewriter
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/rewriter/ordering.h"
#include "util/real_algebraic_number.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace rewriter {
} // namespace rewriter
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "base/check.h"
#include "theory/arith/rewriter/ordering.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace rewriter {
} // namespace rewriter
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
#include "util/real_algebraic_number.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace rewriter {
} // namespace rewriter
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "base/check.h"
#include "expr/node.h"
-namespace cvc5::theory::arith::rewriter {
+namespace cvc5::internal::theory::arith::rewriter {
/**
* Implements an ordering on arithmetic leaf nodes. We expect that values have
}
};
-} // namespace cvc5::theory::arith::rewriter
+} // namespace cvc5::internal::theory::arith::rewriter
#endif
#include "base/check.h"
#include "theory/arith/rewriter/node_utils.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace rewriter {
} // namespace rewriter
} // namespace arith
} // namespace theory
-} // namespace cvc5
\ No newline at end of file
+} // namespace cvc5::internal
\ No newline at end of file
#include "expr/node.h"
#include "theory/arith/rewriter/addition.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace rewriter {
} // namespace rewriter
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <iostream>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__REWRITES_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
}
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/result.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
* Generates a string representation of std::optional and inserts it into a
* stream.
*
- * Note: We define this function here in the cvc5::theory::arith namespace,
+ * Note: We define this function here in the cvc5::internal::theory::arith namespace,
* because it would otherwise not be found for std::optional<int>. This is due
* to the argument-dependent lookup rules.
*
*/
std::ostream& operator<<(std::ostream& out, const std::optional<int>& m)
{
- return cvc5::operator<<(out, m);
+ return cvc5::internal::operator<<(out, m);
}
UpdateInfo::UpdateInfo():
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/constraint_forward.h"
#include "theory/arith/delta_rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/dense_map.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/tableau.h"
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/dense_map.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/tableau_sizes.h"
#include "theory/arith/tableau.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/arithvar.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_model.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/arith/pp_rewrite_eq.h"
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
namespace nl {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/statistics_stats.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/result.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
class EagerProofGenerator;
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__THEORY_ARITH_TYPE_RULES_H */
#include "util/integer.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arith {
} // namespace arith
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARITH__TYPE_ENUMERATOR_H */
#include "smt/smt_statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARRAYS__ARRAY_INFO_H */
#include "theory/theory_state.h"
#include "theory/uf/equality_engine.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_rule.h"
#include "theory/theory_inference_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
# src/theory/builtin/kinds.
#
-theory THEORY_ARRAYS ::cvc5::theory::arrays::TheoryArrays "theory/arrays/theory_arrays.h"
+theory THEORY_ARRAYS ::cvc5::internal::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::internal::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::internal::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::internal::theory::arrays::ArraysProperties::isWellFounded(%TYPE%)" \
+ "::cvc5::internal::theory::arrays::ArraysProperties::mkGroundTerm(%TYPE%)" \
"theory/arrays/theory_arrays_type_rules.h"
enumerator ARRAY_TYPE \
- "::cvc5::theory::arrays::ArrayEnumerator" \
+ "::cvc5::internal::theory::arrays::ArrayEnumerator" \
"theory/arrays/type_enumerator.h"
# select a i is a[i]
constant STORE_ALL \
class \
ArrayStoreAll \
- ::cvc5::ArrayStoreAllHashFunction \
+ ::cvc5::internal::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::internal::ArrayStoreAll class (this is not supported by arrays decision procedure yet, but it is used for returned array models)"
# used internally by array theory
operator ARR_TABLE_FUN 4 "array table function (internal-only symbol)"
# as a shifted over one.
operator ARRAY_LAMBDA 1 "array lambda (internal-only symbol)"
-typerule SELECT ::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::internal::theory::arrays::ArraySelectTypeRule
+typerule STORE ::cvc5::internal::theory::arrays::ArrayStoreTypeRule
+typerule STORE_ALL ::cvc5::internal::theory::arrays::ArrayStoreTypeRule
+typerule ARR_TABLE_FUN ::cvc5::internal::theory::arrays::ArrayTableFunTypeRule
+typerule ARRAY_LAMBDA ::cvc5::internal::theory::arrays::ArrayLambdaTypeRule
+typerule EQ_RANGE ::cvc5::internal::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::internal::theory::arrays::ArrayPartialSelectTypeRule
+typerule PARTIAL_SELECT_1 ::cvc5::internal::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::internal::theory::arrays::ArrayStoreTypeRule
endtheory
#include "theory/arrays/theory_arrays_rewriter.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARRAYS__PROOF_CHECKER_H */
#include "expr/skolem_manager.h"
#include "expr/type_node.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/uf/equality_engine.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARRAYS__THEORY_ARRAYS_H */
#include "theory/arrays/skolem_cache.h"
#include "util/cardinality.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_rewriter.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
class EagerProofGenerator;
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARRAYS__THEORY_ARRAYS_REWRITER_H */
#include "theory/type_enumerator.h"
#include "util/cardinality.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARRAYS__THEORY_ARRAYS_TYPE_RULES_H */
#include "theory/rewriter.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/rewriter.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ARRAYS__TYPE_ENUMERATOR_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace arrays {
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "context/cdo.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace context {
class Context;
} // namespace arrays
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /*CVC5__THEORY__ARRAYS__UNION_FIND_H */
#include "theory/assertion.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
std::ostream& operator<<(std::ostream& out, const Assertion& a) {
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/** Information about an assertion for the theories. */
std::ostream& operator<<(std::ostream& out, const Assertion& a);
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ASSERTION_H */
#include "theory/atom_requests.h"
-using namespace cvc5;
+using namespace cvc5::internal;
AtomRequests::AtomRequests(context::Context* context)
: d_allRequests(context)
#include "context/cdhashset.h"
#include "context/cdhashmap.h"
-namespace cvc5 {
+namespace cvc5::internal {
class AtomRequests {
};
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& out, const BagMakeOp& op)
{
return getType() == op.getType();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <memory>
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
size_t operator()(const BagMakeOp& op) const;
}; /* struct BagMakeOpHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__BAG_MAKE_OP_H */
#include "theory/quantifiers/fmf/bounded_integers.h"
#include "util/rational.h"
-using namespace cvc5;
-using namespace cvc5::kind;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/bags/inference_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__BAG_REDUCTION_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/bags/inference_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAG__SOLVER_H */
#include "util/rational.h"
#include "util/statistics_registry.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_rewriter.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__THEORY_BAGS_REWRITER_H */
#include "smt/smt_statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/bags/rewrites.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS_STATISTICS_H */
#include "theory/type_enumerator.h"
#include "util/rational.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory::datatypes;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory::datatypes;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#ifndef CVC5__THEORY__BAGS__UTILS_H
#define CVC5__THEORY__BAGS__UTILS_H
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
};
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__UTILS_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/bags/inference_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__CARD__SOLVER_H */
#include "theory/bags/inference_manager.h"
#include "theory/inference_manager_buffered.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_id.h"
#include "theory/theory_inference.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class InferenceManagerBuffered;
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__INFER_INFO_H */
#include "theory/uf/equality_engine.h"
#include "util/rational.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory::datatypes;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory::datatypes;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "infer_info.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__INFERENCE_GENERATOR_H */
#include "theory/bags/solver_state.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_manager_buffered.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__INFERENCE_MANAGER_H */
#
theory THEORY_BAGS \
- ::cvc5::theory::bags::TheoryBags \
+ ::cvc5::internal::theory::bags::TheoryBags \
"theory/bags/theory_bags.h"
typechecker "theory/bags/theory_bags_type_rules.h"
-rewriter ::cvc5::theory::bags::BagsRewriter \
+rewriter ::cvc5::internal::theory::bags::BagsRewriter \
"theory/bags/bags_rewriter.h"
properties parametric
constant BAG_EMPTY \
class \
EmptyBag \
- ::cvc5::EmptyBagHashFunction \
+ ::cvc5::internal::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::internal::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::internal::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::internal::theory::bags::BagsProperties::isWellFounded(%TYPE%)" \
+ "::cvc5::internal::theory::bags::BagsProperties::mkGroundTerm(%TYPE%)" \
"theory/bags/theory_bags_type_rules.h"
enumerator BAG_TYPE \
- "::cvc5::theory::bags::BagEnumerator" \
+ "::cvc5::internal::theory::bags::BagEnumerator" \
"theory/bags/theory_bags_type_enumerator.h"
# operators
constant BAG_MAKE_OP \
class \
BagMakeOp \
- ::cvc5::BagMakeOpHashFunction \
+ ::cvc5::internal::BagMakeOpHashFunction \
"theory/bags/bag_make_op.h" \
- "operator for BAG_MAKE; payload is an instance of the cvc5::BagMakeOp class"
+ "operator for BAG_MAKE; payload is an instance of the cvc5::internal::BagMakeOp class"
parameterized BAG_MAKE BAG_MAKE_OP 2 \
"constructs a bag from one element along with its multiplicity"
# B: a bag of type (Bag T1)
operator BAG_FOLD 3 "bag fold operator"
-typerule BAG_UNION_MAX ::cvc5::theory::bags::BinaryOperatorTypeRule
-typerule BAG_UNION_DISJOINT ::cvc5::theory::bags::BinaryOperatorTypeRule
-typerule BAG_INTER_MIN ::cvc5::theory::bags::BinaryOperatorTypeRule
-typerule BAG_DIFFERENCE_SUBTRACT ::cvc5::theory::bags::BinaryOperatorTypeRule
-typerule BAG_DIFFERENCE_REMOVE ::cvc5::theory::bags::BinaryOperatorTypeRule
-typerule BAG_SUBBAG ::cvc5::theory::bags::SubBagTypeRule
-typerule BAG_COUNT ::cvc5::theory::bags::CountTypeRule
-typerule BAG_MEMBER ::cvc5::theory::bags::MemberTypeRule
-typerule BAG_DUPLICATE_REMOVAL ::cvc5::theory::bags::DuplicateRemovalTypeRule
+typerule BAG_UNION_MAX ::cvc5::internal::theory::bags::BinaryOperatorTypeRule
+typerule BAG_UNION_DISJOINT ::cvc5::internal::theory::bags::BinaryOperatorTypeRule
+typerule BAG_INTER_MIN ::cvc5::internal::theory::bags::BinaryOperatorTypeRule
+typerule BAG_DIFFERENCE_SUBTRACT ::cvc5::internal::theory::bags::BinaryOperatorTypeRule
+typerule BAG_DIFFERENCE_REMOVE ::cvc5::internal::theory::bags::BinaryOperatorTypeRule
+typerule BAG_SUBBAG ::cvc5::internal::theory::bags::SubBagTypeRule
+typerule BAG_COUNT ::cvc5::internal::theory::bags::CountTypeRule
+typerule BAG_MEMBER ::cvc5::internal::theory::bags::MemberTypeRule
+typerule BAG_DUPLICATE_REMOVAL ::cvc5::internal::theory::bags::DuplicateRemovalTypeRule
typerule BAG_MAKE_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BAG_MAKE ::cvc5::theory::bags::BagMakeTypeRule
-typerule BAG_EMPTY ::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 BAG_MAP ::cvc5::theory::bags::BagMapTypeRule
-typerule BAG_FILTER ::cvc5::theory::bags::BagFilterTypeRule
-typerule BAG_FOLD ::cvc5::theory::bags::BagFoldTypeRule
+typerule BAG_MAKE ::cvc5::internal::theory::bags::BagMakeTypeRule
+typerule BAG_EMPTY ::cvc5::internal::theory::bags::EmptyBagTypeRule
+typerule BAG_CARD ::cvc5::internal::theory::bags::CardTypeRule
+typerule BAG_CHOOSE ::cvc5::internal::theory::bags::ChooseTypeRule
+typerule BAG_IS_SINGLETON ::cvc5::internal::theory::bags::IsSingletonTypeRule
+typerule BAG_FROM_SET ::cvc5::internal::theory::bags::FromSetTypeRule
+typerule BAG_TO_SET ::cvc5::internal::theory::bags::ToSetTypeRule
+typerule BAG_MAP ::cvc5::internal::theory::bags::BagMapTypeRule
+typerule BAG_FILTER ::cvc5::internal::theory::bags::BagFilterTypeRule
+typerule BAG_FOLD ::cvc5::internal::theory::bags::BagFoldTypeRule
-construle BAG_UNION_DISJOINT ::cvc5::theory::bags::BinaryOperatorTypeRule
-construle BAG_MAKE ::cvc5::theory::bags::BagMakeTypeRule
+construle BAG_UNION_DISJOINT ::cvc5::internal::theory::bags::BinaryOperatorTypeRule
+construle BAG_MAKE ::cvc5::internal::theory::bags::BagMakeTypeRule
# bag.product operator returns the cross product of two tables
operator TABLE_PRODUCT 2 "table cross product"
-typerule TABLE_PRODUCT ::cvc5::theory::bags::TableProductTypeRule
+typerule TABLE_PRODUCT ::cvc5::internal::theory::bags::TableProductTypeRule
endtheory
#include <iostream>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__REWRITES_H */
#include "theory/uf/equality_engine.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__THEORY_SOLVER_STATE_H */
#include "theory/bags/strategy.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__STRATEGY_H */
#include "theory/bags/solver_state.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__TERM_REGISTRY_H */
#include "theory/theory_model.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/theory_eq_notify.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__THEORY_BAGS_H */
#include "theory_bags_type_enumerator.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__TYPE_ENUMERATOR_H */
#include "util/cardinality.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bags {
}
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class NodeManager;
class TypeNode;
} // namespace bags
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BAGS__THEORY_BAGS_TYPE_RULES_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/trust_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofGenerator;
class ProofNode;
} // namespace booleans
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BOOLEANS__CIRCUIT_PROPAGATOR_H */
# src/theory/builtin/kinds.
#
-theory THEORY_BOOL ::cvc5::theory::booleans::TheoryBool "theory/booleans/theory_bool.h"
+theory THEORY_BOOL ::cvc5::internal::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::internal::theory::booleans::TheoryBoolRewriter "theory/booleans/theory_bool_rewriter.h"
sort BOOLEAN_TYPE \
2 \
constant CONST_BOOLEAN \
skip \
bool \
- ::cvc5::BoolHashFunction \
+ ::cvc5::internal::BoolHashFunction \
"util/bool.h" \
"truth and falsity; payload is a (C++) bool"
enumerator BOOLEAN_TYPE \
- "::cvc5::theory::booleans::BooleanEnumerator" \
+ "::cvc5::internal::theory::booleans::BooleanEnumerator" \
"theory/booleans/type_enumerator.h"
operator NOT 1 "logical not"
operator XOR 2 "exclusive or (exactly two parameters)"
operator ITE 3 "if-then-else, used for both Boolean and term ITE constructs; first parameter is (Boolean-sorted) condition, second is 'then', third is 'else' and these two parameters must have same base sort"
-typerule CONST_BOOLEAN ::cvc5::theory::boolean::BooleanTypeRule
+typerule CONST_BOOLEAN ::cvc5::internal::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::internal::theory::boolean::BooleanTypeRule
+typerule AND ::cvc5::internal::theory::boolean::BooleanTypeRule
+typerule IMPLIES ::cvc5::internal::theory::boolean::BooleanTypeRule
+typerule OR ::cvc5::internal::theory::boolean::BooleanTypeRule
+typerule XOR ::cvc5::internal::theory::boolean::BooleanTypeRule
+typerule ITE ::cvc5::internal::theory::boolean::IteTypeRule
endtheory
#include "expr/skolem_manager.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BOOLEANS__PROOF_CHECKER_H */
#include "proof/proof_node_manager.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/proof_rule.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNode;
class ProofNodeManager;
} // namespace booleans
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/valuation.h"
#include "util/hash.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/booleans/theory_bool_rewriter.h"
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BOOLEANS__THEORY_BOOL_H */
#include "expr/node_value.h"
#include "util/cardinality.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BOOLEANS__THEORY_BOOL_REWRITER_H */
#include <sstream>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace boolean {
} // namespace boolean
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace boolean {
} // namespace boolean
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY_BOOL_TYPE_RULES_H */
#include "expr/type_node.h"
#include "expr/kind.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace booleans {
} // namespace booleans
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BOOLEANS__TYPE_ENUMERATOR_H */
# is with your type checker:
#
# cardinality MY_TYPE \
-# ::cvc5::theory::foo::TheoryFoo::CardinalityComputer(%TYPE%) \
+# ::cvc5::internal::theory::foo::TheoryFoo::CardinalityComputer(%TYPE%) \
# "theory/foo/theory_foo_type_rules.h"
#
# well-founded K wellfoundedness-computer ground-term-computer [header]
# commands.
#
-theory THEORY_BUILTIN ::cvc5::theory::builtin::TheoryBuiltin "theory/builtin/theory_builtin.h"
+theory THEORY_BUILTIN ::cvc5::internal::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::internal::theory::builtin::TheoryBuiltinRewriter "theory/builtin/theory_builtin_rewriter.h"
sort BUILTIN_OPERATOR_TYPE \
Cardinality::INTEGERS \
# enough (for now) ?
cardinality SORT_TYPE "Cardinality(Cardinality::INTEGERS)"
well-founded SORT_TYPE \
- "::cvc5::theory::builtin::SortProperties::isWellFounded(%TYPE%)" \
- "::cvc5::theory::builtin::SortProperties::mkGroundTerm(%TYPE%)" \
+ "::cvc5::internal::theory::builtin::SortProperties::isWellFounded(%TYPE%)" \
+ "::cvc5::internal::theory::builtin::SortProperties::mkGroundTerm(%TYPE%)" \
"theory/builtin/theory_builtin_type_rules.h"
constant UNINTERPRETED_SORT_VALUE \
class \
UninterpretedSortValue \
- ::cvc5::UninterpretedSortValueHashFunction \
+ ::cvc5::internal::UninterpretedSortValueHashFunction \
"util/uninterpreted_sort_value.h" \
- "the kind of expressions representing uninterpreted sort values; payload is an instance of the cvc5::AbstractValue class (used in models)"
-typerule UNINTERPRETED_SORT_VALUE ::cvc5::theory::builtin::UninterpretedSortValueTypeRule
-enumerator SORT_TYPE ::cvc5::theory::builtin::UninterpretedSortEnumerator "theory/builtin/type_enumerator.h"
+ "the kind of expressions representing uninterpreted sort values; payload is an instance of the cvc5::internal::AbstractValue class (used in models)"
+typerule UNINTERPRETED_SORT_VALUE ::cvc5::internal::theory::builtin::UninterpretedSortValueTypeRule
+enumerator SORT_TYPE ::cvc5::internal::theory::builtin::UninterpretedSortEnumerator "theory/builtin/type_enumerator.h"
# A kind representing "inlined" operators defined with OPERATOR
# Conceptually, (EQUAL a b) is actually an (APPLY EQUAL a b), but it's
constant BUILTIN \
skip \
Kind \
- ::cvc5::kind::KindHashFunction \
+ ::cvc5::internal::kind::KindHashFunction \
"expr/kind.h" \
"the kind of expressions representing built-in operators"
constant TYPE_CONSTANT \
skip \
TypeConstant \
- ::cvc5::TypeConstantHashFunction \
+ ::cvc5::internal::TypeConstantHashFunction \
"expr/kind.h" \
"a representation for basic types"
sort SEXPR_TYPE \
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 WITNESS ::cvc5::theory::builtin::WitnessTypeRule
+typerule EQUAL ::cvc5::internal::theory::builtin::EqualityTypeRule
+typerule DISTINCT ::cvc5::internal::theory::builtin::DistinctTypeRule
+typerule SEXPR ::cvc5::internal::theory::builtin::SExprTypeRule
+typerule WITNESS ::cvc5::internal::theory::builtin::WitnessTypeRule
endtheory
#include "theory/theory.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_checker.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
} // namespace builtin
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BUILTIN__PROOF_CHECKER_H */
#include "theory/theory_model.h"
#include "theory/valuation.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_inference_manager.h"
#include "theory/theory_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BUILTIN__THEORY_BUILTIN_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BUILTIN__THEORY_BUILTIN_REWRITER_H */
#include "expr/skolem_manager.h"
#include "util/uninterpreted_sort_value.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include <sstream>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BUILTIN__THEORY_BUILTIN_TYPE_RULES_H */
#include "theory/builtin/theory_builtin_rewriter.h"
#include "util/uninterpreted_sort_value.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/type_enumerator.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace builtin {
} // namespace builtin
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BUILTIN_TYPE_ENUMERATOR_H */
#include "proof/conv_proof_generator.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_node_manager.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TConvProofGenerator;
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/bv/theory_bv_utils.h"
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <ostream>
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5__THEORY__BV__BITBLAST__BITBLAST_UTILS_H
#include "theory/valuation.h"
#include "util/resource_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BV__BITBLAST__BITBLASTER_H */
#include "theory/theory_model.h"
#include "theory/theory_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/bv/bitblast/bitblaster.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/bv/bitblast/bitblast_proof_generator.h"
#include "theory/theory_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/term_context.h"
#include "theory/bv/bitblast/node_bitblaster.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TConvProofGenerator;
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "smt/env_obj.h"
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BV__BV_SOLVER_H */
#include "theory/bv/theory_bv_utils.h"
#include "theory/theory_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/bv/bv_solver.h"
#include "theory/bv/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/bv/theory_bv_utils.h"
#include "theory/theory_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/bv/bv_solver.h"
#include "theory/bv/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/iand.h"
#include "util/rational.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory;
-using namespace cvc5::theory::bv;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::theory::bv;
-namespace cvc5 {
+namespace cvc5::internal {
namespace {
return d_nm->mkNode(kind::SUB, maxInt(bvsize), n);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/arith/nl/iand_utils.h"
-namespace cvc5 {
+namespace cvc5::internal {
/*
** Converts bit-vector formulas to integer formulas.
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* __CVC5__THEORY__BV__INT_BLASTER_H */
# src/theory/builtin/kinds.
#
-theory THEORY_BV ::cvc5::theory::bv::TheoryBV "theory/bv/theory_bv.h"
+theory THEORY_BV ::cvc5::internal::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::internal::theory::bv::TheoryBVRewriter "theory/bv/theory_bv_rewriter.h"
constant BITVECTOR_TYPE \
struct \
BitVectorSize \
- "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorSize >" \
+ "::cvc5::internal::UnsignedHashFunction< ::cvc5::internal::BitVectorSize >" \
"util/bitvector.h" \
"bit-vector type"
cardinality BITVECTOR_TYPE \
- "::cvc5::theory::bv::CardinalityComputer::computeCardinality(%TYPE%)" \
+ "::cvc5::internal::theory::bv::CardinalityComputer::computeCardinality(%TYPE%)" \
"theory/bv/theory_bv_type_rules.h"
constant CONST_BITVECTOR \
class \
BitVector \
- ::cvc5::BitVectorHashFunction \
+ ::cvc5::internal::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::internal::BitVector class"
enumerator BITVECTOR_TYPE \
- "::cvc5::theory::bv::BitVectorEnumerator" \
+ "::cvc5::internal::theory::bv::BitVectorEnumerator" \
"theory/bv/type_enumerator.h"
well-founded BITVECTOR_TYPE \
true \
- "(*cvc5::theory::TypeEnumerator(%TYPE%))" \
+ "(*cvc5::internal::theory::TypeEnumerator(%TYPE%))" \
"theory/type_enumerator.h"
### non-parameterized operator kinds ------------------------------------------
constant BITVECTOR_BITOF_OP \
struct \
BitVectorBitOf \
- ::cvc5::BitVectorBitOfHashFunction \
+ ::cvc5::internal::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::internal::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 \
struct \
BitVectorExtract \
- ::cvc5::BitVectorExtractHashFunction \
+ ::cvc5::internal::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::internal::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 \
struct \
BitVectorRepeat \
- "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorRepeat >" \
+ "::cvc5::internal::UnsignedHashFunction< ::cvc5::internal::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::internal::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 \
struct \
BitVectorRotateLeft \
- "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorRotateLeft >" \
+ "::cvc5::internal::UnsignedHashFunction< ::cvc5::internal::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::internal::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 \
struct \
BitVectorRotateRight \
- "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorRotateRight >" \
+ "::cvc5::internal::UnsignedHashFunction< ::cvc5::internal::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::internal::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 \
struct \
BitVectorSignExtend \
- "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorSignExtend >" \
+ "::cvc5::internal::UnsignedHashFunction< ::cvc5::internal::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::internal::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 \
struct \
BitVectorZeroExtend \
- "::cvc5::UnsignedHashFunction< ::cvc5::BitVectorZeroExtend >" \
+ "::cvc5::internal::UnsignedHashFunction< ::cvc5::internal::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::internal::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 \
struct \
IntToBitVector \
- "::cvc5::UnsignedHashFunction< ::cvc5::IntToBitVector >" \
+ "::cvc5::internal::UnsignedHashFunction< ::cvc5::internal::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::internal::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::internal::theory::bv::BitVectorConstantTypeRule
## conversion to bit-vector from vector of Booleans kind
-typerule BITVECTOR_BB_TERM ::cvc5::theory::bv::BitVectorToBVTypeRule
+typerule BITVECTOR_BB_TERM ::cvc5::internal::theory::bv::BitVectorToBVTypeRule
## concatentation kind
-typerule BITVECTOR_CONCAT ::cvc5::theory::bv::BitVectorConcatTypeRule
+typerule BITVECTOR_CONCAT ::cvc5::internal::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::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_COMP ::cvc5::internal::theory::bv::BitVectorBVPredTypeRule
+typerule BITVECTOR_NAND ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_NOR ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_NOT ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_OR ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_XNOR ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_XOR ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
## arithmetic kinds
-typerule BITVECTOR_MULT ::cvc5::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_NEG ::cvc5::theory::bv::BitVectorFixedWidthTypeRule
-typerule BITVECTOR_ADD ::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::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_NEG ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_ADD ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_SUB ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_UDIV ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_UREM ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_SDIV ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_SMOD ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_SREM ::cvc5::internal::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::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_LSHR ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_SHL ::cvc5::internal::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::internal::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_ULT ::cvc5::internal::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_UGE ::cvc5::internal::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_UGT ::cvc5::internal::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_SLE ::cvc5::internal::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_SLT ::cvc5::internal::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_SGE ::cvc5::internal::theory::bv::BitVectorPredicateTypeRule
+typerule BITVECTOR_SGT ::cvc5::internal::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::internal::theory::bv::BitVectorBVPredTypeRule
+typerule BITVECTOR_SLTBV ::cvc5::internal::theory::bv::BitVectorBVPredTypeRule
## if-then-else kind
-typerule BITVECTOR_ITE ::cvc5::theory::bv::BitVectorITETypeRule
+typerule BITVECTOR_ITE ::cvc5::internal::theory::bv::BitVectorITETypeRule
## reduction kinds
-typerule BITVECTOR_REDAND ::cvc5::theory::bv::BitVectorUnaryPredicateTypeRule
-typerule BITVECTOR_REDOR ::cvc5::theory::bv::BitVectorUnaryPredicateTypeRule
+typerule BITVECTOR_REDAND ::cvc5::internal::theory::bv::BitVectorUnaryPredicateTypeRule
+typerule BITVECTOR_REDOR ::cvc5::internal::theory::bv::BitVectorUnaryPredicateTypeRule
## conversion kinds
-typerule BITVECTOR_TO_NAT ::cvc5::theory::bv::BitVectorConversionTypeRule
+typerule BITVECTOR_TO_NAT ::cvc5::internal::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::internal::theory::bv::BitVectorAckermanizationUdivTypeRule
+typerule BITVECTOR_ACKERMANNIZE_UREM ::cvc5::internal::theory::bv::BitVectorAckermanizationUremTypeRule
+typerule BITVECTOR_EAGER_ATOM ::cvc5::internal::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::internal::theory::bv::BitVectorBitOfTypeRule
typerule BITVECTOR_EXTRACT_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_EXTRACT ::cvc5::theory::bv::BitVectorExtractTypeRule
+typerule BITVECTOR_EXTRACT ::cvc5::internal::theory::bv::BitVectorExtractTypeRule
typerule BITVECTOR_REPEAT_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_REPEAT ::cvc5::theory::bv::BitVectorRepeatTypeRule
+typerule BITVECTOR_REPEAT ::cvc5::internal::theory::bv::BitVectorRepeatTypeRule
typerule BITVECTOR_ROTATE_LEFT_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_ROTATE_LEFT ::cvc5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_ROTATE_LEFT ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
typerule BITVECTOR_ROTATE_RIGHT_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_ROTATE_RIGHT ::cvc5::theory::bv::BitVectorFixedWidthTypeRule
+typerule BITVECTOR_ROTATE_RIGHT ::cvc5::internal::theory::bv::BitVectorFixedWidthTypeRule
typerule BITVECTOR_SIGN_EXTEND_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule BITVECTOR_SIGN_EXTEND ::cvc5::theory::bv::BitVectorExtendTypeRule
+typerule BITVECTOR_SIGN_EXTEND ::cvc5::internal::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::internal::theory::bv::BitVectorExtendTypeRule
+typerule INT_TO_BITVECTOR_OP ::cvc5::internal::theory::bv::IntToBitVectorOpTypeRule
+typerule INT_TO_BITVECTOR ::cvc5::internal::theory::bv::BitVectorConversionTypeRule
endtheory
#include "theory/bv/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_checker.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BV__PROOF_CHECKER_H */
#include "theory/trust_substitutions.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_eq_notify.h"
#include "theory/theory_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofRuleChecker;
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BV__THEORY_BV_H */
#include "theory/theory.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // End namespace bv
} // End namespace theory
-} // End namespace cvc5
+} // End namespace cvc5::internal
#include "theory/bv/theory_bv_utils.h"
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
}
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/bv/theory_bv_rewrite_rules.h"
#include "theory/bv/theory_bv_utils.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/rewriter.h"
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/bv/theory_bv_utils.h"
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/bv/theory_bv_utils.h"
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#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::internal;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::theory::bv;
TheoryBVRewriter::TheoryBVRewriter() { initializeRewrites(); }
#include "theory/theory_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BV__THEORY_BV_REWRITER_H */
#include "util/cardinality.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BV__THEORY_BV_TYPE_RULES_H */
#include "util/bitvector.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
namespace utils {
} // namespace utils
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_manager.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
}
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/bitvector.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace bv {
} // namespace bv
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__BV__TYPE_ENUMERATOR_H */
#include "expr/node.h"
#include "theory/theory_id.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
typedef std::set<CarePair> CareGraph;
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__CARE_GRAPH_H */
#include "theory/care_pair_argument_callback.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
CarePairArgumentCallback::CarePairArgumentCallback(Theory& t) : d_theory(t) {}
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_trie_algorithm.h"
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__CARE_ARGUMENT_CALLBACK_H */
#include "theory/shared_solver.h"
#include "theory/theory_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
CombinationCareGraph::CombinationCareGraph(
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/combination_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TheoryEngine;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__COMBINATION_DISTRIBUTED__H */
#include "theory/shared_solver_distributed.h"
#include "theory/theory_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
CombinationEngine::CombinationEngine(Env& env,
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/ee_manager.h"
#include "theory/valuation.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TheoryEngine;
class Env;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__COMBINATION_DISTRIBUTED__H */
#include "util/rational.h"
#include "util/uninterpreted_sort_value.h"
-using namespace cvc5;
-using namespace cvc5::kind;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/evaluator.h"
#include "theory/theory_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__DATATYPES__DATATYPES_REWRITER_H */
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_generator.h"
#include "theory/datatypes/inference.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__DATATYPES__INFER_PROOF_CONS_H */
#include "theory/datatypes/inference_manager.h"
#include "theory/theory.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_id.h"
#include "theory/theory_inference.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/theory_state.h"
#include "theory/trust_substitutions.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/datatypes/infer_proof_cons.h"
#include "theory/inference_manager_buffered.h"
-namespace cvc5 {
+namespace cvc5::internal {
class EagerProofGenerator;
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
# src/theory/builtin/kinds.
#
-theory THEORY_DATATYPES ::cvc5::theory::datatypes::TheoryDatatypes "theory/datatypes/theory_datatypes.h"
+theory THEORY_DATATYPES ::cvc5::internal::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::internal::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::internal::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::uf::FunctionProperties::computeCardinality(%TYPE%)" \
+ "::cvc5::internal::theory::uf::FunctionProperties::computeCardinality(%TYPE%)" \
"theory/uf/theory_uf_type_rules.h"
# tester type has a constructor type
operator TESTER_TYPE 1 "tester"
# can re-use function cardinality
cardinality TESTER_TYPE \
- "::cvc5::theory::uf::FunctionProperties::computeCardinality(%TYPE%)" \
+ "::cvc5::internal::theory::uf::FunctionProperties::computeCardinality(%TYPE%)" \
"theory/uf/theory_uf_type_rules.h"
# tester type has a constructor type
operator UPDATER_TYPE 2 "datatype update"
# can re-use function cardinality
cardinality UPDATER_TYPE \
- "::cvc5::theory::uf::FunctionProperties::computeCardinality(%TYPE%)" \
+ "::cvc5::internal::theory::uf::FunctionProperties::computeCardinality(%TYPE%)" \
"theory/uf/theory_uf_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"
constant DATATYPE_TYPE \
class \
DatatypeIndexConstant \
- "::cvc5::DatatypeIndexConstantHashFunction" \
+ "::cvc5::internal::DatatypeIndexConstantHashFunction" \
"expr/datatype_index.h" \
"a datatype type index"
cardinality DATATYPE_TYPE \
"expr/dtype.h"
enumerator DATATYPE_TYPE \
- "::cvc5::theory::datatypes::DatatypesEnumerator" \
+ "::cvc5::internal::theory::datatypes::DatatypesEnumerator" \
"theory/datatypes/type_enumerator.h"
operator PARAMETRIC_DATATYPE 1: "parametric datatype"
"expr/dtype.h"
enumerator PARAMETRIC_DATATYPE \
- "::cvc5::theory::datatypes::DatatypesEnumerator" \
+ "::cvc5::internal::theory::datatypes::DatatypesEnumerator" \
"theory/datatypes/type_enumerator.h"
parameterized APPLY_TYPE_ASCRIPTION ASCRIPTION_TYPE 1 \
constant ASCRIPTION_TYPE \
class \
AscriptionType \
- ::cvc5::AscriptionTypeHashFunction \
+ ::cvc5::internal::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::internal::AscriptionType class"
-typerule APPLY_CONSTRUCTOR ::cvc5::theory::datatypes::DatatypeConstructorTypeRule
-typerule APPLY_SELECTOR ::cvc5::theory::datatypes::DatatypeSelectorTypeRule
-typerule APPLY_TESTER ::cvc5::theory::datatypes::DatatypeTesterTypeRule
-typerule APPLY_UPDATER ::cvc5::theory::datatypes::DatatypeUpdateTypeRule
-typerule APPLY_TYPE_ASCRIPTION ::cvc5::theory::datatypes::DatatypeAscriptionTypeRule
+typerule APPLY_CONSTRUCTOR ::cvc5::internal::theory::datatypes::DatatypeConstructorTypeRule
+typerule APPLY_SELECTOR ::cvc5::internal::theory::datatypes::DatatypeSelectorTypeRule
+typerule APPLY_TESTER ::cvc5::internal::theory::datatypes::DatatypeTesterTypeRule
+typerule APPLY_UPDATER ::cvc5::internal::theory::datatypes::DatatypeUpdateTypeRule
+typerule APPLY_TYPE_ASCRIPTION ::cvc5::internal::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::internal::theory::datatypes::DatatypeConstructorTypeRule
operator DT_SIZE 1 "datatypes size"
-typerule DT_SIZE ::cvc5::theory::datatypes::DtSizeTypeRule
+typerule DT_SIZE ::cvc5::internal::theory::datatypes::DtSizeTypeRule
operator DT_HEIGHT_BOUND 2 "datatypes height bound"
-typerule DT_HEIGHT_BOUND ::cvc5::theory::datatypes::DtBoundTypeRule
+typerule DT_HEIGHT_BOUND ::cvc5::internal::theory::datatypes::DtBoundTypeRule
operator DT_SIZE_BOUND 2 "datatypes height bound"
-typerule DT_SIZE_BOUND ::cvc5::theory::datatypes::DtBoundTypeRule
+typerule DT_SIZE_BOUND ::cvc5::internal::theory::datatypes::DtBoundTypeRule
operator DT_SYGUS_BOUND 2 "datatypes sygus bound"
-typerule DT_SYGUS_BOUND ::cvc5::theory::datatypes::DtBoundTypeRule
+typerule DT_SYGUS_BOUND ::cvc5::internal::theory::datatypes::DtBoundTypeRule
operator DT_SYGUS_EVAL 1: "datatypes sygus evaluation function"
-typerule DT_SYGUS_EVAL ::cvc5::theory::datatypes::DtSygusEvalTypeRule
+typerule DT_SYGUS_EVAL ::cvc5::internal::theory::datatypes::DtSygusEvalTypeRule
# Kinds for match terms. For example, the match term
operator MATCH_CASE 2 "a match case"
operator MATCH_BIND_CASE 3 "a match case with bound variables"
-typerule MATCH ::cvc5::theory::datatypes::MatchTypeRule
-typerule MATCH_CASE ::cvc5::theory::datatypes::MatchCaseTypeRule
-typerule MATCH_BIND_CASE ::cvc5::theory::datatypes::MatchBindCaseTypeRule
+typerule MATCH ::cvc5::internal::theory::datatypes::MatchTypeRule
+typerule MATCH_CASE ::cvc5::internal::theory::datatypes::MatchCaseTypeRule
+typerule MATCH_BIND_CASE ::cvc5::internal::theory::datatypes::MatchBindCaseTypeRule
constant TUPLE_PROJECT_OP \
class \
TupleProjectOp \
- ::cvc5::TupleProjectOpHashFunction \
+ ::cvc5::internal::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::internal::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::internal::theory::datatypes::TupleProjectTypeRule
# For representing codatatype values
constant CODATATYPE_BOUND_VARIABLE \
class \
CodatatypeBoundVariable \
- ::cvc5::CodatatypeBoundVariableHashFunction \
+ ::cvc5::internal::CodatatypeBoundVariableHashFunction \
"expr/codatatype_bound_variable.h" \
- "the kind of expressions representing bound variables in codatatype constants, which are de Bruijn indexed variables; payload is an instance of the cvc5::CodatatypeBoundVariable class (used in models)"
-typerule CODATATYPE_BOUND_VARIABLE ::cvc5::theory::datatypes::CodatatypeBoundVariableTypeRule
+ "the kind of expressions representing bound variables in codatatype constants, which are de Bruijn indexed variables; payload is an instance of the cvc5::internal::CodatatypeBoundVariable class (used in models)"
+typerule CODATATYPE_BOUND_VARIABLE ::cvc5::internal::theory::datatypes::CodatatypeBoundVariableTypeRule
endtheory
#include "theory/datatypes/theory_datatypes_utils.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_checker.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__DATATYPES__PROOF_CHECKER_H */
#include "theory/evaluator.h"
#include "theory/rewriter.h"
-using namespace cvc5;
-using namespace cvc5::kind;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
namespace utils {
} // namespace utils
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_manager_attributes.h"
#include "theory/datatypes/theory_datatypes_utils.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
// ----------------------- sygus datatype attributes
} // namespace utils
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/theory_state.h"
#include "util/rational.h"
-using namespace cvc5;
-using namespace cvc5::kind;
-using namespace cvc5::context;
-using namespace cvc5::theory;
-using namespace cvc5::theory::datatypes;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::theory::datatypes;
SygusExtension::SygusExtension(Env& env,
TheoryState& s,
#include "theory/quantifiers/sygus_sampler.h"
#include "theory/quantifiers/term_database.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
class SynthConjecture;
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/dtype.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__DATATYPES__SIMPLE_SYM_BREAK_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/uf/equality_engine.h"
#include "util/hash.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__DATATYPES__THEORY_DATATYPES_H */
#include "theory/datatypes/tuple_project_op.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__DATATYPES__THEORY_DATATYPES_TYPE_RULES_H */
#include "expr/dtype.h"
#include "expr/dtype_cons.h"
-using namespace cvc5;
-using namespace cvc5::kind;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
namespace utils {
} // namespace utils
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/node_manager_attributes.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
namespace utils {
} // namespace utils
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& out, const TupleProjectOp& op)
{
return d_indices == op.d_indices;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <ostream>
#include <vector>
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
size_t operator()(const TupleProjectOp& op) const;
}; /* struct TupleProjectOpHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__PROJECT_OP_H */
#include "expr/dtype.h"
#include "expr/dtype_cons.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
};
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__TUPLE__UTILS_H */
#include "theory/datatypes/datatypes_rewriter.h"
#include "theory/datatypes/theory_datatypes_utils.h"
-using namespace cvc5;
+using namespace cvc5::internal;
using namespace theory;
using namespace datatypes;
#include "options/quantifiers_options.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace datatypes {
} // namespace datatypes
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__DATATYPES__TYPE_ENUMERATOR_H */
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
DecisionManager::DecisionManager(context::Context* userContext)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/cdlist.h"
#include "theory/decision_strategy.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/** DecisionManager
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__DECISION_MANAGER__H */
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
DecisionStrategyFmf::DecisionStrategyFmf(Env& env, Valuation valuation)
Node DecisionStrategySingleton::getSingleLiteral() { return d_literal; }
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/valuation.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__DECISION_STRATEGY__H */
#include "theory/theory_model.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
DifficultyManager::DifficultyManager(RelevanceManager* rlv,
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/valuation.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class TheoryModel;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__DIFFICULTY_MANAGER__H */
#include "theory/theory_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
EqEngineManager::EqEngineManager(Env& env, TheoryEngine& te, SharedSolver& shs)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TheoryEngine;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__EE_MANAGER__H */
#include "theory/theory_engine.h"
#include "theory/theory_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
EqEngineManagerCentral::EqEngineManagerCentral(Env& env,
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/master_eq_notify.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__EE_MANAGER_CENTRAL__H */
#include "theory/theory_engine.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
EqEngineManagerDistributed::EqEngineManagerDistributed(Env& env,
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/ee_manager.h"
#include "theory/quantifiers/master_eq_notify.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__EE_MANAGER_DISTRIBUTED__H */
#include <string>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__EE_SETUP_INFO__H */
#include "smt/smt_statistics_registry.h"
#include "theory/theory_engine.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
EngineOutputChannel::Statistics::Statistics(theory::TheoryId theory)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_id.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TheoryEngine;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__ENGINE_OUTPUT_CHANNEL_H */
#include "theory/theory.h"
#include "util/integer.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
EvalResult::EvalResult(const EvalResult& other)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/string.h"
#include "util/uninterpreted_sort_value.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__EVALUATOR_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
const char* toString(ExtReducedId id)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/theory_inference_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class OutputChannel;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__EXT_THEORY_H */
#include "expr/skolem_manager.h"
#include "util/floatingpoint.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace fp {
} // namespace fp
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/trust_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace fp {
} // namespace fp
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__FP__THEORY_FP_H */
#include "util/floatingpoint_literal_symfpu.h"
namespace symfpu {
-using namespace ::cvc5::theory::fp::symfpuSymbolic;
+using namespace ::cvc5::internal::theory::fp::symfpuSymbolic;
#define CVC5_SYM_ITE_DFN(T) \
template <> \
const T& _l, \
const T& _r) \
{ \
- ::cvc5::NodeManager* nm = ::cvc5::NodeManager::currentNM(); \
+ ::cvc5::internal::NodeManager* nm = ::cvc5::internal::NodeManager::currentNM(); \
\
- ::cvc5::Node cond = _cond; \
- ::cvc5::Node l = _l; \
- ::cvc5::Node r = _r; \
+ ::cvc5::internal::Node cond = _cond; \
+ ::cvc5::internal::Node l = _l; \
+ ::cvc5::internal::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::internal::BitVector(1U, 1U))) ? l : r; \
} \
else \
{ \
- if (l.getKind() == ::cvc5::kind::BITVECTOR_ITE) \
+ if (l.getKind() == ::cvc5::internal::kind::BITVECTOR_ITE) \
{ \
if (l[1] == r) \
{ \
return nm->mkNode( \
- ::cvc5::kind::BITVECTOR_ITE, \
- nm->mkNode(::cvc5::kind::BITVECTOR_AND, \
+ ::cvc5::internal::kind::BITVECTOR_ITE, \
+ nm->mkNode(::cvc5::internal::kind::BITVECTOR_AND, \
cond, \
- nm->mkNode(::cvc5::kind::BITVECTOR_NOT, l[0])), \
+ nm->mkNode(::cvc5::internal::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::internal::kind::BITVECTOR_ITE, \
+ nm->mkNode(::cvc5::internal::kind::BITVECTOR_AND, cond, l[0]), \
l[1], \
r); \
} \
} \
- else if (r.getKind() == ::cvc5::kind::BITVECTOR_ITE) \
+ else if (r.getKind() == ::cvc5::internal::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::internal::kind::BITVECTOR_ITE, \
+ nm->mkNode(::cvc5::internal::kind::BITVECTOR_AND, \
+ nm->mkNode(::cvc5::internal::kind::BITVECTOR_NOT, cond), \
+ nm->mkNode(::cvc5::internal::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::internal::kind::BITVECTOR_ITE, \
+ nm->mkNode(::cvc5::internal::kind::BITVECTOR_AND, \
+ nm->mkNode(::cvc5::internal::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::internal::kind::BITVECTOR_ITE, cond, l, r)); \
} \
}
}
}; // namespace symfpu
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace fp {
namespace symfpuSymbolic {
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::internal::NodeManager::currentNM()->mkNode(
+ ::cvc5::internal::kind::BITVECTOR_CONCAT, leadingZero, base));
}
template <>
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::internal::NodeManager::currentNM()->mkNode(
+ ::cvc5::internal::kind::BITVECTOR_CONCAT, leadingOne, base));
}
template <>
{
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::internal::BitVector(1U, 1U)));
return value;
}
Node FpWordBlaster::ubvToNode(const ubv& u) const { return u; }
} // namespace fp
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/floatingpoint_size.h"
#include "util/hash.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace fp {
typedef traits::bwt bwt;
/**
- * Wrap the cvc5::Node types so that we can debug issues with this back-end
+ * Wrap the cvc5::internal::Node types so that we can debug issues with this back-end
*/
class nodeWrapper : public Node
{
} // namespace fp
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__FP__THEORY_FP_H */
# src/theory/builtin/kinds.
#
-theory THEORY_FP ::cvc5::theory::fp::TheoryFp "theory/fp/theory_fp.h"
+theory THEORY_FP ::cvc5::internal::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::internal::theory::fp::TheoryFpRewriter "theory/fp/theory_fp_rewriter.h"
properties check
constant CONST_FLOATINGPOINT \
class \
FloatingPoint \
- ::cvc5::FloatingPointHashFunction \
+ ::cvc5::internal::FloatingPointHashFunction \
"util/floatingpoint.h" \
"a floating-point literal"
-typerule CONST_FLOATINGPOINT ::cvc5::theory::fp::FloatingPointConstantTypeRule
+typerule CONST_FLOATINGPOINT ::cvc5::internal::theory::fp::FloatingPointConstantTypeRule
constant CONST_ROUNDINGMODE \
"enum class" \
RoundingMode \
- ::cvc5::RoundingModeHashFunction \
+ ::cvc5::internal::RoundingModeHashFunction \
"util/roundingmode.h" \
"a floating-point rounding mode"
-typerule CONST_ROUNDINGMODE ::cvc5::theory::fp::RoundingModeConstantTypeRule
+typerule CONST_ROUNDINGMODE ::cvc5::internal::theory::fp::RoundingModeConstantTypeRule
"floating-point rounding mode"
enumerator ROUNDINGMODE_TYPE \
- "::cvc5::theory::fp::RoundingModeEnumerator" \
+ "::cvc5::internal::theory::fp::RoundingModeEnumerator" \
"theory/fp/type_enumerator.h"
constant FLOATINGPOINT_TYPE \
class \
FloatingPointSize \
- ::cvc5::FloatingPointSizeHashFunction \
+ ::cvc5::internal::FloatingPointSizeHashFunction \
"util/floatingpoint.h" \
"floating-point type"
cardinality FLOATINGPOINT_TYPE \
- "::cvc5::theory::fp::CardinalityComputer::computeCardinality(%TYPE%)" \
+ "::cvc5::internal::theory::fp::CardinalityComputer::computeCardinality(%TYPE%)" \
"theory/fp/theory_fp_type_rules.h"
enumerator FLOATINGPOINT_TYPE \
- "::cvc5::theory::fp::FloatingPointEnumerator" \
+ "::cvc5::internal::theory::fp::FloatingPointEnumerator" \
"theory/fp/type_enumerator.h"
well-founded FLOATINGPOINT_TYPE \
true \
- "(*cvc5::theory::TypeEnumerator(%TYPE%))" \
+ "(*cvc5::internal::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::internal::theory::fp::FloatingPointFPTypeRule
operator FLOATINGPOINT_EQ 2: "floating-point equality"
-typerule FLOATINGPOINT_EQ ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_EQ ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_ABS 1 "floating-point absolute value"
-typerule FLOATINGPOINT_ABS ::cvc5::theory::fp::FloatingPointOperationTypeRule
+typerule FLOATINGPOINT_ABS ::cvc5::internal::theory::fp::FloatingPointOperationTypeRule
operator FLOATINGPOINT_NEG 1 "floating-point negation"
-typerule FLOATINGPOINT_NEG ::cvc5::theory::fp::FloatingPointOperationTypeRule
+typerule FLOATINGPOINT_NEG ::cvc5::internal::theory::fp::FloatingPointOperationTypeRule
operator FLOATINGPOINT_ADD 3 "floating-point addition"
-typerule FLOATINGPOINT_ADD ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_ADD ::cvc5::internal::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_SUB 3 "floating-point sutraction"
-typerule FLOATINGPOINT_SUB ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_SUB ::cvc5::internal::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_MULT 3 "floating-point multiply"
-typerule FLOATINGPOINT_MULT ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_MULT ::cvc5::internal::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_DIV 3 "floating-point division"
-typerule FLOATINGPOINT_DIV ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_DIV ::cvc5::internal::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_FMA 4 "floating-point fused multiply and add"
-typerule FLOATINGPOINT_FMA ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_FMA ::cvc5::internal::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_SQRT 2 "floating-point square root"
-typerule FLOATINGPOINT_SQRT ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_SQRT ::cvc5::internal::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_REM 2 "floating-point remainder"
-typerule FLOATINGPOINT_REM ::cvc5::theory::fp::FloatingPointOperationTypeRule
+typerule FLOATINGPOINT_REM ::cvc5::internal::theory::fp::FloatingPointOperationTypeRule
operator FLOATINGPOINT_RTI 2 "floating-point round to integral"
-typerule FLOATINGPOINT_RTI ::cvc5::theory::fp::FloatingPointRoundingOperationTypeRule
+typerule FLOATINGPOINT_RTI ::cvc5::internal::theory::fp::FloatingPointRoundingOperationTypeRule
operator FLOATINGPOINT_MIN 2 "floating-point minimum"
-typerule FLOATINGPOINT_MIN ::cvc5::theory::fp::FloatingPointOperationTypeRule
+typerule FLOATINGPOINT_MIN ::cvc5::internal::theory::fp::FloatingPointOperationTypeRule
operator FLOATINGPOINT_MAX 2 "floating-point maximum"
-typerule FLOATINGPOINT_MAX ::cvc5::theory::fp::FloatingPointOperationTypeRule
+typerule FLOATINGPOINT_MAX ::cvc5::internal::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::internal::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::internal::theory::fp::FloatingPointPartialOperationTypeRule
operator FLOATINGPOINT_LEQ 2: "floating-point less than or equal"
-typerule FLOATINGPOINT_LEQ ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_LEQ ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_LT 2: "floating-point less than"
-typerule FLOATINGPOINT_LT ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_LT ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_GEQ 2: "floating-point greater than or equal"
-typerule FLOATINGPOINT_GEQ ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_GEQ ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_GT 2: "floating-point greater than"
-typerule FLOATINGPOINT_GT ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_GT ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_IS_NORMAL 1 "floating-point is normal"
-typerule FLOATINGPOINT_IS_NORMAL ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_IS_NORMAL ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_IS_SUBNORMAL 1 "floating-point is sub-normal"
-typerule FLOATINGPOINT_IS_SUBNORMAL ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_IS_SUBNORMAL ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_IS_ZERO 1 "floating-point is zero"
-typerule FLOATINGPOINT_IS_ZERO ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_IS_ZERO ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_IS_INF 1 "floating-point is infinite"
-typerule FLOATINGPOINT_IS_INF ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_IS_INF ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_IS_NAN 1 "floating-point is NaN"
-typerule FLOATINGPOINT_IS_NAN ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_IS_NAN ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_IS_NEG 1 "floating-point is negative"
-typerule FLOATINGPOINT_IS_NEG ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_IS_NEG ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
operator FLOATINGPOINT_IS_POS 1 "floating-point is positive"
-typerule FLOATINGPOINT_IS_POS ::cvc5::theory::fp::FloatingPointTestTypeRule
+typerule FLOATINGPOINT_IS_POS ::cvc5::internal::theory::fp::FloatingPointTestTypeRule
constant FLOATINGPOINT_TO_FP_FROM_IEEE_BV_OP \
class \
FloatingPointToFPIEEEBitVector \
- "::cvc5::FloatingPointConvertSortHashFunction<0x1>" \
+ "::cvc5::internal::FloatingPointConvertSortHashFunction<0x1>" \
"util/floatingpoint.h" \
"operator for to_fp from bit vector"
-typerule FLOATINGPOINT_TO_FP_FROM_IEEE_BV_OP ::cvc5::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_FP_FROM_IEEE_BV_OP ::cvc5::internal::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_FP_FROM_IEEE_BV FLOATINGPOINT_TO_FP_FROM_IEEE_BV_OP 1 "convert an IEEE-754 bit vector to floating-point"
-typerule FLOATINGPOINT_TO_FP_FROM_IEEE_BV ::cvc5::theory::fp::FloatingPointToFPIEEEBitVectorTypeRule
+typerule FLOATINGPOINT_TO_FP_FROM_IEEE_BV ::cvc5::internal::theory::fp::FloatingPointToFPIEEEBitVectorTypeRule
constant FLOATINGPOINT_TO_FP_FROM_FP_OP \
class \
FloatingPointToFPFloatingPoint \
- "::cvc5::FloatingPointConvertSortHashFunction<0x2>" \
+ "::cvc5::internal::FloatingPointConvertSortHashFunction<0x2>" \
"util/floatingpoint.h" \
"operator for to_fp from floating point"
-typerule FLOATINGPOINT_TO_FP_FROM_FP_OP ::cvc5::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_FP_FROM_FP_OP ::cvc5::internal::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_FP_FROM_FP FLOATINGPOINT_TO_FP_FROM_FP_OP 2 "convert between floating-point sorts"
-typerule FLOATINGPOINT_TO_FP_FROM_FP ::cvc5::theory::fp::FloatingPointToFPFloatingPointTypeRule
+typerule FLOATINGPOINT_TO_FP_FROM_FP ::cvc5::internal::theory::fp::FloatingPointToFPFloatingPointTypeRule
constant FLOATINGPOINT_TO_FP_FROM_REAL_OP \
class \
FloatingPointToFPReal \
- "::cvc5::FloatingPointConvertSortHashFunction<0x4>" \
+ "::cvc5::internal::FloatingPointConvertSortHashFunction<0x4>" \
"util/floatingpoint.h" \
"operator for to_fp from real"
-typerule FLOATINGPOINT_TO_FP_FROM_REAL_OP ::cvc5::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_FP_FROM_REAL_OP ::cvc5::internal::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_FP_FROM_REAL FLOATINGPOINT_TO_FP_FROM_REAL_OP 2 "convert a real to floating-point"
-typerule FLOATINGPOINT_TO_FP_FROM_REAL ::cvc5::theory::fp::FloatingPointToFPRealTypeRule
+typerule FLOATINGPOINT_TO_FP_FROM_REAL ::cvc5::internal::theory::fp::FloatingPointToFPRealTypeRule
constant FLOATINGPOINT_TO_FP_FROM_SBV_OP \
class \
FloatingPointToFPSignedBitVector \
- "::cvc5::FloatingPointConvertSortHashFunction<0x8>" \
+ "::cvc5::internal::FloatingPointConvertSortHashFunction<0x8>" \
"util/floatingpoint.h" \
"operator for to_fp from signed bit vector"
-typerule FLOATINGPOINT_TO_FP_FROM_SBV_OP ::cvc5::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_FP_FROM_SBV_OP ::cvc5::internal::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_FP_FROM_SBV FLOATINGPOINT_TO_FP_FROM_SBV_OP 2 "convert a signed bit vector to floating-point"
-typerule FLOATINGPOINT_TO_FP_FROM_SBV ::cvc5::theory::fp::FloatingPointToFPSignedBitVectorTypeRule
+typerule FLOATINGPOINT_TO_FP_FROM_SBV ::cvc5::internal::theory::fp::FloatingPointToFPSignedBitVectorTypeRule
constant FLOATINGPOINT_TO_FP_FROM_UBV_OP \
class \
FloatingPointToFPUnsignedBitVector \
- "::cvc5::FloatingPointConvertSortHashFunction<0x10>" \
+ "::cvc5::internal::FloatingPointConvertSortHashFunction<0x10>" \
"util/floatingpoint.h" \
"operator for to_fp from unsigned bit vector"
-typerule FLOATINGPOINT_TO_FP_FROM_UBV_OP ::cvc5::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_FP_FROM_UBV_OP ::cvc5::internal::theory::fp::FloatingPointParametricOpTypeRule
parameterized FLOATINGPOINT_TO_FP_FROM_UBV FLOATINGPOINT_TO_FP_FROM_UBV_OP 2 "convert an unsigned bit vector to floating-point"
-typerule FLOATINGPOINT_TO_FP_FROM_UBV ::cvc5::theory::fp::FloatingPointToFPUnsignedBitVectorTypeRule
+typerule FLOATINGPOINT_TO_FP_FROM_UBV ::cvc5::internal::theory::fp::FloatingPointToFPUnsignedBitVectorTypeRule
constant FLOATINGPOINT_TO_UBV_OP \
class \
FloatingPointToUBV \
- "::cvc5::FloatingPointToBVHashFunction<0x1>" \
+ "::cvc5::internal::FloatingPointToBVHashFunction<0x1>" \
"util/floatingpoint.h" \
"operator for to_ubv"
-typerule FLOATINGPOINT_TO_UBV_OP ::cvc5::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_UBV_OP ::cvc5::internal::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::internal::theory::fp::FloatingPointToUBVTypeRule
constant FLOATINGPOINT_TO_UBV_TOTAL_OP \
class \
FloatingPointToUBVTotal \
- "::cvc5::FloatingPointToBVHashFunction<0x4>" \
+ "::cvc5::internal::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::internal::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::internal::theory::fp::FloatingPointToUBVTotalTypeRule
constant FLOATINGPOINT_TO_SBV_OP \
class \
FloatingPointToSBV \
- "::cvc5::FloatingPointToBVHashFunction<0x2>" \
+ "::cvc5::internal::FloatingPointToBVHashFunction<0x2>" \
"util/floatingpoint.h" \
"operator for to_sbv"
-typerule FLOATINGPOINT_TO_SBV_OP ::cvc5::theory::fp::FloatingPointParametricOpTypeRule
+typerule FLOATINGPOINT_TO_SBV_OP ::cvc5::internal::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::internal::theory::fp::FloatingPointToSBVTypeRule
constant FLOATINGPOINT_TO_SBV_TOTAL_OP \
class \
FloatingPointToSBVTotal \
- "::cvc5::FloatingPointToBVHashFunction<0x8>" \
+ "::cvc5::internal::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::internal::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::internal::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::internal::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::internal::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::internal::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::internal::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::internal::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::internal::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::internal::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::internal::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::internal::theory::fp::RoundingModeBitBlast
endtheory
#include "util/floatingpoint.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace fp {
NodeManager* nm = NodeManager::currentNM();
handleLemma(
- nm->mkNode(kind::EQUAL, addA, nm->mkConst(::cvc5::BitVector(1U, 1U))),
+ nm->mkNode(kind::EQUAL, addA, nm->mkConst(::cvc5::internal::BitVector(1U, 1U))),
InferenceId::FP_EQUATE_TERM);
++oldSize;
node,
nm->mkNode(kind::EQUAL,
wordBlasted,
- nm->mkConst(::cvc5::BitVector(1U, 1U)))),
+ nm->mkConst(::cvc5::internal::BitVector(1U, 1U)))),
InferenceId::FP_EQUATE_TERM);
}
else
} // namespace fp
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_state.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace fp {
} // namespace fp
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__FP__THEORY_FP_H */
#include "theory/fp/fp_word_blaster.h"
#include "util/floatingpoint.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace fp {
} // namespace fp
} // namespace theory
- } // namespace cvc5
+ } // namespace cvc5::internal
#include "theory/fp/fp_expand_defs.h"
#include "theory/theory_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace fp {
} // namespace fp
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__FP__THEORY_FP_REWRITER_H */
#include "util/floatingpoint.h"
#include "util/roundingmode.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace fp {
} // namespace fp
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class NodeManager;
} // namespace fp
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/bitvector.h"
#include "util/floatingpoint.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace fp {
} // namespace fp
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__FP__TYPE_ENUMERATOR_H */
#include <iostream>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
const char* toString(IncompleteId i)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
std::ostream& operator<<(std::ostream& out, IncompleteId i);
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__INCOMPLETE_ID_H */
#include "proof/proof_checker.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
const char* toString(InferenceId i)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/** Types of inferences used in the procedure
bool getInferenceId(TNode n, InferenceId& i);
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__INFERENCE_H */
#include "proof/proof_node.h"
#include "proof/proof_node_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
InferenceIdProofAnnotator::InferenceIdProofAnnotator(ProofNodeManager* pnm,
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/annotation_proof_generator.h"
#include "theory/inference_id.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/** A class that tracks formulas to inference id annotations */
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__INFERENCE_ID_PROOF_ANNOTATOR_H */
#include "theory/theory.h"
#include "theory/theory_state.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
InferenceManagerBuffered::InferenceManagerBuffered(Env& env,
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_inference.h"
#include "theory/theory_inference_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
* An exception signaling that a Theory should immediately stop
* performing processing and relinquish control to its caller (e.g.,
* in a parallel environment). A Theory might be interrupted if it
- * calls into its cvc5::theory::OutputChannel, and it should only
+ * calls into its cvc5::internal::theory::OutputChannel, and it should only
* catch this exception to perform emergency repair of any invariants
* it must re-establish. Further, if this exception is caught by a
* Theory, the Theory should rethrow the same exception (via "throw;"
#include "base/exception.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
-class Interrupted : public cvc5::Exception
+class Interrupted : public cvc5::internal::Exception
{
}; /* class Interrupted */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__INTERRUPTED_H */
#include "expr/kind.h"
using namespace std;
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
LogicInfo::LogicInfo()
: d_logicString(""),
return out << logic.getLogicString();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "cvc5_export.h"
#include "theory/theory_id.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A LogicInfo instance describes a collection of theory modules and some
std::ostream& operator<<(std::ostream& out, const LogicInfo& logic);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__LOGIC_INFO_H */
echo "$kf:$lineno: error: \"theory\" directive missing class or header argument" >&2
exit 1
elif ! expr "$2" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::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::internal::theory::foo)" >&2
+ elif ! expr "$2" : '\(::cvc5::internal::theory::*\)' >/dev/null; then
+ echo "$kf:$lineno: warning: theory class not under ::cvc5::internal::theory namespace" >&2
fi
theory_id="$1"
echo "$kf:$lineno: error: \"theory\" directive missing class or header argument" >&2
exit 1
elif ! expr "$2" : '\(::*\)' >/dev/null; then
- echo "$kf:$lineno: warning: theory class \`$2' isn't fully-qualified (e.g., ::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::internal::theory::foo)" >&2
+ elif ! expr "$2" : '\(::cvc5::internal::theory::*\)' >/dev/null; then
+ echo "$kf:$lineno: warning: theory class not under ::cvc5::internal::theory namespace" >&2
fi
theory_id="$1"
#include "theory/quantifiers_engine.h"
#include "theory/theory_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
ModelManager::ModelManager(Env& env, TheoryEngine& te, EqEngineManager& eem)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/ee_manager.h"
#include "theory/logic_info.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TheoryEngine;
class Env;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__MODEL_MANAGER__H */
#include "theory/theory_model.h"
#include "theory/theory_model_builder.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
ModelManagerDistributed::ModelManagerDistributed(Env& env,
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/ee_manager.h"
#include "theory/model_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__MODEL_MANAGER_DISTRIBUTED__H */
#include "theory/output_channel.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
LemmaProperty operator|(LemmaProperty lhs, LemmaProperty rhs)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/incomplete_id.h"
#include "util/resource_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/** Properties of lemmas */
/**
* Generic "theory output channel" interface.
*
- * All methods can throw unrecoverable cvc5::Exception's unless otherwise
+ * All methods can throw unrecoverable cvc5::internal::Exception's unless otherwise
* documented.
*/
class OutputChannel {
}; /* class OutputChannel */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__OUTPUT_CHANNEL_H */
#include "proof/proof.h"
#include "proof/proof_node.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/quantifiers/quant_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "util/bitvector.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class Rewriter;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__BV_INVERTER_H */
#include "theory/quantifiers/bv_inverter_utils.h"
#include "theory/bv/theory_bv_utils.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace utils {
} // namespace utils
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace utils {
} // namespace utils
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/expr_miner.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__CANDIDATE_REWRITE_DATABASE_H */
#include "options/quantifiers_options.h"
#include "printer/printer.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__CANDIDATE_REWRITE_FILTER_H */
#include "util/random.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/cegqi/ceg_instantiator.h"
#include "theory/quantifiers/cegqi/vts_term_cache.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__CEG_ARITH_INSTANTIATOR_H */
#include "util/random.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/bv_inverter.h"
#include "theory/quantifiers/cegqi/ceg_instantiator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__CEG_BV_INSTANTIATOR_H */
#include "theory/bv/theory_bv_utils.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace utils {
} // namespace utils
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/attribute.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace utils
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/datatypes/theory_datatypes_utils.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/quantifiers/cegqi/ceg_instantiator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__CEG_DT_INSTANTIATOR_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_id.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/quant_module.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "theory/smt_engine_subsolver.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/cdhashmap.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/** Attribute to mark Skolems as virtual terms */
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__CEGQI__VTS_TERM_CACHE_H */
#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::internal;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::theory::quantifiers;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
struct sortConjectureScore {
std::vector< int > d_scores;
bool ConjectureGenerator::optStatsOnly() { return false; }
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/quant_module.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/cdlist.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__DYNAMIC_REWRITER_H */
#include "theory/quantifiers/term_registry.h"
#include "theory/quantifiers/term_util.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__CANDIDATE_GENERATOR_H */
#include "theory/uf/theory_uf_rewriter.h"
#include "util/hash.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/inst_match.h"
#include "theory/quantifiers/ematching/trigger.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__HO_TRIGGER_H */
#include "theory/quantifiers/ematching/trigger.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_id.h"
#include "theory/quantifiers/inst_match.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace inst
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/inst_match.h"
#include "theory/quantifiers/ematching/im_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/term_util.h"
#include "theory/uf/equality_engine_iterator.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/ematching/inst_match_generator.h"
#include "theory/quantifiers/inst_match_trie.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/ematching/trigger_trie.h"
#include "theory/quantifiers/term_util.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/quantifiers/ematching/inst_match_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/term_registry.h"
#include "theory/quantifiers/term_util.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_trie.h"
#include "theory/quantifiers/ematching/inst_match_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "smt/env.h"
#include "theory/quantifiers/quantifiers_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__INSTANTIATION_ENGINE_H */
#include "theory/quantifiers/quantifiers_state.h"
#include "util/random.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory::quantifiers::inst;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory::quantifiers::inst;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/ematching/trigger.h"
#include "theory/quantifiers/quant_relevance.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
}; /* class InstStrategyAutoGenTriggers */
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#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::internal::kind;
+using namespace cvc5::internal::theory::quantifiers::inst;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/ematching/inst_strategy.h"
#include "theory/quantifiers/ematching/trigger.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#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::internal::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::theory::quantifiers::inst;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/quant_module.h"
#include "theory/quantifiers/quant_relevance.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__INSTANTIATION_ENGINE_H */
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "options/quantifiers_options.h"
#include "theory/quantifiers/ematching/trigger_term_info.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/term_util.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/quantifiers/ematching/inst_match_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/term_util.h"
#include "theory/valuation.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/inference_id.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class QuantifiersEngine;
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__TRIGGER_H */
#include "theory/quantifiers/ematching/trigger.h"
#include "theory/quantifiers/term_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/quantifiers/ematching/trigger_trie.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__TRIGGER_DATABASE_H */
#include "theory/quantifiers/term_util.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/ematching/trigger_trie.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/quantifiers/ematching/trigger.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__TRIGGER_TRIE_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/quantifiers/ematching/inst_match_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace inst {
} // namespace inst
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/quantifiers_state.h"
#include "theory/quantifiers/term_database.h"
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__ENTAILMENT_CHECK_H */
#include "theory/quantifiers/term_util.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/quantifiers/quant_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS_EQUALITY_QUERY_H */
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus_sampler.h"
#include "theory/smt_engine_subsolver.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
class SolverEngine;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__EXPRESSION_MINER_H */
#include "theory/quantifiers/query_generator_sample_sat.h"
#include "theory/quantifiers/query_generator_unsat.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/solution_filter.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__EXPR_MINER_MANAGER_H */
#include "theory/strings/word.h"
#include "theory/theory.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class Rewriter;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__EXTENDED_REWRITE_H */
#include "theory/quantifiers/term_registry.h"
#include "theory/quantifiers/term_util.h"
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_model.h"
#include "theory/uf/theory_uf_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class TheoryModel;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__FIRST_ORDER_MODEL_H */
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/quant_bound_inference.h"
#include "theory/quantifiers/quant_module.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class RepSetIterator;
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/fmf/full_model_check.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace fmcheck {
} // namespace fmcheck
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/first_order_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace fmcheck {
} // namespace fmcheck
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__FIRST_ORDER_MODEL_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace fmcheck {
} // namespace fmcheck
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/fmf/first_order_model_fmc.h"
#include "theory/quantifiers/fmf/model_builder.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
namespace fmcheck {
} // namespace fmcheck
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__FULL_MODEL_CHECK_H */
#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::internal;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::theory::quantifiers;
QModelBuilder::QModelBuilder(Env& env,
QuantifiersState& qs,
#include "theory/quantifiers/inst_match.h"
#include "theory/theory_model_builder.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__MODEL_BUILDER_H */
#include "theory/quantifiers/quantifiers_attributes.h"
#include "theory/quantifiers/term_database.h"
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/quant_module.h"
#include "theory/theory_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__MODEL_ENGINE_H */
#include "theory/quantifiers/quantifiers_attributes.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "theory/uf/equality_engine.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/quantifiers/term_database.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__HO_TERM_DATABASE_H */
*/
#include "theory/quantifiers/index_trie.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
}
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/check.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* THEORY__QUANTIFIERS__INDEX_TRIE_H */
#include "theory/quantifiers/quantifiers_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__INST_MATCH_H */
#include "theory/quantifiers/term_database.h"
#include "theory/uf/equality_engine_iterator.h"
-using namespace cvc5::context;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__INST_MATCH_TRIE_H */
#include "theory/quantifiers/term_tuple_enumerator.h"
#include "theory/quantifiers/term_util.h"
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/quantifiers/quant_module.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/term_registry.h"
#include "theory/quantifiers/term_tuple_enumerator.h"
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/quantifiers/quant_module.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/quant_util.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
class LazyCDProof;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__INSTANTIATE_H */
#include "options/io_utils.h"
#include "printer/printer.h"
-namespace cvc5 {
+namespace cvc5::internal {
InstantiationVec::InstantiationVec(const std::vector<Node>& vec,
theory::InferenceId id,
return out;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/inference_id.h"
-namespace cvc5 {
+namespace cvc5::internal {
struct InstantiationVec
{
/** Print the skolem list to stream out */
std::ostream& operator<<(std::ostream& out, const SkolemList& skl);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__INSTANTIATION_LIST_H */
# src/theory/builtin/kinds.
#
-theory THEORY_QUANTIFIERS ::cvc5::theory::quantifiers::TheoryQuantifiers "theory/quantifiers/theory_quantifiers.h"
+theory THEORY_QUANTIFIERS ::cvc5::internal::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::internal::theory::quantifiers::QuantifiersRewriter "theory/quantifiers/quantifiers_rewriter.h"
operator FORALL 2:3 "universally quantified formula; first parameter is an BOUND_VAR_LIST, second is quantifier body, and an optional third parameter is an INST_PATTERN_LIST"
# a list of instantiation patterns
operator INST_PATTERN_LIST 1: "a list of instantiation patterns"
-typerule FORALL ::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::internal::theory::quantifiers::QuantifierTypeRule
+typerule EXISTS ::cvc5::internal::theory::quantifiers::QuantifierTypeRule
+typerule BOUND_VAR_LIST ::cvc5::internal::theory::quantifiers::QuantifierBoundVarListTypeRule
+typerule INST_PATTERN_LIST ::cvc5::internal::theory::quantifiers::QuantifierInstPatternListTypeRule
+
+typerule INST_PATTERN ::cvc5::internal::theory::quantifiers::QuantifierInstPatternTypeRule
+typerule INST_NO_PATTERN ::cvc5::internal::theory::quantifiers::QuantifierAnnotationTypeRule
+typerule INST_ATTRIBUTE ::cvc5::internal::theory::quantifiers::QuantifierAnnotationTypeRule
+typerule INST_POOL ::cvc5::internal::theory::quantifiers::QuantifierAnnotationTypeRule
+typerule INST_ADD_TO_POOL ::cvc5::internal::theory::quantifiers::QuantifierAnnotationTypeRule
+typerule SKOLEM_ADD_TO_POOL ::cvc5::internal::theory::quantifiers::QuantifierAnnotationTypeRule
endtheory
#include "theory/quantifiers/lazy_trie.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__LAZY_TRIE_H */
#include "theory/quantifiers_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/uf/equality_engine_notify.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class QuantifiersEngine;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__MASTER_EQ_NOTIFY__H */
#include "expr/skolem_manager.h"
#include "theory/builtin/proof_checker.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_checker.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__PROOF_CHECKER_H */
#include "theory/quantifiers/fmf/bounded_integers.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include <vector>
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class RepSetIterator;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__QUANT_BOUND_INFERENCE_H */
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_trie.h"
#include "theory/quantifiers/quant_module.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/quant_module.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
QuantifiersModule::QuantifiersModule(
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
class TermDb;
}; /* class QuantifiersModule */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANT_UTIL_H */
#include "theory/quantifiers/quant_relevance.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/quant_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANT_RELEVANCE_H */
#include "theory/quantifiers/first_order_model.h"
#include "theory/quantifiers/quant_bound_inference.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/rep_set.h"
#include "theory/theory_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__FIRST_ORDER_MODEL_H */
#include "theory/quantifiers/first_order_model.h"
#include "theory/quantifiers/term_database.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/quantifiers/quant_module.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class QuantifiersEngine;
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/term_util.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
QuantifiersUtil::QuantifiersUtil(Env& env) : EnvObj(env) {}
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/incomplete_id.h"
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/** Quantifiers utility
};
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANT_UTIL_H */
#include "util/string.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/attribute.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/** Attribute true for function definition quantifiers */
Node mkNamedQuant(Kind k, Node bvl, Node body, const std::string& name);
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/instantiate.h"
#include "theory/quantifiers/skolemize.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_manager_buffered.h"
#include "theory/quantifiers/quantifiers_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__QUANTIFIERS_INFERENCE_MANAGER_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include <vector>
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /*CVC5__THEORY__QUANTIFIERS__QUANTIFIER_MACROS_H */
#include "theory/quantifiers/relevant_domain.h"
#include "theory/quantifiers/term_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/synth_engine.h"
#include "theory/quantifiers/sygus_inst.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class QuantifiersEngine;
*/
class QuantifiersModules
{
- friend class ::cvc5::theory::QuantifiersEngine;
+ friend class ::cvc5::internal::theory::QuantifiersEngine;
public:
QuantifiersModules();
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__QUANTIFIERS_MODULES_H */
#include "theory/quantifiers/quantifiers_rewriter.h"
#include "theory/quantifiers/skolemize.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/trust_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__QUANTIFIERS_REWRITER_H */
#include "theory/quantifiers/quant_module.h"
#include "theory/quantifiers/term_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/quantifiers_attributes.h"
#include "theory/quantifiers/quantifiers_preprocess.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class QuantifiersModule;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__QUANTIFIERS_REGISTRY_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/trust_node.h"
#include "theory/theory_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Options;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__QUANTIFIERS_REWRITER_H */
#include "options/quantifiers_options.h"
#include "theory/uf/equality_engine_iterator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/theory_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__QUANTIFIERS_STATE_H */
#include "smt/smt_statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__QUANTIFIERS_STATISTICS_H */
#include "smt/print_benchmark.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/quantifiers/expr_miner.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS___H */
#include "util/random.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/query_generator.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__QUERY_GENERATOR_SAMPLE_SAT_H */
#include "smt/env.h"
#include "util/random.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/query_generator.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS___H */
#include "theory/quantifiers/term_util.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/first_order_model.h"
#include "theory/quantifiers/quant_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__RELEVANT_DOMAIN_H */
#include "expr/skolem_manager.h"
#include "theory/quantifiers/term_util.h"
-using namespace cvc5;
-using namespace cvc5::kind;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SINGLE_INV_PARTITION_H */
#include "theory/sort_inference.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/trust_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class DTypeConstructor;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SKOLEMIZE_H */
#include "smt/logic_exception.h"
#include "util/random.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/lazy_trie.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SOLUTION_FILTER_H */
#include "theory/quantifiers/term_util.h"
#include "theory/smt_engine_subsolver.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/single_inv_partition.h"
#include "theory/quantifiers/sygus/sygus_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/sygus_module.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__CEGIS_H */
#include "theory/smt_engine_subsolver.h"
#include "util/random.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/cegis.h"
#include "util/result.h"
-namespace cvc5 {
+namespace cvc5::internal {
class SolverEngine;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_REPAIR_CONST_H */
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/cegis.h"
#include "theory/quantifiers/sygus/sygus_unif_rl.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
Node EnumStreamConcrete::getCurrent() { return d_currTerm; }
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/quantifiers/sygus/enum_val_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/term_registry.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/sygus_enumerator_callback.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/sygus/example_min_eval.h"
-using namespace cvc5;
-using namespace cvc5::kind;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_trie.h"
#include "theory/quantifiers/sygus/example_infer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/quant_util.h"
-using namespace cvc5;
-using namespace cvc5::kind;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/sygus_unif_io.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/node_algorithm.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/node_trie.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/skolem_manager.h"
#include "theory/datatypes/sygus_datatype_utils.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5__THEORY__QUANTIFIERS__RCONS_OBLIGATION_H
#include "theory/quantifiers/sygus/rcons_obligation.h"
#include "theory/quantifiers/sygus_sampler.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/candidate_rewrite_database.h"
#include "theory/quantifiers/sygus/sygus_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5__THEORY__QUANTIFIERS__RCONS_TYPE_INFO_H
#include "theory/quantifiers/term_util.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_ABDUCT_H */
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/sygus_enumerator_callback.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_ENUMERATOR_H */
#include "theory/quantifiers/sygus_sampler.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/quantifiers/extended_rewrite.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS__SYGUS_ENUMERATOR_CALLBACK_H */
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/quantifiers/sygus/sygus_invariance.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_EVAL_UNFOLD_H */
#include "theory/quantifiers/sygus/sygus_invariance.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_EXPLAIN_H */
#include "util/string.h"
#include "printer/smt2/smt2_printer.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/sygus_datatype.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <numeric> // for std::iota
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_GRAMMAR_RED_H */
#include "theory/quantifiers/sygus/sygus_grammar_cons.h"
#include "theory/smt_engine_subsolver.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
class SolverEngine;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_INTERPOL_H */
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class Rewriter;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_INVARIANCE_H */
#include "theory/quantifiers/quantifiers_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_MODULE_H */
#include "theory/quantifiers/term_util.h"
#include "util/random.h"
-using namespace cvc5;
-using namespace cvc5::kind;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/quantifiers/sygus/sygus_module.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/single_inv_partition.h"
#include "theory/smt_engine_subsolver.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS__SYGUS_QE_PREPROC_H */
#include "theory/rewriter.h"
#include "util/random.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "theory/quantifiers/sygus/enum_val_generator.h"
-namespace cvc5 {
+namespace cvc5::internal {
class DTypeConstructor;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5__THEORY__QUANTIFIERS__SYGUS_RANDOM_ENUMERATOR_H
#include "theory/datatypes/sygus_datatype_utils.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
Node k0 = ob0->getSkolem();
if (options().quantifiers.cegqiSingleInvReconstruct
- == cvc5::options::CegqiSingleInvRconsMode::TRY)
+ == cvc5::internal::options::CegqiSingleInvRconsMode::TRY)
{
fast(sol, stn, reconstructed);
}
uint64_t enumLimit)
{
bool noLimit = options().quantifiers.cegqiSingleInvReconstruct
- == cvc5::options::CegqiSingleInvRconsMode::ALL;
+ == cvc5::internal::options::CegqiSingleInvRconsMode::ALL;
// Skolem of the main obligation
Node k0 = d_obs[0]->getSkolem();
sti.initialize(d_tds, stn);
std::vector<TypeNode> stns;
sti.getSubfieldTypes(stns);
- std::map<cvc5::TypeNode, int> varCount;
+ std::map<cvc5::internal::TypeNode, int> varCount;
// add the constructors for each sygus datatype to the pool
for (const TypeNode& cstn : stns)
args.push_back(cons->getConstructor());
// populate each constructor argument with a free variable of the
// corresponding type
- for (const std::shared_ptr<cvc5::DTypeSelector>& arg : cons->getArgs())
+ for (const std::shared_ptr<cvc5::internal::DTypeSelector>& arg : cons->getArgs())
{
args.push_back(d_tds->getFreeVarInc(arg->getRangeType(), varCount));
}
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/rcons_obligation.h"
#include "theory/quantifiers/sygus/rcons_type_info.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif // CVC5__THEORY__QUANTIFIERS__SYGUS_RECONSTRUCT_H
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/smt_engine_subsolver.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
class LogicInfo;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_REPAIR_CONST_H */
#include "smt/smt_statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/random.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/quantifiers/sygus/sygus_unif_strat.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_UNIF_H */
#include <math.h>
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include <map>
#include "theory/quantifiers/sygus/sygus_unif.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_UNIF_IO_H */
#include <math.h>
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/sygus_unif.h"
#include "util/bool.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_UNIF_RL_H */
#include "theory/quantifiers/term_util.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_UNIF_H */
#include "theory/quantifiers/quantifiers_attributes.h"
#include "theory/quantifiers/sygus/sygus_grammar_cons.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/subs.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS__SYGUS_UTILS_H */
#include "theory/rewriter.h"
#include "theory/smt_engine_subsolver.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/synth_verify.h"
#include "theory/quantifiers/sygus/template_infer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/term_registry.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/sygus_stats.h"
#include "theory/quantifiers/sygus/synth_conjecture.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
#include "theory/smt_engine_subsolver.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "util/result.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/sygus/sygus_utils.h"
#include "theory/quantifiers/term_util.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/quantifiers/sygus/transition_inference.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/sygus/type_info.h"
#include "theory/quantifiers/term_database.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__TERM_DATABASE_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/inst_match_trie.h"
#include "theory/quantifiers/single_inv_partition.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/sygus/type_node_id_trie.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS__TYPE_INFO_H */
#include "theory/quantifiers/sygus/type_node_id_trie.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS__TYPE_NODE_ID_TRIE_H */
#include "theory/quantifiers/term_util.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/decision_strategy.h"
#include "theory/quantifiers/quant_module.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class QuantifiersEngine;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/sampler.h"
#include "util/string.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/lazy_trie.h"
#include "theory/quantifiers/term_enumeration.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__SYGUS_SAMPLER_H */
#include "theory/rewriter.h"
#include "theory/uf/equality_engine.h"
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__TERM_DATABASE_H */
#include "theory/quantifiers/quant_bound_inference.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__TERM_ENUMERATION_H */
#include "theory/quantifiers/quantifiers_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/quantifiers/quant_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__TERM_POOLS_H */
#include "theory/quantifiers/quantifiers_state.h"
#include "theory/quantifiers/term_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/term_enumeration.h"
#include "theory/quantifiers/term_pools.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__TERM_REGISTRY_H */
#include "theory/quantifiers/term_util.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
template <typename T>
static Cvc5ostream& operator<<(Cvc5ostream& out, const std::vector<T>& v)
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* TERM_TUPLE_ENUMERATOR_H_7640 */
#include "util/bitvector.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/attribute.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
// attribute for "contains instantiation constants from"
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__TERM_UTIL_H */
#include "theory/trust_substitutions.h"
#include "theory/valuation.h"
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/valuation.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__THEORY_QUANTIFIERS_H */
#include "theory/quantifiers/theory_quantifiers_type_rules.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace quantifiers {
} // namespace quantifiers
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS__THEORY_QUANTIFIERS_TYPE_RULES_H */
#include "theory/theory_engine.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
QuantifiersEngine::QuantifiersEngine(
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/quantifiers/quant_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TheoryEngine;
*/
class QuantifiersEngine : protected EnvObj
{
- friend class ::cvc5::TheoryEngine;
+ friend class ::cvc5::internal::TheoryEngine;
typedef context::CDHashMap<Node, bool> BoolMap;
typedef context::CDHashSet<Node> NodeSet;
}; /* class QuantifiersEngine */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__QUANTIFIERS_ENGINE_H */
#include "smt/env.h"
#include "theory/relevance_manager.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
RelevanceManager::RelevanceManager(Env& env, Valuation val)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/difficulty_manager.h"
#include "theory/valuation.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class TheoryModel;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__RELEVANCE_MANAGER__H */
#include "theory/type_enumerator.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
void RepSet::clear(){
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class QuantifiersEngine;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__REP_SET_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
// Note that this function is a simplified version of Theory::theoryOf for
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/theory_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
class TConvProofGenerator;
* The main rewriter class.
*/
class Rewriter {
- friend class cvc5::Env; // to set the resource manager
+ friend class cvc5::internal::Env; // to set the resource manager
public:
Rewriter();
};/* class Rewriter */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/attribute.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
template <bool pre, theory::TheoryId theoryId>
};/* struct RewriteAttribute */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
${rewriter_includes}
// clang-format on
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
Node Rewriter::getPreRewriteCache(theory::TheoryId theoryId, TNode node)
void Rewriter::clearCachesInternal()
{
- typedef cvc5::expr::attr::AttributeUniqueId AttributeUniqueId;
+ typedef cvc5::internal::expr::attr::AttributeUniqueId AttributeUniqueId;
std::vector<AttributeUniqueId> preids;
// clang-format off
${pre_rewrite_attribute_ids} // clang-format on
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
# src/theory/builtin/kinds.
#
-theory THEORY_SEP ::cvc5::theory::sep::TheorySep "theory/sep/theory_sep.h"
+theory THEORY_SEP ::cvc5::internal::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::internal::theory::sep::TheorySepRewriter "theory/sep/theory_sep_rewriter.h"
nullaryoperator SEP_NIL "separation nil"
operator SEP_WAND 2 "separation magic wand"
operator SEP_LABEL 2 "separation label (internal use only)"
-typerule SEP_EMP ::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::internal::theory::sep::SepEmpTypeRule
+typerule SEP_PTO ::cvc5::internal::theory::sep::SepPtoTypeRule
+typerule SEP_STAR ::cvc5::internal::theory::sep::SepStarTypeRule
+typerule SEP_WAND ::cvc5::internal::theory::sep::SepWandTypeRule
+typerule SEP_LABEL ::cvc5::internal::theory::sep::SepLabelTypeRule
+typerule SEP_NIL ::cvc5::internal::theory::sep::SepNilTypeRule
endtheory
#include "util/cardinality.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sep {
} // namespace sep
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/uf/equality_engine.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class TheoryModel;
} // namespace sep
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SEP__THEORY_SEP_H */
#include "options/sep_options.h"
#include "theory/quantifiers/quant_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sep {
} // namespace sep
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_rewriter.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sep {
} // namespace sep
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SEP__THEORY_SEP_REWRITER_H */
#include "theory/sep/theory_sep_type_rules.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sep {
} // namespace sep
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sep {
} // namespace sep
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SEP__THEORY_SEP_TYPE_RULES_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/type_set.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/rewriter.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_manager_buffered.h"
#include "theory/sets/solver_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SETS__INFERENCE_MANAGER_H */
#
theory THEORY_SETS \
- ::cvc5::theory::sets::TheorySets \
+ ::cvc5::internal::theory::sets::TheorySets \
"theory/sets/theory_sets.h"
typechecker "theory/sets/theory_sets_type_rules.h"
-rewriter ::cvc5::theory::sets::TheorySetsRewriter \
+rewriter ::cvc5::internal::theory::sets::TheorySetsRewriter \
"theory/sets/theory_sets_rewriter.h"
properties parametric
constant SET_EMPTY\
class \
EmptySet \
- ::cvc5::EmptySetHashFunction \
+ ::cvc5::internal::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::internal::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::internal::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::internal::theory::sets::SetsProperties::isWellFounded(%TYPE%)" \
+ "::cvc5::internal::theory::sets::SetsProperties::mkGroundTerm(%TYPE%)" \
"theory/sets/theory_sets_type_rules.h"
enumerator SET_TYPE \
- "::cvc5::theory::sets::SetEnumerator" \
+ "::cvc5::internal::theory::sets::SetEnumerator" \
"theory/sets/theory_sets_type_enumerator.h"
# operators
constant SET_SINGLETON_OP \
class \
SetSingletonOp \
- ::cvc5::SetSingletonOpHashFunction \
+ ::cvc5::internal::SetSingletonOpHashFunction \
"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::internal::SingletonOp class"
parameterized SET_SINGLETON SET_SINGLETON_OP 1 \
"constructs a set of a single element. First parameter is a SingletonOp. Second is a term"
operator RELATION_JOIN_IMAGE 2 "relation join image"
operator RELATION_IDEN 1 "relation identity"
-typerule SET_UNION ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
-typerule SET_INTER ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
-typerule SET_MINUS ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
-typerule SET_SUBSET ::cvc5::theory::sets::SubsetTypeRule
-typerule SET_MEMBER ::cvc5::theory::sets::MemberTypeRule
+typerule SET_UNION ::cvc5::internal::theory::sets::SetsBinaryOperatorTypeRule
+typerule SET_INTER ::cvc5::internal::theory::sets::SetsBinaryOperatorTypeRule
+typerule SET_MINUS ::cvc5::internal::theory::sets::SetsBinaryOperatorTypeRule
+typerule SET_SUBSET ::cvc5::internal::theory::sets::SubsetTypeRule
+typerule SET_MEMBER ::cvc5::internal::theory::sets::MemberTypeRule
typerule SET_SINGLETON_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule SET_SINGLETON ::cvc5::theory::sets::SingletonTypeRule
-typerule SET_EMPTY ::cvc5::theory::sets::EmptySetTypeRule
-typerule SET_INSERT ::cvc5::theory::sets::InsertTypeRule
-typerule SET_CARD ::cvc5::theory::sets::CardTypeRule
-typerule SET_COMPLEMENT ::cvc5::theory::sets::ComplementTypeRule
-typerule SET_UNIVERSE ::cvc5::theory::sets::UniverseSetTypeRule
-typerule SET_COMPREHENSION ::cvc5::theory::sets::ComprehensionTypeRule
-typerule SET_CHOOSE ::cvc5::theory::sets::ChooseTypeRule
-typerule SET_IS_SINGLETON ::cvc5::theory::sets::IsSingletonTypeRule
-typerule SET_MAP ::cvc5::theory::sets::SetMapTypeRule
-
-typerule RELATION_JOIN ::cvc5::theory::sets::RelBinaryOperatorTypeRule
-typerule RELATION_PRODUCT ::cvc5::theory::sets::RelBinaryOperatorTypeRule
-typerule RELATION_TRANSPOSE ::cvc5::theory::sets::RelTransposeTypeRule
-typerule RELATION_TCLOSURE ::cvc5::theory::sets::RelTransClosureTypeRule
-typerule RELATION_JOIN_IMAGE ::cvc5::theory::sets::JoinImageTypeRule
-typerule RELATION_IDEN ::cvc5::theory::sets::RelIdenTypeRule
-
-construle SET_UNION ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
-construle SET_SINGLETON ::cvc5::theory::sets::SingletonTypeRule
+typerule SET_SINGLETON ::cvc5::internal::theory::sets::SingletonTypeRule
+typerule SET_EMPTY ::cvc5::internal::theory::sets::EmptySetTypeRule
+typerule SET_INSERT ::cvc5::internal::theory::sets::InsertTypeRule
+typerule SET_CARD ::cvc5::internal::theory::sets::CardTypeRule
+typerule SET_COMPLEMENT ::cvc5::internal::theory::sets::ComplementTypeRule
+typerule SET_UNIVERSE ::cvc5::internal::theory::sets::UniverseSetTypeRule
+typerule SET_COMPREHENSION ::cvc5::internal::theory::sets::ComprehensionTypeRule
+typerule SET_CHOOSE ::cvc5::internal::theory::sets::ChooseTypeRule
+typerule SET_IS_SINGLETON ::cvc5::internal::theory::sets::IsSingletonTypeRule
+typerule SET_MAP ::cvc5::internal::theory::sets::SetMapTypeRule
+
+typerule RELATION_JOIN ::cvc5::internal::theory::sets::RelBinaryOperatorTypeRule
+typerule RELATION_PRODUCT ::cvc5::internal::theory::sets::RelBinaryOperatorTypeRule
+typerule RELATION_TRANSPOSE ::cvc5::internal::theory::sets::RelTransposeTypeRule
+typerule RELATION_TCLOSURE ::cvc5::internal::theory::sets::RelTransClosureTypeRule
+typerule RELATION_JOIN_IMAGE ::cvc5::internal::theory::sets::JoinImageTypeRule
+typerule RELATION_IDEN ::cvc5::internal::theory::sets::RelIdenTypeRule
+
+construle SET_UNION ::cvc5::internal::theory::sets::SetsBinaryOperatorTypeRule
+construle SET_SINGLETON ::cvc5::internal::theory::sets::SingletonTypeRule
endtheory
#include "expr/emptyset.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
};
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/dtype_cons.h"
#include "theory/datatypes/tuple_utils.h"
-using namespace cvc5::theory::datatypes;
+using namespace cvc5::internal::theory::datatypes;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
};
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& out, const SetSingletonOp& op)
{
return getType() == op.getType();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <memory>
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
size_t operator()(const SetSingletonOp& op) const;
}; /* struct SetSingletonOpHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SETS__SINGLETON_OP_H */
#include "expr/skolem_manager.h"
#include "theory/rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class Rewriter;
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__SKOLEM_CACHE_H */
#include "theory/sets/theory_sets_private.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_state.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SETS__THEORY_SOLVER_STATE_H */
#include "expr/skolem_manager.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/sets/skolem_cache.h"
#include "theory/sets/solver_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SETS__TERM_REGISTRY_H */
#include "theory/theory_model.h"
#include "theory/trust_substitutions.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_eq_notify.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SETS__THEORY_SETS_H */
#include "util/result.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
throw LogicException(
"JoinImage cardinality constraint must be a constant");
}
- cvc5::Rational r(INT_MAX);
+ cvc5::internal::Rational r(INT_MAX);
if (node[1].getConst<Rational>() > r)
{
throw LogicException(
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SETS__THEORY_SETS_PRIVATE_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::theory::datatypes;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory::datatypes;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
}
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* SRC_THEORY_SETS_THEORY_SETS_RELS_H_ */
#include "theory/sets/rels_utils.h"
#include "util/rational.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory::datatypes;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory::datatypes;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SETS__THEORY_SETS_REWRITER_H */
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/sets/normal_form.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SETS__TYPE_ENUMERATOR_H */
#include "theory/sets/singleton_op.h"
#include "util/cardinality.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace sets {
} // namespace sets
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SETS__THEORY_SETS_TYPE_RULES_H */
#include "theory/theory_engine.h"
#include "theory/theory_inference_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
// Always creates shared terms database. In all cases, shared terms
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/term_registration_visitor.h"
#include "theory/valuation.h"
-namespace cvc5 {
+namespace cvc5::internal {
class LogicInfo;
class ProofNodeManager;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SHARED_SOLVER__H */
#include "theory/theory_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
SharedSolverDistributed::SharedSolverDistributed(Env& env, TheoryEngine& te)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/shared_solver.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SHARED_SOLVER_DISTRIBUTED__H */
#include "theory/theory_engine.h"
using namespace std;
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
SharedTermsDatabase::SharedTermsDatabase(Env& env, TheoryEngine* theoryEngine)
: ContextNotifyObj(env.getContext()),
return TrustNode::mkTrustPropExp(literal, exp, nullptr);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/uf/proof_equality_engine.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
class TheoryEngine;
ProofNodeManager* d_pnm;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/skolem_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
SkolemLemma::SkolemLemma(TrustNode lem, Node k) : d_lemma(lem), d_skolem(k)
Node SkolemLemma::getProven() const { return d_lemma.getProven(); }
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/trust_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SKOLEM_LEMMA_H */
#include "smt/solver_engine.h"
#include "smt/solver_engine_scope.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
// optimization: try to rewrite to constant
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/solver_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
void getUnsatCoreFromSubsolver(SolverEngine& smt, std::vector<Node>& uasserts);
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SMT_ENGINE_SUBSOLVER_H */
#include "theory/quantifiers/quant_util.h"
#include "theory/rewriter.h"
-using namespace cvc5;
-using namespace cvc5::kind;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
void SortInference::UnionFind::print(const char * c){
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/theory.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class Rewriter;
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/strings/word.h"
#include "util/rational.h"
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/solver_state.h"
#include "theory/strings/term_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/strings/word.h"
#include "util/rational.h"
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/solver_state.h"
#include "theory/strings/term_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/rational.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/solver_state.h"
#include "theory/strings/term_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__BASE_SOLVER_H */
#include "util/string.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/solver_state.h"
#include "theory/strings/term_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__CORE_SOLVER_H */
#include "theory/strings/theory_strings_utils.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/solver_state.h"
#include "theory/strings/term_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__EAGER_SOLVER_H */
#include "theory/strings/word.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/context.h"
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__EQC_INFO_H */
#include "util/statistics_registry.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/strings_rewriter.h"
#include "theory/strings/theory_strings_preprocess.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__EXTF_SOLVER_H */
#include "theory/strings/theory_strings_utils.h"
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_inference.h"
#include "util/safe_print.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__INFER_INFO_H */
#include "theory/strings/theory_strings_utils.h"
#include "util/statistics_registry.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/sequences_stats.h"
#include "theory/uf/proof_equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__INFER_PROOF_CONS_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_inference_manager.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
# src/theory/builtin/kinds.
#
-theory THEORY_STRINGS ::cvc5::theory::strings::TheoryStrings "theory/strings/theory_strings.h"
+theory THEORY_STRINGS ::cvc5::internal::theory::strings::TheoryStrings "theory/strings/theory_strings.h"
properties check parametric presolve
-rewriter ::cvc5::theory::strings::SequencesRewriter "theory/strings/sequences_rewriter.h"
+rewriter ::cvc5::internal::theory::strings::SequencesRewriter "theory/strings/sequences_rewriter.h"
typechecker "theory/strings/theory_strings_type_rules.h"
sort STRING_TYPE \
Cardinality::INTEGERS \
well-founded \
- "NodeManager::currentNM()->mkConst(::cvc5::String())" \
+ "NodeManager::currentNM()->mkConst(::cvc5::internal::String())" \
"util/string.h" \
"String type"
"RegExp type"
enumerator STRING_TYPE \
- "::cvc5::theory::strings::StringEnumerator" \
+ "::cvc5::internal::theory::strings::StringEnumerator" \
"theory/strings/type_enumerator.h"
enumerator REGEXP_TYPE \
- "::cvc5::theory::strings::RegExpEnumerator" \
+ "::cvc5::internal::theory::strings::RegExpEnumerator" \
"theory/strings/regexp_enumerator.h"
constant CONST_STRING \
class \
String \
- ::cvc5::strings::StringHashFunction \
+ ::cvc5::internal::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::internal::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::internal::theory::strings::SequenceProperties::isWellFounded(%TYPE%)" \
+ "::cvc5::internal::theory::strings::SequenceProperties::mkGroundTerm(%TYPE%)" \
"theory/strings/theory_strings_type_rules.h"
enumerator SEQUENCE_TYPE \
- "::cvc5::theory::strings::SequenceEnumerator" \
+ "::cvc5::internal::theory::strings::SequenceEnumerator" \
"theory/strings/type_enumerator.h"
constant CONST_SEQUENCE \
class \
Sequence \
- ::cvc5::SequenceHashFunction \
+ ::cvc5::internal::SequenceHashFunction \
"expr/sequence.h" \
"a sequence of characters"
constant SEQ_UNIT_OP \
class \
SeqUnitOp \
- ::cvc5::SeqUnitOpHashFunction \
+ ::cvc5::internal::SeqUnitOpHashFunction \
"theory/strings/seq_unit_op.h" \
- "operator for sequence units; payload is an instance of the cvc5::SeqUnitOp class"
+ "operator for sequence units; payload is an instance of the cvc5::internal::SeqUnitOp class"
parameterized SEQ_UNIT SEQ_UNIT_OP 1 \
"a sequence of length one. First parameter is a SeqUnitOp. Second is a term"
constant REGEXP_REPEAT_OP \
struct \
RegExpRepeat \
- ::cvc5::RegExpRepeatHashFunction \
+ ::cvc5::internal::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::internal::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 \
struct \
RegExpLoop \
- ::cvc5::RegExpLoopHashFunction \
+ ::cvc5::internal::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::internal::RegExpLoop class"
parameterized REGEXP_LOOP REGEXP_LOOP_OP 1 "regular expression loop; first parameter is a REGEXP_LOOP_OP, second is a regular expression term"
#internal
typerule REGEXP_STAR "SimpleTypeRule<RRegExp, ARegExp>"
typerule REGEXP_PLUS "SimpleTypeRule<RRegExp, ARegExp>"
typerule REGEXP_OPT "SimpleTypeRule<RRegExp, ARegExp>"
-typerule REGEXP_RANGE ::cvc5::theory::strings::RegExpRangeTypeRule
+typerule REGEXP_RANGE ::cvc5::internal::theory::strings::RegExpRangeTypeRule
typerule REGEXP_REPEAT_OP "SimpleTypeRule<RBuiltinOperator>"
typerule REGEXP_REPEAT "SimpleTypeRule<RRegExp, ARegExp>"
typerule REGEXP_LOOP_OP "SimpleTypeRule<RBuiltinOperator>"
typerule REGEXP_LOOP "SimpleTypeRule<RRegExp, ARegExp>"
typerule REGEXP_COMPLEMENT "SimpleTypeRule<RRegExp, ARegExp>"
-typerule STRING_TO_REGEXP ::cvc5::theory::strings::StringToRegExpTypeRule
+typerule STRING_TO_REGEXP ::cvc5::internal::theory::strings::StringToRegExpTypeRule
typerule STRING_IN_REGEXP "SimpleTypeRule<RBool, AString, ARegExp>"
typerule REGEXP_NONE "SimpleTypeRule<RRegExp>"
typerule REGEXP_ALL "SimpleTypeRule<RRegExp>"
typerule REGEXP_ALLCHAR "SimpleTypeRule<RRegExp>"
# we return isConst for some regular expressions, including all that we enumerate
-construle STRING_TO_REGEXP ::cvc5::theory::strings::StringToRegExpTypeRule
+construle STRING_TO_REGEXP ::cvc5::internal::theory::strings::StringToRegExpTypeRule
### 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_CONTAINS ::cvc5::theory::strings::StringRelationTypeRule
-typerule STRING_INDEXOF ::cvc5::theory::strings::StringIndexOfTypeRule
+typerule STRING_CONCAT ::cvc5::internal::theory::strings::StringConcatTypeRule
+typerule STRING_LENGTH ::cvc5::internal::theory::strings::StringStrToIntTypeRule
+typerule STRING_SUBSTR ::cvc5::internal::theory::strings::StringSubstrTypeRule
+typerule STRING_UPDATE ::cvc5::internal::theory::strings::StringUpdateTypeRule
+typerule STRING_CHARAT ::cvc5::internal::theory::strings::StringAtTypeRule
+typerule STRING_CONTAINS ::cvc5::internal::theory::strings::StringRelationTypeRule
+typerule STRING_INDEXOF ::cvc5::internal::theory::strings::StringIndexOfTypeRule
typerule STRING_INDEXOF_RE "SimpleTypeRule<RInteger, AString, ARegExp, AInteger>"
-typerule STRING_REPLACE ::cvc5::theory::strings::StringReplaceTypeRule
-typerule STRING_REPLACE_ALL ::cvc5::theory::strings::StringReplaceTypeRule
+typerule STRING_REPLACE ::cvc5::internal::theory::strings::StringReplaceTypeRule
+typerule STRING_REPLACE_ALL ::cvc5::internal::theory::strings::StringReplaceTypeRule
typerule STRING_REPLACE_RE "SimpleTypeRule<RString, AString, ARegExp, AString>"
typerule STRING_REPLACE_RE_ALL "SimpleTypeRule<RString, AString, ARegExp, AString>"
-typerule STRING_PREFIX ::cvc5::theory::strings::StringStrToBoolTypeRule
-typerule STRING_SUFFIX ::cvc5::theory::strings::StringStrToBoolTypeRule
-typerule STRING_REV ::cvc5::theory::strings::StringStrToStrTypeRule
+typerule STRING_PREFIX ::cvc5::internal::theory::strings::StringStrToBoolTypeRule
+typerule STRING_SUFFIX ::cvc5::internal::theory::strings::StringStrToBoolTypeRule
+typerule STRING_REV ::cvc5::internal::theory::strings::StringStrToStrTypeRule
### string specific operators
### sequence specific operators
-typerule CONST_SEQUENCE ::cvc5::theory::strings::ConstSequenceTypeRule
+typerule CONST_SEQUENCE ::cvc5::internal::theory::strings::ConstSequenceTypeRule
typerule SEQ_UNIT_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule SEQ_UNIT ::cvc5::theory::strings::SeqUnitTypeRule
-typerule SEQ_NTH ::cvc5::theory::strings::SeqNthTypeRule
-typerule SEQ_NTH_TOTAL ::cvc5::theory::strings::SeqNthTypeRule
+typerule SEQ_UNIT ::cvc5::internal::theory::strings::SeqUnitTypeRule
+typerule SEQ_NTH ::cvc5::internal::theory::strings::SeqNthTypeRule
+typerule SEQ_NTH_TOTAL ::cvc5::internal::theory::strings::SeqNthTypeRule
endtheory
#include "theory/strings/word.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include <vector>
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__NORMAL_FORM_H */
#include "theory/strings/theory_strings_utils.h"
#include "theory/strings/word.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_checker.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__PROOF_CHECKER_H */
#include "util/rational.h"
#include "util/string.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/eager_proof_generator.h"
#include "proof/trust_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__REGEXP_ELIM_H */
#include "util/string.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
else if (xc.isConst())
{
// check for constants
- cvc5::String s = xc.getConst<String>();
+ cvc5::internal::String s = xc.getConst<String>();
if (Word::isEmpty(xc))
{
Trace("regexp-ext-rewrite-debug") << "- ignore empty" << std::endl;
}
std::vector<unsigned> ssVec;
ssVec.push_back(t == 0 ? s.back() : s.front());
- cvc5::String ss(ssVec);
+ cvc5::internal::String ss(ssVec);
if (testConstStringInRegExp(ss, 0, rc))
{
// strip off one character
return true;
}
-bool RegExpEntail::testConstStringInRegExp(cvc5::String& s,
+bool RegExpEntail::testConstStringInRegExp(cvc5::internal::String& s,
unsigned index_start,
TNode r)
{
{
case STRING_TO_REGEXP:
{
- cvc5::String s2 = s.substr(index_start, s.size() - index_start);
+ cvc5::internal::String s2 = s.substr(index_start, s.size() - index_start);
if (r[0].isConst())
{
return (s2 == r[0].getConst<String>());
{
for (vec_k[i] = vec_k[i] + 1; vec_k[i] <= left; ++vec_k[i])
{
- cvc5::String t = s.substr(index_start + start, vec_k[i]);
+ cvc5::internal::String t = s.substr(index_start + start, vec_k[i]);
if (testConstStringInRegExp(t, 0, r[i]))
{
start += vec_k[i];
{
for (unsigned i = s.size() - index_start; i > 0; --i)
{
- cvc5::String t = s.substr(index_start, i);
+ cvc5::internal::String t = s.substr(index_start, i);
if (testConstStringInRegExp(t, 0, r[0]))
{
if (index_start + i == s.size()
uint32_t u = r[2].getConst<Rational>().getNumerator().toUnsignedInt();
for (unsigned len = s.size() - index_start; len >= 1; len--)
{
- cvc5::String t = s.substr(index_start, len);
+ cvc5::internal::String t = s.substr(index_start, len);
if (testConstStringInRegExp(t, 0, r[0]))
{
if (len + index_start == s.size())
}
else
{
- Node num2 = nm->mkConstInt(cvc5::Rational(u - 1));
+ Node num2 = nm->mkConstInt(cvc5::internal::Rational(u - 1));
Node r2 = nm->mkNode(REGEXP_LOOP, r[0], r[1], num2);
if (testConstStringInRegExp(s, index_start + len, r2))
{
}
for (unsigned len = 1; len <= s.size() - index_start; len++)
{
- cvc5::String t = s.substr(index_start, len);
+ cvc5::internal::String t = s.substr(index_start, len);
if (testConstStringInRegExp(t, 0, r[0]))
{
- Node num2 = nm->mkConstInt(cvc5::Rational(l - 1));
+ Node num2 = nm->mkConstInt(cvc5::internal::Rational(l - 1));
Node r2 = nm->mkNode(REGEXP_LOOP, r[0], num2, num2);
if (testConstStringInRegExp(s, index_start + len, r2))
{
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_rewriter.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
* 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::internal::String& s,
unsigned index_start,
TNode r);
/** Does regular expression node have (str.to.re "") as a child? */
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__REGEXP_ENTAIL_H */
#include "theory/strings/regexp_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "theory/strings/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__TYPE_ENUMERATOR_H */
#include "theory/strings/word.h"
#include "util/regexp.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
}
// 0-unknown, 1-yes, 2-no
-int RegExpOpr::derivativeS(Node r, cvc5::String c, Node& retNode)
+int RegExpOpr::derivativeS(Node r, cvc5::internal::String c, Node& retNode)
{
Assert(c.size() < 2);
Trace("regexp-derive") << "RegExp-derive starts with /" << mkString( r ) << "/, c=" << c << std::endl;
break;
}
case kind::REGEXP_RANGE: {
- cvc5::String a = r[0].getConst<String>();
- cvc5::String b = r[1].getConst<String>();
+ cvc5::internal::String a = r[0].getConst<String>();
+ cvc5::internal::String b = r[1].getConst<String>();
retNode = (a <= c && c <= b) ? d_emptySingleton : d_emptyRegexp;
break;
}
return ret;
}
-Node RegExpOpr::derivativeSingle(Node r, cvc5::String c)
+Node RegExpOpr::derivativeSingle(Node r, cvc5::internal::String c)
{
Assert(c.size() < 2);
Trace("regexp-derive") << "RegExp-derive starts with /" << mkString( r ) << "/, c=" << c << std::endl;
break;
}
case kind::REGEXP_RANGE: {
- cvc5::String a = r[0].getConst<String>();
- cvc5::String b = r[1].getConst<String>();
+ cvc5::internal::String a = r[0].getConst<String>();
+ cvc5::internal::String b = r[1].getConst<String>();
retNode = (a <= c && c <= b) ? d_emptySingleton : d_emptyRegexp;
break;
}
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/skolem_cache.h"
#include "util/string.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
class RegExpOpr : protected EnvObj
{
- typedef std::pair<Node, cvc5::String> PairNodeStr;
+ typedef std::pair<Node, cvc5::internal::String> PairNodeStr;
typedef std::set< Node > SetNodes;
typedef std::pair< Node, Node > PairNodes;
* - delta( (re.union (re.* "A") R) ) returns 1.
*/
int delta( Node r, Node &exp );
- int derivativeS(Node r, cvc5::String c, Node& retNode);
- Node derivativeSingle(Node r, cvc5::String c);
+ int derivativeS(Node r, cvc5::internal::String c, Node& retNode);
+ Node derivativeSingle(Node r, cvc5::internal::String c);
/**
* Returns the regular expression intersection of r1 and r2. If r1 or r2 is
* not constant, then this method returns null.
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__REGEXP__OPERATION_H */
#include "util/statistics_value.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
d_processed_memberships(context()),
d_regexp_opr(env, tr.getSkolemCache())
{
- d_emptyString = NodeManager::currentNM()->mkConst(::cvc5::String(""));
+ d_emptyString = NodeManager::currentNM()->mkConst(::cvc5::internal::String(""));
d_emptyRegexp = NodeManager::currentNM()->mkNode(REGEXP_NONE);
d_true = NodeManager::currentNM()->mkConst(true);
d_false = NodeManager::currentNM()->mkConst(false);
return true;
}
-cvc5::String RegExpSolver::getHeadConst(Node x)
+cvc5::internal::String RegExpSolver::getHeadConst(Node x)
{
if (x.isConst())
{
Assert(x != d_emptyString);
Trace("regexp-derive") << "RegExpSolver::deriveRegExp: x=" << x
<< ", r= " << r << std::endl;
- cvc5::String s = getHeadConst(x);
+ cvc5::internal::String s = getHeadConst(x);
// only allow RE_DERIVE for concrete constant regular expressions
if (!s.empty() && d_regexp_opr.getRegExpConstType(r) == RE_C_CONRETE_CONSTANT)
{
bool flag = true;
for (unsigned i = 0; i < s.size(); ++i)
{
- cvc5::String c = s.substr(i, 1);
+ cvc5::internal::String c = s.substr(i, 1);
Node dc2;
int rt = d_regexp_opr.derivativeS(dc, c, dc2);
dc = dc2;
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/term_registry.h"
#include "util/string.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
Node x, Node r, Node atom, bool& addedLemma, std::vector<Node>& nf_exp);
Node getMembership(Node n, bool isPos, unsigned i);
unsigned getNumMemberships(Node n, bool isPos);
- cvc5::String getHeadConst(Node x);
+ cvc5::internal::String getHeadConst(Node x);
bool deriveRegExp(Node x, Node r, Node atom, std::vector<Node>& ant);
Node getNormalSymRegExp(Node r, std::vector<Node>& nf_exp);
// regular expression memberships
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__THEORY_STRINGS_H */
#include <iostream>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__REWRITES_H */
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& out, const SeqUnitOp& op)
{
return getType() == op.getType();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <memory>
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
size_t operator()(const SeqUnitOp& op) const;
}; /* struct SeqUnitOpHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__SEQ_UNIT_OP_H */
#include "util/string.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
for (const Node& c : constStrRe)
{
Assert(c.getKind() == STRING_TO_REGEXP && c[0].getKind() == CONST_STRING);
- cvc5::String s = c[0].getConst<String>();
+ cvc5::internal::String s = c[0].getConst<String>();
for (const Node& r : otherRe)
{
Trace("strings-rewrite-debug")
else if (x.isConst() && RegExpEntail::isConstRegExp(r))
{
// test whether x in node[1]
- cvc5::String s = x.getConst<String>();
+ cvc5::internal::String s = x.getConst<String>();
bool test = RegExpEntail::testConstStringInRegExp(s, 0, r);
Node retNode = NodeManager::currentNM()->mkConst(test);
return returnRewrite(node, retNode, Rewrite::RE_IN_EVAL);
if (node[1].isConst() && node[2].isConst())
{
Node s = node[0];
- cvc5::Rational rMaxInt(String::maxSize());
+ cvc5::internal::Rational rMaxInt(String::maxSize());
uint32_t start;
if (node[1].getConst<Rational>() > rMaxInt)
{
}
}
}
- Node zero = nm->mkConstInt(cvc5::Rational(0));
+ Node zero = nm->mkConstInt(cvc5::internal::Rational(0));
// if entailed non-positive length or negative start point
if (d_arithEntail.check(zero, node[1], true))
// rewriting for constant arguments
if (node[1].isConst())
{
- cvc5::Rational rMaxInt(String::maxSize());
+ cvc5::internal::Rational rMaxInt(String::maxSize());
if (node[1].getConst<Rational>() > rMaxInt)
{
// start beyond the maximum size of strings
utils::getConcat(node[0], children0);
if (children0[0].isConst() && node[1].isConst() && node[2].isConst())
{
- cvc5::Rational rMaxInt(cvc5::String::maxSize());
+ cvc5::internal::Rational rMaxInt(cvc5::internal::String::maxSize());
if (node[2].getConst<Rational>() > rMaxInt)
{
if (node[0].isConst())
if (s.isConst() && n.isConst())
{
Rational nrat = n.getConst<Rational>();
- cvc5::Rational rMaxInt(cvc5::String::maxSize());
+ cvc5::internal::Rational rMaxInt(cvc5::internal::String::maxSize());
if (nrat > rMaxInt)
{
// We know that, due to limitations on the size of string constants
Node val;
if (isPrefix)
{
- val = NodeManager::currentNM()->mkConstInt(::cvc5::Rational(0));
+ val = NodeManager::currentNM()->mkConstInt(::cvc5::internal::Rational(0));
}
else
{
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/strings_entail.h"
#include "theory/theory_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__SEQUENCES_REWRITER_H */
#include "smt/smt_statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/rewrites.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__SEQUENCES_STATS_H */
#include "theory/strings/word.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/skolem_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class Rewriter;
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__SKOLEM_CACHE_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/uf/equality_engine.h"
#include "theory/valuation.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__SOLVER_STATE_H */
#include "options/strings_options.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__STRATEGY_H */
#include "util/rational.h"
#include "util/string.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
Assert(dir == 1 || dir == -1);
Assert(nr.empty());
NodeManager* nm = NodeManager::currentNM();
- Node zero = nm->mkConstInt(cvc5::Rational(0));
+ Node zero = nm->mkConstInt(cvc5::internal::Rational(0));
bool ret = false;
bool success = true;
unsigned sindex = 0;
Assert(d_arithEntail.check(curr, true));
Node s = n1[sindex_use];
size_t slen = Word::getLength(s);
- Node ncl = nm->mkConstInt(cvc5::Rational(slen));
+ Node ncl = nm->mkConstInt(cvc5::internal::Rational(slen));
Node next_s = nm->mkNode(SUB, lowerBound, ncl);
next_s = d_rr->rewrite(next_s);
Assert(next_s.isConst());
if (n2[index1].isConst())
{
Assert(n2[index1].getType().isString()); // string-only
- cvc5::String t = n2[index1].getConst<String>();
+ cvc5::internal::String t = n2[index1].getConst<String>();
if (n1.size() == 1)
{
// if n1.size()==1, then if n2[index1] is not a number, we can drop
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/strings/arith_entail.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class Rewriter;
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__STRING_ENTAIL_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/term_registry.h"
#include "theory/valuation.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__STRINGS_FMF_H */
#include "util/rational.h"
#include "util/string.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/strings/sequences_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__STRINGS_REWRITER_H */
#include "util/string.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/solver_state.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class Theory;
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__TERM_REGISTRY_H */
#include "theory/valuation.h"
using namespace std;
-using namespace cvc5::context;
-using namespace cvc5::kind;
+using namespace cvc5::internal::context;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__THEORY_STRINGS_H */
#include "util/statistics_registry.h"
#include "util/string.h"
-using namespace cvc5;
-using namespace cvc5::kind;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "util/hash.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__PREPROCESS_H */
#include "theory/strings/seq_unit_op.h"
#include "util/cardinality.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
}
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
class NodeManager;
class TypeNode;
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__THEORY_STRINGS_TYPE_RULES_H */
#include "util/regexp.h"
#include "util/string.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
namespace utils {
} // namespace utils
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
namespace utils {
} // namespace utils
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/strings/theory_strings_utils.h"
#include "util/string.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/type_node.h"
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__TYPE_ENUMERATOR_H */
#include "expr/sequence.h"
#include "util/string.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace strings {
} // namespace strings
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
SubstitutionMinimize::SubstitutionMinimize(Env& env) : EnvObj(env) {}
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/** SubstitutionMinimize
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SUBS_MINIMIZE_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
SubstitutionMap::SubstitutionMap(context::Context* context)
return out << "[CDMap-iterator]";
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "context/cdhashmap.h"
#include "util/hash.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class Rewriter;
std::ostream& operator<<(std::ostream& out, const theory::SubstitutionMap::iterator& i);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SUBSTITUTIONS_H */
#include "smt/logic_exception.h"
#include "theory/theory_engine.h"
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
std::string PreRegisterVisitor::toString() const {
std::stringstream ss;
d_visited.clear();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/shared_terms_database.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TheoryEngine;
TNodeToTheorySetMap d_preregistered;
};
-} // namespace cvc5
+} // namespace cvc5::internal
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
std::ostream& operator<<(std::ostream& os, Theory::Effort level){
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/valuation.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
class TheoryEngine;
class Theory : protected EnvObj
{
friend class CarePairArgumentCallback;
- friend class ::cvc5::TheoryEngine;
+ friend class ::cvc5::internal::TheoryEngine;
protected:
/** Name of this theory instance. Along with the TheoryId this should
std::ostream& operator<<(std::ostream& os, theory::Theory::Effort level);
inline std::ostream& operator<<(std::ostream& out,
- const cvc5::theory::Theory& theory)
+ const cvc5::internal::theory::Theory& theory)
{
return out << theory.identify();
}
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__THEORY_H */
using namespace std;
-using namespace cvc5::theory;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
/* -------------------------------------------------------------------------- */
*/
#define CVC5_FOR_EACH_THEORY \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_BUILTIN) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_BOOL) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_UF) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_ARITH) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_BV) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_FP) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_ARRAYS) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_DATATYPES) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_SEP) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_SETS) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_BAGS) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_STRINGS) \
- CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::theory::THEORY_QUANTIFIERS)
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_BUILTIN) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_BOOL) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_UF) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_ARITH) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_BV) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_FP) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_ARRAYS) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_DATATYPES) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_SEP) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_SETS) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_BAGS) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_STRINGS) \
+ CVC5_FOR_EACH_THEORY_STATEMENT(cvc5::internal::theory::THEORY_QUANTIFIERS)
} // namespace theory
theory::Rewriter* TheoryEngine::getRewriter() { return d_env.getRewriter(); }
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/hash.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
class ResourceManager;
}; /* class TheoryEngine */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY_ENGINE_H */
#include "proof/proof_node.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
TheoryEngineProofGenerator::TheoryEngineProofGenerator(ProofNodeManager* pnm,
context::Context* c)
return "TheoryEngineProofGenerator";
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_node_manager.h"
#include "proof/trust_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A simple proof generator class used by the theory engine. This class
Node d_false;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY_ENGINE_PROOF_GENERATOR_H */
#include "theory/theory_inference_manager.h"
#include "theory/uf/equality_engine_notify.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "base/check.h"
#include "lib/ffs.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
TheoryId& operator++(TheoryId& id)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/theory_inference_manager.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
SimpleTheoryLemma::SimpleTheoryLemma(InferenceId id,
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_id.h"
#include "theory/output_channel.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class TheoryInferenceManager;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/uf/equality_engine.h"
#include "theory/uf/proof_equality_engine.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
TheoryInferenceManager::TheoryInferenceManager(Env& env,
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/output_channel.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
class ProofNodeManager;
class AnnotationProofGenerator;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__THEORY_INFERENCE_MANAGER_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
TheoryModel::TheoryModel(Env& env, std::string name, bool enableFuncModels)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/uf/equality_engine.h"
#include "util/cardinality.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
};/* class TheoryModel */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__THEORY_MODEL_H */
#include "util/uninterpreted_sort_value.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
TheoryEngineModelBuilder::TheoryEngineModelBuilder(Env& env) : EnvObj(env) {}
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/theory_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
}; /* class TheoryEngineModelBuilder */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__THEORY_MODEL_BUILDER_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
TheoryPreprocessor::TheoryPreprocessor(Env& env, TheoryEngine& engine)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/term_formula_removal.h"
#include "theory/skolem_lemma.h"
-namespace cvc5 {
+namespace cvc5::internal {
class LogicInfo;
class TheoryEngine;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__THEORY_PREPROCESSOR_H */
#include "theory/theory_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
std::ostream& operator<<(std::ostream& os, RewriteStatus rs)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "proof/trust_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class Rewriter;
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__THEORY_REWRITER_H */
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
TheoryState::TheoryState(Env& env, Valuation val)
Valuation& TheoryState::getValuation() { return d_valuation; }
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/valuation.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__SOLVER_STATE_H */
${theory_includes}
// clang-format on
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
template <TheoryId theoryId>
default: Unhandled() << id;
}
}
-}; /* struct cvc5::theory::TheoryConstructor */
+}; /* struct cvc5::internal::theory::TheoryConstructor */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
TrustSubstitutionMap::TrustSubstitutionMap(context::Context* c,
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/trust_node.h"
#include "theory/substitutions.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/**
};
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__TRUST_SUBSTITUTIONS_H */
#include "expr/type_node.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class NoMoreValuesException : public Exception {
};/* class TypeEnumerator */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__TYPE_ENUMERATOR_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
TypeEnumeratorInterface* TypeEnumerator::mkTypeEnumerator(
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/type_set.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
TypeSet::~TypeSet()
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
/* Type set
}; /* class TypeSet */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__TYPE_SET_H */
#include "util/rational.h"
using namespace std;
-using namespace cvc5::kind;
-using namespace cvc5::context;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::context;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY_UF_STRONG_SOLVER_H */
#include "proof/proof.h"
#include "proof/proof_checker.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
} // namespace eq
} // Namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/uf/equality_engine_types.h"
-namespace cvc5 {
+namespace cvc5::internal {
class CDProof;
} // Namespace eq
} // Namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/rewriter.h"
#include "theory/uf/eq_proof.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
} // Namespace uf
} // Namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/uf/equality_engine_types.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
} // Namespace eq
} // Namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/uf/equality_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
} // namespace eq
} // Namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "theory/uf/equality_engine_types.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
} // Namespace eq
} // Namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
} // Namespace eq
} // Namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/hash.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
} // namespace eq
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__UF__EQUALITY_ENGINE_TYPES_H */
#include "expr/array_store_all.h"
#include "theory/rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__UF__FUNCTION_CONST_H */
#include "theory/uf/theory_uf_rewriter.h"
using namespace std;
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_model.h"
#include "theory/theory_state.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
# src/theory/builtin/kinds.
#
-theory THEORY_UF ::cvc5::theory::uf::TheoryUF "theory/uf/theory_uf.h"
+theory THEORY_UF ::cvc5::internal::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::internal::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::internal::theory::uf::UfTypeRule
operator FUNCTION_TYPE 2: "a function type"
cardinality FUNCTION_TYPE \
- "::cvc5::theory::uf::FunctionProperties::computeCardinality(%TYPE%)" \
+ "::cvc5::internal::theory::uf::FunctionProperties::computeCardinality(%TYPE%)" \
"theory/uf/theory_uf_type_rules.h"
well-founded FUNCTION_TYPE \
- "::cvc5::theory::uf::FunctionProperties::isWellFounded(%TYPE%)" \
- "::cvc5::theory::uf::FunctionProperties::mkGroundTerm(%TYPE%)" \
+ "::cvc5::internal::theory::uf::FunctionProperties::isWellFounded(%TYPE%)" \
+ "::cvc5::internal::theory::uf::FunctionProperties::mkGroundTerm(%TYPE%)" \
"theory/uf/theory_uf_type_rules.h"
enumerator FUNCTION_TYPE \
- ::cvc5::theory::uf::FunctionEnumerator \
+ ::cvc5::internal::theory::uf::FunctionEnumerator \
"theory/uf/type_enumerator.h"
operator LAMBDA 2 "a lambda expression; first parameter is a BOUND_VAR_LIST, second is lambda body"
-typerule LAMBDA ::cvc5::theory::uf::LambdaTypeRule
+typerule LAMBDA ::cvc5::internal::theory::uf::LambdaTypeRule
variable BOOLEAN_TERM_VARIABLE "Boolean term variable"
# lambda expressions that are isomorphic to array constants can be considered constants
-construle LAMBDA ::cvc5::theory::uf::LambdaTypeRule
+construle LAMBDA ::cvc5::internal::theory::uf::LambdaTypeRule
operator HO_APPLY 2 "higher-order (partial) function application"
-typerule HO_APPLY ::cvc5::theory::uf::HoApplyTypeRule
+typerule HO_APPLY ::cvc5::internal::theory::uf::HoApplyTypeRule
constant CARDINALITY_CONSTRAINT_OP \
class \
CardinalityConstraint \
- ::cvc5::CardinalityConstraintHashFunction \
+ ::cvc5::internal::CardinalityConstraintHashFunction \
"expr/cardinality_constraint.h" \
- "the empty set constant; payload is an instance of the cvc5::CardinalityConstraint class"
+ "the empty set constant; payload is an instance of the cvc5::internal::CardinalityConstraint class"
parameterized CARDINALITY_CONSTRAINT CARDINALITY_CONSTRAINT_OP 0 "a fixed upper bound on the cardinality of an uninterpreted sort"
-typerule CARDINALITY_CONSTRAINT_OP ::cvc5::theory::uf::CardinalityConstraintOpTypeRule
-typerule CARDINALITY_CONSTRAINT ::cvc5::theory::uf::CardinalityConstraintTypeRule
+typerule CARDINALITY_CONSTRAINT_OP ::cvc5::internal::theory::uf::CardinalityConstraintOpTypeRule
+typerule CARDINALITY_CONSTRAINT ::cvc5::internal::theory::uf::CardinalityConstraintTypeRule
constant COMBINED_CARDINALITY_CONSTRAINT_OP \
class \
CombinedCardinalityConstraint \
- ::cvc5::CombinedCardinalityConstraintHashFunction \
+ ::cvc5::internal::CombinedCardinalityConstraintHashFunction \
"expr/cardinality_constraint.h" \
- "the empty set constant; payload is an instance of the cvc5::CombinedCardinalityConstraint class"
+ "the empty set constant; payload is an instance of the cvc5::internal::CombinedCardinalityConstraint class"
parameterized COMBINED_CARDINALITY_CONSTRAINT COMBINED_CARDINALITY_CONSTRAINT_OP 0 "a fixed upper bound on the sum of cardinalities of uninterpreted sorts"
-typerule COMBINED_CARDINALITY_CONSTRAINT_OP ::cvc5::theory::uf::CombinedCardinalityConstraintOpTypeRule
-typerule COMBINED_CARDINALITY_CONSTRAINT ::cvc5::theory::uf::CombinedCardinalityConstraintTypeRule
+typerule COMBINED_CARDINALITY_CONSTRAINT_OP ::cvc5::internal::theory::uf::CombinedCardinalityConstraintOpTypeRule
+typerule COMBINED_CARDINALITY_CONSTRAINT ::cvc5::internal::theory::uf::CombinedCardinalityConstraintTypeRule
endtheory
#include "options/uf_options.h"
#include "smt/env.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/env_obj.h"
#include "theory/skolem_lemma.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__UF__LAMBDA_LIFT_H */
#include "theory/uf/theory_uf_rewriter.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/proof_checker.h"
#include "proof/proof_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__UF__PROOF_CHECKER_H */
#include "theory/uf/equality_engine.h"
#include "theory/uf/proof_checker.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace eq {
} // namespace eq
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/lazy_proof.h"
#include "smt/env_obj.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Env;
class ProofNode;
} // namespace eq
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__STRINGS__PROOF_MANAGER_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
-using namespace ::cvc5::context;
+using namespace ::cvc5::internal::context;
SymmetryBreaker::Template::Template() :
d_template(),
return out;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/smt_statistics_registry.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
std::ostream& operator<<(
std::ostream& out,
- const ::cvc5::theory::uf::SymmetryBreaker::Permutation& p);
+ const ::cvc5::internal::theory::uf::SymmetryBreaker::Permutation& p);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__UF__SYMMETRY_BREAKER_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/uf/symmetry_breaker.h"
#include "theory/uf/theory_uf_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__UF__THEORY_UF_H */
#include "theory/rewriter.h"
#include "theory/theory_model.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
class TheoryModel;
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/substitutions.h"
#include "theory/uf/function_const.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/substitutions.h"
#include "theory/theory_rewriter.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__UF__THEORY_UF_REWRITER_H */
#include "util/cardinality.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "expr/type_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__UF__THEORY_UF_TYPE_RULES_H */
#include "theory/uf/function_const.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/type_enumerator.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
namespace uf {
} // namespace uf
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__UF__TYPE_ENUMERATOR_H */
#include "theory/theory_engine.h"
#include "theory/theory_model.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace theory {
std::ostream& operator<<(std::ostream& os, EqualityStatus s)
}
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node.h"
#include "options/theory_options.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TheoryEngine;
};/* class Valuation */
} // namespace theory
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__THEORY__VALUATION_H */
#include "base/check.h"
#include "base/exception.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* BinaryHeap that orders its elements greatest-first (i.e., in the opposite
template <class Elem, class CmpFcn>
const size_t BinaryHeap<Elem,CmpFcn>::MAX_SIZE = (std::numeric_limits<size_t>::max()-2)/2;
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__BIN_HEAP_H */
#include "base/exception.h"
-namespace cvc5 {
+namespace cvc5::internal {
unsigned BitVector::getSize() const { return d_size; }
return ~BitVector::mkMinSigned(size);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/exception.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
class BitVector
{
return os << "[" << bv.d_size << "]";
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__BITVECTOR_H */
#ifndef CVC5__BOOL_H
#define CVC5__BOOL_H
-namespace cvc5 {
+namespace cvc5::internal {
struct BoolHashFunction {
inline size_t operator()(bool b) const {
}
};/* struct BoolHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__BOOL_H */
#include "base/check.h"
#include "base/exception.h"
-namespace cvc5 {
+namespace cvc5::internal {
const Integer Cardinality::s_unknownCard(0);
const Integer Cardinality::s_intCard(-1);
return out;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Representation for a Beth number, used only to construct
/** Print a cardinality in a human-readable fashion. */
std::ostream& operator<<(std::ostream& out, const Cardinality& c);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__CARDINALITY_H */
#include <iostream>
-namespace cvc5 {
+namespace cvc5::internal {
const char* toString(CardinalityClass c)
{
return false;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Cardinality classes. A type has exactly one cardinality class. The
*/
bool isCardinalityClassFinite(CardinalityClass c, bool fmfEnabled);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "base/check.h"
#include "util/index.h"
-namespace cvc5 {
+namespace cvc5::internal {
template <class T>
class DenseMap {
void pop_back() { d_map.pop_back(); }
}; /* class DenseMultiset */
-} // namespace cvc5
+} // namespace cvc5::internal
#include <string>
#include <vector>
-namespace cvc5 {
+namespace cvc5::internal {
namespace {
return oss.str();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <string>
#include <vector>
-namespace cvc5 {
+namespace cvc5::internal {
class CVC5_EXPORT DidYouMean {
public:
std::vector<std::string> d_words;
};
-} // namespace cvc5
+} // namespace cvc5::internal
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
Divisible::Divisible(const Integer& n) : k(n) {
PrettyCheckArgument(n > 0, n, "Divisible predicate must be constructed over positive N");
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* The structure representing the divisibility-by-k predicate.
return os << "divisible-by-" << d.k;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__DIVISIBLE_H */
/* -------------------------------------------------------------------------- */
-namespace cvc5 {
+namespace cvc5::internal {
/* -------------------------------------------------------------------------- */
return os << "(_ to_fp " << fpcs.getSize().exponentWidth() << " "
<< fpcs.getSize().significandWidth() << ")";
}
-} // namespace cvc5
+} // namespace cvc5::internal
/* -------------------------------------------------------------------------- */
-namespace cvc5 {
+namespace cvc5::internal {
/* -------------------------------------------------------------------------- */
{
inline size_t operator()(const FloatingPointToBV& fptbv) const
{
- UnsignedHashFunction< ::cvc5::BitVectorSize> f;
+ UnsignedHashFunction< ::cvc5::internal::BitVectorSize> f;
return (key ^ 0x46504256) ^ f(fptbv.d_bv_size);
}
}; /* struct FloatingPointToBVHashFunction */
std::ostream& operator<<(std::ostream& os,
const FloatingPointConvertSort& fpcs);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__FLOATINGPOINT_H */
#define CVC5_LIT_ITE_DFN(T) \
template <> \
- struct ite<::cvc5::symfpuLiteral::Cvc5Prop, T> \
+ struct ite<::cvc5::internal::symfpuLiteral::Cvc5Prop, T> \
{ \
- static const T& iteOp(const ::cvc5::symfpuLiteral::Cvc5Prop& cond, \
+ static const T& iteOp(const ::cvc5::internal::symfpuLiteral::Cvc5Prop& cond, \
const T& l, \
const T& r) \
{ \
} \
}
-CVC5_LIT_ITE_DFN(::cvc5::symfpuLiteral::traits::rm);
-CVC5_LIT_ITE_DFN(::cvc5::symfpuLiteral::traits::prop);
-CVC5_LIT_ITE_DFN(::cvc5::symfpuLiteral::traits::sbv);
-CVC5_LIT_ITE_DFN(::cvc5::symfpuLiteral::traits::ubv);
+CVC5_LIT_ITE_DFN(::cvc5::internal::symfpuLiteral::traits::rm);
+CVC5_LIT_ITE_DFN(::cvc5::internal::symfpuLiteral::traits::prop);
+CVC5_LIT_ITE_DFN(::cvc5::internal::symfpuLiteral::traits::sbv);
+CVC5_LIT_ITE_DFN(::cvc5::internal::symfpuLiteral::traits::ubv);
#undef CVC5_LIT_ITE_DFN
} // namespace symfpu
/* -------------------------------------------------------------------------- */
-namespace cvc5 {
+namespace cvc5::internal {
uint32_t FloatingPointLiteral::getUnpackedExponentWidth(FloatingPointSize& size)
{
d_fp_size, rm, d_symuf, width, undefinedCase);
}
-} // namespace cvc5
+} // namespace cvc5::internal
/* -------------------------------------------------------------------------- */
-namespace cvc5 {
+namespace cvc5::internal {
using SymFPUUnpackedFloatLiteral =
::symfpu::unpackedFloat<symfpuLiteral::traits>;
/* -------------------------------------------------------------------------- */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "base/check.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace symfpuLiteral {
template <bool isSigned>
return;
}
} // namespace symfpuLiteral
-} // namespace cvc5
+} // namespace cvc5::internal
/* -------------------------------------------------------------------------- */
-namespace cvc5 {
+namespace cvc5::internal {
namespace symfpuLiteral {
/**
using Cvc5BitWidth = uint32_t;
using Cvc5Prop = bool;
-using Cvc5RM = ::cvc5::RoundingMode;
-using Cvc5FPSize = ::cvc5::FloatingPointSize;
+using Cvc5RM = ::cvc5::internal::RoundingMode;
+using Cvc5FPSize = ::cvc5::internal::FloatingPointSize;
using Cvc5UnsignedBitVector = wrappedBitVector<false>;
using Cvc5SignedBitVector = wrappedBitVector<true>;
};
/**
- * This extends the interface for cvc5::BitVector for compatibility with symFPU.
+ * This extends the interface for cvc5::internal::BitVector for compatibility with symFPU.
* The template parameter distinguishes signed and unsigned bit-vectors, a
* distinction symfpu uses.
*/
/**
* Inherited but ...
* *sigh* if we use the inherited version then it will return a
- * cvc5::BitVector which can be converted back to a
+ * cvc5::internal::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
Cvc5BitWidth lower) const;
};
} // namespace symfpuLiteral
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "base/check.h"
-namespace cvc5 {
+namespace cvc5::internal {
FloatingPointSize::FloatingPointSize(uint32_t exp_size, uint32_t sig_size)
: d_exp_size(exp_size), d_sig_size(sig_size)
Assert(validSignificandSize(d_sig_size));
}
-} // namespace cvc5
+} // namespace cvc5::internal
#ifndef CVC5__FLOATINGPOINT_SIZE_H
#define CVC5__FLOATINGPOINT_SIZE_H
-namespace cvc5 {
+namespace cvc5::internal {
// Inline these!
inline bool validExponentSize(uint32_t e) { return e >= 2; }
| t.significandWidth());
}
}; /* struct FloatingPointSizeHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <gmpxx.h>
-namespace cvc5 {
+namespace cvc5::internal {
/** Hashes the gmp integer primitive in a word by word fashion. */
inline size_t gmpz_hash(const mpz_t toHash) {
return hash;
}/* gmpz_hash() */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__GMP_UTIL_H */
}/* std namespace */
-namespace cvc5 {
+namespace cvc5::internal {
namespace fnv1a {
}
};/* struct PairHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__HASH_H */
#include "base/exception.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
struct IntAnd
{
return os << "(_ iand " << ia.d_size << ")";
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__IAND_H */
#include <limits>
-namespace cvc5 {
+namespace cvc5::internal {
static_assert(sizeof(Index) <= sizeof(size_t),
"Index cannot be larger than size_t");
* (Limited testing suggests a ~1/16 of running time.) Interestingly,
* uint_fast32_t also has a sizeof == 8 on x86_64.
*/
-} // namespace cvc5
+} // namespace cvc5::internal
#ifndef CVC5__INDEX_H
#define CVC5__INDEX_H
-namespace cvc5 {
+namespace cvc5::internal {
/** Index is a standardized unsigned integer used for efficient indexing. */
using Index = uint32_t;
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__INDEX_H */
#ifndef CVC5__UTIL__INDEXED_ROOT_PREDICATE_H
#define CVC5__UTIL__INDEXED_ROOT_PREDICATE_H
-namespace cvc5 {
+namespace cvc5::internal {
/**
* The structure representing the index of a root predicate.
}
}; /* struct IndexedRootPredicateHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
signed int Integer::s_fastSignedIntMin = -(1 << 29);
signed int Integer::s_fastSignedIntMax = (1 << 29) - 1;
{
return os << n.toString();
}
-} // namespace cvc5
+} // namespace cvc5::internal
struct cl_read_flags;
}
-namespace cvc5 {
+namespace cvc5::internal {
class Rational;
class CVC5_EXPORT Integer
{
- friend class cvc5::Rational;
+ friend class cvc5::internal::Rational;
public:
/**
struct IntegerHashFunction
{
- size_t operator()(const cvc5::Integer& i) const { return i.hash(); }
+ size_t operator()(const cvc5::internal::Integer& i) const { return i.hash(); }
}; /* struct IntegerHashFunction */
std::ostream& operator<<(std::ostream& os, const Integer& n);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__INTEGER_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
Integer::Integer(const char* s, unsigned base)
: d_value(s, base)
return (a >= b) ? a : b;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "cvc5_export.h" // remove when Cvc language support is removed
-namespace cvc5 {
+namespace cvc5::internal {
class Rational;
class CVC5_EXPORT Integer
{
- friend class cvc5::Rational;
+ friend class cvc5::internal::Rational;
public:
/**
struct IntegerHashFunction
{
- inline size_t operator()(const cvc5::Integer& i) const { return i.hash(); }
+ inline size_t operator()(const cvc5::internal::Integer& i) const { return i.hash(); }
}; /* struct IntegerHashFunction */
inline std::ostream& operator<<(std::ostream& os, const Integer& n)
return os << n.toString();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__INTEGER_H */
#include <ostream>
-namespace cvc5 {
+namespace cvc5::internal {
StreamFormatScope::StreamFormatScope(std::ostream& out)
: d_out(out), d_format_flags(out.flags()), d_precision(out.precision())
d_out.flags(d_format_flags);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <ios>
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
// Saves the formatting of an ostream and restores the previous settings on
// destruction. Example usage:
std::streamsize d_precision;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__UTIL__OSTREAM_UTIL_H */
#include "util/rational.h"
#include "util/real_algebraic_number.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace poly_utils {
namespace {
}
} // namespace poly_utils
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <poly/polyxx.h>
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Utilities for working with libpoly.
* This namespace contains various basic conversion routines necessary for the
*/
namespace poly_utils {
-/** Converts a poly::Integer to a cvc5::Integer. */
+/** Converts a poly::Integer to a cvc5::internal::Integer. */
Integer toInteger(const poly::Integer& i);
-/** Converts a poly::Integer to a cvc5::Rational. */
+/** Converts a poly::Integer to a cvc5::internal::Rational. */
Rational toRational(const poly::Integer& r);
-/** Converts a poly::Rational to a cvc5::Rational. */
+/** Converts a poly::Rational to a cvc5::internal::Rational. */
Rational toRational(const poly::Rational& r);
-/** Converts a poly::DyadicRational to a cvc5::Rational. */
+/** Converts a poly::DyadicRational to a cvc5::internal::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::internal::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::internal::Rational (that may be a bit below). */
Rational toRationalBelow(const poly::Value& v);
-/** Converts a cvc5::Integer to a poly::Integer. */
+/** Converts a cvc5::internal::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::internal::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::internal::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::internal::Rational to a poly::DyadicRational. If the input is not
* dyadic, no result is produced.
*/
std::optional<poly::DyadicRational> toDyadicRational(const Rational& r);
/**
* Constructs a poly::AlgebraicNumber, allowing for refinement of the
- * cvc5::Rational bounds. As a poly::AlgebraicNumber works on
+ * cvc5::internal::Rational bounds. As a poly::AlgebraicNumber works on
* poly::DyadicRationals internally, the bounds are iteratively refined using
* approximateToDyadic until the respective interval is isolating. If the
* provided rational bounds are already dyadic, the refinement is skipped.
const Rational& upper);
/**
- * Constructs a cvc5::RealAlgebraicNumber, simply wrapping
+ * Constructs a cvc5::internal::RealAlgebraicNumber, simply wrapping
* toPolyRanWithRefinement.
*/
RealAlgebraicNumber toRanWithRefinement(poly::UPolynomial&& p,
const poly::Polynomial& poly);
} // namespace poly_utils
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include <cfloat>
#include "base/check.h"
-namespace cvc5 {
+namespace cvc5::internal {
Random::Random(uint64_t seed) { setSeed(seed); }
return r < p;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#ifndef CVC5__UTIL__RANDOM_H
#define CVC5__UTIL__RANDOM_H
-namespace cvc5 {
+namespace cvc5::internal {
class Random
{
uint64_t d_state;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
/* Computes a rational given a decimal string. The rational
* version of <code>xxx.yyy</code> is <code>xxxyyy/(10^3)</code>.
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "cvc5_export.h" // remove when Cvc language support is removed
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A multi-precision rational constant.
struct RationalHashFunction
{
- inline size_t operator()(const cvc5::Rational& r) const { return r.hash(); }
+ inline size_t operator()(const cvc5::internal::Rational& r) const { return r.hash(); }
}; /* struct RationalHashFunction */
std::ostream& operator<<(std::ostream& os, const Rational& n) CVC5_EXPORT;
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__RATIONAL_H */
#include "base/check.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& os, const Rational& q){
return os << q.toString();
return std::optional<Rational>();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/gmp_util.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A multi-precision rational constant.
struct RationalHashFunction
{
- inline size_t operator()(const cvc5::Rational& r) const { return r.hash(); }
+ inline size_t operator()(const cvc5::internal::Rational& r) const { return r.hash(); }
}; /* struct RationalHashFunction */
std::ostream& operator<<(std::ostream& os, const Rational& n) CVC5_EXPORT;
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__RATIONAL_H */
#define RAN_UNREACHABLE \
Unreachable() << "RealAlgebraicNumber is not available without libpoly."
-namespace cvc5 {
+namespace cvc5::internal {
#ifdef CVC5_POLY_IMP
RealAlgebraicNumber::RealAlgebraicNumber(poly::AlgebraicNumber&& an)
#endif
}
-} // namespace cvc5
+} // namespace cvc5::internal
namespace std {
-size_t hash<cvc5::RealAlgebraicNumber>::operator()(
- const cvc5::RealAlgebraicNumber& ran) const
+size_t hash<cvc5::internal::RealAlgebraicNumber>::operator()(
+ const cvc5::internal::RealAlgebraicNumber& ran) const
{
#ifdef CVC5_POLY_IMP
return lp_algebraic_number_hash_approx(ran.getValue().get_internal(), 2);
#include "util/integer.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Represents a real algebraic number based on poly::AlgebraicNumber.
using RealAlgebraicNumberHashFunction = std::hash<RealAlgebraicNumber>;
-} // namespace cvc5
+} // namespace cvc5::internal
namespace std {
template <>
-struct hash<cvc5::RealAlgebraicNumber>
+struct hash<cvc5::internal::RealAlgebraicNumber>
{
/**
* Computes a hash of the given real algebraic number. Given that the internal
* interval may be refined for comparisons) we hash a well-defined rational
* approximation.
*/
- size_t operator()(const cvc5::RealAlgebraicNumber& ran) const;
+ size_t operator()(const cvc5::internal::RealAlgebraicNumber& ran) const;
};
} // namespace std
#include <ostream>
-namespace cvc5 {
+namespace cvc5::internal {
RegExpRepeat::RegExpRepeat(uint32_t repeatAmount) : d_repeatAmount(repeatAmount)
{
return os << "[" << r.d_loopMinOcc << ".." << r.d_loopMaxOcc << "]";
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
struct RegExpRepeat
{
std::ostream& operator<<(std::ostream& os, const RegExpLoop& bv);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__UTIL__REGEXP_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
bool WallClockTimer::on() const
{
return d_listeners.push_back(listener);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/inference_id.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Listener;
class Options;
std::unique_ptr<Statistics> d_statistics;
}; /* class ResourceManager */
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__RESOURCE_MANAGER_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
Result::Result()
: d_status(NONE), d_unknownExplanation(UNKNOWN_REASON), d_inputName("")
out << " for " << getInputName();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "options/language.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Result;
std::ostream& operator<<(std::ostream& out, enum Result::Status s);
std::ostream& operator<<(std::ostream& out, enum Result::UnknownExplanation e);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__RESULT_H */
#include "base/check.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& os, RoundingMode rm)
{
return os;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <iosfwd>
-namespace cvc5 {
+namespace cvc5::internal {
#define CVC5_NUM_ROUNDING_MODES 5
std::ostream& operator<<(std::ostream& os, RoundingMode s);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
/* Size of buffers used */
#define BUFFER_SIZE 20
-namespace cvc5 {
+namespace cvc5::internal {
template <>
void safe_print(int fd, const std::string& msg) {
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "cvc5_export.h"
-namespace cvc5 {
+namespace cvc5::internal {
template <size_t N>
void CVC5_EXPORT safe_print(int fd, const char (&msg)[N]);
*/
void safe_print_right_aligned(int fd, uint64_t i, ssize_t width);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SAFE_PRINT_H */
#include "util/bitvector.h"
#include "util/random.h"
-namespace cvc5 {
+namespace cvc5::internal {
BitVector Sampler::pickBvUniform(unsigned sz)
{
return FloatingPoint(e, s, bv);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/floatingpoint.h"
-namespace cvc5 {
+namespace cvc5::internal {
class Sampler
{
static constexpr double probSpecial = 0.2;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__UTIL_FLOATINGPOINT_SAMPLER_H */
#include "util/rational.h"
#include "util/statistics_value.h"
-namespace cvc5 {
+namespace cvc5::internal {
void toSExpr(std::ostream& out, const std::string& s)
{
out << *sbv;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <utility>
#include <vector>
-namespace cvc5 {
+namespace cvc5::internal {
// Forward declarations
struct StatisticBaseValue;
return ss.str();
}
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__SEXPR_H */
#include <sstream>
#include <string>
-namespace cvc5 {
+namespace cvc5::internal {
/**
* SMT-LIB 2 quoting for symbols
return '"' + output + '"';
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <string>
-namespace cvc5 {
+namespace cvc5::internal {
/**
* SMT-LIB 2 quoting for symbols
*/
std::string quoteString(const std::string& s);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__UTIL__SMT2_QUOTE_STRING_H */
#include "theory/theory_id.h"
#include "util/statistics_registry.h"
-namespace cvc5 {
+namespace cvc5::internal {
void registerPublicStatistics(StatisticsRegistry& reg)
{
- reg.registerHistogram<TypeConstant>("api::CONSTANT", false);
- reg.registerHistogram<TypeConstant>("api::VARIABLE", false);
- reg.registerHistogram<api::Kind>("api::TERM", false);
+ reg.registerHistogram<TypeConstant>("cvc5::CONSTANT", false);
+ reg.registerHistogram<TypeConstant>("cvc5::VARIABLE", false);
+ reg.registerHistogram<cvc5::Kind>("cvc5::TERM", false);
reg.registerValue<std::string>("driver::filename", false);
reg.registerTimer("global::totalTime", false);
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#ifndef CVC5__UTIL__STATISTICS_PUBLIC_H
#define CVC5__UTIL__STATISTICS_PUBLIC_H
-namespace cvc5 {
+namespace cvc5::internal {
class StatisticsRegistry;
*/
void registerPublicStatistics(StatisticsRegistry& reg);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "options/base_options.h"
#include "util/statistics_public.h"
-namespace cvc5 {
+namespace cvc5::internal {
StatisticsRegistry::StatisticsRegistry(Env& env, bool registerPublic)
: EnvObj(env)
return os;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/statistics_stats.h"
#include "util/statistics_value.h"
-namespace cvc5 {
+namespace cvc5::internal {
struct StatisticBaseValue;
/** Calls `sr.print(os)`. */
std::ostream& operator<<(std::ostream& os, const StatisticsRegistry& sr);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__STATISTICS_REGISTRY_H */
#include "base/check.h"
#include "util/statistics_value.h"
-namespace cvc5 {
+namespace cvc5::internal {
AverageStat& AverageStat::operator<<(double v)
{
}
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/configuration.h"
-namespace cvc5 {
+namespace cvc5::internal {
// forward declare all values to avoid inclusion
struct StatisticAverageValue;
* `ReferenceStat` the current value of the referenced object is copied into
* the `StatisticsRegistry`.
*
- * To convert to the API representation in `api::Stat`, `T` can only be one
- * of the types accepted by the `api::Stat` constructors (or be implicitly
+ * To convert to the API representation in `cvc5::Stat`, `T` can only be one
+ * of the types accepted by the `cvc5::Stat` constructors (or be implicitly
* converted to one of them).
*/
template <typename T>
{
public:
/** Utility for RAII-style timing of code blocks */
- using CodeTimer = cvc5::CodeTimer;
+ using CodeTimer = cvc5::internal::CodeTimer;
/** Allow access to private constructor */
friend class StatisticsRegistry;
/** Value stored for this statistic */
* Stores a simple value that can be set manually using regular assignment
* or the `set` method.
*
- * To convert to the API representation in `api::Stat`, `T` can only be one
- * of the types accepted by the `api::Stat` constructors (or be implicitly
+ * To convert to the API representation in `cvc5::Stat`, `T` can only be one
+ * of the types accepted by the `cvc5::Stat` constructors (or be implicitly
* converted to one of them).
*/
template <typename T>
IntStat(stat_type* data) : ValueStat(data) {}
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "util/ostream_util.h"
-namespace cvc5 {
+namespace cvc5::internal {
// standard helper, see https://en.cppreference.com/w/cpp/utility/variant/visit
template <class... Ts>
return static_cast<int64_t>(data / std::chrono::milliseconds(1));
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/safe_print.h"
-namespace cvc5 {
+namespace cvc5::internal {
class StatisticsRegistry;
bool d_running;
};
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
static_assert(UCHAR_MAX == 255, "Unsigned char is assumed to have 256 values.");
std::stringstream serr;
serr << "Illegal string character: \"" << ch
<< "\", must use escape sequence";
- throw cvc5::Exception(serr.str());
+ throw cvc5::internal::Exception(serr.str());
}
else
{
namespace strings {
-size_t StringHashFunction::operator()(const ::cvc5::String& s) const
+size_t StringHashFunction::operator()(const ::cvc5::internal::String& s) const
{
uint64_t ret = fnv1a::offsetBasis;
for (unsigned c : s.d_str)
return os << "\"" << s.toString() << "\"";
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace strings {
struct StringHashFunction;
static inline unsigned num_codes() { return 196608; }
/** constructors for String
*
- * Internally, a cvc5::String is represented by a vector of unsigned
+ * Internally, a cvc5::internal::String is represented by a vector of unsigned
* integers (d_str) representing the code points of the characters.
*
* To build a string from a C++ string, we may process escape sequences
* where d_0 ... d_4 are hexadecimal digits, to the appropriate character.
*
* If useEscSequences is false, then the characters of the constructed
- * cvc5::String correspond one-to-one with the input string.
+ * cvc5::internal::String correspond one-to-one with the input string.
*/
String() = default;
explicit String(const std::string& s, bool useEscSequences = false)
* If useEscSequences is false, the string's printable characters are
* printed as characters. Notice that for all std::string s having only
* printable characters, we have that
- * cvc5::String( s ).toString() = s.
+ * cvc5::internal::String( s ).toString() = s.
*/
std::string toString(bool useEscSequences = false) const;
/* toWString
struct StringHashFunction
{
- size_t operator()(const ::cvc5::String& s) const;
+ size_t operator()(const ::cvc5::internal::String& s) const;
}; /* struct StringHashFunction */
} // namespace strings
std::ostream& operator<<(std::ostream& os, const String& s);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__UTIL__STRING_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
SynthResult::SynthResult()
: d_status(NONE), d_unknownExplanation(Result::UNKNOWN_REASON)
return out;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/result.h"
-namespace cvc5 {
+namespace cvc5::internal {
/**
* A result for a synthesis query. This can be used for synthesis, abduction,
std::ostream& operator<<(std::ostream& out, const SynthResult& r);
std::ostream& operator<<(std::ostream& out, SynthResult::Status s);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__RESULT_H */
using namespace std;
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& out, const UninterpretedSortValue& val)
{
|| (getType() == val.getType() && d_index <= val.d_index);
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
class TypeNode;
}
}; /* struct UninterpretedSortValueHashFunction */
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/check.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::unique_ptr<std::fstream> openTmpFile(std::string* pattern)
{
return tmpStream;
}
-} // namespace cvc5
+} // namespace cvc5::internal
#include <optional>
#include <string>
-namespace cvc5 {
+namespace cvc5::internal {
/**
* Using std::find_if(), finds the first iterator in [first,last)
*/
std::unique_ptr<std::fstream> openTmpFile(std::string* pattern);
-} // namespace cvc5
+} // namespace cvc5::internal
#endif /* CVC5__UTILITY_H */
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
using namespace std;
int main() {
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
using namespace std;
int main()
#include "smt/command.h"
using namespace cvc5;
+using namespace cvc5::internal;
using namespace cvc5::parser;
-using namespace cvc5::language;
+using namespace cvc5::internal::language;
int runTest();
{
return runTest();
}
- catch (api::CVC5ApiException& e)
+ catch (cvc5::CVC5ApiException& e)
{
std::cerr << e.getMessage() << std::endl;
}
- catch (parser::ParserException& e)
+ catch (ParserException& e)
{
std::cerr << e.getMessage() << std::endl;
}
(declare-fun a () (Array U (Array U U)))\n\
";
- api::Solver solver;
- std::string ilang = "LANG_SMTLIB_V2_6";
+ cvc5::Solver solver;
+ std::string ilang = "LANG_SMTLIB_V2_6";
- solver.setOption("input-language", input_language);
- solver.setOption("output-language", output_language);
- SymbolManager symman(&solver);
- std::unique_ptr<Parser> parser(
- ParserBuilder(&solver, &symman, false)
- .withInputLanguage(solver.getOption("input-language"))
- .build());
- parser->setInput(
- Input::newStringInput(ilang, declarations, "internal-buffer"));
- // we don't need to execute the commands, but we DO need to parse them to
- // get the declarations
- while (Command* c = parser->nextCommand())
- {
- delete c;
- }
+ solver.setOption("input-language", input_language);
+ solver.setOption("output-language", output_language);
+ SymbolManager symman(&solver);
+
std::unique_ptr<Parser> parser(
+ ParserBuilder(&solver, &symman, false)
+ .withInputLanguage(solver.getOption("input-language"))
+ .build());
+ parser->setInput(
+ Input::newStringInput(ilang, declarations, "internal-buffer"));
+ // we don't need to execute the commands, but we DO need to parse them to
+ // get the declarations
+ while (Command* c = parser->nextCommand())
+ {
+ delete c;
+ }
assert(parser->done()); // parser should be done
parser->setInput(Input::newStringInput(ilang, instr, "internal-buffer"));
- api::Term e = parser->nextExpression();
+ cvc5::Term e = parser->nextExpression();
std::string s = e.toString();
assert(parser->nextExpression().isNull()); // next expr should be null
return s;
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main(void)
{
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main(void)
{
#include "api/cpp/cvc5.h"
#include <cassert>
-using namespace cvc5::api;
+using namespace cvc5;
int main(void)
{
#include "api/cpp/cvc5.h"
#include <cassert>
-using namespace cvc5::api;
+using namespace cvc5;
int main(void)
{
#include "api/cpp/cvc5.h"
#include <cassert>
-using namespace cvc5::api;
+using namespace cvc5;
int main(void)
{
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main(void)
{
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main(void)
{
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main(void)
{
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main(void)
{
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
int main()
{
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
using namespace std;
/**
#include "smt/solver_engine.h"
using namespace cvc5;
+using namespace cvc5::internal;
using namespace cvc5::parser;
using namespace std;
-void testGetInfo(api::Solver* solver, const char* s);
+void testGetInfo(cvc5::Solver* solver, const char* s);
int main()
{
- std::unique_ptr<api::Solver> solver = std::make_unique<api::Solver>();
+ std::unique_ptr<cvc5::Solver> solver = std::make_unique<cvc5::Solver>();
solver->setOption("input-language", "smtlib2");
solver->setOption("output-language", "smtlib2");
testGetInfo(solver.get(), ":error-behavior");
return 0;
}
-void testGetInfo(api::Solver* solver, const char* s)
+void testGetInfo(cvc5::Solver* solver, const char* s)
{
std::unique_ptr<SymbolManager> symman(new SymbolManager(solver));
#include "api/cpp/cvc5.h"
-using namespace cvc5::api;
+using namespace cvc5;
using namespace std;
int main() {
#include "api/cpp/cvc5.h"
#include "base/output.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
}
} // namespace test
-} // namespace cvc5
-
+} // namespace cvc5::internal
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
ASSERT_THROW(nilc.getInstantiatedConstructorTerm(isort), CVC5ApiException);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
ASSERT_THROW(g1.addAnyVariable(start), CVC5ApiException);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
ASSERT_EQ(bitvector_repeat_ot.toString(), op_repr);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
ASSERT_EQ(plus, d_solver.mkOp(ADD));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_api.h"
#include "base/configuration.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
TEST_F(TestApiBlackResult, isNull)
{
- cvc5::api::Result res_null;
+ cvc5::Result res_null;
ASSERT_TRUE(res_null.isNull());
ASSERT_FALSE(res_null.isSat());
ASSERT_FALSE(res_null.isUnsat());
Sort u_sort = d_solver.mkUninterpretedSort("u");
Term x = d_solver.mkConst(u_sort, "x");
d_solver.assertFormula(x.eqTerm(x));
- cvc5::api::Result res = d_solver.checkSat();
+ cvc5::Result res = d_solver.checkSat();
ASSERT_FALSE(res.isNull());
}
Sort u_sort = d_solver.mkUninterpretedSort("u");
Term x = d_solver.mkConst(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::Result res;
+ cvc5::Result res2 = d_solver.checkSat();
+ cvc5::Result res3 = d_solver.checkSat();
res = res2;
ASSERT_EQ(res, res2);
ASSERT_EQ(res3, res2);
Sort u_sort = d_solver.mkUninterpretedSort("u");
Term x = d_solver.mkConst(u_sort, "x");
d_solver.assertFormula(x.eqTerm(x));
- cvc5::api::Result res = d_solver.checkSat();
+ cvc5::Result res = d_solver.checkSat();
ASSERT_TRUE(res.isSat());
ASSERT_FALSE(res.isUnknown());
}
Sort u_sort = d_solver.mkUninterpretedSort("u");
Term x = d_solver.mkConst(u_sort, "x");
d_solver.assertFormula(x.eqTerm(x).notTerm());
- cvc5::api::Result res = d_solver.checkSat();
+ cvc5::Result res = d_solver.checkSat();
ASSERT_TRUE(res.isUnsat());
ASSERT_FALSE(res.isUnknown());
}
Sort int_sort = d_solver.getIntegerSort();
Term x = d_solver.mkConst(int_sort, "x");
d_solver.assertFormula(x.eqTerm(x).notTerm());
- cvc5::api::Result res = d_solver.checkSat();
+ cvc5::Result res = d_solver.checkSat();
ASSERT_FALSE(res.isSat());
ASSERT_TRUE(res.isUnknown());
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/output.h"
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
EXPECT_THROW(d_solver.getOptionInfo("asdf-invalid"), CVC5ApiException);
}
{
- api::OptionInfo info = d_solver.getOptionInfo("verbose");
+ cvc5::OptionInfo info = d_solver.getOptionInfo("verbose");
EXPECT_EQ("verbose", info.name);
EXPECT_EQ(std::vector<std::string>{}, info.aliases);
EXPECT_TRUE(std::holds_alternative<OptionInfo::VoidInfo>(info.valueInfo));
}
{
// bool type with default
- api::OptionInfo info = d_solver.getOptionInfo("print-success");
+ cvc5::OptionInfo info = d_solver.getOptionInfo("print-success");
EXPECT_EQ("print-success", info.name);
EXPECT_EQ(std::vector<std::string>{}, info.aliases);
EXPECT_TRUE(
}
{
// int64 type with default
- api::OptionInfo info = d_solver.getOptionInfo("verbosity");
+ cvc5::OptionInfo info = d_solver.getOptionInfo("verbosity");
EXPECT_EQ("verbosity", info.name);
EXPECT_EQ(std::vector<std::string>{}, info.aliases);
EXPECT_TRUE(std::holds_alternative<OptionInfo::NumberInfo<int64_t>>(
}
{
// uint64 type with default
- api::OptionInfo info = d_solver.getOptionInfo("rlimit");
+ cvc5::OptionInfo info = d_solver.getOptionInfo("rlimit");
EXPECT_EQ("rlimit", info.name);
EXPECT_EQ(std::vector<std::string>{}, info.aliases);
EXPECT_TRUE(std::holds_alternative<OptionInfo::NumberInfo<uint64_t>>(
auto info = d_solver.getOptionInfo("random-freq");
ASSERT_EQ(info.name, "random-freq");
ASSERT_EQ(info.aliases, std::vector<std::string>{"random-frequency"});
- ASSERT_TRUE(std::holds_alternative<api::OptionInfo::NumberInfo<double>>(
+ ASSERT_TRUE(std::holds_alternative<cvc5::OptionInfo::NumberInfo<double>>(
info.valueInfo));
- auto ni = std::get<api::OptionInfo::NumberInfo<double>>(info.valueInfo);
+ auto ni = std::get<cvc5::OptionInfo::NumberInfo<double>>(info.valueInfo);
ASSERT_EQ(ni.currentValue, 0.0);
ASSERT_EQ(ni.defaultValue, 0.0);
ASSERT_TRUE(ni.minimum && ni.maximum);
}
{
// string type with default
- api::OptionInfo info = d_solver.getOptionInfo("force-logic");
+ cvc5::OptionInfo info = d_solver.getOptionInfo("force-logic");
EXPECT_EQ("force-logic", info.name);
EXPECT_EQ(std::vector<std::string>{}, info.aliases);
EXPECT_TRUE(std::holds_alternative<OptionInfo::ValueInfo<std::string>>(
}
{
// mode option
- api::OptionInfo info = d_solver.getOptionInfo("simplification");
+ cvc5::OptionInfo info = d_solver.getOptionInfo("simplification");
EXPECT_EQ("simplification", info.name);
EXPECT_EQ(std::vector<std::string>{"simplification-mode"}, info.aliases);
EXPECT_TRUE(std::holds_alternative<OptionInfo::ModeInfo>(info.valueInfo));
Term t3 = d_solver.mkTerm(Kind::SELECT, {t2, t1});
d_solver.checkSat();
}
- cvc5::api::Statistics stats = d_solver.getStatistics();
+ cvc5::Statistics stats = d_solver.getStatistics();
{
std::stringstream ss;
ss << stats;
// check some basic utility methods
EXPECT_TRUE(!(it == stats.end()));
EXPECT_EQ(s.first, it->first);
- if (s.first == "api::CONSTANT")
+ if (s.first == "cvc5::CONSTANT")
{
EXPECT_FALSE(s.second.isInternal());
EXPECT_FALSE(s.second.isDefault());
{
d_solver.assertFormula(t);
}
- cvc5::api::Result res = d_solver.checkSat();
+ cvc5::Result res = d_solver.checkSat();
ASSERT_TRUE(res.isUnsat());
ASSERT_NO_THROW(d_solver.getProof());
}
solver->declareSepHeap(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::Kind::SEP_PTO, {p, x});
solver->assertFormula(heap);
Term nil = solver->mkSepNil(integer);
solver->assertFormula(nil.eqTerm(solver->mkReal(5)));
ASSERT_THROW(d_solver.getSynthSolution(f), CVC5ApiException);
- cvc5::api::SynthResult sr = d_solver.checkSynth();
+ cvc5::SynthResult sr = d_solver.checkSynth();
ASSERT_EQ(sr.hasSolution(), true);
ASSERT_NO_THROW(d_solver.getSynthSolution(f));
d_solver.setOption("incremental", "true");
Term f = d_solver.synthFun("f", {}, d_solver.getBooleanSort());
- cvc5::api::SynthResult sr = d_solver.checkSynth();
+ cvc5::SynthResult sr = d_solver.checkSynth();
ASSERT_EQ(sr.hasSolution(), true);
ASSERT_NO_THROW(d_solver.getSynthSolutions({f}));
sr = d_solver.checkSynthNext();
ASSERT_THROW(d_solver.isOutputOn("foo-invalid"), CVC5ApiException);
ASSERT_THROW(d_solver.getOutput("foo-invalid"), CVC5ApiException);
ASSERT_FALSE(d_solver.isOutputOn("inst"));
- ASSERT_EQ(cvc5::null_os.rdbuf(), d_solver.getOutput("inst").rdbuf());
+ ASSERT_EQ(null_os.rdbuf(), d_solver.getOutput("inst").rdbuf());
d_solver.setOption("output", "inst");
ASSERT_TRUE(d_solver.isOutputOn("inst"));
- ASSERT_NE(cvc5::null_os.rdbuf(), d_solver.getOutput("inst").rdbuf());
+ ASSERT_NE(null_os.rdbuf(), d_solver.getOutput("inst").rdbuf());
}
TEST_F(TestApiBlackSolver, issue7000)
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/configuration.h"
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
TEST_F(TestApiBlackSynthResult, isNull)
{
- cvc5::api::SynthResult res_null;
+ cvc5::SynthResult res_null;
ASSERT_TRUE(res_null.isNull());
ASSERT_FALSE(res_null.hasSolution());
ASSERT_FALSE(res_null.hasNoSolution());
Term f = d_solver.synthFun("f", {}, d_solver.getBooleanSort());
Term boolTerm = d_solver.mkTrue();
d_solver.addSygusConstraint(boolTerm);
- cvc5::api::SynthResult res = d_solver.checkSynth();
+ cvc5::SynthResult res = d_solver.checkSynth();
ASSERT_FALSE(res.isNull());
ASSERT_TRUE(res.hasSolution());
ASSERT_FALSE(res.hasNoSolution());
{
// note that we never return synth result for which hasNoSolution is true
// currently
- cvc5::api::SynthResult res_null;
+ cvc5::SynthResult res_null;
ASSERT_FALSE(res_null.hasNoSolution());
}
Term f = d_solver.synthFun("f", {}, d_solver.getBooleanSort());
Term boolTerm = d_solver.mkFalse();
d_solver.addSygusConstraint(boolTerm);
- cvc5::api::SynthResult res = d_solver.checkSynth();
+ cvc5::SynthResult res = d_solver.checkSynth();
// currently isUnknown, could also return hasNoSolution when support for
// infeasibility of sygus conjectures is added.
ASSERT_FALSE(res.isNull());
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
TEST_F(TestApiBlackTerm, toString) { ASSERT_NO_THROW(Term().toString()); }
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
ASSERT_EQ(tailTerm.getOp(), Op(&d_solver, APPLY_SELECTOR));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_api.h"
#include "base/configuration.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/configuration.h"
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
for (Statistics.ConstIterator it = stats.iterator(true, true); it.hasNext();)
{
Map.Entry<String, Stat> elem = it.next();
- if (elem.getKey() == "api::CONSTANT")
+ if (elem.getKey() == "cvc5::CONSTANT")
{
assertFalse(elem.getValue().isInternal());
assertFalse(elem.getValue().isDefault());
solver.assertFormula(f1)
solver.checkSat()
s = solver.getStatistics()
- assert s['api::TERM'] == {'defaulted': False, 'internal': False, 'value': {'GEQ': 3, 'OR': 1}}
+ assert s['cvc5::TERM'] == {'defaulted': False, 'internal': False, 'value': {'GEQ': 3, 'OR': 1}}
assert s.get(True, False) != {}
def test_set_info(solver):
#include "context/context.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
using context::CDHashMap;
using context::CDInsertHashMap;
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(ContainsKey(map, "key"));
+ ASSERT_FALSE(ContainsKey(map, "non key"));
ASSERT_EQ(FindOrNull(map, "non key"), nullptr);
if (std::string* found_value = FindOrNull(map, "other"))
TEST_F(TestBaseBlackMap, constant_map)
{
const std::map<std::string, std::string> map = default_map();
- ASSERT_TRUE(cvc5::ContainsKey(map, "key"));
- ASSERT_FALSE(cvc5::ContainsKey(map, "non key"));
+ ASSERT_TRUE(ContainsKey(map, "key"));
+ ASSERT_FALSE(ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
{
std::unordered_map<std::string, std::string> map(default_map().begin(),
default_map().end());
- ASSERT_TRUE(cvc5::ContainsKey(map, "key"));
- ASSERT_FALSE(cvc5::ContainsKey(map, "non key"));
+ ASSERT_TRUE(ContainsKey(map, "key"));
+ ASSERT_FALSE(ContainsKey(map, "non key"));
ASSERT_EQ(FindOrNull(map, "non key"), nullptr);
if (std::string* found_value = FindOrNull(map, "other"))
{
const std::unordered_map<std::string, std::string> map(default_map().begin(),
default_map().end());
- ASSERT_TRUE(cvc5::ContainsKey(map, "key"));
- ASSERT_FALSE(cvc5::ContainsKey(map, "non key"));
+ ASSERT_TRUE(ContainsKey(map, "key"));
+ ASSERT_FALSE(ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
TEST_F(TestBaseBlackMap, set)
{
std::set<std::string> set{"entry", "other"};
- ASSERT_TRUE(cvc5::ContainsKey(set, "entry"));
- ASSERT_FALSE(cvc5::ContainsKey(set, "non member"));
+ ASSERT_TRUE(ContainsKey(set, "entry"));
+ ASSERT_FALSE(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(ContainsKey(const_set, "entry"));
+ ASSERT_FALSE(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(ContainsKey(set, "entry"));
+ ASSERT_FALSE(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(ContainsKey(const_set, "entry"));
+ ASSERT_FALSE(ContainsKey(const_set, "non member"));
}
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(ContainsKey(map, "key"));
+ ASSERT_FALSE(ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
insert_all(default_map(), &store);
const auto& map = store;
- ASSERT_TRUE(cvc5::ContainsKey(map, "key"));
- ASSERT_FALSE(cvc5::ContainsKey(map, "non key"));
+ ASSERT_TRUE(ContainsKey(map, "key"));
+ ASSERT_FALSE(ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
CDInsertHashMap<std::string, std::string> map(&context);
insert_all(default_map(), &map);
- ASSERT_TRUE(cvc5::ContainsKey(map, "key"));
- ASSERT_FALSE(cvc5::ContainsKey(map, "non key"));
+ ASSERT_TRUE(ContainsKey(map, "key"));
+ ASSERT_FALSE(ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
insert_all(default_map(), &store);
const auto& map = store;
- ASSERT_TRUE(cvc5::ContainsKey(map, "key"));
- ASSERT_FALSE(cvc5::ContainsKey(map, "non key"));
+ ASSERT_TRUE(ContainsKey(map, "key"));
+ ASSERT_FALSE(ContainsKey(map, "non key"));
if (const std::string* found_value = FindOrNull(map, "other"))
{
ASSERT_EQ(*found_value, "entry");
ASSERT_EQ(FindOrDie(map, "other"), "entry");
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
* directory for licensing information.
* ****************************************************************************
*
- * Black box testing of cvc5::context::CDMap<>.
+ * Black box testing of context::CDMap<>.
*/
#include <map>
#include "context/cdlist.h"
#include "test_context.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
-using cvc5::context::CDHashMap;
-using cvc5::context::Context;
+using context::CDHashMap;
+using context::Context;
class TestContextBlackCDHashMap : public TestContext
{
ASSERT_TRUE(elements_are(map, {{3, 4}}));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
* directory for licensing information.
* ****************************************************************************
*
- * White box testing of cvc5::context::CDMap<>.
+ * White box testing of context::CDMap<>.
*/
#include "base/check.h"
#include "context/cdhashmap.h"
#include "test_context.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace context;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
* directory for licensing information.
* ****************************************************************************
*
- * Black box testing of cvc5::context::CDList<>.
+ * Black box testing of context::CDList<>.
*/
#include <limits.h>
#include "context/cdlist.h"
#include "test_context.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace context;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
* directory for licensing information.
* ****************************************************************************
*
- * Black box testing of cvc5::context::CDO<>.
+ * Black box testing of context::CDO<>.
*/
#include <iostream>
#include "context/cdo.h"
#include "test_context.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace context;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
* directory for licensing information.
* ****************************************************************************
*
- * Black box testing of cvc5::context::Context.
+ * Black box testing of context::Context.
*/
#include <iostream>
#include "context/cdo.h"
#include "test_context.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace context;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
* directory for licensing information.
* ****************************************************************************
*
- * Black box testing of cvc5::context::ContextMemoryManager.
+ * Black box testing of context::ContextMemoryManager.
*/
#include <cstring>
#include "context/context_mm.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace context;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
* directory for licensing information.
* ****************************************************************************
*
- * White box testing of cvc5::context::Context.
+ * White box testing of context::Context.
*/
#include "base/check.h"
#include "context/cdo.h"
#include "test_context.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace context;
ASSERT_EQ(c.d_ppContextObjPrev, &s->d_pContextObjList);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/command.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestMainBlackInteractiveShell : public TestInternal
d_sin = std::make_unique<std::stringstream>();
d_sout = std::make_unique<std::stringstream>();
- d_solver.reset(new cvc5::api::Solver());
+ d_solver.reset(new cvc5::Solver());
d_solver->setOption("input-language", "smt2");
d_symman.reset(new SymbolManager(d_solver.get()));
}
std::unique_ptr<std::stringstream> d_sin;
std::unique_ptr<std::stringstream> d_sout;
std::unique_ptr<SymbolManager> d_symman;
- std::unique_ptr<cvc5::api::Solver> d_solver;
+ std::unique_ptr<cvc5::Solver> d_solver;
};
TEST_F(TestMainBlackInteractiveShell, assert_true)
countCommands(shell, 0, 3);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_value.h"
#include "test_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace smt;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_engine.h"
#include "theory/uf/theory_uf.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace smt;
ASSERT_FALSE(unnamed.hasAttribute(VarNameAttr()));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/kind.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
ASSERT_EQ(act.str(), exp.str());
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/kind_map.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
-using namespace kind;
+using namespace internal;
+using namespace internal::kind;
namespace test {
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace expr;
using namespace kind;
ASSERT_EQ(subs[x], a);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_manager.h"
#include "test_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace expr;
using namespace kind;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/bitvector.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#define K 30u
#define LARGE_K UINT_MAX / 40
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
ASSERT_EQ(nexpected, n);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace expr;
#endif
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
-using namespace cvc5::expr;
-using namespace cvc5::kind;
+using namespace cvc5::internal::expr;
+using namespace cvc5::internal::kind;
namespace test {
}
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_self_iterator.h"
#include "test_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace expr;
ASSERT_EQ(++i, x_and_y.end());
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/node_value.h"
#include "test_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
ASSERT_EQ(actual, expected);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_node.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace expr;
ASSERT_EQ(v[2], y);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "expr/symbol_table.h"
#include "test_api.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace context;
TEST_F(TestNodeBlackSymbolTable, bind1)
{
SymbolTable symtab;
- api::Sort booleanType = d_solver.getBooleanSort();
- api::Term x = d_solver.mkConst(booleanType);
+ cvc5::Sort booleanType = d_solver.getBooleanSort();
+ cvc5::Term x = d_solver.mkConst(booleanType);
symtab.bind("x", x);
ASSERT_TRUE(symtab.isBound("x"));
ASSERT_EQ(symtab.lookup("x"), x);
TEST_F(TestNodeBlackSymbolTable, bind2)
{
SymbolTable symtab;
- api::Sort booleanType = d_solver.getBooleanSort();
+ cvc5::Sort booleanType = d_solver.getBooleanSort();
// var name attribute shouldn't matter
- api::Term y = d_solver.mkConst(booleanType, "y");
+ cvc5::Term y = d_solver.mkConst(booleanType, "y");
symtab.bind("x", y);
ASSERT_TRUE(symtab.isBound("x"));
ASSERT_EQ(symtab.lookup("x"), y);
TEST_F(TestNodeBlackSymbolTable, bind3)
{
SymbolTable symtab;
- api::Sort booleanType = d_solver.getBooleanSort();
- api::Term x = d_solver.mkConst(booleanType);
+ cvc5::Sort booleanType = d_solver.getBooleanSort();
+ cvc5::Term x = d_solver.mkConst(booleanType);
symtab.bind("x", x);
- api::Term y = d_solver.mkConst(booleanType);
+ cvc5::Term y = d_solver.mkConst(booleanType);
// new binding covers old
symtab.bind("x", y);
ASSERT_TRUE(symtab.isBound("x"));
TEST_F(TestNodeBlackSymbolTable, bind4)
{
SymbolTable symtab;
- api::Sort booleanType = d_solver.getBooleanSort();
- api::Term x = d_solver.mkConst(booleanType);
+ cvc5::Sort booleanType = d_solver.getBooleanSort();
+ cvc5::Term x = d_solver.mkConst(booleanType);
symtab.bind("x", x);
- api::Sort t = d_solver.mkUninterpretedSort("T");
+ cvc5::Sort t = d_solver.mkUninterpretedSort("T");
// duplicate binding for type is OK
symtab.bindType("x", t);
TEST_F(TestNodeBlackSymbolTable, bind_type1)
{
SymbolTable symtab;
- api::Sort s = d_solver.mkUninterpretedSort("S");
+ cvc5::Sort s = d_solver.mkUninterpretedSort("S");
symtab.bindType("S", s);
ASSERT_TRUE(symtab.isBoundType("S"));
ASSERT_EQ(symtab.lookupType("S"), s);
{
SymbolTable symtab;
// type name attribute shouldn't matter
- api::Sort s = d_solver.mkUninterpretedSort("S");
+ cvc5::Sort s = d_solver.mkUninterpretedSort("S");
symtab.bindType("T", s);
ASSERT_TRUE(symtab.isBoundType("T"));
ASSERT_EQ(symtab.lookupType("T"), s);
TEST_F(TestNodeBlackSymbolTable, bind_type3)
{
SymbolTable symtab;
- api::Sort s = d_solver.mkUninterpretedSort("S");
+ cvc5::Sort s = d_solver.mkUninterpretedSort("S");
symtab.bindType("S", s);
- api::Sort t = d_solver.mkUninterpretedSort("T");
+ cvc5::Sort t = d_solver.mkUninterpretedSort("T");
// new binding covers old
symtab.bindType("S", t);
ASSERT_TRUE(symtab.isBoundType("S"));
TEST_F(TestNodeBlackSymbolTable, push_scope)
{
SymbolTable symtab;
- api::Sort booleanType = d_solver.getBooleanSort();
- api::Term x = d_solver.mkConst(booleanType);
+ cvc5::Sort booleanType = d_solver.getBooleanSort();
+ cvc5::Term x = d_solver.mkConst(booleanType);
symtab.bind("x", x);
symtab.pushScope();
ASSERT_TRUE(symtab.isBound("x"));
ASSERT_EQ(symtab.lookup("x"), x);
- api::Term y = d_solver.mkConst(booleanType);
+ cvc5::Term y = d_solver.mkConst(booleanType);
symtab.bind("x", y);
ASSERT_TRUE(symtab.isBound("x"));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_node.h"
#include "util/cardinality.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_node.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace context;
ASSERT_TRUE(bvType.getBaseType() == bvType);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "options/options_public.h"
#include "test_api.h"
-namespace cvc5 {
-
-using namespace api;
+namespace cvc5::internal {
namespace test {
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/command.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace parser;
{
TestInternal::SetUp();
d_symman.reset(nullptr);
- d_solver.reset(new cvc5::api::Solver());
+ d_solver.reset(new cvc5::Solver());
d_solver->setOption("parse-only", "true");
}
parser.bindVar("b", d_solver.get()->getBooleanSort());
parser.bindVar("c", d_solver.get()->getBooleanSort());
/* t, u, v: TYPE */
- api::Sort t = parser.mkSort("t");
- api::Sort u = parser.mkSort("u");
- api::Sort v = parser.mkSort("v");
+ cvc5::Sort t = parser.mkSort("t");
+ cvc5::Sort u = parser.mkSort("u");
+ cvc5::Sort v = parser.mkSort("v");
/* f : t->u; g: u->v; h: v->t; */
parser.bindVar("f", d_solver.get()->mkFunctionSort(t, u));
parser.bindVar("g", d_solver.get()->mkFunctionSort(u, v));
ASSERT_FALSE(parser->done());
setupContext(*parser);
ASSERT_FALSE(parser->done());
- api::Term e = parser->nextExpression();
+ cvc5::Term e = parser->nextExpression();
ASSERT_FALSE(e.isNull());
e = parser->nextExpression();
ASSERT_TRUE(parser->done());
parser->setInput(Input::newStringInput(d_lang, badExpr, "test"));
setupContext(*parser);
ASSERT_FALSE(parser->done());
- ASSERT_THROW(api::Term e = parser->nextExpression();
+ ASSERT_THROW(cvc5::Term e = parser->nextExpression();
std::cout << std::endl
<< "Bad expr succeeded." << std::endl
<< "Input: <<" << badExpr << ">>" << std::endl
}
std::string d_lang;
- std::unique_ptr<cvc5::api::Solver> d_solver;
+ std::unique_ptr<cvc5::Solver> d_solver;
std::unique_ptr<SymbolManager> d_symman;
};
#endif
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt/command.h"
#include "test_api.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace parser;
void checkEmptyInput(Parser* parser)
{
- api::Term e = parser->nextExpression();
+ cvc5::Term e = parser->nextExpression();
ASSERT_TRUE(e.isNull());
}
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/rewriter.h"
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace preprocessing;
using namespace preprocessing::passes;
ASSERT_EQ(d_bv_gauss->getMinBwExpr(Rewriter::rewrite(plus7)), 17);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_smt.h"
#include "util/rational.h"
-using namespace cvc5::kind;
-using namespace cvc5::preprocessing::passes;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::preprocessing::passes;
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestPPWhiteForeignTheoryRewrite : public TestSmt
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/regexp.h"
#include "util/string.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
checkToString(n, "((_ re.loop 1 3) (str.to_re \"x\"))");
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "proof/lfsc/lfsc_node_converter.h"
#include "test.h"
-namespace cvc5 {
-using namespace cvc5::proof;
+namespace cvc5::internal {
+using namespace cvc5::internal::proof;
namespace test {
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/theory_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace context;
using namespace prop;
d_satSolver.reset(new FakeSatSolver());
d_cnfContext.reset(new context::Context());
d_cnfRegistrar.reset(new prop::NullRegistrar);
- d_cnfStream.reset(
- new cvc5::prop::CnfStream(d_slvEngine->getEnv(),
- d_satSolver.get(),
- d_cnfRegistrar.get(),
- d_cnfContext.get()));
+ d_cnfStream.reset(new prop::CnfStream(d_slvEngine->getEnv(),
+ d_satSolver.get(),
+ d_cnfRegistrar.get(),
+ d_cnfContext.get()));
}
void TearDown() override
ASSERT_TRUE(d_cnfStream->hasLiteral(a_and_b));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "gtest/gtest.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestInternal : public ::testing::Test
};
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "api/cpp/cvc5.h"
#include "gtest/gtest.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestApi : public ::testing::Test
{
protected:
- cvc5::api::Solver d_solver;
+ cvc5::Solver d_solver;
};
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "context/context.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
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 context::Context()); }
+ std::unique_ptr<context::Context> d_context;
};
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "smt/solver_engine_scope.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestEnv : public TestInternal
};
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "smt/solver_engine_scope.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestNode : public TestInternal
};
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/valuation.h"
#include "util/resource_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
/* -------------------------------------------------------------------------- */
}
}
-class DummyOutputChannel : public cvc5::theory::OutputChannel
+class DummyOutputChannel : public theory::OutputChannel
{
public:
DummyOutputChannel() {}
/* -------------------------------------------------------------------------- */
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#endif
#include "theory/arith/arith_poly_norm.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace theory::arith;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/rewriter.h"
#include "util/rational.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestTheoryWhiteEvaluator : public TestSmt
}
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test.h"
#include "theory/logic_info.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
LogicInfo info;
ASSERT_FALSE(info.isLocked());
- ASSERT_THROW(info.getLogicString(), cvc5::IllegalArgumentException);
- ASSERT_THROW(info.isTheoryEnabled(THEORY_BUILTIN),
- cvc5::IllegalArgumentException);
- ASSERT_THROW(info.isTheoryEnabled(THEORY_BOOL),
- cvc5::IllegalArgumentException);
- ASSERT_THROW(info.isTheoryEnabled(THEORY_UF), cvc5::IllegalArgumentException);
- ASSERT_THROW(info.isTheoryEnabled(THEORY_ARITH),
- cvc5::IllegalArgumentException);
- ASSERT_THROW(info.isTheoryEnabled(THEORY_ARRAYS),
- cvc5::IllegalArgumentException);
- ASSERT_THROW(info.isTheoryEnabled(THEORY_BV), cvc5::IllegalArgumentException);
+ ASSERT_THROW(info.getLogicString(), IllegalArgumentException);
+ ASSERT_THROW(info.isTheoryEnabled(THEORY_BUILTIN), IllegalArgumentException);
+ ASSERT_THROW(info.isTheoryEnabled(THEORY_BOOL), IllegalArgumentException);
+ ASSERT_THROW(info.isTheoryEnabled(THEORY_UF), IllegalArgumentException);
+ ASSERT_THROW(info.isTheoryEnabled(THEORY_ARITH), IllegalArgumentException);
+ ASSERT_THROW(info.isTheoryEnabled(THEORY_ARRAYS), IllegalArgumentException);
+ ASSERT_THROW(info.isTheoryEnabled(THEORY_BV), IllegalArgumentException);
ASSERT_THROW(info.isTheoryEnabled(THEORY_DATATYPES),
- cvc5::IllegalArgumentException);
+ 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);
+ IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_BUILTIN), IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_BOOL), IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_UF), IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_ARITH), IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_ARRAYS), IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_BV), IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_DATATYPES), IllegalArgumentException);
+ ASSERT_THROW(info.isPure(THEORY_QUANTIFIERS), IllegalArgumentException);
+ ASSERT_THROW(info.isQuantified(), IllegalArgumentException);
+ ASSERT_THROW(info.areIntegersUsed(), IllegalArgumentException);
+ ASSERT_THROW(info.areRealsUsed(), IllegalArgumentException);
+ ASSERT_THROW(info.isLinear(), IllegalArgumentException);
info.lock();
ASSERT_TRUE(info.isLocked());
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.disableTheory(THEORY_DATATYPES),
- 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);
+ ASSERT_THROW(info.arithOnlyLinear(), IllegalArgumentException);
+ ASSERT_THROW(info.disableIntegers(), IllegalArgumentException);
+ ASSERT_THROW(info.disableQuantifiers(), IllegalArgumentException);
+ ASSERT_THROW(info.disableTheory(THEORY_BV), IllegalArgumentException);
+ ASSERT_THROW(info.disableTheory(THEORY_DATATYPES), IllegalArgumentException);
+ ASSERT_THROW(info.enableIntegers(), IllegalArgumentException);
+ ASSERT_THROW(info.disableReals(), IllegalArgumentException);
+ ASSERT_THROW(info.disableTheory(THEORY_ARITH), IllegalArgumentException);
+ ASSERT_THROW(info.disableTheory(THEORY_UF), IllegalArgumentException);
info = info.getUnlockedCopy();
ASSERT_FALSE(info.isLocked());
info.disableTheory(THEORY_STRINGS);
gt(ufHo, "QF_UF");
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/regexp_entail.h"
#include "util/string.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace theory;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
#include "util/string.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory;
-using namespace cvc5::theory::strings;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::theory::strings;
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestTheoryWhiteSequencesRewriter : public TestSmt
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(String("A"));
+ Node abcd = d_nodeManager->mkConst(String("ABCD"));
+ Node aaad = d_nodeManager->mkConst(String("AAAD"));
+ Node b = d_nodeManager->mkConst(String("B"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node negOne = d_nodeManager->mkConst(CONST_RATIONAL, Rational(-1));
Node zero = d_nodeManager->mkConst(CONST_RATIONAL, Rational(0));
Node one = d_nodeManager->mkConst(CONST_RATIONAL, Rational(1));
- Node empty = d_nodeManager->mkConst(::cvc5::String(""));
- Node a = d_nodeManager->mkConst(::cvc5::String("A"));
+ Node empty = d_nodeManager->mkConst(String(""));
+ Node a = d_nodeManager->mkConst(String("A"));
Node slen_y = d_nodeManager->mkNode(kind::STRING_LENGTH, y);
Node x_plus_slen_y = d_nodeManager->mkNode(kind::ADD, x, slen_y);
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(String(""));
+ Node a = d_nodeManager->mkConst(String("A"));
+ Node b = d_nodeManager->mkConst(String("B"));
+ Node abcd = d_nodeManager->mkConst(String("ABCD"));
Node negone = d_nodeManager->mkConst(CONST_RATIONAL, Rational(-1));
Node zero = d_nodeManager->mkConst(CONST_RATIONAL, Rational(0));
Node one = d_nodeManager->mkConst(CONST_RATIONAL, Rational(1));
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(String(""));
+ Node a = d_nodeManager->mkConst(String("A"));
Node zero = d_nodeManager->mkConst(CONST_RATIONAL, Rational(0));
Node three = d_nodeManager->mkConst(CONST_RATIONAL, Rational(3));
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(String(""));
+ Node abcd = d_nodeManager->mkConst(String("ABCD"));
+ Node f = d_nodeManager->mkConst(String("F"));
+ Node gh = d_nodeManager->mkConst(String("GH"));
+ Node ij = d_nodeManager->mkConst(String("IJ"));
Node i = d_nodeManager->mkVar("i", intType);
Node s = d_nodeManager->mkVar("s", strType);
TypeNode intType = d_nodeManager->integerType();
TypeNode strType = d_nodeManager->stringType();
- Node a = d_nodeManager->mkConst(::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(String("A"));
+ Node abcd = d_nodeManager->mkConst(String("ABCD"));
+ Node aaad = d_nodeManager->mkConst(String("AAAD"));
+ Node b = d_nodeManager->mkConst(String("B"));
+ Node c = d_nodeManager->mkConst(String("C"));
+ Node ccc = d_nodeManager->mkConst(String("CCC"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node negOne = d_nodeManager->mkConst(CONST_RATIONAL, Rational(-1));
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(String(""));
+ Node a = d_nodeManager->mkConst(String("A"));
+ Node ab = d_nodeManager->mkConst(String("AB"));
+ Node b = d_nodeManager->mkConst(String("B"));
+ Node c = d_nodeManager->mkConst(String("C"));
+ Node d = d_nodeManager->mkConst(String("D"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node z = d_nodeManager->mkVar("z", strType);
d_nodeManager->mkConst(String("AZZZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String("FOO"));
+ Node res = d_nodeManager->mkConst(String("FOO"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZAZZZBZZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String("ZFOOZZB"));
+ Node res = d_nodeManager->mkConst(String("ZFOOZZB"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZAZZZBZAZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String("ZFOOZAZB"));
+ Node res = d_nodeManager->mkConst(String("ZFOOZAZB"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZZZ")),
re,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String("ZZZ"));
+ Node res = d_nodeManager->mkConst(String("ZZZ"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZZZ")),
sigStar,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String("FOOZZZ"));
+ Node res = d_nodeManager->mkConst(String("FOOZZZ"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("")),
sigStar,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String("FOO"));
+ Node res = d_nodeManager->mkConst(String("FOO"));
sameNormalForm(t, res);
}
}
d_nodeManager->mkConst(String("AZZZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String("FOO"));
+ Node res = d_nodeManager->mkConst(String("FOO"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZAZZZBZZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String("ZFOOZZB"));
+ Node res = d_nodeManager->mkConst(String("ZFOOZZB"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZAZZZBZAZB")),
re,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String("ZFOOZFOO"));
+ Node res = d_nodeManager->mkConst(String("ZFOOZFOO"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZZZ")),
re,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String("ZZZ"));
+ Node res = d_nodeManager->mkConst(String("ZZZ"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("ZZZ")),
sigStar,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String("FOOFOOFOO"));
+ Node res = d_nodeManager->mkConst(String("FOOFOOFOO"));
sameNormalForm(t, res);
}
d_nodeManager->mkConst(String("")),
sigStar,
foo);
- Node res = d_nodeManager->mkConst(::cvc5::String(""));
+ Node res = d_nodeManager->mkConst(String(""));
sameNormalForm(t, res);
}
}
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(String(""));
+ Node a = d_nodeManager->mkConst(String("A"));
+ Node ab = d_nodeManager->mkConst(String("AB"));
+ Node b = d_nodeManager->mkConst(String("B"));
+ Node c = d_nodeManager->mkConst(String("C"));
+ Node e = d_nodeManager->mkConst(String("E"));
+ Node h = d_nodeManager->mkConst(String("H"));
+ Node j = d_nodeManager->mkConst(String("J"));
+ Node p = d_nodeManager->mkConst(String("P"));
+ Node abc = d_nodeManager->mkConst(String("ABC"));
+ Node def = d_nodeManager->mkConst(String("DEF"));
+ Node ghi = d_nodeManager->mkConst(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);
StringsEntail& se = d_seqRewriter->getStringsEntail();
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(String(""));
+ Node a = d_nodeManager->mkConst(String("A"));
+ Node b = d_nodeManager->mkConst(String("B"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node xy = d_nodeManager->mkNode(kind::STRING_CONCAT, x, y);
{
TypeNode strType = d_nodeManager->stringType();
- Node empty = d_nodeManager->mkConst(::cvc5::String(""));
- Node a = d_nodeManager->mkConst(::cvc5::String("A"));
+ Node empty = d_nodeManager->mkConst(String(""));
+ Node a = d_nodeManager->mkConst(String("A"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node xx = d_nodeManager->mkNode(kind::STRING_CONCAT, x, x);
TypeNode strType = d_nodeManager->stringType();
TypeNode intType = d_nodeManager->integerType();
- Node empty = d_nodeManager->mkConst(::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(String(""));
+ Node a = d_nodeManager->mkConst(String("A"));
+ Node aaa = d_nodeManager->mkConst(String("AAA"));
+ Node b = d_nodeManager->mkConst(String("B"));
+ Node ba = d_nodeManager->mkConst(String("BA"));
Node w = d_nodeManager->mkVar("w", strType);
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
TypeNode intType = d_nodeManager->integerType();
TypeNode strType = d_nodeManager->stringType();
- Node empty = d_nodeManager->mkConst(::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(String(""));
+ Node a = d_nodeManager->mkConst(String("A"));
+ Node ab = d_nodeManager->mkConst(String("AB"));
+ Node abc = d_nodeManager->mkConst(String("ABC"));
+ Node abcd = d_nodeManager->mkConst(String("ABCD"));
+ Node bc = d_nodeManager->mkConst(String("BC"));
+ Node c = d_nodeManager->mkConst(String("C"));
+ Node cd = d_nodeManager->mkConst(String("CD"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
Node n = d_nodeManager->mkVar("n", intType);
TypeNode strType = d_nodeManager->stringType();
std::vector<Node> vec_empty;
- Node abc = d_nodeManager->mkConst(::cvc5::String("ABC"));
+ Node abc = d_nodeManager->mkConst(String("ABC"));
Node re_abc = d_nodeManager->mkNode(kind::STRING_TO_REGEXP, abc);
Node x = d_nodeManager->mkVar("x", strType);
}
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/strings_rewriter.h"
#include "util/string.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace theory;
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(String("A"));
+ Node bc = d_nodeManager->mkConst(String("BC"));
Node x = d_nodeManager->mkVar("x", strType);
Node y = d_nodeManager->mkVar("y", strType);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_engine.h"
#include "util/poly_util.h"
-namespace cvc5::test {
+namespace cvc5::internal::test {
-using namespace cvc5;
-using namespace cvc5::kind;
-using namespace cvc5::theory;
-using namespace cvc5::theory::arith;
-using namespace cvc5::theory::arith::nl;
+using namespace cvc5::internal;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::theory::arith;
+using namespace cvc5::internal::theory::arith::nl;
NodeManager* nodeManager;
class TestTheoryWhiteArithCoverings : public TestSmt
EXPECT_TRUE(ran == back);
}
}
-} // namespace cvc5::test
+} // namespace cvc5::internal::test
#endif
#include "theory/arith/nl/pow2_solver.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace theory;
Node d_one;
};
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
#include "util/real_algebraic_number.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace context;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_engine.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace theory::arith;
ASSERT_EQ(Rewriter::rewrite(Rewriter::rewrite(t)), Rewriter::rewrite(t));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
#include "util/string.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace kind;
std::vector<Node> getNStrings(size_t n)
{
std::vector<Node> elements(n);
- cvc5::theory::strings::StringEnumerator enumerator(
- d_nodeManager->stringType());
+ theory::strings::StringEnumerator enumerator(d_nodeManager->stringType());
for (size_t i = 0; i < n; i++)
{
ASSERT_EQ(output3, BagsUtils::evaluate(input3));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
#include "util/string.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace kind;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/type_enumerator.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace kind;
std::vector<Node> getNStrings(size_t n)
{
std::vector<Node> elements(n);
- cvc5::theory::strings::StringEnumerator enumerator(
- d_nodeManager->stringType());
+ theory::strings::StringEnumerator enumerator(d_nodeManager->stringType());
for (size_t i = 0; i < n; i++)
{
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/bitvector.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace context;
ASSERT_TRUE(arr2.isConst());
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/bv/theory_bv_utils.h"
#include "util/bitvector.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace theory;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_smt.h"
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace smt;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/rewriter.h"
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace theory;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory.h"
#include "theory/theory_engine.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace theory::bv;
}
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/integer.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace expr;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_smt.h"
#include "util/rational.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory;
-using namespace cvc5::smt;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory;
+using namespace cvc5::internal::smt;
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestTheoryWhiteIntOpt : public TestSmtNoFinishInit
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_smt.h"
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace smt;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/rewriter.h"
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace theory::bv;
ASSERT_EQ(norm_axax[1], a);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/quantifiers/bv_inverter_utils.h"
#include "util/result.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace theory;
runTestSext(false, BITVECTOR_SGT);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
#include "util/string.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace kind;
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_smt.h"
#include "theory/sets/theory_sets_type_enumerator.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace kind;
ASSERT_TRUE(setEnumerator.isFinished());
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/sets/singleton_op.h"
#include "util/rational.h"
-using namespace cvc5::api;
+using namespace cvc5;
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestTheoryWhiteSetsTypeRuleApi : public TestApi
Term emptyReal = d_solver.mkEmptySet(d_solver.mkSetSort(realSort));
Term integerOne = d_solver.mkInteger(1);
Term realOne = d_solver.mkReal(1);
- Term singletonInt = d_solver.mkTerm(api::SET_SINGLETON, {integerOne});
- Term singletonReal = d_solver.mkTerm(api::SET_SINGLETON, {realOne});
+ Term singletonInt = d_solver.mkTerm(cvc5::SET_SINGLETON, {integerOne});
+ Term singletonReal = d_solver.mkTerm(cvc5::SET_SINGLETON, {realOne});
// (union
// (singleton (singleton_op Int) 1)
// (as emptyset (Set Real)))
ASSERT_TRUE(n.isConst());
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
#include "util/string.h"
-using namespace cvc5::kind;
-using namespace cvc5::theory::strings;
+using namespace cvc5::internal::kind;
+using namespace cvc5::internal::theory::strings;
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestTheoryBlackStringsSkolemCache : public TestSmt
}
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/theory_strings_utils.h"
#include "util/string.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace kind;
using namespace theory;
TypeNode strType = d_nodeManager->stringType();
Node empty = d_nodeManager->mkConst(String(""));
- Node a = d_nodeManager->mkConst(::cvc5::String("A"));
+ Node a = d_nodeManager->mkConst(String("A"));
Node x = d_nodeManager->mkVar("x", strType);
Node emptyEqX = empty.eqNode(x);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/strings/word.h"
#include "util/string.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace theory::strings;
ASSERT_TRUE(Word::roverlap(aaaaa, aa) == 2);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "theory/theory_engine.h"
#include "util/resource_manager.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace expr;
d_outputChannel.d_callHistory.clear();
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
#include "util/uninterpreted_sort_value.h"
-namespace cvc5 {
+namespace cvc5::internal {
using namespace theory;
using namespace kind;
ASSERT_THROW(*++te, NoMoreValuesException);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/rational.h"
#include "util/uninterpreted_sort_value.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilWhiteArrayStoreAll : public TestSmt
IllegalArgumentException);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/check.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilWhite : public TestInternal
ASSERT_THROW(CheckArgument(false, "x"), IllegalArgumentException);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test.h"
#include "util/bin_heap.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilBlackBinaryHeap : public TestInternal
ASSERT_TRUE(heap.empty());
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test.h"
#include "util/bitvector.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilBlackBitVector : public TestInternal
ASSERT_EQ(BitVector::mkMaxSigned(4).toSignedInteger(), Integer(7));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "smt_util/boolean_simplification.h"
#include "test_node.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilBlackBooleanSimplification : public TestNode
#endif
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/cardinality.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilBlackCardinality : public TestInternal
ASSERT_EQ((z ^ z).getBethNumber(), 3);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/check.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilWhiteCheck : public TestInternal
ASSERT_DEATH(AlwaysAssert(false), "false");
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/configuration.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilBlackConfiguration : public TestInternal
Configuration::about();
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test_smt.h"
#include "util/rational.h"
-using namespace cvc5::kind;
+using namespace cvc5::internal::kind;
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilBlackDatatype : public TestSmt
ASSERT_EQ(TypeNode::leastCommonTypeNode(pairIntInt, pairIntInt), pairIntInt);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/didyoumean.h"
-namespace cvc5::test {
+namespace cvc5::internal::test {
class TestUtilDidYouMean : public TestInternal
{
}
}
-} // namespace cvc5::test
+} // namespace cvc5::internal::test
#include "base/exception.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilBlackException : public TestInternal
ASSERT_EQ(s3.str(), std::string("three of 'em!"));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test.h"
#include "util/floatingpoint.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilBlackFloatingPoint : public TestInternal
ASSERT_TRUE(mfp128.isNormal());
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilBlackInteger : public TestInternal
}
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test.h"
#include "util/integer.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilWhiteInteger : public TestInternal
ASSERT_EQ(Integer(u), Integer(u));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "base/output.h"
#include "test.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilBlackOutput : public TestInternal
#endif /* CVC5_MUZZLE */
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilBlackRational : public TestInternal
ASSERT_THROW(Rational::fromDecimal("Hello, world!");, std::invalid_argument);
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test.h"
#include "util/rational.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
class TestUtilWhiteRational : public TestInternal
ASSERT_EQ(Rational(u), Rational(u));
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "test.h"
#include "util/real_algebraic_number.h"
-namespace cvc5 {
+namespace cvc5::internal {
namespace test {
#ifndef CVC5_POLY_IMP
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
#include "util/statistics_registry.h"
#include "util/statistics_stats.h"
-namespace cvc5 {
+namespace cvc5::internal {
std::ostream& operator<<(std::ostream& os, const StatisticBaseValue* sbv)
{
#endif
}
} // namespace test
-} // namespace cvc5
+} // namespace cvc5::internal
projects / cvc5.git / commitdiff