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

[Gabriel Petrovay]

Mature zorba debugger with graceful degradation if libedit not found.

Mature zorba debugger with graceful degradation if libedit not found.

[Gabriel Petrovay (gabipetrovay)]

review: Approve

[David Graf (davidagraf)]

I reviewed CMakeConfiguration.txt, bin/CMakeLists.txt, bin/debugger/config.h.cmake.

Looks good to me. I was only thinking if it would be a good idea to remove the option ZORBA_WITH_DEBUGGER_CLIENT (generating the debugger client if debugging is switched on). The less options to better.

review: Approve

[Gabriel Petrovay (gabipetrovay)]

Use the conversation "Can we please have libedit on the build server?" for opinions about ZORBA_WITH_DEBUGGER_CLIENT.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/debugger_client-2011-12-20T16-40-29.862Z/log.html

[Zorba Build Bot (zorba-buildbot)]

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

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:272 (message):
  Validation queue job debugger_client-2011-12-20T16-40-29.862Z is finished.
  The final status was:

  No tests were run - build or configure step must have failed.

  Not commiting changes.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/debugger_client-2011-12-20T17-21-18.291Z/log.html

[Zorba Build Bot (zorba-buildbot)]

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

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:272 (message):
  Validation queue job debugger_client-2011-12-20T17-21-18.291Z is finished.
  The final status was:

  1 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

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

10593. By Gabriel Petrovay on 2011-12-20

added missing version and xquery version from the dbgp-message-handler.xq module

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/debugger_client-2011-12-20T18-12-16.752Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job debugger_client-2011-12-20T18-12-16.752Z is finished. The final status was:

All tests succeeded!

=== modified file 'CMakeConfiguration.txt'
--- CMakeConfiguration.txt	2011-09-16 19:55:59 +0000
+++ CMakeConfiguration.txt	2011-12-20 18:15:30 +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")
@@ -93,6 +89,13 @@
 SET(ZORBA_WITH_DEBUGGER ON CACHE BOOL "compile zorba with debugger support")
 MESSAGE(STATUS "ZORBA_WITH_DEBUGGER [ON/OFF]:         " ${ZORBA_WITH_DEBUGGER})
 
+SET(ZORBA_WITH_DEBUGGER_CLIENT ON CACHE BOOL "compile zorba with a command line debugger client")
+MESSAGE(STATUS "ZORBA_WITH_DEBUGGER_CLIENT [ON/OFF]:  " ${ZORBA_WITH_DEBUGGER_CLIENT})
+
+IF (ZORBA_WITH_DEBUGGER_CLIENT AND NOT ZORBA_WITH_DEBUGGER)
+  MESSAGE(FATAL_ERROR "Can not build a debugger client if the debugger support is disabled. Turn on ZORBA_WITH_DEBUGGER")
+ENDIF (ZORBA_WITH_DEBUGGER_CLIENT AND NOT ZORBA_WITH_DEBUGGER)
+
 SET(ZORBA_TEST_TIMEOUT_VALUE 60 CACHE INTEGER "default test timeout value")
 MESSAGE(STATUS "ZORBA_TEST_TIMEOUT_VALUE:             " ${ZORBA_TEST_TIMEOUT_VALUE})
 
 
=== modified file 'bin/CMakeLists.txt'
--- bin/CMakeLists.txt	2011-11-04 11:40:20 +0000
+++ bin/CMakeLists.txt	2011-12-20 18:15:30 +0000
@@ -15,26 +15,29 @@
 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_CLIENT)
+  IF (NOT WIN32)
+    FIND_PACKAGE (Libedit)
+    IF (LIBEDIT_FOUND)
+      INCLUDE_DIRECTORIES (${LIBEDIT_INCLUDE_DIRS})
+      SET (LIBEDIT_LIBS ${LIBEDIT_LIBRARIES})
+    ENDIF (LIBEDIT_FOUND)
+  ENDIF (NOT WIN32)
+
+  CHECK_INCLUDE_FILES ("editline/readline.h" ZORBA_HAVE_READLINE_H)
+  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/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_CLIENT)
 
 SET(SRCS
   zorbacmd.cpp
 
=== 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	2011-12-20 18:15:30 +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	2011-12-20 18:15:30 +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	2011-12-20 18:15:30 +0000
@@ -1,4 +1,4 @@
-/*
+  /*
  * Copyright 2006-2008 The FLWOR Foundation.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -23,225 +23,372 @@
 # define msleep Sleep
 #endif
 
-namespace zorba { namespace debugclient {
+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)
+    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();
+  theClient->quit();
+  theQuit = true;
+}
+
+template<>
+void
+CommandLineHandler::handle<Run>(ZORBA_TR1_NS::tuple<> &t)
+{
+  theTerminated = false;
+  theWaitFor = theClient->run();
+}
+
+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: 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	2011-12-20 18:15:30 +0000
@@ -14,46 +14,69 @@
  * 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 "command_prompt.h"
 #include "event_handler.h"
 
-namespace zorba { namespace debugclient {
-  
+
+namespace zorba { namespace debugger {
+
   enum Commands {
     Status,
+    Variables,
+    Quit,
     Run,
     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 +85,93 @@
     }
     
     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<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	2011-12-20 18:15:30 +0000
@@ -0,0 +1,246 @@
+/*
+ * 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 "config.h"
+
+#ifdef ZORBA_HAVE_READLINE_H
+# include <editline/readline.h>
+#endif
+
+#include "command.h"
+
+
+namespace zorba { namespace debugger {
+
+CommandPrompt::~CommandPrompt()
+{
+  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()
+{
+  for (;;) {
+#ifdef ZORBA_HAVE_READLINE_H
+    std::string lCommandLine(readline("(xqdb) "));
+#else
+    std::cout << "(xqdb) ";
+    std::string lCommandLine;
+    std::getline(std::cin, lCommandLine);
+#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;
+      }
+    }
+    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	2011-12-20 18:15:30 +0000
@@ -0,0 +1,60 @@
+/*
+ * 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>
+
+
+namespace zorba { namespace debugger {
+
+class UntypedCommand;
+
+class CommandPrompt
+{
+  public:
+    ~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;
+};  
+
+  
+} // 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	2011-12-20 18:15:30 +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_READLINE_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	2011-12-20 18:15:30 +0000
@@ -13,88 +13,94 @@
  * 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 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;
+}
+
+} // 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	2011-12-20 18:15:30 +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	2011-12-20 18:15:30 +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	2011-12-20 18:15:30 +0000
@@ -13,12 +13,244 @@
  * 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_prompt.h"
 #include "command_line_handler.h"
 
 using namespace zorba;
-using namespace zorba::debugclient;
+using namespace zorba::debugger;
+
+int
+startZorba(std::string& aExec, std::vector<std::string>& aArgs) 
+{
+#ifdef WIN32
+  // **************************
+  // start a process on Windows
+
+  DWORD iReturnVal = 0;
+  DWORD dwExitCode = 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
+    dwExitCode = WaitForSingleObject(piProcessInfo.hProcess, 0);
+  }
+  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;
+    } else {
+      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 +260,68 @@
 _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;
+  // **************************************************************************
+  // 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 {
+    // **************************************************************************
+    // start a zorba
+
+    if (!lStandalone) {
+      int lResult = startZorba(lZorbaExec, lZorbaArgs);
+      if (lResult) {
+        return lResult;
+      }
+    } else {
+      std::cout << "Waiting for an incomming Zorba connection..." << std::endl;
+    }
+
+    // **************************************************************************
+    // start the debugger command line
+
     LockFreeQueue<std::size_t> lQueue;
     LockFreeQueue<bool> lContEvent;
-    EventHandler lHandler(lQueue, lContEvent);
-    CommandLine cli;
-    CommandLineHandler handler(port, lQueue, lContEvent, lHandler, cli);
-    handler.execute();
+    EventHandler lEventHandler(lQueue, lContEvent);
+    lEventHandler.init();
+
+    CommandPrompt lCommandPrompt;
+    CommandLineHandler lCommandLineHandler(lPort, lQueue, lContEvent, lEventHandler, lCommandPrompt);
+
+    lCommandLineHandler.execute();
+
+#ifndef WIN32
+    wait();
+#endif
+
   } catch (...) {
-    return 4;
+    return -1;
   }
+
   return 0;
 }
+
 
=== modified file 'bin/debugger/tuple.h'
--- bin/debug_client/tuple.h	2011-07-04 08:05:46 +0000
+++ bin/debugger/tuple.h	2011-12-20 18:15:30 +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
 
=== modified file 'bin/zorbacmd.cpp'
--- bin/zorbacmd.cpp	2011-11-08 03:11:02 +0000
+++ bin/zorbacmd.cpp	2011-12-20 18:15:30 +0000
@@ -925,17 +925,15 @@
           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)
       {
 
=== added file 'cmake_modules/FindLibedit.cmake'
--- cmake_modules/FindLibedit.cmake	1970-01-01 00:00:00 +0000
+++ cmake_modules/FindLibedit.cmake	2011-12-20 18:15:30 +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 'include/zorba/config.h.cmake'
--- include/zorba/config.h.cmake	2011-10-19 16:19:45 +0000
+++ include/zorba/config.h.cmake	2011-12-20 18:15:30 +0000
@@ -39,19 +39,19 @@
 #endif /* WIN32 */
 
 // Platform headers
-#cmakedefine ZORBA_HAVE_COLL_H     
+#cmakedefine ZORBA_HAVE_COLL_H
 #cmakedefine ZORBA_HAVE_EXECINFO_H
 #cmakedefine ZORBA_HAVE_FLEXLEXER_H
 #cmakedefine ZORBA_HAVE_ICONV_H
-#cmakedefine ZORBA_HAVE_INTTYPES_H 
-#cmakedefine ZORBA_HAVE_LIMITS_H   
-#cmakedefine ZORBA_HAVE_PTHREAD_H  
-#cmakedefine ZORBA_HAVE_STDINT_H   
-#cmakedefine ZORBA_HAVE_STDLIB_H   
+#cmakedefine ZORBA_HAVE_INTTYPES_H
+#cmakedefine ZORBA_HAVE_LIMITS_H
+#cmakedefine ZORBA_HAVE_PTHREAD_H
+#cmakedefine ZORBA_HAVE_STDINT_H
+#cmakedefine ZORBA_HAVE_STDLIB_H
 #cmakedefine ZORBA_HAVE_SYS_MOUNT_H
 #cmakedefine ZORBA_HAVE_SYS_TYPES_H
-#cmakedefine ZORBA_HAVE_USTRING_H  
-#cmakedefine ZORBA_HAVE_UTYPES_H   
+#cmakedefine ZORBA_HAVE_USTRING_H
+#cmakedefine ZORBA_HAVE_UTYPES_H
 
 // Platform functions
 #cmakedefine ZORBA_HAVE_CLOCKGETTIME_FUNCTION
 
=== modified file 'include/zorba/debugger_client.h'
--- include/zorba/debugger_client.h	2011-07-24 22:28:31 +0000
+++ include/zorba/debugger_client.h	2011-12-20 18:15:30 +0000
@@ -162,6 +162,13 @@
      * @return The id of the request.
      */
     virtual std::size_t status() = 0;
+
+    /**
+     * @brief Get the variables in all the contexts in the topmost stack frame.
+     *
+     * @return The id of the request.
+     */
+    virtual std::size_t variables() = 0;
     
     /**
      * @brief Query the debug engine for supported features.
@@ -521,6 +528,7 @@
      */
     virtual void quit() = 0;
   };
+
 }//end of namespace
+
 #endif
-/* vim:set et sw=2 ts=2: */
 
=== modified file 'modules/com/zorba-xquery/www/modules/CMakeLists.txt'
--- modules/com/zorba-xquery/www/modules/CMakeLists.txt	2011-10-14 07:35:51 +0000
+++ modules/com/zorba-xquery/www/modules/CMakeLists.txt	2011-12-20 18:15:30 +0000
@@ -100,6 +100,13 @@
 DECLARE_ZORBA_MODULE(FILE store/static/integrity_constraints/dml.xq VERSION 2.0
   URI "http://www.zorba-xquery.com/modules/store/static/integrity_constraints/dml")
 
+# debugger client DBGP message handler module
+IF (ZORBA_WITH_DEBUGGER)
+  DECLARE_ZORBA_MODULE (FILE debugger/dbgp-message-handler.xq VERSION 1.0
+    URI "http://www.zorba-xquery.com/modules/debugger/dbgp-message-handler")
+ENDIF (ZORBA_WITH_DEBUGGER)
+
+
 # error and warning modules
 DECLARE_ZORBA_MODULE (FILE pregenerated/errors.xq
   URI "http://www.zorba-xquery.com/errors"
 
=== added directory 'modules/com/zorba-xquery/www/modules/debugger'
=== added file 'modules/com/zorba-xquery/www/modules/debugger/dbgp-message-handler.xq'
--- modules/com/zorba-xquery/www/modules/debugger/dbgp-message-handler.xq	1970-01-01 00:00:00 +0000
+++ modules/com/zorba-xquery/www/modules/debugger/dbgp-message-handler.xq	2011-12-20 18:15:30 +0000
@@ -0,0 +1,277 @@
+xquery version "3.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.
+:)
+module namespace dmh = "http://www.zorba-xquery.com/modules/debugger/dbgp-message-handler";
+
+import module namespace base64 = "http://www.zorba-xquery.com/modules/converters/base64";
+
+declare namespace ver = "http://www.zorba-xquery.com/options/versioning";
+declare option ver:module-version "1.0";
+
+
+declare variable $dmh:endl as xs:string := "
+";
+
+(:~
+ : Set this variale to true if you want to have mode debug information when
+ : an error occurs.
+ :)
+declare variable $dmh:debug as xs:boolean := fn:false();
+
+
+declare %private function dmh:status($resp as element(response))
+{
+  switch ($resp/@status)
+  case "starting"
+  case "stopping"
+    return "idle"
+  case "break"
+    return
+      let $status := $resp/@status
+      let $whyInfo :=
+        if ($resp/@reason ne "ok") then
+          fn:concat(" (", $resp/@reason, ")")
+        else
+          ""
+      let $whereInfo :=
+        if ($resp/text()[1] ne "") then
+          fn:concat(" in ", $resp/text()[1])
+        else
+          ""
+      return
+        fn:concat($status, $whyInfo, $whereInfo)
+  default
+    return $resp/@status
+};
+
+declare %private function dmh:source($resp as element(response))
+{
+  $resp/text()
+};
+
+declare %private function dmh:breakpoint-set($resp as element(response))
+{
+  fn:concat("set breakpoint with id ", data($resp/@id), " and state ", data($resp/@state))
+};
+
+declare %private function dmh:breakpoint-get($resp as element(response))
+{
+  let $b := $resp/breakpoint
+  return
+    fn:concat(
+      "Breakpoint ", $b/@id, $dmh:endl,
+      "  type:  ", $b/@type, $dmh:endl,
+      "  file:  ", $b/@filename, $dmh:endl,
+      "  line:  ", $b/@lineno, $dmh:endl,
+      "  state: ", $b/@state
+    )
+};
+
+declare %private function dmh:breakpoint-list($resp as element(response))
+{
+  fn:string-join(
+    let $bs := $resp/breakpoint
+    return
+      if (fn:exists($bs)) then
+        fn:concat(
+          "--------------------------------------", $dmh:endl,
+          "|   ID   |   State   |  Line  | File", $dmh:endl,
+          "|--------|-----------|--------|-------", $dmh:endl,
+          fn:string-join(
+            for $b in $bs
+            return
+              fn:concat(
+                "| ", dmh:lpottl($b/@id, 6, " "), " ",
+                "| ", if ($b/@state eq "enabled") then "enabled  " else "disabled ", " ",
+                "| ", dmh:lpottl($b/@lineno, 6, " "), " ",
+                "| ", $b/@filename, $dmh:endl),
+            ""
+          ),
+          "--------------------------------------", $dmh:endl
+        )
+      else
+        "No breakpoints set"
+  )
+};
+
+(:~
+ : left-pad-or-trim-to-length
+ :)
+declare %private function dmh:lpottl($value as xs:string, $length as xs:integer, $padChar as xs:string)
+ as xs:string
+{
+  let $padChar := fn:substring($padChar, 1, 1)
+  let $len := fn:string-length($value)
+  return
+    if ($len < $length) then
+      let $pad :=
+        fn:string-join(
+          for $i in 1 to $length - $len
+          return $padChar,
+          ""
+        )
+      return
+        fn:concat($pad, $value)
+    else
+      fn:substring($value, $len - $length + 1)
+};
+
+declare %private function dmh:breakpoint-remove($resp as element(response))
+{
+  "Breakpoint removed"
+};
+
+declare %private function dmh:stack-depth($resp as element(response))
+{
+  fn:concat("depth: ", $resp/@depth)
+};
+
+declare %private function dmh:stack-get($resp as element(response))
+{
+  fn:string-join(
+    for $s in $resp/stack
+    return
+      fn:concat("#", $s/@level, " in ", $s/@where, " at ", $s/@filename, ":", $s/@lineno),
+    $dmh:endl
+  )
+};
+
+
+declare %private function dmh:context-names($resp as element(response))
+{
+  fn:string-join(
+    for $c in $resp/context
+    return
+      fn:concat("context ", $c/@id, ": ", $c/@name),
+    $dmh:endl
+  )
+};
+
+declare %private function dmh:context-get($resp as element(response))
+{
+  fn:string-join(
+    for $p in $resp/property
+    return
+      fn:concat($p/@fullname, " ", $p/@type,
+        if ($p/text() ne "") then
+          fn:concat(": ", base64:decode($p/text()))
+        else
+          ""
+      ),
+    $dmh:endl
+  )
+};
+
+declare %private function dmh:eval($resp as element(response))
+{
+  if ($resp/@success eq "1") then
+    dmh:context-get($resp)
+  else
+    dmh:report-error("An unknown error occured while evaluating expression.")
+};
+
+declare %private function dmh:report-error(
+  $message as xs:string)
+{
+  dmh:report-error($message, ())
+};
+
+declare %private function dmh:report-error(
+  $message as xs:string,
+  $debugMessage as xs:string*)
+{
+  fn:string-join(
+    (
+      (: the error message :)
+      fn:concat("Error: ", $message),
+
+      (: the debug info :)
+      if ($dmh:debug and fn:string-length($debugMessage) gt 0) then
+        $debugMessage
+      else
+        ()
+    ),
+    $dmh:endl
+  )
+};
+
+declare %private function dmh:process-response($resp as element(response))
+{
+  switch ($resp/@command)
+  case "eval"               return dmh:eval($resp)
+  case "context_get"        return dmh:context-get($resp)
+  case "context_names"      return dmh:context-names($resp)
+  case "stack_get"          return dmh:stack-get($resp)
+  case "stack_depth"        return dmh:stack-depth($resp)
+  case "breakpoint_remove"  return dmh:breakpoint-remove($resp)
+  case "breakpoint_list"    return dmh:breakpoint-list($resp)
+  case "breakpoint_get"     return dmh:breakpoint-get($resp)
+  case "breakpoint_set"     return dmh:breakpoint-set($resp)
+  case "source"             return dmh:source($resp)
+
+  (: continuation command only need to display/process the status :)
+  case "run"
+  case "step_into"
+  case "step_out"
+  case "step_over"
+  case "stop"
+  case "status"
+    return dmh:status($resp)
+
+  default
+    return dmh:report-error(fn:concat("Command not implemented: ", $resp/@command))
+};
+
+declare function dmh:process-init($init as element(init))
+{
+  fn:string-join(
+    ("Established connection with", $init/@language, "client", $init/@appid),
+    " "
+  )
+};
+
+declare function dmh:process($message as element())
+{
+  let $nodeName := fn:local-name($message)
+  let $id := fn:data($message/@transaction_id)
+  return
+    if ($nodeName eq "response") then
+      (: no transaction_id :)
+      if (fn:count($id) eq 0 or $id eq "") then
+        (0, dmh:report-error("Invalid response", "Missing or empty response transaction ID."))
+      (: wrong transaction_id :)
+      else if (xs:string(fn:number($id)) eq "NaN") then
+        (0, dmh:report-error("Invalid response", "Invalid value for response transaction ID."))
+      (: no or empty command :)
+      else if (fn:count($message/@command) eq 0 or $message/@command eq "") then
+        ($id, dmh:report-error("Invalid response", "Missing or empty response command attribute."))
+      (: error response :)
+      else if (fn:exists($message/error)) then
+        ($id, dmh:report-error(fn:data($message/error/message), fn:concat("Error code: ", fn:data($message/error/@code))))
+      else
+        ($id, dmh:process-response($message))
+    else if ($nodeName eq "init") then
+      (0, dmh:process-init($message))
+    else
+      (
+        if (fn:count($id) eq 0 or $id eq "" or xs:string(fn:number($id)) eq "NaN") then
+          0
+        else
+          $id,
+        dmh:report-error(fn:concat("Unknown message node: ", $nodeName))
+      )
+};
 
=== modified file 'src/compiler/expression/expr.cpp'
--- src/compiler/expression/expr.cpp	2011-12-20 09:04:58 +0000
+++ src/compiler/expression/expr.cpp	2011-12-20 18:15:30 +0000
@@ -1469,7 +1469,6 @@
   compute_scripting_kind();
 }
 
-
 void debugger_expr::serialize(::zorba::serialization::Archiver& ar)
 {
   serialize_baseclass(ar, (expr*)this);
 
=== modified file 'src/compiler/translator/translator.cpp'
--- src/compiler/translator/translator.cpp	2011-12-20 11:50:23 +0000
+++ src/compiler/translator/translator.cpp	2011-12-20 18:15:30 +0000
@@ -1671,7 +1671,7 @@
 void wrap_in_debugger_expr(
   expr_t& aExpr,
   const QueryLoc& aLoc,
-  bool aAddBreakable = true,
+  bool aIsMainModuleBreakable = false,
   bool aIsVarDeclaration = false)
 {
 #ifdef ZORBA_WITH_DEBUGGER
@@ -1686,9 +1686,7 @@
     // add the breakable expression in the debugger commons as a possible
     // breakpoint location
     Breakable lBreakable(aLoc);
-    if (aAddBreakable) {
-      theCCB->theDebuggerCommons->addBreakable(lBreakable);
-    }
+    theCCB->theDebuggerCommons->addBreakable(lBreakable, aIsMainModuleBreakable);
 
     // retrieve all variables that are in the current scope
     typedef std::vector<var_expr_t> VarExprVector;
@@ -2246,7 +2244,7 @@
   // the main module debug iterator has no location otherwise
   // this would take precedence over a child debug iterator
   // starting in the same line
-  wrap_in_debugger_expr(program, program->get_loc(), false);
+  wrap_in_debugger_expr(program, program->get_loc(), true);
 
   program = wrap_in_globalvar_assign(program);
 
@@ -3725,7 +3723,7 @@
       QueryLoc lExpandedLocation = expandQueryLoc(v.get_name()->get_location(),
                                                   initExpr->get_loc());
 
-      wrap_in_debugger_expr(initExpr, lExpandedLocation, true, true);
+      wrap_in_debugger_expr(initExpr, lExpandedLocation, false, true);
     }
 #endif
 
@@ -3747,7 +3745,7 @@
       QueryLoc lExpandedLocation = expandQueryLoc(v.get_name()->get_location(),
                                                   initExpr->get_loc());
 
-      wrap_in_debugger_expr(initExpr, lExpandedLocation, true, true);
+      wrap_in_debugger_expr(initExpr, lExpandedLocation, false, true);
     }
 #endif
 
 
=== modified file 'src/debugger/debugger_client.cpp'
--- src/debugger/debugger_client.cpp	2011-06-14 17:26:33 +0000
+++ src/debugger/debugger_client.cpp	2011-12-20 18:15:30 +0000
@@ -38,5 +38,3 @@
 }
 
 }//end of namespace
-
-/* vim:set et sw=2 ts=2: */
 
=== modified file 'src/debugger/debugger_clientimpl.cpp'
--- src/debugger/debugger_clientimpl.cpp	2011-07-06 20:43:46 +0000
+++ src/debugger/debugger_clientimpl.cpp	2011-12-20 18:15:30 +0000
@@ -24,462 +24,549 @@
 
 namespace zorba {
   
-  DebuggerClient::~DebuggerClient()
-  {}
-  
-  DebuggerClient* DebuggerClient::createDebuggerClient(DebuggerEventHandler* aHandler,
-                                       unsigned short aPort,
-                                       const std::string& aHost)
-  {
-    return new DebuggerClientImpl(aHost, aPort, aHandler);
-  }
-  
-  DebuggerListener::DebuggerListener(DebuggerClientImpl* aClient)
+DebuggerClient*
+DebuggerClient::createDebuggerClient(
+  DebuggerEventHandler* aHandler,
+  unsigned short aPort,
+  const std::string& aHost)
+{
+  return new DebuggerClientImpl(aHost, aPort, aHandler);
+}
+
+// ****************************************************************************
+
+DebuggerListener::DebuggerListener(DebuggerClientImpl* aClient)
   : theClient(aClient), theStopLooping(false)
-  {
-  }
-  
-  void DebuggerListener::run()
-  {
-    while (!theStopLooping) {
-      std::string str;
-      std::getline(*(theClient->theStream), str, '\0');
-#ifndef NDEBUG
-      std::stringstream lStr(str);
-      std::size_t length;
-      lStr >> length;
-#endif
-      // we are not interested in the length, but only in the init
-      // message
-      std::getline(*(theClient->theStream), str, '\0');
-#ifndef NDEBUG
-      assert(str.size() == length);
-#endif
-      theClient->theHandler->parseMessage(str);
-      this->sleep_(1000);
-    }
-  }
-  
-  void DebuggerListener::finish()
-  {
-  }
-  
-  void DebuggerListener::stopLooping()
-  {
-    theStopLooping = true;
-  }
-  
-  DebuggerClientImpl::DebuggerClientImpl(const std::string& aHost,
-                                         unsigned short aPort,
-                                         DebuggerEventHandler* aHandler)
-  : theServerSocket(aHost, aPort), theSocket(0), theStreamBuffer(0), theStream(0),
-  theHandler(aHandler), theListener(this), theLastId(0)
-  {
-  }
-  
-  void DebuggerClientImpl::accept() {
-    theSocket = theServerSocket.accept();
-    theStreamBuffer = new socket_streambuf(*theSocket);
-    theStream = new std::iostream(theStreamBuffer);
-    theListener.start();
-  }
-  
-  std::size_t DebuggerClientImpl::status()
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "status -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::feature_get(std::string const& aFeatureName)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "feature-get -i " << id << " -n " << aFeatureName << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::feature_set(std::string const &aFeatureName,
-                                              std::string const &aValue)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "feature-set -i " << id << " -n " << aFeatureName << " -v "
-               << aValue << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::run()
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "run -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::step_into()
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "step_into -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::step_over()
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "step_over -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::step_out()
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "step_out -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::stop()
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "stop -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::detach()
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "detach -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::breakpoint_set(BreakpointType aType,
-                                                 bool aEnabled,
-                                                 const std::string& aFilename,
-                                                 int aLinenumber,
-                                                 const std::string& aFunctionName,
-                                                 const std::string& aExceptionName,
-                                                 unsigned hit_value,
-                                                 HitCondition aCondition,
-                                                 bool aIsTemporary,
-                                                 const std::string& aExpression)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "breakpoint_set -i " << id
-               << " -t ";
-    switch (aType) {
-      case Line:
-        *theStream << "line";
-        break;
-      case Call:
-        *theStream << "call";
-        break;
-      case Return:
-        *theStream << "return";
-        break;
-      case Exception:
-        *theStream << "exception";
-        break;
-      case Conditional:
-        *theStream << "conditional";
-        break;
-      case Watch:
-        *theStream << "watch";
-        break;
-    }
-    if (!aEnabled)
-      *theStream << " -s disabled";
-    if (aFilename != "") {
-      *theStream << " -f " << aFilename;
-    }
-    if (aLinenumber != -1)
-      *theStream << " -n " << aLinenumber;
-    if (aFunctionName != "")
-      *theStream << " -m " << aFunctionName;
-    if (aExceptionName != "")
-      *theStream << " -x " << aExceptionName;
-    if (hit_value != 0)
-      *theStream << " -h " << hit_value;
-    switch (aCondition) {
-      case BiggerEqual:
-        break;
-      case Equal:
-        *theStream << " -o == ";
-        break;
-      case Multiple:
-        *theStream << " -o % ";
-    }
-    if (aIsTemporary)
-      *theStream << " -r 1 ";
-    if (aExpression != "")
-      *theStream << " -- " << aExpression;
-    *theStream << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::breakpoint_get(std::size_t aBreakpointId)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "breakpoint_get -i " << id << " -d " << aBreakpointId << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::breakpoint_update(std::size_t aBreakpointId,
-                                                    bool aEnabled,
-                                                    int aLinenumber,
-                                                    unsigned hit_value,
-                                                    HitCondition aCondition)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "breakpoint_update -i " << id
-               << " -d " << aBreakpointId;
-    if (aEnabled)
-      *theStream << " -s disabled";
-    if (aLinenumber != -1)
-      *theStream << " -n " << aLinenumber;
-    if (hit_value != 0)
-      *theStream << " -h " << hit_value;
-    switch (aCondition) {
-      case BiggerEqual:
-        break;
-      case Equal:
-        *theStream << " -o == ";
-        break;
-      case Multiple:
-        *theStream << " -o % ";
-    }
-    *theStream << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::breakpoint_remove(std::size_t aBreakpointId)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "breakpoint_remove -i " << id << " -d " << aBreakpointId << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::breakpoint_list()
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "breakpoint_list -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::stack_depth()
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "stack_depth -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::stack_get(int depth)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "stack_depth";
-    if (depth > 0)
-      *theStream << " -d " << depth;
-    *theStream << " -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::context_names(int depth)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "context_names";
-    if (depth > 0)
-      *theStream << " -d " << depth;
-    *theStream << " -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::context_get(int depth, int contextId)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "context_get";
-    if (depth > 0)
-      *theStream << " -d " << depth;
-    if (contextId > 0)
-      *theStream << " -c " << contextId;
-    *theStream << " -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::typemap_get()
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "typemap_get -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::property_get(const std::string& aPropertyLongName,
-                                               int aStackDepth,
-                                               int aContextId,
-                                               std::size_t aMaxDataSize,
-                                               int aDatapage,
-                                               const std::string& aPropertyKey)
-  {
-    std::size_t id = property_x("property_get", aPropertyLongName, aStackDepth, aContextId, aMaxDataSize);
-    if (aDatapage >= 0)
-      *theStream << " -p " << aDatapage;
-    if (aPropertyKey != "")
-      *theStream << " -k " << aPropertyKey;
-    *theStream << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::property_set(const std::string& aPropertyLongName,
-                                               int aStackDepth,
-                                               int aContextId,
-                                               std::size_t aMaxDataSize,
-                                               const std::string& aPropertyAddress)
-  {
-    std::size_t id = property_x("property_set", aPropertyLongName, aStackDepth, aContextId, aMaxDataSize);
-    if (aPropertyAddress != "")
-      *theStream << " -a " << aPropertyAddress;
-    *theStream << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::property_value(const std::string& aPropertyLongName,
-                                                 int aStackDepth,
-                                                 int aContextId,
-                                                 std::size_t aMaxDataSize,
-                                                 int aDatapage,
-                                                 const std::string& aPropertyKey,
-                                                 const std::string& aPropertyAddress)
-  {
-    std::size_t id = property_x("property_get", aPropertyLongName, aStackDepth, aContextId, aMaxDataSize);
-    if (aDatapage >= 0)
-      *theStream << " -p " << aDatapage;
-    if (aPropertyKey != "")
-      *theStream << " -k " << aPropertyKey;
-    if (aPropertyAddress != "")
-      *theStream << " -a " << aPropertyAddress;
-    *theStream << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::property_x(const std::string& aCommand,
-                                             const std::string& aPropertyLongName,
-                                             int aStackDepth,
-                                             int aContextId,
-                                             std::size_t aMaxDataSize)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << aCommand << " -i " << id << " -n " << aPropertyLongName;
-    if (aStackDepth > 0)
-      *theStream << " -d " << aStackDepth;
-    if (aContextId > 0)
-      *theStream << " -c " << aContextId;
-    if (aMaxDataSize > 0)
-      *theStream << " -m " << aMaxDataSize;
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::source(std::string const &aFile,
-                                         unsigned int aBeginLine,
-                                         unsigned int aEndLine)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "source -i " << id << " -f " << aFile;
-    if (aBeginLine)
-      *theStream << " -b " << aBeginLine;
-    if (aEndLine)
-      *theStream << " -e " << aEndLine;
-    *theStream << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::stream_option(OutputStream aStream, StreamBehaviour aBehaviour)
-  {
-    std::size_t id = ++theLastId;
-    switch (aStream) {
-      case Stdout:
-        *theStream << "stdout";
-        break;
-      case Stderr:
-        *theStream << "stderr";
-        break;
-      case Stdin:
-        *theStream << "stdin";
-        break;
-    }
-    *theStream << " -i " << id << " -c ";
-    switch (aBehaviour) {
-      case Disable:
-        *theStream << "0";
-        break;
-      case CopyData:
-        *theStream << "1";
-        break;
-      case Redirection:
-        *theStream << "2";
-        break;
-    }
-    *theStream << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::do_break()
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "break -i " << id << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  std::size_t DebuggerClientImpl::eval(std::string const &aExpr)
-  {
-    std::size_t id = ++theLastId;
-    *theStream << "eval -i " << id << " -- " << encoding::Base64::encode(aExpr.c_str()) << '\0';
-    theStream->sync();
-    return id;
-  }
-  
-  void DebuggerClientImpl::quit() {
-    theListener.stopLooping();
-    theListener.join();
-  }
-  
-  
-  
-  DebuggerClientImpl::~DebuggerClientImpl()
-  {
-    if (theListener.status() == DebuggerListener::RUNNING) {
-      theListener.stopLooping();
-      theListener.join();
-    }
-    if (theSocket) {
-      theSocket->close();
-      theSocket->cleanUp();
-      delete theSocket;
-    }
-    if (theStream) {
-      theStream->sync();
-      delete theStream;
-      delete theStreamBuffer;
-    }
-  }
-}
+{
+}
+
+void
+DebuggerListener::run()
+{
+  while (!theStopLooping) {
+    std::string str;
+    std::getline(*(theClient->theInStream), str, '\0');
+
+#ifndef NDEBUG
+    std::stringstream lStr(str);
+    std::size_t length;
+    lStr >> length;
+#endif
+
+    // we are not interested in the length, but only in the init message
+    std::getline(*(theClient->theInStream), str, '\0');
+
+#ifndef NDEBUG
+    assert(str.size() == length);
+#endif
+
+    theClient->theHandler->parseMessage(str);
+
+    // TODO: this was the initial implementation. This will have to change
+    this->sleep_(1000);
+  }
+}
+  
+void
+DebuggerListener::finish()
+{
+}
+
+void
+DebuggerListener::stopLooping()
+{
+  theStopLooping = true;
+}
+
+// ****************************************************************************
+
+DebuggerClient::~DebuggerClient()
+{
+}
+
+DebuggerClientImpl::DebuggerClientImpl(
+  const std::string& aHost,
+  unsigned short aPort,
+  DebuggerEventHandler* aHandler)
+  : theServerSocket(aHost, aPort),
+    theSocket(0),
+    theInStreamBuffer(0),
+    theOutStreamBuffer(0),
+    theInStream(0),
+    theOutStream(0),
+    theHandler(aHandler),
+    theListener(0),
+    theLastId(0)
+{
+}
+
+DebuggerClientImpl::~DebuggerClientImpl()
+{
+  if (theListener) {
+    if (theListener->status() == DebuggerListener::RUNNING) {
+      theListener->stopLooping();
+      theListener->join();
+    }
+    delete theListener;
+  }
+  if (theSocket) {
+    theInStream->sync();
+    delete theInStream;
+
+    theOutStream->flush();
+    delete theInStream;
+
+    delete theOutStreamBuffer;
+    delete theInStreamBuffer;
+
+    theSocket->close();
+    theSocket->cleanUp();
+    delete theSocket;
+  }
+}
+  
+void
+DebuggerClientImpl::accept()
+{
+  theListener = new DebuggerListener(this);
+  theSocket = theServerSocket.accept();
+  theInStreamBuffer = new SocketStreambuf(*theSocket);
+  theOutStreamBuffer = new SocketStreambuf(*theSocket);
+  theInStream = new std::istream(theInStreamBuffer);
+  theOutStream = new std::ostream(theOutStreamBuffer);
+  theListener->start();
+}
+  
+std::size_t
+DebuggerClientImpl::status()
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "status -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::variables()
+{
+  // we hack the protocol to return all properties if the context ID is -1
+  std::size_t id = ++theLastId;
+  *theOutStream << "context_get -c -1 -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::feature_get(std::string const& aFeatureName)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "feature_get -i " << id << " -n " << aFeatureName << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::feature_set(std::string const &aFeatureName,
+                                            std::string const &aValue)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "feature_set -i " << id << " -n " << aFeatureName << " -v "
+              << aValue << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::run()
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "run -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::step_into()
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "step_into -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::step_over()
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "step_over -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::step_out()
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "step_out -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::stop()
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "stop -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::detach()
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "detach -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+
+std::size_t
+DebuggerClientImpl::breakpoint_set(
+  BreakpointType aType,
+  bool aEnabled,
+  const std::string& aFilename,
+  int aLinenumber,
+  const std::string& aFunctionName,
+  const std::string& aExceptionName,
+  unsigned hit_value,
+  HitCondition aCondition,
+  bool aIsTemporary,
+  const std::string& aExpression)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "breakpoint_set -i " << id
+              << " -t ";
+  switch (aType) {
+    case Line:
+      *theOutStream << "line";
+      break;
+    case Call:
+      *theOutStream << "call";
+      break;
+    case Return:
+      *theOutStream << "return";
+      break;
+    case Exception:
+      *theOutStream << "exception";
+      break;
+    case Conditional:
+      *theOutStream << "conditional";
+      break;
+    case Watch:
+      *theOutStream << "watch";
+      break;
+  }
+  if (!aEnabled)
+    *theOutStream << " -s disabled";
+  if (aFilename != "") {
+    *theOutStream << " -f \"" << aFilename << "\"";
+  }
+  if (aLinenumber != -1)
+    *theOutStream << " -n " << aLinenumber;
+  if (aFunctionName != "")
+    *theOutStream << " -m " << aFunctionName;
+  if (aExceptionName != "")
+    *theOutStream << " -x " << aExceptionName;
+  if (hit_value != 0)
+    *theOutStream << " -h " << hit_value;
+  switch (aCondition) {
+    case BiggerEqual:
+      break;
+    case Equal:
+      *theOutStream << " -o == ";
+      break;
+    case Multiple:
+      *theOutStream << " -o % ";
+  }
+  if (aIsTemporary)
+    *theOutStream << " -r 1 ";
+  if (aExpression != "")
+    *theOutStream << " -- " << aExpression;
+  *theOutStream << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::breakpoint_get(std::size_t aBreakpointId)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "breakpoint_get -i " << id << " -d " << aBreakpointId << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::breakpoint_update(
+  std::size_t aBreakpointId,
+  bool aEnabled,
+  int aLinenumber,
+  unsigned hit_value,
+  HitCondition aCondition)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "breakpoint_update -i " << id
+              << " -d " << aBreakpointId;
+  if (aEnabled)
+    *theOutStream << " -s disabled";
+  if (aLinenumber != -1)
+    *theOutStream << " -n " << aLinenumber;
+  if (hit_value != 0)
+    *theOutStream << " -h " << hit_value;
+  switch (aCondition) {
+    case BiggerEqual:
+      break;
+    case Equal:
+      *theOutStream << " -o == ";
+      break;
+    case Multiple:
+      *theOutStream << " -o % ";
+  }
+  *theOutStream << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::breakpoint_remove(std::size_t aBreakpointId)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "breakpoint_remove -i " << id << " -d " << aBreakpointId << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::breakpoint_list()
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "breakpoint_list -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::stack_depth()
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "stack_depth -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::stack_get(int depth)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "stack_get";
+  if (depth >= 0) {
+    *theOutStream << " -d " << depth;
+  }
+  *theOutStream << " -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::context_names(int depth)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "context_names";
+  if (depth >= 0) {
+    *theOutStream << " -d " << depth;
+  }
+  *theOutStream << " -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+
+std::size_t
+DebuggerClientImpl::context_get(int depth, int contextId)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "context_get";
+  if (depth >= 0) {
+    *theOutStream << " -d " << depth;
+  }
+  if (contextId >= 0){
+    *theOutStream << " -c " << contextId;
+  }
+  *theOutStream << " -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+
+std::size_t
+DebuggerClientImpl::typemap_get()
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "typemap_get -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::property_get(
+  const std::string& aPropertyLongName,
+  int aStackDepth,
+  int aContextId,
+  std::size_t aMaxDataSize,
+  int aDatapage,
+  const std::string& aPropertyKey)
+{
+  std::size_t id = property_x("property_get", aPropertyLongName, aStackDepth, aContextId, aMaxDataSize);
+  if (aDatapage >= 0)
+    *theOutStream << " -p " << aDatapage;
+  if (aPropertyKey != "")
+    *theOutStream << " -k " << aPropertyKey;
+  *theOutStream << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::property_set(
+  const std::string& aPropertyLongName,
+  int aStackDepth,
+  int aContextId,
+  std::size_t aMaxDataSize,
+  const std::string& aPropertyAddress)
+{
+  std::size_t id = property_x("property_set", aPropertyLongName, aStackDepth, aContextId, aMaxDataSize);
+  if (aPropertyAddress != "")
+    *theOutStream << " -a " << aPropertyAddress;
+  *theOutStream << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::property_value(
+  const std::string& aPropertyLongName,
+  int aStackDepth,
+  int aContextId,
+  std::size_t aMaxDataSize,
+  int aDatapage,
+  const std::string& aPropertyKey,
+  const std::string& aPropertyAddress)
+{
+  std::size_t id = property_x("property_get", aPropertyLongName, aStackDepth, aContextId, aMaxDataSize);
+  if (aDatapage >= 0)
+    *theOutStream << " -p " << aDatapage;
+  if (aPropertyKey != "")
+    *theOutStream << " -k " << aPropertyKey;
+  if (aPropertyAddress != "")
+    *theOutStream << " -a " << aPropertyAddress;
+  *theOutStream << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::property_x(
+  const std::string& aCommand,
+  const std::string& aPropertyLongName,
+  int aStackDepth,
+  int aContextId,
+  std::size_t aMaxDataSize)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << aCommand << " -i " << id << " -n " << aPropertyLongName;
+  if (aStackDepth > 0)
+    *theOutStream << " -d " << aStackDepth;
+  if (aContextId > 0)
+    *theOutStream << " -c " << aContextId;
+  if (aMaxDataSize > 0)
+    *theOutStream << " -m " << aMaxDataSize;
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::source(
+  std::string const &aFile,
+  unsigned int aBeginLine,
+  unsigned int aEndLine)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "source -i " << id;
+  // enable zorba extensions
+  *theOutStream << " -z 1";
+  *theOutStream << " -f \"" << aFile << "\"";
+  if (aBeginLine)
+    *theOutStream << " -b " << aBeginLine;
+  if (aEndLine)
+    *theOutStream << " -e " << aEndLine;
+  *theOutStream << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::stream_option(OutputStream aStream, StreamBehaviour aBehaviour)
+{
+  std::size_t id = ++theLastId;
+  switch (aStream) {
+    case Stdout:
+      *theOutStream << "stdout";
+      break;
+    case Stderr:
+      *theOutStream << "stderr";
+      break;
+    case Stdin:
+      *theOutStream << "stdin";
+      break;
+  }
+  *theOutStream << " -i " << id << " -c ";
+  switch (aBehaviour) {
+    case Disable:
+      *theOutStream << "0";
+      break;
+    case CopyData:
+      *theOutStream << "1";
+      break;
+    case Redirection:
+      *theOutStream << "2";
+      break;
+  }
+  *theOutStream << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::do_break()
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "break -i " << id << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+std::size_t
+DebuggerClientImpl::eval(std::string const &aExpr)
+{
+  std::size_t id = ++theLastId;
+  *theOutStream << "eval -i " << id << " -- " << encoding::Base64::encode(aExpr.c_str()) << '\0';
+  theOutStream->flush();
+  return id;
+}
+  
+void
+DebuggerClientImpl::quit()
+{
+  theListener->stopLooping();
+  theListener->join();
+}
+
+} // namespace zorba
 
=== modified file 'src/debugger/debugger_clientimpl.h'
--- src/debugger/debugger_clientimpl.h	2011-07-01 01:53:24 +0000
+++ src/debugger/debugger_clientimpl.h	2011-12-20 18:15:30 +0000
@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#pragma once
+#ifndef ZORBA_DEBUGGER_CLIENTIMPL_H
+#define ZORBA_DEBUGGER_CLIENTIMPL_H
 
 #include <string>
 #include <zorba/debugger_client.h>
@@ -21,7 +22,7 @@
 #include "zorbautils/runnable.h"
 
 namespace zorba {
-  class socket_streambuf;
+  class SocketStreambuf;
   class DebuggerEventHandler;
   class DebuggerListener;
   class DebuggerClientImpl;
@@ -48,6 +49,7 @@
   public: // API
     virtual void accept();
     virtual std::size_t status();
+    virtual std::size_t variables();
     virtual std::size_t feature_get(const std::string& aFeatureName);
     virtual std::size_t feature_set(const std::string& aFeatureName,
                                     const std::string& aValue);
@@ -110,12 +112,17 @@
                            int aContextId = -1,
                            std::size_t aMaxDataSize = 0);
   private:
-    TCPServerSocket theServerSocket;
-    TCPSocket* theSocket;
-    socket_streambuf* theStreamBuffer;
-    std::iostream* theStream;
+    TCPServerSocket       theServerSocket;
+    TCPSocket*            theSocket;
+    SocketStreambuf*      theInStreamBuffer;
+    SocketStreambuf*      theOutStreamBuffer;
+    std::istream*         theInStream;
+    std::ostream*         theOutStream;
     DebuggerEventHandler* theHandler;
-    DebuggerListener theListener;
-    std::size_t theLastId;
+    DebuggerListener*     theListener;
+    std::size_t           theLastId;
   };
-}
+
+} // namespace zorba
+
+#endif // ZORBA_DEBUGGER_CLIENTIMPL_H
 
=== modified file 'src/debugger/debugger_common.h'
--- src/debugger/debugger_common.h	2011-06-22 11:19:07 +0000
+++ src/debugger/debugger_common.h	2011-12-20 18:15:30 +0000
@@ -20,22 +20,15 @@
 #include "common/common.h"
 
 /* Type definitions */
-typedef unsigned char StepCommand;
 typedef unsigned char ExecutionStatus;
 typedef unsigned short SuspensionCause;
 
-/* Kind of step command */
-const StepCommand STEP_INTO   = 0x01;
-const StepCommand STEP_OUT    = 0x02;
-const StepCommand STEP_OVER   = 0x03;
-
 /* Status of the engine */
 const ExecutionStatus QUERY_IDLE       = 0x01;
 const ExecutionStatus QUERY_RUNNING    = 0x02;
-const ExecutionStatus QUERY_RESUMED    = 0x03;
-const ExecutionStatus QUERY_SUSPENDED  = 0x04;
-const ExecutionStatus QUERY_TERMINATED = 0x05;
-const ExecutionStatus QUERY_DETACHED   = 0x06;
+const ExecutionStatus QUERY_SUSPENDED  = 0x03;
+const ExecutionStatus QUERY_TERMINATED = 0x04;
+const ExecutionStatus QUERY_DETACHED   = 0x05;
 
 /* Cause of the suspension of the engine */
 const SuspensionCause CAUSE_USER               = 0x01;
 
=== modified file 'src/debugger/debugger_commons.cpp'
--- src/debugger/debugger_commons.cpp	2011-06-22 11:19:07 +0000
+++ src/debugger/debugger_commons.cpp	2011-12-20 18:15:30 +0000
@@ -151,13 +151,11 @@
     theBreakCondition(0),
     theExecEval(false),
     theStepping(false)
-    
 {
   theRuntime = NULL;
   theCurrentStaticContext = NULL;
   theCurrentDynamicContext = NULL;
   thePlanState = NULL;
-  theDebugIteratorState = NULL;
 }
 
 DebuggerCommons::~DebuggerCommons()
@@ -185,8 +183,6 @@
 
   if(ar.is_serializing_out())
     thePlanState = NULL;
-  if(ar.is_serializing_out())
-    theDebugIteratorState = NULL;
   ar & theEvalItem;
   ar & theExecEval;
   ar & theStepping;
@@ -230,17 +226,98 @@
 }
 
 unsigned int
-DebuggerCommons::addBreakpoint(const QueryLoc& aLocation, bool aEnabled)
+DebuggerCommons::addBreakpoint(String& aFileName, int aLine, bool aEnabled)
 {
-  BreakableIdMap::iterator lIter = theBreakableIDs.find(aLocation);
+  QueryLoc lLocation;
+  lLocation.setLineBegin(aLine);
+  lLocation.setLineEnd(aLine);
+  lLocation.setFilename(aFileName.c_str());
+
+  // we make sure that the this location file name is aligned with the internal ones
+  // it must have a valid URI and a scheme (file://, http://, or https://)
+  adjustLocationFilePath(lLocation);
+
+  BreakableIdMap::iterator lIter = theBreakableIDs.find(lLocation);
+  unsigned int lId;
 
   if (lIter == theBreakableIDs.end()) {
+    String lFileName = aFileName;
+    // be prepared to throw an exception
     std::stringstream lSs;
-    lSs << "The breakpoint could not be set at line " << aLocation.getLineBegin()
-      << " in file: " << aLocation.getFilename();
-    throw lSs.str();
-  }
-  unsigned int lId = lIter->second;
+    lSs << "The breakpoint could not be set at line " << aLine
+      << " in file \"" << lFileName << "\"";
+
+    // let us then try some search before we fail, be good to the user and help him
+    // 1. first we check if he sent a file URI; in this case, sorry!
+    if (lFileName.find("file://") == 0) {
+      throw lSs.str();
+    }
+
+    // now we have to normalize if we hope to find something
+    lFileName = URIHelper::encodeFileURI(lFileName).str();
+    // remove the added file schema prefix
+    // TODO: maybe there is a better way to do this encoding
+    lFileName = lFileName.substr(8);
+
+    // 2. secondly we hope he gave us part of a path of a file
+    lIter = theBreakableIDs.begin();
+    String::size_type lFileNameSize = lFileName.size();
+    std::vector<std::pair<QueryLoc, int> > lFoundBreakables;
+    zorba::String lFirstBreakablePath;
+    while (lIter != theBreakableIDs.end()) {
+      // for now, only valid if on the breakable is on the same line as requested
+      // TODO: this could be improved if the user wants to add a breakpoint to a line
+      //       INSIDE a breakable that spans over multiple lines
+      if (lIter->second != theMainModuleBreakableId && lIter->first.getLineBegin() == aLine) {
+        zorba::String lBreakablePath = lIter->first.getFilename().str();
+
+        // dies the given string matche any part in the breakable file name?
+        if (lBreakablePath.find(lFileName) != String::npos) {
+          // we found the fist candidate path
+          if (lFirstBreakablePath == "") {
+            lFirstBreakablePath = lBreakablePath;
+          }
+          // but stop as soon as we are reaching a second different path (report ambiguity)
+          else if (lFirstBreakablePath != lBreakablePath){
+            lSs.str("");
+            lSs << "The file name \"" << aFileName << "\" is ambiguous. "
+              << "I already found two potential files to set a breakpoint in line " << aLine
+              << ":" << std::endl << "  " << lFirstBreakablePath << std::endl << "  " << lBreakablePath;
+            throw lSs.str();
+          }
+
+          // Yes! We found one!
+          lFoundBreakables.push_back(std::pair<QueryLoc, int>(lIter->first, lIter->second));
+        }
+      }
+      lIter++;
+    }
+
+    // what should I say, not a very successful search :(
+    if (lFoundBreakables.size() == 0) {
+      throw lSs.str();
+    }
+
+    // TODO: The best solution would be for the debugger to enable all the
+    // matched breakables but the protocol can send back only one ID of the
+    // breakpoint set.
+
+    // so we have multiple breakables, get the first in line
+    // TODO: this does not catch multiple breakables starting in the same line
+    // so only one will be picked (depending how the translator generated them)
+    unsigned int lMinCol = lFoundBreakables.at(0).first.getColumnBegin();
+    lId = lFoundBreakables.at(0).second;
+    for (std::size_t i = 1; i < lFoundBreakables.size(); i++) {
+      if (lMinCol > lFoundBreakables.at(i).first.getColumnBegin()) {
+        lId = lFoundBreakables.at(i).second;
+      }
+    }
+  }
+  else {
+    lId = lIter->second;
+  }
+
+  // now we have a breakable, so set it accordingly
   theBreakables[lId].setSet(true);
   theBreakables[lId].setEnabled(aEnabled);
   return lId;
@@ -253,6 +330,12 @@
   return theBreakables[aId];
 }
 
+BreakableVector
+DebuggerCommons::getBreakpoints()
+{
+  return theBreakables;
+}
+
 void
 DebuggerCommons::checkBreakpoint(unsigned int aId)
 {
@@ -338,6 +421,7 @@
 bool
 DebuggerCommons::hasToBreakAt(QueryLoc aLocation)
 {
+  // we make sure that this location file name is a valid URI and has a scheme (file://, http://, or https://)
   adjustLocationFilePath(aLocation);
 
   BreakableIdMap::const_iterator lIter = theBreakableIDs.find(aLocation);
@@ -449,14 +533,6 @@
   ZORBA_ASSERT(thePlanState == aPlanState);
 }
 
-void
-DebuggerCommons::setDebugIteratorState(DebugIteratorState* aState)
-{
-  theDebugIteratorState = aState;
-  //Check postconditions
-  ZORBA_ASSERT(theDebugIteratorState == aState);
-}
-
 std::list<std::pair<zstring, zstring> >
 DebuggerCommons::eval(const zstring& aExpr, Zorba_SerializerOptions& aSerOpts)
 {
@@ -511,11 +587,17 @@
 }
 
 void
-DebuggerCommons::addBreakable(Breakable& aBreakable)
+DebuggerCommons::addBreakable(
+  Breakable& aBreakable,
+  bool aIsMainModuleBreakable)
 {
+  // we make sure that this breakable file name is a valid URI and has a scheme (file://, http://, or https://)
   adjustLocationFilePath(aBreakable.getLocation());
 
   unsigned int lId = theBreakables.size();
+  if (aIsMainModuleBreakable) {
+    theMainModuleBreakableId = lId;
+  }
   theBreakables.push_back(aBreakable);
   theBreakableIDs[aBreakable.getLocation()] = lId;
 }
@@ -523,6 +605,9 @@
 void
 DebuggerCommons::pushStackFrame(QueryLoc aLocation, std::string& aFunctionName)
 {
+  // we make sure that the stack frame locations always have valid URIs and a scheme (file://, http://, or https://)
+  adjustLocationFilePath(aLocation);
+
   theStackTrace.push_back(std::pair<QueryLoc, std::string>(aLocation, aFunctionName));
 }
 
@@ -541,11 +626,24 @@
 void
 DebuggerCommons::adjustLocationFilePath(QueryLoc& aLocation)
 {
-  if (aLocation.getFilename().substr(0, 7) == "file://") {
-    // adjust the file paths by removing the schema and encoding
-    zstring lOldFilename(aLocation.getFilename());
+  zstring lOldFilename(aLocation.getFilename());
+  zstring lPrefix = lOldFilename.substr(0, 7);
+
+  if (lPrefix == "file://") {
+#ifdef WIN32
+    // decode and encode back to solve the driver column encoding: C:, D:, etc.
     const String lNewFilename = URIHelper::decodeFileURI(lOldFilename.str());
-    aLocation.setFilename(lNewFilename.str());
+    const String lNewURI = URIHelper::encodeFileURI(lNewFilename);
+    aLocation.setFilename(lNewURI.str());
+#endif
+    return;
+  }
+
+  // just encode and assume file for non-URI locations
+  if (lPrefix != "http://" && lPrefix != "https:/") {
+    const String lNewURI = URIHelper::encodeFileURI(lOldFilename.str());
+    aLocation.setFilename(lNewURI.str());
+    return;
   }
 }
 
 
=== modified file 'src/debugger/debugger_commons.h'
--- src/debugger/debugger_commons.h	2011-06-22 11:19:07 +0000
+++ src/debugger/debugger_commons.h	2011-12-20 18:15:30 +0000
@@ -19,14 +19,17 @@
 #include <map>
 #include <string>
 
+#include <zorba/util/uri.h>
+#include <zorba/zorba_string.h>
+
 #include "compiler/parser/query_loc.h"
 #include "runtime/core/item_iterator.h"
 
 #include "zorbaserialization/serialization_engine.h"
 #include "zorbatypes/zstring.h"
 
-#include "debugger/debugger_common.h"
-#include "debugger/query_locationimpl.h"
+#include "debugger_common.h"
+#include "query_locationimpl.h"
 
 
 struct Zorba_SerializerOptions;
@@ -208,16 +211,6 @@
     void setPlanState(PlanState* aPlanState);
 
     /**
-    * @brief Sets the current debugger state.
-    *
-    * When the debugger suspends, it saves its state.
-    *
-    * @param aState a pointer to the current debugger state.
-    * @post aState == theDebugIteratorState
-    */
-    void setDebugIteratorState(DebugIteratorState* aState);
-
-    /**
     * @brief Sets a setpoint according to the step out rules.
     *
     * This method sets a breakpoint according to the rules according to
@@ -245,11 +238,14 @@
   public:
 
     unsigned int
-    addBreakpoint(const QueryLoc& location, bool enabled);
+    addBreakpoint(String& fileName, int line, bool enabled);
 
     Breakable
     getBreakpoint(unsigned int id);
 
+    BreakableVector
+    getBreakpoints();
+
     void
     updateBreakpoint(unsigned int id, bool enabled);
 
@@ -336,7 +332,7 @@
     std::string getFilepathOfURI(const std::string& aUri) const;
 
     void
-    addBreakable(Breakable& location);
+    addBreakable(Breakable& location, bool isMainModuleBreakable = false);
 
     void
     pushStackFrame(QueryLoc location, std::string& functionName);
@@ -384,10 +380,10 @@
     std::vector<DebugIterator*>                     theIteratorStack;
     std::size_t                                     theBreakCondition;
     PlanState*                                      thePlanState;
-    DebugIteratorState*                             theDebugIteratorState;
     store::Item_t                                   theEvalItem;
     bool                                            theExecEval;
     bool                                            theStepping;
+    unsigned int                                    theMainModuleBreakableId;
   };
 
 }
 
=== modified file 'src/debugger/debugger_communicator.cpp'
--- src/debugger/debugger_communicator.cpp	2011-07-29 23:01:30 +0000
+++ src/debugger/debugger_communicator.cpp	2011-12-20 18:15:30 +0000
@@ -77,15 +77,15 @@
 void
 DebuggerCommunicator::connect()
 {
-	for (int i = 0; i < 3 && !theSocket; i++)
+	for (int i = 0; i < 5 && !theSocket; i++)
   {
 		try
     {
 			// Connect to the client on the given host and port
       std::auto_ptr<TCPSocket> lSocket(new TCPSocket(theHost, thePort));
       theSocket = lSocket.release();
-      theSocketInStream = new socket_streambuf(*theSocket);
-      theSocketOutStream = new socket_streambuf(*theSocket);
+      theSocketInStream = new SocketStreambuf(*theSocket);
+      theSocketOutStream = new SocketStreambuf(*theSocket);
       theCommunicatorInStream = new std::istream(theSocketInStream);
       theCommunicatorOutStream = new std::ostream(theSocketOutStream);
       theResponseQueue = new ResponseQueue(theCommunicatorOutStream);
 
=== modified file 'src/debugger/debugger_communicator.h'
--- src/debugger/debugger_communicator.h	2011-07-01 16:07:54 +0000
+++ src/debugger/debugger_communicator.h	2011-12-20 18:15:30 +0000
@@ -28,7 +28,7 @@
 namespace zorba {
 
 class TCPSocket;
-class socket_streambuf;
+class SocketStreambuf;
 
 class DebuggerCommunicator {
 
@@ -96,13 +96,13 @@
     
 
     TCPSocket*        theSocket;
-    socket_streambuf* theSocketInStream;
-    socket_streambuf* theSocketOutStream;
+    SocketStreambuf*  theSocketInStream;
+    SocketStreambuf*  theSocketOutStream;
     std::istream*     theCommunicatorInStream;
     std::ostream*     theCommunicatorOutStream;
     ResponseQueue*    theResponseQueue;
 };
 
-}//end of namespace
+} //namespace zorba
 
 #endif // ZORBA_DEBUGGER_COMMUNICATOR_H
 
=== modified file 'src/debugger/debugger_protocol.cpp'
--- src/debugger/debugger_protocol.cpp	2011-06-22 11:19:07 +0000
+++ src/debugger/debugger_protocol.cpp	2011-12-20 18:15:30 +0000
@@ -28,25 +28,17 @@
 DebuggerCommand::DebuggerCommand(std::string& aCommand)
   : theData()
 {
+  // this implements the DBGP command specification:
+  // http://xdebug.org/docs-dbgp.php#ide-to-debugger-engine-communications
+
+  // the debugger client should only send space delimited command
+  // and arguments, therefore we only check for space character
   std::size_t lNameEnd = aCommand.find(" ");
+
+  // first whitespace delimited token is the command name
   theName = aCommand.substr(0, lNameEnd);
-  std::size_t lDataBegin = aCommand.find("--", lNameEnd);
-  std::string lArgs = aCommand.substr(lNameEnd + 1, lDataBegin);
 
-  if (lDataBegin != std::string::npos) {
-    lDataBegin += 2;
-    while (lDataBegin < aCommand.size()) {
-      switch (aCommand.at(lDataBegin)) {
-      case ' ':
-      case '\t':
-        ++lDataBegin;
-        continue;
-      default:
-        theData = aCommand.substr(lDataBegin);
-        lDataBegin = aCommand.size();
-      }
-    }
-  }
+  std::string lArgs = aCommand.substr(lNameEnd + 1);
 
   bool lFollowsArg = true;
   bool lInArgName = false;
@@ -74,6 +66,26 @@
           lInArgName = true;
           continue;
         }
+        // we found the encoded data in this message
+        if (lArgName.str() == "") {
+          // DBGP is fuzzy here: can there be whitespaces between "--" and the encoded data?
+          // so, tollerate the whitespaces before data starts
+          std::string::size_type lDataBegin = i + 1;
+          while (++i < lArgs.size()) {
+            switch (lArgs.at(i)) {
+            case ' ':
+            case '\t':
+              continue;
+            default:
+              lDataBegin = i;
+              // force the while to terminate
+              i = lArgs.size();
+            }
+          }
+
+          theData = lArgs.substr(lDataBegin);
+        }
+
       default:
         if (!lInArgName) {
           throw "error reading command";
 
=== modified file 'src/debugger/debugger_runtime.cpp'
--- src/debugger/debugger_runtime.cpp	2011-08-03 02:26:53 +0000
+++ src/debugger/debugger_runtime.cpp	2011-12-20 18:15:30 +0000
@@ -21,6 +21,7 @@
 #include <memory>
 #include <vector>
 #include <sstream>
+#include <iomanip>
 #include <fstream>
 
 #include <zorba/util/uri.h>
@@ -70,7 +71,8 @@
     thePlanIsOpen(false),
     theSerializer(0),
     theItemHandler(aHandler),
-    theCallbackData(aCallBackData)
+    theCallbackData(aCallBackData),
+    theLastContinuationCommand()
 {
 }
 
@@ -122,7 +124,7 @@
 DebuggerRuntime::runQuery()
 {
   theLock.wlock();
-  theExecStatus = theExecStatus == QUERY_SUSPENDED ? QUERY_RESUMED : QUERY_RUNNING;
+  theExecStatus = QUERY_RUNNING;
 
   try {
     DebuggerCommons* lCommons = getDebbugerCommons();
@@ -144,33 +146,23 @@
     theOStream.flush();
   } catch (FlowCtlException&) {
     // Runtime correctly terminated by user interrupt
-  } catch (ZorbaException const& e){
-    // this does not rethrow but only print the error message
-    ZorbaImpl::notifyError(theQuery->theDiagnosticHandler, e);
+  } catch (ZorbaException const& e) {
+    std::cerr << e << std::endl;
   }
   theLock.wlock();
   theExecStatus = QUERY_TERMINATED;
   theLock.unlock();
 }
 
-
-void
-DebuggerRuntime::setQueryRunning()
-{
-  AutoLock lLock(theLock, Lock::WRITE);
-  assert(theExecStatus == QUERY_RESUMED);
-  theExecStatus = QUERY_RUNNING;
-}
-
 // ****************************************************************************
 // Breakpoints
 
 unsigned int
-DebuggerRuntime::addBreakpoint(const QueryLoc& aLocation, bool aEnabled)
+DebuggerRuntime::addBreakpoint(String& aFileName, int aLine, bool aEnabled)
 {
   AutoLock lLock(theLock, Lock::WRITE);
   DebuggerCommons* lCommons = getDebbugerCommons();
-  return lCommons->addBreakpoint(aLocation, aEnabled);
+  return lCommons->addBreakpoint(aFileName, aLine, aEnabled);
 }
 
 Breakable