Merge lp:~paul-lucas/zorba/pjl-misc into lp:zorba

[Paul J. Lucas]

Major clean-up of properties, zorbacmd, and apitest command-line arguments.

Major clean-up of properties, zorbacmd, and apitest command-line arguments.

[Paul J. Lucas (paul-lucas)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Progress dashboard at http://jenkins.zorba.io:8180/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue result for https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Stage "BuildZorbaUbuntu" failed.

Check compiler output at http://jenkins.zorba.io:8180/job/BuildZorbaUbuntu/513/parsed_console to view the results.

[lp:~paul-lucas/zorba/pjl-misc]

11426. By Paul J. Lucas on 2014-02-10

Fixed abort.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Progress dashboard at http://jenkins.zorba.io:8180/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue result for https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Stage "BuildZorbaUbuntu" failed.

Check compiler output at http://jenkins.zorba.io:8180/job/BuildZorbaUbuntu/514/parsed_console to view the results.

[lp:~paul-lucas/zorba/pjl-misc]

11427. By Paul J. Lucas on 2014-02-10

More fixes.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Progress dashboard at http://jenkins.zorba.io:8180/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue result for https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Stage "BuildZorbaUbuntu" failed.

Check compiler output at http://jenkins.zorba.io:8180/job/BuildZorbaUbuntu/515/parsed_console to view the results.

[lp:~paul-lucas/zorba/pjl-misc]

11428. By Paul J. Lucas on 2014-02-10

More fixes.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Progress dashboard at http://jenkins.zorba.io:8180/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue result for https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Stage "BuildZorbaUbuntu" failed.

Check compiler output at http://jenkins.zorba.io:8180/job/BuildZorbaUbuntu/516/parsed_console to view the results.

[lp:~paul-lucas/zorba/pjl-misc]

11429. By Paul J. Lucas on 2014-02-10

More fixes.

11430. By Paul J. Lucas on 2014-02-10

More fixes.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Progress dashboard at http://jenkins.zorba.io:8180/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue result for https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Stage "TestZorbaUbuntu" failed.
34 tests failed (8754 total tests run).

Check test results at http://jenkins.zorba.io:8180/job/TestZorbaUbuntu/454/testReport/ to view the results.

[lp:~paul-lucas/zorba/pjl-misc]

11431. By Paul J. Lucas on 2014-02-10

Added endl.

11432. By Paul J. Lucas on 2014-02-11

Memory fixes.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Progress dashboard at http://jenkins.zorba.io:8180/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Voting criteria failed for the following merge proposals:

https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515 :
Votes: {'Approve': 1}

[Zorba Build Bot (zorba-buildbot)]

Validation queue result for https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Stage "CommitZorba" failed.

Check console output at http://jenkins.zorba.io:8180/job/CommitZorba/287/console to view the results.

[Matthias Brantner (matthias-brantner)]

review: Approve

[Matthias Brantner (matthias-brantner)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~paul-lucas/zorba/pjl-misc/+merge/205515

Progress dashboard at http://jenkins.zorba.io:8180/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue succeeded - proposal merged!

=== modified file 'bin/CMakeLists.txt'
--- bin/CMakeLists.txt	2014-01-31 23:27:47 +0000
+++ bin/CMakeLists.txt	2014-02-11 00:42:47 +0000
@@ -44,11 +44,10 @@
 ENDIF (ZORBA_WITH_DEBUGGER)
 
 SET(SRCS
+  zorbacmd_args.cpp
+  zorbacmd_props.cpp
+  timers.cpp
   zorbacmd.cpp
-  zorbacmdproperties_base.cpp
-  zorbacmdproperties.cpp
-  util.cpp
-  path_util.cpp
 )
 
 ZORBA_GENERATE_EXE("zorbacmd" "${SRCS}" "" "zorba" "bin")
 
=== removed file 'bin/path_util.cpp'
--- bin/path_util.cpp	2013-05-31 03:38:45 +0000
+++ bin/path_util.cpp	1970-01-01 00:00:00 +0000
@@ -1,85 +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 "path_util.h"
-
-#include <cstdlib>
-
-#include <zorba/static_context.h>
-#include <zorba/util/fs_util.h>
-
-#include "util.h"
-#include "zorbacmdproperties.h"
-
-namespace zorba {
-
-namespace PathUtil {
-
-void
-tokenizePath(
-  const std::string&    aPathStr,
-  std::vector<String>&  aResult)
-{
-  std::vector<std::string> lPath;
-#ifdef WIN32
-  Util::tokenize(aPathStr, ";", lPath);
-#else
-  Util::tokenize(aPathStr, ":", lPath);
-#endif
-  for (std::vector<std::string>::iterator lIter = lPath.begin();
-       lIter != lPath.end(); ++lIter) {
-    aResult.push_back(*lIter);
-  }
-}
-
-void
-setPathsOnContext(
-  const ZorbaCMDProperties& aProperties,
-  StaticContext_t& aStaticCtx)
-{
-  std::vector<String> lPath;
-  std::string lPathStr;
-
-  // Compute the current working directory to append to all paths.
-  std::string lCWD( fs::curdir() );
-
-  // setModulePaths() *overwrites* the URI path and lib path, so there's no
-  // sense in calling both. So if --module-path exists, just use it.
-  aProperties.getModulePath(lPathStr);
-  if (lPathStr.length() > 0) {
-    tokenizePath(lPathStr, lPath);
-    lPath.push_back(lCWD);
-    aStaticCtx->setModulePaths(lPath);
-  }
-  else {
-    // Compute and set URI path
-    aProperties.getURIPath(lPathStr);
-    tokenizePath(lPathStr, lPath);
-    lPath.push_back(lCWD);
-    aStaticCtx->setURIPath(lPath);
-    lPath.clear();
-
-    // Compute and set lib path
-    aProperties.getLibPath(lPathStr);
-    tokenizePath(lPathStr, lPath);
-    lPath.push_back(lCWD);
-    aStaticCtx->setLibPath(lPath);
-  }
-}
-
-} /* namespace ModulePath */
-
-} /* namespace zorba */
 
=== removed file 'bin/path_util.h'
--- bin/path_util.h	2013-02-07 17:24:36 +0000
+++ bin/path_util.h	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.
- */
-#ifndef ZORBA_MODULE_PATH_H
-#define ZORBA_MODULE_PATH_H
-
-#include <vector>
-#include <string>
-#include <zorba/api_shared_types.h>
-
-class ZorbaCMDProperties;
-
-namespace zorba {
-
-  class String;
-
-  namespace PathUtil {
-
-    void
-    setPathsOnContext(const ZorbaCMDProperties& aProperties,
-                      zorba::StaticContext_t& aStaticCtx);
-
-    void
-    tokenizePath(const std::string& aPathStr, std::vector<String>&  aResult);
-
-  }
-} /* namespace zorba */
-
-#endif
 
=== added file 'bin/timers.cpp'
--- bin/timers.cpp	1970-01-01 00:00:00 +0000
+++ bin/timers.cpp	2014-02-11 00:42:47 +0000
@@ -0,0 +1,176 @@
+/*
+ * 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.
+ */
+
+// local
+#include "timers.h"
+
+using namespace std;
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define INIT_TIMER(KIND)          \
+  elapsed_##KIND##_walltime( 0 ), \
+  elapsed_##KIND##_cputime( 0 )
+
+#define START_TIMER(KIND)                                       \
+  zorba::time::get_current_walltime( start_##KIND##_walltime ); \
+  zorba::time::get_current_cputime( start_##KIND##_cputime )
+
+#define STOP_TIMER(KIND)                                        \
+  zorba::time::get_current_walltime( stop_##KIND##_walltime );  \
+  elapsed_##KIND##_walltime += zorba::time::get_walltime_elapsed( start_##KIND##_walltime, stop_##KIND##_walltime ); \
+  zorba::time::get_current_cputime( stop_##KIND##_cputime );    \
+  elapsed_##KIND##_cputime += zorba::time::get_cputime_elapsed( start_##KIND##_cputime, stop_##KIND##_cputime )
+
+Timers::Timers( unsigned long num_execs ) :
+  num_execs_( num_execs ),
+  INIT_TIMER( init ),
+  INIT_TIMER( deinit ),
+  INIT_TIMER( comp ),
+  INIT_TIMER( exec ),
+  INIT_TIMER( load ),
+  INIT_TIMER( unload ),
+  INIT_TIMER( plan_save ),
+  INIT_TIMER( plan_load ),
+  INIT_TIMER( total )
+{
+}
+
+void Timers::startTimer( kind k, unsigned long iteration ) {
+  if ( iteration == 0 && num_execs_ > 1 )
+    return;
+  switch ( k ) {
+    case init:
+      START_TIMER( init );
+      break;
+    case deinit:
+      START_TIMER( deinit );
+      break;
+    case total:
+      START_TIMER( total );
+      break;
+    case comp:
+      START_TIMER( comp );
+      break;
+    case exec:
+      START_TIMER( exec );
+      break;
+    case unload:
+      START_TIMER( unload );
+      break;
+    case plan_save:
+      START_TIMER( plan_save );
+      break;
+    case plan_load:
+      START_TIMER( plan_load );
+      break;
+  } // switch
+}
+
+void Timers::stopTimer( kind k, unsigned long iteration ) {
+  if ( iteration == 0 && num_execs_ > 1 )
+    return;
+  switch ( k ) {
+    case init:
+      STOP_TIMER( init );
+      break;
+    case deinit:
+      STOP_TIMER( deinit );
+      break;
+    case total:
+      STOP_TIMER( total );
+      break;
+    case comp:
+      STOP_TIMER( comp );
+      break;
+    case exec:
+      STOP_TIMER( exec );
+      break;
+    case unload:
+      STOP_TIMER( unload );
+      break;
+    case plan_save:
+      STOP_TIMER( plan_save );
+      break;
+    case plan_load:
+      STOP_TIMER( plan_load );
+      break;
+  } // switch
+}
+
+ostream& Timers::print( ostream &os, bool serializePlan ) {
+  os.precision( 3 );
+  os.setf( ios::fixed );
+
+  os << "\nNumber of executions = " << num_execs_ << endl;
+
+  unsigned long timeDiv = num_execs_ == 1 ? 1 : (num_execs_ - 1);
+  double cWalltime = elapsed_comp_walltime / timeDiv;
+  double eWalltime = elapsed_exec_walltime / timeDiv;
+  double lWalltime = elapsed_load_walltime / timeDiv;
+  double uWalltime = elapsed_unload_walltime / timeDiv;
+  double psWalltime = elapsed_plan_save_walltime / timeDiv;
+  double plWalltime = elapsed_plan_load_walltime / timeDiv;
+  double tWalltime = elapsed_total_walltime / timeDiv;
+
+  double cCputime = elapsed_comp_cputime / timeDiv;
+  double eCputime = elapsed_exec_cputime / timeDiv;
+  double lCputime = elapsed_load_cputime / timeDiv;
+  double uCputime = elapsed_unload_cputime / timeDiv;
+  double psCputime = elapsed_plan_save_cputime / timeDiv;
+  double plCputime = elapsed_plan_load_cputime / timeDiv;
+  double tCputime = elapsed_total_cputime / timeDiv;
+
+  os << "Engine Startup Time     : " << elapsed_init_walltime
+     << " (user: " << elapsed_init_cputime << ")"
+     << " milliseconds" << endl;
+
+  os << "Average Compilation Time: " << cWalltime
+     << " (user: " << cCputime << ")"
+     << " milliseconds" << endl;
+
+  if ( serializePlan ) {
+    os << "Average Plan Saving Time: " << psWalltime
+       << " (user: " << psCputime << ")"
+       << " milliseconds" << endl;
+    
+    os << "Average Plan Loading Time: " << plWalltime
+       << " (user: " << plCputime << ")"
+       << " milliseconds" << endl;
+  }
+
+  os << "Average Execution Time  : " << eWalltime - lWalltime
+     << " (user: " << eCputime - lCputime  << ")"
+     << " milliseconds" << endl;
+
+  os << "Average Loading Time    : " << lWalltime
+     << " (user: " << lCputime << ")"
+     << " milliseconds" << endl;
+
+  os << "Average Unloading Time  : " << uWalltime
+     << " (user: " << uCputime << ")"
+     << " milliseconds" << endl;
+
+  os << "Average Total Time      : " << tWalltime
+     << " (user: " << tCputime << ")"
+     << " milliseconds" << endl;
+
+  return os;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/* vim:set et sw=2 ts=2: */
 
=== added file 'bin/timers.h'
--- bin/timers.h	1970-01-01 00:00:00 +0000
+++ bin/timers.h	2014-02-11 00:42:47 +0000
@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+#ifndef ZORBA_CMD_TIMERS_H
+#define ZORBA_CMD_TIMERS_H
+
+// standard
+#include <iostream>
+
+// Zorba
+#include <zorba/util/time.h>
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define DECLARE_TIMER(KIND)                       \
+  zorba::time::walltime start_##KIND##_walltime;  \
+  zorba::time::walltime stop_##KIND##_walltime;   \
+  zorba::time::cputime start_##KIND##_cputime;    \
+  zorba::time::cputime stop_##KIND##_cputime;     \
+  double elapsed_##KIND##_walltime;               \
+  double elapsed_##KIND##_cputime
+
+struct Timers {
+  enum kind {
+    init,
+    deinit,
+    comp,
+    exec,
+    unload,
+    plan_save,
+    plan_load,
+    total
+  };
+
+  unsigned long num_execs_;
+
+  DECLARE_TIMER( init );
+  DECLARE_TIMER( deinit );
+  DECLARE_TIMER( comp );
+  DECLARE_TIMER( exec );
+  DECLARE_TIMER( load );
+  DECLARE_TIMER( unload );
+  DECLARE_TIMER( plan_save );
+  DECLARE_TIMER( plan_load );
+  DECLARE_TIMER( total );
+
+  Timers( unsigned long num_execs );
+
+  void startTimer( kind, unsigned long iteration );
+  void stopTimer( kind, unsigned long iteration );
+
+  std::ostream& print( std::ostream&, bool );
+};
+
+#undef DECLARE_TIMER
+
+///////////////////////////////////////////////////////////////////////////////
+
+#endif /* ZORBA_CMD_TIMERS_H */
+/* vim:set et sw=2 ts=2: */
 
=== removed file 'bin/util.cpp'
--- bin/util.cpp	2013-02-07 17:24:36 +0000
+++ bin/util.cpp	1970-01-01 00:00:00 +0000
@@ -1,37 +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 "util.h"
-
-namespace zorba {
-
-  void
-  Util::tokenize(const std::string& str,
-                const std::string& delimiters,
-                std::vector<std::string>& tokens)
-  {
-    std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
-        
-    std::string::size_type pos = str.find_first_of(delimiters, lastPos);
-  
-    while (std::string::npos != pos || std::string::npos != lastPos) {
-      tokens.push_back(str.substr(lastPos, pos - lastPos));
-      lastPos = str.find_first_not_of(delimiters, pos);
-      pos = str.find_first_of(delimiters, lastPos);
-    }
-  }
-
-} /* namespace zorba */
 
=== modified file 'bin/util.h'
--- bin/util.h	2013-02-07 17:24:36 +0000
+++ bin/util.h	2014-02-11 00:42:47 +0000
@@ -13,23 +13,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef ZORBA_UTIL_H
-#define ZORBA_UTIL_H
-
+
+#ifndef ZORBA_CMD_UTIL_H
+#define ZORBA_CMD_UTIL_H
+
+#include <string>
 #include <vector>
-#include <string>
-
-namespace zorba {
-
-  class Util {
-  public:
-    static void
-    tokenize(const std::string& str,
-             const std::string& delimiters,
-             std::vector<std::string>& tokens);
-
-  };
-} /* namespace zorba */
-
-#endif
-
+
+///////////////////////////////////////////////////////////////////////////////
+
+template<class InStringType,class OutStringType>
+void tokenize( InStringType const &s, char delim,
+               std::vector<OutStringType> *tokens ) {
+  typename InStringType::size_type last_pos = s.find_first_not_of( delim, 0 );
+  typename InStringType::size_type pos = s.find_first_of( delim, last_pos );
+
+  while ( pos != InStringType::npos || last_pos != InStringType::npos ) {
+    tokens->push_back( s.substr( last_pos, pos - last_pos ).c_str() );
+    last_pos = s.find_first_not_of( delim, pos );
+    pos = s.find_first_of( delim, last_pos );
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#endif /* ZORBA_CMD_UTIL_H */
+/* vim:set et sw=2 ts=2: */
 
=== modified file 'bin/zorbacmd.cpp'
--- bin/zorbacmd.cpp	2013-09-17 21:12:49 +0000
+++ bin/zorbacmd.cpp	2014-02-11 00:42:47 +0000
@@ -14,34 +14,34 @@
  * limitations under the License.
  */
 
-#include "zorbacmdproperties.h"
-
+// standard
+#include <cassert>
+#include <fstream>
 #include <iostream>
-#include <fstream>
 #include <sstream>
+#include <string>
 #include <vector>
-#include <string>
-#include <cassert>
 
 #ifdef WIN32
 #include <windows.h>
-#define sleep(s) Sleep(s*1000)
-#endif
+#endif /* WIN32 */
 
-#include <zorba/zorba.h>
-#include <zorba/zorba_exception.h>
-#include <zorba/xquery_exception.h>
+// Zorba
+#include <zorba/audit.h>
+#include <zorba/audit_scoped.h>
 #include <zorba/document_manager.h>
+#include <zorba/internal/unique_ptr.h>
 #include <zorba/item_sequence.h>
 #include <zorba/iterator.h>
-#include <zorba/xquery_functions.h>
-#include <zorba/uri_resolvers.h>
+#include <zorba/properties.h>
 #include <zorba/serialization_callback.h>
-#include <zorba/audit.h>
-#include <zorba/audit_scoped.h>
 #include <zorba/store_manager.h>
+#include <zorba/uri_resolvers.h>
 #include <zorba/util/fs_util.h>
-#include <zorba/internal/unique_ptr.h>
+#include <zorba/xquery_exception.h>
+#include <zorba/xquery_functions.h>
+#include <zorba/zorba.h>
+#include <zorba/zorba_exception.h>
 
 //#define DO_AUDIT
 
@@ -50,850 +50,464 @@
 #include <zorba/audit_scoped.h>
 #endif
 
+// local
+#include "timers.h"
 #include "util.h"
-#include "path_util.h"
-
-// Timing utilities, including wall-clock timing
-#include <zorba/util/time.h>
+#include "zorbacmd_props.h"
 
 // toggle this to allow configuration via a system properties file
 // (see src/system/properties.*)
 #define ZORBACMD_LOAD_SYSTEM_PROPERTIES 1
 
-#if ZORBACMD_LOAD_SYSTEM_PROPERTIES
-#  include "system/properties.h"
-#endif
-
-//#define DO_AUDIT
-
+using namespace std;
 using namespace zorba;
-namespace zorbatm = zorba::time;
-
-const char *copyright_str =
-  "Copyright 2006-2009 The FLWOR Foundation.\n"
+
+extern char const* get_help_msg();
+extern int  parse_args( int argc, char const *argv[] );
+static void set_paths_on_sctx( StaticContext_t& );
+
+///////////////////////////////////////////////////////////////////////////////
+
+static const char copyright[] =
+  "Copyright 2006-2014 The FLWOR Foundation.\n"
   "License: Apache License 2.0: <http://www.apache.org/licenses/LICENSE-2.0>";
 
 #ifndef ZORBA_NO_FULL_TEXT
-OneToOneURIMapper theStopWordsMapper(EntityData::STOP_WORDS);
-OneToOneURIMapper theThesaurusMapper(EntityData::THESAURUS);
-#endif
-
-
-/*******************************************************************************
-
-********************************************************************************/
-class URIMapperSerializationCallback : public SerializationCallback
-{
+static OneToOneURIMapper stop_words_mapper( EntityData::STOP_WORDS );
+static OneToOneURIMapper thesaurus_mapper( EntityData::THESAURUS );
+#endif /* ZORBA_NO_FULL_TEXT */
+
+class URIMapperSerializationCallback : public SerializationCallback {
+public:
+  void addURIMapper( URIMapper* mapper ) {
+    theURIMappers.push_back( mapper );
+  }
+
+  URIMapper* getURIMapper( size_t i ) const {
+    return theURIMappers[i];
+  }
+
 private:
-  std::vector<URIMapper*>   theURIMappers;
-
-public:
-  void addURIMapper(URIMapper* mapper) { theURIMappers.push_back(mapper); }
-
-  URIMapper* getURIMapper(size_t i) const { return theURIMappers[i]; }
+  vector<URIMapper*> theURIMappers;
 };
 
-
-URIMapperSerializationCallback theSerializationCallback;
-
-/*******************************************************************************
-
-********************************************************************************/
-static void print_exception( ZorbaException const &e,
-                             ZorbaCMDProperties const &props ) {
-  using namespace std;
-
-  if ( props.printErrorsAsXml() )
-    if ( props.indent() )
+URIMapperSerializationCallback serialization_callback;
+
+static void print_exception( ZorbaException const &e ) {
+  ZorbaCmdProperties &zc_props = ZorbaCmdProperties::instance();
+  if ( zc_props.print_errors_as_xml_ )
+    if ( zc_props.indent_ )
       cerr << ZorbaException::format_xml_indented;
     else
       cerr << ZorbaException::format_xml;
   else
     cerr << ZorbaException::format_text;
-
   cerr << e << endl;
 }
 
-/*******************************************************************************
+static void print_help() {
+  cout << "Zorba NoSQL Query Processor\n";
+  cout << "Available options:\n";
+  cout << get_help_msg();
+}
 
-********************************************************************************/
-bool populateStaticContext(
-    Zorba* zorba,
-    zorba::StaticContext_t& sctx,
-    const ZorbaCMDProperties& props)
-{
-  try
-  {
+static bool populateStaticContext( Zorba *zorba, StaticContext_t &sctx ) {
+  ZorbaCmdProperties &zc_props = ZorbaCmdProperties::instance();
+  try {
     // add the following module path to the static context (in this order)
     // 1. command-line properties
     // 2. environment ZORBA_MODULE_PATH
     // 3. current working directory
-    {
-      std::vector<String> lModulePath;
-      PathUtil::setPathsOnContext(props, sctx);
-    }
-
-    if (props.boundarySpace().size() != 0 )
-    {
-      sctx->setBoundarySpacePolicy(props.boundarySpace().compare("preserve") == 0 ?
-                                   preserve_space : 
-                                   strip_space);
-    }
-
-    if (props.constructionMode().size() != 0)
-    {
-      sctx->setConstructionMode(props.boundarySpace().compare("preserve") == 0 ? 
-                                preserve_cons :
-                                strip_cons);
-    }
-
-    if (props.orderingMode().size() != 0 )
-    {
-      sctx->setOrderingMode(props.boundarySpace().compare("ordered") == 0 ?
-                            ordered :
-                            unordered);
-    }
-
-    if (props.baseUri().size() != 0 )
-      sctx->setBaseURI( props.baseUri() );
+    set_paths_on_sctx( sctx );
+
+    if ( !zc_props.boundary_space_.empty() )
+      sctx->setBoundarySpacePolicy(
+        zc_props.boundary_space_ == "preserve" ? preserve_space : strip_space
+      );
+
+    if ( !zc_props.construction_mode_.empty() )
+      sctx->setConstructionMode(
+        zc_props.boundary_space_ == "preserve" ? preserve_cons : strip_cons
+      );
+
+    if ( !zc_props.ordering_mode_.empty() )
+      sctx->setOrderingMode(
+        zc_props.boundary_space_ == "ordered" ? ordered : unordered
+      );
+
+    if ( !zc_props.base_uri_.empty() )
+      sctx->setBaseURI( zc_props.base_uri_ );
   }
-  catch (const zorba::ZorbaException& ze) 
-  {
-    std::cerr << ze << std::endl;
+  catch ( ZorbaException const &ze ) {
+    cerr << ze << endl;
     return false;
   }
 
-  if (props.defaultCollation().size() != 0 )
-  {
-    try 
-    {
-      sctx->addCollation( props.defaultCollation() );
+  if ( !zc_props.default_collation_.empty() ) {
+    try {
+      sctx->addCollation( zc_props.default_collation_ );
     }
-    catch (zorba::ZorbaException const&)
-    {
-      std::cerr << "the given collation {" << props.defaultCollation()
-                << "} is not a valid collation." << std::endl;
+    catch ( ZorbaException const& ) {
+      cerr << "the given collation {" << zc_props.default_collation_
+           << "} is not a valid collation." << endl;
       return false;
     }
-
-    sctx->setDefaultCollation( props.defaultCollation() );
+    sctx->setDefaultCollation( zc_props.default_collation_ );
   }
 
-  ZorbaCMDProperties::Options_t::const_iterator lIter = props.optionsBegin();
-  ZorbaCMDProperties::Options_t::const_iterator end = props.optionsEnd();
-  for (; lIter != end; ++lIter)
-  {
-    try 
-    {
-      Item lQName = zorba->getItemFactory()->createQName(lIter->clark_qname);
-      sctx->declareOption(lQName, lIter->value);
+  sctx_opts::const_iterator i = zc_props.sctx_opts_.begin();
+  sctx_opts::const_iterator const end = zc_props.sctx_opts_.end();
+  for ( ; i != end; ++i ) {
+    try {
+      Item name( zorba->getItemFactory()->createQName( i->clark_qname ) );
+      sctx->declareOption( name, i->value );
     }
-    catch (zorba::ZorbaException const& e)
-    {
-      std::cerr << "unable to set static context option with qname "
-                << lIter->clark_qname << ": " << e.what() << std::endl;
+    catch ( ZorbaException const &e) {
+      cerr << "unable to set static context option with qname "
+           << i->clark_qname << ": " << e.what() << endl;
       return false;
     }
   }
 
 #ifdef DO_AUDIT
-  zorba::audit::Provider* lAuditProvider = zorba->getAuditProvider();
-  zorba::audit::Configuration* config = lAuditProvider->createConfiguration();
-  std::vector<zorba::String> property_names;
-  zorba::audit::Configuration::getPropertyNames(property_names);
+  audit::Provider* lAuditProvider = zorba->getAuditProvider();
+  audit::Configuration* config = lAuditProvider->createConfiguration();
+  vector<String> property_names;
+  audit::Configuration::getPropertyNames(property_names);
 
   bool lIsStatic;
 
-  lIsStatic = zorba::audit::Configuration::
+  lIsStatic = audit::Configuration::
   enableProperty(config, property_names, "xquery/compilation/parse-duration");
   assert(lIsStatic);
 
-  lIsStatic = zorba::audit::Configuration::
+  lIsStatic = audit::Configuration::
   enableProperty(config, property_names, "xquery/compilation/translation-duration");
   assert(lIsStatic);
 
-  lIsStatic = zorba::audit::Configuration::
+  lIsStatic = audit::Configuration::
   enableProperty(config, property_names, "xquery/compilation/optimization-duration");
   assert(lIsStatic);
 
-  lIsStatic = zorba::audit::Configuration::
+  lIsStatic = audit::Configuration::
   enableProperty(config, property_names, "xquery/compilation/codegeneration-duration");
   assert(lIsStatic);
 
-  zorba::audit::Event* event = lAuditProvider->createEvent(config);
+  audit::Event *event = lAuditProvider->createEvent(config);
 
-  sctx->setAuditEvent(event);
-#endif // DO_AUDIT
+  sctx->setAuditEvent( event );
+#endif /* DO_AUDIT */
 
 #ifndef ZORBA_NO_FULL_TEXT
   {
-    ZorbaCMDProperties::FullText_t::const_iterator lIter = props.stopWordsBegin();
-    ZorbaCMDProperties::FullText_t::const_iterator end = props.stopWordsEnd();
-    for (; lIter != end; ++lIter) 
-    {
-      theStopWordsMapper.addMapping(lIter->uri, lIter->value);
-    }
+    ft_mappings::const_iterator i = zc_props.stop_words_mapping_.begin();
+    ft_mappings::const_iterator const end = zc_props.stop_words_mapping_.end();
+    for (; i != end; ++i)
+      stop_words_mapper.addMapping( i->uri, i->value );
 
-    if (props.serializePlan() || props.loadPlan()) 
-    {
-      theSerializationCallback.addURIMapper(&theStopWordsMapper);
-    }
+    if ( zc_props.serialize_plan_ || zc_props.load_plan_ )
+      serialization_callback.addURIMapper( &stop_words_mapper );
     else
-    {
-      sctx->registerURIMapper(&theStopWordsMapper);
-    }
+      sctx->registerURIMapper( &stop_words_mapper );
   }
 
   {
-    ZorbaCMDProperties::FullText_t::const_iterator lIter = props.thesaurusBegin();
-    ZorbaCMDProperties::FullText_t::const_iterator end = props.thesaurusEnd();
-    for (; lIter != end; ++lIter) 
-    {
-      theThesaurusMapper.addMapping(lIter->uri, lIter->value);
-    }
+    ft_mappings::const_iterator i = zc_props.thesaurus_mapping_.begin();
+    ft_mappings::const_iterator const end = zc_props.thesaurus_mapping_.end();
+    for ( ; i != end; ++i )
+      thesaurus_mapper.addMapping( i->uri, i->value );
 
-    if (props.serializePlan() || props.loadPlan())
-    {
-      theSerializationCallback.addURIMapper(&theStopWordsMapper);
-    }
+    if ( zc_props.serialize_plan_ || zc_props.load_plan_ )
+      serialization_callback.addURIMapper( &stop_words_mapper );
     else
-    {
-      sctx->registerURIMapper(&theThesaurusMapper);
-    }
+      sctx->registerURIMapper( &thesaurus_mapper );
   }
 #endif /* ZORBA_NO_FULL_TEXT */
 
   return true;
 }
 
-
-/*******************************************************************************
-
-********************************************************************************/
-bool populateDynamicContext(
-    Zorba* zorba,
-    XmlDataManager* xmlMgr,
-    zorba::DynamicContext* aDynamicContext,
-    const ZorbaCMDProperties& props)
-{
-  if ( props.contextItem().size() != 0 ) 
-  {
-    std::ifstream lInStream(props.contextItem().c_str());
-    Item lDoc = xmlMgr->parseXML(lInStream);
-    aDynamicContext->setContextItem(lDoc);
+bool populateDynamicContext( Zorba *zorba, XmlDataManager *xmlMgr,
+                             DynamicContext *dctx ) {
+  ZorbaCmdProperties const &zc_props = ZorbaCmdProperties::instance();
+
+  if ( !zc_props.ctx_item_.empty() ) {
+    ifstream is( zc_props.ctx_item_.c_str() );
+    Item doc( xmlMgr->parseXML( is ) );
+    dctx->setContextItem( doc );
   }
 
-  ZorbaCMDProperties::ExternalVars_t::const_iterator lIter;
-  ZorbaCMDProperties::ExternalVars_t::const_iterator end = props.externalVarsEnd();
-  for (lIter = props.externalVarsBegin();
-       lIter != end;
-       ++lIter)
-  {
-    try
-    {
-      if ((*lIter).inline_file)
-      {
-        std::ifstream lInStream((*lIter).var_value.c_str());
-        Item lDoc = xmlMgr->parseXML(lInStream);
-        aDynamicContext->setVariable((*lIter).var_name, lDoc);
-      }
-      else
-      {
-        zorba::Item lItem = zorba->getItemFactory()->createString((*lIter).var_value);
-        aDynamicContext->setVariable((*lIter).var_name, lItem);
+  external_vars::const_iterator i = zc_props.external_vars_.begin();
+  external_vars::const_iterator const end = zc_props.external_vars_.end();
+  for ( ; i != end; ++i ) {
+    try {
+      if ( i->inline_file ) {
+        ifstream is( i->var_value.c_str() );
+        Item doc( xmlMgr->parseXML( is ) );
+        dctx->setVariable( i->var_name, doc );
+      } else {
+        Item item( zorba->getItemFactory()->createString( i->var_value ) );
+        dctx->setVariable( i->var_name, item );
       }
     }
-    catch (...)
-    {
+    catch ( ... ) {
       // Let normal exception handling display the error message; here we
       // just want to tell the user what variable binding caused the problem
-      std::cerr << "While binding external variable $"
-                << lIter->var_name << ": ";
+      cerr << "While binding external variable $" << i->var_name << ": ";
       throw;
     }
   }
   return true;
 }
 
-
-/*******************************************************************************
-
-********************************************************************************/
-bool createSerializerOptions(
-    Zorba_SerializerOptions_t& lSerOptions,
-    const ZorbaCMDProperties& props)
-{
-  if ( props.indent() )
-    lSerOptions.indent = ZORBA_INDENT_YES;
-
-  if ( props.omitXmlDeclaration() )
-    lSerOptions.omit_xml_declaration = ZORBA_OMIT_XML_DECLARATION_YES;
-
-  if ( props.byteOrderMark() )
-    lSerOptions.byte_order_mark = ZORBA_BYTE_ORDER_MARK_YES;
-
-  if ( props.serializeHtml() )
-    lSerOptions.ser_method = ZORBA_SERIALIZATION_METHOD_HTML;
-  else if ( props.serializeText() )
-    lSerOptions.ser_method = ZORBA_SERIALIZATION_METHOD_TEXT;
-
-  return true;
+static void set_serializer_opts( Zorba_SerializerOptions_t &ser_opts ) {
+  ZorbaCmdProperties &zc_props = ZorbaCmdProperties::instance();
+
+  if ( zc_props.indent_ )
+    ser_opts.indent = ZORBA_INDENT_YES;
+
+  if ( zc_props.omit_xml_declaration_ )
+    ser_opts.omit_xml_declaration = ZORBA_OMIT_XML_DECLARATION_YES;
+
+  if ( zc_props.byte_order_mark_ )
+    ser_opts.byte_order_mark = ZORBA_BYTE_ORDER_MARK_YES;
+
+  if ( zc_props.serialize_html_ )
+    ser_opts.ser_method = ZORBA_SERIALIZATION_METHOD_HTML;
+  else if ( zc_props.serialize_text_ )
+    ser_opts.ser_method = ZORBA_SERIALIZATION_METHOD_TEXT;
 }
 
 
-/*******************************************************************************
+/******************************************************************************
   Fullfills the command-line "as-file" (-f) switch, or if not requested, infers
   -f for file:// queries. Returns an URI or the empty string.
-********************************************************************************/
-std::string parseFileURI(bool asPath, const std::string &str)
-{
-  if (asPath)
-    return str;
+ ******************************************************************************/
 
-  // otherwise, the user still might have meant a file
+static string parse_file_uri( string const &uri ) {
 #ifdef WIN32
   // file:///c:/ returns c:<backslash>
   // file://localhost returns \\localhost
   // BUG: it seems that <a>/x returns <a>\x
   static const char *file3 = "file:///";
   static const char *file2 = "file://";
-  std::string fpath;
-  if(str.compare(0, strlen(file3), file3) == 0) {
-    fpath = str.substr(strlen(file3));
-  } else if(str.compare(0, strlen(file2), file2) == 0) {
+  string fpath;
+  if ( uri.compare( 0, strlen( file3 ), file3 ) == 0 ) {
+    fpath = uri.substr( strlen( file3 ) );
+  } else if ( uri.compare( 0, strlen( file2 ), file2 ) == 0 ) {
     fpath = fs::dir_separator;
-    fpath += str.substr(strlen(file2));
+    fpath += uri.substr( strlen( file2 ) );
   }
   // replace all slash with backslash
-  std::string::size_type off=0;
-  while ((off=fpath.find('/', off)) != std::string::npos)
-    fpath.replace(off, 1, 1, fs::dir_separator);
+  string::size_type off=0;
+  while ( (off = fpath.find( '/', off )) != string::npos )
+    fpath.replace( off, 1, 1, fs::dir_separator );
   return fpath;
 
-#else // for UNIX
-
-  static const char *pfx = "file://";
-  static unsigned plen = strlen (pfx);
-  if (str.compare (0, plen, pfx) == 0)
-    return str.substr (plen);
+#else /* for UNIX */
+  static const char pfx[] = "file://";
+  if ( uri.compare( 0, 7, pfx ) == 0 )
+    return uri.substr( 7 );
   else
     return "";
-#endif
-}
-
-
-//
-// Timing utilities and class
-//
-
-#define DECLARE_TIMER(kind)                               \
-  zorbatm::walltime start##kind##Walltime;                    \
-  zorbatm::walltime stop##kind##Walltime;                     \
-  zorbatm::cputime start##kind##Cputime;                    \
-  zorbatm::cputime stop##kind##Cputime;                     \
-  double elapsed##kind##Walltime;                             \
-  double elapsed##kind##Cputime
-
-#define START_TIMER(kind)                             \
-  zorbatm::get_current_walltime(start##kind##Walltime);   \
-  zorbatm::get_current_cputime(start##kind##Cputime);
-
-#define STOP_TIMER(kind)                                                \
-  zorbatm::get_current_walltime(stop##kind##Walltime);                      \
-  elapsed##kind##Walltime += zorbatm::get_walltime_elapsed(start##kind##Walltime, \
-    stop##kind##Walltime);                                                  \
-                                                                        \
-  zorbatm::get_current_cputime(stop##kind##Cputime);                      \
-  elapsed##kind##Cputime += zorbatm::get_cputime_elapsed(start##kind##Cputime, \
-    stop##kind##Cputime);
-
-
-
-struct TimingInfo
-{
-  typedef enum
-  {
-    INIT_TIMER,
-    DEINIT_TIMER,
-    COMP_TIMER,
-    EXEC_TIMER,
-    UNLOAD_TIMER,
-    PLAN_SAVE_TIMER,
-    PLAN_LOAD_TIMER,
-    TOTAL_TIMER
-  } TimerKind;
-
-  unsigned long numExecs;
-
-  DECLARE_TIMER(Init);
-  DECLARE_TIMER(Deinit);
-  DECLARE_TIMER(Comp);
-  DECLARE_TIMER(Exec);
-  DECLARE_TIMER(Load);
-  DECLARE_TIMER(Unload);
-  DECLARE_TIMER(PlanSave);
-  DECLARE_TIMER(PlanLoad);
-  DECLARE_TIMER(Total);
-
-  TimingInfo(unsigned long num)
-    :
-    numExecs(num),
-    elapsedInitWalltime(0),
-    elapsedInitCputime(0),
-    elapsedDeinitWalltime(0),
-    elapsedDeinitCputime(0),
-    elapsedCompWalltime(0),
-    elapsedCompCputime(0),
-    elapsedExecWalltime(0),
-    elapsedExecCputime(0),
-    elapsedLoadWalltime(0),
-    elapsedLoadCputime(0),
-    elapsedUnloadWalltime(0),
-    elapsedUnloadCputime(0),
-
-    elapsedPlanSaveWalltime(0),
-    elapsedPlanSaveCputime(0),
-
-    elapsedPlanLoadWalltime(0),
-    elapsedPlanLoadCputime(0),
-
-    elapsedTotalWalltime(0),
-    elapsedTotalCputime(0)
-  {
-  }
-
-  void startTimer(TimerKind kind, unsigned long iteration);
-  void stopTimer(TimerKind kind, unsigned long iteration);
-
-  std::ostream& print(std::ostream& os, bool);
-};
-
-
-void
-TimingInfo::startTimer(TimerKind kind, unsigned long iteration)
-{
-  if (iteration == 0 && numExecs > 1)
-    return;
-
-  switch (kind)
-  {
-  case INIT_TIMER:
-    START_TIMER(Init);
-    break;
-
-  case DEINIT_TIMER:
-    START_TIMER(Deinit);
-    break;
-
-  case TOTAL_TIMER:
-    START_TIMER(Total);
-    break;
-
-  case COMP_TIMER:
-    START_TIMER(Comp);
-    break;
-
-  case EXEC_TIMER:
-    START_TIMER(Exec);
-    break;
-
-  case UNLOAD_TIMER:
-    START_TIMER(Unload);
-    break;
-
-  case PLAN_SAVE_TIMER:
-    START_TIMER(PlanSave);
-    break;
-
-  case PLAN_LOAD_TIMER:
-    START_TIMER(PlanLoad);
-    break;
-  }
-}
-
-
-void
-TimingInfo::stopTimer(TimerKind kind, unsigned long iteration)
-{
-  if (iteration == 0 && numExecs > 1)
-    return;
-
-  switch (kind)
-  {
-  case INIT_TIMER:
-  {
-    STOP_TIMER(Init);
-    break;
-  }
-  case DEINIT_TIMER:
-  {
-    STOP_TIMER(Deinit);
-    break;
-  }
-  case TOTAL_TIMER:
-  {
-    STOP_TIMER(Total);
-    break;
-  }
-  case COMP_TIMER:
-  {
-    STOP_TIMER(Comp);
-    break;
-  }
-  case EXEC_TIMER:
-  {
-    STOP_TIMER(Exec);
-    break;
-  }
-  case UNLOAD_TIMER:
-  {
-    STOP_TIMER(Unload);
-    break;
-  }
-  case PLAN_SAVE_TIMER:
-  {
-    STOP_TIMER(PlanSave);
-    break;
-  }
-  case PLAN_LOAD_TIMER:
-  {
-    STOP_TIMER(PlanLoad);
-    break;
-  }
-  }
-}
-
-
-std::ostream&
-TimingInfo::print(std::ostream& os, bool serializePlan)
-{
-  os.precision(3);
-  os.setf(std::ios::fixed);
-
-  os << "\nNumber of executions = " << numExecs << std::endl;
-
-  unsigned long timeDiv = numExecs == 1 ? 1 : (numExecs - 1);
-  double cWalltime = elapsedCompWalltime / timeDiv;
-  double eWalltime = elapsedExecWalltime / timeDiv;
-  double lWalltime = elapsedLoadWalltime / timeDiv;
-  double uWalltime = elapsedUnloadWalltime / timeDiv;
-  double psWalltime = elapsedPlanSaveWalltime / timeDiv;
-  double plWalltime = elapsedPlanLoadWalltime / timeDiv;
-  double tWalltime = elapsedTotalWalltime / timeDiv;
-
-  double cCputime = elapsedCompCputime / timeDiv;
-  double eCputime = elapsedExecCputime / timeDiv;
-  double lCputime = elapsedLoadCputime / timeDiv;
-  double uCputime = elapsedUnloadCputime / timeDiv;
-  double psCputime = elapsedPlanSaveCputime / timeDiv;
-  double plCputime = elapsedPlanLoadCputime / timeDiv;
-  double tCputime = elapsedTotalCputime / timeDiv;
-
-  os << "Engine Startup Time     : " << elapsedInitWalltime
-     << " (user: " << elapsedInitCputime << ")"
-     << " milliseconds" << std::endl;
-
-  os << "Average Compilation Time: " << cWalltime
-     << " (user: " << cCputime << ")"
-     << " milliseconds" << std::endl;
-
-  if (serializePlan)
-  {
-    os << "Average Plan Saving Time: " << psWalltime
-       << " (user: " << psCputime << ")"
-       << " milliseconds" << std::endl;
-    
-    os << "Average Plan Loading Time: " << plWalltime
-       << " (user: " << plCputime << ")"
-       << " milliseconds" << std::endl;
-  }
-
-  os << "Average Execution Time  : " << eWalltime - lWalltime
-     << " (user: " << eCputime - lCputime  << ")"
-     << " milliseconds" << std::endl;
-
-  os << "Average Loading Time    : " << lWalltime
-     << " (user: " << lCputime << ")"
-     << " milliseconds" << std::endl;
-
-  os << "Average Unloading Time  : " << uWalltime
-     << " (user: " << uCputime << ")"
-     << " milliseconds" << std::endl;
-
-  os << "Average Total Time      : " << tWalltime
-     << " (user: " << tCputime << ")"
-     << " milliseconds" << std::endl;
-
-  return os;
-}
-
-
-void
-removeOutputFileIfNeeded(const ZorbaCMDProperties& lProperties)
-{
+#endif /* WIN32 */
+}
+
+static void remove_output_file() {
 #ifdef ZORBA_WITH_FILE_ACCESS
-  if ( !lProperties.outputFile().empty() )
-    fs::remove( lProperties.outputFile(), true );
+  ZorbaCmdProperties &zc_props = ZorbaCmdProperties::instance();
+  if ( !zc_props.output_file_.empty() )
+    fs::remove( zc_props.output_file_, true );
 #endif /* ZORBA_WITH_FILE_ACCESS */
 }
 
-
-int
-compileAndExecute(
-    zorba::Zorba* zorbaInstance,
-    zorba::XmlDataManager* xmlDataMgr,
-    const ZorbaCMDProperties& properties,
-    zorba::StaticContext_t& staticContext,
-    const std::string& qfilepath,
-    std::istream& qfile,
-    std::ostream& outputStream,
-    TimingInfo& timing)
-{
-  unsigned long lNumExecutions = properties.multiple();
-  bool doTiming = properties.timing();
-  bool serializePlan = properties.serializePlan();
-  bool savePlan = properties.savePlan();
-  bool loadPlan = properties.loadPlan();
-  std::ostringstream lOut;
-  Zorba_CompilerHints lHints;
-
-  std::unique_ptr<std::fstream> planFile;
-  std::fstream* planFilep = NULL;
-
-  if (qfilepath.rfind(".jq") == qfilepath.size() - 3)
-  {
-    staticContext->setJSONiqVersion(zorba::jsoniq_version_1_0);
-  }
-
-  if (serializePlan)
-  {
-    if (savePlan || loadPlan)
-    {
-      std::cerr << "The --serialize-plan option cannot be used together with the --compile-plan or --execute-plan options" << std::endl;
-      exit(1);
+static int compileAndExecute( Zorba *zorba, XmlDataManager *xmlDataMgr,
+                              StaticContext_t &sctx,
+                              string const &qfilepath,
+                              istream &qstream,
+                              ostream &outputStream,
+                              Timers &timers ) {
+  Properties const &z_props = Properties::instance();
+  ZorbaCmdProperties const &zc_props = ZorbaCmdProperties::instance();
+
+  unsigned long lNumExecutions = zc_props.multiple_;
+  ostringstream lOut;
+  Zorba_CompilerHints hints;
+
+  unique_ptr<fstream> planFile;
+  fstream *planFilep = NULL;
+
+  if ( zc_props.jsoniq_ || fs::extension( qfilepath ) == "jq" )
+    sctx->setJSONiqVersion( jsoniq_version_1_0 );
+
+  if ( zc_props.serialize_plan_ ) {
+    if ( zc_props.load_plan_ || zc_props.save_plan_ ) {
+      cerr << "The --serialize-plan option cannot be used together with the --compile-plan or --execute-plan options" << endl;
+      exit( 1 );
     }
 
-    std::string planFilePath = qfilepath;
+    string planFilePath = qfilepath;
     planFilePath += ".plan";
-    planFile.reset(new std::fstream(planFilePath.c_str(), 
-                                    std::fstream::in | 
-                                    std::fstream::out |
-                                    std::fstream::trunc |
-                                    std::fstream::binary));
+    planFile.reset(
+      new fstream(
+        planFilePath.c_str(), ios::in | ios::out | ios::trunc | ios::binary
+      )
+    );
     planFilep = planFile.get();
     assert(planFilep->good());
   }
 
-  if (savePlan && loadPlan)
-  {
-    std::cerr << "The --compile-plan and --execute-plan options cannot be used together" << std::endl;
-    exit(1);
+  if ( zc_props.save_plan_ && zc_props.load_plan_ ) {
+    cerr << "The --compile-plan and --execute-plan options cannot be used together" << endl;
+    exit( 1 );
   }
 
   // default is O1 in the Zorba_CompilerHints constructor
-  if (properties.optimizationLevel() == "O0") 
-  {
-    lHints.opt_level = ZORBA_OPT_LEVEL_O0;
-  }
-  else if (properties.optimizationLevel() == "O2") 
-  {
-    lHints.opt_level = ZORBA_OPT_LEVEL_O2;
-  }
-
-  lHints.for_serialization_only = true;
-
-#if ZORBACMD_LOAD_SYSTEM_PROPERTIES
-  if (Properties::instance()->serializeOnlyQuery() == 0)
-  {
-    lHints.for_serialization_only = false;
-  }
-#endif
-
-  // default is false
-  if (properties.libModule())
-  {
-    lHints.lib_module = true;
-  }
-
-  Zorba_SerializerOptions lSerOptions;
+  switch ( z_props.getOptimizationLevel() ) {
+    case 0: hints.opt_level = ZORBA_OPT_LEVEL_O0; break;
+    case 2: hints.opt_level = ZORBA_OPT_LEVEL_O2; break;
+  }
+
+  hints.for_serialization_only = zc_props.serialize_only_query_;
+  hints.lib_module = zc_props.lib_module_;
+
+  Zorba_SerializerOptions ser_opts;
   try {
-    lSerOptions.set( properties.getSerializerParameters() );
+    ser_opts.set( zc_props.serialization_params_ );
   }
-  catch ( zorba::ZorbaException const &e ) {
-    std::cerr << e << std::endl;
+  catch ( ZorbaException const &e ) {
+    cerr << e << endl;
     return 11;
   }
-  createSerializerOptions(lSerOptions, properties);
+  set_serializer_opts( ser_opts );
 
-  zorba::XQuery_t query;
+  XQuery_t query;
   DiagnosticHandler diagnosticHandler;
 
-  for (unsigned long i = 0; i < lNumExecutions; ++i)
-  {
-    // start the total timer
-    if (doTiming)
-      timing.startTimer(TimingInfo::TOTAL_TIMER, i);
-    
+  for ( unsigned long exec = 0; exec < lNumExecutions; ++exec ) {
+    if ( zc_props.timing_ )
+      timers.startTimer( Timers::total, exec );
+
     //
     // Compile the query
     // Compilation is done only once, unless timing is needed
     //
-    if (doTiming || i == 0)
-    {
+    if ( zc_props.timing_ || exec == 0 ) {
       // go back to the beginning of the stream
-      qfile.clear();
-      qfile.seekg(0);
-      assert (qfile.tellg() >= 0);
+      qstream.clear();
+      qstream.seekg( 0 );
+      assert( qstream.tellg() >= 0 );
 
-      try
-      {
-        // start the compilation timer
-        if (doTiming)
-          timing.startTimer(TimingInfo::COMP_TIMER, i);
+      try {
+        if ( zc_props.timing_ )
+          timers.startTimer( Timers::comp, exec );
 
         // Create and compile the query
-        query = zorbaInstance->createQuery();
-        query->registerDiagnosticHandler(&diagnosticHandler);
-        query->setFileName(qfilepath);
-
-        if (loadPlan) 
-        {
-          query->loadExecutionPlan(qfile, &theSerializationCallback);
-
-          // stop the compilation timer
-          if (doTiming)
-            timing.stopTimer(TimingInfo::COMP_TIMER, i);
-        }
-        else
-        {
-          query->compile(qfile, staticContext, lHints);
-
-          // stop the compilation timer
-          if (doTiming)
-            timing.stopTimer(TimingInfo::COMP_TIMER, i);
+        query = zorba->createQuery();
+        query->registerDiagnosticHandler( &diagnosticHandler );
+        query->setFileName( qfilepath );
+
+        if ( zc_props.load_plan_ ) {
+          query->loadExecutionPlan( qstream, &serialization_callback );
+          if ( zc_props.timing_ )
+            timers.stopTimer( Timers::comp, exec );
+        } else {
+          query->compile( qstream, sctx, hints );
+
+          if ( zc_props.timing_ )
+            timers.stopTimer( Timers::comp, exec );
 
           // Serialize the execution plan, if requested
-          if (serializePlan) 
-          {
+          if ( zc_props.serialize_plan_ ) {
             planFilep->clear();
-            planFilep->seekp(0);
-
-            // start the plan-save timer
-            if (doTiming)
-              timing.startTimer(TimingInfo::PLAN_SAVE_TIMER, i);
-
-            query->saveExecutionPlan(*planFilep);
-
-            // stop the plan-save timer
-            if (doTiming)
-              timing.stopTimer(TimingInfo::PLAN_SAVE_TIMER, i);
-
+            planFilep->seekp( 0 );
+
+            if ( zc_props.timing_ )
+              timers.startTimer( Timers::plan_save, exec );
+            query->saveExecutionPlan( *planFilep );
+            if ( zc_props.timing_ )
+              timers.stopTimer( Timers::plan_save, exec );
             planFilep->flush();
           }
         }
       }
-      catch (zorba::XQueryException const& qe)
-      {
-        print_exception( qe, properties );
+      catch ( XQueryException const &qe ) {
+        print_exception( qe );
         return 11;
       }
-      catch (zorba::ZorbaException const& ze)
-      {
-        std::cerr << ze << std::endl;
+      catch ( ZorbaException const &ze ) {
+        cerr << ze << endl;
         return 12;
       }
-    } // if (doTiming || i == 0)
+    } // if (zc_props.timing_ || exec == 0)
 
     //
-    // Run the query, unless compileOnly has been requested.
+    // Run the query, unless compile-only has been requested.
     //
-    if ( ! properties.compileOnly() && ! properties.libModule() )
-    {
-      try
-      {
+    if ( !zc_props.compile_only_ && !zc_props.lib_module_ ) {
+      try {
         // load the execution plan, if requested
-        if (serializePlan) 
-        {
-          planFilep->seekg(0);
-          assert(planFilep->good());
-          
-          // start the plan-load timer
-          if (doTiming)
-            timing.startTimer(TimingInfo::PLAN_LOAD_TIMER, i);
-
-          query = zorbaInstance->createQuery();
-          query->loadExecutionPlan(*planFilep, &theSerializationCallback);
-
-          // stop the plan-load timer
-          if (doTiming)
-            timing.stopTimer(TimingInfo::PLAN_LOAD_TIMER, i);
+        if ( zc_props.serialize_plan_ ) {
+          planFilep->seekg( 0 );
+          assert( planFilep->good() );
+
+          if ( zc_props.timing_ )
+            timers.startTimer( Timers::plan_load, exec );
+
+          query = zorba->createQuery();
+          query->loadExecutionPlan( *planFilep, &serialization_callback );
+
+          if ( zc_props.timing_ )
+            timers.stopTimer( Timers::plan_load, exec );
         }
 
-        // start the execution timer
-        if (doTiming)
-          timing.startTimer(TimingInfo::EXEC_TIMER, i);
+        if ( zc_props.timing_ )
+          timers.startTimer( Timers::exec, exec );
 
         // Populate the dynamic context
-        zorba::DynamicContext* lDynamicContext = query->getDynamicContext();
-        try
-        {
-          if ( ! populateDynamicContext(zorbaInstance,
-                                        xmlDataMgr,
-                                        lDynamicContext,
-                                        properties) )
-          {
-            properties.printHelp(std::cout);
+        try {
+          DynamicContext *const dctx = query->getDynamicContext();
+          if ( !populateDynamicContext( zorba, xmlDataMgr, dctx ) ) {
+            print_help();
             return 21;
           }
         }
-        catch (zorba::XQueryException const& qe)
-        {
-          print_exception( qe, properties );
+        catch ( XQueryException const &qe ) {
+          print_exception( qe );
           return 22;
         }
-        catch (zorba::ZorbaException const& ze)
-        {
-          std::cerr << ze << std::endl;
+        catch ( ZorbaException const &ze ) {
+          cerr << ze << endl;
           return 23;
         }
 
         // run the query
-        if (properties.noSerializer())
-        {
+        if ( zc_props.no_serializer_ )
           query->executeSAX();
-        }
-        else if (savePlan)
-        {
-          query->saveExecutionPlan(outputStream);
-        }
+        else if ( zc_props.save_plan_ )
+          query->saveExecutionPlan( outputStream );
         else
-        {
-          query->execute(outputStream, &lSerOptions);
-        }
-
-        if (properties.trailingNl()) 
-          outputStream << std::endl;
- 
+          query->execute( outputStream, &ser_opts );
+
+        if ( zc_props.trailing_nl_ )
+          outputStream << endl;
+
         query->close();
 
-         // stop the execution timer
-        if (doTiming)
-          timing.stopTimer(TimingInfo::EXEC_TIMER, i);
+        if ( zc_props.timing_ )
+          timers.stopTimer( Timers::exec, exec );
 
-        if (i > 0 || lNumExecutions == 1) 
-        {
-          timing.elapsedLoadWalltime += query->getDocLoadingTime();
-          timing.elapsedLoadCputime += query->getDocLoadingUserTime();
+        if ( exec > 0 || lNumExecutions == 1 ) {
+          timers.elapsed_load_walltime += query->getDocLoadingTime();
+          timers.elapsed_load_cputime += query->getDocLoadingUserTime();
         }
       }
-      catch (zorba::XQueryException const& qe)
-      {
-        print_exception( qe, properties );
+      catch ( XQueryException const &qe ) {
+        print_exception( qe );
         return 31;
       }
-      catch (zorba::ZorbaException const& ze)
-      {
-        std::cerr << ze << std::endl;
+      catch ( ZorbaException const &ze ) {
+        cerr << ze << endl;
         return 32;
       }
     }
@@ -901,423 +515,374 @@
     //
     // Delete all loaded docs from the store, if timing has been requested
     //
-    if (doTiming)
-    {
-      timing.startTimer(TimingInfo::UNLOAD_TIMER, i);
+    if ( zc_props.timing_ ) {
+      timers.startTimer( Timers::unload, exec );
 
-      DocumentManager* docMgr = xmlDataMgr->getDocumentManager();
+      DocumentManager *const docMgr = xmlDataMgr->getDocumentManager();
       ItemSequence_t docsSeq = docMgr->availableDocuments();
-      Iterator_t lIter = docsSeq->getIterator();
-      lIter->open();
+      Iterator_t i( docsSeq->getIterator() );
+      i->open();
 
       Item uri;
-      std::vector<Item> docURIs;
-      while (lIter->next(uri)) 
-      {
-        docURIs.push_back(uri);
-      }
-      lIter->close();
-
-      size_t numDocs = docURIs.size();
-
-      for (size_t k = 0; k < numDocs; ++k)
-      {
-        docMgr->remove(docURIs[k].getStringValue());
-      }
-
-      timing.stopTimer(TimingInfo::UNLOAD_TIMER, i);
+      vector<Item> docURIs;
+      while ( i->next( uri ) )
+        docURIs.push_back( uri );
+      i->close();
+
+      for ( vector<Item>::const_iterator
+            i = docURIs.begin(); i != docURIs.end(); ++i ) {
+        docMgr->remove( i->getStringValue() );
+      }
+
+      timers.stopTimer( Timers::unload, exec );
     }
 
-    // stop the total timer
-    if (doTiming)
-      timing.stopTimer(TimingInfo::TOTAL_TIMER, i);
+    if ( zc_props.timing_ )
+      timers.stopTimer( Timers::total, exec );
 
 #ifdef DO_AUDIT
-    audit::Event* event = staticContext->getAuditEvent(); 
-    std::cerr << *event << std::endl;
-#endif
+    cerr << *sctx->getAuditEvent() << endl;
+#endif /* DO_AUDIT */
   } // for each execution
 
   return 0;
 }
 
-/////////////////////////////////////////////////////////////////////////////////
-//                                                                             //
-//  Main                                                                       //
-//                                                                             //
-/////////////////////////////////////////////////////////////////////////////////
+static void set_paths_on_sctx( StaticContext_t &sctx ) {
+  ZorbaCmdProperties &zc_props = ZorbaCmdProperties::instance();
+  vector<String> paths;
+
+  // Compute the current working directory to append to all paths.
+  string const cwd( fs::curdir() );
+
+  // setModulePaths() *overwrites* the URI path and lib path, so there's no
+  // sense in calling both. So if --module-path exists, just use it.
+
+  if ( !zc_props.module_path_.empty() ) {
+    tokenize( zc_props.module_path_, fs::path_separator, &paths );
+    paths.push_back( cwd );
+    sctx->setModulePaths( paths );
+  } else {
+    // Compute and set URI path
+    tokenize( zc_props.uri_path_, fs::path_separator, &paths );
+    paths.push_back( cwd );
+    sctx->setURIPath( paths );
+    paths.clear();
+
+    // Compute and set lib path
+    tokenize( zc_props.lib_path_, fs::path_separator, &paths );
+    paths.push_back( cwd );
+    sctx->setLibPath( paths );
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+//  Main                                                                     //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WIN32_WCE
-int
-main(int argc, char* argv[])
+int main( int argc, char const *argv[] ) {
 #else
-int
-_tmain(int argc, _TCHAR* argv[])
-#endif
-{
-#if ZORBACMD_LOAD_SYSTEM_PROPERTIES
-  // only configurable via a config file or environment vars
-  zorba::Properties::load(0, NULL);
-#endif
-
-  // parse the command line and/or the properties file
-  ZorbaCMDProperties properties;
-  if (!properties.loadProperties(argc, argv))
-  {
-    return 1;
-  }
-
-  TimingInfo engineTiming(properties.multiple());
-
-  bool doTiming = properties.timing();
-  bool debug = false;
+int _tmain( int argc, _TCHAR const *argv[] ) {
+#endif
+  int const optind = parse_args( argc, argv );
+  argc -= optind;
+  argv += optind;
+
+  Properties const &z_props = Properties::instance();
+  ZorbaCmdProperties const &zc_props = ZorbaCmdProperties::instance();
+
+  Timers timers( zc_props.multiple_ );
+
 #ifdef ZORBA_WITH_DEBUGGER
-  debug = (properties.debug());
+  bool const debug = zc_props.debug_;
+#else
+  bool const debug = false;
 #endif
 
-  // libModule assumes compileOnly even if compileOnly is false
-  bool compileOnly = (properties.compileOnly() || properties.libModule() );
+  // libModule assumes compile-only even if compile-only is false
+  bool const compile_only = zc_props.compile_only_ || zc_props.lib_module_;
 
   // write to file or standard out
-  std::unique_ptr<std::ostream> 
-  lFileStream(
-      #ifdef ZORBA_WITH_FILE_ACCESS
-        properties.outputFile().size() > 0 ?
-          new std::ofstream(properties.outputFile().c_str()) : 0
-      #else /* ZORBA_WITH_FILE_ACCESS */
-        0
-      #endif /* ZORBA_WITH_FILE_ACCESS */
-        );
+  unique_ptr<ostream> out_stream_ptr(
+#ifdef ZORBA_WITH_FILE_ACCESS
+    !zc_props.output_file_.empty() ?
+      new ofstream( zc_props.output_file_.c_str() ) : 0
+#else /* ZORBA_WITH_FILE_ACCESS */
+    0
+#endif /* ZORBA_WITH_FILE_ACCESS */
+  );
 
-  std::ostream* lOutputStream = lFileStream.get();
-  if ( lOutputStream == 0 )
-  {
-    lOutputStream = &std::cout;
-  }
+  ostream *out_stream = out_stream_ptr.get();
+  if ( !out_stream )
+    out_stream = &cout;
 #ifdef ZORBA_WITH_FILE_ACCESS
-  else if ( !lOutputStream->good() )
-  {
-    std::cerr << "could not write to output file {" << properties.outputFile()
-              << "}" << std::endl;
+  else if ( !out_stream->good() ) {
+    cerr << "could not write to output file {" << zc_props.output_file_
+         << '}' << endl;
     return 2;
   }
 #endif /* ZORBA_WITH_FILE_ACCESS */
 
-  if (properties.queriesOrFilesBegin() == properties.queriesOrFilesEnd())
-  {
-    std::cerr << "no queries submitted." << std::endl;
-    properties.printHelp(std::cout);
+  if ( zc_props.queries_or_files_.empty() ) {
+    cerr << "no queries submitted." << endl;
+    print_help();
     return 3;
   }
 
-  // Add command line --classpath option in front of config/env CLASSPATH
-  Properties* globaproperties = Properties::instance();
-  std::string cmdJvmClassPath;
-  properties.getJVMClassPath(cmdJvmClassPath);
-  std::string configJvmClassPath;
-  globaproperties->getJVMClassPath(configJvmClassPath);
-  globaproperties->setJVMClassPath(cmdJvmClassPath +
-      fs::path_separator + configJvmClassPath);
-
   // Start the engine
 
-  engineTiming.startTimer(TimingInfo::INIT_TIMER, 2);
-
-  void* store = zorba::StoreManager::getStore();
-
-  zorba::Zorba* lZorbaInstance = zorba::Zorba::getInstance(store);
-
-  zorba::XmlDataManager_t xmlDataMgr = lZorbaInstance->getXmlDataManager();
+  timers.startTimer( Timers::init, 2 );
+
+  void *const store = StoreManager::getStore();
+  Zorba *const zorba = Zorba::getInstance( store );
+
+  XmlDataManager_t xmlDataMgr = zorba->getXmlDataManager();
 
 #ifdef DO_AUDIT
-  zorba::audit::Provider* lAuditProvider = lZorbaInstance->getAuditProvider();
-
-  zorba::audit::Configuration* config = lAuditProvider->createConfiguration();
-
-  std::vector<zorba::String> property_names;
-  zorba::audit::Configuration::getPropertyNames(property_names);
-
-  zorba::audit::Configuration::
+  audit::Provider* lAuditProvider = zorba->getAuditProvider();
+
+  audit::Configuration* config = lAuditProvider->createConfiguration();
+
+  vector<String> property_names;
+  audit::Configuration::getPropertyNames(property_names);
+
+  audit::Configuration::
   enableProperty(config, property_names, "xquery/compilation/parse-duration");
 
-  zorba::audit::Configuration::
+  audit::Configuration::
   enableProperty(config, property_names, "xquery/compilation/translation-duration");
 
-  zorba::audit::Configuration::
+  audit::Configuration::
   enableProperty(config, property_names, "xquery/compilation/optimization-duration");
 
-  zorba::audit::Configuration::
+  audit::Configuration::
   enableProperty(config, property_names, "xquery/compilation/codegeneration-duration");
 #endif
 
   {
-  engineTiming.stopTimer(TimingInfo::INIT_TIMER, 2);
+  timers.stopTimer( Timers::init, 2 );
 
   // For each query ...
 
-  int queryNo;
-  ZorbaCMDProperties::QueriesOrFiles_t::const_iterator lIter;
-  for (queryNo = 1, lIter = properties.queriesOrFilesBegin();
-       lIter != properties.queriesOrFilesEnd();
-       ++queryNo, ++lIter)
-  {
+  int query_no;
+  vector<string>::const_iterator i;
+  for ( query_no = 1, i = zc_props.queries_or_files_.begin();
+        i != zc_props.queries_or_files_.end(); ++query_no, ++i ) {
     //
     // Read the query (either from a file or given as parameter)
     //
-    std::string fURI = *lIter;
-    std::string fname = parseFileURI (properties.asFiles (), fURI);
-    std::string path( fname );
-    bool asFile = !fname.empty();
-    std::unique_ptr<std::istream> qfile;
+    string const uri( *i );
+    string const fname( zc_props.as_files_ ? uri : parse_file_uri( uri ) );
+    string path( fname );
+    bool const as_file = !fname.empty();
+    unique_ptr<istream> qstream;
 
-    if (asFile)
-    {
+    if ( as_file ) {
       fs::make_absolute( &path );
-      qfile.reset( new std::ifstream( path.c_str() ) );
-    }
-    else
-    {
-      qfile.reset(new std::istringstream(fURI));
+      qstream.reset( new ifstream( path.c_str() ) );
+    } else {
+      qstream.reset( new istringstream( uri ) );
     }
 
-    if (asFile && (!qfile->good() || qfile->eof()))
-    {
-      std::cerr << "file {" << fname << "} not found or not readable." << std::endl;
-      properties.printHelp(std::cout);
+    if ( as_file && (!qstream->good() || qstream->eof()) ) {
+      cerr << "file {" << fname << "} not found or not readable." << endl;
+      print_help();
       return 3;
-    }
-    else if (fURI.empty ())
-    {
-      std::cerr << "empty query." << std::endl;
-      properties.printHelp(std::cout);
+    } else if ( uri.empty() ) {
+      cerr << "empty query." << endl;
+      print_help();
       return 3;
     }
 
     //
     // Print the query if requested
     //
-    if (properties.printQuery()) 
-    {
-      *lOutputStream << "\nQuery number " << queryNo << " :\n";
-      std::copy (std::istreambuf_iterator<char> (*qfile),
-                 std::istreambuf_iterator<char> (),
-                 std::ostreambuf_iterator<char> (*lOutputStream));
-      *lOutputStream << std::endl;
-      // go back to the beginning
-      qfile->seekg(0);
+    if ( zc_props.print_query_ ) {
+      *out_stream << "\nQuery number " << query_no << " :\n";
+      copy(
+        istreambuf_iterator<char>( *qstream ),
+        istreambuf_iterator<char>(),
+        ostreambuf_iterator<char>( *out_stream )
+      );
+      *out_stream << endl;
+      qstream->seekg( 0 );
     }
 
     //
-    // Create the static context and populate it with info taken from the properties
+    // Create the static context and populate it with info taken from the
+    // properties
     //
-    zorba::StaticContext_t lStaticContext = lZorbaInstance->createStaticContext();
+    StaticContext_t sctx = zorba->createStaticContext();
 
-    if (! populateStaticContext(lZorbaInstance, lStaticContext, properties) )
-    {
-      properties.printHelp(std::cout);
+    if ( !populateStaticContext( zorba, sctx ) ) {
+      print_help();
       return 3;
     }
 
 #ifdef DO_AUDIT
-    zorba::audit::Event* event = lAuditProvider->createEvent(config);
-    lStaticContext->setAuditEvent(event);
+    audit::Event *event = lAuditProvider->createEvent( config );
+    sctx->setAuditEvent( event );
 #endif // DO_AUDIT
 
-    if (!asFile && properties.baseUri().size() == 0 )
-    {
+    if ( !as_file && zc_props.base_uri_.empty() ) {
       // No user set base URI. Set the cwd to be used as base-uri in order
       // to make the doc function doc("mydoc.xml") work
-      std::string p( fs::curdir() );
-      std::stringstream lTmp;
-      std::vector<std::string> lTokens;
-      std::string const delim( 1, fs::dir_separator );
-      Util::tokenize(p.c_str(), delim, lTokens);
+      string p( fs::curdir() );
+      stringstream lTmp;
+      vector<string> lTokens;
+      tokenize( p, fs::dir_separator, &lTokens );
 
       lTmp << "file://";
-      for (std::vector<std::string>::const_iterator lIter = lTokens.begin();
-           lIter != lTokens.end(); ++lIter)
-      {
-        zorba::String lTmpString(*lIter);
-        lTmp << '/' << fn::encode_for_uri( lTmpString );
+      for ( vector<string>::const_iterator i = lTokens.begin();
+            i != lTokens.end(); ++i ) {
+        String s( *i );
+        lTmp << '/' << fn::encode_for_uri( s );
       }
 
       lTmp << '/';
-
-      lStaticContext->setBaseURI(lTmp.str());
+      sctx->setBaseURI( lTmp.str() );
     }
 
     // Parse the query
-    if (properties.parseOnly()) 
-    {
-      try 
-      {
-        zorba::XQuery_t lQuery = lZorbaInstance->createQuery();
-        if (asFile)
-        {
-          lQuery->setFileName(path);
-        }
+    if ( zc_props.parse_only_ ) {
+      try {
+        XQuery_t lQuery = zorba->createQuery();
+        if ( as_file )
+          lQuery->setFileName( path );
 
-        lQuery->parse (*qfile);
+        lQuery->parse (*qstream);
       }
-      catch (zorba::ZorbaException const& ze) 
-      {
-        std::cerr << ze << std::endl;
+      catch ( ZorbaException const &ze ) {
+        cerr << ze << endl;
         return 6;
       }
     }
 
     // Compile and run it if necessary.
     // Print timing information if requested.
-    else if (!debug) 
-    {
-      if (compileOnly) 
-      {
-        try 
-        {
-          zorba::XQuery_t aQuery = lZorbaInstance->createQuery();
-          if (asFile) 
-          {
-            aQuery->setFileName(path);
-          }
-
-          aQuery->parse(*qfile);
-
-          qfile->clear();
-          qfile->seekg(0); // go back to the beginning
+    else if ( !debug ) {
+      if ( compile_only ) {
+        try {
+          XQuery_t aQuery = zorba->createQuery();
+          if ( as_file )
+            aQuery->setFileName( path );
+
+          aQuery->parse( *qstream );
+          qstream->clear();
+          qstream->seekg( 0 );
         }
-        catch (zorba::XQueryException const& qe)
-        {
-          print_exception( qe, properties );
+        catch ( XQueryException const &qe ) {
+          print_exception( qe );
           return 6;
         }
       }
 
-      TimingInfo queryTiming(properties.multiple());
+      Timers queryTiming( zc_props.multiple_ );
 
-      int status = compileAndExecute(lZorbaInstance,
+      int status = compileAndExecute(zorba,
                                      xmlDataMgr,
-                                     properties,
-                                     lStaticContext,
+                                     sctx,
                                      path,
-                                     *qfile,
-                                     *lOutputStream,
+                                     *qstream,
+                                     *out_stream,
                                      queryTiming);
-      if (status != 0) 
-      {
+      if ( status != 0 ) {
         // reset the file handler (in case output option was provided)
         // in order to delete the created output file
-        lFileStream.reset();
-        removeOutputFileIfNeeded(properties);
+        out_stream_ptr.reset();
+        remove_output_file();
         return status;
       }
 
-      if (doTiming) 
-      {
-        bool serializePlan = properties.serializePlan();
-        queryTiming.print(std::cout, serializePlan);
-      }
+      if ( zc_props.timing_ )
+        queryTiming.print( cout, zc_props.serialize_plan_ );
     }
 
 #ifdef ZORBA_WITH_DEBUGGER
-    // Debug the query. Do not allow "compileOnly" flags and inline queries
-    else if (debug) 
-    {
-      if (compileOnly) 
-      {
-        std::cerr << "cannot debug a query if the compileOnly option is specified"
-                  << std::endl;
+    // Debug the query. Do not allow "compile_only" flags and inline queries
+    else if ( debug ) {
+      if ( compile_only ) {
+        cerr << "cannot debug a query if the --compile-only option is specified"
+             << endl;
         return 7;
       }
 
-      if (!asFile) 
-      {
-        std::cerr << "Cannot debug inline queries." << std::endl;
+      if ( !as_file ) {
+        cerr << "Cannot debug inline queries." << endl;
         return 8;
       }
 
-      std::unique_ptr<std::istream> lXQ(new std::ifstream(path.c_str()));
-      std::string lFileName(path);
-
-      zorba::XQuery_t lQuery;
-
-      try 
-      {
-        lQuery = lZorbaInstance->createQuery();
-        lQuery->setFileName(lFileName);
-        lQuery->setDebugMode(true);
-
-        Zorba_CompilerHints lHints;
-        lHints.opt_level = ZORBA_OPT_LEVEL_O0;
-
-        lQuery->compile(*lXQ.get(), lHints);
-        zorba::DynamicContext* lDynamicContext = lQuery->getDynamicContext();
-        if (!populateDynamicContext(lZorbaInstance,
-                                    xmlDataMgr,
-                                    lDynamicContext,
-                                    properties))
+      unique_ptr<istream> lXQ( new ifstream( path.c_str() ) );
+
+      XQuery_t query;
+
+      try {
+        query = zorba->createQuery();
+        query->setFileName( path );
+        query->setDebugMode( true );
+
+        Zorba_CompilerHints hints;
+        hints.opt_level = ZORBA_OPT_LEVEL_O0;
+
+        query->compile( *lXQ.get(), hints );
+        if (!populateDynamicContext(zorba, xmlDataMgr,
+                                    query->getDynamicContext()))
         {
           return 9;
         }
 
-        std::string lHost = properties.debugHost();
-        if (lHost == "") {
-          lHost = "127.0.0.1";
-        }
-
-        Zorba_SerializerOptions lSerOptions(properties.getSerializerParameters());
-        createSerializerOptions(lSerOptions, properties);
-
-        if (!properties.hasNoLogo()) 
-        {
-          std::cout << "Zorba XQuery Debugger Server\n" << copyright_str << std::endl;
-        }
-
-        lQuery->debug(*lOutputStream, lSerOptions, lHost, properties.getDebugPort());
+        Zorba_SerializerOptions ser_opts( zc_props.serialization_params_ );
+        set_serializer_opts( ser_opts );
+
+        if ( !zc_props.no_logo_ )
+          cout << "Zorba XQuery Debugger Server\n" << copyright << endl;
+
+        query->debug( *out_stream, ser_opts, zc_props.debug_host_, zc_props.debug_port_ );
       }
-      catch (zorba::XQueryException const& qe)
-      {
-        print_exception( qe, properties );
+      catch ( XQueryException const &qe ) {
+        print_exception( qe );
         return 5;
       }
-      catch (zorba::ZorbaException const& ze)
-      {
-        std::cerr << ze << std::endl;
+      catch ( ZorbaException const &ze ) {
+        cerr << ze << endl;
         return 6;
       }
     } // else if (debug)
-#endif
+#endif /* ZORBA_WITH_DEBUGGER */
 
 #ifdef DO_AUDIT
-    lAuditProvider->submitEvent(event);
+    lAuditProvider->submitEvent( event );
 #endif
 
   } // for each query
 
   }
 
-  if (doTiming)
-  {
-    engineTiming.startTimer(TimingInfo::DEINIT_TIMER, 2);
-  }
+  if ( zc_props.timing_ )
+    timers.startTimer( Timers::deinit, 2 );
 
 #ifdef DO_AUDIT
   lAuditProvider->destroyConfiguration(config);
-#endif
-
-  xmlDataMgr = NULL;
-
-  lZorbaInstance->shutdown();
-  zorba::StoreManager::shutdownStore(store);
-
-  if (doTiming)
-  {
-    engineTiming.stopTimer(TimingInfo::DEINIT_TIMER, 2);
-
-    std::cout << std::endl << "Engine Shutdown Time     : "
-              << engineTiming.elapsedDeinitWalltime
-              << " (user: " << engineTiming.elapsedDeinitCputime << ")"
-              << " milliseconds" << std::endl;
+#endif /* DO_AUDIT */
+
+  zorba->shutdown();
+  StoreManager::shutdownStore( store );
+
+  if ( zc_props.timing_ ) {
+    timers.stopTimer( Timers::deinit, 2 );
+
+    cout << endl << "Engine Shutdown Time     : "
+         << timers.elapsed_deinit_walltime
+         << " (user: " << timers.elapsed_deinit_cputime << ")"
+         << " milliseconds" << endl;
   }
+
   return 0;
 }
+
+///////////////////////////////////////////////////////////////////////////////
+
 /* vim:set et sw=2 ts=2: */
 
=== added file 'bin/zorbacmd_args.cpp'
--- bin/zorbacmd_args.cpp	1970-01-01 00:00:00 +0000
+++ bin/zorbacmd_args.cpp	2014-02-11 00:42:47 +0000
@@ -0,0 +1,783 @@
+/*
+ * 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.
+ */
+
+// standard
+#include <algorithm>
+#include <cstdlib>
+#include <cctype>
+#include <iostream>
+
+// Zorba
+#include <zorba/zorba.h>
+#include <zorba/properties.h>
+
+// local
+#include "zorbacmd_props.h"
+
+using namespace std;
+using namespace zorba;
+
+///////////////////////////////////////////////////////////////////////////////
+
+static char const* check_args() {
+  ZorbaCmdProperties const &zc_props = ZorbaCmdProperties::instance();
+
+  if ( !( zc_props.boundary_space_.empty() ||
+          zc_props.boundary_space_ == "preserve" ||
+          zc_props.boundary_space_ == "strip" ) )
+    return "Only strip and preserve are allowed as values for the option boundary-space";
+
+  if ( !( zc_props.construction_mode_.empty() ||
+          zc_props.construction_mode_ == "preserve" ||
+          zc_props.construction_mode_ == "strip" ) )
+    return "Only strip and preserve are allowed as values for the option construction-mode";
+
+  if ( zc_props.optimization_level_ > 2 )
+    return "only 0, 1 and 2 are allowed as values for the option --optimization-level";
+
+  if ( !( zc_props.ordering_mode_.empty() ||
+          zc_props.ordering_mode_ == "ordered" ||
+          zc_props.ordering_mode_ == "unordered" ) )
+    return "Only ordered and unordered are allowed as values for the option ordering-mode";
+
+  if ( zc_props.queries_or_files_.empty() )
+    return "No queries submitted\nUsage: zorba -q '1 + 1' execute an inline query \n zorba file.xq execute a query from a file";
+
+  return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define HELP_OPT(ARG) ARG "\n"
+
+char const* get_help_msg() {
+  return
+
+    ////////// a //////////////////////////////////////////////////////////////
+
+#ifndef NDEBUG
+    HELP_OPT( "--abort" )
+      "Call abort(3) when a ZorbaException is thrown.\n\n"
+#endif /* NDEBUG */
+
+    HELP_OPT( "--as-files, -f" )
+      "Treat all -q arguments as file paths instead of URIs or inline queries. This option is deprecated and will be defaulted to true in the future, so any entry in the command line is going to be treated as files.\n\n"
+
+    ////////// b //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--base-uri" )
+      "Set the base URI property of the static context.\n\n"
+
+    HELP_OPT( "--boundary-space" )
+      "Set the boundary-space policy ('strip' or 'preserve') in the static context.\n\n"
+
+    HELP_OPT( "--byte-order-mark" )
+      "Set the byte-order-mark for the serializer.\n\n"
+
+    ////////// c //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--classpath" )
+      "JVM classpath to be used by modules using Java implementations\n\n"
+
+    HELP_OPT( "--compile-only" )
+      "Only compile (don't execute).\n\n"
+
+    HELP_OPT( "--compile-plan," )
+      "Do not execute the query; just compile it and save the execution plan in the file specified with the -o option.\n\n"
+
+    HELP_OPT( "--construction-mode" )
+      "Set the construction mode ('strip' or 'preserve') in the static context.\n\n"
+
+    HELP_OPT( "--context-item" )
+      "Set the context item to the XML document in a given file.\n\n"
+
+    ////////// d //////////////////////////////////////////////////////////////
+
+#ifdef ZORBA_WITH_DEBUGGER
+    HELP_OPT( "--debug, -d" )
+      "Launch the Zorba debugger server and connect to a DBGP-enabled debugger client.\n\n"
+#endif /* ZORBA_WITH_DEBUGGER */
+
+    HELP_OPT( "--debug-file" )
+      "Sets the file to write developer debugging information to.\n\n"
+
+#ifdef ZORBA_WITH_DEBUGGER
+    HELP_OPT( "--debug-host, -h" )
+      "The host where the DBGP-enabled debugger client listens for connections. Defaults to: 127.0.0.1\n\n"
+
+    HELP_OPT( "--debug-port, -p" )
+      "The port on which the DBGP-enabled debugger client listens for connections. Defaults to: 28028\n\n"
+#endif /* ZORBA_WITH_DEBUGGER */
+
+    HELP_OPT( "--default-collation" )
+      "Add the given collation and set the value of the default collation in the static context to the given collation.\n\n"
+
+    HELP_OPT( "--disable-http-resolution" )
+      "Do not use HTTP to resolve URIs.\n\n"
+
+    HELP_OPT( "--dump-lib" )
+      "Dump function library.\n\n"
+
+    ////////// e //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--execute-plan" )
+      "Do not compile the query; instead load the execution plan from the file specified by the -f -q options (or by any file specified without any other argument), and execute the loaded plan.\n\n"
+
+    HELP_OPT( "--external-variable, -e" )
+      "Provide the value for a variable given a file (name=file) or a value (name:=value)\n\n"
+
+    ////////// f //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--force-gflwor" )
+      "Force the compiler to generate GFLWOR iterators.\n\n"
+
+    ////////// h //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--help, -h" )
+      "Print this help message.\n\n"
+
+    ////////// i //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--indent, -i" )
+      "Indent output.\n\n"
+
+    HELP_OPT( "--infer-joins" )
+      "Infer joins.\n\n"
+
+    HELP_OPT( "--inline-udf" )
+      "Inline user-defined functions.\n\n"
+
+    ////////// j //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--jsoniq, -j" )
+      "Force queries to be considered JSONiq.\n\n"
+
+    ////////// l //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--lib-module, -l" )
+      "Query compiler option to treat the query as a library module. If this is set --compile-only option is also set to true.\n\n"
+
+    HELP_OPT( "--lib-path" )
+      "Library path (list of directories) where Zorba will look for dynamic libraries (e.g., module external function implementations.\n\n"
+
+    HELP_OPT( "--loop-hosting" )
+      "Hoist expressions out of loops.\n\n"
+
+    ////////// m //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--max-udf-call-depth" )
+      "Maximum stack depth of user-defined function calls.\n\n"
+
+    HELP_OPT( "--module-path" )
+      "Path (list of directories) to add to both the URI and Library paths.\n\n"
+
+    HELP_OPT( "--multiple, -m" )
+      "Execute the given queries multiple times.\n\n"
+
+    ////////// n //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--no-copy-optim" )
+      "Apply the no-copy optimization.\n\n"
+
+    HELP_OPT( "--no-logo" )
+      "Print no logo when starting.\n\n"
+
+    HELP_OPT( "--no-serializer" )
+      "Do not serialize (discard) result.\n\n"
+
+    HELP_OPT( "--no-tree-ids" )
+      "Suppress IDs and locations from compiler tree dumps.\n\n"
+
+    ////////// o //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--omit-xml-declaration, -r" )
+      "Omit the XML declaration from the result.\n\n"
+
+    HELP_OPT( "--optimization-level, -O" )
+      "Optimization level for the query compiler [0-2], default: 1\n\n"
+
+    HELP_OPT( "--option" )
+      "Set an XQuery option in the static context. The QName of the option is passed as a string in the notation by James Clark (i.e. {namespace}localname). For example, --option {http://zorba.io/}option=value\n\n"
+
+    HELP_OPT( "--ordering-mode" )
+      "Set the ordering mode ('ordered' or 'unordered') in the static context.\n\n"
+
+#ifdef ZORBA_WITH_FILE_ACCESS
+    HELP_OPT( "--output-file, -o" )
+      "Write the result to the given file.\n\n"
+#endif /* ZORBA_WITH_FILE_ACCESS */
+
+    ////////// p //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--parse-only" )
+      "Stop after parsing the query.\n\n"
+
+    HELP_OPT( "--print-ast" )
+      "Print the abstract syntax tree.\n\n"
+
+    HELP_OPT( "--print-errors-as-xml, -x" )
+      "Print the errors as XML.\n\n"
+
+    HELP_OPT( "--print-intermediate-opt" )
+      "Print intermediate optimizations.\n\n"
+
+    HELP_OPT( "--print-item-flow" )
+      "Print items produced by all iterators.\n\n"
+
+    HELP_OPT( "--print-iterator-tree" )
+      "Print the iterator tree.\n\n"
+
+    HELP_OPT( "--print-locations" )
+      "Print parser locations for compiler expressions.\n\n"
+
+    HELP_OPT( "--print-optimized" )
+      "Print the optimized expression tree.\n\n"
+
+    HELP_OPT( "--print-query" )
+      "Print the queries.\n\n"
+
+    HELP_OPT( "--print-static-types" )
+      "Print static type inference.\n\n"
+
+    HELP_OPT( "--print-translated" )
+      "Print the normalized expression tree.\n\n"
+
+    ////////// q //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--query, -q" )
+      "Query test or file URI (file://...)\n\n"
+
+    ////////// s //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--serialization-parameter, -z" )
+      "Set serialization parameter in the form of a parameter=value pair (see http://www.w3.org/TR/xslt-xquery-serialization/#serparam, e.g.: -z method=xhtml -z doctype-system=DTD/xhtml1-strict.dtd -z indent=yes).\n\n"
+
+    HELP_OPT( "--serialize-html" )
+      "Serialize the result as HTML.\n\n"
+
+    HELP_OPT( "--serialize-plan, -s" )
+      "Serialize and then load the query execution plan.\n\n"
+
+    HELP_OPT( "--serialize-only-query" )
+      "Serialize only query.\n\n"
+
+    HELP_OPT( "--serialize-plan, s" )
+      "Serialize and then load the query execution plan.\n\n"
+
+    HELP_OPT( "--serialize-text" )
+      "Serialize the result as text.\n\n"
+
+    HELP_OPT( "--stable-iterator-ids" )
+      "Print the iterator plan with stable IDs.\n\n"
+
+#ifndef ZORBA_NO_FULL_TEXT
+    HELP_OPT( "--stop-words" )
+      "Mapping specifying a stop-words URI to another.\n\n"
+
+    ////////// t //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--thesaurus" )
+      "Mapping specifying a thesaurus URI to another.\n\n"
+#endif /* ZORBA_NO_FULL_TEXT */
+
+    HELP_OPT( "--timing, -t" )
+      "Print timing information. In case of multiple queries, the timing information is provided per query. Both wallclock time and user time (which excludes I/O, network delays and other kernel waits) are shown.\n\n"
+
+    HELP_OPT( "--timeout" )
+      "Specify a timeout in seconds. After the specified time, the execution of the query will be aborted.\n\n"
+
+    HELP_OPT( "--trace-parsing" )
+      "Trace parsing.\n\n"
+
+    HELP_OPT( "--trace-scanning" )
+      "Trace scanning.\n\n"
+
+#ifndef NDEBUG
+    HELP_OPT( "--trace-codegen" )
+      "Trace code generatio.\n\n"
+
+    HELP_OPT( "--trace-fulltext" )
+      "Trace full-text.\n\n"
+
+    HELP_OPT( "--trace-translator" )
+      "Trace the translator.\n\n"
+#endif /* NDEBUG */
+
+    HELP_OPT( "--trailing-nl" )
+      "Print a trailing newline after the result of the query.\n\n"
+
+    ////////// u //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--uri-path" )
+      "URI path (list of directories) added to the built-in URI resolver, i.e. where to find modules/schemas to import.\n\n"
+
+    ////////// v //////////////////////////////////////////////////////////////
+
+    HELP_OPT( "--version, -v" )
+      "Print the version number and exit.\n\n"
+
+    ;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool split_key_value( char const *s, char const *split,
+                             string *key, string *value ) {
+  char const *const p = strstr( s, split );
+  size_t const split_len = strlen( split );
+  if ( !p || p == s /* =xxx */ || !p[ split_len ] /* xxx= */ )
+    return false;
+  key->assign( s, 0, p - s );
+  value->assign( p + split_len );
+  return true;
+}
+
+inline char to_lower( char c ) {
+  return tolower( c );
+}
+
+template<class StringType> inline
+typename enable_if<ZORBA_IS_STRING(StringType),void>::type
+to_lower( StringType &s ) {
+  transform(
+    s.begin(), s.end(), s.begin(), static_cast<char (*)(char)>( to_lower )
+  );
+}
+
+static bool bool_of( char const *s ) {
+  string b( s );
+  to_lower( b );
+  if ( b == "t" || b == "true" || b == "y" || b == "yes" || b == "1" )
+    return true;
+  if ( b == "f" || b == "false" || b == "n" || b == "no" || b == "0" )
+    return false;
+  cerr << '"' << s << "\": invalid boolean value" << endl;
+  exit( 1 );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define IS_LONG_OPT(OPT)  (strcmp( *argv, (OPT) ) == 0)
+#define IS_SHORT_OPT(OPT) (strncmp( *argv, (OPT), 2 ) == 0)
+#define IS_OPT(LOPT,SOPT) (IS_LONG_OPT(LOPT) || IS_SHORT_OPT(SOPT))
+
+#define PARSE_ARG(ARG)                                                    \
+  int offset = 2;                                                         \
+  if ( (*argv)[1] == '-' || !(*argv)[2] ) { offset = 0; ++argv; }         \
+  if ( !*argv ) { error = "No value given for " #ARG " option"; break; }
+
+#define ARG_VAL (*argv + offset)
+
+template<typename T> inline
+void atoi( char const *s,  T *result, int offset = 0 ) {
+  istringstream iss( s + offset );
+  iss >> *result;
+}
+
+#define SET_ZCPROP(PROP) \
+  atoi( *argv, &zc_props.PROP, offset )
+
+template<class C,typename T> inline
+void atoi( char const *s, C &c, void (C::*f)( T ), int offset = 0 ) {
+  T temp;
+  atoi( s, &temp, offset );
+  (c.*f)( temp );
+}
+
+#define SET_ZPROP(PROP) \
+  atoi( *argv, z_props, &Properties::set##PROP, offset )
+
+int parse_args( int argc, char const *argv[] ) {
+  bool got_as_files = false;
+  char const *error = 0;
+  Properties &z_props = Properties::instance();
+  ZorbaCmdProperties &zc_props = ZorbaCmdProperties::instance();
+
+  char const **const argv_orig = argv;
+  for ( ++argv; *argv; ++argv ) {
+
+    ////////// a //////////////////////////////////////////////////////////////
+
+#ifndef NDEBUG
+    if ( IS_LONG_OPT( "--abort" ) )
+      z_props.setAbort( true );
+    else
+#endif /* NDEBUG */
+    if ( IS_OPT( "--as-files", "-f" ) ) {
+      zc_props.as_files_ = true;
+      got_as_files = true;
+    }
+
+    ////////// b //////////////////////////////////////////////////////////////
+
+    else if ( IS_LONG_OPT( "--base-uri" ) ) {
+      PARSE_ARG( "--base-uri" );
+      zc_props.base_uri_ = ARG_VAL;
+    }
+    else if ( IS_LONG_OPT( "--boundary-space" ) ) {
+      PARSE_ARG( "--boundary-space" );
+      zc_props.boundary_space_ = ARG_VAL;
+    }
+    else if ( IS_LONG_OPT( "--byte-order-mark" ) )
+      zc_props.byte_order_mark_ = true;
+
+    ////////// c //////////////////////////////////////////////////////////////
+
+    else if ( IS_LONG_OPT( "--classpath" ) ) {
+      PARSE_ARG( "--classpath" );
+      z_props.setJVMClassPath( ARG_VAL );
+    }
+    else if ( IS_LONG_OPT( "--compile-only" ) )
+      zc_props.compile_only_ = true;
+    else if ( IS_LONG_OPT( "--compile-plan" ) )
+      zc_props.save_plan_ = true;
+    else if ( IS_LONG_OPT( "--construction-mode" ) ) {
+      PARSE_ARG( "--construction-mode" );
+      zc_props.construction_mode_ = ARG_VAL;
+    }
+    else if ( IS_LONG_OPT( "--context-item" ) ) {
+      PARSE_ARG( "--context-item" );
+      zc_props.ctx_item_ = ARG_VAL;
+    }
+
+    ////////// d //////////////////////////////////////////////////////////////
+
+#ifdef ZORBA_WITH_DEBUGGER
+    else if ( IS_OPT( "--debug", "-d" ) )
+      zc_props.debug_ = true;
+#endif /* ZORBA_WITH_DEBUGGER */
+    else if ( IS_LONG_OPT( "--debug-file" ) ) {
+      PARSE_ARG( "--debug-file" );
+      z_props.setDebugFile( ARG_VAL );
+    }
+#ifdef ZORBA_WITH_DEBUGGER
+    else if ( IS_OPT( "--debug-host", "-h" ) ) {
+      PARSE_ARG( "--debug-host" );
+      zc_props.debug_host_ = ARG_VAL;
+    }
+    else if ( IS_OPT( "--debug-port", "-p" ) ) {
+      PARSE_ARG( "--debug-port" );
+      SET_ZCPROP( debug_port_ );
+    }
+#endif /* ZORBA_WITH_DEBUGGER */
+    else if ( IS_LONG_OPT( "--default-collation" ) ) {
+      PARSE_ARG( "--default-collation" );
+      zc_props.default_collation_ = ARG_VAL;
+    }
+    else if ( IS_LONG_OPT( "--disable-http-resolution" ) ) {
+      sctx_opt opt;
+      opt.clark_qname = "{http://zorba.io/options/features}disable";
+      opt.value = "http-uri-resolution";
+      zc_props.sctx_opts_.push_back( opt );
+    }
+    else if ( IS_LONG_OPT( "--dump-lib" ) )
+      z_props.setDumpLib( true );
+
+    ////////// e //////////////////////////////////////////////////////////////
+
+    else if ( IS_LONG_OPT( "--execute-plan" ) )
+      zc_props.load_plan_ = true;
+    else if ( IS_OPT( "--external-variable", "-e" ) ) {
+      PARSE_ARG( "--external-variable" );
+      string key, value;
+      if ( !split_key_value( ARG_VAL, "=", &key, &value ) ) {
+        error = "--external-variable argument must be of the form name=file or name:=value\n";
+        break;
+      }
+      external_var ev;
+      ev.var_value = value;
+
+      if ( key[0] == ':' ) {
+        error = "--external-variable argument must be of the form name=file or name:=value\n";
+        break;
+      }
+      if ( key[ key.size() - 1 ] == ':' )
+        key.erase( key.size() - 1 );
+      else
+        ev.inline_file = true;
+      ev.var_name = key;
+
+      zc_props.external_vars_.push_back( ev );
+    }
+
+    ////////// f //////////////////////////////////////////////////////////////
+
+    else if ( IS_LONG_OPT( "--force-gflwor" ) )
+      z_props.setForceGFLWOR( true );
+
+    ////////// h //////////////////////////////////////////////////////////////
+
+    else if ( IS_OPT( "--help", "-h" ) ) {
+      cout << "Zorba NoSQL Query Processor, Version: "
+           << Zorba::version() << '\n'
+           << "Available options:\n\n"
+           << get_help_msg();
+      exit( 0 );
+    }
+
+    ////////// i //////////////////////////////////////////////////////////////
+
+    else if ( IS_OPT( "--indent", "-i" ) )
+      zc_props.indent_ = true;
+    else if ( IS_LONG_OPT( "--infer-joins" ) ) {
+      PARSE_ARG( "--infer-joins" );
+      z_props.setInferJoins( bool_of( ARG_VAL ) );
+    }
+    else if ( IS_LONG_OPT( "--inline-udf" ) ) {
+      PARSE_ARG( "--inline-udf" );
+      z_props.setInlineUDF( bool_of( ARG_VAL ) );
+    }
+
+    ////////// j //////////////////////////////////////////////////////////////
+
+    else if ( IS_OPT( "--jsoniq", "-j" ) )
+      zc_props.jsoniq_ = true;
+
+    ////////// l //////////////////////////////////////////////////////////////
+
+    else if ( IS_OPT( "--lib-module", "-l" ) )
+      zc_props.lib_module_ = true;
+    else if ( IS_LONG_OPT( "--lib-path" ) ) {
+      PARSE_ARG( "--lib-path" );
+      zc_props.lib_path_ = ARG_VAL;
+    }
+    else if ( IS_LONG_OPT( "--loop-hoisting" ) ) {
+      PARSE_ARG( "--loop-hoisting" );
+      z_props.setLoopHoisting( bool_of( ARG_VAL ) );
+    }
+
+    ////////// m //////////////////////////////////////////////////////////////
+
+    else if ( IS_LONG_OPT( "--max-udf-call-depth" ) ) {
+      PARSE_ARG( "--max-udf-call-depth" );
+      SET_ZPROP( MaxUDFCallDepth );
+    }
+    else if ( IS_LONG_OPT( "--module-path" ) ) {
+      PARSE_ARG( "--module-path" );
+      zc_props.module_path_ = ARG_VAL;
+    }
+    else if ( IS_OPT( "--multiple", "-m" ) ) {
+      PARSE_ARG( "--multiple" );
+      SET_ZCPROP( multiple_ );
+    }
+
+    ////////// n //////////////////////////////////////////////////////////////
+
+    else if ( IS_LONG_OPT( "--no-copy-optim" ) ) {
+      PARSE_ARG( "--no-copy-optim" );
+      z_props.setNoCopyOptim( bool_of( ARG_VAL ) );
+    }
+    else if ( IS_LONG_OPT( "--no-logo" ) )
+      zc_props.no_logo_ = true;
+    else if ( IS_LONG_OPT( "--no-serializer" ) )
+      zc_props.no_serializer_ = true;
+    else if ( IS_LONG_OPT( "--no-tree-ids" ) )
+      z_props.setNoTreeIDs( true );
+
+    ////////// o //////////////////////////////////////////////////////////////
+
+    else if ( IS_OPT( "--omit-xml-declaration", "-r" ) )
+      zc_props.omit_xml_declaration_ = true;
+    else if ( IS_OPT( "--optimization-level", "-O" ) ) {
+      PARSE_ARG( "--optimization-level" );
+      unsigned opt_level;
+      atoi( ARG_VAL, &opt_level );
+      if ( opt_level > 2 ) {
+        error = "Only 0, 1 and 2 are allowed as values for --optimization-level";
+        break;
+      }
+      z_props.setOptimizationLevel( opt_level );
+    }
+    else if ( IS_LONG_OPT( "--option" ) ) {
+      PARSE_ARG( "--option" );
+      string key, value;
+      if ( !split_key_value( ARG_VAL, "=", &key, &value ) ) {
+        error = "--option argument must be of the form {namespace}localname=value\n";
+        break;
+      }
+      // TODO: check key is of the form {ns}local
+      sctx_opt opt;
+      opt.clark_qname = key;
+      opt.value = value;
+      zc_props.sctx_opts_.push_back( opt );
+    }
+    else if ( IS_LONG_OPT( "--ordering-mode" ) ) {
+      PARSE_ARG( "--ordering-mode" );
+      zc_props.ordering_mode_ = ARG_VAL;
+    }
+#ifdef ZORBA_WITH_FILE_ACCESS
+    else if ( IS_OPT( "--output-file", "-o" ) ) {
+      PARSE_ARG( "--output-file" );
+      zc_props.output_file_ = ARG_VAL;
+    }
+#endif /* ZORBA_WITH_FILE_ACCESS */
+
+    ////////// p //////////////////////////////////////////////////////////////
+
+    else if ( IS_LONG_OPT( "--parse-only" ) )
+      zc_props.parse_only_ = true;
+    else if ( IS_OPT( "--print-ast", "-a" ) )
+      z_props.setPrintAST( true );
+    else if ( IS_OPT( "--print-errors-as-xml", "-x" ) )
+      zc_props.print_errors_as_xml_ = true;
+    else if ( IS_LONG_OPT( "--print-intermediate-opt" ) )
+      z_props.setPrintIntermediateOpt( true );
+    else if ( IS_LONG_OPT( "--print-item-flow" ) )
+      z_props.setPrintItemFlow( true );
+    else if ( IS_LONG_OPT( "--print-iterator-tree" ) )
+      z_props.setPrintIteratorTree( true );
+    else if ( IS_LONG_OPT( "--print-locations" ) )
+      z_props.setPrintLocations( true );
+    else if ( IS_OPT( "--print-optimized", "-P" ) )
+      z_props.setPrintOptimized( true );
+    else if ( IS_LONG_OPT( "--print-query" ) )
+      zc_props.print_query_ = true;
+    else if ( IS_LONG_OPT( "--print-static-types" ) )
+      z_props.setPrintStaticTypes( true );
+    else if ( IS_LONG_OPT( "--print-translated" ) )
+      z_props.setPrintTranslated( true );
+
+    ////////// q //////////////////////////////////////////////////////////////
+
+    else if ( IS_OPT( "--query", "-q" ) ) {
+      if ( !got_as_files )
+        zc_props.as_files_ = false;
+      if ( *(argv+1) && !strncmp( *(argv+1), "-f", 2 ) )
+        break; // is it "-q -f <filename>" perhaps?
+      PARSE_ARG( "--query" );
+      zc_props.queries_or_files_.push_back( ARG_VAL );
+    }
+
+    ////////// s //////////////////////////////////////////////////////////////
+
+    else if ( IS_OPT( "--serialization-parameter", "-z" ) ) {
+      PARSE_ARG( "--serialization-parameter" );
+      string key, value;
+      serialization_param sp;
+      if ( split_key_value( ARG_VAL, "=", &key, &value ) ) {
+        sp.first = key;
+        sp.second = value;
+      } else
+        sp.first = ARG_VAL;
+      zc_props.serialization_params_.push_back( sp );
+    }
+    else if ( IS_LONG_OPT( "--serialize-html" ) )
+      zc_props.serialize_html_ = true;
+    else if ( IS_LONG_OPT( "--serialize-only-query" ) ) {
+      PARSE_ARG( "--serialize-only-query" );
+      zc_props.serialize_only_query_ = bool_of( ARG_VAL );
+    }
+    else if ( IS_OPT( "--serialize-plan", "-s" ) )
+      zc_props.serialize_plan_ = true;
+    else if ( IS_LONG_OPT( "--serialize-text" ) )
+      zc_props.serialize_text_ = true;
+    else if ( IS_LONG_OPT( "--stable-iterator-ids" ) )
+      z_props.setStableIteratorIDs( true );
+#ifndef ZORBA_NO_FULL_TEXT
+    else if ( IS_LONG_OPT( "--stop-words" ) ) {
+      PARSE_ARG( "--stop-words" );
+      string uri, value;
+      if ( !split_key_value( ARG_VAL, ":=", &uri, &value ) ) {
+        error = "--stop-words argument must be of the form URI:=value\n";
+        break;
+      }
+      ft_mapping ft;
+      ft.uri = uri;
+      ft.value = value;
+      zc_props.stop_words_mapping_.push_back( ft );
+    }
+
+    ////////// t //////////////////////////////////////////////////////////////
+
+    else if ( IS_LONG_OPT( "--thesaurus" ) ) {
+      PARSE_ARG( "--thesaurus" );
+      string uri, value;
+      if ( !split_key_value( ARG_VAL, ":=", &uri, &value ) ) {
+        error = "--thesaurus argument must be of the form URI:=value\n";
+        break;
+      }
+      if ( uri == "default" )
+        uri = "##default";
+      ft_mapping ft;
+      ft.uri = uri;
+      ft.value = value;
+      zc_props.thesaurus_mapping_.push_back( ft );
+    }
+#endif /* ZORBA_NO_FULL_TEXT */
+    else if ( IS_OPT( "--timing", "-t" ) )
+      zc_props.timing_ = true;
+    else if ( IS_LONG_OPT( "--timeout" ) ) {
+      PARSE_ARG( "--timeout" );
+      SET_ZCPROP( timeout_ );
+    }
+    else if ( IS_LONG_OPT( "--trace-parsing" ) )
+      z_props.setTraceParsing( true );
+    else if ( IS_LONG_OPT( "--trace-scanning" ) )
+      z_props.setTraceScanning( true );
+#ifndef NDEBUG
+    else if ( IS_LONG_OPT( "--trace-codegen" ) )
+      z_props.setTraceCodegen( true );
+    else if ( IS_LONG_OPT( "--trace-fulltext" ) )
+      z_props.setTraceFulltext( true );
+    else if ( IS_LONG_OPT( "--trace-translator" ) )
+      z_props.setTraceTranslator( true );
+#endif /* NDEBUG */
+    else if ( IS_LONG_OPT( "--trailing-nl" ) )
+      zc_props.trailing_nl_ = true;
+
+    ////////// u //////////////////////////////////////////////////////////////
+
+    else if ( IS_LONG_OPT( "--uri-path" ) ) {
+      PARSE_ARG( "--uri-path" );
+      zc_props.uri_path_ = ARG_VAL;
+    }
+    else if ( IS_LONG_OPT( "--use-indexes" ) ) {
+      PARSE_ARG( "--use-indexes" );
+      z_props.setUseIndexes( true );
+    }
+
+    ////////// v //////////////////////////////////////////////////////////////
+
+    else if ( IS_OPT( "--version", "-v" ) ) {
+      cout << "Zorba NoSQL Query Processor, Version: "
+           << zorba::Zorba::version() << endl;
+      exit( 1 ); // should be 0, but the old code returned 1
+    }
+
+    ////////// END ////////////////////////////////////////////////////////////
+
+    else if ( IS_LONG_OPT( "--" ) )
+      break;
+    else if ( (*argv)[0] == '-' ) {
+      cerr << "unknown command line option " << *argv << endl;
+      exit( 1 );
+    } else {
+      zc_props.queries_or_files_.push_back( *argv );
+    }
+  } // for
+
+  if ( !error )
+    error = check_args();
+  if ( error ) {
+    cout << "Error: " << error << "\nUse -h for help." << endl;
+    exit( 1 );
+  }
+  return argv - argv_orig;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/* vim:set et sw=2 ts=2: */
 
=== renamed file 'bin/zorbacmdproperties.cpp' => 'bin/zorbacmd_props.cpp'
--- bin/zorbacmdproperties.cpp	2013-06-16 00:37:21 +0000
+++ bin/zorbacmd_props.cpp	2014-02-11 00:42:47 +0000
@@ -13,202 +13,48 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "zorbacmdproperties.h"
-
-#include <fstream>
-#include <iostream>
-#include <cstdlib>
-
-#include <zorba/zorba.h>
-
-std::string ZorbaCMDProperties::check_args () {
-
-  if(queriesOrFilesBegin() == queriesOrFilesEnd())
-  {
-    return "No queries submitted \nUsage: zorba -q '1 + 1' execute an inline query \n zorba file.xq execute a query from a file \n Use -h for help.";
-  }
-
-  if(unknownOption())
-  {
-    return "Extra arguments found on command line. Use -h for help.";
-  }
-
-  if(queriesOrFilesBegin() == queriesOrFilesEnd())
-  {
-    return "No queries submitted \nUsage: zorba -q '1 + 1' execute an inline query \n zorba file.xq execute a query from a file \n Use -h for help.";
-  }
-
-  if ( theBoundarySpace.size() != 0 )
-  {
-    if ( ! (theBoundarySpace.compare("strip") == 0 || theBoundarySpace.compare("preserve") == 0 ))
-      return "Only strip and preserve are allowed as values for the option boundary-space";
-  }
-
-  if ( theConstructionMode.size() != 0 )
-  {
-    if ( ! (theConstructionMode.compare("strip") == 0 || theConstructionMode.compare("preserve") == 0 ))
-      return "Only strip and preserve are allowed as values for the option construction-mode";
-  }
-
-  if ( theOrderingMode.size() != 0 ) {
-    if ( ! (theOrderingMode.compare("ordered") == 0 || theOrderingMode.compare("unordered") == 0 ))
-      return "Only ordered and unordered are allowed as values for the option ordering-mode";
-  }
-
-  if ( ! (theOptimizationLevel.compare("O0") == 0 || theOptimizationLevel.compare("O1") == 0
-    || theOptimizationLevel.compare("O2") == 0 ) )
-    return "only O0, O1 and O2 are allowed as values for the option opt-level";
-
-  for (std::vector<std::string>::const_iterator lIter = theExternalVariable.begin();
-       lIter != theExternalVariable.end(); ++lIter) 
-  {
-    std::string lStr = *lIter;
-    std::string::size_type lPos = lStr.find_first_of("=");
-    std::string lVarName = lStr.substr(0, lPos);
-    std::string lValue = lStr.substr(lPos + 1);
-    bool lInlineFile = true;
-    if (lVarName.at(lVarName.size()-1) == ':')
-    {
-      lInlineFile = false;
-      lVarName.resize(lVarName.size()-1); // remove the :
-    }
-    ExternalVariable lExternalVariable;
-    lExternalVariable.var_name = lVarName;
-    lExternalVariable.var_value = lValue;
-    lExternalVariable.inline_file = lInlineFile;
-    theExternalVars.push_back(lExternalVariable);
-  }
-
-  for (std::vector<std::string>::const_iterator lIter = theOption.begin();
-       lIter != theOption.end(); ++lIter)
-  {
-    size_t lEQual = lIter->find_last_of("=");
-    if (lEQual == std::string::npos)
-      return "option must be of the form {namespace}localname=value";
-
-    std::string lClarkQName = lIter->substr(0, lEQual);
-    std::string lValue      = lIter->substr(lEQual + 1);
-
-    StaticContextOption lOption;
-    lOption.clark_qname = lClarkQName;
-    lOption.value = lValue;
-    theStaticContextOptions.push_back(lOption);
-  }
-
-  for (std::vector<std::string>::const_iterator lIter = theStopWords.begin();
-       lIter != theStopWords.end(); ++lIter)
-  {
-    size_t lEQual = lIter->find(":=");
-    if (lEQual == std::string::npos)
-      return "Stop-words mapping must be of the form URI:=value";
-
-    std::string lURI   = lIter->substr(0, lEQual);
-    std::string lValue = lIter->substr(lEQual + 2);
-
-    FullTextMapping lMapping;
-    lMapping.uri   = lURI;
-    lMapping.value = lValue;
-    theStopWordsMapping.push_back(lMapping);
-  }
-
-  for (std::vector<std::string>::const_iterator lIter = theThesaurus.begin();
-       lIter != theThesaurus.end(); ++lIter)
-  {
-    size_t lEQual = lIter->find(":=");
-    if (lEQual == std::string::npos)
-      return "Thesaurus mapping must be of the form URI:=value";
-
-    std::string lURI   = lIter->substr(0, lEQual);
-    std::string lValue = lIter->substr(lEQual + 2);
-
-    if ( lURI == "default" )
-      lURI = "##default";
-
-    FullTextMapping lMapping;
-    lMapping.uri   = lURI;
-    lMapping.value = lValue;
-    theThesaurusMapping.push_back(lMapping);
-  }
-       
-  return "";
-}
-
-
-bool ZorbaCMDProperties::loadProperties(int argc, char* argv[]) 
-{
-  std::string result = load_argv(argc, (const char **) argv);
-
-  if (result.empty())
-    result = check_args();
-
-  if (result == "!HELP") 
-  {
-    std::cout << "Zorba NoSQL Query Processor, Version: " 
-              << zorba::Zorba::version() << std::endl;
-    std::cout << "Available options:\n\n";
-    std::cout << get_help_msg ();
-    return false;
-  }
-  else if (result == "!VER") 
-  {
-    std::cout << "Zorba NoSQL Query Processor, Version: " 
-              << zorba::Zorba::version() << std::endl;
-    return false;
-  }
-  else if (result.empty ())
-  {
-    return true;
-  }
-  else if (result [0] != '!')
-  {
-    std::cout << "Error: " << result << std::endl;
-    return false;
-  }
-  else
-  {
-    return false;
-  }  
-}
-
-
-void ZorbaCMDProperties::getModulePath(std::string& aPath) const
-{
-  aPath = theModulePath;
-}
-
-void ZorbaCMDProperties::getURIPath(std::string& aPath) const
-{
-  aPath = theUriPath;
-}
-
-void ZorbaCMDProperties::getLibPath(std::string& aPath) const
-{
-  aPath = theLibPath;
-}
-
-void ZorbaCMDProperties::getJVMClassPath(std::string& aPath) const
-{
-  aPath = theClasspath;
-}
-
-std::vector<std::pair<std::string,std::string> > ZorbaCMDProperties::getSerializerParameters() const
-{
-  std::vector<std::pair<std::string,std::string> > lResult;
-  std::vector<std::string>::const_iterator lEnd = theSerializationParameter.end();
-  for (
-       std::vector<std::string>::const_iterator lIter = theSerializationParameter.begin();
-       lIter != lEnd;
-       ++lIter
-      ) 
-  {
-    std::string lStr = *lIter;
-    std::string::size_type lPos = lStr.find_first_of("=");
-    std::string lVarName = lStr.substr(0, lPos);
-    std::string lValue;
-    if (lPos != std::string::npos)
-        lValue = lStr.substr(lPos + 1);
-
-    lResult.push_back(std::pair<std::string,std::string>(lVarName, lValue));
-  }
-  return lResult;
-}
+
+// local
+#include "zorbacmd_props.h"
+
+///////////////////////////////////////////////////////////////////////////////
+
+ZorbaCmdProperties::ZorbaCmdProperties() {
+  as_files_ = true;
+  byte_order_mark_ = false;
+  compile_only_ = false;
+#ifdef ZORBA_WITH_DEBUGGER
+  debug_ = false;
+  debug_host_ = "127.0.0.1";
+  debug_port_ = 28028;
+#endif /* ZORBA_WITH_DEBUGGER */
+  indent_ = false;
+  jsoniq_ = false;
+  lib_module_ = false;
+  load_plan_ = false;
+  multiple_ = 1;
+  no_logo_ = false;
+  no_serializer_ = false;
+  omit_xml_declaration_ = false;
+  optimization_level_ = 1;
+  parse_only_ = false;
+  print_errors_as_xml_ = false;
+  print_query_ = false;
+  save_plan_ = false;
+  serialize_html_ = false;
+  serialize_only_query_ = false;
+  serialize_plan_ = false;
+  serialize_text_ = false;
+  timeout_ = -1;
+  timing_ = false;
+  trailing_nl_ = false;
+}
+
+ZorbaCmdProperties& ZorbaCmdProperties::instance() {
+  static ZorbaCmdProperties instance;
+  return instance;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/* vim:set et sw=2 ts=2: */
 
=== renamed file 'bin/zorbacmdproperties.h' => 'bin/zorbacmd_props.h'
--- bin/zorbacmdproperties.h	2014-01-31 23:27:47 +0000
+++ bin/zorbacmd_props.h	2014-02-11 00:42:47 +0000
@@ -1,10 +1,10 @@
 /*
- * Copyright 2006-2008 The FLWOR Foundation.
+ * Copyright 2006-2014 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
@@ -13,114 +13,108 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #ifndef ZORBA_CMD_PROPERTIES_H
 #define ZORBA_CMD_PROPERTIES_H
 
+// standard
+#include <string>
+#include <vector>
+#include <utility>                      /* for pair */
+
+// Zorba
 #include <zorba/config.h>
-#include <zorba/item.h>
-
-#include "zorbacmdproperties_base.h"
-
-class ZorbaCMDProperties : public zorbacmd::ZorbaCMDPropertiesBase 
-{
-public:
-  struct ExternalVariable
-  {
-    std::string var_name;
-    std::string var_value;
-    bool        inline_file;
-  };
-
-  typedef std::vector<ExternalVariable> ExternalVars_t;
-
-
-  struct StaticContextOption
-  {
-    std::string clark_qname;
-    std::string value;
-  };
-
-  typedef std::vector<StaticContextOption> Options_t;
-
-  struct FullTextMapping
-  {
-    std::string uri;
-    std::string value;
-  };
-
-  typedef std::vector<FullTextMapping> FullText_t;
-
-  typedef std::vector<std::string>      QueriesOrFiles_t;
-
-protected:
-  ExternalVars_t theExternalVars;
-  Options_t      theStaticContextOptions;
-  FullText_t     theStopWordsMapping;
-  FullText_t     theThesaurusMapping;
-
-public:
-  ExternalVars_t::const_iterator
-  externalVarsBegin() const  { return theExternalVars.begin(); }
-
-  ExternalVars_t::const_iterator
-  externalVarsEnd() const    { return theExternalVars.end(); }
-
-  Options_t::const_iterator
-  optionsBegin() const  { return theStaticContextOptions.begin(); }
-
-  Options_t::const_iterator
-  optionsEnd() const    { return theStaticContextOptions.end(); }
-
-  FullText_t::const_iterator
-  stopWordsBegin() const  { return theStopWordsMapping.begin(); }
-
-  FullText_t::const_iterator
-  stopWordsEnd() const    { return theStopWordsMapping.end(); }
-
-  FullText_t::const_iterator
-  thesaurusBegin() const  { return theThesaurusMapping.begin(); }
-
-  FullText_t::const_iterator
-  thesaurusEnd() const    { return theThesaurusMapping.end(); }
-
-  QueriesOrFiles_t::const_iterator
-  queriesOrFilesBegin() const { return theQueriesOrFiles.begin(); }
-
-  QueriesOrFiles_t::const_iterator
-  queriesOrFilesEnd() const   { return theQueriesOrFiles.end(); }
-  
-  std::vector<std::pair<std::string,std::string> > 
-  getSerializerParameters() const;
-
-  void
-  getModulePath(std::string&) const;
-  
-  void
-  getURIPath(std::string&) const;
-
-  void
-  getLibPath(std::string&) const;
-
-  void
-  getJVMClassPath(std::string&) const;
-
-  bool isDebug(){ return theDebug; }
-
-  bool hasNoLogo(){ return theNoLogo; }
-
-  std::string getDebugHost(){ return theDebugHost; }
-
-  unsigned int getDebugPort(){ return theDebugPort; }
-
-  std::string check_args ();
-
-  void printHelp(std::ostream& os) const {
-    os << "Zorba NoSQL Query Processor\n";
-    os << "Available options:\n";
-    os << get_help_msg ();
-  }
-
-  bool loadProperties(int argc, char* argv[]);
-};
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct external_var {
+  std::string var_name;
+  std::string var_value;
+  bool        inline_file;
+
+  external_var() : inline_file( false ) { }
+};
+
+typedef std::vector<external_var> external_vars;
+
+typedef std::pair<std::string,std::string> serialization_param;
+typedef std::vector<serialization_param> serialization_params;
+
+struct sctx_opt {
+  std::string clark_qname;
+  std::string value;
+};
+
+typedef std::vector<sctx_opt> sctx_opts;
+
+#ifndef ZORBA_NO_FULL_TEXT
+struct ft_mapping {
+  std::string uri;
+  std::string value;
+};
+
+typedef std::vector<ft_mapping> ft_mappings;
+#endif /* ZORBA_NO_FULL_TEXT */
+
+struct ZorbaCmdProperties {
+  static ZorbaCmdProperties& instance();
+
+  bool          as_files_;
+  std::string   base_uri_;
+  std::string   boundary_space_;
+  bool          byte_order_mark_;
+  std::string   classpath_;
+  bool          compile_only_;
+  std::string   construction_mode_;
+  std::string   ctx_item_;
+#ifdef ZORBA_WITH_DEBUGGER
+  bool          debug_;
+  std::string   debug_host_;
+  unsigned      debug_port_;
+#endif /* ZORBA_WITH_DEBUGGER */
+  std::string   default_collation_;
+  external_vars external_vars_;
+  bool          indent_;
+  bool          jsoniq_;
+  bool          lib_module_;
+  std::string   lib_path_;
+  bool          load_plan_;
+  std::string   module_path_;
+  unsigned long multiple_;
+  bool          no_logo_;
+  bool          no_serializer_;
+  bool          omit_xml_declaration_;
+  unsigned      optimization_level_;
+  std::string   ordering_mode_;
+#ifdef ZORBA_WITH_FILE_ACCESS
+  std::string   output_file_;
+#endif /* ZORBA_WITH_FILE_ACCESS */
+  bool          parse_only_;
+  bool          print_errors_as_xml_;
+  bool          print_query_;
+  bool          save_plan_;
+  sctx_opts     sctx_opts_;
+  bool          serialize_html_;
+  bool          serialize_only_query_;
+  bool          serialize_plan_;
+  bool          serialize_text_;
+#ifndef ZORBA_NO_FULL_TEXT
+  ft_mappings   stop_words_mapping_;
+  ft_mappings   thesaurus_mapping_;
+#endif /* ZORBA_NO_FULL_TEXT */
+  long          timeout_;               // unused
+  bool          timing_;
+  bool          trailing_nl_;
+  std::string   uri_path_;
+
+  serialization_params      serialization_params_;
+  std::vector<std::string>  queries_or_files_;
+
+private:
+  ZorbaCmdProperties();
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
 #endif /* ZORBA_CMD_PROPERTIES_H */
 /* vim:set et sw=2 ts=2: */
 
=== removed file 'bin/zorbacmdproperties.txt'
--- bin/zorbacmdproperties.txt	2014-01-31 23:27:47 +0000
+++ bin/zorbacmdproperties.txt	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-("as-files,f", "Treat all -q arguments as file paths instead of URIs or inline queries.")
-("base-uri", po::value<std::string>(), "Set the base URI property of the static context.")
-("boundary-space", po::value<std::string>(), "Set the boundary-space policy ('strip' or 'preserve') in the static context.")
-("byte-order-mark", "Set the byte-order-mark for the serializer.")
-("classpath", po::value<std::string>(), "JVM classpath to be used by modules using Java implementations")
-("compile-only", "Only compile (don't execute)")
-("compile-plan,c", "Output the query plan as binary.")
-("construction-mode", po::value<std::string>(), "Set the construction mode ('strip' or 'preserve') in the static context.")
-("context-item", po::value<std::string> (), "Set the context item to the XML document in a given file.")
-("debug,d", "Launch the Zorba debugger server and connect to a DBGP-enabled debugger client.")
-("debug-host,h", po::value<std::string>()->default_value("127.0.0.1"), "The host where the DBGP-enabled debugger client listens for connections. Defaults to: 127.0.0.1")
-("debug-port,p", po::value<unsigned int>()->default_value (28028), "The port on which the DBGP-enabled debugger client listens for connections. Defaults to: 28028")
-("default-collation", po::value<std::string>(), "Add the given collation and set the value of the default collation in the static context to the given collation.")
-("execute-plan", "Take a query plan as binary and execute it. Binary query plans can be generated using the --compile-plan option.")
-("external-variable,e", po::value<std::vector<std::string> >(), "Provide the value for a variable given a file (name=file) or a value (name:=value)")
-("indent,i", "Indent output.")
-("lib-module,l", "Query compiler option to treat the query as a library module. If this is set --compile-only option is also set to true.")
-("lib-path", po::value<std::string>(), "Library path (list of directories) where Zorba will look for dynamic libraries (e.g., module external function implementations.")
-("module-path", po::value<std::string>(), "Path (list of directories) to add to both the URI and Library paths.")
-("multiple,m", po::value<unsigned long>()->default_value (1), "Execute the given queries multiple times.")
-("no-logo", "Print no logo when starting.")
-("no-serializer", "Do not serialize (discard) result.")
-("omit-xml-declaration,r", "Omit the XML declaration from the result.")
-("optimization-level", po::value<std::string>()->default_value("O1"), "Optimization level for the query compiler (O0, O1 or O2 - default: O1)")
-("option", po::value<std::vector<std::string> >(), "Set an XQuery option in the static context. The QName of the option is passed as a string in the notation by James Clark (i.e. {namespace}localname). For example, --option {http://zorba.io/}option=value").
-("ordering-mode", po::value<std::string>(), "Set the ordering mode ('ordered' or 'unordered') in the static context.")
-("output-file,o", po::value<std::string>(), "Write the result to the given file.")
-("parse-only", "Stop after parsing the query.")
-("print-errors-as-xml,x", "Print the errors as XML.")
-("print-query", "Print the queries.")
-("query,q", po::value<std::vector<std::string> >(&theQueriesOrFiles), "Query test or file URI (file://...)")
-("serialization-parameter,z", po::value<std::vector<std::string> >(), "Set serialization parameter in the form of a parameter=value pair (see http://www.w3.org/TR/xslt-xquery-serialization/#serparam, e.g.: -z method=xhtml -z doctype-system=DTD/xhtml1-strict.dtd -z indent=yes).")
-("serialize-html", "Serialize the result as HTML.")
-("serialize-text", "Serialize the result as Text.")
-("stop-words", po::value<std::vector<std::string> >(), "Mapping specifying a stop-words URI to another.")
-("thesaurus", po::value<std::vector<std::string> >(), "Mapping specifying a thesaurus URI to another.")
-("timeout", po::value<long>()->default_value(-1), "Specify a timeout in seconds. After the specified time, the execution of the query will be aborted.")
-("timing,t", "Print timing information. In case of multiple queries the timing information is provided per each query. Both wallclock time and user time (which excludes I/O, network delays and other kernel waits) are shown.")
-("trailing-nl", "Output a trailing newline after the result of the query.")
-("uri-path", po::value<std::string>(), "URI path (list of directories) added to the built-in URI resolver, i.e. where to find modules/schemas to import.")
 
=== removed file 'bin/zorbacmdproperties_base.cpp'
--- bin/zorbacmdproperties_base.cpp	2014-01-31 23:33:01 +0000
+++ bin/zorbacmdproperties_base.cpp	1970-01-01 00:00:00 +0000
@@ -1,374 +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 "zorbacmdproperties_base.h"
-
-namespace zorbacmd {
-
-///////////////////////////////////////////////////////////////////////////////
-
-ZorbaCMDPropertiesBase::ZorbaCMDPropertiesBase() {
-  theAsFiles = true;
-  theByteOrderMark = false;
-  theCompileOnly = false;
-  theDebug = false;
-  theDebugHost = "127.0.0.1";
-  theDebugPort = 28028;
-  theFparm = false;
-  theIndent = false;
-  theLibModule = false;
-  theLoadPlan = false;
-  theMultiple = 1;
-  theNoLogo = false;
-  theNoSerializer = false;
-  theOmitXmlDeclaration = false;
-  theOptimizationLevel = "O1";
-  theParseOnly = false;
-  thePrintErrorsAsXml = false;
-  thePrintQuery = false;
-  theQBeforeF = false;
-  theSavePlan = false;
-  theSerializeHtml = false;
-  theSerializePlan = false;
-  theSerializeText = false;
-  theTimeout = -1;
-  theTiming = false;
-  theTrailingNl = false;
-  theUnknownOption = false;
-}
-
-char const** ZorbaCMDPropertiesBase::get_all_options() const {
-  static const char* result [] = {
-    "--as-files",
-    "--base-uri",
-    "--boundary-space",
-    "--byte-order-mark",
-    "--classpath",
-    "--compile-only",
-    "--compile-plan",
-    "--construction-mode",
-    "--context-item",
-    "--debug",
-    "--debug-host",
-    "--debug-port",
-    "--default-collation",
-    "--disable-http-resolution",
-    "--execute-plan",
-    "--external-variable",
-    "--indent",
-    "--lib-module",
-    "--lib-path",
-    "--module-path",
-    "--multiple",
-    "--no-logo",
-    "--no-serializer",
-    "--omit-xml-declaration",
-    "--optimization-level",
-    "--option",
-    "--ordering-mode",
-#ifdef ZORBA_WITH_FILE_ACCESS
-    "--output-file",
-#endif /* ZORBA_WITH_FILE_ACCESS */
-    "--parse-only",
-    "--print-errors-as-xml",
-    "--print-query",
-    "--query",
-    "--serialization-parameter",
-    "--serialize-html",
-    "--serialize-plan",
-    "--serialize-text",
-    "--stop-words",
-    "--thesaurus",
-    "--timeout",
-    "--timing",
-    "--trailing-nl",
-    "--uri-path",
-    NULL
-  };
-  return result;
-}
-
-#define IS_LONG_OPT(OPT)  (strcmp( *argv, (OPT) ) == 0)
-#define IS_SHORT_OPT(OPT) (strncmp( *argv, (OPT), 2 ) == 0)
-#define IS_OPT(LOPT,SOPT) (IS_LONG_OPT(LOPT) || IS_SHORT_OPT(SOPT))
-
-std::string ZorbaCMDPropertiesBase::load_argv(int argc, const char **argv) {
-  if ( !argv )
-    return "";
-
-  std::string result;
-  for ( ++argv; *argv; ++argv ) {
-    if ( IS_OPT( "--help", "-h" ) )
-      return "!HELP";
-    if ( IS_OPT( "--version", "-v" ) )
-      return "!VER";
-
-    if ( IS_OPT( "--as-files", "-f" ) ) {
-      theFparm = true;
-      theAsFiles = true;
-    }
-    else if ( IS_LONG_OPT( "--base-uri" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --base-uri option"; break; }
-      init_val(*argv, theBaseUri, d);
-    }
-    else if ( IS_LONG_OPT( "--boundary-space" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --boundary-space option"; break; }
-      init_val(*argv, theBoundarySpace, d);
-    }
-    else if ( IS_LONG_OPT( "--byte-order-mark" ) ) 
-      theByteOrderMark = true;
-    else if ( IS_LONG_OPT( "--classpath" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --classpath option"; break; }
-      init_val(*argv, theClasspath, d);
-    }
-    else if ( IS_LONG_OPT( "--compile-only" ) ) 
-      theCompileOnly = true;
-    else if ( IS_LONG_OPT( "--compile-plan" ) )
-      theSavePlan = true;
-    else if ( IS_LONG_OPT( "--construction-mode" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --construction-mode option"; break; }
-      init_val(*argv, theConstructionMode, d);
-    }
-    else if ( IS_LONG_OPT( "--context-item" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --context-item option"; break; }
-      init_val(*argv, theContextItem, d);
-    }
-    else if ( IS_OPT( "--debug", "-d" ) ) 
-      theDebug = true;
-    else if ( IS_OPT( "--debug-host", "-h" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --debug-host option"; break; }
-      init_val(*argv, theDebugHost, d);
-    }
-    else if ( IS_OPT( "--debug-port", "-p" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --debug-port option"; break; }
-      init_val(*argv, theDebugPort, d);
-    }
-    else if ( IS_LONG_OPT( "--default-collation" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --default-collation option"; break; }
-      init_val(*argv, theDefaultCollation, d);
-    }
-    else if ( IS_LONG_OPT( "--execute-plan" ) )
-      theLoadPlan = true;
-    else if ( IS_OPT( "--external-variable", "-e" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --external-variable option"; break; }
-      init_val(*argv, theExternalVariable, d);
-    }
-    else if ( IS_OPT( "--indent", "-i" ) ) 
-      theIndent = true;
-    else if ( IS_OPT( "--lib-module", "-l" ) )
-      theLibModule = true;
-    else if ( IS_LONG_OPT( "--lib-path" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --lib-path option"; break; }
-      init_val(*argv, theLibPath, d);
-    }
-    else if ( IS_LONG_OPT( "--module-path" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --module-path option"; break; }
-      init_val(*argv, theModulePath, d);
-    }
-    else if ( IS_LONG_OPT( "--no-logo" ) ) 
-      theNoLogo = true;
-    else if ( IS_LONG_OPT( "--no-serializer" ) ) 
-      theNoSerializer = true;
-    else if ( IS_OPT( "--multiple", "-m" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --multiple option"; break; }
-      init_val(*argv, theMultiple, d);
-    }
-    else if ( IS_OPT( "--omit-xml-declaration", "-r" ) ) 
-      theOmitXmlDeclaration = true;
-    else if ( IS_LONG_OPT( "--optimization-level" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --optimization-level option"; break; }
-      init_val(*argv, theOptimizationLevel, d);
-    }
-    else if ( IS_LONG_OPT( "--option" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --option option"; break; }
-      init_val(*argv, theOption, d);
-    }
-    else if ( IS_LONG_OPT( "--ordering-mode" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --ordering-mode option"; break; }
-      init_val(*argv, theOrderingMode, d);
-    }
-#ifdef ZORBA_WITH_FILE_ACCESS
-    else if ( IS_OPT( "--output-file", "-o" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --output-file option"; break; }
-      init_val(*argv, theOutputFile, d);
-    }
-#endif /* ZORBA_WITH_FILE_ACCESS */
-    else if ( IS_LONG_OPT( "--parse-only" ) ) 
-      theParseOnly = true;
-    else if ( IS_OPT( "--print-errors-as-xml", "-x" ) )
-      thePrintErrorsAsXml = true;
-    else if ( IS_LONG_OPT( "--print-query" ) ) 
-      thePrintQuery = true;
-    else if ( IS_OPT( "--query", "-q" ) ) {
-      int d = 2;
-      if(theFparm == false)
-        theAsFiles = false;
-      if(*(argv+1) && !strncmp(*(argv+1), "-f", 2))
-      {
-        theQBeforeF = true; // is it "-q -f <filename>" perhaps?
-        break;           // stop functionality here
-      }
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --query option"; break; }
-      init_val(*argv, theQueriesOrFiles, d);
-    }
-    else if ( IS_LONG_OPT( "--serialize-html" ) ) 
-      theSerializeHtml = true;
-    else if ( IS_LONG_OPT( "--serialize-text" ) ) 
-      theSerializeText = true;
-    else if ( IS_OPT( "--serialization-parameter", "-z" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --serialization-parameter option"; break; }
-      init_val(*argv, theSerializationParameter, d);
-    }
-    else if ( IS_LONG_OPT( "--stop-words" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --stop-words option"; break; }
-      init_val(*argv, theStopWords, d);
-    }
-    else if ( IS_OPT( "--timing", "-t" ) ) 
-      theTiming = true;
-    else if ( IS_LONG_OPT( "--timeout" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --timeout option"; break; }
-      init_val(*argv, theTimeout, d);
-    }
-    else if ( IS_LONG_OPT( "--trailing-nl" ) ) 
-      theTrailingNl = true;
-    else if ( IS_LONG_OPT( "--uri-path" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --uri-path option"; break; }
-      init_val(*argv, theUriPath, d);
-    }
-    else if ( IS_OPT( "--serialize-plan", "-s" ) )
-      theSerializePlan = true;
-    else if ( IS_LONG_OPT( "--disable-http-resolution" ) ) {
-      init_val("{http://zorba.io/options/features}disable=http-uri-resolution",
-                theOption, 0);
-    }
-    else if ( IS_LONG_OPT( "--thesaurus" ) ) {
-      int d = 2;
-      if ((*argv) [1] == '-' || (*argv) [2] == '\0') { d = 0; ++argv; }
-      if (!*argv) { result = "No value given for --thesaurus option"; break; }
-      init_val(*argv, theThesaurus, d);
-    }
-
-    else if ( IS_LONG_OPT( "--" ) ) {
-      copy_args (++argv);
-      break;
-    } else if ( (*argv)[0] == '-' ) {
-      result = "unknown command line option "; result += *argv; 
-      theUnknownOption = true; break; 
-    } else {
-      init_val(*argv, theQueriesOrFiles, 0);
-      copy_args( argv );
-    }
-  } // for
-  return result;
-}
-
-char const* ZorbaCMDPropertiesBase::get_help_msg() const {
-  return
-    "--as-files, -f\nTreat all -q arguments as file paths instead of URIs or inline queries. This option is deprecated and will be defaulted to true in the future, so any entry in the command line is going to be treated as files.\n\n"
-    "--base-uri\nSet the base URI property of the static context.\n\n"
-    "--boundary-space\nSet the boundary-space policy ('strip' or 'preserve') in the static context.\n\n"
-    "--byte-order-mark\nSet the byte-order-mark for the serializer.\n\n"
-    "--classpath\nJVM classpath to be used by modules using Java implementations\n\n"
-    "--compile-only\nOnly compile (don't execute)\n\n"
-    "--compile-plan,\nDo not execute the query; just compile it and save the execution plan in the file specified with the -o option.\n\n"
-    "--construction-mode\nSet the construction mode ('strip' or 'preserve') in the static context.\n\n"
-    "--context-item\nSet the context item to the XML document in a given file.\n\n"
-    "--debug, -d\nLaunch the Zorba debugger server and connect to a DBGP-enabled debugger client.\n\n"
-    "--debug-host, -h\nThe host where the DBGP-enabled debugger client listens for connections. Defaults to: 127.0.0.1\n\n"
-    "--debug-port, -p\nThe port on which the DBGP-enabled debugger client listens for connections. Defaults to: 28028\n\n"
-    "--default-collation\nAdd the given collation and set the value of the default collation in the static context to the given collation.\n\n"
-    "--disable-http-resolution\nDo not use HTTP to resolve URIs\n\n"
-    "--execute-plan\nDo not compile the query; instead load the execution plan from the file specified by the -f -q options (or by any file specified without any other argument), and execute the loaded plan.\n\n"
-    "--external-variable, -e\nProvide the value for a variable given a file (name=file) or a value (name:=value)\n\n"
-    "--indent, -i\nIndent output.\n\n"
-    "--lib-module, -l\nQuery compiler option to treat the query as a library module. If this is set --compile-only option is also set to true.\n\n"
-    "--lib-path\nLibrary path (list of directories) where Zorba will look for dynamic libraries (e.g., module external function implementations.\n\n"
-    "--module-path\nPath (list of directories) to add to both the URI and Library paths.\n\n"
-    "--multiple, -m\nExecute the given queries multiple times.\n\n"
-    "--no-logo\nPrint no logo when starting.\n\n"
-    "--no-serializer\nDo not serialize (discard) result.\n\n"
-    "--omit-xml-declaration, -r\nOmit the XML declaration from the result.\n\n"
-    "--optimization-level\nOptimization level for the query compiler (O0, O1 or O2 - default: O1)\n\n"
-    "--option\nSet an XQuery option in the static context. The QName of the option is passed as a string in the notation by James Clark (i.e. {namespace}localname). For example, --option {http://zorba.io/}option=value\n\n"
-    "--ordering-mode\nSet the ordering mode ('ordered' or 'unordered') in the static context.\n\n"
-    "--output-file, -o\nWrite the result to the given file.\n\n"
-    "--parse-only\nStop after parsing the query.\n\n"
-    "--print-errors-as-xml, -x\nPrint the errors as XML.\n\n"
-    "--print-query\nPrint the queries.\n\n"
-    "--query, -q\nQuery test or file URI (file://...)\n\n"
-    "--serialization-parameter, -z\nSet serialization parameter in the form of a parameter=value pair (see http://www.w3.org/TR/xslt-xquery-serialization/#serparam, e.g.: -z method=xhtml -z doctype-system=DTD/xhtml1-strict.dtd -z indent=yes).\n\n"
-    "--serialize-html\nSerialize the result as HTML.\n\n"
-    "--serialize-plan, -s\nSerialize and then load the query execution plan.\n\n"
-    "--serialize-text\nSerialize the result as Text.\n\n"
-    "--stop-words\nMapping specifying a stop-words URI to another.\n\n"
-    "--thesaurus\nMapping specifying a thesaurus URI to another.\n\n"
-    "--timeout\nSpecify a timeout in seconds. After the specified time, the execution of the query will be aborted.\n\n"
-    "--timing, -t\nPrint timing information. In case of multiple queries the timing information is provided per each query. Both wallclock time and user time (which excludes I/O, network delays and other kernel waits) are shown.\n\n"
-    "--trailing-nl\nOutput a trailing newline after the result of the query.\n\n"
-    "--uri-path\nURI path (list of directories) added to the built-in URI resolver, i.e. where to find modules/schemas to import.\n\n"
-    ;
-}
-
-ZorbaCMDPropertiesBase const* ZorbaCMDPropertiesBase::instance() {
-  static ZorbaCMDPropertiesBase result;
-  return &result;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-} // namespace zorbacmd
-/* vim:set et sw=2 ts=2: */
 
=== removed file 'bin/zorbacmdproperties_base.h'
--- bin/zorbacmdproperties_base.h	2014-01-31 23:27:47 +0000
+++ bin/zorbacmdproperties_base.h	1970-01-01 00:00:00 +0000
@@ -1,142 +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 <string>
-#include <sstream>
-#include <zorba/config.h>
-#include <zorba/properties_base.h>
-#include <cstring>
-
-#ifndef ZORBACMD_ZORBACMDPROPERTIESBASE
-#define ZORBACMD_ZORBACMDPROPERTIESBASE
-namespace zorbacmd {
-
-///////////////////////////////////////////////////////////////////////////////
-
-class ZorbaCMDPropertiesBase : public ::zorba::PropertiesBase {
-protected:
-  bool theTiming;
-#ifdef ZORBA_WITH_FILE_ACCESS
-  std::string theOutputFile;
-#endif /* ZORBA_WITH_FILE_ACCESS */
-  std::vector<std::string> theSerializationParameter;
-  bool theSerializeHtml;
-  bool theSerializeText;
-  bool theIndent;
-  bool thePrintQuery;
-  bool thePrintErrorsAsXml;
-  bool theByteOrderMark;
-  bool theOmitXmlDeclaration;
-  std::string theBaseUri;
-  std::string theBoundarySpace;
-  std::string theDefaultCollation;
-  std::string theConstructionMode;
-  std::string theOrderingMode;
-  unsigned long theMultiple;
-  std::vector<std::string> theQueriesOrFiles;
-  bool theAsFiles;
-  std::vector<std::string> theExternalVariable;
-  std::string theContextItem;
-  std::string theOptimizationLevel;
-  bool theLibModule;
-  bool theParseOnly;
-  bool theCompileOnly;
-  bool theNoSerializer;
-  bool theDebug;
-  std::string theDebugHost;
-  unsigned int theDebugPort;
-  bool theNoLogo;
-  long theTimeout;
-  std::string theUriPath;
-  std::string theLibPath;
-  std::string theModulePath;
-  std::string theClasspath;
-  std::vector<std::string> theOption;
-  bool theTrailingNl;
-  std::vector<std::string> theStopWords;
-  std::vector<std::string> theThesaurus;
-  bool theSerializePlan;
-  bool theSavePlan;
-  bool theLoadPlan;
-  bool theFparm;
-  bool theQBeforeF;
-  bool theUnknownOption;
-
-  // inherited
-  const char** get_all_options() const;
-
-public:
-  ZorbaCMDPropertiesBase();
-
-  bool timing () const { return theTiming; }
-#ifdef ZORBA_WITH_FILE_ACCESS
-  const std::string &outputFile () const { return theOutputFile; }
-#endif /* ZORBA_WITH_FILE_ACCESS */
-  const std::vector<std::string> &serializationParameter () const { return theSerializationParameter; }
-  bool serializeHtml () const { return theSerializeHtml; }
-  bool serializeText () const { return theSerializeText; }
-  bool indent () const { return theIndent; }
-  bool printQuery () const { return thePrintQuery; }
-  bool printErrorsAsXml () const { return thePrintErrorsAsXml; }
-  bool byteOrderMark () const { return theByteOrderMark; }
-  bool omitXmlDeclaration () const { return theOmitXmlDeclaration; }
-  const std::string &baseUri () const { return theBaseUri; }
-  const std::string &boundarySpace () const { return theBoundarySpace; }
-  const std::string &defaultCollation () const { return theDefaultCollation; }
-  const std::string &constructionMode () const { return theConstructionMode; }
-  const std::string &orderingMode () const { return theOrderingMode; }
-  unsigned long multiple () const { return theMultiple; }
-  const std::vector<std::string> &query () const { return theQueriesOrFiles; }
-  bool asFiles () const { return theAsFiles; }
-  const std::vector<std::string> &externalVariable () const { return theExternalVariable; }
-  const std::string &contextItem () const { return theContextItem; }
-  const std::string &optimizationLevel () const { return theOptimizationLevel; }
-  bool libModule () const { return theLibModule; }
-  bool parseOnly () const { return theParseOnly; }
-  bool compileOnly () const { return theCompileOnly; }
-  bool noSerializer () const { return theNoSerializer; }
-  bool debug () const { return theDebug; }
-  const std::string &debugHost () const { return theDebugHost; }
-  unsigned debugPort () const { return theDebugPort; }
-  bool noLogo () const { return theNoLogo; }
-  const long &timeout () const { return theTimeout; }
-  const std::string &uriPath () const { return theUriPath; }
-  const std::string &libPath () const { return theLibPath; }
-  const std::string &modulePath () const { return theModulePath; }
-  const std::string &classpath () const { return theClasspath; }
-  const std::vector<std::string> &option () const { return theOption; }
-  bool trailingNl () const { return theTrailingNl; }
-  const std::vector<std::string> &stopWords () const { return theStopWords; }
-  const std::vector<std::string> &thesaurus () const { return theThesaurus; }
-  bool serializePlan () const { return theSerializePlan; }
-  bool loadPlan () const { return theLoadPlan; }
-  bool savePlan () const { return theSavePlan; }
-  bool qBeforeF () const { return theQBeforeF; }
-  bool unknownOption() const { return theUnknownOption; }
-
-  std::string load_argv(int argc, const char **argv);
-
-  const char* get_help_msg() const;
-
-  static const ZorbaCMDPropertiesBase* instance();
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-} // namespace zorbacmd
-
-#endif /* ZORBACMD_ZORBACMDPROPERTIESBASE */
-/* vim:set et sw=2 ts=2: */
 
=== added file 'include/zorba/properties.h'
--- include/zorba/properties.h	1970-01-01 00:00:00 +0000
+++ include/zorba/properties.h	2014-02-11 00:42:47 +0000
@@ -0,0 +1,400 @@
+/*
+ * 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.
+ */
+#ifndef ZORBA_PROPERTIES_BASE_H
+#define ZORBA_PROPERTIES_BASE_H
+
+// standard
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+// Zorba
+#include <zorba/config.h>
+#include <zorba/internal/ztd.h>
+#include <zorba/internal/type_traits.h>
+#include <zorba/internal/unique_ptr.h>
+
+namespace zorba {
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * \brief This class provides access to global properties.
+ *
+ * This class provides access to global properties set for Zorba in environment
+ * and configuration file.
+ */
+class ZORBA_DLL_PUBLIC Properties {
+public:
+  /**
+   * Gets the singleton instance.
+   *
+   * @return Returns said instance.
+   */
+  static Properties& instance();
+
+#ifndef NDEBUG
+  /**
+   * Gets whether abort(3) will be called when a ZorbaException is thrown.
+   * (This is a developer debugging aid.)
+   */
+  bool getAbort() const {
+    return abort_;
+  }
+
+  /**
+   * Sets whether abort(3) will be called when a ZorbaException is thrown.
+   * (This is a developer debugging aid.)
+   *
+   * @param abort If \c true, call abort(3) when a ZorbaException is thrown.
+   */
+  void setAbort( bool abort ) {
+    abort_ = abort;
+  }
+#endif /* NDEBUG */
+
+  /**
+   * Gets the stream used for additional developer debugging output.
+   * (This has nothing to do with the Zorba debugger.)
+   *
+   * @return Returns said stream; default: standard output.
+   */
+  std::ostream& getDebugStream() const {
+    return *debug_stream_.get();
+  }
+
+  /**
+   * Sets the file to use for additional developer debugging output.
+   * (This has nothing to do with the Zorba debugger.)
+   *
+   * @param file The path to the file to use.
+   */
+  void setDebugFile( char const *file );
+
+  /**
+   * Sets the file to use for additional developer debugging output.
+   * (This has nothing to do with the Zorba debugger.)
+   *
+   * @tparam StringType The string type.
+   * @param file The path to the file to use.
+   */
+  template<class StringType>
+  typename std::enable_if<ZORBA_HAS_C_STR(StringType),void>::type
+  setDebugFile( StringType const &file ) {
+    setDebugFile( file.c_str() );
+  }
+
+  /**
+   * Sets the stream to use for additional developer debugging output.
+   * (This has nothing to do with the Zorba debugger.)
+   *
+   * @param stream The stream to use.
+   * @param take_ownership If \c true, \a stream will be deleted when Zorba
+   * shuts down.
+   */
+  void setDebugStream( std::ostream &os, bool take_ownership = false );
+
+  bool getDumpLib() const {
+    return dump_lib_;
+  }
+
+  void setDumpLib( bool b ) {
+    dump_lib_ = b;
+  }
+
+  bool getForceGFLWOR() const {
+    return force_gflwor_;
+  }
+
+  void setForceGFLWOR( bool b ) {
+    force_gflwor_ = b;
+  }
+
+  bool getInferJoins() const {
+    return infer_joins_;
+  }
+
+  void setInferJoins( bool b ) {
+    infer_joins_ = b;
+  }
+
+  bool getInlineUDF() const {
+    return inline_udf_;
+  }
+
+  void setInlineUDF( bool b ) {
+    inline_udf_ = b;
+  }
+
+  std::string const& getClassPath() const {
+    return classpath_;
+  }
+
+  void setClassPath( char const *classpath ) {
+    classpath_ = classpath;
+  }
+
+  template<class StringType>
+  typename std::enable_if<ZORBA_HAS_C_STR(StringType),void>::type
+  setClassPath( StringType const &classpath ) {
+    setClassPath( classpath.c_str() );
+  }
+
+  /**
+   * \brief Get global JVM classpath property.
+   *
+   * Before the JVM is started this will return the classpath set by
+   * command line option, the CLASSPATH environment variable and in Zorba
+   * config file.
+   *
+   * After the JVM is started this will contain in addition the paths to jars
+   * used by modules that make use of the JVM.
+   *
+   * @deprecated Use getClassPath().
+   */
+  void getJVMClassPath( std::string &jvmClasspath ) const {
+    jvmClasspath = getClassPath();
+  }
+
+  /**
+   * \brief Set global JVM classpath property.
+   *
+   * This method should be used to set additional JVM classpath for modules
+   * that make use of JVM. This will overide the classpath set by CLASSPATH
+   * environment variable or Zorba config file.
+   *
+   * Once the JVM is started this method doesn't have any effect.
+   *
+   * @deprecated Use setClassPath().
+   */
+  void setJVMClassPath( std::string const &jvmClasspath ) {
+    setClassPath( jvmClasspath );
+  }
+
+  bool getLoopHoisting() const {
+    return loop_hoisting_;
+  }
+
+  void setLoopHoisting( bool b ) {
+    loop_hoisting_ = b;
+  }
+
+  uint32_t getMaxUDFCallDepth() const {
+    return max_udf_call_depth_;
+  }
+
+  void setMaxUDFCallDepth( uint32_t u ) {
+    max_udf_call_depth_ = u;
+  }
+
+  bool getNoCopyOptim() const {
+    return no_copy_optim_;
+  }
+
+  void setNoCopyOptim( bool b ) {
+    no_copy_optim_ = b;
+  }
+
+  bool getNoTreeIDs() const {
+    return no_tree_ids_;
+  }
+
+  void setNoTreeIDs( bool b ) {
+    no_tree_ids_ = b;
+  }
+
+  unsigned getOptimizationLevel() const {
+    return optimization_level_;
+  }
+
+  void setOptimizationLevel( unsigned optimization_level );
+
+  bool getPrintAST() const {
+    return print_ast_;
+  }
+
+  void setPrintAST( bool b ) {
+    print_ast_ = b;
+  }
+
+  bool getPrintIntermediateOpt() const {
+    return print_intermediate_opt_;
+  }
+
+  void setPrintIntermediateOpt( bool b ) {
+    print_intermediate_opt_ = b;
+  }
+
+  bool getPrintItemFlow() const {
+    return print_item_flow_;
+  }
+
+  void setPrintItemFlow( bool b ) {
+    print_item_flow_ = b ;
+  }
+
+  bool getPrintIteratorTree() const {
+    return print_iterator_locations_;
+  }
+
+  void setPrintIteratorTree( bool b ) {
+    print_iterator_locations_ = b;
+  }
+
+  bool getPrintLocations() const {
+    return print_locations_;
+  }
+
+  void setPrintLocations( bool b ) {
+    print_locations_ = b;
+  }
+
+  bool getPrintOptimized() const {
+    return print_optimized_;
+  }
+
+  void setPrintOptimized( bool b ) {
+    print_optimized_ = b;
+  }
+
+  bool getPrintStaticTypes() const {
+    return print_static_types_;
+  }
+
+  void setPrintStaticTypes( bool b ) {
+    print_static_types_ = b;
+  }
+
+  bool getPrintTranslated() const {
+    return print_translated_;
+  }
+
+  void setPrintTranslated( bool b ) {
+    print_translated_ = b;
+  }
+
+  bool getStableIteratorIDs() const {
+    return stable_iterator_ids_;
+  }
+
+  void setStableIteratorIDs( bool b ) {
+    stable_iterator_ids_ = b;
+  }
+
+  bool getTraceCodegen() const {
+    return trace_codegen_;
+  }
+
+  void setTraceCodegen( bool b ) {
+    trace_codegen_ = b;
+  }
+
+#ifndef ZORBA_NO_FULL_TEXT
+  bool getTraceFulltext() const {
+    return trace_fulltext_;
+  }
+
+  void setTraceFulltext( bool b ) {
+    trace_fulltext_ = b;
+  }
+#endif /* ZORBA_NO_FULL_TEXT */
+
+  bool getTraceParsing() const {
+    return trace_parsing_;
+  }
+
+  void setTraceParsing( bool b ) {
+    trace_parsing_ = b;
+  }
+
+  bool getTraceScanning() const {
+    return trace_scanning_;
+  }
+
+  void setTraceScanning( bool b ) {
+    trace_scanning_ = b;
+  }
+
+  bool getTraceTranslator() const {
+    return trace_translator_;
+  }
+
+  void setTraceTranslator( bool b ) {
+    trace_translator_ = b;
+  }
+
+  bool getUseIndexes() const {
+    return use_indexes_;
+  }
+
+  void setUseIndexes( bool b ) {
+    use_indexes_ = b;
+  }
+
+private:
+  typedef std::unique_ptr<std::ostream> stream_ptr;
+
+  Properties();
+  ~Properties();
+
+#ifndef NDEBUG
+  bool          abort_;
+#endif /* NDEBUG */
+  std::string   classpath_;
+  stream_ptr    debug_stream_;
+  bool          owns_debug_stream_;
+  bool          dump_lib_;
+  bool          force_gflwor_;
+  bool          infer_joins_;
+  bool          inline_udf_;
+  bool          loop_hoisting_;
+  uint32_t      max_udf_call_depth_;
+  bool          no_copy_optim_;
+  bool          no_tree_ids_;
+  unsigned      optimization_level_;
+  bool          print_ast_;
+  bool          print_intermediate_opt_;
+  bool          print_item_flow_;
+  bool          print_iterator_locations_;
+  bool          print_locations_;
+  bool          print_optimized_;
+  bool          print_static_types_;
+  bool          print_translated_;
+  bool          stable_iterator_ids_;
+  bool          trace_codegen_;
+#ifndef ZORBA_NO_FULL_TEXT
+  bool          trace_fulltext_;
+#endif /* ZORBA_NO_FULL_TEXT */
+  bool          trace_parsing_;
+  bool          trace_scanning_;
+  bool          trace_translator_;
+  bool          use_indexes_;
+};
+
+// deprecated name
+typedef Properties PropertiesGlobal;
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace zorba
+#endif  // ZORBA_PROPERTIES_BASE_H
+/*
+ * Local variables:
+ * mode: c++
+ * End:
+ */
+/* vim:set et sw=2 ts=2: */
 
=== modified file 'include/zorba/properties_base.h'
--- include/zorba/properties_base.h	2013-02-07 17:24:36 +0000
+++ include/zorba/properties_base.h	2014-02-11 00:42:47 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2006-2008 The FLWOR Foundation.
+ * Copyright 2006-2014 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.
@@ -13,136 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #ifndef ZORBA_PROPERTIES_BASE_H
 #define ZORBA_PROPERTIES_BASE_H
 
-#include <string>
-#include <sstream>
-#include <iostream>
-#include <vector>
-#include <cctype>
-#include <zorba/config.h>
-
-namespace zorba {
-
-/***************************************************************************//**
-
-********************************************************************************/
-class ZORBA_DLL_PUBLIC PropertiesBase 
-{
-protected:
-  std::vector<std::string> thePositionalArgs;
-
-public:
-  virtual ~PropertiesBase() {}
-
-  std::string load_all(
-        const char* cfgFilename,
-        const std::string& env_pfx,
-        int argc,
-        const char **argv) 
-  {
-    std::string result;
-
-    if (! (result = load_env(env_pfx)).empty())
-      return result;
-
-    if (! (result = load_file(cfgFilename)).empty())
-      return result;
-
-    return load_argv(argc, argv);
-  }
-
-  std::string load_env(const std::string& env_pfx) 
-  {
-    return load_env(env_pfx, get_all_options()); 
-  }
-
-  std::string load_env(const std::string& env_pfx, const char** options);
-
-  std::string load_file(const char* fname);
-
-  virtual std::string load_argv(int argc, const char **argv) = 0;
-
-  virtual const char** get_all_options() const = 0;
-
-  virtual std::string check_args() { return ""; }
-
-  const std::vector<std::string>& getPositionalArgs() const
-  {
-    return thePositionalArgs;
-  }
-
-  void copy_args (const char** argv) 
-  {
-    for (; *argv != NULL; ++argv) 
-    {
-      thePositionalArgs.push_back(*argv);
-    }
-  }
-
-  template<class T> void init_val(const char* str, T& val, unsigned delta = 0) 
-  {
-    std::istringstream is(str + delta);
-    is >> val;
-  }
-
-};
-
-
-template<> ZORBA_DLL_PUBLIC void PropertiesBase::init_val(
-    const char* str,
-    std::string& val,
-    unsigned delta);
-
-
-template<> ZORBA_DLL_PUBLIC void PropertiesBase::init_val(
-    const char* str,
-    std::vector<std::string>& val,
-    unsigned delta);
-
-/**
- * \brief This class provides access to global properties.
- *
- * This class provides access to global properties set for Zorba in environment
- * and configuration file.
- * It is available using Zorba.getProperties() method.
- * \see { Zorba::getProperties() }
- */
-class ZORBA_DLL_PUBLIC PropertiesGlobal : public PropertiesBase
-{
-public:
-  virtual ~PropertiesGlobal() {}
-
-  /**
-   * \brief Get global JVM classpath property.
-   *
-   * Before the JVM is started this will return the classpath set by
-   * command line option, the CLASSPATH environment variable and in Zorba
-   * config file.
-   *
-   * After the JVM is started this will contain in addition the paths to jars
-   * used by modules that make use of the JVM.
-   */
-  virtual void getJVMClassPath(std::string & jvmClasspath) {}
-
-  /**
-   * \brief Set global JVM classpath property.
-   *
-   * This method should be used to set additional JVM classpath for modules
-   * that make use of JVM. This will overide the classpath set by CLASSPATH
-   * environment variable or Zorba config file.
-   *
-   * Once the JVM is started this method doesn't have any effect.
-   */
-  virtual void setJVMClassPath(const std::string & jvmClasspath) {}
-};
-
-}
-#endif  // ZORBA_PROPERTIES_BASE_H
-/*
- * Local variables:
- * mode: c++
- * End:
- */
+// This is a deprecated header; #include <zorba/properties.h> instead.
+
+#include <zorba/properties.h>
+
+#endif /* ZORBA_PROPERTIES_BASE_H */
 /* vim:set et sw=2 ts=2: */
 
=== modified file 'include/zorba/util/fs_util.h'
--- include/zorba/util/fs_util.h	2013-08-05 22:12:13 +0000
+++ include/zorba/util/fs_util.h	2014-02-11 00:42:47 +0000
@@ -90,6 +90,16 @@
 ////////// Directory //////////////////////////////////////////////////////////
 
 /**
+ * Gets the directory where per-user configuration files are stored.
+ *
+ * @return Returns said directory.
+ * @throws ZorbaException with a diagnostic of zerr::ZOSE0004_IO_ERROR if it
+ * fails.
+ */
+ZORBA_DLL_PUBLIC
+std::string configdir();
+
+/**
  * Gets the current directory.
  *
  * @return Returns said directory.
@@ -269,6 +279,37 @@
   return path.substr( 0, pos );
 }
 
+/**
+ * Gets the extension (the part of the name after the last '.') of the last
+ * path component of the given path name.
+ *
+ * @param path The path to get the extension of.
+ * @return Returns the extension (without the '.') or the empty string if
+ * \a path does not have an extension.
+ */
+inline std::string extension( char const *path ) {
+  char const *const name = base_name( path );
+  char const *const dot = std::strrchr( name, '.' );
+  return dot ? dot + 1 : "";
+}
+
+/**
+ * Gets the extension (the part of the name after the last '.') of the last
+ * path component of the given path name.
+ *
+ * @tparam PathStringType The \a path string type.
+ * @param path The path to get the extension of.
+ * @return Returns the extension (without the '.') or the empty string if
+ * \a path does not have an extension.
+ */
+template<class PathStringType> inline
+typename std::enable_if<ZORBA_IS_STRING(PathStringType),PathStringType>::type
+extension( PathStringType const &path ) {
+  PathStringType const name( base_name( path ) );
+  typename PathStringType::size_type const pos = name.rfind( '.' );
+  return pos != PathStringType::npos ? name.substr( pos + 1 ) : "";
+}
+
 #ifdef ZORBA_WITH_FILE_ACCESS
 
 /**
 
=== modified file 'include/zorba/util/smart_ptr.h'
--- include/zorba/util/smart_ptr.h	2013-06-12 04:55:14 +0000
+++ include/zorba/util/smart_ptr.h	2014-02-11 00:42:47 +0000
@@ -107,6 +107,12 @@
     return assign (rhs);
   }
 
+  T* release() {
+    T *const temp = p;
+    p = 0;
+    return temp;
+  }
+
 }; // SmartPtr
 
 } // namespace zorba
 
=== modified file 'include/zorba/zorba.h'
--- include/zorba/zorba.h	2013-08-06 08:41:26 +0000
+++ include/zorba/zorba.h	2014-02-11 00:42:47 +0000
@@ -34,7 +34,7 @@
 #include <zorba/xquery.h>
 #include <zorba/zorba_string.h>
 #include <zorba/iterator.h>
-#include <zorba/properties_base.h>
+#include <zorba/properties.h>
 
 namespace zorba {
 
@@ -45,7 +45,7 @@
  * (2) create static contexts,
  * (3) provides access to the XmlDataManager,
  * (4) provides access to the ItemFactory, and
- * (5) provides access to the PropertiesGlobal.
+ * (5) provides access to the Properties.
  */
 class ZORBA_DLL_PUBLIC Zorba
 {
@@ -319,9 +319,18 @@
 
   /** \brief Gets the singleton instance of Zorba's properties object.
    *
-   * @return zorba::Properties the singleton instance of Zorba's properties object.
-   */
-  virtual PropertiesGlobal* getPropertiesGlobal() = 0;
+   * @return zorba::Properties the singleton instance of Zorba's properties
+   * object.
+   * @deprecated Use Properties::instance() instead.
+   */
+  virtual Properties* getProperties() = 0;
+
+  /**
+   * @deprecated Use Properties::instance() instead.
+   */
+  Properties* getPropertiesGlobal() {
+    return getProperties();
+  }
 
 }; /* class Zorba */
 
 
=== modified file 'src/api/CMakeLists.txt'
--- src/api/CMakeLists.txt	2014-01-15 02:07:22 +0000
+++ src/api/CMakeLists.txt	2014-02-11 00:42:47 +0000
@@ -62,6 +62,7 @@
     store_consts.cpp
     streambuf.cpp
     mem_streambuf.cpp
+    properties.cpp
     transcode_streambuf.cpp
     uuid.cpp
     module_info_impl.cpp
 
=== renamed file 'src/system/zorba_properties.cpp' => 'src/api/properties.cpp'
--- src/system/zorba_properties.cpp	2014-01-27 23:42:57 +0000
+++ src/api/properties.cpp	2014-02-11 00:42:47 +0000
@@ -14,377 +14,90 @@
  * limitations under the License.
  */
 
-#include <cstring>
-
-#include "zorba_properties.h"
+// standard
+#include <exception>
+#include <fstream>
+#include <iostream>
+
+// Zorba
+#include <zorba/config.h>
+#include <zorba/internal/cxx_util.h>
+#include <zorba/properties.h>
+
+#include "util/string_util.h"
+
+using namespace std;
 
 namespace zorba { 
 
 ///////////////////////////////////////////////////////////////////////////////
 
-ZorbaProperties::ZorbaProperties() {
-  theAbort = false;
-  theCompileOnly = false;
-  theDebug = false;
-  theDumpLib = false;
-  theForceGflwor = false;
-  theInferJoins = true;
-  theInlineUdf = true;
-  theIterPlanTest = false;
-  theJsoniqParser = false;
-  theLibModule = false;
-  theLoopHoisting = true;
-  theMaxUdfCallDepth = 1024;
-  theNoCopyOptim = true;
-  theNoTreeIds = false;
-  theOptimizer = 1;
-  thePrintAst = false;
-  thePrintIntermediateOpt = false;
-  thePrintItemFlow = false;
-  thePrintIteratorTree = false;
-  thePrintLocations = false;
-  thePrintNormalized = false;
-  thePrintOptimized = false;
-  thePrintQuery = false;
-  thePrintStaticTypes = true;
-  thePrintTime = false;
-  thePrintTranslated = false;
-  thePrintXqdoc = false;
-  theReorderGlobals = true;
-  theSerializeOnlyQuery = -1;
-  theSpecializeCmp = true;
-  theSpecializeNum = true;
-  theStableIteratorIds = false;
-  theTestPlanSerialization = false;
-  theTraceCodegen = false;
-  theTraceFulltext = false;
-  theTraceParsing = false;
-  theTraceScanning = false;
-  theTraceTranslator = false;
-  theUseIndexes = true;
-  theUseSerializer = false;
-}
-
-char const** ZorbaProperties::get_all_options() const {
-  static char const *result[] = {
-    "--abort",
-    "--CLASSPATH",
-    "--compile-only",
-    "--debug",
-    "--debug-file",
-    "--dot-plan-file",
-    "--dump-lib",
-    "--external-var",
-    "--force-gflwor",
-    "--infer-joins",
-    "--inline-udf",
-    "--iter-plan-test",
-    "--jsoniq",
-    "--lib-module",
-    "--loop-hoisting",
-    "--max-udf-call-depth",
-    "--no-copy-optim",
-    "--no-tree-ids",
-    "--optimizer",
-    "--plan",
-    "--print-ast",
-    "--print-intermediate-opt",
-    "--print-item-flow",
-    "--print-iterator-tree",
-    "--print-locations",
-    "--print-normalized",
-    "--print-optimized",
-    "--print-query",
-    "--print-static-types",
-    "--print-time",
-    "--print-translated",
-    "--print-xqdoc",
-    "--query",
-    "--reorder-globals",
-    "--result-file",