Merge lp:~zorba-coders/zorba/hof-next into lp:zorba

[Markos Zaharioudakis]

No copying of global variables in function item

No copying of global variables in function item

[lp:~zorba-coders/zorba/hof-next]

11349. By Markos Zaharioudakis on 2013-04-24

No copying of global variables in function item

11350. By Markos Zaharioudakis on 2013-04-24

merge from trunk

[Markos Zaharioudakis (markos-za)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/hof-next-2013-04-24T02-30-54.19Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job hof-next-2013-04-24T02-30-54.19Z is finished. The final status was:

All tests succeeded!

=== modified file 'src/compiler/codegen/plan_visitor.cpp'
--- src/compiler/codegen/plan_visitor.cpp	2013-04-16 20:06:08 +0000
+++ src/compiler/codegen/plan_visitor.cpp	2013-04-24 02:27:27 +0000
@@ -472,69 +472,31 @@
   fnInfo->theCCB = theCCB;
   fnInfo->theLoc = qloc;
 
+  csize numOuterVars = v.get_in_scope_vars().size();
+
+  for (csize i = 0; i < numOuterVars; ++i)
+  {      
+    fnInfo->theInScopeVarIterators.push_back(pop_itstack());
+  }
+  
+  std::reverse(fnInfo->theInScopeVarIterators.begin(),
+               fnInfo->theInScopeVarIterators.end());
+
+  
+  for (csize i = 0; i < numOuterVars; ++i)
   {
-    for (csize i = 0; i < v.get_subst_vars().size(); ++i)
-    {      
-      if (!v.get_is_global_var()[i])     
-        fnInfo->theScopedVarsIterators.push_back(pop_itstack());
-      else if (fnInfo->theScopedVarsValues[i] != NULL)
-        pop_itstack();
-    }
-
-    std::reverse(fnInfo->theScopedVarsIterators.begin(),
-                 fnInfo->theScopedVarsIterators.end());
-  }
-
-
-  // This portion is similar to the eval iterator
-  { 
-    csize curChild = -1;
-    csize numOuterVars = fnInfo->theScopedVarsNames.size();
-    for (csize i = 0; i < numOuterVars; ++i)
-    {
-      if (!fnInfo->theIsGlobalVar[i])
-      {
-        ++curChild;
-
-        if (fnInfo->theSubstVarsValues[i] != NULL &&
-            fnInfo->theSubstVarsValues[i]->get_unique_id() == 0)
-        {
-          fnInfo->theSubstVarsValues[i]->set_var_info(NULL);
-          fnInfo->theSubstVarsValues[i]->set_unique_id(theNextDynamicVarId++);
-        }
-
-        fnInfo->theVarId[i] = fnInfo->theSubstVarsValues[i]->get_unique_id();
-      }
-      else
-      {
-        static_context* outerSctx = fnInfo->theClosureSctx;
-
-        VarInfo* outerGlobalVar = outerSctx->lookup_var(fnInfo->theScopedVarsNames[i]);
-
-        ulong outerGlobalVarId = 0;
-
-        if (outerGlobalVar)
-        {
-          outerGlobalVarId = outerGlobalVar->getId();
-        }
-        else
-        {
-          for (csize j=0; j<fnInfo->theSubstVarsValues.size(); j++)
-          {
-            if (fnInfo->theSubstVarsValues[j]->get_name()->equals(fnInfo->theScopedVarsNames[i].getp()))
-              outerGlobalVarId = fnInfo->theSubstVarsValues[j]->get_unique_id();
-          }
-        }
-
-        if (fnInfo->theSubstVarsValues[i] != NULL &&
-            fnInfo->theSubstVarsValues[i]->get_unique_id() == 0)
-        {
-          fnInfo->theSubstVarsValues[i]->set_unique_id(outerGlobalVarId);
-        }
-
-        fnInfo->theVarId[i] = outerGlobalVarId;
-      }
-    } // for
+    fnInfo->theInScopeVars[i]->set_var_info(NULL);
+
+    if (fnInfo->theInScopeVars[i]->get_unique_id() != 0)
+    {
+      ZORBA_ASSERT(fnInfo->theInScopeVars[i]->get_unique_id() == i+1);
+    }
+    else
+    {
+      fnInfo->theInScopeVars[i]->set_unique_id(i+1);
+    }
+
+    fnInfo->theInScopeVarIds[i] = fnInfo->theInScopeVars[i]->get_unique_id();
   }
 
   push_itstack(new FunctionItemIterator(sctx, qloc, fnInfo));
@@ -929,7 +891,6 @@
   }
 
   case var_expr::prolog_var:
-  case var_expr::hof_var:
   {
     push_itstack(new CtxVarIterator(sctx,
                                     qloc,

=== modified file 'src/compiler/expression/expr_clone.cpp'
--- src/compiler/expression/expr_clone.cpp	2013-04-16 20:06:08 +0000
+++ src/compiler/expression/expr_clone.cpp	2013-04-24 02:27:27 +0000
@@ -375,6 +375,23 @@
   {
     const function_item_expr* e = static_cast<const function_item_expr*>(this);
 
+    csize numInScopeVars = e->theFunctionItemInfo->theInScopeVars.size();
+
+#if 0
+    std::vector<var_expr*> clonedInScopeVars(numInScopeVars);
+    
+    for (csize i = 0; i < numInScopeVars; ++i)
+    {
+      var_expr* var = e->theFunctionItemInfo->theInScopeVars[i];
+
+      clonedInScopeVars[i] = theCCB->theEM->create_var_expr(udf, var);
+
+      subst[var] = clonedVar;
+    }
+
+    user_function* fiudf = e->theFunctionItemInfo->theFunction;
+#endif
+
     function_item_expr* cloneExpr = theCCB->theEM->
     create_function_item_expr(theSctx,
                               udf,
@@ -384,25 +401,14 @@
                               e->is_inline(),
                               e->is_coercion());
 
-    std::vector<expr*>::const_iterator varIter = 
-    e->theFunctionItemInfo->theScopedVarsValues.begin();
-
-    std::vector<var_expr*>::const_iterator substVarIter = 
-    e->theFunctionItemInfo->theSubstVarsValues.begin();
-
-    std::vector<store::Item_t>::const_iterator nameIter = 
-    e->theFunctionItemInfo->theScopedVarsNames.begin();
-
-    std::vector<int>::const_iterator isGlobalIter =
-    e->theFunctionItemInfo->theIsGlobalVar.begin();
-
-    for (; varIter != e->theFunctionItemInfo->theScopedVarsValues.end();
-         ++varIter, ++substVarIter, ++nameIter, ++isGlobalIter)
+    for (csize i = 0; i < numInScopeVars; ++i)
     {
-      cloneExpr->add_variable((*varIter) ? (*varIter)->clone(udf, subst) : NULL,
-                              (*substVarIter) ? static_cast<var_expr*>((*substVarIter)->clone(udf, subst)) : NULL,
-                              *nameIter,
-                              *isGlobalIter);
+      var_expr* var = e->theFunctionItemInfo->theInScopeVars[i];
+
+      expr* clonedDomainExpr = 
+      e->theFunctionItemInfo->theInScopeVarValues[i]->clone(udf, subst);
+
+      cloneExpr->add_variable(clonedDomainExpr, var);
     }
 
     newExpr = cloneExpr;

=== modified file 'src/compiler/expression/expr_iter.cpp'
--- src/compiler/expression/expr_iter.cpp	2013-04-16 20:06:08 +0000
+++ src/compiler/expression/expr_iter.cpp	2013-04-24 02:27:27 +0000
@@ -704,8 +704,8 @@
 
     EXPR_ITER_BEGIN();
 
-    theArgsIter = fiExpr->theFunctionItemInfo->theScopedVarsValues.begin();
-    theArgsEnd = fiExpr->theFunctionItemInfo->theScopedVarsValues.end();
+    theArgsIter = fiExpr->theFunctionItemInfo->theInScopeVarValues.begin();
+    theArgsEnd = fiExpr->theFunctionItemInfo->theInScopeVarValues.end();
 
     for (; theArgsIter != theArgsEnd; ++theArgsIter)
     {

=== modified file 'src/compiler/expression/expr_put.cpp'
--- src/compiler/expression/expr_put.cpp	2013-04-16 20:06:08 +0000
+++ src/compiler/expression/expr_put.cpp	2013-04-24 02:27:27 +0000
@@ -185,7 +185,7 @@
     put_qname(get_name(), os);
   }
 
-  if (get_kind() == prolog_var || get_kind() == hof_var)
+  if (get_kind() == prolog_var)
   {
     os << " uniqueId=" << theUniqueId;
   }
@@ -539,23 +539,24 @@
   os << " " << theFunctionItemInfo->theQName->getStringValue()
      << "#" << theFunctionItemInfo->theArity << " [\n";
 
-  for (csize i = 0; i < theFunctionItemInfo->theScopedVarsValues.size(); ++i)
+  for (csize i = 0; i < theFunctionItemInfo->theInScopeVarValues.size(); ++i)
   {
     os << indent << "using $"
-       << theFunctionItemInfo->theScopedVarsNames[i]->getStringValue()
-       << expr_addr(theFunctionItemInfo->theSubstVarsValues[i])
-       << (theFunctionItemInfo->theIsGlobalVar[i] ? " global=1" : "") << " := [";
-    os << endl << inc_indent;
+       << theFunctionItemInfo->theInScopeVarNames[i]->getStringValue()
+       << expr_addr(theFunctionItemInfo->theInScopeVars[i])
+       << " := [" << endl << inc_indent;
 
-    if (theFunctionItemInfo->theScopedVarsValues[i])
-      theFunctionItemInfo->theScopedVarsValues[i]->put(os);
+    if (theFunctionItemInfo->theInScopeVarValues[i])
+      theFunctionItemInfo->theInScopeVarValues[i]->put(os);
 
     os << dec_indent << indent << "]" << endl;
   }
 
-  if (theFunctionItemInfo->theFunction != NULL &&
-      static_cast<user_function*>(theFunctionItemInfo->theFunction.getp())->getBody() != NULL)
-    static_cast<user_function*>(theFunctionItemInfo->theFunction.getp())->getBody()->put(os);
+  user_function* udf = 
+  static_cast<user_function*>(theFunctionItemInfo->theFunction.getp());
+
+  if (udf != NULL && udf->getBody() != NULL)
+    udf->getBody()->put(os);
 
   END_PUT();
 }

=== modified file 'src/compiler/expression/expr_type.cpp'
--- src/compiler/expression/expr_type.cpp	2013-04-08 15:07:13 +0000
+++ src/compiler/expression/expr_type.cpp	2013-04-24 02:27:27 +0000
@@ -260,7 +260,6 @@
     case var_expr::catch_var: // TODO
     case var_expr::arg_var:
     case var_expr::eval_var:
-    case var_expr::hof_var:
     {
       break;
     }

=== modified file 'src/compiler/expression/function_item_expr.cpp'
--- src/compiler/expression/function_item_expr.cpp	2013-04-16 20:06:08 +0000
+++ src/compiler/expression/function_item_expr.cpp	2013-04-24 02:27:27 +0000
@@ -140,17 +140,13 @@
 }
 
 
-void function_item_expr::add_variable(
-    expr* var,
-    var_expr* substVar,
-    const store::Item_t& name,
-    int isGlobal)
+void function_item_expr::add_variable(expr* var, var_expr* substVar)
 {
-  theFunctionItemInfo->add_variable(var, substVar, name, isGlobal);
+  theFunctionItemInfo->add_variable(var, substVar);
 }
 
 
-  void function_item_expr::set_function(user_function* udf, csize arity)
+void function_item_expr::set_function(user_function* udf, csize arity)
 {
   theFunctionItemInfo->theFunction = udf;
   theFunctionItemInfo->theArity = arity;
@@ -163,9 +159,7 @@
 {
   store::Item_t name;
   std::stringstream ss;
-  ss << "inline function(";
-  ss << loc;
-  ss << ")";
+  ss << "inline-function(" << loc << ")";
   GENV_ITEMFACTORY->createQName(name, "", "", ss.str());
   return name;
 }

=== modified file 'src/compiler/expression/function_item_expr.h'
--- src/compiler/expression/function_item_expr.h	2013-04-16 20:06:08 +0000
+++ src/compiler/expression/function_item_expr.h	2013-04-24 02:27:27 +0000
@@ -29,7 +29,7 @@
 namespace zorba {
 
 /*******************************************************************************
-  [133]     ArgumentPlaceholder      ::=      "?"
+  ArgumentPlaceholder ::= "?"
 ********************************************************************************/
 class argument_placeholder_expr : public expr
 {
@@ -115,6 +115,10 @@
 
   InlineFunction ::= "function" "(" ParamList? ")" ("as" SequenceType)? EnclosedExpr
 
+  theFunctionItemInfo:
+  --------------------
+  See class definition in src/runtime/hof/function_item.h
+
 ********************************************************************************/
 class function_item_expr: public expr
 {
@@ -149,25 +153,16 @@
 public:
   FunctionItemInfo* get_dynamic_fn_info() { return theFunctionItemInfo; }
 
-  void add_variable(
-      expr* var,
-      var_expr* substVar,
-      const store::Item_t& name,
-      int isGlobal);
-
-  const std::vector<var_expr*>& get_subst_vars() const
-  {
-    return theFunctionItemInfo->theSubstVarsValues;
-  }
-
-  const std::vector<store::Item_t>& get_scoped_vars_names() const
-  {
-    return theFunctionItemInfo->theScopedVarsNames;
-  }
-
-  const std::vector<int>& get_is_global_var() const
-  {
-    return theFunctionItemInfo->theIsGlobalVar;
+  void add_variable(expr* var, var_expr* substVar);
+
+  const std::vector<var_expr*>& get_in_scope_vars() const
+  {
+    return theFunctionItemInfo->theInScopeVars;
+  }
+
+  const std::vector<store::Item_t>& get_in_scope_var_names() const
+  {
+    return theFunctionItemInfo->theInScopeVarNames;
   }
 
   void set_function(user_function* udf, csize arity);
@@ -189,8 +184,6 @@
   std::ostream& put(std::ostream& os) const;
   
 public:
-  // Given a location, will create an inline function name string such 
-  // as "inline function(loc)"
   static store::Item_t create_inline_fname(const QueryLoc& loc);
 };
 

=== modified file 'src/compiler/expression/var_expr.cpp'
--- src/compiler/expression/var_expr.cpp	2013-03-04 21:00:58 +0000
+++ src/compiler/expression/var_expr.cpp	2013-04-24 02:27:27 +0000
@@ -53,7 +53,6 @@
   case count_var: return "CNT"; break;
   case score_var: return "SCORE"; break;
   case prolog_var: return "PROLOG"; break;
-  case hof_var: return "HOF"; break;
   case local_var: return "LOCAL"; break;
   case catch_var: return "CATCH"; break;
   case copy_var: return "COPY"; break;
@@ -316,7 +315,7 @@
 ********************************************************************************/
 void var_expr::remove_set_expr(expr* e)
 {
-  assert(theVarKind == local_var || theVarKind == prolog_var || theVarKind == hof_var);
+  assert(theVarKind == local_var || theVarKind == prolog_var);
 
   bool found = false;
   VarSetExprs::iterator ite = theSetExprs.begin();

=== modified file 'src/compiler/expression/var_expr.h'
--- src/compiler/expression/var_expr.h	2013-03-04 21:00:58 +0000
+++ src/compiler/expression/var_expr.h	2013-04-24 02:27:27 +0000
@@ -152,8 +152,6 @@
 
     prolog_var,
 
-    hof_var,      // used by HoF functions, behaves similarly to prolog vars
-
     local_var,
 
     arg_var

=== modified file 'src/compiler/rewriter/rules/nodeid_rules.cpp'
--- src/compiler/rewriter/rules/nodeid_rules.cpp	2013-03-15 08:22:41 +0000
+++ src/compiler/rewriter/rules/nodeid_rules.cpp	2013-04-24 02:27:27 +0000
@@ -1177,7 +1177,6 @@
 
     case var_expr::prolog_var:
     case var_expr::local_var:
-    case var_expr::hof_var:
     {
       if (!e->isVisited(1))
       {

=== modified file 'src/compiler/rewriter/tools/dataflow_annotations.cpp'
--- src/compiler/rewriter/tools/dataflow_annotations.cpp	2013-03-15 08:22:41 +0000
+++ src/compiler/rewriter/tools/dataflow_annotations.cpp	2013-04-24 02:27:27 +0000
@@ -801,7 +801,6 @@
 
     case var_expr::prolog_var:
     case var_expr::local_var:
-    case var_expr::hof_var:
     {
       VarSourcesMap::iterator ite = theVarSourcesMap.find(e);
 
@@ -1238,7 +1237,6 @@
 
     case var_expr::prolog_var:
     case var_expr::local_var:
-    case var_expr::hof_var:
     {
       VarSourcesMap::iterator ite = theVarSourcesMap.find(e);
 

=== modified file 'src/compiler/translator/translator.cpp'
--- src/compiler/translator/translator.cpp	2013-04-23 13:20:31 +0000
+++ src/compiler/translator/translator.cpp	2013-04-24 02:27:27 +0000
@@ -1516,6 +1516,7 @@
 
         xqtref_t cardType = tm->create_any_item_type(paramType->get_quantifier());
 
+        // hof ????
         argExpr = wrap_in_type_match(argExpr,
                                      cardType,
                                      loc,
@@ -1541,8 +1542,10 @@
  The coersion expr is a flwor that looks like this:
 
   for $fi in argExpr
-  return function($p1 as t1, ... $pn as tn) { $fi(p1, ..., pn) }
+  return function($p1 as t1, ... $pn as tn) as rt { $fi(p1, ..., pn) }
 
+  where t1, ..., tn are the param types of the target function type and rt is
+  the return type of .the target function type.
 ********************************************************************************/
 expr* wrap_in_coercion(
     xqtref_t targetType,
@@ -1556,19 +1559,21 @@
 
   push_scope();
 
+  // for $fi in argExpr
   flwor_expr* coersionFlwor = CREATE(flwor)(theRootSctx, theUDF, loc, false);
   for_clause* fiClause = wrap_in_forclause(argExpr, NULL);
   var_expr* fiVar = fiClause->get_var();
   coersionFlwor->add_clause(fiClause);
 
+  // Create the inline-function expr and make it the return expr of the flwor
   function_item_expr* inlineFuncExpr = 
   CREATE(function_item)(theRootSctx, theUDF, loc, true, true);
 
   coersionFlwor->set_return_expr(inlineFuncExpr);
 
-  var_expr* fiSubstVar = bind_var(loc, fiVar->get_name(), var_expr::hof_var);
+  var_expr* fiSubstVar = bind_var(loc, fiVar->get_name(), var_expr::local_var);
 
-  inlineFuncExpr->add_variable(fiVar, fiSubstVar, fiVar->get_name(), 0);
+  inlineFuncExpr->add_variable(fiVar, fiSubstVar);
 
   // Create the inline udf obj.
   user_function_t inlineUDF = 
@@ -1584,13 +1589,12 @@
   std::vector<expr*> arguments;    // Arguments to the dynamic function call
   csize numParams = funcType->get_number_params();
 
-  for(csize i = 0; i < numParams; ++i)
+  for (csize i = 0; i < numParams; ++i)
   {
     xqtref_t paramType = funcType->operator[](i);
 
     var_expr* argVar = create_temp_var(loc, var_expr::arg_var);
     argVar->set_param_pos(i);
-    argVar->set_type(paramType);
     argVars.push_back(argVar);
 
     expr* arg = CREATE(wrapper)(theRootSctx, theUDF, loc, argVar);
@@ -1606,6 +1610,7 @@
                                                       fiSubstVar),
                                       arguments);
 
+  // What if return type is function(...) hof ????
   if (returnType->isBuiltinAtomicAny())
   {
     body = wrap_in_type_promotion(body, returnType, PROMOTE_TYPE_PROMOTION);
@@ -4236,8 +4241,6 @@
 
     // Wrap the UDF body to the type-related expr that enforce the declared
     // return type.
-    returnType = udf->getSignature().returnType();
-
     if (returnType->isBuiltinAtomicAny())
     {
       body = wrap_in_type_promotion(body,
@@ -11140,8 +11143,7 @@
 
 
 /*******************************************************************************
-  The function will process a FunctionDecl to handle all the special function
-  cases. 
+
 ********************************************************************************/
 expr* generate_fncall(
     const QName* qname,
@@ -11455,6 +11457,7 @@
   }
   case FunctionConsts::FN_FUNCTION_LOOKUP_2:
   {
+    // hof ???? What if focus is not defined ?
     arguments.push_back(DOT_REF);
     arguments.push_back(DOT_POS_REF);
     arguments.push_back(DOT_SIZE_REF);
@@ -11895,6 +11898,7 @@
   expr* sourceExpr = pop_nodestack();
   ZORBA_ASSERT(sourceExpr != 0);
 
+  // special case: partial function invocation
   if (v.normalizeArgs() && sourceExpr->get_expr_kind() == function_item_expr_kind)
   {
     function_item_expr* fiExpr = static_cast<function_item_expr*>(sourceExpr);
@@ -11914,7 +11918,6 @@
 
   expr* flworVarExpr = CREATE(wrapper)(theRootSctx, theUDF, loc, fc->get_var());
 
-#ifdef ZORBA_WITH_JSON
   TypeManager* tm = sourceExpr->get_type_manager();
   xqtref_t srcType = sourceExpr->get_return_type();
 
@@ -11956,7 +11959,6 @@
     flworExpr->set_return_expr(accessorExpr);
   }
   else
-#endif
   {
     // This is needed to make sure that the flwor is not thrown away by the optimizer
     // when the FunctionItem expression is an empty sequence.
@@ -12068,9 +12070,7 @@
 
     if (f->isBuiltin() &&
         fn_ns != static_context::W3C_FN_NS &&
-#ifdef ZORBA_WITH_JSON
         fn_ns != static_context::JSONIQ_FN_NS &&
-#endif
         fn_ns != XQUERY_MATH_FN_NS &&
         fn_ns != theModuleNamespace)
     {
@@ -12108,37 +12108,59 @@
       {
       case FunctionConsts::FN_POSITION_0:
       {
-        expr* posVar = NULL;
-        if (lookup_var(getDotPosVarName(), loc, false))
-          posVar = DOT_POS_REF;
-
-        push_scope();
-
-        var_expr* substVar = bind_var(loc, getDotPosVarName(), var_expr::hof_var);
-
-        fiExpr->add_variable(posVar, substVar, substVar->get_name(), false);
-
-        body = generate_fn_body(f, foArgs, loc);
-
-        pop_scope();
+        var_expr* posVar = lookup_var(getDotPosVarName(), loc, false);
+
+        if (posVar && posVar->get_kind() != var_expr::prolog_var)
+        {
+          expr* posVarRef = DOT_POS_REF;
+
+          push_scope();
+
+          var_expr* substVar = bind_var(loc, getDotPosVarName(), var_expr::local_var);
+
+          // Must set the id of the substVar if we are coming here from a
+          // FunctionLookupIterator.
+          substVar->set_unique_id(posVar->get_unique_id());
+
+          fiExpr->add_variable(posVarRef, substVar);
+
+          body = generate_fn_body(f, foArgs, loc);
+
+          pop_scope();
+        }
+        else
+        {
+          body = generate_fn_body(f, foArgs, loc);
+        }
 
         break;
       }
       case FunctionConsts::FN_LAST_0:
       {
-        expr* sizeVar = NULL;
-        if (lookup_var(getLastIdxVarName(), loc, false))
-          sizeVar = DOT_SIZE_REF;
-
-        push_scope();
-
-        var_expr* substVar = bind_var(loc, getLastIdxVarName(), var_expr::hof_var);
-
-        fiExpr->add_variable(sizeVar, substVar, substVar->get_name(), false);
-
-        body = generate_fn_body(f, foArgs, loc);
-
-        pop_scope();
+        var_expr* sizeVar = lookup_var(getLastIdxVarName(), loc, false);
+
+        if (sizeVar && sizeVar->get_kind() != var_expr::prolog_var)
+        {
+          expr* sizeVarRef = DOT_SIZE_REF;
+
+          push_scope();
+
+          var_expr* substVar = bind_var(loc, getLastIdxVarName(), var_expr::local_var);
+
+          // Must set the id of the substVar if we are coming here from a
+          // FunctionLookupIterator.
+          substVar->set_unique_id(sizeVar->get_unique_id());
+
+          fiExpr->add_variable(sizeVarRef, substVar);
+
+          body = generate_fn_body(f, foArgs, loc);
+
+          pop_scope();
+        }
+        else
+        {
+          body = generate_fn_body(f, foArgs, loc);
+        }
 
         break;
       }
@@ -12163,79 +12185,93 @@
       case FunctionConsts::FN_ID_1:
       case FunctionConsts::FN_ELEMENT_WITH_ID_1:
       {
-        expr* dotVarRef = NULL;
         var_expr* dotVar = lookup_var(getDotVarName(), loc, false);
 
-        if (dotVar)
-          dotVarRef = DOT_REF;
-
-        push_scope();
-
-        var_expr* substVar = bind_var(loc, getDotVarName(), var_expr::hof_var);
-
-        if (dotVar)
+        if (dotVar && dotVar->get_kind() != var_expr::prolog_var)
+        {
+          expr* dotVarRef = DOT_REF;
+
+          push_scope();
+
+          var_expr* substVar = bind_var(loc, getDotVarName(), var_expr::local_var);
+
+          // Must set the id of the substVar if we are coming here from a
+          // FunctionLookupIterator.
           substVar->set_unique_id(dotVar->get_unique_id());
 
-        fiExpr->add_variable(dotVarRef, substVar, substVar->get_name(), false);
-
-        body = generate_fn_body(f, foArgs, loc);
-
-        pop_scope();
+          fiExpr->add_variable(dotVarRef, substVar);
+
+          body = generate_fn_body(f, foArgs, loc);
+
+          pop_scope();
+        }
+        else
+        {
+          body = generate_fn_body(f, foArgs, loc);
+        }
 
         break;
       }
       case FunctionConsts::FN_FUNCTION_LOOKUP_2:
       {
-        expr* ctxItemVRef = NULL;
-        expr* ctxPosVRef = NULL;
-        expr* ctxSizeVRef = NULL;
+        bool varAdded = false;
 
         var_expr* ctxItemVar = lookup_var(getDotVarName(), loc, false);
         var_expr* ctxPosVar = lookup_var(getDotPosVarName(), loc, false);
         var_expr* ctxSizeVar = lookup_var(getLastIdxVarName(), loc, false);
 
-        if (ctxItemVar)
-          ctxItemVRef = DOT_REF;
-
-        if (ctxPosVar)
-          ctxPosVRef = DOT_POS_REF;
-
-        if (ctxSizeVar)
-          ctxSizeVRef = DOT_SIZE_REF;
-
-        push_scope();
-
-        var_expr* substItemVar = bind_var(loc, getDotVarName(), var_expr::hof_var);
-        var_expr* substPosVar = bind_var(loc, getDotPosVarName(), var_expr::hof_var);
-        var_expr* substSizeVar = bind_var(loc, getLastIdxVarName(), var_expr::hof_var);
-
-        if (ctxItemVar)
-          substItemVar->set_unique_id(ctxItemVar->get_unique_id());
-
-        if (ctxPosVar)
-          substPosVar->set_unique_id(ctxPosVar->get_unique_id());
-
-        if (ctxSizeVar)
-          substSizeVar->set_unique_id(ctxSizeVar->get_unique_id());
-
-        fiExpr->add_variable(ctxItemVRef,
-                             substItemVar,
-                             substItemVar->get_name(),
-                             ctxItemVar->get_kind() == var_expr::prolog_var ? 1 : 0);
-
-        fiExpr->add_variable(ctxPosVRef,
-                             substPosVar,
-                             substPosVar->get_name(),
-                             ctxPosVar->get_kind() == var_expr::prolog_var ? 1 : 0);
-
-        fiExpr->add_variable(ctxSizeVRef,
-                             substSizeVar,
-                             substSizeVar->get_name(),
-                             ctxSizeVar->get_kind() == var_expr::prolog_var ? 1 : 0);
+        if (ctxItemVar && ctxItemVar->get_kind() != var_expr::prolog_var)
+        {
+          expr* ctxVRef = DOT_REF;
+
+          push_scope();
+          varAdded = true;
+
+          var_expr* substVar = bind_var(loc, getDotVarName(), var_expr::local_var);
+
+          substVar->set_unique_id(ctxItemVar->get_unique_id());
+
+          fiExpr->add_variable(ctxVRef, substVar);
+        }
+
+        if (ctxPosVar && ctxPosVar->get_kind() != var_expr::prolog_var)
+        {
+          expr* ctxVRef = DOT_POS_REF;
+
+          if (!varAdded)
+          {
+            push_scope();
+            varAdded = true;
+          }
+
+          var_expr* substVar = bind_var(loc, getDotPosVarName(), var_expr::local_var);
+
+          substVar->set_unique_id(ctxPosVar->get_unique_id());
+
+          fiExpr->add_variable(ctxVRef, substVar);
+        }
+
+        if (ctxSizeVar && ctxSizeVar->get_kind() != var_expr::prolog_var)
+        {
+          expr* ctxVRef = DOT_SIZE_REF;
+
+          if (!varAdded)
+          {
+            push_scope();
+            varAdded = true;
+          }
+
+          var_expr* substVar = bind_var(loc, getLastIdxVarName(), var_expr::local_var);
+
+          substVar->set_unique_id(ctxSizeVar->get_unique_id());
+
+          fiExpr->add_variable(ctxVRef, substVar);
+        }
 
         body = generate_fn_body(f, foArgs, loc);
 
-        pop_scope();
+        if (varAdded)
+          pop_scope();
 
         break;
       }
@@ -12248,7 +12284,7 @@
 
       udf->setArgVars(udfArgs);
       udf->setBody(body);
-      udf->setOptimized(true); // TODO: this should not be set here
+      udf->setOptimized(true); // hof ????
     } // if builtin function
     else
     {
@@ -12290,9 +12326,9 @@
   // Handle function parameters. Translation of the params, if any, results to
   // a flwor expr with one let binding for each function parameter:
   //
-  // let $x1 as T1 := _x1
+  // let $x1 := _x1
   // .....
-  // let $xN as TN := _xN
+  // let $xN := _xN
   //
   // where each _xi is an arg var.
   rchandle<ParamList> params = v.getParamList();
@@ -12315,35 +12351,24 @@
     var_expr* varExpr = (*ite)->getVar();
     var_expr::var_kind kind = varExpr->get_kind();
 
-    if (kind == var_expr::local_var)
-    {
+    if (kind == var_expr::prolog_var)
       continue;
-    }
-
-    store::Item_t qname = varExpr->get_name();
 
     var_expr* subst_var;
-    if (kind != var_expr::prolog_var)
-    {
-      try 
-      {
-        subst_var = bind_var(loc, qname, var_expr::hof_var);
-      }
-      catch(XQueryException& e)
-      {
-        if (e.diagnostic() == err::XQST0049)
-          continue;
-        else
-          throw;
-      }
-
-      fiExpr->add_variable(varExpr, subst_var, varExpr->get_name(), 0);
-    }
-    else
-    {
-      subst_var = varExpr;
-      fiExpr->add_variable(NULL, subst_var, varExpr->get_name(), 1);
-    }
+
+    try 
+    {
+      subst_var = bind_var(loc, varExpr->get_name(), var_expr::local_var);
+    }
+    catch(XQueryException& e)
+    {
+      if (e.diagnostic() == err::XQST0049)
+        continue;
+      else
+        throw;
+    }
+
+    fiExpr->add_variable(varExpr, subst_var);
   }
 
   if (flwor->num_clauses() > 0)
@@ -12395,7 +12420,7 @@
     }
   }
 
-  create_inline_function(body, flwor, paramTypes, returnType, loc);
+  generate_inline_function(body, flwor, paramTypes, returnType, loc);
 
   // pop the scope.
   pop_scope();
@@ -12405,7 +12430,7 @@
 /*******************************************************************************
 
 ********************************************************************************/
-void create_inline_function(
+void generate_inline_function(
     expr* body,
     flwor_expr* flwor,
     const std::vector<xqtref_t>& paramTypes,
@@ -12414,7 +12439,7 @@
 {
   std::vector<var_expr*> argVars;
 
-  // Wrap the body in appropriate type op.
+  // Wrap the body in appropriate type op. hof ????
   if (returnType->isBuiltinAtomicAny())
   {
     body = wrap_in_type_promotion(body, returnType, PROMOTE_TYPE_PROMOTION);
@@ -12480,14 +12505,14 @@
   udf->setBody(body);
   udf->setScriptingKind(body->get_scripting_detail());
   udf->setArgVars(argVars);
-  udf->setOptimized(true); // TODO: this should not be set here
+  udf->setOptimized(true); // hof ????
 
   // Get the function_item_expr and set its function to the udf created above.
   function_item_expr* fiExpr = dynamic_cast<function_item_expr*>(theNodeStack.top());
   assert(fiExpr != NULL);
   fiExpr->set_function(udf, udf->numArgs());
 
-  if (theCCB->theConfig.translate_cb != NULL && theCCB->theConfig.optimize_cb == NULL)
+  if (theCCB->theConfig.translate_cb != NULL)
     theCCB->theConfig.translate_cb(udf->getBody(),
                                    udf->getName()->getStringValue().c_str());
 }
@@ -12557,11 +12582,6 @@
 void* begin_visit(const JSONArrayConstructor& v)
 {
   TRACE_VISIT();
-
-#ifndef ZORBA_WITH_JSON
-  RAISE_ERROR_NO_PARAMS(err::XPST0003, loc);
-#endif
-
   return no_state;
 }
 
@@ -12569,7 +12589,6 @@
 {
   TRACE_VISIT_OUT();
 
-#ifdef ZORBA_WITH_JSON
   expr* contentExpr = NULL;
 
   if (v.get_expr() != NULL)
@@ -12577,8 +12596,7 @@
     contentExpr = pop_nodestack();
   }
 
-  push_nodestack(theExprManager->create_json_array_expr(theRootSctx, theUDF, loc, contentExpr));
-#endif
+  push_nodestack(CREATE(json_array)(theRootSctx, theUDF, loc, contentExpr));
 }
 
 
@@ -12592,9 +12610,6 @@
 void* begin_visit(const JSONObjectConstructor& v)
 {
   TRACE_VISIT();
-#ifndef ZORBA_WITH_JSON
-  RAISE_ERROR_NO_PARAMS(err::XPST0003, loc);
-#endif
   return no_state;
 }
 
@@ -12602,7 +12617,6 @@
 {
   TRACE_VISIT_OUT();
 
-#ifdef ZORBA_WITH_JSON
   expr* contentExpr = NULL;
 
   if (v.get_expr() != NULL)
@@ -12626,7 +12640,6 @@
                                  v.get_accumulate());
 
   push_nodestack(jo);
-#endif
 }
 
 
@@ -12638,9 +12651,6 @@
 void* begin_visit(const JSONDirectObjectConstructor& v)
 {
   TRACE_VISIT();
-#ifndef ZORBA_WITH_JSON
-  RAISE_ERROR_NO_PARAMS(err::XPST0003, loc);
-#endif
   return no_state;
 }
 
@@ -12648,7 +12658,6 @@
 {
   TRACE_VISIT_OUT();
 
-#ifdef ZORBA_WITH_JSON
   csize numPairs = v.numPairs();
   std::vector<expr*> names(numPairs);
   std::vector<expr*> values(numPairs);
@@ -12663,7 +12672,6 @@
   create_json_direct_object_expr(theRootSctx, theUDF, loc, names, values);
 
   push_nodestack(jo);
-#endif
 }
 
 
@@ -12696,11 +12704,6 @@
 void* begin_visit(const JSONPairConstructor& v)
 {
   TRACE_VISIT ();
-#ifndef ZORBA_WITH_JSON
-  RAISE_ERROR_NO_PARAMS(err::XPST0003, loc);
-#else
-#endif
-
   return no_state;
 }
 
@@ -12708,7 +12711,6 @@
 {
   TRACE_VISIT_OUT();
 
-#ifdef ZORBA_WITH_JSON
   expr* nameExpr = pop_nodestack();
   expr* valueExpr = pop_nodestack();
 
@@ -12729,7 +12731,6 @@
 
   push_nodestack(valueExpr);
   push_nodestack(nameExpr);
-#endif
 }
 
 
@@ -13132,7 +13133,7 @@
 void begin_check_boundary_whitespace()
 {
   if (theSctx->boundary_space_mode() == StaticContextConsts::strip_space)
-{
+  {
     theIsWSBoundaryStack.push(true);
     thePossibleWSContentStack.push(0);
   }
@@ -13159,7 +13160,8 @@
     {
       thePossibleWSContentStack.push(0);
       theIsWSBoundaryStack.push(true);
-      if (lPrev != 0) {
+      if (lPrev != 0)
+      {
         lPrev->setIsStripped(true);
       }
     }
@@ -13171,18 +13173,23 @@
     else
     {
       bool lCouldBe = false;
-      if (lPrevIsBoundary) {
+      if (lPrevIsBoundary)
+      {
         zstring content = v.get_elem_content().str();
         utf8::trim_whitespace(content);
 
         // Filtering out of whitespaces
-        if (content.empty()) {
+        if (content.empty())
+        {
           lCouldBe = true;
         }
       }
-      if (lCouldBe) {
+      if (lCouldBe)
+      {
         thePossibleWSContentStack.push(&v);
-      } else {
+      }
+      else
+      {
         thePossibleWSContentStack.push(0);
       }
       theIsWSBoundaryStack.push(false);
@@ -13190,15 +13197,17 @@
   }
 }
 
-/**
- * Deletes the entries in theIsWSBoundaryStack and thePossibleWSContentStack. If thePossibleWSContentStack
- * contains an item, this item is boundary whitespace because end of content is a boundary.
- */
+
+/*******************************************************************************
+  Deletes the entries in theIsWSBoundaryStack and thePossibleWSContentStack. If
+  thePossibleWSContentStack contains an item, this item is boundary whitespace
+  because end of content is a boundary.
+********************************************************************************/
 void end_check_boundary_whitespace()
 {
   if (theSctx->boundary_space_mode() == StaticContextConsts::strip_space)
   {
-    const DirElemContent* lPrev = translator_ns::pop_stack (thePossibleWSContentStack);
+    const DirElemContent* lPrev = translator_ns::pop_stack(thePossibleWSContentStack);
     if (lPrev != 0)
     {
       lPrev->setIsStripped(true);
@@ -13263,8 +13272,7 @@
   }
   else if (args.size() > 1)
   {
-    fo_expr* expr_list = theExprManager->
-    create_fo_expr(theRootSctx, theUDF, loc, op_concatenate, args);
+    fo_expr* expr_list = CREATE(fo)(theRootSctx, theUDF, loc, op_concatenate, args);
 
     normalize_fo(expr_list);
 
@@ -13401,7 +13409,7 @@
         curRef++;
     }
 
-    expr* lConstExpr = theExprManager->create_const_expr(theRootSctx, theUDF, loc, content);
+    expr* lConstExpr = CREATE(const)(theRootSctx, theUDF, loc, content);
     push_nodestack(lConstExpr);
     break;
   }
@@ -13410,8 +13418,8 @@
     // we always create a text node here because if we are in an attribute, we atomice
     // the text node into its string value
     zstring content("{");
-    expr* lConstExpr = theExprManager->create_const_expr(theRootSctx, theUDF, loc, content);
-    push_nodestack ( lConstExpr );
+    expr* lConstExpr = CREATE(const)(theRootSctx, theUDF, loc, content);
+    push_nodestack (lConstExpr);
     break;
   }
   case ParseConstants::cont_escape_rbrace:
@@ -13420,7 +13428,7 @@
     // the text node into its string value
     zstring content("}");
     expr* lConstExpr = CREATE(const)(theRootSctx, theUDF, loc, content);
-    push_nodestack ( lConstExpr );
+    push_nodestack (lConstExpr);
     break;
   }
   case ParseConstants::cont_expr:
@@ -13475,10 +13483,10 @@
   if (target_upper == "XML")
     RAISE_ERROR(err::XPST0003, loc, ERROR_PARAMS(ZED(XPST0003_PiTarget)));
 
-  expr* target = theExprManager->create_const_expr(theRootSctx, theUDF, loc, target_str);
-  expr* content = theExprManager->create_const_expr(theRootSctx, theUDF, loc, v.get_pi_content().str());
+  expr* target = CREATE(const)(theRootSctx, theUDF, loc, target_str);
+  expr* content = CREATE(const)(theRootSctx, theUDF, loc, v.get_pi_content().str());
 
-  push_nodestack(theExprManager->create_pi_expr(theRootSctx, theUDF, loc, target,  content));
+  push_nodestack(CREATE(pi)(theRootSctx, theUDF, loc, target,  content));
 }
 
 
@@ -13880,18 +13888,13 @@
 void* begin_visit(const StructuredItemType& v)
 {
   TRACE_VISIT();
-#ifndef ZORBA_WITH_JSON
-  RAISE_ERROR_NO_PARAMS(err::XPST0003, loc);
-#endif
   return no_state;
 }
 
 void end_visit(const StructuredItemType& v, void* /*visit_state*/)
 {
   TRACE_VISIT_OUT();
-#ifdef ZORBA_WITH_JSON
   theTypeStack.push(GENV_TYPESYSTEM.STRUCTURED_ITEM_TYPE_ONE);
-#endif
 }
 
 
@@ -13910,16 +13913,13 @@
 void* begin_visit(const JSON_Test& v)
 {
   TRACE_VISIT();
-#ifndef ZORBA_WITH_JSON
-  RAISE_ERROR_NO_PARAMS(err::XPST0003, loc);
-#endif
   return no_state;
 }
 
 void end_visit(const JSON_Test& v, void* /*visit_state*/)
 {
   TRACE_VISIT_OUT();
-#ifdef ZORBA_WITH_JSON
+
   RootTypeManager& rtm = GENV_TYPESYSTEM;
 
   switch (v.get_kind())
@@ -13943,7 +13943,6 @@
   default:
     ZORBA_ASSERT(false);
   }
-#endif /* ZORBA_WITH_JSON */
 }
 
 
@@ -14462,6 +14461,7 @@
   theTypeStack.push(GENV_TYPESYSTEM.ANY_FUNCTION_TYPE_STAR);
 }
 
+
 void* begin_visit(const TypeList& v)
 {
   TRACE_VISIT ();
@@ -14473,12 +14473,14 @@
   TRACE_VISIT_OUT();
 }
 
+
 void* begin_visit(const TypedFunctionTest& v)
 {
   TRACE_VISIT();
   return no_state;
 }
 
+
 void end_visit(const TypedFunctionTest& v, void* /*visit_state*/)
 {
   TRACE_VISIT_OUT ();
@@ -14533,9 +14535,6 @@
 void* begin_visit(const JSONObjectInsertExpr& v)
 {
   TRACE_VISIT();
-#ifndef ZORBA_WITH_JSON
-  RAISE_ERROR_NO_PARAMS(err::XPST0003, loc);
-#endif
   return no_state;
 }
 
@@ -14544,7 +14543,6 @@
 {
   TRACE_VISIT_OUT();
 
-#ifdef ZORBA_WITH_JSON
   RootTypeManager& rtm = GENV_TYPESYSTEM;
 
   expr* targetExpr = pop_nodestack();
@@ -14573,7 +14571,6 @@
                              args);
 
   push_nodestack(updExpr);
-#endif
 }
 
 
@@ -14584,9 +14581,6 @@
 void* begin_visit(const JSONArrayInsertExpr& v)
 {
   TRACE_VISIT();
-#ifndef ZORBA_WITH_JSON
-  RAISE_ERROR_NO_PARAMS(err::XPST0003, loc);
-#endif
   return no_state;
 }
 
@@ -14595,7 +14589,6 @@
 {
   TRACE_VISIT_OUT();
 
-#ifdef ZORBA_WITH_JSON
   RootTypeManager& rtm = GENV_TYPESYSTEM;
 
   expr* posExpr = pop_nodestack();
@@ -14626,7 +14619,6 @@
   normalize_fo(updExpr);
 
   push_nodestack(updExpr);
-#endif
 }
 
 
@@ -14636,9 +14628,6 @@
 void* begin_visit(const JSONArrayAppendExpr& v)
 {
   TRACE_VISIT();
-#ifndef ZORBA_WITH_JSON
-  RAISE_ERROR_NO_PARAMS(err::XPST0003, loc);
-#endif
   return no_state;
 }
 
@@ -14647,7 +14636,6 @@
 {
   TRACE_VISIT_OUT();
 
-#ifdef ZORBA_WITH_JSON
   expr* targetExpr = pop_nodestack();
   expr* contentExpr = pop_nodestack();
 
@@ -14667,7 +14655,6 @@
   normalize_fo(updExpr);
 
   push_nodestack(updExpr);
-#endif
 }
 
 
@@ -14687,9 +14674,6 @@
 void* begin_visit(const JSONDeleteExpr& v)
 {
   TRACE_VISIT();
-#ifndef ZORBA_WITH_JSON
-  RAISE_ERROR_NO_PARAMS(err::XPST0003, loc);
-#endif
   return no_state;
 }
 
@@ -14698,7 +14682,6 @@
 {
   TRACE_VISIT_OUT();
 
-#ifdef ZORBA_WITH_JSON
   expr* selExpr = pop_nodestack();
   expr* targetExpr = pop_nodestack();
 
@@ -14721,7 +14704,6 @@
                  selExpr);
 
   push_nodestack(updExpr);
-#endif
 }
 
 
@@ -14731,9 +14713,6 @@
 void* begin_visit(const JSONReplaceExpr& v)
 {
   TRACE_VISIT();
-#ifndef ZORBA_WITH_JSON
-  RAISE_ERROR_NO_PARAMS(err::XPST0003, loc);
-#endif
   return no_state;
 }
 
@@ -14742,7 +14721,6 @@
 {
   TRACE_VISIT_OUT();
 
-#ifdef ZORBA_WITH_JSON
   expr* valueExpr = pop_nodestack();
   expr* selExpr = pop_nodestack();
   expr* targetExpr = pop_nodestack();
@@ -14772,7 +14750,6 @@
                  args);
 
   push_nodestack(updExpr);
-#endif
 }
 
 

=== modified file 'src/functions/udf.cpp'
--- src/functions/udf.cpp	2013-03-17 13:55:28 +0000
+++ src/functions/udf.cpp	2013-04-24 02:27:27 +0000
@@ -111,7 +111,7 @@
   if (ar.is_serializing_out())
   {
     uint32_t planStateSize;
-    getPlan(planStateSize);
+    getPlan(planStateSize, 1);
     ZORBA_ASSERT(thePlan != NULL);
 
     computeResultCaching(theCCB->theXQueryDiagnostics);
@@ -149,7 +149,7 @@
         }
 
         invalidatePlan();
-        getPlan(planStateSize);
+        getPlan(planStateSize, 1);
         ZORBA_ASSERT(thePlan != NULL);
       }
     }
@@ -522,7 +522,7 @@
 /*******************************************************************************
 
 ********************************************************************************/
-PlanIter_t user_function::getPlan(uint32_t& planStateSize)
+PlanIter_t user_function::getPlan(uint32_t& planStateSize,  ulong nextVarId)
 {
   if (thePlan == NULL)
   {
@@ -539,11 +539,10 @@
       argVarToRefsMap.put((uint64_t)&*theArgVars[i], &theArgVarsRefs[i]);
     }
 
-    ulong nextVarId = 1;
     const store::Item* lName = getName();
     //lName may be null of inlined functions
     thePlan = zorba::codegen((lName == 0 ?
-                              "inline function" :
+                              "inline-function" :
                               lName->getStringValue().c_str()),
                              &*theBodyExpr,
                              theCCB,

=== modified file 'src/functions/udf.h'
--- src/functions/udf.h	2013-04-10 21:01:35 +0000
+++ src/functions/udf.h	2013-04-24 02:27:27 +0000
@@ -118,7 +118,7 @@
 
   unsigned short              theScriptingKind;
 
-  expr*                       theBodyExpr;
+  expr                      * theBodyExpr;
   std::vector<var_expr*>      theArgVars;
 
   std::vector<unsigned char>  theIgnoresSortedNodes;
@@ -201,7 +201,7 @@
 
   void optimize();
 
-  PlanIter_t getPlan(uint32_t& planStateSize);
+  PlanIter_t getPlan(uint32_t& planStateSize, ulong nextVarId);
 
   void invalidatePlan();
 

=== modified file 'src/runtime/core/fncall_iterator.cpp'
--- src/runtime/core/fncall_iterator.cpp	2013-04-15 20:40:36 +0000
+++ src/runtime/core/fncall_iterator.cpp	2013-04-24 02:27:27 +0000
@@ -93,11 +93,12 @@
 ********************************************************************************/
 UDFunctionCallIteratorState::UDFunctionCallIteratorState()
   :
+  theLocalDCtx(NULL),
+  theIsLocalDCtxOwner(true),
   thePlan(NULL),
   thePlanState(NULL),
+  thePlanOpen(false),
   thePlanStateSize(0),
-  theLocalDCtx(NULL),
-  thePlanOpen(false),
   theCache(0)
 {
 }
@@ -114,7 +115,7 @@
   if (thePlanState != NULL)
     delete thePlanState;
 
-  if (theLocalDCtx != NULL)
+  if (theLocalDCtx != NULL && theIsLocalDCtxOwner)
     delete theLocalDCtx;
 }
 
@@ -125,30 +126,35 @@
 void UDFunctionCallIteratorState::open(
     PlanState& planState,
     user_function* udf,
-    bool theIsDynamic,
-    store::ItemHandle<FunctionItem>& theFunctionItem)
+    bool isDynamic,
+    store::ItemHandle<FunctionItem>& functionItem)
 {
-  thePlan = udf->getPlan(thePlanStateSize).getp();
-
-  thePlanStateSize = thePlan->getStateSizeOfSubtree();
-
   // Must allocate new dctx because the udf may be a recursive udf with local
   // block vars, all of which have the same dynamic-context id, but they are
   // distinct vars.
 
-  if (theIsDynamic)
+  if (isDynamic && functionItem->getDctx() != NULL)
   {
-    if (theFunctionItem->getDctx() == NULL)
-      theFunctionItem->setDctx(new dynamic_context(planState.theGlobalDynCtx));
-
-    theLocalDCtx = new dynamic_context(theFunctionItem->getDctx());
+    thePlan = udf->getPlan(thePlanStateSize, functionItem->getMaxInScopeVarId()).getp();
+
+    thePlanStateSize = thePlan->getStateSizeOfSubtree();
+
+    theLocalDCtx = functionItem->getDctx();
+
+    theIsLocalDCtxOwner = false;
   }
   else
   {
+    thePlan = udf->getPlan(thePlanStateSize, 1).getp();
+
+    thePlanStateSize = thePlan->getStateSizeOfSubtree();
+
     theLocalDCtx = new dynamic_context(planState.theGlobalDynCtx);
+
+    theIsLocalDCtxOwner = true;
   }
 
-  thePlanState = new PlanState(theIsDynamic ? theFunctionItem->getDctx() : planState.theGlobalDynCtx,
+  thePlanState = new PlanState(planState.theGlobalDynCtx,
                                theLocalDCtx,
                                thePlanStateSize,
                                planState.theStackDepth + 1,

=== modified file 'src/runtime/core/fncall_iterator.h'
--- src/runtime/core/fncall_iterator.h	2013-04-15 11:53:46 +0000
+++ src/runtime/core/fncall_iterator.h	2013-04-24 02:27:27 +0000
@@ -37,6 +37,13 @@
 
 
 /*******************************************************************************
+
+  theLocalDCtx:
+  -------------
+  The dynamic context for this udf call. It is where the values of the udf's
+  local block-variables are stored.  It is created during 
+  UDFunctionCallIterator::openImpl().
+
   thePlan:
   --------
   The runtime plan for the function body. This is created during 
@@ -52,20 +59,14 @@
   initialized the 1st time that UDFunctionCallIterator::nextImpl() is called 
   (at that time open() is invoked on thePlan).
 
+  thePlanOpen:
+  ------------
+  Whether thePlan has been opened already or not.
+
   thePlanStateSize:
   -----------------
   The size of the plan state block.
 
-  theLocalDCtx:
-  -------------
-  The dynamic context for this udf call. It is where the values of the udf's
-  local block-variables are stored.  It is created during 
-  UDFunctionCallIterator::openImpl(),
-
-  thePlanOpen:
-  ------------
-  Whether thePlan has been opened already or not.
-
   theArgWrappers:
   ---------------
   For each argument of this function call, theArgWrappers stores a plan iterator
@@ -94,11 +95,12 @@
 class UDFunctionCallIteratorState : public PlanIteratorState 
 {
 public:
+  dynamic_context                * theLocalDCtx;
+  bool                             theIsLocalDCtxOwner;
   PlanIter_t                       thePlan;
   PlanState                      * thePlanState;
+  bool                             thePlanOpen;
   uint32_t                         thePlanStateSize;
-  dynamic_context                * theLocalDCtx;
-  bool                             thePlanOpen;
   std::vector<store::Iterator_t>   theArgWrappers;
   store::Index                   * theCache;
   std::vector<store::TempSeq_t>    theArgValues;
@@ -118,6 +120,7 @@
 
 
 /*******************************************************************************
+
   theUDF: 
   -------
   Pointer to the udf object.
@@ -127,7 +130,6 @@
   True if this is a UDFunctionCallIterator that is allocated on the fly during
   DynamicFnCallIterator::nextImpl().
 
-
   theFunctionItem:
   ----------------
 

=== modified file 'src/runtime/hof/fn_hof_functions_impl.cpp'
--- src/runtime/hof/fn_hof_functions_impl.cpp	2013-04-16 20:06:08 +0000
+++ src/runtime/hof/fn_hof_functions_impl.cpp	2013-04-24 02:27:27 +0000
@@ -119,9 +119,8 @@
       factory->createQName(ctxItemName, "", "", static_context::DOT_VAR_NAME);
 
       var_expr* ve = ccb->theEM->
-      create_var_expr(impSctx, NULL, loc, var_expr::prolog_var, ctxItemName);
+      create_var_expr(impSctx, NULL, loc, var_expr::local_var, ctxItemName);
 
-      ve->set_external(true);
       ve->set_unique_id(dynamic_context::IDVAR_CONTEXT_ITEM);
 
       impSctx->bind_var(ve, loc);
@@ -135,9 +134,8 @@
       factory->createQName(ctxPosName, "", "", static_context::DOT_POS_VAR_NAME);
 
       var_expr* ve = ccb->theEM->
-      create_var_expr(impSctx, NULL, loc, var_expr::prolog_var, ctxPosName);
+      create_var_expr(impSctx, NULL, loc, var_expr::local_var, ctxPosName);
 
-      ve->set_external(true);
       ve->set_unique_id(dynamic_context::IDVAR_CONTEXT_ITEM_POSITION);
 
       impSctx->bind_var(ve, loc);
@@ -151,9 +149,8 @@
       factory->createQName(ctxSizeName, "", "", static_context::DOT_SIZE_VAR_NAME);
 
       var_expr* ve = ccb->theEM->
-      create_var_expr(impSctx, NULL, loc, var_expr::prolog_var, ctxSizeName);
+      create_var_expr(impSctx, NULL, loc, var_expr::local_var, ctxSizeName);
 
-      ve->set_external(true);
       ve->set_unique_id(dynamic_context::IDVAR_CONTEXT_ITEM_SIZE);
 
       impSctx->bind_var(ve, loc);
@@ -164,12 +161,19 @@
     expr* fiExpr = 
     Translator::translate_literal_function(qname, arity, ccb, impSctx, loc);
     
-    FunctionItemInfo_t dynFnInfo =
+    FunctionItemInfo_t fiInfo =
     static_cast<function_item_expr*>(fiExpr)->get_dynamic_fn_info();
 
-    dynFnInfo->theCCB = ccb;
+    fiInfo->theCCB = ccb;
 
-    result = new FunctionItem(dynFnInfo, fiDctx.release());
+    if (fiInfo->numInScopeVars() > 0)
+    {
+      result = new FunctionItem(fiInfo, fiDctx.release());
+    }
+    else
+    {
+      result = new FunctionItem(fiInfo, NULL);
+    }
   }
   catch (const ZorbaException& e)
   {

=== modified file 'src/runtime/hof/function_item.cpp'
--- src/runtime/hof/function_item.cpp	2013-04-16 20:06:08 +0000
+++ src/runtime/hof/function_item.cpp	2013-04-24 02:27:27 +0000
@@ -48,6 +48,13 @@
 SERIALIZABLE_CLASS_VERSIONS(FunctionItem)
 
 
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+//  FunctionItem                                                              //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+
+
 /*******************************************************************************
 
 ********************************************************************************/
@@ -55,7 +62,7 @@
     static_context* closureSctx,
     const QueryLoc& loc,
     function* func,
-    store::Item_t qname,
+    const store::Item_t& qname,
     csize arity,
     bool isInline,
     bool isCoercion)
@@ -126,31 +133,28 @@
   // ar & theScopedVarsValues;
   // ar & theSubstVarsValues;
 
-  ar & theScopedVarsNames;
-  ar & theIsGlobalVar;
-  ar & theVarId;
+  ar & theInScopeVarNames;
+  ar & theInScopeVarIds;
 
-  ar & theScopedVarsIterators;
+  ar & theInScopeVarIterators;
 
   if (ar.is_serializing_out())
   {
     uint32_t planStateSize;
-    (void)static_cast<user_function*>(theFunction.getp())->getPlan(planStateSize);
+    (void)static_cast<user_function*>(theFunction.getp())->getPlan(planStateSize, 1);
   }
 }
 
 
-void FunctionItemInfo::add_variable(
-    expr* var,
-    var_expr* substVar,
-    const store::Item_t& name,
-    int isGlobal)
+/*******************************************************************************
+
+********************************************************************************/
+void FunctionItemInfo::add_variable(expr* var, var_expr* substVar)
 {
-  theScopedVarsValues.push_back(var);
-  theSubstVarsValues.push_back(substVar);
-  theScopedVarsNames.push_back(name);
-  theIsGlobalVar.push_back(isGlobal);
-  theVarId.push_back(substVar->get_unique_id());
+  theInScopeVarValues.push_back(var);
+  theInScopeVars.push_back(substVar);
+  theInScopeVarNames.push_back(substVar->get_name());
+  theInScopeVarIds.push_back(substVar->get_unique_id());
 }
 
 
@@ -163,18 +167,25 @@
 {
 }
 
-
-FunctionItem::FunctionItem(
-    const FunctionItemInfo_t& dynamicFunctionInfo,
-    dynamic_context* dctx)
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+//  FunctionItem                                                              //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+
+
+/*******************************************************************************
+
+********************************************************************************/
+FunctionItem::FunctionItem(const FunctionItemInfo_t& fiInfo, dynamic_context* dctx)
   :
   store::Item(store::Item::FUNCTION),
-  theFunctionItemInfo(dynamicFunctionInfo),
-  theArity(dynamicFunctionInfo->theArity),
+  theFunctionItemInfo(fiInfo),
+  theArity(fiInfo->theArity),
   theClosureDctx(dctx)
 {
   assert(theFunctionItemInfo->theFunction->isUdf());
-  theArgumentsValues.resize(theFunctionItemInfo->theArity);
+  theArgValues.resize(theArity);
 
 #if 0
   if (theFunctionItemInfo->theFunction->getName() != NULL)
@@ -188,6 +199,9 @@
 }
 
 
+/*******************************************************************************
+
+********************************************************************************/
 FunctionItem::~FunctionItem()
 {
 #if 0
@@ -202,81 +216,107 @@
 }
 
 
+/*******************************************************************************
+
+********************************************************************************/
 void FunctionItem::serialize(::zorba::serialization::Archiver& ar)
 {
   ar & theFunctionItemInfo;
   ar & theArity;
-  ar & theArgumentsValues;
+  ar & theArgValues;
 }
 
 
+/*******************************************************************************
+
+********************************************************************************/
 const store::Item_t FunctionItem::getFunctionName() const
 {
   return theFunctionItemInfo->theQName;
 }
 
 
-csize FunctionItem::getArity() const
-{
-  return theArity;
-}
-
-
+/*******************************************************************************
+  Returns the arity of the function before any partial application
+********************************************************************************/
 csize FunctionItem::getStartArity() const
 {
   return theFunctionItemInfo->theArity;
 }
 
 
+/*******************************************************************************
+
+********************************************************************************/
 const signature& FunctionItem::getSignature() const
 {
   return theFunctionItemInfo->theFunction->getSignature();
 }
 
 
-const std::vector<PlanIter_t>& FunctionItem::getArgumentsValues() const
-{
-  return theArgumentsValues;
-}
-
-
-bool FunctionItem::isArgumentApplied(unsigned int pos) const
-{
-  assert(pos < theArgumentsValues.size());
-  return (theArgumentsValues[pos].getp() != NULL);
-}
-
-
-void FunctionItem::setArgumentValue(unsigned int pos, const PlanIter_t& value)
+/*******************************************************************************
+  This function will return true if the pos-th argument of the function
+  has been partially applied, i.e. theArgumentsValues[pos] is not NULL
+********************************************************************************/
+bool FunctionItem::isArgumentApplied(csize pos) const
+{
+  assert(pos < theArgValues.size());
+  return (theArgValues[pos].getp() != NULL);
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void FunctionItem::setArgumentValue(csize pos, const PlanIter_t& value)
 {
   theArity--;
 
   // find the pos-th NULL value and fill it
-  for (unsigned int i=0; i<theArgumentsValues.size(); i++)
-    if (theArgumentsValues[i] == NULL)
+  for (csize i = 0; i < theArgValues.size(); ++i)
+  {
+    if (theArgValues[i] == NULL)
     {
       if (pos == 0)
       {
-        theArgumentsValues[i] = value;
+        theArgValues[i] = value;
         return;
       }
       else
+      {
         pos--;
+      }
     }
+  }
 
   assert(false);
 }
 
 
+/*******************************************************************************
+
+********************************************************************************/
+ulong FunctionItem::getMaxInScopeVarId() const
+{
+  return theFunctionItemInfo->
+         theInScopeVarIds[theFunctionItemInfo->theInScopeVarIds.size()-1];
+}
+
+
+/*******************************************************************************
+  The getImplementation function assumes the dynChildren vector comes from a
+  DynamicFnCallIterator, and as such, the first element of dynChildren is
+  the function item itself, so it will be skipped.
+********************************************************************************/
 PlanIter_t FunctionItem::getImplementation(
     const std::vector<PlanIter_t>& dynChildren,
     CompilerCB* ccb)
 {
   std::vector<PlanIter_t> args;
-  args.resize(theArgumentsValues.size());
+  args.resize(theArgValues.size());
 
   std::vector<PlanIter_t>::iterator argsIte = args.begin();
-  std::vector<PlanIter_t>::iterator ite = theArgumentsValues.begin();
+  std::vector<PlanIter_t>::iterator ite = theArgValues.begin();
   std::vector<PlanIter_t>::const_iterator ite2 = dynChildren.begin();
   ++ite2; // skip the first child because it's the function item
 
@@ -313,10 +353,14 @@
 
   udfIter->setDynamic();
   udfIter->setFunctionItem(this);
+
   return udfCallIterator;
 }
 
 
+/*******************************************************************************
+
+********************************************************************************/
 zstring FunctionItem::show() const
 {
   std::ostringstream lRes;

=== modified file 'src/runtime/hof/function_item.h'
--- src/runtime/hof/function_item.h	2013-04-16 20:50:28 +0000
+++ src/runtime/hof/function_item.h	2013-04-24 02:27:27 +0000
@@ -109,20 +109,26 @@
   CompilerCB                  * theCCB;
 
   QueryLoc                      theLoc;
-  static_context*               theClosureSctx;
+
+  static_context              * theClosureSctx;
+
   function_t                    theFunction;
+
   store::Item_t                 theQName;
+
   csize                         theArity;
+
   bool                          theIsInline;
+
   bool                          theIsCoercion;
 
-  std::vector<expr*>            theScopedVarsValues;
-  std::vector<var_expr*>        theSubstVarsValues;
-  std::vector<store::Item_t>    theScopedVarsNames;
-  std::vector<int>              theIsGlobalVar;
-  std::vector<ulong>            theVarId;
-
-  std::vector<PlanIter_t>       theScopedVarsIterators;
+  std::vector<var_expr*>        theInScopeVars;
+  std::vector<expr*>            theInScopeVarValues;
+
+  std::vector<store::Item_t>    theInScopeVarNames;
+  std::vector<ulong>            theInScopeVarIds;
+
+  std::vector<PlanIter_t>       theInScopeVarIterators;
 
   store::NsBindings             theLocalBindings;
 
@@ -136,42 +142,52 @@
       static_context* closureSctx,
       const QueryLoc& loc,
       function* func,
-      store::Item_t qname,
+      const store::Item_t& qname,
       csize arity,
       bool isInline,
       bool isCoercion);
 
   virtual ~FunctionItemInfo();
 
-  void add_variable(
-      expr* var,
-      var_expr* substVar,
-      const store::Item_t& name,
-      int isGlobal);
+  csize numInScopeVars() const { return theInScopeVars.size(); }
+
+  void add_variable(expr* var, var_expr* substVar);
 };
 
 
 /*******************************************************************************
-  A FunctionItem is created during codegen, when a function_item_expr is reached.
-
-  theSctx           : The static context of the function_item_expr.
-  theExpr           : The associated function_item_expr.
-  theVariableValues : Vector of var iterators representing the values of the
-                      in-scope FLWOR variables for inline function items.
+  A FunctionItem is created during FunctionItemIterator::nextImpl().
+
+  theFunctionItemInfo:
+  --------------------
+  The associated function-item info.
+
+  theArity:
+  ---------
+  The arity of the function item will decrease when a partial application is used.
+
+  theClosureDctx:
+  ---------------
+  The dynamic context obj to be used as the local dctx of the function, when the
+  function item is dynamically invoked. This dctx is allocated during
+  FunctionItemIterator::nextImpl(). At that time it is also populated with the
+  values of the outer variables.
+
+  theArgValues:
+  -------------
+
 ********************************************************************************/
 class FunctionItem : public store::Item, public zorba::serialization::SerializeBaseClass
 {
 protected:
   FunctionItemInfo_t              theFunctionItemInfo;
 
-  csize                           theArity;   // The arity of the function
-                                              // item will decrease when a
-                                              // partial application is used.
-
-  std::vector<PlanIter_t>         theArgumentsValues;
+  csize                           theArity;
 
   std::auto_ptr<dynamic_context>  theClosureDctx;
 
+  std::vector<PlanIter_t>         theArgValues;
+
   SYNC_CODE(mutable RCLock        theRCLock;)
 
 public:
@@ -180,48 +196,40 @@
   void serialize(::zorba::serialization::Archiver& ar);
 
 public:
-  FunctionItem(
-      const FunctionItemInfo_t& dynamicFunctionInfo,
-      dynamic_context* dctx);
+  FunctionItem(const FunctionItemInfo_t& fiInfo, dynamic_context* dctx);
 
   ~FunctionItem();
 
   SYNC_CODE(RCLock* getRCLock() const { return &theRCLock; })
 
+  bool isInline() const { return theFunctionItemInfo->theIsInline; }
+  
+  bool isCoercion() const { return theFunctionItemInfo->theIsCoercion; }
+
+  const store::Item_t getFunctionName() const;
+
+  csize getArity() const { return theArity; }
+  
+  csize getStartArity() const;
+
+  const signature& getSignature() const;
+
   dynamic_context* getDctx() const { return theClosureDctx.get(); }
 
   void setDctx(dynamic_context* dctx) { theClosureDctx.reset(dctx); }
 
-  const std::vector<PlanIter_t>& getArgumentsValues() const;
-
-  void setArgumentValue(unsigned int pos, const PlanIter_t& value);
-
-  // This function will return true if the pos-th argument of the function
-  // has been partially applied, i.e. theArgumentsValues[pos] is not NULL
-  bool isArgumentApplied(unsigned int pos) const;
-
-  // The getImplementation function assumes the dynChildren vector comes from a
-  // DynamicFnCallIterator, and as such, the first element of dynChildren is
-  // the function item itself, so it will be skipped.
-  // The last element(s) of dynChildren might contain DOT vars iterators. They
-  // will be picked up automatically if needed.
+  ulong getMaxInScopeVarId() const;
+
+  const std::vector<PlanIter_t>& getArgValues() const { return theArgValues; }
+
+  void setArgumentValue(csize pos, const PlanIter_t& value);
+
+  bool isArgumentApplied(csize pos) const;
+
   PlanIter_t getImplementation(
-      const std::vector<PlanIter_t>& dynChildren,
+      const std::vector<PlanIter_t>& argValues,
       CompilerCB* ccb);
-
-  const store::Item_t getFunctionName() const;
-
-  csize getArity() const;
-  
-  // returns the arity of the function before any partial application
-  csize getStartArity() const;
-
-  const signature& getSignature() const;
-  
-  bool isInline() const { return theFunctionItemInfo->theIsInline; }
-  
-  bool isCoercion() const { return theFunctionItemInfo->theIsCoercion; }
-
+  
   zstring show() const;
 };
 

=== modified file 'src/runtime/hof/function_item_iter.cpp'
--- src/runtime/hof/function_item_iter.cpp	2013-04-10 21:01:35 +0000
+++ src/runtime/hof/function_item_iter.cpp	2013-04-24 02:27:27 +0000
@@ -42,7 +42,10 @@
       const QueryLoc& loc,
       FunctionItemInfo* fnInfo)
   :
-  NaryBaseIterator<FunctionItemIterator, PlanIteratorState>(sctx, loc, fnInfo->theScopedVarsIterators),
+  NaryBaseIterator<FunctionItemIterator,
+                   PlanIteratorState>(sctx,
+                                      loc,
+                                      fnInfo->theInScopeVarIterators),
   theFunctionItemInfo(fnInfo)
 {
 }
@@ -63,20 +66,24 @@
 
 bool FunctionItemIterator::nextImpl(store::Item_t& result, PlanState& planState) const
 {
+  csize numOuterVars;
   PlanIteratorState* state;
   DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
 
-  // This portion is taken from the eval iterator
+  numOuterVars = theFunctionItemInfo->theInScopeVarNames.size();
+
+  if (numOuterVars > 0)
   {
-    // Create the dynamic context for the eval query
     std::auto_ptr<dynamic_context> evalDctx;
     evalDctx.reset(new dynamic_context(planState.theGlobalDynCtx));
 
-    // Import the outer environment.
-    importOuterEnv(planState,
-                   theFunctionItemInfo->theCCB,
-                   theFunctionItemInfo->theClosureSctx,
-                   evalDctx.get());
+    for (csize i = 0; i < numOuterVars; ++i)
+    {
+      // hof ???? pre-allocate the wrappers.
+      store::Iterator_t iter = new PlanIteratorWrapper(theChildren[i], planState);
+
+      evalDctx->add_variable(theFunctionItemInfo->theInScopeVarIds[i], iter);
+    }
 
     if (theFunctionItemInfo->theIsCoercion)
     {
@@ -89,102 +96,16 @@
 
     result = new FunctionItem(theFunctionItemInfo, evalDctx.release());
   }
+  else
+  {
+    result = new FunctionItem(theFunctionItemInfo, NULL);
+  }
 
   STACK_PUSH(result != NULL, state);
   STACK_END(state);
 }
 
 
-/********************************************************************************
-
-  These functions are copied from the EvalIterator -- maybe they could be shared.
-
-********************************************************************************/
-
-/****************************************************************************//**
-  This method imports a static and dynamic environment from the quter query into
-  the eval query. In particular:
-
-  (a) imports into the importSctx all the outer vars of the eval query
-  (b) imports into the importSctx all the ns bindings of the outer query at the
-      place where the eval call appears at
-  (c) Copies all the var values from the outer-query global dctx into the eval-
-      query dctx.
-  (d) For each of the non-global outer vars, places its value into the eval dctx.
-      The var value is represented as a PlanIteratorWrapper over the subplan that
-      evaluates the domain expr of the eval var.
-  (e) Computes the max var id of all the var values set in steps (c) and (d).
-      This max varid will be passed to the compiler of the eval query so that
-      the varids that will be generated for the eval query will not conflict with
-      the varids of the outer vars and the outer-query global vars.
-********************************************************************************/
-void FunctionItemIterator::importOuterEnv(
-    PlanState& planState,
-    CompilerCB* evalCCB,
-    static_context* importSctx,
-    dynamic_context* evalDctx) const
-{
-  // Copy all the var values from the outer-query global dctx into the eval-query
-  // dctx. This is need to handle the following scenario: (a) $x is an outer-query
-  // global var that is not among the outer vars of the eval query (because $x was
-  // hidden at the point where the eval call is made inside the outer query), and
-  // (b) foo() is a function decalred in the outer query that accessed $x and is
-  // invoked by the eval query. The copying must be done using the same positions
-  // (i.e., var ids) in the eval dctx as in the outer-query dctx.
-
-  dynamic_context* outerDctx = evalDctx->getParent();
-
-  const std::vector<dynamic_context::VarValue>& outerGlobalValues =
-  outerDctx->get_variables();
-
-  csize numOuterGlobalVars = outerGlobalValues.size();
-
-  for (csize i = 0; i < numOuterGlobalVars; ++i)
-  {
-    const dynamic_context::VarValue& outerVar = outerGlobalValues[i];
-
-    if (!outerVar.isSet())
-      continue;
-
-    ulong outerVarId = static_cast<ulong>(i);
-
-    store::Item_t itemValue;
-    store::TempSeq_t seqValue;
-
-    if (outerVar.hasItemValue())
-    {
-      store::Item_t value = outerVar.theValue.item;
-      evalDctx->add_variable(outerVarId, value);
-    }
-    else
-    {
-      store::Iterator_t iteValue = outerVar.theValue.temp_seq->getIterator();
-      evalDctx->add_variable(outerVarId, iteValue);
-    }
-  }
-
-  // Import the outer vars. Specifically, for each outer var:
-  // (a) create a declaration inside the importSctx.
-  // (b) Set its var id
-  // (c) If it is not a global one, set its value within the eval dctx.
-  csize curChild = -1;
-
-  csize numOuterVars = theFunctionItemInfo->theScopedVarsNames.size();
-
-  for (csize i = 0; i < numOuterVars; ++i)
-  {
-    if (!theFunctionItemInfo->theIsGlobalVar[i])
-    {
-      ++curChild;
-
-      store::Iterator_t iter = new PlanIteratorWrapper(theChildren[curChild], planState);
-
-      evalDctx->add_variable(theFunctionItemInfo->theVarId[i], iter);
-    }
-  }
-}
-
-
 NARY_ACCEPT(FunctionItemIterator)
 
 

=== modified file 'src/runtime/hof/function_item_iter.h'
--- src/runtime/hof/function_item_iter.h	2013-03-27 07:55:14 +0000
+++ src/runtime/hof/function_item_iter.h	2013-04-24 02:27:27 +0000
@@ -29,7 +29,8 @@
 
 
 /*******************************************************************************
-  An iterator that creates and returns dynamic function items
+  An iterator that creates and returns a function item. The children of the
+  iterator are the subplans that compute the values of the outer variables.
 ********************************************************************************/
 class FunctionItemIterator : public NaryBaseIterator<FunctionItemIterator,
                                                      PlanIteratorState>
@@ -59,13 +60,6 @@
   void accept(PlanIterVisitor& v) const;
 
   bool nextImpl(store::Item_t& result, PlanState& planState) const;
-
-protected:
-  void importOuterEnv(
-      PlanState& planState,
-      CompilerCB* evalCCB,
-      static_context* importSctx,
-      dynamic_context* evalDctx) const;
 };
 
 

=== modified file 'test/fots/CMakeLists.txt'
--- test/fots/CMakeLists.txt	2013-04-23 20:25:27 +0000
+++ test/fots/CMakeLists.txt	2013-04-24 02:27:27 +0000
@@ -342,7 +342,6 @@
 EXPECTED_FOTS_FAILURE (DISPUTED prod-FunctionDecl function-decl-reserved-function-names-029 21568)
 EXPECTED_FOTS_FAILURE (DISPUTED prod-FunctionDecl function-decl-reserved-function-names-031 21568)
 EXPECTED_FOTS_FAILURE (prod-InstanceofExpr instanceof113 0)
-EXPECTED_FOTS_FAILURE (prod-InstanceofExpr instanceof131 0)
 EXPECTED_FOTS_FAILURE (prod-InstanceofExpr instanceof139 1160559)
 EXPECTED_FOTS_FAILURE (prod-InstanceofExpr instanceof140 0)
 EXPECTED_FOTS_FAILURE (prod-InstanceofExpr cbcl-instance-of-001 0)
@@ -433,8 +432,6 @@
 EXPECTED_FOTS_FAILURE (xs-token cbcl-token-004 0)
 EXPECTED_FOTS_FAILURE (fn-fold-left fold-left-009 0)
 EXPECTED_FOTS_FAILURE (fn-function-lookup fn-function-lookup-062 0)
-EXPECTED_FOTS_FAILURE (fn-function-lookup fn-function-lookup-402 0)
-EXPECTED_FOTS_FAILURE (fn-function-lookup fn-function-lookup-404 0)
 EXPECTED_FOTS_FAILURE (fn-function-lookup fn-function-lookup-494 0)
 EXPECTED_FOTS_FAILURE (fn-map-pairs fn-map-pairs-026 0)
 EXPECTED_FOTS_FAILURE (misc-HigherOrderFunctions xqhof12 0)

=== modified file 'test/fots_driver/fots-driver.xq'
--- test/fots_driver/fots-driver.xq	2013-04-17 23:25:47 +0000
+++ test/fots_driver/fots-driver.xq	2013-04-24 02:27:27 +0000
@@ -272,7 +272,7 @@
  : http://dev.w3.org/2011/QT3-test-suite/guide/reporting.html:
  :
  : 'pass' The test-case was run and the assertion(s) was(were) satisfied.
- : 'fail' The test-case was run and the assertion(s) was(were) satisfied.
+ : 'fail' The test-case was run and the assertion(s) was(were) not satisfied.
  : 'wrongError' The test-case was run; the expected results permitted an error
  :              to be reported; the actual result was an error, but not with
  :              the expected error code.
@@ -436,7 +436,7 @@
  : http://dev.w3.org/2011/QT3-test-suite/guide/reporting.html:
  :
  : 'pass' The test-case was run and the assertion(s) was(were) satisfied.
- : 'fail' The test-case was run and the assertion(s) was(were) satisfied.
+ : 'fail' The test-case was run and the assertion(s) was(were) not satisfied.
  : 'wrongError' The test-case was run; the expected results permitted an error
  :              to be reported; the actual result was an error, but not with
  :              the expected error code.
@@ -948,9 +948,9 @@
       setting a COLLATION or COLLECTION but they still PASS even if this setting
       is not done. That is why we first run the test case.
      :)
-    else if(exists($prerequisitesError)) then
+    else if (exists($prerequisitesError)) then
       feedback:not-run($case, $prerequisitesError)
-    else if($expFailureTC/@finalStatus = "disputed") then
+    else if ($expFailureTC/@finalStatus = "disputed") then
       feedback:disputed($case,
                         concat("For details please see https://www.w3.org/Bugs/Public/show_bug.cgi?id=",
                                $expFailureTC/@bug))