From 48e63956d55a8db27a16ee661861303f9ff1ef8a Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Thu, 24 Jun 2021 13:48:51 -0700 Subject: [PATCH 01/47] Encodes most functionality for generic sorts to work with inductive datatypes. One final potential problem remains. --- include/generic_solver.h | 14 + src/#generic_solver.cpp# | 1213 +++++++++++++++++++++++++++++++++++ src/generic_solver.cpp | 123 +++- src/generic_sort.cpp | 2 +- src/solver_enums.cpp | 1 + tests/test-dt.cpp | 19 +- tests/test-generic-sort.cpp | 15 + 7 files changed, 1374 insertions(+), 13 deletions(-) create mode 100644 src/#generic_solver.cpp# diff --git a/include/generic_solver.h b/include/generic_solver.h index fdf3c6b40..db90f2218 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -251,6 +251,20 @@ class GenericSolver : public AbsSmtSolver // maps between sort name and actual sort and vice verse std::unique_ptr> name_term_map; std::unique_ptr> term_name_map; + + std::unique_ptr> name_datatypedecl_map; + std::unique_ptr> datatypedecl_name_map; + + std::unique_ptr> name_datatypeconsdecl_map; + std::unique_ptr> datatypeconsdecl_name_map; + + std::unique_ptr>> dtdecl_dtconsdecl_map; + + struct selectorComponents { + std::string name; + Sort sort; + }; + std::unique_ptr>> dtconsdecl_selector_map; // used to hash terms via their internal string representation std::hash str_hash; }; diff --git a/src/#generic_solver.cpp# b/src/#generic_solver.cpp# new file mode 100644 index 000000000..b8088aff8 --- /dev/null +++ b/src/#generic_solver.cpp# @@ -0,0 +1,1213 @@ +/********************* */ +/*! \file generic_solver.cpp +** \verbatim +** Top contributors (to current version): +** Yoni Zohar +** This file is part of the smt-switch project. +** Copyright (c) 2020 by the authors listed in the file AUTHORS +** in the top-level source directory) and their institutional affiliations. +** All rights reserved. See the file LICENSE in the top-level source +** directory for licensing information.\endverbatim +** +** +** \brief A class that represents a generic solver +** +**/ + +/* Uses code to interact with a process from: +** https://stackoverflow.com/a/6172578/1364765 +*/ + +// generic solvers are not supported on macos +#ifndef __APPLE__ + +#include "generic_solver.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "assert.h" +#include "smtlib_utils.h" +#include "sort.h" +#include "sort_inference.h" +#include "utils.h" + +using namespace std; + +namespace smt { + +// helper functions +bool is_new_line(char c) { return (c == '\n' || c == '\r' || c == 0); } + +// from: https://stackoverflow.com/a/36000453/1364765 +std::string & trim(std::string & str) +{ + // right trim + while (str.length() > 0 + && (str[str.length() - 1] == ' ' || str[str.length() - 1] == '\t' + || str[str.length() - 1] == '\n')) + str.erase(str.length() - 1, 1); + + // left trim + while (str.length() > 0 + && (str[0] == ' ' || str[0] == '\t' || str[0] == '\n')) + str.erase(0, 1); + return str; +} + +// class methods implementation +GenericSolver::GenericSolver(string path, + vector cmd_line_args, + uint write_buf_size, + uint read_buf_size) + : AbsSmtSolver(SolverEnum::GENERIC_SOLVER), + path(path), + cmd_line_args(cmd_line_args), + write_buf_size(write_buf_size), + read_buf_size(read_buf_size), + name_sort_map(new unordered_map()), + sort_name_map(new unordered_map()), + name_term_map(new unordered_map()), + term_name_map(new unordered_map()), + name_datatypedecl_map(new unordered_map()), + datatypedecl_name_map(new unordered_map()), + name_datatypeconsdecl_map(new unordered_map()), + datatypeconsdecl_name_map(new unordered_map()), + dtdecl_dtconsdecl_map(new unordered_map>()), + dtconsdecl_selector_map(new unordered_map>) +{ + // Buffer sizes over 256 caused issues in tests. + // Until this is investigated, we support a conservative + // limit of 256. + // Similarly for buffers of size 1. + if (write_buf_size < 2 || write_buf_size > 256 || read_buf_size < 2 + || read_buf_size > 256) + { + string msg( + "Generic Solvers require a buffer size of at least 2 and at most 256."); + throw IncorrectUsageException(msg); + } + term_counter = new uint; + //allocate memory for the buffers + write_buf = new char[write_buf_size]; + read_buf = new char[read_buf_size]; + + //make sure allocation was successful + assert(write_buf != NULL); + assert(read_buf != NULL); + //initialize write_buf + for (int i=0; i < write_buf_size; i++) { + write_buf[i]=0; + } + //initialize read_buf + for (int i=0; i < read_buf_size; i++) { + read_buf[i]=0; + } + + // start the process with the solver binary + start_solver(); +} + +GenericSolver::~GenericSolver() { + //deallocate the buffers memory + delete write_buf; + delete read_buf; + delete term_counter; + // close the solver process + close_solver(); +} + +void GenericSolver::start_solver() { + pid = 0; + + pipe(inpipefd); + pipe(outpipefd); + pid = fork(); + if (pid == 0) + { + // Child + dup2(outpipefd[0], STDIN_FILENO); + dup2(inpipefd[1], STDOUT_FILENO); + dup2(inpipefd[1], STDERR_FILENO); + + // ask kernel to deliver SIGTERM in case the parent dies + prctl(PR_SET_PDEATHSIG, SIGTERM); + // fcntl(inpipefd[1], F_SETFL, O_NONBLOCK); + // The following part is based on: + // https://stackoverflow.com/a/5797901/1364765 The execv command expects an + // array, and so we create one. First element is the program name, last + // element is NULL, and in between are the elements of cmd_line_args, casted + // to (char*) from std::string. Here we identify the program name with its + // path. + const char ** argv = new const char *[cmd_line_args.size() + 2]; + argv[0] = path.c_str(); + for (int i = 1; i <= cmd_line_args.size(); i++) + { + argv[i] = cmd_line_args[i - 1].c_str(); + } + argv[cmd_line_args.size() + 1] = NULL; + execv(path.c_str(), (char **)argv); + // Nothing below this line should be executed by child process. If so, + // it means that the execl function wasn't successfull, so lets exit: + string msg("failure to run binary: "); + msg += path; + throw IncorrectUsageException(msg); + exit(1); + } + // close unused pipe ends + close(outpipefd[0]); + close(inpipefd[1]); + set_opt("print-success", "true"); +} + +void GenericSolver::write_internal(string str) const +{ + // track how many charas were written so far + uint written_chars = 0; + // continue writing until entire str was written + while (written_chars < str.size()) + { + // how many characters are there left to write + uint remaining = str.size() - written_chars; + // how many characters are we writing in this iteration + uint substr_size; + if (remaining < write_buf_size) + { + substr_size = remaining; + } + else + { + substr_size = write_buf_size; + } + // write + strcpy(write_buf, str.substr(written_chars, substr_size).c_str()); + write(outpipefd[1], write_buf, substr_size); + written_chars += substr_size; + cout << "writebutf" << endl; + cout << write_buf << endl; + } + //cout << "outpipe" << endl; + //cout << outpipefd[1] << endl; +} + +bool GenericSolver::is_done(int just_read, std::string result) const +{ + bool done = false; + int count = 0; + // if we didn't read anything now, the command is done executing + if (just_read == 0) + { + done = true; + } + else if (result[0] == '(') + { + // if the output of the solver starts with '(' + // we will be done only when we see the matching ')' + for (int i = 0; i < result.size(); i++) + { + if (result[i] == '(') + { + count++; + } + else if (result[i] == ')') + { + count--; + } + } + done = (count == 0) && is_new_line(result[result.size() - 1]); + } + else + { + // if the output of the solver does not start with '(' + // we will be done when we reach a newline character + assert(just_read <= read_buf_size); + for (int i = 0; i < just_read; i++) + { + if (is_new_line(read_buf[i])) + { + done = true; + } + } + } + return done; +} + +string GenericSolver::read_internal() const +{ + string result = ""; + bool done = false; + // read to the buffer until no more output to read + while (!done) + { + // read command, and how many chars were read. + //cout <<"readbuf" << endl; + //cout <find(res_sort) != sort_name_map->end()); + // send a define-fun to the binary + run_command("(" + DEFINE_FUN_STR + " " + name + " () " + + (*sort_name_map)[res_sort] + " " + to_smtlib_def(defining_term) + + ")"); +} + +std::string GenericSolver::to_smtlib_def(Term term) const +{ + // cast to generic term + shared_ptr gt = static_pointer_cast(term); + // generic terms with no operators are represented by their + // name. + if (gt->get_op().is_null()) + { + return gt->to_string(); + } + else + { + // generic terms with operators are written as s-expressions. + string result = "("; + // The Apply operator is ignored and the + // function being applied is used instead. + result += + ((term->get_op().prim_op == Apply) ? "" : term->get_op().to_string()); + // For quantifiers we separate the bound variables list + // and the formula body. + if (term->get_op().prim_op == Forall || term->get_op().prim_op == Exists) + { + result += " ((" + (*term_name_map)[gt->get_children()[0]] + " " + + (*sort_name_map)[gt->get_children()[0]->get_sort()] + ")) " + + (*term_name_map)[gt->get_children()[1]]; + } + else + { + // in the general case (other than quantifiers + // and Apply), we use ordinary + // s-expressions notation and write a + // space-separated list of arguments. + for (auto c : gt->get_children()) + { + result += " " + (*term_name_map)[c]; + } + } + result += ")"; + return result; + } +} + +Sort GenericSolver::make_sort(const Sort & sort_con, const SortVec & sorts) const { + throw NotImplementedException( + "Sort constructor are not supported by generic solvers"); +} + +Sort GenericSolver::make_sort(const std::string name, uint64_t arity) const { + // when creating a new uninterpreted sort, the name + // must be new. + if (name_sort_map->find(name) == name_sort_map->end()) + { + // create the sort + Sort sort = make_uninterpreted_generic_sort(name, arity); + // store the sort and the name in the maps + (*name_sort_map)[name] = sort; + (*sort_name_map)[sort] = name; + // declare the sort to the binary of the solver + run_command("(" + DECLARE_SORT_STR + " " + name + " " + + std::to_string(arity) + ")"); + return sort; + } + else + { + throw IncorrectUsageException(string("sort name: ") + name + + string(" already taken")); + } +} + +Sort GenericSolver::make_sort(const SortKind sk) const +{ + // create the sort + Sort sort = make_generic_sort(sk); + // compute the name of the sort + string name = sort->to_string(); + + // note that nothing needs to be communicated to the solver, + // as in this case the sort is built in. + + // store in local maps if needed, and return the sort + if (name_sort_map->find(name) == name_sort_map->end()) + { + (*name_sort_map)[name] = sort; + (*sort_name_map)[sort] = name; + return sort; + } + else + { + return name_sort_map->at(name); + } +} + +Sort GenericSolver::make_sort(const SortKind sk, uint64_t size) const +{ + // create the sort + Sort sort = make_generic_sort(sk, size); + // compute the name + string name = sort->to_string(); + + // note that nothing needs to be communicated to the solver, + // as in this case the sort is built in. + + // store in maps if needed and return the sort + if (name_sort_map->find(name) == name_sort_map->end()) + { + (*name_sort_map)[name] = sort; + (*sort_name_map)[sort] = name; + return sort; + } + else + { + return name_sort_map->at(name); + } +} + +Sort GenericSolver::make_sort(const SortKind sk, const Sort & sort1) const +{ + return make_sort(sk, SortVec({ sort1 })); +} + +Sort GenericSolver::make_sort(const SortKind sk, + const Sort & sort1, + const Sort & sort2) const +{ + return make_sort(sk, SortVec({ sort1, sort2 })); +} + +Sort GenericSolver::make_sort(const SortKind sk, + const Sort & sort1, + const Sort & sort2, + const Sort & sort3) const +{ + return make_sort(sk, SortVec({ sort1, sort2, sort3 })); +} + +Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const +{ + // create the sort + Sort sort = make_generic_sort(sk, sorts); + // compute the name + string name = sort->to_string(); + + // note that nothing needs to be communicated to the solver, + // as in this case the sort is built in, or can used + // by combining sorts that were already defined. + + // store in maps if needed and return the sort + if (name_sort_map->find(name) == name_sort_map->end()) + { + (*name_sort_map)[name] = sort; + (*sort_name_map)[sort] = name; + return sort; + } + else + { + return name_sort_map->at(name); + } +} + +Sort GenericSolver::make_sort(const DatatypeDecl & d) const +{ + //throw NotImplementedException("Generic Solvers do not support + //datatypes"); + std::string dtName = (*datatypedecl_name_map)[d]; + if (name_sort_map->find(dtName) == name_sort_map->end()) { + //std::string dtName = (*datatypedecl_name_map)[d]; + //Sort dtSort = make_generic_sort(DATATYPE); + std::string rawText = "(declare-datatypes (("; + //rawText += " "; + rawText += dtName; + rawText += " 0)) (\n"; + rawText += "("; + for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[d].size(); ++i ) { + DatatypeConstructorDecl currCons = ((*dtdecl_dtconsdecl_map)[d])[i]; + rawText += " (" + (*datatypeconsdecl_name_map)[currCons]; + for (unsigned long f = 0; f < (*dtconsdecl_selector_map)[currCons].size(); ++f) { + rawText += " ( " + (*dtconsdecl_selector_map)[currCons][f].name; + rawText += " " + ((*dtconsdecl_selector_map)[currCons][f].sort)->to_string() + " )"; + } + rawText += ")"; + } + rawText += ")\n))"; + //cout << "This is the rawText:" << endl; + //cout << rawText << endl; + cout << "This is what's sent to the solver: \n"; + cout << rawText << endl; + //run_command(rawText); + //Sort dtSort = make_shared(DATATYPE); + Sort dtSort = make_sort(DATATYPE); + cout << dtSort->to_string() << endl; + cout << "Finished run command!" << endl; + (*name_sort_map)[dtName] = dtSort; + cout << "DId one assignment" + dtName << endl; + *dtSort; + cout << "cant dereference" << endl; + //cout << dtSort << endl; + (*sort_name_map)[dtSort] = dtName; + //Sort dtSort = make_sort(DATATYPE); + cout << "Finsihed map assignment" << endl; + run_command(rawText); + //Sort dtSort = make_sort(INT); + return dtSort; + + } + else { + throw NotImplementedException("Generic Solvers do not support "); + + } +} + +DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) +{ + DatatypeDecl newDT = make_shared(); + //shared_ptr + (*name_datatypedecl_map)[s] = newDT; + (*datatypedecl_name_map)[newDT] = s; + return newDT; +} +DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( + const std::string s) +{ + //throw NotImplementedException("Generic Solvers do not support + //datatypes"); + //shared_ptr newDTC = + //make_shared(); + DatatypeConstructorDecl newDTC = make_shared(); + + //DatatypeConstructorDecl newDTC = make_shared(); + // DLETE + cout << "current map entry\n" + (*datatypeconsdecl_name_map)[newDTC] << endl; + (*name_datatypeconsdecl_map)[s] = newDTC; + (*datatypeconsdecl_name_map)[newDTC] = s; + return newDTC; +} + +void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructorDecl & con) const + { + //throw NotImplementedException("Generic Solvers do not support datatypes"); + //dtdecl_dtconsdecl_map; + cout << "Every construcotr attached: before map assign,ent" << endl; + for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[dt].size(); ++i) { + cout << "\nConstructor #" + std::to_string(i) << endl; + cout << (*datatypeconsdecl_name_map)[(((*dtdecl_dtconsdecl_map)[dt])[i])] << endl; + } + + (*dtdecl_dtconsdecl_map)[dt].push_back(con); + + cout << "Every construcotr attached: after map assignment" << endl; + for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[dt].size(); ++i) { + cout << "\nConstructor #" + std::to_string(i) << endl; + cout << (*datatypeconsdecl_name_map)[(((*dtdecl_dtconsdecl_map)[dt])[i])] << endl; + } +} +void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const +{ + //throw NotImplementedException("Generic Solvers do not support + //datatypes"); + shared_ptr newSelector = make_shared(); + (*newSelector).name = name; + (*newSelector).sort = s; + (*dtconsdecl_selector_map)[dt].push_back(*newSelector); +} + +void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const + { + //throw NotImplementedException("Generic Solvers do not support + //datatypes"); + shared_ptr newSelector = make_shared(); + (*newSelector).name = name; + (*newSelector).sort = make_sort(DATATYPE); + (*dtconsdecl_selector_map)[dt].push_back(*newSelector); +} + +Term GenericSolver::get_constructor(const Sort & s, std::string name) const +{ + throw NotImplementedException("Generic Solvers do not support datatypes"); +} + + +Term GenericSolver::get_tester(const Sort & s, std::string name) const +{ + throw NotImplementedException("Generic Solvers do not support datatypes"); +} + +Term GenericSolver::get_selector(const Sort & s, std::string con, std::string name) const +{ + throw NotImplementedException("Generic Solvers do not support datatypes"); +} + +std::string GenericSolver::get_name(Term term) const +{ + // the names of the terms are `t_i` with a running `i`. + // These names are used for `define-fun` commands. + *term_counter = (*term_counter) + 1; + return "t_" + std::to_string((*term_counter)); +} + +Term GenericSolver::store_term(Term term) const +{ + // cast the term to a GenericTerm + shared_ptr gterm = static_pointer_cast(term); + // store the term in the maps in case it is not there already + if (term_name_map->find(gterm) == term_name_map->end()) + { + string name; + // ground terms are communicated to the binary + // using a define-fun command. + // In future instances of this term, we will use the name + // of the defined function. + // For example: if `term` is `0`, and `name` is `t1`, + // we send a command: + // `(define-fun t1 () Int 0)` + // If in the future we see a term `0+0`, it will + // be sent to the solver as `(+ t1 t1)`. + // + // However, terms with bound variables cannot be given to + // a define-fun command. For them, we store + // their actual definition. + // In future instances, the entire definition will be used. + if (gterm->is_ground()) + { + name = get_name(gterm); + define_fun(name, SortVec{}, gterm->get_sort(), gterm); + } + else + { + name = to_smtlib_def(gterm); + } + (*name_term_map)[name] = gterm; + (*term_name_map)[gterm] = name; + } + // return the term from the internal map + string name = (*term_name_map)[gterm]; + return (*name_term_map)[name]; +} + +Term GenericSolver::make_non_negative_bv_const(string abs_decimal, + uint width) const +{ + Sort bvsort = make_sort(BV, width); + string repr = "(_ bv" + abs_decimal + " " + std::to_string(width) + ")"; + Term term = std::make_shared(bvsort, Op(), TermVec{}, repr); + return term; +} + +Term GenericSolver::make_non_negative_bv_const(int64_t i, uint width) const +{ + assert(i >= 0); + return make_non_negative_bv_const(std::to_string(i), width); +} + +Term GenericSolver::make_negative_bv_const(string abs_decimal, uint width) const +{ + Term zero = make_non_negative_bv_const("0", width); + Term abs = make_non_negative_bv_const(abs_decimal, width); + Term result = make_term(BVSub, zero, abs); + return result; +} + +Term GenericSolver::make_negative_bv_const(int64_t abs_value, uint width) const +{ + assert(abs_value >= 0); + return make_negative_bv_const(std::to_string(abs_value), width); +} + +Term GenericSolver::make_term(bool b) const +{ + Term value_term = make_value(b); + return store_term(value_term); +} + +Term GenericSolver::make_value(bool b) const +{ + // create a generic term that represents `b`. + Sort boolsort = make_sort(BOOL); + Term term = std::make_shared( + boolsort, Op(), TermVec{}, b ? "true" : "false"); + return term; +} + +Term GenericSolver::make_term(int64_t i, const Sort & sort) const +{ + Term value_term = make_value(i, sort); + return store_term(value_term); +} + +Term GenericSolver::make_value(int64_t i, const Sort & sort) const +{ + SortKind sk = sort->get_sort_kind(); + assert(sk == BV || sk == INT || sk == REAL); + if (sk == INT || sk == REAL) + { + string repr = std::to_string(i); + Term term = std::make_shared(sort, Op(), TermVec{}, repr); + return term; + } + else + { + // sk == BV + if (i < 0) + { + int64_t abs_value = i * (-1); + Term term = make_negative_bv_const(abs_value, sort->get_width()); + return term; + } + else + { + Term term = make_non_negative_bv_const(i, sort->get_width()); + return term; + } + } +} + +Term GenericSolver::make_term(const string val, + const Sort & sort, + uint64_t base) const +{ + Term value_term = make_value(val, sort, base); + return store_term(value_term); +} + +Term GenericSolver::make_value(const string val, + const Sort & sort, + uint64_t base) const +{ + SortKind sk = sort->get_sort_kind(); + assert(sk == BV || sk == INT || sk == REAL); + assert(base == 2 || base == 10 | base == 16); + string repr; + if (sk == INT || sk == REAL) + { + assert(base == 10); + repr = val; + Term term = std::make_shared(sort, Op(), TermVec{}, repr); + return term; + } + else + { + // sk == BV + if (base == 10) + { + if (val.find("-") == 0) + { + string abs_decimal = val.substr(1); + return make_negative_bv_const(abs_decimal, sort->get_width()); + } + else + { + return make_non_negative_bv_const(val, sort->get_width()); + } + } + else + { + // base = 2 or 16 + if (base == 2) + { + repr = "#b" + val; + } + else if (base == 16) + { + repr = "#x" + val; + } + Term term = std::make_shared(sort, Op(), TermVec{}, repr); + return term; + } + } +} + +string GenericSolver::cons_arr_string(const Term & val, const Sort & sort) const +{ + assert(term_name_map->find(val) != term_name_map->end()); + assert(sort_name_map->find(sort) != sort_name_map->end()); + return "((as const " + (*sort_name_map)[sort] + ") " + val->to_string() + + ") "; +} + +Term GenericSolver::make_term(const Term & val, const Sort & sort) const +{ + assert(sort->get_sort_kind() == ARRAY); + assert(sort->get_elemsort() == val->get_sort()); + Term term = std::make_shared( + sort, Op(), TermVec{ val }, cons_arr_string(val, sort)); + return store_term(term); +} + +Term GenericSolver::make_symbol(const string name, const Sort & sort) +{ + // make sure that the symbol name is not aready taken. + if (name_term_map->find(name) != name_term_map->end()) + { + throw IncorrectUsageException( + string("symbol name: ") + name + + string(" already taken, either by another symbol or by a param")); + } + + // create the sumbol and store it in the maps + Term term = std::make_shared(sort, Op(), TermVec{}, name, true); + (*name_term_map)[name] = term; + (*term_name_map)[term] = name; + + // communicate the creation of the symbol to the binary of the solver. + // When the sort is not a fucntion, we specify an empty domain. + // Otherwise, the name of the sort includes the domain. + run_command("(" + DECLARE_FUN_STR + " " + name + + (sort->get_sort_kind() == FUNCTION ? " " : " () ") + + (*sort_name_map)[sort] + ")"); + + // return the created symbol as a term + return (*name_term_map)[name]; +} + +Term GenericSolver::make_param(const string name, const Sort & sort) +{ + if (name_term_map->find(name) != name_term_map->end()) + { + throw IncorrectUsageException( + string("param name: ") + name + + string(" already taken, either by another param or by a symbol")); + } + Term term = std::make_shared(sort, Op(), TermVec{}, name, false); + (*name_term_map)[name] = term; + (*term_name_map)[term] = name; + return (*name_term_map)[name]; +} + +Term GenericSolver::make_term(const Op op, const Term & t) const +{ + return make_term(op, TermVec({ t })); +} + +Term GenericSolver::make_term(const Op op, + const Term & t1, + const Term & t2) const +{ + return make_term(op, TermVec({ t1, t2 })); +} + +Term GenericSolver::make_term(const Op op, + const Term & t1, + const Term & t2, + const Term & t3) const +{ + return make_term(op, TermVec({ t1, t2, t3 })); +} + +Term GenericSolver::make_term(const Op op, const TermVec & terms) const +{ + Sort sort = compute_sort(op, this, terms); + string repr = "(" + op.to_string(); + for (int i = 0; i < terms.size(); i++) + { + assert((*term_name_map).find(terms[i]) != (*term_name_map).end()); + repr += " " + (*term_name_map)[terms[i]]; + } + repr += ")"; + Term term = std::make_shared(sort, op, terms, repr); + Term stored_term = store_term(term); + return stored_term; +} + +Term GenericSolver::get_value(const Term & t) const +{ + // we do not support getting array values, function values, and uninterpreted + // values. + Sort sort = t->get_sort(); + assert(sort->get_sort_kind() != ARRAY && sort->get_sort_kind() != FUNCTION + && sort->get_sort_kind() != UNINTERPRETED); + + // get the name of the term (the way the term is defined in the solver) + assert(term_name_map->find(t) != term_name_map->end()); + string name = (*term_name_map)[t]; + + // ask the binary for the value and parse it + string result = run_command("(" + GET_VALUE_STR + " (" + name + "))", false); + + // check that there was no error + check_no_error(result); + + string value = strip_value_from_result(result); + + // translate the string representation of the result into a term + Term resulting_term; + // for bit-vectors, we distinguish between the solver's way of representing + // them. it can be either binary, hex, or decimal. + if (sort->get_sort_kind() == BV) + { + if (value.substr(0, 2) == "#b") + { + // bianry representation + resulting_term = make_value(value.substr(2, value.size() - 2), sort, 2); + } + else if (value.substr(0, 2) == "#x") + { + // hex representation + resulting_term = make_value(value.substr(2, value.size() - 2), sort, 16); + } + else + { + // decimal representation. + // parse strings of the form (_ bv ) + size_t index_of__ = value.find("_ "); + assert(index_of__ != string::npos); + int start_of_decimal = index_of__ + 4; + int end_of_decimal = value.find(' ', start_of_decimal); + string decimal = + value.substr(start_of_decimal, end_of_decimal - start_of_decimal + 1); + resulting_term = make_value(decimal, sort, 10); + } + } + else if (sort->get_sort_kind() == BOOL) + { + Assert(value == "true" || value == "false"); + bool b = (value == "true"); + resulting_term = make_value(b); + } + else + { + resulting_term = make_value(value, t->get_sort()); + } + return resulting_term; +} + +string GenericSolver::strip_value_from_result(string result) const +{ + // trim spaces + result = trim(result); + + // value string ends at first ")" or end of string. + int end_of_value = result.size() - 1; + while (result.at(end_of_value) == ')' || result.at(end_of_value) == ' ') + { + end_of_value--; + } + + // value string begins at the first non-space after '(' + int start_of_value = end_of_value; + while (result.at(start_of_value) != '(') + { + start_of_value--; + } + while (result.at(start_of_value) != ' ') + { + start_of_value++; + } + start_of_value++; + + // special case for bit-vectors with smt-lib style + // (_ bv ) + // in this case we only take + if (result.find("bv", start_of_value) == start_of_value) + { + start_of_value -= 3; + end_of_value++; + } + + // crop the relevant substring + string strip = + result.substr(start_of_value, end_of_value - start_of_value + 1); + return strip; +} + +void GenericSolver::get_unsat_assumptions(UnorderedTermSet & out) +{ + // run get-unsat-assumptions command + string result = run_command("(" + GET_UNSAT_ASSUMPTIONS_STR + ")", false); + + // check that there was no error + check_no_error(result); + + // parse the result -- get the assumptions + UnorderedTermSet assumptions = get_assumptions_from_string(result); + + // put the result in out + out.insert(assumptions.begin(), assumptions.end()); +} + +void GenericSolver::check_no_error(string str) const +{ + str = trim(str); + string err_prefix("(error "); + if (str.compare(0, err_prefix.size(), err_prefix) == 0) + { + throw SmtException("Exception from the solver: " + str); + } +} + +UnorderedTermSet GenericSolver::get_assumptions_from_string(string result) const +{ + // the result from the solver is a + // space-separated list of Boolean literals. + UnorderedTermSet literals; + + // trim the result from spaces + result = trim(result); + + // unwrap parenthesis and trim spaces again + string strip = result.substr(1, result.size() - 2); + strip = trim(strip); + + // position in the string + int index = 0; + // if true, current literal is positive. + // otherwise, it has the form (not ) + bool positive; + + // iterate the string + while (index < strip.size()) + { + // beginning and end of literal + int begin; + int end; + + // negative literal + if (strip.substr(index, 5) == "(not ") + { + begin = index + 5; + end = strip.find(")", begin + 1) - 1; + assert(end != string::npos); + positive = false; + } + else + { + // positive literal -- starts with the variable name + begin = index; + // end -- one character after the end of the substring + end = strip.find(" ", begin + 1); + if (end == string::npos) + { + end = strip.size(); + } + // end -- the actual end of the substring + end--; + positive = true; + } + + // retrieve the literal from the map + string str_atom = strip.substr(begin, end - begin + 1); + assert(name_term_map->find(str_atom) != name_term_map->end()); + Term atom = (*name_term_map)[str_atom]; + Term literal; + if (positive) + { + literal = atom; + } + else + { + literal = make_term(Not, atom); + } + + // add the literal to the result + literals.insert(literal); + if (positive) + { + // next beginning is after a space + index = end + 2; + } + else + { + // next beginning is after a space and a ')' + index = end + 3; + } + } + return literals; +} + +UnorderedTermMap GenericSolver::get_array_values(const Term & arr, + Term & out_const_base) const +{ + throw NotImplementedException( + "Generic solvers do not support get-value for arryas"); +} + +void GenericSolver::reset() +{ + string result = run_command("(" + RESET_STR + ")"); +} + +void GenericSolver::set_opt(const std::string option, const std::string value) +{ + run_command("(" + SET_OPTION_STR + " :" + option + " " + value + ")"); +} + +void GenericSolver::set_logic(const std::string logic) +{ + run_command("(" + SET_LOGIC_STR + " " + logic + ")"); +} + +void GenericSolver::assert_formula(const Term & t) +{ + // cast to generic term, as we need to print it to the solver + shared_ptr lt = static_pointer_cast(t); + + // obtain the name of the term from the internal map + assert(term_name_map->find(lt) != term_name_map->end()); + string name = (*term_name_map)[lt]; + + // communicate the assertion to the binary of the solver + run_command("(" + ASSERT_STR + " " + name + ")"); +} + +Result GenericSolver::str_to_result(string result) const +{ + if (result == "unsat") + { + return Result(UNSAT); + } + else if (result == "sat") + { + return Result(SAT); + } + else if (result == "unknown") + { + return Result(UNKNOWN); + } + else + { + throw NotImplementedException( + "Unimplemented result type from the generic solver. The result was: " + + result); + } +} + +Result GenericSolver::check_sat() +{ + string result = run_command("(" + CHECK_SAT_STR + ")", false); + Result r = str_to_result(result); + return r; +} + +Result GenericSolver::check_sat_assuming(const TermVec & assumptions) +{ + string names; + for (Term t : assumptions) + { + // assumptions can only be Boolean literals + if (t->get_sort()->get_sort_kind() != BOOL) + { + throw IncorrectUsageException( + "Expecting boolean indicator literals but got: " + t->to_string()); + } + + // add the name of the literal to the list of assumptions + assert(term_name_map->find(t) != term_name_map->end()); + names += " " + (*term_name_map)[t]; + } + + // send command to the solver and parse it + string result = + run_command("(" + CHECK_SAT_ASSUMING_STR + " (" + names + "))", false); + Result r = str_to_result(result); + return r; +} + +void GenericSolver::push(uint64_t num) + { + string result = + run_command("(" + PUSH_STR + " " + std::to_string(num) + ")"); + } + +void GenericSolver::pop(uint64_t num) +{ + string result = run_command("(" + POP_STR + " " + std::to_string(num) + ")"); +} + +void GenericSolver::reset_assertions() + { + string result = run_command("(" + RESET_ASSERTIONS_STR + ")"); + } + +} // namespace smt + +#endif // __APPLE__ diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 93863e990..928ba0e66 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -77,7 +77,13 @@ GenericSolver::GenericSolver(string path, name_sort_map(new unordered_map()), sort_name_map(new unordered_map()), name_term_map(new unordered_map()), - term_name_map(new unordered_map()) + term_name_map(new unordered_map()), + name_datatypedecl_map(new unordered_map()), + datatypedecl_name_map(new unordered_map()), + name_datatypeconsdecl_map(new unordered_map()), + datatypeconsdecl_name_map(new unordered_map()), + dtdecl_dtconsdecl_map(new unordered_map>()), + dtconsdecl_selector_map(new unordered_map>) { // Buffer sizes over 256 caused issues in tests. // Until this is investigated, we support a conservative @@ -186,7 +192,11 @@ void GenericSolver::write_internal(string str) const strcpy(write_buf, str.substr(written_chars, substr_size).c_str()); write(outpipefd[1], write_buf, substr_size); written_chars += substr_size; + cout << "writebutf" << endl; + cout << write_buf << endl; } + //cout << "outpipe" << endl; + //cout << outpipefd[1] << endl; } bool GenericSolver::is_done(int just_read, std::string result) const @@ -239,12 +249,19 @@ string GenericSolver::read_internal() const while (!done) { // read command, and how many chars were read. + //cout <<"readbuf" << endl; + //cout <find(dtName) == name_sort_map->end()) { + //std::string dtName = (*datatypedecl_name_map)[d]; + //Sort dtSort = make_generic_sort(DATATYPE); + std::string rawText = "(declare-datatypes (("; + //rawText += " "; + rawText += dtName; + rawText += " 0)) (\n"; + rawText += "("; + for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[d].size(); ++i ) { + DatatypeConstructorDecl currCons = ((*dtdecl_dtconsdecl_map)[d])[i]; + rawText += " (" + (*datatypeconsdecl_name_map)[currCons]; + for (unsigned long f = 0; f < (*dtconsdecl_selector_map)[currCons].size(); ++f) { + rawText += " ( " + (*dtconsdecl_selector_map)[currCons][f].name; + rawText += " " + ((*dtconsdecl_selector_map)[currCons][f].sort)->to_string() + " )"; + } + rawText += ")"; + } + rawText += ")\n))"; + //cout << "This is the rawText:" << endl; + //cout << rawText << endl; + cout << "This is what's sent to the solver: \n"; + cout << rawText << endl; + //run_command(rawText); + //Sort dtSort = make_shared(DATATYPE); + Sort dtSort = make_generic_sort(DATATYPE); + cout << REAL << endl; + cout << "dtsort to string says:" << endl; + cout << dtSort->to_string() << endl; + cout << "Finished run command!" << endl; + (*name_sort_map)[dtName] = dtSort; + cout << "DId one assignment" + dtName << endl; + *dtSort; + cout << "cant dereference" << endl; + //cout << dtSort << endl; + (*sort_name_map)[dtSort] = dtName; + //Sort dtSort = make_sort(DATATYPE); + cout << "Finsihed map assignment" << endl; + run_command(rawText); + //Sort dtSort = make_sort(INT); + return dtSort; + + } + else { + throw NotImplementedException("Generic Solvers do not support "); + + } } DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) { - throw NotImplementedException("Generic Solvers do not support datatypes"); + DatatypeDecl newDT = make_shared(); + //shared_ptr + (*name_datatypedecl_map)[s] = newDT; + (*datatypedecl_name_map)[newDT] = s; + return newDT; } DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( const std::string s) { - throw NotImplementedException("Generic Solvers do not support datatypes"); + //throw NotImplementedException("Generic Solvers do not support + //datatypes"); + //shared_ptr newDTC = + //make_shared(); + DatatypeConstructorDecl newDTC = make_shared(); + + //DatatypeConstructorDecl newDTC = make_shared(); + // DLETE + cout << "current map entry\n" + (*datatypeconsdecl_name_map)[newDTC] << endl; + (*name_datatypeconsdecl_map)[s] = newDTC; + (*datatypeconsdecl_name_map)[newDTC] = s; + return newDTC; } void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructorDecl & con) const { - throw NotImplementedException("Generic Solvers do not support datatypes"); + //throw NotImplementedException("Generic Solvers do not support datatypes"); + //dtdecl_dtconsdecl_map; + cout << "Every construcotr attached: before map assign,ent" << endl; + for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[dt].size(); ++i) { + cout << "\nConstructor #" + std::to_string(i) << endl; + cout << (*datatypeconsdecl_name_map)[(((*dtdecl_dtconsdecl_map)[dt])[i])] << endl; + } + + (*dtdecl_dtconsdecl_map)[dt].push_back(con); + + cout << "Every construcotr attached: after map assignment" << endl; + for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[dt].size(); ++i) { + cout << "\nConstructor #" + std::to_string(i) << endl; + cout << (*datatypeconsdecl_name_map)[(((*dtdecl_dtconsdecl_map)[dt])[i])] << endl; + } } void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const { - throw NotImplementedException("Generic Solvers do not support datatypes"); + //throw NotImplementedException("Generic Solvers do not support + //datatypes"); + shared_ptr newSelector = make_shared(); + (*newSelector).name = name; + (*newSelector).sort = s; + (*dtconsdecl_selector_map)[dt].push_back(*newSelector); } void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const { - throw NotImplementedException("Generic Solvers do not support datatypes"); + //throw NotImplementedException("Generic Solvers do not support + //datatypes"); + shared_ptr newSelector = make_shared(); + (*newSelector).name = name; + (*newSelector).sort = make_sort(DATATYPE); + (*dtconsdecl_selector_map)[dt].push_back(*newSelector); } Term GenericSolver::get_constructor(const Sort & s, std::string name) const diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index aee10fad3..fc1cfc1af 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -35,7 +35,7 @@ Sort make_uninterpreted_generic_sort(Sort sort_cons, Sort make_generic_sort(SortKind sk) { - if (sk != BOOL && sk != INT && sk != REAL) + if (sk != BOOL && sk != INT && sk != REAL && sk != DATATYPE) { throw IncorrectUsageException("Can't create sort from " + to_string(sk)); } diff --git a/src/solver_enums.cpp b/src/solver_enums.cpp index 30c1ef328..8f2d79279 100644 --- a/src/solver_enums.cpp +++ b/src/solver_enums.cpp @@ -63,6 +63,7 @@ const unordered_map> THEORY_REAL, ARRAY_FUN_BOOLS, UNSAT_CORE, + THEORY_DATATYPE, QUANTIFIERS } }, { MSAT, diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 613ffa549..82ec6df0c 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -46,18 +46,25 @@ TEST_P(DTTests, DatatypeDecl) if (sc.is_logging_solver) { return; } - Term five = s->make_term(5, intsort); + //Term five = s->make_term(5, intsort); // Make datatype sort DatatypeDecl consListSpec = s->make_datatype_decl("list"); DatatypeConstructorDecl nildecl = s->make_datatype_constructor_decl("nil"); + //DatatypeConstructorDecl consdecl = s->make_datatype_constructor_decl("cons"); + //s->add_selector(consdecl, "head", s->make_sort(INT)); + //s->add_selector_self(consdecl, "tail"); + s->add_constructor(consListSpec, nildecl); + + //DELETE DatatypeConstructorDecl consdecl = s->make_datatype_constructor_decl("cons"); s->add_selector(consdecl, "head", s->make_sort(INT)); - s->add_selector_self(consdecl, "tail"); - s->add_constructor(consListSpec, nildecl); s->add_constructor(consListSpec, consdecl); - Sort listsort = s->make_sort(consListSpec); + //cout << (*datatypedecl_name_map)[consListSpec] << endl; + Sort listsort = s->make_sort(consListSpec); + cout << "created the sort" << endl; + /* Datatype listdt = listsort->get_datatype(); // Make datatype terms Term cons = s->get_constructor(listsort,"cons"); @@ -90,7 +97,9 @@ TEST_P(DTTests, DatatypeDecl) EXPECT_THROW(s->get_constructor(listsort, "kons"), InternalSolverException); EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); EXPECT_THROW(s->get_selector(listsort, "nil", "head"), InternalSolverException); - EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); + EXPECT_THROW(listdt->get_num_selectors("kons"), + InternalSolverException); + */ } INSTANTIATE_TEST_SUITE_P(ParameterizedSolverDTTests, diff --git a/tests/test-generic-sort.cpp b/tests/test-generic-sort.cpp index de50464c5..81c357335 100644 --- a/tests/test-generic-sort.cpp +++ b/tests/test-generic-sort.cpp @@ -70,5 +70,20 @@ int main() assert(us1 != us3); assert(us1->get_uninterpreted_name() == "sort1"); assert(us1->get_arity() == 0); + + GenericSort d1(DATATYPE); + GenericSort d2(DATATYPE); + std::cout << "testing basic properties of datatype sorts" << std::endl; + assert(d1.hash() == d2.hash()); + assert(d1.to_string() == d2.to_string()); + cout << "d1 to string" + d1.to_string() << endl; + assert(d2.to_string() == d1.to_string()); + assert((d1.get_sort_kind()) == (d2.get_sort_kind())); + assert(d1.get_sort_kind() == DATATYPE); + + Sort dt1 = make_generic_sort(DATATYPE); + Sort dt2 = make_generic_sort(DATATYPE); + assert(dt1 == dt2); + return 0; } From 2c76b8344c74edd0f81fe0b7a77b07d47d18a382 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Thu, 24 Jun 2021 18:07:34 -0700 Subject: [PATCH 02/47] Cleaned up the code, removed erroneous print statements, eliminated the segfault. --- include/generic_solver.h | 11 + include/generic_sort.h | 1 + include/smtlib_utils.h | 1 + src/#generic_solver.cpp# | 1213 ----------------------------------- src/generic_solver.cpp | 94 +-- src/generic_sort.cpp | 8 +- tests/test-generic-sort.cpp | 2 +- 7 files changed, 42 insertions(+), 1288 deletions(-) delete mode 100644 src/#generic_solver.cpp# diff --git a/include/generic_solver.h b/include/generic_solver.h index db90f2218..0d28216c9 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -252,18 +252,29 @@ class GenericSolver : public AbsSmtSolver std::unique_ptr> name_term_map; std::unique_ptr> term_name_map; + // maps between datatype declaration and name and vice versa std::unique_ptr> name_datatypedecl_map; std::unique_ptr> datatypedecl_name_map; + // maps between datatype constructor declaration and name, and vice versa std::unique_ptr> name_datatypeconsdecl_map; std::unique_ptr> datatypeconsdecl_name_map; + // map linking each datatype declaration with a vector of constructors std::unique_ptr>> dtdecl_dtconsdecl_map; + // A struct keeeping track of what each selector needs: a name and + // sort + // These are usually defined at the beginning of the file, I left it + // here for clarity of usage struct selectorComponents { std::string name; Sort sort; }; + + // a map linking each datatype constructor declaration with a vector + // holding its associated selectors, in the form of the previously + // defined struct. std::unique_ptr>> dtconsdecl_selector_map; // used to hash terms via their internal string representation std::hash str_hash; diff --git a/include/generic_sort.h b/include/generic_sort.h index cdcd5c818..b2c21c609 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -16,6 +16,7 @@ #pragma once + #include "exceptions.h" #include "smt_defs.h" #include "sort.h" diff --git a/include/smtlib_utils.h b/include/smtlib_utils.h index 80125d8fd..3993f08af 100644 --- a/include/smtlib_utils.h +++ b/include/smtlib_utils.h @@ -35,3 +35,4 @@ const std::string RESET_STR = "reset"; const std::string INTERPOLATION_GROUP_STR = "interpolation-group"; const std::string MSAT_GET_INTERPOLANT_STR = "get-interpolant"; const std::string CVC4_GET_INTERPOLANT_STR = "get-interpol"; +const std::string DECLARE_DATATYPE_STR = "declare-datatypes"; diff --git a/src/#generic_solver.cpp# b/src/#generic_solver.cpp# deleted file mode 100644 index b8088aff8..000000000 --- a/src/#generic_solver.cpp# +++ /dev/null @@ -1,1213 +0,0 @@ -/********************* */ -/*! \file generic_solver.cpp -** \verbatim -** Top contributors (to current version): -** Yoni Zohar -** This file is part of the smt-switch project. -** Copyright (c) 2020 by the authors listed in the file AUTHORS -** in the top-level source directory) and their institutional affiliations. -** All rights reserved. See the file LICENSE in the top-level source -** directory for licensing information.\endverbatim -** -** -** \brief A class that represents a generic solver -** -**/ - -/* Uses code to interact with a process from: -** https://stackoverflow.com/a/6172578/1364765 -*/ - -// generic solvers are not supported on macos -#ifndef __APPLE__ - -#include "generic_solver.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include "assert.h" -#include "smtlib_utils.h" -#include "sort.h" -#include "sort_inference.h" -#include "utils.h" - -using namespace std; - -namespace smt { - -// helper functions -bool is_new_line(char c) { return (c == '\n' || c == '\r' || c == 0); } - -// from: https://stackoverflow.com/a/36000453/1364765 -std::string & trim(std::string & str) -{ - // right trim - while (str.length() > 0 - && (str[str.length() - 1] == ' ' || str[str.length() - 1] == '\t' - || str[str.length() - 1] == '\n')) - str.erase(str.length() - 1, 1); - - // left trim - while (str.length() > 0 - && (str[0] == ' ' || str[0] == '\t' || str[0] == '\n')) - str.erase(0, 1); - return str; -} - -// class methods implementation -GenericSolver::GenericSolver(string path, - vector cmd_line_args, - uint write_buf_size, - uint read_buf_size) - : AbsSmtSolver(SolverEnum::GENERIC_SOLVER), - path(path), - cmd_line_args(cmd_line_args), - write_buf_size(write_buf_size), - read_buf_size(read_buf_size), - name_sort_map(new unordered_map()), - sort_name_map(new unordered_map()), - name_term_map(new unordered_map()), - term_name_map(new unordered_map()), - name_datatypedecl_map(new unordered_map()), - datatypedecl_name_map(new unordered_map()), - name_datatypeconsdecl_map(new unordered_map()), - datatypeconsdecl_name_map(new unordered_map()), - dtdecl_dtconsdecl_map(new unordered_map>()), - dtconsdecl_selector_map(new unordered_map>) -{ - // Buffer sizes over 256 caused issues in tests. - // Until this is investigated, we support a conservative - // limit of 256. - // Similarly for buffers of size 1. - if (write_buf_size < 2 || write_buf_size > 256 || read_buf_size < 2 - || read_buf_size > 256) - { - string msg( - "Generic Solvers require a buffer size of at least 2 and at most 256."); - throw IncorrectUsageException(msg); - } - term_counter = new uint; - //allocate memory for the buffers - write_buf = new char[write_buf_size]; - read_buf = new char[read_buf_size]; - - //make sure allocation was successful - assert(write_buf != NULL); - assert(read_buf != NULL); - //initialize write_buf - for (int i=0; i < write_buf_size; i++) { - write_buf[i]=0; - } - //initialize read_buf - for (int i=0; i < read_buf_size; i++) { - read_buf[i]=0; - } - - // start the process with the solver binary - start_solver(); -} - -GenericSolver::~GenericSolver() { - //deallocate the buffers memory - delete write_buf; - delete read_buf; - delete term_counter; - // close the solver process - close_solver(); -} - -void GenericSolver::start_solver() { - pid = 0; - - pipe(inpipefd); - pipe(outpipefd); - pid = fork(); - if (pid == 0) - { - // Child - dup2(outpipefd[0], STDIN_FILENO); - dup2(inpipefd[1], STDOUT_FILENO); - dup2(inpipefd[1], STDERR_FILENO); - - // ask kernel to deliver SIGTERM in case the parent dies - prctl(PR_SET_PDEATHSIG, SIGTERM); - // fcntl(inpipefd[1], F_SETFL, O_NONBLOCK); - // The following part is based on: - // https://stackoverflow.com/a/5797901/1364765 The execv command expects an - // array, and so we create one. First element is the program name, last - // element is NULL, and in between are the elements of cmd_line_args, casted - // to (char*) from std::string. Here we identify the program name with its - // path. - const char ** argv = new const char *[cmd_line_args.size() + 2]; - argv[0] = path.c_str(); - for (int i = 1; i <= cmd_line_args.size(); i++) - { - argv[i] = cmd_line_args[i - 1].c_str(); - } - argv[cmd_line_args.size() + 1] = NULL; - execv(path.c_str(), (char **)argv); - // Nothing below this line should be executed by child process. If so, - // it means that the execl function wasn't successfull, so lets exit: - string msg("failure to run binary: "); - msg += path; - throw IncorrectUsageException(msg); - exit(1); - } - // close unused pipe ends - close(outpipefd[0]); - close(inpipefd[1]); - set_opt("print-success", "true"); -} - -void GenericSolver::write_internal(string str) const -{ - // track how many charas were written so far - uint written_chars = 0; - // continue writing until entire str was written - while (written_chars < str.size()) - { - // how many characters are there left to write - uint remaining = str.size() - written_chars; - // how many characters are we writing in this iteration - uint substr_size; - if (remaining < write_buf_size) - { - substr_size = remaining; - } - else - { - substr_size = write_buf_size; - } - // write - strcpy(write_buf, str.substr(written_chars, substr_size).c_str()); - write(outpipefd[1], write_buf, substr_size); - written_chars += substr_size; - cout << "writebutf" << endl; - cout << write_buf << endl; - } - //cout << "outpipe" << endl; - //cout << outpipefd[1] << endl; -} - -bool GenericSolver::is_done(int just_read, std::string result) const -{ - bool done = false; - int count = 0; - // if we didn't read anything now, the command is done executing - if (just_read == 0) - { - done = true; - } - else if (result[0] == '(') - { - // if the output of the solver starts with '(' - // we will be done only when we see the matching ')' - for (int i = 0; i < result.size(); i++) - { - if (result[i] == '(') - { - count++; - } - else if (result[i] == ')') - { - count--; - } - } - done = (count == 0) && is_new_line(result[result.size() - 1]); - } - else - { - // if the output of the solver does not start with '(' - // we will be done when we reach a newline character - assert(just_read <= read_buf_size); - for (int i = 0; i < just_read; i++) - { - if (is_new_line(read_buf[i])) - { - done = true; - } - } - } - return done; -} - -string GenericSolver::read_internal() const -{ - string result = ""; - bool done = false; - // read to the buffer until no more output to read - while (!done) - { - // read command, and how many chars were read. - //cout <<"readbuf" << endl; - //cout <find(res_sort) != sort_name_map->end()); - // send a define-fun to the binary - run_command("(" + DEFINE_FUN_STR + " " + name + " () " - + (*sort_name_map)[res_sort] + " " + to_smtlib_def(defining_term) - + ")"); -} - -std::string GenericSolver::to_smtlib_def(Term term) const -{ - // cast to generic term - shared_ptr gt = static_pointer_cast(term); - // generic terms with no operators are represented by their - // name. - if (gt->get_op().is_null()) - { - return gt->to_string(); - } - else - { - // generic terms with operators are written as s-expressions. - string result = "("; - // The Apply operator is ignored and the - // function being applied is used instead. - result += - ((term->get_op().prim_op == Apply) ? "" : term->get_op().to_string()); - // For quantifiers we separate the bound variables list - // and the formula body. - if (term->get_op().prim_op == Forall || term->get_op().prim_op == Exists) - { - result += " ((" + (*term_name_map)[gt->get_children()[0]] + " " - + (*sort_name_map)[gt->get_children()[0]->get_sort()] + ")) " - + (*term_name_map)[gt->get_children()[1]]; - } - else - { - // in the general case (other than quantifiers - // and Apply), we use ordinary - // s-expressions notation and write a - // space-separated list of arguments. - for (auto c : gt->get_children()) - { - result += " " + (*term_name_map)[c]; - } - } - result += ")"; - return result; - } -} - -Sort GenericSolver::make_sort(const Sort & sort_con, const SortVec & sorts) const { - throw NotImplementedException( - "Sort constructor are not supported by generic solvers"); -} - -Sort GenericSolver::make_sort(const std::string name, uint64_t arity) const { - // when creating a new uninterpreted sort, the name - // must be new. - if (name_sort_map->find(name) == name_sort_map->end()) - { - // create the sort - Sort sort = make_uninterpreted_generic_sort(name, arity); - // store the sort and the name in the maps - (*name_sort_map)[name] = sort; - (*sort_name_map)[sort] = name; - // declare the sort to the binary of the solver - run_command("(" + DECLARE_SORT_STR + " " + name + " " - + std::to_string(arity) + ")"); - return sort; - } - else - { - throw IncorrectUsageException(string("sort name: ") + name - + string(" already taken")); - } -} - -Sort GenericSolver::make_sort(const SortKind sk) const -{ - // create the sort - Sort sort = make_generic_sort(sk); - // compute the name of the sort - string name = sort->to_string(); - - // note that nothing needs to be communicated to the solver, - // as in this case the sort is built in. - - // store in local maps if needed, and return the sort - if (name_sort_map->find(name) == name_sort_map->end()) - { - (*name_sort_map)[name] = sort; - (*sort_name_map)[sort] = name; - return sort; - } - else - { - return name_sort_map->at(name); - } -} - -Sort GenericSolver::make_sort(const SortKind sk, uint64_t size) const -{ - // create the sort - Sort sort = make_generic_sort(sk, size); - // compute the name - string name = sort->to_string(); - - // note that nothing needs to be communicated to the solver, - // as in this case the sort is built in. - - // store in maps if needed and return the sort - if (name_sort_map->find(name) == name_sort_map->end()) - { - (*name_sort_map)[name] = sort; - (*sort_name_map)[sort] = name; - return sort; - } - else - { - return name_sort_map->at(name); - } -} - -Sort GenericSolver::make_sort(const SortKind sk, const Sort & sort1) const -{ - return make_sort(sk, SortVec({ sort1 })); -} - -Sort GenericSolver::make_sort(const SortKind sk, - const Sort & sort1, - const Sort & sort2) const -{ - return make_sort(sk, SortVec({ sort1, sort2 })); -} - -Sort GenericSolver::make_sort(const SortKind sk, - const Sort & sort1, - const Sort & sort2, - const Sort & sort3) const -{ - return make_sort(sk, SortVec({ sort1, sort2, sort3 })); -} - -Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const -{ - // create the sort - Sort sort = make_generic_sort(sk, sorts); - // compute the name - string name = sort->to_string(); - - // note that nothing needs to be communicated to the solver, - // as in this case the sort is built in, or can used - // by combining sorts that were already defined. - - // store in maps if needed and return the sort - if (name_sort_map->find(name) == name_sort_map->end()) - { - (*name_sort_map)[name] = sort; - (*sort_name_map)[sort] = name; - return sort; - } - else - { - return name_sort_map->at(name); - } -} - -Sort GenericSolver::make_sort(const DatatypeDecl & d) const -{ - //throw NotImplementedException("Generic Solvers do not support - //datatypes"); - std::string dtName = (*datatypedecl_name_map)[d]; - if (name_sort_map->find(dtName) == name_sort_map->end()) { - //std::string dtName = (*datatypedecl_name_map)[d]; - //Sort dtSort = make_generic_sort(DATATYPE); - std::string rawText = "(declare-datatypes (("; - //rawText += " "; - rawText += dtName; - rawText += " 0)) (\n"; - rawText += "("; - for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[d].size(); ++i ) { - DatatypeConstructorDecl currCons = ((*dtdecl_dtconsdecl_map)[d])[i]; - rawText += " (" + (*datatypeconsdecl_name_map)[currCons]; - for (unsigned long f = 0; f < (*dtconsdecl_selector_map)[currCons].size(); ++f) { - rawText += " ( " + (*dtconsdecl_selector_map)[currCons][f].name; - rawText += " " + ((*dtconsdecl_selector_map)[currCons][f].sort)->to_string() + " )"; - } - rawText += ")"; - } - rawText += ")\n))"; - //cout << "This is the rawText:" << endl; - //cout << rawText << endl; - cout << "This is what's sent to the solver: \n"; - cout << rawText << endl; - //run_command(rawText); - //Sort dtSort = make_shared(DATATYPE); - Sort dtSort = make_sort(DATATYPE); - cout << dtSort->to_string() << endl; - cout << "Finished run command!" << endl; - (*name_sort_map)[dtName] = dtSort; - cout << "DId one assignment" + dtName << endl; - *dtSort; - cout << "cant dereference" << endl; - //cout << dtSort << endl; - (*sort_name_map)[dtSort] = dtName; - //Sort dtSort = make_sort(DATATYPE); - cout << "Finsihed map assignment" << endl; - run_command(rawText); - //Sort dtSort = make_sort(INT); - return dtSort; - - } - else { - throw NotImplementedException("Generic Solvers do not support "); - - } -} - -DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) -{ - DatatypeDecl newDT = make_shared(); - //shared_ptr - (*name_datatypedecl_map)[s] = newDT; - (*datatypedecl_name_map)[newDT] = s; - return newDT; -} -DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( - const std::string s) -{ - //throw NotImplementedException("Generic Solvers do not support - //datatypes"); - //shared_ptr newDTC = - //make_shared(); - DatatypeConstructorDecl newDTC = make_shared(); - - //DatatypeConstructorDecl newDTC = make_shared(); - // DLETE - cout << "current map entry\n" + (*datatypeconsdecl_name_map)[newDTC] << endl; - (*name_datatypeconsdecl_map)[s] = newDTC; - (*datatypeconsdecl_name_map)[newDTC] = s; - return newDTC; -} - -void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructorDecl & con) const - { - //throw NotImplementedException("Generic Solvers do not support datatypes"); - //dtdecl_dtconsdecl_map; - cout << "Every construcotr attached: before map assign,ent" << endl; - for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[dt].size(); ++i) { - cout << "\nConstructor #" + std::to_string(i) << endl; - cout << (*datatypeconsdecl_name_map)[(((*dtdecl_dtconsdecl_map)[dt])[i])] << endl; - } - - (*dtdecl_dtconsdecl_map)[dt].push_back(con); - - cout << "Every construcotr attached: after map assignment" << endl; - for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[dt].size(); ++i) { - cout << "\nConstructor #" + std::to_string(i) << endl; - cout << (*datatypeconsdecl_name_map)[(((*dtdecl_dtconsdecl_map)[dt])[i])] << endl; - } -} -void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const -{ - //throw NotImplementedException("Generic Solvers do not support - //datatypes"); - shared_ptr newSelector = make_shared(); - (*newSelector).name = name; - (*newSelector).sort = s; - (*dtconsdecl_selector_map)[dt].push_back(*newSelector); -} - -void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const - { - //throw NotImplementedException("Generic Solvers do not support - //datatypes"); - shared_ptr newSelector = make_shared(); - (*newSelector).name = name; - (*newSelector).sort = make_sort(DATATYPE); - (*dtconsdecl_selector_map)[dt].push_back(*newSelector); -} - -Term GenericSolver::get_constructor(const Sort & s, std::string name) const -{ - throw NotImplementedException("Generic Solvers do not support datatypes"); -} - - -Term GenericSolver::get_tester(const Sort & s, std::string name) const -{ - throw NotImplementedException("Generic Solvers do not support datatypes"); -} - -Term GenericSolver::get_selector(const Sort & s, std::string con, std::string name) const -{ - throw NotImplementedException("Generic Solvers do not support datatypes"); -} - -std::string GenericSolver::get_name(Term term) const -{ - // the names of the terms are `t_i` with a running `i`. - // These names are used for `define-fun` commands. - *term_counter = (*term_counter) + 1; - return "t_" + std::to_string((*term_counter)); -} - -Term GenericSolver::store_term(Term term) const -{ - // cast the term to a GenericTerm - shared_ptr gterm = static_pointer_cast(term); - // store the term in the maps in case it is not there already - if (term_name_map->find(gterm) == term_name_map->end()) - { - string name; - // ground terms are communicated to the binary - // using a define-fun command. - // In future instances of this term, we will use the name - // of the defined function. - // For example: if `term` is `0`, and `name` is `t1`, - // we send a command: - // `(define-fun t1 () Int 0)` - // If in the future we see a term `0+0`, it will - // be sent to the solver as `(+ t1 t1)`. - // - // However, terms with bound variables cannot be given to - // a define-fun command. For them, we store - // their actual definition. - // In future instances, the entire definition will be used. - if (gterm->is_ground()) - { - name = get_name(gterm); - define_fun(name, SortVec{}, gterm->get_sort(), gterm); - } - else - { - name = to_smtlib_def(gterm); - } - (*name_term_map)[name] = gterm; - (*term_name_map)[gterm] = name; - } - // return the term from the internal map - string name = (*term_name_map)[gterm]; - return (*name_term_map)[name]; -} - -Term GenericSolver::make_non_negative_bv_const(string abs_decimal, - uint width) const -{ - Sort bvsort = make_sort(BV, width); - string repr = "(_ bv" + abs_decimal + " " + std::to_string(width) + ")"; - Term term = std::make_shared(bvsort, Op(), TermVec{}, repr); - return term; -} - -Term GenericSolver::make_non_negative_bv_const(int64_t i, uint width) const -{ - assert(i >= 0); - return make_non_negative_bv_const(std::to_string(i), width); -} - -Term GenericSolver::make_negative_bv_const(string abs_decimal, uint width) const -{ - Term zero = make_non_negative_bv_const("0", width); - Term abs = make_non_negative_bv_const(abs_decimal, width); - Term result = make_term(BVSub, zero, abs); - return result; -} - -Term GenericSolver::make_negative_bv_const(int64_t abs_value, uint width) const -{ - assert(abs_value >= 0); - return make_negative_bv_const(std::to_string(abs_value), width); -} - -Term GenericSolver::make_term(bool b) const -{ - Term value_term = make_value(b); - return store_term(value_term); -} - -Term GenericSolver::make_value(bool b) const -{ - // create a generic term that represents `b`. - Sort boolsort = make_sort(BOOL); - Term term = std::make_shared( - boolsort, Op(), TermVec{}, b ? "true" : "false"); - return term; -} - -Term GenericSolver::make_term(int64_t i, const Sort & sort) const -{ - Term value_term = make_value(i, sort); - return store_term(value_term); -} - -Term GenericSolver::make_value(int64_t i, const Sort & sort) const -{ - SortKind sk = sort->get_sort_kind(); - assert(sk == BV || sk == INT || sk == REAL); - if (sk == INT || sk == REAL) - { - string repr = std::to_string(i); - Term term = std::make_shared(sort, Op(), TermVec{}, repr); - return term; - } - else - { - // sk == BV - if (i < 0) - { - int64_t abs_value = i * (-1); - Term term = make_negative_bv_const(abs_value, sort->get_width()); - return term; - } - else - { - Term term = make_non_negative_bv_const(i, sort->get_width()); - return term; - } - } -} - -Term GenericSolver::make_term(const string val, - const Sort & sort, - uint64_t base) const -{ - Term value_term = make_value(val, sort, base); - return store_term(value_term); -} - -Term GenericSolver::make_value(const string val, - const Sort & sort, - uint64_t base) const -{ - SortKind sk = sort->get_sort_kind(); - assert(sk == BV || sk == INT || sk == REAL); - assert(base == 2 || base == 10 | base == 16); - string repr; - if (sk == INT || sk == REAL) - { - assert(base == 10); - repr = val; - Term term = std::make_shared(sort, Op(), TermVec{}, repr); - return term; - } - else - { - // sk == BV - if (base == 10) - { - if (val.find("-") == 0) - { - string abs_decimal = val.substr(1); - return make_negative_bv_const(abs_decimal, sort->get_width()); - } - else - { - return make_non_negative_bv_const(val, sort->get_width()); - } - } - else - { - // base = 2 or 16 - if (base == 2) - { - repr = "#b" + val; - } - else if (base == 16) - { - repr = "#x" + val; - } - Term term = std::make_shared(sort, Op(), TermVec{}, repr); - return term; - } - } -} - -string GenericSolver::cons_arr_string(const Term & val, const Sort & sort) const -{ - assert(term_name_map->find(val) != term_name_map->end()); - assert(sort_name_map->find(sort) != sort_name_map->end()); - return "((as const " + (*sort_name_map)[sort] + ") " + val->to_string() - + ") "; -} - -Term GenericSolver::make_term(const Term & val, const Sort & sort) const -{ - assert(sort->get_sort_kind() == ARRAY); - assert(sort->get_elemsort() == val->get_sort()); - Term term = std::make_shared( - sort, Op(), TermVec{ val }, cons_arr_string(val, sort)); - return store_term(term); -} - -Term GenericSolver::make_symbol(const string name, const Sort & sort) -{ - // make sure that the symbol name is not aready taken. - if (name_term_map->find(name) != name_term_map->end()) - { - throw IncorrectUsageException( - string("symbol name: ") + name - + string(" already taken, either by another symbol or by a param")); - } - - // create the sumbol and store it in the maps - Term term = std::make_shared(sort, Op(), TermVec{}, name, true); - (*name_term_map)[name] = term; - (*term_name_map)[term] = name; - - // communicate the creation of the symbol to the binary of the solver. - // When the sort is not a fucntion, we specify an empty domain. - // Otherwise, the name of the sort includes the domain. - run_command("(" + DECLARE_FUN_STR + " " + name - + (sort->get_sort_kind() == FUNCTION ? " " : " () ") - + (*sort_name_map)[sort] + ")"); - - // return the created symbol as a term - return (*name_term_map)[name]; -} - -Term GenericSolver::make_param(const string name, const Sort & sort) -{ - if (name_term_map->find(name) != name_term_map->end()) - { - throw IncorrectUsageException( - string("param name: ") + name - + string(" already taken, either by another param or by a symbol")); - } - Term term = std::make_shared(sort, Op(), TermVec{}, name, false); - (*name_term_map)[name] = term; - (*term_name_map)[term] = name; - return (*name_term_map)[name]; -} - -Term GenericSolver::make_term(const Op op, const Term & t) const -{ - return make_term(op, TermVec({ t })); -} - -Term GenericSolver::make_term(const Op op, - const Term & t1, - const Term & t2) const -{ - return make_term(op, TermVec({ t1, t2 })); -} - -Term GenericSolver::make_term(const Op op, - const Term & t1, - const Term & t2, - const Term & t3) const -{ - return make_term(op, TermVec({ t1, t2, t3 })); -} - -Term GenericSolver::make_term(const Op op, const TermVec & terms) const -{ - Sort sort = compute_sort(op, this, terms); - string repr = "(" + op.to_string(); - for (int i = 0; i < terms.size(); i++) - { - assert((*term_name_map).find(terms[i]) != (*term_name_map).end()); - repr += " " + (*term_name_map)[terms[i]]; - } - repr += ")"; - Term term = std::make_shared(sort, op, terms, repr); - Term stored_term = store_term(term); - return stored_term; -} - -Term GenericSolver::get_value(const Term & t) const -{ - // we do not support getting array values, function values, and uninterpreted - // values. - Sort sort = t->get_sort(); - assert(sort->get_sort_kind() != ARRAY && sort->get_sort_kind() != FUNCTION - && sort->get_sort_kind() != UNINTERPRETED); - - // get the name of the term (the way the term is defined in the solver) - assert(term_name_map->find(t) != term_name_map->end()); - string name = (*term_name_map)[t]; - - // ask the binary for the value and parse it - string result = run_command("(" + GET_VALUE_STR + " (" + name + "))", false); - - // check that there was no error - check_no_error(result); - - string value = strip_value_from_result(result); - - // translate the string representation of the result into a term - Term resulting_term; - // for bit-vectors, we distinguish between the solver's way of representing - // them. it can be either binary, hex, or decimal. - if (sort->get_sort_kind() == BV) - { - if (value.substr(0, 2) == "#b") - { - // bianry representation - resulting_term = make_value(value.substr(2, value.size() - 2), sort, 2); - } - else if (value.substr(0, 2) == "#x") - { - // hex representation - resulting_term = make_value(value.substr(2, value.size() - 2), sort, 16); - } - else - { - // decimal representation. - // parse strings of the form (_ bv ) - size_t index_of__ = value.find("_ "); - assert(index_of__ != string::npos); - int start_of_decimal = index_of__ + 4; - int end_of_decimal = value.find(' ', start_of_decimal); - string decimal = - value.substr(start_of_decimal, end_of_decimal - start_of_decimal + 1); - resulting_term = make_value(decimal, sort, 10); - } - } - else if (sort->get_sort_kind() == BOOL) - { - Assert(value == "true" || value == "false"); - bool b = (value == "true"); - resulting_term = make_value(b); - } - else - { - resulting_term = make_value(value, t->get_sort()); - } - return resulting_term; -} - -string GenericSolver::strip_value_from_result(string result) const -{ - // trim spaces - result = trim(result); - - // value string ends at first ")" or end of string. - int end_of_value = result.size() - 1; - while (result.at(end_of_value) == ')' || result.at(end_of_value) == ' ') - { - end_of_value--; - } - - // value string begins at the first non-space after '(' - int start_of_value = end_of_value; - while (result.at(start_of_value) != '(') - { - start_of_value--; - } - while (result.at(start_of_value) != ' ') - { - start_of_value++; - } - start_of_value++; - - // special case for bit-vectors with smt-lib style - // (_ bv ) - // in this case we only take - if (result.find("bv", start_of_value) == start_of_value) - { - start_of_value -= 3; - end_of_value++; - } - - // crop the relevant substring - string strip = - result.substr(start_of_value, end_of_value - start_of_value + 1); - return strip; -} - -void GenericSolver::get_unsat_assumptions(UnorderedTermSet & out) -{ - // run get-unsat-assumptions command - string result = run_command("(" + GET_UNSAT_ASSUMPTIONS_STR + ")", false); - - // check that there was no error - check_no_error(result); - - // parse the result -- get the assumptions - UnorderedTermSet assumptions = get_assumptions_from_string(result); - - // put the result in out - out.insert(assumptions.begin(), assumptions.end()); -} - -void GenericSolver::check_no_error(string str) const -{ - str = trim(str); - string err_prefix("(error "); - if (str.compare(0, err_prefix.size(), err_prefix) == 0) - { - throw SmtException("Exception from the solver: " + str); - } -} - -UnorderedTermSet GenericSolver::get_assumptions_from_string(string result) const -{ - // the result from the solver is a - // space-separated list of Boolean literals. - UnorderedTermSet literals; - - // trim the result from spaces - result = trim(result); - - // unwrap parenthesis and trim spaces again - string strip = result.substr(1, result.size() - 2); - strip = trim(strip); - - // position in the string - int index = 0; - // if true, current literal is positive. - // otherwise, it has the form (not ) - bool positive; - - // iterate the string - while (index < strip.size()) - { - // beginning and end of literal - int begin; - int end; - - // negative literal - if (strip.substr(index, 5) == "(not ") - { - begin = index + 5; - end = strip.find(")", begin + 1) - 1; - assert(end != string::npos); - positive = false; - } - else - { - // positive literal -- starts with the variable name - begin = index; - // end -- one character after the end of the substring - end = strip.find(" ", begin + 1); - if (end == string::npos) - { - end = strip.size(); - } - // end -- the actual end of the substring - end--; - positive = true; - } - - // retrieve the literal from the map - string str_atom = strip.substr(begin, end - begin + 1); - assert(name_term_map->find(str_atom) != name_term_map->end()); - Term atom = (*name_term_map)[str_atom]; - Term literal; - if (positive) - { - literal = atom; - } - else - { - literal = make_term(Not, atom); - } - - // add the literal to the result - literals.insert(literal); - if (positive) - { - // next beginning is after a space - index = end + 2; - } - else - { - // next beginning is after a space and a ')' - index = end + 3; - } - } - return literals; -} - -UnorderedTermMap GenericSolver::get_array_values(const Term & arr, - Term & out_const_base) const -{ - throw NotImplementedException( - "Generic solvers do not support get-value for arryas"); -} - -void GenericSolver::reset() -{ - string result = run_command("(" + RESET_STR + ")"); -} - -void GenericSolver::set_opt(const std::string option, const std::string value) -{ - run_command("(" + SET_OPTION_STR + " :" + option + " " + value + ")"); -} - -void GenericSolver::set_logic(const std::string logic) -{ - run_command("(" + SET_LOGIC_STR + " " + logic + ")"); -} - -void GenericSolver::assert_formula(const Term & t) -{ - // cast to generic term, as we need to print it to the solver - shared_ptr lt = static_pointer_cast(t); - - // obtain the name of the term from the internal map - assert(term_name_map->find(lt) != term_name_map->end()); - string name = (*term_name_map)[lt]; - - // communicate the assertion to the binary of the solver - run_command("(" + ASSERT_STR + " " + name + ")"); -} - -Result GenericSolver::str_to_result(string result) const -{ - if (result == "unsat") - { - return Result(UNSAT); - } - else if (result == "sat") - { - return Result(SAT); - } - else if (result == "unknown") - { - return Result(UNKNOWN); - } - else - { - throw NotImplementedException( - "Unimplemented result type from the generic solver. The result was: " - + result); - } -} - -Result GenericSolver::check_sat() -{ - string result = run_command("(" + CHECK_SAT_STR + ")", false); - Result r = str_to_result(result); - return r; -} - -Result GenericSolver::check_sat_assuming(const TermVec & assumptions) -{ - string names; - for (Term t : assumptions) - { - // assumptions can only be Boolean literals - if (t->get_sort()->get_sort_kind() != BOOL) - { - throw IncorrectUsageException( - "Expecting boolean indicator literals but got: " + t->to_string()); - } - - // add the name of the literal to the list of assumptions - assert(term_name_map->find(t) != term_name_map->end()); - names += " " + (*term_name_map)[t]; - } - - // send command to the solver and parse it - string result = - run_command("(" + CHECK_SAT_ASSUMING_STR + " (" + names + "))", false); - Result r = str_to_result(result); - return r; -} - -void GenericSolver::push(uint64_t num) - { - string result = - run_command("(" + PUSH_STR + " " + std::to_string(num) + ")"); - } - -void GenericSolver::pop(uint64_t num) -{ - string result = run_command("(" + POP_STR + " " + std::to_string(num) + ")"); -} - -void GenericSolver::reset_assertions() - { - string result = run_command("(" + RESET_ASSERTIONS_STR + ")"); - } - -} // namespace smt - -#endif // __APPLE__ diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 928ba0e66..bf717d489 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -192,11 +192,7 @@ void GenericSolver::write_internal(string str) const strcpy(write_buf, str.substr(written_chars, substr_size).c_str()); write(outpipefd[1], write_buf, substr_size); written_chars += substr_size; - cout << "writebutf" << endl; - cout << write_buf << endl; } - //cout << "outpipe" << endl; - //cout << outpipefd[1] << endl; } bool GenericSolver::is_done(int just_read, std::string result) const @@ -249,19 +245,12 @@ string GenericSolver::read_internal() const while (!done) { // read command, and how many chars were read. - //cout <<"readbuf" << endl; - //cout <find(dtName) == name_sort_map->end()) { - //std::string dtName = (*datatypedecl_name_map)[d]; - //Sort dtSort = make_generic_sort(DATATYPE); - std::string rawText = "(declare-datatypes (("; - //rawText += " "; - rawText += dtName; - rawText += " 0)) (\n"; - rawText += "("; + std::string toSolver = "(" + DECLARE_DATATYPE_STR + " (("; + toSolver += dtName; + toSolver += " 0)) (\n"; + toSolver += "("; + // build string for each constructor for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[d].size(); ++i ) { DatatypeConstructorDecl currCons = ((*dtdecl_dtconsdecl_map)[d])[i]; - rawText += " (" + (*datatypeconsdecl_name_map)[currCons]; + toSolver += " (" + (*datatypeconsdecl_name_map)[currCons]; + // adjust string for each selector for (unsigned long f = 0; f < (*dtconsdecl_selector_map)[currCons].size(); ++f) { - rawText += " ( " + (*dtconsdecl_selector_map)[currCons][f].name; - rawText += " " + ((*dtconsdecl_selector_map)[currCons][f].sort)->to_string() + " )"; + toSolver += " ( " + (*dtconsdecl_selector_map)[currCons][f].name; + toSolver += " " + ((*dtconsdecl_selector_map)[currCons][f].sort)->to_string() + " )"; } - rawText += ")"; + toSolver += ")"; } - rawText += ")\n))"; - //cout << "This is the rawText:" << endl; - //cout << rawText << endl; - cout << "This is what's sent to the solver: \n"; - cout << rawText << endl; - //run_command(rawText); - //Sort dtSort = make_shared(DATATYPE); + toSolver += ")\n))"; + // add the sort to the maps Sort dtSort = make_generic_sort(DATATYPE); - cout << REAL << endl; - cout << "dtsort to string says:" << endl; - cout << dtSort->to_string() << endl; - cout << "Finished run command!" << endl; (*name_sort_map)[dtName] = dtSort; - cout << "DId one assignment" + dtName << endl; - *dtSort; - cout << "cant dereference" << endl; - //cout << dtSort << endl; (*sort_name_map)[dtSort] = dtName; - //Sort dtSort = make_sort(DATATYPE); - cout << "Finsihed map assignment" << endl; - run_command(rawText); - //Sort dtSort = make_sort(INT); + run_command(toSolver); return dtSort; - } else { - throw NotImplementedException("Generic Solvers do not support "); - + throw IncorrectUsageException(string("sort name: ") + dtName + string(" already taken")); } } - + DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) { DatatypeDecl newDT = make_shared(); @@ -567,10 +531,6 @@ DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( //shared_ptr newDTC = //make_shared(); DatatypeConstructorDecl newDTC = make_shared(); - - //DatatypeConstructorDecl newDTC = make_shared(); - // DLETE - cout << "current map entry\n" + (*datatypeconsdecl_name_map)[newDTC] << endl; (*name_datatypeconsdecl_map)[s] = newDTC; (*datatypeconsdecl_name_map)[newDTC] = s; return newDTC; @@ -580,19 +540,7 @@ void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructor { //throw NotImplementedException("Generic Solvers do not support datatypes"); //dtdecl_dtconsdecl_map; - cout << "Every construcotr attached: before map assign,ent" << endl; - for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[dt].size(); ++i) { - cout << "\nConstructor #" + std::to_string(i) << endl; - cout << (*datatypeconsdecl_name_map)[(((*dtdecl_dtconsdecl_map)[dt])[i])] << endl; - } - (*dtdecl_dtconsdecl_map)[dt].push_back(con); - - cout << "Every construcotr attached: after map assignment" << endl; - for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[dt].size(); ++i) { - cout << "\nConstructor #" + std::to_string(i) << endl; - cout << (*datatypeconsdecl_name_map)[(((*dtdecl_dtconsdecl_map)[dt])[i])] << endl; - } } void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const { @@ -606,12 +554,12 @@ void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const { - //throw NotImplementedException("Generic Solvers do not support - //datatypes"); + // NOTE: This function is awaiting perfectly completed + // functionality from make_sort shared_ptr newSelector = make_shared(); - (*newSelector).name = name; - (*newSelector).sort = make_sort(DATATYPE); - (*dtconsdecl_selector_map)[dt].push_back(*newSelector); + //(*newSelector).name = name; + //(*newSelector).sort = make_sort(DATATYPE); + //(*dtconsdecl_selector_map)[dt].push_back(*newSelector); } Term GenericSolver::get_constructor(const Sort & s, std::string name) const diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index fc1cfc1af..19473ea65 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -35,6 +35,7 @@ Sort make_uninterpreted_generic_sort(Sort sort_cons, Sort make_generic_sort(SortKind sk) { + // Tweaked to accept datatypes temporarily if (sk != BOOL && sk != INT && sk != REAL && sk != DATATYPE) { throw IncorrectUsageException("Can't create sort from " + to_string(sk)); @@ -42,6 +43,7 @@ Sort make_generic_sort(SortKind sk) return make_shared(sk); } + Sort make_generic_sort(SortKind sk, uint64_t width) { if (sk != BV) @@ -120,7 +122,7 @@ Sort make_generic_sort(SortKind sk, SortVec sorts) // implementations -GenericSort::GenericSort(SortKind sk) : sk(sk) {} + GenericSort::GenericSort(SortKind sk) : sk(sk) {} GenericSort::~GenericSort() {} @@ -170,7 +172,11 @@ string GenericSort::compute_string() const { } } else if (get_sort_kind() == SortKind::UNINTERPRETED_CONS) { return get_uninterpreted_name(); + } else if(get_sort_kind() == SortKind::DATATYPE) { + // Placeholder response to avoid segfaulting + return smt::to_smtlib(SortKind::BOOL); } else { + cout << "right before the assert false" << endl; assert(false); } } diff --git a/tests/test-generic-sort.cpp b/tests/test-generic-sort.cpp index 81c357335..edf8457f4 100644 --- a/tests/test-generic-sort.cpp +++ b/tests/test-generic-sort.cpp @@ -76,7 +76,7 @@ int main() std::cout << "testing basic properties of datatype sorts" << std::endl; assert(d1.hash() == d2.hash()); assert(d1.to_string() == d2.to_string()); - cout << "d1 to string" + d1.to_string() << endl; + cout << d1.to_string() << endl; assert(d2.to_string() == d1.to_string()); assert((d1.get_sort_kind()) == (d2.get_sort_kind())); assert(d1.get_sort_kind() == DATATYPE); From 6e2d3aa07a834da147871c6061ba6fda06707946 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 25 Jun 2021 12:37:58 -0700 Subject: [PATCH 03/47] Updated tweaks to match pr feedback --- include/generic_solver.h | 25 ++++++--- include/generic_sort.h | 1 - src/generic_solver.cpp | 108 ++++++++++++++++++++---------------- src/generic_sort.cpp | 11 ++-- src/solver_enums.cpp | 5 +- tests/test-dt.cpp | 96 +++++++++++++++++--------------- tests/test-generic-sort.cpp | 4 +- 7 files changed, 140 insertions(+), 110 deletions(-) diff --git a/include/generic_solver.h b/include/generic_solver.h index 0d28216c9..e221382b1 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -253,29 +253,38 @@ class GenericSolver : public AbsSmtSolver std::unique_ptr> term_name_map; // maps between datatype declaration and name and vice versa - std::unique_ptr> name_datatypedecl_map; - std::unique_ptr> datatypedecl_name_map; + std::unique_ptr> + name_datatypedecl_map; + std::unique_ptr> + datatypedecl_name_map; // maps between datatype constructor declaration and name, and vice versa - std::unique_ptr> name_datatypeconsdecl_map; - std::unique_ptr> datatypeconsdecl_name_map; + std::unique_ptr> + name_datatypeconsdecl_map; + std::unique_ptr> + datatypeconsdecl_name_map; // map linking each datatype declaration with a vector of constructors - std::unique_ptr>> dtdecl_dtconsdecl_map; + std::unique_ptr< + std::unordered_map>> + dtdecl_dtconsdecl_map; // A struct keeeping track of what each selector needs: a name and // sort // These are usually defined at the beginning of the file, I left it // here for clarity of usage - struct selectorComponents { + struct selectorComponents + { std::string name; - Sort sort; + Sort sort; }; // a map linking each datatype constructor declaration with a vector // holding its associated selectors, in the form of the previously // defined struct. - std::unique_ptr>> dtconsdecl_selector_map; + std::unique_ptr>> + dtconsdecl_selector_map; // used to hash terms via their internal string representation std::hash str_hash; }; diff --git a/include/generic_sort.h b/include/generic_sort.h index b2c21c609..cdcd5c818 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -16,7 +16,6 @@ #pragma once - #include "exceptions.h" #include "smt_defs.h" #include "sort.h" diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index bf717d489..01a64f2f6 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -80,10 +80,14 @@ GenericSolver::GenericSolver(string path, term_name_map(new unordered_map()), name_datatypedecl_map(new unordered_map()), datatypedecl_name_map(new unordered_map()), - name_datatypeconsdecl_map(new unordered_map()), - datatypeconsdecl_name_map(new unordered_map()), - dtdecl_dtconsdecl_map(new unordered_map>()), - dtconsdecl_selector_map(new unordered_map>) + name_datatypeconsdecl_map( + new unordered_map()), + datatypeconsdecl_name_map( + new unordered_map()), + dtdecl_dtconsdecl_map( + new unordered_map>()), + dtconsdecl_selector_map(new unordered_map>) { // Buffer sizes over 256 caused issues in tests. // Until this is investigated, we support a conservative @@ -279,7 +283,6 @@ string GenericSolver::run_command(string cmd, bool verify_success_flag) const write_internal(cmd); // reading the result string result = read_internal(); - //cout << "Result : \n" + result <find(dtName) == name_sort_map->end()) { - std::string toSolver = "(" + DECLARE_DATATYPE_STR + " (("; - toSolver += dtName; - toSolver += " 0)) (\n"; - toSolver += "("; + assert(datatypedecl_name_map->find(d) != datatypedecl_name_map->end()); + std::string dt_decl_name = (*datatypedecl_name_map)[d]; + if (name_sort_map->find(dt_decl_name) == name_sort_map->end()) + { + std::string to_solver = "(" + DECLARE_DATATYPE_STR + " (("; + to_solver += dt_decl_name; + to_solver += " 0)) (\n"; + to_solver += "("; // build string for each constructor - for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[d].size(); ++i ) { - DatatypeConstructorDecl currCons = ((*dtdecl_dtconsdecl_map)[d])[i]; - toSolver += " (" + (*datatypeconsdecl_name_map)[currCons]; + for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[d].size(); ++i) + { + DatatypeConstructorDecl curr_dt_cons_decl = ((*dtdecl_dtconsdecl_map)[d])[i]; + to_solver += " (" + (*datatypeconsdecl_name_map)[curr_dt_cons_decl]; // adjust string for each selector - for (unsigned long f = 0; f < (*dtconsdecl_selector_map)[currCons].size(); ++f) { - toSolver += " ( " + (*dtconsdecl_selector_map)[currCons][f].name; - toSolver += " " + ((*dtconsdecl_selector_map)[currCons][f].sort)->to_string() + " )"; - } - toSolver += ")"; + for (unsigned long f = 0; f < (*dtconsdecl_selector_map)[curr_dt_cons_decl].size(); + ++f) + { + to_solver += " ( " + (*dtconsdecl_selector_map)[curr_dt_cons_decl][f].name; + to_solver += + " " + ((*dtconsdecl_selector_map)[curr_dt_cons_decl][f].sort)->to_string() + + " )"; + } + to_solver += ")"; } - toSolver += ")\n))"; + to_solver += ")\n))"; // add the sort to the maps - Sort dtSort = make_generic_sort(DATATYPE); - (*name_sort_map)[dtName] = dtSort; - (*sort_name_map)[dtSort] = dtName; - run_command(toSolver); - return dtSort; + Sort dt_sort = make_generic_sort(DATATYPE); + (*name_sort_map)[dt_decl_name] = dt_sort; + (*sort_name_map)[dt_sort] = dt_decl_name; + run_command(to_solver); + return dt_sort; } - else { - throw IncorrectUsageException(string("sort name: ") + dtName + string(" already taken")); + else + { + throw IncorrectUsageException(string("sort name: ") + dt_decl_name + + string(" already taken")); } } DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) { - DatatypeDecl newDT = make_shared(); - //shared_ptr - (*name_datatypedecl_map)[s] = newDT; - (*datatypedecl_name_map)[newDT] = s; - return newDT; + DatatypeDecl new_dt_decl = make_shared(); + // shared_ptr + (*name_datatypedecl_map)[s] = new_dt_decl; + (*datatypedecl_name_map)[new_dt_decl] = s; + return new_dt_decl; } DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( const std::string s) { - //throw NotImplementedException("Generic Solvers do not support - //datatypes"); - //shared_ptr newDTC = - //make_shared(); - DatatypeConstructorDecl newDTC = make_shared(); - (*name_datatypeconsdecl_map)[s] = newDTC; - (*datatypeconsdecl_name_map)[newDTC] = s; - return newDTC; + // throw NotImplementedException("Generic Solvers do not support + // datatypes"); + // shared_ptr newDTC = + // make_shared(); + DatatypeConstructorDecl new_dt_cons_decl = make_shared(); + (*name_datatypeconsdecl_map)[s] = new_dt_cons_decl; + (*datatypeconsdecl_name_map)[new_dt_cons_decl] = s; + return new_dt_cons_decl; } - + void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructorDecl & con) const { - //throw NotImplementedException("Generic Solvers do not support datatypes"); - //dtdecl_dtconsdecl_map; + // throw NotImplementedException("Generic Solvers do not support + // datatypes"); dtdecl_dtconsdecl_map; (*dtdecl_dtconsdecl_map)[dt].push_back(con); } void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const { - //throw NotImplementedException("Generic Solvers do not support - //datatypes"); - shared_ptr newSelector = make_shared(); + // throw NotImplementedException("Generic Solvers do not support + // datatypes"); + shared_ptr newSelector = + make_shared(); (*newSelector).name = name; (*newSelector).sort = s; (*dtconsdecl_selector_map)[dt].push_back(*newSelector); @@ -556,7 +569,8 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s { // NOTE: This function is awaiting perfectly completed // functionality from make_sort - shared_ptr newSelector = make_shared(); + shared_ptr newSelector = + make_shared(); //(*newSelector).name = name; //(*newSelector).sort = make_sort(DATATYPE); //(*dtconsdecl_selector_map)[dt].push_back(*newSelector); diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 19473ea65..1b03412d3 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -43,7 +43,6 @@ Sort make_generic_sort(SortKind sk) return make_shared(sk); } - Sort make_generic_sort(SortKind sk, uint64_t width) { if (sk != BV) @@ -122,7 +121,7 @@ Sort make_generic_sort(SortKind sk, SortVec sorts) // implementations - GenericSort::GenericSort(SortKind sk) : sk(sk) {} +GenericSort::GenericSort(SortKind sk) : sk(sk) {} GenericSort::~GenericSort() {} @@ -172,10 +171,14 @@ string GenericSort::compute_string() const { } } else if (get_sort_kind() == SortKind::UNINTERPRETED_CONS) { return get_uninterpreted_name(); - } else if(get_sort_kind() == SortKind::DATATYPE) { + } + else if (get_sort_kind() == SortKind::DATATYPE) + { // Placeholder response to avoid segfaulting return smt::to_smtlib(SortKind::BOOL); - } else { + } + else + { cout << "right before the assert false" << endl; assert(false); } diff --git a/src/solver_enums.cpp b/src/solver_enums.cpp index 8f2d79279..85128fa84 100644 --- a/src/solver_enums.cpp +++ b/src/solver_enums.cpp @@ -41,7 +41,8 @@ const unordered_map> UNSAT_CORE, // TEMP only temporarily disabled until bitwuzla // quantifier refactoring is done - // see https://github.com/bitwuzla/bitwuzla/commit/605f31557ec6c635e3c617d2b0ab257309e994c4 + // see + // https://github.com/bitwuzla/bitwuzla/commit/605f31557ec6c635e3c617d2b0ab257309e994c4 // QUANTIFIERS, BOOL_BV1_ALIASING } }, @@ -63,7 +64,7 @@ const unordered_map> THEORY_REAL, ARRAY_FUN_BOOLS, UNSAT_CORE, - THEORY_DATATYPE, + THEORY_DATATYPE, QUANTIFIERS } }, { MSAT, diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 82ec6df0c..587cf96e1 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -46,60 +46,64 @@ TEST_P(DTTests, DatatypeDecl) if (sc.is_logging_solver) { return; } - //Term five = s->make_term(5, intsort); + /* Original location of five declaration + if (s->get_solver_enum() != GENERIC_SOLVER) { + Term five = s->make_term(5, intsort); + } + */ // Make datatype sort DatatypeDecl consListSpec = s->make_datatype_decl("list"); DatatypeConstructorDecl nildecl = s->make_datatype_constructor_decl("nil"); - //DatatypeConstructorDecl consdecl = s->make_datatype_constructor_decl("cons"); - //s->add_selector(consdecl, "head", s->make_sort(INT)); - //s->add_selector_self(consdecl, "tail"); - s->add_constructor(consListSpec, nildecl); - - //DELETE DatatypeConstructorDecl consdecl = s->make_datatype_constructor_decl("cons"); s->add_selector(consdecl, "head", s->make_sort(INT)); + if (s->get_solver_enum() != GENERIC_SOLVER) { + s->add_selector_self(consdecl, "tail"); + } + s->add_constructor(consListSpec, nildecl); + s->add_constructor(consListSpec, consdecl); - //cout << (*datatypedecl_name_map)[consListSpec] << endl; - Sort listsort = s->make_sort(consListSpec); - cout << "created the sort" << endl; - /* - Datatype listdt = listsort->get_datatype(); - // Make datatype terms - Term cons = s->get_constructor(listsort,"cons"); - Term nil = s->get_constructor(listsort,"nil"); - Term head = s->get_selector(listsort, "cons", "head"); - Term tail = s->get_selector(listsort, "cons", "tail"); - Term isNil = s->get_tester(listsort, "nil"); - - // Datatype ops - Term nilterm = s->make_term(Apply_Constructor,nil); - Term list5 = s->make_term(Apply_Constructor, cons, five, nilterm); - Term five_again = s->make_term(Apply_Selector, head, list5); - - // Expected booleans - s->assert_formula(s->make_term(Equal, five, five_again)); - s->assert_formula(s->make_term(Apply_Tester, isNil, nilterm)); - s->assert_formula(s->make_term( - Not, s->make_term(Apply_Tester, isNil, list5))); - - Result res=s->check_sat(); - - ASSERT_TRUE(listdt->get_name()=="list"); - ASSERT_TRUE(listdt->get_num_constructors()==2); - ASSERT_TRUE(listdt->get_num_selectors("cons")==2); - ASSERT_TRUE(listdt->get_num_selectors("nil")==0); - - ASSERT_TRUE(res.is_sat()); - - // Expected exceptions - EXPECT_THROW(s->get_constructor(listsort, "kons"), InternalSolverException); - EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); - EXPECT_THROW(s->get_selector(listsort, "nil", "head"), InternalSolverException); - EXPECT_THROW(listdt->get_num_selectors("kons"), - InternalSolverException); - */ + Sort listsort = s->make_sort(consListSpec); + if (s->get_solver_enum() != GENERIC_SOLVER) { + + Term five = s->make_term(5, intsort); +Datatype listdt = listsort->get_datatype(); +// Make datatype terms +Term cons = s->get_constructor(listsort,"cons"); +Term nil = s->get_constructor(listsort,"nil"); +Term head = s->get_selector(listsort, "cons", "head"); +Term tail = s->get_selector(listsort, "cons", "tail"); +Term isNil = s->get_tester(listsort, "nil"); + +// Datatype ops +Term nilterm = s->make_term(Apply_Constructor,nil); +Term list5 = s->make_term(Apply_Constructor, cons, five, nilterm); +Term five_again = s->make_term(Apply_Selector, head, list5); + +// Expected booleans +s->assert_formula(s->make_term(Equal, five, five_again)); +s->assert_formula(s->make_term(Apply_Tester, isNil, nilterm)); +s->assert_formula(s->make_term( + Not, s->make_term(Apply_Tester, isNil, list5))); + +Result res=s->check_sat(); + +ASSERT_TRUE(listdt->get_name()=="list"); +ASSERT_TRUE(listdt->get_num_constructors()==2); +ASSERT_TRUE(listdt->get_num_selectors("cons")==2); +ASSERT_TRUE(listdt->get_num_selectors("nil")==0); + +ASSERT_TRUE(res.is_sat()); + +// Expected exceptions +EXPECT_THROW(s->get_constructor(listsort, "kons"), InternalSolverException); +EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); +EXPECT_THROW(s->get_selector(listsort, "nil", "head"), InternalSolverException); +EXPECT_THROW(listdt->get_num_selectors("kons"), +InternalSolverException); + + } } INSTANTIATE_TEST_SUITE_P(ParameterizedSolverDTTests, diff --git a/tests/test-generic-sort.cpp b/tests/test-generic-sort.cpp index edf8457f4..12556b34c 100644 --- a/tests/test-generic-sort.cpp +++ b/tests/test-generic-sort.cpp @@ -76,7 +76,7 @@ int main() std::cout << "testing basic properties of datatype sorts" << std::endl; assert(d1.hash() == d2.hash()); assert(d1.to_string() == d2.to_string()); - cout << d1.to_string() << endl; + cout << d1.to_string() << endl; assert(d2.to_string() == d1.to_string()); assert((d1.get_sort_kind()) == (d2.get_sort_kind())); assert(d1.get_sort_kind() == DATATYPE); @@ -84,6 +84,6 @@ int main() Sort dt1 = make_generic_sort(DATATYPE); Sort dt2 = make_generic_sort(DATATYPE); assert(dt1 == dt2); - + return 0; } From 73091ebd528b54bafd002b65f91a57b8c3415d6a Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Mon, 28 Jun 2021 09:50:41 -0700 Subject: [PATCH 04/47] Made the requested tweaks and created a generic_datatype.h file. The file is still a husk, no members or methods have benn added yet due to compilation errors. --- CMakeLists.txt | 1 + include/generic_datatype.h | 37 ++++++++++++++++++ include/generic_datatype.h~ | 27 +++++++++++++ include/generic_solver.h | 1 + src/generic_solver.cpp | 20 +++++++--- tests/test-dt.cpp | 77 +++++++++++++++++++------------------ 6 files changed, 119 insertions(+), 44 deletions(-) create mode 100644 include/generic_datatype.h create mode 100644 include/generic_datatype.h~ diff --git a/CMakeLists.txt b/CMakeLists.txt index 43673385e..07c6d6cae 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,6 +23,7 @@ add_definitions(-DSMT_SWITCH_DIR=${PROJECT_SOURCE_DIR}) set (SOURCES "${SMT_SWITCH_LIB_TYPE}" "${PROJECT_SOURCE_DIR}/include/smtlib_utils.h" + "${PROJECT_SOURCE_DIR}/include/generic_datatype.h" "${PROJECT_SOURCE_DIR}/src/generic_solver.cpp" "${PROJECT_SOURCE_DIR}/src/generic_sort.cpp" "${PROJECT_SOURCE_DIR}/src/generic_term.cpp" diff --git a/include/generic_datatype.h b/include/generic_datatype.h new file mode 100644 index 000000000..79a2e2dba --- /dev/null +++ b/include/generic_datatype.h @@ -0,0 +1,37 @@ + +#pragma once + +#include "datatype.h" +#include "smt_defs.h" +#include "exceptions.h" +#include "sort.h" +#include + +//using namespace smt; +namespace smt { + +class GenericDatatypeDecl : public AbsDatatypeDecl +{ + public: + GenericDatatypeDecl(){}; + virtual ~GenericDatatypeDecl(){}; + + protected: + friend class GenericSolver; +}; + +class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl { + public: + GenericDatatypeConstructorDecl(){}; + virtual ~GenericDatatypeConstructorDecl(){}; + protected: + friend class GenericSolver; +}; + +class GenericDatatype : public AbsDatatype { + public: + GenericDatatype(){}; + virtual ~GenericDatatype(){}; + protected: + friend class GenericSolver; +}; diff --git a/include/generic_datatype.h~ b/include/generic_datatype.h~ new file mode 100644 index 000000000..0d7daa8be --- /dev/null +++ b/include/generic_datatype.h~ @@ -0,0 +1,27 @@ + +namespace smt { + +class GenericDatatype : public AbsDatatypeDecl +{ + public: GenericDatatypeDecl(); + virtual ~GenericDatatypeDecl(); + + protected: + friend class GenericSolver; +}; + +class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl { + public: + GenericDatatypeConstructorDecl(){}; + virtual ~GenericDatatypeConstructorDecl(){}; + protected: + friend class GenericSolver; +}; + +class GenericDatatype : public AbsDatatype { + public: + GenericDatatype(){}; + virtual ~GenericDatatype(){}; + proteced: + friend class GenericSolver; +}; diff --git a/include/generic_solver.h b/include/generic_solver.h index e221382b1..972acf41f 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -27,6 +27,7 @@ #include #include +//#include "generic_datatype.h" #include "generic_sort.h" #include "generic_term.h" #include "solver.h" diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 01a64f2f6..ebc3469e7 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -20,6 +20,7 @@ // generic solvers are not supported on macos #ifndef __APPLE__ +//#ifdef "generic_datatype.h" #include "generic_solver.h" @@ -36,10 +37,12 @@ #include #include "assert.h" +//#include "generic_datatype.h" #include "smtlib_utils.h" #include "sort.h" #include "sort_inference.h" #include "utils.h" +//#ifdef "generic_datatype.h" using namespace std; @@ -499,16 +502,20 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // build string for each constructor for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[d].size(); ++i) { - DatatypeConstructorDecl curr_dt_cons_decl = ((*dtdecl_dtconsdecl_map)[d])[i]; + DatatypeConstructorDecl curr_dt_cons_decl = + ((*dtdecl_dtconsdecl_map)[d])[i]; to_solver += " (" + (*datatypeconsdecl_name_map)[curr_dt_cons_decl]; // adjust string for each selector - for (unsigned long f = 0; f < (*dtconsdecl_selector_map)[curr_dt_cons_decl].size(); + for (unsigned long f = 0; + f < (*dtconsdecl_selector_map)[curr_dt_cons_decl].size(); ++f) { - to_solver += " ( " + (*dtconsdecl_selector_map)[curr_dt_cons_decl][f].name; to_solver += - " " + ((*dtconsdecl_selector_map)[curr_dt_cons_decl][f].sort)->to_string() - + " )"; + " ( " + (*dtconsdecl_selector_map)[curr_dt_cons_decl][f].name; + to_solver += " " + + ((*dtconsdecl_selector_map)[curr_dt_cons_decl][f].sort) + ->to_string() + + " )"; } to_solver += ")"; } @@ -542,7 +549,8 @@ DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( // datatypes"); // shared_ptr newDTC = // make_shared(); - DatatypeConstructorDecl new_dt_cons_decl = make_shared(); + DatatypeConstructorDecl new_dt_cons_decl = + make_shared(); (*name_datatypeconsdecl_map)[s] = new_dt_cons_decl; (*datatypeconsdecl_name_map)[new_dt_cons_decl] = s; return new_dt_cons_decl; diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 587cf96e1..9ea784003 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -58,51 +58,52 @@ TEST_P(DTTests, DatatypeDecl) DatatypeConstructorDecl nildecl = s->make_datatype_constructor_decl("nil"); DatatypeConstructorDecl consdecl = s->make_datatype_constructor_decl("cons"); s->add_selector(consdecl, "head", s->make_sort(INT)); - if (s->get_solver_enum() != GENERIC_SOLVER) { + if (s->get_solver_enum() != GENERIC_SOLVER) + { s->add_selector_self(consdecl, "tail"); } s->add_constructor(consListSpec, nildecl); s->add_constructor(consListSpec, consdecl); Sort listsort = s->make_sort(consListSpec); - if (s->get_solver_enum() != GENERIC_SOLVER) { - + if (s->get_solver_enum() != GENERIC_SOLVER) + { Term five = s->make_term(5, intsort); -Datatype listdt = listsort->get_datatype(); -// Make datatype terms -Term cons = s->get_constructor(listsort,"cons"); -Term nil = s->get_constructor(listsort,"nil"); -Term head = s->get_selector(listsort, "cons", "head"); -Term tail = s->get_selector(listsort, "cons", "tail"); -Term isNil = s->get_tester(listsort, "nil"); - -// Datatype ops -Term nilterm = s->make_term(Apply_Constructor,nil); -Term list5 = s->make_term(Apply_Constructor, cons, five, nilterm); -Term five_again = s->make_term(Apply_Selector, head, list5); - -// Expected booleans -s->assert_formula(s->make_term(Equal, five, five_again)); -s->assert_formula(s->make_term(Apply_Tester, isNil, nilterm)); -s->assert_formula(s->make_term( - Not, s->make_term(Apply_Tester, isNil, list5))); - -Result res=s->check_sat(); - -ASSERT_TRUE(listdt->get_name()=="list"); -ASSERT_TRUE(listdt->get_num_constructors()==2); -ASSERT_TRUE(listdt->get_num_selectors("cons")==2); -ASSERT_TRUE(listdt->get_num_selectors("nil")==0); - -ASSERT_TRUE(res.is_sat()); - -// Expected exceptions -EXPECT_THROW(s->get_constructor(listsort, "kons"), InternalSolverException); -EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); -EXPECT_THROW(s->get_selector(listsort, "nil", "head"), InternalSolverException); -EXPECT_THROW(listdt->get_num_selectors("kons"), -InternalSolverException); - + Datatype listdt = listsort->get_datatype(); + // Make datatype terms + Term cons = s->get_constructor(listsort, "cons"); + Term nil = s->get_constructor(listsort, "nil"); + Term head = s->get_selector(listsort, "cons", "head"); + Term tail = s->get_selector(listsort, "cons", "tail"); + Term isNil = s->get_tester(listsort, "nil"); + + // Datatype ops + Term nilterm = s->make_term(Apply_Constructor, nil); + Term list5 = s->make_term(Apply_Constructor, cons, five, nilterm); + Term five_again = s->make_term(Apply_Selector, head, list5); + + // Expected booleans + s->assert_formula(s->make_term(Equal, five, five_again)); + s->assert_formula(s->make_term(Apply_Tester, isNil, nilterm)); + s->assert_formula( + s->make_term(Not, s->make_term(Apply_Tester, isNil, list5))); + + Result res = s->check_sat(); + + ASSERT_TRUE(listdt->get_name() == "list"); + ASSERT_TRUE(listdt->get_num_constructors() == 2); + ASSERT_TRUE(listdt->get_num_selectors("cons") == 2); + ASSERT_TRUE(listdt->get_num_selectors("nil") == 0); + + ASSERT_TRUE(res.is_sat()); + + // Expected exceptions + EXPECT_THROW(s->get_constructor(listsort, "kons"), + InternalSolverException); + EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); + EXPECT_THROW(s->get_selector(listsort, "nil", "head"), + InternalSolverException); + EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); } } From f404a60b8390027e0b485763b96114a0cf1e43f7 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Mon, 28 Jun 2021 09:53:32 -0700 Subject: [PATCH 05/47] Present version contains tweaks in response to the pull request as well as the compilation errors stemming from the new generic_datatype.h file. --- include/generic_solver.h | 2 +- src/generic_solver.cpp | 3 --- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/include/generic_solver.h b/include/generic_solver.h index 972acf41f..b0f257de9 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -27,7 +27,7 @@ #include #include -//#include "generic_datatype.h" +#include "generic_datatype.h" #include "generic_sort.h" #include "generic_term.h" #include "solver.h" diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index ebc3469e7..b99e89467 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -20,7 +20,6 @@ // generic solvers are not supported on macos #ifndef __APPLE__ -//#ifdef "generic_datatype.h" #include "generic_solver.h" @@ -37,12 +36,10 @@ #include #include "assert.h" -//#include "generic_datatype.h" #include "smtlib_utils.h" #include "sort.h" #include "sort_inference.h" #include "utils.h" -//#ifdef "generic_datatype.h" using namespace std; From 186c44bd029b394f1b91d96412f70e1754021126 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Mon, 28 Jun 2021 10:00:02 -0700 Subject: [PATCH 06/47] Contains PR tweaks, non-compiling file, as well as consistent style. --- include/generic_datatype.h | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index 79a2e2dba..deaa433a3 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -1,15 +1,16 @@ #pragma once +#include + #include "datatype.h" -#include "smt_defs.h" #include "exceptions.h" +#include "smt_defs.h" #include "sort.h" -#include -//using namespace smt; +// using namespace smt; namespace smt { - + class GenericDatatypeDecl : public AbsDatatypeDecl { public: @@ -20,18 +21,22 @@ class GenericDatatypeDecl : public AbsDatatypeDecl friend class GenericSolver; }; -class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl { +class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl +{ public: GenericDatatypeConstructorDecl(){}; virtual ~GenericDatatypeConstructorDecl(){}; + protected: friend class GenericSolver; }; -class GenericDatatype : public AbsDatatype { +class GenericDatatype : public AbsDatatype +{ public: GenericDatatype(){}; virtual ~GenericDatatype(){}; + protected: friend class GenericSolver; }; From 8222f9dddadc8b08cf4e163a58330db7b441e822 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 2 Jul 2021 10:25:32 -0700 Subject: [PATCH 07/47] Contains all the revisions in response to the last pr (like moving the datatype state to generic_datataype) along with a host of other changes. Datatype sorts should be functional and allow for multiple datatype sorts. Sort-only push. --- CMakeLists.txt | 2 +- include/generic_datatype.h | 69 +++++++++++++++++++- include/generic_solver.h | 28 +++++---- include/generic_sort.h | 17 ++++- src/generic_datatype.cpp | 126 +++++++++++++++++++++++++++++++++++++ src/generic_solver.cpp | 94 ++++++++++++++------------- src/generic_sort.cpp | 28 +++++++++ 7 files changed, 304 insertions(+), 60 deletions(-) create mode 100644 src/generic_datatype.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 07c6d6cae..0eddadfa9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,7 +23,7 @@ add_definitions(-DSMT_SWITCH_DIR=${PROJECT_SOURCE_DIR}) set (SOURCES "${SMT_SWITCH_LIB_TYPE}" "${PROJECT_SOURCE_DIR}/include/smtlib_utils.h" - "${PROJECT_SOURCE_DIR}/include/generic_datatype.h" + "${PROJECT_SOURCE_DIR}/src/generic_datatype.cpp" "${PROJECT_SOURCE_DIR}/src/generic_solver.cpp" "${PROJECT_SOURCE_DIR}/src/generic_sort.cpp" "${PROJECT_SOURCE_DIR}/src/generic_term.cpp" diff --git a/include/generic_datatype.h b/include/generic_datatype.h index deaa433a3..9694f8579 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -1,16 +1,77 @@ -#pragma once +//#pragma once -#include +//#include + +#include +#include #include "datatype.h" #include "exceptions.h" +#include "generic_sort.h" #include "smt_defs.h" -#include "sort.h" // using namespace smt; namespace smt { +struct selectorComponents +{ + std::string name; + Sort sort; +}; + +class DatatypeMemoryManager +{ + public: + DatatypeMemoryManager(); + virtual ~DatatypeMemoryManager(){}; + void initialize_datatype_memory(); + void add_new_datatype_decl(const std::string & s, + const DatatypeDecl & new_dt_decl); + DatatypeDecl get_datatype_decl_from_name(const std::string & s); + std::string get_name_from_datatype_decl(const DatatypeDecl & new_dt_decl); + void assert_dt_decl_existence(const DatatypeDecl & dt); + void assert_no_existence(const std::string & s); + void make_new_datatypecons_decl( + const std::string & s, const DatatypeConstructorDecl & new_d_cons_decl); + DatatypeConstructorDecl get_datatypecons_decl_from_name( + const std::string & s); + std::string get_name_from_datatypecons_decl( + const DatatypeConstructorDecl & dtc); + void add_datatypecons_decl(const DatatypeDecl & dt, + const DatatypeConstructorDecl & dtc); + std::vector get_datatypecons_decl_vector( + const DatatypeDecl & dt); + + std::shared_ptr make_selector_components( + const std::string & name, const Sort & s); + void add_selector_to_dt_cons_decl( + const DatatypeConstructorDecl & dtc, + const std::shared_ptr & newSelector); + std::vector get_selector_vector( + const DatatypeConstructorDecl & dtc); + + private: + std::unique_ptr> + name_datatypedecl_map; + std::unique_ptr> + datatypedecl_name_map; + std::unique_ptr> + name_datatypeconsdecl_map; + std::unique_ptr> + datatypeconsdecl_name_map; + std::unique_ptr< + std::unordered_map>> + dtdecl_dtconsdecl_map; + + std::unique_ptr>> + dtconsdecl_selector_map; + + protected: + friend class GenericSolver; +}; + class GenericDatatypeDecl : public AbsDatatypeDecl { public: @@ -40,3 +101,5 @@ class GenericDatatype : public AbsDatatype protected: friend class GenericSolver; }; + +} // namespace smt diff --git a/include/generic_solver.h b/include/generic_solver.h index b0f257de9..9c52512f6 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -241,6 +241,7 @@ class GenericSolver : public AbsSmtSolver // buffer sizes uint write_buf_size; uint read_buf_size; + std::unique_ptr solver_dt_memory; // maps between sort name and actual sort and vice verse std::unique_ptr> name_sort_map; @@ -254,38 +255,39 @@ class GenericSolver : public AbsSmtSolver std::unique_ptr> term_name_map; // maps between datatype declaration and name and vice versa - std::unique_ptr> - name_datatypedecl_map; - std::unique_ptr> - datatypedecl_name_map; - - // maps between datatype constructor declaration and name, and vice versa + // std::unique_ptr> + // name_datatypedecl_map; + // std::unique_ptr> + // datatypedecl_name_map; + + // maps between datatype constructor declaration and name, and vice + // versa + /* std::unique_ptr> name_datatypeconsdecl_map; std::unique_ptr> datatypeconsdecl_name_map; - + */ // map linking each datatype declaration with a vector of constructors - std::unique_ptr< - std::unordered_map>> - dtdecl_dtconsdecl_map; + // std::unique_ptr>>dtdecl_dtconsdecl_map; // A struct keeeping track of what each selector needs: a name and // sort // These are usually defined at the beginning of the file, I left it // here for clarity of usage + /* struct selectorComponents { std::string name; Sort sort; }; + */ // a map linking each datatype constructor declaration with a vector // holding its associated selectors, in the form of the previously // defined struct. - std::unique_ptr>> - dtconsdecl_selector_map; + // std::unique_ptr>>dtconsdecl_selector_map; // used to hash terms via their internal string representation std::hash str_hash; }; diff --git a/include/generic_sort.h b/include/generic_sort.h index cdcd5c818..cf373eb81 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -31,7 +31,7 @@ Sort make_generic_sort(SortKind sk, Sort sort1); Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2); Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2, Sort sort3); Sort make_generic_sort(SortKind sk, SortVec sorts); - +Sort make_generic_sort(DatatypeDecl dt, std::string & name); /* smtlib representation of sort kinds */ std::string to_smtlib(SortKind); @@ -187,4 +187,19 @@ class UninterpretedGenericSort : public GenericSort SortVec param_sorts; }; +class GenericDatatypeSort : public GenericSort +{ + public: + GenericDatatypeSort(DatatypeDecl & dt, std::string & name); + ~GenericDatatypeSort(); + std::string get_sort_name(); + DatatypeDecl get_datatype_decl(); + bool compare(const Sort & s) const override; + std::string compute_string() const; + + protected: + std::string sort_name; + DatatypeDecl dt_decl; +}; + } // namespace smt diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp new file mode 100644 index 000000000..4bdea8b40 --- /dev/null +++ b/src/generic_datatype.cpp @@ -0,0 +1,126 @@ +#include "generic_datatype.h" + +//#include "generic_datatype.h" +#include +#include + +#include "assert.h" +//#include "utils.h" + +//#include "generic_datatype.h" + +using namespace std; + +namespace smt { + +/* +GenericSort::GenericSort(SortKind sk) : sk(sk) {} + +GenericSort::~GenericSort() {} + + */ +/* +GenericDatatypeDecl::GenericDatatypeDecl() {} +GenericDatatypeDecl::~GenericDatatypeDecl() {} +GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl() {} +GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl() {} +GenericDatatype::GenericDatatype() {} +GenericDatatype::GenericDatatype() {} +*/ + +DatatypeMemoryManager::DatatypeMemoryManager() + : name_datatypedecl_map(new unordered_map()), + datatypedecl_name_map(new unordered_map()), + name_datatypeconsdecl_map( + new unordered_map()), + datatypeconsdecl_name_map( + new unordered_map()), + dtdecl_dtconsdecl_map( + new unordered_map>()), + dtconsdecl_selector_map(new unordered_map>) +{ +} + +void DatatypeMemoryManager::initialize_datatype_memory() +{ + name_datatypedecl_map = unique_ptr>( + new unordered_map()); + datatypedecl_name_map = unique_ptr>( + new unordered_map()); +} +// name_datatypedecl_map(new unordered_map()); +void DatatypeMemoryManager::add_new_datatype_decl( + const std::string & s, const DatatypeDecl & new_dt_decl) +{ + (*name_datatypedecl_map)[s] = new_dt_decl; + (*datatypedecl_name_map)[new_dt_decl] = s; +} +string DatatypeMemoryManager::get_name_from_datatype_decl( + const DatatypeDecl & dt) +{ + return (*datatypedecl_name_map)[dt]; +} +DatatypeDecl DatatypeMemoryManager::get_datatype_decl_from_name( + const std::string & s) +{ + return (*name_datatypedecl_map)[s]; +} +void DatatypeMemoryManager::assert_dt_decl_existence(const DatatypeDecl & dt) +{ + assert(datatypedecl_name_map->find(d) != datatypedecl_name_map->end()); +} +void DatatypeMemoryManager::assert_no_existence(const std::string & s) +{ + assert(name_datatypedecl_map->find(s) == name_datatypedecl_map->end()); +} + +void DatatypeMemoryManager::make_new_datatypecons_decl( + const std::string & s, const DatatypeConstructorDecl & new_d_cons_decl) +{ + (*name_datatypeconsdecl_map)[s] = new_d_cons_decl; + (*datatypeconsdecl_name_map)[new_d_cons_decl] = s; +} +DatatypeConstructorDecl DatatypeMemoryManager::get_datatypecons_decl_from_name( + const std::string & s) +{ + return (*name_datatypeconsdecl_map)[s]; +} +std::string DatatypeMemoryManager::get_name_from_datatypecons_decl( + const DatatypeConstructorDecl & dtc) +{ + return (*datatypeconsdecl_name_map)[dtc]; +} +void DatatypeMemoryManager::add_datatypecons_decl( + const DatatypeDecl & dt, const DatatypeConstructorDecl & dtc) +{ + (*dtdecl_dtconsdecl_map)[dt].push_back(dtc); +} +std::vector +DatatypeMemoryManager::get_datatypecons_decl_vector(const DatatypeDecl & dt) +{ + return (*dtdecl_dtconsdecl_map)[dt]; +} +shared_ptr DatatypeMemoryManager::make_selector_components( + const std::string & name, const Sort & s) +{ + shared_ptr newSelector = + make_shared(); + (*newSelector).name = name; + (*newSelector).sort = s; + return newSelector; +} + +void DatatypeMemoryManager::add_selector_to_dt_cons_decl( + const DatatypeConstructorDecl & dtc, + const shared_ptr & newSelector) +{ + (*dtconsdecl_selector_map)[dtc].push_back(*newSelector); +} +std::vector DatatypeMemoryManager::get_selector_vector( + const DatatypeConstructorDecl & dtc) +{ + return (*dtconsdecl_selector_map)[dtc]; +} + +} // namespace smt diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index b99e89467..c2043295e 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -77,17 +77,15 @@ GenericSolver::GenericSolver(string path, name_sort_map(new unordered_map()), sort_name_map(new unordered_map()), name_term_map(new unordered_map()), - term_name_map(new unordered_map()), - name_datatypedecl_map(new unordered_map()), - datatypedecl_name_map(new unordered_map()), - name_datatypeconsdecl_map( - new unordered_map()), - datatypeconsdecl_name_map( - new unordered_map()), - dtdecl_dtconsdecl_map( - new unordered_map>()), - dtconsdecl_selector_map(new unordered_map>) + term_name_map(new unordered_map()) +// name_datatypedecl_map(new unordered_map()), +// datatypedecl_name_map(new unordered_map()), +// name_datatypeconsdecl_map(new unordered_map()), datatypeconsdecl_name_map(new +// unordered_map()), dtdecl_dtconsdecl_map(new +// unordered_map>()), +// dtconsdecl_selector_map(new unordered_map>) { // Buffer sizes over 256 caused issues in tests. // Until this is investigated, we support a conservative @@ -116,7 +114,8 @@ GenericSolver::GenericSolver(string path, for (int i=0; i < read_buf_size; i++) { read_buf[i]=0; } - + solver_dt_memory = + unique_ptr(new DatatypeMemoryManager); // start the process with the solver binary start_solver(); } @@ -158,6 +157,7 @@ void GenericSolver::start_solver() { { argv[i] = cmd_line_args[i - 1].c_str(); } + solver_dt_memory->initialize_datatype_memory(); argv[cmd_line_args.size() + 1] = NULL; execv(path.c_str(), (char **)argv); // Nothing below this line should be executed by child process. If so, @@ -488,8 +488,11 @@ Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const Sort GenericSolver::make_sort(const DatatypeDecl & d) const { - assert(datatypedecl_name_map->find(d) != datatypedecl_name_map->end()); - std::string dt_decl_name = (*datatypedecl_name_map)[d]; + // assert(datatypedecl_name_map->find(d) != + // datatypedecl_name_map->end()); + solver_dt_memory->assert_dt_decl_existence(d); + // std::string dt_decl_name = (*datatypedecl_name_map)[d]; + std::string dt_decl_name = solver_dt_memory->get_name_from_datatype_decl(d); if (name_sort_map->find(dt_decl_name) == name_sort_map->end()) { std::string to_solver = "(" + DECLARE_DATATYPE_STR + " (("; @@ -497,28 +500,45 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const to_solver += " 0)) (\n"; to_solver += "("; // build string for each constructor - for (unsigned long i = 0; i < (*dtdecl_dtconsdecl_map)[d].size(); ++i) + for (unsigned long i = 0; + i < (solver_dt_memory->get_datatypecons_decl_vector(d)).size(); + ++i) { DatatypeConstructorDecl curr_dt_cons_decl = - ((*dtdecl_dtconsdecl_map)[d])[i]; - to_solver += " (" + (*datatypeconsdecl_name_map)[curr_dt_cons_decl]; + (solver_dt_memory->get_datatypecons_decl_vector(d))[i]; + // to_solver += " (" + (*datatypeconsdecl_name_map)[curr_dt_cons_decl]; + to_solver += " (" + + solver_dt_memory->get_name_from_datatypecons_decl( + curr_dt_cons_decl); // adjust string for each selector for (unsigned long f = 0; - f < (*dtconsdecl_selector_map)[curr_dt_cons_decl].size(); + f < solver_dt_memory->get_selector_vector(curr_dt_cons_decl).size(); ++f) { to_solver += - " ( " + (*dtconsdecl_selector_map)[curr_dt_cons_decl][f].name; - to_solver += " " - + ((*dtconsdecl_selector_map)[curr_dt_cons_decl][f].sort) - ->to_string() - + " )"; + " ( " + + solver_dt_memory->get_selector_vector(curr_dt_cons_decl)[f].name; + to_solver += + " " + + (solver_dt_memory->get_selector_vector(curr_dt_cons_decl)[f].sort) + ->to_string() + + " )"; } + to_solver += ")"; } to_solver += ")\n))"; // add the sort to the maps - Sort dt_sort = make_generic_sort(DATATYPE); + + // GenericDatatypeSort can't take in a const value + DatatypeDecl testdt = + solver_dt_memory->get_datatype_decl_from_name(dt_decl_name); + // Sort dt_sort = make_generic_sort(testdt, dt_decl_name); + // Exact functionality of make_genericsort, without the linking + // errors (undefined reference when I call the new + // make_generic_sort). + assert(name_sort_map->find(dt_decl_name) == name_sort_map->end()); + Sort dt_sort = make_shared(testdt, dt_decl_name); (*name_sort_map)[dt_decl_name] = dt_sort; (*sort_name_map)[dt_sort] = dt_decl_name; run_command(to_solver); @@ -534,40 +554,30 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) { DatatypeDecl new_dt_decl = make_shared(); - // shared_ptr - (*name_datatypedecl_map)[s] = new_dt_decl; - (*datatypedecl_name_map)[new_dt_decl] = s; + + solver_dt_memory->add_new_datatype_decl(s, new_dt_decl); return new_dt_decl; } DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( const std::string s) { - // throw NotImplementedException("Generic Solvers do not support - // datatypes"); - // shared_ptr newDTC = - // make_shared(); DatatypeConstructorDecl new_dt_cons_decl = make_shared(); - (*name_datatypeconsdecl_map)[s] = new_dt_cons_decl; - (*datatypeconsdecl_name_map)[new_dt_cons_decl] = s; + + solver_dt_memory->make_new_datatypecons_decl(s, new_dt_cons_decl); return new_dt_cons_decl; } void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructorDecl & con) const { - // throw NotImplementedException("Generic Solvers do not support - // datatypes"); dtdecl_dtconsdecl_map; - (*dtdecl_dtconsdecl_map)[dt].push_back(con); + solver_dt_memory->add_datatypecons_decl(dt, con); } + void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const { - // throw NotImplementedException("Generic Solvers do not support - // datatypes"); shared_ptr newSelector = - make_shared(); - (*newSelector).name = name; - (*newSelector).sort = s; - (*dtconsdecl_selector_map)[dt].push_back(*newSelector); + solver_dt_memory->make_selector_components(name, s); + solver_dt_memory->add_selector_to_dt_cons_decl(dt, newSelector); } void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 1b03412d3..f0dcac764 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -119,6 +119,11 @@ Sort make_generic_sort(SortKind sk, SortVec sorts) } } +Sort make_generic_sort(DatatypeDecl & dt, std::string & name) +{ + return make_shared(dt, name); +} + // implementations GenericSort::GenericSort(SortKind sk) : sk(sk) {} @@ -332,5 +337,28 @@ SortVec UninterpretedGenericSort::get_uninterpreted_param_sorts() const return param_sorts; } +GenericDatatypeSort::GenericDatatypeSort(DatatypeDecl & dt, std::string & name) + : GenericSort(DATATYPE), dt_decl(dt), sort_name(name) +{ +} + +GenericDatatypeSort::~GenericDatatypeSort() {} + +std::string GenericDatatypeSort::get_sort_name() { return sort_name; } + +DatatypeDecl GenericDatatypeSort::get_datatype_decl() { return dt_decl; } + +string GenericDatatypeSort::compute_string() const { return sort_name; } + +bool GenericDatatypeSort::compare(const Sort & s) const +{ + // in need of additional casting debugging + /* + const GenericDatatypeSort gdsort = (GenericDatatypeSort) s; + std::string other_sort_name = gdsort->sort_name; + return sort_name.compare(other_sort_name); + */ + return true; +} } // namespace smt From 932e72ed1755e8190581ece7249390ad1fd0daca Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 2 Jul 2021 23:12:37 -0700 Subject: [PATCH 08/47] Completely reworked generic_datatype.h and cpp. Should still work with multiple datatype sorts. --- include/generic_datatype.h | 76 ++++------------ include/generic_solver.h | 26 +++--- src/generic_datatype.cpp | 176 ++++++++++++++----------------------- src/generic_solver.cpp | 83 +++++++++-------- 4 files changed, 143 insertions(+), 218 deletions(-) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index 9694f8579..2c12f34e7 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -1,7 +1,4 @@ -//#pragma once - -//#include #include #include @@ -20,58 +17,6 @@ struct selectorComponents Sort sort; }; -class DatatypeMemoryManager -{ - public: - DatatypeMemoryManager(); - virtual ~DatatypeMemoryManager(){}; - void initialize_datatype_memory(); - void add_new_datatype_decl(const std::string & s, - const DatatypeDecl & new_dt_decl); - DatatypeDecl get_datatype_decl_from_name(const std::string & s); - std::string get_name_from_datatype_decl(const DatatypeDecl & new_dt_decl); - void assert_dt_decl_existence(const DatatypeDecl & dt); - void assert_no_existence(const std::string & s); - void make_new_datatypecons_decl( - const std::string & s, const DatatypeConstructorDecl & new_d_cons_decl); - DatatypeConstructorDecl get_datatypecons_decl_from_name( - const std::string & s); - std::string get_name_from_datatypecons_decl( - const DatatypeConstructorDecl & dtc); - void add_datatypecons_decl(const DatatypeDecl & dt, - const DatatypeConstructorDecl & dtc); - std::vector get_datatypecons_decl_vector( - const DatatypeDecl & dt); - - std::shared_ptr make_selector_components( - const std::string & name, const Sort & s); - void add_selector_to_dt_cons_decl( - const DatatypeConstructorDecl & dtc, - const std::shared_ptr & newSelector); - std::vector get_selector_vector( - const DatatypeConstructorDecl & dtc); - - private: - std::unique_ptr> - name_datatypedecl_map; - std::unique_ptr> - datatypedecl_name_map; - std::unique_ptr> - name_datatypeconsdecl_map; - std::unique_ptr> - datatypeconsdecl_name_map; - std::unique_ptr< - std::unordered_map>> - dtdecl_dtconsdecl_map; - - std::unique_ptr>> - dtconsdecl_selector_map; - - protected: - friend class GenericSolver; -}; - class GenericDatatypeDecl : public AbsDatatypeDecl { public: @@ -79,26 +24,43 @@ class GenericDatatypeDecl : public AbsDatatypeDecl virtual ~GenericDatatypeDecl(){}; protected: + std::vector cons_decl_vector; friend class GenericSolver; }; class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl { public: - GenericDatatypeConstructorDecl(){}; + GenericDatatypeConstructorDecl(const std::string & name); virtual ~GenericDatatypeConstructorDecl(){}; + void add_new_selector(const std::shared_ptr & newSelector); + std::vector get_selector_vector(); + std::string get_name() const; + int get_selector_count() const; protected: + std::vector selector_vector; + std::string cons_name; friend class GenericSolver; }; class GenericDatatype : public AbsDatatype { public: - GenericDatatype(){}; + GenericDatatype(const DatatypeDecl & dt_declaration, const std::string & s); virtual ~GenericDatatype(){}; + void add_constructor(const GenericDatatypeConstructorDecl & dt_cons_decl); + void add_selector(const GenericDatatypeConstructorDecl & dt_cons_decl, const std::shared_ptr & newSelector); + std::vector get_cons_vector(); + std::string get_name() const override; + int get_num_constructors() const override; + int get_num_selectors(std::string cons) const override; protected: + DatatypeDecl dt_decl; + std::string name; + std::vector cons_decl_vector; + friend class GenericSolver; }; diff --git a/include/generic_solver.h b/include/generic_solver.h index 9c52512f6..08bf88880 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -241,7 +241,7 @@ class GenericSolver : public AbsSmtSolver // buffer sizes uint write_buf_size; uint read_buf_size; - std::unique_ptr solver_dt_memory; + //std::unique_ptr solver_dt_memory; // maps between sort name and actual sort and vice verse std::unique_ptr> name_sort_map; @@ -255,22 +255,22 @@ class GenericSolver : public AbsSmtSolver std::unique_ptr> term_name_map; // maps between datatype declaration and name and vice versa - // std::unique_ptr> - // name_datatypedecl_map; - // std::unique_ptr> - // datatypedecl_name_map; + std::unique_ptr> name_datatypedecl_map; + std::unique_ptr> datatypedecl_name_map; + std::unique_ptr>> datatypedecl_datatype_map; + // maps between datatype constructor declaration and name, and vice // versa - /* - std::unique_ptr> - name_datatypeconsdecl_map; - std::unique_ptr> - datatypeconsdecl_name_map; - */ + + //std::unique_ptr> + // name_datatypeconsdecl_map; + // std::unique_ptr> + // datatypeconsdecl_name_map; + // map linking each datatype declaration with a vector of constructors // std::unique_ptr>>dtdecl_dtconsdecl_map; + //std::vector>>dtdecl_dtconsdecl_map; // A struct keeeping track of what each selector needs: a name and // sort @@ -287,7 +287,7 @@ class GenericSolver : public AbsSmtSolver // a map linking each datatype constructor declaration with a vector // holding its associated selectors, in the form of the previously // defined struct. - // std::unique_ptr>>dtconsdecl_selector_map; + // std::unique_ptr>>dtconsdecl_selector_map; // used to hash terms via their internal string representation std::hash str_hash; }; diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 4bdea8b40..184cec23d 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -1,126 +1,78 @@ #include "generic_datatype.h" -//#include "generic_datatype.h" #include #include #include "assert.h" -//#include "utils.h" -//#include "generic_datatype.h" using namespace std; namespace smt { -/* -GenericSort::GenericSort(SortKind sk) : sk(sk) {} - -GenericSort::~GenericSort() {} - - */ -/* -GenericDatatypeDecl::GenericDatatypeDecl() {} -GenericDatatypeDecl::~GenericDatatypeDecl() {} -GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl() {} -GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl() {} -GenericDatatype::GenericDatatype() {} -GenericDatatype::GenericDatatype() {} -*/ - -DatatypeMemoryManager::DatatypeMemoryManager() - : name_datatypedecl_map(new unordered_map()), - datatypedecl_name_map(new unordered_map()), - name_datatypeconsdecl_map( - new unordered_map()), - datatypeconsdecl_name_map( - new unordered_map()), - dtdecl_dtconsdecl_map( - new unordered_map>()), - dtconsdecl_selector_map(new unordered_map>) -{ -} - -void DatatypeMemoryManager::initialize_datatype_memory() -{ - name_datatypedecl_map = unique_ptr>( - new unordered_map()); - datatypedecl_name_map = unique_ptr>( - new unordered_map()); -} -// name_datatypedecl_map(new unordered_map()); -void DatatypeMemoryManager::add_new_datatype_decl( - const std::string & s, const DatatypeDecl & new_dt_decl) -{ - (*name_datatypedecl_map)[s] = new_dt_decl; - (*datatypedecl_name_map)[new_dt_decl] = s; -} -string DatatypeMemoryManager::get_name_from_datatype_decl( - const DatatypeDecl & dt) -{ - return (*datatypedecl_name_map)[dt]; -} -DatatypeDecl DatatypeMemoryManager::get_datatype_decl_from_name( - const std::string & s) -{ - return (*name_datatypedecl_map)[s]; -} -void DatatypeMemoryManager::assert_dt_decl_existence(const DatatypeDecl & dt) -{ - assert(datatypedecl_name_map->find(d) != datatypedecl_name_map->end()); -} -void DatatypeMemoryManager::assert_no_existence(const std::string & s) -{ - assert(name_datatypedecl_map->find(s) == name_datatypedecl_map->end()); -} - -void DatatypeMemoryManager::make_new_datatypecons_decl( - const std::string & s, const DatatypeConstructorDecl & new_d_cons_decl) -{ - (*name_datatypeconsdecl_map)[s] = new_d_cons_decl; - (*datatypeconsdecl_name_map)[new_d_cons_decl] = s; -} -DatatypeConstructorDecl DatatypeMemoryManager::get_datatypecons_decl_from_name( - const std::string & s) -{ - return (*name_datatypeconsdecl_map)[s]; -} -std::string DatatypeMemoryManager::get_name_from_datatypecons_decl( - const DatatypeConstructorDecl & dtc) -{ - return (*datatypeconsdecl_name_map)[dtc]; -} -void DatatypeMemoryManager::add_datatypecons_decl( - const DatatypeDecl & dt, const DatatypeConstructorDecl & dtc) -{ - (*dtdecl_dtconsdecl_map)[dt].push_back(dtc); -} -std::vector -DatatypeMemoryManager::get_datatypecons_decl_vector(const DatatypeDecl & dt) -{ - return (*dtdecl_dtconsdecl_map)[dt]; -} -shared_ptr DatatypeMemoryManager::make_selector_components( - const std::string & name, const Sort & s) -{ - shared_ptr newSelector = - make_shared(); - (*newSelector).name = name; - (*newSelector).sort = s; - return newSelector; -} - -void DatatypeMemoryManager::add_selector_to_dt_cons_decl( - const DatatypeConstructorDecl & dtc, - const shared_ptr & newSelector) -{ - (*dtconsdecl_selector_map)[dtc].push_back(*newSelector); -} -std::vector DatatypeMemoryManager::get_selector_vector( - const DatatypeConstructorDecl & dtc) -{ - return (*dtconsdecl_selector_map)[dtc]; -} + + GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration, const std::string & s) : dt_decl(dt_declaration), name(s) { + } + + GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl(const std::string & name) : cons_name(name) {} + void GenericDatatypeConstructorDecl::add_new_selector(const shared_ptr & newSelector) + { + selector_vector.push_back(*newSelector); + } + + + std::vector GenericDatatypeConstructorDecl::get_selector_vector() + { + return selector_vector; + } + + void GenericDatatype::add_constructor(const GenericDatatypeConstructorDecl & dt_cons_decl) + { + cons_decl_vector.push_back(dt_cons_decl); + } + + std::string GenericDatatype::get_name() const + { + return name; + } + + int GenericDatatypeConstructorDecl::get_selector_count() const + { + return selector_vector.size(); + } + + int GenericDatatype::get_num_constructors() const + { + return cons_decl_vector.size(); + } + + int GenericDatatype::get_num_selectors(std::string cons) const + { + int num_selectors = 0; + for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { + if (cons_decl_vector[i].get_name() == cons) { + num_selectors = cons_decl_vector[i].get_selector_count(); + } + } + return num_selectors; + } + + void GenericDatatype::add_selector(const GenericDatatypeConstructorDecl & dt_cons_decl, const std::shared_ptr & newSelector) + { + for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { + if (cons_decl_vector[i].get_name() == dt_cons_decl.get_name()) { + cons_decl_vector[i].get_selector_vector().push_back(*newSelector); + } + } + } + std::vector GenericDatatype::get_cons_vector() + { + return cons_decl_vector; + } + + std::string GenericDatatypeConstructorDecl::get_name() const + { + return cons_name; + } } // namespace smt diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index c2043295e..49d7479e0 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -77,15 +77,13 @@ GenericSolver::GenericSolver(string path, name_sort_map(new unordered_map()), sort_name_map(new unordered_map()), name_term_map(new unordered_map()), - term_name_map(new unordered_map()) -// name_datatypedecl_map(new unordered_map()), -// datatypedecl_name_map(new unordered_map()), -// name_datatypeconsdecl_map(new unordered_map()), datatypeconsdecl_name_map(new -// unordered_map()), dtdecl_dtconsdecl_map(new -// unordered_map>()), -// dtconsdecl_selector_map(new unordered_map>) + term_name_map(new unordered_map()), + datatypedecl_datatype_map(new unordered_map>()), +name_datatypedecl_map(new unordered_map()), +datatypedecl_name_map(new unordered_map()) + //name_datatypeconsdecl_map(new unordered_map()), datatypeconsdecl_name_map(new unordered_map()) + //dtdecl_dtconsdecl_map(new unordered_map>()), + //dtconsdecl_selector_map(new unordered_map>) { // Buffer sizes over 256 caused issues in tests. // Until this is investigated, we support a conservative @@ -114,8 +112,7 @@ GenericSolver::GenericSolver(string path, for (int i=0; i < read_buf_size; i++) { read_buf[i]=0; } - solver_dt_memory = - unique_ptr(new DatatypeMemoryManager); + //solver_dt_memory = unique_ptr(new DatatypeMemoryManager); // start the process with the solver binary start_solver(); } @@ -157,7 +154,7 @@ void GenericSolver::start_solver() { { argv[i] = cmd_line_args[i - 1].c_str(); } - solver_dt_memory->initialize_datatype_memory(); + //solver_dt_memory->initialize_datatype_memory(); argv[cmd_line_args.size() + 1] = NULL; execv(path.c_str(), (char **)argv); // Nothing below this line should be executed by child process. If so, @@ -490,9 +487,13 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const { // assert(datatypedecl_name_map->find(d) != // datatypedecl_name_map->end()); - solver_dt_memory->assert_dt_decl_existence(d); - // std::string dt_decl_name = (*datatypedecl_name_map)[d]; - std::string dt_decl_name = solver_dt_memory->get_name_from_datatype_decl(d); + assert(datatypedecl_name_map->find(d) != datatypedecl_name_map->end()); + shared_ptr curr_dt = (*datatypedecl_datatype_map)[d]; + //solver_dt_memory->assert_dt_decl_existence(d); + //std::string dt_decl_name = (*datatypedecl_name_map)[d]; + //std::string dt_decl_name = + //solver_dt_memory->get_name_from_datatype_decl(d); + std::string dt_decl_name = curr_dt->get_name(); if (name_sort_map->find(dt_decl_name) == name_sort_map->end()) { std::string to_solver = "(" + DECLARE_DATATYPE_STR + " (("; @@ -501,27 +502,24 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const to_solver += "("; // build string for each constructor for (unsigned long i = 0; - i < (solver_dt_memory->get_datatypecons_decl_vector(d)).size(); + i < curr_dt->get_cons_vector().size(); ++i) { - DatatypeConstructorDecl curr_dt_cons_decl = - (solver_dt_memory->get_datatypecons_decl_vector(d))[i]; + GenericDatatypeConstructorDecl curr_dt_cons_decl = + curr_dt->get_cons_vector()[i]; // to_solver += " (" + (*datatypeconsdecl_name_map)[curr_dt_cons_decl]; to_solver += " (" - + solver_dt_memory->get_name_from_datatypecons_decl( - curr_dt_cons_decl); + + curr_dt_cons_decl.get_name(); // adjust string for each selector for (unsigned long f = 0; - f < solver_dt_memory->get_selector_vector(curr_dt_cons_decl).size(); + f < curr_dt_cons_decl.get_selector_vector().size(); ++f) { to_solver += " ( " - + solver_dt_memory->get_selector_vector(curr_dt_cons_decl)[f].name; + + curr_dt_cons_decl.get_selector_vector()[f].name; to_solver += - " " - + (solver_dt_memory->get_selector_vector(curr_dt_cons_decl)[f].sort) - ->to_string() + " " + (curr_dt_cons_decl.get_selector_vector()[f].sort)->to_string() + " )"; } @@ -531,8 +529,8 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // add the sort to the maps // GenericDatatypeSort can't take in a const value - DatatypeDecl testdt = - solver_dt_memory->get_datatype_decl_from_name(dt_decl_name); + DatatypeDecl testdt = (*name_datatypedecl_map)[dt_decl_name]; + //solver_dt_memory->get_datatype_decl_from_name(dt_decl_name); // Sort dt_sort = make_generic_sort(testdt, dt_decl_name); // Exact functionality of make_genericsort, without the linking // errors (undefined reference when I call the new @@ -554,30 +552,43 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) { DatatypeDecl new_dt_decl = make_shared(); - - solver_dt_memory->add_new_datatype_decl(s, new_dt_decl); + (*name_datatypedecl_map)[s] = new_dt_decl; + (*datatypedecl_name_map)[new_dt_decl] = s; + //shared_ptr(new GenericDatatype(new_dt_decl, s)) + //shared_ptr new_dt = make_shared(new_dt_decl, s); + shared_ptr new_dt = shared_ptr(new GenericDatatype(new_dt_decl, s)); + (*datatypedecl_datatype_map)[new_dt_decl] = new_dt; + //solver_dt_memory->add_new_datatype_decl(s, new_dt_decl); return new_dt_decl; } DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( const std::string s) { - DatatypeConstructorDecl new_dt_cons_decl = - make_shared(); + //GenericDatatypeConstructorDecl new_dt_cons_decl = make_shared(); + shared_ptr new_dt_cons_decl = shared_ptr(new GenericDatatypeConstructorDecl(s)); - solver_dt_memory->make_new_datatypecons_decl(s, new_dt_cons_decl); + //solver_dt_memory->make_new_datatypecons_decl(s, new_dt_cons_decl); return new_dt_cons_decl; } void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructorDecl & con) const { - solver_dt_memory->add_datatypecons_decl(dt, con); + shared_ptr gdtc = static_pointer_cast(con); + auto gdt = (*datatypedecl_datatype_map)[dt]; + gdt->add_constructor(*gdtc); + //solver_dt_memory->add_datatypecons_decl(dt, con); } void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const { - shared_ptr newSelector = - solver_dt_memory->make_selector_components(name, s); - solver_dt_memory->add_selector_to_dt_cons_decl(dt, newSelector); + shared_ptr newSelector = make_shared(); + (*newSelector).name = name; + (*newSelector).sort = s; + shared_ptr gdtc = static_pointer_cast(dt); + //auto gdt = (*datatypedecl_datatype_map)[dt]; + gdtc->add_new_selector(newSelector); + //solver_dt_memory->make_selector_components(name, s); + //solver_dt_memory->add_selector_to_dt_cons_decl(dt, newSelector); } void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const From 4edb86ef9166512a1bbdd55c7db04ba0bc291c41 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 2 Jul 2021 23:13:41 -0700 Subject: [PATCH 09/47] Completely reworked generic_datatype.h and cpp. Should still work with multiple datatype sorts. --- include/generic_datatype.h | 8 ++- include/generic_solver.h | 21 +++--- src/generic_datatype.cpp | 128 ++++++++++++++++++++----------------- src/generic_solver.cpp | 82 +++++++++++++----------- 4 files changed, 131 insertions(+), 108 deletions(-) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index 2c12f34e7..207dccadb 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -33,7 +33,8 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl public: GenericDatatypeConstructorDecl(const std::string & name); virtual ~GenericDatatypeConstructorDecl(){}; - void add_new_selector(const std::shared_ptr & newSelector); + void add_new_selector( + const std::shared_ptr & newSelector); std::vector get_selector_vector(); std::string get_name() const; int get_selector_count() const; @@ -50,7 +51,8 @@ class GenericDatatype : public AbsDatatype GenericDatatype(const DatatypeDecl & dt_declaration, const std::string & s); virtual ~GenericDatatype(){}; void add_constructor(const GenericDatatypeConstructorDecl & dt_cons_decl); - void add_selector(const GenericDatatypeConstructorDecl & dt_cons_decl, const std::shared_ptr & newSelector); + void add_selector(const GenericDatatypeConstructorDecl & dt_cons_decl, + const std::shared_ptr & newSelector); std::vector get_cons_vector(); std::string get_name() const override; int get_num_constructors() const override; @@ -60,7 +62,7 @@ class GenericDatatype : public AbsDatatype DatatypeDecl dt_decl; std::string name; std::vector cons_decl_vector; - + friend class GenericSolver; }; diff --git a/include/generic_solver.h b/include/generic_solver.h index 08bf88880..50c32dc1e 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -241,7 +241,7 @@ class GenericSolver : public AbsSmtSolver // buffer sizes uint write_buf_size; uint read_buf_size; - //std::unique_ptr solver_dt_memory; + // std::unique_ptr solver_dt_memory; // maps between sort name and actual sort and vice verse std::unique_ptr> name_sort_map; @@ -255,22 +255,25 @@ class GenericSolver : public AbsSmtSolver std::unique_ptr> term_name_map; // maps between datatype declaration and name and vice versa - std::unique_ptr> name_datatypedecl_map; - std::unique_ptr> datatypedecl_name_map; - std::unique_ptr>> datatypedecl_datatype_map; - + std::unique_ptr> + name_datatypedecl_map; + std::unique_ptr> + datatypedecl_name_map; + std::unique_ptr< + std::unordered_map>> + datatypedecl_datatype_map; // maps between datatype constructor declaration and name, and vice // versa - - //std::unique_ptr> + + // std::unique_ptr> // name_datatypeconsdecl_map; // std::unique_ptr> // datatypeconsdecl_name_map; // map linking each datatype declaration with a vector of constructors // std::unique_ptr>>dtdecl_dtconsdecl_map; + // std::vector>>dtdecl_dtconsdecl_map; // A struct keeeping track of what each selector needs: a name and // sort @@ -287,7 +290,7 @@ class GenericSolver : public AbsSmtSolver // a map linking each datatype constructor declaration with a vector // holding its associated selectors, in the form of the previously // defined struct. - // std::unique_ptr>>dtconsdecl_selector_map; + // std::unique_ptr>>dtconsdecl_selector_map; // used to hash terms via their internal string representation std::hash str_hash; }; diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 184cec23d..2840f4e06 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -5,74 +5,84 @@ #include "assert.h" - using namespace std; namespace smt { - - GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration, const std::string & s) : dt_decl(dt_declaration), name(s) { - } - - GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl(const std::string & name) : cons_name(name) {} - void GenericDatatypeConstructorDecl::add_new_selector(const shared_ptr & newSelector) - { - selector_vector.push_back(*newSelector); - } - - - std::vector GenericDatatypeConstructorDecl::get_selector_vector() - { - return selector_vector; - } - - void GenericDatatype::add_constructor(const GenericDatatypeConstructorDecl & dt_cons_decl) - { - cons_decl_vector.push_back(dt_cons_decl); - } - - std::string GenericDatatype::get_name() const +GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration, + const std::string & s) + : dt_decl(dt_declaration), name(s) +{ +} + +GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( + const std::string & name) + : cons_name(name) +{ +} +void GenericDatatypeConstructorDecl::add_new_selector( + const shared_ptr & newSelector) +{ + selector_vector.push_back(*newSelector); +} + +std::vector +GenericDatatypeConstructorDecl::get_selector_vector() +{ + return selector_vector; +} + +void GenericDatatype::add_constructor( + const GenericDatatypeConstructorDecl & dt_cons_decl) +{ + cons_decl_vector.push_back(dt_cons_decl); +} + +std::string GenericDatatype::get_name() const { return name; } + +int GenericDatatypeConstructorDecl::get_selector_count() const +{ + return selector_vector.size(); +} + +int GenericDatatype::get_num_constructors() const +{ + return cons_decl_vector.size(); +} + +int GenericDatatype::get_num_selectors(std::string cons) const +{ + int num_selectors = 0; + for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { - return name; - } - - int GenericDatatypeConstructorDecl::get_selector_count() const - { - return selector_vector.size(); - } - - int GenericDatatype::get_num_constructors() const - { - return cons_decl_vector.size(); - } - - int GenericDatatype::get_num_selectors(std::string cons) const - { - int num_selectors = 0; - for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { - if (cons_decl_vector[i].get_name() == cons) { - num_selectors = cons_decl_vector[i].get_selector_count(); - } + if (cons_decl_vector[i].get_name() == cons) + { + num_selectors = cons_decl_vector[i].get_selector_count(); } - return num_selectors; } - - void GenericDatatype::add_selector(const GenericDatatypeConstructorDecl & dt_cons_decl, const std::shared_ptr & newSelector) + return num_selectors; +} + +void GenericDatatype::add_selector( + const GenericDatatypeConstructorDecl & dt_cons_decl, + const std::shared_ptr & newSelector) +{ + for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { - for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { - if (cons_decl_vector[i].get_name() == dt_cons_decl.get_name()) { - cons_decl_vector[i].get_selector_vector().push_back(*newSelector); - } + if (cons_decl_vector[i].get_name() == dt_cons_decl.get_name()) + { + cons_decl_vector[i].get_selector_vector().push_back(*newSelector); } } - std::vector GenericDatatype::get_cons_vector() - { - return cons_decl_vector; - } - - std::string GenericDatatypeConstructorDecl::get_name() const - { - return cons_name; - } +} +std::vector GenericDatatype::get_cons_vector() +{ + return cons_decl_vector; +} + +std::string GenericDatatypeConstructorDecl::get_name() const +{ + return cons_name; +} } // namespace smt diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 49d7479e0..2d7994958 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -78,12 +78,16 @@ GenericSolver::GenericSolver(string path, sort_name_map(new unordered_map()), name_term_map(new unordered_map()), term_name_map(new unordered_map()), - datatypedecl_datatype_map(new unordered_map>()), -name_datatypedecl_map(new unordered_map()), -datatypedecl_name_map(new unordered_map()) - //name_datatypeconsdecl_map(new unordered_map()), datatypeconsdecl_name_map(new unordered_map()) - //dtdecl_dtconsdecl_map(new unordered_map>()), - //dtconsdecl_selector_map(new unordered_map>) + datatypedecl_datatype_map( + new unordered_map>()), + name_datatypedecl_map(new unordered_map()), + datatypedecl_name_map(new unordered_map()) +// name_datatypeconsdecl_map(new +// unordered_map()), +// datatypeconsdecl_name_map(new unordered_map()) dtdecl_dtconsdecl_map(new unordered_map>()), dtconsdecl_selector_map(new +// unordered_map>) { // Buffer sizes over 256 caused issues in tests. // Until this is investigated, we support a conservative @@ -112,7 +116,8 @@ datatypedecl_name_map(new unordered_map()) for (int i=0; i < read_buf_size; i++) { read_buf[i]=0; } - //solver_dt_memory = unique_ptr(new DatatypeMemoryManager); + // solver_dt_memory = unique_ptr(new + // DatatypeMemoryManager); // start the process with the solver binary start_solver(); } @@ -154,7 +159,7 @@ void GenericSolver::start_solver() { { argv[i] = cmd_line_args[i - 1].c_str(); } - //solver_dt_memory->initialize_datatype_memory(); + // solver_dt_memory->initialize_datatype_memory(); argv[cmd_line_args.size() + 1] = NULL; execv(path.c_str(), (char **)argv); // Nothing below this line should be executed by child process. If so, @@ -489,10 +494,10 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // datatypedecl_name_map->end()); assert(datatypedecl_name_map->find(d) != datatypedecl_name_map->end()); shared_ptr curr_dt = (*datatypedecl_datatype_map)[d]; - //solver_dt_memory->assert_dt_decl_existence(d); - //std::string dt_decl_name = (*datatypedecl_name_map)[d]; - //std::string dt_decl_name = - //solver_dt_memory->get_name_from_datatype_decl(d); + // solver_dt_memory->assert_dt_decl_existence(d); + // std::string dt_decl_name = (*datatypedecl_name_map)[d]; + // std::string dt_decl_name = + // solver_dt_memory->get_name_from_datatype_decl(d); std::string dt_decl_name = curr_dt->get_name(); if (name_sort_map->find(dt_decl_name) == name_sort_map->end()) { @@ -501,25 +506,20 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const to_solver += " 0)) (\n"; to_solver += "("; // build string for each constructor - for (unsigned long i = 0; - i < curr_dt->get_cons_vector().size(); - ++i) + for (unsigned long i = 0; i < curr_dt->get_cons_vector().size(); ++i) { GenericDatatypeConstructorDecl curr_dt_cons_decl = - curr_dt->get_cons_vector()[i]; + curr_dt->get_cons_vector()[i]; // to_solver += " (" + (*datatypeconsdecl_name_map)[curr_dt_cons_decl]; - to_solver += " (" - + curr_dt_cons_decl.get_name(); + to_solver += " (" + curr_dt_cons_decl.get_name(); // adjust string for each selector for (unsigned long f = 0; f < curr_dt_cons_decl.get_selector_vector().size(); ++f) { + to_solver += " ( " + curr_dt_cons_decl.get_selector_vector()[f].name; to_solver += - " ( " - + curr_dt_cons_decl.get_selector_vector()[f].name; - to_solver += - " " + (curr_dt_cons_decl.get_selector_vector()[f].sort)->to_string() + " " + (curr_dt_cons_decl.get_selector_vector()[f].sort)->to_string() + " )"; } @@ -530,7 +530,7 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // GenericDatatypeSort can't take in a const value DatatypeDecl testdt = (*name_datatypedecl_map)[dt_decl_name]; - //solver_dt_memory->get_datatype_decl_from_name(dt_decl_name); + // solver_dt_memory->get_datatype_decl_from_name(dt_decl_name); // Sort dt_sort = make_generic_sort(testdt, dt_decl_name); // Exact functionality of make_genericsort, without the linking // errors (undefined reference when I call the new @@ -554,41 +554,49 @@ DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) DatatypeDecl new_dt_decl = make_shared(); (*name_datatypedecl_map)[s] = new_dt_decl; (*datatypedecl_name_map)[new_dt_decl] = s; - //shared_ptr(new GenericDatatype(new_dt_decl, s)) - //shared_ptr new_dt = make_shared(new_dt_decl, s); - shared_ptr new_dt = shared_ptr(new GenericDatatype(new_dt_decl, s)); + // shared_ptr(new GenericDatatype(new_dt_decl, s)) + // shared_ptr new_dt = + // make_shared(new_dt_decl, s); + shared_ptr new_dt = + shared_ptr(new GenericDatatype(new_dt_decl, s)); (*datatypedecl_datatype_map)[new_dt_decl] = new_dt; - //solver_dt_memory->add_new_datatype_decl(s, new_dt_decl); + // solver_dt_memory->add_new_datatype_decl(s, new_dt_decl); return new_dt_decl; } DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( const std::string s) { - //GenericDatatypeConstructorDecl new_dt_cons_decl = make_shared(); - shared_ptr new_dt_cons_decl = shared_ptr(new GenericDatatypeConstructorDecl(s)); + // GenericDatatypeConstructorDecl new_dt_cons_decl = + // make_shared(); + shared_ptr new_dt_cons_decl = + shared_ptr( + new GenericDatatypeConstructorDecl(s)); - //solver_dt_memory->make_new_datatypecons_decl(s, new_dt_cons_decl); + // solver_dt_memory->make_new_datatypecons_decl(s, new_dt_cons_decl); return new_dt_cons_decl; } void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructorDecl & con) const { - shared_ptr gdtc = static_pointer_cast(con); + shared_ptr gdtc = + static_pointer_cast(con); auto gdt = (*datatypedecl_datatype_map)[dt]; gdt->add_constructor(*gdtc); - //solver_dt_memory->add_datatypecons_decl(dt, con); + // solver_dt_memory->add_datatypecons_decl(dt, con); } void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const { - shared_ptr newSelector = make_shared(); + shared_ptr newSelector = + make_shared(); (*newSelector).name = name; (*newSelector).sort = s; - shared_ptr gdtc = static_pointer_cast(dt); - //auto gdt = (*datatypedecl_datatype_map)[dt]; + shared_ptr gdtc = + static_pointer_cast(dt); + // auto gdt = (*datatypedecl_datatype_map)[dt]; gdtc->add_new_selector(newSelector); - //solver_dt_memory->make_selector_components(name, s); - //solver_dt_memory->add_selector_to_dt_cons_decl(dt, newSelector); + // solver_dt_memory->make_selector_components(name, s); + // solver_dt_memory->add_selector_to_dt_cons_decl(dt, newSelector); } void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const From 29821d9278ed78a6dbb3341a5102b52a883ebc28 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Mon, 5 Jul 2021 18:16:34 -0700 Subject: [PATCH 10/47] Commit for git clang reformatting --- include/datatype.h | 10 +++-- include/generic_datatype.h | 10 ++--- include/generic_solver.h | 39 ++--------------- src/generic_datatype.cpp | 88 +++++++++++++++++++++----------------- src/generic_solver.cpp | 46 ++++---------------- 5 files changed, 72 insertions(+), 121 deletions(-) diff --git a/include/datatype.h b/include/datatype.h index fb0c79732..610548905 100644 --- a/include/datatype.h +++ b/include/datatype.h @@ -35,6 +35,8 @@ class AbsDatatypeConstructorDecl { public: AbsDatatypeConstructorDecl(){}; virtual ~AbsDatatypeConstructorDecl(){}; + virtual std::string get_name() const=0; + virtual bool compare(const AbsDatatypeConstructorDecl & d) const=0; }; @@ -47,11 +49,13 @@ class AbsDatatype { virtual std::string get_name() const=0; virtual int get_num_selectors(std::string cons) const=0; virtual int get_num_constructors() const=0; + virtual bool compare(const AbsDatatype & d) const=0; }; +bool operator==(const AbsDatatype& d1, const AbsDatatype& d2); +bool operator!=(const AbsDatatype& d1, const AbsDatatype& d2); - +bool operator==(const AbsDatatypeConstructorDecl& d1, const AbsDatatypeConstructorDecl& d2); +bool operator!=(const AbsDatatypeConstructorDecl& d1, const AbsDatatypeConstructorDecl& d2); } - - diff --git a/include/generic_datatype.h b/include/generic_datatype.h index 207dccadb..f1f04a536 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -1,5 +1,3 @@ - - #include #include @@ -10,7 +8,7 @@ // using namespace smt; namespace smt { - + struct selectorComponents { std::string name; @@ -24,7 +22,6 @@ class GenericDatatypeDecl : public AbsDatatypeDecl virtual ~GenericDatatypeDecl(){}; protected: - std::vector cons_decl_vector; friend class GenericSolver; }; @@ -36,8 +33,9 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl void add_new_selector( const std::shared_ptr & newSelector); std::vector get_selector_vector(); - std::string get_name() const; + std::string get_name() const override; int get_selector_count() const; + bool compare(const AbsDatatypeConstructorDecl & d) const override; protected: std::vector selector_vector; @@ -57,6 +55,8 @@ class GenericDatatype : public AbsDatatype std::string get_name() const override; int get_num_constructors() const override; int get_num_selectors(std::string cons) const override; + bool compare(const AbsDatatype & d) const override; + std::hash str_hash; protected: DatatypeDecl dt_decl; diff --git a/include/generic_solver.h b/include/generic_solver.h index 50c32dc1e..94dbdd802 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -241,7 +241,6 @@ class GenericSolver : public AbsSmtSolver // buffer sizes uint write_buf_size; uint read_buf_size; - // std::unique_ptr solver_dt_memory; // maps between sort name and actual sort and vice verse std::unique_ptr> name_sort_map; @@ -259,40 +258,10 @@ class GenericSolver : public AbsSmtSolver name_datatypedecl_map; std::unique_ptr> datatypedecl_name_map; - std::unique_ptr< - std::unordered_map>> - datatypedecl_datatype_map; - - // maps between datatype constructor declaration and name, and vice - // versa - - // std::unique_ptr> - // name_datatypeconsdecl_map; - // std::unique_ptr> - // datatypeconsdecl_name_map; - - // map linking each datatype declaration with a vector of constructors - // std::unique_ptr>>dtdecl_dtconsdecl_map; - - // A struct keeeping track of what each selector needs: a name and - // sort - // These are usually defined at the beginning of the file, I left it - // here for clarity of usage - /* - struct selectorComponents - { - std::string name; - Sort sort; - }; - */ - - // a map linking each datatype constructor declaration with a vector - // holding its associated selectors, in the form of the previously - // defined struct. - // std::unique_ptr>>dtconsdecl_selector_map; - // used to hash terms via their internal string representation - std::hash str_hash; + // Map between names and Generic datatypes + std::unique_ptr>> + name_datatype_map; + }; } // namespace smt diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 2840f4e06..7e543635e 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -8,28 +8,42 @@ using namespace std; namespace smt { - -GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration, - const std::string & s) - : dt_decl(dt_declaration), name(s) -{ -} - -GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( - const std::string & name) + GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( +const std::string & name) : cons_name(name) { } -void GenericDatatypeConstructorDecl::add_new_selector( - const shared_ptr & newSelector) + + void GenericDatatypeConstructorDecl::add_new_selector(const shared_ptr & newSelector) { - selector_vector.push_back(*newSelector); + selector_vector.push_back(*newSelector); } -std::vector -GenericDatatypeConstructorDecl::get_selector_vector() + std::vector GenericDatatypeConstructorDecl::get_selector_vector() + { + return selector_vector; + } + + std::string GenericDatatypeConstructorDecl::get_name() const + { + return cons_name; + } + + int GenericDatatypeConstructorDecl::get_selector_count() const + { + return selector_vector.size(); + } + bool GenericDatatypeConstructorDecl::compare(const AbsDatatypeConstructorDecl & d) const + { + // Why won't type casting like this work? + // GenericDatatypeConstructorDecl gdtc = (GenericDatatypeConstructorDecl) d; + return cons_name == d.get_name(); + } + +GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration, + const std::string & s) + : dt_decl(dt_declaration), name(s) { - return selector_vector; } void GenericDatatype::add_constructor( @@ -38,12 +52,22 @@ void GenericDatatype::add_constructor( cons_decl_vector.push_back(dt_cons_decl); } -std::string GenericDatatype::get_name() const { return name; } + void GenericDatatype::add_selector(const GenericDatatypeConstructorDecl & dt_cons_decl, const std::shared_ptr & newSelector) + { + for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) + { + if (cons_decl_vector[i].get_name() == dt_cons_decl.get_name()) + { + cons_decl_vector[i].get_selector_vector().push_back(*newSelector); + } + } + } + std::vector GenericDatatype::get_cons_vector() + { + return cons_decl_vector; + } -int GenericDatatypeConstructorDecl::get_selector_count() const -{ - return selector_vector.size(); -} +std::string GenericDatatype::get_name() const { return name; } int GenericDatatype::get_num_constructors() const { @@ -63,26 +87,10 @@ int GenericDatatype::get_num_selectors(std::string cons) const return num_selectors; } -void GenericDatatype::add_selector( - const GenericDatatypeConstructorDecl & dt_cons_decl, - const std::shared_ptr & newSelector) -{ - for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) + bool GenericDatatype::compare(const AbsDatatype & d) const { - if (cons_decl_vector[i].get_name() == dt_cons_decl.get_name()) - { - cons_decl_vector[i].get_selector_vector().push_back(*newSelector); + return name == d.get_name(); } - } -} -std::vector GenericDatatype::get_cons_vector() -{ - return cons_decl_vector; -} - -std::string GenericDatatypeConstructorDecl::get_name() const -{ - return cons_name; -} - + + } // namespace smt diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 2d7994958..fcb0ea18d 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -78,16 +78,10 @@ GenericSolver::GenericSolver(string path, sort_name_map(new unordered_map()), name_term_map(new unordered_map()), term_name_map(new unordered_map()), - datatypedecl_datatype_map( - new unordered_map>()), + name_datatype_map( + new unordered_map>()), name_datatypedecl_map(new unordered_map()), datatypedecl_name_map(new unordered_map()) -// name_datatypeconsdecl_map(new -// unordered_map()), -// datatypeconsdecl_name_map(new unordered_map()) dtdecl_dtconsdecl_map(new unordered_map>()), dtconsdecl_selector_map(new -// unordered_map>) { // Buffer sizes over 256 caused issues in tests. // Until this is investigated, we support a conservative @@ -116,8 +110,6 @@ GenericSolver::GenericSolver(string path, for (int i=0; i < read_buf_size; i++) { read_buf[i]=0; } - // solver_dt_memory = unique_ptr(new - // DatatypeMemoryManager); // start the process with the solver binary start_solver(); } @@ -159,7 +151,6 @@ void GenericSolver::start_solver() { { argv[i] = cmd_line_args[i - 1].c_str(); } - // solver_dt_memory->initialize_datatype_memory(); argv[cmd_line_args.size() + 1] = NULL; execv(path.c_str(), (char **)argv); // Nothing below this line should be executed by child process. If so, @@ -490,15 +481,9 @@ Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const Sort GenericSolver::make_sort(const DatatypeDecl & d) const { - // assert(datatypedecl_name_map->find(d) != - // datatypedecl_name_map->end()); assert(datatypedecl_name_map->find(d) != datatypedecl_name_map->end()); - shared_ptr curr_dt = (*datatypedecl_datatype_map)[d]; - // solver_dt_memory->assert_dt_decl_existence(d); - // std::string dt_decl_name = (*datatypedecl_name_map)[d]; - // std::string dt_decl_name = - // solver_dt_memory->get_name_from_datatype_decl(d); - std::string dt_decl_name = curr_dt->get_name(); + string dt_decl_name = (*datatypedecl_name_map)[d]; + shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; if (name_sort_map->find(dt_decl_name) == name_sort_map->end()) { std::string to_solver = "(" + DECLARE_DATATYPE_STR + " (("; @@ -510,7 +495,6 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const { GenericDatatypeConstructorDecl curr_dt_cons_decl = curr_dt->get_cons_vector()[i]; - // to_solver += " (" + (*datatypeconsdecl_name_map)[curr_dt_cons_decl]; to_solver += " (" + curr_dt_cons_decl.get_name(); // adjust string for each selector for (unsigned long f = 0; @@ -530,8 +514,6 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // GenericDatatypeSort can't take in a const value DatatypeDecl testdt = (*name_datatypedecl_map)[dt_decl_name]; - // solver_dt_memory->get_datatype_decl_from_name(dt_decl_name); - // Sort dt_sort = make_generic_sort(testdt, dt_decl_name); // Exact functionality of make_genericsort, without the linking // errors (undefined reference when I call the new // make_generic_sort). @@ -554,25 +536,17 @@ DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) DatatypeDecl new_dt_decl = make_shared(); (*name_datatypedecl_map)[s] = new_dt_decl; (*datatypedecl_name_map)[new_dt_decl] = s; - // shared_ptr(new GenericDatatype(new_dt_decl, s)) - // shared_ptr new_dt = - // make_shared(new_dt_decl, s); shared_ptr new_dt = shared_ptr(new GenericDatatype(new_dt_decl, s)); - (*datatypedecl_datatype_map)[new_dt_decl] = new_dt; - // solver_dt_memory->add_new_datatype_decl(s, new_dt_decl); + (*name_datatype_map)[s] = new_dt; return new_dt_decl; } DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( const std::string s) { - // GenericDatatypeConstructorDecl new_dt_cons_decl = - // make_shared(); shared_ptr new_dt_cons_decl = shared_ptr( new GenericDatatypeConstructorDecl(s)); - - // solver_dt_memory->make_new_datatypecons_decl(s, new_dt_cons_decl); return new_dt_cons_decl; } @@ -580,9 +554,9 @@ void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructor { shared_ptr gdtc = static_pointer_cast(con); - auto gdt = (*datatypedecl_datatype_map)[dt]; + string name = (*datatypedecl_name_map)[dt]; + auto gdt = (*name_datatype_map)[name]; gdt->add_constructor(*gdtc); - // solver_dt_memory->add_datatypecons_decl(dt, con); } void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const @@ -591,12 +565,8 @@ void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string make_shared(); (*newSelector).name = name; (*newSelector).sort = s; - shared_ptr gdtc = - static_pointer_cast(dt); - // auto gdt = (*datatypedecl_datatype_map)[dt]; + shared_ptr gdtc = static_pointer_cast(dt); gdtc->add_new_selector(newSelector); - // solver_dt_memory->make_selector_components(name, s); - // solver_dt_memory->add_selector_to_dt_cons_decl(dt, newSelector); } void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const From c235259dab3380458b884aef216119c005c6c282 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Mon, 5 Jul 2021 18:17:59 -0700 Subject: [PATCH 11/47] Responded to most requested changes in the last pr. Due to weirdness with the datatypes, some functionality can't be tested currently. --- include/datatype.h | 19 ++++----- include/generic_datatype.h | 2 +- include/generic_solver.h | 6 +-- src/generic_datatype.cpp | 86 ++++++++++++++++++++------------------ src/generic_solver.cpp | 3 +- 5 files changed, 60 insertions(+), 56 deletions(-) diff --git a/include/datatype.h b/include/datatype.h index 610548905..62c358813 100644 --- a/include/datatype.h +++ b/include/datatype.h @@ -35,9 +35,8 @@ class AbsDatatypeConstructorDecl { public: AbsDatatypeConstructorDecl(){}; virtual ~AbsDatatypeConstructorDecl(){}; - virtual std::string get_name() const=0; - virtual bool compare(const AbsDatatypeConstructorDecl & d) const=0; - + virtual std::string get_name() const = 0; + virtual bool compare(const AbsDatatypeConstructorDecl & d) const = 0; }; @@ -49,13 +48,13 @@ class AbsDatatype { virtual std::string get_name() const=0; virtual int get_num_selectors(std::string cons) const=0; virtual int get_num_constructors() const=0; - virtual bool compare(const AbsDatatype & d) const=0; - + virtual bool compare(const AbsDatatype & d) const = 0; }; -bool operator==(const AbsDatatype& d1, const AbsDatatype& d2); -bool operator!=(const AbsDatatype& d1, const AbsDatatype& d2); - -bool operator==(const AbsDatatypeConstructorDecl& d1, const AbsDatatypeConstructorDecl& d2); -bool operator!=(const AbsDatatypeConstructorDecl& d1, const AbsDatatypeConstructorDecl& d2); +bool operator==(const AbsDatatype & d1, const AbsDatatype & d2); +bool operator!=(const AbsDatatype & d1, const AbsDatatype & d2); +bool operator==(const AbsDatatypeConstructorDecl & d1, + const AbsDatatypeConstructorDecl & d2); +bool operator!=(const AbsDatatypeConstructorDecl & d1, + const AbsDatatypeConstructorDecl & d2); } diff --git a/include/generic_datatype.h b/include/generic_datatype.h index f1f04a536..7bab74e4d 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -8,7 +8,7 @@ // using namespace smt; namespace smt { - + struct selectorComponents { std::string name; diff --git a/include/generic_solver.h b/include/generic_solver.h index 94dbdd802..a1d2b7784 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -259,9 +259,9 @@ class GenericSolver : public AbsSmtSolver std::unique_ptr> datatypedecl_name_map; // Map between names and Generic datatypes - std::unique_ptr>> - name_datatype_map; - + std::unique_ptr< + std::unordered_map>> + name_datatype_map; }; } // namespace smt diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 7e543635e..c3d829177 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -8,37 +8,40 @@ using namespace std; namespace smt { - GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( -const std::string & name) +GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( + const std::string & name) : cons_name(name) { } - void GenericDatatypeConstructorDecl::add_new_selector(const shared_ptr & newSelector) +void GenericDatatypeConstructorDecl::add_new_selector( + const shared_ptr & newSelector) { - selector_vector.push_back(*newSelector); + selector_vector.push_back(*newSelector); } - std::vector GenericDatatypeConstructorDecl::get_selector_vector() - { - return selector_vector; - } - - std::string GenericDatatypeConstructorDecl::get_name() const - { - return cons_name; - } +std::vector +GenericDatatypeConstructorDecl::get_selector_vector() +{ + return selector_vector; +} - int GenericDatatypeConstructorDecl::get_selector_count() const - { - return selector_vector.size(); - } - bool GenericDatatypeConstructorDecl::compare(const AbsDatatypeConstructorDecl & d) const - { - // Why won't type casting like this work? - // GenericDatatypeConstructorDecl gdtc = (GenericDatatypeConstructorDecl) d; - return cons_name == d.get_name(); - } +std::string GenericDatatypeConstructorDecl::get_name() const +{ + return cons_name; +} + +int GenericDatatypeConstructorDecl::get_selector_count() const +{ + return selector_vector.size(); +} +bool GenericDatatypeConstructorDecl::compare( + const AbsDatatypeConstructorDecl & d) const +{ + // Why won't type casting like this work? + // GenericDatatypeConstructorDecl gdtc = (GenericDatatypeConstructorDecl) d; + return cons_name == d.get_name(); +} GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration, const std::string & s) @@ -52,20 +55,22 @@ void GenericDatatype::add_constructor( cons_decl_vector.push_back(dt_cons_decl); } - void GenericDatatype::add_selector(const GenericDatatypeConstructorDecl & dt_cons_decl, const std::shared_ptr & newSelector) - { - for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) - { - if (cons_decl_vector[i].get_name() == dt_cons_decl.get_name()) - { - cons_decl_vector[i].get_selector_vector().push_back(*newSelector); - } - } - } - std::vector GenericDatatype::get_cons_vector() +void GenericDatatype::add_selector( + const GenericDatatypeConstructorDecl & dt_cons_decl, + const std::shared_ptr & newSelector) +{ + for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { - return cons_decl_vector; + if (cons_decl_vector[i].get_name() == dt_cons_decl.get_name()) + { + cons_decl_vector[i].get_selector_vector().push_back(*newSelector); + } } +} +std::vector GenericDatatype::get_cons_vector() +{ + return cons_decl_vector; +} std::string GenericDatatype::get_name() const { return name; } @@ -87,10 +92,9 @@ int GenericDatatype::get_num_selectors(std::string cons) const return num_selectors; } - bool GenericDatatype::compare(const AbsDatatype & d) const - { - return name == d.get_name(); - } - - +bool GenericDatatype::compare(const AbsDatatype & d) const +{ + return name == d.get_name(); +} + } // namespace smt diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index fcb0ea18d..30596e7f3 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -565,7 +565,8 @@ void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string make_shared(); (*newSelector).name = name; (*newSelector).sort = s; - shared_ptr gdtc = static_pointer_cast(dt); + shared_ptr gdtc = + static_pointer_cast(dt); gdtc->add_new_selector(newSelector); } From 524b305eedff7cd3d3ed08c7542a9c720404deeb Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Wed, 7 Jul 2021 09:48:52 -0700 Subject: [PATCH 12/47] Added fixes for the generic datatype implementation, and made generic datatype sorts up to speed with other types of sorts and the datatype classes. --- CMakeLists.txt | 1 + cvc4/CMakeLists.txt | 1 + cvc4/include/cvc4_datatype.h | 1 + include/datatype.h | 18 +++++++++--------- include/generic_datatype.h | 16 +++++++++------- include/generic_sort.h | 15 +++++++++------ src/generic_datatype.cpp | 25 +++++++++++++------------ src/generic_solver.cpp | 16 ++++++++-------- src/generic_sort.cpp | 28 ++++++++++++++++++++++------ tests/test-generic-sort.cpp | 6 +++--- 10 files changed, 76 insertions(+), 51 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0eddadfa9..382f42d49 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,6 +23,7 @@ add_definitions(-DSMT_SWITCH_DIR=${PROJECT_SOURCE_DIR}) set (SOURCES "${SMT_SWITCH_LIB_TYPE}" "${PROJECT_SOURCE_DIR}/include/smtlib_utils.h" + "${PROJECT_SOURCE_DIR}/src/datatype.cpp" "${PROJECT_SOURCE_DIR}/src/generic_datatype.cpp" "${PROJECT_SOURCE_DIR}/src/generic_solver.cpp" "${PROJECT_SOURCE_DIR}/src/generic_sort.cpp" diff --git a/cvc4/CMakeLists.txt b/cvc4/CMakeLists.txt index 6ffcaf2f5..747be48e3 100644 --- a/cvc4/CMakeLists.txt +++ b/cvc4/CMakeLists.txt @@ -3,6 +3,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON) find_library(LIBRT rt) add_library(smt-switch-cvc4 "${SMT_SWITCH_LIB_TYPE}" + "${CMAKE_CURRENT_SOURCE_DIR}/src/cvc4_datatype.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/cvc4_factory.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/cvc4_solver.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/cvc4_sort.cpp" diff --git a/cvc4/include/cvc4_datatype.h b/cvc4/include/cvc4_datatype.h index f090af4e9..9dce63c70 100644 --- a/cvc4/include/cvc4_datatype.h +++ b/cvc4/include/cvc4_datatype.h @@ -34,6 +34,7 @@ namespace smt { class CVC4DatatypeConstructorDecl : public AbsDatatypeConstructorDecl { public : CVC4DatatypeConstructorDecl(CVC4::api::DatatypeConstructorDecl t) : datatypeconstructordecl(t) {}; + bool compare(const DatatypeConstructorDecl &) const override; protected: CVC4::api::DatatypeConstructorDecl datatypeconstructordecl; diff --git a/include/datatype.h b/include/datatype.h index 62c358813..4f620fe23 100644 --- a/include/datatype.h +++ b/include/datatype.h @@ -35,8 +35,8 @@ class AbsDatatypeConstructorDecl { public: AbsDatatypeConstructorDecl(){}; virtual ~AbsDatatypeConstructorDecl(){}; - virtual std::string get_name() const = 0; - virtual bool compare(const AbsDatatypeConstructorDecl & d) const = 0; + // virtual std::string get_name() const = 0; + virtual bool compare(const DatatypeConstructorDecl & d) const = 0; }; @@ -48,13 +48,13 @@ class AbsDatatype { virtual std::string get_name() const=0; virtual int get_num_selectors(std::string cons) const=0; virtual int get_num_constructors() const=0; - virtual bool compare(const AbsDatatype & d) const = 0; + //virtual bool compare(const Datatype & d) const = 0; }; -bool operator==(const AbsDatatype & d1, const AbsDatatype & d2); -bool operator!=(const AbsDatatype & d1, const AbsDatatype & d2); +//bool operator==(const Datatype & d1, const Datatype & d2); +//bool operator!=(const Datatype & d1, const Datatype & d2); -bool operator==(const AbsDatatypeConstructorDecl & d1, - const AbsDatatypeConstructorDecl & d2); -bool operator!=(const AbsDatatypeConstructorDecl & d1, - const AbsDatatypeConstructorDecl & d2); +bool operator==(const DatatypeConstructorDecl & d1, + const DatatypeConstructorDecl & d2); +bool operator!=(const DatatypeConstructorDecl & d1, + const DatatypeConstructorDecl & d2); } diff --git a/include/generic_datatype.h b/include/generic_datatype.h index 7bab74e4d..a78509fd9 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -15,6 +15,8 @@ struct selectorComponents Sort sort; }; + + class GenericDatatypeDecl : public AbsDatatypeDecl { public: @@ -33,9 +35,9 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl void add_new_selector( const std::shared_ptr & newSelector); std::vector get_selector_vector(); - std::string get_name() const override; + std::string get_name() const; int get_selector_count() const; - bool compare(const AbsDatatypeConstructorDecl & d) const override; + bool compare(const DatatypeConstructorDecl & d) const override; protected: std::vector selector_vector; @@ -48,20 +50,20 @@ class GenericDatatype : public AbsDatatype public: GenericDatatype(const DatatypeDecl & dt_declaration, const std::string & s); virtual ~GenericDatatype(){}; - void add_constructor(const GenericDatatypeConstructorDecl & dt_cons_decl); - void add_selector(const GenericDatatypeConstructorDecl & dt_cons_decl, + void add_constructor(const DatatypeConstructorDecl & dt_cons_decl); + void add_selector(const DatatypeConstructorDecl & dt_cons_decl, const std::shared_ptr & newSelector); - std::vector get_cons_vector(); + std::vector get_cons_vector(); std::string get_name() const override; int get_num_constructors() const override; int get_num_selectors(std::string cons) const override; - bool compare(const AbsDatatype & d) const override; + //bool compare(const Datatype & d) const override; std::hash str_hash; protected: DatatypeDecl dt_decl; std::string name; - std::vector cons_decl_vector; + std::vector cons_decl_vector; friend class GenericSolver; }; diff --git a/include/generic_sort.h b/include/generic_sort.h index cf373eb81..9d6c13f49 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -31,7 +31,7 @@ Sort make_generic_sort(SortKind sk, Sort sort1); Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2); Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2, Sort sort3); Sort make_generic_sort(SortKind sk, SortVec sorts); -Sort make_generic_sort(DatatypeDecl dt, std::string & name); +Sort make_generic_sort(Datatype dt, std::string & name); /* smtlib representation of sort kinds */ std::string to_smtlib(SortKind); @@ -41,7 +41,8 @@ std::string to_smtlib(SortKind); class GenericSort : public AbsSort { public: - GenericSort(SortKind sk); + GenericSort(SortKind sk); + GenericSort(SortKind sk, std::string name_var); virtual ~GenericSort(); SortKind get_sort_kind() const override; bool compare(const Sort & s) const override; @@ -110,11 +111,13 @@ class GenericSort : public AbsSort // A string representation of a sort std::string to_string() const override; + std::string get_base_name() const; + protected: // internal function to compute // the string representation of a sort std::string compute_string() const; - + std::string base_name; // The underlying SortKind of the GenericSort SortKind sk; @@ -190,16 +193,16 @@ class UninterpretedGenericSort : public GenericSort class GenericDatatypeSort : public GenericSort { public: - GenericDatatypeSort(DatatypeDecl & dt, std::string & name); + GenericDatatypeSort(const Datatype & dt, std::string & name); ~GenericDatatypeSort(); std::string get_sort_name(); - DatatypeDecl get_datatype_decl(); + Datatype get_datatype() const override; bool compare(const Sort & s) const override; std::string compute_string() const; protected: std::string sort_name; - DatatypeDecl dt_decl; + Datatype gdt; }; } // namespace smt diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index c3d829177..990323bd4 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -36,11 +36,11 @@ int GenericDatatypeConstructorDecl::get_selector_count() const return selector_vector.size(); } bool GenericDatatypeConstructorDecl::compare( - const AbsDatatypeConstructorDecl & d) const + const DatatypeConstructorDecl & d) const { // Why won't type casting like this work? // GenericDatatypeConstructorDecl gdtc = (GenericDatatypeConstructorDecl) d; - return cons_name == d.get_name(); + return cons_name == static_pointer_cast(d)->get_name(); } GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration, @@ -50,24 +50,24 @@ GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration, } void GenericDatatype::add_constructor( - const GenericDatatypeConstructorDecl & dt_cons_decl) + const DatatypeConstructorDecl & dt_cons_decl) { cons_decl_vector.push_back(dt_cons_decl); } void GenericDatatype::add_selector( - const GenericDatatypeConstructorDecl & dt_cons_decl, + const DatatypeConstructorDecl & dt_cons_decl, const std::shared_ptr & newSelector) { for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { - if (cons_decl_vector[i].get_name() == dt_cons_decl.get_name()) + if (cons_decl_vector[i] == dt_cons_decl) { - cons_decl_vector[i].get_selector_vector().push_back(*newSelector); + static_pointer_cast(cons_decl_vector[i])->get_selector_vector().push_back(*newSelector); } } } -std::vector GenericDatatype::get_cons_vector() +std::vector GenericDatatype::get_cons_vector() { return cons_decl_vector; } @@ -84,17 +84,18 @@ int GenericDatatype::get_num_selectors(std::string cons) const int num_selectors = 0; for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { - if (cons_decl_vector[i].get_name() == cons) + if (static_pointer_cast(cons_decl_vector[i])->get_name() == cons) { - num_selectors = cons_decl_vector[i].get_selector_count(); + num_selectors = static_pointer_cast(cons_decl_vector[i])->get_selector_count(); } } return num_selectors; } - -bool GenericDatatype::compare(const AbsDatatype & d) const + /* +bool GenericDatatype::compare(const Datatype & d) const { - return name == d.get_name(); + return name == d->get_name(); } + */ } // namespace smt diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 30596e7f3..56b44f2db 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -493,17 +493,17 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // build string for each constructor for (unsigned long i = 0; i < curr_dt->get_cons_vector().size(); ++i) { - GenericDatatypeConstructorDecl curr_dt_cons_decl = + DatatypeConstructorDecl curr_dt_cons_decl = curr_dt->get_cons_vector()[i]; - to_solver += " (" + curr_dt_cons_decl.get_name(); + to_solver += " (" + static_pointer_cast(curr_dt_cons_decl)->get_name(); // adjust string for each selector for (unsigned long f = 0; - f < curr_dt_cons_decl.get_selector_vector().size(); + f < static_pointer_cast(curr_dt_cons_decl)->get_selector_vector().size(); ++f) { - to_solver += " ( " + curr_dt_cons_decl.get_selector_vector()[f].name; + to_solver += " ( " + static_pointer_cast(curr_dt_cons_decl)->get_selector_vector()[f].name; to_solver += - " " + (curr_dt_cons_decl.get_selector_vector()[f].sort)->to_string() + " " + (static_pointer_cast(curr_dt_cons_decl)->get_selector_vector()[f].sort)->to_string() + " )"; } @@ -518,7 +518,7 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // errors (undefined reference when I call the new // make_generic_sort). assert(name_sort_map->find(dt_decl_name) == name_sort_map->end()); - Sort dt_sort = make_shared(testdt, dt_decl_name); + Sort dt_sort = make_shared(curr_dt, dt_decl_name); (*name_sort_map)[dt_decl_name] = dt_sort; (*sort_name_map)[dt_sort] = dt_decl_name; run_command(to_solver); @@ -552,11 +552,11 @@ DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructorDecl & con) const { - shared_ptr gdtc = + DatatypeConstructorDecl gdtc = static_pointer_cast(con); string name = (*datatypedecl_name_map)[dt]; auto gdt = (*name_datatype_map)[name]; - gdt->add_constructor(*gdtc); + gdt->add_constructor(gdtc); } void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index f0dcac764..09d7c3430 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -119,7 +119,7 @@ Sort make_generic_sort(SortKind sk, SortVec sorts) } } -Sort make_generic_sort(DatatypeDecl & dt, std::string & name) +Sort make_generic_sort(Datatype & dt, std::string & name) { return make_shared(dt, name); } @@ -128,6 +128,8 @@ Sort make_generic_sort(DatatypeDecl & dt, std::string & name) GenericSort::GenericSort(SortKind sk) : sk(sk) {} + GenericSort::GenericSort(SortKind sk, std::string name_var) : sk(sk) {} + GenericSort::~GenericSort() {} size_t GenericSort::hash() const { @@ -192,6 +194,11 @@ string GenericSort::compute_string() const { SortKind GenericSort::get_sort_kind() const { return sk; } + std::string GenericSort::get_base_name() const + { + return base_name; + } + bool GenericSort::compare(const Sort & s) const { SortKind other_sk = s->get_sort_kind(); @@ -242,7 +249,13 @@ bool GenericSort::compare(const Sort & s) const } case DATATYPE: { - throw NotImplementedException("GenericSort::compare"); + //throw NotImplementedException("GenericSort::compare"); + assert(sk == DATATYPE); + //shared_ptr this_type_cast = + //reinterpret_cast(*this); + //shared_ptr this_type_cast = static_pointer_cast(*this); + shared_ptr other_type_cast = static_pointer_cast(s); + return base_name == other_type_cast->compute_string(); } case NUM_SORT_KINDS: { @@ -337,8 +350,8 @@ SortVec UninterpretedGenericSort::get_uninterpreted_param_sorts() const return param_sorts; } -GenericDatatypeSort::GenericDatatypeSort(DatatypeDecl & dt, std::string & name) - : GenericSort(DATATYPE), dt_decl(dt), sort_name(name) +GenericDatatypeSort::GenericDatatypeSort(const Datatype & dt, std::string & name) + : GenericSort(DATATYPE), gdt(dt), sort_name(name) { } @@ -346,7 +359,7 @@ GenericDatatypeSort::~GenericDatatypeSort() {} std::string GenericDatatypeSort::get_sort_name() { return sort_name; } -DatatypeDecl GenericDatatypeSort::get_datatype_decl() { return dt_decl; } +Datatype GenericDatatypeSort::get_datatype() const { return gdt; } string GenericDatatypeSort::compute_string() const { return sort_name; } @@ -358,7 +371,10 @@ bool GenericDatatypeSort::compare(const Sort & s) const std::string other_sort_name = gdsort->sort_name; return sort_name.compare(other_sort_name); */ - return true; + //return true; + assert(s->get_sort_kind() == DATATYPE); + shared_ptr other_sort = static_pointer_cast(s); + return sort_name == other_sort->compute_string(); } } // namespace smt diff --git a/tests/test-generic-sort.cpp b/tests/test-generic-sort.cpp index 12556b34c..7c5153b8d 100644 --- a/tests/test-generic-sort.cpp +++ b/tests/test-generic-sort.cpp @@ -70,7 +70,7 @@ int main() assert(us1 != us3); assert(us1->get_uninterpreted_name() == "sort1"); assert(us1->get_arity() == 0); - + cout << "pre datatype" << endl; GenericSort d1(DATATYPE); GenericSort d2(DATATYPE); std::cout << "testing basic properties of datatype sorts" << std::endl; @@ -80,10 +80,10 @@ int main() assert(d2.to_string() == d1.to_string()); assert((d1.get_sort_kind()) == (d2.get_sort_kind())); assert(d1.get_sort_kind() == DATATYPE); - + cout << "almost there" << endl; Sort dt1 = make_generic_sort(DATATYPE); Sort dt2 = make_generic_sort(DATATYPE); - assert(dt1 == dt2); + //assert(dt1 == dt2); return 0; } From 9656480eeed4f113c7e1b5adf95f3ac73c5bc114 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Thu, 8 Jul 2021 01:39:00 -0700 Subject: [PATCH 13/47] First iteration of response to requested changes. --- include/datatype.h | 1 - include/generic_datatype.h | 9 ++++++--- include/generic_datatype.h~ | 27 --------------------------- include/generic_solver.h | 15 +++++++-------- include/generic_sort.h | 8 ++++++-- src/generic_datatype.cpp | 35 +++++++++++++++++++++++++++++------ src/generic_solver.cpp | 31 ++++++++++++++----------------- src/generic_sort.cpp | 16 ++++++++++------ src/solver_enums.cpp | 3 +-- tests/test-generic-sort.cpp | 4 +++- 10 files changed, 76 insertions(+), 73 deletions(-) delete mode 100644 include/generic_datatype.h~ diff --git a/include/datatype.h b/include/datatype.h index 4f620fe23..162e16f45 100644 --- a/include/datatype.h +++ b/include/datatype.h @@ -35,7 +35,6 @@ class AbsDatatypeConstructorDecl { public: AbsDatatypeConstructorDecl(){}; virtual ~AbsDatatypeConstructorDecl(){}; - // virtual std::string get_name() const = 0; virtual bool compare(const DatatypeConstructorDecl & d) const = 0; }; diff --git a/include/generic_datatype.h b/include/generic_datatype.h index a78509fd9..a8ef3060c 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -1,9 +1,10 @@ +#pragma once #include #include #include "datatype.h" #include "exceptions.h" -#include "generic_sort.h" +#include "sort.h" #include "smt_defs.h" // using namespace smt; @@ -20,11 +21,13 @@ struct selectorComponents class GenericDatatypeDecl : public AbsDatatypeDecl { public: - GenericDatatypeDecl(){}; + GenericDatatypeDecl(const std::string name); virtual ~GenericDatatypeDecl(){}; + std::string get_name(); protected: friend class GenericSolver; + std::string dt_name; }; class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl @@ -48,7 +51,7 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl class GenericDatatype : public AbsDatatype { public: - GenericDatatype(const DatatypeDecl & dt_declaration, const std::string & s); + GenericDatatype(const DatatypeDecl & dt_declaration); virtual ~GenericDatatype(){}; void add_constructor(const DatatypeConstructorDecl & dt_cons_decl); void add_selector(const DatatypeConstructorDecl & dt_cons_decl, diff --git a/include/generic_datatype.h~ b/include/generic_datatype.h~ deleted file mode 100644 index 0d7daa8be..000000000 --- a/include/generic_datatype.h~ +++ /dev/null @@ -1,27 +0,0 @@ - -namespace smt { - -class GenericDatatype : public AbsDatatypeDecl -{ - public: GenericDatatypeDecl(); - virtual ~GenericDatatypeDecl(); - - protected: - friend class GenericSolver; -}; - -class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl { - public: - GenericDatatypeConstructorDecl(){}; - virtual ~GenericDatatypeConstructorDecl(){}; - protected: - friend class GenericSolver; -}; - -class GenericDatatype : public AbsDatatype { - public: - GenericDatatype(){}; - virtual ~GenericDatatype(){}; - proteced: - friend class GenericSolver; -}; diff --git a/include/generic_solver.h b/include/generic_solver.h index a1d2b7784..c32fab347 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -27,7 +27,7 @@ #include #include -#include "generic_datatype.h" +//#include "generic_datatype.h" #include "generic_sort.h" #include "generic_term.h" #include "solver.h" @@ -254,14 +254,13 @@ class GenericSolver : public AbsSmtSolver std::unique_ptr> term_name_map; // maps between datatype declaration and name and vice versa - std::unique_ptr> - name_datatypedecl_map; - std::unique_ptr> - datatypedecl_name_map; + //std::unique_ptr> + // name_datatypedecl_map; + //std::unique_ptr> + // datatypedecl_name_map; // Map between names and Generic datatypes - std::unique_ptr< - std::unordered_map>> - name_datatype_map; + std::unique_ptr>> name_datatype_map; + std::unique_ptr, std::string>> datatype_name_map; }; } // namespace smt diff --git a/include/generic_sort.h b/include/generic_sort.h index 9d6c13f49..928fd4409 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -19,9 +19,12 @@ #include "exceptions.h" #include "smt_defs.h" #include "sort.h" +#include "generic_datatype.h" #include + namespace smt { + class GenericDatatye; /* Helper functions for creating generic sorts */ Sort make_uninterpreted_generic_sort(std::string name, uint64_t arity); Sort make_uninterpreted_generic_sort(Sort sort_cons, const SortVec& sorts); @@ -31,7 +34,7 @@ Sort make_generic_sort(SortKind sk, Sort sort1); Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2); Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2, Sort sort3); Sort make_generic_sort(SortKind sk, SortVec sorts); -Sort make_generic_sort(Datatype dt, std::string & name); +Sort make_generic_sort(Datatype dt); /* smtlib representation of sort kinds */ std::string to_smtlib(SortKind); @@ -42,6 +45,7 @@ class GenericSort : public AbsSort { public: GenericSort(SortKind sk); + // This second constructor is only for datatype sorts GenericSort(SortKind sk, std::string name_var); virtual ~GenericSort(); SortKind get_sort_kind() const override; @@ -193,7 +197,7 @@ class UninterpretedGenericSort : public GenericSort class GenericDatatypeSort : public GenericSort { public: - GenericDatatypeSort(const Datatype & dt, std::string & name); + GenericDatatypeSort(const Datatype & dt); ~GenericDatatypeSort(); std::string get_sort_name(); Datatype get_datatype() const override; diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 990323bd4..85dbf6c2e 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -2,12 +2,23 @@ #include #include - +#include #include "assert.h" +#include using namespace std; namespace smt { + +GenericDatatypeDecl::GenericDatatypeDecl(const std::string name) :dt_name(name) +{ +} + +std::string GenericDatatypeDecl::get_name() +{ + return dt_name; +} + GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( const std::string & name) : cons_name(name) @@ -17,6 +28,13 @@ GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( void GenericDatatypeConstructorDecl::add_new_selector( const shared_ptr & newSelector) { + // This seems like an opportunity for a new comparison function for + // the struct. + for (unsigned int i = 0; i < selector_vector.size(); ++i) { + if (selector_vector[i].name == (*newSelector).name) { + throw "Can't add selector. It already exists in vector!"; + } + } selector_vector.push_back(*newSelector); } @@ -43,15 +61,17 @@ bool GenericDatatypeConstructorDecl::compare( return cons_name == static_pointer_cast(d)->get_name(); } -GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration, - const std::string & s) - : dt_decl(dt_declaration), name(s) +GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration) + : dt_decl(dt_declaration) { } void GenericDatatype::add_constructor( const DatatypeConstructorDecl & dt_cons_decl) { + if (std::find(cons_decl_vector.begin(), cons_decl_vector.end(), dt_cons_decl) != cons_decl_vector.end()) { + throw "Can't add constructor. It already has been added!"; + } cons_decl_vector.push_back(dt_cons_decl); } @@ -63,7 +83,8 @@ void GenericDatatype::add_selector( { if (cons_decl_vector[i] == dt_cons_decl) { - static_pointer_cast(cons_decl_vector[i])->get_selector_vector().push_back(*newSelector); + //static_pointer_cast(cons_decl_vector[i])->add_new_selector(*newSelector); + } } } @@ -72,7 +93,9 @@ std::vector GenericDatatype::get_cons_vector() return cons_decl_vector; } -std::string GenericDatatype::get_name() const { return name; } + std::string GenericDatatype::get_name() const { //return name; + return static_pointer_cast(dt_decl)->get_name(); +} int GenericDatatype::get_num_constructors() const { diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 56b44f2db..743830320 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -80,8 +80,8 @@ GenericSolver::GenericSolver(string path, term_name_map(new unordered_map()), name_datatype_map( new unordered_map>()), - name_datatypedecl_map(new unordered_map()), - datatypedecl_name_map(new unordered_map()) + datatype_name_map( + new unordered_map, string>()) { // Buffer sizes over 256 caused issues in tests. // Until this is investigated, we support a conservative @@ -481,8 +481,9 @@ Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const Sort GenericSolver::make_sort(const DatatypeDecl & d) const { - assert(datatypedecl_name_map->find(d) != datatypedecl_name_map->end()); - string dt_decl_name = (*datatypedecl_name_map)[d]; + shared_ptr gdt_decl = static_pointer_cast(d); + string dt_decl_name = gdt_decl->get_name(); + assert(name_datatype_map->find(dt_decl_name) != name_datatype_map->end()); shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; if (name_sort_map->find(dt_decl_name) == name_sort_map->end()) { @@ -510,17 +511,15 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const to_solver += ")"; } to_solver += ")\n))"; - // add the sort to the maps - - // GenericDatatypeSort can't take in a const value - DatatypeDecl testdt = (*name_datatypedecl_map)[dt_decl_name]; // Exact functionality of make_genericsort, without the linking // errors (undefined reference when I call the new // make_generic_sort). assert(name_sort_map->find(dt_decl_name) == name_sort_map->end()); - Sort dt_sort = make_shared(curr_dt, dt_decl_name); + Sort dt_sort = make_shared(curr_dt); (*name_sort_map)[dt_decl_name] = dt_sort; (*sort_name_map)[dt_sort] = dt_decl_name; + cout << "SOlver texr" << endl; + cout << to_solver << endl; run_command(to_solver); return dt_sort; } @@ -533,12 +532,11 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) { - DatatypeDecl new_dt_decl = make_shared(); - (*name_datatypedecl_map)[s] = new_dt_decl; - (*datatypedecl_name_map)[new_dt_decl] = s; + DatatypeDecl new_dt_decl = make_shared(s); shared_ptr new_dt = - shared_ptr(new GenericDatatype(new_dt_decl, s)); + shared_ptr(new GenericDatatype(new_dt_decl)); (*name_datatype_map)[s] = new_dt; + (*datatype_name_map)[new_dt] = s; return new_dt_decl; } DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( @@ -552,11 +550,10 @@ DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructorDecl & con) const { - DatatypeConstructorDecl gdtc = - static_pointer_cast(con); - string name = (*datatypedecl_name_map)[dt]; + shared_ptr gdt_decl = static_pointer_cast(dt); + string name = gdt_decl->get_name(); auto gdt = (*name_datatype_map)[name]; - gdt->add_constructor(gdtc); + gdt->add_constructor(con); } void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 09d7c3430..77aeee8bb 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -15,6 +15,7 @@ #include "generic_sort.h" #include +#include "generic_datatype.h" #include #include "assert.h" #include "utils.h" @@ -36,7 +37,7 @@ Sort make_uninterpreted_generic_sort(Sort sort_cons, Sort make_generic_sort(SortKind sk) { // Tweaked to accept datatypes temporarily - if (sk != BOOL && sk != INT && sk != REAL && sk != DATATYPE) + if (sk != BOOL && sk != INT && sk != REAL) { throw IncorrectUsageException("Can't create sort from " + to_string(sk)); } @@ -119,9 +120,9 @@ Sort make_generic_sort(SortKind sk, SortVec sorts) } } -Sort make_generic_sort(Datatype & dt, std::string & name) +Sort make_generic_sort(Datatype & dt) { - return make_shared(dt, name); + return make_shared(dt); } // implementations @@ -350,8 +351,8 @@ SortVec UninterpretedGenericSort::get_uninterpreted_param_sorts() const return param_sorts; } -GenericDatatypeSort::GenericDatatypeSort(const Datatype & dt, std::string & name) - : GenericSort(DATATYPE), gdt(dt), sort_name(name) +GenericDatatypeSort::GenericDatatypeSort(const Datatype & dt) + : GenericSort(DATATYPE), gdt(dt), sort_name(static_pointer_cast(dt)->get_name()) { } @@ -361,7 +362,10 @@ std::string GenericDatatypeSort::get_sort_name() { return sort_name; } Datatype GenericDatatypeSort::get_datatype() const { return gdt; } -string GenericDatatypeSort::compute_string() const { return sort_name; } +string GenericDatatypeSort::compute_string() const { + //return static_pointer_cast(gdt)->get_name(); + return sort_name; +} bool GenericDatatypeSort::compare(const Sort & s) const { diff --git a/src/solver_enums.cpp b/src/solver_enums.cpp index 85128fa84..60a9953e0 100644 --- a/src/solver_enums.cpp +++ b/src/solver_enums.cpp @@ -41,8 +41,7 @@ const unordered_map> UNSAT_CORE, // TEMP only temporarily disabled until bitwuzla // quantifier refactoring is done - // see - // https://github.com/bitwuzla/bitwuzla/commit/605f31557ec6c635e3c617d2b0ab257309e994c4 + // see https://github.com/bitwuzla/bitwuzla/commit/605f31557ec6c635e3c617d2b0ab257309e994c4 // QUANTIFIERS, BOOL_BV1_ALIASING } }, diff --git a/tests/test-generic-sort.cpp b/tests/test-generic-sort.cpp index 7c5153b8d..a12a984b3 100644 --- a/tests/test-generic-sort.cpp +++ b/tests/test-generic-sort.cpp @@ -71,6 +71,7 @@ int main() assert(us1->get_uninterpreted_name() == "sort1"); assert(us1->get_arity() == 0); cout << "pre datatype" << endl; + /* GenericSort d1(DATATYPE); GenericSort d2(DATATYPE); std::cout << "testing basic properties of datatype sorts" << std::endl; @@ -83,7 +84,8 @@ int main() cout << "almost there" << endl; Sort dt1 = make_generic_sort(DATATYPE); Sort dt2 = make_generic_sort(DATATYPE); - //assert(dt1 == dt2); + assert(dt1 == dt2); + */ return 0; } From 107c61ceb3244a3e249f4459246ee0866d49a8df Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Thu, 8 Jul 2021 01:48:02 -0700 Subject: [PATCH 14/47] Added responses to most requested changes and removed commented lines --- include/generic_solver.h | 8 +------- src/generic_datatype.cpp | 6 +++--- src/generic_sort.cpp | 17 ++--------------- 3 files changed, 6 insertions(+), 25 deletions(-) diff --git a/include/generic_solver.h b/include/generic_solver.h index c32fab347..ea1c30377 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -27,7 +27,6 @@ #include #include -//#include "generic_datatype.h" #include "generic_sort.h" #include "generic_term.h" #include "solver.h" @@ -253,12 +252,7 @@ class GenericSolver : public AbsSmtSolver std::unique_ptr> name_term_map; std::unique_ptr> term_name_map; - // maps between datatype declaration and name and vice versa - //std::unique_ptr> - // name_datatypedecl_map; - //std::unique_ptr> - // datatypedecl_name_map; - // Map between names and Generic datatypes + // Map between names and Generic datatypes and vice versa std::unique_ptr>> name_datatype_map; std::unique_ptr, std::string>> datatype_name_map; }; diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 85dbf6c2e..5df92df72 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -83,8 +83,7 @@ void GenericDatatype::add_selector( { if (cons_decl_vector[i] == dt_cons_decl) { - //static_pointer_cast(cons_decl_vector[i])->add_new_selector(*newSelector); - + static_pointer_cast(cons_decl_vector[i])->add_new_selector(newSelector); } } } @@ -93,7 +92,7 @@ std::vector GenericDatatype::get_cons_vector() return cons_decl_vector; } - std::string GenericDatatype::get_name() const { //return name; + std::string GenericDatatype::get_name() const { return static_pointer_cast(dt_decl)->get_name(); } @@ -114,6 +113,7 @@ int GenericDatatype::get_num_selectors(std::string cons) const } return num_selectors; } + // Still deciding if I should implement a datatype comparison function /* bool GenericDatatype::compare(const Datatype & d) const { diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 77aeee8bb..f2c4955c7 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -182,8 +182,7 @@ string GenericSort::compute_string() const { } else if (get_sort_kind() == SortKind::DATATYPE) { - // Placeholder response to avoid segfaulting - return smt::to_smtlib(SortKind::BOOL); + return base_name; } else { @@ -250,11 +249,7 @@ bool GenericSort::compare(const Sort & s) const } case DATATYPE: { - //throw NotImplementedException("GenericSort::compare"); assert(sk == DATATYPE); - //shared_ptr this_type_cast = - //reinterpret_cast(*this); - //shared_ptr this_type_cast = static_pointer_cast(*this); shared_ptr other_type_cast = static_pointer_cast(s); return base_name == other_type_cast->compute_string(); } @@ -363,22 +358,14 @@ std::string GenericDatatypeSort::get_sort_name() { return sort_name; } Datatype GenericDatatypeSort::get_datatype() const { return gdt; } string GenericDatatypeSort::compute_string() const { - //return static_pointer_cast(gdt)->get_name(); return sort_name; } bool GenericDatatypeSort::compare(const Sort & s) const { - // in need of additional casting debugging - /* - const GenericDatatypeSort gdsort = (GenericDatatypeSort) s; - std::string other_sort_name = gdsort->sort_name; - return sort_name.compare(other_sort_name); - */ - //return true; assert(s->get_sort_kind() == DATATYPE); shared_ptr other_sort = static_pointer_cast(s); - return sort_name == other_sort->compute_string(); + return sort_name == other_sort->to_string(); } } // namespace smt From 91123163971a78d61d299ef581e52f4331a0af78 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 9 Jul 2021 11:41:59 -0700 Subject: [PATCH 15/47] Additional tweaks, refined testing for the datatype sorts. --- include/generic_datatype.h | 10 +++++----- include/generic_sort.h | 1 + src/generic_datatype.cpp | 10 +++++----- src/generic_solver.cpp | 10 +++++----- src/generic_sort.cpp | 4 ++++ tests/test-dt.cpp | 26 ++++++++++++++++++++++++++ tests/test-generic-sort.cpp | 22 ++++++++++++++++++++++ 7 files changed, 68 insertions(+), 15 deletions(-) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index a8ef3060c..a8b8cf1ab 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -10,7 +10,7 @@ // using namespace smt; namespace smt { -struct selectorComponents +struct SelectorComponents { std::string name; Sort sort; @@ -36,14 +36,14 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl GenericDatatypeConstructorDecl(const std::string & name); virtual ~GenericDatatypeConstructorDecl(){}; void add_new_selector( - const std::shared_ptr & newSelector); - std::vector get_selector_vector(); + const SelectorComponents & newSelector); + std::vector get_selector_vector(); std::string get_name() const; int get_selector_count() const; bool compare(const DatatypeConstructorDecl & d) const override; protected: - std::vector selector_vector; + std::vector selector_vector; std::string cons_name; friend class GenericSolver; }; @@ -55,7 +55,7 @@ class GenericDatatype : public AbsDatatype virtual ~GenericDatatype(){}; void add_constructor(const DatatypeConstructorDecl & dt_cons_decl); void add_selector(const DatatypeConstructorDecl & dt_cons_decl, - const std::shared_ptr & newSelector); + const SelectorComponents & newSelector); std::vector get_cons_vector(); std::string get_name() const override; int get_num_constructors() const override; diff --git a/include/generic_sort.h b/include/generic_sort.h index 928fd4409..61a9a0f3d 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -203,6 +203,7 @@ class GenericDatatypeSort : public GenericSort Datatype get_datatype() const override; bool compare(const Sort & s) const override; std::string compute_string() const; + std::string to_string() const override; protected: std::string sort_name; diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 5df92df72..cf476ad79 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -26,19 +26,19 @@ GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( } void GenericDatatypeConstructorDecl::add_new_selector( - const shared_ptr & newSelector) + const SelectorComponents & newSelector) { // This seems like an opportunity for a new comparison function for // the struct. for (unsigned int i = 0; i < selector_vector.size(); ++i) { - if (selector_vector[i].name == (*newSelector).name) { + if (selector_vector[i].name == (newSelector).name) { throw "Can't add selector. It already exists in vector!"; } } - selector_vector.push_back(*newSelector); + selector_vector.push_back(newSelector); } -std::vector +std::vector GenericDatatypeConstructorDecl::get_selector_vector() { return selector_vector; @@ -77,7 +77,7 @@ void GenericDatatype::add_constructor( void GenericDatatype::add_selector( const DatatypeConstructorDecl & dt_cons_decl, - const std::shared_ptr & newSelector) + const SelectorComponents & newSelector) { for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 743830320..928ffcaa6 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -558,21 +558,21 @@ void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructor void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string & name, const Sort & s) const { - shared_ptr newSelector = - make_shared(); + shared_ptr newSelector = + make_shared(); (*newSelector).name = name; (*newSelector).sort = s; shared_ptr gdtc = static_pointer_cast(dt); - gdtc->add_new_selector(newSelector); + gdtc->add_new_selector(*newSelector); } void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const { // NOTE: This function is awaiting perfectly completed // functionality from make_sort - shared_ptr newSelector = - make_shared(); + shared_ptr newSelector = + make_shared(); //(*newSelector).name = name; //(*newSelector).sort = make_sort(DATATYPE); //(*dtconsdecl_selector_map)[dt].push_back(*newSelector); diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index f2c4955c7..070262ec9 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -368,4 +368,8 @@ bool GenericDatatypeSort::compare(const Sort & s) const return sort_name == other_sort->to_string(); } + std::string GenericDatatypeSort::to_string() const + { + return this->compute_string(); + } } // namespace smt diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 9ea784003..7bb957388 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -20,6 +20,7 @@ #include "available_solvers.h" #include "gtest/gtest.h" #include "smt.h" +#include "generic_datatype.h" using namespace smt; using namespace std; @@ -55,8 +56,21 @@ TEST_P(DTTests, DatatypeDecl) // Make datatype sort DatatypeDecl consListSpec = s->make_datatype_decl("list"); + auto dt_decltest = make_shared("secondtestdt"); + std::shared_ptr gdt = make_shared(dt_decltest); + assert(gdt->get_num_constructors() == 0); + + shared_ptr cons2test = shared_ptr(new GenericDatatypeConstructorDecl("constest")); + gdt->add_constructor(cons2test); + assert(gdt->get_num_constructors() == 1); + assert(gdt->get_num_selectors("constest") == 0); + assert(gdt->get_name() == "secondtestdt"); + + DatatypeConstructorDecl nildecl = s->make_datatype_constructor_decl("nil"); DatatypeConstructorDecl consdecl = s->make_datatype_constructor_decl("cons"); + DatatypeConstructorDecl cons_copy = consdecl; + ASSERT_EQ(cons_copy, consdecl); s->add_selector(consdecl, "head", s->make_sort(INT)); if (s->get_solver_enum() != GENERIC_SOLVER) { @@ -66,6 +80,18 @@ TEST_P(DTTests, DatatypeDecl) s->add_constructor(consListSpec, consdecl); Sort listsort = s->make_sort(consListSpec); + + DatatypeDecl counterdecl = s->make_datatype_decl("counter"); + DatatypeConstructorDecl countercons = s->make_datatype_constructor_decl("countercons"); + s->add_constructor(counterdecl,countercons); + Sort countersort = s->make_sort(counterdecl); + assert(countersort->get_sort_kind() == DATATYPE); + assert(listsort->get_sort_kind() == DATATYPE); + assert(countersort != listsort); + + + Datatype listdt = listsort->get_datatype(); + //shared_ptr gdt = static_pointer_cast(listdt); if (s->get_solver_enum() != GENERIC_SOLVER) { Term five = s->make_term(5, intsort); diff --git a/tests/test-generic-sort.cpp b/tests/test-generic-sort.cpp index a12a984b3..b0522299f 100644 --- a/tests/test-generic-sort.cpp +++ b/tests/test-generic-sort.cpp @@ -71,6 +71,28 @@ int main() assert(us1->get_uninterpreted_name() == "sort1"); assert(us1->get_arity() == 0); cout << "pre datatype" << endl; + DatatypeDecl new_dt_decl = make_shared("testSort1"); + shared_ptr new_dt = shared_ptr(new GenericDatatype(new_dt_decl)); + shared_ptr new_dt_cons_decl = shared_ptr(new GenericDatatypeConstructorDecl("Cons")); + new_dt->add_constructor(new_dt_cons_decl); + shared_ptr dt_sort = make_shared(new_dt); + + DatatypeDecl new2_dt_decl = make_shared("testSort2"); + shared_ptr new2_dt = shared_ptr(new GenericDatatype(new2_dt_decl)); + shared_ptr new2_dt_cons_decl = shared_ptr(new GenericDatatypeConstructorDecl("test2")); + new2_dt->add_constructor(new2_dt_cons_decl); + + shared_ptr dt_sort2 = make_shared(new2_dt); + assert(dt_sort != dt_sort2); + auto copy = dt_sort; + assert(dt_sort == copy); + cout << dt_sort->compute_string() << endl; + cout << dt_sort2->compute_string() << endl; + assert(dt_sort->to_string() != dt_sort2->to_string()); + assert((dt_sort->get_sort_kind()) == (dt_sort2->get_sort_kind())); + assert(dt_sort->get_sort_kind() == DATATYPE); + assert(dt_sort2->get_sort_kind() == DATATYPE); + /* GenericSort d1(DATATYPE); GenericSort d2(DATATYPE); From be07ff92f6dbc08ce6df0a6e1a87ca8487eabafb Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 9 Jul 2021 11:43:16 -0700 Subject: [PATCH 16/47] MAde additional tweaks, fleshed out testing. --- cvc4/include/cvc4_datatype.h | 1 + include/datatype.h | 6 ++-- include/generic_datatype.h | 9 ++---- include/generic_solver.h | 8 ++++-- include/generic_sort.h | 9 +++--- src/generic_datatype.cpp | 56 ++++++++++++++++++++---------------- src/generic_solver.cpp | 35 +++++++++++++++------- src/generic_sort.cpp | 37 ++++++++++++------------ src/solver_enums.cpp | 3 +- tests/test-dt.cpp | 23 ++++++++------- tests/test-generic-sort.cpp | 24 ++++++++++------ 11 files changed, 125 insertions(+), 86 deletions(-) diff --git a/cvc4/include/cvc4_datatype.h b/cvc4/include/cvc4_datatype.h index 9dce63c70..15db89b5e 100644 --- a/cvc4/include/cvc4_datatype.h +++ b/cvc4/include/cvc4_datatype.h @@ -35,6 +35,7 @@ namespace smt { public : CVC4DatatypeConstructorDecl(CVC4::api::DatatypeConstructorDecl t) : datatypeconstructordecl(t) {}; bool compare(const DatatypeConstructorDecl &) const override; + protected: CVC4::api::DatatypeConstructorDecl datatypeconstructordecl; diff --git a/include/datatype.h b/include/datatype.h index 162e16f45..325d97481 100644 --- a/include/datatype.h +++ b/include/datatype.h @@ -47,10 +47,10 @@ class AbsDatatype { virtual std::string get_name() const=0; virtual int get_num_selectors(std::string cons) const=0; virtual int get_num_constructors() const=0; - //virtual bool compare(const Datatype & d) const = 0; + // virtual bool compare(const Datatype & d) const = 0; }; -//bool operator==(const Datatype & d1, const Datatype & d2); -//bool operator!=(const Datatype & d1, const Datatype & d2); +// bool operator==(const Datatype & d1, const Datatype & d2); +// bool operator!=(const Datatype & d1, const Datatype & d2); bool operator==(const DatatypeConstructorDecl & d1, const DatatypeConstructorDecl & d2); diff --git a/include/generic_datatype.h b/include/generic_datatype.h index a8b8cf1ab..af6a9bdb1 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -4,8 +4,8 @@ #include "datatype.h" #include "exceptions.h" -#include "sort.h" #include "smt_defs.h" +#include "sort.h" // using namespace smt; namespace smt { @@ -16,8 +16,6 @@ struct SelectorComponents Sort sort; }; - - class GenericDatatypeDecl : public AbsDatatypeDecl { public: @@ -35,8 +33,7 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl public: GenericDatatypeConstructorDecl(const std::string & name); virtual ~GenericDatatypeConstructorDecl(){}; - void add_new_selector( - const SelectorComponents & newSelector); + void add_new_selector(const SelectorComponents & newSelector); std::vector get_selector_vector(); std::string get_name() const; int get_selector_count() const; @@ -60,7 +57,7 @@ class GenericDatatype : public AbsDatatype std::string get_name() const override; int get_num_constructors() const override; int get_num_selectors(std::string cons) const override; - //bool compare(const Datatype & d) const override; + // bool compare(const Datatype & d) const override; std::hash str_hash; protected: diff --git a/include/generic_solver.h b/include/generic_solver.h index ea1c30377..08f49b108 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -253,8 +253,12 @@ class GenericSolver : public AbsSmtSolver std::unique_ptr> term_name_map; // Map between names and Generic datatypes and vice versa - std::unique_ptr>> name_datatype_map; - std::unique_ptr, std::string>> datatype_name_map; + std::unique_ptr< + std::unordered_map>> + name_datatype_map; + std::unique_ptr< + std::unordered_map, std::string>> + datatype_name_map; }; } // namespace smt diff --git a/include/generic_sort.h b/include/generic_sort.h index 61a9a0f3d..beb7b7a14 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -16,15 +16,16 @@ #pragma once +#include + #include "exceptions.h" +#include "generic_datatype.h" #include "smt_defs.h" #include "sort.h" -#include "generic_datatype.h" -#include namespace smt { - class GenericDatatye; +class GenericDatatye; /* Helper functions for creating generic sorts */ Sort make_uninterpreted_generic_sort(std::string name, uint64_t arity); Sort make_uninterpreted_generic_sort(Sort sort_cons, const SortVec& sorts); @@ -207,7 +208,7 @@ class GenericDatatypeSort : public GenericSort protected: std::string sort_name; - Datatype gdt; + Datatype gdt; }; } // namespace smt diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index cf476ad79..fe9ada375 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -1,24 +1,22 @@ #include "generic_datatype.h" +#include +#include #include #include -#include + #include "assert.h" -#include using namespace std; namespace smt { -GenericDatatypeDecl::GenericDatatypeDecl(const std::string name) :dt_name(name) +GenericDatatypeDecl::GenericDatatypeDecl(const std::string name) : dt_name(name) { } -std::string GenericDatatypeDecl::get_name() -{ - return dt_name; -} - +std::string GenericDatatypeDecl::get_name() { return dt_name; } + GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( const std::string & name) : cons_name(name) @@ -30,8 +28,10 @@ void GenericDatatypeConstructorDecl::add_new_selector( { // This seems like an opportunity for a new comparison function for // the struct. - for (unsigned int i = 0; i < selector_vector.size(); ++i) { - if (selector_vector[i].name == (newSelector).name) { + for (unsigned int i = 0; i < selector_vector.size(); ++i) + { + if (selector_vector[i].name == (newSelector).name) + { throw "Can't add selector. It already exists in vector!"; } } @@ -58,7 +58,8 @@ bool GenericDatatypeConstructorDecl::compare( { // Why won't type casting like this work? // GenericDatatypeConstructorDecl gdtc = (GenericDatatypeConstructorDecl) d; - return cons_name == static_pointer_cast(d)->get_name(); + return cons_name + == static_pointer_cast(d)->get_name(); } GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration) @@ -69,21 +70,23 @@ GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration) void GenericDatatype::add_constructor( const DatatypeConstructorDecl & dt_cons_decl) { - if (std::find(cons_decl_vector.begin(), cons_decl_vector.end(), dt_cons_decl) != cons_decl_vector.end()) { + if (std::find(cons_decl_vector.begin(), cons_decl_vector.end(), dt_cons_decl) + != cons_decl_vector.end()) + { throw "Can't add constructor. It already has been added!"; } cons_decl_vector.push_back(dt_cons_decl); } -void GenericDatatype::add_selector( - const DatatypeConstructorDecl & dt_cons_decl, - const SelectorComponents & newSelector) +void GenericDatatype::add_selector(const DatatypeConstructorDecl & dt_cons_decl, + const SelectorComponents & newSelector) { for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { if (cons_decl_vector[i] == dt_cons_decl) { - static_pointer_cast(cons_decl_vector[i])->add_new_selector(newSelector); + static_pointer_cast(cons_decl_vector[i]) + ->add_new_selector(newSelector); } } } @@ -92,8 +95,9 @@ std::vector GenericDatatype::get_cons_vector() return cons_decl_vector; } - std::string GenericDatatype::get_name() const { - return static_pointer_cast(dt_decl)->get_name(); +std::string GenericDatatype::get_name() const +{ + return static_pointer_cast(dt_decl)->get_name(); } int GenericDatatype::get_num_constructors() const @@ -106,19 +110,23 @@ int GenericDatatype::get_num_selectors(std::string cons) const int num_selectors = 0; for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { - if (static_pointer_cast(cons_decl_vector[i])->get_name() == cons) + if (static_pointer_cast(cons_decl_vector[i]) + ->get_name() + == cons) { - num_selectors = static_pointer_cast(cons_decl_vector[i])->get_selector_count(); + num_selectors = static_pointer_cast( + cons_decl_vector[i]) + ->get_selector_count(); } } return num_selectors; } - // Still deciding if I should implement a datatype comparison function - /* +// Still deciding if I should implement a datatype comparison function +/* bool GenericDatatype::compare(const Datatype & d) const { - return name == d->get_name(); +return name == d->get_name(); } - */ +*/ } // namespace smt diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 928ffcaa6..764423547 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -481,7 +481,8 @@ Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const Sort GenericSolver::make_sort(const DatatypeDecl & d) const { - shared_ptr gdt_decl = static_pointer_cast(d); + shared_ptr gdt_decl = + static_pointer_cast(d); string dt_decl_name = gdt_decl->get_name(); assert(name_datatype_map->find(dt_decl_name) != name_datatype_map->end()); shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; @@ -494,18 +495,31 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // build string for each constructor for (unsigned long i = 0; i < curr_dt->get_cons_vector().size(); ++i) { - DatatypeConstructorDecl curr_dt_cons_decl = - curr_dt->get_cons_vector()[i]; - to_solver += " (" + static_pointer_cast(curr_dt_cons_decl)->get_name(); + DatatypeConstructorDecl curr_dt_cons_decl = curr_dt->get_cons_vector()[i]; + to_solver += " (" + + static_pointer_cast( + curr_dt_cons_decl) + ->get_name(); // adjust string for each selector for (unsigned long f = 0; - f < static_pointer_cast(curr_dt_cons_decl)->get_selector_vector().size(); + f < static_pointer_cast( + curr_dt_cons_decl) + ->get_selector_vector() + .size(); ++f) { - to_solver += " ( " + static_pointer_cast(curr_dt_cons_decl)->get_selector_vector()[f].name; - to_solver += - " " + (static_pointer_cast(curr_dt_cons_decl)->get_selector_vector()[f].sort)->to_string() - + " )"; + to_solver += " ( " + + static_pointer_cast( + curr_dt_cons_decl) + ->get_selector_vector()[f] + .name; + to_solver += " " + + (static_pointer_cast( + curr_dt_cons_decl) + ->get_selector_vector()[f] + .sort) + ->to_string() + + " )"; } to_solver += ")"; @@ -550,7 +564,8 @@ DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( void GenericSolver::add_constructor(DatatypeDecl & dt, const DatatypeConstructorDecl & con) const { - shared_ptr gdt_decl = static_pointer_cast(dt); + shared_ptr gdt_decl = + static_pointer_cast(dt); string name = gdt_decl->get_name(); auto gdt = (*name_datatype_map)[name]; gdt->add_constructor(con); diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 070262ec9..225828d9e 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -14,10 +14,12 @@ **/ #include "generic_sort.h" -#include -#include "generic_datatype.h" + #include +#include + #include "assert.h" +#include "generic_datatype.h" #include "utils.h" using namespace std; @@ -129,7 +131,7 @@ Sort make_generic_sort(Datatype & dt) GenericSort::GenericSort(SortKind sk) : sk(sk) {} - GenericSort::GenericSort(SortKind sk, std::string name_var) : sk(sk) {} +GenericSort::GenericSort(SortKind sk, std::string name_var) : sk(sk) {} GenericSort::~GenericSort() {} @@ -194,11 +196,8 @@ string GenericSort::compute_string() const { SortKind GenericSort::get_sort_kind() const { return sk; } - std::string GenericSort::get_base_name() const - { - return base_name; - } - +std::string GenericSort::get_base_name() const { return base_name; } + bool GenericSort::compare(const Sort & s) const { SortKind other_sk = s->get_sort_kind(); @@ -250,7 +249,8 @@ bool GenericSort::compare(const Sort & s) const case DATATYPE: { assert(sk == DATATYPE); - shared_ptr other_type_cast = static_pointer_cast(s); + shared_ptr other_type_cast = + static_pointer_cast(s); return base_name == other_type_cast->compute_string(); } case NUM_SORT_KINDS: @@ -347,7 +347,9 @@ SortVec UninterpretedGenericSort::get_uninterpreted_param_sorts() const } GenericDatatypeSort::GenericDatatypeSort(const Datatype & dt) - : GenericSort(DATATYPE), gdt(dt), sort_name(static_pointer_cast(dt)->get_name()) + : GenericSort(DATATYPE), + gdt(dt), + sort_name(static_pointer_cast(dt)->get_name()) { } @@ -357,19 +359,18 @@ std::string GenericDatatypeSort::get_sort_name() { return sort_name; } Datatype GenericDatatypeSort::get_datatype() const { return gdt; } -string GenericDatatypeSort::compute_string() const { - return sort_name; -} +string GenericDatatypeSort::compute_string() const { return sort_name; } bool GenericDatatypeSort::compare(const Sort & s) const { assert(s->get_sort_kind() == DATATYPE); - shared_ptr other_sort = static_pointer_cast(s); + shared_ptr other_sort = + static_pointer_cast(s); return sort_name == other_sort->to_string(); } - std::string GenericDatatypeSort::to_string() const - { - return this->compute_string(); - } +std::string GenericDatatypeSort::to_string() const +{ + return this->compute_string(); +} } // namespace smt diff --git a/src/solver_enums.cpp b/src/solver_enums.cpp index 60a9953e0..85128fa84 100644 --- a/src/solver_enums.cpp +++ b/src/solver_enums.cpp @@ -41,7 +41,8 @@ const unordered_map> UNSAT_CORE, // TEMP only temporarily disabled until bitwuzla // quantifier refactoring is done - // see https://github.com/bitwuzla/bitwuzla/commit/605f31557ec6c635e3c617d2b0ab257309e994c4 + // see + // https://github.com/bitwuzla/bitwuzla/commit/605f31557ec6c635e3c617d2b0ab257309e994c4 // QUANTIFIERS, BOOL_BV1_ALIASING } }, diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 7bb957388..5c46ffe1e 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -18,9 +18,9 @@ #include #include "available_solvers.h" +#include "generic_datatype.h" #include "gtest/gtest.h" #include "smt.h" -#include "generic_datatype.h" using namespace smt; using namespace std; @@ -57,15 +57,17 @@ TEST_P(DTTests, DatatypeDecl) DatatypeDecl consListSpec = s->make_datatype_decl("list"); auto dt_decltest = make_shared("secondtestdt"); - std::shared_ptr gdt = make_shared(dt_decltest); + std::shared_ptr gdt = + make_shared(dt_decltest); assert(gdt->get_num_constructors() == 0); - - shared_ptr cons2test = shared_ptr(new GenericDatatypeConstructorDecl("constest")); + + shared_ptr cons2test = + shared_ptr( + new GenericDatatypeConstructorDecl("constest")); gdt->add_constructor(cons2test); assert(gdt->get_num_constructors() == 1); assert(gdt->get_num_selectors("constest") == 0); assert(gdt->get_name() == "secondtestdt"); - DatatypeConstructorDecl nildecl = s->make_datatype_constructor_decl("nil"); DatatypeConstructorDecl consdecl = s->make_datatype_constructor_decl("cons"); @@ -82,16 +84,17 @@ TEST_P(DTTests, DatatypeDecl) Sort listsort = s->make_sort(consListSpec); DatatypeDecl counterdecl = s->make_datatype_decl("counter"); - DatatypeConstructorDecl countercons = s->make_datatype_constructor_decl("countercons"); - s->add_constructor(counterdecl,countercons); + DatatypeConstructorDecl countercons = + s->make_datatype_constructor_decl("countercons"); + s->add_constructor(counterdecl, countercons); Sort countersort = s->make_sort(counterdecl); assert(countersort->get_sort_kind() == DATATYPE); assert(listsort->get_sort_kind() == DATATYPE); assert(countersort != listsort); - - + Datatype listdt = listsort->get_datatype(); - //shared_ptr gdt = static_pointer_cast(listdt); + // shared_ptr gdt = + // static_pointer_cast(listdt); if (s->get_solver_enum() != GENERIC_SOLVER) { Term five = s->make_term(5, intsort); diff --git a/tests/test-generic-sort.cpp b/tests/test-generic-sort.cpp index b0522299f..4c84106b1 100644 --- a/tests/test-generic-sort.cpp +++ b/tests/test-generic-sort.cpp @@ -72,17 +72,25 @@ int main() assert(us1->get_arity() == 0); cout << "pre datatype" << endl; DatatypeDecl new_dt_decl = make_shared("testSort1"); - shared_ptr new_dt = shared_ptr(new GenericDatatype(new_dt_decl)); - shared_ptr new_dt_cons_decl = shared_ptr(new GenericDatatypeConstructorDecl("Cons")); + shared_ptr new_dt = + shared_ptr(new GenericDatatype(new_dt_decl)); + shared_ptr new_dt_cons_decl = + shared_ptr( + new GenericDatatypeConstructorDecl("Cons")); new_dt->add_constructor(new_dt_cons_decl); - shared_ptr dt_sort = make_shared(new_dt); - + shared_ptr dt_sort = + make_shared(new_dt); + DatatypeDecl new2_dt_decl = make_shared("testSort2"); - shared_ptr new2_dt = shared_ptr(new GenericDatatype(new2_dt_decl)); - shared_ptr new2_dt_cons_decl = shared_ptr(new GenericDatatypeConstructorDecl("test2")); + shared_ptr new2_dt = + shared_ptr(new GenericDatatype(new2_dt_decl)); + shared_ptr new2_dt_cons_decl = + shared_ptr( + new GenericDatatypeConstructorDecl("test2")); new2_dt->add_constructor(new2_dt_cons_decl); - shared_ptr dt_sort2 = make_shared(new2_dt); + shared_ptr dt_sort2 = + make_shared(new2_dt); assert(dt_sort != dt_sort2); auto copy = dt_sort; assert(dt_sort == copy); @@ -92,7 +100,7 @@ int main() assert((dt_sort->get_sort_kind()) == (dt_sort2->get_sort_kind())); assert(dt_sort->get_sort_kind() == DATATYPE); assert(dt_sort2->get_sort_kind() == DATATYPE); - + /* GenericSort d1(DATATYPE); GenericSort d2(DATATYPE); From 8b138d99b260f9c3d3a97401796712c08b62af72 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 9 Jul 2021 21:00:42 -0700 Subject: [PATCH 17/47] Reworked add_selector_self to work with the new file framework. Added additional tests. One weird compilation bug that I still have not figured out. --- include/generic_datatype.h | 3 +++ src/generic_datatype.cpp | 16 +++++++++++++++- src/generic_solver.cpp | 13 ++++++++----- tests/test-dt.cpp | 39 ++++++++++++++++++++++++-------------- 4 files changed, 51 insertions(+), 20 deletions(-) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index af6a9bdb1..52d1bae65 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -38,10 +38,13 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl std::string get_name() const; int get_selector_count() const; bool compare(const DatatypeConstructorDecl & d) const override; + std::string get_dt_name() const; + void change_dt_name(const std::string new_name); protected: std::vector selector_vector; std::string cons_name; + std::string dt_name; friend class GenericSolver; }; diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index fe9ada375..aa3fe530e 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -19,7 +19,9 @@ std::string GenericDatatypeDecl::get_name() { return dt_name; } GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( const std::string & name) - : cons_name(name) + : cons_name(name), + // Should I turn this into a constant? + dt_name("NOT IMPLEMENTED YET") { } @@ -62,6 +64,16 @@ bool GenericDatatypeConstructorDecl::compare( == static_pointer_cast(d)->get_name(); } + std::string GenericDatatypeConstructorDecl::get_dt_name() const + { + return dt_name; + } + + void GenericDatatypeConstructorDecl::change_dt_name(const std::string new_name) + { + dt_name = new_name; + } + GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration) : dt_decl(dt_declaration) { @@ -75,6 +87,8 @@ void GenericDatatype::add_constructor( { throw "Can't add constructor. It already has been added!"; } + shared_ptr gdt_cons = static_pointer_cast(dt_cons_decl); + gdt_cons->change_dt_name(get_name()); cons_decl_vector.push_back(dt_cons_decl); } diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 764423547..67cb79c7c 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -532,8 +532,6 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const Sort dt_sort = make_shared(curr_dt); (*name_sort_map)[dt_decl_name] = dt_sort; (*sort_name_map)[dt_sort] = dt_decl_name; - cout << "SOlver texr" << endl; - cout << to_solver << endl; run_command(to_solver); return dt_sort; } @@ -588,9 +586,14 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s // functionality from make_sort shared_ptr newSelector = make_shared(); - //(*newSelector).name = name; - //(*newSelector).sort = make_sort(DATATYPE); - //(*dtconsdecl_selector_map)[dt].push_back(*newSelector); + shared_ptr gdt_cons = static_pointer_cast(dt); + string dt_decl_name = gdt_cons->get_dt_name(); + + (*newSelector).name = name; + (*newSelector).sort = (*name_sort_map)[dt_decl_name]; + assert(name_datatype_map->find(dt_decl_name) != name_datatype_map->end()); + shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; + gdt_cons->add_new_selector(*newSelector); } Term GenericSolver::get_constructor(const Sort & s, std::string name) const diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 5c46ffe1e..60e65ac89 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -57,10 +57,12 @@ TEST_P(DTTests, DatatypeDecl) DatatypeDecl consListSpec = s->make_datatype_decl("list"); auto dt_decltest = make_shared("secondtestdt"); + std::shared_ptr gdt = make_shared(dt_decltest); assert(gdt->get_num_constructors() == 0); - + + shared_ptr cons2test = shared_ptr( new GenericDatatypeConstructorDecl("constest")); @@ -68,49 +70,56 @@ TEST_P(DTTests, DatatypeDecl) assert(gdt->get_num_constructors() == 1); assert(gdt->get_num_selectors("constest") == 0); assert(gdt->get_name() == "secondtestdt"); + DatatypeConstructorDecl nildecl = s->make_datatype_constructor_decl("nil"); DatatypeConstructorDecl consdecl = s->make_datatype_constructor_decl("cons"); + + shared_ptr consdeclgen = static_pointer_cast(consdecl); DatatypeConstructorDecl cons_copy = consdecl; ASSERT_EQ(cons_copy, consdecl); + s->add_selector(consdecl, "head", s->make_sort(INT)); - if (s->get_solver_enum() != GENERIC_SOLVER) - { - s->add_selector_self(consdecl, "tail"); - } + //if (s->get_solver_enum() != GENERIC_SOLVER) + // { + //s->add_selector_self(consdecl, "tail"); + //} s->add_constructor(consListSpec, nildecl); - s->add_constructor(consListSpec, consdecl); Sort listsort = s->make_sort(consListSpec); - + DatatypeDecl counterdecl = s->make_datatype_decl("counter"); DatatypeConstructorDecl countercons = s->make_datatype_constructor_decl("countercons"); s->add_constructor(counterdecl, countercons); Sort countersort = s->make_sort(counterdecl); + + + s->add_selector_self(consdecl, "tail"); + assert(countersort->get_sort_kind() == DATATYPE); assert(listsort->get_sort_kind() == DATATYPE); assert(countersort != listsort); - + Datatype listdt = listsort->get_datatype(); - // shared_ptr gdt = - // static_pointer_cast(listdt); if (s->get_solver_enum() != GENERIC_SOLVER) { + Term five = s->make_term(5, intsort); - Datatype listdt = listsort->get_datatype(); + //Datatype listdt = listsort->get_datatype(); // Make datatype terms Term cons = s->get_constructor(listsort, "cons"); Term nil = s->get_constructor(listsort, "nil"); Term head = s->get_selector(listsort, "cons", "head"); + /* Term tail = s->get_selector(listsort, "cons", "tail"); + Term isNil = s->get_tester(listsort, "nil"); - // Datatype ops Term nilterm = s->make_term(Apply_Constructor, nil); Term list5 = s->make_term(Apply_Constructor, cons, five, nilterm); Term five_again = s->make_term(Apply_Selector, head, list5); - + // Expected booleans s->assert_formula(s->make_term(Equal, five, five_again)); s->assert_formula(s->make_term(Apply_Tester, isNil, nilterm)); @@ -132,7 +141,9 @@ TEST_P(DTTests, DatatypeDecl) EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); EXPECT_THROW(s->get_selector(listsort, "nil", "head"), InternalSolverException); - EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); + EXPECT_THROW(listdt->get_num_selectors("kons"), + InternalSolverException); + */ } } From 23741f5be98163a2ada190680cd15a1efb9735e6 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Tue, 13 Jul 2021 01:50:46 -0700 Subject: [PATCH 18/47] Another round of responses to requested changes. --- include/datatype.h | 3 --- include/generic_datatype.h | 4 ++-- include/generic_sort.h | 1 - src/generic_datatype.cpp | 21 ++++++++------------- src/generic_solver.cpp | 3 +-- src/generic_sort.cpp | 13 ++++++------- tests/test-dt.cpp | 20 +++++++------------- tests/test-generic-sort.cpp | 16 ---------------- 8 files changed, 24 insertions(+), 57 deletions(-) diff --git a/include/datatype.h b/include/datatype.h index 325d97481..cebe74cec 100644 --- a/include/datatype.h +++ b/include/datatype.h @@ -47,10 +47,7 @@ class AbsDatatype { virtual std::string get_name() const=0; virtual int get_num_selectors(std::string cons) const=0; virtual int get_num_constructors() const=0; - // virtual bool compare(const Datatype & d) const = 0; }; -// bool operator==(const Datatype & d1, const Datatype & d2); -// bool operator!=(const Datatype & d1, const Datatype & d2); bool operator==(const DatatypeConstructorDecl & d1, const DatatypeConstructorDecl & d2); diff --git a/include/generic_datatype.h b/include/generic_datatype.h index 52d1bae65..8a192308f 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -39,12 +39,12 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl int get_selector_count() const; bool compare(const DatatypeConstructorDecl & d) const override; std::string get_dt_name() const; - void change_dt_name(const std::string new_name); + void update_stored_dt(const DatatypeDecl & datatype_decl); protected: std::vector selector_vector; std::string cons_name; - std::string dt_name; + DatatypeDecl dt_decl; friend class GenericSolver; }; diff --git a/include/generic_sort.h b/include/generic_sort.h index beb7b7a14..461708fc4 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -207,7 +207,6 @@ class GenericDatatypeSort : public GenericSort std::string to_string() const override; protected: - std::string sort_name; Datatype gdt; }; diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index aa3fe530e..221f02343 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -19,22 +19,18 @@ std::string GenericDatatypeDecl::get_name() { return dt_name; } GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( const std::string & name) - : cons_name(name), - // Should I turn this into a constant? - dt_name("NOT IMPLEMENTED YET") + : cons_name(name) { } void GenericDatatypeConstructorDecl::add_new_selector( const SelectorComponents & newSelector) { - // This seems like an opportunity for a new comparison function for - // the struct. for (unsigned int i = 0; i < selector_vector.size(); ++i) { if (selector_vector[i].name == (newSelector).name) { - throw "Can't add selector. It already exists in vector!"; + throw "Can't add selector. It already exists in this datatype!"; } } selector_vector.push_back(newSelector); @@ -58,22 +54,21 @@ int GenericDatatypeConstructorDecl::get_selector_count() const bool GenericDatatypeConstructorDecl::compare( const DatatypeConstructorDecl & d) const { - // Why won't type casting like this work? - // GenericDatatypeConstructorDecl gdtc = (GenericDatatypeConstructorDecl) d; return cons_name == static_pointer_cast(d)->get_name(); } std::string GenericDatatypeConstructorDecl::get_dt_name() const { - return dt_name; + return static_pointer_cast(dt_decl)->get_name(); } - void GenericDatatypeConstructorDecl::change_dt_name(const std::string new_name) + void GenericDatatypeConstructorDecl::update_stored_dt(const DatatypeDecl & datatype_decl) { - dt_name = new_name; + dt_decl = datatype_decl; + } - + GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration) : dt_decl(dt_declaration) { @@ -88,7 +83,7 @@ void GenericDatatype::add_constructor( throw "Can't add constructor. It already has been added!"; } shared_ptr gdt_cons = static_pointer_cast(dt_cons_decl); - gdt_cons->change_dt_name(get_name()); + gdt_cons->update_stored_dt(dt_decl); cons_decl_vector.push_back(dt_cons_decl); } diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 67cb79c7c..61f818300 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -582,8 +582,6 @@ void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const { - // NOTE: This function is awaiting perfectly completed - // functionality from make_sort shared_ptr newSelector = make_shared(); shared_ptr gdt_cons = static_pointer_cast(dt); @@ -610,6 +608,7 @@ Term GenericSolver::get_tester(const Sort & s, std::string name) const Term GenericSolver::get_selector(const Sort & s, std::string con, std::string name) const { throw NotImplementedException("Generic Solvers do not support datatypes"); + } std::string GenericSolver::get_name(Term term) const diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 225828d9e..572ebda9f 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -38,7 +38,6 @@ Sort make_uninterpreted_generic_sort(Sort sort_cons, Sort make_generic_sort(SortKind sk) { - // Tweaked to accept datatypes temporarily if (sk != BOOL && sk != INT && sk != REAL) { throw IncorrectUsageException("Can't create sort from " + to_string(sk)); @@ -188,7 +187,6 @@ string GenericSort::compute_string() const { } else { - cout << "right before the assert false" << endl; assert(false); } } @@ -348,25 +346,26 @@ SortVec UninterpretedGenericSort::get_uninterpreted_param_sorts() const GenericDatatypeSort::GenericDatatypeSort(const Datatype & dt) : GenericSort(DATATYPE), - gdt(dt), - sort_name(static_pointer_cast(dt)->get_name()) + gdt(dt) + //GenericSort::base_name((static_pointer_cast(dt))->get_name()) { + GenericSort::base_name = (static_pointer_cast(dt))->get_name(); } GenericDatatypeSort::~GenericDatatypeSort() {} -std::string GenericDatatypeSort::get_sort_name() { return sort_name; } + std::string GenericDatatypeSort::get_sort_name() { return GenericSort::base_name; } Datatype GenericDatatypeSort::get_datatype() const { return gdt; } -string GenericDatatypeSort::compute_string() const { return sort_name; } + string GenericDatatypeSort::compute_string() const { return GenericSort::base_name; } bool GenericDatatypeSort::compare(const Sort & s) const { assert(s->get_sort_kind() == DATATYPE); shared_ptr other_sort = static_pointer_cast(s); - return sort_name == other_sort->to_string(); + return compute_string() == other_sort->to_string(); } std::string GenericDatatypeSort::to_string() const diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 60e65ac89..0a4339b47 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -47,11 +47,6 @@ TEST_P(DTTests, DatatypeDecl) if (sc.is_logging_solver) { return; } - /* Original location of five declaration - if (s->get_solver_enum() != GENERIC_SOLVER) { - Term five = s->make_term(5, intsort); - } - */ // Make datatype sort DatatypeDecl consListSpec = s->make_datatype_decl("list"); @@ -80,10 +75,6 @@ TEST_P(DTTests, DatatypeDecl) ASSERT_EQ(cons_copy, consdecl); s->add_selector(consdecl, "head", s->make_sort(INT)); - //if (s->get_solver_enum() != GENERIC_SOLVER) - // { - //s->add_selector_self(consdecl, "tail"); - //} s->add_constructor(consListSpec, nildecl); s->add_constructor(consListSpec, consdecl); Sort listsort = s->make_sort(consListSpec); @@ -102,15 +93,18 @@ TEST_P(DTTests, DatatypeDecl) assert(countersort != listsort); Datatype listdt = listsort->get_datatype(); - if (s->get_solver_enum() != GENERIC_SOLVER) - { - Term five = s->make_term(5, intsort); //Datatype listdt = listsort->get_datatype(); // Make datatype terms - Term cons = s->get_constructor(listsort, "cons"); + /* Term cons = s->get_constructor(listsort, "cons"); + assert("cons" == cons->to_string()); Term nil = s->get_constructor(listsort, "nil"); + */ + if (s->get_solver_enum() != GENERIC_SOLVER) + { Term head = s->get_selector(listsort, "cons", "head"); + // This part must be commented out for the code to compile and + // pass the tests. /* Term tail = s->get_selector(listsort, "cons", "tail"); diff --git a/tests/test-generic-sort.cpp b/tests/test-generic-sort.cpp index 4c84106b1..d06739fc4 100644 --- a/tests/test-generic-sort.cpp +++ b/tests/test-generic-sort.cpp @@ -101,21 +101,5 @@ int main() assert(dt_sort->get_sort_kind() == DATATYPE); assert(dt_sort2->get_sort_kind() == DATATYPE); - /* - GenericSort d1(DATATYPE); - GenericSort d2(DATATYPE); - std::cout << "testing basic properties of datatype sorts" << std::endl; - assert(d1.hash() == d2.hash()); - assert(d1.to_string() == d2.to_string()); - cout << d1.to_string() << endl; - assert(d2.to_string() == d1.to_string()); - assert((d1.get_sort_kind()) == (d2.get_sort_kind())); - assert(d1.get_sort_kind() == DATATYPE); - cout << "almost there" << endl; - Sort dt1 = make_generic_sort(DATATYPE); - Sort dt2 = make_generic_sort(DATATYPE); - assert(dt1 == dt2); - */ - return 0; } From a7092b01b2502aad8084185b7df02d74247d412a Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Tue, 13 Jul 2021 20:28:33 -0700 Subject: [PATCH 19/47] Properly functional add_selector_self as well as style fixes. --- include/generic_datatype.h | 3 ++- include/generic_sort.h | 2 ++ include/sort.h | 1 + src/generic_datatype.cpp | 20 +++++++++++++------- src/generic_solver.cpp | 12 ++++++++---- src/generic_sort.cpp | 7 +++++-- tests/test-dt.cpp | 23 ++++++++++------------- 7 files changed, 41 insertions(+), 27 deletions(-) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index 8a192308f..c78dd6961 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -46,6 +46,7 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl std::string cons_name; DatatypeDecl dt_decl; friend class GenericSolver; + friend class GenericDatatype; }; class GenericDatatype : public AbsDatatype @@ -60,7 +61,7 @@ class GenericDatatype : public AbsDatatype std::string get_name() const override; int get_num_constructors() const override; int get_num_selectors(std::string cons) const override; - // bool compare(const Datatype & d) const override; + void change_sort_of_selector(const Sort new_sort); std::hash str_hash; protected: diff --git a/include/generic_sort.h b/include/generic_sort.h index 461708fc4..5cd607a7a 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -48,6 +48,8 @@ class GenericSort : public AbsSort GenericSort(SortKind sk); // This second constructor is only for datatype sorts GenericSort(SortKind sk, std::string name_var); + // ONly for placeholder sorts + GenericSort(std::string name); virtual ~GenericSort(); SortKind get_sort_kind() const override; bool compare(const Sort & s) const override; diff --git a/include/sort.h b/include/sort.h index 5dc3885b9..88d586efe 100644 --- a/include/sort.h +++ b/include/sort.h @@ -44,6 +44,7 @@ enum SortKind // arguments) UNINTERPRETED_CONS, DATATYPE, + PLACEHOLDER, /** IMPORTANT: This must stay at the bottom. It's only use is for sizing the kind2str array diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 221f02343..c575df6a7 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -130,12 +130,18 @@ int GenericDatatype::get_num_selectors(std::string cons) const } return num_selectors; } -// Still deciding if I should implement a datatype comparison function -/* -bool GenericDatatype::compare(const Datatype & d) const -{ -return name == d->get_name(); -} -*/ + void GenericDatatype::change_sort_of_selector(const Sort new_sort) + { + for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { + std::shared_ptr cons_cast = static_pointer_cast(cons_decl_vector[i]); + for (unsigned int f = 0; f < get_num_selectors(cons_cast->get_name()); ++f) { + if (cons_cast->selector_vector[f].sort->get_sort_kind() == PLACEHOLDER) { + cons_cast->selector_vector[f].sort = new_sort; + } + } + + } + } + } // namespace smt diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 61f818300..0ef982f27 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -488,6 +488,9 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; if (name_sort_map->find(dt_decl_name) == name_sort_map->end()) { + Sort dt_sort = make_shared(curr_dt); + curr_dt->change_sort_of_selector(dt_sort); + std::string to_solver = "(" + DECLARE_DATATYPE_STR + " (("; to_solver += dt_decl_name; to_solver += " 0)) (\n"; @@ -529,10 +532,11 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // errors (undefined reference when I call the new // make_generic_sort). assert(name_sort_map->find(dt_decl_name) == name_sort_map->end()); - Sort dt_sort = make_shared(curr_dt); (*name_sort_map)[dt_decl_name] = dt_sort; (*sort_name_map)[dt_sort] = dt_decl_name; + cout << to_solver << endl; run_command(to_solver); + return dt_sort; } else @@ -587,9 +591,9 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s shared_ptr gdt_cons = static_pointer_cast(dt); string dt_decl_name = gdt_cons->get_dt_name(); - (*newSelector).name = name; - (*newSelector).sort = (*name_sort_map)[dt_decl_name]; - assert(name_datatype_map->find(dt_decl_name) != name_datatype_map->end()); + newSelector->name = name; + newSelector->sort = make_shared(name); + //assert(name_datatype_map->find(dt_decl_name) != name_datatype_map->end()); shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; gdt_cons->add_new_selector(*newSelector); } diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 572ebda9f..1c9df8760 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -38,7 +38,7 @@ Sort make_uninterpreted_generic_sort(Sort sort_cons, Sort make_generic_sort(SortKind sk) { - if (sk != BOOL && sk != INT && sk != REAL) + if (sk != BOOL && sk != INT && sk != REAL && sk != PLACEHOLDER) { throw IncorrectUsageException("Can't create sort from " + to_string(sk)); } @@ -132,6 +132,9 @@ GenericSort::GenericSort(SortKind sk) : sk(sk) {} GenericSort::GenericSort(SortKind sk, std::string name_var) : sk(sk) {} + // Only used to make placeholders +GenericSort::GenericSort(std::string name) : sk(PLACEHOLDER), base_name(name) {} + GenericSort::~GenericSort() {} size_t GenericSort::hash() const { @@ -181,7 +184,7 @@ string GenericSort::compute_string() const { } else if (get_sort_kind() == SortKind::UNINTERPRETED_CONS) { return get_uninterpreted_name(); } - else if (get_sort_kind() == SortKind::DATATYPE) + else if (get_sort_kind() == SortKind::DATATYPE || get_sort_kind() == SortKind::PLACEHOLDER) { return base_name; } diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 0a4339b47..9e5ead908 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -77,6 +77,8 @@ TEST_P(DTTests, DatatypeDecl) s->add_selector(consdecl, "head", s->make_sort(INT)); s->add_constructor(consListSpec, nildecl); s->add_constructor(consListSpec, consdecl); + + s->add_selector_self(consdecl, "tail"); Sort listsort = s->make_sort(consListSpec); DatatypeDecl counterdecl = s->make_datatype_decl("counter"); @@ -85,27 +87,22 @@ TEST_P(DTTests, DatatypeDecl) s->add_constructor(counterdecl, countercons); Sort countersort = s->make_sort(counterdecl); - - s->add_selector_self(consdecl, "tail"); assert(countersort->get_sort_kind() == DATATYPE); assert(listsort->get_sort_kind() == DATATYPE); assert(countersort != listsort); Datatype listdt = listsort->get_datatype(); - Term five = s->make_term(5, intsort); - //Datatype listdt = listsort->get_datatype(); + if (s->get_solver_enum() != GENERIC_SOLVER) + { + Term five = s->make_term(5, intsort); // Make datatype terms - /* Term cons = s->get_constructor(listsort, "cons"); - assert("cons" == cons->to_string()); + Term cons = s->get_constructor(listsort, "cons"); + assert("cons" == cons->to_string()); Term nil = s->get_constructor(listsort, "nil"); - */ - if (s->get_solver_enum() != GENERIC_SOLVER) - { + Term head = s->get_selector(listsort, "cons", "head"); - // This part must be commented out for the code to compile and - // pass the tests. - /* + Term tail = s->get_selector(listsort, "cons", "tail"); Term isNil = s->get_tester(listsort, "nil"); @@ -137,7 +134,7 @@ TEST_P(DTTests, DatatypeDecl) InternalSolverException); EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); - */ + } } From b348d6127d3e6d5391ac31fa60a6c6d4c7c28170 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Tue, 13 Jul 2021 20:49:50 -0700 Subject: [PATCH 20/47] Added style tweaks and self selector functionality. --- src/generic_solver.cpp | 4 ++-- src/generic_sort.cpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 0ef982f27..2dbd2d426 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -577,8 +577,8 @@ void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string { shared_ptr newSelector = make_shared(); - (*newSelector).name = name; - (*newSelector).sort = s; + newSelector->name = name; + newSelector->sort = s; shared_ptr gdtc = static_pointer_cast(dt); gdtc->add_new_selector(*newSelector); diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 1c9df8760..d2d59314a 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -38,7 +38,7 @@ Sort make_uninterpreted_generic_sort(Sort sort_cons, Sort make_generic_sort(SortKind sk) { - if (sk != BOOL && sk != INT && sk != REAL && sk != PLACEHOLDER) + if (sk != BOOL && sk != INT && sk != REAL) { throw IncorrectUsageException("Can't create sort from " + to_string(sk)); } From f85666c836dcc19ad6b247ab5c5ac124aa9218c2 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Wed, 14 Jul 2021 17:23:21 -0700 Subject: [PATCH 21/47] Response to another wave of revisions. Still needs to surmount undefined reference errors when using new make_generic_sort functions. --- include/generic_datatype.h | 4 ++-- include/generic_solver.h | 1 + include/generic_sort.h | 2 +- include/sort.h | 1 - src/generic_datatype.cpp | 4 +++- src/generic_solver.cpp | 10 +++++----- src/generic_sort.cpp | 8 ++++---- tests/test-dt.cpp | 12 +++++++----- 8 files changed, 23 insertions(+), 19 deletions(-) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index c78dd6961..11ee961e2 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -5,7 +5,7 @@ #include "datatype.h" #include "exceptions.h" #include "smt_defs.h" -#include "sort.h" +#include "generic_sort.h" // using namespace smt; namespace smt { @@ -14,6 +14,7 @@ struct SelectorComponents { std::string name; Sort sort; + bool finalized; }; class GenericDatatypeDecl : public AbsDatatypeDecl @@ -66,7 +67,6 @@ class GenericDatatype : public AbsDatatype protected: DatatypeDecl dt_decl; - std::string name; std::vector cons_decl_vector; friend class GenericSolver; diff --git a/include/generic_solver.h b/include/generic_solver.h index 08f49b108..4d9df5d73 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -48,6 +48,7 @@ class GenericSolver : public AbsSmtSolver UnorderedTermMap get_array_values(const Term & arr, Term & out_const_base) const override; Sort make_sort(const Sort & sort_con, const SortVec & sorts) const override; + // Mutually recursive datatypes are currently not supported. Sort make_sort(const DatatypeDecl & d) const override; DatatypeDecl make_datatype_decl(const std::string & s) override; DatatypeConstructorDecl make_datatype_constructor_decl( diff --git a/include/generic_sort.h b/include/generic_sort.h index 5cd607a7a..267427793 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -47,7 +47,7 @@ class GenericSort : public AbsSort public: GenericSort(SortKind sk); // This second constructor is only for datatype sorts - GenericSort(SortKind sk, std::string name_var); + GenericSort(SortKind sk, std::string sort_name); // ONly for placeholder sorts GenericSort(std::string name); virtual ~GenericSort(); diff --git a/include/sort.h b/include/sort.h index 88d586efe..5dc3885b9 100644 --- a/include/sort.h +++ b/include/sort.h @@ -44,7 +44,6 @@ enum SortKind // arguments) UNINTERPRETED_CONS, DATATYPE, - PLACEHOLDER, /** IMPORTANT: This must stay at the bottom. It's only use is for sizing the kind2str array diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index c575df6a7..e46379b01 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -136,8 +136,10 @@ int GenericDatatype::get_num_selectors(std::string cons) const for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { std::shared_ptr cons_cast = static_pointer_cast(cons_decl_vector[i]); for (unsigned int f = 0; f < get_num_selectors(cons_cast->get_name()); ++f) { - if (cons_cast->selector_vector[f].sort->get_sort_kind() == PLACEHOLDER) { + + if (cons_cast->selector_vector[f].finalized == false) { cons_cast->selector_vector[f].sort = new_sort; + cons_cast->selector_vector[f].finalized = true; } } diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 2dbd2d426..9086693f8 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -488,6 +488,8 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; if (name_sort_map->find(dt_decl_name) == name_sort_map->end()) { + // Exact functionality of make_genericsort, without the linking + // errors (undefined reference when I call a new make_generic_sort). Sort dt_sort = make_shared(curr_dt); curr_dt->change_sort_of_selector(dt_sort); @@ -528,13 +530,9 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const to_solver += ")"; } to_solver += ")\n))"; - // Exact functionality of make_genericsort, without the linking - // errors (undefined reference when I call the new - // make_generic_sort). assert(name_sort_map->find(dt_decl_name) == name_sort_map->end()); (*name_sort_map)[dt_decl_name] = dt_sort; (*sort_name_map)[dt_sort] = dt_decl_name; - cout << to_solver << endl; run_command(to_solver); return dt_sort; @@ -579,6 +577,7 @@ void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string make_shared(); newSelector->name = name; newSelector->sort = s; + newSelector->finalized = true; shared_ptr gdtc = static_pointer_cast(dt); gdtc->add_new_selector(*newSelector); @@ -593,7 +592,8 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s newSelector->name = name; newSelector->sort = make_shared(name); - //assert(name_datatype_map->find(dt_decl_name) != name_datatype_map->end()); + newSelector->finalized = false; + assert(name_datatype_map->find(dt_decl_name) != name_datatype_map->end()); shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; gdt_cons->add_new_selector(*newSelector); } diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index d2d59314a..ae41f4804 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -128,12 +128,12 @@ Sort make_generic_sort(Datatype & dt) // implementations -GenericSort::GenericSort(SortKind sk) : sk(sk) {} + GenericSort::GenericSort(SortKind sk) : sk(sk) {} -GenericSort::GenericSort(SortKind sk, std::string name_var) : sk(sk) {} + GenericSort::GenericSort(SortKind sk, std::string sort_name) : sk(sk) {} // Only used to make placeholders -GenericSort::GenericSort(std::string name) : sk(PLACEHOLDER), base_name(name) {} + GenericSort::GenericSort(std::string name) : sk(DATATYPE), base_name(name) {} GenericSort::~GenericSort() {} @@ -184,7 +184,7 @@ string GenericSort::compute_string() const { } else if (get_sort_kind() == SortKind::UNINTERPRETED_CONS) { return get_uninterpreted_name(); } - else if (get_sort_kind() == SortKind::DATATYPE || get_sort_kind() == SortKind::PLACEHOLDER) + else if (get_sort_kind() == SortKind::DATATYPE) { return base_name; } diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 9e5ead908..411b184e4 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -94,13 +94,15 @@ TEST_P(DTTests, DatatypeDecl) Datatype listdt = listsort->get_datatype(); if (s->get_solver_enum() != GENERIC_SOLVER) - { + { Term five = s->make_term(5, intsort); // Make datatype terms - Term cons = s->get_constructor(listsort, "cons"); - assert("cons" == cons->to_string()); - Term nil = s->get_constructor(listsort, "nil"); - + //Term cons = s->get_constructor(listsort, "cons"); + // assert("cons" == cons->to_string()); + Term nil = s->get_constructor(listsort, "nil"); + // if (s->get_solver_enum() != GENERIC_SOLVER) + // { + Term cons = s->get_constructor(listsort, "cons"); Term head = s->get_selector(listsort, "cons", "head"); Term tail = s->get_selector(listsort, "cons", "tail"); From 0ea39118881f79cbc8796cd1d0f58709839e014b Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 16 Jul 2021 12:20:27 -0700 Subject: [PATCH 22/47] PR revision requests. Mostly style tweaks. --- CMakeLists.txt | 1 + include/generic_datatype.h | 14 ++++++++++++++ include/generic_sort.h | 5 +++-- src/generic_datatype.cpp | 11 ++++------- src/generic_solver.cpp | 11 +++++++++++ src/generic_sort.cpp | 4 ++-- 6 files changed, 35 insertions(+), 11 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 382f42d49..572062dde 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,6 +6,7 @@ set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) + set(CMAKE_POSITION_INDEPENDENT_CODE ON) list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index 11ee961e2..da2aae881 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -14,6 +14,8 @@ struct SelectorComponents { std::string name; Sort sort; + // Used to determine if the sort needs to be replaced later + // on. Usually true if no further work needs to be done to the selector. bool finalized; }; @@ -22,6 +24,7 @@ class GenericDatatypeDecl : public AbsDatatypeDecl public: GenericDatatypeDecl(const std::string name); virtual ~GenericDatatypeDecl(){}; + // Getter for the dt_name member std::string get_name(); protected: @@ -34,12 +37,19 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl public: GenericDatatypeConstructorDecl(const std::string & name); virtual ~GenericDatatypeConstructorDecl(){}; + // Adds a new selector to the constructor object void add_new_selector(const SelectorComponents & newSelector); + // Getter for the member selector_vector std::vector get_selector_vector(); + // Getter for the member cons_name std::string get_name() const; + // Returns the number of selectors int get_selector_count() const; bool compare(const DatatypeConstructorDecl & d) const override; + // Returns the name of the datatype this constructor is associated with std::string get_dt_name() const; + // Setter for the dt_decl member. Sets what datatype this + // constructor is associated with. void update_stored_dt(const DatatypeDecl & datatype_decl); protected: @@ -55,13 +65,17 @@ class GenericDatatype : public AbsDatatype public: GenericDatatype(const DatatypeDecl & dt_declaration); virtual ~GenericDatatype(){}; + // Stores a new constructor in the datatype object. void add_constructor(const DatatypeConstructorDecl & dt_cons_decl); + // Stores a new selector in the datatype object void add_selector(const DatatypeConstructorDecl & dt_cons_decl, const SelectorComponents & newSelector); + // Getter for the member cons_decl_vector std::vector get_cons_vector(); std::string get_name() const override; int get_num_constructors() const override; int get_num_selectors(std::string cons) const override; + // Updates the sort of any selector whose finalized field is false. void change_sort_of_selector(const Sort new_sort); std::hash str_hash; diff --git a/include/generic_sort.h b/include/generic_sort.h index 267427793..e086cc2b6 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -46,9 +46,9 @@ class GenericSort : public AbsSort { public: GenericSort(SortKind sk); - // This second constructor is only for datatype sorts + // This constructor is only for datatype sorts GenericSort(SortKind sk, std::string sort_name); - // ONly for placeholder sorts + // Only for placeholder sorts used for inductive datatypes. GenericSort(std::string name); virtual ~GenericSort(); SortKind get_sort_kind() const override; @@ -202,6 +202,7 @@ class GenericDatatypeSort : public GenericSort public: GenericDatatypeSort(const Datatype & dt); ~GenericDatatypeSort(); + // Returns the name of the datatype std::string get_sort_name(); Datatype get_datatype() const override; bool compare(const Sort & s) const override; diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index e46379b01..eac342397 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -136,14 +136,11 @@ int GenericDatatype::get_num_selectors(std::string cons) const for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { std::shared_ptr cons_cast = static_pointer_cast(cons_decl_vector[i]); for (unsigned int f = 0; f < get_num_selectors(cons_cast->get_name()); ++f) { - - if (cons_cast->selector_vector[f].finalized == false) { - cons_cast->selector_vector[f].sort = new_sort; - cons_cast->selector_vector[f].finalized = true; - } + if (cons_cast->selector_vector[f].finalized == false) { + cons_cast->selector_vector[f].sort = new_sort; + cons_cast->selector_vector[f].finalized = true; + } } - } } - } // namespace smt diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 9086693f8..8e5ecbe37 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -491,6 +491,8 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // Exact functionality of make_genericsort, without the linking // errors (undefined reference when I call a new make_generic_sort). Sort dt_sort = make_shared(curr_dt); + // Replaces the sort of any selectors with a false finalized field + // with dt_sort and sets finalized to true. curr_dt->change_sort_of_selector(dt_sort); std::string to_solver = "(" + DECLARE_DATATYPE_STR + " (("; @@ -591,7 +593,10 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s string dt_decl_name = gdt_cons->get_dt_name(); newSelector->name = name; + // Sets the sort to be a placeholder value until the self sort is constructed. newSelector->sort = make_shared(name); + // This indicates that the sort in this selector will eventually + // be replaced newSelector->finalized = false; assert(name_datatype_map->find(dt_decl_name) != name_datatype_map->end()); shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; @@ -613,6 +618,7 @@ Term GenericSolver::get_selector(const Sort & s, std::string con, std::string na { throw NotImplementedException("Generic Solvers do not support datatypes"); + } std::string GenericSolver::get_name(Term term) const @@ -853,6 +859,7 @@ Term GenericSolver::make_param(const string name, const Sort & sort) Term GenericSolver::make_term(const Op op, const Term & t) const { + cout << "make term fn called" << endl; return make_term(op, TermVec({ t })); } @@ -873,8 +880,12 @@ Term GenericSolver::make_term(const Op op, Term GenericSolver::make_term(const Op op, const TermVec & terms) const { + cout << "this new fn called" << endl; Sort sort = compute_sort(op, this, terms); + cout << "computer sort" << endl; string repr = "(" + op.to_string(); + cout << repr << endl; + cout << "tedt" << endl; for (int i = 0; i < terms.size(); i++) { assert((*term_name_map).find(terms[i]) != (*term_name_map).end()); diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index ae41f4804..47910bc2a 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -132,7 +132,8 @@ Sort make_generic_sort(Datatype & dt) GenericSort::GenericSort(SortKind sk, std::string sort_name) : sk(sk) {} - // Only used to make placeholders + // Only used to make placeholder sorts for datatypes when the + // sort is the datatype itself but the sort hasn't been constructed. GenericSort::GenericSort(std::string name) : sk(DATATYPE), base_name(name) {} GenericSort::~GenericSort() {} @@ -350,7 +351,6 @@ SortVec UninterpretedGenericSort::get_uninterpreted_param_sorts() const GenericDatatypeSort::GenericDatatypeSort(const Datatype & dt) : GenericSort(DATATYPE), gdt(dt) - //GenericSort::base_name((static_pointer_cast(dt))->get_name()) { GenericSort::base_name = (static_pointer_cast(dt))->get_name(); } From e2cf3d4033330b263a26d018888ed9c084ce727c Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 16 Jul 2021 12:24:30 -0700 Subject: [PATCH 23/47] PR tweaks. --- tests/test-dt.cpp | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 411b184e4..92b585413 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -93,26 +93,28 @@ TEST_P(DTTests, DatatypeDecl) assert(countersort != listsort); Datatype listdt = listsort->get_datatype(); + if (s->get_solver_enum() != GENERIC_SOLVER) - { + { Term five = s->make_term(5, intsort); // Make datatype terms - //Term cons = s->get_constructor(listsort, "cons"); - // assert("cons" == cons->to_string()); + Term cons = s->get_constructor(listsort, "cons"); + assert("cons" == cons->to_string()); Term nil = s->get_constructor(listsort, "nil"); - // if (s->get_solver_enum() != GENERIC_SOLVER) - // { - Term cons = s->get_constructor(listsort, "cons"); Term head = s->get_selector(listsort, "cons", "head"); Term tail = s->get_selector(listsort, "cons", "tail"); + Term isNil = s->get_tester(listsort, "nil"); + // Datatype ops + Term nilterm = s->make_term(Apply_Constructor, nil); Term list5 = s->make_term(Apply_Constructor, cons, five, nilterm); Term five_again = s->make_term(Apply_Selector, head, list5); + // Expected booleans s->assert_formula(s->make_term(Equal, five, five_again)); s->assert_formula(s->make_term(Apply_Tester, isNil, nilterm)); @@ -127,7 +129,6 @@ TEST_P(DTTests, DatatypeDecl) ASSERT_TRUE(listdt->get_num_selectors("nil") == 0); ASSERT_TRUE(res.is_sat()); - // Expected exceptions EXPECT_THROW(s->get_constructor(listsort, "kons"), InternalSolverException); @@ -138,6 +139,7 @@ TEST_P(DTTests, DatatypeDecl) InternalSolverException); } + } INSTANTIATE_TEST_SUITE_P(ParameterizedSolverDTTests, From 29779b9ffabf9ea15e5f53282a2c459c55a5a76e Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 16 Jul 2021 12:25:29 -0700 Subject: [PATCH 24/47] PR tweaks and style adjustements. --- include/generic_datatype.h | 2 +- src/generic_datatype.cpp | 44 ++++++++++++++++++++--------------- src/generic_solver.cpp | 14 ++++++------ src/generic_sort.cpp | 26 +++++++++++++-------- tests/test-dt.cpp | 47 ++++++++++++++++---------------------- 5 files changed, 69 insertions(+), 64 deletions(-) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index da2aae881..875890458 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -4,8 +4,8 @@ #include "datatype.h" #include "exceptions.h" -#include "smt_defs.h" #include "generic_sort.h" +#include "smt_defs.h" // using namespace smt; namespace smt { diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index eac342397..0f42cf426 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -19,7 +19,7 @@ std::string GenericDatatypeDecl::get_name() { return dt_name; } GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( const std::string & name) - : cons_name(name) + : cons_name(name) { } @@ -58,16 +58,16 @@ bool GenericDatatypeConstructorDecl::compare( == static_pointer_cast(d)->get_name(); } - std::string GenericDatatypeConstructorDecl::get_dt_name() const - { - return static_pointer_cast(dt_decl)->get_name(); - } +std::string GenericDatatypeConstructorDecl::get_dt_name() const +{ + return static_pointer_cast(dt_decl)->get_name(); +} - void GenericDatatypeConstructorDecl::update_stored_dt(const DatatypeDecl & datatype_decl) - { - dt_decl = datatype_decl; - - } +void GenericDatatypeConstructorDecl::update_stored_dt( + const DatatypeDecl & datatype_decl) +{ + dt_decl = datatype_decl; +} GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration) : dt_decl(dt_declaration) @@ -82,7 +82,8 @@ void GenericDatatype::add_constructor( { throw "Can't add constructor. It already has been added!"; } - shared_ptr gdt_cons = static_pointer_cast(dt_cons_decl); + shared_ptr gdt_cons = + static_pointer_cast(dt_cons_decl); gdt_cons->update_stored_dt(dt_decl); cons_decl_vector.push_back(dt_cons_decl); } @@ -131,16 +132,21 @@ int GenericDatatype::get_num_selectors(std::string cons) const return num_selectors; } - void GenericDatatype::change_sort_of_selector(const Sort new_sort) +void GenericDatatype::change_sort_of_selector(const Sort new_sort) +{ + for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { - for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { - std::shared_ptr cons_cast = static_pointer_cast(cons_decl_vector[i]); - for (unsigned int f = 0; f < get_num_selectors(cons_cast->get_name()); ++f) { - if (cons_cast->selector_vector[f].finalized == false) { - cons_cast->selector_vector[f].sort = new_sort; - cons_cast->selector_vector[f].finalized = true; - } + std::shared_ptr cons_cast = + static_pointer_cast( + cons_decl_vector[i]); + for (unsigned int f = 0; f < get_num_selectors(cons_cast->get_name()); ++f) + { + if (cons_cast->selector_vector[f].finalized == false) + { + cons_cast->selector_vector[f].sort = new_sort; + cons_cast->selector_vector[f].finalized = true; } } } +} } // namespace smt diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 8e5ecbe37..68c02fe90 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -494,7 +494,7 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // Replaces the sort of any selectors with a false finalized field // with dt_sort and sets finalized to true. curr_dt->change_sort_of_selector(dt_sort); - + std::string to_solver = "(" + DECLARE_DATATYPE_STR + " (("; to_solver += dt_decl_name; to_solver += " 0)) (\n"; @@ -536,7 +536,7 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const (*name_sort_map)[dt_decl_name] = dt_sort; (*sort_name_map)[dt_sort] = dt_decl_name; run_command(to_solver); - + return dt_sort; } else @@ -589,11 +589,13 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s { shared_ptr newSelector = make_shared(); - shared_ptr gdt_cons = static_pointer_cast(dt); + shared_ptr gdt_cons = + static_pointer_cast(dt); string dt_decl_name = gdt_cons->get_dt_name(); - + newSelector->name = name; - // Sets the sort to be a placeholder value until the self sort is constructed. + // Sets the sort to be a placeholder value until the self sort is + // constructed. newSelector->sort = make_shared(name); // This indicates that the sort in this selector will eventually // be replaced @@ -617,8 +619,6 @@ Term GenericSolver::get_tester(const Sort & s, std::string name) const Term GenericSolver::get_selector(const Sort & s, std::string con, std::string name) const { throw NotImplementedException("Generic Solvers do not support datatypes"); - - } std::string GenericSolver::get_name(Term term) const diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 47910bc2a..955824692 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -128,13 +128,13 @@ Sort make_generic_sort(Datatype & dt) // implementations - GenericSort::GenericSort(SortKind sk) : sk(sk) {} +GenericSort::GenericSort(SortKind sk) : sk(sk) {} - GenericSort::GenericSort(SortKind sk, std::string sort_name) : sk(sk) {} +GenericSort::GenericSort(SortKind sk, std::string sort_name) : sk(sk) {} - // Only used to make placeholder sorts for datatypes when the - // sort is the datatype itself but the sort hasn't been constructed. - GenericSort::GenericSort(std::string name) : sk(DATATYPE), base_name(name) {} +// Only used to make placeholder sorts for datatypes when the +// sort is the datatype itself but the sort hasn't been constructed. +GenericSort::GenericSort(std::string name) : sk(DATATYPE), base_name(name) {} GenericSort::~GenericSort() {} @@ -349,19 +349,25 @@ SortVec UninterpretedGenericSort::get_uninterpreted_param_sorts() const } GenericDatatypeSort::GenericDatatypeSort(const Datatype & dt) - : GenericSort(DATATYPE), - gdt(dt) + : GenericSort(DATATYPE), gdt(dt) { - GenericSort::base_name = (static_pointer_cast(dt))->get_name(); + GenericSort::base_name = + (static_pointer_cast(dt))->get_name(); } GenericDatatypeSort::~GenericDatatypeSort() {} - std::string GenericDatatypeSort::get_sort_name() { return GenericSort::base_name; } +std::string GenericDatatypeSort::get_sort_name() +{ + return GenericSort::base_name; +} Datatype GenericDatatypeSort::get_datatype() const { return gdt; } - string GenericDatatypeSort::compute_string() const { return GenericSort::base_name; } +string GenericDatatypeSort::compute_string() const +{ + return GenericSort::base_name; +} bool GenericDatatypeSort::compare(const Sort & s) const { diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 92b585413..fda1829c1 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -52,12 +52,11 @@ TEST_P(DTTests, DatatypeDecl) DatatypeDecl consListSpec = s->make_datatype_decl("list"); auto dt_decltest = make_shared("secondtestdt"); - + std::shared_ptr gdt = make_shared(dt_decltest); assert(gdt->get_num_constructors() == 0); - - + shared_ptr cons2test = shared_ptr( new GenericDatatypeConstructorDecl("constest")); @@ -65,56 +64,53 @@ TEST_P(DTTests, DatatypeDecl) assert(gdt->get_num_constructors() == 1); assert(gdt->get_num_selectors("constest") == 0); assert(gdt->get_name() == "secondtestdt"); - DatatypeConstructorDecl nildecl = s->make_datatype_constructor_decl("nil"); DatatypeConstructorDecl consdecl = s->make_datatype_constructor_decl("cons"); - - shared_ptr consdeclgen = static_pointer_cast(consdecl); + + shared_ptr consdeclgen = + static_pointer_cast(consdecl); DatatypeConstructorDecl cons_copy = consdecl; ASSERT_EQ(cons_copy, consdecl); - + s->add_selector(consdecl, "head", s->make_sort(INT)); s->add_constructor(consListSpec, nildecl); s->add_constructor(consListSpec, consdecl); - + s->add_selector_self(consdecl, "tail"); Sort listsort = s->make_sort(consListSpec); - + DatatypeDecl counterdecl = s->make_datatype_decl("counter"); DatatypeConstructorDecl countercons = s->make_datatype_constructor_decl("countercons"); s->add_constructor(counterdecl, countercons); Sort countersort = s->make_sort(counterdecl); - assert(countersort->get_sort_kind() == DATATYPE); assert(listsort->get_sort_kind() == DATATYPE); assert(countersort != listsort); - + Datatype listdt = listsort->get_datatype(); - + if (s->get_solver_enum() != GENERIC_SOLVER) { - Term five = s->make_term(5, intsort); + Term five = s->make_term(5, intsort); // Make datatype terms - Term cons = s->get_constructor(listsort, "cons"); - assert("cons" == cons->to_string()); - Term nil = s->get_constructor(listsort, "nil"); + Term cons = s->get_constructor(listsort, "cons"); + assert("cons" == cons->to_string()); + Term nil = s->get_constructor(listsort, "nil"); Term head = s->get_selector(listsort, "cons", "head"); - + Term tail = s->get_selector(listsort, "cons", "tail"); - - + Term isNil = s->get_tester(listsort, "nil"); - + // Datatype ops - + Term nilterm = s->make_term(Apply_Constructor, nil); Term list5 = s->make_term(Apply_Constructor, cons, five, nilterm); Term five_again = s->make_term(Apply_Selector, head, list5); - - + // Expected booleans s->assert_formula(s->make_term(Equal, five, five_again)); s->assert_formula(s->make_term(Apply_Tester, isNil, nilterm)); @@ -135,11 +131,8 @@ TEST_P(DTTests, DatatypeDecl) EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); EXPECT_THROW(s->get_selector(listsort, "nil", "head"), InternalSolverException); - EXPECT_THROW(listdt->get_num_selectors("kons"), - InternalSolverException); - + EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); } - } INSTANTIATE_TEST_SUITE_P(ParameterizedSolverDTTests, From 00ddb30c2f8300a4bc267526439294720e2eeb08 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 16 Jul 2021 12:31:05 -0700 Subject: [PATCH 25/47] PR tweaks --- include/generic_datatype.h | 5 ----- 1 file changed, 5 deletions(-) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index 875890458..f0d7aef67 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -24,7 +24,6 @@ class GenericDatatypeDecl : public AbsDatatypeDecl public: GenericDatatypeDecl(const std::string name); virtual ~GenericDatatypeDecl(){}; - // Getter for the dt_name member std::string get_name(); protected: @@ -41,12 +40,9 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl void add_new_selector(const SelectorComponents & newSelector); // Getter for the member selector_vector std::vector get_selector_vector(); - // Getter for the member cons_name std::string get_name() const; - // Returns the number of selectors int get_selector_count() const; bool compare(const DatatypeConstructorDecl & d) const override; - // Returns the name of the datatype this constructor is associated with std::string get_dt_name() const; // Setter for the dt_decl member. Sets what datatype this // constructor is associated with. @@ -70,7 +66,6 @@ class GenericDatatype : public AbsDatatype // Stores a new selector in the datatype object void add_selector(const DatatypeConstructorDecl & dt_cons_decl, const SelectorComponents & newSelector); - // Getter for the member cons_decl_vector std::vector get_cons_vector(); std::string get_name() const override; int get_num_constructors() const override; From f806fc8b8d8414643772c72c4da51553fb2208af Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 16 Jul 2021 20:02:22 -0700 Subject: [PATCH 26/47] Extensive documentation added --- cvc4/src/cvc4_datatype.cpp | 10 ++++++++++ include/datatype.h | 2 +- include/generic_datatype.h | 20 ++++++++++++-------- include/generic_sort.h | 5 +++-- src/datatype.cpp | 8 ++++++++ src/generic_datatype.cpp | 28 ++++++++++++++++++++++++---- src/generic_sort.cpp | 1 + 7 files changed, 59 insertions(+), 15 deletions(-) create mode 100644 cvc4/src/cvc4_datatype.cpp create mode 100644 src/datatype.cpp diff --git a/cvc4/src/cvc4_datatype.cpp b/cvc4/src/cvc4_datatype.cpp new file mode 100644 index 000000000..b5c2a3ff5 --- /dev/null +++ b/cvc4/src/cvc4_datatype.cpp @@ -0,0 +1,10 @@ +#include "cvc4_datatype.h" +namespace smt { + + bool CVC4DatatypeConstructorDecl::compare(const DatatypeConstructorDecl & d) const + { + std::shared_ptr cd = std::static_pointer_cast(d); + return datatypeconstructordecl.toString() == cd->datatypeconstructordecl.toString(); + } + +} diff --git a/include/datatype.h b/include/datatype.h index cebe74cec..fa097a97c 100644 --- a/include/datatype.h +++ b/include/datatype.h @@ -48,7 +48,7 @@ class AbsDatatype { virtual int get_num_selectors(std::string cons) const=0; virtual int get_num_constructors() const=0; }; - +// Overloaded equivalence operators for two datatype constructor declarations bool operator==(const DatatypeConstructorDecl & d1, const DatatypeConstructorDecl & d2); bool operator!=(const DatatypeConstructorDecl & d1, diff --git a/include/generic_datatype.h b/include/generic_datatype.h index f0d7aef67..e81b0c9db 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -7,11 +7,12 @@ #include "generic_sort.h" #include "smt_defs.h" -// using namespace smt; namespace smt { + // Struct used to hold everything needed to work with datatype selectors struct SelectorComponents { + // Name of the selector and its associated sort std::string name; Sort sort; // Used to determine if the sort needs to be replaced later @@ -36,16 +37,17 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl public: GenericDatatypeConstructorDecl(const std::string & name); virtual ~GenericDatatypeConstructorDecl(){}; - // Adds a new selector to the constructor object + // Stores a new selector in the constructor object. newSelector: the + // selectorComponents to be added. void add_new_selector(const SelectorComponents & newSelector); - // Getter for the member selector_vector std::vector get_selector_vector(); std::string get_name() const; + // Returns the size of selector_vector int get_selector_count() const; bool compare(const DatatypeConstructorDecl & d) const override; std::string get_dt_name() const; - // Setter for the dt_decl member. Sets what datatype this - // constructor is associated with. + // Setter for the dt_decl member. Only to be used when a constructor + // is added to a datatype. datatype_decl: The DatatypeDecl of the datatype. void update_stored_dt(const DatatypeDecl & datatype_decl); protected: @@ -61,16 +63,18 @@ class GenericDatatype : public AbsDatatype public: GenericDatatype(const DatatypeDecl & dt_declaration); virtual ~GenericDatatype(){}; - // Stores a new constructor in the datatype object. + // Stores a constructor object (dt_cons_decl) in the datatype object. void add_constructor(const DatatypeConstructorDecl & dt_cons_decl); - // Stores a new selector in the datatype object + // Stores a new selector (newSelector) in the constructor object (dt_cons_decl) if the + // constructor is associated with the datatype void add_selector(const DatatypeConstructorDecl & dt_cons_decl, const SelectorComponents & newSelector); std::vector get_cons_vector(); std::string get_name() const override; int get_num_constructors() const override; int get_num_selectors(std::string cons) const override; - // Updates the sort of any selector whose finalized field is false. + // Updates the sort of any selector whose finalized field is + // false. The not-finalized selectors have their sorts set to new_sort. void change_sort_of_selector(const Sort new_sort); std::hash str_hash; diff --git a/include/generic_sort.h b/include/generic_sort.h index e086cc2b6..9e81191e5 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -46,9 +46,10 @@ class GenericSort : public AbsSort { public: GenericSort(SortKind sk); - // This constructor is only for datatype sorts + // This constructor is only for datatype sorts. GenericSort(SortKind sk, std::string sort_name); - // Only for placeholder sorts used for inductive datatypes. + // Only for placeholder sorts used for inductive datatypes. name + // should be the name of the datatype. GenericSort(std::string name); virtual ~GenericSort(); SortKind get_sort_kind() const override; diff --git a/src/datatype.cpp b/src/datatype.cpp new file mode 100644 index 000000000..0bb107c9e --- /dev/null +++ b/src/datatype.cpp @@ -0,0 +1,8 @@ +#include "datatype.h" + +namespace smt { + // Overloaded operators simply call the constructors' comparison functions + bool operator==(const DatatypeConstructorDecl & d1, const DatatypeConstructorDecl & d2) { return d1->compare(d2); } + bool operator!=(const DatatypeConstructorDecl & d1, const DatatypeConstructorDecl & d2) { return !d1->compare(d2); } + +} diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 0f42cf426..2f83bee52 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -28,6 +28,7 @@ void GenericDatatypeConstructorDecl::add_new_selector( { for (unsigned int i = 0; i < selector_vector.size(); ++i) { + // Checks if the selector has already been added if (selector_vector[i].name == (newSelector).name) { throw "Can't add selector. It already exists in this datatype!"; @@ -54,8 +55,8 @@ int GenericDatatypeConstructorDecl::get_selector_count() const bool GenericDatatypeConstructorDecl::compare( const DatatypeConstructorDecl & d) const { - return cons_name - == static_pointer_cast(d)->get_name(); + // COmpares based off constructor's name + return cons_name == static_pointer_cast(d)->get_name(); } std::string GenericDatatypeConstructorDecl::get_dt_name() const @@ -77,6 +78,7 @@ GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration) void GenericDatatype::add_constructor( const DatatypeConstructorDecl & dt_cons_decl) { + // checks if dt_cons_decl is already associated with the datatype if (std::find(cons_decl_vector.begin(), cons_decl_vector.end(), dt_cons_decl) != cons_decl_vector.end()) { @@ -84,7 +86,9 @@ void GenericDatatype::add_constructor( } shared_ptr gdt_cons = static_pointer_cast(dt_cons_decl); + // Links the constructor to the datatype_decl of the datatype gdt_cons->update_stored_dt(dt_decl); + // Links the datatype to the new constructor cons_decl_vector.push_back(dt_cons_decl); } @@ -93,10 +97,14 @@ void GenericDatatype::add_selector(const DatatypeConstructorDecl & dt_cons_decl, { for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { + // If the constructor is associated with the datatype if (cons_decl_vector[i] == dt_cons_decl) { - static_pointer_cast(cons_decl_vector[i]) - ->add_new_selector(newSelector); + // Adds the selector to the correct constructor + static_pointer_cast(cons_decl_vector[i])->add_new_selector(newSelector); + } + else { + throw "Can't add selector. The constructor is not a member of the datatype!"; } } } @@ -117,32 +125,44 @@ int GenericDatatype::get_num_constructors() const int GenericDatatype::get_num_selectors(std::string cons) const { + // Used to keep track of the number of selectors in the constructor int num_selectors = 0; for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) + // Searches for a matching constructor { if (static_pointer_cast(cons_decl_vector[i]) ->get_name() == cons) { + // Calls the constructor's get_selector_count() function num_selectors = static_pointer_cast( cons_decl_vector[i]) ->get_selector_count(); } } + // Returns 0 if the constructor was not found return num_selectors; } + /* +This function goes through every selector in the datatype and if +finalized is set to false, it replaces the previously stored sort +with new_sort + */ void GenericDatatype::change_sort_of_selector(const Sort new_sort) { + // For every constructor for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { std::shared_ptr cons_cast = static_pointer_cast( cons_decl_vector[i]); + // For every selector for (unsigned int f = 0; f < get_num_selectors(cons_cast->get_name()); ++f) { if (cons_cast->selector_vector[f].finalized == false) { + // Updates the selector's members cons_cast->selector_vector[f].sort = new_sort; cons_cast->selector_vector[f].finalized = true; } diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 955824692..d66da1bac 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -371,6 +371,7 @@ string GenericDatatypeSort::compute_string() const bool GenericDatatypeSort::compare(const Sort & s) const { + // Compares the strings of two datatype sorts assert(s->get_sort_kind() == DATATYPE); shared_ptr other_sort = static_pointer_cast(s); From 51766d1a748b9cafeae2a9c96f9771a5c7198692 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 16 Jul 2021 20:03:47 -0700 Subject: [PATCH 27/47] Added extensive comments and documentation. --- cvc4/src/cvc4_datatype.cpp | 15 +++++++++------ include/generic_datatype.h | 6 +++--- src/datatype.cpp | 16 ++++++++++++---- src/generic_datatype.cpp | 15 +++++++++------ 4 files changed, 33 insertions(+), 19 deletions(-) diff --git a/cvc4/src/cvc4_datatype.cpp b/cvc4/src/cvc4_datatype.cpp index b5c2a3ff5..87d4f275d 100644 --- a/cvc4/src/cvc4_datatype.cpp +++ b/cvc4/src/cvc4_datatype.cpp @@ -1,10 +1,13 @@ #include "cvc4_datatype.h" namespace smt { - bool CVC4DatatypeConstructorDecl::compare(const DatatypeConstructorDecl & d) const - { - std::shared_ptr cd = std::static_pointer_cast(d); - return datatypeconstructordecl.toString() == cd->datatypeconstructordecl.toString(); - } - +bool CVC4DatatypeConstructorDecl::compare( + const DatatypeConstructorDecl & d) const +{ + std::shared_ptr cd = + std::static_pointer_cast(d); + return datatypeconstructordecl.toString() + == cd->datatypeconstructordecl.toString(); } + +} // namespace smt diff --git a/include/generic_datatype.h b/include/generic_datatype.h index e81b0c9db..b920aa1a8 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -9,7 +9,7 @@ namespace smt { - // Struct used to hold everything needed to work with datatype selectors +// Struct used to hold everything needed to work with datatype selectors struct SelectorComponents { // Name of the selector and its associated sort @@ -65,8 +65,8 @@ class GenericDatatype : public AbsDatatype virtual ~GenericDatatype(){}; // Stores a constructor object (dt_cons_decl) in the datatype object. void add_constructor(const DatatypeConstructorDecl & dt_cons_decl); - // Stores a new selector (newSelector) in the constructor object (dt_cons_decl) if the - // constructor is associated with the datatype + // Stores a new selector (newSelector) in the constructor object + // (dt_cons_decl) if the constructor is associated with the datatype void add_selector(const DatatypeConstructorDecl & dt_cons_decl, const SelectorComponents & newSelector); std::vector get_cons_vector(); diff --git a/src/datatype.cpp b/src/datatype.cpp index 0bb107c9e..a2c9a2350 100644 --- a/src/datatype.cpp +++ b/src/datatype.cpp @@ -1,8 +1,16 @@ #include "datatype.h" namespace smt { - // Overloaded operators simply call the constructors' comparison functions - bool operator==(const DatatypeConstructorDecl & d1, const DatatypeConstructorDecl & d2) { return d1->compare(d2); } - bool operator!=(const DatatypeConstructorDecl & d1, const DatatypeConstructorDecl & d2) { return !d1->compare(d2); } - +// Overloaded operators simply call the constructors' comparison functions +bool operator==(const DatatypeConstructorDecl & d1, + const DatatypeConstructorDecl & d2) +{ + return d1->compare(d2); } +bool operator!=(const DatatypeConstructorDecl & d1, + const DatatypeConstructorDecl & d2) +{ + return !d1->compare(d2); +} + +} // namespace smt diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 2f83bee52..5e35ab25e 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -56,7 +56,8 @@ bool GenericDatatypeConstructorDecl::compare( const DatatypeConstructorDecl & d) const { // COmpares based off constructor's name - return cons_name == static_pointer_cast(d)->get_name(); + return cons_name + == static_pointer_cast(d)->get_name(); } std::string GenericDatatypeConstructorDecl::get_dt_name() const @@ -101,9 +102,11 @@ void GenericDatatype::add_selector(const DatatypeConstructorDecl & dt_cons_decl, if (cons_decl_vector[i] == dt_cons_decl) { // Adds the selector to the correct constructor - static_pointer_cast(cons_decl_vector[i])->add_new_selector(newSelector); + static_pointer_cast(cons_decl_vector[i]) + ->add_new_selector(newSelector); } - else { + else + { throw "Can't add selector. The constructor is not a member of the datatype!"; } } @@ -128,7 +131,7 @@ int GenericDatatype::get_num_selectors(std::string cons) const // Used to keep track of the number of selectors in the constructor int num_selectors = 0; for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) - // Searches for a matching constructor + // Searches for a matching constructor { if (static_pointer_cast(cons_decl_vector[i]) ->get_name() @@ -144,11 +147,11 @@ int GenericDatatype::get_num_selectors(std::string cons) const return num_selectors; } - /* +/* This function goes through every selector in the datatype and if finalized is set to false, it replaces the previously stored sort with new_sort - */ + */ void GenericDatatype::change_sort_of_selector(const Sort new_sort) { // For every constructor From 55377b1bc9f18e7d82d7a1f606a54bbba8f8cc11 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Wed, 21 Jul 2021 14:56:49 -0700 Subject: [PATCH 28/47] Relevant to current PR --- CMakeLists.txt | 1 - include/generic_datatype.h | 13 +++++++++---- include/generic_sort.h | 12 +++--------- src/generic_datatype.cpp | 11 +++++++---- src/generic_solver.cpp | 25 ++++++++++++++++++------- src/generic_sort.cpp | 22 ++++++---------------- tests/test-generic-sort.cpp | 11 +++++++---- 7 files changed, 50 insertions(+), 45 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 572062dde..382f42d49 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,6 @@ set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) - set(CMAKE_POSITION_INDEPENDENT_CODE ON) list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index b920aa1a8..9700eaeb6 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -38,7 +38,7 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl GenericDatatypeConstructorDecl(const std::string & name); virtual ~GenericDatatypeConstructorDecl(){}; // Stores a new selector in the constructor object. newSelector: the - // selectorComponents to be added. + // SelectorComponents to be added. void add_new_selector(const SelectorComponents & newSelector); std::vector get_selector_vector(); std::string get_name() const; @@ -46,14 +46,14 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl int get_selector_count() const; bool compare(const DatatypeConstructorDecl & d) const override; std::string get_dt_name() const; - // Setter for the dt_decl member. Only to be used when a constructor - // is added to a datatype. datatype_decl: The DatatypeDecl of the datatype. - void update_stored_dt(const DatatypeDecl & datatype_decl); protected: std::vector selector_vector; std::string cons_name; DatatypeDecl dt_decl; + // Setter for the dt_decl member. Only to be used when a constructor + // is added to a datatype. datatype_decl: The DatatypeDecl of the datatype. + void update_stored_dt(const DatatypeDecl & datatype_decl); friend class GenericSolver; friend class GenericDatatype; }; @@ -75,6 +75,11 @@ class GenericDatatype : public AbsDatatype int get_num_selectors(std::string cons) const override; // Updates the sort of any selector whose finalized field is // false. The not-finalized selectors have their sorts set to new_sort. + // This function is used only as part of the process of adding a + // 'self-selector'. After a self selector is added to a datatype, it + // holds a placeholder sort. This function is + // called when the datatype's sort is created to replace the + // self-selector's placeholder sort with the actual datatype sort. void change_sort_of_selector(const Sort new_sort); std::hash str_hash; diff --git a/include/generic_sort.h b/include/generic_sort.h index 9e81191e5..96e48a161 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -46,9 +46,7 @@ class GenericSort : public AbsSort { public: GenericSort(SortKind sk); - // This constructor is only for datatype sorts. - GenericSort(SortKind sk, std::string sort_name); - // Only for placeholder sorts used for inductive datatypes. name + // Only for placeholder sorts used for datatypes. name // should be the name of the datatype. GenericSort(std::string name); virtual ~GenericSort(); @@ -119,13 +117,11 @@ class GenericSort : public AbsSort // A string representation of a sort std::string to_string() const override; - std::string get_base_name() const; protected: // internal function to compute // the string representation of a sort - std::string compute_string() const; - std::string base_name; + virtual std::string compute_string() const; // The underlying SortKind of the GenericSort SortKind sk; @@ -203,11 +199,9 @@ class GenericDatatypeSort : public GenericSort public: GenericDatatypeSort(const Datatype & dt); ~GenericDatatypeSort(); - // Returns the name of the datatype - std::string get_sort_name(); Datatype get_datatype() const override; bool compare(const Sort & s) const override; - std::string compute_string() const; + std::string compute_string() const override; std::string to_string() const override; protected: diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 5e35ab25e..55e733f63 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -96,6 +96,8 @@ void GenericDatatype::add_constructor( void GenericDatatype::add_selector(const DatatypeConstructorDecl & dt_cons_decl, const SelectorComponents & newSelector) { + // boolean used to keep track of if a successful match was found. + bool success = false; for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) { // If the constructor is associated with the datatype @@ -104,11 +106,12 @@ void GenericDatatype::add_selector(const DatatypeConstructorDecl & dt_cons_decl, // Adds the selector to the correct constructor static_pointer_cast(cons_decl_vector[i]) ->add_new_selector(newSelector); + success = true; + break; } - else - { - throw "Can't add selector. The constructor is not a member of the datatype!"; - } + } + if (!success) { + throw InternalSolverException("Can't add selector. The constructor is not a member of the datatype!"); } } std::vector GenericDatatype::get_cons_vector() diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 68c02fe90..2d75c375a 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -99,7 +99,7 @@ GenericSolver::GenericSolver(string path, write_buf = new char[write_buf_size]; read_buf = new char[read_buf_size]; - //make sure allocation was successful + // sure allocation was successful assert(write_buf != NULL); assert(read_buf != NULL); //initialize write_buf @@ -314,6 +314,10 @@ void GenericSolver::define_fun(std::string name, // (like define-const) assert(args_sorts.size() == 0); assert(sort_name_map->find(res_sort) != sort_name_map->end()); + cout << "command sent:" << endl; + cout << "(" + DEFINE_FUN_STR + " " + name + " () " + + (*sort_name_map)[res_sort] + " " + to_smtlib_def(defining_term) + + ")" << endl; // send a define-fun to the binary run_command("(" + DEFINE_FUN_STR + " " + name + " () " + (*sort_name_map)[res_sort] + " " + to_smtlib_def(defining_term) @@ -489,7 +493,9 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const if (name_sort_map->find(dt_decl_name) == name_sort_map->end()) { // Exact functionality of make_genericsort, without the linking - // errors (undefined reference when I call a new make_generic_sort). + // errors (undefined reference when I call a new + // make_generic_sort). + //Sort dt_sort = make_generic_sort(curr_dt); Sort dt_sort = make_shared(curr_dt); // Replaces the sort of any selectors with a false finalized field // with dt_sort and sets finalized to true. @@ -608,17 +614,20 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s Term GenericSolver::get_constructor(const Sort & s, std::string name) const { throw NotImplementedException("Generic Solvers do not support datatypes"); + } Term GenericSolver::get_tester(const Sort & s, std::string name) const { throw NotImplementedException("Generic Solvers do not support datatypes"); + } Term GenericSolver::get_selector(const Sort & s, std::string con, std::string name) const { throw NotImplementedException("Generic Solvers do not support datatypes"); + } std::string GenericSolver::get_name(Term term) const @@ -654,6 +663,9 @@ Term GenericSolver::store_term(Term term) const if (gterm->is_ground()) { name = get_name(gterm); + cout << "print ground name" << endl; + cout << name << endl; + cout << gterm->get_sort()->to_string() << endl; define_fun(name, SortVec{}, gterm->get_sort(), gterm); } else @@ -859,7 +871,6 @@ Term GenericSolver::make_param(const string name, const Sort & sort) Term GenericSolver::make_term(const Op op, const Term & t) const { - cout << "make term fn called" << endl; return make_term(op, TermVec({ t })); } @@ -880,18 +891,18 @@ Term GenericSolver::make_term(const Op op, Term GenericSolver::make_term(const Op op, const TermVec & terms) const { - cout << "this new fn called" << endl; + cout << "pre compute sort" << endl; Sort sort = compute_sort(op, this, terms); - cout << "computer sort" << endl; + cout << "post compute sort" << endl; string repr = "(" + op.to_string(); - cout << repr << endl; - cout << "tedt" << endl; for (int i = 0; i < terms.size(); i++) { assert((*term_name_map).find(terms[i]) != (*term_name_map).end()); repr += " " + (*term_name_map)[terms[i]]; } repr += ")"; + cout << "repr" << endl; + cout << repr << endl; Term term = std::make_shared(sort, op, terms, repr); Term stored_term = store_term(term); return stored_term; diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index d66da1bac..e672e59e5 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -17,7 +17,6 @@ #include #include - #include "assert.h" #include "generic_datatype.h" #include "utils.h" @@ -130,11 +129,9 @@ Sort make_generic_sort(Datatype & dt) GenericSort::GenericSort(SortKind sk) : sk(sk) {} -GenericSort::GenericSort(SortKind sk, std::string sort_name) : sk(sk) {} - // Only used to make placeholder sorts for datatypes when the // sort is the datatype itself but the sort hasn't been constructed. -GenericSort::GenericSort(std::string name) : sk(DATATYPE), base_name(name) {} +GenericSort::GenericSort(std::string name) : sk(DATATYPE) {} GenericSort::~GenericSort() {} @@ -187,7 +184,7 @@ string GenericSort::compute_string() const { } else if (get_sort_kind() == SortKind::DATATYPE) { - return base_name; + return static_pointer_cast(get_datatype())->get_name(); } else { @@ -198,7 +195,6 @@ string GenericSort::compute_string() const { SortKind GenericSort::get_sort_kind() const { return sk; } -std::string GenericSort::get_base_name() const { return base_name; } bool GenericSort::compare(const Sort & s) const { @@ -253,7 +249,7 @@ bool GenericSort::compare(const Sort & s) const assert(sk == DATATYPE); shared_ptr other_type_cast = static_pointer_cast(s); - return base_name == other_type_cast->compute_string(); + return static_pointer_cast(get_datatype())->get_name() == other_type_cast->compute_string(); } case NUM_SORT_KINDS: { @@ -351,22 +347,15 @@ SortVec UninterpretedGenericSort::get_uninterpreted_param_sorts() const GenericDatatypeSort::GenericDatatypeSort(const Datatype & dt) : GenericSort(DATATYPE), gdt(dt) { - GenericSort::base_name = - (static_pointer_cast(dt))->get_name(); } GenericDatatypeSort::~GenericDatatypeSort() {} -std::string GenericDatatypeSort::get_sort_name() -{ - return GenericSort::base_name; -} - Datatype GenericDatatypeSort::get_datatype() const { return gdt; } -string GenericDatatypeSort::compute_string() const + std::string GenericDatatypeSort::compute_string() const { - return GenericSort::base_name; + return static_pointer_cast(gdt)->get_name(); } bool GenericDatatypeSort::compare(const Sort & s) const @@ -382,4 +371,5 @@ std::string GenericDatatypeSort::to_string() const { return this->compute_string(); } + } // namespace smt diff --git a/tests/test-generic-sort.cpp b/tests/test-generic-sort.cpp index d06739fc4..d3c7b90a6 100644 --- a/tests/test-generic-sort.cpp +++ b/tests/test-generic-sort.cpp @@ -70,7 +70,8 @@ int main() assert(us1 != us3); assert(us1->get_uninterpreted_name() == "sort1"); assert(us1->get_arity() == 0); - cout << "pre datatype" << endl; + + // Creates a new datatype with one constructor DatatypeDecl new_dt_decl = make_shared("testSort1"); shared_ptr new_dt = shared_ptr(new GenericDatatype(new_dt_decl)); @@ -81,6 +82,7 @@ int main() shared_ptr dt_sort = make_shared(new_dt); + // Creates a different datatype with one constructor DatatypeDecl new2_dt_decl = make_shared("testSort2"); shared_ptr new2_dt = shared_ptr(new GenericDatatype(new2_dt_decl)); @@ -88,15 +90,16 @@ int main() shared_ptr( new GenericDatatypeConstructorDecl("test2")); new2_dt->add_constructor(new2_dt_cons_decl); - shared_ptr dt_sort2 = make_shared(new2_dt); + // Asserts that the sorts are distinct from one another and that the + // copy operator works with said sorts assert(dt_sort != dt_sort2); auto copy = dt_sort; assert(dt_sort == copy); - cout << dt_sort->compute_string() << endl; - cout << dt_sort2->compute_string() << endl; + // Compares string names of the sorts assert(dt_sort->to_string() != dt_sort2->to_string()); + // Checks for valid sortKinds assert((dt_sort->get_sort_kind()) == (dt_sort2->get_sort_kind())); assert(dt_sort->get_sort_kind() == DATATYPE); assert(dt_sort2->get_sort_kind() == DATATYPE); From f212c0228bb630daf0d42424e8d497ef7a8c9995 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Wed, 21 Jul 2021 14:58:42 -0700 Subject: [PATCH 29/47] New branch --- include/sort_inference.h | 5 +++++ src/sort_inference.cpp | 40 ++++++++++++++++++++++++++++++++++++++-- tests/test-dt.cpp | 30 +++++++++++++++++++++++------- 3 files changed, 66 insertions(+), 9 deletions(-) diff --git a/include/sort_inference.h b/include/sort_inference.h index 27bbd240b..f1d6d7870 100644 --- a/include/sort_inference.h +++ b/include/sort_inference.h @@ -156,6 +156,11 @@ bool check_select_sorts(const SortVec & sorts); * @param returns true iff the first sort is an array sort * and the next two match the index and element sort */ + + bool check_selector_sorts(const SortVec & sorts); + bool check_constructor_sorts(const SortVec & sorts); + bool check_tester_sorts(const SortVec & sorts); + bool check_store_sorts(const SortVec & sorts); bool bool_sorts(const SortVec & sorts); diff --git a/src/sort_inference.cpp b/src/sort_inference.cpp index 33230f914..99c73d1d4 100644 --- a/src/sort_inference.cpp +++ b/src/sort_inference.cpp @@ -96,7 +96,10 @@ const std::unordered_map> { Select, check_select_sorts }, { Store, check_store_sorts }, { Forall, check_quantifier_sorts }, - { Exists, check_quantifier_sorts } + { Exists, check_quantifier_sorts }, + {Apply_Constructor, check_constructor_sorts }, + {Apply_Selector, check_selector_sorts }, + {Apply_Tester, check_tester_sorts } }); @@ -174,7 +177,10 @@ const std::unordered_map< { Select, select_sort }, { Store, store_sort }, { Forall, bool_sort }, - { Exists, bool_sort } + { Exists, bool_sort }, + {Apply_Constructor, bool_sort }, + {Apply_Tester, bool_sort }, + {Apply_Selector, bool_sort }, }); // main function implementations @@ -227,6 +233,7 @@ Sort compute_sort(Op op, const AbsSmtSolver * solver, const TermVec & terms) { sorts.push_back(t->get_sort()); } + cout << "made sort vec" << endl; return sort_comp_dispatch.at(op.prim_op)(op, solver, sorts); } @@ -368,6 +375,35 @@ bool check_select_sorts(const SortVec & sorts) return true; } + bool check_selector_sorts(const SortVec & sorts) + { + assert(sorts.size()); + if (sorts.size() != 1) + { + return false; + } + + Sort dt_sort = sorts[0]; + if (dt_sort->get_sort_kind() != DATATYPE) + { + return false; + } + return true; + + } + // TO DO!!! DO THIS LATER + bool check_constructor_sorts(const SortVec & sorts) + { + return true; + } + + // TO DO!!! DO THIS LATER + bool check_tester_sorts(const SortVec & sorts) + { + return true; + } + + bool check_store_sorts(const SortVec & sorts) { assert(sorts.size()); diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index fda1829c1..d43ceff9a 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -84,6 +84,18 @@ TEST_P(DTTests, DatatypeDecl) DatatypeConstructorDecl countercons = s->make_datatype_constructor_decl("countercons"); s->add_constructor(counterdecl, countercons); + + DatatypeConstructorDecl nonAddCons = s->make_datatype_constructor_decl("nonAddCons"); + shared_ptr newSelector = + make_shared(); + newSelector->name = "nonaddselector"; + newSelector->sort = s->make_sort(INT); + shared_ptr nonAddDT = make_shared(consListSpec); + EXPECT_THROW(nonAddDT->add_selector(nonAddCons, *newSelector), InternalSolverException); + + + + Sort countersort = s->make_sort(counterdecl); assert(countersort->get_sort_kind() == DATATYPE); @@ -92,25 +104,27 @@ TEST_P(DTTests, DatatypeDecl) Datatype listdt = listsort->get_datatype(); - if (s->get_solver_enum() != GENERIC_SOLVER) - { + //if (s->get_solver_enum() != GENERIC_SOLVER) + // { Term five = s->make_term(5, intsort); // Make datatype terms Term cons = s->get_constructor(listsort, "cons"); assert("cons" == cons->to_string()); Term nil = s->get_constructor(listsort, "nil"); - Term head = s->get_selector(listsort, "cons", "head"); + //Term head = s->get_selector(listsort, "cons", "head"); - Term tail = s->get_selector(listsort, "cons", "tail"); + //Term tail = s->get_selector(listsort, "cons", "tail"); Term isNil = s->get_tester(listsort, "nil"); // Datatype ops Term nilterm = s->make_term(Apply_Constructor, nil); + if (s->get_solver_enum() != GENERIC_SOLVER) + { Term list5 = s->make_term(Apply_Constructor, cons, five, nilterm); - Term five_again = s->make_term(Apply_Selector, head, list5); - + //Term five_again = s->make_term(Apply_Selector, head, list5); + /* // Expected booleans s->assert_formula(s->make_term(Equal, five, five_again)); s->assert_formula(s->make_term(Apply_Tester, isNil, nilterm)); @@ -131,7 +145,9 @@ TEST_P(DTTests, DatatypeDecl) EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); EXPECT_THROW(s->get_selector(listsort, "nil", "head"), InternalSolverException); - EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); + EXPECT_THROW(listdt->get_num_selectors("kons"), + InternalSolverException); + */ } } From 013a0edababaa6498a53d1754f65cbdb0273a1d5 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Thu, 22 Jul 2021 17:28:08 -0700 Subject: [PATCH 30/47] test --- tests/test-dt.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index d43ceff9a..38e847b73 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -111,6 +111,12 @@ TEST_P(DTTests, DatatypeDecl) Term cons = s->get_constructor(listsort, "cons"); assert("cons" == cons->to_string()); Term nil = s->get_constructor(listsort, "nil"); + cout << "nil sort\n" << nil->get_sort() << endl; + cout << "nil sort kind: " << nil->get_sort()->get_sort_kind() << endl; + cout << "list sort: \n" << listsort << endl; + cout << "list sort kind: " << listsort->get_sort_kind() << endl; + assert(nil->get_sort() == listsort); + cout << "CORRECR SORT hypothesis" << endl; //Term head = s->get_selector(listsort, "cons", "head"); //Term tail = s->get_selector(listsort, "cons", "tail"); From 84fdf16e680d5403964b0dd797232bf0da9f507d Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 23 Jul 2021 10:39:12 -0700 Subject: [PATCH 31/47] functionality changes --- include/sort.h | 1 + include/sorting_network.h | 1 - src/generic_solver.cpp | 5 ++++- 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/include/sort.h b/include/sort.h index 5dc3885b9..180153073 100644 --- a/include/sort.h +++ b/include/sort.h @@ -44,6 +44,7 @@ enum SortKind // arguments) UNINTERPRETED_CONS, DATATYPE, + CONSTRUCTOR, /** IMPORTANT: This must stay at the bottom. It's only use is for sizing the kind2str array diff --git a/include/sorting_network.h b/include/sorting_network.h index 0c724722b..90195e829 100644 --- a/include/sorting_network.h +++ b/include/sorting_network.h @@ -91,7 +91,6 @@ class SortingNetwork * @return the combined vector */ TermVec merge(const TermVec & sorted1, const TermVec & sorted2) const; - }; } // namespace smt diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 2d75c375a..0fd603330 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -613,7 +613,10 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s Term GenericSolver::get_constructor(const Sort & s, std::string name) const { - throw NotImplementedException("Generic Solvers do not support datatypes"); + Term new_term = std::make_shared(s, Op(), TermVec{}, name, true); + (*name_term_map)[name] = new_term; + (*term_name_map)[new_term] = name; + return (*name_term_map)[name]; } From ea37bbc9787bf4aae5b8c1898f4fe394a6f49703 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 23 Jul 2021 21:41:33 -0700 Subject: [PATCH 32/47] Working get_constructor, tester functions. I'm struggling with how to go forward with the sort_inference stuff. --- cvc4/src/cvc4_sort.cpp | 4 ++++ include/generic_sort.h | 15 +++++++++++++++ include/sort.h | 1 + src/generic_solver.cpp | 20 ++++++++++++++++++-- src/generic_sort.cpp | 35 ++++++++++++++++++++++++++++++++++- src/sort_inference.cpp | 11 +++++++++++ tests/test-dt.cpp | 1 - 7 files changed, 83 insertions(+), 4 deletions(-) diff --git a/cvc4/src/cvc4_sort.cpp b/cvc4/src/cvc4_sort.cpp index d53991815..cc78859bc 100644 --- a/cvc4/src/cvc4_sort.cpp +++ b/cvc4/src/cvc4_sort.cpp @@ -155,6 +155,10 @@ SortKind CVC4Sort::get_sort_kind() const { return DATATYPE; } + else if (sort.isConstructor()) + { + return CONSTRUCTOR; + } else { throw NotImplementedException("Unknown kind in CVC4 translation."); diff --git a/include/generic_sort.h b/include/generic_sort.h index 96e48a161..91160bb7e 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -36,6 +36,7 @@ Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2); Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2, Sort sort3); Sort make_generic_sort(SortKind sk, SortVec sorts); Sort make_generic_sort(Datatype dt); + Sort make_generic_sort(SortKind sk, std::string cons_name); /* smtlib representation of sort kinds */ std::string to_smtlib(SortKind); @@ -208,4 +209,18 @@ class GenericDatatypeSort : public GenericSort Datatype gdt; }; + class DatatypeComponentSort : public GenericSort + { + public: + DatatypeComponentSort(SortKind sk, std::string name); + ~DatatypeComponentSort(){}; + std::string compute_string() const override; + std::string to_string() const override; + std::string get_uninterpreted_name() const override; + + protected: + std::string name; + }; + + } // namespace smt diff --git a/include/sort.h b/include/sort.h index 180153073..63aa88424 100644 --- a/include/sort.h +++ b/include/sort.h @@ -45,6 +45,7 @@ enum SortKind UNINTERPRETED_CONS, DATATYPE, CONSTRUCTOR, + SELECTOR, /** IMPORTANT: This must stay at the bottom. It's only use is for sizing the kind2str array diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 0fd603330..0dd2cf5d4 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -613,7 +613,18 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s Term GenericSolver::get_constructor(const Sort & s, std::string name) const { - Term new_term = std::make_shared(s, Op(), TermVec{}, name, true); + shared_ptr dt = static_pointer_cast(s->get_datatype()); + bool found = false; + for (int i = 0; i < dt->get_num_constructors(); ++i) { + if (static_pointer_cast(dt->get_cons_vector()[i])->get_name() == name) { + found = true; + } + } + if (!found) { + throw "Constructor not in datatype"; + } + Sort cons_sort = make_generic_sort(CONSTRUCTOR, name); + Term new_term = std::make_shared(cons_sort, Op(), TermVec{}, name, true); (*name_term_map)[name] = new_term; (*term_name_map)[new_term] = name; return (*name_term_map)[name]; @@ -623,7 +634,12 @@ Term GenericSolver::get_constructor(const Sort & s, std::string name) const Term GenericSolver::get_tester(const Sort & s, std::string name) const { - throw NotImplementedException("Generic Solvers do not support datatypes"); + Sort cons_sort = make_generic_sort(SELECTOR, name); + Term new_term = std::make_shared(cons_sort, Op(), TermVec{}, name, true); + (*name_term_map)[name] = new_term; + (*term_name_map)[new_term] = name; + return (*name_term_map)[name]; + } diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index e672e59e5..15f5e347c 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -124,7 +124,11 @@ Sort make_generic_sort(Datatype & dt) { return make_shared(dt); } - + Sort make_generic_sort(SortKind sk, std::string cons_name) + { + return make_shared(sk, cons_name); + } + // implementations GenericSort::GenericSort(SortKind sk) : sk(sk) {} @@ -186,6 +190,11 @@ string GenericSort::compute_string() const { { return static_pointer_cast(get_datatype())->get_name(); } + else if (get_sort_kind() == SortKind::CONSTRUCTOR || get_sort_kind() == SortKind::SELECTOR) + { + cout << "in comptue" << endl; + return get_uninterpreted_name(); + } else { assert(false); @@ -372,4 +381,28 @@ std::string GenericDatatypeSort::to_string() const return this->compute_string(); } + DatatypeComponentSort::DatatypeComponentSort(SortKind sk, std::string name) : + GenericSort(sk), + name(name) + { + if (sk != CONSTRUCTOR && sk != SELECTOR) { + throw "Wrong sortkind input"; + } + } + std::string DatatypeComponentSort::compute_string() const + { + return name; + } + + std::string DatatypeComponentSort::to_string() const + { + return compute_string(); + } + + std::string DatatypeComponentSort::get_uninterpreted_name() const + { + return name; + } + + } // namespace smt diff --git a/src/sort_inference.cpp b/src/sort_inference.cpp index 99c73d1d4..f92043845 100644 --- a/src/sort_inference.cpp +++ b/src/sort_inference.cpp @@ -572,4 +572,15 @@ Sort store_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) return arraysort; } + Sort selector_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) + { + return sorts[0]; + } + Sort constructor_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) + { + return sorts[0]; + + } + + } // namespace smt diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 38e847b73..d43667e16 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -115,7 +115,6 @@ TEST_P(DTTests, DatatypeDecl) cout << "nil sort kind: " << nil->get_sort()->get_sort_kind() << endl; cout << "list sort: \n" << listsort << endl; cout << "list sort kind: " << listsort->get_sort_kind() << endl; - assert(nil->get_sort() == listsort); cout << "CORRECR SORT hypothesis" << endl; //Term head = s->get_selector(listsort, "cons", "head"); From e4f86bb0b81998b02a2621bb6642d25390c07540 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Wed, 28 Jul 2021 15:19:59 -0700 Subject: [PATCH 33/47] Fully functioning representation of datatype components as terms --- include/generic_sort.h | 11 ++++- include/sort.h | 1 + include/sort_inference.h | 5 ++- src/generic_datatype.cpp | 6 ++- src/generic_solver.cpp | 80 ++++++++++++++++++++++++++++--------- src/generic_sort.cpp | 40 ++++++++++++++++--- src/ops.cpp | 2 +- src/sort_inference.cpp | 23 +++++++---- tests/test-dt.cpp | 36 ++++++++--------- tests/test-generic-sort.cpp | 2 +- 10 files changed, 150 insertions(+), 56 deletions(-) diff --git a/include/generic_sort.h b/include/generic_sort.h index 91160bb7e..b904ee258 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -36,7 +36,7 @@ Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2); Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2, Sort sort3); Sort make_generic_sort(SortKind sk, SortVec sorts); Sort make_generic_sort(Datatype dt); - Sort make_generic_sort(SortKind sk, std::string cons_name); + Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt); /* smtlib representation of sort kinds */ std::string to_smtlib(SortKind); @@ -212,14 +212,21 @@ class GenericDatatypeSort : public GenericSort class DatatypeComponentSort : public GenericSort { public: - DatatypeComponentSort(SortKind sk, std::string name); + DatatypeComponentSort(SortKind sk, std::string name, Sort dt); ~DatatypeComponentSort(){}; std::string compute_string() const override; std::string to_string() const override; std::string get_uninterpreted_name() const override; + SortVec get_domain_sorts() const override; + Sort get_selector_sort() const; + void set_selector_sort(Sort new_selector_sort); + int get_num_selectors() const; + Datatype get_datatype() const override; protected: std::string name; + Sort dt_sort; + Sort selector_sort; }; diff --git a/include/sort.h b/include/sort.h index 63aa88424..f291bae12 100644 --- a/include/sort.h +++ b/include/sort.h @@ -46,6 +46,7 @@ enum SortKind DATATYPE, CONSTRUCTOR, SELECTOR, + TESTER, /** IMPORTANT: This must stay at the bottom. It's only use is for sizing the kind2str array diff --git a/include/sort_inference.h b/include/sort_inference.h index f1d6d7870..ef04f3bf8 100644 --- a/include/sort_inference.h +++ b/include/sort_inference.h @@ -21,7 +21,7 @@ #include "assert.h" #include "ops.h" #include "solver.h" -#include "sort.h" +#include "generic_sort.h" #include "term.h" namespace smt { @@ -208,6 +208,9 @@ Sort apply_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); Sort select_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); Sort store_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); + Sort selector_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); + Sort tester_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); + Sort constructor_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); } // namespace smt diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 55e733f63..5bbde1c5b 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -133,6 +133,7 @@ int GenericDatatype::get_num_selectors(std::string cons) const { // Used to keep track of the number of selectors in the constructor int num_selectors = 0; + bool found = false; for (unsigned int i = 0; i < cons_decl_vector.size(); ++i) // Searches for a matching constructor { @@ -140,13 +141,16 @@ int GenericDatatype::get_num_selectors(std::string cons) const ->get_name() == cons) { + found = true; // Calls the constructor's get_selector_count() function num_selectors = static_pointer_cast( cons_decl_vector[i]) ->get_selector_count(); } } - // Returns 0 if the constructor was not found + if (!found) { + throw InternalSolverException("Constructor not found"); + } return num_selectors; } diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 0dd2cf5d4..f088f136e 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -314,10 +314,6 @@ void GenericSolver::define_fun(std::string name, // (like define-const) assert(args_sorts.size() == 0); assert(sort_name_map->find(res_sort) != sort_name_map->end()); - cout << "command sent:" << endl; - cout << "(" + DEFINE_FUN_STR + " " + name + " () " - + (*sort_name_map)[res_sort] + " " + to_smtlib_def(defining_term) - + ")" << endl; // send a define-fun to the binary run_command("(" + DEFINE_FUN_STR + " " + name + " () " + (*sort_name_map)[res_sort] + " " + to_smtlib_def(defining_term) @@ -337,11 +333,26 @@ std::string GenericSolver::to_smtlib_def(Term term) const else { // generic terms with operators are written as s-expressions. - string result = "("; + string result; + if (gt->get_op() == Apply_Constructor) { + shared_ptr dt = static_pointer_cast((gt->get_sort())->get_datatype()); + result = dt->get_num_selectors((*term_name_map)[gt->get_children()[0]]) ? "(" : ""; + } + else if (gt->get_op() == Apply_Tester) { + result = "((_ is "; + result += (*term_name_map)[gt->get_children()[0]]; + result += ") "; + result += (*term_name_map)[gt->get_children()[1]]; + result += ")"; + return result; + } + else { + result = "("; + } // The Apply operator is ignored and the // function being applied is used instead. result += - ((term->get_op().prim_op == Apply) ? "" : term->get_op().to_string()); + ((term->get_op().prim_op == Apply || term->get_op().prim_op == Apply_Constructor || term->get_op().prim_op == Apply_Selector || term->get_op().prim_op == Apply_Tester) ? "" : term->get_op().to_string()); // For quantifiers we separate the bound variables list // and the formula body. if (term->get_op().prim_op == Forall || term->get_op().prim_op == Exists) @@ -361,7 +372,13 @@ std::string GenericSolver::to_smtlib_def(Term term) const result += " " + (*term_name_map)[c]; } } - result += ")"; + if (gt->get_op() == Apply_Constructor) { + shared_ptr dt = static_pointer_cast((gt->get_sort())->get_datatype()); + result += dt->get_num_selectors((*term_name_map)[gt->get_children()[0]]) ? ")" : ""; + } + else { + result += ")"; + } return result; } } @@ -621,9 +638,9 @@ Term GenericSolver::get_constructor(const Sort & s, std::string name) const } } if (!found) { - throw "Constructor not in datatype"; + throw InternalSolverException("Constructor not in datatype"); } - Sort cons_sort = make_generic_sort(CONSTRUCTOR, name); + Sort cons_sort = make_generic_sort(CONSTRUCTOR, name, s); Term new_term = std::make_shared(cons_sort, Op(), TermVec{}, name, true); (*name_term_map)[name] = new_term; (*term_name_map)[new_term] = name; @@ -634,7 +651,18 @@ Term GenericSolver::get_constructor(const Sort & s, std::string name) const Term GenericSolver::get_tester(const Sort & s, std::string name) const { - Sort cons_sort = make_generic_sort(SELECTOR, name); + shared_ptr dt = static_pointer_cast(s->get_datatype()); + bool found = false; + for (int i = 0; i < dt->get_num_constructors(); ++i) { + if (static_pointer_cast(dt->get_cons_vector()[i])->get_name() == name) { + found = true; + } + } + if (!found) { + throw InternalSolverException("Constructor not in datatype"); + } + + Sort cons_sort = make_generic_sort(TESTER, name, s); Term new_term = std::make_shared(cons_sort, Op(), TermVec{}, name, true); (*name_term_map)[name] = new_term; (*term_name_map)[new_term] = name; @@ -645,7 +673,30 @@ Term GenericSolver::get_tester(const Sort & s, std::string name) const Term GenericSolver::get_selector(const Sort & s, std::string con, std::string name) const { - throw NotImplementedException("Generic Solvers do not support datatypes"); + shared_ptr dt = static_pointer_cast(s->get_datatype()); + bool found = false; + Sort cons_sort = make_generic_sort(SELECTOR, name, s); + for (int i = 0; i < dt->get_num_constructors(); ++i) { + shared_ptr curr_con = static_pointer_cast(dt->get_cons_vector()[i]); + if (curr_con->get_name() == con) { + for (int f = 0; f < curr_con->get_selector_count(); ++f) { + if (((curr_con->get_selector_vector())[f]).name == name) { + found = true; + static_pointer_cast(cons_sort)->set_selector_sort(((curr_con->get_selector_vector())[f]).sort); + } + } + } + } + if (!found) { + throw InternalSolverException("Selector not in datatype"); + } + + //Sort cons_sort = make_generic_sort(SELECTOR, name, s); + Term new_term = std::make_shared(cons_sort, Op(), TermVec{}, name, true); + (*name_term_map)[name] = new_term; + (*term_name_map)[new_term] = name; + return (*name_term_map)[name]; + } @@ -682,9 +733,6 @@ Term GenericSolver::store_term(Term term) const if (gterm->is_ground()) { name = get_name(gterm); - cout << "print ground name" << endl; - cout << name << endl; - cout << gterm->get_sort()->to_string() << endl; define_fun(name, SortVec{}, gterm->get_sort(), gterm); } else @@ -910,9 +958,7 @@ Term GenericSolver::make_term(const Op op, Term GenericSolver::make_term(const Op op, const TermVec & terms) const { - cout << "pre compute sort" << endl; Sort sort = compute_sort(op, this, terms); - cout << "post compute sort" << endl; string repr = "(" + op.to_string(); for (int i = 0; i < terms.size(); i++) { @@ -920,8 +966,6 @@ Term GenericSolver::make_term(const Op op, const TermVec & terms) const repr += " " + (*term_name_map)[terms[i]]; } repr += ")"; - cout << "repr" << endl; - cout << repr << endl; Term term = std::make_shared(sort, op, terms, repr); Term stored_term = store_term(term); return stored_term; diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 15f5e347c..944eff891 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -124,9 +124,9 @@ Sort make_generic_sort(Datatype & dt) { return make_shared(dt); } - Sort make_generic_sort(SortKind sk, std::string cons_name) + Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt) { - return make_shared(sk, cons_name); + return make_shared(sk, cons_name, dt); } // implementations @@ -190,7 +190,7 @@ string GenericSort::compute_string() const { { return static_pointer_cast(get_datatype())->get_name(); } - else if (get_sort_kind() == SortKind::CONSTRUCTOR || get_sort_kind() == SortKind::SELECTOR) + else if (get_sort_kind() == SortKind::CONSTRUCTOR || get_sort_kind() == SortKind::SELECTOR || get_sort_kind() == SortKind::TESTER) { cout << "in comptue" << endl; return get_uninterpreted_name(); @@ -381,11 +381,12 @@ std::string GenericDatatypeSort::to_string() const return this->compute_string(); } - DatatypeComponentSort::DatatypeComponentSort(SortKind sk, std::string name) : + DatatypeComponentSort::DatatypeComponentSort(SortKind sk, std::string name, Sort dt) : GenericSort(sk), - name(name) + name(name), + dt_sort(dt) { - if (sk != CONSTRUCTOR && sk != SELECTOR) { + if (sk != CONSTRUCTOR && sk != SELECTOR && sk != TESTER) { throw "Wrong sortkind input"; } } @@ -404,5 +405,32 @@ std::string GenericDatatypeSort::to_string() const return name; } + SortVec DatatypeComponentSort::get_domain_sorts() const + { + std::vector domain_sorts; + domain_sorts.push_back(dt_sort); + return domain_sorts; + } + + Sort DatatypeComponentSort::get_selector_sort() const + { + return selector_sort; + } + + void DatatypeComponentSort::set_selector_sort(Sort new_selector_sort) + { + selector_sort = new_selector_sort; + } + + int DatatypeComponentSort::get_num_selectors() const + { + shared_ptr dt = static_pointer_cast(dt_sort->get_datatype()); + return dt->get_num_selectors(name); + } + + Datatype DatatypeComponentSort::get_datatype() const + { + return dt_sort->get_datatype(); + } } // namespace smt diff --git a/src/ops.cpp b/src/ops.cpp index 340bc2e4b..c19489b41 100644 --- a/src/ops.cpp +++ b/src/ops.cpp @@ -91,7 +91,7 @@ const std::unordered_map primop2str( { Exists, "exists" }, { Apply_Selector, "apply_selector" }, { Apply_Tester, "apply_tester" }, - { Apply_Constructor, "apply_constructor" } }); + { Apply_Constructor, "apply_selector" } }); // a map from PrimOp to // TODO: support INT_MAX arity for those that allow it in SMT-LIB diff --git a/src/sort_inference.cpp b/src/sort_inference.cpp index f92043845..03262a1ee 100644 --- a/src/sort_inference.cpp +++ b/src/sort_inference.cpp @@ -178,9 +178,9 @@ const std::unordered_map< { Store, store_sort }, { Forall, bool_sort }, { Exists, bool_sort }, - {Apply_Constructor, bool_sort }, + {Apply_Constructor, constructor_sort }, {Apply_Tester, bool_sort }, - {Apply_Selector, bool_sort }, + {Apply_Selector, selector_sort }, }); // main function implementations @@ -233,7 +233,6 @@ Sort compute_sort(Op op, const AbsSmtSolver * solver, const TermVec & terms) { sorts.push_back(t->get_sort()); } - cout << "made sort vec" << endl; return sort_comp_dispatch.at(op.prim_op)(op, solver, sorts); } @@ -574,13 +573,21 @@ Sort store_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) Sort selector_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) { - return sorts[0]; + Sort parent_sort = (sorts[0])->get_domain_sorts()[0]; + //shared_ptr dt = + //static_pointer_cast(parent_sort->get_datatype()); + return static_pointer_cast(sorts[0])->get_selector_sort(); + } Sort constructor_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) { - return sorts[0]; - + return (sorts[0])->get_domain_sorts()[0]; } - - + Sort tester_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) + { + return solver->make_sort(BOOL); + } + + + } // namespace smt diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index d43667e16..702a0b387 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -104,37 +104,34 @@ TEST_P(DTTests, DatatypeDecl) Datatype listdt = listsort->get_datatype(); - //if (s->get_solver_enum() != GENERIC_SOLVER) - // { Term five = s->make_term(5, intsort); // Make datatype terms Term cons = s->get_constructor(listsort, "cons"); assert("cons" == cons->to_string()); Term nil = s->get_constructor(listsort, "nil"); - cout << "nil sort\n" << nil->get_sort() << endl; - cout << "nil sort kind: " << nil->get_sort()->get_sort_kind() << endl; - cout << "list sort: \n" << listsort << endl; - cout << "list sort kind: " << listsort->get_sort_kind() << endl; - cout << "CORRECR SORT hypothesis" << endl; - //Term head = s->get_selector(listsort, "cons", "head"); - //Term tail = s->get_selector(listsort, "cons", "tail"); + Term head = s->get_selector(listsort, "cons", "head"); - Term isNil = s->get_tester(listsort, "nil"); + Term tail = s->get_selector(listsort, "cons", "tail"); + Term isNil = s->get_tester(listsort, "nil"); + // Datatype ops - Term nilterm = s->make_term(Apply_Constructor, nil); - if (s->get_solver_enum() != GENERIC_SOLVER) - { Term list5 = s->make_term(Apply_Constructor, cons, five, nilterm); - //Term five_again = s->make_term(Apply_Selector, head, list5); - /* + Term five_again = s->make_term(Apply_Selector, head, list5); + // Expected booleans + + s->assert_formula(s->make_term(Equal, five, five_again)); + s->assert_formula(s->make_term(Apply_Tester, isNil, nilterm)); + s->assert_formula( - s->make_term(Not, s->make_term(Apply_Tester, isNil, list5))); + s->make_term(Not, s->make_term(Apply_Tester, isNil, + list5))); + Result res = s->check_sat(); @@ -145,6 +142,7 @@ TEST_P(DTTests, DatatypeDecl) ASSERT_TRUE(res.is_sat()); // Expected exceptions + EXPECT_THROW(s->get_constructor(listsort, "kons"), InternalSolverException); EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); @@ -152,8 +150,10 @@ TEST_P(DTTests, DatatypeDecl) InternalSolverException); EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); - */ - } + + + + // } } INSTANTIATE_TEST_SUITE_P(ParameterizedSolverDTTests, diff --git a/tests/test-generic-sort.cpp b/tests/test-generic-sort.cpp index d3c7b90a6..db0d3a00b 100644 --- a/tests/test-generic-sort.cpp +++ b/tests/test-generic-sort.cpp @@ -71,7 +71,7 @@ int main() assert(us1->get_uninterpreted_name() == "sort1"); assert(us1->get_arity() == 0); - // Creates a new datatype with one constructor + // Creates a new datatype with one constructor DatatypeDecl new_dt_decl = make_shared("testSort1"); shared_ptr new_dt = shared_ptr(new GenericDatatype(new_dt_decl)); From 32791ac51523e9cbbf3765f4664617cfb21ae1bb Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Wed, 28 Jul 2021 15:22:20 -0700 Subject: [PATCH 34/47] Clang formatted --- include/generic_sort.h | 35 +++--- include/sort_inference.h | 18 +-- src/generic_datatype.cpp | 9 +- src/generic_solver.cpp | 118 +++++++++++++------- src/generic_sort.cpp | 109 +++++++++---------- src/sort_inference.cpp | 229 +++++++++++++++++++-------------------- tests/test-dt.cpp | 109 +++++++++---------- 7 files changed, 325 insertions(+), 302 deletions(-) diff --git a/include/generic_sort.h b/include/generic_sort.h index b904ee258..146406d15 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -36,7 +36,7 @@ Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2); Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2, Sort sort3); Sort make_generic_sort(SortKind sk, SortVec sorts); Sort make_generic_sort(Datatype dt); - Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt); +Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt); /* smtlib representation of sort kinds */ std::string to_smtlib(SortKind); @@ -209,25 +209,24 @@ class GenericDatatypeSort : public GenericSort Datatype gdt; }; - class DatatypeComponentSort : public GenericSort - { +class DatatypeComponentSort : public GenericSort +{ public: - DatatypeComponentSort(SortKind sk, std::string name, Sort dt); - ~DatatypeComponentSort(){}; - std::string compute_string() const override; - std::string to_string() const override; - std::string get_uninterpreted_name() const override; - SortVec get_domain_sorts() const override; - Sort get_selector_sort() const; - void set_selector_sort(Sort new_selector_sort); - int get_num_selectors() const; - Datatype get_datatype() const override; + DatatypeComponentSort(SortKind sk, std::string name, Sort dt); + ~DatatypeComponentSort(){}; + std::string compute_string() const override; + std::string to_string() const override; + std::string get_uninterpreted_name() const override; + SortVec get_domain_sorts() const override; + Sort get_selector_sort() const; + void set_selector_sort(Sort new_selector_sort); + int get_num_selectors() const; + Datatype get_datatype() const override; protected: - std::string name; - Sort dt_sort; - Sort selector_sort; - }; - + std::string name; + Sort dt_sort; + Sort selector_sort; +}; } // namespace smt diff --git a/include/sort_inference.h b/include/sort_inference.h index ef04f3bf8..32f67cbed 100644 --- a/include/sort_inference.h +++ b/include/sort_inference.h @@ -19,9 +19,9 @@ #include #include "assert.h" +#include "generic_sort.h" #include "ops.h" #include "solver.h" -#include "generic_sort.h" #include "term.h" namespace smt { @@ -157,10 +157,10 @@ bool check_select_sorts(const SortVec & sorts); * and the next two match the index and element sort */ - bool check_selector_sorts(const SortVec & sorts); - bool check_constructor_sorts(const SortVec & sorts); - bool check_tester_sorts(const SortVec & sorts); - +bool check_selector_sorts(const SortVec & sorts); +bool check_constructor_sorts(const SortVec & sorts); +bool check_tester_sorts(const SortVec & sorts); + bool check_store_sorts(const SortVec & sorts); bool bool_sorts(const SortVec & sorts); @@ -208,9 +208,11 @@ Sort apply_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); Sort select_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); Sort store_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); - Sort selector_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); - Sort tester_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); - Sort constructor_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); +Sort selector_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); +Sort tester_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts); +Sort constructor_sort(Op op, + const AbsSmtSolver * solver, + const SortVec & sorts); } // namespace smt diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index 5bbde1c5b..b6fdb6efe 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -110,8 +110,10 @@ void GenericDatatype::add_selector(const DatatypeConstructorDecl & dt_cons_decl, break; } } - if (!success) { - throw InternalSolverException("Can't add selector. The constructor is not a member of the datatype!"); + if (!success) + { + throw InternalSolverException( + "Can't add selector. The constructor is not a member of the datatype!"); } } std::vector GenericDatatype::get_cons_vector() @@ -148,7 +150,8 @@ int GenericDatatype::get_num_selectors(std::string cons) const ->get_selector_count(); } } - if (!found) { + if (!found) + { throw InternalSolverException("Constructor not found"); } return num_selectors; diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index f088f136e..73fa0ef17 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -334,11 +334,16 @@ std::string GenericSolver::to_smtlib_def(Term term) const { // generic terms with operators are written as s-expressions. string result; - if (gt->get_op() == Apply_Constructor) { - shared_ptr dt = static_pointer_cast((gt->get_sort())->get_datatype()); - result = dt->get_num_selectors((*term_name_map)[gt->get_children()[0]]) ? "(" : ""; + if (gt->get_op() == Apply_Constructor) + { + shared_ptr dt = static_pointer_cast( + (gt->get_sort())->get_datatype()); + result = dt->get_num_selectors((*term_name_map)[gt->get_children()[0]]) + ? "(" + : ""; } - else if (gt->get_op() == Apply_Tester) { + else if (gt->get_op() == Apply_Tester) + { result = "((_ is "; result += (*term_name_map)[gt->get_children()[0]]; result += ") "; @@ -346,13 +351,18 @@ std::string GenericSolver::to_smtlib_def(Term term) const result += ")"; return result; } - else { + else + { result = "("; } // The Apply operator is ignored and the // function being applied is used instead. - result += - ((term->get_op().prim_op == Apply || term->get_op().prim_op == Apply_Constructor || term->get_op().prim_op == Apply_Selector || term->get_op().prim_op == Apply_Tester) ? "" : term->get_op().to_string()); + result += ((term->get_op().prim_op == Apply + || term->get_op().prim_op == Apply_Constructor + || term->get_op().prim_op == Apply_Selector + || term->get_op().prim_op == Apply_Tester) + ? "" + : term->get_op().to_string()); // For quantifiers we separate the bound variables list // and the formula body. if (term->get_op().prim_op == Forall || term->get_op().prim_op == Exists) @@ -372,11 +382,16 @@ std::string GenericSolver::to_smtlib_def(Term term) const result += " " + (*term_name_map)[c]; } } - if (gt->get_op() == Apply_Constructor) { - shared_ptr dt = static_pointer_cast((gt->get_sort())->get_datatype()); - result += dt->get_num_selectors((*term_name_map)[gt->get_children()[0]]) ? ")" : ""; + if (gt->get_op() == Apply_Constructor) + { + shared_ptr dt = static_pointer_cast( + (gt->get_sort())->get_datatype()); + result += dt->get_num_selectors((*term_name_map)[gt->get_children()[0]]) + ? ")" + : ""; } - else { + else + { result += ")"; } return result; @@ -512,7 +527,7 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const // Exact functionality of make_genericsort, without the linking // errors (undefined reference when I call a new // make_generic_sort). - //Sort dt_sort = make_generic_sort(curr_dt); + // Sort dt_sort = make_generic_sort(curr_dt); Sort dt_sort = make_shared(curr_dt); // Replaces the sort of any selectors with a false finalized field // with dt_sort and sets finalized to true. @@ -630,74 +645,95 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s Term GenericSolver::get_constructor(const Sort & s, std::string name) const { - shared_ptr dt = static_pointer_cast(s->get_datatype()); + shared_ptr dt = + static_pointer_cast(s->get_datatype()); bool found = false; - for (int i = 0; i < dt->get_num_constructors(); ++i) { - if (static_pointer_cast(dt->get_cons_vector()[i])->get_name() == name) { + for (int i = 0; i < dt->get_num_constructors(); ++i) + { + if (static_pointer_cast( + dt->get_cons_vector()[i]) + ->get_name() + == name) + { found = true; } } - if (!found) { + if (!found) + { throw InternalSolverException("Constructor not in datatype"); } Sort cons_sort = make_generic_sort(CONSTRUCTOR, name, s); - Term new_term = std::make_shared(cons_sort, Op(), TermVec{}, name, true); + Term new_term = + std::make_shared(cons_sort, Op(), TermVec{}, name, true); (*name_term_map)[name] = new_term; (*term_name_map)[new_term] = name; return (*name_term_map)[name]; - } Term GenericSolver::get_tester(const Sort & s, std::string name) const { - shared_ptr dt = static_pointer_cast(s->get_datatype()); + shared_ptr dt = + static_pointer_cast(s->get_datatype()); bool found = false; - for (int i = 0; i < dt->get_num_constructors(); ++i) { - if (static_pointer_cast(dt->get_cons_vector()[i])->get_name() == name) { + for (int i = 0; i < dt->get_num_constructors(); ++i) + { + if (static_pointer_cast( + dt->get_cons_vector()[i]) + ->get_name() + == name) + { found = true; } } - if (!found) { + if (!found) + { throw InternalSolverException("Constructor not in datatype"); } - + Sort cons_sort = make_generic_sort(TESTER, name, s); - Term new_term = std::make_shared(cons_sort, Op(), TermVec{}, name, true); + Term new_term = + std::make_shared(cons_sort, Op(), TermVec{}, name, true); (*name_term_map)[name] = new_term; (*term_name_map)[new_term] = name; return (*name_term_map)[name]; - - } Term GenericSolver::get_selector(const Sort & s, std::string con, std::string name) const { - shared_ptr dt = static_pointer_cast(s->get_datatype()); + shared_ptr dt = + static_pointer_cast(s->get_datatype()); bool found = false; Sort cons_sort = make_generic_sort(SELECTOR, name, s); - for (int i = 0; i < dt->get_num_constructors(); ++i) { - shared_ptr curr_con = static_pointer_cast(dt->get_cons_vector()[i]); - if (curr_con->get_name() == con) { - for (int f = 0; f < curr_con->get_selector_count(); ++f) { - if (((curr_con->get_selector_vector())[f]).name == name) { - found = true; - static_pointer_cast(cons_sort)->set_selector_sort(((curr_con->get_selector_vector())[f]).sort); + for (int i = 0; i < dt->get_num_constructors(); ++i) + { + shared_ptr curr_con = + static_pointer_cast( + dt->get_cons_vector()[i]); + if (curr_con->get_name() == con) + { + for (int f = 0; f < curr_con->get_selector_count(); ++f) + { + if (((curr_con->get_selector_vector())[f]).name == name) + { + found = true; + static_pointer_cast(cons_sort) + ->set_selector_sort(((curr_con->get_selector_vector())[f]).sort); + } } } - } } - if (!found) { + if (!found) + { throw InternalSolverException("Selector not in datatype"); } - - //Sort cons_sort = make_generic_sort(SELECTOR, name, s); - Term new_term = std::make_shared(cons_sort, Op(), TermVec{}, name, true); + + // Sort cons_sort = make_generic_sort(SELECTOR, name, s); + Term new_term = + std::make_shared(cons_sort, Op(), TermVec{}, name, true); (*name_term_map)[name] = new_term; (*term_name_map)[new_term] = name; return (*name_term_map)[name]; - - } std::string GenericSolver::get_name(Term term) const diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 944eff891..3f7da9c87 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -124,11 +124,11 @@ Sort make_generic_sort(Datatype & dt) { return make_shared(dt); } - Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt) - { - return make_shared(sk, cons_name, dt); - } - +Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt) +{ + return make_shared(sk, cons_name, dt); +} + // implementations GenericSort::GenericSort(SortKind sk) : sk(sk) {} @@ -190,11 +190,13 @@ string GenericSort::compute_string() const { { return static_pointer_cast(get_datatype())->get_name(); } - else if (get_sort_kind() == SortKind::CONSTRUCTOR || get_sort_kind() == SortKind::SELECTOR || get_sort_kind() == SortKind::TESTER) - { - cout << "in comptue" << endl; - return get_uninterpreted_name(); - } + else if (get_sort_kind() == SortKind::CONSTRUCTOR + || get_sort_kind() == SortKind::SELECTOR + || get_sort_kind() == SortKind::TESTER) + { + cout << "in comptue" << endl; + return get_uninterpreted_name(); + } else { assert(false); @@ -258,7 +260,8 @@ bool GenericSort::compare(const Sort & s) const assert(sk == DATATYPE); shared_ptr other_type_cast = static_pointer_cast(s); - return static_pointer_cast(get_datatype())->get_name() == other_type_cast->compute_string(); + return static_pointer_cast(get_datatype())->get_name() + == other_type_cast->compute_string(); } case NUM_SORT_KINDS: { @@ -362,7 +365,7 @@ GenericDatatypeSort::~GenericDatatypeSort() {} Datatype GenericDatatypeSort::get_datatype() const { return gdt; } - std::string GenericDatatypeSort::compute_string() const +std::string GenericDatatypeSort::compute_string() const { return static_pointer_cast(gdt)->get_name(); } @@ -381,56 +384,52 @@ std::string GenericDatatypeSort::to_string() const return this->compute_string(); } - DatatypeComponentSort::DatatypeComponentSort(SortKind sk, std::string name, Sort dt) : - GenericSort(sk), - name(name), - dt_sort(dt) - { - if (sk != CONSTRUCTOR && sk != SELECTOR && sk != TESTER) { - throw "Wrong sortkind input"; - } - } - std::string DatatypeComponentSort::compute_string() const +DatatypeComponentSort::DatatypeComponentSort(SortKind sk, + std::string name, + Sort dt) + : GenericSort(sk), name(name), dt_sort(dt) +{ + if (sk != CONSTRUCTOR && sk != SELECTOR && sk != TESTER) { - return name; + throw "Wrong sortkind input"; } +} +std::string DatatypeComponentSort::compute_string() const { return name; } - std::string DatatypeComponentSort::to_string() const - { - return compute_string(); - } +std::string DatatypeComponentSort::to_string() const +{ + return compute_string(); +} - std::string DatatypeComponentSort::get_uninterpreted_name() const - { - return name; - } +std::string DatatypeComponentSort::get_uninterpreted_name() const +{ + return name; +} - SortVec DatatypeComponentSort::get_domain_sorts() const - { - std::vector domain_sorts; - domain_sorts.push_back(dt_sort); - return domain_sorts; - } +SortVec DatatypeComponentSort::get_domain_sorts() const +{ + std::vector domain_sorts; + domain_sorts.push_back(dt_sort); + return domain_sorts; +} - Sort DatatypeComponentSort::get_selector_sort() const - { - return selector_sort; - } +Sort DatatypeComponentSort::get_selector_sort() const { return selector_sort; } - void DatatypeComponentSort::set_selector_sort(Sort new_selector_sort) - { - selector_sort = new_selector_sort; - } +void DatatypeComponentSort::set_selector_sort(Sort new_selector_sort) +{ + selector_sort = new_selector_sort; +} - int DatatypeComponentSort::get_num_selectors() const - { - shared_ptr dt = static_pointer_cast(dt_sort->get_datatype()); - return dt->get_num_selectors(name); - } +int DatatypeComponentSort::get_num_selectors() const +{ + shared_ptr dt = + static_pointer_cast(dt_sort->get_datatype()); + return dt->get_num_selectors(name); +} + +Datatype DatatypeComponentSort::get_datatype() const +{ + return dt_sort->get_datatype(); +} - Datatype DatatypeComponentSort::get_datatype() const - { - return dt_sort->get_datatype(); - } - } // namespace smt diff --git a/src/sort_inference.cpp b/src/sort_inference.cpp index 03262a1ee..45f8fe1ad 100644 --- a/src/sort_inference.cpp +++ b/src/sort_inference.cpp @@ -96,10 +96,10 @@ const std::unordered_map> { Select, check_select_sorts }, { Store, check_store_sorts }, { Forall, check_quantifier_sorts }, - { Exists, check_quantifier_sorts }, - {Apply_Constructor, check_constructor_sorts }, - {Apply_Selector, check_selector_sorts }, - {Apply_Tester, check_tester_sorts } + { Exists, check_quantifier_sorts }, + { Apply_Constructor, check_constructor_sorts }, + { Apply_Selector, check_selector_sorts }, + { Apply_Tester, check_tester_sorts } }); @@ -109,79 +109,80 @@ const std::unordered_map< PrimOp, std::function< Sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts)>> - sort_comp_dispatch({ { And, bool_sort }, - { Or, bool_sort }, - { Xor, bool_sort }, - { Not, bool_sort }, - { Implies, bool_sort }, - { Ite, ite_sort }, - { Equal, bool_sort }, - { Distinct, bool_sort }, - { Apply, apply_sort }, - { Plus, same_sort }, - { Minus, same_sort }, - { Negate, same_sort }, - { Mult, same_sort }, - { Div, same_sort }, - { Lt, bool_sort }, - { Le, bool_sort }, - { Gt, bool_sort }, - { Ge, bool_sort }, - { Mod, int_sort }, - // technically Abs/Pow only defined for integers in - // SMT-LIB but not sure if that's true for all solvers - // might also be good to be forward looking - { Abs, same_sort }, - { Pow, same_sort }, - { IntDiv, int_sort }, - { To_Real, real_sort }, - { To_Int, int_sort }, - { Is_Int, bool_sort }, - { Concat, concat_sort }, - { Extract, extract_sort }, - { BVNot, same_sort }, - { BVNeg, same_sort }, - { BVAnd, same_sort }, - { BVOr, same_sort }, - { BVXor, same_sort }, - { BVNand, same_sort }, - { BVNor, same_sort }, - { BVXnor, same_sort }, - { BVAdd, same_sort }, - { BVSub, same_sort }, - { BVMul, same_sort }, - { BVUdiv, same_sort }, - { BVSdiv, same_sort }, - { BVUrem, same_sort }, - { BVSrem, same_sort }, - { BVSmod, same_sort }, - { BVShl, same_sort }, - { BVAshr, same_sort }, - { BVLshr, same_sort }, - { BVComp, single_bit_sort }, - { BVUlt, bool_sort }, - { BVUle, bool_sort }, - { BVUgt, bool_sort }, - { BVUge, bool_sort }, - { BVSlt, bool_sort }, - { BVSle, bool_sort }, - { BVSgt, bool_sort }, - { BVSge, bool_sort }, - { Zero_Extend, extend_sort }, - { Sign_Extend, extend_sort }, - { Repeat, repeat_sort }, - { Rotate_Left, same_sort }, - { Rotate_Right, same_sort }, - { BV_To_Nat, int_sort }, - { Int_To_BV, int_to_bv_sort }, - { Select, select_sort }, - { Store, store_sort }, - { Forall, bool_sort }, - { Exists, bool_sort }, - {Apply_Constructor, constructor_sort }, - {Apply_Tester, bool_sort }, - {Apply_Selector, selector_sort }, - }); + sort_comp_dispatch({ + { And, bool_sort }, + { Or, bool_sort }, + { Xor, bool_sort }, + { Not, bool_sort }, + { Implies, bool_sort }, + { Ite, ite_sort }, + { Equal, bool_sort }, + { Distinct, bool_sort }, + { Apply, apply_sort }, + { Plus, same_sort }, + { Minus, same_sort }, + { Negate, same_sort }, + { Mult, same_sort }, + { Div, same_sort }, + { Lt, bool_sort }, + { Le, bool_sort }, + { Gt, bool_sort }, + { Ge, bool_sort }, + { Mod, int_sort }, + // technically Abs/Pow only defined for integers in + // SMT-LIB but not sure if that's true for all solvers + // might also be good to be forward looking + { Abs, same_sort }, + { Pow, same_sort }, + { IntDiv, int_sort }, + { To_Real, real_sort }, + { To_Int, int_sort }, + { Is_Int, bool_sort }, + { Concat, concat_sort }, + { Extract, extract_sort }, + { BVNot, same_sort }, + { BVNeg, same_sort }, + { BVAnd, same_sort }, + { BVOr, same_sort }, + { BVXor, same_sort }, + { BVNand, same_sort }, + { BVNor, same_sort }, + { BVXnor, same_sort }, + { BVAdd, same_sort }, + { BVSub, same_sort }, + { BVMul, same_sort }, + { BVUdiv, same_sort }, + { BVSdiv, same_sort }, + { BVUrem, same_sort }, + { BVSrem, same_sort }, + { BVSmod, same_sort }, + { BVShl, same_sort }, + { BVAshr, same_sort }, + { BVLshr, same_sort }, + { BVComp, single_bit_sort }, + { BVUlt, bool_sort }, + { BVUle, bool_sort }, + { BVUgt, bool_sort }, + { BVUge, bool_sort }, + { BVSlt, bool_sort }, + { BVSle, bool_sort }, + { BVSgt, bool_sort }, + { BVSge, bool_sort }, + { Zero_Extend, extend_sort }, + { Sign_Extend, extend_sort }, + { Repeat, repeat_sort }, + { Rotate_Left, same_sort }, + { Rotate_Right, same_sort }, + { BV_To_Nat, int_sort }, + { Int_To_BV, int_to_bv_sort }, + { Select, select_sort }, + { Store, store_sort }, + { Forall, bool_sort }, + { Exists, bool_sort }, + { Apply_Constructor, constructor_sort }, + { Apply_Tester, bool_sort }, + { Apply_Selector, selector_sort }, + }); // main function implementations bool check_sortedness(Op op, const TermVec & terms) @@ -374,35 +375,27 @@ bool check_select_sorts(const SortVec & sorts) return true; } - bool check_selector_sorts(const SortVec & sorts) - { - assert(sorts.size()); - if (sorts.size() != 1) - { - return false; - } - - Sort dt_sort = sorts[0]; - if (dt_sort->get_sort_kind() != DATATYPE) - { - return false; - } - return true; - - } - // TO DO!!! DO THIS LATER - bool check_constructor_sorts(const SortVec & sorts) +bool check_selector_sorts(const SortVec & sorts) +{ + assert(sorts.size()); + if (sorts.size() != 1) { - return true; + return false; } - // TO DO!!! DO THIS LATER - bool check_tester_sorts(const SortVec & sorts) + Sort dt_sort = sorts[0]; + if (dt_sort->get_sort_kind() != DATATYPE) { - return true; + return false; } - - + return true; +} +// TO DO!!! DO THIS LATER +bool check_constructor_sorts(const SortVec & sorts) { return true; } + +// TO DO!!! DO THIS LATER +bool check_tester_sorts(const SortVec & sorts) { return true; } + bool check_store_sorts(const SortVec & sorts) { assert(sorts.size()); @@ -571,23 +564,21 @@ Sort store_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) return arraysort; } - Sort selector_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) - { - Sort parent_sort = (sorts[0])->get_domain_sorts()[0]; - //shared_ptr dt = - //static_pointer_cast(parent_sort->get_datatype()); - return static_pointer_cast(sorts[0])->get_selector_sort(); - - } - Sort constructor_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) - { - return (sorts[0])->get_domain_sorts()[0]; - } - Sort tester_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) - { - return solver->make_sort(BOOL); - } - - +Sort selector_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) +{ + Sort parent_sort = (sorts[0])->get_domain_sorts()[0]; + // shared_ptr dt = + // static_pointer_cast(parent_sort->get_datatype()); + return static_pointer_cast(sorts[0]) + ->get_selector_sort(); +} +Sort constructor_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) +{ + return (sorts[0])->get_domain_sorts()[0]; +} +Sort tester_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) +{ + return solver->make_sort(BOOL); +} } // namespace smt diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 702a0b387..d47af6d38 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -84,18 +84,18 @@ TEST_P(DTTests, DatatypeDecl) DatatypeConstructorDecl countercons = s->make_datatype_constructor_decl("countercons"); s->add_constructor(counterdecl, countercons); - - DatatypeConstructorDecl nonAddCons = s->make_datatype_constructor_decl("nonAddCons"); + + DatatypeConstructorDecl nonAddCons = + s->make_datatype_constructor_decl("nonAddCons"); shared_ptr newSelector = - make_shared(); + make_shared(); newSelector->name = "nonaddselector"; newSelector->sort = s->make_sort(INT); - shared_ptr nonAddDT = make_shared(consListSpec); - EXPECT_THROW(nonAddDT->add_selector(nonAddCons, *newSelector), InternalSolverException); - - + shared_ptr nonAddDT = + make_shared(consListSpec); + EXPECT_THROW(nonAddDT->add_selector(nonAddCons, *newSelector), + InternalSolverException); - Sort countersort = s->make_sort(counterdecl); assert(countersort->get_sort_kind() == DATATYPE); @@ -104,56 +104,49 @@ TEST_P(DTTests, DatatypeDecl) Datatype listdt = listsort->get_datatype(); - Term five = s->make_term(5, intsort); - // Make datatype terms - Term cons = s->get_constructor(listsort, "cons"); - assert("cons" == cons->to_string()); - Term nil = s->get_constructor(listsort, "nil"); - - Term head = s->get_selector(listsort, "cons", "head"); - - Term tail = s->get_selector(listsort, "cons", "tail"); - - Term isNil = s->get_tester(listsort, "nil"); - - // Datatype ops - Term nilterm = s->make_term(Apply_Constructor, nil); - Term list5 = s->make_term(Apply_Constructor, cons, five, nilterm); - Term five_again = s->make_term(Apply_Selector, head, list5); - - // Expected booleans - - - s->assert_formula(s->make_term(Equal, five, five_again)); - - s->assert_formula(s->make_term(Apply_Tester, isNil, nilterm)); - - s->assert_formula( - s->make_term(Not, s->make_term(Apply_Tester, isNil, - list5))); - - - Result res = s->check_sat(); - - ASSERT_TRUE(listdt->get_name() == "list"); - ASSERT_TRUE(listdt->get_num_constructors() == 2); - ASSERT_TRUE(listdt->get_num_selectors("cons") == 2); - ASSERT_TRUE(listdt->get_num_selectors("nil") == 0); - - ASSERT_TRUE(res.is_sat()); - // Expected exceptions - - EXPECT_THROW(s->get_constructor(listsort, "kons"), - InternalSolverException); - EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); - EXPECT_THROW(s->get_selector(listsort, "nil", "head"), - InternalSolverException); - EXPECT_THROW(listdt->get_num_selectors("kons"), - InternalSolverException); - - - - // } + Term five = s->make_term(5, intsort); + // Make datatype terms + Term cons = s->get_constructor(listsort, "cons"); + assert("cons" == cons->to_string()); + Term nil = s->get_constructor(listsort, "nil"); + + Term head = s->get_selector(listsort, "cons", "head"); + + Term tail = s->get_selector(listsort, "cons", "tail"); + + Term isNil = s->get_tester(listsort, "nil"); + + // Datatype ops + Term nilterm = s->make_term(Apply_Constructor, nil); + Term list5 = s->make_term(Apply_Constructor, cons, five, nilterm); + Term five_again = s->make_term(Apply_Selector, head, list5); + + // Expected booleans + + s->assert_formula(s->make_term(Equal, five, five_again)); + + s->assert_formula(s->make_term(Apply_Tester, isNil, nilterm)); + + s->assert_formula( + s->make_term(Not, s->make_term(Apply_Tester, isNil, list5))); + + Result res = s->check_sat(); + + ASSERT_TRUE(listdt->get_name() == "list"); + ASSERT_TRUE(listdt->get_num_constructors() == 2); + ASSERT_TRUE(listdt->get_num_selectors("cons") == 2); + ASSERT_TRUE(listdt->get_num_selectors("nil") == 0); + + ASSERT_TRUE(res.is_sat()); + // Expected exceptions + + EXPECT_THROW(s->get_constructor(listsort, "kons"), InternalSolverException); + EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); + EXPECT_THROW(s->get_selector(listsort, "nil", "head"), + InternalSolverException); + EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); + + // } } INSTANTIATE_TEST_SUITE_P(ParameterizedSolverDTTests, From cb59ed9050a0aa600f7a03927ae6473079c1e4e1 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Wed, 28 Jul 2021 16:32:26 -0700 Subject: [PATCH 35/47] Addtl. files to commit --- cvc4/src/cvc4_sort.cpp | 6 +++--- tests/test-dt.cpp | 2 -- tests/test-smtlib-reader.cpp | 1 + 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/cvc4/src/cvc4_sort.cpp b/cvc4/src/cvc4_sort.cpp index cc78859bc..7113be55f 100644 --- a/cvc4/src/cvc4_sort.cpp +++ b/cvc4/src/cvc4_sort.cpp @@ -156,9 +156,9 @@ SortKind CVC4Sort::get_sort_kind() const return DATATYPE; } else if (sort.isConstructor()) - { - return CONSTRUCTOR; - } + { + return CONSTRUCTOR; + } else { throw NotImplementedException("Unknown kind in CVC4 translation."); diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index d47af6d38..9ff558569 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -145,8 +145,6 @@ TEST_P(DTTests, DatatypeDecl) EXPECT_THROW(s->get_selector(listsort, "nil", "head"), InternalSolverException); EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); - - // } } INSTANTIATE_TEST_SUITE_P(ParameterizedSolverDTTests, diff --git a/tests/test-smtlib-reader.cpp b/tests/test-smtlib-reader.cpp index accd2f831..01fe01873 100644 --- a/tests/test-smtlib-reader.cpp +++ b/tests/test-smtlib-reader.cpp @@ -18,6 +18,7 @@ #define STRFY(A) STRHELPER(A) #include + #include #include From 7f2c0caec0c2ed151078a0f74864150b3c602d7a Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Sat, 31 Jul 2021 17:06:19 -0700 Subject: [PATCH 36/47] PR revisions --- cvc4/src/cvc4_sort.cpp | 8 +++ include/generic_sort.h | 4 ++ include/sorting_network.h | 1 + src/generic_datatype.cpp | 1 + src/generic_solver.cpp | 10 ++-- src/generic_sort.cpp | 5 +- src/ops.cpp | 2 +- src/sort_inference.cpp | 8 +-- tests/test-smtlib-reader.cpp | 101 ----------------------------------- 9 files changed, 22 insertions(+), 118 deletions(-) diff --git a/cvc4/src/cvc4_sort.cpp b/cvc4/src/cvc4_sort.cpp index 9eb4dea65..a490bf064 100644 --- a/cvc4/src/cvc4_sort.cpp +++ b/cvc4/src/cvc4_sort.cpp @@ -156,6 +156,14 @@ SortKind CVC4Sort::get_sort_kind() const { return CONSTRUCTOR; } + else if (sort.isSelector()) + { + return SELECTOR; + } + else if (sort.isTester()) + { + return TESTER; + } else { throw NotImplementedException("Unknown kind in CVC4 translation."); diff --git a/include/generic_sort.h b/include/generic_sort.h index 146406d15..ad6e308a5 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -209,6 +209,10 @@ class GenericDatatypeSort : public GenericSort Datatype gdt; }; +/* This class defines a sort class that can represent constructors, + selectors, and testers. Sorts of this variety are primarily used to + build generic terms representing constructors, selectors, and testers. + */ class DatatypeComponentSort : public GenericSort { public: diff --git a/include/sorting_network.h b/include/sorting_network.h index 90195e829..0c724722b 100644 --- a/include/sorting_network.h +++ b/include/sorting_network.h @@ -91,6 +91,7 @@ class SortingNetwork * @return the combined vector */ TermVec merge(const TermVec & sorted1, const TermVec & sorted2) const; + }; } // namespace smt diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index c0f475a10..c7dd1dd9f 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -148,6 +148,7 @@ int GenericDatatype::get_num_selectors(std::string cons) const num_selectors = static_pointer_cast( cons_decl_vector[i]) ->get_selector_count(); + break; } } if (!found) diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index d59223a60..05a9b8ec8 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -324,6 +324,7 @@ std::string GenericSolver::to_smtlib_def(Term term) const { // cast to generic term shared_ptr gt = static_pointer_cast(term); + bool nullary_constructor; // generic terms with no operators are represented by their // name. if (gt->get_op().is_null()) @@ -338,7 +339,8 @@ std::string GenericSolver::to_smtlib_def(Term term) const { shared_ptr dt = static_pointer_cast( (gt->get_sort())->get_datatype()); - result = dt->get_num_selectors((*term_name_map)[gt->get_children()[0]]) + nullary_constructor = dt->get_num_selectors((*term_name_map)[gt->get_children()[0]]); + result = nullary_constructor ? "(" : ""; } @@ -384,9 +386,7 @@ std::string GenericSolver::to_smtlib_def(Term term) const } if (gt->get_op() == Apply_Constructor) { - shared_ptr dt = static_pointer_cast( - (gt->get_sort())->get_datatype()); - result += dt->get_num_selectors((*term_name_map)[gt->get_children()[0]]) + result += nullary_constructor ? ")" : ""; } @@ -723,8 +723,6 @@ Term GenericSolver::get_selector(const Sort & s, std::string con, std::string na { throw InternalSolverException("Selector not in datatype"); } - - // Sort cons_sort = make_generic_sort(SELECTOR, name, s); Term new_term = std::make_shared(cons_sort, Op(), TermVec{}, name, true); (*name_term_map)[name] = new_term; diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 692d5af38..c65bd1701 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -17,6 +17,7 @@ #include #include + #include "assert.h" #include "generic_datatype.h" #include "utils.h" @@ -195,7 +196,6 @@ string GenericSort::compute_string() const { || get_sort_kind() == SortKind::SELECTOR || get_sort_kind() == SortKind::TESTER) { - cout << "in comptue" << endl; return get_uninterpreted_name(); } else @@ -204,7 +204,6 @@ string GenericSort::compute_string() const { } } - SortKind GenericSort::get_sort_kind() const { return sk; } @@ -392,7 +391,7 @@ DatatypeComponentSort::DatatypeComponentSort(SortKind sk, { if (sk != CONSTRUCTOR && sk != SELECTOR && sk != TESTER) { - throw "Wrong sortkind input"; + throw IncorrectUsageException("Wrong sortkind input"); } } std::string DatatypeComponentSort::compute_string() const { return name; } diff --git a/src/ops.cpp b/src/ops.cpp index c19489b41..340bc2e4b 100644 --- a/src/ops.cpp +++ b/src/ops.cpp @@ -91,7 +91,7 @@ const std::unordered_map primop2str( { Exists, "exists" }, { Apply_Selector, "apply_selector" }, { Apply_Tester, "apply_tester" }, - { Apply_Constructor, "apply_selector" } }); + { Apply_Constructor, "apply_constructor" } }); // a map from PrimOp to // TODO: support INT_MAX arity for those that allow it in SMT-LIB diff --git a/src/sort_inference.cpp b/src/sort_inference.cpp index 45f8fe1ad..071422419 100644 --- a/src/sort_inference.cpp +++ b/src/sort_inference.cpp @@ -384,11 +384,7 @@ bool check_selector_sorts(const SortVec & sorts) } Sort dt_sort = sorts[0]; - if (dt_sort->get_sort_kind() != DATATYPE) - { - return false; - } - return true; + return dt_sort->get_sort_kind() == DATATYPE; } // TO DO!!! DO THIS LATER bool check_constructor_sorts(const SortVec & sorts) { return true; } @@ -567,8 +563,6 @@ Sort store_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) Sort selector_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) { Sort parent_sort = (sorts[0])->get_domain_sorts()[0]; - // shared_ptr dt = - // static_pointer_cast(parent_sort->get_datatype()); return static_pointer_cast(sorts[0]) ->get_selector_sort(); } diff --git a/tests/test-smtlib-reader.cpp b/tests/test-smtlib-reader.cpp index b4625311d..accd2f831 100644 --- a/tests/test-smtlib-reader.cpp +++ b/tests/test-smtlib-reader.cpp @@ -18,7 +18,6 @@ #define STRFY(A) STRHELPER(A) #include - #include #include @@ -82,18 +81,6 @@ class IntReaderTests : public ReaderTests { }; -class BitVecReaderTests : public ReaderTests -{ -}; - -class ArrayIntReaderTests : public ReaderTests -{ -}; - -class UninterpReaderTests : public ReaderTests -{ -}; - TEST_P(IntReaderTests, QF_UFLIA_Smt2Files) { // SMT_SWITCH_DIR is a macro defined at build time @@ -113,63 +100,6 @@ TEST_P(IntReaderTests, QF_UFLIA_Smt2Files) } } -TEST_P(BitVecReaderTests, QF_UFBV_Smt2Files) -{ - // SMT_SWITCH_DIR is a macro defined at build time - // and should point to the top-level Smt-Switch directory - string test = STRFY(SMT_SWITCH_DIR); - auto testpair = get<1>(GetParam()); - test += "/tests/smt2/qf_ufbv/" + testpair.first; - reader->parse(test); - auto results = reader->get_results(); - auto expected_results = testpair.second; - ASSERT_EQ(results.size(), expected_results.size()); - - size_t size = results.size(); - for (size_t i = 0; i < size; i++) - { - EXPECT_EQ(results[i], expected_results[i]); - } -} - -TEST_P(ArrayIntReaderTests, QF_ALIA_Smt2Files) -{ - // SMT_SWITCH_DIR is a macro defined at build time - // and should point to the top-level Smt-Switch directory - string test = STRFY(SMT_SWITCH_DIR); - auto testpair = get<1>(GetParam()); - test += "/tests/smt2/qf_alia/" + testpair.first; - reader->parse(test); - auto results = reader->get_results(); - auto expected_results = testpair.second; - ASSERT_EQ(results.size(), expected_results.size()); - - size_t size = results.size(); - for (size_t i = 0; i < size; i++) - { - EXPECT_EQ(results[i], expected_results[i]); - } -} - -TEST_P(UninterpReaderTests, QF_UF_Smt2Files) -{ - // SMT_SWITCH_DIR is a macro defined at build time - // and should point to the top-level Smt-Switch directory - string test = STRFY(SMT_SWITCH_DIR); - auto testpair = get<1>(GetParam()); - test += "/tests/smt2/qf_uf/" + testpair.first; - reader->parse(test); - auto results = reader->get_results(); - auto expected_results = testpair.second; - ASSERT_EQ(results.size(), expected_results.size()); - - size_t size = results.size(); - for (size_t i = 0; i < size; i++) - { - EXPECT_EQ(results[i], expected_results[i]); - } -} - INSTANTIATE_TEST_SUITE_P( ParameterizedSolverIntReaderTests, IntReaderTests, @@ -178,35 +108,4 @@ INSTANTIATE_TEST_SUITE_P( testing::ValuesIn(qf_uflia_tests.begin(), qf_uflia_tests.end()))); -INSTANTIATE_TEST_SUITE_P( - ParameterizedSolverBitVecReaderTests, - BitVecReaderTests, - testing::Combine( - testing::ValuesIn(available_non_generic_solver_configurations()), - testing::ValuesIn(qf_ufbv_tests.begin(), qf_ufbv_tests.end()))); - -INSTANTIATE_TEST_SUITE_P( - ParameterizedSolverArrayIntReaderTests, - ArrayIntReaderTests, - testing::Combine(testing::ValuesIn(filter_non_generic_solver_configurations( - { THEORY_INT, ARRAY_MODELS })), - testing::ValuesIn(qf_alia_tests.begin(), - qf_alia_tests.end()))); - -INSTANTIATE_TEST_SUITE_P( - ParameterizedSolverUninterpReaderTests, - UninterpReaderTests, - testing::Combine(testing::ValuesIn(filter_non_generic_solver_configurations( - { UNINTERP_SORT })), - testing::ValuesIn(qf_uf_tests.begin(), - qf_uf_tests.end()))); - -INSTANTIATE_TEST_SUITE_P( - ParameterizedSolverParamUninterpReaderTests, - UninterpReaderTests, - testing::Combine(testing::ValuesIn(filter_non_generic_solver_configurations( - { PARAM_UNINTERP_SORT })), - testing::ValuesIn(qf_uf_param_sorts_tests.begin(), - qf_uf_param_sorts_tests.end()))); - } // namespace smt_tests From 1e55c4977cbae2ef8b1c46f43e5083ee54386488 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Sat, 31 Jul 2021 17:08:21 -0700 Subject: [PATCH 37/47] clang formatted --- cvc4/src/cvc4_sort.cpp | 12 ++++++------ src/generic_solver.cpp | 11 ++++------- src/generic_sort.cpp | 9 ++++----- 3 files changed, 14 insertions(+), 18 deletions(-) diff --git a/cvc4/src/cvc4_sort.cpp b/cvc4/src/cvc4_sort.cpp index a490bf064..944b2cc8c 100644 --- a/cvc4/src/cvc4_sort.cpp +++ b/cvc4/src/cvc4_sort.cpp @@ -157,13 +157,13 @@ SortKind CVC4Sort::get_sort_kind() const return CONSTRUCTOR; } else if (sort.isSelector()) - { - return SELECTOR; - } + { + return SELECTOR; + } else if (sort.isTester()) - { - return TESTER; - } + { + return TESTER; + } else { throw NotImplementedException("Unknown kind in CVC4 translation."); diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 05a9b8ec8..eb9c2f85b 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -339,10 +339,9 @@ std::string GenericSolver::to_smtlib_def(Term term) const { shared_ptr dt = static_pointer_cast( (gt->get_sort())->get_datatype()); - nullary_constructor = dt->get_num_selectors((*term_name_map)[gt->get_children()[0]]); - result = nullary_constructor - ? "(" - : ""; + nullary_constructor = + dt->get_num_selectors((*term_name_map)[gt->get_children()[0]]); + result = nullary_constructor ? "(" : ""; } else if (gt->get_op() == Apply_Tester) { @@ -386,9 +385,7 @@ std::string GenericSolver::to_smtlib_def(Term term) const } if (gt->get_op() == Apply_Constructor) { - result += nullary_constructor - ? ")" - : ""; + result += nullary_constructor ? ")" : ""; } else { diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index c65bd1701..8c0dbc3ba 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -125,11 +125,10 @@ Sort make_generic_sort(Datatype dt) { return make_shared(dt); } - Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt) - { - return make_shared(sk, cons_name, dt); - } - +Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt) +{ + return make_shared(sk, cons_name, dt); +} // implementations From 84b121fb32b42f90057272693391ba7cb0c03576 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Mon, 2 Aug 2021 16:45:16 -0700 Subject: [PATCH 38/47] forgot to add the type checking --- src/sort_inference.cpp | 27 +++++++++++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) diff --git a/src/sort_inference.cpp b/src/sort_inference.cpp index 071422419..754ce5c17 100644 --- a/src/sort_inference.cpp +++ b/src/sort_inference.cpp @@ -387,10 +387,33 @@ bool check_selector_sorts(const SortVec & sorts) return dt_sort->get_sort_kind() == DATATYPE; } // TO DO!!! DO THIS LATER -bool check_constructor_sorts(const SortVec & sorts) { return true; } +bool check_constructor_sorts(const SortVec & sorts) +{ + assert(sorts.size()); + if (sorts.size() != 1) + { + return false; + + } + Sort dt_sort = sorts[0]; + return dt_sort->get_sort_kind() == DATATYPE; + +} // TO DO!!! DO THIS LATER -bool check_tester_sorts(const SortVec & sorts) { return true; } +bool check_tester_sorts(const SortVec & sorts) +{ + assert(sorts.size()); + if (sorts.size() != 1) + { + return false; + + + } + Sort dt_sort = sorts[0]; + return dt_sort->get_sort_kind() == BOOL; + +} bool check_store_sorts(const SortVec & sorts) { From 5c4fb58f1cb8e901f08b021b545aeaed9300a464 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Mon, 2 Aug 2021 16:47:36 -0700 Subject: [PATCH 39/47] clang formatted --- src/generic_sort.cpp | 1 - src/sort_inference.cpp | 17 ++++++----------- 2 files changed, 6 insertions(+), 12 deletions(-) diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 8c0dbc3ba..8cfe99a24 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -205,7 +205,6 @@ string GenericSort::compute_string() const { SortKind GenericSort::get_sort_kind() const { return sk; } - bool GenericSort::compare(const Sort & s) const { SortKind other_sk = s->get_sort_kind(); diff --git a/src/sort_inference.cpp b/src/sort_inference.cpp index 754ce5c17..fa663b7dd 100644 --- a/src/sort_inference.cpp +++ b/src/sort_inference.cpp @@ -391,13 +391,11 @@ bool check_constructor_sorts(const SortVec & sorts) { assert(sorts.size()); if (sorts.size() != 1) - { - return false; - - } + { + return false; + } Sort dt_sort = sorts[0]; return dt_sort->get_sort_kind() == DATATYPE; - } // TO DO!!! DO THIS LATER @@ -405,14 +403,11 @@ bool check_tester_sorts(const SortVec & sorts) { assert(sorts.size()); if (sorts.size() != 1) - { - return false; - - - } + { + return false; + } Sort dt_sort = sorts[0]; return dt_sort->get_sort_kind() == BOOL; - } bool check_store_sorts(const SortVec & sorts) From 630c193a16e98df1a0385a9de47671a471a3c231 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Tue, 3 Aug 2021 17:04:57 -0700 Subject: [PATCH 40/47] pr revisions --- include/generic_sort.h | 1 + src/generic_sort.cpp | 30 ++++++++++++++++++++++++++++++ src/sort_inference.cpp | 2 +- 3 files changed, 32 insertions(+), 1 deletion(-) diff --git a/include/generic_sort.h b/include/generic_sort.h index ad6e308a5..84d205919 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -222,6 +222,7 @@ class DatatypeComponentSort : public GenericSort std::string to_string() const override; std::string get_uninterpreted_name() const override; SortVec get_domain_sorts() const override; + Sort get_codomain_sort() const override; Sort get_selector_sort() const; void set_selector_sort(Sort new_selector_sort); int get_num_selectors() const; diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 8cfe99a24..63acb1214 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -407,10 +407,40 @@ std::string DatatypeComponentSort::get_uninterpreted_name() const SortVec DatatypeComponentSort::get_domain_sorts() const { std::vector domain_sorts; + if (sk == CONSTRUCTOR) { + shared_ptr cast_dt_sort = static_pointer_cast(dt_sort); + shared_ptr gdt = static_pointer_cast(cast_dt_sort->get_datatype()); + for (int i =0; i < gdt->get_num_constructors(); ++i) { + shared_ptr curr_con = static_pointer_cast(gdt->get_cons_vector()[i]); + if (curr_con->get_name() == name) { + for (int f = 0; f < curr_con->get_selector_count(); ++f) { + domain_sorts.push_back(curr_con->get_selector_vector()[f].sort); + } + } + } + } + else { domain_sorts.push_back(dt_sort); return domain_sorts; + } } + Sort DatatypeComponentSort::get_codomain_sort() const + { + if (sk == CONSTRUCTOR) { + return dt_sort; + } + else if (sk == TESTER) { + return make_generic_sort(BOOL); + } + else if (sk == SELECTOR) { + return selector_sort; + } + else { + throw IncorrectUsageException("Invalid sortkind"); + } + } + Sort DatatypeComponentSort::get_selector_sort() const { return selector_sort; } void DatatypeComponentSort::set_selector_sort(Sort new_selector_sort) diff --git a/src/sort_inference.cpp b/src/sort_inference.cpp index fa663b7dd..c60f7b1b9 100644 --- a/src/sort_inference.cpp +++ b/src/sort_inference.cpp @@ -586,7 +586,7 @@ Sort selector_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) } Sort constructor_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) { - return (sorts[0])->get_domain_sorts()[0]; + return (sorts[0])->get_codomain_sort(); } Sort tester_sort(Op op, const AbsSmtSolver * solver, const SortVec & sorts) { From dbbf72bf31b2e99532bd1aef95cd5e91cbe9d693 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Tue, 3 Aug 2021 17:06:37 -0700 Subject: [PATCH 41/47] clang formatted --- include/generic_sort.h | 1 - src/generic_sort.cpp | 63 +++++++++++++++++++++++++----------------- 2 files changed, 38 insertions(+), 26 deletions(-) diff --git a/include/generic_sort.h b/include/generic_sort.h index 84d205919..679aa9a30 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -118,7 +118,6 @@ class GenericSort : public AbsSort // A string representation of a sort std::string to_string() const override; - protected: // internal function to compute // the string representation of a sort diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 63acb1214..b93afce63 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -407,39 +407,52 @@ std::string DatatypeComponentSort::get_uninterpreted_name() const SortVec DatatypeComponentSort::get_domain_sorts() const { std::vector domain_sorts; - if (sk == CONSTRUCTOR) { - shared_ptr cast_dt_sort = static_pointer_cast(dt_sort); - shared_ptr gdt = static_pointer_cast(cast_dt_sort->get_datatype()); - for (int i =0; i < gdt->get_num_constructors(); ++i) { - shared_ptr curr_con = static_pointer_cast(gdt->get_cons_vector()[i]); - if (curr_con->get_name() == name) { - for (int f = 0; f < curr_con->get_selector_count(); ++f) { - domain_sorts.push_back(curr_con->get_selector_vector()[f].sort); - } + if (sk == CONSTRUCTOR) + { + shared_ptr cast_dt_sort = + static_pointer_cast(dt_sort); + shared_ptr gdt = + static_pointer_cast(cast_dt_sort->get_datatype()); + for (int i = 0; i < gdt->get_num_constructors(); ++i) + { + shared_ptr curr_con = + static_pointer_cast( + gdt->get_cons_vector()[i]); + if (curr_con->get_name() == name) + { + for (int f = 0; f < curr_con->get_selector_count(); ++f) + { + domain_sorts.push_back(curr_con->get_selector_vector()[f].sort); + } } } } - else { - domain_sorts.push_back(dt_sort); - return domain_sorts; + else + { + domain_sorts.push_back(dt_sort); + return domain_sorts; } } - Sort DatatypeComponentSort::get_codomain_sort() const +Sort DatatypeComponentSort::get_codomain_sort() const +{ + if (sk == CONSTRUCTOR) { - if (sk == CONSTRUCTOR) { - return dt_sort; - } - else if (sk == TESTER) { - return make_generic_sort(BOOL); - } - else if (sk == SELECTOR) { - return selector_sort; - } - else { - throw IncorrectUsageException("Invalid sortkind"); - } + return dt_sort; + } + else if (sk == TESTER) + { + return make_generic_sort(BOOL); + } + else if (sk == SELECTOR) + { + return selector_sort; } + else + { + throw IncorrectUsageException("Invalid sortkind"); + } +} Sort DatatypeComponentSort::get_selector_sort() const { return selector_sort; } From 450158a0b69cceb5f1ce645e9b5bff14d81cf6d1 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Tue, 17 Aug 2021 23:33:45 -0700 Subject: [PATCH 42/47] test proven parametric datatypes --- include/generic_datatype.h | 13 +++- include/generic_solver.h | 4 ++ include/generic_sort.h | 14 ++++ include/sort.h | 1 + src/generic_datatype.cpp | 50 +++++++++++-- src/generic_solver.cpp | 87 ++++++++++++++++++++--- src/generic_sort.cpp | 32 +++++++++ src/sort.cpp | 3 +- src/utils.cpp | 140 ++++++++++++++++++------------------- tests/test-dt.cpp | 42 ++++++++++- 10 files changed, 301 insertions(+), 85 deletions(-) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index 9700eaeb6..4efe76434 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -20,16 +20,23 @@ struct SelectorComponents bool finalized; }; + class GenericDatatypeDecl : public AbsDatatypeDecl { public: GenericDatatypeDecl(const std::string name); virtual ~GenericDatatypeDecl(){}; - std::string get_name(); + std::string get_name() const; + int get_param_count() const; + std::vector get_param_sorts(); + void register_param_sort(std::string param_name); protected: friend class GenericSolver; std::string dt_name; + int param_count; + std::vector param_sorts; + }; class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl @@ -46,10 +53,13 @@ class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl int get_selector_count() const; bool compare(const DatatypeConstructorDecl & d) const override; std::string get_dt_name() const; + void add_selector_param(const std::string & name, int param_num); protected: std::vector selector_vector; std::string cons_name; + bool contains_param; + DatatypeDecl dt_decl; // Setter for the dt_decl member. Only to be used when a constructor // is added to a datatype. datatype_decl: The DatatypeDecl of the datatype. @@ -85,6 +95,7 @@ class GenericDatatype : public AbsDatatype protected: DatatypeDecl dt_decl; + std::vector cons_decl_vector; friend class GenericSolver; diff --git a/include/generic_solver.h b/include/generic_solver.h index 4d9df5d73..55e88db3c 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -50,7 +50,9 @@ class GenericSolver : public AbsSmtSolver Sort make_sort(const Sort & sort_con, const SortVec & sorts) const override; // Mutually recursive datatypes are currently not supported. Sort make_sort(const DatatypeDecl & d) const override; + Sort make_sort(const std::vector & dt_vector) const; DatatypeDecl make_datatype_decl(const std::string & s) override; + DatatypeDecl make_datatype_decl(const std::string & s, int num_param); DatatypeConstructorDecl make_datatype_constructor_decl( const std::string s) override; void add_constructor(DatatypeDecl & dt, @@ -60,6 +62,7 @@ class GenericSolver : public AbsSmtSolver const Sort & s) const override; void add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const override; + Term get_constructor(const Sort & s, std::string name) const override; Term get_tester(const Sort & s, std::string name) const override; Term get_selector(const Sort & s, @@ -260,6 +263,7 @@ class GenericSolver : public AbsSmtSolver std::unique_ptr< std::unordered_map, std::string>> datatype_name_map; + std::unique_ptr> par_map; }; } // namespace smt diff --git a/include/generic_sort.h b/include/generic_sort.h index 679aa9a30..e1abb9ca7 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -26,6 +26,7 @@ namespace smt { class GenericDatatye; +std::string get_param_name(int param_num); /* Helper functions for creating generic sorts */ Sort make_uninterpreted_generic_sort(std::string name, uint64_t arity); Sort make_uninterpreted_generic_sort(Sort sort_cons, const SortVec& sorts); @@ -37,6 +38,7 @@ Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2, Sort sort3); Sort make_generic_sort(SortKind sk, SortVec sorts); Sort make_generic_sort(Datatype dt); Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt); + Sort make_generic_param_sort(std::string param_name); /* smtlib representation of sort kinds */ std::string to_smtlib(SortKind); @@ -233,4 +235,16 @@ class DatatypeComponentSort : public GenericSort Sort selector_sort; }; + class ParamSort : public GenericSort + { + public: + ParamSort(std::string param_name); + ~ParamSort(){}; + std::string get_uninterpreted_name() const override; + std::string compute_string() const override; + + protected: + std::string name; + }; + } // namespace smt diff --git a/include/sort.h b/include/sort.h index f291bae12..2fdbe539f 100644 --- a/include/sort.h +++ b/include/sort.h @@ -47,6 +47,7 @@ enum SortKind CONSTRUCTOR, SELECTOR, TESTER, + PARAM, /** IMPORTANT: This must stay at the bottom. It's only use is for sizing the kind2str array diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index c7dd1dd9f..fea88d7a0 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -11,15 +11,45 @@ using namespace std; namespace smt { -GenericDatatypeDecl::GenericDatatypeDecl(const std::string name) : dt_name(name) + GenericDatatypeDecl::GenericDatatypeDecl(const std::string name) : dt_name(name), param_count(0) { + cout << "made decl!" << endl; } -std::string GenericDatatypeDecl::get_name() { return dt_name; } + +std::string GenericDatatypeDecl::get_name() const { return dt_name; } + + int GenericDatatypeDecl::get_param_count() const + { + return param_count; + } + + std::vector GenericDatatypeDecl::get_param_sorts() + { + return param_sorts; + } + + void GenericDatatypeDecl::register_param_sort(std::string param_name) + { + cout << "param sorts size" << param_count << endl; + for (unsigned int i = 0; i < param_count; ++i) + { + // Checks if the selector has already been added + if (param_sorts[i]->to_string() == param_name) + { + throw "Can't add selector. It already exists in this datatype!"; + } + } + Sort new_param = make_generic_param_sort(param_name); + param_sorts.push_back(new_param); + cout << "REGISTERED param sort" << endl; + param_count += 1; + + } GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( const std::string & name) - : cons_name(name) + : cons_name(name), contains_param(false) { } @@ -71,9 +101,11 @@ void GenericDatatypeConstructorDecl::update_stored_dt( dt_decl = datatype_decl; } + GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration) - : dt_decl(dt_declaration) + : dt_decl(dt_declaration) { + } void GenericDatatype::add_constructor( @@ -87,6 +119,15 @@ void GenericDatatype::add_constructor( } shared_ptr gdt_cons = static_pointer_cast(dt_cons_decl); + + if (gdt_cons->contains_param == true) { + cout << "in contains param" << endl; + for (int i=0; i < gdt_cons->get_selector_count(); ++i) { + if (gdt_cons->get_selector_vector()[i].sort->get_sort_kind() == SortKind::PARAM) { + static_pointer_cast(dt_decl)->register_param_sort(static_pointer_cast(gdt_cons->get_selector_vector()[i].sort)->to_string()); + } + } + } // Links the constructor to the datatype_decl of the datatype gdt_cons->update_stored_dt(dt_decl); // Links the datatype to the new constructor @@ -158,6 +199,7 @@ int GenericDatatype::get_num_selectors(std::string cons) const return num_selectors; } + /* This function goes through every selector in the datatype and if finalized is set to false, it replaces the previously stored sort diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index eb9c2f85b..4eec54f94 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -80,8 +80,8 @@ GenericSolver::GenericSolver(string path, term_name_map(new unordered_map()), name_datatype_map( new unordered_map>()), - datatype_name_map( - new unordered_map, string>()) + datatype_name_map(new unordered_map, string>()), + par_map(new unordered_map()) { // Buffer sizes over 256 caused issues in tests. // Until this is investigated, we support a conservative @@ -110,6 +110,11 @@ GenericSolver::GenericSolver(string path, for (int i=0; i < read_buf_size; i++) { read_buf[i]=0; } + *par_map = { + {0, "T"}, + {1, "F"}, + {2, "Q"} + }; // start the process with the solver binary start_solver(); } @@ -447,10 +452,13 @@ Sort GenericSolver::make_sort(const SortKind sk) const Sort GenericSolver::make_sort(const SortKind sk, uint64_t size) const { + + // create the sort Sort sort = make_generic_sort(sk, size); // compute the name string name = sort->to_string(); + // note that nothing needs to be communicated to the solver, // as in this case the sort is built in. @@ -490,10 +498,22 @@ Sort GenericSolver::make_sort(const SortKind sk, Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const { + string name; + Sort sort; + cout << "in solver sortkind is" << sk << "instead of " << SortKind::PARAM << endl; + if (sk == SortKind::PARAM) { + name = sorts[0]->to_string(); + sort = make_generic_param_sort(name); + + } + else { // create the sort - Sort sort = make_generic_sort(sk, sorts); + sort = make_generic_sort(sk, sorts); // compute the name - string name = sort->to_string(); + name = sort->to_string(); + } + cout << "in solver next sortkind is" << sort->get_sort_kind() << "instead of " << SortKind::PARAM<< endl; + // note that nothing needs to be communicated to the solver, // as in this case the sort is built in, or can used @@ -514,6 +534,7 @@ Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const Sort GenericSolver::make_sort(const DatatypeDecl & d) const { + cout << "start of make sort" << endl; shared_ptr gdt_decl = static_pointer_cast(d); string dt_decl_name = gdt_decl->get_name(); @@ -528,8 +549,21 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const std::string to_solver = "(" + DECLARE_DATATYPE_STR + " (("; to_solver += dt_decl_name; - to_solver += " 0)) (\n"; + to_solver += " "; + cout << "pre param count" << endl; + to_solver += std::to_string(gdt_decl->get_param_count()); + cout << "post param count" << endl; + to_solver += ")) (\n"; to_solver += "("; + if (gdt_decl->get_param_count()) { + to_solver += "par ("; + for (int g = 0; g < gdt_decl->get_param_count(); ++g) { + to_solver += gdt_decl->get_param_sorts()[g]->to_string(); + to_solver += " "; + } + to_solver += ")"; + to_solver += " ("; + } // build string for each constructor for (unsigned long i = 0; i < curr_dt->get_cons_vector().size(); ++i) { @@ -551,6 +585,22 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const curr_dt_cons_decl) ->get_selector_vector()[f] .name; + auto gdtc_cast = static_pointer_cast(curr_dt_cons_decl ); + if ((gdtc_cast + ->get_selector_vector()[f] + .sort) + ->to_string() + == gdt_decl->get_name() && gdtc_cast->contains_param) { + to_solver += " ("; + to_solver += (gdtc_cast->get_selector_vector()[f].sort) + ->to_string() + " "; + for (int t = 0; t < gdt_decl->get_param_count(); ++t) { + to_solver += gdt_decl->get_param_sorts()[t]->to_string(); + to_solver += " "; + } + to_solver += "))"; + } + else { to_solver += " " + (static_pointer_cast( curr_dt_cons_decl) @@ -558,14 +608,18 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const .sort) ->to_string() + " )"; + } } to_solver += ")"; } + to_solver += gdt_decl->get_param_count() ? ")" : ""; to_solver += ")\n))"; assert(name_sort_map->find(dt_decl_name) == name_sort_map->end()); (*name_sort_map)[dt_decl_name] = dt_sort; (*sort_name_map)[dt_sort] = dt_decl_name; + cout << "TO solver:\n" << endl; + cout << to_solver << endl; run_command(to_solver); return dt_sort; @@ -579,16 +633,21 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) { - DatatypeDecl new_dt_decl = make_shared(s); + cout << "in make datatype decl" << endl; + shared_ptr new_dt_decl = make_shared(s); + cout << "HELLO" << endl; + cout << "in generic solver paramcount is " << new_dt_decl->param_count << endl; shared_ptr new_dt = shared_ptr(new GenericDatatype(new_dt_decl)); (*name_datatype_map)[s] = new_dt; (*datatype_name_map)[new_dt] = s; return new_dt_decl; } + DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( const std::string s) { + cout << "in make construcotr" << end; shared_ptr new_dt_cons_decl = shared_ptr( new GenericDatatypeConstructorDecl(s)); @@ -608,11 +667,22 @@ void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string { shared_ptr newSelector = make_shared(); + shared_ptr gdtc = + static_pointer_cast(dt); + newSelector->name = name; + cout << "sort kind is "<< s->get_sort_kind() << endl; + cout << SortKind::PARAM << end; + if (s->get_sort_kind() == SortKind::PARAM) { + newSelector->sort = s; + gdtc->contains_param = true; + cout << "it is true" << gdtc->contains_param << endl; + //(static_pointer_cast(dt))->register_param_sort(static_pointer_cast(s)->to_string()); + } + else { newSelector->sort = s; + } newSelector->finalized = true; - shared_ptr gdtc = - static_pointer_cast(dt); gdtc->add_new_selector(*newSelector); } @@ -636,6 +706,7 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s gdt_cons->add_new_selector(*newSelector); } + Term GenericSolver::get_constructor(const Sort & s, std::string name) const { shared_ptr dt = diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index b93afce63..b7a4dfee6 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -25,6 +25,18 @@ using namespace std; namespace smt { + std::unordered_map param_map( + { + {0, "T"}, + {1, "F"}, + {2, "G"} + }); + std::string get_param_name(int param_num) + { + return param_map[param_num]; + } + + Sort make_uninterpreted_generic_sort(string name, uint64_t arity) { return make_shared(name, arity); @@ -130,6 +142,11 @@ Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt) return make_shared(sk, cons_name, dt); } + Sort make_generic_param_sort(std::string param_name) + { + return make_shared(param_name); + } + // implementations GenericSort::GenericSort(SortKind sk) : sk(sk) {} @@ -197,6 +214,9 @@ string GenericSort::compute_string() const { { return get_uninterpreted_name(); } + else if (get_sort_kind() == SortKind::PARAM) { + return get_uninterpreted_name(); + } else { assert(false); @@ -473,4 +493,16 @@ Datatype DatatypeComponentSort::get_datatype() const return dt_sort->get_datatype(); } + ParamSort::ParamSort(std::string param_name) : name(param_name), GenericSort(SortKind::PARAM) + { + } + + std::string ParamSort::compute_string() const + { + return name; + } + std::string ParamSort::get_uninterpreted_name() const + { + return name; + } } // namespace smt diff --git a/src/sort.cpp b/src/sort.cpp index 5bdd671cf..068e01440 100644 --- a/src/sort.cpp +++ b/src/sort.cpp @@ -32,7 +32,8 @@ const std::unordered_map sortkind2str( { FUNCTION, "Function" }, { UNINTERPRETED, "Uninterpreted" }, { UNINTERPRETED_CONS, "UninterpretedSortConstructor" }, - { DATATYPE, "Datatype" } }); + { DATATYPE, "Datatype" }, + {PARAM, "Parameterized"}}); std::string to_string(SortKind sk) { diff --git a/src/utils.cpp b/src/utils.cpp index 03402ba03..57c0e24f4 100644 --- a/src/utils.cpp +++ b/src/utils.cpp @@ -249,9 +249,9 @@ void cnf_to_dimacs(Term cnf, std::ostringstream & y) smt::Op op = t->get_op(); assert(op.is_null() || op == smt::Or || op == smt::Not); - if(op.prim_op == smt::Or) + if (op.prim_op == smt::Or) { - for(auto u : t) + for (auto u : t) { before_or_elimination.push_back(u); } @@ -263,74 +263,74 @@ void cnf_to_dimacs(Term cnf, std::ostringstream & y) } } clauses.push_back(after_or_elimination); - } - - std::map ma; // This map will create a mapping from symbols to - // distinct contiguous integer values. - int ptr = 0; // pointer to store the next integer used in mapping - - // iterating within each clause and mapping every distinct symbol to a - // natural number - for (auto u : clauses) - { - for (auto uu : u) - { // Using literals from all the clauses to create the mapping - if (uu->is_value() && uu->to_string() == "false") - { // For an empty clause, which will just contain the term "false" - } - else if (uu->is_symbolic_const()) - { // A positive literal - if (ma.find(uu) == ma.end()) - { // Checking if symbol is absent in the mapping done till now - ptr++; - ma[uu] = ptr; - } - } - else - { // A negative literal - Term t = (*(uu->begin())); - if (ma.find(t) == ma.end()) - { - ptr++; - ma[t] = ptr; - } - } - } - } - //printing the output in DIMACS format - y << "p cnf "; - y << ptr; // number of distinct symbols - y << " "; - - int sz = clauses.size(); - - y << sz; // number of clauses - y << "\n"; - - // iterating within each clause and assigning the literal their mapped - // value(for a positive literal) or it's negative value(for a negative - // literal) - for (auto u : clauses) - { - for (auto uu : u) - { - if (uu->is_value() && uu->to_string() == "false") - { // For an empty clause - } - else if (uu->is_symbolic_const()) - { - y << (ma[uu]); // Positive number for a positive literal - y << " "; - } - else - { - Term t = (*(uu->begin())); - y << ((-(ma[t]))); // Negative number for a negative literal - y << " "; - } - } - y << 0; // Symbolizing end of line - y << "\n"; + } + + std::map ma; // This map will create a mapping from symbols to + // distinct contiguous integer values. + int ptr = 0; // pointer to store the next integer used in mapping + + // iterating within each clause and mapping every distinct symbol to a + // natural number + for (auto u : clauses) + { + for (auto uu : u) + { // Using literals from all the clauses to create the mapping + if (uu->is_value() && uu->to_string() == "false") + { // For an empty clause, which will just contain the term "false" + } + else if (uu->is_symbolic_const()) + { // A positive literal + if (ma.find(uu) == ma.end()) + { // Checking if symbol is absent in the mapping done till now + ptr++; + ma[uu] = ptr; + } + } + else + { // A negative literal + Term t = (*(uu->begin())); + if (ma.find(t) == ma.end()) + { + ptr++; + ma[t] = ptr; + } + } + } + } + // printing the output in DIMACS format + y << "p cnf "; + y << ptr; // number of distinct symbols + y << " "; + + int sz = clauses.size(); + + y << sz; // number of clauses + y << "\n"; + + // iterating within each clause and assigning the literal their mapped + // value(for a positive literal) or it's negative value(for a negative + // literal) + for (auto u : clauses) + { + for (auto uu : u) + { + if (uu->is_value() && uu->to_string() == "false") + { // For an empty clause + } + else if (uu->is_symbolic_const()) + { + y << (ma[uu]); // Positive number for a positive literal + y << " "; + } + else + { + Term t = (*(uu->begin())); + y << ((-(ma[t]))); // Negative number for a negative literal + y << " "; + } + } + y << 0; // Symbolizing end of line + y << "\n"; } } diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 9ff558569..8b8856a1e 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -130,13 +130,16 @@ TEST_P(DTTests, DatatypeDecl) s->assert_formula( s->make_term(Not, s->make_term(Apply_Tester, isNil, list5))); + + + Result res = s->check_sat(); ASSERT_TRUE(listdt->get_name() == "list"); ASSERT_TRUE(listdt->get_num_constructors() == 2); ASSERT_TRUE(listdt->get_num_selectors("cons") == 2); ASSERT_TRUE(listdt->get_num_selectors("nil") == 0); - + cout << "first wave of asserts" << endl; ASSERT_TRUE(res.is_sat()); // Expected exceptions @@ -144,9 +147,46 @@ TEST_P(DTTests, DatatypeDecl) EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); EXPECT_THROW(s->get_selector(listsort, "nil", "head"), InternalSolverException); + cout << "almost end" << endl; EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); + cout << "all done " << endl; } + TEST_P(DTTests, param_datatypes) + { + // in future, we should have a better parameterization + // I can help with that, but for now this would work + SolverConfiguration sc = GetParam(); + if (sc.solver_enum != GENERIC_SOLVER) + { + return; + } + if (sc.is_logging_solver) { + return; + + } + + DatatypeDecl pair_decl = s->make_datatype_decl("Pair"); + DatatypeConstructorDecl pair_cons = s->make_datatype_constructor_decl("pair"); + s->add_selector(pair_cons, "first", s->make_sort(PARAM, make_generic_param_sort("X"))); + s->add_selector(pair_cons, "second", s->make_sort(PARAM, make_generic_param_sort("Y"))); + s->add_constructor(pair_decl, pair_cons); + Sort pairSort = s->make_sort(pair_decl); + + DatatypeDecl par_list = s->make_datatype_decl("List"); + DatatypeConstructorDecl par_nil = s->make_datatype_constructor_decl("nil"); + DatatypeConstructorDecl par_cons = s->make_datatype_constructor_decl("cons"); + s->add_selector(par_cons, "car", s->make_sort(PARAM, make_generic_param_sort("T"))); + s->add_constructor(par_list, par_nil); + s->add_constructor(par_list, par_cons); + s->add_selector_self(par_cons, "cdr"); + //s->add_constructor(par_list, par_cons); + Sort par_sort = s->make_sort(par_list); + + + + } + INSTANTIATE_TEST_SUITE_P(ParameterizedSolverDTTests, DTTests, testing::ValuesIn(filter_solver_configurations({ THEORY_DATATYPE }))); From d001672b4537ec98f9910e2adebe2252d55e8c98 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Wed, 18 Aug 2021 12:28:53 -0700 Subject: [PATCH 43/47] working tests for parametric datatypes --- src/generic_datatype.cpp | 4 ---- src/generic_solver.cpp | 14 -------------- tests/test-dt.cpp | 4 ---- 3 files changed, 22 deletions(-) diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index fea88d7a0..e35dbd1f2 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -13,7 +13,6 @@ namespace smt { GenericDatatypeDecl::GenericDatatypeDecl(const std::string name) : dt_name(name), param_count(0) { - cout << "made decl!" << endl; } @@ -31,7 +30,6 @@ std::string GenericDatatypeDecl::get_name() const { return dt_name; } void GenericDatatypeDecl::register_param_sort(std::string param_name) { - cout << "param sorts size" << param_count << endl; for (unsigned int i = 0; i < param_count; ++i) { // Checks if the selector has already been added @@ -42,7 +40,6 @@ std::string GenericDatatypeDecl::get_name() const { return dt_name; } } Sort new_param = make_generic_param_sort(param_name); param_sorts.push_back(new_param); - cout << "REGISTERED param sort" << endl; param_count += 1; } @@ -121,7 +118,6 @@ void GenericDatatype::add_constructor( static_pointer_cast(dt_cons_decl); if (gdt_cons->contains_param == true) { - cout << "in contains param" << endl; for (int i=0; i < gdt_cons->get_selector_count(); ++i) { if (gdt_cons->get_selector_vector()[i].sort->get_sort_kind() == SortKind::PARAM) { static_pointer_cast(dt_decl)->register_param_sort(static_pointer_cast(gdt_cons->get_selector_vector()[i].sort)->to_string()); diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 4eec54f94..5b5fac212 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -500,7 +500,6 @@ Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const { string name; Sort sort; - cout << "in solver sortkind is" << sk << "instead of " << SortKind::PARAM << endl; if (sk == SortKind::PARAM) { name = sorts[0]->to_string(); sort = make_generic_param_sort(name); @@ -512,7 +511,6 @@ Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const // compute the name name = sort->to_string(); } - cout << "in solver next sortkind is" << sort->get_sort_kind() << "instead of " << SortKind::PARAM<< endl; // note that nothing needs to be communicated to the solver, @@ -534,7 +532,6 @@ Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const Sort GenericSolver::make_sort(const DatatypeDecl & d) const { - cout << "start of make sort" << endl; shared_ptr gdt_decl = static_pointer_cast(d); string dt_decl_name = gdt_decl->get_name(); @@ -550,9 +547,7 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const std::string to_solver = "(" + DECLARE_DATATYPE_STR + " (("; to_solver += dt_decl_name; to_solver += " "; - cout << "pre param count" << endl; to_solver += std::to_string(gdt_decl->get_param_count()); - cout << "post param count" << endl; to_solver += ")) (\n"; to_solver += "("; if (gdt_decl->get_param_count()) { @@ -618,7 +613,6 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const assert(name_sort_map->find(dt_decl_name) == name_sort_map->end()); (*name_sort_map)[dt_decl_name] = dt_sort; (*sort_name_map)[dt_sort] = dt_decl_name; - cout << "TO solver:\n" << endl; cout << to_solver << endl; run_command(to_solver); @@ -633,10 +627,7 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) { - cout << "in make datatype decl" << endl; shared_ptr new_dt_decl = make_shared(s); - cout << "HELLO" << endl; - cout << "in generic solver paramcount is " << new_dt_decl->param_count << endl; shared_ptr new_dt = shared_ptr(new GenericDatatype(new_dt_decl)); (*name_datatype_map)[s] = new_dt; @@ -647,7 +638,6 @@ DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) DatatypeConstructorDecl GenericSolver::make_datatype_constructor_decl( const std::string s) { - cout << "in make construcotr" << end; shared_ptr new_dt_cons_decl = shared_ptr( new GenericDatatypeConstructorDecl(s)); @@ -671,13 +661,9 @@ void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string static_pointer_cast(dt); newSelector->name = name; - cout << "sort kind is "<< s->get_sort_kind() << endl; - cout << SortKind::PARAM << end; if (s->get_sort_kind() == SortKind::PARAM) { newSelector->sort = s; gdtc->contains_param = true; - cout << "it is true" << gdtc->contains_param << endl; - //(static_pointer_cast(dt))->register_param_sort(static_pointer_cast(s)->to_string()); } else { newSelector->sort = s; diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 8b8856a1e..82a930baa 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -139,7 +139,6 @@ TEST_P(DTTests, DatatypeDecl) ASSERT_TRUE(listdt->get_num_constructors() == 2); ASSERT_TRUE(listdt->get_num_selectors("cons") == 2); ASSERT_TRUE(listdt->get_num_selectors("nil") == 0); - cout << "first wave of asserts" << endl; ASSERT_TRUE(res.is_sat()); // Expected exceptions @@ -147,9 +146,7 @@ TEST_P(DTTests, DatatypeDecl) EXPECT_THROW(s->get_tester(listsort, "head"), InternalSolverException); EXPECT_THROW(s->get_selector(listsort, "nil", "head"), InternalSolverException); - cout << "almost end" << endl; EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); - cout << "all done " << endl; } TEST_P(DTTests, param_datatypes) @@ -180,7 +177,6 @@ TEST_P(DTTests, DatatypeDecl) s->add_constructor(par_list, par_nil); s->add_constructor(par_list, par_cons); s->add_selector_self(par_cons, "cdr"); - //s->add_constructor(par_list, par_cons); Sort par_sort = s->make_sort(par_list); From ca5c402ef5675f496c6fda6e02fccc88c3e984fc Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 20 Aug 2021 13:46:13 -0700 Subject: [PATCH 44/47] partial recursive functionality --- include/generic_solver.h | 5 +++-- include/generic_sort.h | 20 +++++++++++++++++-- include/sort.h | 1 + src/generic_solver.cpp | 19 ++++++++++++++++++ src/generic_sort.cpp | 42 ++++++++++++++++++++++++++++------------ tests/test-dt.cpp | 19 +++++++++++++++--- 6 files changed, 87 insertions(+), 19 deletions(-) diff --git a/include/generic_solver.h b/include/generic_solver.h index 55e88db3c..95266e8cd 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -50,9 +50,9 @@ class GenericSolver : public AbsSmtSolver Sort make_sort(const Sort & sort_con, const SortVec & sorts) const override; // Mutually recursive datatypes are currently not supported. Sort make_sort(const DatatypeDecl & d) const override; - Sort make_sort(const std::vector & dt_vector) const; + DatatypeDecl make_datatype_decl(const std::string & s) override; - DatatypeDecl make_datatype_decl(const std::string & s, int num_param); + DatatypeConstructorDecl make_datatype_constructor_decl( const std::string s) override; void add_constructor(DatatypeDecl & dt, @@ -62,6 +62,7 @@ class GenericSolver : public AbsSmtSolver const Sort & s) const override; void add_selector_self(DatatypeConstructorDecl & dt, const std::string & name) const override; + Sort get_unresolved_sort(DatatypeDecl dt_decl); Term get_constructor(const Sort & s, std::string name) const override; Term get_tester(const Sort & s, std::string name) const override; diff --git a/include/generic_sort.h b/include/generic_sort.h index e1abb9ca7..ca14eb675 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -26,7 +26,7 @@ namespace smt { class GenericDatatye; -std::string get_param_name(int param_num); + /* Helper functions for creating generic sorts */ Sort make_uninterpreted_generic_sort(std::string name, uint64_t arity); Sort make_uninterpreted_generic_sort(Sort sort_cons, const SortVec& sorts); @@ -38,7 +38,9 @@ Sort make_generic_sort(SortKind sk, Sort sort1, Sort sort2, Sort sort3); Sort make_generic_sort(SortKind sk, SortVec sorts); Sort make_generic_sort(Datatype dt); Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt); - Sort make_generic_param_sort(std::string param_name); +Sort make_generic_param_sort(std::string param_name); + Sort make_generic_datatype_sort(Datatype dt); + Sort make_generic_unresolved_sort(DatatypeDecl dt); /* smtlib representation of sort kinds */ std::string to_smtlib(SortKind); @@ -246,5 +248,19 @@ class DatatypeComponentSort : public GenericSort protected: std::string name; }; + + + class UnresolvedSort : public GenericSort + { + public: + UnresolvedSort(DatatypeDecl dt_decl); + ~UnresolvedSort(){}; + std::string compute_string() const override; + std::string to_string() const override; + DatatypeDecl get_datatype_decl(); + protected: + DatatypeDecl datatype_decl; + + }; } // namespace smt diff --git a/include/sort.h b/include/sort.h index 2fdbe539f..18da044ac 100644 --- a/include/sort.h +++ b/include/sort.h @@ -48,6 +48,7 @@ enum SortKind SELECTOR, TESTER, PARAM, + UNRESOLVED, /** IMPORTANT: This must stay at the bottom. It's only use is for sizing the kind2str array diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 5b5fac212..7d65b9fd6 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -505,6 +505,12 @@ Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const sort = make_generic_param_sort(name); } + else if (sk == SortKind::UNRESOLVED && sorts.size() == 1) { + cout << "in make sort" << endl; + shared_ptr dt_sort = static_pointer_cast(sorts[0]); + name = dt_sort->to_string(); + sort = make_generic_unresolved_sort(dt_sort->get_datatype_decl()); + } else { // create the sort sort = make_generic_sort(sk, sorts); @@ -692,6 +698,19 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s gdt_cons->add_new_selector(*newSelector); } + Sort GenericSolver::get_unresolved_sort(DatatypeDecl dt_decl) + { + shared_ptr gdt_decl = + static_pointer_cast(dt_decl); + string dt_decl_name = gdt_decl->get_name(); + assert(name_datatype_map->find(dt_decl_name) != name_datatype_map->end()); + shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; + Sort dt_sort = make_generic_datatype_sort(curr_dt); + (*name_sort_map)[dt_decl_name] = dt_sort; + (*sort_name_map)[dt_sort] = dt_decl_name; + return dt_sort; + } + Term GenericSolver::get_constructor(const Sort & s, std::string name) const { diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index b7a4dfee6..721765fce 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -25,18 +25,6 @@ using namespace std; namespace smt { - std::unordered_map param_map( - { - {0, "T"}, - {1, "F"}, - {2, "G"} - }); - std::string get_param_name(int param_num) - { - return param_map[param_num]; - } - - Sort make_uninterpreted_generic_sort(string name, uint64_t arity) { return make_shared(name, arity); @@ -146,6 +134,14 @@ Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt) { return make_shared(param_name); } + Sort make_generic_datatype_sort(Datatype dt) + { + return make_shared(dt); + } + Sort make_generic_unresolved_sort(DatatypeDecl dt) + { + return make_shared(dt); + } // implementations @@ -505,4 +501,26 @@ Datatype DatatypeComponentSort::get_datatype() const { return name; } + + UnresolvedSort::UnresolvedSort(DatatypeDecl dt_decl) : datatype_decl(dt_decl), GenericSort(SortKind::UNRESOLVED) + { + } + + std::string UnresolvedSort::compute_string() const + { + return static_pointer_cast(datatype_decl)->get_name(); + + } + + std::string UnresolvedSort::to_string() const + { + return compute_string(); + } + + DatatypeDecl UnresolvedSort::get_datatype_decl() + { + return datatype_decl; + } + + } // namespace smt diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 82a930baa..08372d75a 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -178,9 +178,22 @@ TEST_P(DTTests, DatatypeDecl) s->add_constructor(par_list, par_cons); s->add_selector_self(par_cons, "cdr"); Sort par_sort = s->make_sort(par_list); - - - + + + DatatypeDecl tree = s->make_datatype_decl("Tree"); + DatatypeDecl tree_list = s->make_datatype_decl("TreeList"); + DatatypeConstructorDecl empty_cons = s->make_datatype_constructor_decl("empty"); + s->add_constructor(tree_list, empty_cons); + DatatypeConstructorDecl node_cons = s->make_datatype_constructor_decl("node"); + Sort tree_sort = s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree)); + Sort tree_list_sort = s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree_list)); + s->add_selector(node_cons, "value", s->make_sort(PARAM, make_generic_param_sort("X"))); + s->add_selector(node_cons, "children", tree_list_sort); + DatatypeConstructorDecl insert_cons = s->make_datatype_constructor_decl("insert"); + s->add_selector(insert_cons, "head", tree_sort); + s->add_selector(insert_cons, "tail", tree_list_sort); + + } INSTANTIATE_TEST_SUITE_P(ParameterizedSolverDTTests, From d6bf1fa075724f12f9b1d7fb607cc8aa07a73c5d Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 20 Aug 2021 21:17:34 -0700 Subject: [PATCH 45/47] Fully working mutually recursive datatypes --- include/generic_solver.h | 4 ++ include/generic_sort.h | 3 ++ src/generic_datatype.cpp | 4 +- src/generic_solver.cpp | 87 ++++++++++++++++++++++++++++++++++++++++ src/generic_sort.cpp | 13 +++++- tests/test-dt.cpp | 23 +++++++++-- 6 files changed, 127 insertions(+), 7 deletions(-) diff --git a/include/generic_solver.h b/include/generic_solver.h index 1cc2f4a53..c14e14972 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -69,6 +69,10 @@ class GenericSolver : public AbsSmtSolver Term get_selector(const Sort & s, std::string con, std::string name) const override; + SortVec make_datatype_sorts( + const std::vector & decls, + const UnorderedSortSet & uninterp_sorts + ) const override; /***************************************************************/ /* methods from AbsSmtSolver that are implemented */ diff --git a/include/generic_sort.h b/include/generic_sort.h index ca14eb675..f3107f53b 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -258,8 +258,11 @@ class DatatypeComponentSort : public GenericSort std::string compute_string() const override; std::string to_string() const override; DatatypeDecl get_datatype_decl(); + std::vector get_params(); + void insert_param(std::string new_param); protected: DatatypeDecl datatype_decl; + std::vector params_vector; }; diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index e35dbd1f2..b8f41fd65 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -35,7 +35,9 @@ std::string GenericDatatypeDecl::get_name() const { return dt_name; } // Checks if the selector has already been added if (param_sorts[i]->to_string() == param_name) { - throw "Can't add selector. It already exists in this datatype!"; + //throw "Can't add selector. It already exists in this + //datatype!"; + return; } } Sort new_param = make_generic_param_sort(param_name); diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index 5411ce486..d0671f6b7 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -510,6 +510,7 @@ Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const shared_ptr dt_sort = static_pointer_cast(sorts[0]); name = dt_sort->to_string(); sort = make_generic_unresolved_sort(dt_sort->get_datatype_decl()); + return sort; } else { // create the sort @@ -670,6 +671,17 @@ void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string if (s->get_sort_kind() == SortKind::PARAM) { newSelector->sort = s; gdtc->contains_param = true; + } + else if (s->get_sort_kind() == UNRESOLVED) { + auto gdt_decl = static_pointer_cast(static_pointer_cast(dt)->dt_decl); + auto dt_sort = static_pointer_cast(s); + for (int i =0; i < dt_sort->get_params().size(); i++) { + gdt_decl->register_param_sort(dt_sort->get_params()[i]); + } + newSelector->sort = s; + newSelector->finalized = true; + + } else { newSelector->sort = s; @@ -803,6 +815,81 @@ Term GenericSolver::get_selector(const Sort & s, std::string con, std::string na return (*name_term_map)[name]; } + SortVec GenericSolver::make_datatype_sorts(const std::vector & decls, const UnorderedSortSet & uninterp_sorts) const + { + assert(decls.size()); + assert(uninterp_sorts.size()); + std::vector rec_sorts; + std::string to_solver = "(" + DECLARE_DATATYPE_STR + " ("; + for (auto decl : decls) { + to_solver += " (" + static_pointer_cast(decl)->get_name() + " " + std::to_string(static_pointer_cast(decl)->get_param_count()) + ")"; + } + to_solver += ") ("; + shared_ptr curr_decl; + shared_ptr curr_dt; + for (auto decl : decls) { + curr_decl = static_pointer_cast(decl); + curr_dt = (*name_datatype_map)[curr_decl->get_name()]; + to_solver += "\n; " + curr_decl->get_name() + "\n"; + if (curr_decl->get_param_count()) { + to_solver += "(par ("; + for (int g = 0; g < curr_decl->get_param_count(); ++g) { + to_solver += curr_decl->get_param_sorts()[g]->to_string(); + to_solver += " "; + } + to_solver += ")"; + } + to_solver += " ( "; + for (auto cons : curr_dt->get_cons_vector()) { + to_solver += " (" + + static_pointer_cast(cons)->get_name(); + for (auto selector : static_pointer_cast(cons)->get_selector_vector()) { + to_solver += " ( " + selector.name + " "; + if (selector.sort->get_sort_kind() == UNRESOLVED) + { + if (static_pointer_cast(selector.sort)->get_params().size() > 0) { + to_solver += "(" + static_pointer_cast(selector.sort)->to_string(); + for (auto param : static_pointer_cast(selector.sort)->get_params()) { + to_solver += " " + param; + } + to_solver += ")"; + } + else { + to_solver += static_pointer_cast(selector.sort)->to_string(); + } + + + + } + else { + to_solver += selector.sort->to_string(); + } + to_solver += ")"; + } + to_solver += ")"; + } + to_solver += "))"; + + + } + to_solver += " ))"; + cout << to_solver << end; + run_command(to_solver); + for (auto decl : decls) { + + + Sort rec_sort = make_generic_datatype_sort((*name_datatype_map)[static_pointer_cast(decl)->get_name()]); + assert(name_sort_map->find(static_pointer_cast(decl)->get_name()) == name_sort_map->end()); + (*name_sort_map)[static_pointer_cast(decl)->get_name()] = rec_sort; + (*sort_name_map)[rec_sort] = static_pointer_cast(decl)->get_name(); + rec_sorts.push_back(rec_sort); + } + + + + return rec_sorts; + } + std::string GenericSolver::get_name(Term term) const { // the names of the terms are `t_i` with a running `i`. diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index 721765fce..f170194dd 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -502,7 +502,7 @@ Datatype DatatypeComponentSort::get_datatype() const return name; } - UnresolvedSort::UnresolvedSort(DatatypeDecl dt_decl) : datatype_decl(dt_decl), GenericSort(SortKind::UNRESOLVED) + UnresolvedSort::UnresolvedSort(DatatypeDecl dt_decl) : datatype_decl(dt_decl), GenericSort(SortKind::UNRESOLVED) { } @@ -521,6 +521,15 @@ Datatype DatatypeComponentSort::get_datatype() const { return datatype_decl; } - + + std::vector UnresolvedSort::get_params() + { + return params_vector; + } + + void UnresolvedSort::insert_param(std::string new_param) + { + params_vector.push_back(new_param); + } } // namespace smt diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index bf5fcd5ee..25b63ea55 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -216,19 +216,34 @@ TEST_P(DTTests, DatatypeDecl) s->add_selector_self(par_cons, "cdr"); Sort par_sort = s->make_sort(par_list); - + std::unordered_set unresTypes; DatatypeDecl tree = s->make_datatype_decl("Tree"); DatatypeDecl tree_list = s->make_datatype_decl("TreeList"); DatatypeConstructorDecl empty_cons = s->make_datatype_constructor_decl("empty"); s->add_constructor(tree_list, empty_cons); DatatypeConstructorDecl node_cons = s->make_datatype_constructor_decl("node"); Sort tree_sort = s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree)); - Sort tree_list_sort = s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree_list)); + Sort tree_list_sort_X = s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree_list)); + Sort tree_list_sort_Y = s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree_list)); + static_pointer_cast(tree_sort)->insert_param("Y"); + static_pointer_cast(tree_list_sort_X)->insert_param("X"); + static_pointer_cast(tree_list_sort_Y)->insert_param("Y"); + + unresTypes.insert(tree_sort); + unresTypes.insert(tree_list_sort_Y); s->add_selector(node_cons, "value", s->make_sort(PARAM, make_generic_param_sort("X"))); - s->add_selector(node_cons, "children", tree_list_sort); + s->add_constructor(tree, node_cons); + s->add_selector(node_cons, "children", tree_list_sort_X); DatatypeConstructorDecl insert_cons = s->make_datatype_constructor_decl("insert"); + + s->add_constructor(tree_list, insert_cons); s->add_selector(insert_cons, "head", tree_sort); - s->add_selector(insert_cons, "tail", tree_list_sort); + s->add_selector(insert_cons, "tail", tree_list_sort_Y); + std::vector dtdecls; + dtdecls.push_back(tree); + dtdecls.push_back(tree_list); + std::vector dtsorts; + dtsorts = s->make_datatype_sorts(dtdecls, unresTypes); } From cff090b860ac5c79a220af5ff1e61e1717721f74 Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Fri, 20 Aug 2021 21:26:31 -0700 Subject: [PATCH 46/47] clang formatted --- include/generic_datatype.h | 2 - include/generic_solver.h | 5 +- include/generic_sort.h | 49 +++--- src/generic_datatype.cpp | 65 ++++---- src/generic_solver.cpp | 305 ++++++++++++++++++++----------------- src/generic_sort.cpp | 85 +++++------ tests/test-dt.cpp | 127 +++++++-------- 7 files changed, 324 insertions(+), 314 deletions(-) diff --git a/include/generic_datatype.h b/include/generic_datatype.h index 4efe76434..637cc859f 100644 --- a/include/generic_datatype.h +++ b/include/generic_datatype.h @@ -20,7 +20,6 @@ struct SelectorComponents bool finalized; }; - class GenericDatatypeDecl : public AbsDatatypeDecl { public: @@ -36,7 +35,6 @@ class GenericDatatypeDecl : public AbsDatatypeDecl std::string dt_name; int param_count; std::vector param_sorts; - }; class GenericDatatypeConstructorDecl : public AbsDatatypeConstructorDecl diff --git a/include/generic_solver.h b/include/generic_solver.h index c14e14972..74ea7c9ef 100644 --- a/include/generic_solver.h +++ b/include/generic_solver.h @@ -70,9 +70,8 @@ class GenericSolver : public AbsSmtSolver std::string con, std::string name) const override; SortVec make_datatype_sorts( - const std::vector & decls, - const UnorderedSortSet & uninterp_sorts - ) const override; + const std::vector & decls, + const UnorderedSortSet & uninterp_sorts) const override; /***************************************************************/ /* methods from AbsSmtSolver that are implemented */ diff --git a/include/generic_sort.h b/include/generic_sort.h index f3107f53b..72c754b11 100644 --- a/include/generic_sort.h +++ b/include/generic_sort.h @@ -39,8 +39,8 @@ Sort make_generic_sort(SortKind sk, SortVec sorts); Sort make_generic_sort(Datatype dt); Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt); Sort make_generic_param_sort(std::string param_name); - Sort make_generic_datatype_sort(Datatype dt); - Sort make_generic_unresolved_sort(DatatypeDecl dt); +Sort make_generic_datatype_sort(Datatype dt); +Sort make_generic_unresolved_sort(DatatypeDecl dt); /* smtlib representation of sort kinds */ std::string to_smtlib(SortKind); @@ -237,33 +237,32 @@ class DatatypeComponentSort : public GenericSort Sort selector_sort; }; - class ParamSort : public GenericSort - { +class ParamSort : public GenericSort +{ public: - ParamSort(std::string param_name); - ~ParamSort(){}; - std::string get_uninterpreted_name() const override; - std::string compute_string() const override; + ParamSort(std::string param_name); + ~ParamSort(){}; + std::string get_uninterpreted_name() const override; + std::string compute_string() const override; protected: - std::string name; - }; - + std::string name; +}; - class UnresolvedSort : public GenericSort - { +class UnresolvedSort : public GenericSort +{ public: - UnresolvedSort(DatatypeDecl dt_decl); - ~UnresolvedSort(){}; - std::string compute_string() const override; - std::string to_string() const override; - DatatypeDecl get_datatype_decl(); - std::vector get_params(); - void insert_param(std::string new_param); + UnresolvedSort(DatatypeDecl dt_decl); + ~UnresolvedSort(){}; + std::string compute_string() const override; + std::string to_string() const override; + DatatypeDecl get_datatype_decl(); + std::vector get_params(); + void insert_param(std::string new_param); + protected: - DatatypeDecl datatype_decl; - std::vector params_vector; - - }; - + DatatypeDecl datatype_decl; + std::vector params_vector; +}; + } // namespace smt diff --git a/src/generic_datatype.cpp b/src/generic_datatype.cpp index b8f41fd65..dea89c276 100644 --- a/src/generic_datatype.cpp +++ b/src/generic_datatype.cpp @@ -11,44 +11,37 @@ using namespace std; namespace smt { - GenericDatatypeDecl::GenericDatatypeDecl(const std::string name) : dt_name(name), param_count(0) +GenericDatatypeDecl::GenericDatatypeDecl(const std::string name) + : dt_name(name), param_count(0) { } - std::string GenericDatatypeDecl::get_name() const { return dt_name; } - int GenericDatatypeDecl::get_param_count() const - { - return param_count; - } +int GenericDatatypeDecl::get_param_count() const { return param_count; } - std::vector GenericDatatypeDecl::get_param_sorts() - { - return param_sorts; - } +std::vector GenericDatatypeDecl::get_param_sorts() { return param_sorts; } - void GenericDatatypeDecl::register_param_sort(std::string param_name) +void GenericDatatypeDecl::register_param_sort(std::string param_name) +{ + for (unsigned int i = 0; i < param_count; ++i) { - for (unsigned int i = 0; i < param_count; ++i) - { - // Checks if the selector has already been added - if (param_sorts[i]->to_string() == param_name) - { - //throw "Can't add selector. It already exists in this - //datatype!"; - return; - } - } - Sort new_param = make_generic_param_sort(param_name); - param_sorts.push_back(new_param); - param_count += 1; - + // Checks if the selector has already been added + if (param_sorts[i]->to_string() == param_name) + { + // throw "Can't add selector. It already exists in this + // datatype!"; + return; + } } + Sort new_param = make_generic_param_sort(param_name); + param_sorts.push_back(new_param); + param_count += 1; +} GenericDatatypeConstructorDecl::GenericDatatypeConstructorDecl( const std::string & name) - : cons_name(name), contains_param(false) + : cons_name(name), contains_param(false) { } @@ -100,11 +93,9 @@ void GenericDatatypeConstructorDecl::update_stored_dt( dt_decl = datatype_decl; } - GenericDatatype::GenericDatatype(const DatatypeDecl & dt_declaration) - : dt_decl(dt_declaration) + : dt_decl(dt_declaration) { - } void GenericDatatype::add_constructor( @@ -119,10 +110,17 @@ void GenericDatatype::add_constructor( shared_ptr gdt_cons = static_pointer_cast(dt_cons_decl); - if (gdt_cons->contains_param == true) { - for (int i=0; i < gdt_cons->get_selector_count(); ++i) { - if (gdt_cons->get_selector_vector()[i].sort->get_sort_kind() == SortKind::PARAM) { - static_pointer_cast(dt_decl)->register_param_sort(static_pointer_cast(gdt_cons->get_selector_vector()[i].sort)->to_string()); + if (gdt_cons->contains_param == true) + { + for (int i = 0; i < gdt_cons->get_selector_count(); ++i) + { + if (gdt_cons->get_selector_vector()[i].sort->get_sort_kind() + == SortKind::PARAM) + { + static_pointer_cast(dt_decl)->register_param_sort( + static_pointer_cast( + gdt_cons->get_selector_vector()[i].sort) + ->to_string()); } } } @@ -197,7 +195,6 @@ int GenericDatatype::get_num_selectors(std::string cons) const return num_selectors; } - /* This function goes through every selector in the datatype and if finalized is set to false, it replaces the previously stored sort diff --git a/src/generic_solver.cpp b/src/generic_solver.cpp index d0671f6b7..fbf5f88a5 100644 --- a/src/generic_solver.cpp +++ b/src/generic_solver.cpp @@ -80,7 +80,8 @@ GenericSolver::GenericSolver(string path, term_name_map(new unordered_map()), name_datatype_map( new unordered_map>()), - datatype_name_map(new unordered_map, string>()), + datatype_name_map( + new unordered_map, string>()), par_map(new unordered_map()) { // Buffer sizes over 256 caused issues in tests. @@ -110,11 +111,7 @@ GenericSolver::GenericSolver(string path, for (int i=0; i < read_buf_size; i++) { read_buf[i]=0; } - *par_map = { - {0, "T"}, - {1, "F"}, - {2, "Q"} - }; + *par_map = { { 0, "T" }, { 1, "F" }, { 2, "Q" } }; // start the process with the solver binary start_solver(); } @@ -452,13 +449,10 @@ Sort GenericSolver::make_sort(const SortKind sk) const Sort GenericSolver::make_sort(const SortKind sk, uint64_t size) const { - - // create the sort Sort sort = make_generic_sort(sk, size); // compute the name string name = sort->to_string(); - // note that nothing needs to be communicated to the solver, // as in this case the sort is built in. @@ -500,25 +494,27 @@ Sort GenericSolver::make_sort(SortKind sk, const SortVec & sorts) const { string name; Sort sort; - if (sk == SortKind::PARAM) { + if (sk == SortKind::PARAM) + { name = sorts[0]->to_string(); sort = make_generic_param_sort(name); - } - else if (sk == SortKind::UNRESOLVED && sorts.size() == 1) { + else if (sk == SortKind::UNRESOLVED && sorts.size() == 1) + { cout << "in make sort" << endl; - shared_ptr dt_sort = static_pointer_cast(sorts[0]); + shared_ptr dt_sort = + static_pointer_cast(sorts[0]); name = dt_sort->to_string(); sort = make_generic_unresolved_sort(dt_sort->get_datatype_decl()); return sort; } - else { - // create the sort - sort = make_generic_sort(sk, sorts); - // compute the name - name = sort->to_string(); + else + { + // create the sort + sort = make_generic_sort(sk, sorts); + // compute the name + name = sort->to_string(); } - // note that nothing needs to be communicated to the solver, // as in this case the sort is built in, or can used @@ -557,11 +553,13 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const to_solver += std::to_string(gdt_decl->get_param_count()); to_solver += ")) (\n"; to_solver += "("; - if (gdt_decl->get_param_count()) { + if (gdt_decl->get_param_count()) + { to_solver += "par ("; - for (int g = 0; g < gdt_decl->get_param_count(); ++g) { - to_solver += gdt_decl->get_param_sorts()[g]->to_string(); - to_solver += " "; + for (int g = 0; g < gdt_decl->get_param_count(); ++g) + { + to_solver += gdt_decl->get_param_sorts()[g]->to_string(); + to_solver += " "; } to_solver += ")"; to_solver += " ("; @@ -587,30 +585,32 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const curr_dt_cons_decl) ->get_selector_vector()[f] .name; - auto gdtc_cast = static_pointer_cast(curr_dt_cons_decl ); - if ((gdtc_cast - ->get_selector_vector()[f] - .sort) - ->to_string() - == gdt_decl->get_name() && gdtc_cast->contains_param) { - to_solver += " ("; - to_solver += (gdtc_cast->get_selector_vector()[f].sort) - ->to_string() + " "; - for (int t = 0; t < gdt_decl->get_param_count(); ++t) { - to_solver += gdt_decl->get_param_sorts()[t]->to_string(); - to_solver += " "; - } - to_solver += "))"; - } - else { - to_solver += " " - + (static_pointer_cast( - curr_dt_cons_decl) - ->get_selector_vector()[f] - .sort) - ->to_string() - + " )"; - } + auto gdtc_cast = static_pointer_cast( + curr_dt_cons_decl); + if ((gdtc_cast->get_selector_vector()[f].sort)->to_string() + == gdt_decl->get_name() + && gdtc_cast->contains_param) + { + to_solver += " ("; + to_solver += + (gdtc_cast->get_selector_vector()[f].sort)->to_string() + " "; + for (int t = 0; t < gdt_decl->get_param_count(); ++t) + { + to_solver += gdt_decl->get_param_sorts()[t]->to_string(); + to_solver += " "; + } + to_solver += "))"; + } + else + { + to_solver += " " + + (static_pointer_cast( + curr_dt_cons_decl) + ->get_selector_vector()[f] + .sort) + ->to_string() + + " )"; + } } to_solver += ")"; @@ -634,7 +634,8 @@ Sort GenericSolver::make_sort(const DatatypeDecl & d) const DatatypeDecl GenericSolver::make_datatype_decl(const std::string & s) { - shared_ptr new_dt_decl = make_shared(s); + shared_ptr new_dt_decl = + make_shared(s); shared_ptr new_dt = shared_ptr(new GenericDatatype(new_dt_decl)); (*name_datatype_map)[s] = new_dt; @@ -665,26 +666,29 @@ void GenericSolver::add_selector(DatatypeConstructorDecl & dt, const std::string shared_ptr newSelector = make_shared(); shared_ptr gdtc = - static_pointer_cast(dt); - + static_pointer_cast(dt); + newSelector->name = name; - if (s->get_sort_kind() == SortKind::PARAM) { + if (s->get_sort_kind() == SortKind::PARAM) + { newSelector->sort = s; gdtc->contains_param = true; } - else if (s->get_sort_kind() == UNRESOLVED) { - auto gdt_decl = static_pointer_cast(static_pointer_cast(dt)->dt_decl); + else if (s->get_sort_kind() == UNRESOLVED) + { + auto gdt_decl = static_pointer_cast( + static_pointer_cast(dt)->dt_decl); auto dt_sort = static_pointer_cast(s); - for (int i =0; i < dt_sort->get_params().size(); i++) { + for (int i = 0; i < dt_sort->get_params().size(); i++) + { gdt_decl->register_param_sort(dt_sort->get_params()[i]); } newSelector->sort = s; newSelector->finalized = true; - - } - else { - newSelector->sort = s; + else + { + newSelector->sort = s; } newSelector->finalized = true; gdtc->add_new_selector(*newSelector); @@ -710,19 +714,18 @@ void GenericSolver::add_selector_self(DatatypeConstructorDecl & dt, const std::s gdt_cons->add_new_selector(*newSelector); } - Sort GenericSolver::get_unresolved_sort(DatatypeDecl dt_decl) - { - shared_ptr gdt_decl = +Sort GenericSolver::get_unresolved_sort(DatatypeDecl dt_decl) +{ + shared_ptr gdt_decl = static_pointer_cast(dt_decl); - string dt_decl_name = gdt_decl->get_name(); - assert(name_datatype_map->find(dt_decl_name) != name_datatype_map->end()); - shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; - Sort dt_sort = make_generic_datatype_sort(curr_dt); - (*name_sort_map)[dt_decl_name] = dt_sort; - (*sort_name_map)[dt_sort] = dt_decl_name; - return dt_sort; - } - + string dt_decl_name = gdt_decl->get_name(); + assert(name_datatype_map->find(dt_decl_name) != name_datatype_map->end()); + shared_ptr curr_dt = (*name_datatype_map)[dt_decl_name]; + Sort dt_sort = make_generic_datatype_sort(curr_dt); + (*name_sort_map)[dt_decl_name] = dt_sort; + (*sort_name_map)[dt_sort] = dt_decl_name; + return dt_sort; +} Term GenericSolver::get_constructor(const Sort & s, std::string name) const { @@ -815,81 +818,105 @@ Term GenericSolver::get_selector(const Sort & s, std::string con, std::string na return (*name_term_map)[name]; } - SortVec GenericSolver::make_datatype_sorts(const std::vector & decls, const UnorderedSortSet & uninterp_sorts) const +SortVec GenericSolver::make_datatype_sorts( + const std::vector & decls, + const UnorderedSortSet & uninterp_sorts) const +{ + assert(decls.size()); + assert(uninterp_sorts.size()); + std::vector rec_sorts; + std::string to_solver = "(" + DECLARE_DATATYPE_STR + " ("; + for (auto decl : decls) { - assert(decls.size()); - assert(uninterp_sorts.size()); - std::vector rec_sorts; - std::string to_solver = "(" + DECLARE_DATATYPE_STR + " ("; - for (auto decl : decls) { - to_solver += " (" + static_pointer_cast(decl)->get_name() + " " + std::to_string(static_pointer_cast(decl)->get_param_count()) + ")"; - } - to_solver += ") ("; - shared_ptr curr_decl; - shared_ptr curr_dt; - for (auto decl : decls) { - curr_decl = static_pointer_cast(decl); - curr_dt = (*name_datatype_map)[curr_decl->get_name()]; - to_solver += "\n; " + curr_decl->get_name() + "\n"; - if (curr_decl->get_param_count()) { - to_solver += "(par ("; - for (int g = 0; g < curr_decl->get_param_count(); ++g) { - to_solver += curr_decl->get_param_sorts()[g]->to_string(); - to_solver += " "; - } - to_solver += ")"; - } - to_solver += " ( "; - for (auto cons : curr_dt->get_cons_vector()) { - to_solver += " (" - + static_pointer_cast(cons)->get_name(); - for (auto selector : static_pointer_cast(cons)->get_selector_vector()) { - to_solver += " ( " + selector.name + " "; - if (selector.sort->get_sort_kind() == UNRESOLVED) - { - if (static_pointer_cast(selector.sort)->get_params().size() > 0) { - to_solver += "(" + static_pointer_cast(selector.sort)->to_string(); - for (auto param : static_pointer_cast(selector.sort)->get_params()) { - to_solver += " " + param; - } - to_solver += ")"; - } - else { - to_solver += static_pointer_cast(selector.sort)->to_string(); - } - - - - } - else { - to_solver += selector.sort->to_string(); - } - to_solver += ")"; - } - to_solver += ")"; + to_solver += + " (" + static_pointer_cast(decl)->get_name() + " " + + std::to_string( + static_pointer_cast(decl)->get_param_count()) + + ")"; + } + to_solver += ") ("; + shared_ptr curr_decl; + shared_ptr curr_dt; + for (auto decl : decls) + { + curr_decl = static_pointer_cast(decl); + curr_dt = (*name_datatype_map)[curr_decl->get_name()]; + to_solver += "\n; " + curr_decl->get_name() + "\n"; + if (curr_decl->get_param_count()) + { + to_solver += "(par ("; + for (int g = 0; g < curr_decl->get_param_count(); ++g) + { + to_solver += curr_decl->get_param_sorts()[g]->to_string(); + to_solver += " "; } - to_solver += "))"; - - + to_solver += ")"; } - to_solver += " ))"; - cout << to_solver << end; - run_command(to_solver); - for (auto decl : decls) { - - - Sort rec_sort = make_generic_datatype_sort((*name_datatype_map)[static_pointer_cast(decl)->get_name()]); - assert(name_sort_map->find(static_pointer_cast(decl)->get_name()) == name_sort_map->end()); - (*name_sort_map)[static_pointer_cast(decl)->get_name()] = rec_sort; - (*sort_name_map)[rec_sort] = static_pointer_cast(decl)->get_name(); - rec_sorts.push_back(rec_sort); + to_solver += " ( "; + for (auto cons : curr_dt->get_cons_vector()) + { + to_solver += " (" + + static_pointer_cast(cons) + ->get_name(); + for (auto selector : + static_pointer_cast(cons) + ->get_selector_vector()) + { + to_solver += " ( " + selector.name + " "; + if (selector.sort->get_sort_kind() == UNRESOLVED) + { + if (static_pointer_cast(selector.sort) + ->get_params() + .size() + > 0) + { + to_solver += "(" + + static_pointer_cast(selector.sort) + ->to_string(); + for (auto param : static_pointer_cast(selector.sort) + ->get_params()) + { + to_solver += " " + param; + } + to_solver += ")"; + } + else + { + to_solver += + static_pointer_cast(selector.sort)->to_string(); + } + } + else + { + to_solver += selector.sort->to_string(); + } + to_solver += ")"; + } + to_solver += ")"; } + to_solver += "))"; + } + to_solver += " ))"; + cout << to_solver << end; + run_command(to_solver); + for (auto decl : decls) + { + Sort rec_sort = make_generic_datatype_sort( + (*name_datatype_map)[static_pointer_cast(decl) + ->get_name()]); + assert(name_sort_map->find( + static_pointer_cast(decl)->get_name()) + == name_sort_map->end()); + (*name_sort_map)[static_pointer_cast(decl) + ->get_name()] = rec_sort; + (*sort_name_map)[rec_sort] = + static_pointer_cast(decl)->get_name(); + rec_sorts.push_back(rec_sort); + } + return rec_sorts; +} - - return rec_sorts; - } - std::string GenericSolver::get_name(Term term) const { // the names of the terms are `t_i` with a running `i`. diff --git a/src/generic_sort.cpp b/src/generic_sort.cpp index f170194dd..d498d9c7a 100644 --- a/src/generic_sort.cpp +++ b/src/generic_sort.cpp @@ -130,18 +130,18 @@ Sort make_generic_sort(SortKind sk, std::string cons_name, Sort dt) return make_shared(sk, cons_name, dt); } - Sort make_generic_param_sort(std::string param_name) - { - return make_shared(param_name); - } - Sort make_generic_datatype_sort(Datatype dt) - { - return make_shared(dt); - } - Sort make_generic_unresolved_sort(DatatypeDecl dt) - { - return make_shared(dt); - } +Sort make_generic_param_sort(std::string param_name) +{ + return make_shared(param_name); +} +Sort make_generic_datatype_sort(Datatype dt) +{ + return make_shared(dt); +} +Sort make_generic_unresolved_sort(DatatypeDecl dt) +{ + return make_shared(dt); +} // implementations @@ -210,7 +210,8 @@ string GenericSort::compute_string() const { { return get_uninterpreted_name(); } - else if (get_sort_kind() == SortKind::PARAM) { + else if (get_sort_kind() == SortKind::PARAM) + { return get_uninterpreted_name(); } else @@ -489,47 +490,33 @@ Datatype DatatypeComponentSort::get_datatype() const return dt_sort->get_datatype(); } - ParamSort::ParamSort(std::string param_name) : name(param_name), GenericSort(SortKind::PARAM) - { - } +ParamSort::ParamSort(std::string param_name) + : name(param_name), GenericSort(SortKind::PARAM) +{ +} - std::string ParamSort::compute_string() const - { - return name; - } - std::string ParamSort::get_uninterpreted_name() const - { - return name; - } +std::string ParamSort::compute_string() const { return name; } +std::string ParamSort::get_uninterpreted_name() const { return name; } - UnresolvedSort::UnresolvedSort(DatatypeDecl dt_decl) : datatype_decl(dt_decl), GenericSort(SortKind::UNRESOLVED) - { - } +UnresolvedSort::UnresolvedSort(DatatypeDecl dt_decl) + : datatype_decl(dt_decl), GenericSort(SortKind::UNRESOLVED) +{ +} - std::string UnresolvedSort::compute_string() const - { - return static_pointer_cast(datatype_decl)->get_name(); - - } +std::string UnresolvedSort::compute_string() const +{ + return static_pointer_cast(datatype_decl)->get_name(); +} - std::string UnresolvedSort::to_string() const - { - return compute_string(); - } +std::string UnresolvedSort::to_string() const { return compute_string(); } - DatatypeDecl UnresolvedSort::get_datatype_decl() - { - return datatype_decl; - } +DatatypeDecl UnresolvedSort::get_datatype_decl() { return datatype_decl; } - std::vector UnresolvedSort::get_params() - { - return params_vector; - } +std::vector UnresolvedSort::get_params() { return params_vector; } + +void UnresolvedSort::insert_param(std::string new_param) +{ + params_vector.push_back(new_param); +} - void UnresolvedSort::insert_param(std::string new_param) - { - params_vector.push_back(new_param); - } - } // namespace smt diff --git a/tests/test-dt.cpp b/tests/test-dt.cpp index 25b63ea55..208bde43f 100644 --- a/tests/test-dt.cpp +++ b/tests/test-dt.cpp @@ -167,9 +167,6 @@ TEST_P(DTTests, DatatypeDecl) s->assert_formula( s->make_term(Not, s->make_term(Apply_Tester, isNil, list5))); - - - Result res = s->check_sat(); ASSERT_TRUE(listdt->get_name() == "list"); @@ -186,67 +183,73 @@ TEST_P(DTTests, DatatypeDecl) EXPECT_THROW(listdt->get_num_selectors("kons"), InternalSolverException); } - TEST_P(DTTests, param_datatypes) +TEST_P(DTTests, param_datatypes) +{ + // in future, we should have a better parameterization + // I can help with that, but for now this would work + SolverConfiguration sc = GetParam(); + if (sc.solver_enum != GENERIC_SOLVER) { - // in future, we should have a better parameterization - // I can help with that, but for now this would work - SolverConfiguration sc = GetParam(); - if (sc.solver_enum != GENERIC_SOLVER) - { - return; - } - if (sc.is_logging_solver) { - return; - - } + return; + } + if (sc.is_logging_solver) + { + return; + } - DatatypeDecl pair_decl = s->make_datatype_decl("Pair"); - DatatypeConstructorDecl pair_cons = s->make_datatype_constructor_decl("pair"); - s->add_selector(pair_cons, "first", s->make_sort(PARAM, make_generic_param_sort("X"))); - s->add_selector(pair_cons, "second", s->make_sort(PARAM, make_generic_param_sort("Y"))); - s->add_constructor(pair_decl, pair_cons); - Sort pairSort = s->make_sort(pair_decl); - - DatatypeDecl par_list = s->make_datatype_decl("List"); - DatatypeConstructorDecl par_nil = s->make_datatype_constructor_decl("nil"); - DatatypeConstructorDecl par_cons = s->make_datatype_constructor_decl("cons"); - s->add_selector(par_cons, "car", s->make_sort(PARAM, make_generic_param_sort("T"))); - s->add_constructor(par_list, par_nil); - s->add_constructor(par_list, par_cons); - s->add_selector_self(par_cons, "cdr"); - Sort par_sort = s->make_sort(par_list); - - std::unordered_set unresTypes; - DatatypeDecl tree = s->make_datatype_decl("Tree"); - DatatypeDecl tree_list = s->make_datatype_decl("TreeList"); - DatatypeConstructorDecl empty_cons = s->make_datatype_constructor_decl("empty"); - s->add_constructor(tree_list, empty_cons); - DatatypeConstructorDecl node_cons = s->make_datatype_constructor_decl("node"); - Sort tree_sort = s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree)); - Sort tree_list_sort_X = s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree_list)); - Sort tree_list_sort_Y = s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree_list)); - static_pointer_cast(tree_sort)->insert_param("Y"); - static_pointer_cast(tree_list_sort_X)->insert_param("X"); - static_pointer_cast(tree_list_sort_Y)->insert_param("Y"); - - unresTypes.insert(tree_sort); - unresTypes.insert(tree_list_sort_Y); - s->add_selector(node_cons, "value", s->make_sort(PARAM, make_generic_param_sort("X"))); - s->add_constructor(tree, node_cons); - s->add_selector(node_cons, "children", tree_list_sort_X); - DatatypeConstructorDecl insert_cons = s->make_datatype_constructor_decl("insert"); - - s->add_constructor(tree_list, insert_cons); - s->add_selector(insert_cons, "head", tree_sort); - s->add_selector(insert_cons, "tail", tree_list_sort_Y); - std::vector dtdecls; - dtdecls.push_back(tree); - dtdecls.push_back(tree_list); - std::vector dtsorts; - dtsorts = s->make_datatype_sorts(dtdecls, unresTypes); - - - } + DatatypeDecl pair_decl = s->make_datatype_decl("Pair"); + DatatypeConstructorDecl pair_cons = s->make_datatype_constructor_decl("pair"); + s->add_selector( + pair_cons, "first", s->make_sort(PARAM, make_generic_param_sort("X"))); + s->add_selector( + pair_cons, "second", s->make_sort(PARAM, make_generic_param_sort("Y"))); + s->add_constructor(pair_decl, pair_cons); + Sort pairSort = s->make_sort(pair_decl); + + DatatypeDecl par_list = s->make_datatype_decl("List"); + DatatypeConstructorDecl par_nil = s->make_datatype_constructor_decl("nil"); + DatatypeConstructorDecl par_cons = s->make_datatype_constructor_decl("cons"); + s->add_selector( + par_cons, "car", s->make_sort(PARAM, make_generic_param_sort("T"))); + s->add_constructor(par_list, par_nil); + s->add_constructor(par_list, par_cons); + s->add_selector_self(par_cons, "cdr"); + Sort par_sort = s->make_sort(par_list); + + std::unordered_set unresTypes; + DatatypeDecl tree = s->make_datatype_decl("Tree"); + DatatypeDecl tree_list = s->make_datatype_decl("TreeList"); + DatatypeConstructorDecl empty_cons = + s->make_datatype_constructor_decl("empty"); + s->add_constructor(tree_list, empty_cons); + DatatypeConstructorDecl node_cons = s->make_datatype_constructor_decl("node"); + Sort tree_sort = s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree)); + Sort tree_list_sort_X = + s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree_list)); + Sort tree_list_sort_Y = + s->make_sort(UNRESOLVED, make_generic_unresolved_sort(tree_list)); + static_pointer_cast(tree_sort)->insert_param("Y"); + static_pointer_cast(tree_list_sort_X)->insert_param("X"); + static_pointer_cast(tree_list_sort_Y)->insert_param("Y"); + + unresTypes.insert(tree_sort); + unresTypes.insert(tree_list_sort_Y); + s->add_selector( + node_cons, "value", s->make_sort(PARAM, make_generic_param_sort("X"))); + s->add_constructor(tree, node_cons); + s->add_selector(node_cons, "children", tree_list_sort_X); + DatatypeConstructorDecl insert_cons = + s->make_datatype_constructor_decl("insert"); + + s->add_constructor(tree_list, insert_cons); + s->add_selector(insert_cons, "head", tree_sort); + s->add_selector(insert_cons, "tail", tree_list_sort_Y); + std::vector dtdecls; + dtdecls.push_back(tree); + dtdecls.push_back(tree_list); + std::vector dtsorts; + dtsorts = s->make_datatype_sorts(dtdecls, unresTypes); +} INSTANTIATE_TEST_SUITE_P(ParameterizedSolverDTTests, DTTests, From 86f90d49f2f4e6f2b2b9e16ef259461333a574ea Mon Sep 17 00:00:00 2001 From: Afnaan Mohammad Hashmi Date: Tue, 24 Aug 2021 13:52:12 -0700 Subject: [PATCH 47/47] add some style tweaks --- include/solver.h | 14 +++++++------- src/sort.cpp | 4 ++-- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/include/solver.h b/include/solver.h index 170faabd6..63a50245e 100644 --- a/include/solver.h +++ b/include/solver.h @@ -233,15 +233,15 @@ class AbsSmtSolver * If no symbol of that name has been declared, throws * IncorrectUsageException * - * Allows a user to look up a symbol by name. This can be very useful for term - * translation, since we can look up symbols instead of keeping track of the - * mapping via externally populated caches (in the case where the target + * Allows a user to look up a symbol by name. This can be very useful for + * term translation, since we can look up symbols instead of keeping track of + * the mapping via externally populated caches (in the case where the target * solver has already been used). * - * Note, solver backend deals with the implementation. The main motivation for - * this is that each backend solver has to own the symbol table. If the symbol - * table were stored in AbsSmtSolver then it would get destructed after the - * backend solver which has bad refcounting implications for many solvers. + * Note, solver backend deals with the implementation. The main motivation + * for this is that each backend solver has to own the symbol table. If the + * symbol table were stored in AbsSmtSolver then it would get destructed after + * the backend solver which has bad refcounting implications for many solvers. * * @param name the name of the symbol to look up * @return the Term representation of the corresponding symbol diff --git a/src/sort.cpp b/src/sort.cpp index 068e01440..b063cc86f 100644 --- a/src/sort.cpp +++ b/src/sort.cpp @@ -32,8 +32,8 @@ const std::unordered_map sortkind2str( { FUNCTION, "Function" }, { UNINTERPRETED, "Uninterpreted" }, { UNINTERPRETED_CONS, "UninterpretedSortConstructor" }, - { DATATYPE, "Datatype" }, - {PARAM, "Parameterized"}}); + { DATATYPE, "Datatype" }, + { PARAM, "Parameterized" } }); std::string to_string(SortKind sk) {