Merge lp:~zorba-coders/zorba/markos-scratch into lp:zorba

[Markos Zaharioudakis]

reduced include dependencies on the compiler + various optimizer optimizations

reduced include dependencies on the compiler + various optimizer optimizations

[Markos Zaharioudakis (markos-za)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/markos-scratch-2012-10-24T12-23-01.282Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job markos-scratch-2012-10-24T12-23-01.282Z is finished. The final status was:

All tests succeeded!

=== modified file 'ChangeLog'
--- ChangeLog	2012-10-23 21:07:15 +0000
+++ ChangeLog	2012-10-24 11:34:21 +0000
@@ -8,6 +8,7 @@
 
 Optimizations:
   * Optimized the MarkExpr and EliminateFlworVariables rules of the optimizer
+  * Optimized the MarkFreeVars optimizer rule
 
 Bug Fixes/Other Changes:
   * Fixed mustCopyInputNodes() method of no-copy, and jsoniq functions.
 
=== modified file 'src/compiler/api/compilercb.cpp'
--- src/compiler/api/compilercb.cpp	2012-10-12 09:05:54 +0000
+++ src/compiler/api/compilercb.cpp	2012-10-24 11:34:21 +0000
@@ -17,6 +17,7 @@
 
 #include "compiler/api/compilercb.h"
 #include "compiler/expression/expr_base.h"
+#include "compiler/expression/expr_manager.h"
 
 #ifdef ZORBA_WITH_DEBUGGER
 #include "debugger/debugger_commons.h"
 
=== modified file 'src/compiler/api/compilercb.h'
--- src/compiler/api/compilercb.h	2012-10-12 09:05:54 +0000
+++ src/compiler/api/compilercb.h	2012-10-24 11:34:21 +0000
@@ -29,19 +29,21 @@
 // without having the definition of static_context availble.
 # include "context/static_context.h"
 #endif
+
 #include "compiler/expression/pragma.h"
 
 #include "zorbaserialization/class_serializer.h"
 
-#include "compiler/expression/mem_manager.h"
-#include "compiler/expression/expr_manager.h"
 
-namespace zorba {
+namespace zorba 
+{
 
 #ifdef ZORBA_WITH_DEBUGGER
 class DebuggerCommons;
 #endif
 class static_context;
+class ExprManager;
+
 
 /*******************************************************************************
   There is one CompilerCB per query plus one CompilerCB per invocation of an
@@ -233,8 +235,6 @@
 
   ExprManager* getExprManager() const { return theEM; }
 
-  MemoryManager& getMemoryManager() const { return theEM->getMemory(); }
-
   //
   // Pragmas
   //
 
=== modified file 'src/compiler/codegen/plan_visitor.cpp'
--- src/compiler/codegen/plan_visitor.cpp	2012-10-08 12:09:36 +0000
+++ src/compiler/codegen/plan_visitor.cpp	2012-10-24 11:34:21 +0000
@@ -31,6 +31,7 @@
 #include "system/globalenv.h"
 #include "system/properties.h"
 
+#include "compiler/expression/expr_manager.h"
 #include "compiler/api/compilercb.h"
 #include "compiler/codegen/plan_visitor.h"
 #include "compiler/expression/expr.h"
@@ -896,7 +897,9 @@
           {
             ++numForClauses;
 
-            if (c->get_expr()->is_sequential())
+            const for_clause* fc = static_cast<const for_clause*>(c);
+
+            if (fc->get_expr()->is_sequential())
             {
               // TODO: do not convert to general flwor if the whole flwor consists
               // of a single FOR followed by RETURN.
@@ -907,7 +910,9 @@
           }
           else if (c->get_kind() == flwor_clause::let_clause)
           {
-            if (c->get_expr()->is_sequential())
+            const let_clause* lc = static_cast<const let_clause*>(c);
+
+            if (lc->get_expr()->is_sequential())
             {
               if (numForClauses > 0)
               {
@@ -933,7 +938,7 @@
       {
         materialize_clause* mat =
         theCCB->theEM->create_materialize_clause(v.get_sctx(),
-                                            v.get_return_expr()->get_loc());
+                                                 v.get_return_expr()->get_loc());
 
         v.add_clause(mat);
         ++numClauses;
@@ -960,14 +965,17 @@
         case flwor_clause::let_clause:
         case flwor_clause::window_clause:
         {
+          expr* domExpr = static_cast<const forletwin_clause*>(c)->get_expr();
+
           if (k == flwor_clause::for_clause || k == flwor_clause::window_clause)
           {
-            xqtref_t domainType = c->get_expr()->get_return_type();
+            xqtref_t domainType = domExpr->get_return_type();
+
             if (domainType->get_quantifier() != TypeConstants::QUANT_ONE)
               ++numForClauses;
           }
 
-          if (c->get_expr()->is_sequential())
+          if (domExpr->is_sequential())
           {
             if (k == flwor_clause::for_clause ||
                 k == flwor_clause::window_clause ||
@@ -981,12 +989,12 @@
                   v.get_clause(i-1)->get_kind() != flwor_clause::order_clause &&
                   v.get_clause(i-1)->get_kind() != flwor_clause::group_clause)
               {
-                orderby_clause* mat =
-                theCCB->theEM->create_orderby_clause(v.get_sctx(),
-                                   c->get_loc(),
-                                   true,
-                                   modifiers,
-                                   orderingExprs);
+                orderby_clause* mat = theCCB->theEM->
+                create_orderby_clause(v.get_sctx(),
+                                      c->get_loc(),
+                                      true,
+                                      modifiers,
+                                      orderingExprs);
 
                 v.add_clause(i, mat);
                 ++i;
@@ -997,12 +1005,12 @@
                   (i < numClauses - 1 &&
                    v.get_clause(i+1)->get_kind() != flwor_clause::group_clause))
               {
-                orderby_clause* mat =
-                theCCB->theEM->create_orderby_clause(v.get_sctx(),
-                                   c->get_loc(),
-                                   true,
-                                   modifiers,
-                                   orderingExprs);
+                orderby_clause* mat = theCCB->theEM->
+                create_orderby_clause(v.get_sctx(),
+                                      c->get_loc(),
+                                      true,
+                                      modifiers,
+                                      orderingExprs);
 
                 v.add_clause(i+1, mat);
                 ++numClauses;
@@ -1032,12 +1040,12 @@
           lastClause->get_kind() != flwor_clause::order_clause &&
           lastClause->get_kind() != flwor_clause::group_clause)
       {
-        orderby_clause* mat =
-        theCCB->theEM->create_orderby_clause(v.get_sctx(),
-                           v.get_return_expr()->get_loc(),
-                           true,
-                           modifiers,
-                           orderingExprs);
+        orderby_clause* mat = theCCB->theEM->
+        create_orderby_clause(v.get_sctx(),
+                              v.get_return_expr()->get_loc(),
+                              true,
+                              modifiers,
+                              orderingExprs);
 
         v.add_clause(mat);
         ++numClauses;
@@ -1566,7 +1574,7 @@
 
     return new flwor::WindowIterator(sctx,
                                      var->get_loc(),
-                                     wc->get_winkind() == window_clause::tumbling_window ? flwor::WindowIterator::TUMBLING : flwor::WindowIterator::SLIDING,
+                                     wc->get_winkind() == tumbling_window ? flwor::WindowIterator::TUMBLING : flwor::WindowIterator::SLIDING,
                                      PREV_ITER,
                                      domainIter,
                                      var->get_name(),
@@ -2272,10 +2280,10 @@
   enum FlowCtlException::action a;
   switch (v.get_action())
   {
-  case flowctl_expr::BREAK:
+  case FLOW_BREAK:
     a = FlowCtlException::BREAK;
     break;
-  case flowctl_expr::CONTINUE:
+  case FLOW_CONTINUE:
     a = FlowCtlException::CONTINUE;
     break;
   default:
@@ -3022,7 +3030,7 @@
 
   theConstructorsStack.push(&v);
 
-  if (v.get_type() == text_expr::text_constructor)
+  if (v.get_type() == text_constructor)
     theEnclosedContextStack.push(TEXT_CONTENT);
   else
     theEnclosedContextStack.push(ATTRIBUTE_CONTENT);
@@ -3049,11 +3057,11 @@
 
   switch (v.get_type())
   {
-  case text_expr::text_constructor:
+  case text_constructor:
     push_itstack(new TextIterator(sctx, qloc, content, isRoot));
     break;
 
-  case text_expr::comment_constructor:
+  case comment_constructor:
     push_itstack(new CommentIterator(sctx, qloc, content, isRoot));
     break;
 
 
=== modified file 'src/compiler/expression/expr.cpp'
--- src/compiler/expression/expr.cpp	2012-10-22 15:10:23 +0000
+++ src/compiler/expression/expr.cpp	2012-10-24 11:34:21 +0000
@@ -174,12 +174,12 @@
     static_context* sctx,
     user_function* udf,
     const QueryLoc& loc,
-    order_type_t type,
-    expr* inExpr)
+    DocOrderMode type,
+    expr* input)
   :
   expr(ccb, sctx, udf, loc, order_expr_kind),
-  theType(type),
-  theExpr(inExpr)
+  theInput(input),
+  theType(type)
 {
   compute_scripting_kind();
 }
@@ -187,7 +187,7 @@
 
 void order_expr::compute_scripting_kind()
 {
-  theScriptingKind = theExpr->get_scripting_detail();
+  theScriptingKind = theInput->get_scripting_detail();
 
   if (is_vacuous())
     theScriptingKind = SIMPLE_EXPR;
@@ -204,14 +204,14 @@
     const QueryLoc& loc,
     enum ParseConstants::validation_mode_t mode,
     const store::Item_t& typeName,
-    expr* inExpr,
+    expr* input,
     rchandle<TypeManager> typemgr)
   :
   expr(ccb, sctx, udf, loc, validate_expr_kind),
+  theInput(input),
   theMode(mode),
   theTypeName(typeName),
-  theTypeMgr(typemgr),
-  theExpr(inExpr)
+  theTypeMgr(typemgr)
 {
   compute_scripting_kind();
 }
@@ -219,9 +219,9 @@
 
 void validate_expr::compute_scripting_kind()
 {
-  checkNonUpdating(theExpr);
+  checkNonUpdating(theInput);
 
-  theScriptingKind = theExpr->get_scripting_detail();
+  theScriptingKind = theInput->get_scripting_detail();
 
   if (is_vacuous())
     theScriptingKind = SIMPLE_EXPR;
@@ -266,7 +266,7 @@
     const xqtref_t& type)
   :
   expr(ccb, sctx, udf, loc, kind),
-  theInputExpr(input),
+  theInput(input),
   theTargetType(type)
 {
   assert(type != NULL);
@@ -290,9 +290,9 @@
 
 void cast_or_castable_base_expr::compute_scripting_kind()
 {
-  checkNonUpdating(theInputExpr);
+  checkNonUpdating(theInput);
 
-  theScriptingKind = theInputExpr->get_scripting_detail();
+  theScriptingKind = theInput->get_scripting_detail();
 
   if (is_vacuous())
     theScriptingKind = SIMPLE_EXPR;
@@ -355,7 +355,7 @@
     const QueryLoc& loc,
     expr* inputExpr,
     const xqtref_t& type,
-    TreatIterator::ErrorKind err,
+    TreatErrorKind err,
     bool check_prime,
     store::Item* qname)
   :
@@ -378,7 +378,7 @@
     const QueryLoc& loc,
     expr* input,
     const xqtref_t& type,
-    PromoteIterator::ErrorKind err,
+    PromoteErrorKind err,
     store::Item* qname)
   :
   cast_base_expr(ccb, sctx, udf, loc, promote_expr_kind, input, type),
@@ -663,7 +663,7 @@
     static_context* sctx,
     user_function* udf,
     const QueryLoc& loc,
-    text_constructor_type type_arg,
+    TextConstructorType type_arg,
     expr* content)
   :
   expr(ccb, sctx, udf, loc, text_expr_kind),
@@ -743,10 +743,10 @@
     static_context* sctx,
     user_function* udf,
     const QueryLoc& loc,
-    expr* wrapped)
+    expr* input)
   :
   expr(ccb, sctx, udf, loc, wrapper_expr_kind),
-  theWrappedExpr(wrapped)
+  theInput(input)
 {
   compute_scripting_kind();
 }
@@ -754,7 +754,7 @@
 
 void wrapper_expr::compute_scripting_kind()
 {
-  theScriptingKind = theWrappedExpr->get_scripting_detail();
+  theScriptingKind = theInput->get_scripting_detail();
 }
 
 
@@ -1105,6 +1105,14 @@
 }
 
 
+void eval_expr::add_var(var_expr* var)
+{
+  theOuterVarNames.push_back(var->get_name());
+  theOuterVarTypes.push_back(var->get_return_type());
+  theArgs.push_back(var);
+}
+
+
 #ifdef ZORBA_WITH_DEBUGGER
 /*******************************************************************************
 
@@ -1131,6 +1139,13 @@
   theScriptingKind = theExpr->get_scripting_detail();
 }
 
+
+void debugger_expr::add_var(var_expr* var, expr* arg)
+{
+  theVars.push_back(var);
+  theArgs.push_back(arg);
+}
+
 #endif
 
 
@@ -1142,10 +1157,10 @@
     static_context* sctx,
     user_function* udf,
     const QueryLoc& loc,
-    expr* aChild)
+    expr* input)
   :
-  expr(ccb, sctx, udf, loc, aChild->get_expr_kind()),
-  theExpr(aChild),
+  expr(ccb, sctx, udf, loc, function_trace_expr_kind),
+  theInput(input),
   theFunctionArity(0)
 {
   bool modified;
@@ -1154,14 +1169,14 @@
 }
 
 
-function_trace_expr::function_trace_expr(user_function* udf, expr* aExpr)
+function_trace_expr::function_trace_expr(user_function* udf, expr* input)
   :
-  expr(aExpr->get_ccb(),
-       aExpr->get_sctx(),
+  expr(input->get_ccb(),
+       input->get_sctx(),
        udf,
-       aExpr->get_loc(),
+       input->get_loc(),
        function_trace_expr_kind),
-  theExpr(aExpr),
+  theInput(input),
   theFunctionArity(0)
 {
   bool modified;
@@ -1177,7 +1192,7 @@
 
 void function_trace_expr::compute_scripting_kind()
 {
-  theScriptingKind = theExpr->get_scripting_detail();
+  theScriptingKind = theInput->get_scripting_detail();
 }
 
 
 
=== modified file 'src/compiler/expression/expr.h'
--- src/compiler/expression/expr.h	2012-10-09 14:06:08 +0000
+++ src/compiler/expression/expr.h	2012-10-24 11:34:21 +0000
@@ -28,7 +28,7 @@
 
 #include "functions/signature.h"
 
-#include "compiler/expression/var_expr.h"
+#include "compiler/expression/expr_base.h"
 
 #include "context/static_context.h"
 #include "context/namespace_context.h"
@@ -37,7 +37,6 @@
 
 #include "store/api/item.h"
 
-#include "runtime/core/sequencetypes.h"
 
 namespace zorba
 {
@@ -48,6 +47,7 @@
 class signature;
 class pragma;
 
+
 /*******************************************************************************
   [68] IfExpr ::= "if" "(" Expr ")" "then" ExprSingle "else" ExprSingle
 ********************************************************************************/
@@ -96,16 +96,9 @@
   friend class ExprIterator;
   friend class expr;
 
-public:
-  enum order_type_t
-  {
-    ordered,
-    unordered
-  };
-
 protected:
-  order_type_t   theType;
-  expr         * theExpr;
+  expr         * theInput;
+  DocOrderMode   theType;
 
 protected:
   order_expr(
@@ -113,13 +106,13 @@
       static_context* sctx,
       user_function* udf,
       const QueryLoc&,
-      order_type_t,
+      DocOrderMode,
       expr*);
 
 public:
-  order_type_t get_type() const { return theType; }
+  expr* get_input() const { return theInput; }
 
-  expr* get_expr() const { return theExpr; }
+  DocOrderMode get_type() const { return theType; }
 
   void compute_scripting_kind();
 
@@ -139,10 +132,10 @@
   friend class expr;
 
 protected:
-  ParseConstants::validation_mode_t theMode;
-  store::Item_t                     theTypeName;
-  rchandle<TypeManager>             theTypeMgr;
-  expr                            * theExpr;
+  expr                             * theInput;
+  ParseConstants::validation_mode_t  theMode;
+  store::Item_t                      theTypeName;
+  rchandle<TypeManager>              theTypeMgr;
 
 protected:
   validate_expr(
@@ -156,7 +149,7 @@
       rchandle<TypeManager>);
 
 public:
-  expr* get_expr() const { return theExpr; }
+  expr* get_input() const { return theInput; }
 
   const store::Item* get_type_name() const { return theTypeName; }
 
@@ -205,7 +198,7 @@
   friend class expr;
 
 protected:
-  expr     * theInputExpr;
+  expr     * theInput;
   xqtref_t   theTargetType;
 
 protected:
@@ -219,7 +212,7 @@
       const xqtref_t& type);
 
 public:
-  expr* get_input() const { return theInputExpr; }
+  expr* get_input() const { return theInput; }
 
   xqtref_t get_target_type() const;
 
@@ -297,9 +290,9 @@
   friend class expr;
 
 protected:
-  TreatIterator::ErrorKind theErrorKind;
-  bool                     theCheckPrime;
-  store::Item_t            theQName;
+  TreatErrorKind  theErrorKind;
+  bool            theCheckPrime;
+  store::Item_t   theQName;
 
 protected:
   treat_expr(
@@ -309,12 +302,12 @@
       const QueryLoc&,
       expr*,
       const xqtref_t&,
-      TreatIterator::ErrorKind err,
+      TreatErrorKind err,
       bool check_prime = true,
       store::Item* qname = NULL);
 
 public:
-  TreatIterator::ErrorKind get_err() const { return theErrorKind; }
+  TreatErrorKind get_err() const { return theErrorKind; }
 
   bool get_check_prime() const { return theCheckPrime; }
 
@@ -375,8 +368,8 @@
   friend class expr;
 
 protected:
-  PromoteIterator::ErrorKind theErrorKind;
-  store::Item_t              theQName;
+  PromoteErrorKind theErrorKind;
+  store::Item_t    theQName;
 
 protected:
   promote_expr(
@@ -386,11 +379,11 @@
       const QueryLoc& loc,
       expr* input,
       const xqtref_t& type,
-      PromoteIterator::ErrorKind err,
+      PromoteErrorKind err,
       store::Item* qname);
 
 public:
-  PromoteIterator::ErrorKind get_err() const { return theErrorKind; }
+  PromoteErrorKind get_err() const { return theErrorKind; }
 
   void set_qname(const store::Item_t& qname) { theQName = qname; }
 
@@ -504,8 +497,8 @@
   friend class expr;
 
 private:
-  expr*             theInputExpr;
-  bool               theIsAttrName;
+  expr  * theInputExpr;
+  bool    theIsAttrName;
 
 protected:
   name_cast_expr(
@@ -541,7 +534,7 @@
 
 protected:
   expr  * theContent;
-  bool     theCopyInputNodes;
+  bool    theCopyInputNodes;
 
 protected:
   doc_expr(
@@ -713,16 +706,9 @@
   friend class ExprIterator;
   friend class expr;
 
-public:
-  typedef enum
-  {
-    text_constructor,
-    comment_constructor
-  } text_constructor_type;
-
 protected:
-  text_constructor_type   type;
-  expr                  * theContentExpr;
+  TextConstructorType   type;
+  expr                * theContentExpr;
 
 protected:
   text_expr(
@@ -730,13 +716,13 @@
       static_context* sctx,
       user_function* udf,
       const QueryLoc&,
-      text_constructor_type,
+      TextConstructorType,
       expr*);
 
 public:
   expr* get_text() const { return theContentExpr; }
 
-  text_constructor_type get_type() const { return type; }
+  TextConstructorType get_type() const { return type; }
 
   void compute_scripting_kind();
 
@@ -1040,7 +1026,7 @@
   friend class ExprManager;
 
 protected:
-  expr  * theWrappedExpr;
+  expr    * theInput;
 
 protected:
   wrapper_expr(
@@ -1051,9 +1037,9 @@
       expr* wrapped);
 
 public:
-  expr* get_expr() const { return theWrappedExpr; }
+  expr* get_input() const { return theInput; }
 
-  void set_expr(expr* e) { theWrappedExpr = e;}
+  void set_expr(expr* e) { theInput = e;}
 
   void compute_scripting_kind();
 
@@ -1073,11 +1059,11 @@
   friend class ExprManager;
 
 protected:
-  expr*        theExpr;
-  store::Item_t theFunctionName;
-  QueryLoc      theFunctionLocation;
-  QueryLoc      theFunctionCallLocation;
-  unsigned int  theFunctionArity;
+  expr         * theInput;
+  store::Item_t  theFunctionName;
+  QueryLoc       theFunctionLocation;
+  QueryLoc       theFunctionCallLocation;
+  unsigned int   theFunctionArity;
 
 protected:
   function_trace_expr(
@@ -1094,14 +1080,14 @@
 public:
   virtual ~function_trace_expr();
 
+  expr* get_input() const { return theInput; }
+
   void compute_scripting_kind();
 
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
 
-  expr* get_expr() const { return theExpr; }
-
   void setFunctionName(store::Item_t aFunctionName)
   {
     theFunctionName = aFunctionName;
@@ -1215,12 +1201,7 @@
 
   const std::vector<xqtref_t>& get_var_types() const { return theOuterVarTypes; }
 
-  void add_var(var_expr* var)
-  {
-    theOuterVarNames.push_back(var->get_name());
-    theOuterVarTypes.push_back(var->get_return_type());
-    theArgs.push_back(var);
-  }
+  void add_var(var_expr* var);
 
   expr_script_kind_t get_inner_scripting_kind() const;
 
@@ -1288,11 +1269,7 @@
 
   const var_expr* get_var(csize i) const { return theVars[i]; }
 
-  void add_var(var_expr* var, expr* arg)
-  {
-    theVars.push_back(var);
-    theArgs.push_back(arg);
-  }
+  void add_var(var_expr* var, expr* arg);
 
   void compute_scripting_kind();
 };
 
=== modified file 'src/compiler/expression/expr_base.cpp'
--- src/compiler/expression/expr_base.cpp	2012-10-22 15:10:23 +0000
+++ src/compiler/expression/expr_base.cpp	2012-10-24 11:34:21 +0000
@@ -20,6 +20,7 @@
 #include "compiler/expression/fo_expr.h"
 #include "compiler/expression/flwor_expr.h"
 #include "compiler/expression/path_expr.h"
+#include "compiler/expression/script_exprs.h"
 #include "compiler/expression/expr_iter.h"
 #include "compiler/expression/expr_visitor.h"
 #include "compiler/expression/expr_manager.h"
@@ -155,6 +156,7 @@
   // This is the default. The constructors for certain exprs set different values.
   setNonDiscardable(ANNOTATION_FALSE);
   setUnfoldable(ANNOTATION_FALSE);
+  setContainsRecursiveCall(ANNOTATION_FALSE);
   setConstructsNodes(ANNOTATION_FALSE);
   setDereferencesNodes(ANNOTATION_FALSE);
 }
@@ -766,8 +768,7 @@
 
   while (kind == wrapper_expr_kind)
   {
-    const wrapper_expr* wrapperExpr = static_cast<const wrapper_expr*>(currExpr);
-    currExpr = wrapperExpr->get_expr();
+    currExpr = static_cast<const wrapper_expr*>(currExpr)->get_input();
     kind = currExpr->get_expr_kind();
   }
 
@@ -834,14 +835,14 @@
 
   case order_expr_kind:
   {
-    const order_expr* orderExpr = static_cast<const order_expr *>(this);
-    return orderExpr->get_expr()->is_map_internal(e, found);
+    return static_cast<const order_expr*>(this)->get_input()->
+           is_map_internal(e, found);
   }
 
   case wrapper_expr_kind:
   {
-    const wrapper_expr* wrapperExpr = static_cast<const wrapper_expr *>(this);
-    return wrapperExpr->get_expr()->is_map_internal(e, found);
+    return static_cast<const wrapper_expr*>(this)->get_input()->
+           is_map_internal(e, found);
   }
 
   case const_expr_kind:
@@ -896,7 +897,9 @@
         if (found)
           break;
 
-        if (clause->get_expr()->is_map_internal(e, found) && found)
+        const for_clause* fc = static_cast<const for_clause*>(clause);
+
+        if (fc->get_expr()->is_map_internal(e, found) && found)
         {
           break;
         }
@@ -908,12 +911,25 @@
         break;
       }
       case flwor_clause::let_clause:
+      {
+        if (found)
+          break;
+
+        const let_clause* lc = static_cast<const let_clause*>(clause);
+
+        if (lc->get_expr()->contains_expr(e))
+          return false;
+
+        break;
+      }
       case flwor_clause::where_clause:
       {
         if (found)
           break;
 
-        if (clause->get_expr()->contains_expr(e))
+        const where_clause* wc = static_cast<const where_clause*>(clause);
+
+        if (wc->get_expr()->contains_expr(e))
           return false;
 
         break;
@@ -923,10 +939,11 @@
         if (found)
           break;
 
-        if (clause->get_expr()->contains_expr(e))
-          return false;
-
         const window_clause* wc = static_cast<const window_clause*>(clause);
+
+        if (wc->get_expr()->contains_expr(e))
+          return false;
+
         flwor_wincond* startCond = wc->get_win_start();
         flwor_wincond* stopCond = wc->get_win_stop();
 
 
=== modified file 'src/compiler/expression/expr_base.h'
--- src/compiler/expression/expr_base.h	2012-10-22 15:10:23 +0000
+++ src/compiler/expression/expr_base.h	2012-10-24 11:34:21 +0000
@@ -124,7 +124,6 @@
 ********************************************************************************/
 class expr
 {
-  friend class expr_iterator_data;
   friend class ExprIterator;
   friend class forletwin_clause;
   friend class for_clause;
 
=== modified file 'src/compiler/expression/expr_clone.cpp'
--- src/compiler/expression/expr_clone.cpp	2012-10-09 12:56:08 +0000
+++ src/compiler/expression/expr_clone.cpp	2012-10-24 11:34:21 +0000
@@ -24,6 +24,7 @@
 #include "compiler/expression/json_exprs.h"
 #include "compiler/expression/function_item_expr.h"
 #include "compiler/expression/ft_expr.h"
+#include "compiler/expression/ftnode.h"
 #include "compiler/expression/expr_manager.h"
 
 #include "compiler/api/compilercb.h"
@@ -462,7 +463,7 @@
                          theLoc,
                          e->get_valmode(),
                          const_cast<store::Item*>(e->get_type_name()),
-                         e->get_expr()->clone(udf, subst),
+                         e->get_input()->clone(udf, subst),
                          e->get_typemgr());
 
     break;
@@ -502,7 +503,7 @@
                       udf,
                       theLoc,
                       e->get_type(),
-                      e->get_expr()->clone(udf, subst));
+                      e->get_input()->clone(udf, subst));
     break;
   }
 #ifndef ZORBA_NO_FULL_TEXT
@@ -734,9 +735,9 @@
   {
     const wrapper_expr* e = static_cast<const wrapper_expr*>(this);
 
-    expr* wrappedClone = e->theWrappedExpr->clone(udf, subst);
+    expr* wrappedClone = e->theInput->clone(udf, subst);
 
-    if (e->theWrappedExpr->get_expr_kind() == var_expr_kind &&
+    if (e->theInput->get_expr_kind() == var_expr_kind &&
         wrappedClone->get_expr_kind() != var_expr_kind)
     {
       newExpr = wrappedClone;
@@ -753,7 +754,7 @@
     const function_trace_expr* e = static_cast<const function_trace_expr*>(this);
 
     function_trace_expr* cloneExpr = theCCB->theEM->
-    create_function_trace_expr(udf, e->theExpr->clone(udf, subst));
+    create_function_trace_expr(udf, e->theInput->clone(udf, subst));
 
     cloneExpr->theFunctionName = e->theFunctionName;
     cloneExpr->theFunctionLocation = e->theFunctionLocation;
 
=== modified file 'src/compiler/expression/expr_consts.h'
--- src/compiler/expression/expr_consts.h	2012-09-19 21:16:15 +0000
+++ src/compiler/expression/expr_consts.h	2012-10-24 11:34:21 +0000
@@ -21,6 +21,65 @@
 {
 
 
+enum PromoteErrorKind
+{
+  PROMOTE_FUNC_RETURN,
+  PROMOTE_FUNC_PARAM,
+  PROMOTE_TYPE_PROMOTION,
+  PROMOTE_JSONIQ_ARRAY_SELECTOR,
+  PROMOTE_JSONIQ_OBJECT_SELECTOR,
+  PROMOTE_JSONIQ_SELECTOR
+};
+
+
+enum TreatErrorKind
+{
+  TREAT_FUNC_RETURN,
+  TREAT_FUNC_PARAM,
+  TREAT_TYPE_MATCH,
+  TREAT_EXPR,
+  TREAT_INDEX_DOMAIN,
+  TREAT_INDEX_KEY,
+  TREAT_PATH_STEP,
+  TREAT_PATH_DOT,
+  TREAT_MULTI_VALUED_GROUPING_KEY,
+  TREAT_JSONIQ_VALUE,
+  TREAT_JSONIQ_UPDATE_TARGET,
+  TREAT_JSONIQ_OBJECT_UPDATE_TARGET,
+  TREAT_JSONIQ_OBJECT_UPDATE_CONTENT,
+  TREAT_JSONIQ_ARRAY_UPDATE_TARGET,
+  TREAT_JSONIQ_OBJECT_UPDATE_VALUE
+};
+
+
+enum WindowKind
+{
+  tumbling_window,
+  sliding_window
+};
+
+
+enum TextConstructorType
+{
+  text_constructor,
+  comment_constructor
+};
+
+
+enum FlowCtlAction
+{
+  FLOW_BREAK,
+  FLOW_CONTINUE
+};
+
+
+enum DocOrderMode
+{
+  doc_ordered,
+  doc_unordered
+};
+
+
 enum axis_kind_t
 {
   axis_kind_self = 0,
 
=== modified file 'src/compiler/expression/expr_iter.cpp'
--- src/compiler/expression/expr_iter.cpp	2012-10-22 15:10:23 +0000
+++ src/compiler/expression/expr_iter.cpp	2012-10-24 11:34:21 +0000
@@ -94,12 +94,6 @@
 
 void ExprIterator::next()
 {
-  flwor_clause* c = NULL;
-  window_clause* wc = NULL;
-  orderby_clause* oc = NULL;
-  group_clause* gc = NULL;
-  flwor_wincond* wincond = NULL;
-
   switch (theExpr->get_expr_kind())
   {
   case flwor_expr_kind:
@@ -107,6 +101,223 @@
   {
     flwor_expr* flworExpr = static_cast<flwor_expr*>(theExpr);
 
+#if 0
+    switch (theState)
+    {
+    case 0:
+    {
+      theClausesIter = flworExpr->theClauses.begin();
+      theClausesEnd = flworExpr->theClauses.end();
+
+      if (theClausesIter == theClausesEnd)
+      {
+        theIsDone = true;
+        theState = 10;
+        return;
+      }
+
+      flwor_clause* c = *theClausesIter;
+
+      switch (c->get_kind())
+      {
+      case flwor_clause::for_clause:
+      case flwor_clause::let_clause:
+      {
+        theCurrentChild = &(static_cast<forletwin_clause *>(c)->theDomainExpr);
+
+        ++theClausesIter;
+        theState = 1;
+        return;
+      }
+      case flwor_clause::window_clause:
+      {
+        theCurrentChild = &(static_cast<forletwin_clause *>(c)->theDomainExpr);
+
+        theWincondIter = 0;
+        theState = 2;
+        return;
+      }
+      case flwor_clause::where_clause:
+      {
+        theCurrentChild = &(static_cast<where_clause *>(c)->theWhereExpr);
+
+        ++theClausesIter;
+        theState = 1;
+        return;
+      }
+      case flwor_clause::count_clause:
+      {
+        ++theClausesIter;
+        break;
+      }
+      default:
+        ZORBA_ASSERT(false);
+      }
+    }
+    case 1:
+    {
+nextclause:
+
+      while(theClausesIter != theClausesEnd)
+      {
+        flwor_clause* c = *theClausesIter;
+
+        switch (c->get_kind())
+        {
+        case flwor_clause::for_clause:
+        case flwor_clause::let_clause:
+        {
+          theCurrentChild = &(static_cast<forletwin_clause *>(c)->theDomainExpr);
+          ++theClausesIter;
+          return;
+        }
+        case flwor_clause::window_clause:
+        {
+          window_clause* wc = static_cast<window_clause *>(*theClausesIter);
+
+          theCurrentChild = &(wc->theDomainExpr);
+
+          theState = 2;
+          theWincondIter = 0;
+          return;
+        }
+
+        case flwor_clause::where_clause:
+        {
+          theCurrentChild = &(static_cast<where_clause *>(c)->theWhereExpr);
+          ++theClausesIter;
+          return;
+        }
+
+        case flwor_clause::order_clause:
+        {
+          orderby_clause* oc = static_cast<orderby_clause *>(c);
+
+          theArgsIter = oc->theOrderingExprs.begin();
+          theArgsEnd = oc->theOrderingExprs.end();
+          
+          theCurrentChild = &(*theArgsIter);
+          
+          ++theArgsIter;
+          theState = 3;
+          return;
+        }
+
+        case flwor_clause::group_clause:
+        {
+          group_clause* gc = static_cast<group_clause *>(c);
+
+          theGroupVarsIter = gc->theGroupVars.begin();
+          theGroupVarsEnd = gc->theGroupVars.end();
+          theNonGroupVarsIter = gc->theNonGroupVars.begin();
+          theNonGroupVarsEnd = gc->theNonGroupVars.end();
+
+          theCurrentChild = &((*theGroupVarsIter).first);
+
+          ++theGroupVarsIter;
+          theState = 4;
+          return;
+        }
+
+        case flwor_clause::count_clause:
+        {
+          ++theClausesIter;
+          break;
+        }
+
+        default:
+        {
+          ZORBA_ASSERT(false);
+        }
+        }
+      } // while
+
+      theCurrentChild = &(flworExpr->theReturnExpr);
+      theState = 10;
+      return;
+    }
+
+    case 2:
+    {
+      while (theWincondIter < 2)
+      {
+        window_clause* wc = static_cast<window_clause *>(*theClausesIter);
+            
+        flwor_wincond* wincond = (theWincondIter == 0 ?
+                                  wc->theWinStartCond :
+                                  wc->theWinStopCond );
+        if (wincond != 0)
+        {
+          theCurrentChild = &(wincond->theCondExpr);
+          ++theWincondIter;
+          return;
+        }
+
+        ++theWincondIter;
+      }
+
+      theState = 1;
+      ++theClausesIter;
+      goto nextclause;
+    }
+
+    case 3:
+    {
+      while (theArgsIter != theArgsEnd)
+      {
+        theCurrentChild = &(*theArgsIter);
+        ++theArgsIter;
+        return;
+      }
+      
+      theState = 1;
+      ++theClausesIter;
+      goto nextclause;
+    }
+
+    case 4:
+    {
+      while (theGroupVarsIter != theGroupVarsEnd)
+      {
+        theCurrentChild = &((*theGroupVarsIter).first);
+
+        ++theGroupVarsIter;
+        return;
+      }
+
+      theState = 5;
+    }
+
+    case 5:
+    {
+      while (theNonGroupVarsIter != theNonGroupVarsEnd)
+      {
+        theCurrentChild = &((*theNonGroupVarsIter).first);
+
+        ++theNonGroupVarsIter;
+        return;
+      }
+
+      theState = 1;
+      ++theClausesIter;
+      goto nextclause;
+    }
+
+    default:
+    {
+      theIsDone = true;
+      return;
+    }
+    }
+
+#else
+
+    flwor_clause* c = NULL;
+    window_clause* wc = NULL;
+    orderby_clause* oc = NULL;
+    group_clause* gc = NULL;
+    flwor_wincond* wincond = NULL;
+
     EXPR_ITER_BEGIN();
 
     theClausesBegin = flworExpr->theClauses.begin();
@@ -127,6 +338,11 @@
         EXPR_ITER_NEXT(static_cast<let_clause *>(c)->theDomainExpr);
       }
 
+      else if (c->get_kind() == flwor_clause::where_clause)
+      {
+        EXPR_ITER_NEXT(static_cast<where_clause *>(c)->theWhereExpr);
+      }
+
       else if (c->get_kind() == flwor_clause::window_clause)
       {
         for (theWincondIter = 0; theWincondIter < 2; ++theWincondIter)
@@ -146,11 +362,6 @@
         EXPR_ITER_NEXT(wc->theDomainExpr);
       }
 
-      else if (c->get_kind() == flwor_clause::where_clause)
-      {
-        EXPR_ITER_NEXT(static_cast<where_clause *>(c)->theWhereExpr);
-      }
-
       else if (c->get_kind() == flwor_clause::group_clause)
       {
         gc = static_cast<group_clause *>(c);
@@ -188,7 +399,8 @@
 
       if (theClausesEnd != flworExpr->theClauses.end())
       {
-        ulong pos = (ulong)(theClausesIter - theClausesBegin);
+        ZORBA_ASSERT(0);
+        csize pos = (theClausesIter - theClausesBegin);
         if (pos >= flworExpr->num_clauses())
           break;
 
@@ -200,86 +412,55 @@
     EXPR_ITER_NEXT(flworExpr->theReturnExpr);
 
     EXPR_ITER_END();
-    break;
+#endif
+    return;
   }
 
   case relpath_expr_kind:
   {
     EXPR_ITER_BEGIN();
 
-    {
-      relpath_expr* pathExpr = static_cast<relpath_expr*>(theExpr);
-      theArgsIter = pathExpr->theSteps.begin();
-      theArgsEnd = pathExpr->theSteps.end();
-    }
-
+    theArgsIter = static_cast<relpath_expr*>(theExpr)->theSteps.begin();
+    theArgsEnd = static_cast<relpath_expr*>(theExpr)->theSteps.end();
     for (; theArgsIter != theArgsEnd; ++theArgsIter)
     {
       EXPR_ITER_NEXT(*theArgsIter);
     }
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case axis_step_expr_kind:
   {
-    axis_step_expr* axisExpr = static_cast<axis_step_expr*>(theExpr);
-
     EXPR_ITER_BEGIN();
-
-    EXPR_ITER_NEXT(axisExpr->theNodeTest);
-
+    EXPR_ITER_NEXT(static_cast<axis_step_expr*>(theExpr)->theNodeTest);
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case match_expr_kind:
-  {
-    theIsDone = true;
-    break;
-  }
-
   case var_expr_kind:
-  {
-    theIsDone = true;
-    break;
-  }
-
-  case wrapper_expr_kind:
-  {
-    wrapper_expr* wrapperExpr = static_cast<wrapper_expr*>(theExpr);
-
-    EXPR_ITER_BEGIN();
-
-    EXPR_ITER_NEXT(wrapperExpr->theWrappedExpr);
-
-    EXPR_ITER_END();
-    break;
-  }
-
   case const_expr_kind:
+  case flowctl_expr_kind:
   {
     theIsDone = true;
-    break;
+    return;
   }
 
-
   case fo_expr_kind:
   {
-    fo_expr* foExpr = static_cast<fo_expr*>(theExpr);
-
     EXPR_ITER_BEGIN();
 
-    theArgsIter = foExpr->theArgs.begin();
-    theArgsEnd = foExpr->theArgs.end();
+    theArgsIter = static_cast<fo_expr*>(theExpr)->theArgs.begin();
+    theArgsEnd = static_cast<fo_expr*>(theExpr)->theArgs.end();
     for (; theArgsIter != theArgsEnd; ++theArgsIter)
     {
       EXPR_ITER_NEXT(*theArgsIter);
     }
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case cast_expr_kind:
@@ -288,27 +469,55 @@
   case instanceof_expr_kind:
   case castable_expr_kind:
   {
-    cast_or_castable_base_expr* castExpr =
-    static_cast<cast_or_castable_base_expr*>(theExpr);
-
-    EXPR_ITER_BEGIN();
-
-    EXPR_ITER_NEXT(castExpr->theInputExpr);
-
-    EXPR_ITER_END();
-    break;
+    EXPR_ITER_BEGIN();
+    EXPR_ITER_NEXT(static_cast<cast_or_castable_base_expr*>(theExpr)->theInput);
+    EXPR_ITER_END();
+    return;
+  }
+
+  case wrapper_expr_kind:
+  {
+    EXPR_ITER_BEGIN();
+    EXPR_ITER_NEXT(static_cast<wrapper_expr*>(theExpr)->theInput);
+    EXPR_ITER_END();
+    return;
+  }
+
+  case function_trace_expr_kind:
+  {
+    EXPR_ITER_BEGIN();
+    EXPR_ITER_NEXT(static_cast<function_trace_expr*>(theExpr)->theInput);
+    EXPR_ITER_END();
+    return;
+  }
+
+  case order_expr_kind:
+  {
+    if (theState == 0)
+    {
+      theCurrentChild = &(static_cast<order_expr*>(theExpr)->theInput);
+      theState = 1;
+      return;
+    }
+
+    theIsDone = true;
+    return;
+  }
+
+  case validate_expr_kind:
+  {
+    EXPR_ITER_BEGIN();
+    EXPR_ITER_NEXT(static_cast<validate_expr*>(theExpr)->theInput);
+    EXPR_ITER_END();
+    return;
   }
 
   case name_cast_expr_kind:
   {
-    name_cast_expr* nameCastExpr = static_cast<name_cast_expr*>(theExpr);
-
     EXPR_ITER_BEGIN();
-
-    EXPR_ITER_NEXT(nameCastExpr->theInputExpr);
-
+    EXPR_ITER_NEXT(static_cast<name_cast_expr*>(theExpr)->theInputExpr);
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case doc_expr_kind:
@@ -321,7 +530,7 @@
       EXPR_ITER_NEXT(docExpr->theContent);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case elem_expr_kind:
@@ -339,7 +548,7 @@
       EXPR_ITER_NEXT(elemExpr->theContent);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case attr_expr_kind:
@@ -354,7 +563,7 @@
       EXPR_ITER_NEXT(attrExpr->theValueExpr);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case text_expr_kind:
@@ -366,7 +575,7 @@
     EXPR_ITER_NEXT(textExpr->theContentExpr);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case pi_expr_kind:
@@ -374,12 +583,10 @@
     pi_expr* piExpr = static_cast<pi_expr*>(theExpr);
 
     EXPR_ITER_BEGIN();
-
     EXPR_ITER_NEXT(piExpr->theTargetExpr);
     EXPR_ITER_NEXT(piExpr->theContentExpr);
-
     EXPR_ITER_END();
-    break;
+    return;
   }
 
 #ifdef ZORBA_WITH_JSON
@@ -393,7 +600,7 @@
         EXPR_ITER_NEXT(e->theContentExpr);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case json_object_expr_kind:
@@ -406,7 +613,7 @@
         EXPR_ITER_NEXT(e->theContentExpr);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case json_direct_object_expr_kind:
@@ -430,7 +637,7 @@
     }
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
 #endif
@@ -446,31 +653,7 @@
     EXPR_ITER_NEXT(ifExpr->theElseExpr);
 
     EXPR_ITER_END();
-    break;
-  }
-
-  case order_expr_kind:
-  {
-    order_expr* ordExpr = static_cast<order_expr*>(theExpr);
-
-    EXPR_ITER_BEGIN();
-
-    EXPR_ITER_NEXT(ordExpr->theExpr);
-
-    EXPR_ITER_END();
-    break;
-  }
-
-  case validate_expr_kind:
-  {
-    validate_expr* valExpr = static_cast<validate_expr*>(theExpr);
-
-    EXPR_ITER_BEGIN();
-
-    EXPR_ITER_NEXT(valExpr->theExpr);
-
-    EXPR_ITER_END();
-    break;
+    return;
   }
 
   case extension_expr_kind:
@@ -478,11 +661,9 @@
     extension_expr* extExpr = static_cast<extension_expr*>(theExpr);
 
     EXPR_ITER_BEGIN();
-
     EXPR_ITER_NEXT(extExpr->theExpr);
-
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case trycatch_expr_kind:
@@ -501,7 +682,7 @@
     }
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case function_item_expr_kind:
@@ -518,7 +699,7 @@
     }
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case dynamic_function_invocation_expr_kind:
@@ -538,7 +719,7 @@
     }
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case insert_expr_kind:
@@ -551,7 +732,7 @@
     EXPR_ITER_NEXT(insExpr->theTargetExpr);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case delete_expr_kind:
@@ -563,7 +744,7 @@
     EXPR_ITER_NEXT(delExpr->theTargetExpr);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case replace_expr_kind:
@@ -576,7 +757,7 @@
     EXPR_ITER_NEXT(repExpr->theSourceExpr);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case rename_expr_kind:
@@ -589,7 +770,7 @@
     EXPR_ITER_NEXT(renExpr->theSourceExpr);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case transform_expr_kind:
@@ -609,7 +790,7 @@
     EXPR_ITER_NEXT(trfExpr->theReturnExpr);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case block_expr_kind:
@@ -626,7 +807,7 @@
     }
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case apply_expr_kind:
@@ -635,7 +816,7 @@
     EXPR_ITER_BEGIN();
     EXPR_ITER_NEXT(applyExpr->theExpr);
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case var_decl_expr_kind:
@@ -648,7 +829,7 @@
       EXPR_ITER_NEXT(varDeclExpr->theInitExpr);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case var_set_expr_kind:
@@ -657,13 +838,7 @@
     EXPR_ITER_BEGIN();
     EXPR_ITER_NEXT(varSetExpr->theExpr);
     EXPR_ITER_END();
-    break;
-  }
-
-  case flowctl_expr_kind:
-  {
-    theIsDone = true;
-    break;
+    return;
   }
 
   case while_expr_kind:
@@ -671,11 +846,9 @@
     while_expr* whileExpr = static_cast<while_expr*>(theExpr);
 
     EXPR_ITER_BEGIN();
-
     EXPR_ITER_NEXT(whileExpr->theBody);
-
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case exit_expr_kind:
@@ -683,11 +856,9 @@
     exit_expr* exitExpr = static_cast<exit_expr*>(theExpr);
 
     EXPR_ITER_BEGIN();
-
     EXPR_ITER_NEXT(exitExpr->theExpr);
-
     EXPR_ITER_END();
-    break;
+    return;
   }
 
   case exit_catcher_expr_kind:
@@ -699,7 +870,7 @@
     EXPR_ITER_NEXT(catcherExpr->theExpr);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
 #ifndef ZORBA_NO_FULL_TEXT
@@ -723,7 +894,7 @@
       EXPR_ITER_NEXT(ftExpr->ftignore_);
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 #endif /* ZORBA_NO_FULL_TEXT */
 
@@ -743,7 +914,7 @@
     }
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 
 #ifdef ZORBA_WITH_DEBUGGER
@@ -763,19 +934,10 @@
     }
 
     EXPR_ITER_END();
-    break;
+    return;
   }
 #endif
 
-  case function_trace_expr_kind:
-  {
-    function_trace_expr* dummyExpr = static_cast<function_trace_expr*>(theExpr);
-    EXPR_ITER_BEGIN();
-    EXPR_ITER_NEXT(dummyExpr->theExpr);
-    EXPR_ITER_END();
-    break;
-  }
-
   default:
   {
     ZORBA_ASSERT(false);
 
=== modified file 'src/compiler/expression/expr_manager.cpp'
--- src/compiler/expression/expr_manager.cpp	2012-10-09 14:06:08 +0000
+++ src/compiler/expression/expr_manager.cpp	2012-10-24 11:34:21 +0000
@@ -179,7 +179,7 @@
     static_context* sctx,
     user_function* udf,
     const QueryLoc& loc,
-    order_expr::order_type_t order,
+    DocOrderMode order,
     expr* exp)
 {
   CREATE_AND_RETURN_EXPR(order_expr, sctx, udf, loc, order, exp);
@@ -216,7 +216,7 @@
     const QueryLoc& loc,
     expr* treated,
     const xqtref_t& type,
-    TreatIterator::ErrorKind err,
+    TreatErrorKind err,
     bool check_prime,
     store::Item* qname)
 {
@@ -231,7 +231,7 @@
     const QueryLoc& loc,
     expr* promoted,
     const xqtref_t& type,
-    PromoteIterator::ErrorKind err,
+    PromoteErrorKind err,
     store::Item* qname)
 {
   CREATE_AND_RETURN_EXPR(promote_expr, sctx, udf, loc, promoted, type, err, qname);
@@ -329,7 +329,7 @@
     static_context* sctx,
     user_function* udf,
     const QueryLoc& loc,
-    text_expr::text_constructor_type textType,
+    TextConstructorType textType,
     expr* text)
 {
   CREATE_AND_RETURN_EXPR(text_expr, sctx, udf, loc, textType, text);
@@ -538,10 +538,15 @@
     static_context* sctx,
     user_function* udf,
     const QueryLoc& loc,
-    var_expr::var_kind k,
+    ulong varKind,
     store::Item* name)
 {
-  CREATE_AND_RETURN_EXPR(var_expr, sctx, udf, loc, k, name);
+  CREATE_AND_RETURN_EXPR(var_expr,
+                         sctx,
+                         udf,
+                         loc,
+                         static_cast<var_expr::var_kind>(varKind),
+                         name);
 }
 
 
@@ -729,7 +734,7 @@
     static_context* sctx,
     user_function* udf,
     const QueryLoc& loc,
-    flowctl_expr::action action)
+    FlowCtlAction action)
 {
   CREATE_AND_RETURN_EXPR(flowctl_expr, sctx, udf, loc, action);
 }
@@ -908,7 +913,7 @@
 window_clause* ExprManager::create_window_clause(
     static_context* sctx,
     const QueryLoc& loc,
-    window_clause::window_t winKind,
+    WindowKind winKind,
     var_expr* varExpr,
     expr* domainExpr,
     flwor_wincond* winStart,
@@ -935,7 +940,7 @@
     static_context* sctx,
     const QueryLoc& loc,
     const flwor_clause::rebind_list_t& gvars,
-    flwor_clause::rebind_list_t ngvars,
+    const flwor_clause::rebind_list_t& ngvars,
     const std::vector<std::string>& collations)
 {
   CREATE_AND_RETURN(group_clause, sctx, theCCB,  loc, gvars, ngvars, collations);
 
=== modified file 'src/compiler/expression/expr_manager.h'
--- src/compiler/expression/expr_manager.h	2012-10-09 14:06:08 +0000
+++ src/compiler/expression/expr_manager.h	2012-10-24 11:34:21 +0000
@@ -19,17 +19,37 @@
 #define ZORBA_COMPILER_EXPRMANAGER_H
 
 #include "expr_classes.h"
-#include "expr.h"
-#include "script_exprs.h"
-#include "flwor_expr.h"
-#include "ftnode.h"
-
+#include "expr_consts.h"
+#include "expr_utils.h"
 #include "mem_manager.h"
 
+#include "compiler/parser/parse_constants.h"
+
+#include "zorbatypes/schema_types.h"
+
+#include "store/api/update_consts.h"
+
+
 namespace zorba
 {
 
 class CompilerCB;
+class expr;
+class var_expr;
+class catch_clause;
+class pragma;
+class flwor_clause;
+class flwor_wincond;
+class copy_clause;
+class window_clause;
+class group_clause;
+class where_clause;
+class count_clause;
+class orderby_clause;
+class materialize_clause;
+struct flwor_wincond_vars;
+class ftnode;
+
 
 
 class ExprManager
@@ -86,7 +106,7 @@
       static_context* sctx,
       user_function* udf,
       const QueryLoc& loc,
-      order_expr::order_type_t,
+      DocOrderMode,
       expr*);
 
   validate_expr* create_validate_expr(
@@ -111,7 +131,7 @@
       const QueryLoc& loc,
       expr* input,
       const xqtref_t& type,
-      TreatIterator::ErrorKind err,
+      TreatErrorKind err,
       bool check_prime = true,
       store::Item* qnname = NULL);
 
@@ -122,7 +142,7 @@
       const QueryLoc& loc,
       expr* input,
       const xqtref_t& type,
-      PromoteIterator::ErrorKind err,
+      PromoteErrorKind err,
       store::Item* qname);
 
   castable_expr* create_castable_expr(
@@ -185,7 +205,7 @@
       static_context* sctx,
       user_function* udf,
       const QueryLoc&,
-      text_expr::text_constructor_type,
+      TextConstructorType,
       expr*);
 
   pi_expr* create_pi_expr(
@@ -312,7 +332,7 @@
       static_context* sctx,
       user_function* udf,
       const QueryLoc& loc,
-      var_expr::var_kind k,
+      ulong varKind,
       store::Item* name);
 
   var_expr* create_var_expr(user_function* udf, const var_expr& source);
@@ -427,7 +447,7 @@
       static_context* sctx,
       user_function* udf,
       const QueryLoc& loc,
-      flowctl_expr::action action);
+      FlowCtlAction action);
 
   while_expr* create_while_expr(
       static_context* sctx,
@@ -479,7 +499,7 @@
       user_function* udf,
       QueryLoc const&,
       expr* range,
-      ftnode *ftselection,
+      ftnode* ftselection,
       expr* ftignore);
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -539,7 +559,7 @@
   window_clause* create_window_clause(
       static_context* sctx,
       const QueryLoc& loc,
-      window_clause::window_t winKind,
+      WindowKind winKind,
       var_expr* varExpr,
       expr* domainExpr,
       flwor_wincond* winStart,
@@ -549,15 +569,15 @@
   flwor_wincond* create_flwor_wincond(
       static_context* sctx,
       bool isOnly,
-      const flwor_wincond::vars& in_vars,
-      const flwor_wincond::vars& out_vars,
+      const flwor_wincond_vars& in_vars,
+      const flwor_wincond_vars& out_vars,
       expr* cond);
 
   group_clause* create_group_clause(
       static_context* sctx,
       const QueryLoc& loc,
-      const flwor_clause::rebind_list_t& gvars,
-      flwor_clause::rebind_list_t ngvars,
+      const var_rebind_list_t& gvars,
+      const var_rebind_list_t& ngvars,
       const std::vector<std::string>& collations);
 
   orderby_clause * create_orderby_clause (
 
=== modified file 'src/compiler/expression/expr_put.cpp'
--- src/compiler/expression/expr_put.cpp	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/expr_put.cpp	2012-10-24 11:34:21 +0000
@@ -154,9 +154,9 @@
   get_expr()->put(os);
   return os;
 #else
-  if (get_expr()->get_expr_kind() == var_expr_kind)
+  if (get_input()->get_expr_kind() == var_expr_kind)
   {
-    const var_expr* varExpr = static_cast<const var_expr*>(get_expr());
+    const var_expr* varExpr = static_cast<const var_expr*>(get_input());
 
     BEGIN_PUT_NO_EOL(var_ref) ;
     put_qname(varExpr->get_name(), os);
@@ -165,8 +165,8 @@
   }
   else
   {
-    BEGIN_PUT( wrapper_expr );
-    get_expr()->put(os);
+    BEGIN_PUT(wrapper_expr);
+    get_input()->put(os);
     END_PUT();
   }
 #endif
@@ -440,7 +440,7 @@
 {
   os << indent << "promote_expr " << theTargetType->toString()
      << expr_addr (this) << " [\n" << inc_indent;
-  theInputExpr->put(os);
+  theInput->put(os);
   END_PUT();
 }
 
@@ -491,7 +491,7 @@
 ostream& function_trace_expr::put(ostream& os) const
 {
   BEGIN_PUT(function_trace_expr);
-  theExpr->put(os);
+  theInput->put(os);
   END_PUT();
 }
 
@@ -599,28 +599,28 @@
 ostream& instanceof_expr::put( ostream& os) const
 {
   BEGIN_PUT1( instanceof_expr, theTargetType->toString() );
-  theInputExpr->put(os);
+  theInput->put(os);
   END_PUT();
 }
 
 ostream& treat_expr::put( ostream& os) const
 {
   BEGIN_PUT1( treat_expr, theTargetType->toString() );
-  theInputExpr->put(os);
+  theInput->put(os);
   END_PUT();
 }
 
 ostream& castable_expr::put( ostream& os) const
 {
   BEGIN_PUT1( castable_expr, theTargetType->toString() );
-  theInputExpr->put(os);
+  theInput->put(os);
   END_PUT();
 }
 
 ostream& cast_expr::put( ostream& os) const
 {
   BEGIN_PUT1( cast_expr, theTargetType->toString() );
-  theInputExpr->put(os);
+  theInput->put(os);
   END_PUT();
 }
 
@@ -643,7 +643,7 @@
   case ParseConstants::val_typename: os << "typename\n"; break;
   default: os << "??\n";
   }
-  theExpr->put(os) << endl;
+  theInput->put(os) << endl;
   END_PUT();
 }
 
@@ -796,16 +796,16 @@
 
 ostream& order_expr::put(ostream& os) const
 {
-  os << indent << "order_expr" << expr_addr (this) << "\n" << inc_indent
+  os << indent << "order_expr" << expr_addr(this) << "\n" << inc_indent
      << indent << "[ ";
 
   switch (theType)
   {
-  case ordered: os << "ordered\n"; break;
-  case unordered: os << "unordered\n"; break;
+  case doc_ordered: os << "ordered\n"; break;
+  case doc_unordered: os << "unordered\n"; break;
   default: os << "??\n";
   }
-  theExpr->put(os) << endl;
+  theInput->put(os) << endl;
   END_PUT();
 }
 
 
=== modified file 'src/compiler/expression/expr_type.cpp'
--- src/compiler/expression/expr_type.cpp	2012-10-16 13:08:12 +0000
+++ src/compiler/expression/expr_type.cpp	2012-10-24 11:34:21 +0000
@@ -105,14 +105,6 @@
     break;
   }
 
-  case order_expr_kind:
-  {
-    order_expr* e = static_cast<order_expr*>(this);
-
-    newType = e->theExpr->get_return_type();
-    break;
-  }
-
   case validate_expr_kind:
   {
     theType = rtm.ANY_NODE_TYPE_ONE;
@@ -332,7 +324,7 @@
   {
     cast_expr* e = static_cast<cast_expr*>(this);
 
-    xqtref_t argType = e->theInputExpr->get_return_type();
+    xqtref_t argType = e->theInput->get_return_type();
     TypeConstants::quantifier_t argQuant = argType->get_quantifier();
     TypeConstants::quantifier_t targetQuant = e->theTargetType->get_quantifier();
 
@@ -378,7 +370,7 @@
   {
     promote_expr* e = static_cast<promote_expr*>(this);
 
-    xqtref_t in_type = e->theInputExpr->get_return_type();
+    xqtref_t in_type = e->theInput->get_return_type();
     xqtref_t in_ptype = TypeOps::prime_type(tm, *in_type);
     xqtref_t target_ptype = TypeOps::prime_type(tm, *e->theTargetType);
 
@@ -490,7 +482,7 @@
 
     switch (e->type)
     {
-    case text_expr::text_constructor:
+    case text_constructor:
     {
       xqtref_t t = e->get_text()->get_return_type();
 
@@ -504,7 +496,7 @@
       break;
     }
 
-    case text_expr::comment_constructor:
+    case comment_constructor:
       nodeKind = store::StoreConsts::commentNode;
       break;
 
@@ -702,15 +694,19 @@
 
   case function_trace_expr_kind:
   {
-    function_trace_expr* e = static_cast<function_trace_expr*>(this);
-    newType = e->theExpr->get_return_type();
+    newType = static_cast<function_trace_expr*>(this)->theInput->get_return_type();
+    break;
+  }
+
+  case order_expr_kind:
+  {
+    newType = static_cast<order_expr*>(this)->theInput->get_return_type();
     break;
   }
 
   case wrapper_expr_kind:
   {
-    wrapper_expr* e = static_cast<wrapper_expr*>(this);
-    newType = e->theWrappedExpr->get_return_type();
+    newType = static_cast<wrapper_expr*>(this)->theInput->get_return_type();
     break;
   }
 
 
=== modified file 'src/compiler/expression/expr_utils.h'
--- src/compiler/expression/expr_utils.h	2012-09-19 21:16:15 +0000
+++ src/compiler/expression/expr_utils.h	2012-10-24 11:34:21 +0000
@@ -22,6 +22,9 @@
 namespace zorba 
 {
 
+class expr;
+class var_expr;
+
 /******************************************************************************
   Used by the orderspecs of an order by clause, and by the keyspecs of an
   index declaration.
@@ -47,6 +50,11 @@
 };
 
 
+/******************************************************************************
+
+********************************************************************************/
+typedef std::vector<std::pair<expr*, var_expr*> > var_rebind_list_t;
+
 }
 #endif
 
 
=== modified file 'src/compiler/expression/flwor_expr.cpp'
--- src/compiler/expression/flwor_expr.cpp	2012-10-22 15:10:23 +0000
+++ src/compiler/expression/flwor_expr.cpp	2012-10-24 11:34:21 +0000
@@ -25,6 +25,7 @@
 #include "compiler/expression/fo_expr.h"
 #include "compiler/expression/expr.h"
 #include "compiler/expression/expr_visitor.h"
+#include "compiler/expression/expr_manager.h"
 
 #include "compiler/api/compilercb.h"
 
@@ -111,7 +112,7 @@
                           theDomainExpr->get_loc(),
                           theDomainExpr,
                           varType,
-                          TreatIterator::TYPE_MATCH);
+                          TREAT_TYPE_MATCH);
       }
     }
   }
@@ -180,7 +181,7 @@
                             loc,
                             domainExpr,
                             declaredType,
-                            TreatIterator::TYPE_MATCH);
+                            TREAT_TYPE_MATCH);
 
           set_expr(domainExpr);
         }
@@ -307,7 +308,7 @@
                           loc,
                           domainExpr,
                           declaredType,
-                          TreatIterator::TYPE_MATCH);
+                          TREAT_TYPE_MATCH);
 
         set_expr(domainExpr);
       }
@@ -370,7 +371,7 @@
     static_context* sctx,
     CompilerCB* ccb,
     const QueryLoc& loc,
-    window_t winKind,
+    WindowKind winKind,
     var_expr* varExpr,
     expr* domainExpr,
     flwor_wincond* winStart,
@@ -412,7 +413,7 @@
                           loc,
                           domainExpr,
                           varType,
-                          TreatIterator::TYPE_MATCH);
+                          TREAT_TYPE_MATCH);
 
         set_expr(domainExpr);
       }
@@ -523,7 +524,7 @@
 }
 
 
-flwor_wincond::vars::vars()
+flwor_wincond_vars::flwor_wincond_vars()
   :
   posvar(NULL),
   curr(NULL),
@@ -533,13 +534,13 @@
 }
 
 
-flwor_wincond::vars::~vars()
+flwor_wincond_vars::~flwor_wincond_vars()
 {
 //  set_flwor_clause(NULL);
 }
 
 
-void flwor_wincond::vars::set_flwor_clause(flwor_clause* c)
+void flwor_wincond_vars::set_flwor_clause(flwor_clause* c)
 {
   if (posvar != NULL) posvar->set_flwor_clause(c);
   if (curr != NULL) curr->set_flwor_clause(c);
@@ -548,7 +549,7 @@
 }
 
 
-void flwor_wincond::vars::clone(
+void flwor_wincond_vars::clone(
     ExprManager* mgr,
     user_function* udf,
     flwor_wincond::vars& cloneVars,
@@ -619,7 +620,7 @@
      CompilerCB* ccb,
      const QueryLoc& loc,
      const rebind_list_t& gvars,
-     rebind_list_t ngvars,
+     const rebind_list_t& ngvars,
      const std::vector<std::string>& collations)
   :
   flwor_clause(sctx, ccb, loc, flwor_clause::group_clause),
@@ -808,6 +809,8 @@
   flwor_clause(sctx, ccb, loc, flwor_clause::count_clause),
   theVarExpr(var)
 {
+  if (theVarExpr != NULL)
+    theVarExpr->set_flwor_clause(this);
 }
 
 
 
=== modified file 'src/compiler/expression/flwor_expr.h'
--- src/compiler/expression/flwor_expr.h	2012-10-22 15:10:23 +0000
+++ src/compiler/expression/flwor_expr.h	2012-10-24 11:34:21 +0000
@@ -51,7 +51,7 @@
   friend class ExprManager;
 
 public:
-  typedef std::vector<std::pair<expr*, var_expr*> > rebind_list_t;
+  typedef var_rebind_list_t rebind_list_t;
 
   typedef enum
   {
@@ -98,8 +98,6 @@
 
   flwor_expr* get_flwor_expr() const { return theFlworExpr; }
 
-  virtual expr* get_expr() const { return NULL; }
-
   virtual void set_expr(expr* v) { }
 
   virtual var_expr* get_pos_var() const { return NULL; }
@@ -271,11 +269,8 @@
   friend class ExprManager;
   friend class ExprIterator;
 
-public:
-  typedef enum { tumbling_window, sliding_window } window_t;
-
 protected:
-  window_t         theWindowKind;
+  WindowKind       theWindowKind;
   flwor_wincond  * theWinStartCond;
   flwor_wincond  * theWinStopCond;
   bool             theLazyEval;
@@ -285,7 +280,7 @@
         static_context* sctx,
         CompilerCB* ccb,
         const QueryLoc& loc,
-        window_t winKind,
+        WindowKind winKind,
         var_expr* varExpr,
         expr* domainExpr,
         flwor_wincond* winStart,
@@ -295,7 +290,7 @@
 public:
   ~window_clause();
 
-  window_t get_winkind() const { return theWindowKind; }
+  WindowKind get_winkind() const { return theWindowKind; }
 
   flwor_wincond* get_win_start() const { return theWinStartCond; }
 
@@ -317,6 +312,32 @@
 
 /***************************************************************************//**
 
+********************************************************************************/
+struct flwor_wincond_vars
+{
+  var_expr* posvar;
+  var_expr* curr;
+  var_expr* prev;
+  var_expr* next;
+
+  flwor_wincond_vars();
+
+  ~flwor_wincond_vars();
+
+  void set_flwor_clause(flwor_clause* c);
+
+  void clone(
+      ExprManager* mgr,
+      user_function* udf,
+      flwor_wincond_vars& cloneVars,
+      expr::substitution_t& subst) const;
+
+  std::ostream& put(std::ostream&) const;
+};
+
+
+/***************************************************************************//**
+
   Class flwor_wincond represents a start/stop condition of a window clause.
 
   - Syntax:
@@ -353,27 +374,7 @@
   friend class ExprIterator;
 
 public:
-  struct vars
-  {
-    var_expr* posvar;
-    var_expr* curr;
-    var_expr* prev;
-    var_expr* next;
-
-    vars();
-
-    ~vars();
-
-    void set_flwor_clause(flwor_clause* c);
-
-    void clone(
-      ExprManager* mgr,
-      user_function* udf,
-      vars& cloneVars,
-      expr::substitution_t& subst) const;
-
-    std::ostream& put(std::ostream&) const;
-  };
+  typedef flwor_wincond_vars vars;
 
 protected:
   bool         theIsOnly;
@@ -456,7 +457,7 @@
       CompilerCB* ccb,
       const QueryLoc& loc,
       const rebind_list_t& gvars,
-      rebind_list_t ngvars,
+      const rebind_list_t& ngvars,
       const std::vector<std::string>& collations);
 
 public:
 
=== modified file 'src/compiler/expression/fo_expr.cpp'
--- src/compiler/expression/fo_expr.cpp	2012-10-09 14:06:08 +0000
+++ src/compiler/expression/fo_expr.cpp	2012-10-24 11:34:21 +0000
@@ -19,6 +19,7 @@
 
 #include "compiler/expression/fo_expr.h"
 #include "compiler/expression/expr_visitor.h"
+#include "compiler/expression/expr_manager.h"
 
 #include "compiler/api/compilercb.h"
 
 
=== modified file 'src/compiler/expression/fo_expr.h'
--- src/compiler/expression/fo_expr.h	2012-10-09 14:06:08 +0000
+++ src/compiler/expression/fo_expr.h	2012-10-24 11:34:21 +0000
@@ -118,30 +118,6 @@
 };
 
 
-////////// The following expressions in the AST "decay" into an fo_expr ///////
-
-typedef fo_expr additive_expr;
-
-typedef fo_expr and_expr;
-
-typedef fo_expr comparison_expr;
-
-typedef fo_expr enclosed_expr;
-
-typedef fo_expr intersect_except_expr;
-
-typedef fo_expr multiplicative_expr;
-
-typedef fo_expr or_expr;
-
-typedef fo_expr quantified_expr;
-
-typedef fo_expr range_expr;
-
-typedef fo_expr unary_expr;
-
-typedef fo_expr union_expr;
-
 } // namespace zorba
 
 #endif
 
=== modified file 'src/compiler/expression/ftnode.h'
--- src/compiler/expression/ftnode.h	2012-10-09 14:06:08 +0000
+++ src/compiler/expression/ftnode.h	2012-10-24 11:34:21 +0000
@@ -20,13 +20,17 @@
 #include <zorba/locale.h>
 
 #include "common/shared_types.h"
+
 #include "compiler/expression/expr_base.h"
 #include "compiler/expression/ftnode_classes.h"
 #include "compiler/parser/ft_types.h"
 #include "compiler/parser/parse_constants.h"
 #include "compiler/parsetree/parsenodes.h"
+
 #include "runtime/base/plan_iterator.h"
+
 #include "util/cxx_util.h"
+
 #include "zorbatypes/rchandle.h"
 #include "zorbatypes/zstring.h"
 
 
=== modified file 'src/compiler/expression/script_exprs.cpp'
--- src/compiler/expression/script_exprs.cpp	2012-10-09 14:06:08 +0000
+++ src/compiler/expression/script_exprs.cpp	2012-10-24 11:34:21 +0000
@@ -26,7 +26,7 @@
 #include "functions/function.h"
 
 #include "diagnostics/assert.h"
-
+#include "diagnostics/xquery_diagnostics.h"
 
 namespace zorba
 {
@@ -401,7 +401,7 @@
     static_context* sctx,
     user_function* udf,
     const QueryLoc& loc,
-    enum action action)
+    FlowCtlAction action)
   :
   expr(ccb, sctx, udf, loc, flowctl_expr_kind),
   theAction(action)
 
=== modified file 'src/compiler/expression/script_exprs.h'
--- src/compiler/expression/script_exprs.h	2012-10-09 14:06:08 +0000
+++ src/compiler/expression/script_exprs.h	2012-10-24 11:34:21 +0000
@@ -390,11 +390,8 @@
   friend class ExprIterator;
   friend class expr;
 
-public:
-  enum action { BREAK, CONTINUE };
-
 protected:
-  enum action theAction;
+  FlowCtlAction theAction;
 
 protected:
   flowctl_expr(
@@ -402,10 +399,10 @@
       static_context* sctx,
       user_function* udf,
       const QueryLoc& loc,
-      enum action action);
+      FlowCtlAction action);
 
 public:
-  enum action get_action() const { return theAction; }
+  FlowCtlAction get_action() const { return theAction; }
 
   void compute_scripting_kind();
 
 
=== modified file 'src/compiler/expression/update_exprs.cpp'
--- src/compiler/expression/update_exprs.cpp	2012-10-22 15:10:23 +0000
+++ src/compiler/expression/update_exprs.cpp	2012-10-24 11:34:21 +0000
@@ -18,6 +18,7 @@
 #include "compiler/expression/update_exprs.h"
 #include "compiler/expression/var_expr.h"
 #include "compiler/expression/expr_visitor.h"
+#include "compiler/expression/expr_manager.h"
 
 #include "compiler/api/compilercb.h"
 
 
=== modified file 'src/compiler/rewriter/framework/rewriter.h'
--- src/compiler/rewriter/framework/rewriter.h	2012-09-19 21:16:15 +0000
+++ src/compiler/rewriter/framework/rewriter.h	2012-10-24 11:34:21 +0000
@@ -29,12 +29,10 @@
 {
 public:
   Rewriter() {}
+
   virtual ~Rewriter() { }
 
   virtual bool rewrite(RewriterContext& rCtx) = 0;
-
-protected:
-  CompilerCB::config::opt_level_t theOptLevel;
 };
 
 }
 
=== modified file 'src/compiler/rewriter/rewriters/default_optimizer.cpp'
--- src/compiler/rewriter/rewriters/default_optimizer.cpp	2012-10-19 20:42:38 +0000
+++ src/compiler/rewriter/rewriters/default_optimizer.cpp	2012-10-24 11:34:21 +0000
@@ -36,8 +36,6 @@
 public:
   FoldRules()
   {
-    //ADD_RULE(MarkExpensiveOps);
-    // Most rules try to update the freevars annotations, but for now let's stay on the safe side
     ADD_RULE(MarkExprs);
     ADD_RULE(MarkFreeVars);
     ADD_RULE(FoldConst(false));
@@ -65,7 +63,6 @@
 
   SingletonRuleMajorDriver<EliminateTypeEnforcingOperations> driverTypeRules;
   SingletonRuleMajorDriver<EliminateExtraneousPathSteps> driverPathSimplify;
-  //SingletonRuleMajorDriver<ReplaceExprWithConstantOneWhenPossible> driverExprSimplify;
   RuleOnceDriver<EliminateUnusedLetVars> driverEliminateVars;
   RuleOnceDriver<MarkProducerNodeProps> driverMarkProducerNodeProps;
   RuleOnceDriver<MarkConsumerNodeProps> driverMarkConsumerNodeProps;
 
=== modified file 'src/compiler/rewriter/rules/flwor_rules.cpp'
--- src/compiler/rewriter/rules/flwor_rules.cpp	2012-10-22 15:10:23 +0000
+++ src/compiler/rewriter/rules/flwor_rules.cpp	2012-10-24 11:34:21 +0000
@@ -23,6 +23,7 @@
 #include "compiler/rewriter/tools/expr_tools.h"
 
 #include "compiler/expression/flwor_expr.h"
+#include "compiler/expression/script_exprs.h"
 #include "compiler/expression/expr_iter.h"
 #include "compiler/expression/expr.h"
 
@@ -239,19 +240,22 @@
 
       if (clause->get_kind() == flwor_clause::where_clause)
       {
-        whereExpr = clause->get_expr();
+        whereExpr = static_cast<where_clause*>(clause)->get_expr();
         const expr::FreeVars& whereVars = whereExpr->getFreeVars();
 
-        if (myVars.empty())
-          flwor.get_vars(myVars);
-
-        expr::FreeVars diff;
-        std::set_intersection(myVars.begin(),
-                              myVars.end(),
-                              whereVars.begin(),
-                              whereVars.end(),
-                              std::inserter(diff, diff.begin()));
-        if (diff.empty())
+        csize k = 0;
+        expr::FreeVars::const_iterator ite = whereVars.begin();
+        expr::FreeVars::const_iterator end = whereVars.end();
+        for (; ite != end; ++ite)
+        {
+          flwor_clause* vc = (*ite)->get_flwor_clause();
+          if (vc != NULL && vc->get_flwor_expr() == flworp)
+            break;
+
+          ++k;
+        }
+
+        if (k == whereVars.size())
         {
           flwor.remove_clause(i);
 
@@ -522,7 +526,7 @@
     }
     else if (clause->get_kind() == flwor_clause::where_clause)
     {
-      expr* whereExpr = clause->get_expr();
+      expr* whereExpr = static_cast<where_clause*>(clause)->get_expr();
 
       //TODO: Consider case where both whereExpr and whereCond ar AND ops
       if (whereCond == NULL)
@@ -638,7 +642,7 @@
   }
   case wrapper_expr_kind:
   {
-    return is_trivial_expr(static_cast<const wrapper_expr*>(e)->get_expr());
+    return is_trivial_expr(static_cast<const wrapper_expr*>(e)->get_input());
   }
   default:
     return false;
@@ -709,10 +713,6 @@
           domExpr->get_return_type()->max_card() >= 2)
         return false;
 
-      // test rbkt/zorba/extern/5890.xq illustrates why this check is needed
-      //if (hasNodeConstr && fc.get_expr()->contains_node_construction())
-      //  return false;
-
       break;
     }
     case flwor_clause::where_clause:
@@ -722,9 +722,11 @@
 
       assert(varQuant == TypeConstants::QUANT_ONE);
 
-      if (std::find(refpath.begin(), refpath.end(), clause->get_expr()) != refpath.end())
+      expr* whereExpr = static_cast<const where_clause*>(clause)->get_expr();
+
+      if (std::find(refpath.begin(), refpath.end(), whereExpr) != refpath.end())
       {
-        referencingExpr = clause->get_expr();
+        referencingExpr = whereExpr;
         break;
       }
 
@@ -1324,7 +1326,7 @@
       if (clause->get_kind() != flwor_clause::where_clause)
         continue;
 
-      expr* whereExpr = clause->get_expr();
+      expr* whereExpr = static_cast<where_clause*>(clause)->get_expr();
 
       expr* posExpr = NULL;
       var_expr* posVar = NULL;
@@ -1807,24 +1809,22 @@
   {
     bool merge = false;
     flwor_expr* nestedFlwor = NULL;
-    ulong numNestedClauses;
+    csize numNestedClauses;
 
     flwor_clause* c = flwor->get_clause(i);
 
-    expr* domainExpr = c->get_expr();
-
-    if (domainExpr != NULL &&
-        domainExpr->get_expr_kind() == flwor_expr_kind &&
-        !domainExpr->is_sequential())
+    if (c->get_kind() == flwor_clause::let_clause)
     {
-      nestedFlwor = static_cast<flwor_expr*>(c->get_expr());
-      numNestedClauses = nestedFlwor->num_clauses();
+      expr* domainExpr = static_cast<let_clause*>(c)->get_expr();
 
-      if (c->get_kind() == flwor_clause::let_clause)
+      if (domainExpr->get_expr_kind() == flwor_expr_kind &&
+          !domainExpr->is_sequential())
       {
+        nestedFlwor = static_cast<flwor_expr*>(domainExpr);
+        numNestedClauses = nestedFlwor->num_clauses();
         merge = true;
 
-        for (ulong j = 0; j < numNestedClauses; ++j)
+        for (csize j = 0; j < numNestedClauses; ++j)
         {
           flwor_clause* nestedClause = nestedFlwor->get_clause(j);
           flwor_clause::ClauseKind nestedClauseKind = nestedClause->get_kind();
@@ -1832,7 +1832,7 @@
           if (nestedClauseKind == flwor_clause::for_clause)
           {
             xqtref_t nestedDomainType =
-              nestedClause->get_expr()->get_return_type();
+            static_cast<for_clause*>(nestedClause)->get_expr()->get_return_type();
 
             if (nestedDomainType->get_quantifier() != TypeConstants::QUANT_ONE)
             {
@@ -1847,12 +1847,20 @@
           }
         }
       }
-      else if (c->get_kind() == flwor_clause::for_clause &&
-               c->get_pos_var() == NULL)
+    }
+    else if (c->get_kind() == flwor_clause::for_clause &&
+             static_cast<for_clause*>(c)->get_pos_var() == NULL)
+    {
+      expr* domainExpr = static_cast<for_clause*>(c)->get_expr();
+
+      if (domainExpr->get_expr_kind() == flwor_expr_kind &&
+          !domainExpr->is_sequential())
       {
+        nestedFlwor = static_cast<flwor_expr*>(domainExpr);
+        numNestedClauses = nestedFlwor->num_clauses();
         merge = true;
 
-        for (ulong j = 0; j < numNestedClauses; ++j)
+        for (csize j = 0; j < numNestedClauses; ++j)
         {
           flwor_clause* nestedClause = nestedFlwor->get_clause(j);
           flwor_clause::ClauseKind nestedClauseKind = nestedClause->get_kind();
 
=== modified file 'src/compiler/rewriter/rules/fold_rules.cpp'
--- src/compiler/rewriter/rules/fold_rules.cpp	2012-10-22 15:10:23 +0000
+++ src/compiler/rewriter/rules/fold_rules.cpp	2012-10-24 11:34:21 +0000
@@ -51,8 +51,6 @@
 
 namespace zorba {
 
-static void remove_wincond_vars(const flwor_wincond*, expr::FreeVars&);
-
 static bool standalone_expr(expr*);
 
 static bool already_folded(expr*, RewriterContext&);
@@ -236,84 +234,82 @@
     iter.next();
   }
 
+  switch (node->get_expr_kind())
+  {
+  case fo_expr_kind:
+  {
+    fo_expr* fo = static_cast<fo_expr *>(node);
+    function* f = fo->get_func();
+        
+    if (!f->isUdf())
+    {
+      if (FunctionConsts::FN_ERROR_0 <= f->getKind() &&
+          f->getKind() <= FunctionConsts::FN_TRACE_2)
+      {
+        curNonDiscardable = ANNOTATION_TRUE_FIXED;
+        curUnfoldable = ANNOTATION_TRUE_FIXED;
+      }
+      else if (f->getKind() == FunctionConsts::FN_ZORBA_REF_NODE_BY_REFERENCE_1)
+      {
+        curDereferencesNodes = ANNOTATION_TRUE;
+      }
+      
+      // Do not fold functions that always require access to the dynamic context,
+      // or may need to access the implicit timezone (which is also in the dynamic
+      // constext).
+      if (saveUnfoldable != ANNOTATION_TRUE_FIXED &&
+          (f->accessesDynCtx() ||
+           maybe_needs_implicit_timezone(fo) ||
+           !f->isDeterministic()))
+      {
+        curUnfoldable = ANNOTATION_TRUE_FIXED;
+      }
+    }
+    else if (theIsLocal)
+    {
+      curUnfoldable = saveUnfoldable;
+      curDereferencesNodes = saveDereferencesNodes;
+      curConstructsNodes = saveConstructsNodes;
+    }
+    else
+    {
+      if (saveUnfoldable != ANNOTATION_TRUE_FIXED &&
+          (f->accessesDynCtx() || !f->isDeterministic()))
+      {
+        curUnfoldable = ANNOTATION_TRUE_FIXED;
+      }
+      
+      if (static_cast<user_function*>(f)->dereferencesNodes())
+        curDereferencesNodes = ANNOTATION_TRUE;
+      
+      if (static_cast<user_function*>(f)->constructsNodes())
+        curConstructsNodes = ANNOTATION_TRUE;
+    }
+    
+    break;
+  }
+  
+  case var_expr_kind:
+  {
+    var_expr::var_kind varKind = static_cast<var_expr *>(node)->get_kind();
+    
+    if (varKind == var_expr::prolog_var || varKind == var_expr::local_var)
+      curUnfoldable = ANNOTATION_TRUE_FIXED;
+    
+    break;
+  }
+  
+  default:
+  {
+    break;
+  }
+  }
+
   if (node->is_sequential())
   {
     curNonDiscardable = ANNOTATION_TRUE_FIXED;
     curUnfoldable = ANNOTATION_TRUE_FIXED;
   }
-  else
-  {
-    switch (node->get_expr_kind())
-    {
-    case fo_expr_kind:
-    {
-      fo_expr* fo = static_cast<fo_expr *>(node);
-      function* f = fo->get_func();
-        
-      if (!f->isUdf())
-      {
-        if (FunctionConsts::FN_ERROR_0 <= f->getKind() &&
-            f->getKind() <= FunctionConsts::FN_TRACE_2)
-        {
-          curNonDiscardable = ANNOTATION_TRUE_FIXED;
-          curUnfoldable = ANNOTATION_TRUE_FIXED;
-        }
-        else if (f->getKind() == FunctionConsts::FN_ZORBA_REF_NODE_BY_REFERENCE_1)
-        {
-          curDereferencesNodes = ANNOTATION_TRUE;
-        }
-
-        // Do not fold functions that always require access to the dynamic context,
-        // or may need to access the implicit timezone (which is also in the dynamic
-        // constext).
-        if (saveUnfoldable != ANNOTATION_TRUE_FIXED &&
-            (f->accessesDynCtx() ||
-             maybe_needs_implicit_timezone(fo) ||
-             !f->isDeterministic()))
-        {
-          curUnfoldable = ANNOTATION_TRUE_FIXED;
-        }
-      }
-      else if (theIsLocal)
-      {
-        curUnfoldable = saveUnfoldable;
-        curDereferencesNodes = saveDereferencesNodes;
-        curConstructsNodes = saveConstructsNodes;
-      }
-      else
-      {
-        if (saveUnfoldable != ANNOTATION_TRUE_FIXED &&
-            (f->accessesDynCtx() || !f->isDeterministic()))
-        {
-          curUnfoldable = ANNOTATION_TRUE_FIXED;
-        }
-
-        if (static_cast<user_function*>(f)->dereferencesNodes())
-          curDereferencesNodes = ANNOTATION_TRUE;
-
-        if (static_cast<user_function*>(f)->constructsNodes())
-          curConstructsNodes = ANNOTATION_TRUE;
-      }
-      
-      break;
-    }
-    
-    case var_expr_kind:
-    {
-      var_expr::var_kind varKind = static_cast<var_expr *>(node)->get_kind();
-        
-      if (varKind == var_expr::prolog_var || varKind == var_expr::local_var)
-        curUnfoldable = ANNOTATION_TRUE_FIXED;
-    
-      break;
-    }
-
-    default:
-    {
-      break;
-    }
-    }
-  }
 
   if (saveNonDiscardable != curNonDiscardable &&
       saveNonDiscardable != ANNOTATION_TRUE_FIXED)
@@ -382,134 +378,79 @@
   For each expr E, collect all the variables that are referenced directly by E
   and its subexpressions.
 ********************************************************************************/
-
-RULE_REWRITE_PRE(MarkFreeVars)
-{
-  return NULL;
-}
-
-RULE_REWRITE_POST(MarkFreeVars)
+expr* MarkFreeVars::apply(RewriterContext& rCtx, expr* node, bool& modified)
 {
   expr::FreeVars& freevars = node->getFreeVars();
 
   freevars.clear();
 
-  if (node->get_expr_kind() == var_expr_kind)
+  switch (node->get_expr_kind())
+  {
+  case var_expr_kind:
   {
     var_expr* v = static_cast<var_expr *>(node);
     freevars.insert(v);
-  }
-  else
-  {
-    // Get the free vars of each child expr and add them to the free vars of the
-    // parent.
-    ExprIterator iter(node);
-    while (!iter.done())
-    {
-      expr* e = **iter;
-
+
+    break;
+  }
+  // Get the free vars of each child expr and add them to the free vars of the
+  // parent. But in case of a flwor expr, do not add any variables defined by
+  // the flwor expr itself
+
+  case flwor_expr_kind:
+  case gflwor_expr_kind:
+  {
+    flwor_expr* flwor = static_cast<flwor_expr *> (node);
+
+    ExprIterator iter(node);
+    while (!iter.done())
+    {
+      expr* e = **iter;
+        
+      apply(rCtx, e, modified);
+
+      const expr::FreeVars& kfv = e->getFreeVars();
+
+      expr::FreeVars::const_iterator ite = kfv.begin();
+      expr::FreeVars::const_iterator end = kfv.end();
+      for (; ite != end; ++ite)
+      {
+        flwor_clause* c = (*ite)->get_flwor_clause();
+        if (c != NULL && c->get_flwor_expr() == flwor)
+          continue;
+        
+        freevars.insert(*ite);
+      }
+      
+      iter.next();
+    }
+
+    break;
+  }
+  default:
+  {
+    ExprIterator iter(node);
+
+    while (!iter.done())
+    {
+      expr* e = **iter;
+
+      apply(rCtx, e, modified);
+        
       const expr::FreeVars& kfv = e->getFreeVars();
       std::copy(kfv.begin(),
                 kfv.end(),
                 inserter(freevars, freevars.begin()));
-
+      
       iter.next();
     }
-
-    // For a flwor expr, remove the vars defined by the flwor expr itself from
-    // the flwor free vars .
-    if (node->get_expr_kind() == flwor_expr_kind ||
-        node->get_expr_kind() == gflwor_expr_kind)
-    {
-      flwor_expr* flwor = dynamic_cast<flwor_expr *> (node);
-      for (flwor_expr::clause_list_t::const_iterator i = flwor->clause_begin();
-           i != flwor->clause_end();
-           ++i)
-      {
-        const flwor_clause* c = *i;
-
-        if (c->get_kind() == flwor_clause::for_clause)
-        {
-          const for_clause* fc = static_cast<const for_clause *>(c);
-
-          freevars.erase(fc->get_var());
-          if (fc->get_pos_var() != NULL)
-            freevars.erase(fc->get_pos_var());
-        }
-        else if (c->get_kind() == flwor_clause::let_clause)
-        {
-          const let_clause* lc = static_cast<const let_clause *>(c);
-
-          freevars.erase(lc->get_var());
-        }
-        else if (c->get_kind() == flwor_clause::window_clause)
-        {
-          const window_clause* wc = static_cast<const window_clause *>(c);
-
-          freevars.erase(wc->get_var());
-
-          flwor_wincond* startCond = wc->get_win_start();
-          flwor_wincond* stopCond = wc->get_win_stop();
-
-          if (startCond != NULL)
-            remove_wincond_vars(startCond, freevars);
-
-          if (stopCond != NULL)
-            remove_wincond_vars(stopCond, freevars);
-        }
-        else if (c->get_kind() == flwor_clause::group_clause)
-        {
-          const group_clause* gc = static_cast<const group_clause *>(c);
-
-          const flwor_clause::rebind_list_t& gvars = gc->get_grouping_vars();
-          csize numGroupVars = gvars.size();
-
-          for (csize i = 0; i < numGroupVars; ++i)
-          {
-            freevars.erase(gvars[i].second);
-          }
-
-          const flwor_clause::rebind_list_t& ngvars = gc->get_nongrouping_vars();
-          csize numNonGroupVars = ngvars.size();
-
-          for (csize i = 0; i < numNonGroupVars; ++i)
-          {
-            freevars.erase(ngvars[i].second);
-          }
-        }
-        else if (c->get_kind() == flwor_clause::count_clause)
-        {
-          const count_clause* cc = static_cast<const count_clause *>(c);
-
-          freevars.erase(cc->get_var());
-        }
-      }
-    }
+  }
   }
 
   return NULL;
 }
 
 
-static void remove_wincond_vars(
-    const flwor_wincond* cond,
-    expr::FreeVars& freevars)
-{
-  const flwor_wincond::vars& inVars = cond->get_in_vars();
-  const flwor_wincond::vars& outVars = cond->get_out_vars();
-
-  freevars.erase(inVars.posvar);
-  freevars.erase(inVars.curr);
-  freevars.erase(inVars.prev);
-  freevars.erase(inVars.next);
-
-  freevars.erase(outVars.posvar);
-  freevars.erase(outVars.curr);
-  freevars.erase(outVars.prev);
-  freevars.erase(outVars.next);
-}
-
-
 /*******************************************************************************
   Execute const exprs that return at most one item as a result. Replace such
   exprs by either a const_expr whose value is the returned item, or an empty
@@ -1014,7 +955,7 @@
 
       if (c->get_kind() == flwor_clause::for_clause)
       {
-        return c->get_expr();
+        return static_cast<for_clause*>(c)->get_expr();
       }
       else
       {
 
=== modified file 'src/compiler/rewriter/rules/hoist_rules.cpp'
--- src/compiler/rewriter/rules/hoist_rules.cpp	2012-10-20 21:29:37 +0000
+++ src/compiler/rewriter/rules/hoist_rules.cpp	2012-10-24 11:34:21 +0000
@@ -564,7 +564,7 @@
       k == axis_step_expr_kind ||
       k == match_expr_kind ||
       (k == wrapper_expr_kind &&
-       non_hoistable(static_cast<const wrapper_expr*>(e)->get_expr())) ||
+       non_hoistable(static_cast<const wrapper_expr*>(e)->get_input())) ||
       is_already_hoisted(e) ||
       is_enclosed_expr(e) ||
       e->containsRecursiveCall() ||
 
=== modified file 'src/compiler/rewriter/rules/index_join_rule.cpp'
--- src/compiler/rewriter/rules/index_join_rule.cpp	2012-10-10 13:05:50 +0000
+++ src/compiler/rewriter/rules/index_join_rule.cpp	2012-10-24 11:34:21 +0000
@@ -736,9 +736,9 @@
   {
     wrapper_expr* wrapper = reinterpret_cast<wrapper_expr*>(subExpr);
 
-    if (wrapper->get_expr()->get_expr_kind() == var_expr_kind)
+    if (wrapper->get_input()->get_expr_kind() == var_expr_kind)
     {
-      var_expr* var = reinterpret_cast<var_expr*>(wrapper->get_expr());
+      var_expr* var = reinterpret_cast<var_expr*>(wrapper->get_input());
       long varid = -1;
 
       if (rCtx.theVarIdMap->find(var) != rCtx.theVarIdMap->end())
 
=== modified file 'src/compiler/rewriter/rules/nodeid_rules.cpp'
--- src/compiler/rewriter/rules/nodeid_rules.cpp	2012-10-16 13:24:49 +0000
+++ src/compiler/rewriter/rules/nodeid_rules.cpp	2012-10-24 11:34:21 +0000
@@ -122,7 +122,7 @@
 
     order_expr* orderExpr = static_cast<order_expr *>(node);
 
-    rCtx.theIsInOrderedMode = (orderExpr->get_type() == order_expr::ordered ?
+    rCtx.theIsInOrderedMode = (orderExpr->get_type() == doc_ordered ?
                                true : false);
     break;
   }
@@ -278,17 +278,17 @@
 
   case wrapper_expr_kind :
   {
-    wrapper_expr* we = static_cast<wrapper_expr *>(node);
-    pushdown_ignores_sorted_nodes(node, we->get_expr());
-    pushdown_ignores_duplicate_nodes(node, we->get_expr());
+    wrapper_expr* e = static_cast<wrapper_expr *>(node);
+    pushdown_ignores_sorted_nodes(node, e->get_input());
+    pushdown_ignores_duplicate_nodes(node, e->get_input());
     break;
   }
 
   case function_trace_expr_kind :
   {
-    function_trace_expr* fte = static_cast<function_trace_expr*>(node);
-    pushdown_ignores_sorted_nodes(node, fte->get_expr());
-    pushdown_ignores_duplicate_nodes(node, fte->get_expr());
+    function_trace_expr* e = static_cast<function_trace_expr *>(node);
+    pushdown_ignores_sorted_nodes(node, e->get_input());
+    pushdown_ignores_duplicate_nodes(node, e->get_input());
     break;
   }
 
@@ -892,7 +892,7 @@
   {
     validate_expr* e = static_cast<validate_expr *>(node);
     std::vector<expr*> sources;
-    theSourceFinder->findNodeSources(e->get_expr(), sources);
+    theSourceFinder->findNodeSources(e->get_input(), sources);
     markSources(sources);
     break;
   }
 
=== modified file 'src/compiler/rewriter/rules/path_rules.cpp'
--- src/compiler/rewriter/rules/path_rules.cpp	2012-09-19 21:16:15 +0000
+++ src/compiler/rewriter/rules/path_rules.cpp	2012-10-24 11:34:21 +0000
@@ -26,22 +26,22 @@
 
 RULE_REWRITE_PRE(EliminateExtraneousPathSteps)
 {
-  relpath_expr* re = dynamic_cast<relpath_expr *>(node);
-  if (re != NULL)
+  if (node->get_expr_kind() == relpath_expr_kind)
   {
+    relpath_expr* re = static_cast<relpath_expr *>(node);
     csize numSteps = re->size();
 
-    for (csize i = 0; i < numSteps - 1; i++)
+    for (csize i = 1; i < numSteps - 1; ++i)
     {
-      axis_step_expr* axisStep = dynamic_cast<axis_step_expr*>((*re)[i]);
-
-      if (axisStep != NULL &&
-          axisStep->getAxis() == axis_kind_descendant_or_self &&
+      assert((*re)[i]->get_expr_kind() == axis_step_expr_kind);
+
+      axis_step_expr* axisStep = static_cast<axis_step_expr*>((*re)[i]);
+
+      if (axisStep->getAxis() == axis_kind_descendant_or_self &&
           axisStep->getTest()->getTestKind() == match_anykind_test)
       {
-        axis_step_expr* nextStep = dynamic_cast<axis_step_expr*>((*re)[i+1]);
-        if (nextStep != NULL &&
-            nextStep->getAxis() == axis_kind_child)
+        axis_step_expr* nextStep = static_cast<axis_step_expr*>((*re)[i+1]);
+        if (nextStep->getAxis() == axis_kind_child)
         {
           nextStep->setAxis(axis_kind_descendant);
           (*re).erase(i);
@@ -53,7 +53,7 @@
 
     if (numSteps == 1)
     {
-      return (*re) [0];
+      return (*re)[0];
     }
   }
 
 
=== modified file 'src/compiler/rewriter/rules/ruleset.h'
--- src/compiler/rewriter/rules/ruleset.h	2012-10-19 20:42:38 +0000
+++ src/compiler/rewriter/rules/ruleset.h	2012-10-24 11:34:21 +0000
@@ -47,10 +47,10 @@
 
 PREPOST_RULE(MergeFLWOR);
 
+  //PREPOST_RULE(MarkFreeVars);
+
 PREPOST_RULE(EliminateExtraneousPathSteps);
 
-PREPOST_RULE(MarkFreeVars);
-
 PREPOST_RULE(InlineFunctions);
 
 PREPOST_RULE(PartialEval);
@@ -100,6 +100,22 @@
   expr* apply(RewriterContext& rCtx, expr* node, bool& modified);
 };
 
+#if 1
+/*******************************************************************************
+
+********************************************************************************/
+class MarkFreeVars : public RewriteRule
+{
+public:
+  MarkFreeVars()
+    :
+    RewriteRule(RewriteRule::MarkFreeVars, "MarkFreeVars")
+  {
+  }
+
+  expr* apply(RewriterContext& rCtx, expr* node, bool& modified);
+};
+#endif
 
 /*******************************************************************************
 
 
=== modified file 'src/compiler/rewriter/rules/type_rules.cpp'
--- src/compiler/rewriter/rules/type_rules.cpp	2012-10-10 13:05:50 +0000
+++ src/compiler/rewriter/rules/type_rules.cpp	2012-10-24 11:34:21 +0000
@@ -188,7 +188,7 @@
                                            node->get_loc(),
                                            arg,
                                            target_type,
-                                           TreatIterator::TYPE_MATCH,
+                                           TREAT_TYPE_MATCH,
                                            false); // do not check the prime types
     }
 
@@ -268,7 +268,7 @@
                               argExpr->get_loc(),
                               argExpr,
                               rtm.DOUBLE_TYPE_STAR,
-                              PromoteIterator::FUNC_PARAM,
+                              PROMOTE_FUNC_PARAM,
                               replacement->getName());
 
           fo->set_arg(0, promoteExpr);
@@ -570,7 +570,7 @@
                                          arg->get_loc(),
                                          arg,
                                          t,
-                                         PromoteIterator::FUNC_PARAM,
+                                         PROMOTE_FUNC_PARAM,
                                          fn->getName());
 }
 
 
=== modified file 'src/compiler/rewriter/tools/dataflow_annotations.cpp'
--- src/compiler/rewriter/tools/dataflow_annotations.cpp	2012-10-12 09:05:54 +0000
+++ src/compiler/rewriter/tools/dataflow_annotations.cpp	2012-10-24 11:34:21 +0000
@@ -110,16 +110,32 @@
   case while_expr_kind:         // TODO
     break;
 
+  case promote_expr_kind:
+  case castable_expr_kind:
+  case instanceof_expr_kind:
+  {
+    default_walk(e);
+    cast_or_castable_base_expr* ue = static_cast<cast_or_castable_base_expr*>(e);
+    PROPOGATE_SORTED_NODES(ue->get_input(), e);
+    PROPOGATE_DISTINCT_NODES(ue->get_input(), e);
+    break;
+  }
+
   case wrapper_expr_kind:
-    compute_wrapper_expr(static_cast<wrapper_expr *>(e));
+  {
+    default_walk(e);
+    wrapper_expr* ue = static_cast<wrapper_expr*>(e);
+    PROPOGATE_SORTED_NODES(ue->get_input(), e);
+    PROPOGATE_DISTINCT_NODES(ue->get_input(), e);
     break;
+  }
 
   case function_trace_expr_kind:
   {
     default_walk(e);
-    function_trace_expr* fte = static_cast<function_trace_expr*>(e);
-    PROPOGATE_SORTED_NODES(fte->get_expr(), e);
-    PROPOGATE_DISTINCT_NODES(fte->get_expr(), e);
+    function_trace_expr* ue = static_cast<function_trace_expr*>(e);
+    PROPOGATE_SORTED_NODES(ue->get_input(), e);
+    PROPOGATE_DISTINCT_NODES(ue->get_input(), e);
     break;
   }
 
@@ -136,10 +152,6 @@
     compute_trycatch_expr(static_cast<trycatch_expr *>(e));
     break;
 
-  case promote_expr_kind:
-    compute_promote_expr(static_cast<promote_expr *>(e));
-    break;
-
   case if_expr_kind:
     compute_if_expr(static_cast<if_expr *>(e));
     break;
@@ -148,18 +160,10 @@
     compute_fo_expr(static_cast<fo_expr *>(e));
     break;
 
-  case instanceof_expr_kind:
-    compute_instanceof_expr(static_cast<instanceof_expr *>(e));
-    break;
-
   case treat_expr_kind:
     compute_treat_expr(static_cast<treat_expr *>(e));
     break;
 
-  case castable_expr_kind:
-    compute_castable_expr(static_cast<castable_expr *>(e));
-    break;
-
   case cast_expr_kind:
     compute_cast_expr(static_cast<cast_expr *>(e));
     break;
@@ -336,17 +340,6 @@
 /*******************************************************************************
 
 ********************************************************************************/
-void DataflowAnnotationsComputer::compute_wrapper_expr(wrapper_expr* e)
-{
-  default_walk(e);
-  PROPOGATE_SORTED_NODES(e->get_expr(), e);
-  PROPOGATE_DISTINCT_NODES(e->get_expr(), e);
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
 void DataflowAnnotationsComputer::compute_var_expr(var_expr* e)
 {
   if (!generic_compute(e))
@@ -451,17 +444,6 @@
 /*******************************************************************************
 
 ********************************************************************************/
-void DataflowAnnotationsComputer::compute_promote_expr(promote_expr* e)
-{
-  default_walk(e);
-  PROPOGATE_SORTED_NODES(e->get_input(), e);
-  PROPOGATE_DISTINCT_NODES(e->get_input(), e);
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
 void DataflowAnnotationsComputer::compute_if_expr(if_expr* e)
 {
   default_walk(e);
@@ -540,17 +522,6 @@
 /*******************************************************************************
 
 ********************************************************************************/
-void DataflowAnnotationsComputer::compute_instanceof_expr(instanceof_expr *e)
-{
-  default_walk(e);
-  PROPOGATE_SORTED_NODES(e->get_input(), e);
-  PROPOGATE_DISTINCT_NODES(e->get_input(), e);
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
 void DataflowAnnotationsComputer::compute_treat_expr(treat_expr *e)
 {
   default_walk(e);
@@ -565,17 +536,6 @@
 /*******************************************************************************
 
 ********************************************************************************/
-void DataflowAnnotationsComputer::compute_castable_expr(castable_expr *e)
-{
-  default_walk(e);
-  PROPOGATE_SORTED_NODES(e->get_input(), e);
-  PROPOGATE_DISTINCT_NODES(e->get_input(), e);
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
 void DataflowAnnotationsComputer::compute_cast_expr(cast_expr* e)
 {
   default_walk(e);
@@ -601,8 +561,8 @@
   default_walk(e);
   if (!generic_compute(e))
   {
-    PROPOGATE_SORTED_NODES(e->get_expr(), e);
-    PROPOGATE_DISTINCT_NODES(e->get_expr(), e);
+    PROPOGATE_SORTED_NODES(e->get_input(), e);
+    PROPOGATE_DISTINCT_NODES(e->get_input(), e);
   }
 }
 
 
=== modified file 'src/compiler/rewriter/tools/dataflow_annotations.h'
--- src/compiler/rewriter/tools/dataflow_annotations.h	2012-10-12 09:05:54 +0000
+++ src/compiler/rewriter/tools/dataflow_annotations.h	2012-10-24 11:34:21 +0000
@@ -38,15 +38,12 @@
 private:
   void compute_var_decl_expr(var_decl_expr* e);
   void compute_block_expr(block_expr* e);
-  void compute_wrapper_expr(wrapper_expr* e);
   void compute_var_expr(var_expr* e);
   void compute_var_set_expr(var_set_expr* e);
   void compute_flwor_expr(flwor_expr* e);
   void compute_trycatch_expr(trycatch_expr* e);
-  void compute_promote_expr(promote_expr* e);
   void compute_if_expr(if_expr* e);
   void compute_fo_expr(fo_expr* e);
-  void compute_instanceof_expr(instanceof_expr* e);
   void compute_treat_expr(treat_expr* e);
   void compute_castable_expr(castable_expr* e);
   void compute_cast_expr(cast_expr* e);
 
=== modified file 'src/compiler/rewriter/tools/expr_tools.cpp'
--- src/compiler/rewriter/tools/expr_tools.cpp	2012-10-22 15:10:23 +0000
+++ src/compiler/rewriter/tools/expr_tools.cpp	2012-10-24 11:34:21 +0000
@@ -188,7 +188,7 @@
   {
     wrapper_expr* wrapper = reinterpret_cast<wrapper_expr*>(e);
 
-    if (wrapper->get_expr() == oldVar)
+    if (wrapper->get_input() == oldVar)
     {
       wrapper->set_expr(newVar);
       return;
 
=== modified file 'src/compiler/translator/translator.cpp'
--- src/compiler/translator/translator.cpp	2012-10-23 19:08:52 +0000
+++ src/compiler/translator/translator.cpp	2012-10-24 11:34:21 +0000
@@ -1463,7 +1463,7 @@
       {
         argExpr = wrap_in_type_promotion(argExpr,
                                          paramType,
-                                         PromoteIterator::FUNC_PARAM,
+                                         PROMOTE_FUNC_PARAM,
                                          func->getName());
       }
       else
@@ -1471,7 +1471,7 @@
         argExpr = wrap_in_type_match(argExpr,
                                      paramType,
                                      loc,
-                                     TreatIterator::FUNC_PARAM,
+                                     TREAT_FUNC_PARAM,
                                      func->getName());
       }
     }
@@ -1500,7 +1500,7 @@
 expr* wrap_in_type_promotion(
     expr* e,
     const xqtref_t& type,
-    PromoteIterator::ErrorKind errorKind,
+    PromoteErrorKind errorKind,
     store::Item* qname = NULL)
 {
   e = wrap_in_atomization(e);
@@ -1522,7 +1522,7 @@
     expr* e,
     const xqtref_t& type,
     const QueryLoc& loc,
-    TreatIterator::ErrorKind errorKind,
+    TreatErrorKind errorKind,
     store::Item_t qname = NULL)
 {
   TypeManager* tm = e->get_type_manager();
@@ -2053,7 +2053,7 @@
                       loc,
                       initExpr,
                       varType,
-                      TreatIterator::TYPE_MATCH);
+                      TREAT_TYPE_MATCH);
   }
 
   expr* declExpr = theExprManager->
@@ -2073,7 +2073,7 @@
                       loc,
                       getExpr,
                       varType,
-                      TreatIterator::TYPE_MATCH);
+                      TREAT_TYPE_MATCH);
 
     stmts.push_back(treatExpr);
   }
@@ -3823,7 +3823,7 @@
     {
       body = wrap_in_type_promotion(body,
                                     returnType,
-                                    PromoteIterator::FUNC_RETURN,
+                                    PROMOTE_FUNC_RETURN,
                                     udf->getName());
 
       body->set_loc(v.get_return_type()->get_location());
@@ -3833,7 +3833,7 @@
       body = wrap_in_type_match(body,
                                 returnType,
                                 loc,
-                                TreatIterator::FUNC_RETURN,
+                                TREAT_FUNC_RETURN,
                                 udf->getName());
     }
 
@@ -4540,13 +4540,13 @@
   domainExpr = wrap_in_type_match(domainExpr,
                                   theRTM.STRUCTURED_ITEM_TYPE_STAR,
                                   loc,
-                                  TreatIterator::INDEX_DOMAIN,
+                                  TREAT_INDEX_DOMAIN,
                                   index->getName());
 #else
   domainExpr = wrap_in_type_match(domainExpr,
                                   theRTM.ANY_NODE_TYPE_STAR,
                                   loc,
-                                  TreatIterator::INDEX_DOMAIN,
+                                  TREAT_INDEX_DOMAIN,
                                   index->getName());
 #endif
 
@@ -4718,7 +4718,7 @@
       keyExpr = wrap_in_type_match(keyExpr,
                                    type,
                                    loc,
-                                   TreatIterator::INDEX_KEY,
+                                   TREAT_INDEX_KEY,
                                    index->getName());
 
       keyTypes[i] = ptype->getBaseBuiltinType();
@@ -5941,7 +5941,7 @@
                                                   loc,
                                                   valueExpr,
                                                   varType,
-                                                  TreatIterator::TYPE_MATCH);
+                                                  TREAT_TYPE_MATCH);
 
   push_nodestack(theExprManager->create_var_set_expr(theRootSctx,
                                                      theUDF,
@@ -6047,7 +6047,7 @@
   expr* condExpr = pop_nodestack();
 
   expr* breakExpr = theExprManager->
-  create_flowctl_expr(theRootSctx, theUDF, loc, flowctl_expr::BREAK);
+  create_flowctl_expr(theRootSctx, theUDF, loc, FLOW_BREAK);
 
   condExpr = theExprManager->
   create_if_expr(theRootSctx, theUDF, loc, condExpr, create_empty_seq(loc), breakExpr);
@@ -6082,7 +6082,7 @@
 {
   TRACE_VISIT_OUT();
 
-  enum flowctl_expr::action a;
+  FlowCtlAction a;
 
   switch (v.get_action())
   {
@@ -6092,7 +6092,7 @@
     {
       RAISE_ERROR_NO_PARAMS(zerr::XSST0009, loc);
     }
-    a = flowctl_expr::BREAK;
+    a = FLOW_BREAK;
     break;
   }
   case FlowCtlStatement::CONTINUE:
@@ -6101,7 +6101,7 @@
     {
       RAISE_ERROR_NO_PARAMS(zerr::XSST0010, loc);
     }
-    a = flowctl_expr::CONTINUE;
+    a = FLOW_CONTINUE;
     break;
   }
   default:
@@ -6557,9 +6557,9 @@
   // Pop the window the domain expr.
   expr* windowDomainExpr = pop_nodestack();
 
-  window_clause::window_t winKind = (v.get_wintype() == WindowClause::tumbling_window ?
-                                     window_clause::tumbling_window :
-                                     window_clause::sliding_window);
+  WindowKind winKind = (v.get_wintype() == WindowClause::tumbling_window ?
+                        tumbling_window :
+                        sliding_window);
 
   window_clause* clause = theExprManager->create_window_clause(theRootSctx,
                                                                v.get_location(),
@@ -6943,7 +6943,7 @@
       inputExpr = wrap_in_type_match(inputExpr,
                                      theRTM.ANY_ATOMIC_TYPE_QUESTION,
                                      specLoc,
-                                     TreatIterator::MULTI_VALUED_GROUPING_KEY);
+                                     TREAT_MULTI_VALUED_GROUPING_KEY);
 
       // We need to do this to handle grouping vars with same names but
       // different collations.
@@ -7589,7 +7589,7 @@
                         loc,
                         sv,
                         type,
-                        TreatIterator::TREAT_EXPR);
+                        TREAT_EXPR);
 
       // clauseExpr = [let $caseVar := treat_as($sv, caseType) return NULL]
       clauseExpr = wrap_in_let_flwor(treatExpr, caseVar, NULL);
@@ -8421,10 +8421,10 @@
 {
   TRACE_VISIT_OUT();
 
-  push_nodestack(theExprManager->create_instanceof_expr(theRootSctx, theUDF,
-                                     loc,
-                                     pop_nodestack(),
-                                     pop_tstack()));
+  push_nodestack(CREATE(instanceof)(theRootSctx, theUDF,
+                                    loc,
+                                    pop_nodestack(),
+                                    pop_tstack()));
 }
 
 
@@ -8441,11 +8441,11 @@
 {
   TRACE_VISIT_OUT();
 
-  push_nodestack(theExprManager->create_treat_expr(theRootSctx, theUDF,
-                                loc,
-                                pop_nodestack(),
-                                pop_tstack(),
-                                TreatIterator::TREAT_EXPR));
+  push_nodestack(CREATE(treat)(theRootSctx, theUDF,
+                               loc,
+                               pop_nodestack(),
+                               pop_tstack(),
+                               TREAT_EXPR));
 }
 
 
@@ -9003,22 +9003,23 @@
                                        loc,
                                        DOT_REF,
                                        GENV_TYPESYSTEM.ANY_NODE_TYPE_ONE,
-                                       TreatIterator::PATH_DOT);
+                                       TREAT_PATH_DOT);
 
     ctx_path_expr->add_back(sourceExpr);
 
-    match_expr* me = theExprManager->create_match_expr(theRootSctx, theUDF, loc);
+    match_expr* me = CREATE(match)(theRootSctx, theUDF, loc);
     me->setTestKind(match_anykind_test);
-    axis_step_expr* ase = theExprManager->create_axis_step_expr(theRootSctx, theUDF, loc);
+    axis_step_expr* ase = CREATE(axis_step)(theRootSctx, theUDF, loc);
     ase->setAxis(axis_kind_self);
     ase->setTest(me);
 
     ctx_path_expr->add_back(&*ase);
 
-    fo_expr* fnroot = theExprManager->create_fo_expr(theRootSctx, theUDF,
-                                   loc,
-                                   BUILTIN_FUNC(FN_ROOT_1),
-                                   ctx_path_expr);
+    fo_expr* fnroot = CREATE(fo)(theRootSctx,
+                                 theUDF,
+                                 loc,
+                                 BUILTIN_FUNC(FN_ROOT_1),
+                                 ctx_path_expr);
     normalize_fo(fnroot);
 
     if (pathExpr != NULL)
@@ -9032,11 +9033,12 @@
     else
     {
       // case 1
-      expr* result = theExprManager->create_treat_expr(theRootSctx, theUDF,
-                                     loc,
-                                     fnroot,
-                                     GENV_TYPESYSTEM.DOCUMENT_TYPE_ONE,
-                                     TreatIterator::TREAT_EXPR);
+      expr* result = CREATE(treat)(theRootSctx,
+                                   theUDF,
+                                   loc,
+                                   fnroot,
+                                   GENV_TYPESYSTEM.DOCUMENT_TYPE_ONE,
+                                   TREAT_EXPR);
       push_nodestack(result);
     }
   }
@@ -9127,7 +9129,7 @@
                                          loc,
                                          DOT_REF,
                                          GENV_TYPESYSTEM.ANY_NODE_TYPE_ONE,
-                                         TreatIterator::PATH_DOT);
+                                         TREAT_PATH_DOT);
       pathExpr->add_back(sourceExpr);
 
       if (axisStep->get_predicate_list() == NULL)
@@ -9200,14 +9202,13 @@
 #ifdef NODE_SORT_OPT
     if (pathExpr->size() == 0)
     {
-      TreatIterator::ErrorKind errKind = TreatIterator::PATH_STEP;
+      TreatErrorKind errKind = TREAT_PATH_STEP;
 
       if (stepExpr->get_expr_kind() == wrapper_expr_kind)
       {
-        wrapper_expr* tmp = static_cast<wrapper_expr*>(stepExpr);
         var_expr* dotVar = lookup_var(DOT_VARNAME, loc, zerr::ZXQP0000_NO_ERROR);
-        if (tmp->get_expr() == dotVar)
-          errKind = TreatIterator::PATH_DOT;
+        if (static_cast<wrapper_expr*>(stepExpr)->get_input() == dotVar)
+          errKind = TREAT_PATH_DOT;
       }
 
       expr* sourceExpr = theExprManager->create_treat_expr(theRootSctx, theUDF,
@@ -10369,7 +10370,7 @@
 
   push_nodestack(theExprManager->create_order_expr(theRootSctx, theUDF,
                                 loc,
-                                order_expr::ordered,
+                                doc_ordered,
                                 pop_nodestack()));
 }
 
@@ -10390,7 +10391,7 @@
 
   push_nodestack(theExprManager->create_order_expr(theRootSctx, theUDF,
                                 loc,
-                                order_expr::unordered,
+                                doc_unordered,
                                 pop_nodestack()));
 }
 
@@ -10642,22 +10643,26 @@
 
         var_expr* tv = create_temp_var(loc, var_expr::let_var);
 
-        expr* nanExpr = theExprManager->create_const_expr(theRootSctx, theUDF, loc, xs_double::nan());
+        expr* nanExpr = CREATE(const)(theRootSctx, theUDF, loc, xs_double::nan());
 
-        expr* condExpr = theExprManager->create_castable_expr(theRootSctx, theUDF, loc, &*tv, theRTM.DOUBLE_TYPE_ONE);
+        expr* condExpr = CREATE(castable)(theRootSctx,
+                                          theUDF,
+                                          loc,
+                                          tv,
+                                          theRTM.DOUBLE_TYPE_ONE);
 
         expr* castExpr = create_cast_expr(loc, tv, theRTM.DOUBLE_TYPE_ONE, true);
 
-        expr* ret = theExprManager->create_if_expr(theRootSctx, theUDF, loc, condExpr, castExpr, nanExpr);
+        expr* ret = CREATE(if)(theRootSctx, theUDF, loc, condExpr, castExpr, nanExpr);
 
         expr* data_expr = wrap_in_atomization(arguments[0]);
 
-        push_nodestack(wrap_in_let_flwor(theExprManager->create_treat_expr(theRootSctx,
-                                                                           theUDF,
-                                                          loc,
-                                                          data_expr,
-                                                          theRTM.ANY_ATOMIC_TYPE_QUESTION,
-                                                          TreatIterator::TYPE_MATCH),
+        push_nodestack(wrap_in_let_flwor(CREATE(treat)(theRootSctx,
+                                                       theUDF,
+                                                       loc,
+                                                       data_expr,
+                                                       theRTM.ANY_ATOMIC_TYPE_QUESTION,
+                                                       TREAT_TYPE_MATCH),
                                            tv,
                                            ret));
         return;
@@ -10665,19 +10670,21 @@
       case FunctionConsts::FN_STATIC_BASE_URI_0:
       {
         if (numArgs != 0)
+        {
           RAISE_ERROR(err::XPST0017, loc,
           ERROR_PARAMS("fn:static-base-uri",
                        ZED(FunctionUndeclared_3),
                        numArgs));
+        }
 
         zstring baseuri = theSctx->get_base_uri();
         if (baseuri.empty())
           push_nodestack(create_empty_seq(loc));
         else
-          push_nodestack(theExprManager->create_cast_expr(theRootSctx, theUDF,
-                                       loc,
-                                       theExprManager->create_const_expr(theRootSctx, theUDF, loc, baseuri),
-                                       theRTM.ANY_URI_TYPE_ONE));
+          push_nodestack(CREATE(cast)(theRootSctx, theUDF,
+                                      loc,
+                                      CREATE(const)(theRootSctx, theUDF, loc, baseuri),
+                                      theRTM.ANY_URI_TYPE_ONE));
         return;
       }
       case FunctionConsts::FN_ID_1:
@@ -10890,7 +10897,7 @@
       resultExpr = wrap_in_type_match(foExpr,
                                       resultType,
                                       loc,
-                                      TreatIterator::FUNC_RETURN,
+                                      TREAT_FUNC_RETURN,
                                       f->getName());
     }
 
@@ -11024,7 +11031,7 @@
         // wrap function's QName
         expr* qnameExpr = wrap_in_type_promotion(arguments[0],
                                                  theRTM.QNAME_TYPE_ONE,
-                                                 PromoteIterator::TYPE_PROMOTION);
+                                                 PROMOTE_TYPE_PROMOTION);
 
         for (csize i = 0; i < numArgs ; ++i)
         {
@@ -11487,11 +11494,11 @@
   // Wrap the body in appropriate type op.
   if (TypeOps::is_builtin_simple(CTX_TM, *returnType))
   {
-    body = wrap_in_type_promotion(body, returnType, PromoteIterator::TYPE_PROMOTION);
+    body = wrap_in_type_promotion(body, returnType, PROMOTE_TYPE_PROMOTION);
   }
   else
   {
-    body = wrap_in_type_match(body, returnType, loc, TreatIterator::TYPE_MATCH);
+    body = wrap_in_type_match(body, returnType, loc, TREAT_TYPE_MATCH);
   }
 
   // Make the body be the return expr of the flwor that binds the function params.
@@ -11608,19 +11615,21 @@
   {
     contentExpr = pop_nodestack();
 
-    contentExpr = theExprManager->
-    create_treat_expr(theRootSctx,
-                      theUDF,
-                      contentExpr->get_loc(),
-                      contentExpr,
-                      GENV_TYPESYSTEM.JSON_OBJECT_TYPE_STAR,
-                      TreatIterator::TYPE_MATCH,
-                      true,
-                      NULL);
+    contentExpr = CREATE(treat)(theRootSctx,
+                                theUDF,
+                                contentExpr->get_loc(),
+                                contentExpr,
+                                GENV_TYPESYSTEM.JSON_OBJECT_TYPE_STAR,
+                                TREAT_TYPE_MATCH,
+                                true,
+                                NULL);
   }
 
-  expr* jo = theExprManager->
-  create_json_object_expr(theRootSctx, theUDF, loc, contentExpr, v.get_accumulate());
+  expr* jo = CREATE(json_object)(theRootSctx,
+                                 theUDF,
+                                 loc,
+                                 contentExpr,
+                                 v.get_accumulate());
 
   push_nodestack(jo);
 #endif
@@ -12114,11 +12123,9 @@
   {
     if (!v.isStripped())
     {
-      expr* content = theExprManager->create_const_expr(theRootSctx, theUDF, loc, v.get_elem_content().str());
+      expr* content = CREATE(const)(theRootSctx, theUDF, loc, v.get_elem_content().str());
 
-      push_nodestack(theExprManager->create_text_expr(theRootSctx, theUDF, loc,
-                                   text_expr::text_constructor,
-                                   content));
+      push_nodestack(CREATE(text)(theRootSctx, theUDF, loc, text_constructor, content));
     }
   }
 }
@@ -12146,6 +12153,7 @@
 void check_boundary_whitespace(const DirElemContent& v)
 {
   v.setIsStripped(false);
+
   if (theSctx->boundary_space_mode() == StaticContextConsts::strip_space)
   {
     bool lPrevIsBoundary = translator_ns::pop_stack (theIsWSBoundaryStack);
@@ -12220,8 +12228,8 @@
   // Skip empty CDATA sections
   if(!lCDATA_content.empty())
   {
-    expr* content = theExprManager->create_const_expr(theRootSctx, theUDF, loc, lCDATA_content);
-    push_nodestack(theExprManager->create_text_expr(theRootSctx, theUDF, loc, text_expr::text_constructor, content));
+    expr* content = CREATE(const)(theRootSctx, theUDF, loc, lCDATA_content);
+    push_nodestack(CREATE(text)(theRootSctx, theUDF, loc, text_constructor, content));
   }
 }
 
@@ -12397,7 +12405,7 @@
     // we always create a text node here because if we are in an attribute, we atomice
     // the text node into its string value
     zstring content("}");
-    expr* lConstExpr = theExprManager->create_const_expr(theRootSctx, theUDF, loc, content);
+    expr* lConstExpr = CREATE(const)(theRootSctx, theUDF, loc, content);
     push_nodestack ( lConstExpr );
     break;
   }
@@ -12420,10 +12428,13 @@
   TRACE_VISIT_OUT();
 
   zstring str = v.get_comment().str();
-  expr* content = theExprManager->create_const_expr (theRootSctx, theUDF, loc, str);
-  push_nodestack (theExprManager->create_text_expr(theRootSctx, theUDF, loc,
-                                text_expr::comment_constructor,
-                                content));
+  expr* content = CREATE(const)(theRootSctx, theUDF, loc, str);
+
+  push_nodestack (CREATE(text)(theRootSctx,
+                               theUDF,
+                               loc,
+                               comment_constructor,
+                               content));
 }
 
 
@@ -12589,8 +12600,8 @@
   fo_expr* enclosedExpr = wrap_in_enclosed_expr(inputExpr, loc);
 
   expr* textExpr = theExprManager->create_text_expr(theRootSctx, theUDF, loc,
-                                                     text_expr::comment_constructor,
-                                                     enclosedExpr);
+                                                    comment_constructor,
+                                                    enclosedExpr);
 
   push_nodestack(textExpr);
 }
@@ -12653,7 +12664,7 @@
 
   expr* textExpr = theExprManager->create_text_expr(theRootSctx, theUDF,
                                                      loc,
-                                                     text_expr::text_constructor,
+                                                     text_constructor,
                                                      enclosedExpr);
 
   push_nodestack(textExpr);
@@ -13454,29 +13465,24 @@
   targetExpr = wrap_in_type_match(targetExpr,
                                   rtm.JSON_OBJECT_TYPE_ONE,
                                   loc,
-                                  TreatIterator::JSONIQ_OBJECT_UPDATE_TARGET, // JNUP0008
+                                  TREAT_JSONIQ_OBJECT_UPDATE_TARGET, // JNUP0008
                                   NULL);
 
   contentExpr = wrap_in_type_match(contentExpr,
                                   rtm.JSON_OBJECT_TYPE_STAR,
                                   loc,
-                                  TreatIterator::JSONIQ_OBJECT_UPDATE_CONTENT, // JNUP0019
+                                  TREAT_JSONIQ_OBJECT_UPDATE_CONTENT, // JNUP0019
                                   NULL);
 
   std::vector<expr*> args(2);
   args[0] = targetExpr;
-  args[1] = theExprManager->create_json_object_expr(
-      theRootSctx,
-      theUDF,
-      loc,
-      contentExpr,
-      false);
+  args[1] = CREATE(json_object)(theRootSctx, theUDF, loc, contentExpr, false);
 
-  expr* updExpr = theExprManager->
-  create_fo_expr(theRootSctx, theUDF,
-                 loc,
-                 BUILTIN_FUNC(OP_ZORBA_JSON_OBJECT_INSERT_2),
-                 args);
+  expr* updExpr = CREATE(fo)(theRootSctx,
+                             theUDF,
+                             loc,
+                             BUILTIN_FUNC(OP_ZORBA_JSON_OBJECT_INSERT_2),
+                             args);
 
   push_nodestack(updExpr);
 #endif
@@ -13510,12 +13516,12 @@
 
   posExpr = wrap_in_type_promotion(posExpr,
                                    rtm.INTEGER_TYPE_ONE,
-                                   PromoteIterator::JSONIQ_ARRAY_SELECTOR); // JNUP0007
+                                   PROMOTE_JSONIQ_ARRAY_SELECTOR); // JNUP0007
 
   targetExpr = wrap_in_type_match(targetExpr,
                                   rtm.JSON_ARRAY_TYPE_ONE,
                                   loc,
-                                  TreatIterator::JSONIQ_ARRAY_UPDATE_TARGET, // JNUP0008
+                                  TREAT_JSONIQ_ARRAY_UPDATE_TARGET, // JNUP0008
                                   NULL);
 
   std::vector<expr*> args(3);
@@ -13560,15 +13566,15 @@
   targetExpr = wrap_in_type_match(targetExpr,
                                   theRTM.JSON_ARRAY_TYPE_ONE,
                                   loc,
-                                  TreatIterator::JSONIQ_ARRAY_UPDATE_TARGET, // JNUP0008
+                                  TREAT_JSONIQ_ARRAY_UPDATE_TARGET, // JNUP0008
                                   NULL);
 
-  fo_expr* updExpr = theExprManager->
-  create_fo_expr(theRootSctx, theUDF,
-                 loc,
-                 BUILTIN_FUNC(OP_ZORBA_JSON_ARRAY_APPEND_2),
-                 targetExpr,
-                 contentExpr);
+  fo_expr* updExpr = CREATE(fo)(theRootSctx,
+                                theUDF,
+                                loc,
+                                BUILTIN_FUNC(OP_ZORBA_JSON_ARRAY_APPEND_2),
+                                targetExpr,
+                                contentExpr);
 
   normalize_fo(updExpr);
 
@@ -13610,13 +13616,13 @@
 
   selExpr = wrap_in_type_promotion(selExpr,
                                    theRTM.ANY_ATOMIC_TYPE_ONE,
-                                   PromoteIterator::JSONIQ_SELECTOR, // JNUP0007
+                                   PROMOTE_JSONIQ_SELECTOR, // JNUP0007
                                    NULL);
 
   targetExpr = wrap_in_type_match(targetExpr,
                                   theRTM.JSON_ITEM_TYPE_ONE,
                                   loc,
-                                  TreatIterator::JSONIQ_UPDATE_TARGET, // JNUP0008
+                                  TREAT_JSONIQ_UPDATE_TARGET, // JNUP0008
                                   NULL);
 
   fo_expr* updExpr = theExprManager->
@@ -13658,12 +13664,12 @@
   args[0] = wrap_in_type_match(targetExpr,
                                theRTM.JSON_ITEM_TYPE_ONE,
                                loc,
-                               TreatIterator::JSONIQ_UPDATE_TARGET, // JNUP0008
+                               TREAT_JSONIQ_UPDATE_TARGET, // JNUP0008
                                NULL);
 
   args[1] = wrap_in_type_promotion(selExpr,
                                    theRTM.ANY_ATOMIC_TYPE_ONE,
-                                   PromoteIterator::JSONIQ_SELECTOR, // JNUP0007
+                                   PROMOTE_JSONIQ_SELECTOR, // JNUP0007
                                    NULL);
 
   args[2] = theExprManager->create_fo_expr(theRootSctx, theUDF,
@@ -13709,22 +13715,22 @@
   args[0] = wrap_in_type_match(targetExpr,
                                theRTM.JSON_OBJECT_TYPE_ONE,
                                loc,
-                               TreatIterator::JSONIQ_OBJECT_UPDATE_TARGET, // JNUP0008
+                               TREAT_JSONIQ_OBJECT_UPDATE_TARGET, // JNUP0008
                                NULL);
 
   args[1] = wrap_in_type_promotion(nameExpr,
                                    theRTM.STRING_TYPE_ONE,
-                                   PromoteIterator::JSONIQ_OBJECT_SELECTOR); // JNUP0007
+                                   PROMOTE_JSONIQ_OBJECT_SELECTOR); // JNUP0007
 
   args[2] = wrap_in_type_promotion(newNameExpr,
                                    theRTM.STRING_TYPE_ONE,
-                                   PromoteIterator::JSONIQ_OBJECT_SELECTOR); // JNUP0007
+                                   PROMOTE_JSONIQ_OBJECT_SELECTOR); // JNUP0007
 
-  fo_expr* updExpr = theExprManager->
-  create_fo_expr(theRootSctx, theUDF,
-                 loc,
-                 BUILTIN_FUNC(OP_ZORBA_JSON_RENAME_3),
-                 args);
+  fo_expr* updExpr = CREATE(fo)(theRootSctx,
+                                theUDF,
+                                loc,
+                                BUILTIN_FUNC(OP_ZORBA_JSON_RENAME_3),
+                                args);
 
   push_nodestack(updExpr);
 #endif
@@ -14142,7 +14148,7 @@
   push_nodestack( wrap_in_type_match(e,
                                      theRTM.ANY_NODE_TYPE_STAR,
                                      e->get_loc(),
-                                     TreatIterator::TYPE_MATCH));
+                                     TREAT_TYPE_MATCH));
 #endif /* ZORBA_NO_FULL_TEXT */
 }
 
@@ -14319,12 +14325,12 @@
   if ( e1 ) {
     e1 = wrap_in_type_promotion(e1,
                                 theRTM.INTEGER_TYPE_ONE,
-                                PromoteIterator::TYPE_PROMOTION);
+                                PROMOTE_TYPE_PROMOTION);
   }
   if ( e2 ) {
     e2 = wrap_in_type_promotion(e2,
                                 theRTM.INTEGER_TYPE_ONE,
-                                PromoteIterator::TYPE_PROMOTION);
+                                PROMOTE_TYPE_PROMOTION);
   }
 
   ftrange *const r = new ftrange( loc, v.get_mode(), e1, e2 );
@@ -14584,7 +14590,7 @@
   expr* e( pop_nodestack() );
   e = wrap_in_type_promotion(e,
                              theRTM.DOUBLE_TYPE_ONE,
-                             PromoteIterator::TYPE_PROMOTION);
+                             PROMOTE_TYPE_PROMOTION);
   push_ftstack( new ftweight( loc, e ) );
 #endif /* ZORBA_NO_FULL_TEXT */
 }
@@ -14620,7 +14626,7 @@
   expr* e( pop_nodestack() );
   e = wrap_in_type_promotion(e,
                              theRTM.INTEGER_TYPE_ONE,
-                             PromoteIterator::TYPE_PROMOTION);
+                             PROMOTE_TYPE_PROMOTION);
   push_ftstack( new ftwindow_filter( loc, e, v.get_unit()->get_unit() ) );
 #endif /* ZORBA_NO_FULL_TEXT */
 }
@@ -14637,7 +14643,7 @@
   expr* e( pop_nodestack() );
   e = wrap_in_type_promotion(e,
                              theRTM.STRING_TYPE_STAR,
-                             PromoteIterator::TYPE_PROMOTION);
+                             PROMOTE_TYPE_PROMOTION);
   push_ftstack( new ftwords( loc, e, v.get_any_all_option()->get_option() ) );
 #endif /* ZORBA_NO_FULL_TEXT */
 }
 
=== modified file 'src/compiler/xqddf/value_index.cpp'
--- src/compiler/xqddf/value_index.cpp	2012-10-22 15:10:23 +0000
+++ src/compiler/xqddf/value_index.cpp	2012-10-24 11:34:21 +0000
@@ -29,6 +29,7 @@
 #include "compiler/expression/script_exprs.h"
 #include "compiler/expression/expr.h"
 #include "compiler/expression/expr_iter.h"
+#include "compiler/expression/expr_manager.h"
 #include "compiler/codegen/plan_visitor.h"
 
 #include "runtime/base/plan_iterator.h"
 
=== modified file 'src/functions/func_booleans_impl.cpp'
--- src/functions/func_booleans_impl.cpp	2012-10-10 13:05:50 +0000
+++ src/functions/func_booleans_impl.cpp	2012-10-24 11:34:21 +0000
@@ -47,10 +47,9 @@
     :
     function(sig, kind)
   {
+    setFlag(FunctionConsts::IsComparison);
   }
 
-  bool isComparisonFunction() const { return true; }
-
   virtual const char* comparison_name() const { return ""; }
 
   virtual function* toValueComp(static_context *) const { return NULL; }
 
=== modified file 'src/functions/func_collections_impl.cpp'
--- src/functions/func_collections_impl.cpp	2012-10-16 13:08:47 +0000
+++ src/functions/func_collections_impl.cpp	2012-10-24 11:34:21 +0000
@@ -25,6 +25,9 @@
 #include "compiler/expression/pragma.h"
 #include "compiler/api/compilercb.h"
 
+#include "zorbamisc/ns_consts.h"
+
+
 namespace zorba
 {
 
 
=== modified file 'src/functions/func_sequences_impl.cpp'
--- src/functions/func_sequences_impl.cpp	2012-10-15 13:35:59 +0000
+++ src/functions/func_sequences_impl.cpp	2012-10-24 11:34:21 +0000
@@ -32,6 +32,7 @@
 
 #include "compiler/expression/expr.h"
 #include "compiler/expression/fo_expr.h"
+#include "compiler/expression/var_expr.h"
 #include "compiler/expression/path_expr.h"
 
 #include "types/typeops.h"
@@ -43,6 +44,148 @@
 /*******************************************************************************
 
 ********************************************************************************/
+xqtref_t fn_unordered::getReturnType(const fo_expr* caller) const
+{
+  return caller->get_arg(0)->get_return_type();
+}
+
+
+BoolAnnotationValue fn_unordered::ignoresSortedNodes(expr* fo, csize input) const
+{
+  return ANNOTATION_TRUE;
+}
+
+
+BoolAnnotationValue fn_unordered::ignoresDuplicateNodes(expr* fo, csize input) const
+{
+  return fo->getIgnoresDuplicateNodes();
+}
+
+
+PlanIter_t fn_unordered::codegen(
+    CompilerCB* /*cb*/,
+    static_context* sctx,
+    const QueryLoc& loc,
+    std::vector<PlanIter_t>& argv,
+    expr& ) const
+{
+  return argv[0];
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+xqtref_t fn_exactly_one_noraise::getReturnType(const fo_expr* caller) const
+{
+  TypeManager* tm = caller->get_type_manager();
+
+  xqtref_t srcType = caller->get_arg(0)->get_return_type();
+
+  if (theRaiseError)
+    return TypeOps::prime_type(tm, *srcType);
+  else
+    return function::getReturnType(caller);
+}
+
+
+PlanIter_t fn_exactly_one_noraise::codegen(
+    CompilerCB* aCb,
+    static_context* aSctx,
+    const QueryLoc& aLoc,
+    std::vector<PlanIter_t>& aArgs,
+    expr& aAnn) const
+{
+  return new FnExactlyOneIterator(aSctx,
+                                  aLoc,
+                                  aArgs,
+                                  theRaiseError,
+                                  testFlag(FunctionConsts::DoDistinct));
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+PlanIter_t fn_union::codegen(
+    CompilerCB* /*cb*/,
+    static_context* sctx,
+    const QueryLoc& loc,
+    std::vector<PlanIter_t>& argv,
+    expr& ann) const
+{
+  return new FnConcatIterator(sctx, loc, argv);
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+BoolAnnotationValue fn_intersect::ignoresSortedNodes(expr* fo, csize input) const 
+{
+  if (input == 0)
+    return fo->getIgnoresSortedNodes();
+  
+  return ANNOTATION_TRUE;
+}
+
+
+BoolAnnotationValue fn_intersect::ignoresDuplicateNodes(expr* fo, csize input) const 
+{
+  if (input == 0)
+    return fo->getIgnoresDuplicateNodes();
+
+  return ANNOTATION_TRUE;
+}
+
+
+PlanIter_t fn_intersect::codegen(
+    CompilerCB* /*cb*/,
+    static_context* sctx,
+    const QueryLoc& loc,
+    std::vector<PlanIter_t>& argv,
+    expr& ann) const
+{
+  return new HashSemiJoinIterator(sctx, loc, argv);
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+BoolAnnotationValue fn_except::ignoresSortedNodes(expr* fo, csize input) const 
+{
+  if (input == 0)
+    return fo->getIgnoresSortedNodes();
+  
+  return ANNOTATION_TRUE;
+}
+
+
+BoolAnnotationValue fn_except::ignoresDuplicateNodes(expr* fo, csize input) const 
+{
+  if (input == 0)
+    return fo->getIgnoresDuplicateNodes();
+  
+  return ANNOTATION_TRUE;
+}
+
+
+PlanIter_t fn_except::codegen(
+    CompilerCB* /*cb*/,
+    static_context* sctx,
+    const QueryLoc& loc,
+    std::vector<PlanIter_t>& argv,
+    expr& ann) const
+{
+  // TODO: use SortAntiJoinIterator when available (trac ticket 254)
+  return new HashSemiJoinIterator(sctx, loc, argv, true);
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
 xqtref_t op_concatenate::getReturnType(const fo_expr* caller) const
 {
   TypeManager* tm = caller->get_type_manager();
@@ -608,32 +751,6 @@
 /*******************************************************************************
 
 ********************************************************************************/
-BoolAnnotationValue fn_unordered::ignoresSortedNodes(expr* fo, csize input) const
-{
-  return ANNOTATION_TRUE;
-}
-
-
-BoolAnnotationValue fn_unordered::ignoresDuplicateNodes(expr* fo, csize input) const
-{
-  return fo->getIgnoresDuplicateNodes();
-}
-
-
-PlanIter_t fn_unordered::codegen(
-    CompilerCB* /*cb*/,
-    static_context* sctx,
-    const QueryLoc& loc,
-    std::vector<PlanIter_t>& argv,
-    expr& ) const
-{
-  return argv[0];
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
 xqtref_t fn_zero_or_one::getReturnType(const fo_expr* caller) const
 {
   TypeManager* tm = caller->get_type_manager();
@@ -693,37 +810,6 @@
 /*******************************************************************************
 
 ********************************************************************************/
-xqtref_t fn_exactly_one_noraise::getReturnType(const fo_expr* caller) const
-{
-  TypeManager* tm = caller->get_type_manager();
-
-  xqtref_t srcType = caller->get_arg(0)->get_return_type();
-
-  if (theRaiseError)
-    return TypeOps::prime_type(tm, *srcType);
-  else
-    return function::getReturnType(caller);
-}
-
-
-PlanIter_t fn_exactly_one_noraise::codegen(
-    CompilerCB* aCb,
-    static_context* aSctx,
-    const QueryLoc& aLoc,
-    std::vector<PlanIter_t>& aArgs,
-    expr& aAnn) const
-{
-  return new FnExactlyOneIterator(aSctx,
-                                  aLoc,
-                                  aArgs,
-                                  theRaiseError,
-                                  testFlag(FunctionConsts::DoDistinct));
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
 bool fn_deep_equal::mustCopyInputNodes(expr* fo, csize producer) const
 {
   return (producer < 2 &&
@@ -734,60 +820,6 @@
 /*******************************************************************************
 
 ********************************************************************************/
-PlanIter_t fn_union::codegen(
-    CompilerCB* /*cb*/,
-    static_context* sctx,
-    const QueryLoc& loc,
-    std::vector<PlanIter_t>& argv,
-    expr& ann) const
-{
-  return new FnConcatIterator(sctx, loc, argv);
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-PlanIter_t fn_intersect::codegen(
-    CompilerCB* /*cb*/,
-    static_context* sctx,
-    const QueryLoc& loc,
-    std::vector<PlanIter_t>& argv,
-    expr& ann) const
-{
-#if 0  // we can't access PRODUCES_* from the inputs, must rethink
-  bool distinct = ann.get_annotation (Annotations::IGNORES_DUP_NODES) != TSVAnnotationValue::TRUE_VAL;
-  bool sort = ann.get_annotation (Annotations::IGNORES_SORTED_NODES) != TSVAnnotationValue::TRUE_VAL;
-
-  std::vector<PlanIter_t> inputs;
-  for (std::vector<PlanIter_t>::iterator i = argv.begin ();
-       i != argv.end (); i++)
-    inputs.push_back (new NodeSortIterator (loc, *i, true, distinct, false));
-  return new SortSemiJoinIterator(loc, inputs);
-#endif
-
-  return new HashSemiJoinIterator(sctx, loc, argv);
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-PlanIter_t fn_except::codegen(
-    CompilerCB* /*cb*/,
-    static_context* sctx,
-    const QueryLoc& loc,
-    std::vector<PlanIter_t>& argv,
-    expr& ann) const
-{
-  // TODO: use SortAntiJoinIterator when available (trac ticket 254)
-  return new HashSemiJoinIterator(sctx, loc, argv, true);
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
 BoolAnnotationValue fn_count::ignoresSortedNodes(expr* fo, csize input) const
 {
   return ANNOTATION_TRUE;
 
=== modified file 'src/functions/func_sequences_impl.h'
--- src/functions/func_sequences_impl.h	2012-09-19 21:16:15 +0000
+++ src/functions/func_sequences_impl.h	2012-10-24 11:34:21 +0000
@@ -21,9 +21,8 @@
 
 #include "functions/function_impl.h"
 
-#include "compiler/expression/fo_expr.h"
-
-namespace zorba {
+namespace zorba
+{
 
 void populate_context_sequences_impl(static_context* sctx);
 
@@ -40,10 +39,7 @@
   {
   }
 
-  xqtref_t getReturnType(const fo_expr* caller) const
-  {
-    return caller->get_arg(0)->get_return_type();
-  }
+  xqtref_t getReturnType(const fo_expr* caller) const;
 
   bool isMap(csize input) const
   {
@@ -206,21 +202,9 @@
     return producer == 0;
   }
 
-  BoolAnnotationValue ignoresSortedNodes(expr* fo, csize input) const 
-  {
-    if (input == 0)
-      return fo->getIgnoresSortedNodes();
-
-    return ANNOTATION_TRUE;
-  }
-
-  BoolAnnotationValue ignoresDuplicateNodes(expr* fo, csize input) const 
-  {
-    if (input == 0)
-      return fo->getIgnoresDuplicateNodes();
-
-    return ANNOTATION_TRUE;
-  }
+  BoolAnnotationValue ignoresSortedNodes(expr* fo, csize input) const; 
+
+  BoolAnnotationValue ignoresDuplicateNodes(expr* fo, csize input) const;
 
   bool propagatesInputNodes(expr* fo, csize input) const
   {
@@ -258,21 +242,9 @@
     return  producer == 0;
   }
 
-  BoolAnnotationValue ignoresSortedNodes(expr* fo, csize input) const 
-  {
-    if (input == 0)
-      return fo->getIgnoresSortedNodes();
-
-    return ANNOTATION_TRUE;
-  }
-
-  BoolAnnotationValue ignoresDuplicateNodes(expr* fo, csize input) const 
-  {
-    if (input == 0)
-      return fo->getIgnoresDuplicateNodes();
-
-    return ANNOTATION_TRUE;
-  }
+  BoolAnnotationValue ignoresSortedNodes(expr* fo, csize input) const;
+
+  BoolAnnotationValue ignoresDuplicateNodes(expr* fo, csize input) const;
 
   bool propagatesInputNodes(expr* fo, csize input) const
   {
 
=== modified file 'src/functions/function.h'
--- src/functions/function.h	2012-10-08 12:09:36 +0000
+++ src/functions/function.h	2012-10-24 11:34:21 +0000
@@ -145,6 +145,8 @@
       resetFlag(FunctionConsts::isPrivate);
   }
 
+  bool isComparisonFunction() const { return testFlag(FunctionConsts::IsComparison); }
+
   bool isDeterministic() const
   {
     // Note: For udfs, the flag is set before the udf is optimized (see call
@@ -201,8 +203,6 @@
     return ArithmeticConsts::UNKNOWN;
   }
 
-  virtual bool isComparisonFunction() const { return false; }
-
   virtual bool isValueComparisonFunction() const { return false; }
 
   virtual bool isGeneralComparisonFunction() const { return false; }
 
=== modified file 'src/functions/function_consts.h'
--- src/functions/function_consts.h	2012-10-20 21:29:37 +0000
+++ src/functions/function_consts.h	2012-10-24 11:34:21 +0000
@@ -271,7 +271,8 @@
   mustCopyInputNodes   = 128,
   AccessesDynCtx       = 256,
   ConstructsNodes      = 512,
-  DereferencesNodes    = 1024
+  DereferencesNodes    = 1024,
+  IsComparison         = 2048
 } AnnotationFlags;
 
 };
 
=== modified file 'src/functions/udf.h'
--- src/functions/udf.h	2012-10-20 21:29:37 +0000
+++ src/functions/udf.h	2012-10-24 11:34:21 +0000
@@ -19,12 +19,14 @@
 
 #include "functions/function.h"
 
-#include "compiler/expression/expr_base.h"
+//#include "compiler/expression/expr_base.h"
 
 
 namespace zorba
 {
 
+  class expr;
+
   namespace store
   {
     class Index;
 
=== modified file 'src/runtime/core/sequencetypes.cpp'
--- src/runtime/core/sequencetypes.cpp	2012-10-08 12:09:36 +0000
+++ src/runtime/core/sequencetypes.cpp	2012-10-24 11:34:21 +0000
@@ -355,7 +355,7 @@
     const QueryLoc& loc,
     PlanIter_t& child,
     const xqtref_t& promoteType,
-    ErrorKind err,
+    PromoteErrorKind err,
     store::Item_t qname)
   :
   UnaryBaseIterator<PromoteIterator, PlanIteratorState>(sctx, loc, child),
@@ -379,7 +379,7 @@
 
   ar & thePromoteType;
   SERIALIZE_ENUM(TypeConstants::quantifier_t, theQuantifier);
-  SERIALIZE_ENUM(ErrorKind, theErrorKind);
+  SERIALIZE_ENUM(PromoteErrorKind, theErrorKind);
   ar & theQName;
 }
 
@@ -463,7 +463,7 @@
 
   switch (theErrorKind)
   {
-  case FUNC_RETURN:
+  case PROMOTE_FUNC_RETURN:
   {
     assert(theQName != NULL);
 
@@ -472,7 +472,7 @@
                  valueType, targetType, theQName->getStringValue()));
     break;
   }
-  case FUNC_PARAM:
+  case PROMOTE_FUNC_PARAM:
   {
     assert(theQName != NULL);
 
@@ -481,26 +481,26 @@
                  valueType, targetType, theQName->getStringValue()));
     break;
   }
-  case TYPE_PROMOTION:
+  case PROMOTE_TYPE_PROMOTION:
   {
     RAISE_ERROR(err::XPTY0004, loc, 
     ERROR_PARAMS(ZED(XPTY0004_TypePromotion), valueType, targetType));
     break;
   }
 #ifdef ZORBA_WITH_JSON
-  case JSONIQ_ARRAY_SELECTOR:
+  case PROMOTE_JSONIQ_ARRAY_SELECTOR:
   {
     RAISE_ERROR(jerr::JNUP0007, loc,
     ERROR_PARAMS(ZED(JNUP0007_Array), valueType));
     break;
   }
-  case JSONIQ_OBJECT_SELECTOR:
+  case PROMOTE_JSONIQ_OBJECT_SELECTOR:
   {
     RAISE_ERROR(jerr::JNUP0007, loc,
     ERROR_PARAMS(ZED(JNUP0007_Object), valueType));
     break;
   }
-  case JSONIQ_SELECTOR:
+  case PROMOTE_JSONIQ_SELECTOR:
   {
     RAISE_ERROR(jerr::JNUP0007, loc,
     ERROR_PARAMS(ZED(JNUP0007_ObjectArray), valueType));
@@ -528,7 +528,7 @@
     PlanIter_t& child,
     const xqtref_t& treatType,
     bool checkPrime,
-    ErrorKind errorKind,
+    TreatErrorKind errorKind,
     store::Item_t qname)
   :
   UnaryBaseIterator<TreatIterator, PlanIteratorState>(sctx, loc, child),
@@ -549,7 +549,7 @@
   ar & theTreatType;
   SERIALIZE_ENUM(TypeConstants::quantifier_t, theQuantifier);
   ar & theCheckPrime;
-  SERIALIZE_ENUM(ErrorKind, theErrorKind);
+  SERIALIZE_ENUM(TreatErrorKind, theErrorKind);
   ar & theQName;
 }
 
@@ -665,7 +665,7 @@
 
   switch (theErrorKind)
   {
-  case FUNC_RETURN:
+  case TREAT_FUNC_RETURN:
   {
     assert(theQName != NULL);
 
@@ -674,7 +674,7 @@
                  valueType, targetType, theQName->getStringValue()));
     break;
   }
-  case FUNC_PARAM:
+  case TREAT_FUNC_PARAM:
   {
     assert(theQName != NULL);
 
@@ -683,7 +683,7 @@
                  valueType, targetType, theQName->getStringValue()));
     break;
   }
-  case TYPE_MATCH:
+  case TREAT_TYPE_MATCH:
   {
     RAISE_ERROR(err::XPTY0004, loc, 
     ERROR_PARAMS(ZED(XPTY0004_TypeMatch), valueType, targetType));
@@ -694,65 +694,65 @@
     RAISE_ERROR(err::XPDY0050, loc, ERROR_PARAMS(valueType, targetType));
     break;
   }
-  case INDEX_DOMAIN:
+  case TREAT_INDEX_DOMAIN:
   {
     RAISE_ERROR(zerr::ZDTY0010_INDEX_DOMAIN_TYPE_ERROR, loc,
     ERROR_PARAMS(theQName->getStringValue()));
     break;
   }
-  case INDEX_KEY:
+  case TREAT_INDEX_KEY:
   {
     RAISE_ERROR(zerr::ZDTY0011_INDEX_KEY_TYPE_ERROR, loc,
     ERROR_PARAMS(valueType, targetType, theQName->getStringValue()));
     break;
   }
-  case PATH_STEP:
+  case TREAT_PATH_STEP:
   {
     RAISE_ERROR_NO_PARAMS(err::XPTY0019, loc);
     break;
   }
-  case PATH_DOT:
+  case TREAT_PATH_DOT:
   {
     RAISE_ERROR_NO_PARAMS(err::XPTY0020, loc);
     break;
   }
-  case MULTI_VALUED_GROUPING_KEY:
+  case TREAT_MULTI_VALUED_GROUPING_KEY:
   {
     RAISE_ERROR(err::XPTY0004, loc,
     ERROR_PARAMS(ZED(XPTY0004_MultiValuedGroupingKey)));
     break;
   }
 #ifdef ZORBA_WITH_JSON
-  case JSONIQ_VALUE:
+  case TREAT_JSONIQ_VALUE:
   {
     RAISE_ERROR_NO_PARAMS(jerr::JNTY0002, loc);
     break;
   }
-  case JSONIQ_UPDATE_TARGET:
+  case TREAT_JSONIQ_UPDATE_TARGET:
   {
     RAISE_ERROR(jerr::JNUP0008, loc,
     ERROR_PARAMS(ZED(JNUP0008_ObjectArray), valueType));
     break;
   }
-  case JSONIQ_OBJECT_UPDATE_TARGET:
+  case TREAT_JSONIQ_OBJECT_UPDATE_TARGET:
   {
     RAISE_ERROR(jerr::JNUP0008, loc,
     ERROR_PARAMS(ZED(JNUP0008_Object), valueType));
     break;
   }
-  case JSONIQ_OBJECT_UPDATE_CONTENT:
+  case TREAT_JSONIQ_OBJECT_UPDATE_CONTENT:
   {
     RAISE_ERROR(jerr::JNUP0019, loc,
     ERROR_PARAMS(ZED(JNUP0019), valueType));
     break;
   }
-  case JSONIQ_ARRAY_UPDATE_TARGET:
+  case TREAT_JSONIQ_ARRAY_UPDATE_TARGET:
   {
     RAISE_ERROR(jerr::JNUP0008, loc,
     ERROR_PARAMS(ZED(JNUP0008_Array), valueType));
     break;
   }
-  case JSONIQ_OBJECT_UPDATE_VALUE:
+  case TREAT_JSONIQ_OBJECT_UPDATE_VALUE:
   {
     RAISE_ERROR_NO_PARAMS(jerr::JNUP0017, loc);
     break;
 
=== modified file 'src/runtime/core/sequencetypes.h'
--- src/runtime/core/sequencetypes.h	2012-10-08 12:09:36 +0000
+++ src/runtime/core/sequencetypes.h	2012-10-24 11:34:21 +0000
@@ -24,6 +24,8 @@
 
 #include "types/typeconstants.h"
 
+#include "compiler/expression/expr_consts.h"
+
 namespace zorba 
 {
 
@@ -143,21 +145,10 @@
 {
   friend class PrinterVisitor;
 
-public:
-  typedef enum
-  {
-    FUNC_RETURN,
-    FUNC_PARAM,
-    TYPE_PROMOTION,
-    JSONIQ_ARRAY_SELECTOR,
-    JSONIQ_OBJECT_SELECTOR,
-    JSONIQ_SELECTOR
-  } ErrorKind;
-
 private:
   xqtref_t                    thePromoteType;
   TypeConstants::quantifier_t theQuantifier;
-  ErrorKind                   theErrorKind;
+  PromoteErrorKind            theErrorKind;
   store::Item_t								theQName; 
 
 public:
@@ -173,7 +164,7 @@
       const QueryLoc& loc,
       PlanIter_t& child,
       const xqtref_t& promoteType,
-      ErrorKind err,
+      PromoteErrorKind err,
       store::Item_t qname = NULL);
 
   ~PromoteIterator();
@@ -202,31 +193,11 @@
 {
   friend class PrinterVisitor;
 
-public:
-  typedef enum
-  {
-    FUNC_RETURN,
-    FUNC_PARAM,
-    TYPE_MATCH,
-    TREAT_EXPR,
-    INDEX_DOMAIN,
-    INDEX_KEY,
-    PATH_STEP,
-    PATH_DOT,
-    MULTI_VALUED_GROUPING_KEY,
-    JSONIQ_VALUE,
-    JSONIQ_UPDATE_TARGET,
-    JSONIQ_OBJECT_UPDATE_TARGET,
-    JSONIQ_OBJECT_UPDATE_CONTENT,
-    JSONIQ_ARRAY_UPDATE_TARGET,
-    JSONIQ_OBJECT_UPDATE_VALUE
-  } ErrorKind;
-
 private:
   xqtref_t                    theTreatType;
   TypeConstants::quantifier_t theQuantifier;
   bool                        theCheckPrime;
-  ErrorKind                   theErrorKind;
+  TreatErrorKind              theErrorKind;
   store::Item_t								theQName;
 
 public:
@@ -243,7 +214,7 @@
       PlanIter_t& child,
       const xqtref_t& treatType,
       bool check_prime,
-      ErrorKind errorKind,
+      TreatErrorKind errorKind,
       store::Item_t qname);
 
   void accept(PlanIterVisitor& v) const;
 
=== modified file 'src/runtime/eval/eval.cpp'
--- src/runtime/eval/eval.cpp	2012-10-12 09:05:54 +0000
+++ src/runtime/eval/eval.cpp	2012-10-24 11:34:21 +0000
@@ -30,6 +30,7 @@
 #include "compiler/api/compilercb.h"
 #include "compiler/api/compiler_api.h"
 #include "compiler/expression/var_expr.h"
+#include "compiler/expression/expr_manager.h"
 
 #include "context/dynamic_context.h"
 #include "context/static_context.h"
 
=== modified file 'src/runtime/function_item/function_item.cpp'
--- src/runtime/function_item/function_item.cpp	2012-10-09 14:06:08 +0000
+++ src/runtime/function_item/function_item.cpp	2012-10-24 11:34:21 +0000
@@ -21,6 +21,7 @@
 
 #include "compiler/api/compilercb.h"
 #include "compiler/expression/function_item_expr.h"
+#include "compiler/expression/expr_manager.h"
 
 #include "functions/signature.h"
 #include "functions/udf.h"
 
=== modified file 'src/runtime/json/jsoniq_functions_impl.cpp'
--- src/runtime/json/jsoniq_functions_impl.cpp	2012-10-16 14:30:02 +0000
+++ src/runtime/json/jsoniq_functions_impl.cpp	2012-10-24 11:34:21 +0000
@@ -40,6 +40,7 @@
 #include "zorba/internal/diagnostic.h"
 
 #include "context/static_context.h"
+#include "context/namespace_context.h"
 
 #include "types/casting.h"
 #include "types/typeimpl.h"