Merge lp:~zorba-coders/zorba/stack into lp:~zorba-coders/zorba/zorba-experimental

[Matthias Brantner]

...

...

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~zorba-coders/zorba/stack into lp:~zorba-coders/zorba/zorba-experimental failed. Below is the output from the failed tests.

experimental build started for lp:~zorba-coders/zorba/stack. Check out http://stack.zorba-xquery.com/ in half an hour or so. Logfile at http://zorbatest.lambda.nu:8080/remotequeue/experimental/stack.log .

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~zorba-coders/zorba/stack into lp:~zorba-coders/zorba/zorba-experimental failed. Below is the output from the failed tests.

experimental build started for lp:~zorba-coders/zorba/stack. Check out http://stack.zorba-xquery.com/ in half an hour or so. Logfile at http://zorbatest.lambda.nu:8080/remotequeue/experimental/stack.log .

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~zorba-coders/zorba/stack into lp:~zorba-coders/zorba/zorba-experimental failed. Below is the output from the failed tests.

experimental build started for lp:~zorba-coders/zorba/stack. Check out http://stack.zorba-xquery.com/ in half an hour or so. Logfile at http://zorbatest.lambda.nu:8080/remotequeue/experimental/stack.log .

=== modified file 'CMakeConfiguration.txt'
--- CMakeConfiguration.txt	2011-09-16 19:55:59 +0000
+++ CMakeConfiguration.txt	2012-02-03 01:13:24 +0000
@@ -70,10 +70,6 @@
 SET(ZORBA_FOR_ONE_THREAD_ONLY OFF CACHE BOOL "compile zorba for single threaded use")
 MESSAGE(STATUS "ZORBA_FOR_ONE_THREAD_ONLY:            " ${ZORBA_FOR_ONE_THREAD_ONLY})
 
-# by default the zorba command line client is deactivated until it gets to a more stable and userfriendly state
-SET(ZORBA_WITH_DEBUGGER_CLIENT OFF CACHE BOOL "build and install zorbas command line debugger client")
-MESSAGE(STATUS "ZORBA_WITH_DEBUGGER_CLIENT:           " ${ZORBA_WITH_DEBUGGER_CLIENT})
-
 IF (DEFINED UNIX)
   IF (NOT DEFINED ZORBA_HAVE_PTHREAD_H AND NOT DEFINED ZORBA_FOR_ONE_THREAD_ONLY)
     MESSAGE(FATAL_ERROR "pthread is not available")

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2011-10-09 13:56:39 +0000
+++ CMakeLists.txt	2012-02-03 01:13:24 +0000
@@ -417,13 +417,35 @@
 
 # zorba versioning
 SET(ZORBA_MAJOR_NUMBER "2")
-SET(ZORBA_MINOR_NUMBER "0")
-SET(ZORBA_PATCH_NUMBER "1")
+SET(ZORBA_MINOR_NUMBER "1")
+SET(ZORBA_PATCH_NUMBER "0")
 SET(ZORBA_VERSION ${ZORBA_MAJOR_NUMBER}.${ZORBA_MINOR_NUMBER}.${ZORBA_PATCH_NUMBER})
 MESSAGE(STATUS "Zorba version number: ${ZORBA_VERSION}")
-SET(ZORBA_MODULES_INSTALL_DIR "share/zorba-${ZORBA_VERSION}/modules"
-  CACHE STRING "Path (relative to installdir) to modules" FORCE)
-MARK_AS_ADVANCED(ZORBA_MODULES_INSTALL_DIR)
+
+SET(ZORBA_LIB_DIRNAME "lib" CACHE STRING
+  "directory name for libs (may want to set to 'lib64' on 64-bit Linux platforms)")
+
+# Directories for modules and schemas. "Core" are those which are
+# shipped with Zorba and must be present for correct Zorba
+# functionality. "Non-core" are developed independently of Zorba and
+# have different version lifecycles.
+#
+# URI dir is for things resolved by URI - specifically modules (.xq
+# files) and schemas (.xsd files) - which are platform-
+# independent. Lib dir is for platform-specific files, specifically
+# shared libraries for module external functions.
+SET(ZORBA_NONCORE_URI_DIR "share/zorba/uris"
+  CACHE STRING "Path (relative to installdir) to non-core modules/schemas")
+MARK_AS_ADVANCED(ZORBA_NONCORE_URI_DIR)
+SET(ZORBA_CORE_URI_DIR "${ZORBA_NONCORE_URI_DIR}/core/${ZORBA_VERSION}"
+  CACHE STRING "Path (relative to installdir) to core modules/schemas")
+MARK_AS_ADVANCED(ZORBA_CORE_URI_DIR)
+SET(ZORBA_NONCORE_LIB_DIR "${ZORBA_LIB_DIRNAME}/zorba"
+  CACHE STRING "Path (relative to installdir) to non-core libraries")
+MARK_AS_ADVANCED(ZORBA_NONCORE_LIB_DIR)
+SET(ZORBA_CORE_LIB_DIR "${ZORBA_NONCORE_LIB_DIR}/core/${ZORBA_VERSION}"
+  CACHE STRING "Path (relative to installdir) to core libraries")
+MARK_AS_ADVANCED(ZORBA_CORE_LIB_DIR)
 
 # add compiler variables
 ADD_DEFINITIONS(${DEFINITIONS})
@@ -460,7 +482,7 @@
   SET(ZORBA_CMAKE_DIR "cmake" CACHE STRING
     "Relative path to CMake files in Zorba installation")
 ELSE (WIN32)
-  SET(ZORBA_CMAKE_DIR "share/zorba-${ZORBA_VERSION}/cmake" CACHE STRING
+  SET(ZORBA_CMAKE_DIR "share/cmake/zorba-${ZORBA_VERSION}" CACHE STRING
     "Relative path to CMake files in Zorba installation")
 ENDIF (WIN32)
 
@@ -534,4 +556,4 @@
 # This dependency is zorba-only related, which is why it's added here
 # and not within zorba-modules, which is for general use in other
 # non-zorba modules.
-ADD_DEPENDENCIES(check_uris gen_diag_modules)
+ADD_DEPENDENCIES(check_core_uris gen_diag_modules)

=== modified file 'CPackSourceConfig.cmake.in'
--- CPackSourceConfig.cmake.in	2009-10-30 16:24:51 +0000
+++ CPackSourceConfig.cmake.in	2012-02-03 01:13:24 +0000
@@ -19,7 +19,7 @@
 
 SET(CPACK_CMAKE_GENERATOR "Unix Makefiles")
 SET(CPACK_GENERATOR "TGZ;TZ")
-SET(CPACK_IGNORE_FILES "test/coverity/;dist/;_CPack_Packages/;build/;build./;CVS/;/\\.svn/;\\.swp$;\\.#;/#")
+SET(CPACK_IGNORE_FILES "test/coverity/;dist/;_CPack_Packages/;build/;build./;CVS/;/\\.svn/;\\.swp$;\\.#;/#;\\.bzr/")
 SET(CPACK_INSTALLED_DIRECTORIES "@CMAKE_SOURCE_DIR@;/")
 SET(CPACK_INSTALL_CMAKE_PROJECTS "")
 SET(CPACK_MODULE_PATH "")

=== modified file 'ChangeLog'
--- ChangeLog	2011-10-20 23:05:55 +0000
+++ ChangeLog	2012-02-03 01:13:24 +0000
@@ -1,13 +1,61 @@
 Zorba - The XQuery Processor
 
-version 2.x
-
-  * Custom Full-text thesaurus.
-  * Fixed bug #3401971 (node-by-reference on dynamic collections)
+version 2.2
+
+  * No-copy optimization: avoids copying nodes during node-constructor expressions.
+  * Added external function annotations %ann:propagates-input-nodes and 
+    %ann:must-copy-input-nodes to be used by the no-copy optimization.
+  * Caching of results for recursive functions with atomic parameter and return types.
+  * Added %ann:cache and %ann:no-cache to enable or disable caching of results of functions with atomic parameter and return types.
+  * Fixed bug 917923 (bug in copying outer var values into the eval dynamic context)
+  * Fixed bug 909126 (bug in cloning of var_expr)
+  * Fixed bug in destruction of exit_catcher_expr
+  * Types-related optimization for the comparison operators
+  * Fixed bug #911585 (management of variables during eval)
+  * Fixed bug #866423 (fn:empty and fn:exists iterators must reset their input in
+    case of early-out)
+  * Added index management function to the C++ api's StaticCollectionManager.
+  * Fixed bug #905041 (allow for the default element and function namespaces to be
+    set multiple times via the c++ api).
+  * Fixed bug #907872 (segfault when returning an input ItemSequence from an external function).
+  * Fixed bug #905050 (setting and getting the context item type via the c++ api).
+  * Added createDayTimeDuration, createYearMonthDuration, createDocumentNode, createCommentNode, createPiNode to api's ItemFactory.
+  * Added split function to the string module that allows for streamable tokenization but doesn't have regular expression
+    support.
+  * Fixed bug involving positional var and groupby 
+  * zerr is not predeclared anymore to be http://www.zorba-xquery.com/errors
+  * Add new XQuery interface for the PHP bindings.
+  * Added API method Item::getNamespaceBindings().
+  * Added API method StaticContext::getNamespaceBindings() (see bug #905035)
+  * Deprecated StaticContext:getNamespaceURIByPrefix()
+  * Fixed bug #918211 (xqueryx fulltext w3c conformance generation)
+  * Fixed bug #918157 (Add XQFTTS to validation queue)
+
+version 2.1
+
+New Features:
+  * New node-position module. This module allows to obtain a representation of a node position, which
+    can be used to assess structural relationships with other nodes.
+  * New node-reference module. References can be obtained for any node, and
+	different nodes cannot have the same identifier.
+  * Custom Full-text thesaurus using Zorba URI resolver mechanism.
+  * Modified C++ API to add isSequential, getExternalVariables, isBoundContextItem and 
+  isBoundExternalVariable Functions
+  * Collection allows to retrieve information about the type
+  and the annotations of a static collection.
+  * Implemented the probe-index-range-value for general indexes
+  * Added ExternalFunctionParameter class to be registered in the DynamicContext
+  * New module for compiling and executing XQueries from XQuery (xqxq)
+  * External functions are allowed to be updating (i.e. return a pending update list)
+
+Optimization:
   * Optimization for positioned sequence access (e.g. $x[$x[1]] where $x is a
   sequence of integers)
-  * documentation improvements
-  * installer improvements
+  * Optimization for count(collection()) expressions
+  * Optimization of the fn:substring function in the case when its $start and $length arguments
+  are integers
+
+Bug Fixes/Other Changes:
   * Fixed bug #3403291 (build for Fedora 15)
   * Fixed bug #3397293 (Incorrect XQueryX error message)
   * Fixed bug #3398637 (Nested element constructors cause loss of namespace bindings)
@@ -15,20 +63,19 @@
   * Fixed bug #3404689 (assignment problem in flwor)
   * Fix for bug #3404450 (testdriver_mt problem: caching and validation of docs)
   * Fixed installation bug to not install the .so for test modules
-  * Fix for running ctest on Windows
   * Fixed bug #3390410 (Adding a node to a collection causes out of bound in vector)
   * Fixed bug #3406200 (node types were not being moved to new tree during node detach)
   * Fixed bug #3406191 (Namespace bindings lost after update due to bug in node detach)
   * Fixed bug #3290122 (ZDST0003 needs collection name)
-  * Collection allows to retrieve information about the type
-  and the annotations of a static collection.
   * Fixed bug #3406272 (merging of adjacent text nodes must be done after all
     updates have been applied).
+  * Don't raise warnings for unknown annotations.
   * Fixed bug #3409344 (during detach, if the node being detached is the root of
     its tree, it should be detached from the tree as well; otherwise memory
     corruption will occur)
   * Fixed bug # (Should not destroy the parent of a node that is being detached
     before the detach is done).
+  * Added const qualifier to StaticContext::getAuditEvent() 
   * Fixed bug #3408181 (available-collection() returns undeclared collections)
   * Fixed bug #859465 (Fatal error if a PUL contains two deactivate IC primitives)
   * Fixed bug #859467 (Fatal error if a PUL contains two activate Foreign Key primitives)
@@ -36,11 +83,10 @@
   * Fixed bug #859522 (Fatal error if a PUL contains two delete document primitives)
   * Fixed bug #859968 (Using put on an attribute produces an invalid XDM instance and may cause segmentation faults)
   * Fixed bug #855314 (should not fold a constant expr that returns an error item)
-  * Added ExternalFunctionParameter class to be registered in the DynamicContext
+  * Fixed bug when parsing a document with a base-uri attribute.
   * Fixed bug #863320 (Sentence is incorrectly incremented when token characters end without sentence terminator)
   * Fixed bug #863730 (static delete-node* functions don't raise ZDDY0012)
-  * Implemented the probe-index-range-value for general indexes
-  * Fixed bug #867662 ("nullptr" warning)
+  * Removed ZSTR0005 and ZSTR0006 error codes
   * Fixed bug #868258 (Assertion failure with two delete collection)
   * Fixed bug #871623 and #871629 (assertion failures with insertions in dynamic collections)
   * Fixed bug #867262 (allow reuse of iterator over ExtFuncArgItemSequence)
@@ -54,6 +100,36 @@
   * Fixed bug #872796  (validate-in-place can interfere with other update primitives)
   * Fixed bug #872799 (validate-in-place can set incorrect types)
   * Fixed bug #855715 (Invalid escaped characters in regex not caught)
+  * Fixed bug #868325 (fn:analyze-string fails with some recursive subgroups)
+  * Fixed bug #872697 (segmentation fault with validation of NMTOKENS)
+  * General index cannot be declared as unique if the type of its key is
+  xs:anyAtomicType or xs:untypedAtomic.
+  * Added undo for node revalidation
+  * Optimization for count(collection()) expressions
+  * Fixed bug #867133 (SWIG PHP build failure on Mac OSX)
+  * Fixed bug #872796 (validate-in-place can interfere with other update primitives)
+  * Fixed bug #872799 (validate-in-place can set incorrect types)
+  * Fixed bug #872850 (Serialization of Tumbling Window For fails)
+  * Fixed bug #855715 (Invalid escaped characters in regex not caught)
+  * Fixed bug #862089 (Split binary/xq install directories for modules) by
+  splitting "module path" into separate URI and Library paths
+  * Fixed bug #872502 (validation of the JSON module xqdoc fails)
+  * Fixed bug #897619 (testdriver_mt can not run the XQueryX tests)
+  * Fixed bug #867107 (xqdoc dependency to zorba is wrong)
+  * Fixed bug #897616 (Fix the generation of the XQFTTS report results for
+  W3C)
+
+version 2.0.3
+  * Fixed bug #867662 ("nullptr" warning)
+  * documentation improvements
+
+version 2.0.2
+  * Fixed bug #3401971 (node-by-reference on dynamic collections)
+  * documentation improvements
+  * installer improvements
+  * Fixed bug #3403291 (build for Fedora 15)
+  * Don't install the .so for test modules
+  * Fix for running ctest on Windows
 
 version 2.0.1
 

=== modified file 'NOTICE.txt'
--- NOTICE.txt	2011-10-19 15:28:51 +0000
+++ NOTICE.txt	2012-02-03 01:13:24 +0000
@@ -1,5 +1,5 @@
 -----------
-Zorba 2.0.1
+Zorba 2.1.0
 -----------
 
 (Note: This file is generated automatically from NOTICE.xml.

=== modified file 'bin/CMakeLists.txt'
--- bin/CMakeLists.txt	2011-08-05 02:21:55 +0000
+++ bin/CMakeLists.txt	2012-02-03 01:13:24 +0000
@@ -15,33 +15,38 @@
 INCLUDE_DIRECTORIES(AFTER ${CMAKE_SOURCE_DIR}/src/)
 INCLUDE_DIRECTORIES(AFTER ${CMAKE_CURRENT_SOURCE_DIR})
 
-IF(ZORBA_WITH_DEBUGGER_CLIENT)
-  CONFIGURE_FILE (debug_client/event_handler_init.cpp.in debug_client/event_handler_init.cpp)
-  
-  SET(DEBUG_CLIENT_SRCS
-      debug_client/tuple.h
-      debug_client/main.cpp
-      debug_client/debug_command.h
-      debug_client/debug_command.cpp
-      debug_client/command_line_handler.h
-      debug_client/command_line_handler.cpp
-      debug_client/lock_free_queue.h
-      debug_client/event_handler.h
-      debug_client/event_handler.cpp
-      ${CMAKE_CURRENT_BINARY_DIR}/debug_client/event_handler_init.cpp
+IF (ZORBA_WITH_DEBUGGER)
+  IF (NOT WIN32)
+    FIND_PACKAGE (Libedit)
+    IF (LIBEDIT_FOUND)
+      INCLUDE_DIRECTORIES (${LIBEDIT_INCLUDE_DIRS})
+      SET (LIBEDIT_LIBS ${LIBEDIT_LIBRARIES})
+      SET (ZORBA_HAVE_LIBEDIT_H ${LIBEDIT_FOUND})
+    ENDIF (LIBEDIT_FOUND)
+  ENDIF (NOT WIN32)
+
+  CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/debugger/config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/debugger/config.h)
+  MESSAGE(STATUS "configured ${CMAKE_CURRENT_SOURCE_DIR}/debugger/config.h.cmake --> ${CMAKE_CURRENT_BINARY_DIR}/debugger/config.h")
+  INCLUDE_DIRECTORIES (BEFORE ${CMAKE_CURRENT_BINARY_DIR}/debugger)
+
+  SET (DEBUG_CLIENT_SRCS
+    debugger/main.cpp
+    debugger/xqdb_client.cpp
+    debugger/process_listener.cpp
+    debugger/command_prompt.cpp
+    debugger/command_line_handler.cpp
+    debugger/event_handler.cpp
   )
   
-  CONFIGURE_FILE (debug_client/message-handler.xq message-handler.xq)
-  
-  ZORBA_GENERATE_EXE("debuggercmd" "${DEBUG_CLIENT_SRCS}" "" "debugger" "bin")
-ENDIF(ZORBA_WITH_DEBUGGER_CLIENT)
+  ZORBA_GENERATE_EXE ("xqdb" "${DEBUG_CLIENT_SRCS}" "${LIBEDIT_LIBS}" "xqdb" "bin")
+ENDIF (ZORBA_WITH_DEBUGGER)
 
 SET(SRCS
   zorbacmd.cpp
   zorbacmdproperties.cpp
   error_printer.cpp
   util.cpp
-  module_path.cpp
+  path_util.cpp
 )
 
 INCLUDE("${CMAKE_SOURCE_DIR}/cmake_modules/ZorbaGenerateExe.cmake")
@@ -84,3 +89,37 @@
 # test the --option option to set an option in the static context
 ZORBA_ADD_TEST(bin/zorba_option zorbacmd -q "${CMAKE_CURRENT_SOURCE_DIR}/test/option.xq" -f --option "{http://www.zorba-xquery.com}option=value")
 ZORBA_SET_TEST_PROPERTY(bin/zorba_option PASS_REGULAR_EXPRESSION "value")
+
+# test the --uri-path, --lib-path, and --module-path args.
+# Use the versioning tests as they utilize test modules already.
+SET (_testdir
+  "${CMAKE_CURRENT_SOURCE_DIR}/../test/rbkt/Queries/zorba/versioning")
+SET (_uridir "${CMAKE_BINARY_DIR}/TEST_URI_PATH")
+SET (_libdir "${CMAKE_BINARY_DIR}/TEST_LIB_PATH")
+ZORBA_ADD_TEST(bin/zorba_uri_path_1 zorbacmd -f -q "${_testdir}/import1.xq"
+  --uri-path "${_uridir}")
+ZORBA_SET_TEST_PROPERTY(bin/zorba_uri_path_1
+  PASS_REGULAR_EXPRESSION "hello, v2")
+
+ZORBA_ADD_TEST(bin/zorba_uri_path_2 zorbacmd -f -q "${_testdir}/external1.xq"
+  --uri-path "${_uridir}")
+ZORBA_SET_TEST_PROPERTY(bin/zorba_uri_path_2
+  PASS_REGULAR_EXPRESSION "ZXQP0008")
+
+ZORBA_ADD_TEST(bin/zorba_uri_path_3 zorbacmd -f -q "${_testdir}/external1.xq"
+  --uri-path "${_uridir}" --lib-path "${_libdir}")
+ZORBA_SET_TEST_PROPERTY(bin/zorba_uri_path_3
+  PASS_REGULAR_EXPRESSION "hello, v2")
+
+IF(WIN32)
+  SET(PATH_SEP ";")
+ELSE(WIN32)
+  SET(PATH_SEP ":")
+ENDIF(WIN32)
+ZORBA_ADD_TEST(bin/zorba_module_path_1 zorbacmd -f -q "${_testdir}/external1.xq"
+  --module-path "${_libdir}${PATH_SEP}${_uridir}")
+ZORBA_SET_TEST_PROPERTY(bin/zorba_module_path_1
+  PASS_REGULAR_EXPRESSION "hello, v2")
+
+# test compilation of the perf script
+ZORBA_ADD_TEST(bin/zorba_compilechk4 zorbacmd -q "${CMAKE_CURRENT_SOURCE_DIR}/../test/zperf/src/start.xq" -f --compile-only)

=== removed file 'bin/debug_client/debug_command.cpp'
--- bin/debug_client/debug_command.cpp	2011-07-01 01:53:24 +0000
+++ bin/debug_client/debug_command.cpp	1970-01-01 00:00:00 +0000
@@ -1,99 +0,0 @@
-/*
- * Copyright 2006-2008 The FLWOR Foundation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <iostream>
-#include "debug_client/debug_command.h"
-
-namespace zorba { namespace debugclient {
-  
-  
-  void CommandLine::execute()
-  {
-    for (;;) {
-      std::cout << "zdb>> ";
-      std::string command;
-      std::getline(std::cin, command);
-      std::vector<std::string> args;
-      args << command;
-      std::map<std::string, UntypedCommand*>::iterator lIter = theCommands.find(args[0]);
-      if (lIter == theCommands.end()) {
-        std::cout << args[0] << ": Command not found" << std::endl;
-        continue;
-      }
-      if (!lIter->second->execute(args))
-        continue;
-      return;
-    }
-  }
-  
-  
-  CommandLine::~CommandLine()
-  {
-    for (std::map<std::string, UntypedCommand*>::iterator i = theCommands.begin();
-         i != theCommands.end(); ++i)
-    {
-      delete i->second;
-    }
-  }
-  
-  CommandLine& CommandLine::operator<<(UntypedCommand *aCommand)
-  {
-    theCommands.insert(std::make_pair(aCommand->get_name(), aCommand));
-    return *this;
-  }
-}}
-
-namespace std {
-  vector<string>& operator<< (vector<string>& vec, const string& str)
-  {
-    string::size_type before = 0;
-    string::size_type pos = str.find(" ", 0);
-    while (pos != str.npos) {
-      std::string lSub = str.substr(before, pos - before);
-      if (lSub[0] == '"') {
-        std::string::size_type lBeforeCopy = before;
-        do {
-          lBeforeCopy = str.find("\"", lBeforeCopy + 1);
-        } while (pos != str.npos && str.size() > pos + 1 && str[pos + 1] == '\\');
-        pos = lBeforeCopy;
-        lSub = str.substr(before + 1, pos - before - 1);
-      }
-      vec.push_back(lSub);
-      before = pos + 1;
-      pos = str.find(" ", before);
-    }
-    std::string lSub = str.substr(before);
-    if (lSub[0] == '"') {
-      pos = str.find("\"", before + 1);
-      lSub = str.substr(before + 1, pos - before - 1);
-    }
-    vec.push_back(lSub);
-    return vec;
-  }
-  
-  set<string>& operator<< (set<string>& vec, const string& str)
-  {
-    string::size_type before = 0;
-    string::size_type pos = str.find(" ", 0);
-    while (pos != str.npos) {
-      vec.insert(str.substr(before, pos));
-      before = pos + 1;
-      pos = str.find(" ", before);
-    }
-    vec.insert(str.substr(before));
-    return vec;
-  }
-
-}

=== removed file 'bin/debug_client/event_handler_init.cpp.in'
--- bin/debug_client/event_handler_init.cpp.in	2011-07-01 01:53:24 +0000
+++ bin/debug_client/event_handler_init.cpp.in	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-/*
- * Copyright 2006-2008 The FLWOR Foundation.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <fstream>
-#include "debug_client/event_handler.h"
-
-namespace zorba { namespace debugclient {
-
-  std::istream* EventHandler::getCurrentDirectory() {
-    const char* build_dir = "@CMAKE_BINARY_DIR@/bin/message-handler.xq";
-    const char* install_dir = 
-#ifndef WIN32
-    "@CMAKE_INSTALL_PREFIX@/bin/";
-#else
-    "C:/Program Files/Zorba XQuery Processor @ZORBA_MAJOR_NUMBER@.@ZORBA_MINOR_NUMBER@.@ZORBA_PATCH_NUMBER@/bin/";
-#endif
-    std::auto_ptr<std::ifstream> stream(new std::ifstream(build_dir));
-    if (stream->good()) {
-      return stream.release();
-    }
-    stream.reset(new std::ifstream(install_dir));
-    if (stream->good()) {
-      return stream.release();
-    }
-    return 0;
-  }
-
-}} // end of namespace zorba::debugclient
-

=== removed file 'bin/debug_client/lock_free_queue.cpp'
--- bin/debug_client/lock_free_queue.cpp	2011-07-01 01:53:24 +0000
+++ bin/debug_client/lock_free_queue.cpp	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-/*
- * Copyright 2006-2008 The FLWOR Foundation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "lock_free_queue.h"

=== removed file 'bin/debug_client/message-handler.xq'
--- bin/debug_client/message-handler.xq	2011-08-26 23:36:24 +0000
+++ bin/debug_client/message-handler.xq	1970-01-01 00:00:00 +0000
@@ -1,165 +0,0 @@
-(:
- : Copyright 2006-2009 The FLWOR Foundation.
- :
- : Licensed under the Apache License, Version 2.0 (the "License");
- : you may not use this file except in compliance with the License.
- : You may obtain a copy of the License at
- :
- : http://www.apache.org/licenses/LICENSE-2.0
- :
- : Unless required by applicable law or agreed to in writing, software
- : distributed under the License is distributed on an "AS IS" BASIS,
- : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- : See the License for the specific language governing permissions and
- : limitations under the License.
-:)
-
-import module namespace refl = 'http://www.zorba-xquery.com/modules/reflection';
-import module namespace sctx = "http://www.zorba-xquery.com/modules/introspection/sctx";
-import module namespace base64 = "http://www.zorba-xquery.com/modules/converters/base64";
-
-
-declare variable $local:localns as xs:string := 'http://www.w3.org/2005/xquery-local-functions';
-
-
-declare variable $local:endl as xs:string := '
-';
-
-declare function local:has-to-stop($resp as element())
-{
-  fn:not(($resp/@command/data(.) eq "stop" and $resp/@reason/data(.) eq "ok")
-    or ($resp/@status/data(.) eq "stopped")
-    or ($resp/@status/data(.) eq "stopping"))
-};
-
-declare function local:status($resp as element())
-{
-  fn:concat(
-    "Status: ", $resp/@status/data(.), $local:endl,
-    "Reason: ", $resp/@reason/data(.), $local:endl,
-    let $msg := $resp/text()
-    return
-      if (fn:empty($msg) or $msg eq "") then
-        ""
-      else
-        fn:concat($msg, $local:endl)
-  )
-};
-
-
-declare function local:run($resp as element()) {
-  if ($resp/@status/data(.) eq "starting") then
-    "Starting query"
-  else
-    local:status($resp)
-};
-
-declare function local:stop($resp as element())
-{
-  local:status($resp)
-};
-
-declare function local:breakpoint_set($resp as element())
-{
-  if ($resp/error) then
-    fn:concat("Error when setting a breakpoint: ", if ($resp/error/message) then $resp/error/message/text() else concat(" errcode: ", data($resp/error/@code)))
-  else
-    fn:concat("set breakpoint with id ", data($resp/@id), " and state ", data($resp/@state))
-};
-
-declare function local:breakpoint_list($resp as element())
-{
-  string-join(
-    for $b in $resp/breakpoint
-    return concat("Breakpoint ", data($b/@id), " at ", data($b/@filename), ":", data($b/@lineno), " ", data($b/@state)),
-    $local:endl
-  )
-};
-
-declare function local:breakpoint_remove($resp as element())
-{
-  "Breakpoint removed"
-};
-
-declare function local:stack_depth($resp as element())
-{
-  concat("Depth: ", data($resp/@depth))
-};
-
-declare function local:stack_get($resp as element())
-{
-  string-join(
-    for $s in $resp/stack
-    return concat("Level ", data($s/@level), " at ", data($s/@filename), ":", data($s/@lineno)),
-    $local:endl
-  )
-};
-
-
-declare function local:context_names($resp as element())
-{
-  string-join(
-    for $c in $resp/context
-    return concat("Context: ", data($c/@name), " id: ", data($c/@id)),
-    $local:endl
-  )
-};
-
-declare function local:context_get($resp as element())
-{
-  string-join(
-    for $p in $resp/property
-    return concat(data($p/@fullname), ": [", data($p/@type), "]",
-                  if ($p/text() ne "") then concat(": ", base64:decode($p/text())) else ""),
-    $local:endl
-  )
-};
-
-declare function local:eval($resp as element())
-{
-  if (data($resp/@success) eq "1") then
-    local:context_get($resp)
-  else
-    concat("Eval failed", ":", $resp/error/message/text())
-};
-
-declare function local:process-response($resp as element())
-{
-  if (data($resp/@command) eq "") then
-    (fn:true(), $resp/@transaction_id/data(.), local:status($resp))
-  else
-    let $fun-cont-name := fn:QName($local:localns, concat("local:", $resp/@command/data(.), "-cont"))
-    let $fun-msg-name := fn:QName($local:localns, concat("local:", $resp/@command/data(.)))
-    return (
-      if (sctx:function-arguments-count($fun-cont-name) = 1) then
-        refl:invoke($fun-cont-name, $resp)
-      else
-        local:has-to-stop($resp),
-      $resp/@transaction_id/data(.),
-      if (sctx:function-arguments-count($fun-msg-name) = 1) then
-        refl:invoke($fun-msg-name, $resp)
-      else
-        "Recieved a message - command not implemented"
-    )
-};
-
-declare function local:process-init($init as element())
-{
-  fn:true(),
-  0,
-  fn:concat(fn:string-join(
-  ('Established connection with', $init/@language/data(.), 'client', $init/@appid/data(.)), ' '), '
-')
-};
-
-declare function local:main($response as element()) {
-  let $process-fun as xs:QName := fn:QName($local:localns, concat("local:process-", node-name($response)))
-  return
-    if (sctx:function-arguments-count($process-fun) = 1) then
-      refl:invoke($process-fun, $response)
-    else (
-          true(),
-          ($response/@transaction_id, 0)[1]/data(.),
-          "ERROR: Recieved unknown node from client"
-         )
-};

=== renamed directory 'bin/debug_client' => 'bin/debugger'
=== renamed file 'bin/debug_client/debug_command.h' => 'bin/debugger/command.h'
--- bin/debug_client/debug_command.h	2011-07-04 08:05:46 +0000
+++ bin/debugger/command.h	2012-02-03 01:13:24 +0000
@@ -14,7 +14,9 @@
  * limitations under the License.
  */
 #pragma once
-#include <zorba/config.h>
+#ifndef ZORBA_DEBUGGER_COMMAND_H
+#define ZORBA_DEBUGGER_COMMAND_H
+
 #include <string>
 #include <vector>
 #include <iostream>
@@ -23,151 +25,18 @@
 #include <sstream>
 #include <memory>
 #include <typeinfo>
-#include "debug_client/tuple.h"
-
-namespace zorba { namespace debugclient {
+
+#include <zorba/config.h>
+
+#include "command_arg.h"
+#include "tuple.h"
+
+
+namespace zorba { namespace debugger {
   
   class DebugClientParseException : public std::exception {
   };
   
-  template<typename Tuple>
-  class CommandArg;
-  
-  template<typename Tuple>
-  class CommandArgInstance {
-  public:
-    virtual int get_index() const = 0;
-    virtual const CommandArg<Tuple>* get_arg() const = 0;
-    virtual void insertValue(Tuple& t) = 0;
-    virtual bool isSet(Tuple& t) const = 0;
-  };
-  
-  template<typename T, int Idx, typename Tuple>
-  class TypedCommandArgInstance : public CommandArgInstance<Tuple>
-  {
-  public:
-    TypedCommandArgInstance(T aValue, const CommandArg<Tuple>* aArg)
-    : theValue(aValue), theArg(aArg) {}
-    virtual int get_index() const { return Idx; }
-    virtual const CommandArg<Tuple>* get_arg() const { return theArg; }
-    virtual void insertValue(Tuple& t)
-    {
-      ZORBA_TR1_NS::get<Idx>(t).first = true;
-      ZORBA_TR1_NS::get<Idx>(t).second = theValue;
-    }
-    virtual bool isSet(Tuple& t) const
-    {
-      return ZORBA_TR1_NS::get<Idx>(t).first;
-    }
-  private:
-    T theValue;
-    const CommandArg<Tuple>* theArg;
-  };
-  
-  template<typename Tuple>
-  class CommandArgType {
-  public:
-    virtual CommandArgInstance<Tuple>* parse(const std::string& str,
-                                             const CommandArg<Tuple>* arg) = 0;
-    virtual bool isVoid() const = 0;
-    virtual bool isSet(Tuple& t) const = 0;
-    virtual ~CommandArgType() {}
-  };
-  
-  template<typename T, int Idx, typename Tuple>
-  class TypedCommandArgType : public CommandArgType<Tuple> {
-  public:
-    typedef T Type;
-  public: // implementation
-    TypedCommandArgType(bool aIsVoid) : theIsVoid(aIsVoid) {}
-    TypedCommandArgType(const T& aValue,
-                        bool aIsVoid)
-    : theDefault(aValue), theIsVoid(aIsVoid) {}
-    virtual CommandArgInstance<Tuple>* parse(const std::string& str,
-                                             const CommandArg<Tuple>* arg)
-    {
-      T aValue;
-      std::stringstream stream(str);
-      stream >> aValue;
-      if (stream.fail()) {
-        std::cerr << "Could not parse argument of type "
-          << typeid(T).name()
-          << std::endl;
-        return 0;
-      }
-      return new TypedCommandArgInstance<T, Idx, Tuple>(aValue, arg);
-    }
-    virtual bool isVoid() const { return theIsVoid; }
-    virtual bool isSet(Tuple& t) const
-    {
-      return ZORBA_TR1_NS::get<Idx>(t).first;
-    }
-  private:
-    TypedCommandArgType<T, Idx, Tuple>() {}
-    T theDefault;
-    bool theIsVoid;
-  };
-
-  template<typename Tuple>
-  class CommandArg {
-  public:
-    CommandArg(unsigned aId,
-               CommandArgType<Tuple>* aType,
-               const std::set<std::string>& aFlags,
-               const std::string& aDescription,
-               bool aIsRequired)
-    : theId(aId),
-    theType(aType),
-    theFlags(aFlags),
-    theDescription(aDescription),
-    theIsRequired(aIsRequired)
-    {
-    }
-    ~CommandArg() { delete theType; }
-    unsigned get_id() const { return theId; }
-    bool canHandle(const std::string& arg) const
-    {
-      if (theFlags.find(arg) != theFlags.end()) {
-        return true;
-      }
-      return false;
-    }
-    CommandArgInstance<Tuple>* parse(const std::string& str) const
-    {
-      return theType->parse(str, this);
-    }
-    bool isVoid() const {
-      return theType->isVoid();
-    }
-    bool isRequired() const { return theIsRequired; }
-    std::string get_name() const {
-      return *(theFlags.begin());
-    }
-    bool isSet(Tuple& t) const
-    {
-      return theType->isSet(t);
-    }
-  private:
-    unsigned theId;
-    CommandArgType<Tuple>* theType;
-    std::set<std::string> theFlags;
-    std::string theDescription;
-    bool theIsRequired;
-  };
-}} // end namespace zorba
-
-namespace std {
-  
-  /**
-   * This is a helper split function
-   */
-  vector<string>& operator<< (vector<string>& vec, const string& str);
-  
-  set<string>& operator<< (set<string>& vec, const string& str);
-} //end namespace std
-
-namespace zorba { namespace debugclient {
-
   template<typename Func, typename Tuple, int CommandIdx>
   class CommandInstance
   {
@@ -188,8 +57,10 @@
   
   class UntypedCommand {
   public:
-    virtual std::string get_name() const = 0;
-    virtual std::string get_description() const = 0;
+    virtual std::string getName() const = 0;
+    virtual std::set<std::string> getAliases() const = 0;
+    virtual std::string getDescription() const = 0;
+    virtual void printHelp() const = 0;
     virtual bool execute(const std::vector<std::string>& args) = 0;
   };
   
@@ -197,77 +68,141 @@
   class Command : public UntypedCommand {
   public:
     Command(const std::string& aName, Func& aFunction, const std::string& aDescription)
-      : theName(aName), theFunction(aFunction), theDescription(aDescription) {}
+      : theName(aName), theFunction(aFunction), theDescription(aDescription)
+    {}
+
+    Command(const std::string& aName, const std::set<std::string> aAliases, Func& aFunction, const std::string& aDescription)
+      : theName(aName), theAliases(aAliases), theFunction(aFunction), theDescription(aDescription)
+    {}
+
     ~Command();
+
   public:
-    Command& operator() (unsigned aId,
-                         const std::string& aFlags,
-                         CommandArgType<Tuple>* aType,
-                         const std::string& aDescription = "",
-                         bool isRequired = false);
-    virtual std::string get_name() const { return theName; }
-    virtual std::string get_description() const { return theDescription; }
+
+    void
+    addArgument(
+      unsigned aId,
+      const std::string& aFlags,
+      CommandArgType<Tuple>* aType,
+      const std::string& aDescription = "",
+      bool isRequired = false);
+
+    static void
+    splitNames(
+      const std::string& names,
+      std::set<std::string>& set);
+
+    virtual std::string
+    getName() const
+    {
+      return theName;
+    }
+
+    virtual std::set<std::string> getAliases() const
+    {
+      return theAliases;
+    }
+
+    virtual std::string
+    getDescription() const
+    {
+      return theDescription;
+    }
+
+    virtual void
+    printHelp() const;
+
     virtual bool execute(const std::vector<std::string>& args)
     {
       CommandInstance<Func, Tuple, CommandIdx> instance(theFunction, theTuple);
-      if (instance.parseArguments(args, theArgs))
+      if (instance.parseArguments(args, theArgs)) {
         instance.execute();
-      else
-        return false;
-      return true;
+        return true;
+      }
+      return false;
     }
   private:
     std::string theName;
+    std::set<std::string> theAliases;
     Func& theFunction;
     Tuple theTuple;
     std::string theDescription;
-    std::map<std::string, CommandArg<Tuple>* > theArgs;
-  };
-  
-  class CommandLine {
-  public:
-    ~CommandLine();
-  public:
-    void execute();
-    CommandLine& operator<< (UntypedCommand* aCommand);
-  private:
-    std::map<std::string, UntypedCommand*> theCommands;
-  };
-  
-  template<typename Func, typename Tuple, int CommandIdx>
-  Command<Func, Tuple, CommandIdx>::~Command()
-  {
-    typedef std::map<std::string, CommandArg<Tuple>* > ArgType;
-    for (typename ArgType::iterator i = theArgs.begin(); i != theArgs.end(); ++i) {
-      delete i->second;
-    }
-  }
-    
- 
-  template<typename Func, typename Tuple, int CommandIdx>
-  Command<Func, Tuple, CommandIdx>& 
-  Command<Func, Tuple, CommandIdx>::operator() (unsigned aId,
-                                    const std::string& aFlags,
-                                    CommandArgType<Tuple>* aType,
-                                    const std::string& aDescription,
-                                    bool isRequired)
-  {
-    std::set<std::string> args;
-    args << aFlags;
-    for (std::set<std::string>::iterator i = args.begin(); i != args.end(); ++i) {
-      std::string toAdd = (i->size() == 1) ? "-" + *i : "--" + *i;
-      theArgs.insert(std::make_pair(toAdd,
-                                    new CommandArg<Tuple>(aId,
-                                                          aType,
-                                                          args,
-                                                          aDescription,
-                                                          isRequired)
-                                    )
-                     );
-    }
-    return *this;
-  }
-  
+    std::map<std::string, CommandArg<Tuple>*> theArgs;
+  };
+
+/*****************************************************************************/
+/*****************************************************************************/
+
+template<typename Func, typename Tuple, int CommandIdx>
+Command<Func, Tuple, CommandIdx>::~Command()
+{
+  typedef std::map<std::string, CommandArg<Tuple>*> ArgType;
+  for (typename ArgType::iterator i = theArgs.begin(); i != theArgs.end(); ++i) {
+    delete i->second;
+  }
+}
+
+template<typename Func, typename Tuple, int CommandIdx>
+void
+Command<Func, Tuple, CommandIdx>::printHelp() const
+{
+  std::cout << "Purpose: " << getDescription() << std::endl;
+
+  typename std::map<std::string, CommandArg<Tuple>*>::const_iterator lIter = theArgs.begin();
+  if (lIter == theArgs.end()) {
+    std::cout << "This command has no arguments." << std::endl;
+    std::cout << std::endl;
+    return;
+  }
+  
+  std::cout << "Arguments:" << std::endl << std::endl;
+  for (; lIter != theArgs.end(); ++lIter) {
+    std::cout << "  " << lIter->first << "\t" << lIter->second->getDescription() << std::endl;
+  }
+  std::cout << std::endl;
+}
+
+template<typename Func, typename Tuple, int CommandIdx>
+void
+Command<Func, Tuple, CommandIdx>::splitNames(const std::string& aNames, std::set<std::string>& aSet)
+{
+  std::string::size_type before = 0;
+  std::string::size_type pos = aNames.find(" ", 0);
+  while (pos != aNames.npos) {
+    std::string lName = aNames.substr(before, pos);
+    if (lName != "") {
+      aSet.insert(lName);
+    }
+    before = pos + 1;
+    pos = aNames.find(" ", before);
+  }
+  std::string lName = aNames.substr(before);
+  if (lName != "") {
+    aSet.insert(lName);
+  }
+}
+
+template<typename Func, typename Tuple, int CommandIdx>
+void
+Command<Func, Tuple, CommandIdx>::addArgument(
+  unsigned aId,
+  const std::string& aFlags,
+  CommandArgType<Tuple>* aType,
+  const std::string& aDescription,
+  bool isRequired)
+{
+  std::set<std::string> lNames;
+  splitNames(aFlags, lNames);
+
+  for (std::set<std::string>::iterator i = lNames.begin(); i != lNames.end(); ++i) {
+    std::string toAdd = (i->size() == 1) ? "-" + *i : "--" + *i;
+    CommandArg<Tuple>* lArg = new CommandArg<Tuple>(aId, aType, lNames, aDescription, isRequired);
+    theArgs.insert(std::make_pair(toAdd, lArg));
+  }
+}
+
+/*****************************************************************************/
+
   template<typename Tuple, typename T, int Idx>
   CommandArgType<Tuple>* createArgType(Tuple t)
   {
@@ -290,6 +225,16 @@
     return new Command<Func, Tuple, CommandIdx>(aName, aFunction, aDescription);
   }
   
+  template<int CommandIdx, typename Tuple, typename Func>
+  Command<Func, Tuple, CommandIdx>* createCommand(Tuple t,
+                                                  const std::string& aName,
+                                                  const std::set<std::string>& aAliases,
+                                                  Func& aFunction,
+                                                  const std::string& aDescription)
+  {
+    return new Command<Func, Tuple, CommandIdx>(aName, aAliases, aFunction, aDescription);
+  }
+  
   template<typename Func, typename Tuple, int CommandIdx>
   bool CommandInstance<Func, Tuple, CommandIdx>::
   parseArguments(const std::vector<std::string>& args,
@@ -301,29 +246,34 @@
     for (ArgType::size_type i = 1; i < size; ++i) {
       typename CArgType::const_iterator pos = aCommandArgs.find(args[i]);
       if (pos == aCommandArgs.end()) {
-        std::cerr << "Error: Unknown Argument " << args[i] << std::endl;
+        std::cerr << "Error: Unknown option " << args[i] << std::endl;
         parseError = true;
         return false;
       }
       const CommandArg<Tuple>& arg = *(pos->second);
-      if (!arg.isVoid() && args[++i][0] == '-') {
-        std::cerr << "Did not expect parameter for option " << args[i] << std::endl;
-        return false;
-      }
       std::auto_ptr<CommandArgInstance<Tuple> > instance;
       if (arg.isVoid()) {
         instance.reset(arg.parse("1"));
       } else {
+        ++i;
+        if (i >= size) {
+          std::cerr << "Error: Missing value for argument " << args[i - 1] << std::endl;
+          parseError = true;
+          allSet = false;
+          return false;
+        }
         instance.reset(arg.parse(args[i]));
       }
-      instance->insertValue(theTuple);
+      if (instance.get()) {
+        instance->insertValue(theTuple);
+      }
     }
     bool allSet = true;
     for (typename CArgType::const_iterator i = aCommandArgs.begin();
          i != aCommandArgs.end(); ++i)
     {
       if (i->second->isRequired() && !i->second->isSet(theTuple)) {
-        std::cerr << "Error: Argument " << i->second->get_name() << " not set" << std::endl;
+        std::cerr << "Error: Argument -" << i->second->getName() << " not set" << std::endl;
         allSet = false;
       }
     }
@@ -336,4 +286,7 @@
     theFunction.template handle<CommandIdx>(this->theTuple);
   }
 
-}} // end of namespace zorba::debugclient
+} // namespace zorba
+} // namespace debugger
+
+#endif // ZORBA_DEBUGGER_COMMAND_H

=== added file 'bin/debugger/command_arg.h'
--- bin/debugger/command_arg.h	1970-01-01 00:00:00 +0000
+++ bin/debugger/command_arg.h	2012-02-03 01:13:24 +0000
@@ -0,0 +1,237 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#ifndef ZORBA_DEBUGGER_COMMAND_ARG_H
+#define ZORBA_DEBUGGER_COMMAND_ARG_H
+
+#include <string>
+#include <iostream>
+#include <set>
+#include <sstream>
+
+#include "tuple.h"
+
+
+namespace zorba { namespace debugger {
+
+template<typename Tuple>
+class CommandArg;
+
+template<typename Tuple>
+class CommandArgInstance {
+  public:
+    virtual int get_index() const = 0;
+    virtual const CommandArg<Tuple>* get_arg() const = 0;
+    virtual void insertValue(Tuple& t) = 0;
+    virtual bool isSet(Tuple& t) const = 0;
+};
+
+template<typename T, int Idx, typename Tuple>
+class TypedCommandArgInstance : public CommandArgInstance<Tuple>
+{
+  public:
+    TypedCommandArgInstance(T aValue, const CommandArg<Tuple>* aArg)
+      : theValue(aValue), theArg(aArg)
+    {
+    }
+
+    virtual int
+    get_index() const
+    {
+      return Idx;
+    }
+
+    virtual const CommandArg<Tuple>*
+    get_arg() const
+    {
+      return theArg;
+    }
+
+    virtual void
+    insertValue(Tuple& t)
+    {
+      ZORBA_TR1_NS::get<Idx>(t).first = true;
+      ZORBA_TR1_NS::get<Idx>(t).second = theValue;
+    }
+
+    virtual bool isSet(Tuple& t) const
+    {
+      return ZORBA_TR1_NS::get<Idx>(t).first;
+    }
+
+  private:
+
+    T theValue;
+    const CommandArg<Tuple>* theArg;
+};
+  
+template<typename Tuple>
+class CommandArgType
+{
+  public:
+    virtual CommandArgInstance<Tuple>*
+    parse(
+      const std::string& str,
+      const CommandArg<Tuple>* arg) = 0;
+
+    virtual bool
+    isVoid() const = 0;
+  
+    virtual bool
+    isSet(Tuple& t) const = 0;
+
+    virtual ~CommandArgType() {}
+};
+  
+  template<typename T, int Idx, typename Tuple>
+  class TypedCommandArgType : public CommandArgType<Tuple> {
+  public:
+    typedef T Type;
+  public: // implementation
+    TypedCommandArgType(bool aIsVoid) : theIsVoid(aIsVoid) {}
+    TypedCommandArgType(const T& aValue,
+                        bool aIsVoid)
+    : theDefault(aValue), theIsVoid(aIsVoid) {}
+    virtual CommandArgInstance<Tuple>* parse(const std::string& str,
+                                             const CommandArg<Tuple>* arg)
+    {
+      T aValue;
+
+      // special treatment for strings
+      // this is a double hack:
+      // - we check the type name if this starts with: class std::basic_string
+      // - we use void* in readEntireString to workaround the template type T
+      //   which would otherwise complain during compilation if types and
+      //   operators do not match
+      // TOSO: probably someone can find a more elegant solution
+      std::string lTypeName(typeid(T).name());
+      if (lTypeName.find("class std::basic_string") == 0) {
+        readEntireString(str, &aValue);
+      } else {
+        std::stringstream stream(str);
+        std::stringstream out;
+        stream >> aValue;
+        if (stream.fail()) {
+          std::cerr << "Error: Could not parse value \"" << str << "\" as type "
+            << typeid(T).name()
+            << std::endl;
+          return 0;
+        }
+      }
+
+      return new TypedCommandArgInstance<T, Idx, Tuple>(aValue, arg);
+    }
+    virtual bool isVoid() const { return theIsVoid; }
+    virtual bool isSet(Tuple& t) const
+    {
+      return ZORBA_TR1_NS::get<Idx>(t).first;
+    }
+  private:
+    void readEntireString(std::string aIn, void* aValue)
+    {
+      *((std::string*)aValue) = aIn;
+    }
+
+    TypedCommandArgType<T, Idx, Tuple>() {}
+    T theDefault;
+    bool theIsVoid;
+  };
+
+  template<typename Tuple>
+  class CommandArg {
+  public:
+    CommandArg(unsigned aId,
+               CommandArgType<Tuple>* aType,
+               const std::set<std::string>& aNames,
+               const std::string& aDescription,
+               bool aIsRequired)
+    : theId(aId),
+    theType(aType),
+    theNames(aNames),
+    theDescription(aDescription),
+    theIsRequired(aIsRequired)
+    {
+    }
+
+    ~CommandArg()
+    { 
+      delete theType;
+    }
+
+    unsigned
+    get_id() const
+    {
+      return theId;
+    }
+
+    bool
+    canHandle(const std::string& arg) const
+    {
+      if (theNames.find(arg) != theNames.end()) {
+        return true;
+      }
+      return false;
+    }
+
+    CommandArgInstance<Tuple>*
+    parse(const std::string& str) const
+    {
+      return theType->parse(str, this);
+    }
+
+    bool
+    isVoid() const
+    {
+      return theType->isVoid();
+    }
+    
+    bool
+    isRequired() const
+    {
+      return theIsRequired;
+    }
+
+    std::string
+    getName() const
+    {
+      return *(theNames.begin());
+    }
+
+    std::string
+    getDescription() const
+    {
+      return theDescription;
+    }
+
+    bool
+    isSet(Tuple& t) const
+    {
+      return theType->isSet(t);
+    }
+
+  private:
+
+    unsigned theId;
+    CommandArgType<Tuple>* theType;
+    std::set<std::string> theNames;
+    std::string theDescription;
+    bool theIsRequired;
+  };
+
+} // namespace zorba
+} // namespace debugger
+
+#endif // ZORBA_DEBUGGER_COMMAND_ARG_H

=== modified file 'bin/debugger/command_line_handler.cpp'
--- bin/debug_client/command_line_handler.cpp	2011-07-01 01:53:24 +0000
+++ bin/debugger/command_line_handler.cpp	2012-02-03 01:13:24 +0000
@@ -1,4 +1,4 @@
-/*
+  /*
  * Copyright 2006-2008 The FLWOR Foundation.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -23,225 +23,385 @@
 # define msleep Sleep
 #endif
 
-namespace zorba { namespace debugclient {
+#include "command_prompt.h"
+
+
+namespace zorba { namespace debugger {
   
-  using namespace ::std;
   using namespace ::ZORBA_TR1_NS;
   
-  CommandLineHandler::CommandLineHandler(unsigned short port,
-                                         LockFreeConsumer<std::size_t>& aConsumer,
-                                         LockFreeConsumer<bool>& aContinueQueue,
-                                         EventHandler& aHandler,
-                                         CommandLine& aCommandLine)
+CommandLineHandler::CommandLineHandler(
+  unsigned short port,
+  LockFreeConsumer<std::size_t>& aConsumer,
+  LockFreeConsumer<bool>& aContinueQueue,
+  EventHandler* aHandler,
+  CommandPrompt* aCommandPrompt)
   : theConsumer(aConsumer),
     theContinueQueue(aContinueQueue),
-    theClient(DebuggerClient::createDebuggerClient(&aHandler, port, "localhost")),
-    theCommandLine(aCommandLine),
-    theQuit(false), theContinue(false), theWaitFor(0)
+    theClient(DebuggerClient::createDebuggerClient(aHandler, port, "localhost")),
+    theCommandLine(aCommandPrompt),
+    theQuit(false), theTerminated(true), theContinue(false), theWaitFor(0)
   {
     addCommands();
   }
   
-  CommandLineHandler::~CommandLineHandler()
-  {
-  }
+CommandLineHandler::~CommandLineHandler()
+{
+}
   
-  void CommandLineHandler::execute()
-  {
-    theClient->accept();
-    std::set<std::size_t> lIdList;
-    do {
+void
+CommandLineHandler::execute()
+{
+  theClient->accept();
+  std::set<std::size_t> lIdList;
+  do {
+    getNextId(lIdList);
+    while (lIdList.find(theWaitFor) == lIdList.end()) {
       getNextId(lIdList);
-      while (!theQuit && lIdList.find(theWaitFor) == lIdList.end()) {
-        getNextId(lIdList);
-        msleep(20);
-      }
-      while (!theContinueQueue.consume(theQuit)) {
-        msleep(20);
-      }
-      theQuit = !theQuit;
-      if (!theQuit) {
-        theCommandLine.execute();
-        while (theContinue) {
-          theContinue = false;
-          theCommandLine.execute();
-        }
-      }
-    } while (!theQuit);
-  }
-  
-  void CommandLineHandler::getNextId(std::set<std::size_t>& aIdList)
-  {
-    std::size_t result;
-    if (theConsumer.consume(result)) {
-      aIdList.insert(result);
-    }
-  }
-  
-  template<>
-  void CommandLineHandler::handle<Status>(ZORBA_TR1_NS::tuple<> &t)
-  {
-    theWaitFor = theClient->status();
-  }
-  
-  template<>
-  void CommandLineHandler::handle<Quit>(ZORBA_TR1_NS::tuple<> &t)
-  {
+      msleep(20);
+    }
+    bool lCanQuit;
+    while (!theContinueQueue.consume(lCanQuit)) {
+      msleep(20);
+    }
+    if (lCanQuit) {
+      theTerminated = true;
+    }
+    theCommandLine->execute();
+    while (theContinue) {
+      theContinue = false;
+      theCommandLine->execute();
+    }
+  } while (!theQuit);
+}
+  
+void
+CommandLineHandler::getNextId(std::set<std::size_t>& aIdList)
+{
+  std::size_t result;
+  if (theConsumer.consume(result)) {
+    aIdList.insert(result);
+  }
+}
+
+template<>
+void
+CommandLineHandler::handle<Status>(ZORBA_TR1_NS::tuple<> &t)
+{
+  theWaitFor = theClient->status();
+}
+
+template<>
+void
+CommandLineHandler::handle<Variables>(ZORBA_TR1_NS::tuple<> &t)
+{
+  theWaitFor = theClient->variables();
+}
+
+template<>
+void
+CommandLineHandler::handle<Quit>(ZORBA_TR1_NS::tuple<> &t)
+{
+  if (!theTerminated) {
     bool answered = false;
     while (!answered) {
       std::cout << "Do you really want to stop debugging and exit? (y/n) ";
-      char answer;
-      std::cin >> answer;
-      std::cout << std::endl;
-      if (answer == 'y') {
+      std::string lAnswer;
+      std::getline(std::cin, lAnswer);
+      if (lAnswer == "y" || lAnswer == "yes") {
         answered = true;
-      } else if (answered == 'n') {
+      } else if (lAnswer == "n" || lAnswer == "no") {
         theContinue = true;
         return;
       }
     }
-    theWaitFor = theClient->stop();
-    theClient->quit();
-  }
-  
-  template<>
-  void CommandLineHandler::handle<Run>(ZORBA_TR1_NS::tuple<> &t)
-  {
-    theWaitFor = theClient->run();
-  }
-  
-  template<>
-  void CommandLineHandler::handle<BreakpointSet>(std::tr1::tuple<bstring, bstring, bint> &t)
-  {
-    DebuggerClient::BreakpointType lType = DebuggerClient::Line;
-    bool lEnabled = true;
-    if (get<0>(t).first) {
-      if (get<0>(t).second == "disabled") {
-        lEnabled = false;
-      }
-    }
-    theWaitFor = theClient->breakpoint_set(lType,
-                                           lEnabled,
-                                           get<1>(t).second,
-                                           get<2>(t).second);
-  }
-  
-  template<>
-  void CommandLineHandler::handle<BreakpointGet>(tuple<bint> &aTuple)
-  {
-    theWaitFor = theClient->breakpoint_get(get<0>(aTuple).second);
-  }
-  
-  template<>
-  void CommandLineHandler::handle<BreakpointDel>(tuple<bint> &aTuple)
-  {
-    theWaitFor = theClient->breakpoint_remove(get<0>(aTuple).second);
-  }
-  
-  template<>
-  void CommandLineHandler::handle<BreakpointList>(tuple<> &t)
-  {
-    theWaitFor = theClient->breakpoint_list();
-  }
-  
-  template<>
-  void CommandLineHandler::handle<StackDepth>(tuple<> &t)
-  {
-    theWaitFor = theClient->stack_depth();
-  }
-  
-  template<>
-  void CommandLineHandler::handle<StackGet>(tuple<bint> &aTuple)
-  {
-    if (get<0>(aTuple).first) {
-      theWaitFor = theClient->stack_get(get<0>(aTuple).second);
-    } else {
-      theWaitFor = theClient->stack_get();
-    }
-  }
-  
-  template<>
-  void CommandLineHandler::handle<ContextNames>(tuple<>& aTuple)
-  {
-    theWaitFor = theClient->context_names();
-  }
-  
-  template<>
-  void CommandLineHandler::handle<ContextGet>(tuple<bint> &aTuple)
-  {
-    if (get<0>(aTuple).first)
-      theWaitFor = theClient->context_get(get<0>(aTuple).second);
-    else
-      theWaitFor = theClient->context_get();
-  }
-  
-  template<>
-  void CommandLineHandler::handle<Eval>(tuple<bstring>& aTuple)
-  {
-    theWaitFor = theClient->eval(get<0>(aTuple).second);
-  }
-  
-  void CommandLineHandler::addCommands()
-  {
-    theCommandLine << createCommand<Status>(tuple<>(), "status", *this,
-                                            "Gets the status of the server");
-    theCommandLine << createCommand<Quit>(tuple<>(), "quit", *this,
-                                          "Stops debugging and quits the client");
-    theCommandLine << createCommand<Run>(tuple<>(), "run", *this, "Run the Query");
-    {
-      Command<CommandLineHandler, tuple<bstring, bstring, bint>, BreakpointSet>* lCommand =
-      createCommand<BreakpointSet>(tuple<bstring, bstring, bint>(), "break", *this, "Set a breakpoint");
-      (*lCommand)(0, "s", createArgType<tuple<bstring, bstring, bint>, std::string, 0>(tuple<bstring, bstring, bint>()),
-                  "breakpoint state (enabled or disabled - default: enabled)", false);
-      (*lCommand)(1, "f", createArgType<tuple<bstring, bstring, bint>, std::string, 1>(tuple<bstring, bstring, bint>()),
-                  "The name of the file where to stop", true);
-      (*lCommand)(2, "l", createArgType<tuple<bstring, bstring, bint>, int, 2>(tuple<bstring, bstring, bint>()),
-                  "The line number", true);
-      
-      theCommandLine << lCommand;
-    }
-    {
-      Command<CommandLineHandler, tuple<bint>, BreakpointGet>* lCommand
-      = createCommand<BreakpointGet>(tuple<bint>(), "binfo", *this, 
-                                   "Get information about a given breakpoint");
-      (*lCommand)(0, "i", createArgType<tuple<bint>, int, 0>(tuple<bint>()),
-                  "The id of the breakpoint", true);
-      
-      theCommandLine << lCommand;
-    }
-    {
-      Command<CommandLineHandler, tuple<bint>, BreakpointDel>* lCommand
-      = createCommand<BreakpointDel>(tuple<bint>(), "bdel", *this, "Delete a breakpoint with a given id");
-      (*lCommand)(0, "i", createArgType<tuple<bint>, int, 0>(tuple<bint>()), "The id of the breakpoint", true);
-      
-      theCommandLine << lCommand;
-    }
-    theCommandLine << createCommand<BreakpointList>(tuple<>(), "blist", *this, "List all set breakpoints");
-    theCommandLine << createCommand<StackDepth>(tuple<>(), "sdepth", *this, "Get the depth of the stack");
-    {
-      Command<CommandLineHandler, tuple<bint>, StackGet>* lCommand
-      = createCommand<StackGet>(tuple<bint>(), "sget", *this, "Get information about one or all stack frames");
-      (*lCommand)(0, "d", createArgType<tuple<bint>, int, 0>(tuple<bint>()), "The stack entry two show (show all if not provided)", false);
-      theCommandLine << lCommand;
-    }
-    theCommandLine << createCommand<ContextNames>(tuple<>(), "cnames", *this, "Get the names of the avilable contexts");
-    {
-      Command<CommandLineHandler, tuple<bint>, ContextGet>* lCommand
-      = createCommand<ContextGet>(tuple<bint>(), "cget", *this, "Get a context");
-      
-      (*lCommand)(0, "c", createArgType<tuple<bint>, int, 0>(tuple<bint>()), "The id of the context", false);
-      
-      theCommandLine << lCommand;
-    }
-    {
-      Command<CommandLineHandler, tuple<bstring>, Eval>* lCommand
-      = createCommand<Eval>(tuple<bstring>(), "eval", *this, "Evaluate a function");
-      
-      (*lCommand)(0, "c", createArgType<tuple<bstring>, std::string, 0>(tuple<bstring>()), "The command to evaluate", true);
-      
-      theCommandLine << lCommand;
-    }
-  }
-  
-}} // namespace zorba::debugclient
-
+  }
+  theWaitFor = theClient->stop(true);
+  theClient->quit();
+  theQuit = true;
+}
+
+template<>
+void
+CommandLineHandler::handle<Run>(ZORBA_TR1_NS::tuple<> &t)
+{
+  theTerminated = false;
+  theWaitFor = theClient->run();
+}
+
+template<>
+void
+CommandLineHandler::handle<Stop>(ZORBA_TR1_NS::tuple<> &t)
+{
+  theWaitFor = theClient->stop(false);
+}
+
+template<>
+void
+CommandLineHandler::handle<BreakpointSet>(std::tr1::tuple<bstring, bstring, bint> &aTuple)
+{
+  DebuggerClient::BreakpointType lType = DebuggerClient::Line;
+  bool lEnabled = true;
+  if (get<0>(aTuple).first) {
+    if (get<0>(aTuple).second == "disabled") {
+      lEnabled = false;
+    }
+  }
+  theWaitFor = theClient->breakpoint_set(lType,
+                                          lEnabled,
+                                          get<1>(aTuple).second,
+                                          get<2>(aTuple).second);
+}
+  
+template<>
+void
+CommandLineHandler::handle<BreakpointGet>(tuple<bint> &aTuple)
+{
+  theWaitFor = theClient->breakpoint_get(get<0>(aTuple).second);
+}
+  
+template<>
+void
+CommandLineHandler::handle<BreakpointRemove>(tuple<bint> &aTuple)
+{
+  theWaitFor = theClient->breakpoint_remove(get<0>(aTuple).second);
+}
+  
+template<>
+void
+CommandLineHandler::handle<BreakpointList>(tuple<> &aTuple)
+{
+  theWaitFor = theClient->breakpoint_list();
+}
+  
+template<>
+void
+CommandLineHandler::handle<StackDepth>(tuple<> &aTuple)
+{
+  theWaitFor = theClient->stack_depth();
+}
+  
+template<>
+void
+CommandLineHandler::handle<StackGet>(tuple<bint> &aTuple)
+{
+  if (get<0>(aTuple).first) {
+    theWaitFor = theClient->stack_get(get<0>(aTuple).second);
+  } else {
+    theWaitFor = theClient->stack_get();
+  }
+}
+  
+template<>
+void
+CommandLineHandler::handle<ContextNames>(tuple<>& aTuple)
+{
+  theWaitFor = theClient->context_names();
+}
+  
+template<>
+void CommandLineHandler::handle<ContextGet>(tuple<bint, bint> &aTuple)
+{
+  int lDepth = -1;
+  int lContext = -1;
+
+  if (get<0>(aTuple).first) {
+    lDepth = get<0>(aTuple).second;
+  }
+  if (get<1>(aTuple).first) {
+    lContext  = get<1>(aTuple).second;
+  }
+  theWaitFor = theClient->context_get(lDepth, lContext);
+}
+
+template<>
+void CommandLineHandler::handle<Source>(tuple<bint, bint, bstring> &aTuple)
+{
+  theWaitFor = theClient->source(
+    get<2>(aTuple).second,
+    get<0>(aTuple).second,
+    get<1>(aTuple).second);
+}
+  
+template<>
+void CommandLineHandler::handle<Eval>(tuple<bstring>& aTuple)
+{
+  theWaitFor = theClient->eval(get<0>(aTuple).second);
+}
+
+template<>
+void
+CommandLineHandler::handle<StepIn>(ZORBA_TR1_NS::tuple<> &t)
+{
+  theTerminated = false;
+  theWaitFor = theClient->step_into();
+}
+
+template<>
+void
+CommandLineHandler::handle<StepOut>(ZORBA_TR1_NS::tuple<> &t)
+{
+  theWaitFor = theClient->step_out();
+}
+
+template<>
+void
+CommandLineHandler::handle<StepOver>(ZORBA_TR1_NS::tuple<> &t)
+{
+  theTerminated = false;
+  theWaitFor = theClient->step_over();
+}
+
+void
+CommandLineHandler::addCommands()
+{
+  typedef tuple<> TUPLE;
+  typedef tuple<bint> TUPLE_INT;
+  typedef tuple<bstring> TUPLE_STR;
+  typedef tuple<bint, bint> TUPLE_INT_INT;
+  typedef tuple<bstring, bstring, bint> TUPLE_STR_STR_INT;
+  typedef tuple<bint, bint, bstring> TUPLE_INT_INT_STR;
+
+  // DBGP: status
+  *theCommandLine << createCommand<Status>(TUPLE(), "status", *this, "Gets the status of the server");
+
+  // ALIAS: variables (context_get -c -1)
+  {
+    std::set<std::string> lAliases;
+    lAliases.insert("vars");
+    *theCommandLine << createCommand<Variables>(TUPLE(), "variables", lAliases, *this, "Gets the variables visible in the current scope");
+  }
+
+  // META: quit
+  *theCommandLine << createCommand<Quit>(TUPLE(), "quit", *this, "Stops debugging and quits the client");
+
+  // DBGP: run
+  *theCommandLine << createCommand<Run>(TUPLE(), "run", *this, "Run the query");
+
+  // DBGP: stop
+  *theCommandLine << createCommand<Stop>(TUPLE(), "stop", *this, "Stop the query");
+
+  // DBGP: breakpoint_set
+  {
+    std::set<std::string> lAliases;
+    lAliases.insert("break");
+    Command<CommandLineHandler, TUPLE_STR_STR_INT, BreakpointSet>* lCommand =
+      createCommand<BreakpointSet>(TUPLE_STR_STR_INT(), "bset", lAliases, *this, "Set a breakpoint");
+
+    lCommand->addArgument(0, "s", createArgType<TUPLE_STR_STR_INT, std::string, 0>(TUPLE_STR_STR_INT()), "breakpoint state (optional, 'enabled' or 'disabled', default: enabled)", false);
+    lCommand->addArgument(1, "f", createArgType<TUPLE_STR_STR_INT, std::string, 1>(TUPLE_STR_STR_INT()), "name of the file where to stop", true);
+    lCommand->addArgument(2, "l", createArgType<TUPLE_STR_STR_INT, int, 2>(TUPLE_STR_STR_INT()), "line number", true);
+      
+    *theCommandLine << lCommand;
+  }
+
+  // DBGP: breakpoint_get
+  {
+    Command<CommandLineHandler, TUPLE_INT, BreakpointGet>* lCommand =
+      createCommand<BreakpointGet>(TUPLE_INT(), "bget", *this, "Get information about a given breakpoint");
+
+    lCommand->addArgument(0, "d", createArgType<TUPLE_INT, int, 0>(TUPLE_INT()), "breakpoint ID", true);
+      
+    *theCommandLine << lCommand;
+  }
+
+  // DBGP: breakpoint_remove
+  {
+    std::set<std::string> lAliases;
+    lAliases.insert("clear");
+    lAliases.insert("delete");
+    Command<CommandLineHandler, TUPLE_INT, BreakpointRemove>* lCommand = 
+      createCommand<BreakpointRemove>(TUPLE_INT(), "bremove", lAliases, *this, "Delete a breakpoint");
+
+    lCommand->addArgument(0, "d", createArgType<TUPLE_INT, int, 0>(TUPLE_INT()), "breakpoint ID", true);
+      
+    *theCommandLine << lCommand;
+  }
+
+  // DBGP: breakpoint_list
+  *theCommandLine << createCommand<BreakpointList>(TUPLE(), "blist", *this, "List all set breakpoints");
+
+  // DBGP: stack_depth
+  *theCommandLine << createCommand<StackDepth>(TUPLE(), "sdepth", *this, "Get the depth of the stack");
+
+  // DBGP: stack_get
+  {
+    Command<CommandLineHandler, TUPLE_INT, StackGet>* lCommand =
+      createCommand<StackGet>(TUPLE_INT(), "sget", *this, "Get information about one or all stack frames");
+
+    lCommand->addArgument(0, "d", createArgType<TUPLE_INT, int, 0>(TUPLE_INT()), "stack frame to show: 0 for current stack frame, N for the main module (optional, all frames are shown if not provided)", false);
+
+    *theCommandLine << lCommand;
+  }
+
+  // DBGP: context_names
+  *theCommandLine << createCommand<ContextNames>(tuple<>(), "cnames", *this, "Get the names of the avilable contexts");
+  // the DBGP -d arguments for this command is omitted since we always have/return: 0 - Local, 1 - Global
+
+  // DBGP: context_get
+  {
+    Command<CommandLineHandler, TUPLE_INT_INT, ContextGet>* lCommand =
+      createCommand<ContextGet>(TUPLE_INT_INT(), "cget", *this, "Get a context (list variables in this context)");
+
+    lCommand->addArgument(0, "d", createArgType<TUPLE_INT_INT, int, 0>(TUPLE_INT_INT()), "stack depth (optional, default: 0)", false);
+    lCommand->addArgument(0, "c", createArgType<TUPLE_INT_INT, int, 1>(TUPLE_INT_INT()), "context ID: 0 for Local, 1 for Global (optional, default: 0)", false);
+
+    *theCommandLine << lCommand;
+  }
+
+  // DBGP: source
+  {
+    std::set<std::string> lAliases;
+    lAliases.insert("list");
+    Command<CommandLineHandler, TUPLE_INT_INT_STR, Source>* lCommand =
+      createCommand<Source>(TUPLE_INT_INT_STR(), "source", lAliases, *this, "List source code");
+
+    lCommand->addArgument(0, "b", createArgType<TUPLE_INT_INT_STR, int, 0>(TUPLE_INT_INT_STR()), "begin line (optional, default: first line)", false);
+    lCommand->addArgument(1, "e", createArgType<TUPLE_INT_INT_STR, int, 1>(TUPLE_INT_INT_STR()), "end line (optional, default: last line)", false);
+    lCommand->addArgument(2, "f", createArgType<TUPLE_INT_INT_STR, std::string, 2>(TUPLE_INT_INT_STR()), "file URI (optional, default: the file in the top-most stack frame during execution, main module otherwise)", false);
+
+    *theCommandLine << lCommand;
+  }
+
+  // DBGP: eval
+  {
+    std::set<std::string> lAliases;
+    lAliases.insert("print");
+    Command<CommandLineHandler, TUPLE_STR, Eval>* lCommand =
+      createCommand<Eval>(TUPLE_STR(), "eval", lAliases, *this, "Evaluate an expression");
+
+    // TODO: this argument should not be here at all. Eval has the form: eval -i transaction_id -- {DATA}
+    // Eval should be called with a command like: eval 1 + 3
+    // - no need for an argument name
+    // - everything following the fist contiguous set of whitespaces are sent as string
+    lCommand->addArgument(0, "c", createArgType<TUPLE_STR, std::string, 0>(TUPLE_STR()), "expression to evaluate", true);
+      
+    *theCommandLine << lCommand;
+  }
+
+  // DBGP: step_in
+  {
+    std::set<std::string> lAliases;
+    lAliases.insert("step");
+    lAliases.insert("s");
+    *theCommandLine << createCommand<StepIn>(TUPLE(), "in", lAliases, *this, "Step in");
+  }
+
+  // DBGP: step_out
+  {
+    std::set<std::string> lAliases;
+    lAliases.insert("finish");
+    *theCommandLine << createCommand<StepOut>(TUPLE(), "out", lAliases, *this, "Step out");
+  }
+
+  // DBGP: step_over
+  {
+    std::set<std::string> lAliases;
+    lAliases.insert("next");
+    lAliases.insert("n");
+    *theCommandLine << createCommand<StepOver>(TUPLE(), "over", lAliases, *this, "Step over");
+  }
+}
+  
+} // namespace zorba
+} // namespace debugger

=== modified file 'bin/debugger/command_line_handler.h'
--- bin/debug_client/command_line_handler.h	2011-07-01 01:53:24 +0000
+++ bin/debugger/command_line_handler.h	2012-02-03 01:13:24 +0000
@@ -14,46 +14,71 @@
  * limitations under the License.
  */
 #pragma once
+#ifndef ZORBA_DEBUGGER_COMMAND_LINE_HANDLER_H
+#define ZORBA_DEBUGGER_COMMAND_LINE_HANDLER_H
 
 #include <set>
 #include <cassert>
+
 #include <zorba/debugger_client.h>
-#include "debug_command.h"
+
+#include "command.h"
 #include "event_handler.h"
 
-namespace zorba { namespace debugclient {
-  
+
+namespace zorba { namespace debugger {
+
+  class CommandPrompt;
+
   enum Commands {
     Status,
+    Variables,
+    Quit,
     Run,
+    Stop,
     BreakpointSet,
     BreakpointGet,
-    BreakpointDel,
+    BreakpointRemove,
     BreakpointList,
     StackDepth,
     StackGet,
     ContextNames,
     ContextGet,
+    Source,
     Eval,
-    Quit
+    StepIn,
+    StepOut,
+    StepOver
   };
   
-  class CommandLineHandler {
+class CommandLineHandler
+{
   private:
+
     typedef std::pair<bool, std::string> bstring;
     typedef std::pair<bool, int> bint;
+
   public:
-    CommandLineHandler(unsigned short port,
-                       LockFreeConsumer<std::size_t>& aConsumer,
-                       LockFreeConsumer<bool>& aContinueQueue,
-                       EventHandler& aHandler,
-                       CommandLine& aCommandLine);
+
+    CommandLineHandler(
+      unsigned short port,
+      LockFreeConsumer<std::size_t>& aConsumer,
+      LockFreeConsumer<bool>& aContinueQueue,
+      EventHandler* aHandler,
+      CommandPrompt* aCommandPrompt);
+
     ~CommandLineHandler();
+
   public:
     void execute();
+  
   public: // Handlers
+
     template<int>
-    void handle(ZORBA_TR1_NS::tuple<>& aTuple) { assert(false); }
+    void handle(ZORBA_TR1_NS::tuple<>& aTuple)
+    {
+      assert(false);
+    }
     
     template<int>
     void handle(ZORBA_TR1_NS::tuple<bstring, bstring, bint>& t)
@@ -62,63 +87,96 @@
     }
     
     template<int>
+    void handle(ZORBA_TR1_NS::tuple<bint, bint, bstring>& t)
+    {
+      assert(false);
+    }
+    
+    template<int>
     void handle(ZORBA_TR1_NS::tuple<bint>& aTuple)
     {
       assert(false);
     }
     
     template<int>
+    void handle(ZORBA_TR1_NS::tuple<bint, bint>& aTuple)
+    {
+      assert(false);
+    }
+    
+    template<int>
     void handle(ZORBA_TR1_NS::tuple<bstring>& aTuple)
     {
       assert(false);
     }
+
   private:
-    LockFreeConsumer<std::size_t>& theConsumer;
-    LockFreeConsumer<bool>& theContinueQueue;
-    DebuggerClient* theClient;
-    CommandLine& theCommandLine;
-    bool theQuit;
-    bool theContinue;
-    std::size_t theWaitFor;
+    LockFreeConsumer<std::size_t>&  theConsumer;
+    LockFreeConsumer<bool>&         theContinueQueue;
+    DebuggerClient*                 theClient;
+    CommandPrompt*                  theCommandLine;
+    bool                            theQuit;
+    bool                            theTerminated;
+    bool                            theContinue;
+    std::size_t                     theWaitFor;
+
   private:
     void getNextId(std::set<std::size_t>& aIdList);
     void addCommands();
-  };
-  
-  template<>
-  void CommandLineHandler::handle<Status> (ZORBA_TR1_NS::tuple<>& t);
-  
-  template<>
-  void CommandLineHandler::handle<Quit> (ZORBA_TR1_NS::tuple<>& t);
-  
-  template<>
-  void CommandLineHandler::handle<Run> (ZORBA_TR1_NS::tuple<> &t);
-  
-  template<>
-  void CommandLineHandler::handle<StackDepth> (ZORBA_TR1_NS::tuple<>& t);
-  
-  template<>
-  void CommandLineHandler::handle<BreakpointList> (ZORBA_TR1_NS::tuple<>& aTuple);
-  
-  template<>
-  void CommandLineHandler::handle<BreakpointSet> (ZORBA_TR1_NS::tuple<bstring, bstring, bint> &t);
-  
-  template<>
-  void CommandLineHandler::handle<BreakpointGet> (ZORBA_TR1_NS::tuple<bint>& aTuple);
-  
-  template<>
-  void CommandLineHandler::handle<BreakpointDel>(ZORBA_TR1_NS::tuple<bint> &aTuple);
-  
-  template<>
-  void CommandLineHandler::handle<StackGet> (ZORBA_TR1_NS::tuple<bint>& aTuple);
-  
-  template<>
-  void CommandLineHandler::handle<ContextNames>(ZORBA_TR1_NS::tuple<> &aTuple);
-  
-  template<>
-  void CommandLineHandler::handle<ContextGet>(ZORBA_TR1_NS::tuple<bint> &aTuple);
-  
-  template<>
-  void CommandLineHandler::handle<Eval>(ZORBA_TR1_NS::tuple<bstring>& aTuple);
-  
-}} // close namespaces zorba::debugclient
+};
+
+template<>
+void CommandLineHandler::handle<Status> (ZORBA_TR1_NS::tuple<>& t);
+
+template<>
+void CommandLineHandler::handle<Quit> (ZORBA_TR1_NS::tuple<>& t);
+
+template<>
+void CommandLineHandler::handle<Run> (ZORBA_TR1_NS::tuple<> &t);
+
+template<>
+void CommandLineHandler::handle<Stop> (ZORBA_TR1_NS::tuple<> &t);
+
+template<>
+void CommandLineHandler::handle<StackDepth> (ZORBA_TR1_NS::tuple<>& t);
+
+template<>
+void CommandLineHandler::handle<BreakpointList> (ZORBA_TR1_NS::tuple<>& aTuple);
+  
+template<>
+void CommandLineHandler::handle<BreakpointSet> (ZORBA_TR1_NS::tuple<bstring, bstring, bint> &t);
+  
+template<>
+void CommandLineHandler::handle<BreakpointGet> (ZORBA_TR1_NS::tuple<bint>& aTuple);
+  
+template<>
+void CommandLineHandler::handle<BreakpointRemove>(ZORBA_TR1_NS::tuple<bint> &aTuple);
+  
+template<>
+void CommandLineHandler::handle<StackGet> (ZORBA_TR1_NS::tuple<bint>& aTuple);
+  
+template<>
+void CommandLineHandler::handle<ContextNames>(ZORBA_TR1_NS::tuple<> &aTuple);
+  
+template<>
+void CommandLineHandler::handle<ContextGet>(ZORBA_TR1_NS::tuple<bint, bint> &aTuple);
+  
+template<>
+void CommandLineHandler::handle<Source>(ZORBA_TR1_NS::tuple<bint, bint, bstring> &aTuple);
+  
+template<>
+void CommandLineHandler::handle<Eval>(ZORBA_TR1_NS::tuple<bstring>& aTuple);
+
+template<>
+void CommandLineHandler::handle<StepIn> (ZORBA_TR1_NS::tuple<> &t);
+
+template<>
+void CommandLineHandler::handle<StepOut> (ZORBA_TR1_NS::tuple<> &t);
+
+template<>
+void CommandLineHandler::handle<StepOver> (ZORBA_TR1_NS::tuple<> &t);
+
+} // namespace zorba
+} // namespace debugger
+
+#endif // ZORBA_DEBUGGER_COMMAND_LINE_HANDLER_H

=== added file 'bin/debugger/command_prompt.cpp'
--- bin/debugger/command_prompt.cpp	1970-01-01 00:00:00 +0000
+++ bin/debugger/command_prompt.cpp	2012-02-03 01:13:24 +0000
@@ -0,0 +1,287 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "command_prompt.h"
+
+#include <string>
+#include <vector>
+#include <map>
+#include <iostream>
+
+#include "command.h"
+
+
+namespace zorba { namespace debugger {
+
+#ifdef ZORBA_HAVE_LIBEDIT_H
+const char*
+prompt(EditLine* aEl) {
+  return "(xqdb) ";
+}
+#endif
+
+CommandPrompt::CommandPrompt()
+{
+#ifdef ZORBA_HAVE_LIBEDIT_H
+  theEditLine = el_init("xqdb", stdin, stdout, stderr);
+  theHistory = history_init();
+  HistEvent lHistoryEvent;
+  history(theHistory, &lHistoryEvent, H_SETSIZE, 100);
+
+  el_set(theEditLine, EL_PROMPT, prompt);
+
+  el_set(theEditLine, EL_HIST, history, theHistory);
+  el_set(theEditLine, EL_EDITOR, "emacs");
+#endif
+}
+
+CommandPrompt::~CommandPrompt()
+{
+#ifdef ZORBA_HAVE_LIBEDIT_H
+  history_end(theHistory);
+  el_end(theEditLine);
+#endif
+
+  std::map<std::string, UntypedCommand*>::iterator lIter;
+  for (lIter = theCommands.begin(); lIter != theCommands.end(); ++lIter) {
+    delete lIter->second;
+  }
+}
+
+void
+CommandPrompt::printHelp(UntypedCommand* aCommand)
+{
+  // if no command is provided, print all the available commands
+  if (!aCommand) {
+    std::cout << "Available commands:" << std::endl;
+
+    // print the names of all commands
+    std::map<std::string, UntypedCommand*>::iterator lIter = theCommands.begin();
+    while (lIter != theCommands.end()) {
+      std::cout << "  " << (*lIter).first;
+      std::set<std::string> lAliases = (*lIter).second->getAliases();
+      std::set<std::string>::const_iterator lAliasIter = lAliases.begin();
+      while (lAliasIter != lAliases.end()) {
+        std::cout << ", " << *lAliasIter;
+        lAliasIter++;
+      }
+      std::cout << std::endl;
+      lIter++;
+    }
+
+    // some hints for detailed help
+    std::cout << std::endl;
+    std::cout << "Type help <command> to get more information about one command." << std::endl;
+    std::cout << std::endl;
+  } else {
+    // ok, so we have a command; then print the help
+    aCommand->printHelp();
+  }
+}
+
+void
+CommandPrompt::execute()
+{
+  bool lWithOutput = true;
+
+  for (;;) {
+#ifdef ZORBA_HAVE_LIBEDIT_H
+    const char* lBuf;
+    int lCharsRead = -1;
+    lBuf = el_gets(theEditLine, &lCharsRead);
+    std::string lCommandLine(lBuf, lCharsRead - 1);
+#else
+    if (lWithOutput) {
+      std::cout << "(xqdb) ";
+    }
+    lWithOutput = true;
+    std::string lCommandLine;
+    std::getline(std::cin, lCommandLine);
+    if (std::cin.fail()) {
+      lWithOutput = false;
+      std::cin.clear();
+      continue;
+    }
+#endif
+    
+    std::vector<std::string> lArgs;
+
+    // split the command into arguments
+    parseLine(lCommandLine, lArgs);
+    std::string::size_type lSize = lArgs.size();
+
+    // empty command? do nothing!
+    if (lSize == 0) {
+      lArgs = theLastArgs;
+      if (lArgs.size() == 0) {
+        continue;
+      }
+    }
+#ifdef ZORBA_HAVE_LIBEDIT_H
+    else {
+      HistEvent lHistoryEvent;
+      history(theHistory, &lHistoryEvent, H_ENTER, lCommandLine.c_str());
+    }
+#endif
+    theLastArgs = lArgs;
+
+    UntypedCommand* lCommand = NULL;
+
+    // help is not a command but a hook here
+    if (lArgs.at(0) == "h" || lArgs.at(0) == "help") {
+      std::string lCmd = "";
+
+      // if the user needs the help for a specific command
+      if (lSize > 1) {
+        // do nothing if we don't have a command starting with this prefix?
+        // findCommand will print the appropriate errors
+        if (!findCommand(lArgs[1], lCommand)) {
+          continue;
+        }
+      }
+      printHelp(lCommand);
+      continue;
+    }
+    if (findCommand(lArgs[0], lCommand) && lCommand->execute(lArgs)) {
+      return;
+    }
+    continue;
+  }
+}
+  
+CommandPrompt&
+CommandPrompt::operator<<(UntypedCommand *aCommand)
+{
+  theCommands.insert(std::make_pair(aCommand->getName(), aCommand));
+  return *this;
+}
+
+bool
+CommandPrompt::findCommand(const std::string& aPrefix, UntypedCommand*& aCommand)
+{
+  std::vector<UntypedCommand*> lFoundCommands;
+
+  std::map<std::string, UntypedCommand*>::iterator lIter = theCommands.begin();
+  while (lIter != theCommands.end()) {
+    // if a command name is equal with the prefix, this is the command we want
+    if ((*lIter).first == aPrefix) {
+      aCommand = (*lIter).second;
+      return true;
+    }
+
+    bool lIsCandidate = false;
+
+    // add this command to candidate commands if the prefix matches
+    if ((*lIter).first.find(aPrefix) == 0) {
+      lFoundCommands.push_back((*lIter).second);
+      lIsCandidate = true;
+    }
+
+    // now process the aliases
+    std::set<std::string> lAliases = (*lIter).second->getAliases();
+    std::set<std::string>::const_iterator lAliasIter = lAliases.begin();
+    while (lAliasIter != lAliases.end()) {
+      // if a command alias is equal with the prefix, this is the command we want
+      if (*lAliasIter == aPrefix) {
+        aCommand = (*lIter).second;
+        return true;
+      }
+
+      // add this command to candidate commands if the prefix matches one alias
+      // and if the command is not already added 
+      if (!lIsCandidate && (*lAliasIter).find(aPrefix) == 0) {
+        lFoundCommands.push_back((*lIter).second);
+        break;
+      }
+      lAliasIter++;
+    }
+
+    lIter++;
+  }
+
+  if (lFoundCommands.empty()) {
+    std::cout << "Command not found: " << aPrefix << std::endl;
+    return false;
+  }
+
+  if (lFoundCommands.size() > 1) {
+    std::cout << "Ambigous command: " << aPrefix << std::endl;
+    // show all possible commands that start with this prefix
+    for (std::string::size_type i = 0; i < lFoundCommands.size(); i++) {
+      UntypedCommand* lCommand = lFoundCommands.at(i);
+
+      // commands
+      if (lCommand->getName().find(aPrefix) == 0) {
+        std::cout << "  " << lCommand->getName() << std::endl;
+      }
+
+      // and aliases
+      std::set<std::string> lAliases = lCommand->getAliases();
+      std::set<std::string>::const_iterator lAliasIter = lAliases.begin();
+      while (lAliasIter != lAliases.end()) {
+        if ((*lAliasIter).find(aPrefix) == 0) {
+          std::cout << "  " << *lAliasIter << std::endl;
+        }
+        lAliasIter++;
+      }
+    }
+    return false;
+  }
+
+  aCommand = lFoundCommands[0];
+  return true;
+}
+
+void
+CommandPrompt::parseLine(const std::string& aLine, std::vector<std::string>& aVector)
+{
+  std::string::size_type lBefore = 0;
+  std::string::size_type lPos = aLine.find_first_of(" \t", 0);
+
+  while (lPos != aLine.npos) {
+    std::string lSub = aLine.substr(lBefore, lPos - lBefore);
+
+    // if two consecutive spaces, you get an empty string here
+    if (lSub != "") {
+      if (lSub[0] == '"') {
+        std::string::size_type lBeforeCopy = lBefore;
+        do {
+          lBeforeCopy = aLine.find("\"", lBeforeCopy + 1);
+        } while (lPos != aLine.npos && aLine.size() > lPos + 1 && aLine[lPos + 1] == '\\');
+        lPos = lBeforeCopy;
+        lSub = aLine.substr(lBefore + 1, lPos - lBefore - 1);
+      }
+      aVector.push_back(lSub);
+    }
+
+    lBefore = lPos + 1;
+    lPos = aLine.find_first_of(" \t", lBefore);
+  }
+  std::string lSub = aLine.substr(lBefore);
+
+  // catching the case when the command ends with a space
+  if (lSub == "") {
+    return;
+  }
+
+  if (lSub[0] == '"') {
+    lPos = aLine.find("\"", lBefore + 1);
+    lSub = aLine.substr(lBefore + 1, lPos - lBefore - 1);
+  }
+  aVector.push_back(lSub);
+}
+  
+} // namespace zorba
+} // namespace debugger

=== added file 'bin/debugger/command_prompt.h'
--- bin/debugger/command_prompt.h	1970-01-01 00:00:00 +0000
+++ bin/debugger/command_prompt.h	2012-02-03 01:13:24 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#ifndef ZORBA_DEBUGGER_COMMAND_PROMPT_H
+#define ZORBA_DEBUGGER_COMMAND_PROMPT_H
+
+#include <string>
+#include <map>
+#include <vector>
+
+#include "config.h"
+
+#ifdef ZORBA_HAVE_LIBEDIT_H
+# include <histedit.h>
+#endif
+
+
+namespace zorba { namespace debugger {
+
+class UntypedCommand;
+
+class CommandPrompt
+{
+  public:
+    CommandPrompt();
+    ~CommandPrompt();
+
+  public:
+
+    void execute();
+
+    CommandPrompt& operator<< (UntypedCommand* command);
+
+  private:
+
+    void
+    printHelp(UntypedCommand* command);
+
+    bool
+    findCommand(const std::string& prefix, UntypedCommand*& command);
+
+    void
+    parseLine(const std::string& line, std::vector<std::string>& vector);
+
+  private:
+    std::map<std::string, UntypedCommand*>  theCommands;
+    std::vector<std::string>                theLastArgs;
+
+#ifdef ZORBA_HAVE_LIBEDIT_H
+    EditLine*                               theEditLine;
+    History*                                theHistory;
+#endif
+};  
+
+  
+} // namespace zorba
+} // namespace debugger
+
+#endif // ZORBA_DEBUGGER_COMMAND_PROMPT_H

=== added file 'bin/debugger/config.h.cmake'
--- bin/debugger/config.h.cmake	1970-01-01 00:00:00 +0000
+++ bin/debugger/config.h.cmake	2012-02-03 01:13:24 +0000
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This header is configured by Zorba's build process -- DO NOT EDIT!
+
+#ifndef ZORBA_DEBUGGER_CONFIG_H
+#define ZORBA_DEBUGGER_CONFIG_H
+
+#cmakedefine ZORBA_HAVE_LIBEDIT_H
+
+#endif /* ZORBA_DEBUGGER_CONFIG_H */

=== modified file 'bin/debugger/event_handler.cpp'
--- bin/debug_client/event_handler.cpp	2011-07-01 01:53:24 +0000
+++ bin/debugger/event_handler.cpp	2012-02-03 01:13:24 +0000
@@ -13,88 +13,93 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#include "event_handler.h"
+
+#include <sstream>
+
 #include <zorba/zorba.h>
 #include <zorba/store_manager.h>
 #include <zorba/iterator.h>
-#include <sstream>
-#include "debug_client/event_handler.h"
 
-namespace zorba { namespace debugclient {
+namespace zorba { namespace debugger {
   
-  EventHandler::EventHandler(LockFreeProducer<std::size_t>& aQueue, LockFreeProducer<bool>& aContProducer)
+EventHandler::EventHandler(LockFreeProducer<std::size_t>& aQueue, LockFreeProducer<bool>& aContProducer)
   : theIdQueue(aQueue), theContinueProducer(aContProducer),
     theStore(StoreManager::getStore()),
     theZorbaInstance(Zorba::getInstance(theStore)),
     theStaticContext(theZorbaInstance->createStaticContext())
-    
-  {
-    try {
-      Zorba_CompilerHints_t lHints;
-      lHints.opt_level = ZORBA_OPT_LEVEL_O1;
-      std::auto_ptr<std::istream> stream(getCurrentDirectory());
-      zorba::String query;
-      char buffer[1024];
-      std::string::size_type s;
-      while ((s = stream->readsome(buffer, 1024))) {
-        query.append(std::string(buffer, s));
-      }
-      theStaticContext->loadProlog(query, lHints);
-    } catch (zorba::ZorbaException& e) {
-      std::cerr << "Exception: I was not able to load the query file:" << std::endl;
-      std::cerr << e.what() << std::endl;
-      throw;
-    }
-  }
-  
-  EventHandler::~EventHandler()
-  {
-    theStaticContext = 0;
-    theZorbaInstance->shutdown();
-    StoreManager::shutdownStore(theStore);
-  }
-  
-  void EventHandler::parseMessage(const std::string &aMessage)
-  {
-    try {
-      zorba::String queryString = "local:main(";
-      queryString += aMessage + ")";
-      XQuery_t query = theZorbaInstance->compileQuery(queryString, theStaticContext);
-      Iterator_t lIter = query->iterator();
-      Item item;
-      lIter->open();
-      bool doContinue = false;
-      lIter->next(item);
-      {
-        const std::string& continueString = item.getStringValue().str();
-        if (continueString == "true") {
-          doContinue = true;
-        } else if (continueString == "false") {
-          doContinue = false;
-        } else {
-          std::stringstream stream(continueString);
-          stream >> doContinue;
-        }
-      }
-      lIter->next(item);
-      std::size_t lId;
-      {
-        std::stringstream stream(item.getStringValue().c_str());
-        stream >> lId;
-      }
-      lIter->next(item);
-      std::cout << item.getStringValue() << std::endl;
-      theContinueProducer.produce(doContinue);
-      theIdQueue.produce(lId);
-    } catch (ZorbaException& e) {
-      std::cerr << "FATAL: could not execute query: " << std::endl;
-      std::cerr << e << std::endl;
-      std::cerr << "This is a bug, please report to [e-mail]" << std::endl;
-      theContinueProducer.produce(false);
-    }
-  }
-  
-  void EventHandler::error(unsigned int errcode, const std::string &msg)
-  {
-    std::cerr << "Error " << errcode << ": " << msg << std::endl;
-  }
-}}
+{
+}
+
+EventHandler::~EventHandler()
+{
+  theStaticContext = 0;
+  theZorbaInstance->shutdown();
+  StoreManager::shutdownStore(theStore);
+}
+
+void
+EventHandler::init()
+{
+  try {
+    Zorba_CompilerHints_t lHints;
+    lHints.opt_level = ZORBA_OPT_LEVEL_O1;
+    zorba::String lProlog("import module namespace dmh = 'http://www.zorba-xquery.com/modules/debugger/dbgp-message-handler';");
+    theStaticContext->loadProlog(lProlog, lHints);
+  } catch (zorba::ZorbaException& e) {
+    std::cerr << "Exception: I was not able to load the query file:" << std::endl;
+    std::cerr << e.what() << std::endl;
+    throw;
+  }
+}
+
+void
+EventHandler::parseMessage(const std::string &aMessage)
+{
+  try {
+#ifndef NDEBUG
+    // uncomment this to see the raw messages received by the event handler
+    //std::cout << "Processing response: " << aMessage << std::endl;
+#endif
+    // the query to process the response
+    std::stringstream lQueryStream;
+    lQueryStream << "dmh:process(" << aMessage << ")";
+    XQuery_t lQuery = theZorbaInstance->compileQuery(lQueryStream.str(), theStaticContext);
+
+    // get the query result sequrence:
+    //   1. a message
+    Iterator_t lIter = lQuery->iterator();
+    Item lItem;
+    lIter->open();
+    lIter->next(lItem);
+    std::size_t lId;
+    std::stringstream lStream(lItem.getStringValue().c_str());
+    lStream >> lId;
+
+    //   2. an "idle" flag (to disable quit confirmation)
+    bool lCanQuit = false;
+    if (lIter->next(lItem)) {
+      String lMessage = lItem.getStringValue();
+      lCanQuit = lMessage == "idle";
+      std::cout << std::endl << lItem.getStringValue() << std::endl;
+    }
+    theContinueProducer.produce(lCanQuit);
+
+    // go and solve the event with this id
+    theIdQueue.produce(lId);
+  } catch (ZorbaException& e) {
+    std::cerr << "FATAL: could not execute query: " << std::endl;
+    std::cerr << e << std::endl;
+    std::cerr << "This is a bug, please report it at http://bugs.launchpad.net/zorba" << std::endl;
+  }
+}
+  
+void
+EventHandler::error(unsigned int errcode, const std::string &msg)
+{
+  std::cerr << "Error " << errcode << ": " << msg << std::endl;
+}
+
+} // namespace zorba
+} // namespace debugger

=== modified file 'bin/debugger/event_handler.h'
--- bin/debug_client/event_handler.h	2011-07-01 01:53:24 +0000
+++ bin/debugger/event_handler.h	2012-02-03 01:13:24 +0000
@@ -14,33 +14,46 @@
  * limitations under the License.
  */
 #pragma once
+#ifndef ZORBA_DEBUGGER_EVENT_HANDLER_H
+#define ZORBA_DEBUGGER_EVENT_HANDLER_H
+
 #include <string>
 #include <iostream>
+
 #include <zorba/debugger_event_handler.h>
 #include <zorba/static_context.h>
+
 #include "lock_free_queue.h"
 
-namespace zorba {
-  class Zorba;
-}
-
-namespace zorba { namespace debugclient {
-  
-  class EventHandler : public zorba::DebuggerEventHandler
-  {
+
+namespace zorba { namespace debugger {
+
+class EventHandler : public zorba::DebuggerEventHandler
+{
   public:
-    EventHandler(LockFreeProducer<std::size_t>& aQueue, LockFreeProducer<bool>& aContQueue);
+    EventHandler(
+      LockFreeProducer<std::size_t>& aQueue,
+      LockFreeProducer<bool>& aContQueue);
+
     ~EventHandler();
+
   public:
     virtual void parseMessage(const std::string& aMessage);
+
     virtual void error(unsigned int errcode, const std::string& msg);
+
+    virtual void init();
+
   private:
-    static std::istream* getCurrentDirectory();
     LockFreeProducer<std::size_t>& theIdQueue;
     LockFreeProducer<bool>& theContinueProducer;
     void* theStore;
     Zorba* theZorbaInstance;
     StaticContext_t theStaticContext;
-  };
+
+};
   
-}} // end of namespace zorba::debugclient
+} // namespace zorba
+} // namespace debugger
+
+#endif // ZORBA_DEBUGGER_EVENT_HANDLER_H

=== modified file 'bin/debugger/lock_free_queue.h'
--- bin/debug_client/lock_free_queue.h	2011-07-01 01:53:24 +0000
+++ bin/debugger/lock_free_queue.h	2012-02-03 01:13:24 +0000
@@ -14,10 +14,14 @@
  * limitations under the License.
  */
 #pragma once
+#ifndef ZORBA_DEBUGGER_LOCK_FREE_QUEUE_H
+#define ZORBA_DEBUGGER_LOCK_FREE_QUEUE_H
+
 #include <iostream>
 #include <list>
 
-namespace zorba { namespace debugclient {
+
+namespace zorba { namespace debugger {
 
 template<typename T>
 class LockFreeProducer
@@ -80,4 +84,8 @@
   }
   return false;
 }
-}} // namespace zorba::debugclient
+
+} // namespace zorba
+} // namespace debugger
+
+#endif // ZORBA_DEBUGGER_LOCK_FREE_QUEUE_H

=== modified file 'bin/debugger/main.cpp'
--- bin/debug_client/main.cpp	2011-07-01 01:53:24 +0000
+++ bin/debugger/main.cpp	2012-02-03 01:13:24 +0000
@@ -13,12 +13,286 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#ifdef WIN32
+# include <windows.h>
+# include <string.h>
+# include <strsafe.h>
+#endif
+
+#include <vector>
+
 #include <zorba/config.h>
-#include "debug_command.h"
-#include "command_line_handler.h"
+
+#include "xqdb_client.h"
+#include "process_listener.h"
+
 
 using namespace zorba;
-using namespace zorba::debugclient;
+using namespace zorba::debugger;
+
+
+std::auto_ptr<XqdbClient> theClient;
+
+// this will make sure the xqdb process will not quit when Ctrl-C is pressed
+#ifdef WIN32
+BOOL WINAPI
+ctrlC_Handler(DWORD aCtrlType)
+{
+  if (CTRL_C_EVENT == aCtrlType) {
+    return true;
+  }
+  return false;
+}
+#else
+void
+ctrlC_Handler(int lParam)
+{
+  // an empty sugnal handler on Linux should do the job
+}
+#endif
+
+
+// this handler function is passed the the zorba process listener and will
+// the client if the zorba process terminates
+void
+onExitProcess(ExitCode aExitCode) {
+  std::cout << std::endl << "Terminating debugger client." << std::endl;
+
+#ifndef WIN32
+  XqdbClient* lClient = theClient.release();
+  if (lClient) {
+    delete lClient;
+  }
+#endif
+
+  exit(aExitCode);
+}
+
+
+int
+startZorba(std::string& aExec, std::vector<std::string>& aArgs, std::auto_ptr<ProcessListener>& aProcessListener) 
+{
+#ifdef WIN32
+  // **************************
+  // start a process on Windows
+
+  DWORD iReturnVal = 0;
+
+  std::wstring lExec;
+  std::wstring lArgs;
+
+  lExec.assign(aExec.begin(), aExec.end());
+
+  // the executable must be the first in the list of arguments
+  lArgs.append(L"\"");
+  lArgs.append(lExec);
+  lArgs.append(L"\"");
+
+  for (std::vector<std::string>::size_type j = 0; j < aArgs.size(); j++) {
+    std::string lArg(aArgs.at(j));
+    std::wstring lArgW;
+    lArgW.assign(lArg.begin(), lArg.end());
+    lArgs.append(L" ");
+    lArgs.append(lArgW);
+  }
+
+  // CreateProcessW can modify Parameters thus we allocate needed memory
+  wchar_t * pwszParam = new wchar_t[lArgs.size() + 1];
+  if (pwszParam == 0) {
+    return 1;
+  }
+  const wchar_t* pchrTemp = lArgs.c_str();
+  wcscpy_s(pwszParam, lArgs.size() + 1, pchrTemp); 
+
+  // CreateProcess API initialization
+  STARTUPINFOW siStartupInfo;
+  PROCESS_INFORMATION piProcessInfo;
+  memset(&siStartupInfo, 0, sizeof(siStartupInfo));
+  memset(&piProcessInfo, 0, sizeof(piProcessInfo));
+  siStartupInfo.cb = sizeof(siStartupInfo);
+
+  BOOL lResult = CreateProcessW(
+    const_cast<LPCWSTR>(lExec.c_str()),
+    pwszParam, 0, 0, false,
+    CREATE_DEFAULT_ERROR_MODE, 0, 0,
+    &siStartupInfo, &piProcessInfo);
+
+  if (lResult) {
+    // Watch the process
+    aProcessListener.reset(new ProcessListener(piProcessInfo.dwProcessId, &onExitProcess));
+  }
+  else {
+    // CreateProcess failed
+    iReturnVal = GetLastError();
+    LPVOID lpMsgBuf;
+    LPVOID lpDisplayBuf;
+
+    FormatMessage(
+      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+      NULL,
+      iReturnVal,
+      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+      (LPTSTR) &lpMsgBuf,
+      0, NULL);
+
+    // Display the error message and exit the process
+
+    lpDisplayBuf = (LPVOID)LocalAlloc(
+      LMEM_ZEROINIT,
+      (lstrlen((LPCTSTR)lpMsgBuf) + 40) * sizeof(TCHAR));
+
+    StringCchPrintf(
+      (LPTSTR)lpDisplayBuf,
+      LocalSize(lpDisplayBuf) / sizeof(TCHAR),
+      TEXT("Error (%d) when starting zorba: %s"),
+      iReturnVal,
+      lpMsgBuf);
+
+    std::wstring lErrorW((wchar_t*)lpDisplayBuf);
+    std::string lError;
+    lError.assign(lErrorW.begin(), lErrorW.end());
+    std::cout << lError << std::endl;
+
+    LocalFree(lpMsgBuf);
+    LocalFree(lpDisplayBuf);
+  }
+
+  // Free memory
+  delete[]pwszParam;
+  pwszParam = 0;
+
+  // Release handles
+  CloseHandle(piProcessInfo.hProcess);
+  CloseHandle(piProcessInfo.hThread);
+
+  return iReturnVal; 
+
+#else
+  // ************************
+  // start a process on Linux
+
+  pid_t pID = fork();
+  if (pID == 0) {
+    // Code only executed by child process
+    std::stringstream lCommand;
+    lCommand << aExec;
+    for (std::vector<std::string>::size_type j = 0; j < aArgs.size(); j++) {
+      lCommand << " " << aArgs.at(j);
+    }
+
+    int lRes = system(lCommand.str().c_str());
+    exit(lRes);
+  }
+  else {
+    // Code only executed by parent process
+    if (pID < 0) {
+      std::cerr << "Failed to fork Zorba" << std::endl;
+      return pID;
+    }
+    
+    // Watch the process
+    aProcessListener.reset(new ProcessListener(pID, &onExitProcess));
+
+    return 0;
+  }
+#endif
+}
+
+void printUsage(std::string& aProgram)
+{
+  std::cerr << "Usage:" << std::endl
+    << "    " << aProgram << " <zorba_arguments>" << std::endl
+    << "        this will start a debugger command line and a zorba process with the given arguments" << std::endl;
+}
+
+bool
+processArguments(
+  int argc,
+  char* argv[],
+  std::string& aProgram,
+  bool& aStandalone,
+  std::string& aZorba,
+  unsigned int& aPort,
+  std::vector<std::string>& aZorbaArgs)
+{
+  aPort = 28028;
+
+  // find the path to Zorba and this executable name
+  aProgram = argv[0];
+
+#ifdef WIN32
+  char lSep = '\\';
+#else
+  char lSep = '/';
+#endif
+  std::string::size_type lPos = aProgram.find_last_of(lSep);
+
+  std::stringstream lZs;
+
+  if (lPos == aProgram.npos) {
+    lZs << "." << lSep;
+  } else {
+    lZs << aProgram.substr(0, lPos + 1);
+    aProgram = aProgram.substr(lPos + 1);
+  }
+  lZs << "zorba";
+#ifdef WIN32
+  lZs << ".exe";
+#endif
+  aZorba = lZs.str();
+
+
+  bool lHasFileArg = false;
+  bool lHasQueryArg = false;
+  bool lHasQueryVal = false;
+
+  // find if the user asked for help or specified a specific port
+  for (int i = 1; i < argc; i++) {
+    std::string lArg = argv[i];
+    if (lArg == "-h" || lArg == "--help") {
+      return false;
+    }
+    else if (lArg == "-p" || lArg == "--debug-port") {
+      // if there is one more argument
+      if (i < argc - 1) {
+        // get the port value
+        int lPort;
+        std::stringstream lStream(argv[i + 1]);
+        lStream >> lPort;
+        if (!lStream.fail()) {
+          aPort = lPort;
+        }
+      }
+    }
+    else if (lArg == "-f") {
+      lHasFileArg = true;
+    }
+    else if (lArg == "-q") {
+      lHasQueryArg = true;
+      if (++i < argc) {
+        lHasQueryVal = true;
+      }
+    }
+  }
+
+  if (!lHasFileArg || !lHasQueryArg || !lHasQueryVal) {
+    std::cout << "Not enough arguments to start Zorba." << std::endl;
+    std::cout << "Running the standalone XQuery debugger client on port: " << aPort << std::endl;
+    return true;
+  }
+
+  // zorba will need the -d flag
+  aZorbaArgs.push_back("-d");
+
+  // gather all arguments (excepting the program name)
+  for (int i = 1; i < argc; i++) {
+    aZorbaArgs.push_back(argv[i]);
+  }
+
+  aStandalone = false;
+  return true;
+}
 
 #ifndef _WIN32_WCE
 int
@@ -28,24 +302,72 @@
 _tmain(int argc, _TCHAR* argv[])
 #endif
 {
-  int port = 28028;
-  if (argv[1]) {
-    std::stringstream stream(argv[1]);
-    stream >> port;
-    if (stream.fail() || argv[2]) {
-      std::cerr << "Unknown argument. USAGE: " << argv[0] << " [PORT]" << std::endl;
-      return 2;
+#ifdef WIN32
+  SetConsoleCtrlHandler(ctrlC_Handler, TRUE);
+#else
+  signal(SIGINT, ctrlC_Handler);
+#endif
+
+  // **************************************************************************
+  // processing arguments
+
+  std::string lProgram, lZorbaExec;
+  unsigned int lPort = 28028;
+  std::vector<std::string> lZorbaArgs;
+
+  bool lStandalone = true;
+  if (!processArguments(argc, argv, lProgram, lStandalone, lZorbaExec, lPort, lZorbaArgs)) {
+    printUsage(lProgram);
+    return 1;
+  }
+
+#ifndef NDEBUG
+  // **************************************************************************
+  // debug reporting
+
+  if (!lStandalone) {
+    std::cout << "Communication port: " << lPort << std::endl;
+    std::cout << "Zorba executable:   " << lZorbaExec << std::endl;
+    std::cout << "Zorba arguments:    ";
+    for (std::vector<std::string>::size_type j = 0; j < lZorbaArgs.size(); j++) {
+      std::cout << lZorbaArgs.at(j) << " ";
     }
+    std::cout << std::endl;
   }
+#endif
+
   try {
-    LockFreeQueue<std::size_t> lQueue;
-    LockFreeQueue<bool> lContEvent;
-    EventHandler lHandler(lQueue, lContEvent);
-    CommandLine cli;
-    CommandLineHandler handler(port, lQueue, lContEvent, lHandler, cli);
-    handler.execute();
+    // **************************************************************************
+    // start a zorba
+
+    // This is a process listener used to watch the Zorba process termination.
+    std::auto_ptr<ProcessListener> lProcessListener;
+
+    if (!lStandalone) {
+      int lResult = startZorba(lZorbaExec, lZorbaArgs, lProcessListener);
+      if (lResult) {
+        return lResult;
+      }
+    } else {
+      std::cout << "Listening for an incomming Zorba connection on port " << lPort << "..." << std::endl;
+    }
+
+    // **************************************************************************
+    // start the debugger command line
+
+    theClient.reset(new XqdbClient(lPort));
+    theClient->start();
+
   } catch (...) {
-    return 4;
-  }
+    return -1;
+  }
+
+#ifndef WIN32
+  XqdbClient* lClient = theClient.release();
+  if (lClient) {
+    delete lClient;
+  }
+#endif
+
   return 0;
 }

=== added file 'bin/debugger/process_listener.cpp'
--- bin/debugger/process_listener.cpp	1970-01-01 00:00:00 +0000
+++ bin/debugger/process_listener.cpp	2012-02-03 01:13:24 +0000
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "process_listener.h"
+
+#include <iostream>
+
+#ifdef ZORBA_HAVE_PTHREAD_H
+# include <cassert>
+#endif
+
+
+namespace zorba { namespace debugger {
+  
+ProcessListener::ProcessListener(ProcessId aProcessID, ExitCallbackType aCallback)
+  : theProcessID(aProcessID), theCallback(aCallback)
+{
+#ifdef WIN32
+  theThread = CreateThread(NULL, 0, &run, (void*) this, 0, &theThreadId);
+#else
+  if (pthread_create(&theThread, NULL, &run, (void*) this)) {
+    assert(false);
+  }
+#endif
+}
+
+ProcessListener::~ProcessListener()
+{
+}
+
+ProcessId
+ProcessListener::getProcessID()
+{
+  return theProcessID;
+}
+
+ExitCallbackType
+ProcessListener::getCallback()
+{
+  return theCallback;
+}
+
+
+ZORBA_THREAD_RETURN
+ProcessListener::run(void* params)
+{
+  ProcessListener* lThis = static_cast<ProcessListener*>(params);
+  ExitCode lExitCode = -1;
+  ProcessId lPid = lThis->getProcessID();
+
+#ifdef WIN32
+  HANDLE lProcessHandle = OpenProcess(SYNCHRONIZE, false, lPid);
+  if (lProcessHandle != NULL) {
+    // wait for the process to exit
+    DWORD lResult = WaitForSingleObject(lProcessHandle, INFINITE);
+ 
+    // find out the process exit code if possible
+    if (!GetExitCodeProcess(lProcessHandle, &lExitCode)) {
+      lExitCode = -1;
+    }
+    DWORD dw = GetLastError();
+ 
+    // wait a little for zorba to dump the garbage
+    Sleep(1000);
+  }
+#else
+  int lChildExitStatus;
+
+  // wait for the process to exit
+  waitpid(lPid, &lChildExitStatus, 0);
+
+  // find out the process exit code if possible
+  if (WIFEXITED(lChildExitStatus)) {
+    lExitCode = WEXITSTATUS(lChildExitStatus);
+  }
+
+  // wait a little for zorba to dump the garbage
+  sleep(1);
+#endif
+
+  // and call the callback when this happened
+  ExitCallbackType lCallback = lThis->getCallback();
+  lCallback(lExitCode);
+
+  for (int i = 0; i < 10; i++) {
+    std::cout << i << std::endl;
+  }
+  return NULL;
+}
+
+} // namespace zorba
+} // namespace debugger

=== added file 'bin/debugger/process_listener.h'
--- bin/debugger/process_listener.h	1970-01-01 00:00:00 +0000
+++ bin/debugger/process_listener.h	2012-02-03 01:13:24 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#ifndef ZORBA_DEBUGGER_PROCESS_LISTENER_H
+#define ZORBA_DEBUGGER_PROCESS_LISTENER_H
+
+#include <zorba/config.h>
+
+#ifdef ZORBA_HAVE_PTHREAD_H
+# include <pthread.h>
+# include <sys/wait.h>
+  typedef pthread_t ThreadId;
+  typedef pid_t ProcessId;
+  typedef int ExitCode;
+# define ZORBA_THREAD_RETURN void *
+#else
+# include <windows.h>
+  typedef DWORD ThreadId;
+  typedef DWORD ProcessId;
+  typedef DWORD ExitCode;
+# define ZORBA_THREAD_RETURN DWORD WINAPI
+#endif
+
+typedef void (*ExitCallbackType)(ExitCode);
+
+
+namespace zorba { namespace debugger {
+
+class ProcessListener
+{
+  public:
+    ProcessListener(ProcessId processID, ExitCallbackType callback);
+
+    ~ProcessListener();
+
+    ProcessId
+    getProcessID();
+
+    ExitCallbackType
+    getCallback();
+
+  private:
+
+    static ZORBA_THREAD_RETURN run(void* params);
+
+  private:
+
+#ifdef ZORBA_HAVE_PTHREAD_H
+    pthread_t         theThread;
+#else
+    ThreadId          theThreadId;
+    HANDLE            theThread;
+#endif
+
+    ProcessId         theProcessID;
+    ExitCallbackType  theCallback;
+};
+  
+} // namespace zorba
+} // namespace debugger
+
+#endif // ZORBA_DEBUGGER_PROCESS_LISTENER_H

=== modified file 'bin/debugger/tuple.h'
--- bin/debug_client/tuple.h	2011-07-04 08:05:46 +0000
+++ bin/debugger/tuple.h	2012-02-03 01:13:24 +0000
@@ -14,9 +14,15 @@
  * limitations under the License.
  */
 #pragma once
+#ifndef ZORBA_DEBUGGER_TUPLE_H
+#define ZORBA_DEBUGGER_TUPLE_H
+
 #include <zorba/config.h>
+
 #if ZORBA_TR1_IN_TR1_SUBDIRECTORY
 # include <tr1/tuple>
 #else
 # include <tuple>
 #endif
+
+#endif // ZORBA_DEBUGGER_TUPLE_H

=== added file 'bin/debugger/xqdb_client.cpp'
--- bin/debugger/xqdb_client.cpp	1970-01-01 00:00:00 +0000
+++ bin/debugger/xqdb_client.cpp	2012-02-03 01:13:24 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "xqdb_client.h"
+
+#include <iostream>
+
+#ifdef ZORBA_HAVE_PTHREAD_H
+# include <cassert>
+#endif
+
+
+namespace zorba { namespace debugger {
+
+XqdbClient::XqdbClient(unsigned int aPort)
+{
+  theIdQueue = new LockFreeQueue<std::size_t>();
+  theQuitQueue = new LockFreeQueue<bool>();
+  theEventHandler = new EventHandler(*theIdQueue, *theQuitQueue);
+  theEventHandler->init();
+
+  theCommandPrompt = new CommandPrompt();
+  theCommandLineHandler = new CommandLineHandler(aPort, *theIdQueue, *theQuitQueue, theEventHandler, theCommandPrompt);
+}
+
+XqdbClient::~XqdbClient()
+{
+  if (theCommandLineHandler) {
+    delete theCommandLineHandler;
+  }
+  if (theCommandPrompt) {
+    delete theCommandPrompt;
+  }
+  if (theEventHandler) {
+    delete theEventHandler;
+  }
+
+  delete theIdQueue;
+  delete theQuitQueue;
+}
+
+void
+XqdbClient::start()
+{
+  theCommandLineHandler->execute();
+}
+
+
+} // namespace zorba
+} // namespace debugger

=== added file 'bin/debugger/xqdb_client.h'
--- bin/debugger/xqdb_client.h	1970-01-01 00:00:00 +0000
+++ bin/debugger/xqdb_client.h	2012-02-03 01:13:24 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#ifndef ZORBA_DEBUGGER_XQDB_CLIENT_H
+#define ZORBA_DEBUGGER_XQDB_CLIENT_H
+
+#include "command_prompt.h"
+#include "command_line_handler.h"
+
+
+namespace zorba { namespace debugger {
+
+class XqdbClient {
+
+  public:
+
+    XqdbClient(unsigned int aPort);
+
+    ~XqdbClient();
+
+    void
+    start();
+
+  private:
+
+    LockFreeQueue<std::size_t>* theIdQueue;
+    LockFreeQueue<bool>*        theQuitQueue;
+
+    EventHandler*       theEventHandler;
+    CommandPrompt*      theCommandPrompt;
+    CommandLineHandler* theCommandLineHandler;
+};
+
+  
+} // namespace zorba
+} // namespace debugger
+
+#endif // ZORBA_DEBUGGER_XQDB_CLIENT_H

=== renamed file 'bin/module_path.cpp' => 'bin/path_util.cpp'
--- bin/module_path.cpp	2011-05-25 16:40:26 +0000
+++ bin/path_util.cpp	2012-02-03 01:13:24 +0000
@@ -14,85 +14,100 @@
  * limitations under the License.
  */
 
-#include "module_path.h"
+#include "path_util.h"
 
 #include <stdlib.h>
-#include "zorba/zorba_string.h"
+//#include "zorba/zorba_string.h"
 #include "zorba/util/path.h"
 
 #include "util.h"
 #include "zorbacmdproperties.h"
+#include <zorba/static_context.h>
 
 namespace zorba {
 
-std::string
-ModulePath::getEnvironmentModulePath()
+namespace PathUtil {
+
+static std::string
+getPathFromEnvironment(std::string const& aEnvVar)
 {
-  std::string lEnvName("ZORBA_MODULE_PATH");
 #ifdef WIN32
   char* lBuffer;
   size_t lLen=0;
-  errno_t lErr = getenv_s(&lLen, NULL, 0, lEnvName.c_str());
+  errno_t lErr = getenv_s(&lLen, NULL, 0, aEnvVar.c_str());
   if (lErr || !lLen) return "";
   lBuffer = (char*)malloc(lLen * sizeof(char));
   if (!lBuffer) return "";
-  getenv_s(&lLen, lBuffer, lLen, lEnvName.c_str());
+  getenv_s(&lLen, lBuffer, lLen, aEnvVar.c_str());
   std::string lRes(lBuffer);
   free(lBuffer);
   return lRes;
 #else
-  const char* lEnvValue = getenv(lEnvName.c_str());
-  return lEnvValue!=0?lEnvValue:"";
+  const char* lEnvValue = getenv(aEnvVar.c_str());
+  return lEnvValue != 0 ? lEnvValue : "";
 #endif
 }
 
-void
-ModulePath::convertVector(
-  const std::vector<std::string>& aSource,
-  std::vector<String>&            aDest)
-{
-  for (std::vector<std::string>::const_iterator lIter = aSource.begin();
-       lIter != aSource.end(); ++lIter) {
-    aDest.push_back(*lIter);
-  } 
-}
 
-void
-ModulePath::tokenizeModulePath(
-  const std::string&        aModulePath,
-  std::vector<std::string>& aResult)
+static void
+tokenizePath(
+  const std::string&    aPathStr,
+  std::vector<String>&  aResult)
 {
+  std::vector<std::string> lPath;
 #ifdef WIN32
-  Util::tokenize(aModulePath, ";", aResult);
+  Util::tokenize(aPathStr, ";", lPath);
 #else
-  Util::tokenize(aModulePath, ":", aResult);
+  Util::tokenize(aPathStr, ":", lPath);
 #endif
+  for (std::vector<std::string>::iterator lIter = lPath.begin();
+       lIter != lPath.end(); ++lIter) {
+    aResult.push_back(*lIter);
+  }
 }
 
 void
-ModulePath::getModulePaths(
+setPathsOnContext(
   const ZorbaCMDProperties& aProperties,
-  std::vector<String>&      aModulePaths)
+  StaticContext_t& aStaticCtx)
 {
-  std::vector<std::string> lModulePaths; // result vector
-  std::string lModulePath; // temporary variable for collections paths
-
-  // 1. add the module paths from the command line properties
-  aProperties.getModulePaths(lModulePath);
-
-  tokenizeModulePath(lModulePath, lModulePaths);
-
-  // 2. add the module paths from the environment
-  lModulePath = ModulePath::getEnvironmentModulePath();
-
-  tokenizeModulePath(lModulePath, lModulePaths);
-
-  // 3. add the current working directory as module path
+  std::vector<String> lPath;
+  std::string lPathStr, lEnvStr;
+
+  // Compute the current working directory to append to all paths.
   filesystem_path lCWD;
-  lModulePaths.push_back(lCWD.get_path());
-
-  // convert std::string to zorba::String
-  convertVector(lModulePaths, aModulePaths);
+
+  // setModulePaths() *overwrites* the URI path and lib path, so there's no
+  // sense in calling both. So if either --module-path or ZORBA_MODULE_PATH
+  // exists, just use those.
+  aProperties.getModulePath(lPathStr);
+  lEnvStr = getPathFromEnvironment("ZORBA_MODULE_PATH");
+  if (lPathStr.length() > 0 || lEnvStr.length() > 0) {
+    tokenizePath(lPathStr, lPath);
+    tokenizePath(lEnvStr, lPath);
+    lPath.push_back(lCWD.get_path());
+    aStaticCtx->setModulePaths(lPath);
+  }
+  else {
+    // Compute and set URI path
+    aProperties.getURIPath(lPathStr);
+    tokenizePath(lPathStr, lPath);
+    lEnvStr = getPathFromEnvironment("ZORBA_URI_PATH");
+    tokenizePath(lEnvStr, lPath);
+    lPath.push_back(lCWD.get_path());
+    aStaticCtx->setURIPath(lPath);
+    lPath.clear();
+
+    // Compute and set lib path
+    aProperties.getLibPath(lPathStr);
+    tokenizePath(lPathStr, lPath);
+    lEnvStr = getPathFromEnvironment("ZORBA_LIB_PATH");
+    lPath.push_back(lCWD.get_path());
+    tokenizePath(lEnvStr, lPath);
+    aStaticCtx->setLibPath(lPath);
+  }
 }
 
+} /* namespace ModulePath */
+
 } /* namespace zorba */

=== renamed file 'bin/module_path.h' => 'bin/path_util.h'
--- bin/module_path.h	2010-02-12 08:57:04 +0000
+++ bin/path_util.h	2012-02-03 01:13:24 +0000
@@ -18,6 +18,7 @@
 
 #include <vector>
 #include <string>
+#include <zorba/api_shared_types.h>
 
 class ZorbaCMDProperties;
 
@@ -25,30 +26,14 @@
 
   class String;
 
-  class ModulePath {
-  protected:
-    static std::string
-    getEnvironmentModulePath();
-
-    static void
-    convertVector(const std::vector<std::string>& aSource,
-                  std::vector<String>& aDest); 
-
-    static void
-    tokenizeModulePath(const std::string& aModulePath,
-                       std::vector<std::string>& aResult);
-
-    static void
-    getInstalledModulePath(const std::string& aModulePath,
-                       std::vector<std::string>& aResult);
-
-  public:
-    static void
-    getModulePaths(const ZorbaCMDProperties& aProperties,
-                   std::vector<String>& aModulePaths);
-
-
-  };
+  namespace PathUtil {
+
+    void
+    setPathsOnContext(const ZorbaCMDProperties& aProperties,
+                      zorba::StaticContext_t& aStaticCtx);
+
+
+  }
 } /* namespace zorba */
 
 #endif

=== modified file 'bin/zorbacmd.cpp'
--- bin/zorbacmd.cpp	2011-07-11 11:12:23 +0000
+++ bin/zorbacmd.cpp	2012-02-03 01:13:24 +0000
@@ -43,7 +43,7 @@
 
 #include "error_printer.h"
 #include "util.h"
-#include "module_path.h"
+#include "path_util.h"
 
 // For setting the base URI from the current directory
 #include <zorba/util/path.h>
@@ -70,7 +70,7 @@
 
 #ifndef ZORBA_NO_FULL_TEXT
 OneToOneURIMapper theStopWordsMapper(EntityData::STOP_WORDS);
-OneToOneURIMapper theThesaurusMapper(EntityData::THESAURUS, URIMapper::COMPONENT);
+OneToOneURIMapper theThesaurusMapper(EntityData::THESAURUS);
 #endif
 
 bool
@@ -85,10 +85,8 @@
     // 2. environment ZORBA_MODULE_PATH
     // 3. current working directory
     {
-      std::vector<String> lModulePaths;
-      ModulePath::getModulePaths(aProperties, lModulePaths);
-
-      aStaticContext->setModulePaths(lModulePaths);
+      std::vector<String> lModulePath;
+      PathUtil::setPathsOnContext(aProperties, aStaticContext);
     }
 
     if (aProperties.boundarySpace().size() != 0 )
@@ -509,12 +507,24 @@
   Zorba_CompilerHints lHints;
 
   // default is O1 in the Zorba_CompilerHints constructor
-  if (properties.optimizationLevel() == "O0") {
+  if (properties.optimizationLevel() == "O0") 
+  {
     lHints.opt_level = ZORBA_OPT_LEVEL_O0;
-  } else if (properties.optimizationLevel() == "O2") {
+  }
+  else if (properties.optimizationLevel() == "O2") 
+  {
     lHints.opt_level = ZORBA_OPT_LEVEL_O2;
   }
 
+  lHints.for_serialization_only = true;
+
+#if ZORBACMD_LOAD_SYSTEM_PROPERTIES
+  if (Properties::instance()->serializeOnlyQuery() == 0)
+  {
+    lHints.for_serialization_only = false;
+  }
+#endif
+
   // default is false
   if (properties.libModule())
   {
@@ -577,8 +587,6 @@
         return 12;
       }
 
-      // if (diagnosticHandler.
-
       //
       // Create and populate the dynamic context
       //
@@ -661,19 +669,22 @@
       XmlDataManager* store = zorbaInstance->getXmlDataManager();
 
       timing.startTimer(TimingInfo::UNLOAD_TIMER, i);
+
       DocumentManager* lMgr = store->getDocumentManager();
       ItemSequence_t lSeq = lMgr->availableDocuments();
       Iterator_t lIter = lSeq->getIterator();
       lIter->open();
       Item lURI;
-      while (lIter->next(lURI)) {
+      while (lIter->next(lURI)) 
+      {
         lMgr->remove(lURI.getStringValue());
       }
+
       timing.stopTimer(TimingInfo::UNLOAD_TIMER, i);
 
       timing.stopTimer(TimingInfo::TOTAL_TIMER, i);
     }
-  }
+  } // for each execution
 
   return 0;
 }
@@ -704,7 +715,7 @@
     return 1;
   }
 
-  TimingInfo timing(lProperties.multiple());
+  TimingInfo engineTiming(lProperties.multiple());
 
   bool doTiming = lProperties.timing();
   bool debug = false;
@@ -741,14 +752,14 @@
 
   // Start the engine
 
-  timing.startTimer(TimingInfo::INIT_TIMER, 2);
+  engineTiming.startTimer(TimingInfo::INIT_TIMER, 2);
 
   void* store = zorba::StoreManager::getStore();
 
   zorba::Zorba* lZorbaInstance = zorba::Zorba::getInstance(store);
 
   {
-  timing.stopTimer(TimingInfo::INIT_TIMER, 2);
+  engineTiming.stopTimer(TimingInfo::INIT_TIMER, 2);
 
   // For each query ...
 
@@ -770,14 +781,14 @@
     if (asFile)
     {
       path.resolve_relative ();
-      qfile.reset (new std::ifstream (path.c_str ()));
+      qfile.reset(new std::ifstream (path.c_str ()));
     }
     else
     {
-      qfile.reset (new std::istringstream(fURI));
+      qfile.reset(new std::istringstream(fURI));
     }
 
-    if ( asFile && (!qfile->good() || qfile->eof()) )
+    if (asFile && (!qfile->good() || qfile->eof()))
     {
       std::cerr << "file {" << fname << "} not found or not readable." << std::endl;
       lProperties.printHelp(std::cout);
@@ -793,7 +804,8 @@
     //
     // Print the query if requested
     //
-    if (lProperties.printQuery()) {
+    if (lProperties.printQuery()) 
+    {
       *lOutputStream << "\nQuery number " << queryNo << " :\n";
       std::copy (std::istreambuf_iterator<char> (*qfile),
                  std::istreambuf_iterator<char> (),
@@ -836,8 +848,10 @@
     }
 
     // Parse the query
-    if (lProperties.parseOnly()) {
-      try {
+    if (lProperties.parseOnly()) 
+    {
+      try 
+      {
         zorba::XQuery_t lQuery = lZorbaInstance->createQuery();
         if (asFile) {
           lQuery->setFileName(path.get_path());
@@ -845,7 +859,8 @@
 
         lQuery->parse (*qfile);
       }
-      catch (zorba::ZorbaException const& ze) {
+      catch (zorba::ZorbaException const& ze) 
+      {
         std::cerr << ze << std::endl;
         return 6;
       }
@@ -853,30 +868,44 @@
 
     // Compile and run it if necessary.
     // Print timing information if requested.
-    else if (!debug) {
-      if (compileOnly) {
-        try {
+    else if (!debug) 
+    {
+      if (compileOnly) 
+      {
+        try 
+        {
           zorba::XQuery_t aQuery = lZorbaInstance->createQuery();
-          if (asFile) {
+          if (asFile) 
+          {
             aQuery->setFileName(path.get_path());
           }
+
           aQuery->parse(*qfile);
+
           qfile->clear();
           qfile->seekg(0); // go back to the beginning
-        } catch (zorba::XQueryException const& qe) {
-          ErrorPrinter::print(qe, std::cerr, lProperties.printErrorsAsXml(), lProperties.indent());
+        }
+        catch (zorba::XQueryException const& qe)
+        {
+          ErrorPrinter::print(qe,
+                              std::cerr,
+                              lProperties.printErrorsAsXml(),
+                              lProperties.indent());
           return 6;
         }
       }
 
+      TimingInfo queryTiming(lProperties.multiple());
+
       int status = compileAndExecute(lZorbaInstance,
                                      lProperties,
                                      lStaticContext,
                                      path.get_path(),
                                      *qfile,
                                      *lOutputStream,
-                                     timing);
-      if (status != 0) {
+                                     queryTiming);
+      if (status != 0) 
+      {
         // reset the file handler (in case output option was provided)
         // in order to delete the created output file
         lFileStream.reset();
@@ -884,21 +913,25 @@
         return status;
       }
 
-      if (doTiming) {
-        timing.print(std::cout);
+      if (doTiming) 
+      {
+        queryTiming.print(std::cout);
       }
     }
 
 #ifdef ZORBA_WITH_DEBUGGER
     // Debug the query. Do not allow "compileOnly" flags and inline queries
-    else if (debug) {
-      if (compileOnly) {
+    else if (debug) 
+    {
+      if (compileOnly) 
+      {
         std::cerr << "cannot debug a query if the compileOnly option is specified"
                   << std::endl;
         return 7;
       }
 
-      if (!asFile) {
+      if (!asFile) 
+      {
         std::cerr << "Cannot debug inline queries." << std::endl;
         return 8;
       }
@@ -908,7 +941,8 @@
 
       zorba::XQuery_t lQuery;
 
-      try {
+      try 
+      {
         lQuery = lZorbaInstance->createQuery();
         lQuery->setFileName(lFileName);
         lQuery->setDebugMode(true);
@@ -927,21 +961,24 @@
           lHost = "127.0.0.1";
         }
 
-        if (lProperties.debug()) {
-          Zorba_SerializerOptions lSerOptions =
-              Zorba_SerializerOptions::SerializerOptionsFromStringParams(
-              lProperties.getSerializerParameters());
-          createSerializerOptions(lSerOptions, lProperties);
+        Zorba_SerializerOptions lSerOptions =
+            Zorba_SerializerOptions::SerializerOptionsFromStringParams(
+            lProperties.getSerializerParameters());
+        createSerializerOptions(lSerOptions, lProperties);
 
-          if (!lProperties.hasNoLogo() && !lProperties.debug()) {
-            std::cout << "Zorba XQuery Debugger Server\n" << copyright_str << std::endl;
-          }
-          lQuery->debug(*lOutputStream, lSerOptions, lHost, lProperties.getDebugPort());
+        if (!lProperties.hasNoLogo()) 
+        {
+          std::cout << "Zorba XQuery Debugger Server\n" << copyright_str << std::endl;
         }
+
+        lQuery->debug(*lOutputStream, lSerOptions, lHost, lProperties.getDebugPort());
       }
       catch (zorba::XQueryException const& qe)
       {
-        ErrorPrinter::print(qe, std::cerr, lProperties.printErrorsAsXml(), lProperties.indent());
+        ErrorPrinter::print(qe,
+                            std::cerr,
+                            lProperties.printErrorsAsXml(),
+                            lProperties.indent());
         return 5;
       }
       catch (zorba::ZorbaException const& ze)
@@ -958,7 +995,7 @@
 
   if (doTiming)
   {
-    timing.startTimer(TimingInfo::DEINIT_TIMER, 2);
+    engineTiming.startTimer(TimingInfo::DEINIT_TIMER, 2);
   }
 
   lZorbaInstance->shutdown();
@@ -966,11 +1003,11 @@
 
   if (doTiming)
   {
-    timing.stopTimer(TimingInfo::DEINIT_TIMER, 2);
+    engineTiming.stopTimer(TimingInfo::DEINIT_TIMER, 2);
 
     std::cout << std::endl << "Engine Shutdown Time     : "
-              << timing.elapsedDeinitWalltime
-              << " (user: " << timing.elapsedDeinitCputime << ")"
+              << engineTiming.elapsedDeinitWalltime
+              << " (user: " << engineTiming.elapsedDeinitCputime << ")"
               << " milliseconds" << std::endl;
   }
   return 0;

=== modified file 'bin/zorbacmdproperties.cpp'
--- bin/zorbacmdproperties.cpp	2011-07-21 19:21:25 +0000
+++ bin/zorbacmdproperties.cpp	2012-02-03 01:13:24 +0000
@@ -166,11 +166,20 @@
 }
 
 
-void ZorbaCMDProperties::getModulePaths(std::string& aPaths) const
-{
-  aPaths = theModulePath;
-}
-
+void ZorbaCMDProperties::getModulePath(std::string& aPath) const
+{
+  aPath = theModulePath;
+}
+
+void ZorbaCMDProperties::getURIPath(std::string& aPath) const
+{
+  aPath = theUriPath;
+}
+
+void ZorbaCMDProperties::getLibPath(std::string& aPath) const
+{
+  aPath = theLibPath;
+}
 
 std::vector<std::pair<std::string,std::string> > ZorbaCMDProperties::getSerializerParameters() const
 {

=== modified file 'bin/zorbacmdproperties.h'
--- bin/zorbacmdproperties.h	2011-06-29 17:25:50 +0000
+++ bin/zorbacmdproperties.h	2012-02-03 01:13:24 +0000
@@ -84,8 +84,14 @@
   getSerializerParameters() const;
 
   void
-  getModulePaths(std::string&) const;
+  getModulePath(std::string&) const;
   
+  void
+  getURIPath(std::string&) const;
+
+  void
+  getLibPath(std::string&) const;
+
   bool isDebug(){ return theDebug; }
 
   bool hasNoLogo(){ return theNoLogo; }

=== modified file 'bin/zorbacmdproperties.txt'
--- bin/zorbacmdproperties.txt	2011-07-04 08:31:01 +0000
+++ bin/zorbacmdproperties.txt	2012-02-03 01:13:24 +0000
@@ -28,7 +28,9 @@
 ("debug-port,p", po::value<unsigned int>()->default_value (28028), "The port on which the DBGP-enabled debugger client listens for connections. Defaults to: 28028")
 ("no-logo", "Print no logo when starting.")
 ("timeout", po::value<long>()->default_value(-1), "Specify a timeout in seconds. After the specified time, the execution of the query will be aborted.")
-("module-path", po::value<std::string>(), "Module paths added to the built-in resolver, i.e. where module imports are looking for modules.")
+("uri-path", po::value<std::string>(), "URI path (list of directories) added to the built-in URI resolver, i.e. where to find modules/schemas to import.")
+("lib-path", po::value<std::string>(), "Library path (list of directories) where Zorba will look for dynamic libraries (e.g., module external function implementations.")
+("module-path", po::value<std::string>(), "Path (list of directories) to add to both the URI and Library paths.")
 ("option", po::value<std::vector<std::string> >(), "Set an XQuery option in the static context. The QName of the option is passed as a string in the notation by James Clark (i.e. {namespace}localname). For example, --option {http://www.zorba-xquery.com}option=value").
 ("trailing-nl", "Output a trailing newline after the result of the query.")
 ("stop-words", po::value<std::vector<std::string> >(), "Mapping specifying a stop-words URI to another.")

=== modified file 'bin/zorbacmdproperties_base.h'
--- bin/zorbacmdproperties_base.h	2011-07-04 08:31:01 +0000
+++ bin/zorbacmdproperties_base.h	2012-02-03 01:13:24 +0000
@@ -34,7 +34,7 @@
 class ZorbaCMDPropertiesBase : public ::zorba::PropertiesBase {
 protected:
   const char **get_all_options () const {
-    static const char *result [] = { "--timing", "--output-file", "--serialization-parameter", "--serialize-html", "--serialize-text", "--indent", "--print-query", "--print-errors-as-xml", "--byte-order-mark", "--omit-xml-declaration", "--base-uri", "--boundary-space", "--default-collation", "--construction-mode", "--ordering-mode", "--multiple", "--query", "--as-files", "--external-variable", "--context-item", "--optimization-level", "--lib-module", "--parse-only", "--compile-only", "--no-serializer", "--debug", "--debug-host", "--debug-port", "--no-logo", "--timeout", "--module-path", "--option", "--trailing-nl", "--stop-words", "--thesaurus", NULL };
+    static const char *result [] = { "--timing", "--output-file", "--serialization-parameter", "--serialize-html", "--serialize-text", "--indent", "--print-query", "--print-errors-as-xml", "--byte-order-mark", "--omit-xml-declaration", "--base-uri", "--boundary-space", "--default-collation", "--construction-mode", "--ordering-mode", "--multiple", "--query", "--as-files", "--external-variable", "--context-item", "--optimization-level", "--lib-module", "--parse-only", "--compile-only", "--no-serializer", "--debug", "--debug-host", "--debug-port", "--no-logo", "--timeout", "--uri-path", "--lib-path", "--module-path", "--option", "--trailing-nl", "--stop-words", "--thesaurus", NULL };
     return result;
   }
   bool theTiming;
@@ -67,6 +67,8 @@
   unsigned int theDebugPort;
   bool theNoLogo;
   long theTimeout;
+  std::string theUriPath;
+  std::string theLibPath;
   std::string theModulePath;
   std::vector<std::string> theOption;
   bool theTrailingNl;
@@ -127,6 +129,8 @@
   const unsigned int &debugPort () const { return theDebugPort; }
   const bool &noLogo () const { return theNoLogo; }
   const long &timeout () const { return theTimeout; }
+  const std::string &uriPath () const { return theUriPath; }
+  const std::string &libPath () const { return theLibPath; }
   const std::string &modulePath () const { return theModulePath; }
   const std::vector<std::string> &option () const { return theOption; }
   const bool &trailingNl () const { return theTrailingNl; }
@@ -262,6 +266,16 @@
         if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
         if (*argv == NULL) { result = "No value given for --timeout option"; break; }        init_val (*argv, theTimeout, d);
       }
+      else if (strcmp (*argv, "--uri-path") == 0) {
+        int d = 2;
+        if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
+        if (*argv == NULL) { result = "No value given for --uri-path option"; break; }        init_val (*argv, theUriPath, d);
+      }
+      else if (strcmp (*argv, "--lib-path") == 0) {
+        int d = 2;
+        if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
+        if (*argv == NULL) { result = "No value given for --lib-path option"; break; }        init_val (*argv, theLibPath, d);
+      }
       else if (strcmp (*argv, "--module-path") == 0) {
         int d = 2;
         if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
@@ -327,11 +341,13 @@
 "--compile-only\nOnly compile (don't execute)\n\n"
 "--no-serializer\nDo not serialize (discard) result.\n\n"
 "--debug, -d\nLaunch the Zorba debugger server and connect to a DBGP-enabled debugger client.\n\n"
-"--debug-host, -p\nThe host where the DBGP-enabled debugger client listens for connections. Defaults to: 127.0.0.1\n\n"
+"--debug-host, -h\nThe host where the DBGP-enabled debugger client listens for connections. Defaults to: 127.0.0.1\n\n"
 "--debug-port, -p\nThe port on which the DBGP-enabled debugger client listens for connections. Defaults to: 28028\n\n"
 "--no-logo\nPrint no logo when starting.\n\n"
 "--timeout\nSpecify a timeout in seconds. After the specified time, the execution of the query will be aborted.\n\n"
-"--module-path\nModule paths added to the built-in resolver, i.e. where module imports are looking for modules.\n\n"
+"--uri-path\nURI path (list of directories) added to the built-in URI resolver, i.e. where to find modules/schemas to import.\n\n"
+"--lib-path\nLibrary path (list of directories) where Zorba will look for dynamic libraries (e.g., module external function implementations.\n\n"
+"--module-path\nPath (list of directories) to add to both the URI and Library paths.\n\n"
 "--option\nSet an XQuery option in the static context. The QName of the option is passed as a string in the notation by James Clark (i.e. {namespace}localname). For example, --option {http://www.zorba-xquery.com}option=value\n\n"
 "--trailing-nl\nOutput a trailing newline after the result of the query.\n\n"
 "--stop-words\nMapping specifying a stop-words URI to another.\n\n"

=== added file 'cmake_modules/FindLibedit.cmake'
--- cmake_modules/FindLibedit.cmake	1970-01-01 00:00:00 +0000
+++ cmake_modules/FindLibedit.cmake	2012-02-03 01:13:24 +0000
@@ -0,0 +1,46 @@
+# Copyright 2011 The FLWOR Foundation.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# - Try to find the libedit library
+#
+# Once done this will define
+#
+#  LIBEDIT_FOUND        - True if libedit library is found
+#  LIBEDIT_INCLUDE_DIRS - Directory to include to get libedit headers
+#  LIBEDIT_LIBRARIES    - Libraries to link against for the libedit library
+#
+
+FIND_PATH (
+  LIBEDIT_INCLUDE
+  editline/readline.h
+  PATHS ${LIBEDIT_INCLUDE_DIR} /usr/include /usr/local/include
+)
+MESSAGE(STATUS ${LIBEDIT_INCLUDE})
+
+FIND_LIBRARY (
+  LIBEDIT_LIBRARY
+  NAMES edit
+  PATHS ${LIBEDIT_LIBRARY_DIR} /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
+) 
+MESSAGE(STATUS ${LIBEDIT_LIBRARY})
+
+SET (LIBEDIT_INCLUDE_DIRS ${LIBEDIT_INCLUDE})
+SET (LIBEDIT_LIBRARIES ${LIBEDIT_LIBRARY})
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS (
+  Libedit
+  DEFAULT_MSG
+  LIBEDIT_INCLUDE LIBEDIT_LIBRARY
+)
+

=== modified file 'cmake_modules/FindPHP5.cmake'
--- cmake_modules/FindPHP5.cmake	2011-08-19 00:03:31 +0000
+++ cmake_modules/FindPHP5.cmake	2012-02-03 01:13:24 +0000
@@ -97,6 +97,11 @@
     _zend_rsrc_list_get_rsrc_type
     _zend_wrong_param_count
     _zval_used_for_init
+    _zval_is_true
+    _zend_lookup_class
+    __object_init
+    __zend_hash_add_or_update
+    _php_strtolower
     )
     SET(CMAKE_SHARED_MODULE_CREATE_C_FLAGS
       "${CMAKE_SHARED_MODULE_CREATE_C_FLAGS},-U,${symbol}")

=== modified file 'cmake_modules/ZorbaModule.cmake'
--- cmake_modules/ZorbaModule.cmake	2011-10-10 10:31:20 +0000
+++ cmake_modules/ZorbaModule.cmake	2012-02-03 01:13:24 +0000
@@ -272,12 +272,12 @@
       IF(NOT ${PROJECT_NAME} STREQUAL "zorba")
         STRING(REPLACE "-" "_"  component_name ${PROJECT_NAME})
         INSTALL(TARGETS ${module_lib_target}
-          ${target_type} DESTINATION ${ZORBA_MODULES_INSTALL_DIR}/${module_path}
+          ${target_type} DESTINATION ${ZORBA_NONCORE_LIB_DIR}/${module_path}
           COMPONENT ${component_name})
       
       ELSE(NOT ${PROJECT_NAME} STREQUAL "zorba")
         INSTALL(TARGETS ${module_lib_target}
-          ${target_type} DESTINATION ${ZORBA_MODULES_INSTALL_DIR}/${module_path})
+          ${target_type} DESTINATION ${ZORBA_CORE_LIB_DIR}/${module_path})
       ENDIF(NOT ${PROJECT_NAME} STREQUAL "zorba")
     ENDIF (NOT MODULE_TEST_ONLY)
       
@@ -296,7 +296,7 @@
     ENDIF (patch_ver)
   ENDIF (MODULE_VERSION)
   FOREACH (version_infix "" ${version_infixes})
-    ADD_COPY_RULE ("${SOURCE_FILE}" "${module_path}/${module_filename}"
+    ADD_COPY_RULE ("URI" "${SOURCE_FILE}" "${module_path}/${module_filename}"
       "${version_infix}" "" "${MODULE_TEST_ONLY}")
   ENDFOREACH (version_infix)
 
@@ -304,7 +304,7 @@
   IF (module_lib_target)
     GET_TARGET_PROPERTY (lib_location "${module_lib_target}" LOCATION)
     GET_FILENAME_COMPONENT (lib_filename "${lib_location}" NAME)
-    ADD_COPY_RULE ("${lib_location}" "${module_path}/${lib_filename}"
+    ADD_COPY_RULE ("LIB" "${lib_location}" "${module_path}/${lib_filename}"
       "" "${module_lib_target}" "${MODULE_TEST_ONLY}")
   ENDIF (module_lib_target)
 
@@ -357,27 +357,30 @@
     ADD_ZORBA_MANIFEST_ENTRY("schema" ${SCHEMA_URI} "")
   ENDIF (NOT SCHEMA_TEST_ONLY)
 
-  ADD_COPY_RULE ("${SOURCE_FILE}" "${schema_path}/${schema_filename}"
+  ADD_COPY_RULE ("URI" "${SOURCE_FILE}" "${schema_path}/${schema_filename}"
     "" "" "${SCHEMA_TEST_ONLY}")
 
 ENDMACRO (DECLARE_ZORBA_SCHEMA)
 
 # Utility macro for setting up a build rule to copy a file to a
-# particular (possible versioned) file in URI_PATH if such a file has
+# particular (possibly versioned) file in a shared directory if such a file has
 # not already been output.
+# FILE_TYPE: Either "URI" or "LIB"; will be used to determine which shared
+#    directory to place output in (URI_PATH or LIB_PATH).
 # INPUT_FILE: Absolute path to file to copy.
 # OUTPUT_FILE: Relative path to output file (relative to URI_PATH).
 # VERSION_ARG: Version; may be "" for non-versioned files.
 # DEPEND_TARGET: A CMake target name upon which the copy rule should depend;
 #    may be "".
 # TEST_ONLY: If 1, file is for testcases only; will be copied into
-#    TEST_URI_PATH and will not be installed
-MACRO (ADD_COPY_RULE INPUT_FILE OUTPUT_FILE VERSION_ARG DEPEND_TARGET TEST_ONLY)
+#    TEST_URI_PATH/TEST_LIB_PATH and will not be installed
+MACRO (ADD_COPY_RULE FILE_TYPE INPUT_FILE OUTPUT_FILE VERSION_ARG
+       DEPEND_TARGET TEST_ONLY)
   # Choose output base directory
   IF (${TEST_ONLY} EQUAL 1)
-    SET (_output_basedir "${CMAKE_BINARY_DIR}/TEST_URI_PATH")
+    SET (_output_basedir "${CMAKE_BINARY_DIR}/TEST_${FILE_TYPE}_PATH")
   ELSE (${TEST_ONLY} EQUAL 1)
-    SET (_output_basedir "${CMAKE_BINARY_DIR}/URI_PATH")
+    SET (_output_basedir "${CMAKE_BINARY_DIR}/${FILE_TYPE}_PATH")
   ENDIF (${TEST_ONLY} EQUAL 1)
 
   # Compute the modified output filename by inserting VERSION_ARG (if
@@ -404,19 +407,27 @@
   IF (file_found EQUAL -1)
     SET_PROPERTY (GLOBAL APPEND PROPERTY "${_dir_sym}-output-files"
       "${_output_file}")
-    # Save the input file, output file, and any library dependency
-    # target for this rule in a global property
+    # Detect whether this is a core URI or not
+    IF (PROJECT_NAME STREQUAL "zorba")
+      SET (_is_core 1)
+    ELSE (PROJECT_NAME STREQUAL "zorba")
+      SET (_is_core 0)
+    ENDIF (PROJECT_NAME STREQUAL "zorba")
+
+    # Save the (input file, output file, any library dependency
+    # target, and whether this is a core or non-core file) for this
+    # rule in a global property
     SET_PROPERTY (GLOBAL APPEND PROPERTY ZORBA_URI_FILES
-      "${INPUT_FILE}" "${_output_file}" "${DEPEND_TARGET}")
+      "${INPUT_FILE}" "${_output_file}" "${DEPEND_TARGET}" "${_is_core}")
 
     # For .xq and .xsd files, also set up an INSTALL rule (if not TEST_ONLY).
     IF (NOT ${TEST_ONLY} EQUAL 1)
       IF (${_output_ext} STREQUAL ".xq" OR ${_output_ext} STREQUAL ".xsd")
         
-        IF(NOT PROJECT_NAME STREQUAL "zorba")
+        IF(NOT _is_core)
           STRING(REPLACE "-" "_"  component_name ${PROJECT_NAME})   
           INSTALL (FILES "${INPUT_FILE}"
-            DESTINATION "${ZORBA_MODULES_INSTALL_DIR}/${_output_path}"
+            DESTINATION "${ZORBA_NONCORE_URI_DIR}/${_output_path}"
             RENAME "${_output_filename}"
             COMPONENT "${component_name}")
           
@@ -434,13 +445,11 @@
             FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeCPackModules.cmake "SET(CPACK_COMPONENT_${component_name2}_INSTALL_TYPES Full)\n")
           ENDIF (NOT ${component_name}_cpack)  
             
-        ELSE(NOT PROJECT_NAME STREQUAL "zorba")
+        ELSE(NOT _is_core)
           INSTALL (FILES "${INPUT_FILE}"
-          DESTINATION "${ZORBA_MODULES_INSTALL_DIR}/${_output_path}"
+          DESTINATION "${ZORBA_CORE_URI_DIR}/${_output_path}"
           RENAME "${_output_filename}")
-        ENDIF(NOT PROJECT_NAME STREQUAL "zorba")
-        
-        
+        ENDIF(NOT _is_core)
           
       ENDIF (${_output_ext} STREQUAL ".xq" OR ${_output_ext} STREQUAL ".xsd")
     ENDIF (NOT ${TEST_ONLY} EQUAL 1)
@@ -485,16 +494,17 @@
     IF (POLICY CMP0007)
       CMAKE_POLICY (SET CMP0007 NEW)
     ENDIF (POLICY CMP0007)
-    MESSAGE (STATUS "Creating check_uris target")
+    MESSAGE (STATUS "Creating check_core_uris and check_uris targets")
     GET_PROPERTY (copy_rules GLOBAL PROPERTY ZORBA_URI_FILES)
     SET (_output_files)
     WHILE (copy_rules)
-      # Pop three items off the list, and set up the corresponding
+      # Pop four items off the list, and set up the corresponding
       # rule
       LIST (GET copy_rules 0 _input_file)
       LIST (GET copy_rules 1 _output_file)
       LIST (GET copy_rules 2 _depend_target)
-      LIST (REMOVE_AT copy_rules 0 1 2)
+      LIST (GET copy_rules 3 _is_core)
+      LIST (REMOVE_AT copy_rules 0 1 2 3)
       SET (_depends "${_input_file}")
       IF (_depend_target)
         LIST (APPEND _depends "${_depend_target}")
@@ -504,12 +514,30 @@
         "${_input_file}" "${_output_file}"
         DEPENDS ${_depends}
         COMMENT "Copying ${_input_file} to URI path" VERBATIM)
-      LIST (APPEND _output_files "${_output_file}")
+      IF (_is_core)
+        LIST (APPEND _core_output_files "${_output_file}")
+      ELSE (_is_core)
+        LIST (APPEND _noncore_output_files "${_output_file}")
+      ENDIF (_is_core)
     ENDWHILE (copy_rules)
-    ADD_CUSTOM_TARGET (check_uris ALL DEPENDS ${_output_files} VERBATIM)
-    SET_TARGET_PROPERTIES(check_uris PROPERTIES
-      FOLDER "Modules"
-    )
+
+    # Targets and dependencies:
+    #   ALL depends on check_uris; check_uris depends on check_core_uris;
+    #   zorbacmd depends on check_core_uris.
+    ADD_CUSTOM_TARGET (check_uris ALL
+      DEPENDS ${_noncore_output_files} VERBATIM)
+    SET_TARGET_PROPERTIES(check_uris PROPERTIES FOLDER "Modules")
+    # Only create check_core_uris target and associated dependencies if
+    # there are any core URIs; there should never be any when building a
+    # standalone module project.
+    LIST (LENGTH _core_output_files _num_core)
+    IF (_num_core GREATER 0)
+      ADD_CUSTOM_TARGET (check_core_uris 
+        DEPENDS ${_core_output_files} VERBATIM)
+      ADD_DEPENDENCIES(check_uris check_core_uris)
+      ADD_DEPENDENCIES(zorbacmd check_core_uris)
+      SET_TARGET_PROPERTIES(check_core_uris PROPERTIES FOLDER "Modules")
+    ENDIF (_num_core GREATER 0)
     SET_PROPERTY (GLOBAL PROPERTY ZORBA_URI_FILES)
 
     #add 'xqdoc' and 'xqdoc-xml' targets
@@ -695,7 +723,7 @@
       COMMENT "Building XQDoc XML documentation ..."
   )
   MESSAGE(STATUS "  added target xqdoc-xml")
-  ADD_DEPENDENCIES(xqdoc-xml zorba_simplestore)
+  ADD_DEPENDENCIES(xqdoc-xml zorbacmd check_core_uris)
 
   SET_TARGET_PROPERTIES (xqdoc-xml PROPERTIES
     EXCLUDE_FROM_DEFAULT_BUILD 1

=== modified file 'config/CMakeLists.txt'
--- config/CMakeLists.txt	2011-09-08 19:19:54 +0000
+++ config/CMakeLists.txt	2012-02-03 01:13:24 +0000
@@ -34,7 +34,8 @@
 SET(Zorba_EXE_PATH "${ZORBA_ROOT}/bin/zorba")
 SET(Zorba_EXTERNALMODULECONFIG_FILE
   "${ZORBA_ROOT}/${ZORBA_CMAKE_DIR}/ExternalModuleConfig.cmake.in")   
-SET(Zorba_MODULES_INSTALL_DIR "${ZORBA_ROOT}/${ZORBA_MODULES_INSTALL_DIR}")
+SET(Zorba_NONCORE_URI_DIR "${ZORBA_ROOT}/${ZORBA_NONCORE_URI_DIR}")
+SET(Zorba_NONCORE_LIB_DIR "${ZORBA_ROOT}/${ZORBA_NONCORE_LIB_DIR}")
 
 CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/ZorbaConfig.cmake.in"
   "${CMAKE_CURRENT_BINARY_DIR}/ZorbaConfig.cmake" @ONLY)
@@ -58,7 +59,7 @@
   STRING (REPLACE ".exe" ".bat" Zorba_TESTDRIVER ${Zorba_TESTDRIVER})
 ENDIF (WIN32)
 
-SET(Zorba_EXE_PATH     "${ZORBA_EXE}")
+SET(Zorba_EXE_PATH "${ZORBA_EXE}")
 SET(Zorba_EXTERNALMODULECONFIG_FILE
   "${CMAKE_CURRENT_SOURCE_DIR}/ExternalModuleConfig.cmake.in")
 # Note: We also set these two into the parent's scope, so that it is
@@ -67,10 +68,9 @@
   "${CMAKE_CURRENT_SOURCE_DIR}/ExternalModuleConfig.cmake.in"
   PARENT_SCOPE)
 SET(Zorba_EXE "${ZORBA_EXE}" PARENT_SCOPE)
+SET(Zorba_NONCORE_URI_DIR "${ZORBA_NONCORE_URI_DIR}")
+SET(Zorba_NONCORE_LIB_DIR "${ZORBA_NONCORE_LIB_DIR}")
 
-# Note: This value doesn't really make much sense, but neither does any
-# other value
-SET(Zorba_MODULES_INSTALL_DIR "${ZORBA_MODULES_INSTALL_DIR}")
 CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/ZorbaConfig.cmake.in"
   "${CMAKE_BINARY_DIR}/ZorbaConfig.cmake" @ONLY)
 

=== modified file 'config/ZorbaConfig.cmake.in'
--- config/ZorbaConfig.cmake.in	2011-08-24 09:09:02 +0000
+++ config/ZorbaConfig.cmake.in	2012-02-03 01:13:24 +0000
@@ -47,10 +47,13 @@
   "Path to Zorba's testdriver" FORCE)
 SET_NORMALIZED (Zorba_EXE "@Zorba_EXE_PATH@" CACHE PATH "Path to Zorba executable" FORCE)
 
-# Tell the user project where modules are installed. Note: This variable
-# is all-uppercase because it is also used internally by Zorba's build.
-SET (ZORBA_MODULES_INSTALL_DIR "@Zorba_MODULES_INSTALL_DIR@"
-  CACHE STRING "Path to Zorba modules in this Zorba installation" FORCE)
+# Tell the user project where (non-core) modules are installed. Note:
+# These variables are all-uppercase because they are also used
+# internally by Zorba's build.
+SET (ZORBA_NONCORE_URI_DIR "@Zorba_NONCORE_URI_DIR@"
+  CACHE STRING "Path to Zorba to non-core modules/schemas in this Zorba installation" FORCE)
+SET (ZORBA_NONCORE_LIB_DIR "@Zorba_NONCORE_LIB_DIR@"
+  CACHE STRING "Path to Zorba to non-core libraries in this Zorba installation" FORCE)
 
 # Tell the user project where to find the "USE" file.
 # This file uses the above settings to configure the user project.

=== modified file 'doc/cxx/examples/errors.cpp'
--- doc/cxx/examples/errors.cpp	2011-08-11 05:11:12 +0000
+++ doc/cxx/examples/errors.cpp	2012-02-03 01:13:24 +0000
@@ -139,12 +139,12 @@
     // make sure that the warning zwarn::ZWST0002 is turned
     // into an error
     StaticContext_t lCtx = aZorba->createStaticContext();
-    lCtx->declareOption(lQName, "ZWST0002");
+    lCtx->declareOption(lQName, "ZWST0003");
 
     std::ostringstream s;
-    s << "declare namespace unknown = 'unknown-annotation';" << std::endl
-      << "declare %unknown:test variable $var := 3;" << std::endl
-      << "$var" << std::endl;
+    s << "declare namespace z = 'http://www.zorba-xquery.com/annotations';" << std::endl
+      << "declare %z:sequential function local:foo() { 1 };" << std::endl
+      << "local:foo()" << std::endl;
     XQuery_t lQuery = aZorba->compileQuery(s.str(), lCtx); 
 
     std::cout << lQuery << std::endl;

=== modified file 'doc/cxx/examples/simple.cpp'
--- doc/cxx/examples/simple.cpp	2011-06-14 14:21:49 +0000
+++ doc/cxx/examples/simple.cpp	2012-02-03 01:13:24 +0000
@@ -33,14 +33,14 @@
 
   std::cout << lQuery << std::endl;
 
-	return true;
+  return true;
 }
 
 
 bool
 example_2(Zorba* aZorba)
 {
-	XQuery_t lQuery = aZorba->compileQuery("1+2");
+  XQuery_t lQuery = aZorba->compileQuery("1+2");
 
   Iterator_t lIterator = lQuery->iterator();
   lIterator->open();
@@ -53,7 +53,7 @@
 
   lIterator->close();
 
-	return true;
+  return true;
 }
 
 
@@ -61,7 +61,7 @@
 example_3(Zorba* aZorba)
 {
 
-	XQuery_t lQuery = aZorba->compileQuery("1 div 0"); 
+  XQuery_t lQuery = aZorba->compileQuery("1 div 0");
   try {
     std::cout << lQuery << std::endl;
   } catch ( ZorbaException& e ) {
@@ -69,7 +69,7 @@
     return true;
   }
 
-	return false;
+  return false;
 }
 
 
@@ -125,9 +125,7 @@
 bool
 example_7()
 {
-
   std::cout << Zorba::version() << std::endl;
-
   return true;
 }
 
@@ -246,7 +244,8 @@
 bool
 example_12(Zorba* aZorba)
 {
-	XQuery_t lQuery = aZorba->compileQuery("<a><b attr='1'/><b attr='2'/></a>");
+  XQuery_t lQuery = aZorba->compileQuery
+      ("<a xmlns:foo='http://www.zorba-xquery.com/'><b attr='1' xmlns:bar='http://www.zorba-xquery.com/uri2'/><b attr='2'/></a>");
 
   Iterator_t lIterator = lQuery->iterator();
   lIterator->open();
@@ -263,16 +262,24 @@
       Item lNodeName;
       lChild.getNodeName(lNodeName);
       std::cout << "node name " << lNodeName.getStringValue() << std::endl;
+
       Iterator_t lAttrIter = lChild.getAttributes();
-      
       lAttrIter->open();
-
       Item lAttr;
       while (lAttrIter->next(lAttr)) 
       {
         std::cout << "  attribute value " << lAttr.getStringValue() << std::endl;
       }
       lAttrIter->close();
+
+      NsBindings lBindings;
+      lChild.getNamespaceBindings(lBindings,
+                                  store::StoreConsts::ONLY_LOCAL_NAMESPACES);
+      for (NsBindings::const_iterator ite = lBindings.begin();
+           ite != lBindings.end(); ++ite) {
+        std::cout << "  namespace binding " << ite->first
+                  << "->" << ite->second << std::endl;
+      }
     }
     lChildIter->close();
   }

=== modified file 'doc/php/CMakeLists.txt'
--- doc/php/CMakeLists.txt	2011-06-20 12:44:21 +0000
+++ doc/php/CMakeLists.txt	2012-02-03 01:13:24 +0000
@@ -1,4 +1,4 @@
-# Copyright 2006-2008 The FLWOR Foundation.
+# Copyright 2006-2012 The FLWOR Foundation.
 # 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

=== modified file 'doc/php/examples/CMakeLists.txt'
--- doc/php/examples/CMakeLists.txt	2011-08-19 00:03:31 +0000
+++ doc/php/examples/CMakeLists.txt	2012-02-03 01:13:24 +0000
@@ -1,4 +1,4 @@
-# Copyright 2006-2008 The FLWOR Foundation.
+# Copyright 2006-2012 The FLWOR Foundation.
 # 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -20,14 +20,24 @@
   MESSAGE(STATUS "PHP Path:" ${phpPath})
   SET(phpExtensionPath ${CMAKE_BINARY_DIR}/swig/php)
   MESSAGE(STATUS "PHP Extension Path: " ${phpExtensionPath})
+  SET(phpIncludePath ${CMAKE_BINARY_DIR}/swig/php)
+  MESSAGE(STATUS "PHP Include Path: " ${phpExtensionPath})
   CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/php.ini.in ${CMAKE_CURRENT_BINARY_DIR}/php.ini)
   MESSAGE(STATUS "Configuration file: " ${CMAKE_CURRENT_BINARY_DIR}/php.ini)
   CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/simple.php.in ${CMAKE_CURRENT_BINARY_DIR}/simple.php)
   MESSAGE(STATUS "Simple configuration file: " ${CMAKE_CURRENT_BINARY_DIR}/simple.php)
-  ADD_TEST("php" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/simple.php)
+  CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/test.php.in ${CMAKE_CURRENT_BINARY_DIR}/test.php)
+  MESSAGE(STATUS "PHP test  file configured: " ${CMAKE_CURRENT_BINARY_DIR}/test.php)
+  ADD_TEST("php1" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/simple.php)
   MESSAGE(STATUS "Installing: " ${CMAKE_CURRENT_BINARY_DIR}/simple.php)
-  
-  INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/simple.php
+  ADD_TEST("php2" ${PHP5_EXECUTABLE} -c ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/test.php)
+
+  EXPECTED_FAILURE(php2 918592)
+
+  MESSAGE(STATUS "Installing: " ${CMAKE_CURRENT_BINARY_DIR}/test.php)
+  
+  
+  INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/simple.php ${CMAKE_CURRENT_BINARY_DIR}/test.php
           COMPONENT "php_examples"
           DESTINATION
           share/doc/zorba-${ZORBA_MAJOR_NUMBER}.${ZORBA_MINOR_NUMBER}.${ZORBA_PATCH_NUMBER}/php/examples)

=== modified file 'doc/php/examples/php.ini.in'
--- doc/php/examples/php.ini.in	2009-10-30 16:34:37 +0000
+++ doc/php/examples/php.ini.in	2012-02-03 01:13:24 +0000
@@ -1,2 +1,3 @@
 enable_dl=On
 extension_dir=@phpExtensionPath@
+include_path=".:@phpIncludePath@"
\ No newline at end of file

=== modified file 'doc/php/examples/simple.php.in'
--- doc/php/examples/simple.php.in	2011-08-04 02:14:56 +0000
+++ doc/php/examples/simple.php.in	2012-02-03 01:13:24 +0000
@@ -1,6 +1,6 @@
 <?php
 /*
- * Copyright 2006-2008 The FLWOR Foundation.
+ * Copyright 2006-2012 The FLWOR Foundation.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-require '@phpPath@/zorba_api_wrapper.php';
+require '@phpPath@/Zorba/zorba_api_wrapper.php';
 
 function example_1(Zorba $aZorba)
 {

=== added file 'doc/php/examples/test.php.in'
--- doc/php/examples/test.php.in	1970-01-01 00:00:00 +0000
+++ doc/php/examples/test.php.in	2012-02-03 01:13:24 +0000
@@ -0,0 +1,120 @@
+<?php
+/*
+ * Copyright 2006-2012 The FLWOR Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+require '@phpPath@/Zorba/XQueryProcessor.php';
+
+function omitXMLDecl($xml)
+{
+  $xml = str_replace('<?xml version="1.0" encoding="UTF-8"?>', '', $xml);
+  $xml = trim($xml);
+  return $xml;
+}
+
+function assertEquality($test, $reference, $label)
+{
+  $test = omitXMLDecl($test);
+  echo "=====================================\n";
+  var_dump($test);
+  var_dump($reference);
+  if($test != $reference) {
+    throw new Exception(
+       "Test "
+     . $label
+     . " failed. Result:\n"
+     . $test
+     . "\nDoesn't match reference:\n"
+     . $reference
+    );
+  }
+}
+/* Test 1 */
+$xquery = new XQueryProcessor();
+$xquery->importQuery('1+1');
+$result = $xquery->execute();
+assertEquality($result, '2', "1+1");
+
+/* Test 2 */
+$query = '
+declare variable $foo as xs:string external;
+declare variable $bar as xs:integer external;
+declare variable $doc1 as document-node() external;
+declare variable $doc2-str as xs:string external;
+declare variable $doc2 as document-node() := parse-xml($doc2-str);
+
+$foo, $bar, $doc1 , $doc2
+';
+
+$xquery->importQuery($query);
+
+$xquery->setVariable("foo", "bar");
+$xquery->setVariable("bar", 3);
+
+$doc = simplexml_load_string('<root />');
+$xquery->setVariable("doc1", $doc);
+
+$doc = "<root />";
+$xquery->setVariable("doc2-str", $doc);
+
+$result = trim($xquery->execute());
+assertEquality($result,  "bar 3<root/><root/>", "Test PHP Types Mapping");
+
+/* Test 3 */
+$xquery->importQuery("(1, 2, <foo bar='bar' />)");
+$it = $xquery->getIterator();
+
+foreach($it as $pos => $value) {
+  switch($pos) {
+    case 0:
+      assertEquality($value, "1", "Consume the item at position {$pos}");
+    break;
+    case 1:
+      assertEquality($value, "2", "Consume the item at position {$pos}");
+    break;
+    case 3:
+      assertEquality($value, '<foo bar="bar"/>', "Consume the item at position {$pos}");
+    break;
+  }
+}
+
+//Let's do it again by leveraging the SPL IteratorAggregate
+foreach($xquery as $pos => $value) {
+  switch($pos) {
+    case 0:
+      assertEquality($value, "1", "Consume the item at position {$pos}");
+    break;
+    case 1:
+      assertEquality($value, "2", "Consume the item at position {$pos}");
+    break;
+    case 3:
+      assertEquality($value, '<foo bar="bar"/>', "Consume the item at position {$pos}");
+    break;
+  }
+}
+
+//Try the same query with execute
+$result = $xquery->execute();
+assertEquality($result, "1 2<foo bar=\"bar\"/>", "Execute To URI");
+
+/* Test 4 */
+$xquery->importQueryFromURI("@phpPath@/test.xq");
+$result = $xquery->execute();
+assertEquality($result, "2", "Test importQueryFromURI");
+
+/* Test 5 */
+//$xquery->importQueryFromURI("http://zorba.s3.amazonaws.com/test.xq");
+//$result = $xquery->execute();
+//assertEquality($result, "2", "Test importQueryFromURI");
+?>

=== modified file 'doc/php/examples/zorba_api.php'
--- doc/php/examples/zorba_api.php	2010-01-27 13:25:24 +0000
+++ doc/php/examples/zorba_api.php	2012-02-03 01:13:24 +0000
@@ -1,6 +1,6 @@
 <?php
 /*
- * Copyright 2006-2008 The FLWOR Foundation.
+ * Copyright 2006-2012 The FLWOR Foundation.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

=== modified file 'doc/zorba/commandline.dox'
--- doc/zorba/commandline.dox	2011-07-24 22:28:31 +0000
+++ doc/zorba/commandline.dox	2012-02-03 01:13:24 +0000
@@ -112,8 +112,14 @@
 --timeout
 Specify a timeout in seconds. After the specified time, the execution of the query will be aborted.
 
+--uri-path
+URI path (list of directories) added to the built-in URI resolver, i.e. where to find modules/schemas to import.
+
+--lib-path
+Library path (list of directories) where Zorba will look for dynamic libraries (e.g., module external function implementations.
+
 --module-path
-Module paths added to the built-in resolver, i.e. where module imports are looking for modules.
+Path (list of directories) to add to both the URI and Library paths.
 
 --option
 Set an XQuery option in the static context. The QName of the option is passed as a string in the notation by James Clark (i.e. {namespace}localname). For example, --option {http://www.zorba-xquery.com}option=value

=== modified file 'doc/zorba/conformance.dox'
--- doc/zorba/conformance.dox	2011-09-06 16:39:46 +0000
+++ doc/zorba/conformance.dox	2012-02-03 01:13:24 +0000
@@ -344,18 +344,18 @@
   </tr>
   <tr bgcolor="lightcyan">
     <td bgcolor="lightcyan">Minimal Conformance</td>
-    <td align="center" bgcolor="palegreen">384/429<br />89.51%</td>
-    <td align="center" bgcolor="coral">24/429<br />5.59%</td>
+    <td align="center" bgcolor="palegreen">385/429<br />89.74%</td>
+    <td align="center" bgcolor="palegreen">374/429<br />87.18%</td>
   </tr>
   <tr bgcolor="lightcyan">
     <td bgcolor="lightcyan">Optional Features</td>
     <td align="center" bgcolor="palegreen">106/125<br />84.8%</td>
-    <td align="center" bgcolor="coral">0/125<br />0%</td>
+    <td align="center" bgcolor="palegreen">97/125<br />77.6%</td>
   </tr>
   <tr bgcolor="lightcyan">
     <td bgcolor="lightcyan">Use Cases</td>
     <td align="center" bgcolor="palegreen">121/135<br />89.63%</td>
-    <td align="center" bgcolor="coral">0/135<br />0%</td>
+    <td align="center" bgcolor="palegreen">103/135<br />76.3%</td>
   </tr>
   <tr bgcolor="lightcyan">
     <td bgcolor="lightcyan">Consistency in XQFTTS Catalog</td>

=== modified file 'doc/zorba/conformanceXQFTTS.dox'
--- doc/zorba/conformanceXQFTTS.dox	2011-09-06 16:21:54 +0000
+++ doc/zorba/conformanceXQFTTS.dox	2012-02-03 01:13:24 +0000
@@ -1,8 +1,8 @@
 /** \page conformanceXQFTTS  W3C XQuery and XPath Full Text 1.0 Conformance
 
-Zorba achieves 89.51% on minimal conformance (and 84.8% on Optional Features) for the W3C XPath Full Text 1.0 Test Suite.
-Please see the table below for more details.
-
+ Zorba achieves 89.74% on minimal conformance (84.8% on Optional Features) for the W3C XPath Full Text 1.0 Test Suite.
+            
+Please see the table below for more details. 
 <table bgcolor="lightcyan">
   <tr>
     <td>W3C XQuery and XPath Full Text 1.0 features</td>
@@ -27,7 +27,7 @@
   <tr bgcolor="lightcyan">
     <td bgcolor="lightcyan">    Section 2.2.2</td>
     <td align="center" bgcolor="mediumseagreen">4/4</td>
-    <td align="center" bgcolor="coral">0/4</td>
+    <td align="center" bgcolor="mediumseagreen">4/4</td>
   </tr>
   <tr bgcolor="lightcyan">
     <td bgcolor="lightcyan">    Section 2.3</td>
@@ -42,27 +42,27 @@
   <tr bgcolor="lightcyan">
     <td bgcolor="lightcyan">    Section 3.2</td>
     <td align="center" bgcolor="palegreen">4/5</td>
-    <td align="center" bgcolor="coral">0/5</td>
+    <td align="center" bgcolor="palegreen">4/5</td>
   </tr>
   <tr bgcolor="lightcyan">
     <td bgcolor="lightcyan">    Section 3.3</td>
     <td align="center" bgcolor="mediumseagreen">2/2</td>
-    <td align="center" bgcolor="coral">0/2</td>
+    <td align="center" bgcolor="mediumseagreen">2/2</td>
   </tr>
   <tr bgcolor="lightcyan">
     <td bgcolor="lightcyan">    Section 3.4</td>
     <td align="center" bgcolor="mediumseagreen">2/2</td>
-    <td align="center" bgcolor="coral">0/2</td>
+    <td align="center" bgcolor="mediumseagreen">2/2</td>
   </tr>
   <tr bgcolor="lightcyan">
     <td bgcolor="lightcyan">    Section 3.4.1</td>
     <td align="center" bgcolor="mediumseagreen">1/1</td>
-    <td align="center" bgcolor="coral">0/1</td>
+    <td align="center" bgcolor="mediumseagreen">1/1</td>
   </tr>
   <tr bgcolor="lightcyan">
     <td bgcolor="lightcyan">    Section 3.4.2</td>
     <td align="center" bgcolor="mediumseagreen">4/4</td>
-    <td align="center" bgcolor="coral">0/4</td>
+    <td align="center" bgcolor="mediumseagreen">4/4</td>