Merge lp:~zorba-coders/zorba/expr-memman into lp:zorba

[Markos Zaharioudakis]

New memory management for compiler expressions

New memory management for compiler expressions

[lp:~zorba-coders/zorba/expr-memman]

10875. By Carlos Manuel Lopez on 2012-07-02

Made all constructors for exprs protected, made more calls for new exprs into factory calls. Exprs now contain a pointer to the ExprManager that created them.

10876. By Carlos Manuel Lopez on 2012-07-02

Changed the way in which objects are deleted.

10877. By Carlos Manuel Lopez on 2012-07-03

Merged Markos changes and trunk, and fixed all conflicts.

10878. By Carlos Manuel Lopez on 2012-07-03

Fixed a few issues remaining from the previous merge.

10879. By Carlos Manuel Lopez on 2012-07-03

Merged trunk.

10880. By Carlos Manuel Lopez on 2012-07-04

Fixed a conflict.

10881. By Carlos Manuel Lopez on 2012-07-04

Merged Marko's code changes.

10882. By Carlos Manuel Lopez on 2012-07-05

Made Exprs contain a CompilerCB instead of the ExprManager.

10883. By Carlos Manuel Lopez on 2012-07-06

Merged Marko's changes, fixed a few conflicts.

10884. By Carlos Manuel Lopez on 2012-07-09

Merged trunk.

10885. By Carlos Manuel Lopez on 2012-07-10

Merged marko's changes.

10886. By Markos Zaharioudakis on 2012-08-08

merged MemPage class into MemoryManager

10887. By Markos Zaharioudakis on 2012-08-09

disabled auditing in zorbacmd

10888. By Markos Zaharioudakis on 2012-08-10

merge from trunk

10889. By Markos Zaharioudakis on 2012-08-10

merge from markos-scratch

=== modified file 'bin/zorbacmd.cpp'
--- bin/zorbacmd.cpp	2012-07-24 08:48:48 +0000
+++ bin/zorbacmd.cpp	2012-08-10 11:20:27 +0000
@@ -39,6 +39,9 @@
 #include <zorba/xquery_functions.h>
 #include <zorba/uri_resolvers.h>
 #include <zorba/serialization_callback.h>
+#include <zorba/audit.h>
+#include <zorba/audit_scoped.h>
+
 #include <zorba/store_manager.h>
 
 //#define DO_AUDIT
@@ -66,6 +69,8 @@
 #  include "system/properties.h"
 #endif
 
+//#define DO_AUDIT
+
 using namespace zorba;
 namespace zorbatm = zorba::time;
 
@@ -181,6 +186,35 @@
     }
   }
 
+#ifdef DO_AUDIT
+  zorba::audit::Provider* lAuditProvider = zorba->getAuditProvider();
+  zorba::audit::Configuration* config = lAuditProvider->createConfiguration();
+  std::vector<zorba::String> property_names;
+  zorba::audit::Configuration::getPropertyNames(property_names);
+
+  bool lIsStatic;
+
+  lIsStatic = zorba::audit::Configuration::
+  enableProperty(config, property_names, "xquery/compilation/parse-duration");
+  assert(lIsStatic);
+
+  lIsStatic = zorba::audit::Configuration::
+  enableProperty(config, property_names, "xquery/compilation/translation-duration");
+  assert(lIsStatic);
+
+  lIsStatic = zorba::audit::Configuration::
+  enableProperty(config, property_names, "xquery/compilation/optimization-duration");
+  assert(lIsStatic);
+
+  lIsStatic = zorba::audit::Configuration::
+  enableProperty(config, property_names, "xquery/compilation/codegeneration-duration");
+  assert(lIsStatic);
+
+  zorba::audit::Event* event = lAuditProvider->createEvent(config);
+
+  sctx->setAuditEvent(event);
+#endif // DO_AUDIT
+
 #ifndef ZORBA_NO_FULL_TEXT
   {
     ZorbaCMDProperties::FullText_t::const_iterator lIter = props.stopWordsBegin();

=== modified file 'doc/c/examples/ccontext.c'
--- doc/c/examples/ccontext.c	2012-07-24 08:48:48 +0000
+++ doc/c/examples/ccontext.c	2012-08-10 11:20:27 +0000
@@ -207,7 +207,8 @@
   lExpr2->execute(lExpr2, lContext, &lSequence2);
 
   // iterate over the result two times
-  while ( lSequence2->next(lSequence2) != XQC_END_OF_SEQUENCE ) {
+  while ( lSequence2->next(lSequence2) != XQC_END_OF_SEQUENCE ) 
+  {
     lSequence2->string_value(lSequence2, &lStringValue);
     printf("%s ", lStringValue);
   }
@@ -349,7 +350,7 @@
 
   if ( zorba_implementation(&impl, store) != XQC_NO_ERROR)
     return 1;
-
+  /*
   printf("executing C example 1\n");
   res = ccontext_example_1(impl);
   if (!res) { impl->free(impl); return 1; };
@@ -364,12 +365,12 @@
   res = ccontext_example_3(impl);
   if (!res) { impl->free(impl); return 1; };
   printf("\n");
-
+  */
   printf("executing C example 4\n");
   res = ccontext_example_4(impl);
   if (!res) { impl->free(impl); return 1; };
   printf("\n");
-
+  /*
   printf("executing C example 5\n");
   res = ccontext_example_5(impl);
   if (!res) { impl->free(impl); return 1; };
@@ -379,7 +380,7 @@
   res = ccontext_example_6(impl);
   if (!res) { impl->free(impl); return 1; };
   printf("\n");
-
+  */
   impl->free(impl);
   shutdown_store(store);
   return 0;

=== modified file 'src/api/auditimpl.cpp'
--- src/api/auditimpl.cpp	2012-07-24 08:48:48 +0000
+++ src/api/auditimpl.cpp	2012-08-10 11:20:27 +0000
@@ -59,14 +59,19 @@
 //************************************************************************
 
 const PropertyImpl INVALID("");
+
 const PropertyImpl XQUERY_COMPILATION_FILENAME(
     XQUERY_COMPILATION, "filename", 0, Property::STRING);
+
 const PropertyImpl XQUERY_COMPILATION_PARSE_DURATION(
     XQUERY_COMPILATION, "parse-duration", 1, Property::INT);
+
 const PropertyImpl XQUERY_COMPILATION_TRANSLATION_DURATION(
     XQUERY_COMPILATION, "translation-duration", 2, Property::INT);
+
 const PropertyImpl XQUERY_COMPILATION_OPTIMIZATION_DURATION(
     XQUERY_COMPILATION, "optimization-duration", 3, Property::INT);
+
 const PropertyImpl XQUERY_COMPILATION_CODEGENERATION_DURATION(
     XQUERY_COMPILATION, "codegeneration-duration", 4, Property::INT);
 

=== modified file 'src/api/dynamiccontextimpl.cpp'
--- src/api/dynamiccontextimpl.cpp	2012-07-24 08:48:48 +0000
+++ src/api/dynamiccontextimpl.cpp	2012-08-10 11:20:27 +0000
@@ -38,7 +38,6 @@
 #include "compiler/parser/query_loc.h"
 #include "compiler/parsetree/parsenodes.h"
 #include "compiler/api/compilercb.h"
-#include "compiler/expression/var_expr.h"
 
 #include "runtime/util/item_iterator.h"
 
@@ -98,9 +97,9 @@
   tree. The var_expr can be found within the static context that the variable
   belongs to. In the case of a lexical QName, this method will only attempt to
   look up the namespace prefix in the main module's static context. For a clark
-  name, it will call to the other form of get_var_expr().
+  name, it will call to the other form of get_var_info().
 ********************************************************************************/
-var_expr* DynamicContextImpl::get_var_expr(const zstring& inVarName)
+VarInfo* DynamicContextImpl::get_var_info(const zstring& inVarName)
 {
   // First check for universal name.
   zstring nsUri;
@@ -109,7 +108,7 @@
     // Looks like it is a universal name; jump over to other form.
     zstring localname;
     xml::clark_localname(inVarName, &localname);
-    return get_var_expr(nsUri, localname);
+    return get_var_info(nsUri, localname);
   }
 
   ZORBA_ASSERT(theStaticContext);
@@ -125,11 +124,9 @@
                                  QueryLoc::null);
 
   // Note: lookup_var will return NULL if the variable is not known.
-  var_expr* var = theStaticContext->lookup_var(qnameItem,
-                                               QueryLoc::null,
-                                               zerr::ZXQP0000_NO_ERROR);
+  VarInfo* var = theStaticContext->lookup_var(qnameItem);
 
-  if (var == NULL)
+  if (!var)
   {
     throw XQUERY_EXCEPTION(err::XPST0008,
     ERROR_PARAMS(BUILD_STRING('{',
@@ -150,33 +147,34 @@
   the variable  belongs to. This method will search through all static contexts,
   including library modules, for a matching variable declaration.
 ********************************************************************************/
-var_expr* DynamicContextImpl::get_var_expr(
+VarInfo* DynamicContextImpl::get_var_info(
     const zstring& inVarUri,
     const zstring& inVarLocalName) const
 {
-  var_expr* var = NULL;
-
   store::Item_t qname;
   GENV_ITEMFACTORY->createQName(qname, inVarUri, zstring(), inVarLocalName);
 
+  VarInfo* var = NULL;
+
   if (theQuery != NULL)
   {
     CompilerCB::SctxMap& lMap = theQuery->theCompilerCB->theSctxMap;
     CompilerCB::SctxMap::const_iterator ite;
+
     for (ite = lMap.begin(); ite != lMap.end(); ++ite)
     {
-      var = ite->second->lookup_var(qname, QueryLoc::null, zerr::ZXQP0000_NO_ERROR);
+      var = ite->second->lookup_var(qname);
 
       if (var)
-        break;
+        return var;
     }
   }
   else
   {
-    var = theStaticContext->lookup_var(qname, QueryLoc::null, zerr::ZXQP0000_NO_ERROR);
+    var = theStaticContext->lookup_var(qname);
   }
 
-  if (var == NULL)
+  if (!var)
   {
     throw XQUERY_EXCEPTION(err::XPST0008,
     ERROR_PARAMS(BUILD_STRING('{', inVarUri, '}', inVarLocalName ), ZED(Variable)));
@@ -200,13 +198,14 @@
     const zstring& nameSpace = Unmarshaller::getInternalString(inNamespace);
     const zstring& localName = Unmarshaller::getInternalString(inLocalname);
 
-    var_expr* var = get_var_expr(nameSpace, localName);
-    ulong varId = var->get_unique_id();
+    VarInfo* var = get_var_info(nameSpace, localName);
+
+    ulong varId = var->getId();
 
     store::Item_t item;
     store::TempSeq_t tempseq;
 
-    theCtx->get_variable(varId, var->get_name(), QueryLoc::null, item, tempseq);
+    theCtx->get_variable(varId, var->getName(), QueryLoc::null, item, tempseq);
 
     if (! item.isNull())
     {
@@ -248,11 +247,11 @@
     const zstring& localName = Unmarshaller::getInternalString(inLocalname);
     store::Iterator_t value = Unmarshaller::getInternalIterator(inValue.get());
 
-    var_expr* var;
+    VarInfo* var = NULL;
 
     try
     {
-      var = get_var_expr(nameSpace, localName);
+      var = get_var_info(nameSpace, localName);
     }
     catch (ZorbaException const& e)
     {
@@ -266,7 +265,7 @@
       throw;
     }
 
-    ulong varId = var->get_unique_id();
+    ulong varId = var->getId();
 
     theCtx->add_variable(varId, value);
 
@@ -292,7 +291,6 @@
     const zstring& varName = Unmarshaller::getInternalString(inVarName);
     store::Item_t value(Unmarshaller::getInternalItem(inValue));
     ZorbaImpl::checkItem(value);
-    var_expr* var;
 
     // For string items, check that the value is a valid Unicode codepoint sequence
     const char* invalid_char;
@@ -311,9 +309,11 @@
                    << (static_cast<unsigned int>(*invalid_char) & 0xFF)) ));
     }
 
+    VarInfo* var = NULL;
+
     try
     {
-      var = get_var_expr(varName);
+      var = get_var_info(varName);
     }
     catch (ZorbaException const& e)
     {
@@ -327,7 +327,7 @@
       throw;
     }
 
-    ulong varId = var->get_unique_id();
+    ulong varId = var->getId();
 
     // add it to the internal context
     theCtx->add_variable(varId, value);
@@ -358,11 +358,12 @@
 
     const zstring& varName = Unmarshaller::getInternalString(inVarName);
     store::Iterator_t value = Unmarshaller::getInternalIterator(inValue.get());
-    var_expr* var;
+
+    VarInfo* var = NULL;
 
     try
     {
-      var = get_var_expr(varName);
+      var = get_var_info(varName);
     }
     catch (ZorbaException const& e)
     {
@@ -376,7 +377,7 @@
       throw;
     }
 
-    ulong varId = var->get_unique_id();
+    ulong varId = var->getId();
 
     theCtx->add_variable(varId, value);
 

=== modified file 'src/api/dynamiccontextimpl.h'
--- src/api/dynamiccontextimpl.h	2012-07-24 08:48:48 +0000
+++ src/api/dynamiccontextimpl.h	2012-08-10 11:20:27 +0000
@@ -26,6 +26,7 @@
 
 class DiagnosticHandler;
 class XQueryImpl;
+class VarInfo;
 
 
 /*******************************************************************************
@@ -138,10 +139,10 @@
   getExternalFunctionParam(const String& aName, void*&) const;
 
   virtual bool
-  addExternalFunctionParameter ( const String& aName, ExternalFunctionParameter* aParam );
+  addExternalFunctionParameter(const String& aName, ExternalFunctionParameter* aParam);
 
   virtual ExternalFunctionParameter*
-  getExternalFunctionParameter ( const String& aName ) const;
+  getExternalFunctionParameter(const String& aName) const;
 
   virtual bool 
   isBoundExternalVariable(const String& aNamespace, const String& aLocalname) const;
@@ -153,9 +154,9 @@
   void checkNoIterators() const;
 
 private:
-  var_expr* get_var_expr(const zstring& inVarName);
+  VarInfo* get_var_info(const zstring& varName);
 
-  var_expr* get_var_expr(const zstring& inVarUri, const zstring& inVarLocalName) const;
+  VarInfo* get_var_info(const zstring& varUri, const zstring& varLocalName) const;
 };
 
 } /* namespace zorba */

=== modified file 'src/api/staticcontextimpl.cpp'
--- src/api/staticcontextimpl.cpp	2012-07-24 08:48:48 +0000
+++ src/api/staticcontextimpl.cpp	2012-08-10 11:20:27 +0000
@@ -73,6 +73,7 @@
 ********************************************************************************/
 StaticContextImpl::StaticContextImpl(DiagnosticHandler* aDiagnosticHandler)
   :
+  theCompilerCB(NULL),
   theMaxVarId(2),
   theDiagnosticHandler(aDiagnosticHandler),
   theUserDiagnosticHandler(true),
@@ -98,6 +99,7 @@
     DiagnosticHandler* aDiagnosticHandler)
   :
   theCtx(aCtx),
+  theCompilerCB(NULL),
   theMaxVarId(2),
   theDiagnosticHandler(aDiagnosticHandler),
   theUserDiagnosticHandler(true),
@@ -120,6 +122,7 @@
 StaticContextImpl::StaticContextImpl(const StaticContextImpl& aStaticContext)
   :
   StaticContext(),
+  theCompilerCB(NULL),
   theMaxVarId(2),
   theDiagnosticHandler(aStaticContext.theDiagnosticHandler),
   theUserDiagnosticHandler(aStaticContext.theUserDiagnosticHandler),
@@ -151,6 +154,11 @@
   {
     delete theCollectionMgr;
   }
+
+  theCtx = NULL;
+
+  if (theCompilerCB)
+    delete theCompilerCB;
 }
 
 
@@ -1015,6 +1023,8 @@
     const String& prolog,
     const Zorba_CompilerHints_t& hints)
 {
+  ZORBA_ASSERT(theCompilerCB == NULL);
+
   // Create and compile an internal query whose prolog is the given prolog and
   // its body is just the emtpy sequence expression: "()".
   XQueryImpl impl;
@@ -1023,7 +1033,9 @@
   // Copy theSctxMap of the internal query into "this". When "this" is then passed
   // as an input to a user query Q, theSctxMap of Q will be initialized as a copy
   // of this->theSctxMap.
-  theSctxMap = impl.theCompilerCB->theSctxMap;
+  //theSctxMap = impl.theCompilerCB->theSctxMap;
+  theCompilerCB = impl.theCompilerCB;
+  impl.theCompilerCB = NULL;
 }
 
 
@@ -1531,29 +1543,31 @@
 StaticContextImpl::getExternalVariables(Iterator_t& aVarsIter) const
 {
   ZORBA_TRY
-  std::vector<var_expr_t> lVars;
-  theCtx->getVariables(lVars, true, false, true);
-
-  std::vector<var_expr_t>::const_iterator lIte = lVars.begin();
-  std::vector<var_expr_t>::const_iterator lEnd = lVars.end();
-  std::vector<store::Item_t> lExVars;
-
-  for (; lIte != lEnd; ++lIte) 
+  std::vector<VarInfo*> vars;
+  theCtx->getVariables(vars, true, false, true);
+
+  std::vector<VarInfo*>::const_iterator ite = vars.begin();
+  std::vector<VarInfo*>::const_iterator end = vars.end();
+  std::vector<store::Item_t> extVars;
+
+  for (; ite != end; ++ite) 
   { 
-    lExVars.push_back(lIte->getp()->get_name());        
+    extVars.push_back((*ite)->getName());        
   }
 
-  Iterator_t vIter = new VectorIterator(lExVars, theDiagnosticHandler);
+  Iterator_t vIter = new VectorIterator(extVars, theDiagnosticHandler);
   aVarsIter = vIter; 
   ZORBA_CATCH
 }
 
+
 Item
 StaticContextImpl::fetch(const String& aURI) const
 {
   return fetch(aURI, "SOME_CONTENT", "UTF-8");
 }
 
+
 Item
 StaticContextImpl::fetch(
     const String& aURI,

=== modified file 'src/api/staticcontextimpl.h'
--- src/api/staticcontextimpl.h	2012-07-24 08:48:48 +0000
+++ src/api/staticcontextimpl.h	2012-08-10 11:20:27 +0000
@@ -65,7 +65,9 @@
 protected:
   static_context_t                    theCtx;
 
-  std::map<csize, static_context_t>   theSctxMap;
+  CompilerCB                        * theCompilerCB;
+
+  //std::map<csize, static_context_t>   theSctxMap;
 
   ulong                               theMaxVarId;
 

=== modified file 'src/api/xqueryimpl.cpp'
--- src/api/xqueryimpl.cpp	2012-07-24 08:48:48 +0000
+++ src/api/xqueryimpl.cpp	2012-08-10 11:20:27 +0000
@@ -55,7 +55,6 @@
 
 #include "compiler/api/compiler_api.h"
 #include "compiler/api/compilercb.h"
-#include "compiler/expression/var_expr.h"
 
 #include "runtime/base/plan_iterator.h"
 #include "runtime/api/plan_wrapper.h"
@@ -191,13 +190,11 @@
     delete theCompilerCB;
     theCompilerCB = NULL;
   }
-  else
-  {
-    ar.set_ccb(theCompilerCB);
-  }
-
+   
   ar & theCompilerCB;
+
   ar & thePlanProxy;
+
   ar & theStaticContext;
 
   if (!ar.is_serializing_out())
@@ -489,11 +486,13 @@
 
     // If the static context results from loadProlog, we need all the contexts
     // that were created when compiling the load-prolog query
-    theCompilerCB->theSctxMap =
-    static_cast<StaticContextImpl*>(aStaticContext.get())->theSctxMap;
-
-    ulong nextVarId = 
-    static_cast<StaticContextImpl*>(aStaticContext.get())->getMaxVarId();
+    StaticContextImpl* externalSctx = 
+    static_cast<StaticContextImpl*>(aStaticContext.get());
+
+    if (externalSctx->theCompilerCB)
+      theCompilerCB->theSctxMap = externalSctx->theCompilerCB->theSctxMap;
+
+    ulong nextVarId = externalSctx->getMaxVarId();
 
     std::istringstream lQueryStream(aQuery.c_str());
 
@@ -522,11 +521,13 @@
 
     // if the static context results from loadProlog, we need all the context
     // that were created when compiling the load-prolog query
-    theCompilerCB->theSctxMap =
-    static_cast<StaticContextImpl*>(aStaticContext.get())->theSctxMap;
-
-    ulong nextVarId = 
-    static_cast<StaticContextImpl*>(aStaticContext.get())->getMaxVarId();
+    StaticContextImpl* externalSctx = 
+    static_cast<StaticContextImpl*>(aStaticContext.get());
+
+    if (externalSctx->theCompilerCB)
+      theCompilerCB->theSctxMap = externalSctx->theCompilerCB->theSctxMap;
+
+    ulong nextVarId = externalSctx->getMaxVarId();
 
     doCompile(aQuery, aHints, true, nextVarId);
   }
@@ -762,26 +763,26 @@
     checkNotClosed();
     checkCompiled();
 
-    std::vector<var_expr_t> lVars;
-
-    CompilerCB::SctxMap::const_iterator lIte = theCompilerCB->theSctxMap.begin();
-    CompilerCB::SctxMap::const_iterator lEnd = theCompilerCB->theSctxMap.end();
-
-    for(; lIte != lEnd; ++lIte)
+    std::vector<VarInfo*> vars;
+
+    CompilerCB::SctxMap::const_iterator ite = theCompilerCB->theSctxMap.begin();
+    CompilerCB::SctxMap::const_iterator end = theCompilerCB->theSctxMap.end();
+
+    for(; ite != end; ++ite)
     {
-      lIte->second.getp()->getVariables(lVars, false, false, true);
+      ite->second.getp()->getVariables(vars, false, false, true);
     }
     
-    std::vector<var_expr_t>::const_iterator lVarIte = lVars.begin();
-    std::vector<var_expr_t>::const_iterator lVarEnd = lVars.end();
-    std::vector<store::Item_t> lExVars;
+    std::vector<VarInfo*>::const_iterator lVarIte = vars.begin();
+    std::vector<VarInfo*>::const_iterator lVarEnd = vars.end();
+    std::vector<store::Item_t> extVars;
    
     for(; lVarIte != lVarEnd; ++lVarIte)
     { 
-      lExVars.push_back((*lVarIte)->get_name());
+      extVars.push_back((*lVarIte)->getName());
     } 
 
-   Iterator_t vIter = new VectorIterator(lExVars, theDiagnosticHandler);
+   Iterator_t vIter = new VectorIterator(extVars, theDiagnosticHandler);
 
     aVarsIter = vIter; 
     
@@ -801,34 +802,40 @@
     checkNotClosed();
     checkCompiled();
 
-    var_expr* var = NULL;
-
     zstring& nameSpace = Unmarshaller::getInternalString(aNamespace);
     zstring& localName = Unmarshaller::getInternalString(aLocalname);
     
     store::Item_t qname;
     GENV_ITEMFACTORY->createQName(qname, nameSpace, zstring(), localName);
     
+    VarInfo* var = NULL;
+
     CompilerCB::SctxMap& lMap = theCompilerCB->theSctxMap;
-    CompilerCB::SctxMap::const_iterator lIte = lMap.begin();
-    CompilerCB::SctxMap::const_iterator lEnd = lMap.end();
+    CompilerCB::SctxMap::const_iterator ite = lMap.begin();
+    CompilerCB::SctxMap::const_iterator end = lMap.end();
 
-    for (; lIte != lEnd; ++lIte)
+    for (; ite != end; ++ite)
     {
-      var = lIte->second->lookup_var(qname, QueryLoc::null, zerr::ZXQP0000_NO_ERROR);
+      var = ite->second->lookup_var(qname);
       
-      if(var)
+      if (var)
         break;
     }
     
-    if(var == NULL)
+    if (!var)
+    {
       throw XQUERY_EXCEPTION(zerr::ZAPI0011_ELEMENT_NOT_DECLARED,
-      ERROR_PARAMS(BUILD_STRING('{', qname->getNamespace(), '}', qname->getLocalName()), ZED(Variable)));
+      ERROR_PARAMS(BUILD_STRING('{',
+                                qname->getNamespace(),
+                                '}',
+                                qname->getLocalName()),
+                   ZED(Variable)));
+    }
 
     if (var->hasInitializer())
       return true;
     
-    ulong varId = var->get_unique_id();
+    ulong varId = var->getId();
 
     if (theDynamicContext->is_set_variable(varId))
       return true;

=== modified file 'src/compiler/api/compiler_api.cpp'
--- src/compiler/api/compiler_api.cpp	2012-07-24 08:48:48 +0000
+++ src/compiler/api/compiler_api.cpp	2012-08-10 11:20:27 +0000
@@ -154,8 +154,8 @@
 
   if(xqxconvertor->isXQueryX((char*)xquery_str.c_str()))
   {
-    // identify XQueryX by content: 
-    // root tag = 
+    // identify XQueryX by content:
+    // root tag =
     // "<prefix:module ... xmlns:prefix="http://www.w3.org/2005/XQueryX" ... > "
 
     is_xqueryx = true;
@@ -211,18 +211,17 @@
   zorba::audit::ScopedRecord sar(ae);
 
   const char* lFileName = aFileName.c_str();
-  zorba::audit::ScopedAuditor<const char*> filenameAudit(
-      sar, zorba::audit::XQUERY_COMPILATION_FILENAME, lFileName);
+
+  audit::ScopedAuditor<const char*>
+  filenameAudit(sar, zorba::audit::XQUERY_COMPILATION_FILENAME, lFileName);
 
   parsenode_t lAST;
 
   {
     time::Timer lTimer;
 
-    audit::DurationAuditor 
-    durationAudit(sar,
-                  audit::XQUERY_COMPILATION_PARSE_DURATION,
-                  lTimer);
+    audit::DurationAuditor
+    durationAudit(sar, audit::XQUERY_COMPILATION_PARSE_DURATION, lTimer);
 
     lAST = parse(aXQuery, aFileName);
 
@@ -252,7 +251,7 @@
   {
     time::Timer lTimer;
 
-    audit::DurationAuditor 
+    audit::DurationAuditor
     durationAudit(aAuditRecord,
                   audit::XQUERY_COMPILATION_TRANSLATION_DURATION,
                   lTimer);
@@ -276,6 +275,7 @@
 #endif
 
   PlanIter_t plan;
+
   {
     time::Timer lTimer;
 
@@ -287,6 +287,8 @@
     plan = codegen("main query", rootExpr, theCompilerCB, nextDynamicVarId);
   }
 
+  //theCompilerCB->getExprManager()->garbageCollect();
+
   return plan;
 }
 
@@ -307,6 +309,10 @@
   expr_t lExpr = translate(*aParsenode, theCompilerCB);
 
 #if 0
+  std::cout << "Num exprs after translation = "
+            << theCompilerCB->getExprManager()->numExprs()
+            << std::endl << std::endl;
+
   time::get_current_walltime(stopTime);
   elapsedTime = time::get_walltime_elapsed(startTime, stopTime);      
   std::cout << "Translation time = " << elapsedTime << std::endl;
@@ -356,13 +362,19 @@
   if ( theCompilerCB->theConfig.optimize_cb != NULL )
     theCompilerCB->theConfig.optimize_cb(lExpr.getp(), "main query");
 
+#if 0
+  std::cout << "Num exprs after optimization = " 
+            << theCompilerCB->getExprManager()->numExprs()
+            << std::endl << std::endl;
+#endif
+
   return lExpr;
 }
 
 
 /******************************************************************************
   This is a small helper class used when the user wants to compile a library
-  module. The ONLY place it is used (and should be used) is in the 
+  module. The ONLY place it is used (and should be used) is in the
   XQueryCompiler::createMainModule method below.
   QQQ When we have the ability to compile a library module indepedently, this
   rather hacky class can go away. At that time, we can also eliminate the
@@ -372,20 +384,27 @@
 class FakeLibraryModuleURLResolver : public internal::URLResolver
 {
 public:
-  FakeLibraryModuleURLResolver
-  (zstring const& aLibraryModuleNamespace, 
-    zstring const& aLibraryModuleFilename, std::istream& aStream)
-    : theLibraryModuleNamespace(aLibraryModuleNamespace),
-      theLibraryModuleFilename(aLibraryModuleFilename),
-      theStream(aStream)
-  {}
+  FakeLibraryModuleURLResolver(
+      zstring const& aLibraryModuleNamespace,
+      zstring const& aLibraryModuleFilename,
+      std::istream& aStream)
+    :
+    theLibraryModuleNamespace(aLibraryModuleNamespace),
+    theLibraryModuleFilename(aLibraryModuleFilename),
+    theStream(aStream)
+  {
+  }
+
   virtual ~FakeLibraryModuleURLResolver()
-  {}
+  {
+  }
 
-  virtual internal::Resource* resolveURL
-  (zstring const& aUrl, internal::EntityData const* aEntityData)
+  virtual internal::Resource* resolveURL(
+      zstring const& aUrl,
+      internal::EntityData const* aEntityData)
   {
-    if (aUrl != theLibraryModuleNamespace) {
+    if (aUrl != theLibraryModuleNamespace)
+    {
       return NULL;
     }
     assert (theStream.good());

=== modified file 'src/compiler/api/compilercb.cpp'
--- src/compiler/api/compilercb.cpp	2012-07-24 08:48:48 +0000
+++ src/compiler/api/compilercb.cpp	2012-08-10 11:20:27 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -30,7 +30,7 @@
 #include "zorbaserialization/serialize_zorba_types.h"
 
 
-namespace zorba 
+namespace zorba
 {
 
 SERIALIZABLE_CLASS_VERSIONS(CompilerCB)
@@ -80,7 +80,7 @@
 /*******************************************************************************
 
 ********************************************************************************/
-CompilerCB::config::config(::zorba::serialization::Archiver& ar) 
+CompilerCB::config::config(::zorba::serialization::Archiver& ar)
   :
   parse_cb(NULL),
   translate_cb(NULL),
@@ -121,6 +121,8 @@
   theTimeout(timeout),
   theTempIndexCounter(0)
 {
+  theEM = new ExprManager(this);
+
   if (timeout >= 0)
     theHaveTimeout = true;
 }
@@ -128,7 +130,7 @@
 
 /*******************************************************************************
   Used by the eval iterator to create a new ccb as a copy of the ccb of the
-  enclosing query. 
+  enclosing query.
 *******************************************************************************/
 CompilerCB::CompilerCB(const CompilerCB& cb)
   :
@@ -148,6 +150,7 @@
   theTempIndexCounter(0),
   theConfig(cb.theConfig)
 {
+  theEM = new ExprManager(this);
 }
 
 
@@ -165,14 +168,17 @@
   theHasEval(false),
   theIsEval(false)
 {
+  theEM = new ExprManager(this);
 }
 
 
 /*******************************************************************************
 
 ********************************************************************************/
-CompilerCB::~CompilerCB() 
+CompilerCB::~CompilerCB()
 {
+  theSctxMap.clear();
+  delete theEM;
 }
 
 
@@ -181,6 +187,8 @@
 ********************************************************************************/
 void CompilerCB::serialize(::zorba::serialization::Archiver& ar)
 {
+  ar.set_ccb(this);
+
   ar & theHasEval;
   ar & theIsEval;
   ar & theIsLoadProlog;
@@ -190,7 +198,7 @@
 #ifdef ZORBA_WITH_DEBUGGER
   ar & theDebuggerCommons;
 #endif
-  if (!ar.is_serializing_out()) 
+  if (!ar.is_serializing_out())
   {
     //don't serialize this
     theXQueryDiagnostics = NULL;

=== modified file 'src/compiler/api/compilercb.h'
--- src/compiler/api/compilercb.h	2012-07-24 08:48:48 +0000
+++ src/compiler/api/compilercb.h	2012-08-10 11:20:27 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -32,6 +32,9 @@
 
 #include "zorbaserialization/class_serializer.h"
 
+#include "compiler/expression/mem_manager.h"
+#include "compiler/expression/expr_manager.h"
+
 namespace zorba {
 
 #ifdef ZORBA_WITH_DEBUGGER
@@ -57,7 +60,7 @@
   A query-level (or eval-level) map that stores the sctx objs that need to be
   kept around for the whole duration of a query (including runtime). In non-
   DEBUGGER mode, the map stores only for root sctx of each module. In DEBUGGER
-  mode, it stores all the sctxs created by each module. Each sctx stored in 
+  mode, it stores all the sctxs created by each module. Each sctx stored in
   this map has an associated numeric id, and theSctxMap actually maps these
   numeric ids to their associated sctx objs. The map is modified by the methods
   TranslatorImpl::end_visit(ModuleImport) and TranslatorImpl::push_scope().
@@ -89,7 +92,7 @@
 
   theIsUpdating :
   ---------------
-  Set to true if the root expr of the query or eval expr is an updating expr. 
+  Set to true if the root expr of the query or eval expr is an updating expr.
 
   theTimeout :
   ------------
@@ -124,13 +127,13 @@
 public:
   struct config : public zorba::serialization::SerializeBaseClass
   {
-    typedef enum 
+    typedef enum
     {
       O0,
       O1,
       O2
     } opt_level_t;
-    
+
     typedef void (* expr_callback) (const expr *, const std::string& name);
 
     typedef void (* ast_callback) (const parsenode *, const std::string& name);
@@ -157,7 +160,9 @@
 
   typedef std::map<csize, static_context_t> SctxMap;
 
-public:  
+public:
+  ExprManager             * theEM;
+
   XQueryDiagnostics       * theXQueryDiagnostics;
 
   SctxMap                   theSctxMap;
@@ -211,6 +216,11 @@
   bool isSequential() const { return theIsSequential;}
 
   static_context* getStaticContext(int id);
+
+  ExprManager* getExprManager() const { return theEM; }
+
+  MemoryManager& getMemoryManager() const { return theEM->getMemory(); }
+
 };
 
 

=== modified file 'src/compiler/codegen/plan_visitor.cpp'
--- src/compiler/codegen/plan_visitor.cpp	2012-07-24 08:48:48 +0000
+++ src/compiler/codegen/plan_visitor.cpp	2012-08-10 11:20:27 +0000
@@ -2075,18 +2075,24 @@
 
   csize numVars = v.var_count();
 
-  checked_vector<PlanIter_t> args(numVars+1);
-  checked_vector<store::Item_t> varnames(numVars);
-  checked_vector<xqtref_t> vartypes(numVars);
+  checked_vector<PlanIter_t> args;
+  args.reserve(numVars+1);
+
+  std::vector<store::Item_t> varNames(numVars);
+  std::vector<xqtref_t> varTypes(numVars);
+  std::vector<int> isGlobalVar(numVars);
 
   for (csize i = 0; i < numVars; ++i)
   {
-    varnames[i] = v.get_var(i)->get_name();
-    vartypes[i] = v.get_var(i)->get_type();
-    args[i] = pop_itstack();
+    varNames[i] = v.get_var(i)->get_name();
+    varTypes[i] = v.get_var(i)->get_type();
+    isGlobalVar[i] = (v.get_arg_expr(i) == NULL);
+
+    if (!isGlobalVar[i])
+      args.push_back(pop_itstack());
   }
 
-  args[numVars] = pop_itstack();
+  args.push_back(pop_itstack());
   reverse(args.begin(), args.end());
 
   store::NsBindings localBindings;
@@ -2095,8 +2101,9 @@
   push_itstack(new EvalIterator(sctx,
                                 qloc,
                                 args,
-                                varnames,
-                                vartypes, 
+                                varNames,
+                                varTypes,
+                                isGlobalVar, 
                                 v.get_inner_scripting_kind(),
                                 localBindings,
                                 v.getNodeCopy(),
@@ -2127,14 +2134,17 @@
   std::vector<PlanIter_t> argvEvalIter;
 
   csize numVars = v.var_count();
-  std::vector<store::Item_t> varnames(numVars);
-  std::vector<xqtref_t> vartypes(numVars);
+  std::vector<store::Item_t> varNames(numVars);
+  std::vector<xqtref_t> varTypes(numVars);
+  std::vector<int> isGlobalVar(numVars);
 
   //create the eval iterator children
   for (csize i = 0; i < numVars; i++) 
   {
-    varnames[i] = v.get_var(i)->get_name();
-    vartypes[i] = v.get_var(i)->get_type();
+    varNames[i] = v.get_var(i)->get_name();
+    varTypes[i] = v.get_var(i)->get_type();
+    isGlobalVar[i] = (v.get_var(i)->get_kind() == var_expr::prolog_var);
+
     argvEvalIter.push_back(pop_itstack());
   }
 
@@ -2167,15 +2177,16 @@
   argv.push_back(new EvalIterator(sctx,
                                   qloc,
                                   argvEvalIter,
-                                  varnames,
-                                  vartypes,
+                                  varNames,
+                                  varTypes,
+                                  isGlobalVar,
                                   SEQUENTIAL_FUNC_EXPR,
                                   localBindings,
                                   true,
                                   true));
 
   lDebugIterator->setChildren(&argv);
-  lDebugIterator->setVariables(varnames, vartypes);
+  lDebugIterator->setVariables(varNames, varTypes);
 
   // link all debugger iterators in the tree
   if (!theDebuggerStack.empty()) 

=== modified file 'src/compiler/expression/CMakeLists.txt'
--- src/compiler/expression/CMakeLists.txt	2012-07-24 08:48:48 +0000
+++ src/compiler/expression/CMakeLists.txt	2012-08-10 11:20:27 +0000
@@ -26,7 +26,9 @@
     fo_expr.cpp
     script_exprs.cpp
     update_exprs.cpp
-    function_item_expr.cpp)
+    function_item_expr.cpp
+    mem_manager.cpp
+    expr_manager.cpp)
 
 IF (NOT ZORBA_NO_FULL_TEXT)
   LIST(APPEND EXPRESSION_SRCS

=== modified file 'src/compiler/expression/expr.cpp'
--- src/compiler/expression/expr.cpp	2012-07-24 08:48:48 +0000
+++ src/compiler/expression/expr.cpp	2012-08-10 11:20:27 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -43,12 +43,15 @@
 #include "compiler/expression/expr_utils.h"
 #include "compiler/expression/expr_visitor.h"
 #include "compiler/parser/parse_constants.h"
+#include "compiler/expression/expr_manager.h"
+
 #include "compiler/api/compilercb.h"
 
 #include "store/api/store.h"
 #include "store/api/item_factory.h"
 
-namespace zorba 
+
+namespace zorba
 {
 
 
@@ -88,23 +91,24 @@
   [68] IfExpr ::= "if" "(" Expr ")" "then" ExprSingle "else" ExprSingle
 ********************************************************************************/
 if_expr::if_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_t condExpr,
     expr_t thenExpr,
     expr_t elseExpr)
   :
-  expr(sctx, loc, if_expr_kind),
+  expr(ccb, sctx, loc, if_expr_kind),
   theThenExpr(thenExpr),
   theElseExpr(elseExpr)
 {
   if (sctx != NULL &&
-      !TypeOps::is_equal(sctx->get_typemanager(), 
+      !TypeOps::is_equal(sctx->get_typemanager(),
                          *condExpr->get_return_type(),
                          *GENV_TYPESYSTEM.BOOLEAN_TYPE_ONE,
                          loc))
   {
-    fo_expr* boolExpr = new fo_expr(sctx,
+    fo_expr* boolExpr = theCCB->theEM->create_fo_expr(sctx,
                                     loc,
                                     GET_BUILTIN_FUNCTION(FN_BOOLEAN_1),
                                     condExpr);
@@ -153,7 +157,7 @@
   {
     theScriptingKind = VACUOUS_EXPR;
   }
-  else 
+  else
   {
     theScriptingKind = SIMPLE_EXPR;
   }
@@ -162,9 +166,9 @@
 }
 
 
-expr_t if_expr::clone(substitution_t& subst) const 
+expr_t if_expr::clone(substitution_t& subst) const
 {
-  return new if_expr(theSctx,
+  return theCCB->theEM->create_if_expr(theSctx,
                      get_loc(),
                      get_cond_expr()->clone(subst),
                      get_then_expr()->clone(subst),
@@ -176,12 +180,13 @@
 
 ********************************************************************************/
 order_expr::order_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     order_type_t type,
     expr_t inExpr)
   :
-  expr(sctx, loc, order_expr_kind),
+  expr(ccb, sctx, loc, order_expr_kind),
   theType(type),
   theExpr(inExpr)
 {
@@ -200,7 +205,7 @@
 
 expr_t order_expr::clone(substitution_t& subst) const
 {
-  return new order_expr(theSctx, get_loc(), get_type(), get_expr()->clone(subst));
+  return theCCB->theEM->create_order_expr(theSctx, get_loc(), get_type(), get_expr()->clone(subst));
 }
 
 
@@ -208,6 +213,7 @@
 
 ********************************************************************************/
 validate_expr::validate_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     enum ParseConstants::validation_mode_t mode,
@@ -215,7 +221,7 @@
     expr_t inExpr,
     rchandle<TypeManager> typemgr)
   :
-  expr(sctx, loc, validate_expr_kind),
+  expr(ccb, sctx, loc, validate_expr_kind),
   theMode(mode),
   theTypeName(typeName),
   theTypeMgr(typemgr),
@@ -238,7 +244,7 @@
 
 expr_t validate_expr::clone(substitution_t& subst) const
 {
-  return new validate_expr(theSctx,
+  return theCCB->theEM->create_validate_expr(theSctx,
                            get_loc(),
                            get_valmode(),
                            const_cast<store::Item*>(get_type_name()),
@@ -251,12 +257,13 @@
   Base for expression classes that require a namespace context
 ********************************************************************************/
 namespace_context_base_expr::namespace_context_base_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_kind_t kind,
     const namespace_context* aNSCtx)
   :
-  expr(sctx, loc, kind),
+  expr(ccb, sctx, loc, kind),
   theNSCtx(const_cast<namespace_context*>(aNSCtx))
 {
 }
@@ -264,7 +271,7 @@
 
 const namespace_context* namespace_context_base_expr::getNSCtx() const
 {
-  return theNSCtx.getp(); 
+  return theNSCtx.getp();
 }
 
 
@@ -273,13 +280,14 @@
   Base for cast, treat, promote, castable, instanceof
 ********************************************************************************/
 cast_or_castable_base_expr::cast_or_castable_base_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_kind_t kind,
     const expr_t& input,
     const xqtref_t& type)
   :
-  expr(sctx, loc, kind),
+  expr(ccb, sctx, loc, kind),
   theInputExpr(input),
   theTargetType(type)
 {
@@ -290,13 +298,13 @@
 }
 
 
-xqtref_t cast_or_castable_base_expr::get_target_type() const 
+xqtref_t cast_or_castable_base_expr::get_target_type() const
 {
   return theTargetType;
 }
 
 
-void cast_or_castable_base_expr::set_target_type(xqtref_t target) 
+void cast_or_castable_base_expr::set_target_type(xqtref_t target)
 {
   theTargetType = target;
 }
@@ -317,13 +325,14 @@
   Base for cast, treat, promote
 ********************************************************************************/
 cast_base_expr::cast_base_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_kind_t kind,
     const expr_t& input,
     const xqtref_t& type)
-  : 
-  cast_or_castable_base_expr(sctx, loc, kind, input, type)
+  :
+  cast_or_castable_base_expr(ccb, sctx, loc, kind, input, type)
 {
   setNonDiscardable(ANNOTATION_TRUE_FIXED);
 }
@@ -335,37 +344,39 @@
   SingleType ::= AtomicType "?"?
 ********************************************************************************/
 cast_expr::cast_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     const expr_t& inputExpr,
     const xqtref_t& type)
   :
-  cast_base_expr(sctx, loc, cast_expr_kind, inputExpr, type)
+  cast_base_expr(ccb, sctx, loc, cast_expr_kind, inputExpr, type)
 {
   assert(type->get_quantifier() == TypeConstants::QUANT_ONE ||
          type->get_quantifier() == TypeConstants::QUANT_QUESTION);
 }
 
 
-bool cast_expr::is_optional() const 
+bool cast_expr::is_optional() const
 {
-  return theTargetType->get_quantifier() == TypeConstants::QUANT_QUESTION; 
+  return theTargetType->get_quantifier() == TypeConstants::QUANT_QUESTION;
 }
 
 
 expr_t cast_expr::clone(substitution_t& subst) const
 {
-  return new cast_expr(theSctx,
+  return theCCB->theEM->create_cast_expr(theSctx,
                        get_loc(),
-                       get_input()->clone(subst), 
+                       get_input()->clone(subst),
                        get_target_type());
 }
 
 
 /***************************************************************************//**
-	TreatExpr ::= CastableExpr ( "treat" "as" SequenceType )?
+  TreatExpr ::= CastableExpr ( "treat" "as" SequenceType )?
 ********************************************************************************/
 treat_expr::treat_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     const expr_t& inputExpr,
@@ -374,7 +385,7 @@
     bool check_prime,
     store::Item* qname)
   :
-  cast_base_expr(sctx, loc, treat_expr_kind, inputExpr, type),
+  cast_base_expr(ccb, sctx, loc, treat_expr_kind, inputExpr, type),
   theErrorKind(err),
   theCheckPrime(check_prime),
   theQName(qname)
@@ -384,9 +395,9 @@
 
 expr_t treat_expr::clone(substitution_t& subst) const
 {
-  return new treat_expr(theSctx,
+  return theCCB->theEM->create_treat_expr(theSctx,
                         get_loc(),
-                        get_input()->clone(subst), 
+                        get_input()->clone(subst),
                         get_target_type(),
                         get_err(),
                         get_check_prime(),
@@ -398,6 +409,7 @@
 
 ********************************************************************************/
 promote_expr::promote_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     const expr_t& input,
@@ -405,7 +417,7 @@
     PromoteIterator::ErrorKind err,
     store::Item* qname)
   :
-  cast_base_expr(sctx, loc, promote_expr_kind, input, type),
+  cast_base_expr(ccb, sctx, loc, promote_expr_kind, input, type),
   theErrorKind(err),
   theQName(qname)
 {
@@ -414,7 +426,7 @@
 
 expr_t promote_expr::clone(substitution_t& subst) const
 {
-  return new promote_expr(theSctx, 
+  return theCCB->theEM->create_promote_expr(theSctx,
                           get_loc(),
                           get_input()->clone(subst),
                           get_target_type(),
@@ -427,13 +439,14 @@
   Base for castable, instanceof
 ********************************************************************************/
 castable_base_expr::castable_base_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_kind_t kind,
     const expr_t& input,
     const xqtref_t& type)
   :
-  cast_or_castable_base_expr(sctx, loc, kind, input, type)
+  cast_or_castable_base_expr(ccb, sctx, loc, kind, input, type)
 {
 }
 
@@ -444,25 +457,26 @@
   SingleType ::= AtomicType "?"?
 ********************************************************************************/
 castable_expr::castable_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     const expr_t& inputExpr,
     const xqtref_t& type)
   :
-  castable_base_expr (sctx, loc, castable_expr_kind, inputExpr, type)
+  castable_base_expr (ccb, sctx, loc, castable_expr_kind, inputExpr, type)
 {
 }
 
 
-bool castable_expr::is_optional() const 
+bool castable_expr::is_optional() const
 {
-  return theTargetType->get_quantifier() == TypeConstants::QUANT_QUESTION; 
+  return theTargetType->get_quantifier() == TypeConstants::QUANT_QUESTION;
 }
 
 
 expr_t castable_expr::clone(substitution_t& subst) const
 {
-  return new castable_expr(theSctx, 
+  return theCCB->theEM->create_castable_expr(theSctx,
                            get_loc(),
                            get_input()->clone(subst),
                            get_target_type());
@@ -470,16 +484,17 @@
 
 
 /***************************************************************************//**
-	InstanceofExpr ::= TreatExpr ( "instance" "of" SequenceType )?
+  InstanceofExpr ::= TreatExpr ( "instance" "of" SequenceType )?
 ********************************************************************************/
 instanceof_expr::instanceof_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     const expr_t& inputExpr,
     const xqtref_t& type,
     bool checkPrimeOnly)
   :
-  castable_base_expr(sctx, loc, instanceof_expr_kind, inputExpr, type),
+  castable_base_expr(ccb, sctx, loc, instanceof_expr_kind, inputExpr, type),
   theCheckPrimeOnly(checkPrimeOnly)
 {
 }
@@ -487,7 +502,7 @@
 
 expr_t instanceof_expr::clone(substitution_t& subst) const
 {
-  return new instanceof_expr(theSctx,
+  return theCCB->theEM->create_instanceof_expr(theSctx,
                              get_loc(),
                              get_input()->clone(subst),
                              get_target_type());
@@ -498,13 +513,14 @@
 
 ********************************************************************************/
 name_cast_expr::name_cast_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_t inputExpr,
     const namespace_context* aNSCtx,
     bool isAttrName)
   :
-  namespace_context_base_expr(sctx, loc, name_cast_expr_kind, aNSCtx),
+  namespace_context_base_expr(ccb, sctx, loc, name_cast_expr_kind, aNSCtx),
   theInputExpr(inputExpr),
   theIsAttrName(isAttrName)
 {
@@ -525,7 +541,7 @@
 
 expr_t name_cast_expr::clone(substitution_t& subst) const
 {
-  return new name_cast_expr(theSctx,
+  return theCCB->theEM->create_name_cast_expr(theSctx,
                             get_loc(),
                             get_input()->clone(subst),
                             getNSCtx(),
@@ -537,12 +553,13 @@
   CompDocConstructor ::= "document" "{" Expr "}"
 ********************************************************************************/
 doc_expr::doc_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr* aContent,
     bool copyNodes)
   :
-  expr(sctx, loc, doc_expr_kind),
+  expr(ccb, sctx, loc, doc_expr_kind),
   theContent(aContent),
   theCopyInputNodes(copyNodes)
 {
@@ -563,7 +580,7 @@
 
 expr_t doc_expr::clone(substitution_t& subst) const
 {
-  doc_expr* clone = new doc_expr(theSctx,
+  doc_expr* clone = theCCB->theEM->create_doc_expr(theSctx,
                                  get_loc(),
                                  CLONE(getContent(), subst),
                                  theCopyInputNodes);
@@ -575,6 +592,7 @@
 
 ********************************************************************************/
 elem_expr::elem_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& aLoc,
     expr* aQNameExpr,
@@ -583,7 +601,7 @@
     const namespace_context* aNSCtx,
     bool copyNodes)
   :
-  namespace_context_base_expr(sctx, aLoc, elem_expr_kind, aNSCtx),
+  namespace_context_base_expr(ccb, sctx, aLoc, elem_expr_kind, aNSCtx),
   theQNameExpr(aQNameExpr),
   theAttrs(attrs),
   theContent(content),
@@ -596,6 +614,7 @@
 
 
 elem_expr::elem_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& aLoc,
     expr* aQNameExpr,
@@ -603,7 +622,7 @@
     const namespace_context* aNSCtx,
     bool copyNodes)
   :
-  namespace_context_base_expr(sctx, aLoc, elem_expr_kind, aNSCtx),
+  namespace_context_base_expr(ccb, sctx, aLoc, elem_expr_kind, aNSCtx),
   theQNameExpr(aQNameExpr),
   theAttrs(0),
   theContent(content),
@@ -613,7 +632,7 @@
 
   setUnfoldable(ANNOTATION_TRUE_FIXED);
 }
-  
+
 
 void elem_expr::compute_scripting_kind()
 {
@@ -643,7 +662,7 @@
 
 expr_t elem_expr::clone(substitution_t& subst) const
 {
-  elem_expr* clone =  new elem_expr(theSctx,
+  elem_expr* clone =  theCCB->theEM->create_elem_expr(theSctx,
                                     get_loc(),
                                     CLONE(getQNameExpr(), subst),
                                     CLONE(getAttrs(), subst),
@@ -658,12 +677,13 @@
 
 ********************************************************************************/
 attr_expr::attr_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_t aQNameExpr,
     expr_t aValueExpr)
   :
-  expr(sctx, loc, attr_expr_kind),
+  expr(ccb, sctx, loc, attr_expr_kind),
   theQNameExpr(aQNameExpr),
   theValueExpr(aValueExpr)
 {
@@ -709,7 +729,7 @@
 
 expr_t attr_expr::clone(substitution_t& subst) const
 {
-  return new attr_expr(theSctx,
+  return theCCB->theEM->create_attr_expr(theSctx,
                        get_loc(),
                        CLONE(getQNameExpr(), subst),
                        CLONE(getValueExpr(), subst));
@@ -723,12 +743,13 @@
 
 ********************************************************************************/
 text_expr::text_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     text_constructor_type type_arg,
     expr_t content)
   :
-  expr(sctx, loc, text_expr_kind),
+  expr(ccb, sctx, loc, text_expr_kind),
   type(type_arg),
   theContentExpr(content)
 {
@@ -751,7 +772,7 @@
 
 expr_t text_expr::clone(substitution_t& subst) const
 {
-  return new text_expr(theSctx, get_loc(), get_type(), CLONE(get_text(), subst));
+  return theCCB->theEM->create_text_expr(theSctx, get_loc(), get_type(), CLONE(get_text(), subst));
 }
 
 
@@ -759,12 +780,13 @@
 
 ********************************************************************************/
 pi_expr::pi_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_t targetExpr,
     expr_t contentExpr)
 :
-  expr(sctx, loc, pi_expr_kind),
+  expr(ccb, sctx, loc, pi_expr_kind),
   theTargetExpr(targetExpr),
   theContentExpr(contentExpr)
 {
@@ -800,7 +822,7 @@
 
 expr_t pi_expr::clone(substitution_t& subst) const
 {
-  return new pi_expr(theSctx,
+  return theCCB->theEM->create_pi_expr(theSctx,
                      get_loc(),
                      CLONE(get_target_expr(), subst),
                      CLONE(get_content_expr(), subst));
@@ -812,9 +834,9 @@
   Normally, it is used to wrap a var_expr in order to represent a var reference
   (see var_expr.h). But it may wrap any other kind of expr as well.
 ********************************************************************************/
-wrapper_expr::wrapper_expr(static_context* sctx, const QueryLoc& loc, expr_t wrapped)
+wrapper_expr::wrapper_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, expr_t wrapped)
   :
-  expr(sctx, loc, wrapper_expr_kind),
+  expr(ccb, sctx, loc, wrapper_expr_kind),
   theWrappedExpr(wrapped)
 {
   compute_scripting_kind();
@@ -835,67 +857,69 @@
       e->get_expr_kind() != var_expr_kind)
     return e;
   else
-    return new wrapper_expr(theSctx, get_loc(), e);
+    return theCCB->theEM->create_wrapper_expr(theSctx, get_loc(), e);
 }
 
 
 /***************************************************************************//**
 
 ********************************************************************************/
-const_expr::const_expr(static_context* sctx, const QueryLoc& loc, zstring& v)
-  :
-  expr(sctx, loc, const_expr_kind)
-{
-  GENV_ITEMFACTORY->createString(theValue, v); 
-  theScriptingKind = SIMPLE_EXPR;
-}
-
-
-const_expr::const_expr(static_context* sctx, const QueryLoc& loc, const std::string& v)
-  :
-  expr(sctx, loc, const_expr_kind)
-{
-  zstring tmp(v);
-  GENV_ITEMFACTORY->createString(theValue, tmp); 
-  theScriptingKind = SIMPLE_EXPR;
-}
-
-
-const_expr::const_expr(static_context* sctx, const QueryLoc& loc, const char* v)
-  :
-  expr(sctx, loc, const_expr_kind)
-{
-  zstring tmp(v);
-  GENV_ITEMFACTORY->createString(theValue, tmp); 
-  theScriptingKind = SIMPLE_EXPR;
-}
-
-
-const_expr::const_expr(static_context* sctx, const QueryLoc& loc, xs_integer v)
-  :
-  expr(sctx, loc, const_expr_kind)
+const_expr::const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, zstring& v)
+  :
+  expr(ccb, sctx, loc, const_expr_kind)
+{
+  GENV_ITEMFACTORY->createString(theValue, v);
+  theScriptingKind = SIMPLE_EXPR;
+}
+
+
+const_expr::const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, const std::string& v)
+  :
+  expr(ccb, sctx, loc, const_expr_kind)
+{
+  zstring tmp(v);
+  GENV_ITEMFACTORY->createString(theValue, tmp);
+  theScriptingKind = SIMPLE_EXPR;
+}
+
+
+const_expr::const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, const char* v)
+  :
+  expr(ccb, sctx, loc, const_expr_kind)
+{
+  zstring tmp(v);
+  GENV_ITEMFACTORY->createString(theValue, tmp);
+  theScriptingKind = SIMPLE_EXPR;
+}
+
+
+const_expr::const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, xs_integer v)
+  :
+  expr(ccb, sctx, loc, const_expr_kind)
 {
   GENV_ITEMFACTORY->createInteger(theValue, v);
   theScriptingKind = SIMPLE_EXPR;
 }
 
 const_expr::const_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     xs_decimal v)
   :
-  expr(sctx, loc, const_expr_kind)
+  expr(ccb, sctx, loc, const_expr_kind)
 {
   GENV_ITEMFACTORY->createDecimal(theValue, v);
   theScriptingKind = SIMPLE_EXPR;
 }
 
 const_expr::const_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     xs_double v)
   :
-  expr(sctx, loc, const_expr_kind)
+  expr(ccb, sctx, loc, const_expr_kind)
 {
   GENV_ITEMFACTORY->createDouble(theValue, v);
   theScriptingKind = SIMPLE_EXPR;
@@ -903,11 +927,12 @@
 
 
 const_expr::const_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     xs_boolean v)
   :
-  expr(sctx, loc, const_expr_kind)
+  expr(ccb, sctx, loc, const_expr_kind)
 {
   GENV_ITEMFACTORY->createBoolean(theValue, v);
   theScriptingKind = SIMPLE_EXPR;
@@ -915,11 +940,12 @@
 
 
 const_expr::const_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     store::Item_t v)
   :
-  expr(sctx, loc, const_expr_kind),
+  expr(ccb, sctx, loc, const_expr_kind),
   theValue(v)
 {
   theScriptingKind = SIMPLE_EXPR;
@@ -927,13 +953,14 @@
 
 
 const_expr::const_expr(
+    CompilerCB* ccb,
     static_context* sctx,
-    const QueryLoc& aLoc, 
+    const QueryLoc& aLoc,
     const char* aNamespace,
-    const char* aPrefix, 
+    const char* aPrefix,
     const char* aLocal)
   :
-  expr(sctx, aLoc, const_expr_kind)
+  expr(ccb, sctx, aLoc, const_expr_kind)
 {
   GENV_ITEMFACTORY->createQName(theValue, aNamespace, aPrefix, aLocal);
   theScriptingKind = SIMPLE_EXPR;
@@ -948,7 +975,7 @@
 
 expr_t const_expr::clone(substitution_t&) const
 {
-  return new const_expr(theSctx, get_loc(), theValue);
+  return theCCB->theEM->create_const_expr(theSctx, get_loc(), theValue);
 }
 
 
@@ -964,21 +991,23 @@
 
 
 extension_expr::extension_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc)
   :
-  expr(sctx, loc, extension_expr_kind)
+  expr(ccb, sctx, loc, extension_expr_kind)
 {
   compute_scripting_kind();
 }
 
 
 extension_expr::extension_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_t e)
   :
-  expr(sctx, loc, extension_expr_kind),
+  expr(ccb, sctx, loc, extension_expr_kind),
   theExpr(e)
 {
   compute_scripting_kind();
@@ -996,16 +1025,16 @@
 }
 
 
-expr_t extension_expr::clone(substitution_t& subst) const 
+expr_t extension_expr::clone(substitution_t& subst) const
 {
   rchandle<extension_expr> lClone(0);
   lClone = (
-    theExpr == 0 ? new extension_expr(theSctx, get_loc())
-                 : new extension_expr(theSctx, get_loc(), theExpr->clone()) );
+    theExpr == 0 ? theCCB->theEM->create_extension_expr(theSctx, get_loc())
+                 : theCCB->theEM->create_extension_expr(theSctx, get_loc(), theExpr->clone()) );
   // pragm doesn't contain expressions. Thus, it is not cloned.
   for ( std::vector<rchandle<pragma> >::const_iterator lIter = thePragmas.begin();
         lIter != thePragmas.end();
-        ++lIter ) 
+        ++lIter )
   {
     lClone->add(*lIter);
   }
@@ -1015,7 +1044,7 @@
 
 /////////////////////////////////////////////////////////////////////////
 //                                                                     //
-//	XQuery 3.0 expressions                                             //
+//  XQuery 3.0 expressions                                             //
 //  [http://www.w3.org/TR/xquery-3/]                                   //
 //                                                                     //
 /////////////////////////////////////////////////////////////////////////
@@ -1030,11 +1059,12 @@
 
 
 trycatch_expr::trycatch_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_t tryExpr)
   :
-  expr(sctx, loc, trycatch_expr_kind),
+  expr(ccb, sctx, loc, trycatch_expr_kind),
   theTryExpr(tryExpr)
 {
   compute_scripting_kind();
@@ -1068,7 +1098,7 @@
 
   csize numCatchClauses = theCatchClauses.size();
 
-  for (csize i = 0; i < numCatchClauses; ++i) 
+  for (csize i = 0; i < numCatchClauses; ++i)
   {
     const expr* catchExpr = theCatchExprs[i].getp();
     short catchKind = catchExpr->get_scripting_detail();
@@ -1085,7 +1115,7 @@
         RAISE_ERROR(err::XUST0001, catchExpr->get_loc(),
         ERROR_PARAMS(ZED(XUST0001_TRYCATCH)));
       }
-        
+
       if (!is_updating() && !is_vacuous() && (catchKind & UPDATING_EXPR))
       {
         RAISE_ERROR(err::XUST0001, catchExpr->get_loc(),
@@ -1115,13 +1145,13 @@
 
   for (nt_list_t::const_iterator lIter = theNameTests.begin();
        lIter != theNameTests.end();
-       ++lIter) 
+       ++lIter)
   {
     lClause->add_nametest_h(lIter->getp());
   }
   for (var_map_t::const_iterator lIter = theVarMap.begin();
        lIter != theVarMap.end();
-       ++lIter) 
+       ++lIter)
   {
     lClause->add_var((catch_clause::var_type)lIter->first, lIter->second.getp());
   }
@@ -1133,16 +1163,16 @@
 expr_t trycatch_expr::clone(substitution_t& subst) const
 {
   std::auto_ptr<trycatch_expr> lTryCatch(
-      new trycatch_expr(theSctx, get_loc(), theTryExpr->clone(subst)));
+      theCCB->theEM->create_trycatch_expr(theSctx, get_loc(), theTryExpr->clone(subst)));
 
   for (std::vector<expr_t>::const_iterator lIter = theCatchExprs.begin();
        lIter != theCatchExprs.end();
-       ++lIter) 
+       ++lIter)
   {
     lTryCatch->add_catch_expr((*lIter)->clone(subst));
   }
 
-  for (uint32_t i = 0; i < clause_count(); ++i) 
+  for (uint32_t i = 0; i < clause_count(); ++i)
   {
     lTryCatch->add_clause(theCatchClauses[i]->clone(subst));
   }
@@ -1155,14 +1185,15 @@
 
 ********************************************************************************/
 eval_expr::eval_expr(
+    CompilerCB* creating_ccb,
     CompilerCB* ccb,
     static_context* sctx,
-    const QueryLoc& loc, 
+    const QueryLoc& loc,
     const expr_t& e,
     expr_script_kind_t scriptingKind,
     namespace_context* nsCtx)
   :
-  namespace_context_base_expr(sctx, loc, eval_expr_kind, nsCtx),
+  namespace_context_base_expr(creating_ccb, sctx, loc, eval_expr_kind, nsCtx),
   theExpr(e),
   theInnerScriptingKind(scriptingKind),
   theDoNodeCopy(false)
@@ -1174,9 +1205,9 @@
 }
 
 
-expr_script_kind_t eval_expr::get_inner_scripting_kind() const 
+expr_script_kind_t eval_expr::get_inner_scripting_kind() const
 {
-  return theInnerScriptingKind; 
+  return theInnerScriptingKind;
 }
 
 
@@ -1198,9 +1229,10 @@
 
 expr_t eval_expr::clone(substitution_t& s) const
 {
-  rchandle<eval_expr> new_eval = new eval_expr(NULL,
-                                               theSctx, 
-                                               theLoc, 
+  rchandle<eval_expr> new_eval = theCCB->theEM->create_eval_expr(
+                                               NULL,
+                                               theSctx,
+                                               theLoc,
                                                theExpr->clone(s),
                                                theInnerScriptingKind,
                                                theNSCtx.getp());
@@ -1210,7 +1242,7 @@
   {
     var_expr_t cloneVar = dynamic_cast<var_expr*>(theVars[i]->clone(s).getp());
     assert(cloneVar != NULL);
-    new_eval->add_var(cloneVar, theArgs[i]->clone(s));
+    new_eval->add_var(cloneVar, (theArgs[i] ? theArgs[i]->clone(s) : NULL));
   }
 
   return new_eval.getp();
@@ -1222,13 +1254,14 @@
 
 ********************************************************************************/
 debugger_expr::debugger_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     const expr_t& aChild,
     namespace_context* nsCtx,
     bool aIsVarDeclaration)
   :
-  namespace_context_base_expr(sctx, loc, debugger_expr_kind, nsCtx),
+  namespace_context_base_expr(ccb, sctx, loc, debugger_expr_kind, nsCtx),
   theExpr(aChild),
   theIsVarDeclaration(aIsVarDeclaration)
 {
@@ -1248,11 +1281,12 @@
 
 ********************************************************************************/
 function_trace_expr::function_trace_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_t aChild)
   :
-  expr(sctx, loc, function_trace_expr_kind),
+  expr(ccb, sctx, loc, aChild->get_expr_kind()),
   theExpr(aChild),
   theFunctionArity(0)
 {
@@ -1264,7 +1298,7 @@
 
 function_trace_expr::function_trace_expr(expr_t aExpr)
   :
-  expr(aExpr->get_sctx(), aExpr->get_loc(), function_trace_expr_kind),
+  expr(aExpr->get_ccb(), aExpr->get_sctx(), aExpr->get_loc(), function_trace_expr_kind),
   theExpr(aExpr),
   theFunctionArity(0)
 {
@@ -1274,7 +1308,7 @@
 }
 
 
-function_trace_expr::~function_trace_expr() 
+function_trace_expr::~function_trace_expr()
 {
 }
 
@@ -1287,12 +1321,14 @@
 
 expr_t function_trace_expr::clone(substitution_t& s) const
 {
-  function_trace_expr* clone = new function_trace_expr(theExpr->clone(s));
+  function_trace_expr* clone = theCCB->theEM->
+      create_function_trace_expr(theExpr->clone(s));
 
   clone->theFunctionName = theFunctionName;
   clone->theFunctionLocation = theFunctionLocation;
   clone->theFunctionCallLocation = theFunctionCallLocation;
   clone->theFunctionArity = theFunctionArity;
+
   return clone;
 }
 

=== modified file 'src/compiler/expression/expr.h'
--- src/compiler/expression/expr.h	2012-07-24 08:48:48 +0000
+++ src/compiler/expression/expr.h	2012-08-10 11:20:27 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -39,20 +39,20 @@
 
 #include "runtime/core/sequencetypes.h"
 
-namespace zorba 
+namespace zorba
 {
 
+class ExprManager;
 class expr_visitor;
 class NodeNameTest;
 class signature;
 
-
-
 /*******************************************************************************
   [68] IfExpr ::= "if" "(" Expr ")" "then" ExprSingle "else" ExprSingle
 ********************************************************************************/
-class if_expr : public expr 
+class if_expr : public expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
@@ -61,14 +61,16 @@
   expr_t theThenExpr;
   expr_t theElseExpr;
 
-public:
+protected:
   if_expr(
+        CompilerCB* ccb,
         static_context* sctx,
         const QueryLoc& loc,
         expr_t c,
         expr_t t,
         expr_t e);
 
+public:
   expr* get_cond_expr() const { return theCondExpr.getp(); }
 
   expr* get_then_expr() const { return theThenExpr.getp(); }
@@ -88,13 +90,14 @@
 /***************************************************************************//**
 
 ********************************************************************************/
-class order_expr : public expr 
+class order_expr : public expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
 public:
-  enum order_type_t 
+  enum order_type_t
   {
     ordered,
     unordered
@@ -104,9 +107,10 @@
   order_type_t theType;
   expr_t       theExpr;
 
+protected:
+  order_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, order_type_t, expr_t);
+
 public:
-  order_expr(static_context* sctx, const QueryLoc&, order_type_t, expr_t);
-
   order_type_t get_type() const { return theType; }
 
   expr* get_expr() const { return theExpr.getp(); }
@@ -124,8 +128,9 @@
 /***************************************************************************//**
 
 ********************************************************************************/
-class validate_expr : public expr 
+class validate_expr : public expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
@@ -135,8 +140,9 @@
   rchandle<TypeManager>             theTypeMgr;
   expr_t                            theExpr;
 
-public:
+protected:
   validate_expr(
+        CompilerCB* ccb,
         static_context* sctx,
         const QueryLoc&,
         ParseConstants::validation_mode_t,
@@ -144,6 +150,7 @@
         expr_t,
         rchandle<TypeManager>);
 
+public:
   expr* get_expr() const { return theExpr.getp(); }
 
   const store::Item* get_type_name() const { return theTypeName; }
@@ -174,6 +181,7 @@
 
 protected:
   namespace_context_base_expr(
+      CompilerCB* ccb,
       static_context* sctx,
       const QueryLoc& loc,
       expr_kind_t kind,
@@ -187,7 +195,7 @@
 /***************************************************************************//**
   Base for cast, treat, promote, castable, instanceof
 ********************************************************************************/
-class cast_or_castable_base_expr : public expr 
+class cast_or_castable_base_expr : public expr
 {
   friend class ExprIterator;
   friend class expr;
@@ -198,12 +206,13 @@
 
 protected:
   cast_or_castable_base_expr(
+        CompilerCB* ccb,
         static_context* sctx,
         const QueryLoc& loc,
         expr_kind_t kind,
         const expr_t& input,
         const xqtref_t& type);
-  
+
 public:
   expr* get_input() const { return theInputExpr.getp(); }
 
@@ -222,13 +231,14 @@
 {
   friend class ExprIterator;
 
-public:
+protected:
   cast_base_expr(
-      static_context* sctx, 
-      const QueryLoc& loc,
-      expr_kind_t kind,
-      const expr_t& input,
-      const xqtref_t& type);
+        CompilerCB* ccb,
+        static_context* sctx,
+        const QueryLoc& loc,
+        expr_kind_t kind,
+        const expr_t& input,
+        const xqtref_t& type);
 };
 
 
@@ -239,12 +249,19 @@
 ********************************************************************************/
 class cast_expr : public cast_base_expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
+protected:
+  cast_expr(
+      CompilerCB* ccb,
+      static_context* sctx,
+      const QueryLoc&,
+      const expr_t&,
+      const xqtref_t&);
+
 public:
-  cast_expr(static_context* sctx, const QueryLoc&, const expr_t&, const xqtref_t&);
-
   bool is_optional() const;
 
   expr_t clone(substitution_t& s) const;
@@ -256,7 +273,7 @@
 
 
 /***************************************************************************//**
-	TreatExpr ::= CastableExpr ( "treat" "as" SequenceType )?
+  TreatExpr ::= CastableExpr ( "treat" "as" SequenceType )?
 
   theCheckPrime : Normally, this is true. If false, then during runtime, only
                   the cardinality of theInputExpr will be checked w.r.t. the
@@ -265,11 +282,12 @@
                   static type of theInputExpr is a subtype of the prime type of
                   theTargetType.
 
-  theFnQName    : Stores the QName of the function, if the treat expr is used 
+  theFnQName    : Stores the QName of the function, if the treat expr is used
                   to cast the function's body to its result type
 ********************************************************************************/
-class treat_expr : public cast_base_expr 
+class treat_expr : public cast_base_expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
@@ -278,16 +296,18 @@
   bool                     theCheckPrime;
   store::Item_t            theQName;
 
-public:
+protected:
   treat_expr(
-        static_context* sctx, 
-        const QueryLoc& loc,
-        const expr_t& input,
-        const xqtref_t& type,
+        CompilerCB* ccb,
+        static_context* sctx,
+        const QueryLoc&,
+        const expr_t&,
+        const xqtref_t&,
         TreatIterator::ErrorKind err,
         bool check_prime = true,
         store::Item* qname = NULL);
 
+public:
   TreatIterator::ErrorKind get_err() const { return theErrorKind; }
 
   bool get_check_prime() const { return theCheckPrime; }
@@ -323,7 +343,7 @@
      - If the target type is the NONE type, F(I) = error, else
      - If the actual type is a subtype of the target type, F(I) = I, else
      - If the target type is not an atomic type, F(I) = error, else
-     - If the actual type is untypedAtomic and the target type is not QName, 
+     - If the actual type is untypedAtomic and the target type is not QName,
        F(I) = cast(I, target type), else
      - If the actual type is (subtype of) decimal and the target type is float,
        F(I) = cast(I, target type), else
@@ -339,26 +359,29 @@
   -----------
   Stores the QName of the function, if the promote expr is used to cast the
   function's body to its result type
-  
+
 ********************************************************************************/
 class promote_expr : public cast_base_expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
 protected:
   PromoteIterator::ErrorKind theErrorKind;
-  store::Item_t              theQName; 
-  
-public:
+  store::Item_t              theQName;
+
+protected:
   promote_expr(
-      static_context* sctx, 
-      const QueryLoc& loc, 
-      const expr_t& input, 
-      const xqtref_t& type, 
+      CompilerCB* ccb,
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& input,
+      const xqtref_t& type,
       PromoteIterator::ErrorKind err,
       store::Item* qname);
 
+public:
   expr_t clone(substitution_t& s) const;
 
   PromoteIterator::ErrorKind get_err() const { return theErrorKind; }
@@ -376,12 +399,13 @@
 /***************************************************************************//**
   Base for castable, instanceof
 ********************************************************************************/
-class castable_base_expr : public cast_or_castable_base_expr 
+class castable_base_expr : public cast_or_castable_base_expr
 {
   friend class ExprIterator;
 
-public:
+protected:
   castable_base_expr(
+        CompilerCB* ccb,
         static_context* sctx,
         const QueryLoc&,
         expr_kind_t kind,
@@ -395,14 +419,21 @@
 
   SingleType ::= AtomicType "?"?
 ********************************************************************************/
-class castable_expr : public castable_base_expr 
+class castable_expr : public castable_base_expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
+protected:
+  castable_expr(
+      CompilerCB* ccb,
+      static_context* sctx,
+      const QueryLoc&,
+      const expr_t&,
+      const xqtref_t&);
+
 public:
-  castable_expr(static_context* sctx, const QueryLoc&, const expr_t&, const xqtref_t&);
-  
   bool is_optional() const;
 
   expr_t clone(substitution_t& s) const;
@@ -414,30 +445,33 @@
 
 
 /***************************************************************************//**
-	InstanceofExpr ::= TreatExpr ( "instance" "of" SequenceType )?
+  InstanceofExpr ::= TreatExpr ( "instance" "of" SequenceType )?
 
-  theCheckPrimeOnly : 
+  theCheckPrimeOnly :
   Normally, this is false. It is set to true only if this is an instanceof expr
   that is created during the translation of a PredicateList (see translator.cpp).
   This flag is used during the PartialEval rule.
 
 ********************************************************************************/
-class instanceof_expr : public castable_base_expr 
+class instanceof_expr : public castable_base_expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
 protected:
   bool theCheckPrimeOnly;
 
-public:
+protected:
   instanceof_expr(
+      CompilerCB* ccb,
       static_context* sctx,
-      const QueryLoc&, 
-      const expr_t&, 
+      const QueryLoc&,
+      const expr_t&,
       const xqtref_t&,
       bool checkPrimeOnly = false);
 
+public:
   bool getCheckPrimeOnly() const { return theCheckPrimeOnly; }
 
   expr_t clone(substitution_t& s) const;
@@ -460,6 +494,7 @@
 ********************************************************************************/
 class name_cast_expr : public namespace_context_base_expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
@@ -467,14 +502,16 @@
   expr_t             theInputExpr;
   bool               theIsAttrName;
 
-public:
+protected:
   name_cast_expr(
+      CompilerCB* ccb,
       static_context* sctx,
       const QueryLoc&,
       expr_t,
       const namespace_context*,
       bool isAttr);
 
+public:
   expr* get_input() const { return theInputExpr.getp(); }
 
   bool is_attr_name() const { return theIsAttrName; }
@@ -492,8 +529,9 @@
 /***************************************************************************//**
   CompDocConstructor ::= "document" "{" Expr "}"
 ********************************************************************************/
-class doc_expr : public expr 
+class doc_expr : public expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
@@ -501,9 +539,10 @@
   expr_t theContent;
   bool   theCopyInputNodes;
 
+protected:
+  doc_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, expr* content, bool copyNodes);
+
 public:
-  doc_expr(static_context* sctx, const QueryLoc&, expr* content, bool copyNodes);
-
   expr* getContent() const { return theContent.getp(); }
 
   bool copyInputNodes() const { return theCopyInputNodes; }
@@ -548,6 +587,7 @@
 ********************************************************************************/
 class elem_expr : public namespace_context_base_expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
@@ -557,8 +597,9 @@
   expr_t theContent;
   bool   theCopyInputNodes;
 
-public:
+protected:
   elem_expr(
+        CompilerCB* ccb,
         static_context* sctx,
         const QueryLoc&,
         expr* qnameExpr,
@@ -566,15 +607,17 @@
         expr* content,
         const namespace_context* nsCtx,
         bool copyNodes);
-  
+
   elem_expr(
+        CompilerCB* ccb,
         static_context* sctx,
         const QueryLoc&,
         expr* qnameExpr,
         expr* content,
         const namespace_context* nsCtx,
         bool copyNodes);
-  
+
+public:
   expr* getQNameExpr() const { return theQNameExpr.getp(); }
 
   expr* getContent() const { return theContent.getp(); }
@@ -586,8 +629,8 @@
   void setCopyInputNodes() { theCopyInputNodes = true; }
 
   void compute_scripting_kind();
-  
-  expr_t clone(substitution_t& s) const;  
+
+  expr_t clone(substitution_t& s) const;
 
   void accept(expr_visitor&);
 
@@ -619,8 +662,9 @@
   CommonContent ::= PredefinedEntityRef | CharRef | "{{" | "}}" | EnclosedExpr
 
 ********************************************************************************/
-class attr_expr : public expr 
+class attr_expr : public expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
@@ -628,13 +672,15 @@
   expr_t theQNameExpr;
   expr_t theValueExpr;
 
-public:
+protected:
   attr_expr(
+    CompilerCB* ccb,
     static_context* sctx,
     const QueryLoc& loc,
     expr_t aQNameExpr,
     expr_t aValueExpr);
 
+public:
   expr* getQNameExpr() const { return theQNameExpr.getp(); }
 
   expr* getValueExpr() const { return theValueExpr.getp(); }
@@ -654,13 +700,14 @@
 /***************************************************************************//**
 
 ********************************************************************************/
-class text_expr : public expr 
+class text_expr : public expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
 public:
-  typedef enum 
+  typedef enum
   {
     text_constructor,
     comment_constructor
@@ -670,20 +717,22 @@
   text_constructor_type type;
   expr_t                theContentExpr;
 
-public:
+protected:
   text_expr(
+      CompilerCB* ccb,
       static_context* sctx,
       const QueryLoc&,
       text_constructor_type,
       expr_t);
 
+public:
   expr* get_text() const { return theContentExpr.getp(); }
 
   text_constructor_type get_type() const { return type; }
 
   void compute_scripting_kind();
 
-  expr_t clone(substitution_t& s) const;  
+  expr_t clone(substitution_t& s) const;
 
   void accept(expr_visitor&);
 
@@ -694,8 +743,9 @@
 /***************************************************************************//**
 
 ********************************************************************************/
-class pi_expr : public expr 
+class pi_expr : public expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
@@ -703,16 +753,17 @@
   expr_t theTargetExpr;
   expr_t theContentExpr;
 
+protected:
+  pi_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, expr_t, expr_t);
+
 public:
-  pi_expr(static_context* sctx, const QueryLoc&, expr_t, expr_t);
- 
   expr* get_target_expr() const { return theTargetExpr.getp(); }
 
   expr* get_content_expr() const { return theContentExpr.getp(); }
 
   void compute_scripting_kind();
-  
-  expr_t clone(substitution_t& s) const;  
+
+  expr_t clone(substitution_t& s) const;
 
   void accept(expr_visitor&);
 
@@ -723,33 +774,35 @@
 /***************************************************************************//**
 
 ********************************************************************************/
-class const_expr : public expr 
+class const_expr : public expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
 protected:
   store::Item_t theValue;
 
+protected:
+  const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, zstring& sval);
+
+  const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, const std::string& sval);
+
+  const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, const char* sval);
+
+  const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, xs_integer);
+
+  const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, xs_decimal);
+
+  const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, xs_double);
+
+  const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, xs_boolean);
+
+  const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, store::Item_t);
+
+  const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, const char* ns, const char* pre, const char* local);
+
 public:
-  const_expr(static_context* sctx, const QueryLoc&, zstring& sval);
-
-  const_expr(static_context* sctx, const QueryLoc&, const std::string& sval);
-
-  const_expr(static_context* sctx, const QueryLoc&, const char* sval);
-
-  const_expr(static_context* sctx, const QueryLoc&, xs_integer);
-
-  const_expr(static_context* sctx, const QueryLoc&, xs_decimal);
-
-  const_expr(static_context* sctx, const QueryLoc&, xs_double);
-
-  const_expr(static_context* sctx, const QueryLoc&, xs_boolean);
-
-  const_expr(static_context* sctx, const QueryLoc&, store::Item_t);  
-
-  const_expr(static_context* sctx, const QueryLoc&, const char* ns, const char* pre, const char* local);
-
   store::Item* get_val() const { return theValue.getp(); }
 
   void compute_scripting_kind();
@@ -781,8 +834,9 @@
 /***************************************************************************//**
 
 ********************************************************************************/
-class extension_expr : public expr 
+class extension_expr : public expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
@@ -790,11 +844,12 @@
   std::vector<rchandle<pragma> > thePragmas;
   expr_t                         theExpr;
 
+protected:
+  extension_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&);
+
+  extension_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, expr_t);
+
 public:
-  extension_expr(static_context* sctx, const QueryLoc&);
-
-  extension_expr(static_context* sctx, const QueryLoc&, expr_t);
-
   void add(rchandle<pragma> p) { thePragmas.push_back(p); }
 
   expr* get_expr() const { return theExpr.getp(); }
@@ -811,7 +866,7 @@
 
 /////////////////////////////////////////////////////////////////////////
 //                                                                     //
-//	XQuery 3.0 expressions                                             //
+//  XQuery 3.0 expressions                                             //
 //  [http://www.w3.org/TR/xquery-3/]                                   //
 //                                                                     //
 /////////////////////////////////////////////////////////////////////////
@@ -836,7 +891,7 @@
 typedef rchandle<catch_clause> catch_clause_t;
 
 
-class catch_clause : public SimpleRCObject 
+class catch_clause : public SimpleRCObject
 {
   friend class expr;
   friend class trycatch_expr;
@@ -861,28 +916,30 @@
 protected:
   nt_list_t  theNameTests;
   var_map_t  theVarMap;
-  
+
 public:
   catch_clause();
-  
+
+public:
   void set_nametests(nt_list_t& a) { theNameTests = a; }
 
   nt_list_t& get_nametests() { return theNameTests; }
-  
+
   void add_nametest_h(nt_t n) { theNameTests.push_back(n); }
 
   void set_vars(var_map_t& a) { theVarMap = a; }
 
   var_map_t& get_vars() { return theVarMap; }
-  
+
   void add_var(var_type v, var_expr_t n) { theVarMap[v] = n; }
-  
+
   catch_clause_t clone(expr::substitution_t& subst) const;
 };
 
 
-class trycatch_expr : public expr 
+class trycatch_expr : public expr
 {
+  friend class ExprManager;
   friend class ExprIterator;
   friend class expr;
 
@@ -891,9 +948,10 @@
   std::vector<expr_t>         theCatchExprs;
   std::vector<catch_clause_t> theCatchClauses;
 
+protected:
+  trycatch_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, expr_t tryExpr);
+
 public:
-  trycatch_expr(static_context* sctx, const QueryLoc&, expr_t tryExpr);
-
   expr* get_try_expr() const { return theTryExpr.getp(); }
 
   void set_try_expr(expr* e) { theTryExpr = e; }
@@ -903,9 +961,9 @@
   void add_catch_expr(expr_t e);
 
   void add_clause(catch_clause_t cc);
-  
+
   csize clause_count() const { return theCatchClauses.size(); }
-  
+
   const catch_clause_t& operator[](csize i) const { return theCatchClauses[i]; }
 
   void compute_scripting_kind();
@@ -920,7 +978,7 @@
 
 /////////////////////////////////////////////////////////////////////////
 //                                                                     //
-//	Zorba expressions                                                  //
+//  Zorba expressions                                                  //
 //                                                                     //
 /////////////////////////////////////////////////////////////////////////
 
@@ -929,17 +987,19 @@
   Normally, it is used to wrap a var_expr in order to represent a var reference
   (see var_expr.h). But it may wrap any other kind of expr as well.
 ********************************************************************************/
-class wrapper_expr : public expr 
+class wrapper_expr : public expr
 {
   friend class ExprIterator;
   friend class expr;
+  friend class ExprManager;
 
 protected:
   expr_t theWrappedExpr;
 
+protected:
+  wrapper_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, expr_t wrapped);
+
 public:
-  wrapper_expr(static_context* sctx, const QueryLoc& loc, expr_t wrapped);
-
   expr* get_expr() const { return theWrappedExpr.getp(); }
 
   void set_expr(const expr* e) { theWrappedExpr = e; }
@@ -961,6 +1021,7 @@
 {
   friend class ExprIterator;
   friend class expr;
+  friend class ExprManager;
 
 protected:
   expr_t        theExpr;
@@ -969,14 +1030,16 @@
   QueryLoc      theFunctionCallLocation;
   unsigned int  theFunctionArity;
 
-public:
+protected:
   function_trace_expr(
+      CompilerCB* ccb,
       static_context* sctx,
       const QueryLoc& loc,
       expr_t aChild);
 
   function_trace_expr(expr_t aExpr);
 
+public:
   virtual ~function_trace_expr();
 
   void compute_scripting_kind();
@@ -1018,7 +1081,7 @@
   {
     return theFunctionCallLocation;
   }
-  
+
   void setFunctionArity(unsigned int arity)
   {
     theFunctionArity = arity;
@@ -1041,8 +1104,8 @@
 
   theVars:
   --------
-  There is one "eval" var for each non-global var that is in scope where the call
-  to the eval function appears at.
+  There is one "eval" var (of kind var_expr::eval_var) for each var that is in
+  scope where the call to the eval function appears at.
 
   theArgs:
   --------
@@ -1061,6 +1124,7 @@
 {
   friend class ExprIterator;
   friend class expr;
+  friend class ExprManager;
 
 protected:
   expr_t                      theExpr;
@@ -1071,15 +1135,17 @@
   expr_script_kind_t          theInnerScriptingKind;
   bool                        theDoNodeCopy;
 
-public:
+protected:
   eval_expr(
+      CompilerCB* creating_ccb,
       CompilerCB* ccb,
       static_context* sctx,
-      const QueryLoc& loc, 
+      const QueryLoc& loc,
       const expr_t& e,
       expr_script_kind_t scriptingKind,
       namespace_context* nsCtx);
 
+public:
   expr* get_expr() const { return theExpr.getp(); }
 
   expr* get_arg_expr(csize i) { return theArgs[i].getp(); }
@@ -1088,7 +1154,7 @@
 
   const var_expr* get_var(csize i) const { return theVars[i]; }
 
-  void add_var(const var_expr_t& var, const expr_t& arg) 
+  void add_var(const var_expr_t& var, const expr_t& arg)
   {
     theVars.push_back(var);
     theArgs.push_back(arg);
@@ -1131,6 +1197,7 @@
 {
   friend class ExprIterator;
   friend class expr;
+  friend class ExprManager;
 
 private:
   expr_t                      theExpr;
@@ -1138,14 +1205,16 @@
   std::vector<expr_t>         theArgs;
   bool                        theIsVarDeclaration;
 
-public:
+protected:
   debugger_expr(
+      CompilerCB* ccb,
       static_context* sctx,
       const QueryLoc& loc,
       const expr_t& aChild,
       namespace_context* nsCtx,
       bool aIsVarDeclaration);
 
+public:
   expr* get_expr() const { return theExpr.getp(); }
 
   bool isVarDeclaration() const { return theIsVarDeclaration; }
@@ -1158,7 +1227,7 @@
 
   const var_expr* get_var(csize i) const { return theVars[i]; }
 
-  void add_var(const var_expr_t& var, const expr_t& arg) 
+  void add_var(const var_expr_t& var, const expr_t& arg)
   {
     theVars.push_back(var);
     theArgs.push_back(arg);

=== modified file 'src/compiler/expression/expr_base.cpp'
--- src/compiler/expression/expr_base.cpp	2012-07-24 08:48:48 +0000
+++ src/compiler/expression/expr_base.cpp	2012-08-10 11:20:27 +0000
@@ -23,6 +23,9 @@
 #include "compiler/expression/path_expr.h"
 #include "compiler/expression/expr_iter.h"
 #include "compiler/expression/expr_visitor.h"
+#include "compiler/expression/expr_manager.h"
+
+#include "compiler/api/compilercb.h"
 
 #include "functions/function.h"
 #include "functions/library.h"
@@ -85,7 +88,7 @@
   return (theScriptingKind & (VAR_SETTING_EXPR |
                               APPLYING_EXPR |
                               EXITING_EXPR |
-                              BREAKING_EXPR | 
+                              BREAKING_EXPR |
                               SEQUENTIAL_FUNC_EXPR)) != 0;
 }
 
@@ -94,7 +97,7 @@
 {
   if (e != 0 && e->is_updating())
   {
-    throw XQUERY_EXCEPTION(err::XUST0001, 
+    throw XQUERY_EXCEPTION(err::XUST0001,
                            ERROR_PARAMS(ZED(XUST0001_Generic)),
                            ERROR_LOC(e->get_loc()));
   }
@@ -105,7 +108,7 @@
 {
   if (e != 0 && e->is_updating())
   {
-    throw XQUERY_EXCEPTION(err::XUST0001, 
+    throw XQUERY_EXCEPTION(err::XUST0001,
                            ERROR_PARAMS(ZED(XUST0001_Generic)),
                            ERROR_LOC(e->get_loc()));
   }
@@ -120,12 +123,13 @@
 /*******************************************************************************
 
 ********************************************************************************/
-expr::expr(static_context* sctx, const QueryLoc& loc, expr_kind_t k)
+expr::expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, expr_kind_t k)
   :
   theSctx(sctx),
   theLoc(loc),
   theKind(k),
-  theFlags1(0)
+  theFlags1(0),
+  theCCB(ccb)
 {
   theScriptingKind = UNKNOWN_SCRIPTING_KIND;
 
@@ -146,9 +150,9 @@
 /*******************************************************************************
 
 ********************************************************************************/
-TypeManager* expr::get_type_manager() const 
+TypeManager* expr::get_type_manager() const
 {
-  return theSctx->get_typemanager(); 
+  return theSctx->get_typemanager();
 }
 
 
@@ -541,11 +545,11 @@
 
 
 /*******************************************************************************
-  This annotation tells whether the expr must produce nodes that belong to 
-  "standalone" trees or not. A tree is standalone if it does not contain 
-  references to other trees. Such references are created when the optimizer 
+  This annotation tells whether the expr must produce nodes that belong to
+  "standalone" trees or not. A tree is standalone if it does not contain
+  references to other trees. Such references are created when the optimizer
   decides that it is ok to avoid copying the referenced subtree (as would be
-  required by required by a strict implementation of the spec, eg., during 
+  required by required by a strict implementation of the spec, eg., during
   node construction).
 ********************************************************************************/
 BoolAnnotationValue expr::getMustCopyNodes() const
@@ -791,13 +795,13 @@
   if (found)
     return true;
 
-  if (this == e) 
+  if (this == e)
   {
     found = true;
     return true;
   }
 
-  switch(get_expr_kind()) 
+  switch(get_expr_kind())
   {
 #ifdef ZORBA_WITH_DEBUGGER
   case debugger_expr_kind:
@@ -829,13 +833,13 @@
     const function* func = foExpr->get_func();
     csize numArgs = foExpr->num_args();
 
-    for (csize i = 0; i < numArgs; ++i) 
+    for (csize i = 0; i < numArgs; ++i)
     {
       const expr* argExpr = foExpr->get_arg(i);
 
-      if (func->isMap(i)) 
+      if (func->isMap(i))
       {
-        if (argExpr->is_map_internal(e, found) && found) 
+        if (argExpr->is_map_internal(e, found) && found)
         {
           return true;
         }
@@ -1166,7 +1170,7 @@
 ********************************************************************************/
 xqtref_t expr::get_return_type_with_empty_input(const expr* input) const
 {
-  expr_t emptyExpr = new fo_expr(input->get_sctx(),
+  expr_t emptyExpr = theCCB->theEM->create_fo_expr(input->get_sctx(),
                                  QueryLoc::null,
                                  GET_BUILTIN_FUNCTION(OP_CONCATENATE_N));
   expr::substitution_t subst;

=== modified file 'src/compiler/expression/expr_base.h'
--- src/compiler/expression/expr_base.h	2012-07-24 08:48:48 +0000
+++ src/compiler/expression/expr_base.h	2012-08-10 11:20:27 +0000
@@ -45,6 +45,7 @@
 
 class expr_visitor;
 
+class CompilerCB;
 
 enum expr_kind_t
 {
@@ -85,7 +86,7 @@
   order_expr_kind,
 
 #ifndef ZORBA_NO_FULL_TEXT
-	ft_expr_kind,
+  ft_expr_kind,
 #endif /* ZORBA_NO_FULL_TEXT */
 
   delete_expr_kind,
@@ -187,6 +188,8 @@
 
   FreeVars           theFreeVars;
 
+  CompilerCB       * theCCB;
+
 public:
   static bool is_sequential(unsigned short theScriptingKind);
 
@@ -194,13 +197,18 @@
 
   static void checkNonUpdating(const expr* e);
 
+  virtual void free() {}
+
+protected:
+  expr(CompilerCB*, static_context*, const QueryLoc&, expr_kind_t);
+
+  expr() : theSctx(NULL), theFlags1(0), theCCB(NULL) {}
+
 public:
-  expr() : theSctx(NULL), theFlags1(0) {}
-
-  expr(static_context*, const QueryLoc&, expr_kind_t);
-
   virtual ~expr();
 
+  CompilerCB* get_ccb() {return theCCB;}
+
   expr_kind_t get_expr_kind() const { return static_cast<expr_kind_t>(theKind); }
 
   const QueryLoc& get_loc() const { return theLoc; }

=== modified file 'src/compiler/expression/expr_classes.h'
--- src/compiler/expression/expr_classes.h	2012-07-24 08:48:48 +0000
+++ src/compiler/expression/expr_classes.h	2012-08-10 11:20:27 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,38 +17,38 @@
 #include <zorba/config.h>
 #include "common/shared_types.h"
 
-namespace zorba 
+namespace zorba
 {
-  class order_modifier; 
-  class flwor_expr; 
-  class case_clause; 
-  class if_expr; 
+  class order_modifier;
+  class flwor_expr;
+  class case_clause;
+  class if_expr;
   class fo_expr;
 #ifndef ZORBA_NO_FULL_TEXT
   class ftcontains_expr;
 #endif /* ZORBA_NO_FULL_TEXT */
   class promote_expr;
-  class instanceof_expr; 
-  class treat_expr; 
-  class castable_expr; 
-  class cast_expr; 
+  class instanceof_expr;
+  class treat_expr;
+  class castable_expr;
+  class cast_expr;
   class name_cast_expr;
-  class validate_expr; 
-  class extension_expr; 
+  class validate_expr;
+  class extension_expr;
   class relpath_expr;
-  class axis_step_expr; 
-  class match_expr; 
+  class axis_step_expr;
+  class match_expr;
   class const_expr;
-  class order_expr; 
+  class order_expr;
 
-  class elem_expr; 
+  class elem_expr;
   class doc_expr;
   class attr_expr;
   class text_expr;
   class pi_expr;
 
   class trycatch_expr;
-  class function_item_expr; 
+  class function_item_expr;
   class dynamic_function_invocation_expr;
 
   class insert_expr;
@@ -57,16 +57,16 @@
   class rename_expr;
   class transform_expr;
 
-  class block_expr; 
+  class block_expr;
   class apply_expr;
   class var_decl_expr;
   class var_set_expr;
   class exit_expr;
-  class exit_catcher_expr; 
-  class while_expr; 
+  class exit_catcher_expr;
+  class while_expr;
   class flowctl_expr;
 
-  class eval_expr; 
+  class eval_expr;
   class debugger_expr;
   class function_trace_expr;
   class wrapper_expr;

=== modified file 'src/compiler/expression/expr_consts.h'
--- src/compiler/expression/expr_consts.h	2012-07-24 08:48:48 +0000
+++ src/compiler/expression/expr_consts.h	2012-08-10 11:20:27 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,7 +17,7 @@
 #ifndef ZORBA_COMPILER_EXPR_CONSTS_H
 #define ZORBA_COMPILER_EXPR_CONSTS_H
 
-namespace zorba 
+namespace zorba
 {
 
 
@@ -77,16 +77,16 @@
                                  // expr may return non-empty XDM as well.
 
   VAR_SETTING_EXPR       =   8,  // An expr E during the evaluation of which a
-                                 // var may be set and that var is declared 
+                                 // var may be set and that var is declared
                                  // outside the innermost block that contains E.
 
-  APPLYING_EXPR          =  16,  // An expr during the evaluation of which a 
+  APPLYING_EXPR          =  16,  // An expr during the evaluation of which a
                                  // PUL may get applied.
 
   EXITING_EXPR           =  32,  // An expr during the evaluation of which an
                                  // exit expression may be executed.
 
-  BREAKING_EXPR          =  64,  // An expr E during the evaluation of which 
+  BREAKING_EXPR          =  64,  // An expr E during the evaluation of which
                                  // a break or continue expr may be executed
                                  // and the the while or flwor expr being
                                  // broken or continued contains E.
@@ -105,7 +105,7 @@
 };
 
 
-class CompareConsts 
+class CompareConsts
 {
 public:
   enum CompareType
@@ -121,7 +121,7 @@
 };
 
 
-class ArithmeticConsts 
+class ArithmeticConsts
 {
 public:
   enum OperationKind

=== added file 'src/compiler/expression/expr_manager.cpp'
--- src/compiler/expression/expr_manager.cpp	1970-01-01 00:00:00 +0000
+++ src/compiler/expression/expr_manager.cpp	2012-08-10 11:20:27 +0000
@@ -0,0 +1,884 @@
+/*
+ * Copyright 2006-2012 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "expr_manager.h"
+
+#include "mem_manager.h"
+
+#include "expr.h"
+#include "ftnode.h"
+#include "var_expr.h"
+#include "flwor_expr.h"
+#include "fo_expr.h"
+#include "ft_expr.h"
+#include "function_item_expr.h"
+#include "path_expr.h"
+#include "script_exprs.h"
+#include "update_exprs.h"
+#include "json_exprs.h"
+
+namespace zorba
+{
+
+//A simple expression that can just be deallocated without calling the
+//destructor.
+class NullExpr : public expr
+{
+public:
+  NullExpr() : expr(NULL, NULL, QueryLoc(), unknown_expr_kind){}
+  void accept(expr_visitor& v){}
+  void compute_scripting_kind(){}
+  std::ostream& put(std::ostream& stream) const{return stream;}
+};
+
+
+ExprManager::ExprManager(CompilerCB* ccb)
+  :
+  theCCB(ccb)
+{
+  theExprs.reserve(1024);
+}
+
+
+//calls on the destructors and also keeps tracks of certain numbers
+ExprManager::~ExprManager()
+{
+  for(std::vector<expr*>::iterator iter = theExprs.begin();
+      iter != theExprs.end();
+      ++iter)
+  {
+    //Here we delete all remaining exprs, we assume that they may be "held"
+    //by a reference somewhere.
+    //To prevent deleting an already deleted expr, we replace them with
+    //a NullExpr
+
+    expr* exp = *iter;
+
+    exp->~expr();
+
+    //constructs a new NULLExpr where the old expr existed
+    new (exp) NullExpr();
+  }
+}
+
+
+void ExprManager::garbageCollect()
+{
+  unsigned long numTotalBytes = 0;
+  unsigned long numDeadBytes = 0;
+  unsigned long numTotalExprs = theExprs.size();
+  unsigned long numDeadExprs = 0;
+
+  while (theExprs.size() > 0)
+  {
+    bool deleted_expr = false;
+
+    for(std::vector<expr*>::iterator iter = theExprs.begin();
+        iter != theExprs.end();
+        ++iter)
+    {
+      expr* exp = *iter;
+
+      if (exp->getRefCount() <= 0)
+      {
+        deleted_expr = true;
+        unsigned long bytes = sizeof *exp;
+
+        numTotalBytes += bytes;
+        numDeadBytes += bytes;
+        ++numDeadExprs;
+
+        exp->~expr();
+        iter = theExprs.erase(iter);
+        --iter;
+      }
+    }
+
+    if (!deleted_expr)
+      break;
+  }
+
+  for(std::vector<expr*>::iterator iter = theExprs.begin();
+      iter != theExprs.end();
+      ++iter)
+  {
+    expr* exp = *iter;
+    numTotalBytes += sizeof *exp;
+  }
+
+  std::cout << "Num Total Exprs = " << numTotalExprs
+            << " Num Total Bytes = " << numTotalBytes << std::endl
+            << "Num Dead Exprs  = " << numDeadExprs
+            << " Num Dead Bytes = " << numDeadBytes << std::endl << std::endl;
+}
+
+
+expr* ExprManager::reg(expr* exp)
+{
+  theExprs.push_back(exp);
+  return exp;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+#define CREATE_AND_RETURN_EXPR(EXPRTYPE, ...) \
+  EXPRTYPE* EXPPTR = new (theMemoryMgr) EXPRTYPE(theCCB, __VA_ARGS__); \
+  reg(EXPPTR); \
+  return EXPPTR
+
+#define CREATE_AND_RETURN(TYPE, ...) \
+  TYPE* EXPPTR = new (theMemoryMgr) TYPE(__VA_ARGS__); \
+  return EXPPTR
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+if_expr* ExprManager::create_if_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr_t cond_expr,
+    expr_t then_expr,
+    expr_t else_expr)
+{
+  CREATE_AND_RETURN_EXPR(if_expr, sctx, loc, cond_expr, then_expr, else_expr);
+}
+
+
+order_expr* ExprManager::create_order_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    order_expr::order_type_t order,
+    expr_t exp)
+{
+  CREATE_AND_RETURN_EXPR(order_expr, sctx, loc, order, exp);
+}
+
+
+validate_expr* ExprManager::create_validate_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    ParseConstants::validation_mode_t mode,
+    const store::Item_t& aTypeName,
+    expr_t validated,
+    rchandle<TypeManager> tm)
+{
+  CREATE_AND_RETURN_EXPR(validate_expr, sctx, loc, mode, aTypeName, validated, tm);
+}
+
+
+cast_expr* ExprManager::create_cast_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr_t casted,
+    xqtref_t type)
+{
+  CREATE_AND_RETURN_EXPR(cast_expr, sctx, loc, casted, type);
+}
+
+
+treat_expr* ExprManager::create_treat_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const expr_t& treated,
+    const xqtref_t& type,
+    TreatIterator::ErrorKind err,
+    bool check_prime,
+    store::Item* qname)
+{
+  CREATE_AND_RETURN_EXPR(treat_expr,
+  sctx, loc, treated, type, err, check_prime, qname);
+}
+
+
+promote_expr* ExprManager::create_promote_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const expr_t& promoted,
+    const xqtref_t& type,
+    PromoteIterator::ErrorKind err,
+    store::Item* qname)
+{
+  CREATE_AND_RETURN_EXPR(promote_expr, sctx, loc, promoted, type, err, qname);
+}
+
+
+castable_expr* ExprManager::create_castable_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr_t castable,
+    xqtref_t type)
+{
+  CREATE_AND_RETURN_EXPR(castable_expr, sctx, loc, castable, type);
+}
+
+
+instanceof_expr* ExprManager::create_instanceof_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr_t instanced,
+    xqtref_t type,
+    bool checkPrimeOnly)
+{
+  CREATE_AND_RETURN_EXPR(instanceof_expr,
+          sctx, loc, instanced, type, checkPrimeOnly);
+}
+
+
+name_cast_expr* ExprManager::create_name_cast_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr_t casted,
+    const namespace_context* ns,
+    bool isAttr)
+{
+  CREATE_AND_RETURN_EXPR(name_cast_expr, sctx, loc, casted, ns, isAttr);
+}
+
+
+doc_expr* ExprManager::create_doc_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr* content,
+    bool copyNodes)
+{
+  CREATE_AND_RETURN_EXPR(doc_expr, sctx, loc, content, copyNodes);
+}
+
+
+elem_expr* ExprManager::create_elem_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr* qnameExpr,
+    expr* attrs,
+    expr* content,
+    const namespace_context* nsCtx,
+    bool copyNodes)
+{
+  CREATE_AND_RETURN_EXPR(elem_expr,
+          sctx, loc, qnameExpr, attrs, content, nsCtx, copyNodes);
+}
+
+
+elem_expr* ExprManager::create_elem_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr* qnameExpr,
+    expr* content,
+    const namespace_context* nsCtx,
+    bool copyNodes)
+{
+  CREATE_AND_RETURN_EXPR(elem_expr,
+          sctx, loc, qnameExpr, content, nsCtx, copyNodes);
+}
+
+
+attr_expr* ExprManager::create_attr_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr_t aQNameExpr,
+    expr_t aValueExpr)
+{
+  CREATE_AND_RETURN_EXPR(attr_expr, sctx, loc, aQNameExpr, aValueExpr);
+}
+
+
+text_expr* ExprManager::create_text_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    text_expr::text_constructor_type textType,
+    expr_t text)
+{
+  CREATE_AND_RETURN_EXPR(text_expr, sctx, loc, textType, text);
+}
+
+
+pi_expr* ExprManager::create_pi_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr_t targetExpr,
+    expr_t contentExpr)
+{
+  CREATE_AND_RETURN_EXPR(pi_expr, sctx, loc, targetExpr, contentExpr);
+}
+
+
+const_expr* ExprManager::create_const_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    zstring& sval)
+{
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, sval);
+}
+
+
+const_expr* ExprManager::create_const_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const std::string& sval)
+{
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, sval);
+}
+
+
+const_expr* ExprManager::create_const_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const char* sval)
+{
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, sval);
+}
+
+
+const_expr* ExprManager::create_const_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    xs_integer val)
+{
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, val);
+}
+
+
+const_expr* ExprManager::create_const_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    xs_decimal val)
+{
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, val);
+}
+
+
+const_expr* ExprManager::create_const_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    xs_double val)
+{
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, val);
+}
+
+
+const_expr* ExprManager::create_const_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    xs_boolean val)
+{
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, val);
+}
+
+
+const_expr* ExprManager::create_const_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    store::Item_t val)
+{
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, val);
+}
+
+
+const_expr* ExprManager::create_const_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const char* ns,
+    const char* pre,
+    const char* local)
+{
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, ns, pre, local);
+}
+
+
+extension_expr* ExprManager::create_extension_expr(
+    static_context* sctx,
+    const QueryLoc& loc)
+{
+  CREATE_AND_RETURN_EXPR(extension_expr, sctx, loc);
+}
+
+
+extension_expr* ExprManager::create_extension_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr_t extended)
+{
+  CREATE_AND_RETURN_EXPR(extension_expr, sctx, loc, extended);
+}
+
+
+catch_clause* ExprManager::create_catch_clause()
+{
+  CREATE_AND_RETURN(catch_clause);
+}
+
+
+trycatch_expr* ExprManager::create_trycatch_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr_t tryExpr)
+{
+  CREATE_AND_RETURN_EXPR(trycatch_expr, sctx, loc, tryExpr);
+}
+
+
+wrapper_expr* ExprManager::create_wrapper_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr_t wrapped)
+{
+  CREATE_AND_RETURN_EXPR(wrapper_expr, sctx, loc, wrapped);
+}
+
+
+function_trace_expr* ExprManager::create_function_trace_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr_t aChild)
+{
+  CREATE_AND_RETURN_EXPR(function_trace_expr, sctx, loc, aChild);
+}
+
+
+function_trace_expr* ExprManager::create_function_trace_expr(expr_t aExpr)
+{
+  //this function gets the ExprManager from the expression it recieves.
+  return static_cast<function_trace_expr*>
+      (reg(new (theMemoryMgr) function_trace_expr(aExpr)));
+}
+
+
+eval_expr* ExprManager::create_eval_expr(
+    CompilerCB* ccb,
+    static_context* sctx,
+    const QueryLoc& loc,
+    const expr_t& e,
+    expr_script_kind_t scriptingKind,
+    namespace_context* nsCtx)
+{
+  CREATE_AND_RETURN_EXPR(eval_expr, ccb, sctx, loc, e, scriptingKind, nsCtx);
+}
+
+#ifdef ZORBA_WITH_DEBUGGER
+
+debugger_expr* ExprManager::create_debugger_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const expr_t& aChild,
+    namespace_context* nsCtx,
+    bool aIsVarDeclaration)
+{
+  CREATE_AND_RETURN_EXPR(debugger_expr,
+  sctx, loc, aChild, nsCtx, aIsVarDeclaration);
+}
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+var_expr* ExprManager::create_var_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    var_expr::var_kind k,
+    store::Item* name)
+{
+  CREATE_AND_RETURN_EXPR(var_expr, sctx, loc, k, name);
+}
+
+
+var_expr* ExprManager::create_var_expr(const var_expr& source)
+{
+  return static_cast<var_expr*>(reg(new (theMemoryMgr) var_expr(source)));
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+insert_expr* ExprManager::create_insert_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    store::UpdateConsts::InsertType insertType,
+    const expr_t& aSourceExpr,
+    const expr_t& aTargetExpr)
+{
+  CREATE_AND_RETURN_EXPR(insert_expr,
+  sctx, loc, insertType, aSourceExpr, aTargetExpr);
+}
+
+
+delete_expr* ExprManager::create_delete_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const expr_t& aTargetExpr)
+{
+  CREATE_AND_RETURN_EXPR(delete_expr, sctx, loc, aTargetExpr);
+}
+
+
+replace_expr* ExprManager::create_replace_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    store::UpdateConsts::ReplaceType aType,
+    const expr_t& aSourceExpr,
+    const expr_t& aTargetExpr)
+{
+  CREATE_AND_RETURN_EXPR(replace_expr, sctx, loc, aType, aSourceExpr, aTargetExpr);
+}
+
+
+rename_expr* ExprManager::create_rename_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const expr_t& aSourceExpr,
+    const expr_t& aTargetExpr)
+{
+  CREATE_AND_RETURN_EXPR(rename_expr, sctx, loc, aSourceExpr, aTargetExpr);
+}
+
+
+copy_clause* ExprManager::create_copy_clause(var_expr_t aVar, expr_t aExpr)
+{
+  CREATE_AND_RETURN(copy_clause, aVar, aExpr);
+}
+
+
+transform_expr* ExprManager::create_transform_expr(
+    static_context* sctx,
+    const QueryLoc& loc)
+{
+  CREATE_AND_RETURN_EXPR(transform_expr, sctx, loc);
+}
+
+
+block_expr* ExprManager::create_block_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    bool allowLastUpdating,
+    std::vector<expr_t>& seq,
+    std::vector<var_expr*>* assignedVars)
+{
+  CREATE_AND_RETURN_EXPR(block_expr,
+  sctx, loc, allowLastUpdating, seq, assignedVars);
+}
+
+
+apply_expr* ExprManager::create_apply_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const expr_t& inExpr,
+    bool discardXDM)
+{
+  CREATE_AND_RETURN_EXPR(apply_expr, sctx, loc, inExpr, discardXDM);
+}
+
+
+var_decl_expr* ExprManager::create_var_decl_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const var_expr_t& varExpr,
+    const expr_t& initExpr)
+{
+  CREATE_AND_RETURN_EXPR(var_decl_expr, sctx, loc, varExpr, initExpr);
+}
+
+
+var_set_expr* ExprManager::create_var_set_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const var_expr_t& varExpr,
+    const expr_t& setExpr)
+{
+  CREATE_AND_RETURN_EXPR(var_set_expr, sctx, loc, varExpr, setExpr);
+}
+
+
+exit_expr* ExprManager::create_exit_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const expr_t& inExpr)
+{
+  CREATE_AND_RETURN_EXPR(exit_expr, sctx, loc, inExpr);
+}
+
+
+exit_catcher_expr* ExprManager::create_exit_catcher_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const expr_t& inExpr,
+    std::vector<expr*>& exitExprs)
+{
+  CREATE_AND_RETURN_EXPR(exit_catcher_expr, sctx, loc, inExpr, exitExprs);
+}
+
+
+flowctl_expr* ExprManager::create_flowctl_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    flowctl_expr::action action)
+{
+  CREATE_AND_RETURN_EXPR(flowctl_expr, sctx, loc, action);
+}
+
+
+while_expr* ExprManager::create_while_expr(
+      static_context* sctx, const QueryLoc& loc, expr_t body)
+{
+  CREATE_AND_RETURN_EXPR(while_expr, sctx, loc, body);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+relpath_expr* ExprManager::create_relpath_expr(
+     static_context* sctx,
+     const QueryLoc& loc)
+{
+  CREATE_AND_RETURN_EXPR(relpath_expr, sctx, loc);
+}
+
+
+axis_step_expr* ExprManager::create_axis_step_expr(
+    static_context* sctx,
+    const QueryLoc& loc)
+{
+  CREATE_AND_RETURN_EXPR(axis_step_expr, sctx, loc);
+}
+
+
+match_expr* ExprManager::create_match_expr(
+    static_context* sctx,
+    const QueryLoc& loc)
+{
+  CREATE_AND_RETURN_EXPR(match_expr, sctx, loc);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+dynamic_function_invocation_expr*
+ExprManager::create_dynamic_function_invocation_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const expr_t& anExpr,
+    const std::vector<expr_t>& args)
+{
+  CREATE_AND_RETURN_EXPR(dynamic_function_invocation_expr, sctx, loc, anExpr, args);
+}
+
+
+function_item_expr* ExprManager::create_function_item_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const store::Item* aQName,
+    function* f,
+    uint32_t aArity)
+{
+  CREATE_AND_RETURN_EXPR(function_item_expr, sctx, loc, aQName, f, aArity);
+}
+
+
+function_item_expr* ExprManager::create_function_item_expr(
+    static_context* sctx,
+    const QueryLoc& loc)
+{
+  CREATE_AND_RETURN_EXPR(function_item_expr, sctx, loc);
+}
+
+
+ftcontains_expr* ExprManager::create_ftcontains_expr(
+    static_context* sctx,
+    QueryLoc const& loc,
+    expr_t range,
+    ftnode *ftselection,
+    expr_t ftignore)
+{
+  CREATE_AND_RETURN_EXPR(ftcontains_expr, sctx, loc, range, ftselection, ftignore);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+//this calls the static create_seq within fo_expr
+fo_expr* ExprManager::create_seq(static_context* sctx, const QueryLoc& loc)
+{
+  //TODO make fo_expr use this factory to generate everything
+  return fo_expr::create_seq(theCCB, sctx, loc);
+}
+
+
+fo_expr* ExprManager::create_fo_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const function* f,
+    const expr* arg)
+{
+  CREATE_AND_RETURN_EXPR(fo_expr, sctx, loc, f, arg);
+}
+
+
+fo_expr* ExprManager::create_fo_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const function* f,
+    const expr* arg1,
+    const expr* arg2)
+{
+  CREATE_AND_RETURN_EXPR(fo_expr, sctx, loc, f, arg1, arg2);
+}
+
+
+fo_expr* ExprManager::create_fo_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const function* f,
+    const std::vector<expr_t>& args)
+{
+  CREATE_AND_RETURN_EXPR(fo_expr, sctx, loc, f, args);
+}
+
+fo_expr* ExprManager::create_fo_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const function* f)
+{
+
+  CREATE_AND_RETURN_EXPR(fo_expr, sctx, loc, f);
+}
+////////////////////////////////////////////////////////////////////////////////
+
+for_clause* ExprManager::create_for_clause(
+    static_context* sctx,
+    const QueryLoc& loc,
+    var_expr_t varExpr,
+    expr_t domainExpr,
+    var_expr_t posVarExpr,
+    var_expr_t scoreVarExpr,
+    bool isOuter)
+{
+  CREATE_AND_RETURN(for_clause,
+          sctx, theCCB, loc, varExpr, domainExpr, posVarExpr, scoreVarExpr, isOuter);
+}
+
+let_clause* ExprManager::create_let_clause(
+    static_context* sctx,
+    const QueryLoc& loc,
+    var_expr_t varExpr,
+    expr_t domainExpr,
+    bool lazy)
+{
+  CREATE_AND_RETURN(let_clause, sctx, theCCB, loc, varExpr, domainExpr, lazy);
+}
+
+window_clause* ExprManager::create_window_clause(
+    static_context* sctx,
+    const QueryLoc& loc,
+    window_clause::window_t winKind,
+    var_expr_t varExpr,
+    expr_t domainExpr,
+    flwor_wincond_t winStart,
+    flwor_wincond_t winStop,
+    bool lazy)
+{
+  CREATE_AND_RETURN(window_clause,
+          sctx, theCCB, loc, winKind, varExpr, domainExpr, winStart, winStop, lazy);
+}
+
+flwor_wincond* ExprManager::create_flwor_wincond(
+  static_context* sctx,
+  bool isOnly,
+  const flwor_wincond::vars& in_vars,
+  const flwor_wincond::vars& out_vars,
+  expr_t cond)
+{
+  CREATE_AND_RETURN(flwor_wincond, theCCB, sctx, isOnly, in_vars, out_vars, cond);
+}
+
+group_clause* ExprManager::create_group_clause(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const flwor_clause::rebind_list_t& gvars,
+    flwor_clause::rebind_list_t ngvars,
+    const std::vector<std::string>& collations)
+{
+  CREATE_AND_RETURN(group_clause, sctx, loc, gvars, ngvars, collations);
+}
+
+orderby_clause* ExprManager::create_orderby_clause(
+  static_context* sctx,
+  const QueryLoc& loc,
+  bool stable,
+  const std::vector<OrderModifier>& modifiers,
+  const std::vector<expr_t>& orderingExprs)
+{
+  CREATE_AND_RETURN(orderby_clause, sctx, loc, stable, modifiers, orderingExprs);
+}
+
+materialize_clause* ExprManager::create_materialize_clause(
+      static_context* sctx, const QueryLoc& loc)
+{
+  CREATE_AND_RETURN(materialize_clause, sctx, loc);
+}
+
+count_clause* ExprManager::create_count_clause(
+      static_context* sctx, const QueryLoc& loc, var_expr_t var)
+{
+  CREATE_AND_RETURN(count_clause, sctx, loc, var);
+}
+
+where_clause* ExprManager::create_where_clause(
+      static_context* sctx, const QueryLoc& loc, expr_t where)
+{
+  CREATE_AND_RETURN(where_clause, sctx, loc, where);
+}
+
+flwor_expr* ExprManager::create_flwor_expr(
+      static_context* sctx, const QueryLoc& loc, bool general)
+{
+  CREATE_AND_RETURN_EXPR(flwor_expr, sctx, loc, general);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#ifdef ZORBA_WITH_JSON
+
+json_array_expr* ExprManager::create_json_array_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& content)
+{
+  CREATE_AND_RETURN_EXPR(json_array_expr, sctx, loc, content);
+}
+
+json_object_expr* ExprManager::create_json_object_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& content,
+      bool accumulate)
+{
+  CREATE_AND_RETURN_EXPR(json_object_expr, sctx, loc, content, accumulate);
+}
+
+json_direct_object_expr* ExprManager::create_json_direct_object_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      std::vector<expr_t>& names,
+      std::vector<expr_t>& values)
+{
+  CREATE_AND_RETURN_EXPR(json_direct_object_expr, sctx, loc, names, values);
+}
+
+#endif // ZORBA_WITH_JSON
+
+} // namespace zorba
+

=== added file 'src/compiler/expression/expr_manager.h'
--- src/compiler/expression/expr_manager.h	1970-01-01 00:00:00 +0000
+++ src/compiler/expression/expr_manager.h	2012-08-10 11:20:27 +0000
@@ -0,0 +1,506 @@
+/*
+ * Copyright 2006-2012 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#ifndef ZORBA_COMPILER_EXPRMANAGER_H
+#define ZORBA_COMPILER_EXPRMANAGER_H
+
+#include "expr_classes.h"
+#include "expr.h"
+#include "script_exprs.h"
+#include "flwor_expr.h"
+#include "ftnode.h"
+
+#include "mem_manager.h"
+
+namespace zorba
+{
+
+class CompilerCB;
+
+class ExprManager
+{
+private:
+  std::vector<expr*> theExprs;
+  MemoryManager      theMemoryMgr;
+  CompilerCB     * theCCB;
+
+public:
+  ExprManager(CompilerCB* ccb);
+
+  ~ExprManager();
+
+  expr* reg(expr*);
+
+private:
+  //An ExprManager is the only objecto to handle a collection of Exprs and
+  //the memory in which they recide. It makes no sense to copy it.
+  ExprManager(const ExprManager&);
+  ExprManager& operator= (const ExprManager&);
+
+public:
+  MemoryManager& getMemory() { return theMemoryMgr; }
+
+  csize numExprs() const { return theExprs.size(); }
+
+  void garbageCollect();
+
+public:
+  if_expr* create_if_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      expr_t cond_expr,
+      expr_t then_expr,
+      expr_t else_expr);
+
+  order_expr* create_order_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      order_expr::order_type_t,
+      expr_t);
+
+  validate_expr* create_validate_expr(
+      static_context*,
+      const QueryLoc&,
+      ParseConstants::validation_mode_t,
+      const store::Item_t& aTypeName,
+      expr_t validated,
+      rchandle<TypeManager>);
+
+  cast_expr* create_cast_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      expr_t,
+      xqtref_t);
+
+  treat_expr* create_treat_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& input,
+      const xqtref_t& type,
+      TreatIterator::ErrorKind err,
+      bool check_prime = true,
+      store::Item* qnname = NULL);
+
+
+  promote_expr* create_promote_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& input,
+      const xqtref_t& type,
+      PromoteIterator::ErrorKind err,
+      store::Item* qname);
+
+  castable_expr* create_castable_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      expr_t,
+      xqtref_t);
+
+  instanceof_expr* create_instanceof_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      expr_t,
+      xqtref_t,
+      bool checkPrimeOnly = false);
+
+  name_cast_expr* create_name_cast_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      expr_t,
+      const namespace_context*,
+      bool isAttr);
+
+  doc_expr* create_doc_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      expr* content,
+      bool copyNodes);
+
+  elem_expr* create_elem_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      expr* qnameExpr,
+      expr* attrs,
+      expr* content,
+      const namespace_context* nsCtx,
+      bool copyNodes);
+
+  elem_expr* create_elem_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      expr* qnameExpr,
+      expr* content,
+      const namespace_context* nsCtx,
+      bool copyNodes);
+
+  attr_expr* create_attr_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      expr_t aQNameExpr,
+      expr_t aValueExpr);
+
+  text_expr* create_text_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      text_expr::text_constructor_type,
+      expr_t);
+
+  pi_expr* create_pi_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      expr_t,
+      expr_t);
+
+  const_expr* create_const_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      zstring& sval);
+
+  const_expr* create_const_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      const std::string& sval);
+
+  const_expr* create_const_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      const char* sval);
+
+  const_expr* create_const_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      xs_integer);
+
+  const_expr* create_const_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      xs_decimal);
+
+  const_expr* create_const_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      xs_double);
+
+  const_expr* create_const_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      xs_boolean);
+
+  const_expr* create_const_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      store::Item_t);
+
+  const_expr* create_const_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      const char* ns,
+      const char* pre,
+      const char* local);
+
+  extension_expr* create_extension_expr(
+      static_context* sctx,
+      const QueryLoc&);
+
+  extension_expr* create_extension_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      expr_t);
+
+  catch_clause* create_catch_clause();
+
+  trycatch_expr* create_trycatch_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      expr_t tryExpr);
+
+  wrapper_expr* create_wrapper_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      expr_t wrapped);
+
+  function_trace_expr* create_function_trace_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      expr_t aChild);
+
+  function_trace_expr* create_function_trace_expr(expr_t aExpr);
+
+  eval_expr* create_eval_expr(
+      CompilerCB* ccb,
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& e,
+      expr_script_kind_t scriptingKind,
+      namespace_context* nsCtx);
+
+#ifdef ZORBA_WITH_DEBUGGER
+  debugger_expr* create_debugger_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& aChild,
+      namespace_context* nsCtx,
+      bool aIsVarDeclaration);
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+  var_expr* create_var_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      var_expr::var_kind k,
+      store::Item* name);
+
+  var_expr* create_var_expr(const var_expr& source);
+
+////////////////////////////////////////////////////////////////////////////////
+
+  insert_expr* create_insert_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      store::UpdateConsts::InsertType,
+      const expr_t& aSourceExpr,
+      const expr_t& aTargetExpr);
+
+  delete_expr* create_delete_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      const expr_t&);
+
+  replace_expr* create_replace_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      store::UpdateConsts::ReplaceType aType,
+      const expr_t&,
+      const expr_t&);
+
+  rename_expr* create_rename_expr(
+      static_context* sctx,
+      const QueryLoc&,
+      const expr_t&,
+      const expr_t&);
+
+  copy_clause* create_copy_clause(var_expr_t aVar, expr_t aExpr);
+
+  transform_expr* create_transform_expr(
+      static_context* sctx,
+      const QueryLoc& loc);
+
+  block_expr* create_block_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      bool allowLastUpdating,
+      std::vector<expr_t>& seq,
+      std::vector<var_expr*>* assignedVars);
+
+  apply_expr* create_apply_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& inExpr,
+      bool discardXDM);
+
+  var_decl_expr* create_var_decl_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const var_expr_t& varExpr,
+      const expr_t& initExpr);
+
+  var_set_expr* create_var_set_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const var_expr_t& varExpr,
+      const expr_t& setExpr);
+
+  exit_expr* create_exit_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& inExpr);
+
+  exit_catcher_expr* create_exit_catcher_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& inExpr,
+      std::vector<expr*>& exitExprs);
+
+  flowctl_expr* create_flowctl_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      flowctl_expr::action action);
+
+  while_expr* create_while_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      expr_t body);
+
+////////////////////////////////////////////////////////////////////////////////
+
+  relpath_expr* create_relpath_expr(static_context* sctx, const QueryLoc& loc);
+
+  axis_step_expr* create_axis_step_expr(static_context* sctx, const QueryLoc&);
+
+  match_expr* create_match_expr(static_context* sctx, const QueryLoc&);
+
+////////////////////////////////////////////////////////////////////////////////
+
+  dynamic_function_invocation_expr* create_dynamic_function_invocation_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& anExpr,
+      const std::vector<expr_t>& args);
+
+  function_item_expr* create_function_item_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const store::Item* aQName,
+      function* f,
+      uint32_t aArity);
+
+  function_item_expr* create_function_item_expr(
+      static_context* sctx,
+      const QueryLoc& loc);
+
+  ftcontains_expr* create_ftcontains_expr(
+      static_context*,
+      QueryLoc const&,
+      expr_t range,
+      ftnode *ftselection,
+      expr_t ftignore);
+
+////////////////////////////////////////////////////////////////////////////////
+
+  //this calls the static create_seq within fo_expr
+  fo_expr* create_seq(static_context* sctx, const QueryLoc &);
+
+  fo_expr* create_fo_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const function* f,
+      const expr* arg);
+
+  fo_expr* create_fo_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const function* f,
+      const expr* arg1,
+      const expr* arg2);
+
+  fo_expr* create_fo_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const function* f,
+      const std::vector<expr_t>& args);
+
+  fo_expr* create_fo_expr(
+    static_context* sctx,
+    const QueryLoc& loc,
+    const function* f);
+
+////////////////////////////////////////////////////////////////////////////////
+
+  for_clause* create_for_clause(
+      static_context* sctx,
+      const QueryLoc& loc,
+      var_expr_t varExpr,
+      expr_t domainExpr,
+      var_expr_t posVarExpr = NULL,
+      var_expr_t scoreVarExpr = NULL,
+      bool isOuter = false);
+
+  let_clause* create_let_clause(
+      static_context* sctx,
+      const QueryLoc& loc,
+      var_expr_t varExpr,
+      expr_t domainExpr,
+      bool lazy = false);
+
+  window_clause* create_window_clause(
+      static_context* sctx,
+      const QueryLoc& loc,
+      window_clause::window_t winKind,
+      var_expr_t varExpr,
+      expr_t domainExpr,
+      flwor_wincond_t winStart,
+      flwor_wincond_t winStop,
+      bool lazy = false);
+
+  flwor_wincond* create_flwor_wincond(
+      static_context* sctx,
+      bool isOnly,
+      const flwor_wincond::vars& in_vars,
+      const flwor_wincond::vars& out_vars,
+      expr_t 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 std::vector<std::string>& collations);
+
+  orderby_clause * create_orderby_clause (
+      static_context* sctx,
+      const QueryLoc& loc,
+      bool stable,
+      const std::vector<OrderModifier>& modifiers,
+      const std::vector<expr_t>& orderingExprs);
+
+  materialize_clause* create_materialize_clause(
+      static_context* sctx,
+      const QueryLoc& loc);
+
+  count_clause* create_count_clause(
+      static_context* sctx,
+      const QueryLoc& loc,
+      var_expr_t var);
+
+  where_clause* create_where_clause(
+      static_context* sctx,
+      const QueryLoc& loc,
+      expr_t where);
+
+  flwor_expr* create_flwor_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      bool general);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+#ifdef ZORBA_WITH_JSON
+
+json_array_expr* create_json_array_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& content);
+
+json_object_expr* create_json_object_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      const expr_t& content,
+      bool accumulate);
+
+json_direct_object_expr* create_json_direct_object_expr(
+      static_context* sctx,
+      const QueryLoc& loc,
+      std::vector<expr_t>& names,
+      std::vector<expr_t>& values);
+
+#endif
+
+} // namespace zorba
+
+#endif // ZORBA_COMPILER_EXPRMANAGER_H

=== modified file 'src/compiler/expression/flwor_expr.cpp'
--- src/compiler/expression/flwor_expr.cpp	2012-07-24 08:48:48 +0000
+++ src/compiler/expression/flwor_expr.cpp	2012-08-10 11:20:27 +0000
@@ -26,6 +26,8 @@
 #include "compiler/expression/expr.h"
 #include "compiler/expression/expr_visitor.h"
 
+#include "compiler/api/compilercb.h"
+
 #include "types/root_typemanager.h"
 #include "types/typeops.h"
 
@@ -44,6 +46,7 @@
 ********************************************************************************/
 forletwin_clause::forletwin_clause(
     static_context* sctx,
+    CompilerCB* ccb,
     const QueryLoc& loc,
     flwor_clause::ClauseKind kind,
     var_expr_t varExpr,
@@ -51,7 +54,8 @@
   :
   flwor_clause(sctx, loc, kind),
   theVarExpr(varExpr),
-  theDomainExpr(domainExpr)
+  theDomainExpr(domainExpr),
+  theCCB(ccb)
 {
   if (theVarExpr != NULL)
     theVarExpr->set_flwor_clause(this);
@@ -87,6 +91,7 @@
 ********************************************************************************/
 for_clause::for_clause(
     static_context* sctx,
+    CompilerCB* ccb,
     const QueryLoc& loc,
     var_expr_t varExpr,
     expr_t domainExpr,
@@ -94,7 +99,7 @@
     var_expr_t scoreVarExpr,
     bool isAllowingEmpty)
   :
-  forletwin_clause(sctx, loc, flwor_clause::for_clause, varExpr, domainExpr),
+  forletwin_clause(sctx, ccb, loc, flwor_clause::for_clause, varExpr, domainExpr),
   thePosVarExpr(posVarExpr),
   theScoreVarExpr(scoreVarExpr),
   theAllowingEmpty(isAllowingEmpty)
@@ -137,11 +142,11 @@
                          *declaredType));
           }
 
-          domainExpr = new treat_expr(sctx,
-                                      loc,
-                                      domainExpr,
-                                      declaredType,
-                                      TreatIterator::TYPE_MATCH);
+          domainExpr = theCCB->theEM->create_treat_expr(sctx,
+                                            loc,
+                                            domainExpr,
+                                            declaredType,
+                                            TreatIterator::TYPE_MATCH);
 
           set_expr(domainExpr);
         }
@@ -193,14 +198,14 @@
 {
   expr_t domainCopy = theDomainExpr->clone(subst);
 
-  var_expr_t varCopy(new var_expr(*theVarExpr));
+  var_expr_t varCopy = theCCB->theEM->create_var_expr(*theVarExpr);
   subst[theVarExpr.getp()] = varCopy.getp();
 
   var_expr_t posvarCopy;
   var_expr* pos_var_ptr = thePosVarExpr.getp();
   if (pos_var_ptr)
   {
-    posvarCopy = new var_expr(*pos_var_ptr);
+    posvarCopy = theCCB->theEM->create_var_expr(*pos_var_ptr);
     subst[pos_var_ptr] = posvarCopy.getp();
   }
 
@@ -208,11 +213,12 @@
   var_expr* score_var_ptr = theScoreVarExpr.getp();
   if (score_var_ptr)
   {
-    scorevarCopy = new var_expr(*score_var_ptr);
+    scorevarCopy = theCCB->theEM->create_var_expr(*score_var_ptr);
     subst[score_var_ptr] = scorevarCopy.getp();
   }
 
   return new for_clause(theContext,
+                        theCCB,
                         get_loc(),
                         varCopy,
                         domainCopy,
@@ -227,12 +233,13 @@
 ********************************************************************************/
 let_clause::let_clause(
     static_context* sctx,
+    CompilerCB* ccb,
     const QueryLoc& loc,
     var_expr_t varExpr,
     expr_t domainExpr,
     bool lazy)
   :
-  forletwin_clause(sctx, loc, flwor_clause::let_clause, varExpr, domainExpr),
+  forletwin_clause(sctx, ccb, loc, flwor_clause::let_clause, varExpr, domainExpr),
   theScoreVarExpr(NULL),
   theLazyEval(lazy)
 {
@@ -259,7 +266,7 @@
           ERROR_PARAMS(ZED(BadType_23o), *domainType, ZED(NoTreatAs_4), *declaredType));
         }
 
-        domainExpr = new treat_expr(sctx,
+        domainExpr = theCCB->theEM->create_treat_expr(sctx,
                                     loc,
                                     domainExpr,
                                     declaredType,
@@ -297,7 +304,7 @@
 {
   expr_t domainCopy = theDomainExpr->clone(subst);
 
-  var_expr_t varCopy(new var_expr(*theVarExpr));
+  var_expr_t varCopy = theCCB->theEM->create_var_expr(*theVarExpr);
   subst[theVarExpr.getp()] = varCopy.getp();
 
 #if 0
@@ -310,7 +317,12 @@
   }
 #endif
 
-  return new let_clause(theContext, get_loc(), varCopy, domainCopy, theLazyEval);
+  return new let_clause(theContext,
+                        theCCB,
+                        get_loc(),
+                        varCopy,
+                        domainCopy,
+                        theLazyEval);
 }
 
 
@@ -320,6 +332,7 @@
 ********************************************************************************/
 window_clause::window_clause(
     static_context* sctx,
+    CompilerCB* ccb,
     const QueryLoc& loc,
     window_t winKind,
     var_expr_t varExpr,
@@ -328,7 +341,7 @@
     flwor_wincond_t winStop,
     bool lazy)
   :
-  forletwin_clause(sctx, loc, flwor_clause::window_clause, varExpr, domainExpr),
+  forletwin_clause(sctx, ccb, loc, flwor_clause::window_clause, varExpr, domainExpr),
   theWindowKind(winKind),
   theWinStartCond(winStart),
   theWinStopCond(winStop),
@@ -356,7 +369,7 @@
       if (!TypeOps::is_subtype(tm, *rtm.ITEM_TYPE_STAR, *varType, loc) &&
           !TypeOps::is_subtype(tm, *domainType, *varType, loc))
       {
-        domainExpr = new treat_expr(sctx,
+        domainExpr = theCCB->theEM->create_treat_expr(sctx,
                                     loc,
                                     domainExpr,
                                     varType,
@@ -399,7 +412,7 @@
 {
   expr_t domainCopy = theDomainExpr->clone(subst);
 
-  var_expr_t varCopy(new var_expr(*theVarExpr));
+  var_expr_t varCopy = theCCB->theEM->create_var_expr(*theVarExpr);
   subst[theVarExpr.getp()] = varCopy.getp();
 
   flwor_wincond_t cloneStartCond;
@@ -412,6 +425,7 @@
     cloneStopCond = theWinStopCond->clone(subst);
 
   return new window_clause(theContext,
+                           theCCB,
                            get_loc(),
                            theWindowKind,
                            varCopy,
@@ -426,6 +440,7 @@
 
 ********************************************************************************/
 flwor_wincond::flwor_wincond(
+    CompilerCB* ccb,
     static_context* sctx,
     bool isOnly,
     const vars& in_vars,
@@ -435,7 +450,8 @@
   theIsOnly(isOnly),
   theInputVars(in_vars),
   theOutputVars(out_vars),
-  theCondExpr(cond)
+  theCondExpr(cond),
+  theCCB(ccb)
 {
   expr::checkSimpleExpr(theCondExpr);
 
@@ -450,7 +466,7 @@
                           *GENV_TYPESYSTEM.BOOLEAN_TYPE_ONE,
                           theCondExpr->get_loc()))
     {
-      theCondExpr = new fo_expr(theCondExpr->get_sctx(),
+      theCondExpr = theCCB->theEM->create_fo_expr(theCondExpr->get_sctx(),
                                 theCondExpr->get_loc(),
                                 GET_BUILTIN_FUNCTION(FN_BOOLEAN_1),
                                 theCondExpr);
@@ -485,33 +501,34 @@
 
 
 void flwor_wincond::vars::clone(
+    ExprManager* mgr,
     flwor_wincond::vars& cloneVars,
     expr::substitution_t& subst) const
 {
   if (posvar != NULL)
   {
-    var_expr_t varCopy(new var_expr(*posvar));
+    var_expr_t varCopy = mgr->create_var_expr(*posvar);
     subst[posvar.getp()] = varCopy.getp();
     cloneVars.posvar = varCopy;
   }
 
   if (curr != NULL)
   {
-    var_expr_t varCopy(new var_expr(*curr));
+    var_expr_t varCopy = mgr->create_var_expr(*curr);
     subst[curr.getp()] = varCopy.getp();
     cloneVars.curr = varCopy;
   }
 
   if (prev != NULL)
   {
-    var_expr_t varCopy(new var_expr(*prev));
+    var_expr_t varCopy = mgr->create_var_expr(*prev);
     subst[prev.getp()] = varCopy.getp();
     cloneVars.prev = varCopy;
   }
 
   if (next != NULL)
   {
-    var_expr_t varCopy(new var_expr(*next));
+    var_expr_t varCopy = mgr->create_var_expr(*next);
     subst[next.getp()] = varCopy.getp();
     cloneVars.next = varCopy;
   }
@@ -530,12 +547,17 @@
   flwor_wincond::vars cloneInVars;
   flwor_wincond::vars cloneOutVars;
 
-  theInputVars.clone(cloneInVars, subst);
-  theOutputVars.clone(cloneOutVars, subst);
+  theInputVars.clone(theCCB->theEM, cloneInVars, subst);
+  theOutputVars.clone(theCCB->theEM, cloneOutVars, subst);
 
   expr_t cloneCondExpr = theCondExpr->clone(subst);
 
-  return new flwor_wincond(NULL, theIsOnly, cloneInVars, cloneOutVars, cloneCondExpr);
+  return new flwor_wincond(theCCB,
+                           NULL,
+                           theIsOnly,
+                           cloneInVars,
+                           cloneOutVars,
+                           cloneCondExpr);
 }
 
 
@@ -612,17 +634,24 @@
   rebind_list_t cloneGroupVars(numGroupVars);
   rebind_list_t cloneNonGroupVars(numNonGroupVars);
 
+  ExprManager* exprMgr = NULL;
+
+  if (numGroupVars > 0)
+    exprMgr = theGroupVars[0].first->get_ccb()->theEM;
+  else if (numNonGroupVars > 0)
+    exprMgr = theNonGroupVars[0].first->get_ccb()->theEM;
+
   for (csize i = 0; i < numGroupVars; ++i)
   {
     cloneGroupVars[i].first = theGroupVars[i].first->clone(subst);
-    cloneGroupVars[i].second = new var_expr(*theGroupVars[i].second);
+    cloneGroupVars[i].second = exprMgr->create_var_expr(*theGroupVars[i].second);
     subst[theGroupVars[i].second.getp()] = cloneGroupVars[i].second.getp();
   }
 
   for (csize i = 0; i < numNonGroupVars; ++i)
   {
     cloneNonGroupVars[i].first = theNonGroupVars[i].first->clone(subst);
-    cloneNonGroupVars[i].second = new var_expr(*theNonGroupVars[i].second);
+    cloneNonGroupVars[i].second = exprMgr->create_var_expr(*theNonGroupVars[i].second);
     subst[theNonGroupVars[i].second.getp()] = cloneNonGroupVars[i].second.getp();
   }
 
@@ -722,7 +751,9 @@
 
 flwor_clause_t count_clause::clone(expr::substitution_t& subst) const
 {
-  var_expr_t cloneVar = new var_expr(*theVarExpr);
+  ExprManager* exprMgr = theVarExpr->get_ccb()->theEM;
+
+  var_expr_t cloneVar = exprMgr->create_var_expr(*theVarExpr);
   subst[theVarExpr.getp()] = cloneVar;
 
   return new count_clause(theContext, get_loc(), cloneVar);
@@ -758,9 +789,9 @@
 /*******************************************************************************
 
 ********************************************************************************/
-flwor_expr::flwor_expr(static_context* sctx, const QueryLoc& loc, bool general)
+flwor_expr::flwor_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, bool general)
   :
-  expr(sctx, loc, (general ? gflwor_expr_kind : flwor_expr_kind)),
+  expr(ccb, sctx, loc, (general ? gflwor_expr_kind : flwor_expr_kind)),
   theIsGeneral(general),
   theHasSequentialClauses(false)
 {
@@ -1045,7 +1076,7 @@
     if (k == flwor_clause::for_clause ||
         k == flwor_clause::let_clause ||
         k == flwor_clause::window_clause)
-    { 
+    {
       const forletwin_clause* c2 = static_cast<const forletwin_clause*>(c);
 
       theScriptingKind |= c2->get_expr()->get_scripting_detail();
@@ -1090,7 +1121,7 @@
 {
   ulong numClauses = num_clauses();
 
-  flwor_expr_t cloneFlwor = new flwor_expr(theSctx, get_loc(), theIsGeneral);
+  flwor_expr_t cloneFlwor = theCCB->theEM->create_flwor_expr(theSctx, get_loc(), theIsGeneral);
 
   for (ulong i = 0; i < numClauses; ++i)
   {

=== modified file 'src/compiler/expression/flwor_expr.h'
--- src/compiler/expression/flwor_expr.h	2012-07-24 08:48:48 +0000
+++ src/compiler/expression/flwor_expr.h	2012-08-10 11:20:27 +0000
@@ -23,10 +23,11 @@
 #include "compiler/expression/var_expr.h"
 #include "compiler/expression/expr_utils.h"
 
-