zorba-coders team mailing list archive

[Markos Zaharioudakis <markos_za@xxxxxxxxx>]

Markos Zaharioudakis has proposed merging lp:~zorba-coders/zorba/markos-annotations into lp:zorba.

Requested reviews:
  Markos Zaharioudakis (markos-za)

For more details, see:
https://code.launchpad.net/~zorba-coders/zorba/markos-annotations/+merge/80899

simplified and optimized the implementation for annotations
-- 
https://code.launchpad.net/~zorba-coders/zorba/markos-annotations/+merge/80899
Your team Zorba Coders is subscribed to branch lp:zorba.

=== modified file 'src/annotations/annotations.cpp'
--- src/annotations/annotations.cpp	2011-08-11 17:19:25 +0000
+++ src/annotations/annotations.cpp	2011-11-01 13:50:27 +0000
@@ -15,21 +15,17 @@
  */
 #include "stdafx.h"
 
-#include <cmath>
-
 #include "annotations/annotations.h"
-#include "system/globalenv.h"
 
 #include "store/api/item.h"
 #include "store/api/item_factory.h"
 
-#include "context/static_context.h"
-#include "context/static_context_consts.h"
 #include "compiler/expression/expr.h"
 
 #include "zorbaserialization/serialization_engine.h"
 
 #include "diagnostics/assert.h"
+#include "diagnostics/util_macros.h"
 
 #include "system/globalenv.h"
 
@@ -38,90 +34,270 @@
 SERIALIZABLE_CLASS_VERSIONS(AnnotationInternal)
 END_SERIALIZABLE_CLASS_VERSIONS(AnnotationInternal)
 
-SERIALIZABLE_CLASS_VERSIONS(AnnotationLiteral)
-END_SERIALIZABLE_CLASS_VERSIONS(AnnotationLiteral)
-
 SERIALIZABLE_CLASS_VERSIONS(AnnotationList)
 END_SERIALIZABLE_CLASS_VERSIONS(AnnotationList);
 
 
-/*******************************************************************************
-
-********************************************************************************/
-AnnotationInternal::AnnotationInternal(const store::Item_t& aExpandedQName)
+std::vector<store::Item_t> 
+AnnotationInternal::theAnnotId2NameMap;
+
+ItemHandleHashMap<AnnotationInternal::AnnotationId> 
+AnnotationInternal::theAnnotName2IdMap(0, NULL, 64, false);
+
+std::vector<AnnotationInternal::RuleBitSet> 
+AnnotationInternal::theRuleSet;
+
+
+/*******************************************************************************
+  Static method, called from GlobalEnvironment::init()
+********************************************************************************/
+void AnnotationInternal::createBuiltIn()
+{
+  store::Item_t qname;
+  AnnotationId id;
+
+  theAnnotId2NameMap.resize(zann_end);
+
+  //
+  // W3C annotations
+  //
+  GENV_ITEMFACTORY->createQName(qname, static_context::W3C_FN_NS, "fn", "public");
+  id = fn_public;
+  theAnnotId2NameMap[id] = qname;
+  theAnnotName2IdMap.insert(qname, id);
+
+  GENV_ITEMFACTORY->createQName(qname, static_context::W3C_FN_NS, "fn", "private");
+  id = fn_private;
+  theAnnotId2NameMap[id] = qname;
+  theAnnotName2IdMap.insert(qname, id);
+
+#define ZANN(a, b)                                                     \
+  GENV_ITEMFACTORY->createQName(qname, ZORBA_ANNOTATIONS_NS, "", #a);  \
+  id = zann_##b;                                                      \
+  theAnnotId2NameMap[id] = qname;                                     \
+  theAnnotName2IdMap.insert(qname, id);
+
+
+  //
+  // Zorba annotations - deterministic/nondeterministic
+  //
+  ZANN(deterministic, deterministic);
+  ZANN(nondeterministic, nondeterministic);
+
+  //
+  // Zorba annotations - xquery scripting
+  //
+  ZANN(assignable, assignable);
+  ZANN(nonassignable, nonassignable);
+
+  ZANN(sequential, sequential);
+  ZANN(nonsequential, nonsequential);
+
+  //
+  // Zorba annotations - misc
+  //
+  ZANN(variadic, variadic);
+
+  ZANN(streamable, streamable);
+
+  //
+  // Zorba annotations - xqddf
+  //
+  ZANN(unique, unique);
+  ZANN(nonunique, nonunique);
+
+  ZANN(value-equality, value_equality);
+  ZANN(general-equality, general_equality);
+  ZANN(value-range, value_range);
+  ZANN(general-range, general_range);
+
+  ZANN(automatic, automatic);
+  ZANN(manual, manual);
+
+  ZANN(mutable, mutable);
+  ZANN(queue, queue);
+  ZANN(append-only, append_only);
+  ZANN(const, const);
+
+  ZANN(ordered, ordered);
+  ZANN(unordered, unordered);
+
+  ZANN(read-only-nodes, read_only_nodes);
+  ZANN(mutable-nodes, mutable_nodes);
+
+#undef ZANN
+
+  // create a set of rules to detect conflicts between annotations
+#define ZANN(a) \
+  ( 1 << static_cast<uint64_t>(AnnotationInternal::a) )
+
+  theRuleSet.push_back(
+       ZANN(zann_unique) |
+       ZANN(zann_nonunique));
+
+  theRuleSet.push_back(
+      ZANN(zann_value_equality) |
+      ZANN(zann_general_equality) |
+      ZANN(zann_value_range) |
+      ZANN(zann_general_range));
+
+  theRuleSet.push_back(
+      ZANN(zann_automatic) |
+      ZANN(zann_manual));
+
+  theRuleSet.push_back(
+      ZANN(zann_mutable) |
+      ZANN(zann_queue) |
+      ZANN(zann_append_only) |
+      ZANN(zann_const));
+
+  theRuleSet.push_back(
+      ZANN(zann_ordered) |
+      ZANN(zann_unordered));
+
+  theRuleSet.push_back(
+      ZANN(zann_assignable) |
+      ZANN(zann_nonassignable));
+
+  theRuleSet.push_back(
+      ZANN(zann_deterministic) |
+      ZANN(zann_nondeterministic));
+
+  theRuleSet.push_back(
+      ZANN(zann_sequential) |
+      ZANN(zann_nonsequential));
+
+  theRuleSet.push_back(
+      ZANN(fn_private) |
+      ZANN(fn_public));
+
+  theRuleSet.push_back(
+      ZANN(zann_unordered) |
+      ZANN(zann_queue));
+
+  theRuleSet.push_back(
+      ZANN(zann_unordered) |
+      ZANN(zann_append_only));
+
+  theRuleSet.push_back(
+      ZANN(zann_queue) |
+      ZANN(zann_append_only));
+
+  theRuleSet.push_back(
+      ZANN(zann_read_only_nodes) |
+      ZANN(zann_mutable_nodes));
+#undef ZANN
+}
+
+
+/*******************************************************************************
+  Static method, called from GlobalEnvironment::init()
+********************************************************************************/
+void AnnotationInternal::destroyBuiltIn()
+{
+  theAnnotId2NameMap.clear();
+  theAnnotName2IdMap.clear();
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+AnnotationInternal::AnnotationId AnnotationInternal::lookup(
+    const store::Item_t& qname)
+{
+  ItemHandleHashMap<AnnotationId>::iterator ite = theAnnotName2IdMap.find(qname);
+
+  if (ite == theAnnotName2IdMap.end())
+    return zann_end;
+
+  return (*ite).second;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::Item* AnnotationInternal::lookup(AnnotationInternal::AnnotationId id)
+{
+  assert(id < zann_end);
+  assert(id < theAnnotId2NameMap.size());
+
+  return theAnnotId2NameMap[id].getp();
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+AnnotationInternal::AnnotationInternal(const store::Item_t& qname)
   :
-  theQName(aExpandedQName)
+  theId(zann_end),
+  theQName(qname)
 {
+  ItemHandleHashMap<AnnotationId>::iterator ite = theAnnotName2IdMap.find(qname);
+  if (ite != theAnnotName2IdMap.end())
+    theId = (*ite).second;
 }
 
 
+/*******************************************************************************
+
+********************************************************************************/
 AnnotationInternal::AnnotationInternal(
-  const store::Item_t& aExpandedQName,
-  const std::vector<AnnotationLiteral_t>& aLiteralList)
+  const store::Item_t& qname,
+  std::vector<store::Item_t>& literals)
   :
-  theQName(aExpandedQName),
-  theLiteralList(aLiteralList)
+  theId(zann_end),
+  theQName(qname)
 {
+  theLiterals.swap(literals);
+
+  ItemHandleHashMap<AnnotationId>::iterator ite = theAnnotName2IdMap.find(qname);
+  if (ite != theAnnotName2IdMap.end())
+    theId = (*ite).second;
 }
 
 
+/*******************************************************************************
+
+********************************************************************************/
 void AnnotationInternal::serialize(::zorba::serialization::Archiver& ar)
 {
+  SERIALIZE_ENUM(AnnotationId, theId);
   ar & theQName;
-  ar & theLiteralList;
+  ar & theLiterals;
 }
 
 
+/*******************************************************************************
+
+********************************************************************************/
 const store::Item* AnnotationInternal::getQName() const
 {
   return theQName.getp();
 }
 
 
-unsigned int AnnotationInternal::getNumLiterals() const
-{
-  return (unsigned int)theLiteralList.size();
-}
-
-
-const AnnotationLiteral* AnnotationInternal::getLiteral(unsigned int index) const
-{
-  if (index < theLiteralList.size())
-    return theLiteralList[index];
-  else
-    return NULL;
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-void AnnotationLiteral::serialize(::zorba::serialization::Archiver& ar)
-{
-  ar & theLiteral;
-}
-
-
-AnnotationLiteral::AnnotationLiteral(const store::Item_t& aLiteralValue)
-  : theLiteral(aLiteralValue)
-{
-}
-
-
-store::Item_t AnnotationLiteral::getLiteralItem() const
-{
-  return theLiteral;
-}
-
-
-AnnotationInternal* AnnotationList::getAnnotation(unsigned int index) const
-{
-  if (index < theAnnotationList.size())
-    return theAnnotationList[index].getp();
-  else
-    return NULL;
-}
-
+/*******************************************************************************
+
+********************************************************************************/
+csize AnnotationInternal::getNumLiterals() const
+{
+  return theLiterals.size();
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+store::Item* AnnotationInternal::getLiteral(csize index) const
+{
+  if (index < theLiterals.size())
+    return theLiterals[index].getp();
+  else
+    return NULL;
+}
 
 
 /*******************************************************************************
@@ -152,38 +328,45 @@
 /*******************************************************************************
 
 ********************************************************************************/
+AnnotationInternal* AnnotationList::getAnnotation(csize index) const
+{
+  if (index < theAnnotationList.size())
+    return theAnnotationList[index].getp();
+  else
+    return NULL;
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
 void AnnotationList::push_back(
-    const store::Item_t& aExpQName,
-    const std::vector<rchandle<const_expr> >& aLiterals)
+    const store::Item_t& qname,
+    const std::vector<rchandle<const_expr> >& literals)
 {
-  std::vector<AnnotationLiteral_t> lLiterals;
+  std::vector<store::Item_t> lLiterals;
 
-  for (std::vector<rchandle<const_expr> >::const_iterator it = aLiterals.begin();
-       it != aLiterals.end();
+  for (std::vector<rchandle<const_expr> >::const_iterator it = literals.begin();
+       it != literals.end();
        ++it)
   {
-    lLiterals.push_back(new AnnotationLiteral((*it)->get_val()));
+    lLiterals.push_back((*it)->get_val());
   }
 
-  theAnnotationList.push_back(new AnnotationInternal(aExpQName, lLiterals));
+  theAnnotationList.push_back(new AnnotationInternal(qname, lLiterals));
 }
 
 
 /*******************************************************************************
 
 ********************************************************************************/
-bool AnnotationList::contains(const store::Item_t& aSearchQName) const
+bool AnnotationList::contains(AnnotationInternal::AnnotationId id) const
 {
-  if (aSearchQName.getp() == NULL)
-    return false;
-
-  // sequential search might not be the most efficient but
-  // how many annotations might a function or variable have? 5?
-  for (ListConstIter_t lIter = theAnnotationList.begin();
-       lIter != theAnnotationList.end();
-       ++lIter)
+  for (ListConstIter_t ite = theAnnotationList.begin();
+       ite != theAnnotationList.end();
+       ++ite)
   {
-    if ((*lIter)->getQName()->equals(aSearchQName))
+    if ((*ite)->getId() == id)
       return true;
   }
 
@@ -196,232 +379,61 @@
 ********************************************************************************/
 void AnnotationList::checkConflictingDeclarations(const QueryLoc& loc) const
 {
-  static_context& lCtx = GENV_ROOT_STATIC_CONTEXT;
-
   // make sure we don't have more annotations then max 64 bit
-  assert( static_cast<uint64_t>(StaticContextConsts::zann_end) <
+  assert( static_cast<uint64_t>(AnnotationInternal::zann_end) <
           std::numeric_limits<uint64_t>::max() );
 
   RuleBitSet lCurrAnn;
 
   // mark and detect duplicates
-  for (ListConstIter_t lIter = theAnnotationList.begin();
-       lIter != theAnnotationList.end();
-       ++lIter)
+  for (ListConstIter_t ite = theAnnotationList.begin();
+       ite != theAnnotationList.end();
+       ++ite)
   {
-    store::Item_t lQName = const_cast<store::Item*>((*lIter)->getQName());
-    StaticContextConsts::annotations_t lAnn = lCtx.lookup_ann(lQName);
+    const store::Item* qname = (*ite)->getQName();
+    AnnotationId id = (*ite)->getId();
 
     // detect duplicate annotations (if we "know" them)
-    if ( lAnn != StaticContextConsts::zann_end && lCurrAnn.test( lAnn ) )
+    if (id != AnnotationInternal::zann_end && lCurrAnn.test(id))
     {
-        throw XQUERY_EXCEPTION(
-            err::XQST0106,
-            ERROR_PARAMS(
-              lQName->getStringValue(),
-              ZED(XQST0106_THE_SAME)
-            ),
-            ERROR_LOC(loc));
+      RAISE_ERROR(err::XQST0106, loc,
+      ERROR_PARAMS(qname->getStringValue(), ZED(XQST0106_THE_SAME)));
     }
 
-    lCurrAnn.set( lAnn );
+    lCurrAnn.set(id);
   }
 
   // check rules
-  for ( std::vector<RuleBitSet>::const_iterator lIter = theRuleSet.begin();
-        lIter != theRuleSet.end();
-        ++lIter )
+  std::vector<RuleBitSet>::const_iterator ite = AnnotationInternal::theRuleSet.begin();
+  std::vector<RuleBitSet>::const_iterator end = AnnotationInternal::theRuleSet.end();
+
+  for (; ite != end; ++ite)
   {
-    const RuleBitSet lCurrSet = *lIter;
-    if ( ( lCurrAnn & lCurrSet ).count() >  1 )
+    const RuleBitSet& lCurrSet = *ite;
+
+    if ((lCurrAnn & lCurrSet).count() >  1)
     {
       // build error string to return set of conflicting annotations
       std::ostringstream lProblems;
-      for ( size_t i = 0, j = 0; i < StaticContextConsts::zann_end; ++i )
+      for (csize i = 0, j = 0; i < AnnotationInternal::zann_end; ++i)
       {
-        if ( lCurrSet.test( i ) )
+        if (lCurrSet.test(i))
         {
-          lProblems
-            << lCtx.lookup_ann(
-                static_cast<StaticContextConsts::annotations_t>(i)
-              )->getStringValue()
-            << ((j == lCurrSet.count() - 1) ? "" : ", ");
+          AnnotationId id = static_cast<AnnotationId>(i);
+
+          lProblems << AnnotationInternal::lookup(id)->getStringValue()
+                    << ((j == lCurrSet.count() - 1) ? "" : ", ");
           ++j;
         }
       }
-      throw XQUERY_EXCEPTION(
-          err::XQST0106,
-          ERROR_PARAMS(
-            lProblems.str(),
-            ZED(XQST0106_CONFLICTING)
-          ),
-          ERROR_LOC(loc));
+
+      RAISE_ERROR(err::XQST0106, loc,
+      ERROR_PARAMS(lProblems.str(), ZED(XQST0106_CONFLICTING)));
     }
   }
 }
 
 
-void AnnotationList::createBuiltIn(static_context* aCtx)
-{
-  store::Item_t lTmp;
-
-  //
-  // W3C annotations
-  //
-  GENV_ITEMFACTORY->createQName(lTmp, static_context::W3C_FN_NS, "fn", "public");
-  aCtx->add_ann(StaticContextConsts::fn_public, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, static_context::W3C_FN_NS, "fn", "private");
-  aCtx->add_ann(StaticContextConsts::fn_private, lTmp);
-
-  //
-  // Zorba annotations - deterministic/nondeterministic
-  //
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "deterministic");
-  aCtx->add_ann(StaticContextConsts::zann_deterministic, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "nondeterministic");
-  aCtx->add_ann(StaticContextConsts::zann_nondeterministic, lTmp);
-
-  //
-  // Zorba annotations - xquery scripting
-  //
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "assignable");
-  aCtx->add_ann(StaticContextConsts::zann_assignable, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "nonassignable");
-  aCtx->add_ann(StaticContextConsts::zann_nonassignable, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "sequential");
-  aCtx->add_ann(StaticContextConsts::zann_sequential, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "nonsequential");
-  aCtx->add_ann(StaticContextConsts::zann_nonsequential, lTmp);
-
-  //
-  // Zorba annotations - misc
-  //
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "variadic");
-  aCtx->add_ann(StaticContextConsts::zann_variadic, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "streamable");
-  aCtx->add_ann(StaticContextConsts::zann_streamable, lTmp);
-
-  //
-  // Zorba annotations - xqddf
-  //
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "unique");
-  aCtx->add_ann(StaticContextConsts::zann_unique, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "nonunique");
-  aCtx->add_ann(StaticContextConsts::zann_nonunique, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "value-equality");
-  aCtx->add_ann(StaticContextConsts::zann_value_equality, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "general-equality");
-  aCtx->add_ann(StaticContextConsts::zann_general_equality, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "value-range");
-  aCtx->add_ann(StaticContextConsts::zann_value_range, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "general-range");
-  aCtx->add_ann(StaticContextConsts::zann_general_range, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "automatic");
-  aCtx->add_ann(StaticContextConsts::zann_automatic, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "manual");
-  aCtx->add_ann(StaticContextConsts::zann_manual, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "mutable");
-  aCtx->add_ann(StaticContextConsts::zann_mutable, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "queue");
-  aCtx->add_ann(StaticContextConsts::zann_queue, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "append-only");
-  aCtx->add_ann(StaticContextConsts::zann_append_only, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "const");
-  aCtx->add_ann(StaticContextConsts::zann_const, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "ordered");
-  aCtx->add_ann(StaticContextConsts::zann_ordered, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "unordered");
-  aCtx->add_ann(StaticContextConsts::zann_unordered, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "read-only-nodes");
-  aCtx->add_ann(StaticContextConsts::zann_read_only_nodes, lTmp);
-
-  GENV_ITEMFACTORY->createQName(lTmp, ZORBA_ANNOTATIONS_NS, "", "mutable-nodes");
-  aCtx->add_ann(StaticContextConsts::zann_mutable_nodes, lTmp);
-
-  // create a set of rules to detect conflicts between annotations
-#define ZANN(a) \
-  ( 1 << static_cast<uint64_t>(StaticContextConsts:: a) )
-  theRuleSet.push_back(
-       ZANN(zann_unique) |
-       ZANN(zann_nonunique)
-    );
-  theRuleSet.push_back(
-      ZANN(zann_value_equality) |
-      ZANN(zann_general_equality) |
-      ZANN(zann_value_range) |
-      ZANN(zann_general_range)
-    );
-  theRuleSet.push_back(
-      ZANN(zann_automatic) |
-      ZANN(zann_manual)
-    );
-  theRuleSet.push_back(
-      ZANN(zann_mutable) |
-      ZANN(zann_queue) |
-      ZANN(zann_append_only) |
-      ZANN(zann_const)
-    );
-  theRuleSet.push_back(
-      ZANN(zann_ordered) |
-      ZANN(zann_unordered)
-    );
-  theRuleSet.push_back(
-      ZANN(zann_assignable) |
-      ZANN(zann_nonassignable)
-    );
-  theRuleSet.push_back(
-      ZANN(zann_deterministic) |
-      ZANN(zann_nondeterministic)
-    );
-  theRuleSet.push_back(
-      ZANN(zann_sequential) |
-      ZANN(zann_nonsequential)
-    );
-  theRuleSet.push_back(
-      ZANN(fn_private) |
-      ZANN(fn_public)
-    );
-  theRuleSet.push_back(
-      ZANN(zann_unordered) |
-      ZANN(zann_queue)
-    );
-  theRuleSet.push_back(
-      ZANN(zann_unordered) |
-      ZANN(zann_append_only)
-    );
-  theRuleSet.push_back(
-      ZANN(zann_queue) |
-      ZANN(zann_append_only)
-    );
-  theRuleSet.push_back(
-      ZANN(zann_read_only_nodes) |
-      ZANN(zann_mutable_nodes)
-    );
-#undef ZANN
-}
-
-std::vector<AnnotationList::RuleBitSet> AnnotationList::theRuleSet;
-
 
 } /* namespace zorba */
 /* vim:set et sw=2 ts=2: */

=== modified file 'src/annotations/annotations.h'
--- src/annotations/annotations.h	2011-07-21 01:30:19 +0000
+++ src/annotations/annotations.h	2011-11-01 13:50:27 +0000
@@ -19,39 +19,95 @@
 
 #include <vector>
 #include <bitset>
+
 #include "common/shared_types.h"
+
 #include "compiler/parsetree/parsenodes.h"
 
+#include "zorbautils/hashmap_itemh.h"
+
 namespace zorba
 {
 
-class AnnotationLiteral;
 class AnnotationInternal;
 class AnnotationList;
 
 typedef rchandle<AnnotationInternal> AnnotationInternal_t;
 typedef rchandle<AnnotationList> AnnotationList_t;
-typedef rchandle<AnnotationLiteral> AnnotationLiteral_t;
 
 class const_expr;
 
 /*******************************************************************************
-
+  Annotation ::= "%" EQName  ("(" Literal  ("," Literal)* ")")?
 ********************************************************************************/
 class AnnotationInternal : public SimpleRCObject
 {
   friend class AnnotationList;
 
-protected:
-  store::Item_t                      theQName;
-  std::vector<AnnotationLiteral_t>   theLiteralList;
-
-public:
-  AnnotationInternal(const store::Item_t& aExpandedQName); 
+public:
+  enum AnnotationId
+  {
+    fn_public = 0,
+    fn_private,
+    zann_deterministic,
+    zann_nondeterministic,
+    zann_assignable,
+    zann_nonassignable,
+    zann_sequential,
+    zann_nonsequential,
+    zann_variadic,
+    zann_streamable,
+    zann_unique,
+    zann_nonunique,
+    zann_value_equality,
+    zann_general_equality,
+    zann_value_range,
+    zann_general_range,
+    zann_automatic,
+    zann_manual,
+    zann_mutable,
+    zann_queue,
+    zann_append_only,
+    zann_const,
+    zann_ordered,
+    zann_unordered,
+    zann_read_only_nodes,
+    zann_mutable_nodes,
+
+    // must be at the end
+    zann_end
+  };
+
+protected:
+  typedef std::bitset<zann_end + 1> RuleBitSet;
+
+protected:
+  static std::vector<store::Item_t>      theAnnotId2NameMap;
+
+  static ItemHandleHashMap<AnnotationId> theAnnotName2IdMap;
+
+  static std::vector<RuleBitSet>         theRuleSet;
+
+protected:
+  AnnotationId                   theId;
+  store::Item_t                  theQName;
+  std::vector<store::Item_t>     theLiterals;
+
+public:
+  static void createBuiltIn();
+
+  static void destroyBuiltIn();
+
+  static AnnotationId lookup(const store::Item_t& qname);
+
+  static store::Item* lookup(AnnotationId id);
+
+public:
+  AnnotationInternal(const store::Item_t& qname); 
 
   AnnotationInternal(
-    const store::Item_t& aExpandedQName,
-    const std::vector<AnnotationLiteral_t>& aLiteralList); 
+    const store::Item_t& qname,
+    std::vector<store::Item_t>& literals); 
 
 public:
   SERIALIZABLE_CLASS(AnnotationInternal);
@@ -59,55 +115,37 @@
   void serialize(::zorba::serialization::Archiver& ar);
 
 public:
-  virtual ~AnnotationInternal() { };
+  ~AnnotationInternal() { };
+
+  AnnotationId getId() const { return theId; }
 
   const store::Item* getQName() const;
 
-  unsigned int getNumLiterals() const;
-
-  const AnnotationLiteral* getLiteral(unsigned int index) const;
-};
-
-
-
-/*******************************************************************************
-
-********************************************************************************/
-class AnnotationLiteral : public SimpleRCObject
-{
-protected:
-  store::Item_t  theLiteral;
-
-public:
-  AnnotationLiteral(const store::Item_t& aLiteral);
-
-public:
-  SERIALIZABLE_CLASS(AnnotationLiteral);
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(AnnotationLiteral, SimpleRCObject)
-  void serialize(::zorba::serialization::Archiver& ar);
-
-public:
-  virtual ~AnnotationLiteral() {};
-
-  store::Item_t getLiteralItem() const;
-};
-
-
-/*******************************************************************************
-
+  csize getNumLiterals() const;
+
+  store::Item* getLiteral(csize index) const;
+};
+
+
+/*******************************************************************************
+  AnnotationList := Annotation*
+
+  Annotation ::= "%" EQName  ("(" Literal  ("," Literal)* ")")?
 ********************************************************************************/
 class AnnotationList : public SimpleRCObject
 {
 public:
+  typedef  AnnotationInternal::RuleBitSet RuleBitSet;
+
+  typedef AnnotationInternal::AnnotationId AnnotationId;
+
   typedef std::vector<AnnotationInternal_t> List_t;
+
   typedef List_t::const_iterator ListConstIter_t;
 
 protected:
   List_t theAnnotationList;
 
-  typedef std::bitset<StaticContextConsts::zann_end + 1> RuleBitSet;
-  static std::vector<RuleBitSet> theRuleSet;
-
 public:
   SERIALIZABLE_CLASS(AnnotationList);
   SERIALIZABLE_CLASS_CONSTRUCTOR2(AnnotationList, SimpleRCObject)
@@ -116,22 +154,19 @@
 public:
   AnnotationList();
 
-	virtual ~AnnotationList();
-
-  size_t size() const { return theAnnotationList.size(); }
-
-  AnnotationInternal* getAnnotation(unsigned int index) const;
+	~AnnotationList();
+
+  csize size() const { return theAnnotationList.size(); }
+
+  AnnotationInternal* getAnnotation(csize index) const;
 
   void push_back(
-      const store::Item_t& aExpQName,
-      const std::vector<rchandle<const_expr> >& aLiterals);
+      const store::Item_t& qname,
+      const std::vector<rchandle<const_expr> >& literals);
 
-  bool contains(const store::Item_t& aSearchQName) const;
+  bool contains(AnnotationInternal::AnnotationId id) const;
 
   void checkConflictingDeclarations(const QueryLoc& loc) const;
-
-public:
-  static void createBuiltIn(static_context* aCtx);
 };
 
 

=== modified file 'src/api/annotationimpl.cpp'
--- src/api/annotationimpl.cpp	2011-06-14 17:26:33 +0000
+++ src/api/annotationimpl.cpp	2011-11-01 13:50:27 +0000
@@ -50,7 +50,7 @@
   if (i >= theAnnotation->getNumLiterals())
     return Item(NULL);
 
-  Item lItem(theAnnotation->getLiteral(i)->getLiteralItem().getp());
+  Item lItem(theAnnotation->getLiteral(i));
   return lItem;
 }
 

=== modified file 'src/api/collectionimpl.cpp'
--- src/api/collectionimpl.cpp	2011-09-15 13:11:51 +0000
+++ src/api/collectionimpl.cpp	2011-11-01 13:50:27 +0000
@@ -444,17 +444,10 @@
     {
       store::Annotation_t lSAnn = *lIter;
 
-      std::vector<AnnotationLiteral_t> lILiterals;
-      std::vector<store::Item_t>::const_iterator lLiteral;
-      for (lLiteral = lSAnn->theLiterals.begin();
-           lLiteral != lSAnn->theLiterals.end();
-           ++lLiteral)
-      {
-        lILiterals.push_back(new AnnotationLiteral(*lLiteral));
-      }
+      std::vector<store::Item_t> lLiterals = lSAnn->theLiterals;
 
       aAnnotations.push_back(
-      new AnnotationImpl(new AnnotationInternal(lSAnn->theName, lILiterals)));
+      new AnnotationImpl(new AnnotationInternal(lSAnn->theName, lLiterals)));
     }
   }
   ZORBA_DM_CATCH

=== modified file 'src/compiler/translator/translator.cpp'
--- src/compiler/translator/translator.cpp	2011-10-21 22:53:06 +0000
+++ src/compiler/translator/translator.cpp	2011-11-01 13:50:27 +0000
@@ -161,8 +161,7 @@
 /*******************************************************************************
 
 ********************************************************************************/
-#define ZANN_CONTAINS( ann ) \
-  theAnnotations->contains(theSctx->lookup_ann(StaticContextConsts:: ann))
+#define ZANN_CONTAINS( ann ) theAnnotations->contains(AnnotationInternal::ann)
 
 
 /*******************************************************************************
@@ -3554,8 +3553,7 @@
 
   let_clause_t lc = wrap_in_letclause(&*arg_var, subst_var);
 
-  // theCurrentPrologVFDecl might be null in case
-  // of inline functions
+  // theCurrentPrologVFDecl might be null in case of inline functions
   // inline functions currently can't be sequential anyway
   // hence, we can always lazy evaluation
   if (!theCurrentPrologVFDecl.isNull())
@@ -3668,19 +3666,15 @@
   {
     if (v.is_global())
     {
-      if (theAnnotations->contains(
-
-            theSctx->lookup_ann(StaticContextConsts::fn_private)))
+      if (ZANN_CONTAINS(fn_private))
         ve->set_private(true);
     }
 
-    if (theAnnotations->contains(
-          theSctx->lookup_ann(StaticContextConsts::zann_assignable)))
+    if (ZANN_CONTAINS(zann_assignable))
     {
       ve->set_mutable(true);
     }
-    else if (theAnnotations->contains(
-          theSctx->lookup_ann(StaticContextConsts::zann_nonassignable)))
+    else if (ZANN_CONTAINS(zann_nonassignable))
     {
       ve->set_mutable(false);
     }
@@ -3807,22 +3801,22 @@
   store::Item_t lExpandedQName;
   expand_function_qname(lExpandedQName, v.get_qname().getp(), loc);
 
-  if (lExpandedQName->getNamespace() == static_context::W3C_XML_NS ||
-      lExpandedQName->getNamespace() == XML_SCHEMA_NS ||
-      lExpandedQName->getNamespace() == XSI_NS ||
-      lExpandedQName->getNamespace() == static_context::W3C_FN_NS ||
-      lExpandedQName->getNamespace() == XQUERY_MATH_FN_NS ||
-      lExpandedQName->getNamespace() == ZORBA_ANNOTATIONS_NS)
+  zstring annotNS = lExpandedQName->getNamespace();
+
+  if (annotNS == static_context::W3C_XML_NS ||
+      annotNS == XML_SCHEMA_NS ||
+      annotNS == XSI_NS ||
+      annotNS == static_context::W3C_FN_NS ||
+      annotNS == XQUERY_MATH_FN_NS ||
+      annotNS == ZORBA_ANNOTATIONS_NS)
   {
-    if ( theSctx->lookup_ann(lExpandedQName) ==  StaticContextConsts::zann_end)
+    if (AnnotationInternal::lookup(lExpandedQName) == AnnotationInternal::zann_end)
     {
-      throw XQUERY_EXCEPTION(
-          err::XQST0045,
-          ERROR_PARAMS( "%" + (lExpandedQName->getPrefix().empty() ?
-                        "\'" + lExpandedQName->getNamespace() + "\'"
-                        : lExpandedQName->getPrefix())
-                        + ":" + lExpandedQName->getLocalName()),
-          ERROR_LOC(loc));
+      RAISE_ERROR(err::XQST0045, loc,
+      ERROR_PARAMS( "%" + (lExpandedQName->getPrefix().empty() ?
+                           "\'" + lExpandedQName->getNamespace() + "\'"
+                           : lExpandedQName->getPrefix())
+                    + ":" + lExpandedQName->getLocalName()));
     }
   }
   else
@@ -3839,6 +3833,7 @@
   }
 
   std::vector<rchandle<const_expr> > lLiterals;
+
   if (v.get_literals())
   {
     std::vector<rchandle<exprnode> >::const_iterator lIter;
@@ -4031,62 +4026,62 @@
   StaticContextConsts::node_modifier_t lNodeModifier;
 
   std::vector<rchandle<const_expr> > lLiterals;
-  if ( ZANN_CONTAINS (zann_queue) )
+  if (ZANN_CONTAINS(zann_queue))
   {
     lUpdateMode = StaticContextConsts::decl_queue;
   }
-  else if ( ZANN_CONTAINS ( zann_append_only) )
+  else if (ZANN_CONTAINS(zann_append_only))
   {
     lUpdateMode = StaticContextConsts::decl_append_only;
   }
-  else if ( ZANN_CONTAINS ( zann_const ) )
+  else if (ZANN_CONTAINS(zann_const))
   {
     lUpdateMode = StaticContextConsts::decl_const;
   }
-  else if ( ZANN_CONTAINS ( zann_mutable ) )
+  else if (ZANN_CONTAINS(zann_mutable))
   {
     lUpdateMode = StaticContextConsts::decl_mutable;
   }
   else
   {
-    theAnnotations->push_back(
-        theSctx->lookup_ann( StaticContextConsts::zann_mutable ),
-        lLiterals
-    );
+    theAnnotations->
+    push_back(AnnotationInternal::lookup(AnnotationInternal::zann_mutable),
+              lLiterals);
+
     lUpdateMode = StaticContextConsts::decl_mutable;
   }
 
-  if ( ZANN_CONTAINS ( zann_ordered) )
+  if (ZANN_CONTAINS(zann_ordered))
   {
     lOrderMode = StaticContextConsts::decl_ordered;
   }
-  else if ( ZANN_CONTAINS ( zann_unordered ) )
+  else if (ZANN_CONTAINS(zann_unordered))
   {
     lOrderMode = StaticContextConsts::decl_unordered;
   }
   else
   {
-    theAnnotations->push_back(
-        theSctx->lookup_ann( StaticContextConsts::zann_unordered ),
-        lLiterals
-    );
+    theAnnotations->
+    push_back(AnnotationInternal::lookup(AnnotationInternal::zann_unordered),
+              lLiterals);
+
     lOrderMode = StaticContextConsts::decl_unordered;
   }
 
-  if ( ZANN_CONTAINS ( zann_read_only_nodes) )
+  if (ZANN_CONTAINS(zann_read_only_nodes))
   {
     lNodeModifier = StaticContextConsts::read_only;
   }
-  else if ( ZANN_CONTAINS ( zann_mutable_nodes ) )
+  else if (ZANN_CONTAINS(zann_mutable_nodes))
   {
     lNodeModifier = StaticContextConsts::mutable_node;
   }
   else
   {
-    theAnnotations->push_back(
-        theSctx->lookup_ann( StaticContextConsts::zann_mutable_nodes ),
-        lLiterals
-    );
+    theAnnotations->
+    push_back(AnnotationInternal::lookup(AnnotationInternal::zann_mutable_nodes),
+              lLiterals);
+
     lNodeModifier = StaticContextConsts::mutable_node;
   }
 
@@ -10343,15 +10338,13 @@
 
   if ( !theSctx->is_feature_set(feature::hof) )
   {
-    throw XQUERY_EXCEPTION(
-      zerr::ZXQP0050_FEATURE_NOT_AVAILABLE,
-      ERROR_PARAMS( "higher-order functions (hof)" ),
-      ERROR_LOC( v.get_location() )
-    );
+    RAISE_ERROR(zerr::ZXQP0050_FEATURE_NOT_AVAILABLE, v.get_location(),
+    ERROR_PARAMS("higher-order functions (hof)"));
   }
   return no_state;
 }
 
+
 void end_visit(const LiteralFunctionItem& v, void* /*visit_state*/)
 {
   TRACE_VISIT_OUT();
@@ -10359,10 +10352,12 @@
   rchandle<QName> qname = v.getQName();
   uint32_t arity = 0;
 
-  try {
+  try 
+  {
     arity = to_xs_unsignedInt(v.getArity());
   }
-  catch ( std::range_error const& ) {
+  catch ( std::range_error const& ) 
+  {
     RAISE_ERROR(err::XPST0017, loc,
     ERROR_PARAMS(v.getArity(), ZED(NoParseFnArity)));
   }
@@ -10476,6 +10471,7 @@
 
     var_expr_t arg_var = create_var(loc, qname, var_expr::arg_var);
     var_expr_t subst_var = bind_var(loc, qname, var_expr::let_var);
+
     let_clause_t lc = wrap_in_letclause(&*arg_var, subst_var);
 
     arg_var->set_type(varExpr->get_return_type());

=== modified file 'src/context/static_context.cpp'
--- src/context/static_context.cpp	2011-10-18 19:06:06 +0000
+++ src/context/static_context.cpp	2011-11-01 13:50:27 +0000
@@ -475,7 +475,6 @@
   theImportedPrivateVariablesMap(NULL),
   theFunctionMap(NULL),
   theFunctionArityMap(NULL),
-  theAnnotationMap(NULL),
   theCollectionMap(NULL),
   theW3CCollectionMap(NULL),
   theIndexMap(NULL),
@@ -523,7 +522,6 @@
   theImportedPrivateVariablesMap(NULL),
   theFunctionMap(NULL),
   theFunctionArityMap(NULL),
-  theAnnotationMap(NULL),
   theCollectionMap(0),
   theW3CCollectionMap(NULL),
   theIndexMap(NULL),
@@ -576,7 +574,6 @@
   theImportedPrivateVariablesMap(NULL),
   theFunctionMap(NULL),
   theFunctionArityMap(NULL),
-  theAnnotationMap(NULL),
   theCollectionMap(0),
   theW3CCollectionMap(NULL),
   theIndexMap(0),
@@ -652,9 +649,6 @@
     delete theFunctionArityMap;
   }
 
-  if (theAnnotationMap)
-    delete theAnnotationMap;
-
   if (theW3CCollectionMap)
     delete theW3CCollectionMap;
 
@@ -890,8 +884,6 @@
   ar & theFunctionArityMap;
   ar.set_serialize_only_for_eval(false);
 
-  ar & theAnnotationMap;
-
   ar & theCollectionMap;
 
   ar & theW3CCollectionMap;
@@ -2616,49 +2608,6 @@
   return lModule->getExternalFunction(aLocalName.str());
 }
 
-/////////////////////////////////////////////////////////////////////////////////
-//                                                                             //
-//  Annotations                                                               //
-//                                                                             //
-/////////////////////////////////////////////////////////////////////////////////
-void
-static_context::add_ann(
-    StaticContextConsts::annotations_t aAnnotation,
-    const store::Item_t& aQName)
-{
-  if (!theAnnotationMap) {
-    theAnnotationMap = new AnnotationMap();
-  }
-  (*theAnnotationMap)[static_cast<uint64_t>(aAnnotation)] = aQName;
-}
-
-store::Item_t
-static_context::lookup_ann(StaticContextConsts::annotations_t aAnnotation) const
-{
-  std::map<uint64_t, store::Item_t>::const_iterator lIter;
-  if (!theAnnotationMap ||
-      (lIter = theAnnotationMap->find(static_cast<uint64_t>(aAnnotation))) == theAnnotationMap->end()) {
-    return theParent?theParent->lookup_ann(aAnnotation):NULL;
-  }
-  return lIter->second;
-}
-
-StaticContextConsts::annotations_t
-static_context::lookup_ann(const store::Item_t& aQName) const
-{
-  if ( theAnnotationMap )
-  {
-    std::map<uint64_t, store::Item_t>::const_iterator lIter;
-    for (lIter = theAnnotationMap->begin(); lIter != theAnnotationMap->end(); ++lIter)
-    {
-      if (aQName->equals(lIter->second))
-      {
-        return static_cast<StaticContextConsts::annotations_t>(lIter->first);
-      }
-    }
-  }
-  return theParent?theParent->lookup_ann(aQName):StaticContextConsts::zann_end;
-}
 
 /////////////////////////////////////////////////////////////////////////////////
 //                                                                             //

=== modified file 'src/context/static_context.h'
--- src/context/static_context.h	2011-10-18 19:06:06 +0000
+++ src/context/static_context.h	2011-11-01 13:50:27 +0000
@@ -321,13 +321,6 @@
   different arities. One of these versions is stored in the theFunctionMap,
   and the rest are regisreded in theFunctionArityMap.
 
-  theAnnotations:
-  --------------
-  annotations_t -> store::Item_t map that contains a list of built-in annotations
-  Those annotations are used in the translator to check if a function,
-  variable, index, or collection declares any of these annotations.
-
-
   theCollectionMap :
   ------------------
   A hash mash map mapping XQDDF collection qnames to the objs storing the info
@@ -413,8 +406,6 @@
 
   typedef std::map<std::string, XQPCollator*> CollationMap;
 
-  typedef std::map<uint64_t, store::Item_t> AnnotationMap;
-
 public:
 
   struct ctx_module_t : public ::zorba::serialization::SerializeBaseClass
@@ -538,8 +529,6 @@
   FunctionMap                           * theFunctionMap;
   FunctionArityMap                      * theFunctionArityMap;
 
-  AnnotationMap                         * theAnnotationMap;
-
   CollectionMap                         * theCollectionMap;
 
   W3CCollectionMap                      * theW3CCollectionMap;
@@ -838,16 +827,6 @@
 
 
   //
-  // Annotation
-  //
-  void add_ann(StaticContextConsts::annotations_t ann, const store::Item_t& aQName);
-
-  store::Item_t lookup_ann(StaticContextConsts::annotations_t ann) const;
-
-  StaticContextConsts::annotations_t lookup_ann(const store::Item_t& aQName) const;
-
-
-  //
   // Documents
   //
   void bind_document(const zstring& uri, xqtref_t& t);

=== modified file 'src/functions/function.cpp'
--- src/functions/function.cpp	2011-07-29 06:13:28 +0000
+++ src/functions/function.cpp	2011-11-01 13:50:27 +0000
@@ -104,22 +104,16 @@
   if (!theAnnotationList)
     return;
 
-  static_context& lCtx = GENV_ROOT_STATIC_CONTEXT;
-
-  if (theAnnotationList->contains(
-        lCtx.lookup_ann(StaticContextConsts::zann_nondeterministic)))
+  if (theAnnotationList->contains(AnnotationInternal::zann_nondeterministic))
     setDeterministic(false);
 
-  setPrivate(theAnnotationList->contains(
-        lCtx.lookup_ann(StaticContextConsts::fn_private)));
+  setPrivate(theAnnotationList->contains(AnnotationInternal::fn_private));
 
-  if (isUpdating()
-      &&
-      theAnnotationList->contains(
-        lCtx.lookup_ann(StaticContextConsts::zann_sequential)))
+  if (isUpdating() &&
+      theAnnotationList->contains(AnnotationInternal::zann_sequential))
   {
     throw XQUERY_EXCEPTION(zerr::XSST0001,
-                           ERROR_PARAMS(getName()->getStringValue()));
+    ERROR_PARAMS(getName()->getStringValue()));
   }
 }
 

=== modified file 'src/runtime/collections/collections_impl.cpp'
--- src/runtime/collections/collections_impl.cpp	2011-10-19 15:28:51 +0000
+++ src/runtime/collections/collections_impl.cpp	2011-11-01 13:50:27 +0000
@@ -554,15 +554,15 @@
 
     // dynamic collections have some default properties
     lAnn = new store::Annotation();
-    lAnn->theName = theSctx->lookup_ann(StaticContextConsts::zann_mutable);
-    lAnnotations.push_back(lAnn);
-
-    lAnn = new store::Annotation();
-    lAnn->theName = theSctx->lookup_ann(StaticContextConsts::zann_ordered);
-    lAnnotations.push_back(lAnn);
-
-    lAnn = new store::Annotation();
-    lAnn->theName = theSctx->lookup_ann(StaticContextConsts::zann_mutable_nodes);
+    lAnn->theName = AnnotationInternal::lookup(AnnotationInternal::zann_mutable);
+    lAnnotations.push_back(lAnn);
+
+    lAnn = new store::Annotation();
+    lAnn->theName = AnnotationInternal::lookup(AnnotationInternal::zann_ordered);
+    lAnnotations.push_back(lAnn);
+
+    lAnn = new store::Annotation();
+    lAnn->theName = AnnotationInternal::lookup(AnnotationInternal::zann_mutable_nodes);
     lAnnotations.push_back(lAnn);
 
     pul->addCreateCollection(
@@ -584,9 +584,9 @@
 
       lAnn->theName = lTmp->getQName();
 
-      for (size_t j = 0; j < lTmp->getNumLiterals(); ++j)
+      for (csize j = 0; j < lTmp->getNumLiterals(); ++j)
       {
-        lAnn->theLiterals.push_back(lTmp->getLiteral(j)->getLiteralItem());
+        lAnn->theLiterals.push_back(lTmp->getLiteral(j));
       }
       lAnnotations.push_back(lAnn);
     }

=== modified file 'src/store/api/annotation.h'
--- src/store/api/annotation.h	2011-09-12 22:42:28 +0000
+++ src/store/api/annotation.h	2011-11-01 13:50:27 +0000
@@ -23,22 +23,24 @@
 
 namespace zorba { namespace store {
 
-  class Annotation : public RCObject
-  {
-    protected:
-      SYNC_CODE(mutable RCLock theRCLock;)
+
+class Annotation : public RCObject
+{
+protected:
+  SYNC_CODE(mutable RCLock theRCLock;)
     
-    public:
-      SYNC_CODE(RCLock* getRCLock() const { return &theRCLock; })
-
-      long* getSharedRefCounter() const { return NULL; } 
-
-      virtual ~Annotation() {}
-
-    public:
-      Item_t theName;
-      std::vector<Item_t> theLiterals;
-  };
+public:
+  Item_t              theName;
+  std::vector<Item_t> theLiterals;
+
+public:
+  SYNC_CODE(RCLock* getRCLock() const { return &theRCLock; })
+
+  long* getSharedRefCounter() const { return NULL; } 
+
+  virtual ~Annotation() {}
+};
+
 
 } /* namespace store */ } /* namespace zorba */
 

=== modified file 'src/system/globalenv.cpp'
--- src/system/globalenv.cpp	2011-06-26 09:43:12 +0000
+++ src/system/globalenv.cpp	2011-11-01 13:50:27 +0000
@@ -75,10 +75,11 @@
 
   m_globalEnv->m_rootStaticContext = new root_static_context();
   m_globalEnv->m_rootStaticContext->init();
-  RCHelper::addReference (m_globalEnv->m_rootStaticContext);
+  RCHelper::addReference(m_globalEnv->m_rootStaticContext);
 
   BuiltinFunctionLibrary::create(m_globalEnv->m_rootStaticContext);
-  AnnotationList::createBuiltIn(m_globalEnv->m_rootStaticContext);
+
+  AnnotationInternal::createBuiltIn();
 
 #ifdef ZORBA_XQUERYX
   //libxml2 and libxslt are needed
@@ -93,9 +94,10 @@
 
   std::auto_ptr<XQueryCompilerSubsystem> lSubSystem = 
     XQueryCompilerSubsystem::create();
+
   m_globalEnv->m_compilerSubSys = lSubSystem.release();
 
-  m_globalEnv->m_http_resolver      = new impl::HTTPURLResolver();
+  m_globalEnv->m_http_resolver = new impl::HTTPURLResolver();
 }
 
 
@@ -118,9 +120,11 @@
   delete m_globalEnv->xqueryx_convertor;
 #endif
 
-  RCHelper::removeReference (m_globalEnv->m_rootStaticContext);
+  RCHelper::removeReference(m_globalEnv->m_rootStaticContext);
   m_globalEnv->m_rootStaticContext = 0;
 
+  AnnotationInternal::destroyBuiltIn();
+
   m_globalEnv->m_store = NULL;
 
   // we shutdown icu
@@ -133,6 +137,8 @@
 
   BuiltinFunctionLibrary::destroy();
 
+  AnnotationInternal::destroyBuiltIn();
+
   delete m_globalEnv;
 	m_globalEnv = NULL;