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

[Markos Zaharioudakis]

Associated expressions with UDFs

Associated expressions with UDFs

[lp:~zorba-coders/zorba/markos-scratch]

10960. By Markos Zaharioudakis on 2012-10-09

associating exprs with udfs

[Markos Zaharioudakis (markos-za)]

review: Approve

[lp:~zorba-coders/zorba/markos-scratch]

10961. By Markos Zaharioudakis on 2012-10-09

cleaning up no-copy rule

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/markos-scratch-2012-10-09T13-39-57.923Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job markos-scratch-2012-10-09T13-39-57.923Z is finished. The final status was:

All tests succeeded!

=== modified file 'src/compiler/expression/CMakeLists.txt'
--- src/compiler/expression/CMakeLists.txt	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/CMakeLists.txt	2012-10-09 13:35:26 +0000
@@ -14,6 +14,7 @@
 SET(EXPRESSION_SRCS
     expr_consts.cpp
     expr_base.cpp
+    expr_clone.cpp
     expr_iter.cpp
     expr_type.cpp
     expr.cpp
 
=== modified file 'src/compiler/expression/expr.cpp'
--- src/compiler/expression/expr.cpp	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/expr.cpp	2012-10-09 13:35:26 +0000
@@ -83,22 +83,19 @@
 DEF_EXPR_ACCEPT (pi_expr)
 
 
-#define CLONE( e, s ) ((e) == NULL ? NULL : (e)->clone(s))
-
-
-
 /*******************************************************************************
   [68] IfExpr ::= "if" "(" Expr ")" "then" ExprSingle "else" ExprSingle
 ********************************************************************************/
 if_expr::if_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* condExpr,
     expr* thenExpr,
     expr* elseExpr)
   :
-  expr(ccb, sctx, loc, if_expr_kind),
+  expr(ccb, sctx, udf, loc, if_expr_kind),
   theThenExpr(thenExpr),
   theElseExpr(elseExpr)
 {
@@ -108,10 +105,13 @@
                          *GENV_TYPESYSTEM.BOOLEAN_TYPE_ONE,
                          loc))
   {
-    fo_expr* boolExpr = theCCB->theEM->create_fo_expr(sctx,
-                                    loc,
-                                    GET_BUILTIN_FUNCTION(FN_BOOLEAN_1),
-                                    condExpr);
+    fo_expr* boolExpr = theCCB->theEM->
+    create_fo_expr(sctx,
+                   udf,
+                   loc,
+                   GET_BUILTIN_FUNCTION(FN_BOOLEAN_1),
+                   condExpr);
+
     condExpr = boolExpr;
   }
 
@@ -166,27 +166,18 @@
 }
 
 
-expr* if_expr::cloneImpl(substitution_t& subst) const 
-{
-  return theCCB->theEM->create_if_expr(theSctx,
-                     get_loc(),
-                     get_cond_expr()->clone(subst),
-                     get_then_expr()->clone(subst),
-                     get_else_expr()->clone(subst));
-}
-
-
 /***************************************************************************//**
 
 ********************************************************************************/
 order_expr::order_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     order_type_t type,
     expr* inExpr)
   :
-  expr(ccb, sctx, loc, order_expr_kind),
+  expr(ccb, sctx, udf, loc, order_expr_kind),
   theType(type),
   theExpr(inExpr)
 {
@@ -203,25 +194,20 @@
 }
 
 
-expr* order_expr::cloneImpl(substitution_t& subst) const
-{
-  return theCCB->theEM->create_order_expr(theSctx, get_loc(), get_type(), get_expr()->clone(subst));
-}
-
-
 /***************************************************************************//**
 
 ********************************************************************************/
 validate_expr::validate_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     enum ParseConstants::validation_mode_t mode,
     const store::Item_t& typeName,
     expr* inExpr,
     rchandle<TypeManager> typemgr)
   :
-  expr(ccb, sctx, loc, validate_expr_kind),
+  expr(ccb, sctx, udf, loc, validate_expr_kind),
   theMode(mode),
   theTypeName(typeName),
   theTypeMgr(typemgr),
@@ -242,16 +228,6 @@
 }
 
 
-expr* validate_expr::cloneImpl(substitution_t& subst) const
-{
-  return theCCB->theEM->create_validate_expr(theSctx,
-                           get_loc(),
-                           get_valmode(),
-                           const_cast<store::Item*>(get_type_name()),
-                           get_expr()->clone(subst),
-                           get_typemgr());
-}
-
 
 /***************************************************************************//**
   Base for expression classes that require a namespace context
@@ -259,11 +235,12 @@
 namespace_context_base_expr::namespace_context_base_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr_kind_t kind,
     const namespace_context* aNSCtx)
   :
-  expr(ccb, sctx, loc, kind),
+  expr(ccb, sctx, udf, loc, kind),
   theNSCtx(const_cast<namespace_context*>(aNSCtx))
 {
 }
@@ -282,12 +259,13 @@
 cast_or_castable_base_expr::cast_or_castable_base_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr_kind_t kind,
     expr* input,
     const xqtref_t& type)
   :
-  expr(ccb, sctx, loc, kind),
+  expr(ccb, sctx, udf, loc, kind),
   theInputExpr(input),
   theTargetType(type)
 {
@@ -327,12 +305,13 @@
 cast_base_expr::cast_base_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr_kind_t kind,
     expr* input,
     const xqtref_t& type)
   :
-  cast_or_castable_base_expr(ccb, sctx, loc, kind, input, type)
+  cast_or_castable_base_expr(ccb, sctx, udf, loc, kind, input, type)
 {
   setNonDiscardable(ANNOTATION_TRUE_FIXED);
 }
@@ -346,11 +325,12 @@
 cast_expr::cast_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* inputExpr,
     const xqtref_t& type)
   :
-  cast_base_expr(ccb, sctx, loc, cast_expr_kind, inputExpr, type)
+  cast_base_expr(ccb, sctx, udf, loc, cast_expr_kind, inputExpr, type)
 {
   assert(type->get_quantifier() == TypeConstants::QUANT_ONE ||
          type->get_quantifier() == TypeConstants::QUANT_QUESTION);
@@ -363,21 +343,13 @@
 }
 
 
-expr* cast_expr::cloneImpl(substitution_t& subst) const
-{
-  return theCCB->theEM->create_cast_expr(theSctx,
-                       get_loc(),
-                       get_input()->clone(subst),
-                       get_target_type());
-}
-
-
 /***************************************************************************//**
   TreatExpr ::= CastableExpr ( "treat" "as" SequenceType )?
 ********************************************************************************/
 treat_expr::treat_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* inputExpr,
     const xqtref_t& type,
@@ -385,7 +357,7 @@
     bool check_prime,
     store::Item* qname)
   :
-  cast_base_expr(ccb, sctx, loc, treat_expr_kind, inputExpr, type),
+  cast_base_expr(ccb, sctx, udf, loc, treat_expr_kind, inputExpr, type),
   theErrorKind(err),
   theCheckPrime(check_prime),
   theQName(qname)
@@ -393,31 +365,20 @@
 }
 
 
-expr* treat_expr::cloneImpl(substitution_t& subst) const
-{
-  return theCCB->theEM->create_treat_expr(theSctx,
-                        get_loc(),
-                        get_input()->clone(subst),
-                        get_target_type(),
-                        get_err(),
-                        get_check_prime(),
-                        get_qname());
-}
-
-
 /***************************************************************************//**
 
 ********************************************************************************/
 promote_expr::promote_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* input,
     const xqtref_t& type,
     PromoteIterator::ErrorKind err,
     store::Item* qname)
   :
-  cast_base_expr(ccb, sctx, loc, promote_expr_kind, input, type),
+  cast_base_expr(ccb, sctx, udf, loc, promote_expr_kind, input, type),
   theErrorKind(err),
   theQName(qname)
 {
@@ -427,29 +388,19 @@
 }
 
 
-expr* promote_expr::cloneImpl(substitution_t& subst) const
-{
-  return theCCB->theEM->create_promote_expr(theSctx,
-                          get_loc(),
-                          get_input()->clone(subst),
-                          get_target_type(),
-                          theErrorKind,
-                          theQName.getp());
-}
-
-
 /***************************************************************************//**
   Base for castable, instanceof
 ********************************************************************************/
 castable_base_expr::castable_base_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr_kind_t kind,
     expr* input,
     const xqtref_t& type)
   :
-  cast_or_castable_base_expr(ccb, sctx, loc, kind, input, type)
+  cast_or_castable_base_expr(ccb, sctx, udf, loc, kind, input, type)
 {
 }
 
@@ -462,11 +413,12 @@
 castable_expr::castable_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* inputExpr,
     const xqtref_t& type)
   :
-  castable_base_expr (ccb, sctx, loc, castable_expr_kind, inputExpr, type)
+  castable_base_expr(ccb, sctx, udf, loc, castable_expr_kind, inputExpr, type)
 {
 }
 
@@ -477,53 +429,37 @@
 }
 
 
-expr* castable_expr::cloneImpl(substitution_t& subst) const
-{
-  return theCCB->theEM->create_castable_expr(theSctx,
-                           get_loc(),
-                           get_input()->clone(subst),
-                           get_target_type());
-}
-
-
 /***************************************************************************//**
   InstanceofExpr ::= TreatExpr ( "instance" "of" SequenceType )?
 ********************************************************************************/
 instanceof_expr::instanceof_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* inputExpr,
     const xqtref_t& type,
     bool checkPrimeOnly)
   :
-  castable_base_expr(ccb, sctx, loc, instanceof_expr_kind, inputExpr, type),
+  castable_base_expr(ccb, sctx, udf, loc, instanceof_expr_kind, inputExpr, type),
   theCheckPrimeOnly(checkPrimeOnly)
 {
 }
 
 
-expr* instanceof_expr::cloneImpl(substitution_t& subst) const
-{
-  return theCCB->theEM->create_instanceof_expr(theSctx,
-                             get_loc(),
-                             get_input()->clone(subst),
-                             get_target_type());
-}
-
-
 /***************************************************************************//**
 
 ********************************************************************************/
 name_cast_expr::name_cast_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* inputExpr,
     const namespace_context* aNSCtx,
     bool isAttrName)
   :
-  namespace_context_base_expr(ccb, sctx, loc, name_cast_expr_kind, aNSCtx),
+  namespace_context_base_expr(ccb, sctx, udf, loc, name_cast_expr_kind, aNSCtx),
   theInputExpr(inputExpr),
   theIsAttrName(isAttrName)
 {
@@ -542,27 +478,18 @@
 }
 
 
-expr* name_cast_expr::cloneImpl(substitution_t& subst) const
-{
-  return theCCB->theEM->create_name_cast_expr(theSctx,
-                            get_loc(),
-                            get_input()->clone(subst),
-                            getNSCtx(),
-                            theIsAttrName);
-}
-
-
 /***************************************************************************//**
   CompDocConstructor ::= "document" "{" Expr "}"
 ********************************************************************************/
 doc_expr::doc_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* aContent,
     bool copyNodes)
   :
-  expr(ccb, sctx, loc, doc_expr_kind),
+  expr(ccb, sctx, udf, loc, doc_expr_kind),
   theContent(aContent),
   theCopyInputNodes(copyNodes)
 {
@@ -581,22 +508,13 @@
 }
 
 
-expr* doc_expr::cloneImpl(substitution_t& subst) const
-{
-  doc_expr* clone = theCCB->theEM->create_doc_expr(theSctx,
-                                 get_loc(),
-                                 CLONE(getContent(), subst),
-                                 theCopyInputNodes);
-  return clone;
-}
-
-
 /***************************************************************************//**
 
 ********************************************************************************/
 elem_expr::elem_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& aLoc,
     expr* aQNameExpr,
     expr* attrs,
@@ -604,7 +522,7 @@
     const namespace_context* aNSCtx,
     bool copyNodes)
   :
-  namespace_context_base_expr(ccb, sctx, aLoc, elem_expr_kind, aNSCtx),
+  namespace_context_base_expr(ccb, sctx, udf, aLoc, elem_expr_kind, aNSCtx),
   theQNameExpr(aQNameExpr),
   theAttrs(attrs),
   theContent(content),
@@ -619,13 +537,14 @@
 elem_expr::elem_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& aLoc,
     expr* aQNameExpr,
     expr* content,
     const namespace_context* aNSCtx,
     bool copyNodes)
   :
-  namespace_context_base_expr(ccb, sctx, aLoc, elem_expr_kind, aNSCtx),
+  namespace_context_base_expr(ccb, sctx, udf, aLoc, elem_expr_kind, aNSCtx),
   theQNameExpr(aQNameExpr),
   theAttrs(0),
   theContent(content),
@@ -663,30 +582,18 @@
 }
 
 
-expr* elem_expr::cloneImpl(substitution_t& subst) const
-{
-  elem_expr* clone =  theCCB->theEM->create_elem_expr(theSctx,
-                                    get_loc(),
-                                    CLONE(getQNameExpr(), subst),
-                                    CLONE(getAttrs(), subst),
-                                    CLONE(getContent(), subst),
-                                    getNSCtx(),
-                                    theCopyInputNodes);
-  return clone;
-}
-
-
 /***************************************************************************//**
 
 ********************************************************************************/
 attr_expr::attr_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* aQNameExpr,
     expr* aValueExpr)
   :
-  expr(ccb, sctx, loc, attr_expr_kind),
+  expr(ccb, sctx, udf, loc, attr_expr_kind),
   theQNameExpr(aQNameExpr),
   theValueExpr(aValueExpr)
 {
@@ -730,15 +637,6 @@
 }
 
 
-expr* attr_expr::cloneImpl(substitution_t& subst) const
-{
-  return theCCB->theEM->create_attr_expr(theSctx,
-                       get_loc(),
-                       CLONE(getQNameExpr(), subst),
-                       CLONE(getValueExpr(), subst));
-}
-
-
 DEF_EXPR_ACCEPT(attr_expr)
 
 
@@ -748,11 +646,12 @@
 text_expr::text_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     text_constructor_type type_arg,
     expr* content)
   :
-  expr(ccb, sctx, loc, text_expr_kind),
+  expr(ccb, sctx, udf, loc, text_expr_kind),
   type(type_arg),
   theContentExpr(content)
 {
@@ -773,23 +672,18 @@
 }
 
 
-expr* text_expr::cloneImpl(substitution_t& subst) const
-{
-  return theCCB->theEM->create_text_expr(theSctx, get_loc(), get_type(), CLONE(get_text(), subst));
-}
-
-
 /***************************************************************************//**
 
 ********************************************************************************/
 pi_expr::pi_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* targetExpr,
     expr* contentExpr)
 :
-  expr(ccb, sctx, loc, pi_expr_kind),
+  expr(ccb, sctx, udf, loc, pi_expr_kind),
   theTargetExpr(targetExpr),
   theContentExpr(contentExpr)
 {
@@ -823,23 +717,18 @@
 }
 
 
-expr* pi_expr::cloneImpl(substitution_t& subst) const
-{
-  return theCCB->theEM->create_pi_expr(theSctx,
-                     get_loc(),
-                     CLONE(get_target_expr(), subst),
-                     CLONE(get_content_expr(), subst));
-}
-
-
-
 /*******************************************************************************
   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(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, expr* wrapped)
+wrapper_expr::wrapper_expr(
+    CompilerCB* ccb,
+    static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc,
+    expr* wrapped)
   :
-  expr(ccb, sctx, loc, wrapper_expr_kind),
+  expr(ccb, sctx, udf, loc, wrapper_expr_kind),
   theWrappedExpr(wrapped)
 {
   compute_scripting_kind();
@@ -852,77 +741,89 @@
 }
 
 
-expr* wrapper_expr::cloneImpl(substitution_t& subst) const
-{
-  expr* e = theWrappedExpr->clone(subst);
-
-  if (theWrappedExpr->get_expr_kind() == var_expr_kind &&
-      e->get_expr_kind() != var_expr_kind)
-    return e;
-  else
-    return theCCB->theEM->create_wrapper_expr(theSctx, get_loc(), e);
-}
-
-
 /***************************************************************************//**
 
 ********************************************************************************/
-const_expr::const_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, zstring& v)
+const_expr::const_expr(
+    CompilerCB* ccb,
+    static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc,
+    zstring& v)
   :
-  expr(ccb, sctx, loc, const_expr_kind)
+  expr(ccb, sctx, udf, 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)
+const_expr::const_expr(
+    CompilerCB* ccb,
+    static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc,
+    const std::string& v)
+  :
+  expr(ccb, sctx, udf, loc, const_expr_kind)
+{
+  zstring tmp(v);
+  GENV_ITEMFACTORY->createString(theValue, tmp);
+  theScriptingKind = SIMPLE_EXPR;
+}
+
+
+const_expr::const_expr(
+    CompilerCB* ccb,
+    static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc,
+    const char* v)
+  :
+  expr(ccb, sctx, udf, loc, const_expr_kind)
+{
+  zstring tmp(v);
+  GENV_ITEMFACTORY->createString(theValue, tmp);
+  theScriptingKind = SIMPLE_EXPR;
+}
+
+
+const_expr::const_expr(
+    CompilerCB* ccb,
+    static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc,
+    xs_integer v)
+  :
+  expr(ccb, sctx, udf, loc, const_expr_kind)
 {
   GENV_ITEMFACTORY->createInteger(theValue, v);
   theScriptingKind = SIMPLE_EXPR;
 }
 
+
 const_expr::const_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     xs_decimal v)
   :
-  expr(ccb, sctx, loc, const_expr_kind)
+  expr(ccb, sctx, udf, loc, const_expr_kind)
 {
   GENV_ITEMFACTORY->createDecimal(theValue, v);
   theScriptingKind = SIMPLE_EXPR;
 }
 
+
 const_expr::const_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     xs_double v)
   :
-  expr(ccb, sctx, loc, const_expr_kind)
+  expr(ccb, sctx, udf, loc, const_expr_kind)
 {
   GENV_ITEMFACTORY->createDouble(theValue, v);
   theScriptingKind = SIMPLE_EXPR;
@@ -932,10 +833,11 @@
 const_expr::const_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     xs_boolean v)
   :
-  expr(ccb, sctx, loc, const_expr_kind)
+  expr(ccb, sctx, udf, loc, const_expr_kind)
 {
   GENV_ITEMFACTORY->createBoolean(theValue, v);
   theScriptingKind = SIMPLE_EXPR;
@@ -945,10 +847,11 @@
 const_expr::const_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const store::Item_t& v)
   :
-  expr(ccb, sctx, loc, const_expr_kind),
+  expr(ccb, sctx, udf, loc, const_expr_kind),
   theValue(v)
 {
   theScriptingKind = SIMPLE_EXPR;
@@ -958,12 +861,13 @@
 const_expr::const_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& aLoc,
     const char* aNamespace,
     const char* aPrefix,
     const char* aLocal)
   :
-  expr(ccb, sctx, aLoc, const_expr_kind)
+  expr(ccb, sctx, udf, aLoc, const_expr_kind)
 {
   GENV_ITEMFACTORY->createQName(theValue, aNamespace, aPrefix, aLocal);
   theScriptingKind = SIMPLE_EXPR;
@@ -976,21 +880,16 @@
 }
 
 
-expr* const_expr::cloneImpl(substitution_t&) const
-{
-  return theCCB->theEM->create_const_expr(theSctx, get_loc(), theValue);
-}
-
-
 /*******************************************************************************
 
 ********************************************************************************/
 extension_expr::extension_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc)
   :
-  expr(ccb, sctx, loc, extension_expr_kind)
+  expr(ccb, sctx, udf, loc, extension_expr_kind)
 {
   compute_scripting_kind();
 }
@@ -999,10 +898,11 @@
 extension_expr::extension_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* e)
   :
-  expr(ccb, sctx, loc, extension_expr_kind),
+  expr(ccb, sctx, udf, loc, extension_expr_kind),
   theExpr(e)
 {
   compute_scripting_kind();
@@ -1020,23 +920,6 @@
 }
 
 
-expr* extension_expr::cloneImpl(substitution_t& subst) const 
-{
-  extension_expr* lClone(0);
-  lClone = (
-    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<pragma*>::const_iterator lIter = thePragmas.begin();
-        lIter != thePragmas.end();
-        ++lIter )
-  {
-    lClone->add(*lIter);
-  }
-  return lClone;
-}
-
-
 /////////////////////////////////////////////////////////////////////////
 //                                                                     //
 //  XQuery 3.0 expressions                                             //
@@ -1049,7 +932,8 @@
 
 ********************************************************************************/
 catch_clause::catch_clause(CompilerCB* ccb)
-:theCCB(ccb)
+  :
+  theCCB(ccb)
 {
 }
 
@@ -1057,10 +941,11 @@
 trycatch_expr::trycatch_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* tryExpr)
   :
-  expr(ccb, sctx, loc, trycatch_expr_kind),
+  expr(ccb, sctx, udf, loc, trycatch_expr_kind),
   theTryExpr(tryExpr)
 {
   compute_scripting_kind();
@@ -1145,6 +1030,7 @@
   {
     lClause->add_nametest_h(lIter->getp());
   }
+
   for (var_map_t::const_iterator lIter = theVarMap.begin();
        lIter != theVarMap.end();
        ++lIter)
@@ -1156,39 +1042,19 @@
 }
 
 
-expr* trycatch_expr::cloneImpl(substitution_t& subst) const
-{
-  std::auto_ptr<trycatch_expr> lTryCatch(
-      theCCB->theEM->create_trycatch_expr(theSctx, get_loc(), theTryExpr->clone(subst)));
-
-  for (std::vector<expr*>::const_iterator lIter = theCatchExprs.begin();
-       lIter != theCatchExprs.end();
-       ++lIter)
-  {
-    lTryCatch->add_catch_expr((*lIter)->clone(subst));
-  }
-
-  for (csize i = 0; i < clause_count(); ++i)
-  {
-    lTryCatch->add_clause(theCatchClauses[i]->clone(subst));
-  }
-
-  return lTryCatch.release();
-}
-
-
 /*******************************************************************************
 
 ********************************************************************************/
 eval_expr::eval_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* e,
     expr_script_kind_t scriptingKind,
     namespace_context* nsCtx)
   :
-  namespace_context_base_expr(ccb, sctx, loc, eval_expr_kind, nsCtx),
+  namespace_context_base_expr(ccb, sctx, udf, loc, eval_expr_kind, nsCtx),
   theExpr(e),
   theInnerScriptingKind(scriptingKind),
   theDoNodeCopy(false)
@@ -1222,33 +1088,6 @@
 }
 
 
-expr* eval_expr::cloneImpl(substitution_t& s) const
-{
-  eval_expr* new_eval = theCCB->theEM->
-  create_eval_expr(theSctx,
-                   theLoc,
-                   theExpr->clone(s),
-                   theInnerScriptingKind,
-                   theNSCtx.getp());
-
-  new_eval->setNodeCopy(theDoNodeCopy);
-
-  new_eval->theOuterVarNames = theOuterVarNames;
-  new_eval->theOuterVarTypes = theOuterVarTypes;
-
-  csize numVars = theOuterVarNames.size();
-
-  new_eval->theArgs.resize(numVars);
-
-  for (csize i = 0; i < numVars; ++i)
-  {
-    new_eval->theArgs[i] = theArgs[i]->clone(s);
-  }
-
-  return new_eval;
-}
-
-
 #ifdef ZORBA_WITH_DEBUGGER
 /*******************************************************************************
 
@@ -1256,12 +1095,13 @@
 debugger_expr::debugger_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* aChild,
     namespace_context* nsCtx,
     bool aIsVarDeclaration)
   :
-  namespace_context_base_expr(ccb, sctx, loc, debugger_expr_kind, nsCtx),
+  namespace_context_base_expr(ccb, sctx, udf, loc, debugger_expr_kind, nsCtx),
   theExpr(aChild),
   theIsVarDeclaration(aIsVarDeclaration)
 {
@@ -1283,10 +1123,11 @@
 function_trace_expr::function_trace_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* aChild)
   :
-  expr(ccb, sctx, loc, aChild->get_expr_kind()),
+  expr(ccb, sctx, udf, loc, aChild->get_expr_kind()),
   theExpr(aChild),
   theFunctionArity(0)
 {
@@ -1296,9 +1137,13 @@
 }
 
 
-function_trace_expr::function_trace_expr(expr* aExpr)
+function_trace_expr::function_trace_expr(user_function* udf, expr* aExpr)
   :
-  expr(aExpr->get_ccb(), aExpr->get_sctx(), aExpr->get_loc(), function_trace_expr_kind),
+  expr(aExpr->get_ccb(),
+       aExpr->get_sctx(),
+       udf,
+       aExpr->get_loc(),
+       function_trace_expr_kind),
   theExpr(aExpr),
   theFunctionArity(0)
 {
@@ -1319,20 +1164,5 @@
 }
 
 
-expr* function_trace_expr::cloneImpl(substitution_t& s) const
-{
-  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;
-}
-
-
-
 } /* namespace zorba */
 /* vim:set et sw=2 ts=2: */
 
=== modified file 'src/compiler/expression/expr.h'
--- src/compiler/expression/expr.h	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/expr.h	2012-10-09 13:35:26 +0000
@@ -58,14 +58,15 @@
   friend class expr;
 
 protected:
-  expr* theCondExpr;
-  expr* theThenExpr;
-  expr* theElseExpr;
+  expr  * theCondExpr;
+  expr  * theThenExpr;
+  expr  * theElseExpr;
 
 protected:
   if_expr(
         CompilerCB* ccb,
         static_context* sctx,
+        user_function* udf,
         const QueryLoc& loc,
         expr* c,
         expr* t,
@@ -80,8 +81,6 @@
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -105,11 +104,17 @@
   };
 
 protected:
-  order_type_t theType;
-  expr*       theExpr;
+  order_type_t   theType;
+  expr         * theExpr;
 
 protected:
-  order_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, order_type_t, expr*);
+  order_expr(
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&,
+      order_type_t,
+      expr*);
 
 public:
   order_type_t get_type() const { return theType; }
@@ -118,8 +123,6 @@
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -139,17 +142,18 @@
   ParseConstants::validation_mode_t theMode;
   store::Item_t                     theTypeName;
   rchandle<TypeManager>             theTypeMgr;
-  expr*                            theExpr;
+  expr                            * theExpr;
 
 protected:
   validate_expr(
-        CompilerCB* ccb,
-        static_context* sctx,
-        const QueryLoc&,
-        ParseConstants::validation_mode_t,
-        const store::Item_t& aTypeName,
-        expr*,
-        rchandle<TypeManager>);
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&,
+      ParseConstants::validation_mode_t,
+      const store::Item_t& aTypeName,
+      expr*,
+      rchandle<TypeManager>);
 
 public:
   expr* get_expr() const { return theExpr; }
@@ -162,8 +166,6 @@
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -184,6 +186,7 @@
   namespace_context_base_expr(
       CompilerCB* ccb,
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr_kind_t kind,
       const namespace_context* aNSCtx);
@@ -207,12 +210,13 @@
 
 protected:
   cast_or_castable_base_expr(
-        CompilerCB* ccb,
-        static_context* sctx,
-        const QueryLoc& loc,
-        expr_kind_t kind,
-        expr* input,
-        const xqtref_t& type);
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc& loc,
+      expr_kind_t kind,
+      expr* input,
+      const xqtref_t& type);
 
 public:
   expr* get_input() const { return theInputExpr; }
@@ -234,12 +238,13 @@
 
 protected:
   cast_base_expr(
-        CompilerCB* ccb,
-        static_context* sctx,
-        const QueryLoc& loc,
-        expr_kind_t kind,
-        expr* input,
-        const xqtref_t& type);
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc& loc,
+      expr_kind_t kind,
+      expr* input,
+      const xqtref_t& type);
 };
 
 
@@ -258,6 +263,7 @@
   cast_expr(
       CompilerCB* ccb,
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*,
       const xqtref_t&);
@@ -265,8 +271,6 @@
 public:
   bool is_optional() const;
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -299,14 +303,15 @@
 
 protected:
   treat_expr(
-        CompilerCB* ccb,
-        static_context* sctx,
-        const QueryLoc&,
-        expr*,
-        const xqtref_t&,
-        TreatIterator::ErrorKind err,
-        bool check_prime = true,
-        store::Item* qname = NULL);
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&,
+      expr*,
+      const xqtref_t&,
+      TreatIterator::ErrorKind err,
+      bool check_prime = true,
+      store::Item* qname = NULL);
 
 public:
   TreatIterator::ErrorKind get_err() const { return theErrorKind; }
@@ -319,8 +324,6 @@
 
   store::Item_t get_qname() const { return theQName; }
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -379,6 +382,7 @@
   promote_expr(
       CompilerCB* ccb,
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* input,
       const xqtref_t& type,
@@ -386,8 +390,6 @@
       store::Item* qname);
 
 public:
-  expr* cloneImpl(substitution_t& s) const;
-
   PromoteIterator::ErrorKind get_err() const { return theErrorKind; }
 
   void set_qname(const store::Item_t& qname) { theQName = qname; }
@@ -409,12 +411,13 @@
 
 protected:
   castable_base_expr(
-        CompilerCB* ccb,
-        static_context* sctx,
-        const QueryLoc&,
-        expr_kind_t kind,
-        expr*,
-        const xqtref_t&);
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&,
+      expr_kind_t kind,
+      expr*,
+      const xqtref_t&);
 };
 
 
@@ -433,6 +436,7 @@
   castable_expr(
       CompilerCB* ccb,
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*,
       const xqtref_t&);
@@ -440,8 +444,6 @@
 public:
   bool is_optional() const;
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -470,6 +472,7 @@
   instanceof_expr(
       CompilerCB* ccb,
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*,
       const xqtref_t&,
@@ -478,8 +481,6 @@
 public:
   bool getCheckPrimeOnly() const { return theCheckPrimeOnly; }
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -510,6 +511,7 @@
   name_cast_expr(
       CompilerCB* ccb,
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*,
       const namespace_context*,
@@ -522,8 +524,6 @@
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -540,11 +540,17 @@
   friend class expr;
 
 protected:
-  expr* theContent;
-  bool   theCopyInputNodes;
+  expr  * theContent;
+  bool     theCopyInputNodes;
 
 protected:
-  doc_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, expr* content, bool copyNodes);
+  doc_expr(
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&,
+      expr* content,
+      bool copyNodes);
 
 public:
   expr* getContent() const { return theContent; }
@@ -555,8 +561,6 @@
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -596,25 +600,27 @@
   friend class expr;
 
 protected:
-  expr* theQNameExpr;
-  expr* theAttrs;
-  expr* theContent;
-  bool   theCopyInputNodes;
+  expr  * theQNameExpr;
+  expr  * theAttrs;
+  expr  * theContent;
+  bool    theCopyInputNodes;
 
 protected:
   elem_expr(
-        CompilerCB* ccb,
-        static_context* sctx,
-        const QueryLoc&,
-        expr* qnameExpr,
-        expr* attrs,
-        expr* content,
-        const namespace_context* nsCtx,
-        bool copyNodes);
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&,
+      expr* qnameExpr,
+      expr* attrs,
+      expr* content,
+      const namespace_context* nsCtx,
+      bool copyNodes);
 
   elem_expr(
         CompilerCB* ccb,
         static_context* sctx,
+        user_function* udf,
         const QueryLoc&,
         expr* qnameExpr,
         expr* content,
@@ -634,8 +640,6 @@
 
   void compute_scripting_kind();
   
-  expr* cloneImpl(substitution_t& s) const;  
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -673,16 +677,17 @@
   friend class expr;
 
 protected:
-  expr* theQNameExpr;
-  expr* theValueExpr;
+  expr  * theQNameExpr;
+  expr  * theValueExpr;
 
 protected:
   attr_expr(
-    CompilerCB* ccb,
-    static_context* sctx,
-    const QueryLoc& loc,
-    expr* aQNameExpr,
-    expr* aValueExpr);
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc& loc,
+      expr* aQNameExpr,
+      expr* aValueExpr);
 
 public:
   expr* getQNameExpr() const { return theQNameExpr; }
@@ -693,8 +698,6 @@
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -718,13 +721,14 @@
   } text_constructor_type;
 
 protected:
-  text_constructor_type type;
-  expr*                theContentExpr;
+  text_constructor_type   type;
+  expr                  * theContentExpr;
 
 protected:
   text_expr(
       CompilerCB* ccb,
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       text_constructor_type,
       expr*);
@@ -736,8 +740,6 @@
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& s) const;  
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -754,11 +756,17 @@
   friend class expr;
 
 protected:
-  expr* theTargetExpr;
-  expr* theContentExpr;
+  expr * theTargetExpr;
+  expr * theContentExpr;
 
 protected:
-  pi_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, expr*, expr*);
+  pi_expr(
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&,
+      expr*,
+      expr*);
 
 public:
   expr* get_target_expr() const { return theTargetExpr; }
@@ -767,8 +775,6 @@
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& s) const;  
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -788,31 +794,76 @@
   store::Item_t theValue;
 
 protected:
-  const_expr(CompilerCB*, static_context*, const QueryLoc&, zstring& sval);
-
-  const_expr(CompilerCB*, static_context*, const QueryLoc&, const std::string& sval);
-
-  const_expr(CompilerCB*, static_context*, const QueryLoc&, const char* sval);
-
-  const_expr(CompilerCB*, static_context*, const QueryLoc&, xs_integer);
-
-  const_expr(CompilerCB*, static_context*, const QueryLoc&, xs_decimal);
-
-  const_expr(CompilerCB*, static_context*, const QueryLoc&, xs_double);
-
-  const_expr(CompilerCB*, static_context*, const QueryLoc&, xs_boolean);
-
-  const_expr(CompilerCB*, static_context*, const QueryLoc&, const store::Item_t&);
-
-  const_expr(CompilerCB*, static_context*, const QueryLoc&, const char* ns, const char* pre, const char* local);
+  const_expr(
+      CompilerCB*,
+      static_context*,
+      user_function* udf,
+      const QueryLoc&,
+      zstring& sval);
+
+  const_expr(
+      CompilerCB*,
+      static_context*,
+      user_function* udf,
+      const QueryLoc&,
+      const std::string& sval);
+
+  const_expr(
+      CompilerCB*,
+      static_context*,
+      user_function* udf,
+      const QueryLoc&,
+      const char* sval);
+
+  const_expr(
+      CompilerCB*,
+      static_context*,
+      user_function* udf,
+      const QueryLoc&,
+      xs_integer);
+
+  const_expr(
+      CompilerCB*,
+      static_context*,
+      user_function* udf,
+      const QueryLoc&,
+      xs_decimal);
+
+  const_expr(
+      CompilerCB*,
+      static_context*,
+      user_function* udf,
+      const QueryLoc&,
+      xs_double);
+
+  const_expr(
+      CompilerCB*,
+      static_context*,
+      user_function* udf,
+      const QueryLoc&,
+      xs_boolean);
+
+  const_expr(
+      CompilerCB*,
+      static_context*,
+      user_function* udf,
+      const QueryLoc&,
+      const store::Item_t&);
+
+  const_expr(
+      CompilerCB*,
+      static_context*,
+      user_function* udf,
+      const QueryLoc&,
+      const char* ns,
+      const char* pre,
+      const char* local);
 
 public:
   store::Item* get_val() const { return theValue.getp(); }
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -829,13 +880,22 @@
   friend class expr;
 
 protected:
-  std::vector<pragma*> thePragmas;
-  expr*                theExpr;
+  std::vector<pragma*>   thePragmas;
+  expr                 * theExpr;
 
 protected:
-  extension_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&);
+  extension_expr(
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&);
 
-  extension_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, expr*);
+  extension_expr(
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&,
+      expr*);
 
 public:
   void add(pragma* p) { thePragmas.push_back(p); }
@@ -844,8 +904,6 @@
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& subst) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -934,7 +992,12 @@
   std::vector<catch_clause*> theCatchClauses;
 
 protected:
-  trycatch_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc&, expr* tryExpr);
+  trycatch_expr(
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&,
+      expr* tryExpr);
 
 public:
   expr* get_try_expr() const { return theTryExpr; }
@@ -953,8 +1016,6 @@
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& subst) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
@@ -979,10 +1040,15 @@
   friend class ExprManager;
 
 protected:
-  expr* theWrappedExpr;
+  expr  * theWrappedExpr;
 
 protected:
-  wrapper_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, expr* wrapped);
+  wrapper_expr(
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc& loc,
+      expr* wrapped);
 
 public:
   expr* get_expr() const { return theWrappedExpr; }
@@ -993,8 +1059,6 @@
 
   void accept(expr_visitor&);
 
-  expr* cloneImpl(substitution_t& s) const;
-
   std::ostream& put(std::ostream&) const;
 };
 
@@ -1019,10 +1083,13 @@
   function_trace_expr(
       CompilerCB* ccb,
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* aChild);
 
-  function_trace_expr(expr* aExpr);
+  function_trace_expr(
+      user_function* udf,
+      expr* aExpr);
 
 public:
   virtual ~function_trace_expr();
@@ -1031,8 +1098,6 @@
 
   void accept(expr_visitor&);
 
-  expr* cloneImpl(substitution_t& s) const;
-
   std::ostream& put(std::ostream&) const;
 
   expr* get_expr() const { return theExpr; }
@@ -1133,6 +1198,7 @@
   eval_expr(
       CompilerCB* ccb,
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* e,
       expr_script_kind_t scriptingKind,
@@ -1166,8 +1232,6 @@
 
   void accept(expr_visitor&);
 
-  expr* cloneImpl(substitution_t& s) const;
-
   std::ostream& put(std::ostream&) const;
 };
 
@@ -1205,6 +1269,7 @@
   debugger_expr(
       CompilerCB* ccb,
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* aChild,
       namespace_context* nsCtx,
 
=== modified file 'src/compiler/expression/expr_base.cpp'
--- src/compiler/expression/expr_base.cpp	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/expr_base.cpp	2012-10-09 13:35:26 +0000
@@ -19,7 +19,6 @@
 #include "compiler/expression/expr.h"
 #include "compiler/expression/fo_expr.h"
 #include "compiler/expression/flwor_expr.h"
-#include "compiler/expression/script_exprs.h"
 #include "compiler/expression/path_expr.h"
 #include "compiler/expression/expr_iter.h"
 #include "compiler/expression/expr_visitor.h"
@@ -123,13 +122,19 @@
 /*******************************************************************************
 
 ********************************************************************************/
-expr::expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, expr_kind_t k)
+expr::expr(
+    CompilerCB* ccb,
+    static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc,
+    expr_kind_t k)
   :
+  theCCB(ccb),
   theSctx(sctx),
+  theUDF(udf),
   theLoc(loc),
   theKind(k),
-  theFlags1(0),
-  theCCB(ccb)
+  theFlags1(0)
 {
   theScriptingKind = UNKNOWN_SCRIPTING_KIND;
 
@@ -239,40 +244,6 @@
 /*******************************************************************************
 
 ********************************************************************************/
-expr* expr::clone() const
-{
-  substitution_t subst;
-  return clone(subst);
-}
-
-
-expr* expr::clone(substitution_t& subst) const
-{
-  expr* lNewExpr = cloneImpl(subst);
-
-  if (containsPragma())
-  {
-    lNewExpr->setContainsPragma(ANNOTATION_TRUE);
-    std::vector<pragma*> lPragmas;
-    theCCB->lookup_pragmas(this, lPragmas);
-    for (size_t i = 0; i < lPragmas.size(); ++i)
-    {
-      theCCB->add_pragma(lNewExpr, lPragmas[i]);
-    }
-  }
-  return lNewExpr;
-}
-
-
-expr* expr::cloneImpl(substitution_t& subst) const
-{
-  throw XQUERY_EXCEPTION(zerr::ZXQP0003_INTERNAL_ERROR, ERROR_LOC(get_loc()));
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
 void expr::accept_children(expr_visitor& v)
 {
   ExprIterator iter(this);
@@ -1212,13 +1183,18 @@
 ********************************************************************************/
 xqtref_t expr::get_return_type_with_empty_input(const expr* input) const
 {
-  expr* emptyExpr = theCCB->theEM->create_fo_expr(input->get_sctx(),
-                                 QueryLoc::null,
-                                 GET_BUILTIN_FUNCTION(OP_CONCATENATE_N));
+  assert(input->get_udf() == theUDF);
+
+  expr* emptyExpr = theCCB->theEM->
+  create_fo_expr(input->get_sctx(),
+                 theUDF,
+                 QueryLoc::null,
+                 GET_BUILTIN_FUNCTION(OP_CONCATENATE_N));
+
   expr::substitution_t subst;
   subst[input] = emptyExpr;
 
-  expr* cloneExpr = clone(subst);
+  expr* cloneExpr = clone(theUDF, subst);
 
   return cloneExpr->get_return_type();
 }
 
=== modified file 'src/compiler/expression/expr_base.h'
--- src/compiler/expression/expr_base.h	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/expr_base.h	2012-10-09 13:35:26 +0000
@@ -173,8 +173,12 @@
   static expr*    * iter_done;
 
 protected:
+  CompilerCB * const theCCB;
+
   static_context   * theSctx;
 
+  user_function    * theUDF;
+
   QueryLoc           theLoc;
 
   unsigned short     theKind;
@@ -186,8 +190,6 @@
 
   FreeVars           theFreeVars;
 
-  CompilerCB  *const theCCB;
-
 public:
   static bool is_sequential(unsigned short theScriptingKind);
 
@@ -196,14 +198,20 @@
   static void checkNonUpdating(const expr* e);
 
 protected:
-  expr(CompilerCB*, static_context*, const QueryLoc&, expr_kind_t);
+  expr(CompilerCB*, static_context*, user_function*, const QueryLoc&, expr_kind_t);
 
-  expr() : theSctx(NULL), theFlags1(0), theCCB(NULL) {}
+  expr() : theCCB(NULL), theSctx(NULL), theUDF(NULL), theFlags1(0) {}
 
 public:
   virtual ~expr();
 
-  CompilerCB* get_ccb() {return theCCB;}
+  CompilerCB* get_ccb() { return theCCB; }
+
+  static_context* get_sctx() const { return theSctx; }
+
+  TypeManager* get_type_manager() const;
+
+  user_function* get_udf() const { return theUDF; }
 
   expr_kind_t get_expr_kind() const { return static_cast<expr_kind_t>(theKind); }
 
@@ -211,10 +219,6 @@
 
   void set_loc(const QueryLoc& loc) { theLoc = loc; }
 
-  static_context* get_sctx() const { return theSctx; }
-
-  TypeManager* get_type_manager() const;
-
   uint32_t getFlags() const { return theFlags1; }
 
   void setFlags(uint32_t flags) { theFlags1 = flags; }
@@ -241,11 +245,9 @@
 
   xqtref_t get_return_type();
 
-  expr* clone() const;
-
-  expr* clone(substitution_t&) const;
-
-  virtual expr* cloneImpl(substitution_t& substitution) const;
+  expr* clone(user_function* udf) const;
+
+  expr* clone(user_function* udf, substitution_t& subst) const;
 
   virtual void accept(expr_visitor& v) = 0;
 
 
=== added file 'src/compiler/expression/expr_clone.cpp'
--- src/compiler/expression/expr_clone.cpp	1970-01-01 00:00:00 +0000
+++ src/compiler/expression/expr_clone.cpp	2012-10-09 13:35:26 +0000
@@ -0,0 +1,790 @@
+/*
+ * 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.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "compiler/expression/expr_base.h"
+#include "compiler/expression/update_exprs.h"
+#include "compiler/expression/expr.h"
+#include "compiler/expression/fo_expr.h"
+#include "compiler/expression/flwor_expr.h"
+#include "compiler/expression/script_exprs.h"
+#include "compiler/expression/path_expr.h"
+#include "compiler/expression/json_exprs.h"
+#include "compiler/expression/function_item_expr.h"
+#include "compiler/expression/ft_expr.h"
+#include "compiler/expression/expr_manager.h"
+
+#include "compiler/api/compilercb.h"
+
+#include "functions/function.h"
+
+#include "diagnostics/xquery_diagnostics.h"
+#include "diagnostics/util_macros.h"
+
+namespace zorba
+{
+
+#define CLONE(e, udf, subst) ((e) == NULL ? NULL : (e)->clone(udf, subst))
+
+
+/*******************************************************************************
+
+********************************************************************************/
+expr* expr::clone(user_function* udf) const
+{
+  substitution_t subst;
+  return clone(udf, subst);
+}
+
+
+expr* expr::clone(user_function* udf, substitution_t& subst) const
+{
+  expr* newExpr = NULL;
+
+  switch (get_expr_kind())
+  {
+  case const_expr_kind:
+  {
+    const const_expr* e = static_cast<const const_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_const_expr(theSctx, udf, theLoc, e->theValue);
+
+    break;
+  }
+  case var_expr_kind:
+  {
+    expr::subst_iter_t i = subst.find(this);
+
+    if (i == subst.end())
+      newExpr = const_cast<expr*>(this);
+    else
+      newExpr = i->second;
+
+    break;
+  }
+  case doc_expr_kind:
+  {
+    const doc_expr* e = static_cast<const doc_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_doc_expr(theSctx,
+                    udf,
+                    theLoc,
+                    CLONE(e->getContent(), udf, subst),
+                    e->theCopyInputNodes);
+    break;
+  }
+  case elem_expr_kind:
+  {
+    const elem_expr* e = static_cast<const elem_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_elem_expr(theSctx,
+                     udf,
+                     theLoc,
+                     CLONE(e->getQNameExpr(), udf, subst),
+                     CLONE(e->getAttrs(), udf, subst),
+                     CLONE(e->getContent(), udf, subst),
+                     e->getNSCtx(),
+                     e->theCopyInputNodes);
+    break;
+  }
+  case attr_expr_kind:
+  {
+    const attr_expr* e = static_cast<const attr_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_attr_expr(theSctx,
+                     udf,
+                     theLoc,
+                     CLONE(e->getQNameExpr(), udf, subst),
+                     CLONE(e->getValueExpr(), udf, subst));
+    break;
+  }
+  case text_expr_kind:
+  {
+    const text_expr* e = static_cast<const text_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_text_expr(theSctx,
+                     udf,
+                     theLoc,
+                     e->get_type(),
+                     CLONE(e->get_text(), udf, subst));
+    break;
+  }
+  case pi_expr_kind:
+  {
+    const pi_expr* e = static_cast<const pi_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_pi_expr(theSctx,
+                   udf,
+                   theLoc,
+                   CLONE(e->get_target_expr(), udf, subst),
+                   CLONE(e->get_content_expr(), udf, subst));
+    break;
+  }
+#ifdef ZORBA_WITH_JSON
+  case json_direct_object_expr_kind:
+  {
+    const json_direct_object_expr* e = static_cast<const json_direct_object_expr*>(this);
+
+    std::vector<expr*> names;
+    std::vector<expr*> values;
+    
+    names.reserve(e->theNames.size());
+    values.reserve(e->theValues.size());
+
+    std::vector<expr*>::const_iterator ite = e->theNames.begin();
+    std::vector<expr*>::const_iterator end = e->theNames.end();
+    for (; ite != end; ++ite)
+    {
+      names.push_back((*ite)->clone(udf, subst));
+    }
+
+    ite = e->theValues.begin();
+    end = e->theValues.end();
+    for (; ite != end; ++ite)
+    {
+      values.push_back((*ite)->clone(udf, subst));
+    }
+
+    newExpr = theCCB->theEM->
+    create_json_direct_object_expr(theSctx, udf, theLoc, names, values);
+
+    break;
+  }
+  case json_object_expr_kind:
+  {
+    const json_object_expr* e = static_cast<const json_object_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_json_object_expr(theSctx,
+                            udf,
+                            theLoc,
+                            (e->theContentExpr ?
+                             e->theContentExpr->clone(udf, subst) : NULL),
+                            e->theAccumulate);
+
+    break;
+  }
+  case json_array_expr_kind:
+  {
+    const json_array_expr* e = static_cast<const json_array_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_json_array_expr(theSctx,
+                           udf,
+                           theLoc,
+                           e->theContentExpr->clone(udf, subst));
+
+    break;
+  }
+#endif
+
+  case relpath_expr_kind:
+  {
+    const relpath_expr* e = static_cast<const relpath_expr*>(this);
+
+    relpath_expr* cloneExpr = theCCB->theEM->
+    create_relpath_expr(theSctx, udf, theLoc);
+
+    for (csize i = 0; i < e->size(); ++i)
+    {
+      cloneExpr->add_back((*e)[i]->clone(udf, subst));
+    }
+
+    newExpr = cloneExpr;
+    break;
+  }
+  case axis_step_expr_kind:
+  {
+    const axis_step_expr* e = static_cast<const axis_step_expr*>(this);
+
+    axis_step_expr* cloneExpr = theCCB->theEM->
+    create_axis_step_expr(theSctx, udf, theLoc);
+
+    cloneExpr->setAxis(e->getAxis());
+    cloneExpr->setTest(static_cast<match_expr*>(CLONE(e->getTest(), udf, subst)));
+    cloneExpr->theReverseOrder = e->theReverseOrder;
+
+    newExpr = cloneExpr;
+    break;
+  }
+  case match_expr_kind:
+  {
+    const match_expr* e = static_cast<const match_expr*>(this);
+
+    match_expr* cloneExpr = theCCB->theEM->
+    create_match_expr(theSctx, udf, theLoc);
+
+    cloneExpr->setTestKind(e->getTestKind());
+    cloneExpr->setDocTestKind(e->getDocTestKind());
+    cloneExpr->setWildName(e->getWildName());
+    cloneExpr->setWildKind(e->getWildKind());
+    cloneExpr->setQName(e->getQName());
+    cloneExpr->setTypeName(e->getTypeName());
+    cloneExpr->setNilledAllowed(e->getNilledAllowed());
+
+    newExpr = cloneExpr;
+    break;
+  }
+
+  case flwor_expr_kind:
+  case gflwor_expr_kind:
+  {
+    const flwor_expr* e = static_cast<const flwor_expr*>(this);
+
+    flwor_expr* cloneExpr = theCCB->theEM->
+    create_flwor_expr(theSctx, udf, theLoc, e->theIsGeneral);
+
+    csize numClauses = e->num_clauses();
+
+    for (csize i = 0; i < numClauses; ++i)
+    {
+      flwor_clause* cloneClause = e->theClauses[i]->clone(udf, subst);
+
+      cloneExpr->add_clause(cloneClause, false);
+    }
+
+    cloneExpr->set_return_expr(e->theReturnExpr->clone(udf, subst));
+
+    newExpr = cloneExpr;
+    break;
+  }
+  case if_expr_kind:
+  {
+    const if_expr* e = static_cast<const if_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_if_expr(theSctx,
+                   udf,
+                   theLoc,
+                   e->get_cond_expr()->clone(udf, subst),
+                   e->get_then_expr()->clone(udf, subst),
+                   e->get_else_expr()->clone(udf, subst));
+    break;
+  }
+  case trycatch_expr_kind:
+  {
+    const trycatch_expr* e = static_cast<const trycatch_expr*>(this);
+
+    trycatch_expr* cloneExpr = theCCB->theEM->
+    create_trycatch_expr(theSctx, udf, theLoc, e->theTryExpr->clone(udf, subst));
+
+    for (std::vector<expr*>::const_iterator ite = e->theCatchExprs.begin();
+         ite != e->theCatchExprs.end();
+         ++ite)
+    {
+      cloneExpr->add_catch_expr((*ite)->clone(udf, subst));
+    }
+
+    for (csize i = 0; i < e->clause_count(); ++i)
+    {
+      cloneExpr->add_clause(e->theCatchClauses[i]->clone(subst));
+    }
+
+    newExpr = cloneExpr;
+    break;
+  }
+  case fo_expr_kind:
+  {
+    const fo_expr* e = static_cast<const fo_expr*>(this);
+
+    if (e->get_func()->getKind() == FunctionConsts::STATIC_COLLECTIONS_DML_COLLECTION_1)
+    {
+      expr::subst_iter_t i = subst.find(this);
+
+      if (i != subst.end())
+      {
+        newExpr = i->second;
+        break;
+      }
+    }
+
+    fo_expr* cloneExpr = theCCB->theEM->
+    create_fo_expr(theSctx, udf, theLoc, e->get_func());
+
+    cloneExpr->theArgs.reserve(e->theArgs.size());
+
+    for (csize i = 0; i < e->theArgs.size(); ++i)
+      cloneExpr->theArgs.push_back(e->theArgs[i]->clone(udf, subst));
+
+    cloneExpr->theScriptingKind  = e->theScriptingKind;
+
+    newExpr = cloneExpr;
+    break;
+  }
+  case dynamic_function_invocation_expr_kind:
+  {
+    const dynamic_function_invocation_expr* e = 
+    static_cast<const dynamic_function_invocation_expr*>(this);
+
+    checked_vector<expr*> newArgs;
+    for (checked_vector<expr*>::const_iterator ite = e->theArgs.begin();
+         ite != e->theArgs.end();
+         ++ite)
+    {
+      newArgs.push_back((*ite)->clone(udf, subst));
+    }
+    
+    newExpr = theCCB->theEM->
+    create_dynamic_function_invocation_expr(theSctx,
+                                            udf,
+                                            theLoc,
+                                            e->theExpr->clone(udf, subst),
+                                            newArgs);
+    break;
+  }
+  case function_item_expr_kind:
+  {
+    const function_item_expr* e = static_cast<const function_item_expr*>(this);
+
+    function_item_expr* cloneExpr = theCCB->theEM->
+    create_function_item_expr(theSctx,
+                              udf,
+                              theLoc,
+                              e->theFunction->getName(),
+                              e->theFunction.getp(),
+                              e->theArity);
+
+    std::vector<expr*> lNewVariables;
+    for (std::vector<expr*>::const_iterator ite = e->theScopedVariables.begin();
+         ite != e->theScopedVariables.end();
+         ++ite)
+    {
+      cloneExpr->add_variable((*ite)->clone(udf, subst));
+    }
+
+    newExpr = cloneExpr;
+    break;
+  }
+  case castable_expr_kind:
+  {
+    const castable_expr* e = static_cast<const castable_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_castable_expr(theSctx,
+                         udf,
+                         theLoc,
+                         e->get_input()->clone(udf, subst),
+                         e->get_target_type());
+
+    break;
+  }
+  case cast_expr_kind:
+  {
+    const cast_expr* e = static_cast<const cast_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_cast_expr(theSctx,
+                     udf,
+                     theLoc,
+                     e->get_input()->clone(udf, subst),
+                     e->get_target_type());
+    break;
+  }
+  case instanceof_expr_kind:
+  {
+    const instanceof_expr* e = static_cast<const instanceof_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_instanceof_expr(theSctx,
+                           udf,
+                           theLoc,
+                           e->get_input()->clone(udf, subst),
+                           e->get_target_type());
+    break;
+  }
+  case treat_expr_kind:
+  {
+    const treat_expr* e = static_cast<const treat_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_treat_expr(theSctx,
+                      udf,
+                      theLoc,
+                      e->get_input()->clone(udf, subst),
+                      e->get_target_type(),
+                      e->get_err(),
+                      e->get_check_prime(),
+                      e->get_qname());
+    break;
+  }
+  case promote_expr_kind:
+  {
+    const promote_expr* e = static_cast<const promote_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_promote_expr(theSctx,
+                        udf,
+                        theLoc,
+                        e->get_input()->clone(udf, subst),
+                        e->get_target_type(),
+                        e->theErrorKind,
+                        e->theQName.getp());
+    break;
+  }
+  case name_cast_expr_kind:
+  {
+    const name_cast_expr* e = static_cast<const name_cast_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_name_cast_expr(theSctx,
+                          udf,
+                          theLoc,
+                          e->get_input()->clone(udf, subst),
+                          e->getNSCtx(),
+                          e->theIsAttrName);
+    break;
+  }
+  case validate_expr_kind:
+  {
+    const validate_expr* e = static_cast<const validate_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_validate_expr(theSctx,
+                         udf,
+                         theLoc,
+                         e->get_valmode(),
+                         const_cast<store::Item*>(e->get_type_name()),
+                         e->get_expr()->clone(udf, subst),
+                         e->get_typemgr());
+
+    break;
+  }
+  case extension_expr_kind:
+  {
+    const extension_expr* e = static_cast<const extension_expr*>(this);
+
+    extension_expr* cloneExpr;
+    if(e->theExpr == 0)
+    {
+      cloneExpr = theCCB->theEM->create_extension_expr(theSctx, udf, theLoc);
+    }
+    else
+    {
+      cloneExpr = theCCB->theEM->
+      create_extension_expr(theSctx, udf, theLoc, e->theExpr->clone(udf, subst));
+    }
+
+    // pragma doesn't contain expressions. Thus, it is not cloned.
+    for (std::vector<pragma*>::const_iterator lIter = e->thePragmas.begin();
+         lIter != e->thePragmas.end();
+         ++lIter)
+    {
+      cloneExpr->add(*lIter);
+    }
+
+    newExpr = cloneExpr;
+    break;
+  }
+  case order_expr_kind:
+  {
+    const order_expr* e = static_cast<const order_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_order_expr(theSctx,
+                      udf,
+                      theLoc,
+                      e->get_type(),
+                      e->get_expr()->clone(udf, subst));
+    break;
+  }
+#ifndef ZORBA_NO_FULL_TEXT
+  case ft_expr_kind:
+  {
+    const ftcontains_expr* e = static_cast<const ftcontains_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_ftcontains_expr(theSctx,
+                           udf,
+                           theLoc,
+                           e->range_->clone(udf, subst),
+                           e->ftselection_->clone(udf, subst).release(),
+                           (e->ftignore_ == NULL ? 0 : e->ftignore_->clone(udf, subst)));
+
+    break;
+  }
+#endif /* ZORBA_NO_FULL_TEXT */
+
+  case delete_expr_kind:
+  {
+    const delete_expr* e = static_cast<const delete_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_delete_expr(theSctx, udf, theLoc, e->getTargetExpr()->clone(udf, subst));
+
+    break;
+  }
+  case insert_expr_kind:
+  {
+    const insert_expr* e = static_cast<const insert_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_insert_expr(theSctx,
+                       udf,
+                       theLoc,
+                       e->getType(),
+                       e->getSourceExpr()->clone(udf, subst),
+                       e->getTargetExpr()->clone(udf, subst));
+    break;
+  }
+  case rename_expr_kind:
+  {
+    const rename_expr* e = static_cast<const rename_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_rename_expr(theSctx,
+                       udf,
+                       theLoc,
+                       e->getTargetExpr()->clone(udf, subst),
+                       e->getNameExpr()->clone(udf, subst));
+    break;
+  }
+  case replace_expr_kind:
+  {
+    const zorba::replace_expr* e = static_cast<const zorba::replace_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_replace_expr(theSctx,
+                        udf,
+                        theLoc,
+                        e->getType(),
+                        e->getTargetExpr()->clone(udf, subst),
+                        e->getReplaceExpr()->clone(udf, subst));
+    break;
+  }
+  case transform_expr_kind:
+  {
+    const transform_expr* e = static_cast<const transform_expr*>(this);
+
+    ZORBA_ASSERT(e->theModifyExpr && e->theReturnExpr);
+
+    transform_expr* cloneExpr = theCCB->theEM->
+    create_transform_expr(theSctx, udf, theLoc);
+    
+    for (std::vector<copy_clause*>::const_iterator ite = e->theCopyClauses.begin();
+         ite != e->theCopyClauses.end();
+         ++ite)
+    {
+      cloneExpr->add_back((*ite)->clone(udf, subst));
+    }
+
+    cloneExpr->setModifyExpr(e->theModifyExpr->clone(udf, subst));
+    cloneExpr->setReturnExpr(e->theReturnExpr->clone(udf, subst));
+
+    newExpr = cloneExpr;
+    break;
+  }
+
+  case block_expr_kind:
+  {
+    const block_expr* e = static_cast<const block_expr*>(this);
+
+    checked_vector<expr*> seq2;
+    for (csize i = 0; i < e->theArgs.size(); ++i)
+      seq2.push_back(e->theArgs[i]->clone(udf, subst));
+
+    newExpr = theCCB->theEM->
+    create_block_expr(theSctx, udf, theLoc, true, seq2, NULL);
+
+    break;
+  }
+  case var_decl_expr_kind:
+  {
+    const var_decl_expr* e = static_cast<const var_decl_expr*>(this);
+
+    var_expr* varCopy = theCCB->theEM->create_var_expr(udf, *e->theVarExpr);
+    subst[e->theVarExpr] = varCopy;
+
+    newExpr = theCCB->theEM->
+    create_var_decl_expr(theSctx,
+                         udf,
+                         theLoc,
+                         varCopy,
+                         (e->theInitExpr ? e->theInitExpr->clone(udf, subst) : NULL));
+    
+    break;
+  }
+  case var_set_expr_kind:
+  {
+    const var_set_expr* e = static_cast<const var_set_expr*>(this);
+
+    expr* varClone = e->theVarExpr->clone(udf, subst);
+
+    ZORBA_ASSERT(varClone->get_expr_kind() == var_expr_kind);
+
+    newExpr = theCCB->theEM->
+    create_var_set_expr(theSctx,
+                        udf,
+                        theLoc,
+                        static_cast<var_expr*>(varClone),
+                        e->theExpr->clone(udf, subst));
+    break;
+  }
+  case apply_expr_kind:
+  {
+    const apply_expr* e = static_cast<const apply_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_apply_expr(theSctx,
+                      udf,
+                      theLoc,
+                      e->theExpr->clone(udf, subst),
+                      e->theDiscardXDM);
+
+    break;
+  }
+  case exit_expr_kind:
+  {
+    const exit_expr* e = static_cast<const exit_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_exit_expr(theSctx, udf, theLoc, e->get_expr()->clone(udf, subst));
+
+    subst[this] = newExpr;
+
+    break;
+  }
+  case exit_catcher_expr_kind:
+  {
+    const exit_catcher_expr* e = static_cast<const exit_catcher_expr*>(this);
+
+    expr* clonedInput = e->get_expr()->clone(udf, subst);
+
+    std::vector<expr*> clonedExits;
+    std::vector<expr*>::const_iterator ite = e->theExitExprs.begin();
+    std::vector<expr*>::const_iterator end = e->theExitExprs.end();
+    for (; ite != end; ++ite)
+    {
+      assert(subst.find(*ite) != subst.end());
+      
+      clonedExits.push_back(subst[*ite]);
+    }
+    
+    newExpr = theCCB->theEM->
+    create_exit_catcher_expr(theSctx, udf, theLoc, clonedInput, clonedExits);
+
+    break;
+  }
+  case flowctl_expr_kind:
+  {
+    const flowctl_expr* e = static_cast<const flowctl_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_flowctl_expr(theSctx, udf, theLoc, e->get_action());
+
+    break;
+  }
+  case while_expr_kind:
+  {
+    const while_expr* e = static_cast<const while_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_while_expr(theSctx, udf, theLoc, e->get_body()->clone(udf, subst));
+
+    break;
+  }
+  case eval_expr_kind:
+  {
+    const eval_expr* e = static_cast<const eval_expr*>(this);
+
+    newExpr = theCCB->theEM->
+    create_eval_expr(theSctx,
+                     udf,
+                     theLoc,
+                     e->theExpr->clone(udf, subst),
+                     e->theInnerScriptingKind,
+                     e->theNSCtx.getp());
+
+    eval_expr* newEval = static_cast<eval_expr*>(newExpr);
+
+    newEval->setNodeCopy(e->theDoNodeCopy);
+
+    newEval->theOuterVarNames = e->theOuterVarNames;
+    newEval->theOuterVarTypes = e->theOuterVarTypes;
+
+    csize numVars = e->theOuterVarNames.size();
+
+    newEval->theArgs.resize(numVars);
+
+    for (csize i = 0; i < numVars; ++i)
+    {
+      newEval->theArgs[i] = e->theArgs[i]->clone(udf, subst);
+    }
+
+    break;
+  }
+  case wrapper_expr_kind:
+  {
+    const wrapper_expr* e = static_cast<const wrapper_expr*>(this);
+
+    expr* wrappedClone = e->theWrappedExpr->clone(udf, subst);
+
+    if (e->theWrappedExpr->get_expr_kind() == var_expr_kind &&
+        wrappedClone->get_expr_kind() != var_expr_kind)
+    {
+      newExpr = wrappedClone;
+    }
+    else
+    {
+      newExpr = theCCB->theEM->create_wrapper_expr(theSctx, udf, theLoc, wrappedClone);
+    }
+
+    break;
+  }
+  case function_trace_expr_kind:
+  {
+    const function_trace_expr* e = static_cast<const function_trace_expr*>(this);
+
+    function_trace_expr* cloneExpr = theCCB->theEM->
+    create_function_trace_expr(udf, e->theExpr->clone(udf, subst));
+
+    cloneExpr->theFunctionName = e->theFunctionName;
+    cloneExpr->theFunctionLocation = e->theFunctionLocation;
+    cloneExpr->theFunctionCallLocation = e->theFunctionCallLocation;
+    cloneExpr->theFunctionArity = e->theFunctionArity;
+
+    newExpr = cloneExpr;
+    break;
+  }
+  case debugger_expr_kind:
+  default:
+  {
+    RAISE_ERROR(zerr::ZXQP0003_INTERNAL_ERROR, theLoc,
+    ERROR_PARAMS(ZED(CloneNotImplemented)));
+  }
+  }
+
+  if (containsPragma())
+  {
+    newExpr->setContainsPragma(ANNOTATION_TRUE);
+
+    std::vector<pragma*> pragmas;
+    theCCB->lookup_pragmas(this, pragmas);
+
+    for (csize i = 0; i < pragmas.size(); ++i)
+    {
+      theCCB->add_pragma(newExpr, pragmas[i]);
+    }
+  }
+
+  return newExpr;
+}
+
+}
 
=== modified file 'src/compiler/expression/expr_manager.cpp'
--- src/compiler/expression/expr_manager.cpp	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/expr_manager.cpp	2012-10-09 13:35:26 +0000
@@ -35,60 +35,6 @@
 namespace zorba
 {
 
-#if 0
-//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; }
-};
-
-
-class NullFlworClause : public flwor_clause
-{
-public:
-  //it being a let clause is arbitrary, it doesn't matter what type it is.
-  NullFlworClause() :flwor_clause(NULL, NULL, QueryLoc(), flwor_clause::let_clause) {}
-
-  std::ostream& put(std::ostream& stream) const { return stream; }
-
-  flwor_clause* clone(expr::substitution_t &) const { return NULL; }
-};
-
-
-class NullWincond : public flwor_wincond
-{
-public:
-  NullWincond() : flwor_wincond(NULL, NULL, false, vars(), vars(), NULL) {}
-
-  std::ostream& put(std::ostream& stream) const { return stream; }
-};
-
-
-class NullCatchClause : public catch_clause
-{
-public:
-  NullCatchClause() : catch_clause(NULL) {}
-
-  std::ostream& put(std::ostream& stream) const{return stream;}
-};
-
-
-class NullCopyClause : public copy_clause
-{
-public:
-  NullCopyClause() : copy_clause(NULL, NULL, NULL) {}
-};
-#endif
-
-
 ExprManager::ExprManager(CompilerCB* ccb)
   :
   theCCB(ccb)
@@ -219,49 +165,54 @@
 
 if_expr* ExprManager::create_if_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* cond_expr,
     expr* then_expr,
     expr* else_expr)
 {
-  CREATE_AND_RETURN_EXPR(if_expr, sctx, loc, cond_expr, then_expr, else_expr);
+  CREATE_AND_RETURN_EXPR(if_expr, sctx, udf, loc, cond_expr, then_expr, else_expr);
 }
 
 
 order_expr* ExprManager::create_order_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     order_expr::order_type_t order,
     expr* exp)
 {
-  CREATE_AND_RETURN_EXPR(order_expr, sctx, loc, order, exp);
+  CREATE_AND_RETURN_EXPR(order_expr, sctx, udf, loc, order, exp);
 }
 
 
 validate_expr* ExprManager::create_validate_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     ParseConstants::validation_mode_t mode,
     const store::Item_t& aTypeName,
     expr* validated,
     rchandle<TypeManager> tm)
 {
-  CREATE_AND_RETURN_EXPR(validate_expr, sctx, loc, mode, aTypeName, validated, tm);
+  CREATE_AND_RETURN_EXPR(validate_expr, sctx, udf, loc, mode, aTypeName, validated, tm);
 }
 
 
 cast_expr* ExprManager::create_cast_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* casted,
     xqtref_t type)
 {
-  CREATE_AND_RETURN_EXPR(cast_expr, sctx, loc, casted, type);
+  CREATE_AND_RETURN_EXPR(cast_expr, sctx, udf, loc, casted, type);
 }
 
 
 treat_expr* ExprManager::create_treat_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* treated,
     const xqtref_t& type,
@@ -270,67 +221,73 @@
     store::Item* qname)
 {
   CREATE_AND_RETURN_EXPR(treat_expr,
-  sctx, loc, treated, type, err, check_prime, qname);
+  sctx, udf, loc, treated, type, err, check_prime, qname);
 }
 
 
 promote_expr* ExprManager::create_promote_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* promoted,
     const xqtref_t& type,
     PromoteIterator::ErrorKind err,
     store::Item* qname)
 {
-  CREATE_AND_RETURN_EXPR(promote_expr, sctx, loc, promoted, type, err, qname);
+  CREATE_AND_RETURN_EXPR(promote_expr, sctx, udf, loc, promoted, type, err, qname);
 }
 
 
 castable_expr* ExprManager::create_castable_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* castable,
     xqtref_t type)
 {
-  CREATE_AND_RETURN_EXPR(castable_expr, sctx, loc, castable, type);
+  CREATE_AND_RETURN_EXPR(castable_expr, sctx, udf, loc, castable, type);
 }
 
 
 instanceof_expr* ExprManager::create_instanceof_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* instanced,
     xqtref_t type,
     bool checkPrimeOnly)
 {
   CREATE_AND_RETURN_EXPR(instanceof_expr,
-          sctx, loc, instanced, type, checkPrimeOnly);
+          sctx, udf, loc, instanced, type, checkPrimeOnly);
 }
 
 
 name_cast_expr* ExprManager::create_name_cast_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* casted,
     const namespace_context* ns,
     bool isAttr)
 {
-  CREATE_AND_RETURN_EXPR(name_cast_expr, sctx, loc, casted, ns, isAttr);
+  CREATE_AND_RETURN_EXPR(name_cast_expr, sctx, udf, loc, casted, ns, isAttr);
 }
 
 
 doc_expr* ExprManager::create_doc_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* content,
     bool copyNodes)
 {
-  CREATE_AND_RETURN_EXPR(doc_expr, sctx, loc, content, copyNodes);
+  CREATE_AND_RETURN_EXPR(doc_expr, sctx, udf, loc, content, copyNodes);
 }
 
 
 elem_expr* ExprManager::create_elem_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* qnameExpr,
     expr* attrs,
@@ -339,12 +296,13 @@
     bool copyNodes)
 {
   CREATE_AND_RETURN_EXPR(elem_expr,
-          sctx, loc, qnameExpr, attrs, content, nsCtx, copyNodes);
+          sctx, udf, loc, qnameExpr, attrs, content, nsCtx, copyNodes);
 }
 
 
 elem_expr* ExprManager::create_elem_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* qnameExpr,
     expr* content,
@@ -352,137 +310,151 @@
     bool copyNodes)
 {
   CREATE_AND_RETURN_EXPR(elem_expr,
-          sctx, loc, qnameExpr, content, nsCtx, copyNodes);
+          sctx, udf, loc, qnameExpr, content, nsCtx, copyNodes);
 }
 
 
 attr_expr* ExprManager::create_attr_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* aQNameExpr,
     expr* aValueExpr)
 {
-  CREATE_AND_RETURN_EXPR(attr_expr, sctx, loc, aQNameExpr, aValueExpr);
+  CREATE_AND_RETURN_EXPR(attr_expr, sctx, udf, loc, aQNameExpr, aValueExpr);
 }
 
 
 text_expr* ExprManager::create_text_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     text_expr::text_constructor_type textType,
     expr* text)
 {
-  CREATE_AND_RETURN_EXPR(text_expr, sctx, loc, textType, text);
+  CREATE_AND_RETURN_EXPR(text_expr, sctx, udf, loc, textType, text);
 }
 
 
 pi_expr* ExprManager::create_pi_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* targetExpr,
     expr* contentExpr)
 {
-  CREATE_AND_RETURN_EXPR(pi_expr, sctx, loc, targetExpr, contentExpr);
+  CREATE_AND_RETURN_EXPR(pi_expr, sctx, udf, loc, targetExpr, contentExpr);
 }
 
 
 const_expr* ExprManager::create_const_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     zstring& sval)
 {
-  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, sval);
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, udf, loc, sval);
 }
 
 
 const_expr* ExprManager::create_const_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const std::string& sval)
 {
-  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, sval);
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, udf, loc, sval);
 }
 
 
 const_expr* ExprManager::create_const_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const char* sval)
 {
-  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, sval);
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, udf, loc, sval);
 }
 
 
 const_expr* ExprManager::create_const_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     xs_integer val)
 {
-  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, val);
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, udf, loc, val);
 }
 
 
 const_expr* ExprManager::create_const_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     xs_decimal val)
 {
-  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, val);
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, udf, loc, val);
 }
 
 
 const_expr* ExprManager::create_const_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     xs_double val)
 {
-  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, val);
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, udf, loc, val);
 }
 
 
 const_expr* ExprManager::create_const_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     xs_boolean val)
 {
-  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, val);
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, udf, loc, val);
 }
 
 
 const_expr* ExprManager::create_const_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     store::Item_t val)
 {
-  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, val);
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, udf, loc, val);
 }
 
 
 const_expr* ExprManager::create_const_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const char* ns,
     const char* pre,
     const char* local)
 {
-  CREATE_AND_RETURN_EXPR(const_expr, sctx, loc, ns, pre, local);
+  CREATE_AND_RETURN_EXPR(const_expr, sctx, udf, loc, ns, pre, local);
 }
 
 
 extension_expr* ExprManager::create_extension_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc)
 {
-  CREATE_AND_RETURN_EXPR(extension_expr, sctx, loc);
+  CREATE_AND_RETURN_EXPR(extension_expr, sctx, udf, loc);
 }
 
 
 extension_expr* ExprManager::create_extension_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* extended)
 {
-  CREATE_AND_RETURN_EXPR(extension_expr, sctx, loc, extended);
+  CREATE_AND_RETURN_EXPR(extension_expr, sctx, udf, loc, extended);
 }
 
 
@@ -494,35 +466,40 @@
 
 trycatch_expr* ExprManager::create_trycatch_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* tryExpr)
 {
-  CREATE_AND_RETURN_EXPR(trycatch_expr, sctx, loc, tryExpr);
+  CREATE_AND_RETURN_EXPR(trycatch_expr, sctx, udf, loc, tryExpr);
 }
 
 
 wrapper_expr* ExprManager::create_wrapper_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* wrapped)
 {
-  CREATE_AND_RETURN_EXPR(wrapper_expr, sctx, loc, wrapped);
+  CREATE_AND_RETURN_EXPR(wrapper_expr, sctx, udf, loc, wrapped);
 }
 
-
+#if 0
 function_trace_expr* ExprManager::create_function_trace_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* aChild)
 {
-  CREATE_AND_RETURN_EXPR(function_trace_expr, sctx, loc, aChild);
+  CREATE_AND_RETURN_EXPR(function_trace_expr, sctx, udf, loc, aChild);
 }
-
-
-function_trace_expr* ExprManager::create_function_trace_expr(expr* aExpr)
+#endif
+
+function_trace_expr* ExprManager::create_function_trace_expr(
+    user_function* udf,
+    expr* aExpr)
 {
   //this function gets the ExprManager from the expression it recieves.
-  function_trace_expr* e = new (theMemoryMgr) function_trace_expr(aExpr);
+  function_trace_expr* e = new (theMemoryMgr) function_trace_expr(udf, aExpr);
   reg(e);
   return e;
 }
@@ -530,25 +507,27 @@
 
 eval_expr* ExprManager::create_eval_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* e,
     expr_script_kind_t scriptingKind,
     namespace_context* nsCtx)
 {
-  CREATE_AND_RETURN_EXPR(eval_expr, sctx, loc, e, scriptingKind, nsCtx);
+  CREATE_AND_RETURN_EXPR(eval_expr, sctx, udf, loc, e, scriptingKind, nsCtx);
 }
 
 #ifdef ZORBA_WITH_DEBUGGER
 
 debugger_expr* ExprManager::create_debugger_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* aChild,
     namespace_context* nsCtx,
     bool aIsVarDeclaration)
 {
   CREATE_AND_RETURN_EXPR(debugger_expr,
-  sctx, loc, aChild, nsCtx, aIsVarDeclaration);
+  sctx, udf, loc, aChild, nsCtx, aIsVarDeclaration);
 }
 
 #endif
@@ -557,17 +536,20 @@
 
 var_expr* ExprManager::create_var_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     var_expr::var_kind k,
     store::Item* name)
 {
-  CREATE_AND_RETURN_EXPR(var_expr, sctx, loc, k, name);
+  CREATE_AND_RETURN_EXPR(var_expr, sctx, udf, loc, k, name);
 }
 
 
-var_expr* ExprManager::create_var_expr(const var_expr& source)
+var_expr* ExprManager::create_var_expr(
+    user_function* udf,
+    const var_expr& source)
 {
-  var_expr* e = new (theMemoryMgr) var_expr(source);
+  var_expr* e = new (theMemoryMgr) var_expr(udf, source);
   reg(e);
   return e;
 }
@@ -580,30 +562,33 @@
 
 json_array_expr* ExprManager::create_json_array_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* content)
 {
-  CREATE_AND_RETURN_EXPR(json_array_expr, sctx, loc, content);
+  CREATE_AND_RETURN_EXPR(json_array_expr, sctx, udf, loc, content);
 }
 
 
 json_object_expr* ExprManager::create_json_object_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* content,
     bool accumulate)
 {
-  CREATE_AND_RETURN_EXPR(json_object_expr, sctx, loc, content, accumulate);
+  CREATE_AND_RETURN_EXPR(json_object_expr, sctx, udf, loc, content, accumulate);
 }
 
 
 json_direct_object_expr* ExprManager::create_json_direct_object_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     std::vector<expr*>& names,
     std::vector<expr*>& values)
 {
-  CREATE_AND_RETURN_EXPR(json_direct_object_expr, sctx, loc, names, values);
+  CREATE_AND_RETURN_EXPR(json_direct_object_expr, sctx, udf, loc, names, values);
 }
 
 
@@ -614,43 +599,47 @@
 
 insert_expr* ExprManager::create_insert_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     store::UpdateConsts::InsertType insertType,
     expr* aSourceExpr,
     expr* aTargetExpr)
 {
   CREATE_AND_RETURN_EXPR(insert_expr,
-  sctx, loc, insertType, aSourceExpr, aTargetExpr);
+  sctx, udf, loc, insertType, aSourceExpr, aTargetExpr);
 }
 
 
 delete_expr* ExprManager::create_delete_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* aTargetExpr)
 {
-  CREATE_AND_RETURN_EXPR(delete_expr, sctx, loc, aTargetExpr);
+  CREATE_AND_RETURN_EXPR(delete_expr, sctx, udf, loc, aTargetExpr);
 }
 
 
 replace_expr* ExprManager::create_replace_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     store::UpdateConsts::ReplaceType aType,
     expr* aSourceExpr,
     expr* aTargetExpr)
 {
-  CREATE_AND_RETURN_EXPR(replace_expr, sctx, loc, aType, aSourceExpr, aTargetExpr);
+  CREATE_AND_RETURN_EXPR(replace_expr, sctx, udf, loc, aType, aSourceExpr, aTargetExpr);
 }
 
 
 rename_expr* ExprManager::create_rename_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* aSourceExpr,
     expr* aTargetExpr)
 {
-  CREATE_AND_RETURN_EXPR(rename_expr, sctx, loc, aSourceExpr, aTargetExpr);
+  CREATE_AND_RETURN_EXPR(rename_expr, sctx, udf, loc, aSourceExpr, aTargetExpr);
 }
 
 
@@ -662,112 +651,126 @@
 
 transform_expr* ExprManager::create_transform_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc)
 {
-  CREATE_AND_RETURN_EXPR(transform_expr, sctx, loc);
+  CREATE_AND_RETURN_EXPR(transform_expr, sctx, udf, loc);
 }
 
 
 block_expr* ExprManager::create_block_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     bool allowLastUpdating,
     std::vector<expr*>& seq,
     std::vector<var_expr*>* assignedVars)
 {
   CREATE_AND_RETURN_EXPR(block_expr,
-  sctx, loc, allowLastUpdating, seq, assignedVars);
+  sctx, udf, loc, allowLastUpdating, seq, assignedVars);
 }
 
 
 apply_expr* ExprManager::create_apply_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* inExpr,
     bool discardXDM)
 {
-  CREATE_AND_RETURN_EXPR(apply_expr, sctx, loc, inExpr, discardXDM);
+  CREATE_AND_RETURN_EXPR(apply_expr, sctx, udf, loc, inExpr, discardXDM);
 }
 
 
 var_decl_expr* ExprManager::create_var_decl_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     var_expr* varExpr,
     expr* initExpr)
 {
-  CREATE_AND_RETURN_EXPR(var_decl_expr, sctx, loc, varExpr, initExpr);
+  CREATE_AND_RETURN_EXPR(var_decl_expr, sctx, udf, loc, varExpr, initExpr);
 }
 
 
 var_set_expr* ExprManager::create_var_set_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     var_expr* varExpr,
     expr* setExpr)
 {
-  CREATE_AND_RETURN_EXPR(var_set_expr, sctx, loc, varExpr, setExpr);
+  CREATE_AND_RETURN_EXPR(var_set_expr, sctx, udf, loc, varExpr, setExpr);
 }
 
 
 exit_expr* ExprManager::create_exit_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* inExpr)
 {
-  CREATE_AND_RETURN_EXPR(exit_expr, sctx, loc, inExpr);
+  CREATE_AND_RETURN_EXPR(exit_expr, sctx, udf, loc, inExpr);
 }
 
 
 exit_catcher_expr* ExprManager::create_exit_catcher_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* inExpr,
     std::vector<expr*>& exitExprs)
 {
-  CREATE_AND_RETURN_EXPR(exit_catcher_expr, sctx, loc, inExpr, exitExprs);
+  CREATE_AND_RETURN_EXPR(exit_catcher_expr, sctx, udf, loc, inExpr, exitExprs);
 }
 
 
 flowctl_expr* ExprManager::create_flowctl_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     flowctl_expr::action action)
 {
-  CREATE_AND_RETURN_EXPR(flowctl_expr, sctx, loc, action);
+  CREATE_AND_RETURN_EXPR(flowctl_expr, sctx, udf, loc, action);
 }
 
 
 while_expr* ExprManager::create_while_expr(
-      static_context* sctx, const QueryLoc& loc, expr* body)
+    static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc,
+    expr* body)
 {
-  CREATE_AND_RETURN_EXPR(while_expr, sctx, loc, body);
+  CREATE_AND_RETURN_EXPR(while_expr, sctx, udf, loc, body);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 relpath_expr* ExprManager::create_relpath_expr(
-     static_context* sctx,
-     const QueryLoc& loc)
+    static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc)
 {
-  CREATE_AND_RETURN_EXPR(relpath_expr, sctx, loc);
+  CREATE_AND_RETURN_EXPR(relpath_expr, sctx, udf, loc);
 }
 
 
 axis_step_expr* ExprManager::create_axis_step_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc)
 {
-  CREATE_AND_RETURN_EXPR(axis_step_expr, sctx, loc);
+  CREATE_AND_RETURN_EXPR(axis_step_expr, sctx, udf, loc);
 }
 
 
 match_expr* ExprManager::create_match_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc)
 {
-  CREATE_AND_RETURN_EXPR(match_expr, sctx, loc);
+  CREATE_AND_RETURN_EXPR(match_expr, sctx, udf, loc);
 }
 
 
@@ -776,92 +779,105 @@
 dynamic_function_invocation_expr*
 ExprManager::create_dynamic_function_invocation_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     expr* anExpr,
     const std::vector<expr*>& args)
 {
-  CREATE_AND_RETURN_EXPR(dynamic_function_invocation_expr, sctx, loc, anExpr, args);
+  CREATE_AND_RETURN_EXPR(dynamic_function_invocation_expr, sctx, udf, loc, anExpr, args);
 }
 
 
 function_item_expr* ExprManager::create_function_item_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const store::Item* aQName,
     function* f,
     uint32_t aArity)
 {
-  CREATE_AND_RETURN_EXPR(function_item_expr, sctx, loc, aQName, f, aArity);
+  CREATE_AND_RETURN_EXPR(function_item_expr, sctx, udf, loc, aQName, f, aArity);
 }
 
 
 function_item_expr* ExprManager::create_function_item_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc)
 {
-  CREATE_AND_RETURN_EXPR(function_item_expr, sctx, loc);
+  CREATE_AND_RETURN_EXPR(function_item_expr, sctx, udf, loc);
 }
 
 
 ftcontains_expr* ExprManager::create_ftcontains_expr(
     static_context* sctx,
+    user_function* udf,
     QueryLoc const& loc,
     expr* range,
     ftnode *ftselection,
     expr* ftignore)
 {
-  CREATE_AND_RETURN_EXPR(ftcontains_expr, sctx, loc, range, ftselection, ftignore);
+  CREATE_AND_RETURN_EXPR(ftcontains_expr, sctx, udf, loc, range, ftselection, ftignore);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 //this calls the static create_seq within fo_expr
-fo_expr* ExprManager::create_seq(static_context* sctx, const QueryLoc& loc)
+fo_expr* ExprManager::create_seq(
+    static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc)
 {
   //TODO make fo_expr use this factory to generate everything
-  return fo_expr::create_seq(theCCB, sctx, loc);
+  return fo_expr::create_seq(theCCB, sctx, udf, loc);
 }
 
 
 fo_expr* ExprManager::create_fo_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f,
     expr* arg)
 {
-  CREATE_AND_RETURN_EXPR(fo_expr, sctx, loc, f, arg);
+  CREATE_AND_RETURN_EXPR(fo_expr, sctx, udf, loc, f, arg);
 }
 
 
 fo_expr* ExprManager::create_fo_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f,
     expr* arg1,
     expr* arg2)
 {
-  CREATE_AND_RETURN_EXPR(fo_expr, sctx, loc, f, arg1, arg2);
+  CREATE_AND_RETURN_EXPR(fo_expr, sctx, udf, loc, f, arg1, arg2);
 }
 
 
 fo_expr* ExprManager::create_fo_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f,
     const std::vector<expr*>& args)
 {
-  CREATE_AND_RETURN_EXPR(fo_expr, sctx, loc, f, args);
+  CREATE_AND_RETURN_EXPR(fo_expr, sctx, udf, loc, f, args);
 }
 
+
 fo_expr* ExprManager::create_fo_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f)
 {
 
-  CREATE_AND_RETURN_EXPR(fo_expr, sctx, loc, f);
+  CREATE_AND_RETURN_EXPR(fo_expr, sctx, udf, loc, f);
 }
+
 ////////////////////////////////////////////////////////////////////////////////
 
 for_clause* ExprManager::create_for_clause(
@@ -877,6 +893,7 @@
           sctx, theCCB, loc, varExpr, domainExpr, posVarExpr, scoreVarExpr, isOuter);
 }
 
+
 let_clause* ExprManager::create_let_clause(
     static_context* sctx,
     const QueryLoc& loc,
@@ -887,6 +904,7 @@
   CREATE_AND_RETURN(let_clause, sctx, theCCB, loc, varExpr, domainExpr, lazy);
 }
 
+
 window_clause* ExprManager::create_window_clause(
     static_context* sctx,
     const QueryLoc& loc,
@@ -901,16 +919,18 @@
           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* cond)
+    static_context* sctx,
+    bool isOnly,
+    const flwor_wincond::vars& in_vars,
+    const flwor_wincond::vars& out_vars,
+    expr* 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,
@@ -921,40 +941,54 @@
   CREATE_AND_RETURN(group_clause, sctx, theCCB,  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*>& orderingExprs)
+    static_context* sctx,
+    const QueryLoc& loc,
+    bool stable,
+    const std::vector<OrderModifier>& modifiers,
+    const std::vector<expr*>& orderingExprs)
 {
   CREATE_AND_RETURN(orderby_clause, sctx, theCCB, loc, stable, modifiers, orderingExprs);
 }
 
+
 materialize_clause* ExprManager::create_materialize_clause(
-      static_context* sctx, const QueryLoc& loc)
+    static_context* sctx,
+    const QueryLoc& loc)
 {
   CREATE_AND_RETURN(materialize_clause, sctx, theCCB, loc);
 }
 
+
 count_clause* ExprManager::create_count_clause(
-      static_context* sctx, const QueryLoc& loc, var_expr* var)
+    static_context* sctx,
+    const QueryLoc& loc,
+    var_expr* var)
 {
   CREATE_AND_RETURN(count_clause, sctx, theCCB, loc, var);
 }
 
+
 where_clause* ExprManager::create_where_clause(
-      static_context* sctx, const QueryLoc& loc, expr* where)
+    static_context* sctx,
+    const QueryLoc& loc,
+    expr* where)
 {
   CREATE_AND_RETURN(where_clause, sctx, theCCB, loc, where);
 }
 
+
 flwor_expr* ExprManager::create_flwor_expr(
-      static_context* sctx, const QueryLoc& loc, bool general)
+    static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc,
+    bool general)
 {
-  CREATE_AND_RETURN_EXPR(flwor_expr, sctx, loc, general);
+  CREATE_AND_RETURN_EXPR(flwor_expr, sctx, udf, loc, general);
 }
 
+
 pragma* ExprManager::create_pragma(
     const store::Item_t& name,
     const zstring& lit)
 
=== modified file 'src/compiler/expression/expr_manager.h'
--- src/compiler/expression/expr_manager.h	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/expr_manager.h	2012-10-09 13:35:26 +0000
@@ -31,6 +31,7 @@
 
 class CompilerCB;
 
+
 class ExprManager
 {
 private:
@@ -75,6 +76,7 @@
 public:
   if_expr* create_if_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* cond_expr,
       expr* then_expr,
@@ -82,12 +84,14 @@
 
   order_expr* create_order_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       order_expr::order_type_t,
       expr*);
 
   validate_expr* create_validate_expr(
       static_context*,
+      user_function* udf,
       const QueryLoc&,
       ParseConstants::validation_mode_t,
       const store::Item_t& aTypeName,
@@ -96,12 +100,14 @@
 
   cast_expr* create_cast_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*,
       xqtref_t);
 
   treat_expr* create_treat_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* input,
       const xqtref_t& type,
@@ -112,6 +118,7 @@
 
   promote_expr* create_promote_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* input,
       const xqtref_t& type,
@@ -120,12 +127,14 @@
 
   castable_expr* create_castable_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*,
       xqtref_t);
 
   instanceof_expr* create_instanceof_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*,
       xqtref_t,
@@ -133,6 +142,7 @@
 
   name_cast_expr* create_name_cast_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*,
       const namespace_context*,
@@ -140,12 +150,14 @@
 
   doc_expr* create_doc_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr* content,
       bool copyNodes);
 
   elem_expr* create_elem_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr* qnameExpr,
       expr* attrs,
@@ -155,6 +167,7 @@
 
   elem_expr* create_elem_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr* qnameExpr,
       expr* content,
@@ -163,64 +176,76 @@
 
   attr_expr* create_attr_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* aQNameExpr,
       expr* aValueExpr);
 
   text_expr* create_text_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       text_expr::text_constructor_type,
       expr*);
 
   pi_expr* create_pi_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*,
       expr*);
 
   const_expr* create_const_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       zstring& sval);
 
   const_expr* create_const_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       const std::string& sval);
 
   const_expr* create_const_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       const char* sval);
 
   const_expr* create_const_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       xs_integer);
 
   const_expr* create_const_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       xs_decimal);
 
   const_expr* create_const_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       xs_double);
 
   const_expr* create_const_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       xs_boolean);
 
   const_expr* create_const_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       store::Item_t);
 
   const_expr* create_const_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       const char* ns,
       const char* pre,
@@ -228,10 +253,12 @@
 
   extension_expr* create_extension_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&);
 
   extension_expr* create_extension_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*);
 
@@ -239,23 +266,31 @@
 
   trycatch_expr* create_trycatch_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr* tryExpr);
 
   wrapper_expr* create_wrapper_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* wrapped);
 
+#if 0
   function_trace_expr* create_function_trace_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* aChild);
+#endif
 
-  function_trace_expr* create_function_trace_expr(expr* aExpr);
+  function_trace_expr* create_function_trace_expr(
+      user_function* udf,
+      expr* aExpr);
 
   eval_expr* create_eval_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* e,
       expr_script_kind_t scriptingKind,
@@ -264,6 +299,7 @@
 #ifdef ZORBA_WITH_DEBUGGER
   debugger_expr* create_debugger_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* aChild,
       namespace_context* nsCtx,
@@ -274,11 +310,12 @@
 
   var_expr* create_var_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       var_expr::var_kind k,
       store::Item* name);
 
-  var_expr* create_var_expr(const var_expr& source);
+  var_expr* create_var_expr(user_function* udf, const var_expr& source);
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -286,17 +323,20 @@
 
   json_array_expr* create_json_array_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* content);
 
   json_object_expr* create_json_object_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* content,
       bool accumulate);
 
   json_direct_object_expr* create_json_direct_object_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       std::vector<expr*>& names,
       std::vector<expr*>& values);
@@ -307,6 +347,7 @@
 
   insert_expr* create_insert_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       store::UpdateConsts::InsertType,
       expr* aSourceExpr,
@@ -314,11 +355,13 @@
 
   delete_expr* create_delete_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*);
 
   replace_expr* create_replace_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       store::UpdateConsts::ReplaceType aType,
       expr*,
@@ -326,6 +369,7 @@
 
   rename_expr* create_rename_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc&,
       expr*,
       expr*);
@@ -334,10 +378,12 @@
 
   transform_expr* create_transform_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc);
 
   block_expr* create_block_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       bool allowLastUpdating,
       std::vector<expr*>& seq,
@@ -345,61 +391,79 @@
 
   apply_expr* create_apply_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* inExpr,
       bool discardXDM);
 
   var_decl_expr* create_var_decl_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       var_expr* varExpr,
       expr* initExpr);
 
   var_set_expr* create_var_set_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       var_expr* varExpr,
       expr* setExpr);
 
   exit_expr* create_exit_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* inExpr);
 
   exit_catcher_expr* create_exit_catcher_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* inExpr,
       std::vector<expr*>& exitExprs);
 
   flowctl_expr* create_flowctl_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       flowctl_expr::action action);
 
   while_expr* create_while_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* 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&);
+  relpath_expr* create_relpath_expr(
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc& loc);
+
+  axis_step_expr* create_axis_step_expr(
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&);
+
+  match_expr* create_match_expr(
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&);
 
 ////////////////////////////////////////////////////////////////////////////////
 
   dynamic_function_invocation_expr* create_dynamic_function_invocation_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* anExpr,
       const std::vector<expr*>& args);
 
   function_item_expr* create_function_item_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       const store::Item* aQName,
       function* f,
@@ -407,10 +471,12 @@
 
   function_item_expr* create_function_item_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc);
 
   ftcontains_expr* create_ftcontains_expr(
       static_context*,
+      user_function* udf,
       QueryLoc const&,
       expr* range,
       ftnode *ftselection,
@@ -419,16 +485,21 @@
 ////////////////////////////////////////////////////////////////////////////////
 
   //this calls the static create_seq within fo_expr
-  fo_expr* create_seq(static_context* sctx, const QueryLoc &);
+  fo_expr* create_seq(
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc &);
 
   fo_expr* create_fo_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       const function* f,
       expr* arg);
 
   fo_expr* create_fo_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       const function* f,
       expr* arg1,
@@ -436,12 +507,14 @@
 
   fo_expr* create_fo_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       const function* f,
       const std::vector<expr*>& args);
 
   fo_expr* create_fo_expr(
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f);
 
@@ -510,6 +583,7 @@
 
   flwor_expr* create_flwor_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       bool general);
  
@@ -524,17 +598,20 @@
 
 json_array_expr* create_json_array_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* content);
 
 json_object_expr* create_json_object_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       expr* content,
       bool accumulate);
 
 json_direct_object_expr* create_json_direct_object_expr(
       static_context* sctx,
+      user_function* udf,
       const QueryLoc& loc,
       std::vector<expr*>& names,
       std::vector<expr*>& values);
 
=== modified file 'src/compiler/expression/flwor_expr.cpp'
--- src/compiler/expression/flwor_expr.cpp	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/flwor_expr.cpp	2012-10-09 13:35:26 +0000
@@ -107,6 +107,7 @@
       {
         theDomainExpr = theCCB->theEM->
         create_treat_expr(theDomainExpr->get_sctx(),
+                          theDomainExpr->get_udf(),
                           theDomainExpr->get_loc(),
                           theDomainExpr,
                           varType,
@@ -173,11 +174,13 @@
                          *declaredType));
           }
 
-          domainExpr = theCCB->theEM->create_treat_expr(sctx,
-                                            loc,
-                                            domainExpr,
-                                            declaredType,
-                                            TreatIterator::TYPE_MATCH);
+          domainExpr = theCCB->theEM->
+          create_treat_expr(sctx,
+                            domainExpr->get_udf(),
+                            loc,
+                            domainExpr,
+                            declaredType,
+                            TreatIterator::TYPE_MATCH);
 
           set_expr(domainExpr);
         }
@@ -225,18 +228,18 @@
 }
 
 
-flwor_clause* for_clause::clone(expr::substitution_t& subst) const
+flwor_clause* for_clause::clone(user_function* udf, expr::substitution_t& subst) const
 {
-  expr* domainCopy = theDomainExpr->clone(subst);
+  expr* domainCopy = theDomainExpr->clone(udf, subst);
 
-  var_expr* varCopy = theCCB->theEM->create_var_expr(*theVarExpr);
+  var_expr* varCopy = theCCB->theEM->create_var_expr(udf, *theVarExpr);
   subst[theVarExpr] = varCopy;
 
   var_expr* posvarCopy = NULL;
   var_expr* pos_var_ptr = thePosVarExpr;
   if (pos_var_ptr)
   {
-    posvarCopy = theCCB->theEM->create_var_expr(*pos_var_ptr);
+    posvarCopy = theCCB->theEM->create_var_expr(udf, *pos_var_ptr);
     subst[pos_var_ptr] = posvarCopy;
   }
 
@@ -244,17 +247,17 @@
   var_expr* score_var_ptr = theScoreVarExpr;
   if (score_var_ptr)
   {
-    scorevarCopy = theCCB->theEM->create_var_expr(*score_var_ptr);
+    scorevarCopy = theCCB->theEM->create_var_expr(udf, *score_var_ptr);
     subst[score_var_ptr] = scorevarCopy;
   }
 
   return theCCB->theEM->create_for_clause(theContext,
-                        get_loc(),
-                        varCopy,
-                        domainCopy,
-                        posvarCopy,
-                        scorevarCopy,
-                        theAllowingEmpty);
+                                          get_loc(),
+                                          varCopy,
+                                          domainCopy,
+                                          posvarCopy,
+                                          scorevarCopy,
+                                          theAllowingEmpty);
 }
 
 
@@ -298,11 +301,13 @@
           ERROR_PARAMS(ZED(BadType_23o), *domainType, ZED(NoTreatAs_4), *declaredType));
         }
 
-        domainExpr = theCCB->theEM->create_treat_expr(sctx,
-                                    loc,
-                                    domainExpr,
-                                    declaredType,
-                                    TreatIterator::TYPE_MATCH);
+        domainExpr = theCCB->theEM->
+        create_treat_expr(sctx,
+                          domainExpr->get_udf(),
+                          loc,
+                          domainExpr,
+                          declaredType,
+                          TreatIterator::TYPE_MATCH);
 
         set_expr(domainExpr);
       }
@@ -332,11 +337,11 @@
 }
 
 
-flwor_clause* let_clause::clone(expr::substitution_t& subst) const
+flwor_clause* let_clause::clone(user_function* udf, expr::substitution_t& subst) const
 {
-  expr* domainCopy = theDomainExpr->clone(subst);
+  expr* domainCopy = theDomainExpr->clone(udf, subst);
 
-  var_expr* varCopy = theCCB->theEM->create_var_expr(*theVarExpr);
+  var_expr* varCopy = theCCB->theEM->create_var_expr(udf, *theVarExpr);
   subst[theVarExpr] = varCopy;
 
 #if 0
@@ -350,10 +355,10 @@
 #endif
 
   return theCCB->theEM->create_let_clause(theContext,
-                        get_loc(),
-                        varCopy,
-                        domainCopy,
-                        theLazyEval);
+                                          get_loc(),
+                                          varCopy,
+                                          domainCopy,
+                                          theLazyEval);
 }
 
 
@@ -403,6 +408,7 @@
       {
         domainExpr = theCCB->theEM->
         create_treat_expr(sctx,
+                          domainExpr->get_udf(),
                           loc,
                           domainExpr,
                           varType,
@@ -441,21 +447,23 @@
 }
 
 
-flwor_clause* window_clause::clone(expr::substitution_t& subst) const
+flwor_clause* window_clause::clone(
+    user_function* udf,
+    expr::substitution_t& subst) const
 {
-  expr* domainCopy = theDomainExpr->clone(subst);
+  expr* domainCopy = theDomainExpr->clone(udf, subst);
 
-  var_expr* varCopy = theCCB->theEM->create_var_expr(*theVarExpr);
+  var_expr* varCopy = theCCB->theEM->create_var_expr(udf, *theVarExpr);
   subst[theVarExpr] = varCopy;
 
   flwor_wincond* cloneStartCond = NULL;
   flwor_wincond* cloneStopCond = NULL;
 
   if (theWinStartCond != NULL)
-    cloneStartCond = theWinStartCond->clone(subst);
+    cloneStartCond = theWinStartCond->clone(udf, subst);
 
   if (theWinStopCond != NULL)
-    cloneStopCond = theWinStopCond->clone(subst);
+    cloneStopCond = theWinStopCond->clone(udf, subst);
 
   return theCCB->theEM->create_window_clause(theContext,
                                              get_loc(),
@@ -493,15 +501,17 @@
 
     xqtref_t condType = theCondExpr->get_return_type();
 
-    if(!TypeOps::is_equal(tm,
+    if (!TypeOps::is_equal(tm,
                           *condType,
                           *GENV_TYPESYSTEM.BOOLEAN_TYPE_ONE,
                           theCondExpr->get_loc()))
     {
-      theCondExpr = theCCB->theEM->create_fo_expr(theCondExpr->get_sctx(),
-                                theCondExpr->get_loc(),
-                                GET_BUILTIN_FUNCTION(FN_BOOLEAN_1),
-                                theCondExpr);
+      theCondExpr = theCCB->theEM->
+      create_fo_expr(theCondExpr->get_sctx(),
+                     theCondExpr->get_udf(),
+                     theCondExpr->get_loc(),
+                     GET_BUILTIN_FUNCTION(FN_BOOLEAN_1),
+                     theCondExpr);
     }
   }
 }
@@ -514,14 +524,15 @@
 
 
 flwor_wincond::vars::vars()
-:
-posvar(NULL),
-curr(NULL),
-prev(NULL),
-next(NULL)
+  :
+  posvar(NULL),
+  curr(NULL),
+  prev(NULL),
+  next(NULL)
 {
 }
 
+
 flwor_wincond::vars::~vars()
 {
 //  set_flwor_clause(NULL);
@@ -539,33 +550,34 @@
 
 void flwor_wincond::vars::clone(
     ExprManager* mgr,
+    user_function* udf,
     flwor_wincond::vars& cloneVars,
     expr::substitution_t& subst) const
 {
   if (posvar != NULL)
   {
-    var_expr* varCopy = mgr->create_var_expr(*posvar);
+    var_expr* varCopy = mgr->create_var_expr(udf, *posvar);
     subst[posvar] = varCopy;
     cloneVars.posvar = varCopy;
   }
 
   if (curr != NULL)
   {
-    var_expr* varCopy = mgr->create_var_expr(*curr);
+    var_expr* varCopy = mgr->create_var_expr(udf, *curr);
     subst[curr] = varCopy;
     cloneVars.curr = varCopy;
   }
 
   if (prev != NULL)
   {
-    var_expr* varCopy = mgr->create_var_expr(*prev);
+    var_expr* varCopy = mgr->create_var_expr(udf, *prev);
     subst[prev] = varCopy;
     cloneVars.prev = varCopy;
   }
 
   if (next != NULL)
   {
-    var_expr* varCopy = mgr->create_var_expr(*next);
+    var_expr* varCopy = mgr->create_var_expr(udf, *next);
     subst[next] = varCopy;
     cloneVars.next = varCopy;
   }
@@ -579,21 +591,23 @@
 }
 
 
-flwor_wincond* flwor_wincond::clone(expr::substitution_t& subst) const
+flwor_wincond* flwor_wincond::clone(
+    user_function* udf,
+    expr::substitution_t& subst) const
 {
   flwor_wincond::vars cloneInVars;
   flwor_wincond::vars cloneOutVars;
 
-  theInputVars.clone(theCCB->theEM, cloneInVars, subst);
-  theOutputVars.clone(theCCB->theEM, cloneOutVars, subst);
+  theInputVars.clone(theCCB->theEM, udf, cloneInVars, subst);
+  theOutputVars.clone(theCCB->theEM, udf, cloneOutVars, subst);
 
-  expr* cloneCondExpr = theCondExpr->clone(subst);
+  expr* cloneCondExpr = theCondExpr->clone(udf, subst);
 
   return theCCB->theEM->create_flwor_wincond(NULL,
-                           theIsOnly,
-                           cloneInVars,
-                           cloneOutVars,
-                           cloneCondExpr);
+                                             theIsOnly,
+                                             cloneInVars,
+                                             cloneOutVars,
+                                             cloneCondExpr);
 }
 
 
@@ -663,7 +677,9 @@
 }
 
 
-flwor_clause* group_clause::clone(expr::substitution_t& subst) const
+flwor_clause* group_clause::clone(
+    user_function* udf,
+    expr::substitution_t& subst) const
 {
   csize numGroupVars = theGroupVars.size();
   csize numNonGroupVars = theNonGroupVars.size();
@@ -680,23 +696,29 @@
 
   for (csize i = 0; i < numGroupVars; ++i)
   {
-    cloneGroupVars[i].first = theGroupVars[i].first->clone(subst);
-    cloneGroupVars[i].second = exprMgr->create_var_expr(*theGroupVars[i].second);
+    cloneGroupVars[i].first = theGroupVars[i].first->clone(udf, subst);
+
+    cloneGroupVars[i].second = exprMgr->
+    create_var_expr(udf, *theGroupVars[i].second);
+
     subst[theGroupVars[i].second] = cloneGroupVars[i].second;
   }
 
   for (csize i = 0; i < numNonGroupVars; ++i)
   {
-    cloneNonGroupVars[i].first = theNonGroupVars[i].first->clone(subst);
-    cloneNonGroupVars[i].second = exprMgr->create_var_expr(*theNonGroupVars[i].second);
+    cloneNonGroupVars[i].first = theNonGroupVars[i].first->clone(udf, subst);
+
+    cloneNonGroupVars[i].second = exprMgr->
+    create_var_expr(udf, *theNonGroupVars[i].second);
+
     subst[theNonGroupVars[i].second] = cloneNonGroupVars[i].second;
   }
 
   return theCCB->theEM->create_group_clause(theContext,
-                          get_loc(),
-                          cloneGroupVars,
-                          cloneNonGroupVars,
-                          theCollations);
+                                            get_loc(),
+                                            cloneGroupVars,
+                                            cloneNonGroupVars,
+                                            theCollations);
 }
 
 
@@ -726,7 +748,9 @@
 }
 
 
-flwor_clause* orderby_clause::clone(expr::substitution_t& subst) const
+flwor_clause* orderby_clause::clone(
+    user_function* udf,
+    expr::substitution_t& subst) const
 {
   csize numColumns = num_columns();
 
@@ -734,14 +758,14 @@
 
   for (csize i = 0; i < numColumns; ++i)
   {
-    cloneExprs[i] = theOrderingExprs[i]->clone(subst);
+    cloneExprs[i] = theOrderingExprs[i]->clone(udf, subst);
   }
 
   return theCCB->theEM->create_orderby_clause(theContext,
-                            get_loc(),
-                            theStableOrder,
-                            theModifiers,
-                            cloneExprs);
+                                              get_loc(),
+                                              theStableOrder,
+                                              theModifiers,
+                                              cloneExprs);
 }
 
 
@@ -758,7 +782,9 @@
 }
 
 
-flwor_clause* materialize_clause::clone(expr::substitution_t& subst) const
+flwor_clause* materialize_clause::clone(
+    user_function* udf,
+    expr::substitution_t& subst) const
 {
   // we will reach here under the following scenario:
   // 1. We do plan seriazation
@@ -792,11 +818,13 @@
 }
 
 
-flwor_clause* count_clause::clone(expr::substitution_t& subst) const
+flwor_clause* count_clause::clone(
+    user_function* udf,
+    expr::substitution_t& subst) const
 {
   ExprManager* exprMgr = theVarExpr->get_ccb()->theEM;
 
-  var_expr* cloneVar = exprMgr->create_var_expr(*theVarExpr);
+  var_expr* cloneVar = exprMgr->create_var_expr(udf, *theVarExpr);
   subst[theVarExpr] = cloneVar;
 
   return theCCB->theEM->create_count_clause(theContext, get_loc(), cloneVar);
@@ -825,9 +853,11 @@
 }
 
 
-flwor_clause* where_clause::clone(expr::substitution_t& subst) const
+flwor_clause* where_clause::clone(
+    user_function* udf,
+    expr::substitution_t& subst) const
 {
-  expr* cloneExpr = theWhereExpr->clone(subst);
+  expr* cloneExpr = theWhereExpr->clone(udf, subst);
 
   return theCCB->theEM->create_where_clause(theContext, get_loc(), cloneExpr);
 }
@@ -839,10 +869,11 @@
 flwor_expr::flwor_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     bool general)
   :
-  expr(ccb, sctx, loc, (general ? gflwor_expr_kind : flwor_expr_kind)),
+  expr(ccb, sctx, udf, loc, (general ? gflwor_expr_kind : flwor_expr_kind)),
   theIsGeneral(general),
   theHasSequentialClauses(false),
   theReturnExpr(NULL)
@@ -1167,27 +1198,5 @@
 }
 
 
-/*******************************************************************************
-
-********************************************************************************/
-expr* flwor_expr::cloneImpl(substitution_t& subst) const
-{
-  ulong numClauses = num_clauses();
-
-  flwor_expr* cloneFlwor = theCCB->theEM->create_flwor_expr(theSctx, get_loc(), theIsGeneral);
-
-  for (ulong i = 0; i < numClauses; ++i)
-  {
-    flwor_clause* cloneClause = theClauses[i]->clone(subst);
-
-    cloneFlwor->add_clause(cloneClause, false);
-  }
-
-  cloneFlwor->set_return_expr(theReturnExpr->clone(subst));
-
-  return cloneFlwor;
-}
-
-
 } // namespace zorba
 /* vim:set et sw=2 ts=2: */
 
=== modified file 'src/compiler/expression/flwor_expr.h'
--- src/compiler/expression/flwor_expr.h	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/flwor_expr.h	2012-10-09 13:35:26 +0000
@@ -105,7 +105,9 @@
 
   virtual var_expr* get_score_var() const { return NULL; }
 
-  virtual flwor_clause* clone(expr::substitution_t& substitution) const = 0;
+  virtual flwor_clause* clone(
+      user_function* udf,
+      expr::substitution_t& substitution) const = 0;
 };
 
 
@@ -207,7 +209,7 @@
 
   void set_score_var(var_expr* v);
 
-  flwor_clause* clone(expr::substitution_t& substitution) const;
+  flwor_clause* clone(user_function* udf, expr::substitution_t& substitution) const;
 
   std::ostream& put(std::ostream&) const;
 };
@@ -247,7 +249,7 @@
 
   bool lazyEval() const { return theLazyEval; }
 
-  flwor_clause* clone(expr::substitution_t& substitution) const;
+  flwor_clause* clone(user_function* udf, expr::substitution_t& substitution) const;
 
   std::ostream& put(std::ostream&) const;
 };
@@ -303,7 +305,7 @@
 
   bool lazyEval() const { return theLazyEval; }
 
-  flwor_clause* clone(expr::substitution_t& substitution) const;
+  flwor_clause* clone(user_function* udf, expr::substitution_t& substitution) const;
 
   std::ostream& put(std::ostream&) const;
 };
@@ -354,10 +356,16 @@
     var_expr* next;
 
     vars();
+
     ~vars();
+
     void set_flwor_clause(flwor_clause* c);
 
-    void clone(ExprManager* mgr, vars& cloneVars, expr::substitution_t& subst) const;
+    void clone(
+      ExprManager* mgr,
+      user_function* udf,
+      vars& cloneVars,
+      expr::substitution_t& subst) const;
 
     std::ostream& put(std::ostream&) const;
   };
@@ -394,7 +402,7 @@
 
   void set_flwor_clause(flwor_clause *);
 
-  flwor_wincond* clone(expr::substitution_t& substitution) const;
+  flwor_wincond* clone(user_function* udf, expr::substitution_t& substitution) const;
 
   std::ostream& put(std::ostream&) const;
 };
@@ -484,7 +492,7 @@
 
   expr* get_input_for_nongroup_var(const var_expr* var);
 
-  flwor_clause* clone(expr::substitution_t& substitution) const;
+  flwor_clause* clone(user_function* udf, expr::substitution_t& substitution) const;
 
   std::ostream& put(std::ostream&) const;
 };
@@ -552,7 +560,7 @@
 
   void set_column_expr(csize i, expr* e) { theOrderingExprs[i] = e; }
 
-  flwor_clause* clone(expr::substitution_t& substitution) const;
+  flwor_clause* clone(user_function* udf, expr::substitution_t& substitution) const;
 
   std::ostream& put(std::ostream&) const;
 };
@@ -572,7 +580,7 @@
   materialize_clause(static_context* sctx, CompilerCB* ccb, const QueryLoc& loc);
 
 public:
-  flwor_clause* clone(expr::substitution_t& substitution) const;
+  flwor_clause* clone(user_function* udf, expr::substitution_t& substitution) const;
 
   std::ostream& put(std::ostream&) const;
 };
@@ -597,7 +605,7 @@
 
   var_expr* get_var() const { return theVarExpr; }
 
-  flwor_clause* clone(expr::substitution_t& substitution) const;
+  flwor_clause* clone(user_function* udf, expr::substitution_t& substitution) const;
 };
 
 
@@ -619,7 +627,7 @@
 
   void set_expr(expr* where);
 
-  flwor_clause* clone(expr::substitution_t& substitution) const;
+  flwor_clause* clone(user_function* udf, expr::substitution_t& substitution) const;
 };
 
 
@@ -665,7 +673,12 @@
   expr          * theReturnExpr;
 
 protected:
-  flwor_expr(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc, bool general);
+  flwor_expr(
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc& loc,
+      bool general);
 
 public:
   bool is_general() const { return theIsGeneral; }
@@ -704,8 +717,6 @@
 
   void get_vars_defined(std::vector<var_expr*>& varExprs) const;
 
-  expr* cloneImpl(substitution_t& substitution) const;
-
   // The following 5 methods are for the simple flwor only. They should be
   // removed eventually.
   expr* get_where() const;
 
=== modified file 'src/compiler/expression/fo_expr.cpp'
--- src/compiler/expression/fo_expr.cpp	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/fo_expr.cpp	2012-10-09 13:35:26 +0000
@@ -55,11 +55,15 @@
   UnionExpr, and IntersectExceptExpr.
 ********************************************************************************/
 
-fo_expr* fo_expr::create_seq(CompilerCB* ccb, static_context* sctx, const QueryLoc& loc)
+fo_expr* fo_expr::create_seq(
+    CompilerCB* ccb,
+    static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc)
 {
   function* f = BuiltinFunctionLibrary::getFunction(FunctionConsts::OP_CONCATENATE_N);
 
-  std::auto_ptr<fo_expr> fo(ccb->theEM->create_fo_expr(sctx, loc, f));
+  std::auto_ptr<fo_expr> fo(ccb->theEM->create_fo_expr(sctx, udf, loc, f));
 
   return fo.release();
 }
@@ -68,10 +72,11 @@
 fo_expr::fo_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f)
   :
-  expr(ccb, sctx, loc, fo_expr_kind),
+  expr(ccb, sctx, udf, loc, fo_expr_kind),
   theFunction(const_cast<function*>(f))
 {
   // This method is private and it is to be used only by the clone method
@@ -83,11 +88,12 @@
 fo_expr::fo_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f,
     expr* arg)
   :
-  expr(ccb, sctx, loc, fo_expr_kind),
+  expr(ccb, sctx, udf, loc, fo_expr_kind),
   theFunction(const_cast<function*>(f))
 {
   assert(f != NULL);
@@ -101,12 +107,13 @@
 fo_expr::fo_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f,
     expr* arg1,
     expr* arg2)
   :
-  expr(ccb, sctx, loc, fo_expr_kind),
+  expr(ccb, sctx, udf, loc, fo_expr_kind),
   theFunction(const_cast<function*>(f))
 {
   assert(f != NULL);
@@ -121,11 +128,12 @@
 fo_expr::fo_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f,
     const std::vector<expr*>& args)
   :
-  expr(ccb, sctx, loc, fo_expr_kind),
+  expr(ccb, sctx, udf, loc, fo_expr_kind),
   theArgs(args),
   theFunction(const_cast<function*>(f))
 {
@@ -273,29 +281,6 @@
 }
 
 
-expr* fo_expr::cloneImpl(substitution_t& subst) const
-{
-  if (get_func()->getKind() == FunctionConsts::STATIC_COLLECTIONS_DML_COLLECTION_1)
-  {
-    expr::subst_iter_t i = subst.find(this);
-
-    if (i != subst.end())
-      return i->second;
-  }
-
-  std::auto_ptr<fo_expr> fo(theCCB->theEM->create_fo_expr(theSctx,
-                                                          get_loc(),
-                                                          get_func()));
-
-  for (csize i = 0; i < theArgs.size(); ++i)
-    fo->theArgs.push_back(theArgs[i]->clone(subst));
-
-  fo->theScriptingKind  = theScriptingKind;
-
-  return fo.release();
-}
-
-
 }
 
 /* vim:set et sw=2 ts=2: */
 
=== modified file 'src/compiler/expression/fo_expr.h'
--- src/compiler/expression/fo_expr.h	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/fo_expr.h	2012-10-09 13:35:26 +0000
@@ -45,12 +45,24 @@
 public:
 
 protected:
-  static fo_expr* create_seq(CompilerCB* ccb, static_context* sctx, const QueryLoc&);
+  static fo_expr* create_seq(
+      CompilerCB* ccb,
+      static_context* sctx,
+      user_function* udf,
+      const QueryLoc&);
 
 protected:
   fo_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
+    const QueryLoc& loc,
+    const function* f);
+
+  fo_expr(
+    CompilerCB* ccb,
+    static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f,
     expr* arg);
@@ -58,6 +70,7 @@
   fo_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f,
     expr* arg1,
@@ -66,6 +79,7 @@
   fo_expr(
     CompilerCB* ccb,
     static_context* sctx,
+    user_function* udf,
     const QueryLoc& loc,
     const function* f,
     const std::vector<expr*>& args);
@@ -95,8 +109,6 @@
 
   void compute_scripting_kind();
 
-  expr* cloneImpl(substitution_t& s) const;
-
   void accept(expr_visitor&);
 
   std::ostream& put(std::ostream&) const;
 
=== modified file 'src/compiler/expression/ft_expr.cpp'
--- src/compiler/expression/ft_expr.cpp	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/ft_expr.cpp	2012-10-09 13:35:26 +0000
@@ -35,12 +35,13 @@
 ftcontains_expr::ftcontains_expr(
   CompilerCB* ccb,
   static_context* sctx,
+  user_function* udf,
   QueryLoc const &loc,
   expr* range,
   ftnode *ftselection,
   expr* ftignore
 ) :
-  expr(ccb, sctx, loc, ft_expr_kind ),
+  expr(ccb, sctx, udf, loc, ft_expr_kind ),
   range_( range ),
   ftselection_( ftselection ),
   ftignore_( ftignore )
@@ -50,6 +51,7 @@
   compute_scripting_kind();
 }
 
+
 void ftcontains_expr::accept( expr_visitor &v ) {
   if ( v.begin_visit( *this ) ) {
     EV_ACCEPT( range_, v );
@@ -59,16 +61,9 @@
   v.end_visit( *this );
 }
 
-expr* ftcontains_expr::cloneImpl( substitution_t &s ) const {
-  return theCCB->theEM->create_ftcontains_expr(
-    theSctx, get_loc(),
-    range_->clone( s ),
-    ftselection_->clone( s ).release(),
-    ftignore_ == NULL ? 0 : ftignore_->clone( s )
-  );
-}
 
-void ftcontains_expr::compute_scripting_kind() {
+void ftcontains_expr::compute_scripting_kind() 
+{
   checkSimpleExpr(range_);
 
   theScriptingKind = SIMPLE_EXPR;
 
=== modified file 'src/compiler/expression/ft_expr.h'
--- src/compiler/expression/ft_expr.h	2012-10-08 12:09:36 +0000
+++ src/compiler/expression/ft_expr.h	2012-10-09 13:35:26 +0000
@@ -29,6 +29,7 @@
  */
 class ftcontains_expr : public expr
 {
+  friend class expr;
   friend class ExprIterator;
   friend class ExprManager;
 
@@ -36,6 +37,7 @@
   ftcontains_expr(
     CompilerCB* ccb,
     static_context*,
+    user_function*,
     QueryLoc const&,
     expr* range,
     ftnode *ftselection,
@@ -43,8 +45,6 @@
   );
 
 public:
-  expr* cloneImpl( substitution_t& ) const;
-
   void compute_scripting_kind();
 
   expr* get_range() const { return range_; }
 
=== modified file 'src/compiler/expression/ftnode.cpp'
--- src/compiler/expression/ftnode.cpp	2012-09-19 21:16:15 +0000
+++ src/compiler/expression/ftnode.cpp	2012-10-09 13:35:26 +0000
@@ -171,37 +171,60 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 template<typename PointerType>
-inline PointerType clone_ptr( PointerType p, expr::substitution_t &s ) {
-  return static_cast<PointerType>( p->clone( s ).release() );
+inline PointerType clone_ptr(
+    PointerType p,
+    user_function* udf,
+    expr::substitution_t &s )
+{
+  return static_cast<PointerType>( p->clone( udf, s ).release() );
 }
 
+
 template<>
-inline expr* clone_ptr( expr* p, expr::substitution_t &s ) {
-  return static_cast<expr*>( p->clone( s ) );
+inline expr* clone_ptr( expr* p, user_function* udf, expr::substitution_t &s ) {
+  return static_cast<expr*>( p->clone(udf, s) );
 }
 
+
 template<class RCHandleValueType>
-inline RCHandleValueType* clone_ptr( rchandle<RCHandleValueType> const &p,
-                                     expr::substitution_t &s ) {
-  return static_cast<RCHandleValueType*>( p->clone( s ).release() );
+inline RCHandleValueType* clone_ptr( 
+    rchandle<RCHandleValueType> const &p,
+    user_function* udf,
+    expr::substitution_t &s )
+{
+  return static_cast<RCHandleValueType*>( p->clone(udf, s).release() );
 }
 
+
 template<typename PointerType>
-inline PointerType clone_ptr_if( PointerType p, expr::substitution_t &s ) {
-  return p ? clone_ptr( p, s ) : nullptr;
+inline PointerType clone_ptr_if(
+    PointerType p,
+    user_function* udf,
+    expr::substitution_t &s )
+{
+  return p ? clone_ptr( p, udf, s ) : nullptr;
 }
 
+
 template<class RCHandleValueType>
-inline RCHandleValueType* clone_ptr_if( rchandle<RCHandleValueType> const &p,
-                                        expr::substitution_t &s ) {
-  return p.isNull() ? nullptr : clone_ptr( p, s );
+inline RCHandleValueType* clone_ptr_if(
+    rchandle<RCHandleValueType> const &p,
+    user_function* udf,
+    expr::substitution_t &s )
+{
+  return p.isNull() ? nullptr : clone_ptr( p, udf, s );
 }
 
+
 template<class ContainerType>
-void clone_list( ContainerType const &from, ContainerType *to,
-                 expr::substitution_t &s ) {
+void clone_list(
+    ContainerType const &from,
+    ContainerType *to,
+    user_function* udf,
+    expr::substitution_t &s )
+{
   FOR_EACH( typename ContainerType, i, from )
-    to->push_back( clone_ptr( *i, s ) );
+    to->push_back( clone_ptr( *i, udf, s ) );
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -221,9 +244,9 @@
   END_VISIT( v );
 }
 
-ftnode_t ftand::clone( expr::substitution_t &s ) const {
+ftnode_t ftand::clone(user_function* udf, expr::substitution_t &s ) const {
   ftnode_list_t copy;
-  clone_list( get_node_list(), &copy, s );
+  clone_list( get_node_list(), &copy, udf, s );
   return new ftand( get_loc(), copy );
 }
 
@@ -251,7 +274,7 @@
   END_VISIT( v );
 }
 
-ftnode_t ftcase_option::clone( expr::substitution_t& ) const {
+ftnode_t ftcase_option::clone(user_function* udf, expr::substitution_t& ) const {
   return new ftcase_option( get_loc(), mode_ );
 }
 
@@ -279,7 +302,7 @@
   END_VISIT( v );
 }
 
-ftnode_t ftcontent_filter::clone( expr::substitution_t &s ) const {
+ftnode_t ftcontent_filter::clone(user_function* udf,  expr::substitution_t &s ) const {
   return new ftcontent_filter( get_loc(), mode_ );
 }
 
@@ -308,7 +331,7 @@
   END_VISIT( v );
 }
 
-ftnode_t ftdiacritics_option::clone( expr::substitution_t& ) const {
+ftnode_t ftdiacritics_option::clone(user_function* udf,  expr::substitution_t& ) const {
   return new ftdiacritics_option( get_loc(), mode_ );
 }
 
@@ -345,8 +368,8 @@
   END_VISIT( v );
 }
 
-ftnode_t ftdistance_filter::clone( expr::substitution_t &s ) const {
-  return new ftdistance_filter( get_loc(), clone_ptr_if( range_, s ), unit_ );
+ftnode_t ftdistance_filter::clone(user_function* udf,  expr::substitution_t &s ) const {
+  return new ftdistance_filter( get_loc(), clone_ptr_if( range_, udf, s ), unit_ );
 }
 
 ostream& ftdistance_filter::put( ostream &o ) const {
@@ -384,9 +407,9 @@
   END_VISIT( v );
 }
 
-ftnode_t ftextension_selection::clone( expr::substitution_t &s ) const {
+ftnode_t ftextension_selection::clone(user_function* udf,  expr::substitution_t &s ) const {
   return new ftextension_selection(
-    get_loc(), pragmas_, clone_ptr_if( ftselection_, s )
+             get_loc(), pragmas_, clone_ptr_if( ftselection_, udf, s )
   );
 }
 
@@ -418,7 +441,7 @@
   END_VISIT( v );
 }
 
-ftnode_t ftextension_option::clone( expr::substitution_t& ) const {