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

[Markos Zaharioudakis]

1. optimization: replaced use of create_value_type() in runtime with getTypeCode()
2. optimized switch expression

1. optimization: replaced use of create_value_type() in runtime with getTypeCode()
2. optimized switch expression

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

11139. By Markos Zaharioudakis on 2013-06-11

optimized switch expression

[Markos Zaharioudakis (markos-za)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/markos-scratch-2013-06-11T10-20-00.706Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job markos-scratch-2013-06-11T10-20-00.706Z is finished. The final status was:

All tests succeeded!

=== modified file 'ChangeLog'
--- ChangeLog	2013-06-08 05:33:57 +0000
+++ ChangeLog	2013-06-11 09:57:50 +0000
@@ -13,6 +13,8 @@
   * Optimized implementation of fn:deep-equal
   * No need to apply document ordering on the domain expression of a FOR clause
     if the FOR clause is followed by an orderby or groupby clause.
+  * Replaced use of create_value_type() in runtime with getTypeCode().
+  * Optimized switch expression
 
 Bug Fixes/Other Changes:
   * Fixed bug #1117952 (Improve XML error output format)
 
=== modified file 'src/compiler/translator/translator.cpp'
--- src/compiler/translator/translator.cpp	2013-06-09 08:09:40 +0000
+++ src/compiler/translator/translator.cpp	2013-06-11 09:57:50 +0000
@@ -7977,41 +7977,16 @@
 
   se = wrap_in_atomization(se);
 
-  // atomizedFlwor = [let $atomv := data(E) return NULL]
-  var_expr* atomv = create_temp_var(v.get_switch_expr()->get_location(),
-                                     var_expr::let_var);
-
-  expr* atomizedFlwor = wrap_in_let_flwor(se, atomv, NULL);
-
-  // TODO: cast as xs:string should not really be necessary
-  // atomizedFlwor =
-  //  [let $atomv := data(E)
-  //   return
-  //     let $sv :=
-  //          if ($atomv instanceof xs:untypedAtomic)
-  //          then $atomv cast as xs:string
-  //          else $atomv
-  //     return NULL]
-  static_cast<flwor_expr*>(atomizedFlwor)->set_return_expr(
-      CREATE(if)(theRootSctx,
-                 theUDF,
-                 loc,
-                 CREATE(instanceof)(theRootSctx,
-                                    theUDF,
-                                    loc,
-                                    atomv,
-                                    theRTM.UNTYPED_ATOMIC_TYPE_ONE),
-                 CREATE(cast)(theRootSctx,
-                              theUDF,
-                              loc,
-                              atomv,
-                              theRTM.STRING_TYPE_ONE,
-                              false),
-                 atomv));
-
-  // flworExpr = [let $sv := atomizedFlwor return NULL]
+  se = CREATE(treat)(theRootSctx, theUDF, loc,
+                     se,
+                     theRTM.ANY_ATOMIC_TYPE_QUESTION,
+                     TREAT_TYPE_MATCH,
+                     false);
+
+  // flworExpr = [let $sv := data(E) treat as xs:anyAtomicType? return NULL]
   var_expr* sv = create_temp_var(v.get_switch_expr()->get_location(), var_expr::let_var);
-  expr* flworExpr = wrap_in_let_flwor(atomizedFlwor, sv, NULL);
+
+  expr* flworExpr = wrap_in_let_flwor(se, sv, NULL);
 
   // retExpr = [Ed]
   v.get_default_expr()->accept(*this);
@@ -8039,7 +8014,7 @@
       operand->accept(*this);
 
       expr* operandExpr = pop_nodestack();
-      operandExpr = wrap_in_atomization(operandExpr);
+
       operandExpr = CREATE(fo)(theRootSctx,
                                theUDF,
                                loc,
@@ -8047,6 +8022,8 @@
                                sv,
                                operandExpr);
       
+      normalize_fo(static_cast<fo_expr*>(operandExpr));
+
       condOperands.push_back(operandExpr);
     } // for
 
@@ -8056,20 +8033,15 @@
     }
     else if (condOperands.size() > 1)
     {
-      condExpr = theExprManager->
-      create_fo_expr(theRootSctx,
-                     theUDF,
-                     loc,
-                     BUILTIN_FUNC(OP_OR_N),
-                     condOperands);
+      condExpr = CREATE(fo)(theRootSctx, theUDF, loc,
+                            BUILTIN_FUNC(OP_OR_N), condOperands);
     }
 
     switchCaseClause->get_return_expr()->accept(*this);
     expr* caseReturnExpr = pop_nodestack();
 
     // retExpr = [if (condExpr) then caseReturnExpr else retExpr]
-    retExpr = theExprManager->
-    create_if_expr(theRootSctx, theUDF, loc, condExpr, caseReturnExpr, retExpr);
+    retExpr = CREATE(if)(theRootSctx, theUDF, loc, condExpr, caseReturnExpr, retExpr);
 
   } // for
 
@@ -8088,6 +8060,7 @@
   ZORBA_ASSERT (false);
 }
 
+
 void* begin_visit(const SwitchCaseClause& v)
 {
   TRACE_VISIT();
@@ -8095,7 +8068,7 @@
   return NULL;
 }
 
-void end_visit (const SwitchCaseClause& v, void* /*visit_state*/)
+void end_visit(const SwitchCaseClause& v, void* /*visit_state*/)
 {
   TRACE_VISIT_OUT ();
   // shouldn't get here, begin_visit() rejects visitor
 
=== modified file 'src/functions/func_booleans_impl.cpp'
--- src/functions/func_booleans_impl.cpp	2013-02-07 17:24:36 +0000
+++ src/functions/func_booleans_impl.cpp	2013-06-11 09:57:50 +0000
@@ -868,8 +868,8 @@
 // http://www.w3.org/TR/xquery-11/#dt-equivalence-two-atomic-values
 DECL(sctx, op_atomic_values_equivalent,
      (createQName(zorba_ns, "", "atomic-values-equivalent"),
-      GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR,
-      GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR,
+      GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_QUESTION,
+      GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_QUESTION,
       GENV_TYPESYSTEM.BOOLEAN_TYPE_ONE));
 
 }
 
=== modified file 'src/runtime/booleans/BooleanImpl.cpp'
--- src/runtime/booleans/BooleanImpl.cpp	2013-05-08 20:14:47 +0000
+++ src/runtime/booleans/BooleanImpl.cpp	2013-06-11 09:57:50 +0000
@@ -121,7 +121,6 @@
     // node => true
     result = negate ^ true;
   }
-#ifdef ZORBA_WITH_JSON
   else if (item->isJSONItem())
   {
     xqtref_t type = tm->create_value_type(item);
@@ -129,7 +128,6 @@
     RAISE_ERROR(err::FORG0006, loc,
     ERROR_PARAMS(ZED(BadArgTypeForFn_2o34o), *type, "fn:boolean" ));
   }
-#endif
   else
   {
     store::SchemaTypeCode type = item->getTypeCode();
@@ -1221,86 +1219,67 @@
     store::Item_t& result,
     PlanState& planState) const
 {
-  store::Item_t lItem0, lItem1, tItem0, tItem1;
-  int count0, count1;
-  xqtref_t type0, type1;
+  store::Item_t lItem0, lItem1;
+  store::SchemaTypeCode type0;
+  store::SchemaTypeCode type1;
   bool are_equivalent;
 
-  RootTypeManager& rtm = GENV_TYPESYSTEM;
-  TypeManager* tm = theSctx->get_typemanager();
-
   PlanIteratorState* state;
   DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
 
-  count0 = 0;
-  count1 = 0;
-
   if (consumeNext(lItem0, theChild0.getp(), planState))
-    count0 = 1;
-
-  if (count0 && consumeNext(tItem0, theChild0.getp(), planState))
-    throw XQUERY_EXCEPTION(
-      err::XPTY0004,
-      ERROR_PARAMS( ZED( NoSeqTestedForAtomicEquiv ) ),
-      ERROR_LOC( loc )
-    );
-
-  if (consumeNext(lItem1, theChild1.getp(), planState))
-    count1 = 1;
-
-  if (count1 && consumeNext(tItem1, theChild1.getp(), planState))
-    throw XQUERY_EXCEPTION(
-      err::XPTY0004,
-      ERROR_PARAMS( ZED( NoSeqTestedForAtomicEquiv ) ),
-      ERROR_LOC( loc )
-    );
-
-  if (count0 == 0 && count1 == 0)
+  {
+    if (consumeNext(lItem1, theChild1.getp(), planState))
+    {
+      type0 = lItem0->getTypeCode();
+      type1 = lItem1->getTypeCode();
+
+      if ((TypeOps::is_subtype(type0, store::XS_FLOAT) ||
+           TypeOps::is_subtype(type0, store::XS_DOUBLE))
+          &&
+          (TypeOps::is_subtype(type1, store::XS_FLOAT) ||
+           TypeOps::is_subtype(type1, store::XS_DOUBLE))
+          &&
+          lItem0->isNaN() && lItem1->isNaN())
+      {
+        STACK_PUSH(GENV_ITEMFACTORY->createBoolean(result, true), state);
+      }
+      else
+      {
+        try
+        {
+          are_equivalent = CompareIterator::valueEqual(loc,
+                                                       lItem0,
+                                                       lItem1,
+                                                       theTypeManager,
+                                                       theTimezone,
+                                                       theCollation);
+        }
+        catch (ZorbaException const& e)
+        {
+          if (e.diagnostic() == err::XPTY0004)
+            are_equivalent = false;
+          else
+            throw;
+        }
+
+        STACK_PUSH(GENV_ITEMFACTORY->createBoolean(result, are_equivalent),
+                   state);
+      }
+    }
+    else
+    {
+      STACK_PUSH(GENV_ITEMFACTORY->createBoolean(result, false), state);
+    }
+  }
+  else if (consumeNext(lItem1, theChild1.getp(), planState))
+  {
+    STACK_PUSH(GENV_ITEMFACTORY->createBoolean(result, false), state);
+  }
+  else
   {
     STACK_PUSH(GENV_ITEMFACTORY->createBoolean(result, true), state);
   }
-  else if ((count0 == 0 && count1 == 1) || (count0 == 1 && count1 == 0))
-  {
-    STACK_PUSH(GENV_ITEMFACTORY->createBoolean(result, false), state);
-  }
-  else
-  {
-    type0 = theTypeManager->create_value_type(lItem0.getp());
-    type1 = theTypeManager->create_value_type(lItem1.getp());
-
-    if ((TypeOps::is_subtype(tm, *type0, *rtm.FLOAT_TYPE_ONE) ||
-         TypeOps::is_subtype(tm, *type0, *rtm.DOUBLE_TYPE_ONE))
-        &&
-        (TypeOps::is_subtype(tm, *type1, *rtm.FLOAT_TYPE_ONE) ||
-         TypeOps::is_subtype(tm, *type1, *rtm.DOUBLE_TYPE_ONE))
-        &&
-        lItem0->isNaN() && lItem1->isNaN())
-    {
-      STACK_PUSH(GENV_ITEMFACTORY->createBoolean(result, true), state);
-    }
-    else
-    {
-      try
-      {
-        are_equivalent = CompareIterator::valueEqual(loc,
-                                                     lItem0,
-                                                     lItem1,
-                                                     theTypeManager,
-                                                     theTimezone,
-                                                     theCollation);
-      }
-      catch (ZorbaException const& e)
-      {
-        if (e.diagnostic() == err::XPTY0004)
-          are_equivalent = false;
-        else
-          throw;
-      }
-
-      STACK_PUSH(GENV_ITEMFACTORY->createBoolean(result, are_equivalent),
-                 state);
-    }
-  }
 
   STACK_END(state);
 }
 
=== modified file 'src/runtime/core/arithmetic_impl.cpp'
--- src/runtime/core/arithmetic_impl.cpp	2013-05-08 20:14:47 +0000
+++ src/runtime/core/arithmetic_impl.cpp	2013-06-11 09:57:50 +0000
@@ -167,16 +167,16 @@
   assert(n0->isAtomic());
   assert(n1->isAtomic());
 
-  xqtref_t type0 = tm->create_value_type(n0);
-  xqtref_t type1 = tm->create_value_type(n1);
+  store::SchemaTypeCode type0 = n0->getTypeCode();
+  store::SchemaTypeCode type1 = n1->getTypeCode();
   
-  if (TypeOps::is_numeric(tm, *type0) &&
-      (TypeOps::is_subtype(tm, *type1, *rtm.YM_DURATION_TYPE_ONE) ||
-       TypeOps::is_subtype(tm, *type1, *rtm.DT_DURATION_TYPE_ONE)))
+  if (TypeOps::is_numeric(type0) &&
+      (TypeOps::is_subtype(type1, store::XS_YM_DURATION) ||
+       TypeOps::is_subtype(type1, store::XS_DT_DURATION)))
   {
     GenericCast::castToAtomic(n0, n0, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, aLoc);
 
-    if (TypeOps::is_subtype(tm, *type1, *rtm.YM_DURATION_TYPE_ONE))
+    if (TypeOps::is_subtype(type1, store::XS_YM_DURATION))
     {
       return Operation::template
              compute<store::XS_DOUBLE, store::XS_YM_DURATION>
@@ -189,44 +189,44 @@
              (result, dctx, tm, &aLoc, n0, n1);
     }
   }
-  else if (TypeOps::is_subtype(tm, *type0, *rtm.DT_DURATION_TYPE_ONE) &&
-           TypeOps::is_subtype(tm, *type1, *rtm.TIME_TYPE_ONE))
+  else if (TypeOps::is_subtype(type0, store::XS_DT_DURATION) &&
+           TypeOps::is_subtype(type1, store::XS_TIME))
   {
     return Operation::template
            compute<store::XS_DURATION,store::XS_TIME>
            (result, dctx, tm, &aLoc, n0, n1);
   }
-  else if (TypeOps::is_subtype(tm, *type0, *rtm.YM_DURATION_TYPE_ONE))
+  else if (TypeOps::is_subtype(type0, store::XS_YM_DURATION))
   {
-    if(TypeOps::is_numeric(tm, *type1))
+    if (TypeOps::is_numeric(type1))
     {
       GenericCast::castToAtomic(n1, n1, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, aLoc);
       return Operation::template
              compute<store::XS_YM_DURATION,store::XS_DOUBLE>
              (result, dctx, tm, &aLoc, n0, n1);
     }
-    else if (TypeOps::is_subtype(tm, *type1, *rtm.DATETIME_TYPE_ONE))
+    else if (TypeOps::is_subtype(type1, store::XS_DATETIME))
     {
       return Operation::template
              compute<store::XS_DURATION,store::XS_DATETIME>
              (result, dctx, tm, &aLoc, n0, n1);
     }
-    else if (TypeOps::is_subtype(tm, *type1, *rtm.DATE_TYPE_ONE))
+    else if (TypeOps::is_subtype(type1, store::XS_DATE))
     {
       return Operation::template
              compute<store::XS_DURATION,store::XS_DATE>
              (result, dctx, tm, &aLoc, n0, n1);
     }
-    else if (TypeOps::is_equal(tm, *type0, *type1))
+    else if (type0 == type1)
     {
       return Operation::template
       computeSingleType<store::XS_YM_DURATION>
       (result, dctx, tm, &aLoc, n0, n1);
     }
   }
-  else if (TypeOps::is_subtype(tm, *type0, *rtm.DT_DURATION_TYPE_ONE))
+  else if (TypeOps::is_subtype(type0, store::XS_DT_DURATION))
   {
-    if(TypeOps::is_numeric(tm, *type1))
+    if (TypeOps::is_numeric(type1))
     {
       GenericCast::castToAtomic(n1, n1, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, aLoc);
 
@@ -234,94 +234,96 @@
              compute<store::XS_DT_DURATION,store::XS_DOUBLE>
              (result, dctx, tm, &aLoc, n0, n1);
     }
-    else if (TypeOps::is_subtype(tm, *type1, *rtm.DATETIME_TYPE_ONE))
+    else if (TypeOps::is_subtype(type1, store::XS_DATETIME))
     {
       return Operation::template 
              compute<store::XS_DURATION,store::XS_DATETIME>
              (result, dctx, tm, &aLoc, n0, n1);
     }
-    else if (TypeOps::is_subtype(tm, *type1, *rtm.DATE_TYPE_ONE))
+    else if (TypeOps::is_subtype(type1, store::XS_DATE))
     {
       return Operation::template
              compute<store::XS_DURATION,store::XS_DATE>
              (result, dctx, tm, &aLoc, n0, n1);
     }
-    else if (TypeOps::is_equal(tm, *type0, *type1))
+    else if (type0 == type1)
     {
       return Operation::template
              computeSingleType<store::XS_DT_DURATION>
              (result, dctx, tm, &aLoc, n0, n1);
     }
   }
-  else if(TypeOps::is_subtype(tm, *type0, *rtm.DATETIME_TYPE_ONE))
+  else if (TypeOps::is_subtype(type0, store::XS_DATETIME))
   {
-    if(TypeOps::is_subtype(tm, *type1, *rtm.DATETIME_TYPE_ONE))
+    if (TypeOps::is_subtype(type1, store::XS_DATETIME))
     {
       return Operation::template
              compute<store::XS_DATETIME,store::XS_DATETIME>
              (result, dctx, tm, &aLoc, n0, n1);
     }
-    else if (TypeOps::is_subtype(tm, *type1, *rtm.YM_DURATION_TYPE_ONE ))
+    else if (TypeOps::is_subtype(type1, store::XS_YM_DURATION))
     {
       return Operation::template
              compute<store::XS_DATETIME,store::XS_DURATION>
             (result, dctx, tm, &aLoc, n0, n1);
     }
-    else if (TypeOps::is_subtype(tm, *type1, *rtm.DT_DURATION_TYPE_ONE ))
+    else if (TypeOps::is_subtype(type1, store::XS_DT_DURATION))
     {
       return Operation::template
              compute<store::XS_DATETIME,store::XS_DURATION>
             (result, dctx, tm, &aLoc, n0, n1);
     }
   }
-  else if(TypeOps::is_subtype(tm, *type0, *rtm.DATE_TYPE_ONE))
+  else if (TypeOps::is_subtype(type0, store::XS_DATE))
   {
-    if (TypeOps::is_subtype(tm, *type1, *rtm.DATE_TYPE_ONE))
+    if (TypeOps::is_subtype(type1, store::XS_DATE))
     {
       return Operation::template
              compute<store::XS_DATE,store::XS_DATE>
              (result, dctx, tm, &aLoc, n0, n1);
     }
-    else if (TypeOps::is_subtype(tm, *type1, *rtm.YM_DURATION_TYPE_ONE))
+    else if (TypeOps::is_subtype(type1, store::XS_YM_DURATION))
     {
       return Operation::template
              compute<store::XS_DATE,store::XS_DURATION>
              (result, dctx, tm, &aLoc, n0, n1);
     }
-    else if (TypeOps::is_subtype(tm, *type1, *rtm.DT_DURATION_TYPE_ONE))
+    else if (TypeOps::is_subtype(type1, store::XS_DT_DURATION))
     {
       return Operation::template
              compute<store::XS_DATE,store::XS_DURATION>
              (result, dctx, tm, &aLoc, n0, n1);
     }
   }
-  else if(TypeOps::is_subtype(tm, *type0, *rtm.TIME_TYPE_ONE))
+  else if (TypeOps::is_subtype(type0, store::XS_TIME))
   {
-    if(TypeOps::is_subtype(tm, *type1, *rtm.TIME_TYPE_ONE))
+    if (TypeOps::is_subtype(type1, store::XS_TIME))
     {
       return Operation::template
              compute<store::XS_TIME,store::XS_TIME>
              (result, dctx, tm, &aLoc, n0, n1);
     }
-    else if (TypeOps::is_subtype(tm, *type1, *rtm.DT_DURATION_TYPE_ONE))
+    else if (TypeOps::is_subtype(type1, store::XS_DT_DURATION))
     {
       return Operation::template 
              compute<store::XS_TIME,store::XS_DURATION>
              (result, dctx, tm, &aLoc, n0, n1);
     }
   }
-  else if ((TypeOps::is_numeric(tm, *type0) ||
-            TypeOps::is_subtype(tm, *type0, *rtm.UNTYPED_ATOMIC_TYPE_ONE)) &&
-           ( TypeOps::is_numeric(tm, *type1) ||
-             TypeOps::is_subtype(tm, *type1, *rtm.UNTYPED_ATOMIC_TYPE_ONE)))
+  else if ((TypeOps::is_numeric(type0) || type0 == store::XS_UNTYPED_ATOMIC) &&
+           (TypeOps::is_numeric(type1) || type1 == store::XS_UNTYPED_ATOMIC))
   {
     return NumArithIterator<Operation>::
            computeAtomic(result, dctx, tm, aLoc, n0, type0, n1, type1);
   }
-  
-  
-  RAISE_ERROR(err::XPTY0004, aLoc,
-  ERROR_PARAMS(ZED(ArithOpNotDefinedBetween_23), *type0, *type1));
+
+  {  
+    xqtref_t type0 = tm->create_value_type(n0);
+    xqtref_t type1 = tm->create_value_type(n1);
+
+    RAISE_ERROR(err::XPTY0004, aLoc,
+    ERROR_PARAMS(ZED(ArithOpNotDefinedBetween_23), *type0, *type1));
+  }
 
   return false; // suppresses wanring
 }
 
=== modified file 'src/runtime/indexing/index_ddl.cpp'
--- src/runtime/indexing/index_ddl.cpp	2013-05-02 18:34:27 +0000
+++ src/runtime/indexing/index_ddl.cpp	2013-06-11 09:57:50 +0000
@@ -70,7 +70,8 @@
 
 
 /*******************************************************************************
-
+  This function is called from the probe function to chaeck that the type of
+  the probing key is consistent with the index declaration.
 ********************************************************************************/
 static void checkKeyType(
     const QueryLoc& loc,
@@ -138,6 +139,7 @@
     {
       GENV_STORE.getItemFactory()->
       createDouble(searchKey, xs_float(searchKey->getDecimalValue()));
+
       return;
     }
 
@@ -1217,7 +1219,6 @@
     PlanState& planState) const
 {
   TypeManager* tm = theSctx->get_typemanager();
-  RootTypeManager& rtm = GENV_TYPESYSTEM;
   store::IndexCondition_t cond;
   csize numChildren = theChildren.size();
   csize numNonKeyParams = (theSkip ? 2 : 1);
@@ -1262,37 +1263,37 @@
     if (state->theIndexDecl->isGeneral() &&
         (state->theIndexDecl->getKeyTypes())[keyNo] == NULL)
     {
-      xqtref_t leftType;
-      xqtref_t rightType;
+      store::SchemaTypeCode leftType;
+      store::SchemaTypeCode rightType;
 
       if (tempLeft != NULL)
       {
-        leftType = tm->create_value_type(tempLeft);
+        leftType = tempLeft->getTypeCode();
           
-        if (TypeOps::is_equal(tm, *leftType, *rtm.UNTYPED_ATOMIC_TYPE_ONE))
+        if (leftType == store::XS_UNTYPED_ATOMIC)
         {
           zstring str = tempLeft->getStringValue();
           GENV_ITEMFACTORY->createString(tempLeft, str);
-          leftType = rtm.STRING_TYPE_ONE;
+          leftType = store::XS_STRING;
         }
       }
         
       if (tempRight != NULL)
       {
-        rightType = tm->create_value_type(tempRight);
+        rightType = tempRight->getTypeCode();
           
-        if (TypeOps::is_equal(tm, *rightType, *rtm.UNTYPED_ATOMIC_TYPE_ONE))
+        if (rightType == store::XS_UNTYPED_ATOMIC)
         {
           zstring str = tempRight->getStringValue();
           GENV_ITEMFACTORY->createString(tempRight, str);
-          rightType = rtm.STRING_TYPE_ONE;
+          rightType = store::XS_STRING;
         }
       }
         
-      if (leftType != NULL && rightType != NULL)
+      if (tempLeft != NULL && tempRight != NULL)
       {
-        if (!TypeOps::is_subtype(tm, *leftType, *rightType) &&
-            !TypeOps::is_subtype(tm, *rightType, *leftType))
+        if (!TypeOps::is_subtype(leftType, rightType) &&
+            !TypeOps::is_subtype(rightType, leftType))
         {
           RAISE_ERROR(zerr::ZDDY0034_INDEX_RANGE_VALUE_PROBE_BAD_KEY_TYPES, loc,
           ERROR_PARAMS(state->theIndexDecl->getName()->getStringValue()));
 
=== modified file 'src/runtime/maths/maths_impl.cpp'
--- src/runtime/maths/maths_impl.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/maths/maths_impl.cpp	2013-06-11 09:57:50 +0000
@@ -30,6 +30,8 @@
 #include "store/api/item.h"
 
 #include "diagnostics/xquery_diagnostics.h"
+#include "diagnostics/util_macros.h"
+
 #include "zorbatypes/numconversions.h"
 
 namespace zorba {
@@ -345,44 +347,27 @@
   {
     if (consumeNext(n1, this->theChild1.getp(), planState))
     {
+      assert(n1->isAtomic());
+
       {
-        xqtref_t type;
-
         const TypeManager* tm = theSctx->get_typemanager();
-
         const RootTypeManager& rtm = GENV_TYPESYSTEM;
+
         xs_double doub1 = n0->getDoubleValue();
-        //xs_double  doub2 = n1->getDoubleValue();
-
-        //GENV_ITEMFACTORY->createDouble(result, doub1.pow(doub2));
-
-        assert(n1->isAtomic());
-
-        type = tm->create_value_type(n1);
-
-        if (TypeOps::is_subtype(tm, *type, *rtm.UNTYPED_ATOMIC_TYPE_ONE))
+
+        store::SchemaTypeCode type1 = n1->getTypeCode();
+
+        if (type1 == store::XS_UNTYPED_ATOMIC)
         {
           GenericCast::castToAtomic(result, result, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, loc);
-          type = tm->create_value_type(result);
-        }
-
-        if (TypeOps::is_subtype(tm, *type, *rtm.DOUBLE_TYPE_ONE))
-        {
-          GENV_ITEMFACTORY->createDouble(result, doub1.pow(n1->getDoubleValue()));
-        }
-        else if (TypeOps::is_subtype(tm, *type, *rtm.FLOAT_TYPE_ONE))
-        {
-          store::Item_t n1_double;
-          GenericCast::castToAtomic(n1_double,
-                                    n1,
-                                    rtm.DOUBLE_TYPE_ONE.getp(),
-                                    tm,
-                                    NULL,
-                                    loc);
-
-          GENV_ITEMFACTORY->createDouble(result, doub1.pow(n1_double->getDoubleValue()));
-        }
-        else if (TypeOps::is_subtype(tm, *type, *rtm.INTEGER_TYPE_ONE))
+
+          GENV_ITEMFACTORY->createDouble(result, doub1.pow(n1->getDoubleValue()));
+        }
+        else if (type1 == store::XS_DOUBLE || type1 == store::XS_FLOAT)
+        {
+          GENV_ITEMFACTORY->createDouble(result, doub1.pow(n1->getDoubleValue()));
+        }
+        else if (type1 == store::XS_INTEGER)
         {
           xs_integer n1_integer = n1->getIntegerValue();
           try
@@ -390,16 +375,13 @@
             xs_int const n1_int = to_xs_int(n1_integer);
             GENV_ITEMFACTORY->createDouble(result, doub1.pow(n1_int));
           }
-          catch ( std::range_error const& )
+          catch (std::range_error const&)
           {
-            throw XQUERY_EXCEPTION(
-              err::XPTY0004,
-              ERROR_PARAMS( ZED( NoCastToCInt_2 ), n1_integer ),
-              ERROR_LOC( loc )
-            );
+            RAISE_ERROR(err::XPTY0004, loc,
+            ERROR_PARAMS(ZED(NoCastToCInt_2), n1_integer));
           }
         }
-        else if (TypeOps::is_subtype(tm, *type, *rtm.DECIMAL_TYPE_ONE))
+        else if (type1 == store::XS_DECIMAL)
         {
           store::Item_t n1_double;
           GenericCast::castToAtomic(n1_double,
@@ -413,19 +395,13 @@
         }
         else
         {
-          throw XQUERY_EXCEPTION(
-            err::XPTY0004,
-            ERROR_PARAMS( ZED( BadTypeFor_23 ), type, "math:pow" ),
-            ERROR_LOC( loc )
-          );
+          xqtref_t type = tm->create_value_type(n1);
+
+          RAISE_ERROR(err::XPTY0004, loc,
+          ERROR_PARAMS(ZED(BadTypeFor_23), type, "math:pow"));
         }
       }
 
-      if (consumeNext(n0, this->theChild0.getp(), planState) ||
-          consumeNext(n1, this->theChild1.getp(), planState))
-        throw XQUERY_EXCEPTION(
-          err::XPTY0004, ERROR_PARAMS( ZED( NoSeqForFnOp_2 ), "math:pow" )
-        );
       STACK_PUSH(true, state);
     }
   }
 
=== modified file 'src/runtime/numerics/NumericsImpl.cpp'
--- src/runtime/numerics/NumericsImpl.cpp	2013-05-05 03:16:33 +0000
+++ src/runtime/numerics/NumericsImpl.cpp	2013-06-11 09:57:50 +0000
@@ -687,8 +687,8 @@
   assert(n0->isAtomic());
   assert(n1->isAtomic());
 
-  xqtref_t type0 = tm->create_value_type(n0);
-  xqtref_t type1 = tm->create_value_type(n1);
+  store::SchemaTypeCode type0 = n0->getTypeCode();
+  store::SchemaTypeCode type1 = n1->getTypeCode();
 
   return computeAtomic(result, dctx, tm, aLoc, n0, type0, n1, type1);
 }
@@ -701,9 +701,9 @@
     const TypeManager* tm,
     const QueryLoc& aLoc,
     store::Item_t& item0,
-    xqtref_t type0,
+    store::SchemaTypeCode type0,
     store::Item_t& item1,
-    xqtref_t type1)
+    store::SchemaTypeCode type1)
 {
   bool res;
   store::Item_t n0;
@@ -711,14 +711,14 @@
 
   bool isDivision = Operation::getOperationKind() == ArithmeticConsts::DIVISION;
 
-  xqtref_t resultType = TypeOps::arithmetic_type(tm, *type0, *type1, isDivision);
+  store::SchemaTypeCode resultType = TypeOps::arithmetic_type(type0, type1, isDivision);
 
-  switch (TypeOps::get_atomic_type_code(*resultType))
+  switch (resultType)
   {
   case store::XS_DOUBLE:
   {
-    GenericCast::castToAtomic(n0, item0, &*resultType, tm, NULL, aLoc);
-    GenericCast::castToAtomic(n1, item1, &*resultType, tm, NULL, aLoc);
+    GenericCast::castToBuiltinAtomic(n0, item0, resultType, NULL, aLoc);
+    GenericCast::castToBuiltinAtomic(n1, item1, resultType, NULL, aLoc);
     
     res = Operation::template
           computeSingleType<store::XS_DOUBLE>
@@ -727,8 +727,8 @@
   }
   case store::XS_FLOAT:
   {
-    GenericCast::castToAtomic(n0, item0, &*resultType, tm, NULL, aLoc);
-    GenericCast::castToAtomic(n1, item1, &*resultType, tm, NULL, aLoc);
+    GenericCast::castToBuiltinAtomic(n0, item0, resultType, NULL, aLoc);
+    GenericCast::castToBuiltinAtomic(n1, item1, resultType, NULL, aLoc);
 
     res = Operation::template 
           computeSingleType<store::XS_FLOAT>
@@ -737,8 +737,8 @@
   }
   case store::XS_DECIMAL:
   {
-    GenericCast::castToAtomic(n0, item0, &*resultType, tm, NULL, aLoc);
-    GenericCast::castToAtomic(n1, item1, &*resultType, tm, NULL, aLoc);
+    GenericCast::castToBuiltinAtomic(n0, item0, resultType, NULL, aLoc);
+    GenericCast::castToBuiltinAtomic(n1, item1, resultType, NULL, aLoc);
 
     res = Operation::template
           computeSingleType<store::XS_DECIMAL>
@@ -747,8 +747,8 @@
   }
   case store::XS_INTEGER:
   {
-    GenericCast::castToAtomic(n0, item0, &*resultType, tm, NULL, aLoc);
-    GenericCast::castToAtomic(n1, item1, &*resultType, tm, NULL, aLoc);
+    GenericCast::castToBuiltinAtomic(n0, item0, resultType, NULL, aLoc);
+    GenericCast::castToBuiltinAtomic(n1, item1, resultType, NULL, aLoc);
 
     res = Operation::template 
           computeSingleType<store::XS_INTEGER>
@@ -757,11 +757,13 @@
   }
   default:
   {
-    throw XQUERY_EXCEPTION(
-        err::XPTY0004,
-        ERROR_PARAMS( ZED( ArithOpNotDefinedBetween_23 ), *type0, *type1 ),
-        ERROR_LOC( aLoc )
-      );
+    xqtref_t type0 = tm->create_value_type(item0);
+    xqtref_t type1 = tm->create_value_type(item1);
+
+    RAISE_ERROR(err::XPTY0004, aLoc,
+    ERROR_PARAMS(ZED(ArithOpNotDefinedBetween_23),
+                 type0->toSchemaString(),
+                 type1->toSchemaString()));
   }
   }
 
@@ -896,9 +898,8 @@
 bool OpNumericUnaryIterator::nextImpl(store::Item_t& result, PlanState& planState) const
 {
   store::Item_t item;
-  xqtref_t type;
+  store::SchemaTypeCode type;
 
-  const RootTypeManager& rtm = GENV_TYPESYSTEM;
   const TypeManager* tm = theSctx->get_typemanager();
 
   PlanIteratorState* state;
@@ -908,35 +909,35 @@
   {
     assert(item->isAtomic());
 
-    type = tm->create_value_type(item);
+    type = item->getTypeCode();
 
-    if (TypeOps::is_subtype(tm, *type, *rtm.UNTYPED_ATOMIC_TYPE_ONE ) )
+    if (type == store::XS_UNTYPED_ATOMIC)
     {
-      GenericCast::castToAtomic(item, item, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, loc);
-      type = rtm.DOUBLE_TYPE_ONE;
+      GenericCast::castToBuiltinAtomic(item, item, store::XS_DOUBLE, NULL, loc);
+      type = store::XS_DOUBLE;
     }
     
     // TODO Optimizations (e.g. if item has already the correct type and value,
     // it does not have to be created newly)
-    if (TypeOps::is_subtype(tm, *type, *rtm.DOUBLE_TYPE_ONE))
+    if (TypeOps::is_subtype(type, store::XS_DOUBLE))
     {
       GENV_ITEMFACTORY->
       createDouble(result,
                    (thePlus ? item->getDoubleValue() : -item->getDoubleValue()));
     }
-    else if ( TypeOps::is_subtype(tm, *type, *rtm.FLOAT_TYPE_ONE ) )
+    else if (TypeOps::is_subtype(type, store::XS_FLOAT))
     {
       GENV_ITEMFACTORY->
       createFloat(result,
                   (thePlus ? item->getFloatValue() : -item->getFloatValue()));
     }
-    else if ( TypeOps::is_subtype(tm, *type, *rtm.INTEGER_TYPE_ONE ) )
+    else if (TypeOps::is_subtype(type, store::XS_INTEGER))
     {
       GENV_ITEMFACTORY->
       createInteger(result,
                     (thePlus ? item->getIntegerValue() : -item->getIntegerValue()));
     }
-    else if ( TypeOps::is_subtype(tm, *type, *rtm.DECIMAL_TYPE_ONE ) )
+    else if (TypeOps::is_subtype(type, store::XS_DECIMAL))
     {
       GENV_ITEMFACTORY->
       createDecimal(result,
@@ -944,8 +945,9 @@
     }
     else
     {
+      xqtref_t type = tm->create_value_type(item);
       RAISE_ERROR(err::XPTY0004, loc,
-      ERROR_PARAMS(ZED(BadTypeFor_23), type, ZED(UnaryArithOp)));
+      ERROR_PARAMS(ZED(BadTypeFor_23), type->toSchemaString(), ZED(UnaryArithOp)));
     }
     
     STACK_PUSH(true, state);
@@ -985,7 +987,7 @@
   PlanIteratorState* state;
   DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
 
-  if (consumeNext(item, theChild.getp(), planState ))
+  if (consumeNext(item, theChild.getp(), planState))
   {
     assert(item->isAtomic());
 
 
=== modified file 'src/runtime/numerics/NumericsImpl.h'
--- src/runtime/numerics/NumericsImpl.h	2013-02-07 17:24:36 +0000
+++ src/runtime/numerics/NumericsImpl.h	2013-06-11 09:57:50 +0000
@@ -61,9 +61,9 @@
         const TypeManager* tm,
         const QueryLoc&,
         store::Item_t& item0,
-        xqtref_t type0,
+        store::SchemaTypeCode type0,
         store::Item_t& item1,
-        xqtref_t type1);
+        store::SchemaTypeCode type1);
 
 public:
   NumArithIterator(static_context* sctx, const QueryLoc&, PlanIter_t&, PlanIter_t&);
 
=== modified file 'src/runtime/numerics/numerics_impl.cpp'
--- src/runtime/numerics/numerics_impl.cpp	2013-05-02 18:34:27 +0000
+++ src/runtime/numerics/numerics_impl.cpp	2013-06-11 09:57:50 +0000
@@ -52,12 +52,9 @@
 AbsIterator::nextImpl(store::Item_t& result, PlanState& planState) const
 {
   store::Item_t item;
-  xqtref_t type;
-
+  store::SchemaTypeCode type;
   const TypeManager* tm = theSctx->get_typemanager();
 
-  const RootTypeManager& rtm = GENV_TYPESYSTEM;
-
   PlanIteratorState* state;
   DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
 
@@ -65,31 +62,31 @@
   {
     assert(result->isAtomic());
 
-    type = tm->create_value_type(result);
+    type = result->getTypeCode();
 
-    if (TypeOps::is_subtype(tm, *type, *rtm.UNTYPED_ATOMIC_TYPE_ONE))
+    if (type == store::XS_UNTYPED_ATOMIC)
     {
-      GenericCast::castToAtomic(result, result, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, loc);
-      type = tm->create_value_type(result);
+      GenericCast::castToBuiltinAtomic(result, result, store::XS_DOUBLE, NULL, loc);
+      type = store::XS_DOUBLE;
     }
 
-    if (TypeOps::is_subtype(tm, *type, *rtm.DOUBLE_TYPE_ONE))
+    if (TypeOps::is_subtype(type, store::XS_DOUBLE))
     {
       if (result->getDoubleValue().isPos() || result->getDoubleValue().isPosZero())
       {
-        if ( !TypeOps::is_equal(tm, *type, *rtm.DOUBLE_TYPE_ONE))
-          GENV_ITEMFACTORY->createDouble (result, result->getDoubleValue());
+        if (type != store::XS_DOUBLE)
+          GENV_ITEMFACTORY->createDouble(result, result->getDoubleValue());
       }
       else
       {
         GENV_ITEMFACTORY->createDouble(result, -result->getDoubleValue());
       }
     }
-    else if (TypeOps::is_subtype(tm, *type, *rtm.FLOAT_TYPE_ONE))
+    else if (TypeOps::is_subtype(type, store::XS_FLOAT))
     {
       if ( result->getFloatValue().isPos() || result->getFloatValue().isPosZero())
       {
-        if ( !TypeOps::is_equal(tm, *type, *rtm.FLOAT_TYPE_ONE))
+        if (type != store::XS_FLOAT)
           GENV_ITEMFACTORY->createFloat (result, result->getFloatValue());
       }
       else
@@ -97,11 +94,11 @@
         GENV_ITEMFACTORY->createFloat(result, -result->getFloatValue());
       }
     }
-    else if (TypeOps::is_subtype(tm, *type, *rtm.INTEGER_TYPE_ONE))
+    else if (TypeOps::is_subtype(type, store::XS_INTEGER))
     {
       if (result->getIntegerValue().sign() >= 0)
       {
-        if ( !TypeOps::is_equal(tm, *type, *rtm.INTEGER_TYPE_ONE))
+        if (type != store::XS_INTEGER)
           GENV_ITEMFACTORY->createInteger(result, result->getIntegerValue());
       }
       else
@@ -109,28 +106,23 @@
         GENV_ITEMFACTORY->createInteger(result, -result->getIntegerValue());
       }
     }
-    else if (TypeOps::is_subtype(tm, *type, *rtm.DECIMAL_TYPE_ONE))
+    else if (TypeOps::is_subtype(type, store::XS_DECIMAL))
     {
       if ( result->getDecimalValue().sign() >= 0)
       {
-        if ( !TypeOps::is_equal(tm, *type, *rtm.DECIMAL_TYPE_ONE))
+        if (type != store::XS_DECIMAL)
           GENV_ITEMFACTORY->createDecimal(result, result->getDecimalValue());
       }
       else
       {
-        GENV_ITEMFACTORY->createDecimal (result, -result->getDecimalValue());
+        GENV_ITEMFACTORY->createDecimal(result, -result->getDecimalValue());
       }
     }
     else
     {
-      RAISE_ERROR(err::XPTY0004, loc,
-      ERROR_PARAMS(ZED(BadTypeFor_23), type, "fn:abs" ));
-    }
-
-    if ( consumeNext(item, theChildren[0].getp(), planState ))
-    {
-      RAISE_ERROR(err::XPTY0004, loc,
-      ERROR_PARAMS(ZED(NoSeqForFnOp_2), "fn:abs"));
+      xqtref_t type = tm->create_value_type(result);
+      RAISE_ERROR(err::XPTY0004, loc,
+      ERROR_PARAMS(ZED(BadTypeFor_23), type->toSchemaString(), "fn:abs" ));
     }
 
     STACK_PUSH(true, state);
@@ -138,15 +130,15 @@
   STACK_END(state);
 }
 
+
 //6.4.2 fn:ceiling
 bool
 CeilingIterator::nextImpl(store::Item_t& result, PlanState& planState) const
 {
   store::Item_t item;
-  xqtref_t type;
+  store::SchemaTypeCode type;
 
   const TypeManager* tm = theSctx->get_typemanager();
-  const RootTypeManager& rtm = GENV_TYPESYSTEM;
 
   PlanIteratorState* state;
   DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
@@ -156,116 +148,109 @@
     //get the value and the type of the item
     assert(result->isAtomic());
 
-    type = tm->create_value_type(result);
+    type = result->getTypeCode();
 
     //Parameters of type xs:untypedAtomic are always promoted to xs:double
-    if ( TypeOps::is_subtype(tm, *type, *rtm.UNTYPED_ATOMIC_TYPE_ONE))
+    if (TypeOps::is_subtype(type, store::XS_UNTYPED_ATOMIC))
     {
-      GenericCast::castToAtomic(result, result, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, loc);
-      type = tm->create_value_type(result);
+      GenericCast::castToBuiltinAtomic(result, result, store::XS_DOUBLE, NULL, loc);
+      type = store::XS_DOUBLE;
     }
 
-    //item type is subtype of DOUBLE
-    if ( TypeOps::is_subtype(tm, *type, *rtm.DOUBLE_TYPE_ONE))
+    if (TypeOps::is_subtype(type, store::XS_DOUBLE))
+    {
       GENV_ITEMFACTORY->createDouble(result, result->getDoubleValue().ceil());
-
-    //item type is subtype of FLOAT
-    else if ( TypeOps::is_subtype(tm, *type, *rtm.FLOAT_TYPE_ONE))
+    }
+    else if (TypeOps::is_subtype(type, store::XS_FLOAT))
+    {
       GENV_ITEMFACTORY->createFloat(result, result->getFloatValue().ceil());
-
-    //item type is subtype of INTEGER
-    else if(TypeOps::is_subtype(tm, *type, *rtm.INTEGER_TYPE_ONE))
-    { /* do nothing */ }
-
-    //item type is subtype of DECIMAL
-    else if (TypeOps::is_subtype(tm, *type, *rtm.DECIMAL_TYPE_ONE))
+    }
+    else if (TypeOps::is_subtype(type, store::XS_INTEGER))
+    {
+      /* do nothing */
+    }
+    else if (TypeOps::is_subtype(type, store::XS_DECIMAL))
+    {
       GENV_ITEMFACTORY->createDecimal(result, result->getDecimalValue().ceil());
-
+    }
     else
     {
+      xqtref_t type = tm->create_value_type(result);
       RAISE_ERROR(err::XPTY0004, loc,
       ERROR_PARAMS(ZED(BadTypeFor_23), type, "fn:ceiling" ));
     }
 
-    if ( consumeNext(item, theChildren[0].getp(), planState ))
-    {
-      RAISE_ERROR(err::XPTY0004, loc,
-      ERROR_PARAMS(ZED(NoSeqForFnOp_2), "fn:ceiling"));
-    }
     STACK_PUSH(true, state);
   }
+
   STACK_END(state);
 }
 
+
 //6.4.3 fn:floor
 bool
 FloorIterator::nextImpl(store::Item_t& result, PlanState& planState) const
 {
   store::Item_t item;
-  xqtref_t type;
+  store::SchemaTypeCode type;
 
   const TypeManager* tm = theSctx->get_typemanager();
-  const RootTypeManager& rtm = GENV_TYPESYSTEM;
 
   PlanIteratorState* state;
   DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
 
   if (consumeNext(result, theChildren[0].getp(), planState))
   {
-    //get the value and the type of the item
     assert(result->isAtomic());
 
-    type = tm->create_value_type(result);
+    type = result->getTypeCode();
 
     //Parameters of type xs:untypedAtomic are always promoted to xs:double
-    if (TypeOps::is_subtype(tm, *type, *rtm.UNTYPED_ATOMIC_TYPE_ONE))
+    if (TypeOps::is_subtype(type, store::XS_UNTYPED_ATOMIC))
     {
-      GenericCast::castToAtomic(result, result, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, loc);
-      type = tm->create_value_type(result);
+      GenericCast::castToBuiltinAtomic(result, result, store::XS_DOUBLE, NULL, loc);
+      type = store::XS_DOUBLE;
     }
 
-    //item type is subtype of DOUBLE
-    if (TypeOps::is_subtype(tm, *type, *rtm.DOUBLE_TYPE_ONE))
+    if (TypeOps::is_subtype(type, store::XS_DOUBLE))
+    {
       GENV_ITEMFACTORY->createDouble(result, result->getDoubleValue().floor());
-
-    //item type is subtype of FLOAT
-    else if (TypeOps::is_subtype(tm, *type, *rtm.FLOAT_TYPE_ONE))
+    }
+    else if (TypeOps::is_subtype(type, store::XS_FLOAT))
+    {
       GENV_ITEMFACTORY->createFloat(result, result->getFloatValue().floor());
-
-    //item type is subtype of INTEGER
-    else if(TypeOps::is_subtype(tm, *type, *rtm.INTEGER_TYPE_ONE))
-    { /* do nothing */ }
-
-    //item type is subtype of DECIMAL
-    else if (TypeOps::is_subtype(tm, *type, *rtm.DECIMAL_TYPE_ONE))
+    }
+    else if(TypeOps::is_subtype(type, store::XS_INTEGER))
+    {
+      /* do nothing */
+    }
+    else if (TypeOps::is_subtype(type, store::XS_DECIMAL))
+    {
       GENV_ITEMFACTORY->createDecimal(result, result->getDecimalValue().floor());
-
+    }
     else
     {
+      xqtref_t type = tm->create_value_type(result);
       RAISE_ERROR(err::XPTY0004, loc,
       ERROR_PARAMS(ZED(BadTypeFor_23), type, "fn:floor"));
     }
 
-    if ( consumeNext(item, theChildren[0].getp(), planState ) )
-    {
-      RAISE_ERROR(err::XPTY0004, loc,
-      ERROR_PARAMS(ZED(NoSeqForFnOp_2), "fn:floor" ));
-    }
-    STACK_PUSH (true, state );
+    STACK_PUSH(true, state);
   }
-  STACK_END (state);
+
+  STACK_END(state);
 }
 
+
 bool
 RoundIterator::nextImpl(store::Item_t& result, PlanState& planState) const
 {
   store::Item_t item;
-  xqtref_t type;
+  store::SchemaTypeCode type;
   store::Item_t precision;
   Integer precision_integer(0);
 
   const TypeManager* tm = theSctx->get_typemanager();
-  const RootTypeManager& rtm = GENV_TYPESYSTEM;
 
   PlanIteratorState* state;
   DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
@@ -280,125 +265,120 @@
       precision_integer = precision->getIntegerValue();
     }
 
-    //get the value and the type of the item
     assert(result->isAtomic());
 
-    type = tm->create_value_type(result);
-
-    //Parameters of type xs:untypedAtomic are always promoted to xs:double
-    if ( TypeOps::is_subtype(tm, *type, *rtm.UNTYPED_ATOMIC_TYPE_ONE))
-    {
-      GenericCast::castToAtomic(result, result, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, loc);
-      type = tm->create_value_type(result);
-    }
-
-    //item type is subtype of DOUBLE
-    if ( TypeOps::is_subtype(tm, *type, *rtm.DOUBLE_TYPE_ONE))
-      GENV_ITEMFACTORY->createDouble(result, result->getDoubleValue().round(precision_integer));
-
-    //item type is subtype of FLOAT
-    else if ( TypeOps::is_subtype(tm, *type, *rtm.FLOAT_TYPE_ONE))
-      GENV_ITEMFACTORY->createFloat(result, result->getFloatValue().round(precision_integer));
-
-    //item type is subtype of INTEGER
-    else if(TypeOps::is_subtype(tm, *type, *rtm.INTEGER_TYPE_ONE))
-    {
-      if(precision_integer.sign() < 0)
-        GENV_ITEMFACTORY->createInteger(result, result->getIntegerValue().round(precision_integer));
-    }
-
-    //item type is subtype of DECIMAL
-    else if (TypeOps::is_subtype(tm, *type, *rtm.DECIMAL_TYPE_ONE))
-      GENV_ITEMFACTORY->createDecimal(result, result->getDecimalValue().round(precision_integer));
-
+    type = result->getTypeCode();
+
+    if (TypeOps::is_subtype(type, store::XS_UNTYPED_ATOMIC))
+    {
+      GenericCast::castToBuiltinAtomic(result, result, store::XS_DOUBLE, NULL, loc);
+      type = store::XS_DOUBLE;
+    }
+
+    if (TypeOps::is_subtype(type, store::XS_DOUBLE))
+    {
+      GENV_ITEMFACTORY->
+      createDouble(result, result->getDoubleValue().round(precision_integer));
+    }
+    else if (TypeOps::is_subtype(type, store::XS_FLOAT))
+    {
+      GENV_ITEMFACTORY->
+      createFloat(result, result->getFloatValue().round(precision_integer));
+    }
+    else if (TypeOps::is_subtype(type, store::XS_INTEGER))
+    {
+      if (precision_integer.sign() < 0)
+        GENV_ITEMFACTORY->
+        createInteger(result, result->getIntegerValue().round(precision_integer));
+    }
+
+    else if (TypeOps::is_subtype(type, store::XS_DECIMAL))
+    {
+      GENV_ITEMFACTORY->
+      createDecimal(result, result->getDecimalValue().round(precision_integer));
+    }
     else
     {
+      xqtref_t type = tm->create_value_type(result);
       RAISE_ERROR(err::XPTY0004, loc,
       ERROR_PARAMS(ZED(BadTypeFor_23), type, "fn:round"));
     }
 
-    if ( consumeNext(item, theChildren[0].getp(), planState ))
-    {
-      RAISE_ERROR(err::XPTY0004, loc,
-      ERROR_PARAMS(ZED(NoSeqForFnOp_2), "fn:round" ));
-    }
-    STACK_PUSH (true, state );
+    STACK_PUSH(true, state);
   }
-  STACK_END (state);
+
+  STACK_END(state);
 }
 
+
 //6.4.5 fn:round-half-to-even
-bool RoundHalfToEvenIterator::nextImpl( store::Item_t &result,
-                                        PlanState& planState ) const {
+bool RoundHalfToEvenIterator::nextImpl(
+    store::Item_t& result,
+    PlanState& planState ) const
+{
   store::Item_t item;
   xs_integer precision;
-  RootTypeManager const &rtm = GENV_TYPESYSTEM;
   TypeManager const *const tm = theSctx->get_typemanager();
-  xqtref_t type;
-
-  PlanIteratorState *state;
-  DEFAULT_STACK_INIT( PlanIteratorState, state, planState );
-
-  if ( consumeNext( result, theChildren [0].getp(), planState ) ) {
-    assert( result->isAtomic() );
-    type = tm->create_value_type( result );
-
-    if ( theChildren.size() == 2 ) {
-      consumeNext( item, theChildren[1].getp(), planState );
-      assert( item->isAtomic() );
+  store::SchemaTypeCode type;
+
+  PlanIteratorState* state;
+  DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
+
+  if (consumeNext(result, theChildren [0].getp(), planState))
+  {
+    assert(result->isAtomic());
+    type = result->getTypeCode();
+
+    if (theChildren.size() == 2)
+    {
+      consumeNext(item, theChildren[1].getp(), planState);
+      assert(item->isAtomic());
       precision = item->getIntegerValue();
     }
 
-    if ( TypeOps::is_subtype( tm, *type, *rtm.UNTYPED_ATOMIC_TYPE_ONE ) ) {
+    if (TypeOps::is_subtype(type, store::XS_UNTYPED_ATOMIC))
+    {
       //
       // XQuery 3.0 3.1.5.2: Each item in the atomic sequence that is of type
       // xs:untypedAtomic is cast to the expected generalized atomic type. For
       // built-in functions where the expected type is specified as numeric,
       // arguments of type xs:untypedAtomic are cast to xs:double.
       //
-      GenericCast::castToAtomic(
-        result, result, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, loc
-      );
-      type = tm->create_value_type( result );
-    }
-
-    if ( TypeOps::is_subtype( tm, *type, *rtm.DOUBLE_TYPE_ONE ) )
-      GENV_ITEMFACTORY->createDouble(
-        result, result->getDoubleValue().roundHalfToEven( precision )
-      );
-
-    else if ( TypeOps::is_subtype( tm, *type, *rtm.FLOAT_TYPE_ONE ) )
-      GENV_ITEMFACTORY->createFloat(
-        result, result->getFloatValue().roundHalfToEven( precision )
-      );
-
-    else if ( TypeOps::is_subtype( tm, *type, *rtm.INTEGER_TYPE_ONE ) )
-      GENV_ITEMFACTORY->createInteger(
-        result, result->getIntegerValue().roundHalfToEven( precision )
-      );
-
-    else if ( TypeOps::is_subtype( tm, *type, *rtm.DECIMAL_TYPE_ONE ) )
-      GENV_ITEMFACTORY->createDecimal(
-        result, result->getDecimalValue().roundHalfToEven( precision )
-      );
-
+      GenericCast::castToBuiltinAtomic(result, result, store::XS_DOUBLE, NULL, loc);
+      type = store::XS_DOUBLE;
+    }
+
+    if (TypeOps::is_subtype(type, store::XS_DOUBLE))
+    {
+      GENV_ITEMFACTORY->
+      createDouble(result, result->getDoubleValue().roundHalfToEven(precision));
+    }
+    else if (TypeOps::is_subtype(type, store::XS_FLOAT))
+    {
+      GENV_ITEMFACTORY->
+      createFloat(result, result->getFloatValue().roundHalfToEven(precision));
+    }
+    else if (TypeOps::is_subtype(type, store::XS_INTEGER))
+    {
+      GENV_ITEMFACTORY->
+      createInteger(result, result->getIntegerValue().roundHalfToEven(precision));
+    }
+    else if (TypeOps::is_subtype(type, store::XS_DECIMAL))
+    {
+      GENV_ITEMFACTORY->
+      createDecimal(result, result->getDecimalValue().roundHalfToEven(precision));
+    }
     else
-      throw XQUERY_EXCEPTION(
-        err::XPTY0004,
-        ERROR_PARAMS( ZED( BadTypeFor_23 ), type, "fn:round-half-to-even" ),
-        ERROR_LOC( loc )
-      );
+    {
+      xqtref_t type = tm->create_value_type(result);
+      RAISE_ERROR(err::XPTY0004, loc,
+      ERROR_PARAMS(ZED(BadTypeFor_23), type, "fn:round-half-to-even"));
+    }
 
-    if ( consumeNext( item, theChildren [0].getp(), planState ) ) {
-      throw XQUERY_EXCEPTION(
-        err::XPTY0004,
-        ERROR_PARAMS( ZED( NoSeqForFnOp_2 ), "fn:round-half-to-even" ),
-        ERROR_LOC( loc )
-      );
-    }
-    STACK_PUSH( true, state );
+    STACK_PUSH(true, state);
   }
-  STACK_END( state );
+
+  STACK_END(state);
 }
 
 } // namespace zorba
 
=== modified file 'src/runtime/sequences/SequencesImpl.cpp'
--- src/runtime/sequences/SequencesImpl.cpp	2013-05-15 23:22:01 +0000
+++ src/runtime/sequences/SequencesImpl.cpp	2013-06-11 09:57:50 +0000
@@ -62,35 +62,6 @@
 
 NARY_ACCEPT(FnMinMaxIterator);
 
-namespace sequences_impl_ns{
-static XQPCollator* getCollator(
-    static_context* sctx,
-    const QueryLoc& loc,
-    PlanState& planState,
-    const PlanIterator* iter)
-{
-  store::Item_t lCollationItem;
-  store::Item_t temp;
-
-  if (!PlanIterator::consumeNext(lCollationItem, iter, planState))
-    throw XQUERY_EXCEPTION(
-      err::XPTY0004,
-      ERROR_PARAMS( ZED( NoEmptySeqAsCollationParam ) ),
-      ERROR_LOC( loc )
-    );
-
-  if (PlanIterator::consumeNext(temp, iter, planState))
-    throw XQUERY_EXCEPTION(
-      err::XPTY0004,
-      ERROR_PARAMS( ZED( NoSeqAsCollationParam ) ),
-      ERROR_LOC( loc )
-    );
-
-  xqtref_t lCollationItemType = sctx->get_typemanager()->create_value_type(lCollationItem);
-
-  return sctx->get_collator(lCollationItem->getStringValue().str(), loc);
-}
-}
 
 /////////////////////////////////////////////////////////////////////////////////
 //                                                                             //
@@ -121,104 +92,108 @@
 bool
 FnMinMaxIterator::nextImpl(store::Item_t& result, PlanState& planState) const
 {
-  store::Item_t lRunningItem = NULL;
-  xqtref_t lMaxType;
+  store::Item_t runningItem = NULL;
+  store::SchemaTypeCode maxType = store::XS_LAST;
 
   const TypeManager* tm = theSctx->get_typemanager();
-  const RootTypeManager& rtm = GENV_TYPESYSTEM;
-
   long timezone = planState.theLocalDynCtx->get_implicit_timezone();
-  XQPCollator*  lCollator = 0;
+  XQPCollator* collator = 0;
   unsigned elems_in_seq = 0;
   result = NULL;
 
   try
   {
-  PlanIteratorState* state;
-  DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
-
-  if (theChildren.size() == 2)
-    lCollator = sequences_impl_ns::getCollator(theSctx, loc, planState, theChildren[1].getp());
-  else
-    lCollator = theSctx->get_default_collator(loc);
-
-  if (consumeNext(lRunningItem, theChildren[0].getp(), planState))
-  {
-    do
-    {
-      // casting of untyped atomic
-      xqtref_t lRunningType = tm->create_value_type(lRunningItem);
-
-      if (TypeOps::is_subtype(tm, *lRunningType, *rtm.UNTYPED_ATOMIC_TYPE_ONE))
-      {
-        GenericCast::castToAtomic(lRunningItem,
-                                  lRunningItem,
-                                  &*rtm.DOUBLE_TYPE_ONE,
-                                  tm,
-                                  NULL,
-                                  loc);
-        lRunningType = rtm.DOUBLE_TYPE_ONE;
-      }
-
-      // implementation dependent: return the first occurence)
-      if (lRunningItem->isNaN())
-      {
-        /** It must be checked if the sequence contains any
-         * xs:double("NaN") [xs:double("NaN") is returned] or
-         * only xs:float("NaN")'s [xs:float("NaN") is returned]'.
-         */
-        result = lRunningItem;
-        if (TypeOps::is_subtype(tm, *lRunningType, *rtm.DOUBLE_TYPE_ONE))
-          break;
-
-        lMaxType = tm->create_value_type(result);
-      }
-
-      if (result != 0)
-      {
-        // Type Promotion
-        store::Item_t lItemCur;
-        if (!GenericCast::promote(lItemCur, lRunningItem, &*lMaxType, NULL, tm, loc))
-        {
-          if (GenericCast::promote(lItemCur, result, &*lRunningType, NULL, tm, loc))
+    PlanIteratorState* state;
+    DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
+
+    if (theChildren.size() == 2)
+    {
+      store::Item_t collationItem;
+      consumeNext(collationItem, theChildren[1], planState);
+      collator = theSctx->get_collator(collationItem->getStringValue().str(), loc);
+    }
+    else
+    {
+      collator = theSctx->get_default_collator(loc);
+    }
+
+    if (consumeNext(runningItem, theChildren[0], planState))
+    {
+      do
+      {
+        // casting of untyped atomic
+        store::SchemaTypeCode runningType = runningItem->getTypeCode();
+
+        if (runningType == store::XS_UNTYPED_ATOMIC)
+        {
+          GenericCast::castToBuiltinAtomic(runningItem,
+                                           runningItem,
+                                           store::XS_DOUBLE,
+                                           NULL,
+                                           loc);
+          runningType = store::XS_DOUBLE;
+        }
+
+        // implementation dependent: return the first occurence)
+        if (runningItem->isNaN())
+        {
+          // It must be checked if the sequence contains any
+          // xs:double("NaN") [xs:double("NaN") is returned] or
+          // only xs:float("NaN")'s [xs:float("NaN") is returned]'.
+
+          result = runningItem;
+          if (TypeOps::is_subtype(runningType, store::XS_DOUBLE))
+            break;
+
+          maxType = runningType;
+        }
+
+        if (result != 0)
+        {
+          // Type Promotion
+          store::Item_t lItemCur;
+          if (!GenericCast::promote(lItemCur, runningItem, maxType, NULL, tm, loc))
           {
-            result.transfer(lItemCur);
-            lMaxType = tm->create_value_type(result);
+            if (GenericCast::promote(lItemCur, result, runningType, NULL, tm, loc))
+            {
+              result.transfer(lItemCur);
+              maxType = result->getTypeCode();
+            }
+            else
+            {
+              RAISE_ERROR(err::FORG0006, loc,
+						  ERROR_PARAMS(ZED(PromotionImpossible)));
+            }
           }
           else
           {
-						RAISE_ERROR(err::FORG0006, loc,
-						ERROR_PARAMS(ZED(PromotionImpossible)));
+            runningItem.transfer(lItemCur);
+            runningType = runningItem->getTypeCode();
+          }
+ 
+          store::Item_t current_copy(runningItem);
+          store::Item_t max_copy(result);
+          if (CompareIterator::valueComparison(loc,
+                                               current_copy,
+                                               max_copy,
+                                               theCompareType,
+                                               tm,
+                                               timezone,
+                                               collator))
+          {
+            maxType = runningType;
+            result.transfer(runningItem);
           }
         }
         else
         {
-          lRunningItem.transfer(lItemCur);
-          lRunningType = tm->create_value_type(lRunningItem);
-        }
-
-        store::Item_t current_copy(lRunningItem);
-        store::Item_t max_copy(result);
-        if (CompareIterator::valueComparison(loc,
-                                             current_copy,
-                                             max_copy,
-                                             theCompareType,
-                                             tm,
-                                             timezone,
-                                             lCollator) )
-        {
-          lMaxType = lRunningType;
-          result.transfer(lRunningItem);
-        }
-      }
-      else
-      {
-        lMaxType = lRunningType;
-        result.transfer(lRunningItem);
-      }
-
-      elems_in_seq++;
-    } while (consumeNext(lRunningItem, theChildren[0].getp(), planState));
+          maxType = runningType;
+          result.transfer(runningItem);
+        }
+
+        elems_in_seq++;
+      }
+      while (consumeNext(runningItem, theChildren[0], planState));
 
     if (elems_in_seq == 1)
     {
@@ -231,7 +206,7 @@
                                        theCompareType,
                                        tm,
                                        timezone,
-                                       lCollator);
+                                       collator);
     }
 
     STACK_PUSH(result != NULL, state);
 
=== modified file 'src/runtime/sequences/sequences_impl.cpp'
--- src/runtime/sequences/sequences_impl.cpp	2013-06-05 00:37:35 +0000
+++ src/runtime/sequences/sequences_impl.cpp	2013-06-11 09:57:50 +0000
@@ -1438,7 +1438,7 @@
 {
   store::Item_t lSumItem;
   store::Item_t lRunningItem;
-  xqtref_t      lRunningType;
+  store::SchemaTypeCode lRunningType;
   store::Item_t countItem;
   int lCount = 0;
   bool lHitNumeric = false, lHitYearMonth = false, lHitDayTime = false;
@@ -1446,86 +1446,101 @@
   const TypeManager* tm = theSctx->get_typemanager();
   const RootTypeManager& rtm = GENV_TYPESYSTEM;
 
-  xqtref_t lUntypedAtomic     = rtm.UNTYPED_ATOMIC_TYPE_ONE;
-  xqtref_t lYearMonthDuration = rtm.YM_DURATION_TYPE_ONE;
-  xqtref_t lDayTimeDuration   = rtm.DT_DURATION_TYPE_ONE;
-
   PlanIteratorState* state;
   DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
 
   while (consumeNext(lRunningItem, theChildren[0].getp(), planState))
   {
-    lRunningType = tm->create_value_type(lRunningItem);
+    lRunningType = lRunningItem->getTypeCode();
 
-    if (TypeOps::is_numeric(tm, *lRunningType) ||
-        TypeOps::is_equal(tm, *lRunningType, *lUntypedAtomic))
+    if (TypeOps::is_numeric(lRunningType) ||
+        lRunningType == store::XS_UNTYPED_ATOMIC)
     {
       lHitNumeric = true;
 
-      if ( lHitYearMonth )
+      if (lHitYearMonth)
+      {
+        xqtref_t type = tm->create_value_type(lRunningItem);
         RAISE_ERROR(err::FORG0006, loc,
 				ERROR_PARAMS(ZED(BadArgTypeForFn_2o34o),
-                     *lRunningType,
+                     *type,
                      "fn:avg",
                      ZED(ExpectedType_5),
-                     *lYearMonthDuration));
+                     *rtm.YM_DURATION_TYPE_ONE));
+      }
 
-      if ( lHitDayTime )
+      if (lHitDayTime)
+      {
+        xqtref_t type = tm->create_value_type(lRunningItem);
         RAISE_ERROR(err::FORG0006, loc,
         ERROR_PARAMS(ZED( BadArgTypeForFn_2o34o ),
-                     *lRunningType,
+                     *type,
                      "fn:avg",
                      ZED( ExpectedType_5 ),
-                     *lDayTimeDuration));
+                     *rtm.DT_DURATION_TYPE_ONE));
+      }
     }
-    else if (TypeOps::is_equal(tm, *lRunningType, *lYearMonthDuration))
+    else if (lRunningType == store::XS_YM_DURATION)
     {
       lHitYearMonth = true;
 
       if (lHitNumeric)
+      {
+        xqtref_t type = tm->create_value_type(lRunningItem);
         RAISE_ERROR(err::FORG0006, loc,
         ERROR_PARAMS(ZED(BadArgTypeForFn_2o34o),
-                     *lRunningType,
+                     *type,
                      "fn:avg",
                      ZED(ExpectedNumericType)));
+      }
 
       if (lHitDayTime)
+      {
+        xqtref_t type = tm->create_value_type(lRunningItem);
         RAISE_ERROR(err::FORG0006, loc,
         ERROR_PARAMS(ZED( BadArgTypeForFn_2o34o ),
-                     *lRunningType,
+                     *type,
                      "fn:avg",
                      ZED( ExpectedType_5 ),
-                     *lDayTimeDuration));
+                     *rtm.DT_DURATION_TYPE_ONE));
+      }
     }
-    else if (TypeOps::is_equal(tm, *lRunningType, *lDayTimeDuration))
+    else if (lRunningType == store::XS_DT_DURATION)
     {
       lHitDayTime = true;
 
-      if ( lHitNumeric )
+      if (lHitNumeric)
+      {
+        xqtref_t type = tm->create_value_type(lRunningItem);
         RAISE_ERROR(err::FORG0006, loc,
         ERROR_PARAMS(ZED(BadArgTypeForFn_2o34o),
-                     *lRunningType,
+                     *type,
                      "fn:avg",
                      ZED(ExpectedNumericType)));
+      }
 
-      if ( lHitYearMonth )
+      if (lHitYearMonth)
+      {
+        xqtref_t type = tm->create_value_type(lRunningItem);
         RAISE_ERROR(err::FORG0006, loc,
         ERROR_PARAMS(ZED(BadArgTypeForFn_2o34o),
-                     *lRunningType,
+                     *type,
                      "fn:avg",
                      ZED(ExpectedType_5),
-                     *lYearMonthDuration));
+                     *rtm.YM_DURATION_TYPE_ONE));
+      }
     }
     else
     {
+      xqtref_t type = tm->create_value_type(lRunningItem);
 			RAISE_ERROR(err::FORG0006, loc,
 			ERROR_PARAMS(ZED(BadArgTypeForFn_2o34o),
-                   *lRunningType,
+                   *type,
                    "fn:avg",
                    ZED(ExpectedNumericOrDurationType)));
     }
 
-    if ( lCount++ == 0 )
+    if (lCount++ == 0)
     {
       lSumItem = lRunningItem;
     }
@@ -1559,17 +1574,17 @@
   STACK_END (state);
 }
 
+
 /*******************************************************************************
   15.4.5 fn:sum - Generic
 ********************************************************************************/
 bool FnSumIterator::nextImpl(store::Item_t& result, PlanState& planState) const
 {
   store::Item_t lRunningItem;
-  xqtref_t      lResultType;
-  xqtref_t      lRunningType;
+  store::SchemaTypeCode lResultType;
+  store::SchemaTypeCode lRunningType;
 
   const TypeManager* tm = theSctx->get_typemanager();
-  const RootTypeManager& rtm = GENV_TYPESYSTEM;
 
   PlanIteratorState* state;
   DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
@@ -1577,37 +1592,37 @@
   if (consumeNext(result, theChildren[0].getp(), planState))
   {
     // casting of untyped atomic
-    lResultType = tm->create_value_type(result);
+    lResultType = result->getTypeCode();
 
-    if (TypeOps::is_subtype(tm, *lResultType, *rtm.UNTYPED_ATOMIC_TYPE_ONE))
+    if (lResultType == store::XS_UNTYPED_ATOMIC)
     {
-      GenericCast::castToAtomic(result, result, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, loc);
-      lResultType = rtm.DOUBLE_TYPE_ONE;
+      GenericCast::castToBuiltinAtomic(result, result, store::XS_DOUBLE, NULL, loc);
+      lResultType = store::XS_DOUBLE;
     }
 
-    if (!TypeOps::is_numeric(tm, *lResultType) &&
-        (!TypeOps::is_subtype(tm, *lResultType, *rtm.DURATION_TYPE_ONE) ||
-         TypeOps::is_equal(tm, *lResultType, *rtm.DURATION_TYPE_ONE)))
+    if (!TypeOps::is_numeric(lResultType) &&
+        (!TypeOps::is_subtype(lResultType, store::XS_DURATION) ||
+         lResultType == store::XS_DURATION))
     {
+      xqtref_t type = tm->create_value_type(result);
       RAISE_ERROR(err::FORG0006, loc,
-			ERROR_PARAMS(ZED(BadArgTypeForFn_2o34o), *lResultType, "fn:sum"));
+			ERROR_PARAMS(ZED(BadArgTypeForFn_2o34o), *type, "fn:sum"));
     }
 
     while (consumeNext(lRunningItem, theChildren[0].getp(), planState))
     {
       // casting of untyped atomic
-      lRunningType = tm->create_value_type(lRunningItem);
+      lRunningType = lRunningItem->getTypeCode();
 
-      if (TypeOps::is_subtype(tm, *lRunningType, *rtm.UNTYPED_ATOMIC_TYPE_ONE))
+      if (lRunningType == store::XS_UNTYPED_ATOMIC)
       {
-        GenericCast::castToAtomic(lRunningItem,
-                                  lRunningItem,
-                                  &*rtm.DOUBLE_TYPE_ONE,
-                                  tm,
-                                  NULL,
-                                  loc);
+        GenericCast::castToBuiltinAtomic(lRunningItem,
+                                         lRunningItem,
+                                         store::XS_DOUBLE,
+                                         NULL,
+                                         loc);
 
-        lRunningType = rtm.DOUBLE_TYPE_ONE;
+        lRunningType = store::XS_DOUBLE;
       }
 
       // handling of NaN
@@ -1617,12 +1632,12 @@
         break;
       }
 
-      if((TypeOps::is_numeric(tm, *lResultType) &&
-          TypeOps::is_numeric(tm, *lRunningType)) ||
-         (TypeOps::is_subtype(tm, *lResultType, *rtm.YM_DURATION_TYPE_ONE) &&
-          TypeOps::is_subtype(tm, *lRunningType, *rtm.YM_DURATION_TYPE_ONE)) ||
-         (TypeOps::is_subtype(tm, *lResultType, *rtm.DT_DURATION_TYPE_ONE) &&
-          TypeOps::is_subtype(tm, *lRunningType, *rtm.DT_DURATION_TYPE_ONE)))
+      if ((TypeOps::is_numeric(lResultType) &&
+           TypeOps::is_numeric(lRunningType)) ||
+          (TypeOps::is_subtype(lResultType, store::XS_YM_DURATION) &&
+           TypeOps::is_subtype(lRunningType, store::XS_YM_DURATION)) ||
+          (TypeOps::is_subtype(lResultType, store::XS_DT_DURATION) &&
+           TypeOps::is_subtype(lRunningType, store::XS_DT_DURATION)))
       {
         GenericArithIterator<AddOperation>::compute(result,
                                                     planState.theLocalDynCtx,
@@ -1633,13 +1648,10 @@
       }
       else
       {
-				throw XQUERY_EXCEPTION(
-					err::FORG0006,
-					ERROR_PARAMS(
-						ZED( SumImpossibleWithTypes_23 ), *lResultType, *lRunningType
-					),
-					ERROR_LOC( loc )
-				);
+        xqtref_t type1 = tm->create_value_type(result);
+        xqtref_t type2 = tm->create_value_type(lRunningItem);
+				RAISE_ERROR(err::FORG0006, loc,
+				ERROR_PARAMS(ZED( SumImpossibleWithTypes_23 ), *type1, *type2));
       }
     }
 
@@ -1657,18 +1669,16 @@
     }
     else
     {
-      STACK_PUSH(
-				GENV_ITEMFACTORY->createInteger(
-          result, numeric_consts<xs_integer>::zero()
-        ),
-        state
-			);
+      STACK_PUSH(GENV_ITEMFACTORY->
+                 createInteger(result, numeric_consts<xs_integer>::zero()),
+                 state);
     }
   }
 
-  STACK_END (state);
+  STACK_END(state);
 }
 
+
 /*******************************************************************************
   15.4.5 fn:sum - Double
 ********************************************************************************/
@@ -1766,6 +1776,7 @@
   STACK_END (state);
 }
 
+
 /*******************************************************************************
   15.4.5 fn:sum - Decimal
 ********************************************************************************/
@@ -1814,6 +1825,7 @@
   STACK_END (state);
 }
 
+
 /*******************************************************************************
   15.4.5 fn:sum - Integer
 ********************************************************************************/
@@ -1823,8 +1835,8 @@
 {
   xs_integer    sum;
   store::Item_t item;
-  xqtref_t      lResultType;
-  xqtref_t      lTmpType;
+  store::SchemaTypeCode lResultType;
+  store::SchemaTypeCode lTmpType;
 
   const TypeManager* tm = theSctx->get_typemanager();
 
@@ -1833,13 +1845,15 @@
 
   if (consumeNext(item, theChildren[0].getp(), planState))
   {
-    lResultType = tm->create_value_type(item);
+    lResultType = item->getTypeCode();
+
     sum = item->getIntegerValue();
 
     while (consumeNext(item, theChildren[0].getp(), planState))
     {
-      lTmpType = tm->create_value_type(item);
-      if(TypeOps::is_subtype(tm, *lResultType, *lTmpType))
+      lTmpType = item->getTypeCode();
+
+      if (TypeOps::is_subtype(lResultType, lTmpType))
         lResultType = lTmpType;
 
       if (item->isNaN())
@@ -1852,7 +1866,8 @@
     }
 
     GENV_ITEMFACTORY->createInteger(result, sum);
-    GenericCast::castToAtomic(result, result, &*lResultType, tm, NULL, loc);
+
+    GenericCast::castToBuiltinAtomic(result, result, lResultType, NULL, loc);
 
     STACK_PUSH(true, state);
   }
@@ -1872,6 +1887,7 @@
   STACK_END (state);
 }
 
+
 /*******************************************************************************
   15.5.1 op:to
 ********************************************************************************/
@@ -1906,6 +1922,7 @@
   STACK_END (state);
 }
 
+
 /*******************************************************************************
   15.5.4 fn:doc
 ********************************************************************************/
 
=== modified file 'src/runtime/store/maps_impl.cpp'
--- src/runtime/store/maps_impl.cpp	2013-05-08 20:14:47 +0000
+++ src/runtime/store/maps_impl.cpp	2013-06-11 09:57:50 +0000
@@ -77,10 +77,7 @@
               loc ) )
         {
           RAISE_ERROR(zerr::ZXQD0005_INVALID_KEY_FOR_MAP, loc,
-            ERROR_PARAMS(*searchKeyType,
-                         *indexKeyType,
-                         aQName->getStringValue())
-          );
+          ERROR_PARAMS(*searchKeyType, *indexKeyType, aQName->getStringValue()));
         }
         else
         {
@@ -91,10 +88,7 @@
         if ( e.diagnostic() == err::FORG0001 )
         {
           RAISE_ERROR(zerr::ZXQD0005_INVALID_KEY_FOR_MAP, loc,
-            ERROR_PARAMS(*searchKeyType,
-                         *indexKeyType,
-                         aQName->getStringValue())
-          );
+          ERROR_PARAMS(*searchKeyType, *indexKeyType, aQName->getStringValue()));
         }
         throw;
       }
 
=== modified file 'src/types/typeops.cpp'
--- src/types/typeops.cpp	2013-06-03 23:03:58 +0000
+++ src/types/typeops.cpp	2013-06-11 09:57:50 +0000
@@ -1151,7 +1151,6 @@
 
   RootTypeManager& rtm = GENV_TYPESYSTEM;
 
-  xqtref_t resultType;
   TypeConstants::quantifier_t resultQuant = TypeConstants::QUANT_ONE;
 
   TypeConstants::quantifier_t quant1 = type1.get_quantifier();
@@ -1166,43 +1165,43 @@
   }
 
   if (division &&
-      TypeOps::is_subtype(tm, type1, *rtm.INTEGER_TYPE_STAR) &&
-      TypeOps::is_subtype(tm, type2, *rtm.INTEGER_TYPE_STAR))
+      is_subtype(tm, type1, *rtm.INTEGER_TYPE_STAR) &&
+      is_subtype(tm, type2, *rtm.INTEGER_TYPE_STAR))
   {
     return (resultQuant == TypeConstants::QUANT_ONE ?
             rtm.DECIMAL_TYPE_ONE : rtm.DECIMAL_TYPE_QUESTION); 
   }
 
-  if (TypeOps::is_subtype(tm, type1, *rtm.UNTYPED_ATOMIC_TYPE_STAR) ||
-      TypeOps::is_subtype(tm, type2, *rtm.UNTYPED_ATOMIC_TYPE_STAR)) 
-  {
-    return (resultQuant == TypeConstants::QUANT_ONE ?
-            rtm.DOUBLE_TYPE_ONE : rtm.DOUBLE_TYPE_QUESTION);
-  }
- 
-  if (TypeOps::is_subtype(tm, type1, *rtm.DOUBLE_TYPE_STAR) ||
-      TypeOps::is_subtype(tm, type2, *rtm.DOUBLE_TYPE_STAR)) 
-  {
-    return (resultQuant == TypeConstants::QUANT_ONE ?
-            rtm.DOUBLE_TYPE_ONE : rtm.DOUBLE_TYPE_QUESTION);
-  }
- 
-  if (TypeOps::is_subtype(tm, type1, *rtm.FLOAT_TYPE_STAR) ||
-      TypeOps::is_subtype(tm, type2, *rtm.FLOAT_TYPE_STAR)) 
+  if (is_subtype(tm, type1, *rtm.UNTYPED_ATOMIC_TYPE_STAR) ||
+      is_subtype(tm, type2, *rtm.UNTYPED_ATOMIC_TYPE_STAR)) 
+  {
+    return (resultQuant == TypeConstants::QUANT_ONE ?
+            rtm.DOUBLE_TYPE_ONE : rtm.DOUBLE_TYPE_QUESTION);
+  }
+ 
+  if (is_subtype(tm, type1, *rtm.DOUBLE_TYPE_STAR) ||
+      is_subtype(tm, type2, *rtm.DOUBLE_TYPE_STAR)) 
+  {
+    return (resultQuant == TypeConstants::QUANT_ONE ?
+            rtm.DOUBLE_TYPE_ONE : rtm.DOUBLE_TYPE_QUESTION);
+  }
+ 
+  if (is_subtype(tm, type1, *rtm.FLOAT_TYPE_STAR) ||
+      is_subtype(tm, type2, *rtm.FLOAT_TYPE_STAR)) 
   {
     return (resultQuant == TypeConstants::QUANT_ONE ?
             rtm.FLOAT_TYPE_ONE : rtm.FLOAT_TYPE_QUESTION);
   }
 
-  if (TypeOps::is_subtype(tm, type1, *rtm.INTEGER_TYPE_STAR) &&
-      TypeOps::is_subtype(tm, type2, *rtm.INTEGER_TYPE_STAR)) 
+  if (is_subtype(tm, type1, *rtm.INTEGER_TYPE_STAR) &&
+      is_subtype(tm, type2, *rtm.INTEGER_TYPE_STAR)) 
   {
     return (resultQuant == TypeConstants::QUANT_ONE ?
             rtm.INTEGER_TYPE_ONE : rtm.INTEGER_TYPE_QUESTION);
   }
 
-  if (TypeOps::is_subtype(tm, type1, *rtm.DECIMAL_TYPE_STAR) &&
-      TypeOps::is_subtype(tm, type2, *rtm.DECIMAL_TYPE_STAR)) 
+  if (is_subtype(tm, type1, *rtm.DECIMAL_TYPE_STAR) &&
+      is_subtype(tm, type2, *rtm.DECIMAL_TYPE_STAR)) 
   {
     return (resultQuant == TypeConstants::QUANT_ONE ?
             rtm.DECIMAL_TYPE_ONE : rtm.DECIMAL_TYPE_QUESTION); 
@@ -1215,6 +1214,50 @@
 /*******************************************************************************
 
 ********************************************************************************/
+store::SchemaTypeCode TypeOps::arithmetic_type(
+    store::SchemaTypeCode type1,
+    store::SchemaTypeCode type2,
+    bool division)
+{
+  if (division &&
+      is_subtype(type1, store::XS_INTEGER) &&
+      is_subtype(type2, store::XS_INTEGER))
+  {
+    return store::XS_DECIMAL;
+  }
+
+  if (type1 == store::XS_UNTYPED_ATOMIC || type2 == store::XS_UNTYPED_ATOMIC) 
+  {
+    return store::XS_DOUBLE;
+  }
+ 
+  if (is_subtype(type1, store::XS_DOUBLE) || is_subtype(type2, store::XS_DOUBLE))
+  {
+    return store::XS_DOUBLE;
+  }
+ 
+  if (is_subtype(type1, store::XS_FLOAT) || is_subtype(type2, store::XS_FLOAT)) 
+  {
+    return store::XS_FLOAT;
+  }
+
+  if (is_subtype(type1, store::XS_INTEGER) && is_subtype(type2, store::XS_INTEGER)) 
+  {
+    return store::XS_INTEGER;
+  }
+
+  if (is_subtype(type1, store::XS_DECIMAL) && is_subtype(type2, store::XS_DECIMAL)) 
+  {
+    return store::XS_DECIMAL;
+  }
+
+  return store::XS_ANY_ATOMIC;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
 static inline IdentTypes::quantifier_t get_typeident_quant(
     TypeConstants::quantifier_t quant)
 {
 
=== modified file 'src/types/typeops.h'
--- src/types/typeops.h	2013-02-07 17:24:36 +0000
+++ src/types/typeops.h	2013-06-11 09:57:50 +0000
@@ -181,6 +181,11 @@
         const XQType& type2,
         bool division);
 
+  static store::SchemaTypeCode arithmetic_type(
+    store::SchemaTypeCode type1,
+    store::SchemaTypeCode type2,
+    bool division);
+
   /*
    * Returns a type identifier that represents the given type.
    * The invariant that is guaranteed is: