// compiler directs the user to the template file instead of the
// generated one. We don't want the user to modify the generated one,
// since it'll get overwritten on a later build.
-#line 35 "${template}"
+#line 33 "${template}"
#ifdef CVC4_STATISTICS_ON
#define INC_STAT(kind) \
// compiler directs the user to the template file instead of the
// generated one. We don't want the user to modify the generated one,
// since it'll get overwritten on a later build.
-#line 40 "${template}"
+#line 38 "${template}"
namespace CVC4 {
// compiler directs the user to the template file instead of the
// generated one. We don't want the user to modify the generated one,
// since it'll get overwritten on a later build.
-#line 36 "${template}"
+#line 34 "${template}"
using namespace CVC4::kind;
using namespace std;
// compiler directs the user to the template file instead of the
// generated one. We don't want the user to modify the generated one,
// since it'll get overwritten on a later build.
-#line 46 "${template}"
+#line 44 "${template}"
namespace CVC4 {
${getConst_instantiations}
-#line 930 "${template}"
+#line 928 "${template}"
namespace expr {
return out;
}
-#line 66 "${template}"
+#line 64 "${template}"
/** Returns true if the given kind is associative. This is used by ExprManager to
* decide whether it's safe to modify big expressions by changing the grouping of
*/
enum TypeConstant {
${type_constant_list}
-#line 104 "${template}"
+#line 102 "${template}"
LAST_TYPE
};/* enum TypeConstant */
inline std::ostream& operator<<(std::ostream& out, TypeConstant typeConstant) {
switch(typeConstant) {
${type_constant_descriptions}
-#line 120 "${template}"
+#line 118 "${template}"
default:
out << "UNKNOWN_TYPE_CONSTANT";
break;
enum TheoryId {
${theory_enum}
-#line 132 "${template}"
+#line 130 "${template}"
THEORY_LAST
};/* enum TheoryId */
inline std::ostream& operator<<(std::ostream& out, TheoryId theoryId) {
switch(theoryId) {
${theory_descriptions}
-#line 146 "${template}"
+#line 144 "${template}"
default:
out << "UNKNOWN_THEORY";
break;
case kind::NULL_EXPR:
break;
${kind_to_theory_id}
-#line 160 "${template}"
+#line 158 "${template}"
case kind::LAST_KIND:
break;
}
inline TheoryId typeConstantToTheoryId(::CVC4::TypeConstant typeConstant) {
switch(typeConstant) {
${type_constant_to_theory_id}
-#line 170 "${template}"
+#line 168 "${template}"
case LAST_TYPE:
break;
}
** TypeChecker implementation.
**/
-#line 20 "${template}"
+#line 18 "${template}"
#include "expr/type_checker.h"
#include "expr/node_manager.h"
${typechecker_includes}
-#line 27 "${template}"
+#line 25 "${template}"
namespace CVC4 {
namespace expr {
${typerules}
-#line 48 "${template}"
+#line 46 "${template}"
default:
Debug("getType") << "FAILURE" << std::endl;
switch(n.getKind()) {
${construles}
-#line 71 "${template}"
+#line 69 "${template}"
default:;
}
#ifndef __CVC4__TYPE_PROPERTIES_H
#define __CVC4__TYPE_PROPERTIES_H
-#line 25 "${template}"
+#line 23 "${template}"
#include "expr/type_node.h"
#include "util/cvc4_assert.h"
${type_properties_includes}
-#line 37 "${template}"
+#line 35 "${template}"
namespace CVC4 {
namespace kind {
inline Cardinality getCardinality(TypeConstant tc) {
switch(tc) {
${type_constant_cardinalities}
-#line 51 "${template}"
+#line 49 "${template}"
default: {
std::stringstream ss;
ss << "No cardinality known for type constant " << tc;
case TYPE_CONSTANT:
return getCardinality(typeNode.getConst<TypeConstant>());
${type_cardinalities}
-#line 72 "${template}"
+#line 70 "${template}"
default: {
std::stringstream ss;
ss << "A theory kinds file did not provide a cardinality "
inline bool isWellFounded(TypeConstant tc) {
switch(tc) {
${type_constant_wellfoundednesses}
-#line 86 "${template}"
+#line 84 "${template}"
default: {
std::stringstream ss;
ss << "No well-foundedness status known for type constant: " << tc;
case TYPE_CONSTANT:
return isWellFounded(typeNode.getConst<TypeConstant>());
${type_wellfoundednesses}
-#line 101 "${template}"
+#line 99 "${template}"
default: {
std::stringstream ss;
ss << "A theory kinds file did not provide a well-foundedness "
inline Node mkGroundTerm(TypeConstant tc) {
switch(tc) {
${type_constant_groundterms}
-#line 115 "${template}"
+#line 113 "${template}"
default: {
std::stringstream ss;
ss << "No ground term known for type constant: " << tc;
case TYPE_CONSTANT:
return mkGroundTerm(typeNode.getConst<TypeConstant>());
${type_groundterms}
-#line 130 "${template}"
+#line 128 "${template}"
default: {
std::stringstream ss;
ss << "A theory kinds file did not provide a ground term "
${module_accessors}
-#line 26 "${template}"
+#line 24 "${template}"
namespace options {
${module_global_definitions}
-#line 32 "${template}"
+#line 30 "${template}"
}/* CVC4::options namespace */
#include "options/options.h"
${module_includes}
-#line 28 "${template}"
+#line 26 "${template}"
${module_optionholder_spec}
-#line 32 "${template}"
+#line 30 "${template}"
namespace CVC4 {
${module_decls}
-#line 40 "${template}"
+#line 38 "${template}"
}/* CVC4::options namespace */
${module_specializations}
-#line 46 "${template}"
+#line 44 "${template}"
namespace options {
${module_inlines}
-#line 52 "${template}"
+#line 50 "${template}"
}/* CVC4::options namespace */
${include_all_option_headers}
-#line 27 "${template}"
+#line 25 "${template}"
namespace CVC4 {
namespace options {
OptionsHolder();
${all_modules_contributions}
-#line 36 "${template}"
+#line 34 "${template}"
};/* struct OptionsHolder */
${include_all_option_headers}
-#line 41 "${template}"
+#line 39 "${template}"
#include "util/output.h"
#include "options/options_holder.h"
${option_handler_includes}
-#line 50 "${template}"
+#line 48 "${template}"
using namespace CVC4;
using namespace CVC4::options;
${all_custom_handlers}
-#line 187 "${template}"
+#line 220 "${template}"
#ifdef CVC4_DEBUG
# define USE_EARLY_TYPE_CHECKING_BY_DEFAULT true
{
}
-#line 217 "${template}"
+#line 215 "${template}"
static const std::string mostCommonOptionsDescription = "\
Most commonly-used CVC4 options:${common_documentation}";
-#line 222 "${template}"
+#line 220 "${template}"
static const std::string optionsDescription = mostCommonOptionsDescription + "\n\
\n\
Additional CVC4 options:${remaining_documentation}";
-#line 228 "${template}"
+#line 226 "${template}"
static const std::string optionsFootnote = "\n\
[*] Each of these options has a --no-OPTIONNAME variant, which reverses the\n\
{ NULL, no_argument, NULL, '\0' }
};/* cmdlineOptions */
-#line 299 "${template}"
+#line 297 "${template}"
static void preemptGetopt(int& argc, char**& argv, const char* opt) {
const size_t maxoptlen = 128;
switch(c) {
${all_modules_option_handlers}
-#line 463 "${template}"
+#line 461 "${template}"
case ':':
// This can be a long or short option, and the way to get at the
${include_all_option_headers}
${option_handler_includes}
-#line 33 "${template}"
+#line 31 "${template}"
using namespace std;
${smt_setoption_handlers}
-#line 54 "${template}"
+#line 52 "${template}"
throw UnrecognizedOptionException(key);
}
${smt_getoption_handlers}
-#line 71 "${template}"
+#line 69 "${template}"
throw UnrecognizedOptionException(key);
}
${instantiator_includes}
-#line 26 "${template}"
+#line 24 "${template}"
namespace CVC4 {
namespace theory {
Instantiator* Theory::makeInstantiator(context::Context* c, theory::QuantifiersEngine* qe) {
switch(d_id) {
${make_instantiator_cases}
-#line 34 "${template}"
+#line 32 "${template}"
default:
Unhandled(d_id);
}
#include "util/cvc4_assert.h"
${type_enumerator_includes}
-#line 28 "${template}"
+#line 26 "${template}"
using namespace std;
}
Unreachable();
${mk_type_enumerator_cases}
-#line 49 "${template}"
+#line 47 "${template}"
default:
{
stringstream ss;