* disallow internal uses of mkVar() (you have to mkSkolem())

* add support for mkBoundVar() (BOUND_VAR_LISTs in quantifiers must be bound vars)

diff --git a/src/compat/cvc3_compat.cpp b/src/compat/cvc3_compat.cpp
index afac925e2f4a3cbfc90fda799f6b0cd11b141177..62885f55f9d3f47db0088f569a3a442a45ebe7ff 100644 (file)
--- a/src/compat/cvc3_compat.cpp
+++ b/src/compat/cvc3_compat.cpp
@@ -330,7 +330,7 @@ bool Expr::isString() const {
 }
 
 bool Expr::isBoundVar() const {
-  Unimplemented();
+  return getKind() == CVC4::kind::BOUND_VARIABLE;
 }
 
 bool Expr::isLambda() const {
@@ -1857,7 +1857,7 @@ Expr ValidityChecker::datatypeTestExpr(const std::string& constructor, const Exp
 
 Expr ValidityChecker::boundVarExpr(const std::string& name, const std::string& uid,
                                    const Type& type) {
-  Unimplemented("Quantifiers not supported by CVC4 yet (sorry!)");
+  return d_em->mkBoundVar(name, type);
 }
 
 Expr ValidityChecker::forallExpr(const std::vector<Expr>& vars, const Expr& body) {

diff --git a/src/expr/expr_manager_template.cpp b/src/expr/expr_manager_template.cpp
index a8491c93776b432d66ab4f5388aa78aa9436be86..5e7aebbecfb2179044fa42fa96c25136d9b5ec17 100644 (file)
--- a/src/expr/expr_manager_template.cpp
+++ b/src/expr/expr_manager_template.cpp
@@ -44,16 +44,16 @@ ${includes}
     } \
     ++ *(d_exprStatistics[kind]); \
   }
-  #define INC_STAT_VAR(type) \
+  #define INC_STAT_VAR(type, bound_var) \
   { \
     TypeNode* typeNode = Type::getTypeNode(type); \
     TypeConstant type = typeNode->getKind() == kind::TYPE_CONSTANT ? typeNode->getConst<TypeConstant>() : LAST_TYPE; \
     if (d_exprStatisticsVars[type] == NULL) { \
       stringstream statName; \
       if (type == LAST_TYPE) { \
-        statName << "expr::ExprManager::VARIABLE:Parameterized type"; \
+        statName << "expr::ExprManager::" << ((bound_var) ? "BOUND_VARIABLE" : "VARIABLE") << ":Parameterized type"; \
       } else { \
-        statName << "expr::ExprManager::VARIABLE:" << type; \
+        statName << "expr::ExprManager::" << ((bound_var) ? "BOUND_VARIABLE" : "VARIABLE") << ":" << type; \
       } \
       d_exprStatisticsVars[type] = new IntStat(statName.str(), 0); \
       d_nodeManager->getStatisticsRegistry()->registerStat_(d_exprStatisticsVars[type]); \
@@ -62,7 +62,7 @@ ${includes}
   }
 #else
   #define INC_STAT(kind)
-  #define INC_STAT_VAR(type)
+  #define INC_STAT_VAR(type, bound_var)
 #endif
 
 using namespace std;
@@ -791,19 +791,35 @@ Type ExprManager::getType(Expr e, bool check) throw (TypeCheckingException) {
 }
 
 Expr ExprManager::mkVar(const std::string& name, Type type) {
+  Assert(NodeManager::currentNM() == NULL, "ExprManager::mkVar() should only be called externally, not from within CVC4 code.  Please use mkSkolem().");
   NodeManagerScope nms(d_nodeManager);
   Node* n = d_nodeManager->mkVarPtr(name, *type.d_typeNode);
   Debug("nm") << "set " << name << " on " << *n << std::endl;
-  INC_STAT_VAR(type);
+  INC_STAT_VAR(type, false);
   return Expr(this, n);
 }
 
 Expr ExprManager::mkVar(Type type) {
+  Assert(NodeManager::currentNM() == NULL, "ExprManager::mkVar() should only be called externally, not from within CVC4 code.  Please use mkSkolem().");
   NodeManagerScope nms(d_nodeManager);
-  INC_STAT_VAR(type);
+  INC_STAT_VAR(type, false);
   return Expr(this, d_nodeManager->mkVarPtr(*type.d_typeNode));
 }
 
+Expr ExprManager::mkBoundVar(const std::string& name, Type type) {
+  NodeManagerScope nms(d_nodeManager);
+  Node* n = d_nodeManager->mkBoundVarPtr(name, *type.d_typeNode);
+  Debug("nm") << "set " << name << " on " << *n << std::endl;
+  INC_STAT_VAR(type, true);
+  return Expr(this, n);
+}
+
+Expr ExprManager::mkBoundVar(Type type) {
+  NodeManagerScope nms(d_nodeManager);
+  INC_STAT_VAR(type, true);
+  return Expr(this, d_nodeManager->mkBoundVarPtr(*type.d_typeNode));
+}
+
 Expr ExprManager::mkAssociative(Kind kind,
                                 const std::vector<Expr>& children) {
   CheckArgument( kind::isAssociative(kind), kind,

diff --git a/src/expr/expr_manager_template.h b/src/expr/expr_manager_template.h
index b762da3eaf36aa78df9279a2eacb8e85e76f6c13..158f17c14548723436d9b27a65b19dcabbc1ac9e 100644 (file)
--- a/src/expr/expr_manager_template.h
+++ b/src/expr/expr_manager_template.h
@@ -450,6 +450,8 @@ public:
   // variables are special, because duplicates are permitted
   Expr mkVar(const std::string& name, Type type);
   Expr mkVar(Type type);
+  Expr mkBoundVar(const std::string& name, Type type);
+  Expr mkBoundVar(Type type);
 
   /** Get a reference to the statistics registry for this ExprManager */
   StatisticsRegistry* getStatisticsRegistry() const throw();

diff --git a/src/expr/node_manager.h b/src/expr/node_manager.h
index 18b60738f953ff1d2da16cd600866f9846408659..27d77a646efe9d5690ccba649ac216575aa79a7d 100644 (file)
--- a/src/expr/node_manager.h
+++ b/src/expr/node_manager.h
@@ -69,6 +69,10 @@ class NodeManager {
   friend class expr::NodeValue;
   friend class expr::TypeChecker;
 
+  // friends so they can access mkVar() here, which is private
+  friend Expr ExprManager::mkVar(const std::string& name, Type type);
+  friend Expr ExprManager::mkVar(Type type);
+
   /** Predicate for use with STL algorithms */
   struct NodeValueReferenceCountNonZero {
     bool operator()(expr::NodeValue* nv) { return nv->d_rc > 0; }
@@ -257,6 +261,20 @@ class NodeManager {
 
   void init();
 
+  /**
+   * Create a variable with the given name and type.  NOTE that no
+   * lookup is done on the name.  If you mkVar("a", type) and then
+   * mkVar("a", type) again, you have two variables.  The NodeManager
+   * version of this is private to avoid internal uses of mkVar() from
+   * within CVC4.  Such uses should employ mkSkolem() instead.
+   */
+  Node mkVar(const std::string& name, const TypeNode& type);
+  Node* mkVarPtr(const std::string& name, const TypeNode& type);
+
+  /** Create a variable with the given type. */
+  Node mkVar(const TypeNode& type);
+  Node* mkVarPtr(const TypeNode& type);
+
 public:
 
   explicit NodeManager(context::Context* ctxt, ExprManager* exprManager);
@@ -347,20 +365,15 @@ public:
   template <bool ref_count>
   Node* mkNodePtr(TNode opNode, const std::vector<NodeTemplate<ref_count> >& children);
 
-  /**
-   * Create a variable with the given name and type.  NOTE that no
-   * lookup is done on the name.  If you mkVar("a", type) and then
-   * mkVar("a", type) again, you have two variables.
-   */
-  Node mkVar(const std::string& name, const TypeNode& type);
-  Node* mkVarPtr(const std::string& name, const TypeNode& type);
+  Node mkBoundVar(const std::string& name, const TypeNode& type);
+  Node* mkBoundVarPtr(const std::string& name, const TypeNode& type);
 
-  /** Create a variable with the given type. */
-  Node mkVar(const TypeNode& type);
-  Node* mkVarPtr(const TypeNode& type);
+  Node mkBoundVar(const TypeNode& type);
+  Node* mkBoundVarPtr(const TypeNode& type);
 
   /** Create a skolem constant with the given type. */
   Node mkSkolem(const TypeNode& type);
+  Node mkSkolem(const std::string& name, const TypeNode& type);
 
   /** Create a instantiation constant with the given type. */
   Node mkInstConstant(const TypeNode& type);
@@ -1356,7 +1369,6 @@ inline TypeNode NodeManager::mkTypeNode(Kind kind,
 
 inline Node NodeManager::mkVar(const std::string& name, const TypeNode& type) {
   Node n = mkVar(type);
-  setAttribute(n, TypeAttr(), type);
   setAttribute(n, expr::VarNameAttr(), name);
   return n;
 }
@@ -1364,7 +1376,19 @@ inline Node NodeManager::mkVar(const std::string& name, const TypeNode& type) {
 inline Node* NodeManager::mkVarPtr(const std::string& name,
                                    const TypeNode& type) {
   Node* n = mkVarPtr(type);
-  setAttribute(*n, TypeAttr(), type);
+  setAttribute(*n, expr::VarNameAttr(), name);
+  return n;
+}
+
+inline Node NodeManager::mkBoundVar(const std::string& name, const TypeNode& type) {
+  Node n = mkBoundVar(type);
+  setAttribute(n, expr::VarNameAttr(), name);
+  return n;
+}
+
+inline Node* NodeManager::mkBoundVarPtr(const std::string& name,
+                                        const TypeNode& type) {
+  Node* n = mkBoundVarPtr(type);
   setAttribute(*n, expr::VarNameAttr(), name);
   return n;
 }
@@ -1383,6 +1407,26 @@ inline Node* NodeManager::mkVarPtr(const TypeNode& type) {
   return n;
 }
 
+inline Node NodeManager::mkBoundVar(const TypeNode& type) {
+  Node n = NodeBuilder<0>(this, kind::BOUND_VARIABLE);
+  setAttribute(n, TypeAttr(), type);
+  setAttribute(n, TypeCheckedAttr(), true);
+  return n;
+}
+
+inline Node* NodeManager::mkBoundVarPtr(const TypeNode& type) {
+  Node* n = NodeBuilder<0>(this, kind::BOUND_VARIABLE).constructNodePtr();
+  setAttribute(*n, TypeAttr(), type);
+  setAttribute(*n, TypeCheckedAttr(), true);
+  return n;
+}
+
+inline Node NodeManager::mkSkolem(const std::string& name, const TypeNode& type) {
+  Node n = mkSkolem(type);
+  setAttribute(n, expr::VarNameAttr(), name);
+  return n;
+}
+
 inline Node NodeManager::mkSkolem(const TypeNode& type) {
   Node n = NodeBuilder<0>(this, kind::SKOLEM);
   setAttribute(n, TypeAttr(), type);

diff --git a/src/parser/cvc/Cvc.g b/src/parser/cvc/Cvc.g
index 05fed15ea20ed2dae1941e6f8541b4f2fad12c3b..3c4a51ad47bcd9f7fd89592392588ffcdb2177a3 100644 (file)
--- a/src/parser/cvc/Cvc.g
+++ b/src/parser/cvc/Cvc.g
@@ -1254,14 +1254,14 @@ prefixFormula[CVC4::Expr& f]
     { PARSER_STATE->pushScope(); } LPAREN
     boundVarDecl[ids,t]
     { for(std::vector<std::string>::const_iterator i = ids.begin(); i != ids.end(); ++i) {
-        bvs.push_back(PARSER_STATE->mkVar(*i, t));
+        bvs.push_back(PARSER_STATE->mkBoundVar(*i, t));
       }
       ids.clear();
     }
     ( COMMA boundVarDecl[ids,t]
       {
         for(std::vector<std::string>::const_iterator i = ids.begin(); i != ids.end(); ++i) {
-          bvs.push_back(PARSER_STATE->mkVar(*i, t));
+          bvs.push_back(PARSER_STATE->mkBoundVar(*i, t));
         }
         ids.clear();
       }

diff --git a/src/parser/parser.cpp b/src/parser/parser.cpp
index 29db640c7d76c43135689e21e478c45cf0e6d682..bf7c372b732164b18f762ecbd8afc87b85a76249 100644 (file)
--- a/src/parser/parser.cpp
+++ b/src/parser/parser.cpp
@@ -149,6 +149,14 @@ Parser::mkVar(const std::string& name, const Type& type,
   return expr;
 }
 
+Expr
+Parser::mkBoundVar(const std::string& name, const Type& type) {
+  Debug("parser") << "mkVar(" << name << ", " << type << ")" << std::endl;
+  Expr expr = d_exprManager->mkBoundVar(name, type);
+  defineVar(name, expr, false);
+  return expr;
+}
+
 Expr
 Parser::mkFunction(const std::string& name, const Type& type,
                             bool levelZero) {
@@ -178,7 +186,8 @@ Parser::mkVars(const std::vector<std::string> names,
 
 void
 Parser::defineVar(const std::string& name, const Expr& val,
-                       bool levelZero) {
+                  bool levelZero) {
+  Debug("parser") << "defineVar( " << name << " := " << val << " , " << levelZero << ")" << std::endl;;
   d_symtab->bind(name, val, levelZero);
   Assert( isDeclared(name) );
 }
@@ -300,14 +309,14 @@ Parser::mkMutualDatatypeTypes(const std::vector<Datatype>& datatypes) {
       Expr::printtypes::Scope pts(Debug("parser-idt"), true);
       Expr constructor = ctor.getConstructor();
       Debug("parser-idt") << "+ define " << constructor << std::endl;
-      string constructorName = constructor.toString();
+      string constructorName = ctor.getName();
       if(isDeclared(constructorName, SYM_VARIABLE)) {
         throw ParserException(constructorName + " already declared");
       }
       defineVar(constructorName, constructor);
       Expr tester = ctor.getTester();
       Debug("parser-idt") << "+ define " << tester << std::endl;
-      string testerName = tester.toString();
+      string testerName = ctor.getTesterName();
       if(isDeclared(testerName, SYM_VARIABLE)) {
         throw ParserException(testerName + " already declared");
       }
@@ -318,7 +327,7 @@ Parser::mkMutualDatatypeTypes(const std::vector<Datatype>& datatypes) {
           ++k) {
         Expr selector = (*k).getSelector();
         Debug("parser-idt") << "+++ define " << selector << std::endl;
-        string selectorName = selector.toString();
+        string selectorName = (*k).getName();
         if(isDeclared(selectorName, SYM_VARIABLE)) {
           throw ParserException(selectorName + " already declared");
         }

diff --git a/src/parser/parser.h b/src/parser/parser.h
index f3210ae29e9804ebddcb02569ed4368195cdb166..7efc4d78c68b5c64e45987912a5f289964815aff 100644 (file)
--- a/src/parser/parser.h
+++ b/src/parser/parser.h
@@ -347,6 +347,9 @@ public:
     mkVars(const std::vector<std::string> names, const Type& type,
            bool levelZero = false);
 
+  /** Create a new CVC4 bound variable expression of the given type. */
+  Expr mkBoundVar(const std::string& name, const Type& type);
+
   /** Create a new CVC4 function expression of the given type. */
   Expr mkFunction(const std::string& name, const Type& type,
                   bool levelZero = false);

diff --git a/src/parser/smt/Smt.g b/src/parser/smt/Smt.g
index f9c38385f1c30dcf5f720ed4fc59dc1c3e0f158d..0298497e91c2cc2dae9710311837575cf07cd90e 100644 (file)
--- a/src/parser/smt/Smt.g
+++ b/src/parser/smt/Smt.g
@@ -253,7 +253,7 @@ annotatedFormula[CVC4::Expr& expr]
     ( FORALL_TOK { kind = kind::FORALL; } | EXISTS_TOK { kind = kind::EXISTS; } )
     { PARSER_STATE->pushScope(); }
     ( LPAREN_TOK let_identifier[name,CHECK_NONE] t=sortSymbol RPAREN_TOK
-      { args.push_back(PARSER_STATE->mkVar(name, t)); }
+      { args.push_back(PARSER_STATE->mkBoundVar(name, t)); }
     )+
     annotatedFormula[expr] RPAREN_TOK
     { args2.push_back( MK_EXPR( kind::BOUND_VAR_LIST, args ) );

diff --git a/src/parser/smt2/Smt2.g b/src/parser/smt2/Smt2.g
index 456e3c656146b08be615c22bdb80b9d582fcbc59..d8157acbc84c34f070a8f39d4b8da1dcfb93d414 100644 (file)
--- a/src/parser/smt2/Smt2.g
+++ b/src/parser/smt2/Smt2.g
@@ -407,7 +407,7 @@ rewriterulesCommand[CVC4::Command*& cmd]
             sortedVarNames.begin(), iend = sortedVarNames.end();
           i != iend;
           ++i) {
-        args.push_back(PARSER_STATE->mkVar((*i).first, (*i).second));
+        args.push_back(PARSER_STATE->mkBoundVar((*i).first, (*i).second));
       }
       bvl = MK_EXPR(kind::BOUND_VAR_LIST, args);
     }
@@ -448,7 +448,7 @@ rewriterulesCommand[CVC4::Command*& cmd]
             sortedVarNames.begin(), iend = sortedVarNames.end();
           i != iend;
           ++i) {
-        args.push_back(PARSER_STATE->mkVar((*i).first, (*i).second));
+        args.push_back(PARSER_STATE->mkBoundVar((*i).first, (*i).second));
       }
       bvl = MK_EXPR(kind::BOUND_VAR_LIST, args);
     }
@@ -597,7 +597,7 @@ term[CVC4::Expr& expr, CVC4::Expr& expr2]
             sortedVarNames.begin(), iend = sortedVarNames.end();
           i != iend;
           ++i) {
-        args.push_back(PARSER_STATE->mkVar((*i).first, (*i).second));
+        args.push_back(PARSER_STATE->mkBoundVar((*i).first, (*i).second));
       }
       Expr bvl = MK_EXPR(kind::BOUND_VAR_LIST, args);
       args.clear();

diff --git a/src/parser/tptp/Tptp.g b/src/parser/tptp/Tptp.g
index 63774a0870a6791a2aa648f887a8a3b479175c44..068e92cd7422f1c151789937c339116cbad19a8c 100644 (file)
--- a/src/parser/tptp/Tptp.g
+++ b/src/parser/tptp/Tptp.g
@@ -327,7 +327,7 @@ variable[CVC4::Expr & expr]
       if(!PARSER_STATE->cnf || PARSER_STATE->isDeclared(name)){
         expr = PARSER_STATE->getVariable(name);
       } else {
-        expr = PARSER_STATE->mkVar(name, PARSER_STATE->d_unsorted);
+        expr = PARSER_STATE->mkBoundVar(name, PARSER_STATE->d_unsorted);
         if(PARSER_STATE->cnf) PARSER_STATE->addFreeVar(expr);
       }
     }
@@ -402,7 +402,7 @@ bindvariable[CVC4::Expr & expr]
   : UPPER_WORD
     {
       std::string name = AntlrInput::tokenText($UPPER_WORD);
-      expr = PARSER_STATE->mkVar(name, PARSER_STATE->d_unsorted);
+      expr = PARSER_STATE->mkBoundVar(name, PARSER_STATE->d_unsorted);
     }
     ;
 

diff --git a/src/printer/dagification_visitor.cpp b/src/printer/dagification_visitor.cpp
index f22b3515259d297915d6bef2f15a7e7528f61317..cb56c34309f857c7bdfda390709cb7971319af33 100644 (file)
--- a/src/printer/dagification_visitor.cpp
+++ b/src/printer/dagification_visitor.cpp
@@ -135,7 +135,7 @@ void DagificationVisitor::done(TNode node) {
     // construct the let binder
     std::stringstream ss;
     ss << d_letVarPrefix << d_letVar++;
-    Node letvar = NodeManager::currentNM()->mkVar(ss.str(), (*i).getType());
+    Node letvar = NodeManager::currentNM()->mkSkolem(ss.str(), (*i).getType());
 
     // apply previous substitutions to the rhs, enabling cascading LETs
     Node n = d_substitutions->apply(*i);

diff --git a/src/theory/arith/dio_solver.cpp b/src/theory/arith/dio_solver.cpp
index e3eae88b3b86144f512fa0c8c9152187d9797753..83ba492572485d3444648a1de2f0f090190cdec2 100644 (file)
--- a/src/theory/arith/dio_solver.cpp
+++ b/src/theory/arith/dio_solver.cpp
@@ -28,7 +28,7 @@ namespace arith {
 
 inline Node makeIntegerVariable(){
   NodeManager* curr = NodeManager::currentNM();
-  return curr->mkVar(curr->integerType());
+  return curr->mkSkolem(curr->integerType());
 }
 
 DioSolver::DioSolver(context::Context* ctxt) :

diff --git a/src/theory/arith/theory_arith_instantiator.cpp b/src/theory/arith/theory_arith_instantiator.cpp
index 1682897ae0db807987f9448718822f9230d8cce6..51e3a6638bc2c7e5d93ac2876a00f3df18626cc0 100644 (file)
--- a/src/theory/arith/theory_arith_instantiator.cpp
+++ b/src/theory/arith/theory_arith_instantiator.cpp
@@ -412,7 +412,7 @@ Node InstantiatorTheoryArith::getDelta( Node n ){
   if( it==d_deltas.end() ){
     std::ostringstream os;
     os << "delta_" << d_deltas.size();
-    Node delta = NodeManager::currentNM()->mkVar( os.str(), n.getType() );
+    Node delta = NodeManager::currentNM()->mkSkolem( os.str(), n.getType() );
     d_deltas[ n.getType() ] = delta;
     Node gt = NodeManager::currentNM()->mkNode( GT, delta, NodeManager::currentNM()->mkConst( Rational(0) ) );
     //add split

diff --git a/src/theory/arrays/theory_arrays.cpp b/src/theory/arrays/theory_arrays.cpp
index 4f2497d2b5e012262f1d200bd7010937874de836..4beab2d61d8500660e8fe8becc945a303d2248db 100644 (file)
--- a/src/theory/arrays/theory_arrays.cpp
+++ b/src/theory/arrays/theory_arrays.cpp
@@ -694,7 +694,7 @@ void TheoryArrays::check(Effort e) {
             TNode k;
             std::hash_map<TNode, Node, TNodeHashFunction>::iterator it = d_diseqCache.find(fact);
             if (it == d_diseqCache.end()) {
-              Node newk = nm->mkVar(indexType);
+              Node newk = nm->mkSkolem(indexType);
              Dump.declareVar(newk.toExpr(),
                               "an extensional lemma index variable from the theory of arrays");
               d_diseqCache[fact] = newk;

diff --git a/src/theory/arrays/theory_arrays_model.cpp b/src/theory/arrays/theory_arrays_model.cpp
index 7a574fac1e52d623cc1e0b97a7192abb895f4655..5c969060d4e8342d7a31ec149aefd74923b15aef 100644 (file)
--- a/src/theory/arrays/theory_arrays_model.cpp
+++ b/src/theory/arrays/theory_arrays_model.cpp
@@ -29,7 +29,7 @@ using namespace CVC4::theory::arrays;
 ArrayModel::ArrayModel( Node arr, quantifiers::FirstOrderModel* m ) : d_model( m ), d_arr( arr ){
   Assert( arr.getKind()!=STORE );
   //look at ground assertions
-  Node sel = NodeManager::currentNM()->mkNode( SELECT, arr, NodeManager::currentNM()->mkVar( arr.getType().getArrayIndexType() ) );
+  Node sel = NodeManager::currentNM()->mkNode( SELECT, arr, NodeManager::currentNM()->mkSkolem( arr.getType().getArrayIndexType() ) );
   Node sel_op = sel.getOperator();  //FIXME: easier way to do this?
   for( size_t i=0; i<d_model->getTermDatabase()->d_op_map[ sel_op ].size(); i++ ){
     Node n = d_model->getTermDatabase()->d_op_map[ sel_op ][i];

diff --git a/src/theory/builtin/kinds b/src/theory/builtin/kinds
index 285eb651f5f8cd0c3ca8780c647f263c931c20ef..48fe4d84ab0c8823b5669c1b3b88d739e85956dd 100644 (file)
--- a/src/theory/builtin/kinds
+++ b/src/theory/builtin/kinds
@@ -293,8 +293,9 @@ parameterized APPLY FUNCTION 0: "defined function application"
 
 operator EQUAL 2 "equality"
 operator DISTINCT 2: "disequality"
-variable SKOLEM "skolem var"
 variable VARIABLE "variable"
+variable BOUND_VARIABLE "bound variable"
+variable SKOLEM "skolem var"
 operator TUPLE 1: "a tuple"
 
 constant TYPE_CONSTANT \

diff --git a/src/theory/builtin/theory_builtin_type_rules.h b/src/theory/builtin/theory_builtin_type_rules.h
index ef707862476fe4f35bc78a3af60638e1bb14986e..68d9e8702a52568064af0ea3085d0f6d2a36c29d 100644 (file)
--- a/src/theory/builtin/theory_builtin_type_rules.h
+++ b/src/theory/builtin/theory_builtin_type_rules.h
@@ -152,7 +152,7 @@ public:
   }
   inline static Node mkGroundTerm(TypeNode type) {
     Assert(type.getKind() == kind::SORT_TYPE);
-    return NodeManager::currentNM()->mkVar( type );
+    return NodeManager::currentNM()->mkSkolem( type );
   }
 };/* class SortProperties */
 

diff --git a/src/theory/bv/theory_bv_utils.h b/src/theory/bv/theory_bv_utils.h
index a0d418c4bfe1cdfbc33f45c1ec924592ce1c283e..8349a1479134f6aba69cbcb7e8d5ebbbe5ac0fb3 100644 (file)
--- a/src/theory/bv/theory_bv_utils.h
+++ b/src/theory/bv/theory_bv_utils.h
@@ -68,7 +68,7 @@ inline Node mkFalse() {
 
 inline Node mkVar(unsigned size) {
   NodeManager* nm =  NodeManager::currentNM();
-  return nm->mkVar(nm->mkBitVectorType(size)); 
+  return nm->mkSkolem(nm->mkBitVectorType(size)); 
 }
 
 inline Node mkAnd(std::vector<TNode>& children) {

diff --git a/src/theory/ite_simplifier.cpp b/src/theory/ite_simplifier.cpp
index ab8f159a9d67e8bb068dad5d9fe0e0c567e42c86..6eb777ad56343b7970cc1e7cb7367e2febf3031b 100644 (file)
--- a/src/theory/ite_simplifier.cpp
+++ b/src/theory/ite_simplifier.cpp
@@ -148,7 +148,7 @@ Node ITESimplifier::getSimpVar(TypeNode t)
     return (*it).second;
   }
   else {
-    Node var = NodeManager::currentNM()->mkVar(t);
+    Node var = NodeManager::currentNM()->mkSkolem(t);
     d_simpVars[t] = var;
     return var;
   }

diff --git a/src/theory/model.cpp b/src/theory/model.cpp
index 2260e86d3a072709e6da033408dc1cddea8b5e02..a194336fb3d5febab12f8f3d94ac97e0ee8cf25d 100644 (file)
--- a/src/theory/model.cpp
+++ b/src/theory/model.cpp
@@ -236,7 +236,7 @@ Node TheoryModel::getNewDomainValue( TypeNode tn ){
     }while( true );
   }else{
     //otherwise must make a variable  FIXME: how to make constants for other sorts?
-    //return NodeManager::currentNM()->mkVar( tn );
+    //return NodeManager::currentNM()->mkSkolem( tn );
     return Node::null();
   }
 }
@@ -374,7 +374,7 @@ Node DefaultModel::getInterpretedValue( TNode n ){
           default_v = v;
         }
         if( default_v.isNull() ){
-          default_v = getInterpretedValue( NodeManager::currentNM()->mkVar( type.getRangeType() ) );
+          default_v = getInterpretedValue( NodeManager::currentNM()->mkSkolem( type.getRangeType() ) );
         }
         ufmt.setDefaultValue( this, default_v );
         ufmt.simplify();

diff --git a/src/theory/quantifiers/quantifiers_rewriter.cpp b/src/theory/quantifiers/quantifiers_rewriter.cpp
index 800fa910ccbf7ef8778d89f4e1ed8a7dcfc734d9..e928010b6413eb9c20f01d2548b483e99eb1b55a 100644 (file)
--- a/src/theory/quantifiers/quantifiers_rewriter.cpp
+++ b/src/theory/quantifiers/quantifiers_rewriter.cpp
@@ -384,7 +384,7 @@ Node QuantifiersRewriter::computeCNF( Node n, std::vector< Node >& args, NodeBui
       TypeNode typ = NodeManager::currentNM()->mkFunctionType( argTypes, NodeManager::currentNM()->booleanType() );
       std::stringstream ss;
       ss << "cnf_" << n.getKind() << "_" << n.getId();
-      Node op = NodeManager::currentNM()->mkVar( ss.str(), typ );
+      Node op = NodeManager::currentNM()->mkSkolem( ss.str(), typ );
       std::vector< Node > predArgs;
       predArgs.push_back( op );
       predArgs.insert( predArgs.end(), activeArgs.begin(), activeArgs.end() );
@@ -473,7 +473,7 @@ Node QuantifiersRewriter::computePrenex( Node body, std::vector< Node >& args, b
         for( int i=0; i<(int)body[0].getNumChildren(); i++ ){
           //if( std::find( args.begin(), args.end(), body[0][i] )!=args.end() ){
           terms.push_back( body[0][i] );
-          subs.push_back( NodeManager::currentNM()->mkVar( body[0][i].getType() ) );
+          subs.push_back( NodeManager::currentNM()->mkSkolem( body[0][i].getType() ) );
         }
         args.insert( args.end(), subs.begin(), subs.end() );
       }else{
@@ -486,7 +486,7 @@ Node QuantifiersRewriter::computePrenex( Node body, std::vector< Node >& args, b
           terms.push_back( body[0][i] );
           //make the new function symbol
           TypeNode typ = NodeManager::currentNM()->mkFunctionType( argTypes, body[0][i].getType() );
-          Node op = NodeManager::currentNM()->mkVar( typ );
+          Node op = NodeManager::currentNM()->mkSkolem( typ );
           std::vector< Node > funcArgs;
           funcArgs.push_back( op );
           funcArgs.insert( funcArgs.end(), args.begin(), args.end() );

diff --git a/src/theory/quantifiers/term_database.cpp b/src/theory/quantifiers/term_database.cpp
index e1cd7e42cea725091f2141c44fb84e965c19ae8d..cc74e3e76382db113c92d0333175be7875c525bd 100644 (file)
--- a/src/theory/quantifiers/term_database.cpp
+++ b/src/theory/quantifiers/term_database.cpp
@@ -198,7 +198,7 @@ Node TermDb::getModelBasisTerm( TypeNode tn, int i ){
       std::stringstream ss;
       ss << Expr::setlanguage(options::outputLanguage());
       ss << "e_" << tn;
-      mbt = NodeManager::currentNM()->mkVar( ss.str(), tn );
+      mbt = NodeManager::currentNM()->mkSkolem( ss.str(), tn );
     }else{
       mbt = d_type_map[ tn ][ 0 ];
     }
@@ -342,7 +342,7 @@ Node TermDb::getFreeVariableForInstConstant( Node n ){
       d_free_vars[tn] = NodeManager::currentNM()->mkConst( z );
     }else{
       if( d_type_map[ tn ].empty() ){
-        d_free_vars[tn] = NodeManager::currentNM()->mkVar( tn );
+        d_free_vars[tn] = NodeManager::currentNM()->mkSkolem( tn );
       }else{
         d_free_vars[tn] = d_type_map[ tn ][ 0 ];
       }

diff --git a/src/theory/quantifiers/theory_quantifiers_type_rules.h b/src/theory/quantifiers/theory_quantifiers_type_rules.h
index ceec36d7bf77fc81fe854a10149d6aa159717217..50d5a8142b87fb0fb27ee6153a3776eec87cc1e3 100644 (file)
--- a/src/theory/quantifiers/theory_quantifiers_type_rules.h
+++ b/src/theory/quantifiers/theory_quantifiers_type_rules.h
@@ -73,8 +73,8 @@ struct QuantifierBoundVarListTypeRule {
     Assert(n.getKind() == kind::BOUND_VAR_LIST );
     if( check ){
       for( int i=0; i<(int)n.getNumChildren(); i++ ){
-        if( n[i].getKind()!=kind::VARIABLE ){
-          throw TypeCheckingExceptionPrivate(n, "argument of bound var list is not variable");
+        if( n[i].getKind()!=kind::BOUND_VARIABLE ){
+          throw TypeCheckingExceptionPrivate(n, "argument of bound var list is not bound variable");
         }
       }
     }

diff --git a/src/theory/uf/theory_uf_strong_solver.cpp b/src/theory/uf/theory_uf_strong_solver.cpp
index 2ee8b6c931fc13754a07731c127b90535f120e95..f0b386caefbcbe76ec22e9e95fe05bda3d06cc2b 100644 (file)
--- a/src/theory/uf/theory_uf_strong_solver.cpp
+++ b/src/theory/uf/theory_uf_strong_solver.cpp
@@ -1048,7 +1048,7 @@ Node StrongSolverTheoryUf::ConflictFind::getCardinalityLemma(){
       std::stringstream ss;
       ss << Expr::setlanguage(options::outputLanguage());
       ss << "t_" << d_type;
-      d_cardinality_lemma_term = NodeManager::currentNM()->mkVar( ss.str(), d_type );
+      d_cardinality_lemma_term = NodeManager::currentNM()->mkSkolem( ss.str(), d_type );
     }
     Node lem = NodeManager::currentNM()->mkNode( CARDINALITY_CONSTRAINT, d_cardinality_lemma_term,
                                   NodeManager::currentNM()->mkConst( Rational( d_cardinality ) ) );

diff --git a/src/theory/unconstrained_simplifier.cpp b/src/theory/unconstrained_simplifier.cpp
index 58254df33e8c4b46e137ea32a0592b9229868546..c23a72c91312962841a3eb4c84af84c264087627 100644 (file)
--- a/src/theory/unconstrained_simplifier.cpp
+++ b/src/theory/unconstrained_simplifier.cpp
@@ -93,7 +93,7 @@ void UnconstrainedSimplifier::visitAll(TNode assertion)
 
 Node UnconstrainedSimplifier::newUnconstrainedVar(TypeNode t, TNode var)
 {
-  Node n = NodeManager::currentNM()->mkVar(t);
+  Node n = NodeManager::currentNM()->mkSkolem(t);
   Dump.declareVar(n.toExpr(), "a new var introduced because of unconstrained variable " + var.toString());
   return n;
 }

diff --git a/src/util/datatype.cpp b/src/util/datatype.cpp
index 86a43c8780798d60779fbe188e7c7bff57e90cb0..bdefe67550ec4ad90b2ce8eeb3326e4e4ca7359c 100644 (file)
--- a/src/util/datatype.cpp
+++ b/src/util/datatype.cpp
@@ -392,6 +392,12 @@ void DatatypeConstructor::resolve(ExprManager* em, DatatypeType self,
                 "cannot resolve a Datatype constructor twice; "
                 "perhaps the same constructor was added twice, "
                 "or to two datatypes?");
+
+  // we're using some internals, so we have to set up this library context
+  ExprManagerScope ems(*em);
+
+  NodeManager* nm = NodeManager::fromExprManager(em);
+  TypeNode selfTypeNode = TypeNode::fromType(self);
   size_t index = 0;
   for(iterator i = begin(), i_end = end(); i != i_end; ++i) {
     if((*i).d_selector.isNull()) {
@@ -399,7 +405,7 @@ void DatatypeConstructor::resolve(ExprManager* em, DatatypeType self,
       string typeName = (*i).d_name.substr((*i).d_name.find('\0') + 1);
       (*i).d_name.resize((*i).d_name.find('\0'));
       if(typeName == "") {
-        (*i).d_selector = em->mkVar((*i).d_name, em->mkSelectorType(self, self));
+        (*i).d_selector = nm->mkSkolem((*i).d_name, nm->mkSelectorType(selfTypeNode, selfTypeNode)).toExpr();
       } else {
         map<string, DatatypeType>::const_iterator j = resolutions.find(typeName);
         if(j == resolutions.end()) {
@@ -409,7 +415,7 @@ void DatatypeConstructor::resolve(ExprManager* em, DatatypeType self,
               << "of constructor \"" << d_name << "\"";
           throw DatatypeResolutionException(msg.str());
         } else {
-          (*i).d_selector = em->mkVar((*i).d_name, em->mkSelectorType(self, (*j).second));
+          (*i).d_selector = nm->mkSkolem((*i).d_name, nm->mkSelectorType(selfTypeNode, TypeNode::fromType((*j).second))).toExpr();
         }
       }
     } else {
@@ -422,7 +428,7 @@ void DatatypeConstructor::resolve(ExprManager* em, DatatypeType self,
       if(!paramTypes.empty() ) {
         range = doParametricSubstitution( range, paramTypes, paramReplacements );
       }
-      (*i).d_selector = em->mkVar((*i).d_name, em->mkSelectorType(self, range));
+      (*i).d_selector = nm->mkSkolem((*i).d_name, nm->mkSelectorType(selfTypeNode, TypeNode::fromType(range))).toExpr();
     }
     Node::fromExpr((*i).d_selector).setAttribute(DatatypeIndexAttr(), index++);
     (*i).d_resolved = true;
@@ -435,9 +441,8 @@ void DatatypeConstructor::resolve(ExprManager* em, DatatypeType self,
   // fails above, we want Constuctor::isResolved() to remain "false".
   // Further, mkConstructorType() iterates over the selectors, so
   // should get the results of any resolutions we did above.
-  d_tester = em->mkVar(d_name.substr(d_name.find('\0') + 1), em->mkTesterType(self));
-  d_name.resize(d_name.find('\0'));
-  d_constructor = em->mkVar(d_name, em->mkConstructorType(*this, self));
+  d_tester = nm->mkSkolem(getTesterName(), nm->mkTesterType(selfTypeNode)).toExpr();
+  d_constructor = nm->mkSkolem(getName(), nm->mkConstructorType(*this, selfTypeNode)).toExpr();
   // associate constructor with all selectors
   for(iterator i = begin(), i_end = end(); i != i_end; ++i) {
     (*i).d_constructor = d_constructor;
@@ -503,7 +508,11 @@ void DatatypeConstructor::addArg(std::string selectorName, Type selectorType) {
   // create the proper selector type)
   CheckArgument(!isResolved(), this, "cannot modify a finalized Datatype constructor");
   CheckArgument(!selectorType.isNull(), selectorType, "cannot add a null selector type");
-  Expr type = selectorType.getExprManager()->mkVar(selectorType);
+
+  // we're using some internals, so we have to set up this library context
+  ExprManagerScope ems(selectorType);
+
+  Expr type = NodeManager::currentNM()->mkSkolem(TypeNode::fromType(selectorType)).toExpr();
   Debug("datatypes") << type << endl;
   d_args.push_back(DatatypeConstructorArg(selectorName, type));
 }
@@ -529,11 +538,11 @@ void DatatypeConstructor::addArg(std::string selectorName, DatatypeSelfType) {
 }
 
 std::string DatatypeConstructor::getName() const throw() {
-  string name = d_name;
-  if(!isResolved()) {
-    name.resize(name.find('\0'));
-  }
-  return name;
+  return d_name.substr(0, d_name.find('\0'));
+}
+
+std::string DatatypeConstructor::getTesterName() const throw() {
+  return d_name.substr(d_name.find('\0') + 1);
 }
 
 Expr DatatypeConstructor::getConstructor() const {

diff --git a/src/util/datatype.h b/src/util/datatype.h
index c7631ae7b2e7c942a6c31a83fb9bd16508814d54..60d2c7acdf9ed115e26e52d689e44d17d4aeb644 100644 (file)
--- a/src/util/datatype.h
+++ b/src/util/datatype.h
@@ -232,6 +232,11 @@ public:
    */
   Expr getTester() const;
 
+  /**
+   * Get the tester name for this Datatype constructor.
+   */
+  std::string getTesterName() const throw();
+
   /**
    * Get the number of arguments (so far) of this Datatype constructor.
    */

diff --git a/src/util/ite_removal.cpp b/src/util/ite_removal.cpp
index 9a4fc8dc2141d74f0a097f30b97abe6e96a68e0e..50713e2b4def7d103ff8302a4ebda6aca50c3aed 100644 (file)
--- a/src/util/ite_removal.cpp
+++ b/src/util/ite_removal.cpp
@@ -55,7 +55,7 @@ Node RemoveITE::run(TNode node, std::vector<Node>& output,
     TypeNode nodeType = node.getType();
     if(!nodeType.isBoolean()) {
       // Make the skolem to represent the ITE
-      Node skolem = nodeManager->mkVar(nodeType);
+      Node skolem = nodeManager->mkSkolem(nodeType);
 
       Dump.declareVar(skolem.toExpr(), "a variable introduced due to term-level ITE removal");