Merge lp:~zorba-coders/zorba/threads into lp:zorba

[Markos Zaharioudakis]

More multi-threading work:
1. Function objects for builtin functions should not use any non-builtin types in their signature.
2. XQType does not inherit from RCObject anymore; instead it replicates RCObject functionalityinternally

More multi-threading work:
1. Function objects for builtin functions should not use any non-builtin types in their signature.
2. XQType does not inherit from RCObject anymore; instead it replicates RCObject functionalityinternally

[lp:~zorba-coders/zorba/threads]

11579. By Markos Zaharioudakis on 2013-09-19

removed unnecessary recreation of mem archiver during shutdown

11580. By Markos Zaharioudakis on 2013-09-19

fixed type-related multi-threading problems

11581. By Markos Zaharioudakis on 2013-09-19

merge from trunk

11582. By Markos Zaharioudakis on 2013-09-19

fixed type-related multi-threading problems

[Markos Zaharioudakis (markos-za)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~zorba-coders/zorba/threads/+merge/186514

Progress dashboard at http://jenkins.lambda.nu/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue result for https://code.launchpad.net/~zorba-coders/zorba/threads/+merge/186514

Stage "TestZorbaUbuntu" failed.
11 tests failed (8535 total tests run).

Check test results at http://jenkins.lambda.nu/job/TestZorbaUbuntu/315/testReport/ to view the results.

[lp:~zorba-coders/zorba/threads]

11583. By Markos Zaharioudakis on 2013-09-20

fixed type-related multi-threading problems

11584. By Markos Zaharioudakis on 2013-09-20

reverted previous change: the mem archiver MUST be recreated after shutdown

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~zorba-coders/zorba/threads/+merge/186514

Progress dashboard at http://jenkins.lambda.nu/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue result for https://code.launchpad.net/~zorba-coders/zorba/threads/+merge/186514

Stage "TestZorbaUbuntu" failed.
6 tests failed (8535 total tests run).

Check test results at http://jenkins.lambda.nu/job/TestZorbaUbuntu/319/testReport/ to view the results.

[lp:~zorba-coders/zorba/threads]

11585. By Markos Zaharioudakis on 2013-09-20

fixed .csv files

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~zorba-coders/zorba/threads/+merge/186514

Progress dashboard at http://jenkins.lambda.nu/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue succeeded - proposal merged!

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~zorba-coders/zorba/threads/+merge/186514

Progress dashboard at http://jenkins.lambda.nu/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue result for https://code.launchpad.net/~zorba-coders/zorba/threads/+merge/186514

Stage "TestZorbaUbuntu" failed.
1 tests failed (8550 total tests run).

Check test results at http://jenkins.lambda.nu/job/TestZorbaUbuntu/329/testReport/ to view the results.

=== modified file 'src/compiler/expression/expr_type.cpp'
--- src/compiler/expression/expr_type.cpp	2013-08-16 13:00:06 +0000
+++ src/compiler/expression/expr_type.cpp	2013-09-20 12:27:16 +0000
@@ -675,7 +675,7 @@
       for (csize i = 0; i < fiExpr->get_function()->getSignature().paramCount(); ++i)
         paramTypes.push_back(fiExpr->get_function()->getSignature()[i]);
 
-      theType = new FunctionXQType(&rtm, paramTypes, retType, TypeConstants::QUANT_ONE);
+      theType = rtm.create_function_type(paramTypes, retType, TypeConstants::QUANT_ONE);
     }
     return;
   }
 
=== modified file 'src/compiler/translator/translator.cpp'
--- src/compiler/translator/translator.cpp	2013-09-17 21:12:49 +0000
+++ src/compiler/translator/translator.cpp	2013-09-20 12:27:16 +0000
@@ -1506,8 +1506,99 @@
 
   TypeManager* tm = argExpr->get_type_manager();
 
+  paramType = sign[i];
+
   switch (func->getKind())
   {
+  case FunctionConsts::FN_ZORBA_XML_PARSE_2:
+  {
+    if (i == 1)
+    {
+      paramType = tm->
+      create_node_type(store::StoreConsts::elementNode,
+                       createQName(static_context::ZORBA_XML_FN_OPTIONS_NS,
+                                   "",
+                                   "options"),
+                       NULL,
+                       TypeConstants::QUANT_QUESTION,
+                       false,
+                       false);
+    }
+    break;
+  }
+  case FunctionConsts::FN_FOR_EACH_2:
+  {
+    if (i == 1)
+    {
+      std::vector<xqtref_t> args;
+      args.push_back(theRTM.ITEM_TYPE_ONE);
+
+      paramType = tm->
+      create_function_type(args,
+                           theRTM.ITEM_TYPE_STAR,
+                           TypeConstants::QUANT_ONE);
+    }
+    break;
+  }
+  case FunctionConsts::FN_FOR_EACH_PAIR_3:
+  {
+    if (i == 2)
+    {
+      std::vector<xqtref_t> args;
+      args.push_back(theRTM.ITEM_TYPE_ONE);
+      args.push_back(theRTM.ITEM_TYPE_ONE);
+
+      paramType = tm->
+      create_function_type(args,
+                           theRTM.ITEM_TYPE_STAR,
+                           TypeConstants::QUANT_ONE);
+    }
+    break;
+  }
+  case FunctionConsts::FN_FOLD_LEFT_3:
+  {
+    if (i == 2)
+    {
+      std::vector<xqtref_t> args;
+      args.push_back(theRTM.ITEM_TYPE_STAR);
+      args.push_back(theRTM.ITEM_TYPE_ONE);
+
+      paramType = tm->
+      create_function_type(args,
+                           theRTM.ITEM_TYPE_STAR,
+                           TypeConstants::QUANT_ONE);
+    }
+    break;
+  }
+  case FunctionConsts::FN_FOLD_RIGHT_3:
+  {
+    if (i == 2)
+    {
+      std::vector<xqtref_t> args;
+      args.push_back(theRTM.ITEM_TYPE_ONE);
+      args.push_back(theRTM.ITEM_TYPE_STAR);
+
+      paramType = tm->
+      create_function_type(args,
+                           theRTM.ITEM_TYPE_STAR,
+                           TypeConstants::QUANT_ONE);
+    }
+    break;
+  }
+  case FunctionConsts::FN_FILTER_2:
+  {
+    if (i == 1)
+    {
+      std::vector<xqtref_t> args;
+      args.push_back(theRTM.ITEM_TYPE_ONE);
+
+      paramType = tm->
+      create_function_type(args,
+                           theRTM.BOOLEAN_TYPE_ONE,
+                           TypeConstants::QUANT_ONE);
+    }
+    break;
+  }
   case FunctionConsts::FN_ZORBA_XQDDF_PROBE_INDEX_POINT_VALUE_N:
   {
     if (i == 0)
@@ -1562,7 +1653,7 @@
   }
   default:
   {
-    paramType = sign[i];
+    break;
   }
   }
 
@@ -4041,7 +4132,7 @@
         // We make sure that the types of the parameters and the return type
         // are subtypes of the ones declared in the module
         const signature& s = f->getSignature();
-        if (!s.subtype(tm, sig, loc))
+        if (!s.subtype(tm, f, sig, loc))
         {
           RAISE_ERROR(zerr::ZXQP0007_FUNCTION_SIGNATURE_NOT_EQUAL, loc,
           ERROR_PARAMS(BUILD_STRING('{',
 
=== modified file 'src/functions/func_fn_hof_functions_impl.cpp'
--- src/functions/func_fn_hof_functions_impl.cpp	2013-06-04 21:47:40 +0000
+++ src/functions/func_fn_hof_functions_impl.cpp	2013-09-20 12:27:16 +0000
@@ -143,100 +143,48 @@
 ********************************************************************************/
 void populate_context_hof_impl(static_context* sctx)
 {
-  {
-    std::vector<xqtref_t> args;
-    args.push_back(GENV_TYPESYSTEM.ITEM_TYPE_ONE);
-
-    xqtref_t hofParamType = GENV_TYPESYSTEM.create_function_type(
-                   args,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   TypeConstants::QUANT_ONE);
-
-    DECL_WITH_KIND(sctx,
-                   fn_for_each_3_0,
-                   (createQName(static_context::W3C_FN_NS, "", "for-each"),
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   hofParamType,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR),
-                   FunctionConsts::FN_FOR_EACH_2);
-  }
-
-  {
-    std::vector<xqtref_t> args;
-    args.push_back(GENV_TYPESYSTEM.ITEM_TYPE_ONE);
-
-    xqtref_t hofParamType = GENV_TYPESYSTEM.create_function_type(
-                   args,
-                   GENV_TYPESYSTEM.BOOLEAN_TYPE_ONE,
-                   TypeConstants::QUANT_ONE);
-
-    DECL_WITH_KIND(sctx,
-                   fn_filter,
-                   (createQName(static_context::W3C_FN_NS, "", "filter"),
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   hofParamType,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR),
-                   FunctionConsts::FN_FILTER_2);
-  }
-
-  {
-    std::vector<xqtref_t> args;
-    args.push_back(GENV_TYPESYSTEM.ITEM_TYPE_ONE);
-    args.push_back(GENV_TYPESYSTEM.ITEM_TYPE_ONE);
-
-    xqtref_t hofParamType = GENV_TYPESYSTEM.create_function_type(
-                   args,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   TypeConstants::QUANT_ONE);
-
-    DECL_WITH_KIND(sctx,
-                   fn_for_each_pair_3_0,
-                   (createQName(static_context::W3C_FN_NS, "", "for-each-pair"),
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   hofParamType,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR),
-                   FunctionConsts::FN_FOR_EACH_PAIR_3);
-  }
-
-  {
-    std::vector<xqtref_t> args;
-    xqtref_t hofParamType;
-    
-    args.push_back(GENV_TYPESYSTEM.ITEM_TYPE_STAR);
-    args.push_back(GENV_TYPESYSTEM.ITEM_TYPE_ONE);
-    hofParamType = GENV_TYPESYSTEM.create_function_type(
-                   args,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   TypeConstants::QUANT_ONE);
-
-    DECL_WITH_KIND(sctx,
-                   fn_fold_left_3_0,
-                   (createQName(static_context::W3C_FN_NS, "", "fold-left"),
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   hofParamType,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR),
-                   FunctionConsts::FN_FOLD_LEFT_3);
-    
-    args.clear();
-    args.push_back(GENV_TYPESYSTEM.ITEM_TYPE_ONE);
-    args.push_back(GENV_TYPESYSTEM.ITEM_TYPE_STAR);
-    hofParamType = GENV_TYPESYSTEM.create_function_type(
-                   args,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   TypeConstants::QUANT_ONE);
-
-    DECL_WITH_KIND(sctx,
-                   fn_fold_right_3_0,
-                   (createQName(static_context::W3C_FN_NS, "", "fold-right"),
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR,
-                   hofParamType,
-                   GENV_TYPESYSTEM.ITEM_TYPE_STAR),
-                   FunctionConsts::FN_FOLD_RIGHT_3);
-  }
-
+  DECL_WITH_KIND(sctx,
+                 fn_for_each_3_0,
+                 (createQName(static_context::W3C_FN_NS, "", "for-each"),
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR,
+                  GENV_TYPESYSTEM.ANY_FUNCTION_TYPE_ONE,
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR),
+                 FunctionConsts::FN_FOR_EACH_2);
+
+  DECL_WITH_KIND(sctx,
+                 fn_filter,
+                 (createQName(static_context::W3C_FN_NS, "", "filter"),
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR,
+                  GENV_TYPESYSTEM.ANY_FUNCTION_TYPE_ONE,
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR),
+                 FunctionConsts::FN_FILTER_2);
+  
+  DECL_WITH_KIND(sctx,
+                 fn_for_each_pair_3_0,
+                 (createQName(static_context::W3C_FN_NS, "", "for-each-pair"),
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR,
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR,
+                  GENV_TYPESYSTEM.ANY_FUNCTION_TYPE_ONE,
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR),
+                 FunctionConsts::FN_FOR_EACH_PAIR_3);
+  
+  DECL_WITH_KIND(sctx,
+                 fn_fold_left_3_0,
+                 (createQName(static_context::W3C_FN_NS, "", "fold-left"),
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR,
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR,
+                  GENV_TYPESYSTEM.ANY_FUNCTION_TYPE_ONE,
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR),
+                 FunctionConsts::FN_FOLD_LEFT_3);
+  
+  DECL_WITH_KIND(sctx,
+                 fn_fold_right_3_0,
+                 (createQName(static_context::W3C_FN_NS, "", "fold-right"),
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR,
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR,
+                  GENV_TYPESYSTEM.ANY_FUNCTION_TYPE_ONE,
+                  GENV_TYPESYSTEM.ITEM_TYPE_STAR),
+                 FunctionConsts::FN_FOLD_RIGHT_3);
 }
 
 }
 
=== modified file 'src/functions/func_parse_fragment_impl.cpp'
--- src/functions/func_parse_fragment_impl.cpp	2013-07-24 09:06:02 +0000
+++ src/functions/func_parse_fragment_impl.cpp	2013-09-20 12:27:16 +0000
@@ -37,25 +37,17 @@
 ********************************************************************************/
 void populate_context_parse_fragment_impl(static_context* sctx)
 {
-  xqtref_t lParseOptType =
-    GENV_TYPESYSTEM.create_node_type(
-        store::StoreConsts::elementNode,
-        createQName(static_context::ZORBA_XML_FN_OPTIONS_NS,"","options"),
-        NULL,
-        TypeConstants::QUANT_QUESTION,
-        false,
-        false
-      );
-
-  {
-    DECL_WITH_KIND(sctx, fn_zorba_xml_parse,
-        (createQName(static_context::ZORBA_XML_FN_NS,"","parse"),
-        GENV_TYPESYSTEM.STRING_TYPE_QUESTION, 
-        lParseOptType, 
-        GENV_TYPESYSTEM.ANY_NODE_TYPE_STAR),
-        FunctionConsts::FN_ZORBA_XML_PARSE_2);
-
-  }
+  // Note: the actual type of the 2nd param should be element(options)?
+  // However, we cannot use a non-builtin type in the signature of a builtin
+  // function. That's why we use type element() here and do special handling
+  // of this function in the translator.
+  DECL_WITH_KIND(sctx, fn_zorba_xml_parse,
+                 (createQName(static_context::ZORBA_XML_FN_NS, "", "parse"), 
+                  GENV_TYPESYSTEM.STRING_TYPE_QUESTION, 
+                  GENV_TYPESYSTEM.ELEMENT_TYPE_QUESTION, 
+                  GENV_TYPESYSTEM.ANY_NODE_TYPE_STAR),
+                 FunctionConsts::FN_ZORBA_XML_PARSE_2);
+
 }
 
 }
 
=== modified file 'src/functions/func_strings_impl.cpp'
--- src/functions/func_strings_impl.cpp	2013-02-07 17:24:36 +0000
+++ src/functions/func_strings_impl.cpp	2013-09-20 12:27:16 +0000
@@ -62,27 +62,34 @@
 }
 
 
+
 /*******************************************************************************
 
 ********************************************************************************/
-void populate_context_strings_impl(static_context* sctx)
+xqtref_t fn_analyze_string_3_0::getReturnType(const fo_expr* caller) const
 {
-  xqtref_t lAnalyzeStringResultType =
-    GENV_TYPESYSTEM.create_node_type(
+  return
+  GENV_TYPESYSTEM.create_node_type(
         store::StoreConsts::elementNode,
-        createQName("http://www.w3.org/2005/xpath-functions","","analyze-string-result"),
+        createQName(static_context::W3C_FN_NS,"","analyze-string-result"),
         NULL,
         TypeConstants::QUANT_ONE,
         false,
-        false
-      );
-
+        false);
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void populate_context_strings_impl(static_context* sctx)
+{
   {
     DECL_WITH_KIND(sctx, fn_analyze_string_3_0,
         (createQName("http://www.w3.org/2005/xpath-functions","","analyze-string"), 
         GENV_TYPESYSTEM.STRING_TYPE_QUESTION, 
         GENV_TYPESYSTEM.STRING_TYPE_ONE, 
-        lAnalyzeStringResultType),
+        GENV_TYPESYSTEM.ELEMENT_TYPE_ONE),
         FunctionConsts::FN_ANALYZE_STRING_2);
 
   }
@@ -94,7 +101,7 @@
         GENV_TYPESYSTEM.STRING_TYPE_QUESTION, 
         GENV_TYPESYSTEM.STRING_TYPE_ONE, 
         GENV_TYPESYSTEM.STRING_TYPE_ONE, 
-        lAnalyzeStringResultType),
+        GENV_TYPESYSTEM.ELEMENT_TYPE_ONE),
         FunctionConsts::FN_ANALYZE_STRING_3);
   }
 }
 
=== modified file 'src/functions/function.cpp'
--- src/functions/function.cpp	2013-07-31 16:35:39 +0000
+++ src/functions/function.cpp	2013-09-20 12:27:16 +0000
@@ -57,6 +57,12 @@
     setFlag(FunctionConsts::isBuiltin);
 #ifndef NDEBUG
     theRefCount = 1000000;
+
+    csize numTypes = sig.theTypes.size();
+    for (csize i = 0; i < numTypes; ++i)
+    {
+      assert(sig.theTypes[i]->is_builtin());
+    }
 #endif
   }
 
 
=== modified file 'src/functions/function.h'
--- src/functions/function.h	2013-08-02 21:35:01 +0000
+++ src/functions/function.h	2013-09-20 12:27:16 +0000
@@ -48,11 +48,7 @@
   The root sctx of the module containing the declaration. It is NULL for 
   functions that must be executed in the static context of the caller.
 ********************************************************************************/
-#if defined NDEBUG || defined ZORBA_FOR_ONE_THREAD_ONLY
 class function : public SimpleRCObject
-#else
-class function : public SyncedRCObject
-#endif
 {
 protected:
 	signature                    theSignature;
@@ -66,11 +62,7 @@
 
 public:
   SERIALIZABLE_CLASS(function);
-#if defined NDEBUG || defined ZORBA_FOR_ONE_THREAD_ONLY
   SERIALIZABLE_CLASS_CONSTRUCTOR3(function, SimpleRCObject, theSignature);
-#else
-  SERIALIZABLE_CLASS_CONSTRUCTOR3(function, SyncedRCObject, theSignature);
-#endif
   void serialize(::zorba::serialization::Archiver& ar);
 
 public:
 
=== modified file 'src/functions/pregenerated/func_strings.h'
--- src/functions/pregenerated/func_strings.h	2013-07-11 22:08:29 +0000
+++ src/functions/pregenerated/func_strings.h	2013-09-20 12:27:16 +0000
@@ -447,6 +447,8 @@
 theXQueryVersion = StaticContextConsts::xquery_version_3_0;
   }
 
+  xqtref_t getReturnType(const fo_expr* caller) const;
+
   CODEGEN_DECL();
 };
 
 
=== modified file 'src/functions/signature.cpp'
--- src/functions/signature.cpp	2013-03-04 21:00:58 +0000
+++ src/functions/signature.cpp	2013-09-20 12:27:16 +0000
@@ -21,6 +21,13 @@
 
 #include "types/typeops.h"
 
+#include "functions/function.h"
+#include "functions/library.h"
+
+#include "context/static_context.h"
+
+#include "store/api/item_factory.h"
+
 #include "zorbaserialization/serialize_template_types.h"
 #include "zorbaserialization/serialize_zorba_types.h"
 
@@ -31,100 +38,100 @@
 {
 
 SERIALIZABLE_CLASS_VERSIONS(signature)
-
-
-signature::signature(
-    const store::Item_t& name,
-    const xqtref_t& paramType1,
-    bool variadic,
-    const xqtref_t& returnType)
-  :
-  theQName(name),
-  theNonOptimizedReturnType(NULL),
-  theIsVariadic(variadic)
-{
-  theTypes.push_back(returnType);
-  theTypes.push_back(paramType1);
-}
-
-
-signature::signature(
-    const store::Item_t& name,
-    const xqtref_t& paramType1,
-    const xqtref_t& paramType2,
-    bool variadic,
-    const xqtref_t& returnType)
-  :
-  theQName(name),
-  theNonOptimizedReturnType(NULL),
-  theIsVariadic(variadic)
-{
-  theTypes.push_back(returnType);
-  theTypes.push_back(paramType1);
-  theTypes.push_back(paramType2);
-}
-
-
-signature::signature(
-    const store::Item_t& name,
-    const xqtref_t& returnType)
-  :
-  theQName(name),
-  theNonOptimizedReturnType(NULL),
-  theIsVariadic(false)
-{
-  theTypes.push_back(returnType);
-}
-
-
-signature::signature(
-    const store::Item_t& name,
-    const xqtref_t& paramType1,
-    const xqtref_t& returnType)
-  :
-  theQName(name),
-  theNonOptimizedReturnType(NULL),
-  theIsVariadic(false)
-{
-  theTypes.push_back(returnType);
-  theTypes.push_back(paramType1);
-}
-
-
-signature::signature(
-    const store::Item_t& name,
-    const xqtref_t& paramType1,
-    const xqtref_t& paramType2,
-    const xqtref_t& returnType)
-  :
-  theQName(name),
-  theNonOptimizedReturnType(NULL),
-  theIsVariadic(false)
-{
-  theTypes.push_back(returnType);
-  theTypes.push_back(paramType1);
-  theTypes.push_back(paramType2);
-}
-
-
-signature::signature(
-    const store::Item_t& name,
-    const xqtref_t& paramType1,
-    const xqtref_t& paramType2,
+
+
+signature::signature(
+    const store::Item_t& name,
+    const xqtref_t& paramType1,
+    bool variadic,
+    const xqtref_t& returnType)
+  :
+  theQName(name),
+  theNonOptimizedReturnType(NULL),
+  theIsVariadic(variadic)
+{
+  theTypes.push_back(returnType);
+  theTypes.push_back(paramType1);
+}
+
+
+signature::signature(
+    const store::Item_t& name,
+    const xqtref_t& paramType1,
+    const xqtref_t& paramType2,
+    bool variadic,
+    const xqtref_t& returnType)
+  :
+  theQName(name),
+  theNonOptimizedReturnType(NULL),
+  theIsVariadic(variadic)
+{
+  theTypes.push_back(returnType);
+  theTypes.push_back(paramType1);
+  theTypes.push_back(paramType2);
+}
+
+
+signature::signature(
+    const store::Item_t& name,
+    const xqtref_t& returnType)
+  :
+  theQName(name),
+  theNonOptimizedReturnType(NULL),
+  theIsVariadic(false)
+{
+  theTypes.push_back(returnType);
+}
+
+
+signature::signature(
+    const store::Item_t& name,
+    const xqtref_t& paramType1,
+    const xqtref_t& returnType)
+  :
+  theQName(name),
+  theNonOptimizedReturnType(NULL),
+  theIsVariadic(false)
+{
+  theTypes.push_back(returnType);
+  theTypes.push_back(paramType1);
+}
+
+
+signature::signature(
+    const store::Item_t& name,
+    const xqtref_t& paramType1,
+    const xqtref_t& paramType2,
+    const xqtref_t& returnType)
+  :
+  theQName(name),
+  theNonOptimizedReturnType(NULL),
+  theIsVariadic(false)
+{
+  theTypes.push_back(returnType);
+  theTypes.push_back(paramType1);
+  theTypes.push_back(paramType2);
+}
+
+
+signature::signature(
+    const store::Item_t& name,
+    const xqtref_t& paramType1,
+    const xqtref_t& paramType2,
     const xqtref_t& paramType3,
-    const xqtref_t& returnType)
-  :
-  theQName(name),
-  theNonOptimizedReturnType(NULL),
-  theIsVariadic(false)
-{
-  theTypes.push_back(returnType);
-  theTypes.push_back(paramType1);
-  theTypes.push_back(paramType2);
+    const xqtref_t& returnType)
+  :
+  theQName(name),
+  theNonOptimizedReturnType(NULL),
+  theIsVariadic(false)
+{
+  theTypes.push_back(returnType);
+  theTypes.push_back(paramType1);
+  theTypes.push_back(paramType2);
   theTypes.push_back(paramType3);
 }
-
-
+
+
 signature::signature(
     const store::Item_t& name,
     const xqtref_t& paramType1,
@@ -309,8 +316,13 @@
 }
 
 
+/*******************************************************************************
+  "this" is the signature of the function object. "s" is the signature of the
+  declaration appearing in the lib module.
+********************************************************************************/
 bool signature::subtype(
     const TypeManager* tm,
+    const function* func,
     const signature& s,
     const QueryLoc& loc) const
 {
@@ -320,8 +332,8 @@
   if (!theQName->equals(s.theQName.getp()))
     return false;
 
-  if (theNonOptimizedReturnType.getp() != NULL && s.theNonOptimizedReturnType.getp() != NULL
-      &&
+  if (theNonOptimizedReturnType.getp() != NULL &&
+      s.theNonOptimizedReturnType.getp() != NULL &&
       !TypeOps::is_subtype(tm,
                            *theNonOptimizedReturnType.getp(),
                            *s.theNonOptimizedReturnType.getp(),
@@ -330,12 +342,35 @@
     return false;
   }
 
-  assert (s.theTypes.size() == theTypes.size() || theIsVariadic );
+  assert (s.theTypes.size() == theTypes.size() || theIsVariadic);
+
   for (csize i = 0; i < theTypes.size(); ++i)
   {
+    xqtref_t builtinParamType = theTypes[i];
+
+    if (func == BUILTIN_FUNC(FN_ZORBA_XML_PARSE_2))
+    {
+      if (i == 2)
+      {
+        store::Item_t typeName;
+        GENV_ITEMFACTORY->createQName(typeName,
+                                      static_context::ZORBA_XML_FN_OPTIONS_NS,
+                                      "",
+                                      "options"),
+
+        builtinParamType = tm->
+        create_node_type(store::StoreConsts::elementNode,
+                         typeName,
+                         NULL,
+                         TypeConstants::QUANT_QUESTION,
+                         false,
+                         false);
+      }
+    }
+
     if (!TypeOps::is_subtype(tm,
-                             *theTypes[i].getp(),
-                             *s.theTypes[i].getp(),
+                             *builtinParamType,   // subtype
+                             *s.theTypes[i].getp(), // supertype
                              loc))
     {
       return false;
 
=== modified file 'src/functions/signature.h'
--- src/functions/signature.h	2013-03-04 21:00:58 +0000
+++ src/functions/signature.h	2013-09-20 12:27:16 +0000
@@ -25,24 +25,36 @@
 
 namespace zorba {
 
+class function;
+
 #define VARIADIC_SIG_SIZE 1000000
 
 /*******************************************************************************
 
-  By convention, theTypes[0]    = return type
-                 theTypes[1]    = first param type
-                 theTypes[2]    = second param type
-                  ...       =  ...
+  theQName :
+  the qname of the function
+
+  theTypes:
+  The return type and the paremater types. By convention, theTypes[0] holds the
+  return type, theTypes[1] holds the first param type, theTypes[2] holds the 2nd
+  param type, etc.
+
+  theNonOptimizedReturnType:
+  This is the original, non-optimized return type of a function. Used in function
+  literals type checks.
+
+  theIsVariadic:
+  Whether thefunction is variadic.
 
 ********************************************************************************/
 class signature: public SimpleRCObject
 {
+  friend class function;
+
  protected:
   store::Item_t            theQName;
   checked_vector<xqtref_t> theTypes;
-  xqtref_t                 theNonOptimizedReturnType; // This is the original, non-optimized
-                                                      // return type of a function. Used in
-                                                      // function literals type checks.
+  xqtref_t                 theNonOptimizedReturnType;
   bool                     theIsVariadic;
 
  public:
@@ -192,6 +204,7 @@
 
   bool subtype(
       const TypeManager* tm,
+      const function* func,
       const signature& s,
       const QueryLoc& loc) const;
 };
 
=== modified file 'src/runtime/spec/strings/strings.xml'
--- src/runtime/spec/strings/strings.xml	2013-07-11 22:08:29 +0000
+++ src/runtime/spec/strings/strings.xml	2013-09-20 12:27:16 +0000
@@ -670,19 +670,26 @@
   </zorba:description>
 
   <zorba:function generateDECL="false">
-    <zorba:signature localname="analyze-string" prefix="fn" version="3.0">
-      <zorba:param>xs:string?</zorba:param>
-      <zorba:param>xs:string</zorba:param>
-      <zorba:output>element()</zorba:output>
-    </zorba:signature>
-
-    <zorba:signature localname="analyze-string" prefix="fn" version="3.0">
-      <zorba:param>xs:string?</zorba:param>
-      <zorba:param>xs:string</zorba:param>
-      <zorba:param>xs:string</zorba:param>
-      <zorba:output>element()</zorba:output>
-    </zorba:signature>
+
+    <zorba:signature localname="analyze-string" prefix="fn" version="3.0">
+      <zorba:param>xs:string?</zorba:param>
+      <zorba:param>xs:string</zorba:param>
+      <zorba:output>element()</zorba:output>
+    </zorba:signature>
+
+    <zorba:signature localname="analyze-string" prefix="fn" version="3.0">
+      <zorba:param>xs:string?</zorba:param>
+      <zorba:param>xs:string</zorba:param>
+      <zorba:param>xs:string</zorba:param>
+      <zorba:output>element()</zorba:output>
+    </zorba:signature>
+
+    <zorba:methods>
+      <zorba:getReturnType/>
+    </zorba:methods>
+
   </zorba:function>
+
 </zorba:iterator>
 
 <!--
 
=== modified file 'src/system/globalenv.cpp'
--- src/system/globalenv.cpp	2013-08-14 08:46:44 +0000
+++ src/system/globalenv.cpp	2013-09-20 12:27:16 +0000
@@ -61,6 +61,11 @@
 
 #include "diagnostics/assert.h"
 
+
+#include "types/schema/xercesIncludes.h"
+#include "types/schema/StrX.h"
+
+
 using namespace zorba;
 
 
@@ -72,7 +77,18 @@
 void GlobalEnvironment::init(store::Store* store)
 {
   // initialize Xerces-C lib
-  Schema::initialize();
+#ifndef ZORBA_NO_XMLSCHEMA
+  try
+  {
+    XERCES_CPP_NAMESPACE::XMLPlatformUtils::Initialize();
+  }
+  catch (const XERCES_CPP_NAMESPACE::XMLException& toCatch)
+  {
+    std::cerr << "Error during Xerces-C initialization! Message:\n"
+              << StrX(toCatch.getMessage()) << std::endl;
+    abort();
+  }
+#endif
 
   m_globalEnv = new GlobalEnvironment();
 
@@ -122,10 +138,9 @@
 
 
 /*******************************************************************************
-
+  destroy all components that were initialized in init 
+  note: destruction must be done in reverse initialization order
 ********************************************************************************/
-// destroy all components that were initialized in init 
-// note: destruction must be done in reverse initialization order
 void GlobalEnvironment::destroy()
 {
   delete m_globalEnv->theDynamicLoader;
@@ -168,8 +183,9 @@
 	m_globalEnv = NULL;
 
   // terminate Xerces-C lib
-  Schema::terminate();
-
+#ifndef ZORBA_NO_XMLSCHEMA
+  XERCES_CPP_NAMESPACE::XMLPlatformUtils::Terminate();
+#endif
 }
 
 
 
=== modified file 'src/types/schema/schema.cpp'
--- src/types/schema/schema.cpp	2013-09-17 21:12:49 +0000
+++ src/types/schema/schema.cpp	2013-09-20 12:27:16 +0000
@@ -18,6 +18,7 @@
 #include <string>
 
 #include "compiler/parser/query_loc.h"
+
 #include "context/namespace_context.h"
 #include "context/static_context.h"
 #include "context/uri_resolver.h"
@@ -36,10 +37,14 @@
 #include "types/schema/LoadSchemaErrorHandler.h"
 #include "types/schema/PrintSchema.h"
 #include "types/schema/XercesParseUtils.h"
+#include "types/schema/xercesIncludes.h"
+
 #include "system/globalenv.h"
+
 #include "store/api/item_factory.h"
+
 #include "util/utf8_util.h"
-#include "types/schema/xercesIncludes.h"
+
 #include "zorbatypes/URI.h"
 #include <zorba/internal/unique_ptr.h>
 
@@ -82,8 +87,6 @@
 
 const char* Schema::XSD_NAMESPACE = static_context::W3C_XML_SCHEMA_NS;
 
-bool Schema::theIsInitialized = false;
-
 #ifndef ZORBA_NO_XMLSCHEMA
 
 
@@ -332,45 +335,6 @@
 
 
 /*******************************************************************************
-  Initialize the Xerces platform. Called from GlobalEnvironment::init().
-*******************************************************************************/
-void Schema::initialize()
-{
-#ifndef ZORBA_NO_XMLSCHEMA
-  if (theIsInitialized)
-    return;
-
-  try
-  {
-    XERCES_CPP_NAMESPACE::XMLPlatformUtils::Initialize();
-    theIsInitialized = true;
-  }
-  catch (const XERCES_CPP_NAMESPACE::XMLException& toCatch)
-  {
-    std::cerr   << "Error during Xerces-C initialization! Message:\n"
-                << StrX(toCatch.getMessage()) << std::endl;
-    return;
-  }
-#endif
-}
-
-
-/*******************************************************************************
-  Terminate the Xerces platform. Called from GlobalEnvironment::destroy().
-*******************************************************************************/
-void Schema::terminate()
-{
-#ifndef ZORBA_NO_XMLSCHEMA
-  if (theIsInitialized)
-  {
-    XERCES_CPP_NAMESPACE::XMLPlatformUtils::Terminate();
-    theIsInitialized = false;
-  }
-#endif
-}
-
-
-/*******************************************************************************
 
 *******************************************************************************/
 Schema::Schema(TypeManager* tm)
@@ -378,6 +342,8 @@
   theTypeManager(tm),
   theHasXSD(false)
 {
+  ZORBA_ASSERT(tm != &GENV_TYPESYSTEM);
+
 #ifndef ZORBA_NO_XMLSCHEMA
   theGrammarPool = new XMLGrammarPoolImpl(XMLPlatformUtils::fgMemoryManager);
   // QQQ should be zstring
@@ -393,7 +359,6 @@
 Schema::Schema(::zorba::serialization::Archiver& ar)
 {
 #ifndef ZORBA_NO_XMLSCHEMA
-  initialize();
   theGrammarPool = new XMLGrammarPoolImpl(XMLPlatformUtils::fgMemoryManager);
   theHasXSD = false;
 #endif
@@ -443,8 +408,8 @@
   try
   {
     SAX2XMLReader* reader =
-      XMLReaderFactory::createXMLReader(XMLPlatformUtils::fgMemoryManager,
-					theGrammarPool);
+    XMLReaderFactory::createXMLReader(XMLPlatformUtils::fgMemoryManager,
+                                      theGrammarPool);
 
     parser.reset(reader);
     // Perform namespace processing
@@ -879,7 +844,8 @@
                                                 baseXQType,
                                                 TypeConstants::QUANT_ONE,
                                                 XQType::ATOMIC_UDT,
-                                                XQType::SIMPLE_CONTENT_KIND);
+                                                XQType::SIMPLE_CONTENT_KIND,
+                                                false);
 
         TRACE("created atomic " << qname->getStringValue()
               << " base:" << baseXQType->toString());
@@ -913,7 +879,8 @@
                                                 xsTypeDef->getAnonymous(),
                                                 qname,
                                                 NULL,
-                                                itemXQType.getp());
+                                                itemXQType.getp(),
+                                                false);
 
         //cout << "   created UDT Simple List Type: " << xqType->toString() <<
         //  endl; cout.flush();
@@ -970,7 +937,8 @@
                                                 qname,
                                                 baseXQType,
                                                 TypeConstants::QUANT_ONE,
-                                                unionItemTypes);
+                                                unionItemTypes,
+                                                false);
 
         //std::cout << "   created UDT Union Type: " << xqType->toString() << std::endl;
         //  std::cout.flush();
@@ -1073,7 +1041,8 @@
                                               baseXQType,
                                               TypeConstants::QUANT_ONE,
                                               XQType::COMPLEX_UDT,
-                                              contentType);
+                                              contentType,
+                                              false);
 
       result = xqType;
 
@@ -1330,7 +1299,8 @@
   }
 
   XSNamedMap<XSObject> * elemDefs =
-      model->getComponents(XSConstants::ELEMENT_DECLARATION);
+  model->getComponents(XSConstants::ELEMENT_DECLARATION);
+
   for( uint i = 0; i<elemDefs->getLength(); i++)
   {
     XSElementDeclaration* elemDecl = (XSElementDeclaration*)(elemDefs->item(i));
@@ -1539,13 +1509,14 @@
       }
 
       xqtref_t xqType =
-        xqtref_t(new UserDefinedXQType(typeManager,
-                                       xsTypeDef->getAnonymous(),
-                                       qname,
-                                       baseXQType,
-                                       TypeConstants::QUANT_ONE,
-                                       XQType::COMPLEX_UDT,
-                                       contentType));
+      xqtref_t(new UserDefinedXQType(typeManager,
+                                     xsTypeDef->getAnonymous(),
+                                     qname,
+                                     baseXQType,
+                                     TypeConstants::QUANT_ONE,
+                                     XQType::COMPLEX_UDT,
+                                     contentType,
+                                     false));
 
       addTypeToCache(xqType);
 
 
=== modified file 'src/types/schema/schema.h'
--- src/types/schema/schema.h	2013-05-16 17:38:41 +0000
+++ src/types/schema/schema.h	2013-09-20 12:27:16 +0000
@@ -68,23 +68,15 @@
   static const char* XSD_NAMESPACE;
 
 private:
-  static bool                                theIsInitialized;
-
   TypeManager                              * theTypeManager;
 
   bool                                       theHasXSD;
 #ifndef ZORBA_NO_XMLSCHEMA
   XERCES_CPP_NAMESPACE::XMLGrammarPool     * theGrammarPool;
-  // QQQ use zstring?
   UdTypesCache                             * theUdTypesCache;
 #endif // ZORBA_NO_XMLSCHEMA
 
 public:
-    static void initialize();
-
-    static void terminate();
-
-public:
   SERIALIZABLE_CLASS(Schema)
   Schema(::zorba::serialization::Archiver& ar);
   void serialize(::zorba::serialization::Archiver& ar);
 
=== modified file 'src/types/typeimpl.cpp'
--- src/types/typeimpl.cpp	2013-07-23 17:34:35 +0000
+++ src/types/typeimpl.cpp	2013-09-20 12:27:16 +0000
@@ -174,6 +174,7 @@
     TypeConstants::quantifier_t quantifier,
     bool builtin)
   :
+  theRefCount(0),
   theManager((TypeManager*)manager),
   theKind(type_kind),
   theQuantifier(quantifier),
@@ -182,13 +183,33 @@
   if (theIsBuiltin)
   {
 #ifndef NDEBUG
-    theRefCount = 1000000;
+    //theRefCount = 1000000;
 #endif
     // register this hardcoded object to help plan serialization
     XQType* this_ptr = this;
     *::zorba::serialization::ClassSerializer::getInstance()->
     getArchiverForHardcodedObjects() & this_ptr;
   }
+#if 0
+  else
+  {
+    std::cout << "allocated type " << this << " of kind "
+              << KIND_STRINGS[type_kind] << std::endl;
+  }
+#endif
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+XQType::~XQType()
+{
+  if (theIsBuiltin)
+  {
+    assert(theRefCount == 0);
+    theRefCount = 0;
+  }
 }
 
 
@@ -796,6 +817,21 @@
          (contentType == NULL ||
           contentType->type_kind() == XQType::UNTYPED_KIND ||
           contentType->type_kind() == XQType::ANY_TYPE_KIND));
+
+#if 0
+  if (theIsBuiltin == false &&
+      nodeKind == store::StoreConsts::elementNode &&
+      contentType == NULL &&
+      nodeName == NULL)
+  {
+    ZORBA_ASSERT(false);
+  }
+
+  if (!theIsBuiltin)
+  {
+    std::cout << "allocated type " << this << " : " << toSchemaString() << std::endl;
+  }
+#endif
 }
 
 
@@ -804,15 +840,31 @@
 ********************************************************************************/
 NodeXQType::NodeXQType(
     const NodeXQType& source,
-    TypeConstants::quantifier_t quantifier)
+    TypeConstants::quantifier_t quantifier,
+    bool builtin)
   :
-  XQType(source.theManager, NODE_TYPE_KIND, quantifier, false),
+  XQType(source.theManager, NODE_TYPE_KIND, quantifier, builtin),
   theNodeKind(source.theNodeKind),
   theNodeName(source.theNodeName),
   theContentType(source.theContentType),
   theNillable(source.theNillable),
   theIsSchemaTest(source.theIsSchemaTest)
 {
+#if 0
+  if (theIsBuiltin == false &&
+      theNodeKind == store::StoreConsts::elementNode &&
+      theContentType == NULL &&
+      theNodeName == NULL)
+  {
+    std::cerr << "STRANGE TYPE" << std::endl;
+    theNodeKind = store::StoreConsts::elementNode;
+  }
+
+  if (!theIsBuiltin)
+  {
+    std::cout << "allocated copy type " << this << " : " << toSchemaString() << std::endl;
+  }
+#endif
 }
 
 
 
=== modified file 'src/types/typeimpl.h'
--- src/types/typeimpl.h	2013-08-02 21:35:01 +0000
+++ src/types/typeimpl.h	2013-09-20 12:27:16 +0000
@@ -264,11 +264,7 @@
   TypeManager is deleted during engine shutdown.
 
 ********************************************************************************/
-#if defined NDEBUG || defined ZORBA_FOR_ONE_THREAD_ONLY 
-class XQType : public SimpleRCObject
-#else
-class XQType : public SyncedRCObject
-#endif
+class XQType : public serialization::SerializeBaseClass
 {
 public:
   //
@@ -341,6 +337,8 @@
 protected:
   static const char            * KIND_STRINGS[XQType::MAX_TYPE_KIND];
 
+  mutable long                   theRefCount;
+
   TypeManager                  * theManager;
   TypeKind                       theKind;
   TypeConstants::quantifier_t    theQuantifier;
@@ -349,21 +347,42 @@
 
 public:
   SERIALIZABLE_ABSTRACT_CLASS(XQType)
-#if defined NDEBUG || defined ZORBA_FOR_ONE_THREAD_ONLY
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(XQType, SimpleRCObject)
-#else
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(XQType, SyncedRCObject)
-#endif
+
+  XQType(::zorba::serialization::Archiver& ar)
+    :
+    serialization::SerializeBaseClass(),
+    theRefCount(0),
+    theIsBuiltin(false)
+  {
+  }
+
   void serialize(::zorba::serialization::Archiver& ar);
 
 public:
-  virtual ~XQType() { }
-
-  void free()
-  {
-    if (!theIsBuiltin)
-      delete this;
-  }
+  long getRefCount() const
+  {
+    return theRefCount;
+  }
+
+  void addReference() const
+  {
+    if (!theIsBuiltin)
+      ++theRefCount;
+  }
+
+  void removeReference() 
+  {
+    if (!theIsBuiltin)
+    {
+      assert(getRefCount() > 0);
+
+      if (--theRefCount == 0)
+        delete this;
+    }
+  }
+
+public:
+  virtual ~XQType();
 
   TypeManager* get_manager() const { return theManager; }
 
@@ -421,6 +440,9 @@
       TypeKind kind,
       TypeConstants::quantifier_t quant,
       bool builtin);
+
+private:
+  XQType& operator=(const XQType& t);
 };
 
 
@@ -435,7 +457,7 @@
 class NoneXQType : public XQType
 {
 public:
-  NoneXQType(const TypeManager* manager, bool builtin = false);
+  NoneXQType(const TypeManager* manager, bool builtin);
 
  public:
   SERIALIZABLE_CLASS(NoneXQType)
@@ -450,7 +472,7 @@
 class EmptyXQType : public XQType
 {
 public:
-  EmptyXQType(const TypeManager* manager, bool builtin = false);
+  EmptyXQType(const TypeManager* manager, bool builtin);
 
  public:
   SERIALIZABLE_CLASS(EmptyXQType)
@@ -468,7 +490,7 @@
   ItemXQType(
       const TypeManager* tm,
       TypeConstants::quantifier_t q,
-      bool builtin = false);
+      bool builtin);
 
  public:
   SERIALIZABLE_CLASS(ItemXQType)
@@ -501,7 +523,7 @@
       const TypeManager* manager,
       store::SchemaTypeCode code,
       TypeConstants::quantifier_t quant,
-      bool builtin = false)
+      bool builtin)
     :
     XQType(manager, ATOMIC_TYPE_KIND, quant, builtin),
     theAtomicCode(code)
@@ -524,7 +546,7 @@
   StructuredItemXQType(
       const TypeManager* tm,
       TypeConstants::quantifier_t quant,
-      bool builtin = false);
+      bool builtin);
 
  public:
   SERIALIZABLE_CLASS(StructuredItemXQType)
@@ -552,7 +574,7 @@
       const TypeManager* manager,
       store::StoreConsts::JSONItemKind kind,
       TypeConstants::quantifier_t quantifier,
-      bool builtin = false);
+      bool builtin);
 
   store::StoreConsts::JSONItemKind get_json_kind() const { return theJSONKind; }
 
@@ -589,9 +611,12 @@
       TypeConstants::quantifier_t quantifier,
       bool nillable,
       bool schematest,
-      bool builtin = false);
+      bool builtin);
 
-  NodeXQType(const NodeXQType& source, TypeConstants::quantifier_t quant);
+  NodeXQType(
+      const NodeXQType& source,
+      TypeConstants::quantifier_t quant,
+      bool builtin);
 
   store::StoreConsts::NodeKind get_node_kind() const { return theNodeKind; }
 
@@ -630,7 +655,7 @@
 class AnyFunctionXQType : public XQType
 {
 public:
-  AnyFunctionXQType(const TypeManager* manager, bool builtin = false)
+  AnyFunctionXQType(const TypeManager* manager, bool builtin)
     :
     XQType(manager, ANY_FUNCTION_TYPE_KIND, TypeConstants::QUANT_STAR, builtin)
   {
@@ -639,7 +664,7 @@
   AnyFunctionXQType(
       const TypeManager* manager,
       TypeConstants::quantifier_t quantifier,
-      bool builtin = false)
+      bool builtin)
     :
     XQType(manager, ANY_FUNCTION_TYPE_KIND, quantifier, builtin)
   {
@@ -673,7 +698,7 @@
         const std::vector<xqtref_t>& aParamTypes,
         const xqtref_t& aReturnType,
         TypeConstants::quantifier_t quantifier,
-        bool builtin = false);
+        bool builtin);
 
   const std::vector<xqtref_t>&
   get_param_types() const { return m_param_types; }
@@ -773,7 +798,7 @@
       TypeConstants::quantifier_t quantifier,
       UDTKind typeCategory,
       content_kind_t contentKind,
-      bool builtin = false);
+      bool builtin);
 
   // Constructor for List types
   UserDefinedXQType(
@@ -782,7 +807,7 @@
       store::Item_t qname,
       const xqtref_t& baseType,
       const XQType* listItemType,
-      bool builtin = false);
+      bool builtin);
 
   // Constructor for Union types
   UserDefinedXQType(
@@ -792,7 +817,7 @@
       const xqtref_t& baseType,
       TypeConstants::quantifier_t quantifier,
       const std::vector<xqtref_t>& unionItemTypes,
-      bool builtin = false);
+      bool builtin);
 
   virtual ~UserDefinedXQType() {}
 
@@ -823,7 +848,7 @@
 class AnyXQType : public XQType
 {
 public:
-  AnyXQType(const TypeManager* manager, bool builtin = false)
+  AnyXQType(const TypeManager* manager, bool builtin)
     :
     XQType(manager, ANY_TYPE_KIND, TypeConstants::QUANT_STAR, builtin)
   {
@@ -842,7 +867,7 @@
 class UntypedXQType : public XQType
 {
 public:
-  UntypedXQType(const TypeManager* manager, bool builtin = false)
+  UntypedXQType(const TypeManager* manager, bool builtin)
     :
     XQType(manager, UNTYPED_KIND, TypeConstants::QUANT_STAR, builtin)
   {
@@ -861,7 +886,7 @@
 class AnySimpleXQType : public XQType
 {
 public:
-  AnySimpleXQType(const TypeManager* manager, bool builtin = false)
+  AnySimpleXQType(const TypeManager* manager, bool builtin)
     :
     XQType(manager, ANY_SIMPLE_TYPE_KIND, TypeConstants::QUANT_STAR, builtin)
   {
 
=== modified file 'src/types/typemanagerimpl.cpp'
--- src/types/typemanagerimpl.cpp	2013-07-01 18:59:06 +0000
+++ src/types/typemanagerimpl.cpp	2013-09-20 12:27:16 +0000
@@ -112,6 +112,8 @@
 ********************************************************************************/
 void TypeManagerImpl::initializeSchema()
 {
+  ZORBA_ASSERT(this != &GENV_TYPESYSTEM);
+
   if ( m_schema == NULL )
     m_schema = new Schema(this);
 }
@@ -223,7 +225,7 @@
     const xqtref_t& returnType,
     TypeConstants::quantifier_t quant) const
 {
-  return new FunctionXQType(this, paramTypes, returnType, quant);
+  return new FunctionXQType(this, paramTypes, returnType, quant, false);
 }
 
 
@@ -532,7 +534,14 @@
     }
     else
     {
-      return new NodeXQType(this, nodeKind, NULL, contentType, quant, false, false);
+      return new NodeXQType(this,
+                            nodeKind,
+                            NULL,
+                            contentType,
+                            quant,
+                            false,
+                            false,
+                            false);
     }
   }
 
@@ -548,7 +557,8 @@
                             contentType,
                             quant,
                             nillable,
-                            schematest);
+                            schematest,
+                            false);
     }
     else
     {
@@ -567,7 +577,8 @@
                             contentType,
                             quant,
                             false,
-                            schematest);
+                            schematest,
+                            false);
     }
     else
     {
@@ -594,6 +605,7 @@
                             RTM.STRING_TYPE_ONE,
                             quant,
                             nillable,
+                            false,
                             false);
     }
   }
@@ -861,7 +873,8 @@
     return new FunctionXQType(this,
                               paramTypes,
                               nonOptimizedRetType.getp() ? nonOptimizedRetType : retType,
-                              quant);
+                              quant,
+                              false);
   }
 
   else
@@ -1006,7 +1019,7 @@
     }
     else
     {
-      return new NodeXQType(nt, quantifier);
+      return new NodeXQType(nt, quantifier, false);
     }
   }
 
@@ -1027,7 +1040,8 @@
     return new FunctionXQType(this,
                               ft.get_param_types(),
                               ft.get_return_type(),
-                              quantifier);
+                              quantifier,
+                              false);
   }
 
   case XQType::ITEM_KIND:
@@ -1064,7 +1078,8 @@
                                    udt.isAnonymous(),
                                    udt.getQName(),
                                    udt.getBaseType(),
-                                   udt.getListItemType());
+                                   udt.getListItemType(),
+                                   false);
     }
     else if (udt.isUnion())
     {
@@ -1073,7 +1088,8 @@
                                    udt.getQName(),
                                    udt.getBaseType(),
                                    quantifier,
-                                   udt.getUnionItemTypes());
+                                   udt.getUnionItemTypes(),
+                                   false);
     }
     else
     {
@@ -1083,7 +1099,8 @@
                                    udt.getBaseType(),
                                    quantifier,
                                    udt.getUDTKind(),
-                                   udt.contentKind());
+                                   udt.contentKind(),
+                                   false);
     }
   }
   default:
 
=== modified file 'src/types/typeops.cpp'
--- src/types/typeops.cpp	2013-06-24 07:56:21 +0000
+++ src/types/typeops.cpp	2013-09-20 12:27:16 +0000
@@ -322,7 +322,6 @@
 
   case XQType::JSON_TYPE_KIND: 
   case XQType::NODE_TYPE_KIND:
-
   {
     if (type.get_quantifier() == TypeConstants::QUANT_ONE)
       return &type;
 
=== modified file 'src/zorbaserialization/class_serializer.cpp'
--- src/zorbaserialization/class_serializer.cpp	2013-02-07 17:24:36 +0000
+++ src/zorbaserialization/class_serializer.cpp	2013-09-20 12:27:16 +0000
@@ -40,6 +40,16 @@
 /*******************************************************************************
 
 ********************************************************************************/
+ClassSerializer* ClassSerializer::getInstance()
+{
+  static ClassSerializer theInstance;
+  return &theInstance;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
 ClassSerializer::ClassSerializer() 
 {
   theClassFactories.resize(TYPE_LAST);
@@ -60,12 +70,21 @@
 
 
 /*******************************************************************************
-
-********************************************************************************/
-ClassSerializer* ClassSerializer::getInstance()
-{
-  static ClassSerializer theInstance;
-  return &theInstance;
+  called from GlobalEnvironment::destroy()
+********************************************************************************/
+void ClassSerializer::destroyArchiverForHardcodedObjects()
+{
+  delete harcoded_objects_archive;
+  harcoded_objects_archive = new MemArchiver(true, true);;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+Archiver* ClassSerializer::getArchiverForHardcodedObjects()
+{
+  return harcoded_objects_archive;
 }
 
 
@@ -93,26 +112,6 @@
 }
 
 
-/*******************************************************************************
-
-********************************************************************************/
-Archiver* ClassSerializer::getArchiverForHardcodedObjects()
-{
-  return harcoded_objects_archive;
-}
-
-
-/*******************************************************************************
-  called at shutdown
-********************************************************************************/
-void ClassSerializer::destroyArchiverForHardcodedObjects()
-{
-  delete harcoded_objects_archive;
-  harcoded_objects_archive = NULL;
-  harcoded_objects_archive = new MemArchiver(true, true);
-}
-
-
 } // namespace serialization
 } // namespace zorba
 /* vim:set et sw=2 ts=2: */
 
=== modified file 'src/zorbaserialization/class_serializer.h'
--- src/zorbaserialization/class_serializer.h	2013-03-05 00:45:43 +0000
+++ src/zorbaserialization/class_serializer.h	2013-09-20 12:27:16 +0000
@@ -125,7 +125,7 @@
   void operator&(Archiver& ar, T*& obj).
 
 ********************************************************************************/
-class ZORBA_DLL_PUBLIC SerializeBaseClass
+class SerializeBaseClass
 {
 public:
   virtual ~SerializeBaseClass() {}