Merge lp:~zorba-coders/zorba/bug-1180220 into lp:zorba

[Paul J. Lucas]

Removed plethora of file classes; moved much of fs_util to the public API to take its place.

Removed plethora of file classes; moved much of fs_util to the public API to take its place.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-03T23-40-21.931Z/log.html

[Zorba Build Bot (zorba-buildbot)]

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

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:281 (message):
  Validation queue job bug-1180220-2013-06-03T23-40-21.931Z is finished. The
  final status was:

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

  Not commiting changes.

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

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-04T16-43-15.194Z/log.html

[Zorba Build Bot (zorba-buildbot)]

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

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:281 (message):
  Validation queue job bug-1180220-2013-06-04T16-43-15.194Z is finished. The
  final status was:

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

  Not commiting changes.

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

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-04T20-19-05.33Z/log.html

[Zorba Build Bot (zorba-buildbot)]

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

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:281 (message):
  Validation queue job bug-1180220-2013-06-04T20-19-05.33Z is finished. The
  final status was:

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

  Not commiting changes.

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

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-04T23-20-14.642Z/log.html

[Zorba Build Bot (zorba-buildbot)]

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

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:281 (message):
  Validation queue job bug-1180220-2013-06-04T23-20-14.642Z is finished. The
  final status was:

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

  Not commiting changes.

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

[Zorba Build Bot (zorba-buildbot)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-05T00-34-07.697Z/log.html

[Paul J. Lucas (paul-lucas)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

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

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:281 (message):
  Validation queue job bug-1180220-2013-06-05T00-34-07.697Z is finished. The
  final status was:

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

  Not commiting changes.

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

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-05T04-36-11.699Z/log.html

[Zorba Build Bot (zorba-buildbot)]

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

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:281 (message):
  Validation queue job bug-1180220-2013-06-05T04-36-11.699Z is finished. The
  final status was:

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

  Not commiting changes.

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

[Chris Hillery (ceejatec)]

FYI, these failures keep happening after the build when it calls "make fots-import". So you should be able to test that locally.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-05T05-18-15.697Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-05T06-31-30.942Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-05T07-18-28.862Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-05T08-36-15.066Z/log.html

[Chris Hillery (ceejatec)]

This merge proposal was timing out, which is why it kept running the RQ over and over again. (Yes, the RQ should respond more gracefully to timeouts.) I've set it to "Needs Fixing" to stop it.

The problem tests seem to be xqts-xquery and xqtsx-xqx, not too surprisingly. In particular, based on lsof output from the testdriver_mt processes, they are getting stuck in an infinite loop while executing the test Functions/AllStringFunc/MatchStringFunc/MatchesFunc/caselessmatch15. I base this on the fact that the processes in question have an open file descriptor for build/test/rbkt/QueryResults/w3c_testsuite/XQuery/Functions/AllStringFunc/MatchStringFunc/MatchesFunc/caselessmatch15.err_0 , which I think should have been closed if the testcase hadn't hung. (The xqts-xqueryx testdriver_mt process has the same file only in .../w3c_testsuite/XQueryX/....)

Looking at that test case, I can't begin to guess why it would hang with your changes, but it seems pretty consistent.

[Zorba Build Bot (zorba-buildbot)]

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

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:281 (message):
  Validation queue job bug-1180220-2013-06-05T08-36-15.066Z is finished. The
  final status was:

  13 tests did not succeed - changes not commited.

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

[Chris Hillery (ceejatec)]

Ok, I manually killed the testdriver_mt processes on the RQ box, which allowed the last run to submit its results to CDash. So in addition to the XQTS problems, you can see there are 11 other test failures to look at.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-06T00-35-08.319Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug-1180220-2013-06-06T00-35-08.319Z is finished. The final status was:

All tests succeeded!

[Zorba Build Bot (zorba-buildbot)]

Voting does not meet specified criteria. Required: Approve > 1, Disapprove < 1, Needs Fixing < 1, Pending < 1, Needs Information < 1, Resubmit < 1. Got: 1 Approve.

[Matthias Brantner (matthias-brantner)]

What are the changes in modules/ExternalModules.conf good for?

[Paul J. Lucas (paul-lucas)]

> What are the changes in modules/ExternalModules.conf good for?

Did you read Chris's only way to make incompatible changes affecting external modules e-mail? That's why. It's temporary because it's a chicken-and-egg problem.

[Matthias Brantner (matthias-brantner)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-07T05-03-17.543Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug-1180220-2013-06-07T05-03-17.543Z is finished. The final status was:

All tests succeeded!

[Zorba Build Bot (zorba-buildbot)]

Voting does not meet specified criteria. Required: Approve > 1, Disapprove < 1, Needs Fixing < 1, Pending < 1, Needs Information < 1, Resubmit < 1. Got: 2 Approve, 1 Pending.

[lp:~zorba-coders/zorba/bug-1180220]

11502. By Chris Hillery on 2013-06-07

Removed commented-out lines that only differed in removal of tags.

[Chris Hillery (ceejatec)]

1. What's the difference between include/zorba/internal and include/zorba/util?

2. Was it necessary/a good idea to move cxx_util.h and error_util.h into the set of shipped headers?

3. Why was cxx_util.h moved to internal/ and error_util.h to util/ ?

4. Have you done any testing on Windows? There are several #ifdef WIN32 changes. If necessary I could request Juan or Luis to test it out (would prefer Rodolfo but he's busy with website stuff).

review: Needs Information

[Paul J. Lucas (paul-lucas)]

> 1. What's the difference between include/zorba/internal and
> include/zorba/util?

Internal is for our use only. We make no claim that stuff in there will not either change or be removed at any time.

> 2. Was it necessary/a good idea to move cxx_util.h and error_util.h into the
> set of shipped headers?

Because they're necessary for fs_util.h.

> 3. Why was cxx_util.h moved to internal/ and error_util.h to util/ ?

Because cxx_util.h is a temporary measure until C++0x compilers are wide-spread and the file may disappear at any time; error_util.h will stick around (see #1 answer above).

> 4. Have you done any testing on Windows?

It's pretty much impossible for me to do that.

> There are several #ifdef WIN32
> changes. If necessary I could request Juan or Luis to test it out (would
> prefer Rodolfo but he's busy with website stuff).

You can, if you like.

[lp:~zorba-coders/zorba/bug-1180220]

11503. By Paul J. Lucas on 2013-06-07

Merge from trunk.

11504. By Paul J. Lucas on 2013-06-07

Merge from trunk.

11505. By Paul J. Lucas on 2013-06-10

Merge from trunk.

11506. By Paul J. Lucas on 2013-06-10

Windows fixes.

11507. By Paul J. Lucas on 2013-06-11

Windows fix.

11508. By Paul J. Lucas on 2013-06-11

Windows fix.

11509. By Paul J. Lucas on 2013-06-11

Windows fix.

11510. By Paul J. Lucas on 2013-06-11

Merge from trunk.

11511. By Paul J. Lucas on 2013-06-11

Merge from trunk.

11512. By Paul J. Lucas on 2013-06-11

Windows fix.

[Chris Hillery (ceejatec)]

Juan reported some Windows compilation failures which are now fixed. There are a number of test failures but they seem to be the same set as without Paul's changes, so presumably no regressions.

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1180220-2013-06-11T23-06-19.773Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug-1180220-2013-06-11T23-06-19.773Z is finished. The final status was:

All tests succeeded!

=== modified file 'ChangeLog'
--- ChangeLog	2013-06-11 15:47:07 +0000
+++ ChangeLog	2013-06-11 16:49:27 +0000
@@ -21,6 +21,7 @@
   * Fixed bug #1188084 (fn-replace-42 failing)
   * Fixed bug in hoisting through try-catch expr
   * Fixed bug #1162631 (format-integer 'w' format of negative numbers)
+  * Fixed bug #1180220 (Consolidate redundant path/file public APIs)
   * Fixed bug #1103115 (Timezone units as hours are wrong)
   * Fixed implementation of fn:deep-equal according to latest W3C spec.
   * Must apply document ordering on the domain expression of a FOR clause, if

=== modified file 'bin/path_util.cpp'
--- bin/path_util.cpp	2013-02-07 17:24:36 +0000
+++ bin/path_util.cpp	2013-06-11 16:49:27 +0000
@@ -16,13 +16,13 @@
 
 #include "path_util.h"
 
-#include <stdlib.h>
-//#include "zorba/zorba_string.h"
-#include "zorba/util/path.h"
+#include <cstdlib>
+
+#include <zorba/static_context.h>
+#include <zorba/util/fs_util.h>
 
 #include "util.h"
 #include "zorbacmdproperties.h"
-#include <zorba/static_context.h>
 
 namespace zorba {
 
@@ -54,28 +54,28 @@
   std::string lPathStr;
 
   // Compute the current working directory to append to all paths.
-  filesystem_path lCWD;
+  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.get_path());
+    lPath.push_back(lCWD);
     aStaticCtx->setModulePaths(lPath);
   }
   else {
     // Compute and set URI path
     aProperties.getURIPath(lPathStr);
     tokenizePath(lPathStr, lPath);
-    lPath.push_back(lCWD.get_path());
+    lPath.push_back(lCWD);
     aStaticCtx->setURIPath(lPath);
     lPath.clear();
 
     // Compute and set lib path
     aProperties.getLibPath(lPathStr);
     tokenizePath(lPathStr, lPath);
-    lPath.push_back(lCWD.get_path());
+    lPath.push_back(lCWD);
     aStaticCtx->setLibPath(lPath);
   }
 }

=== modified file 'bin/zorbacmd.cpp'
--- bin/zorbacmd.cpp	2013-05-28 00:58:27 +0000
+++ bin/zorbacmd.cpp	2013-06-11 16:49:27 +0000
@@ -30,7 +30,6 @@
 #endif
 
 #include <zorba/zorba.h>
-#include <zorba/file.h>
 #include <zorba/zorba_exception.h>
 #include <zorba/xquery_exception.h>
 #include <zorba/document_manager.h>
@@ -41,8 +40,8 @@
 #include <zorba/serialization_callback.h>
 #include <zorba/audit.h>
 #include <zorba/audit_scoped.h>
-
 #include <zorba/store_manager.h>
+#include <zorba/util/fs_util.h>
 
 //#define DO_AUDIT
 
@@ -54,9 +53,6 @@
 #include "util.h"
 #include "path_util.h"
 
-// For setting the base URI from the current directory
-#include <zorba/util/path.h>
-
 // Timing utilities, including wall-clock timing
 #include <zorba/util/time.h>
 
@@ -77,8 +73,6 @@
   "Copyright 2006-2009 The FLWOR Foundation.\n"
   "License: Apache License 2.0: <http://www.apache.org/licenses/LICENSE-2.0>";
 
-#define PATH_SEP (zorba::filesystem_path::get_directory_separator ())
-
 #ifndef ZORBA_NO_FULL_TEXT
 OneToOneURIMapper theStopWordsMapper(EntityData::STOP_WORDS);
 OneToOneURIMapper theThesaurusMapper(EntityData::THESAURUS);
@@ -368,13 +362,13 @@
   if(str.compare(0, strlen(file3), file3) == 0) {
     fpath = str.substr(strlen(file3));
   } else if(str.compare(0, strlen(file2), file2) == 0) {
-    fpath = PATH_SEP;
+    fpath = fs::dir_separator;
     fpath += str.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, PATH_SEP);
+    fpath.replace(off, 1, 1, fs::dir_separator);
   return fpath;
 
 #else // for UNIX
@@ -639,14 +633,8 @@
 removeOutputFileIfNeeded(const ZorbaCMDProperties& lProperties)
 {
 #ifdef ZORBA_WITH_FILE_ACCESS
-  if (lProperties.outputFile().size() > 0)
-  {
-    File_t lFile = zorba::File::createFile(lProperties.outputFile());
-    if (lFile->exists())
-    {
-      lFile->remove();
-    }
-  }
+  if ( !lProperties.outputFile().empty() )
+    fs::remove( lProperties.outputFile(), true );
 #endif /* ZORBA_WITH_FILE_ACCESS */
 }
 
@@ -1021,7 +1009,7 @@
   std::string configJvmClassPath;
   globaproperties->getJVMClassPath(configJvmClassPath);
   globaproperties->setJVMClassPath(cmdJvmClassPath +
-      filesystem_path::get_path_separator() + configJvmClassPath);
+      fs::path_separator + configJvmClassPath);
 
   // Start the engine
 
@@ -1068,14 +1056,14 @@
     //
     std::string fURI = *lIter;
     std::string fname = parseFileURI (properties.asFiles (), fURI);
-    zorba::filesystem_path path (fname);
-    bool asFile = ! fname.empty ();
+    std::string path( fname );
+    bool asFile = !fname.empty();
     std::auto_ptr<std::istream> qfile;
 
     if (asFile)
     {
-      path.resolve_relative ();
-      qfile.reset(new std::ifstream (path.c_str ()));
+      fs::make_absolute( path );
+      qfile.reset( new std::ifstream( path.c_str() ) );
     }
     else
     {
@@ -1129,10 +1117,11 @@
     {
       // 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
-      zorba::filesystem_path p;
+      std::string p( fs::curdir() );
       std::stringstream lTmp;
       std::vector<std::string> lTokens;
-      Util::tokenize(p.c_str(), PATH_SEP, lTokens);
+      std::string const delim( 1, fs::dir_separator );
+      Util::tokenize(p.c_str(), delim, lTokens);
 
       lTmp << "file://";
       for (std::vector<std::string>::const_iterator lIter = lTokens.begin();
@@ -1155,7 +1144,7 @@
         zorba::XQuery_t lQuery = lZorbaInstance->createQuery();
         if (asFile)
         {
-          lQuery->setFileName(path.get_path());
+          lQuery->setFileName(path);
         }
 
         lQuery->parse (*qfile);
@@ -1178,7 +1167,7 @@
           zorba::XQuery_t aQuery = lZorbaInstance->createQuery();
           if (asFile) 
           {
-            aQuery->setFileName(path.get_path());
+            aQuery->setFileName(path);
           }
 
           aQuery->parse(*qfile);
@@ -1198,7 +1187,7 @@
       int status = compileAndExecute(lZorbaInstance,
                                      properties,
                                      lStaticContext,
-                                     path.get_path(),
+                                     path,
                                      *qfile,
                                      *lOutputStream,
                                      queryTiming);
@@ -1236,7 +1225,7 @@
       }
 
       std::auto_ptr<std::istream> lXQ(new std::ifstream(path.c_str()));
-      std::string lFileName(path.get_path());
+      std::string lFileName(path);
 
       zorba::XQuery_t lQuery;
 

=== modified file 'include/zorba/api_shared_types.h'
--- include/zorba/api_shared_types.h	2013-04-10 10:13:31 +0000
+++ include/zorba/api_shared_types.h	2013-06-11 16:49:27 +0000
@@ -16,75 +16,71 @@
 #ifndef ZORBA_SHARED_TYPES_INCL_H
 #define ZORBA_SHARED_TYPES_INCL_H
 
-#include <memory>
-
 #include <zorba/config.h>
 #include <zorba/smart_ptr.h>
 
 namespace zorba {
 
-  class Zorba;
-  class XQuery;
-  class StaticContext;
-  class DynamicContext;
-  class XmlDataManager;
-  class DocumentManager;
-  class CollectionManager;
-  class StaticCollectionManager;
-  class ItemFactory;
-  class Iterator;
-  class StatelessExternalFunction;
-  class ExternalFunctionParameter;
-  class ExternalModule;
-  class TypeIdentifier;
-  class ItemSequence;
-  class Collection;
-  class Function;
-  class Annotation;
-  class SerializationCallback;
-  class File;
-  class DirectoryIterator;
-  class Serializer;
-  class ModuleInfo;
-
-  class DiagnosticHandler;
-  class QueryLocation;
-  typedef SmartPtr<QueryLocation> QueryLocation_t;
-
+///////////////////////////////////////////////////////////////////////////////
+
+class Annotation;
+class Collection;
+class CollectionManager;
+class DiagnosticHandler;
+class DocumentManager;
+class DynamicContext;
+class ExternalFunctionParameter;
+class ExternalModule;
+class Function;
+class ItemFactory;
+class ItemSequence;
+class Iterator;
+class ModuleInfo;
+class QueryLocation;
+class SerializationCallback;
+class Serializer;
+class StatelessExternalFunction;
+class StaticCollectionManager;
+class StaticContext;
 #ifndef ZORBA_NO_FULL_TEXT
-  class StemmerProvider;
-  class TokenizerProvider;
+class StemmerProvider;
+class TokenizerProvider;
 #endif /* ZORBA_NO_FULL_TEXT */
-
-  // smart pointers
-  typedef zorba::SmartPtr<XQuery>                  XQuery_t;
-  typedef zorba::SmartPtr<StaticContext>           StaticContext_t;
-  typedef zorba::SmartPtr<Iterator>                Iterator_t;
-  typedef zorba::SmartPtr<TypeIdentifier>          TypeIdentifier_t;
-  typedef zorba::SmartPtr<Collection>              Collection_t;
-  typedef zorba::SmartPtr<Function>                Function_t;
-  typedef zorba::SmartPtr<Annotation>              Annotation_t;
-  typedef zorba::SmartPtr<File>                    File_t;
-  typedef zorba::SmartPtr<DirectoryIterator>       DirectoryIterator_t;
-  typedef zorba::SmartPtr<Serializer>              Serializer_t;
-  typedef zorba::SmartPtr<ItemSequence>            ItemSequence_t;
-  typedef zorba::SmartPtr<ModuleInfo>              ModuleInfo_t;
-
-  // data handlers
-  class Item;
-  class String;
-
-  // uri resolvers
-  class URIMapper;
-  class Resource;
-  class URLResolver;
-
-  namespace audit {
-    class Provider;
-    class Event;
-    class ScopedRecord;
-  }
-
-} /* namespace zorba */
-#endif
+class TypeIdentifier;
+class XmlDataManager;
+class XQuery;
+class Zorba;
+
+// smart pointers
+typedef SmartPtr<Annotation>      Annotation_t;
+typedef SmartPtr<Collection>      Collection_t;
+typedef SmartPtr<Function>        Function_t;
+typedef SmartPtr<ItemSequence>    ItemSequence_t;
+typedef SmartPtr<Iterator>        Iterator_t;
+typedef SmartPtr<ModuleInfo>      ModuleInfo_t;
+typedef SmartPtr<QueryLocation>   QueryLocation_t;
+typedef SmartPtr<Serializer>      Serializer_t;
+typedef SmartPtr<StaticContext>   StaticContext_t;
+typedef SmartPtr<TypeIdentifier>  TypeIdentifier_t;
+typedef SmartPtr<XQuery>          XQuery_t;
+
+// data handlers
+class Item;
+class String;
+
+// uri resolvers
+class URIMapper;
+class Resource;
+class URLResolver;
+
+namespace audit {
+  class Provider;
+  class Event;
+  class ScopedRecord;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace zorba
+#endif /* ZORBA_SHARED_TYPES_INCL_H */
 /* vim:set et sw=2 ts=2: */

=== modified file 'include/zorba/base64_stream.h'
--- include/zorba/base64_stream.h	2013-02-12 03:55:18 +0000
+++ include/zorba/base64_stream.h	2013-06-11 16:49:27 +0000
@@ -20,6 +20,7 @@
 #include <streambuf>
 
 #include <zorba/config.h>
+#include <zorba/internal/cxx_util.h>
 #include <zorba/internal/streambuf.h>
 
 namespace zorba {
@@ -174,7 +175,7 @@
 void detach( std::basic_ios<charT,Traits> &ios ) {
   int const index = internal::base64::get_streambuf_index();
   if ( streambuf *const buf = static_cast<streambuf*>( ios.pword( index ) ) ) {
-    ios.pword( index ) = 0;
+    ios.pword( index ) = nullptr;
     ios.rdbuf( buf->orig_streambuf() );
     internal::dealloc_streambuf( buf );
   }

=== removed file 'include/zorba/file.h'
--- include/zorba/file.h	2013-04-19 22:25:21 +0000
+++ include/zorba/file.h	1970-01-01 00:00:00 +0000
@@ -1,100 +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_FILE_API_H
-#define ZORBA_FILE_API_H
-
-#include <string>
-
-#include <zorba/config.h>
-#include <zorba/api_shared_types.h>
-
-namespace zorba {
-
-  /** \brief This class is the representation of file system file.
-   *
-   * ...
-   */
-  class ZORBA_DLL_PUBLIC DirectoryIterator : public SmartObject
-  {
-    public:
-
-      virtual ~DirectoryIterator() {}
-
-      virtual bool next(std::string& aPathStr) const = 0;
-      /** \brief Rewind the file find iterator
-      */
-      virtual void reset() = 0;
-  };
-
-
-  /** \brief This class is the representation of file system file.
-   *
-   * ...
-   */
-  class ZORBA_DLL_PUBLIC File : public SmartObject
-  {
-    public: // constructors
-
-      virtual ~File() {}
-
-      static File_t createFile(const std::string& path);
-
-      static const char* getDirectorySeparator();
-
-      static const char* getPathSeparator();
-
-    public: // type, enums
-
-#ifdef WIN32
-      typedef __int64 FileSize_t;
-#else
-      typedef int64_t FileSize_t;
-#endif
-
-
-    public: // public methods
-
-      virtual const std::string getFilePath() const = 0;
-      virtual const std::string getFileUri() const = 0;
-
-      virtual bool isDirectory( bool follow_symlinks = true ) const = 0;
-      virtual bool isFile( bool follow_symlinks = true ) const = 0;
-      virtual bool isLink() const = 0;
-      virtual bool isVolume( bool follow_symlinks = true ) const = 0;
-      virtual bool isInvalid() const = 0; // deprecated
-      virtual bool exists( bool follow_symlinks = true ) const = 0;
-
-      virtual void remove() = 0;
-      virtual bool create() = 0;
-      virtual bool rename(std::string const& newpath) = 0;
-
-      virtual FileSize_t getSize() const = 0;
-
-      virtual void mkdir(bool recursive) = 0;
-
-      virtual DirectoryIterator_t files() const = 0;
-
-      virtual void openInputStream(std::ifstream& aInStream, bool binary, bool trimByteOrderMark) const = 0;
-      virtual void openOutputStream(std::ofstream& aOutStream, bool binary, bool append) const = 0;
-
-      virtual time_t lastModified() const = 0;
-
-  };
-
-} /* namespace zorba */
-
-#endif
-/* vim:set et sw=2 ts=2: */

=== renamed file 'src/util/cxx_util.h' => 'include/zorba/internal/cxx_util.h'
--- src/util/cxx_util.h	2013-02-07 17:24:36 +0000
+++ include/zorba/internal/cxx_util.h	2013-06-11 16:49:27 +0000
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ZORBA_CXX_UTIL_H
-#define ZORBA_CXX_UTIL_H
+#ifndef ZORBA_INTERNAL_CXX_UTIL_H
+#define ZORBA_INTERNAL_CXX_UTIL_H
 
 #include <zorba/config.h>
 
@@ -24,6 +24,7 @@
 #ifndef ZORBA_CXX_NULLPTR
 
 namespace zorba {
+namespace internal {
 
 /**
  * A \c nullptr type.
@@ -45,6 +46,7 @@
   void operator&() const;               // whose address can't be taken
 };
 
+} // namespace internal
 } // namespace zorba
 
 /**
@@ -55,7 +57,7 @@
  * Bjarne's paper has a slight performance penalty.
  */
 ZORBA_DLL_PUBLIC
-extern zorba::nullptr_type const zorba_nullptr;
+extern zorba::internal::nullptr_type const zorba_nullptr;
 
 #define nullptr ::zorba_nullptr
 
@@ -78,5 +80,5 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#endif /* ZORBA_CXX_UTIL_H */
+#endif /* ZORBA_INTERNAL_CXX_UTIL_H */
 /* vim:set et sw=2 ts=2: */

=== modified file 'include/zorba/internal/unique_ptr.h'
--- include/zorba/internal/unique_ptr.h	2013-02-07 17:24:36 +0000
+++ include/zorba/internal/unique_ptr.h	2013-06-11 16:49:27 +0000
@@ -25,6 +25,7 @@
 #else
 
 #include <algorithm>                    /* for swap() */
+#include "cxx_util.h"
 #include "type_traits.h"
 #include "ztd.h"
 
@@ -159,7 +160,8 @@
    */
   template<typename U>
   default_delete( default_delete<U> const&,
-    typename enable_if<ZORBA_TR1_NS::is_convertible<U*,T*>::value>::type* = 0 )
+    typename enable_if<ZORBA_TR1_NS::is_convertible<U*,T*>::value>::type*
+      = nullptr )
   {
   }
 
@@ -218,7 +220,7 @@
    *
    * @param p A pointer to the object to point to, if any.
    */
-  explicit unique_ptr( pointer p = 0 ) throw() : storage_( p ) {
+  explicit unique_ptr( pointer p = nullptr ) throw() : storage_( p ) {
   }
 
   /**
@@ -266,7 +268,7 @@
         !ZORBA_TR1_NS::is_reference<D>::value ||
          ZORBA_TR1_NS::is_same<D,E>::value
       )
-    >::type* = 0
+    >::type* = nullptr
   ) :
     storage_( p.release(), move<D>( p.get_deleter() ) )
   {
@@ -374,7 +376,7 @@
    */
   pointer release() throw() {
     pointer const temp = get();
-    storage_.ptr_ = 0;
+    storage_.ptr_ = nullptr;
     return temp;
   }
 
@@ -385,7 +387,7 @@
    *
    * @param p The new pointer value, if any.
    */
-  void reset( pointer p = 0 ) throw() {
+  void reset( pointer p = nullptr ) throw() {
     if ( p != storage_.ptr_ ) {
       call_deleter();
       storage_.ptr_ = p;
@@ -462,7 +464,7 @@
   typedef T* pointer;
   typedef D deleter_type;
 
-  explicit unique_ptr( pointer p = 0 ) throw() : storage_( p ) {
+  explicit unique_ptr( pointer p = nullptr ) throw() : storage_( p ) {
   }
 
   unique_ptr( pointer p, deleter_reference d ) : storage_( p, d ) {
@@ -496,11 +498,11 @@
 
   pointer release() throw() {
     pointer const temp = get();
-    storage_.ptr_ = 0;
+    storage_.ptr_ = nullptr;
     return temp;
   }
 
-  void reset( pointer p = 0 ) throw() {
+  void reset( pointer p = nullptr ) throw() {
     if ( p != storage_.ptr_ ) {
       call_deleter();
       storage_.ptr_ = p;

=== modified file 'include/zorba/internal/ztd.h'
--- include/zorba/internal/ztd.h	2013-05-09 00:48:27 +0000
+++ include/zorba/internal/ztd.h	2013-06-11 16:49:27 +0000
@@ -24,6 +24,7 @@
 
 #include <zorba/config.h>
 
+#include "cxx_util.h"
 #include "type_traits.h"
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -210,7 +211,8 @@
   template<typename U>
   destroy_delete( destroy_delete<U> const&,
     typename
-      std::enable_if<ZORBA_TR1_NS::is_convertible<U*,T*>::value>::type* = 0 )
+      std::enable_if<ZORBA_TR1_NS::is_convertible<U*,T*>::value>::type*
+        = nullptr )
   {
   }
 

=== modified file 'include/zorba/stemmer.h'
--- include/zorba/stemmer.h	2013-02-07 17:24:36 +0000
+++ include/zorba/stemmer.h	2013-06-11 16:49:27 +0000
@@ -21,6 +21,7 @@
 
 #ifndef ZORBA_NO_FULL_TEXT
 
+#include <zorba/internal/cxx_util.h>
 #include <zorba/internal/unique_ptr.h>
 #include <zorba/internal/ztd.h>
 #include <zorba/locale.h>
@@ -98,7 +99,7 @@
    * \a lang.
    */
   virtual bool getStemmer( locale::iso639_1::type lang,
-                           Stemmer::ptr *s = 0 ) const = 0;
+                           Stemmer::ptr *s = nullptr ) const = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////////////

=== modified file 'include/zorba/thesaurus.h'
--- include/zorba/thesaurus.h	2013-02-07 17:24:36 +0000
+++ include/zorba/thesaurus.h	2013-06-11 16:49:27 +0000
@@ -21,6 +21,7 @@
 
 #ifndef ZORBA_NO_FULL_TEXT
 
+#include <zorba/internal/cxx_util.h>
 #include <zorba/internal/unique_ptr.h>
 #include <zorba/internal/ztd.h>
 #include <zorba/locale.h>
@@ -128,7 +129,7 @@
    * \a lang.
    */
   virtual bool getThesaurus( locale::iso639_1::type lang,
-                             Thesaurus::ptr *t = 0 ) const = 0;
+                             Thesaurus::ptr *t = nullptr ) const = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////////////

=== modified file 'include/zorba/tokenizer.h'
--- include/zorba/tokenizer.h	2013-02-07 17:24:36 +0000
+++ include/zorba/tokenizer.h	2013-06-11 16:49:27 +0000
@@ -21,9 +21,10 @@
 #include <vector>
 
 #include <zorba/config.h>
-#include <zorba/locale.h>
+#include <zorba/internal/cxx_util.h>
 #include <zorba/internal/unique_ptr.h>
 #include <zorba/internal/ztd.h>
+#include <zorba/locale.h>
 
 namespace zorba {
 
@@ -101,7 +102,7 @@
     virtual void token( char const *utf8_s, size_type utf8_len,
                         locale::iso639_1::type lang,
                         size_type token_no, size_type sent_no,
-                        size_type para_no, Item const *item = 0 ) = 0;
+                        size_type para_no, Item const *item = nullptr ) = 0;
   };
 
   /////////////////////////////////////////////////////////////////////////////
@@ -200,7 +201,8 @@
    */
   virtual void tokenize_string( char const *utf8_s, size_type utf8_len,
                                 locale::iso639_1::type lang, bool wildcards,
-                                Callback &callback, Item const *item = 0 ) = 0;
+                                Callback &callback,
+                                Item const *item = nullptr ) = 0;
 
   /////////////////////////////////////////////////////////////////////////////
 
@@ -295,8 +297,8 @@
    * \a lang.
    */
   virtual bool getTokenizer( locale::iso639_1::type lang,
-                             Tokenizer::State *state = 0,
-                             Tokenizer::ptr *t = 0 ) const = 0;
+                             Tokenizer::State *state = nullptr,
+                             Tokenizer::ptr *t = nullptr ) const = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////////////

=== modified file 'include/zorba/transcode_stream.h'
--- include/zorba/transcode_stream.h	2013-02-26 04:12:43 +0000
+++ include/zorba/transcode_stream.h	2013-06-11 16:49:27 +0000
@@ -18,6 +18,7 @@
 #define ZORBA_TRANSCODE_STREAM_API_H
 
 #include <zorba/config.h>
+#include <zorba/internal/cxx_util.h>
 #include <zorba/internal/streambuf.h>
 #include <zorba/internal/unique_ptr.h>
 
@@ -164,7 +165,7 @@
 void detach( std::basic_ios<charT,Traits> &ios ) {
   int const index = internal::transcode::get_streambuf_index();
   if ( streambuf *const buf = static_cast<streambuf*>( ios.pword( index ) ) ) {
-    ios.pword( index ) = 0;
+    ios.pword( index ) = nullptr;
     ios.rdbuf( buf->orig_streambuf() );
     internal::dealloc_streambuf( buf );
   }

=== modified file 'include/zorba/user_exception.h'
--- include/zorba/user_exception.h	2013-02-07 17:24:36 +0000
+++ include/zorba/user_exception.h	2013-06-11 16:49:27 +0000
@@ -21,6 +21,7 @@
 
 #include <zorba/api_shared_types.h>
 #include <zorba/error.h>
+#include <zorba/internal/cxx_util.h>
 #include <zorba/xquery_exception.h>
 
 namespace zorba {
@@ -60,7 +61,7 @@
                      ZorbaException::line_type raise_line,
                      char const *ns, char const *prefix, char const *localname,
                      char const *description, diagnostic::location const &loc,
-                     error_object_type *error_object = 0 );
+                     error_object_type *error_object = nullptr );
 
 /**
  * \internal
@@ -83,7 +84,7 @@
                      ZorbaException::line_type raise_line,
                      Error const &error, char const *description,
                      diagnostic::location const &loc,
-                     error_object_type *error_object = 0 );
+                     error_object_type *error_object = nullptr );
 
 } // namespace internal
 
@@ -369,7 +370,7 @@
 make_user_exception( char const *raise_file,
                      ZorbaException::line_type raise_line,
                      Error const &error, String const &description,
-                     error_object_type *error_object = 0 );
+                     error_object_type *error_object = nullptr );
 
 ///////////////////////////////////////////////////////////////////////////////
 

=== renamed file 'src/util/error_util.h' => 'include/zorba/util/error_util.h'
--- src/util/error_util.h	2013-05-08 01:05:04 +0000
+++ include/zorba/util/error_util.h	2013-06-11 16:49:27 +0000
@@ -15,10 +15,13 @@
  */
 
 #pragma once
-#ifndef ZORBA_ERROR_UTIL_H
-#define ZORBA_ERROR_UTIL_H
+#ifndef ZORBA_API_ERROR_UTIL_H
+#define ZORBA_API_ERROR_UTIL_H
 
 #include <zorba/config.h>
+#include <zorba/internal/cxx_util.h>
+#include <zorba/internal/type_traits.h>
+#include <zorba/internal/ztd.h>
 
 #include <stdexcept>
 #ifndef WIN32
@@ -27,9 +30,6 @@
 # include <windows.h>
 #endif /* WIN32 */
 
-#include "cxx_util.h"
-#include "string_util.h"
-
 namespace zorba {
 namespace os_error {
 
@@ -47,7 +47,7 @@
  * An %exception is-a std::runtime_error for reporting errors with operating
  * system or library functions.
  */
-class exception : public std::runtime_error {
+class ZORBA_DLL_PUBLIC exception : public std::runtime_error {
 public:
   /**
    * Constructs an %exception.
@@ -60,11 +60,7 @@
    * the operating system error string; if empty, no error string is used.
    */
   exception( char const *function, char const *path,
-             char const *err_string = nullptr ) :
-    std::runtime_error( make_what( function, path, err_string ) ),
-    function_( function ), path_( path )
-  {
-  }
+             char const *err_string = nullptr );
 
   /**
    * Destroys an %exception.
@@ -90,9 +86,6 @@
   }
 
 protected:
-  static std::string make_what( char const *function, char const *path,
-                                char const *err_string = nullptr );
-
   std::string function_;
   std::string path_;
 };
@@ -106,6 +99,7 @@
  * @param err_string The error string.
  * @return Returns said error string.
  */
+ZORBA_DLL_PUBLIC
 std::string format_err_string( char const *function, char const *err_string );
 
 /**
@@ -116,6 +110,7 @@
  * @param err_string The error string.
  * @return Returns said error string.
  */
+ZORBA_DLL_PUBLIC
 std::string format_err_string( char const *function, code_type code,
                                char const *err_string );
 
@@ -139,6 +134,7 @@
  * @param code The operating system error code.
  * @return Returns said error string.
  */
+ZORBA_DLL_PUBLIC
 std::string get_err_string( char const *function,
                             code_type code = get_err_code() );
 
@@ -170,8 +166,7 @@
 
 } // namespace os_error
 } // namespace zorba
-
-#endif /* ZORBA_ERROR_UTIL_H */
+#endif /* ZORBA_API_ERROR_UTIL_H */
 /*
  * Local variables:
  * mode: c++

=== removed file 'include/zorba/util/file.h'
--- include/zorba/util/file.h	2013-04-19 22:25:21 +0000
+++ include/zorba/util/file.h	1970-01-01 00:00:00 +0000
@@ -1,122 +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_FILE_H
-#define ZORBA_FILE_H
-
-#ifndef WIN32
-#include <stdint.h>
-#endif
-
-#include <cstdio>
-#include <string>
-#include <time.h>
-#include <vector>
-
-#include <zorba/config.h>
-#include <zorba/file.h>
-#include <zorba/util/path.h>
-
-namespace zorba {
-
-class ZORBA_DLL_PUBLIC file : public filesystem_path
-{
-public:
-
-  enum filetype {
-    type_invalid,
-    type_non_existent,
-    type_directory,
-    type_link,
-    type_file,
-    type_volume,
-    type_other
-  };
-
-  typedef zorba::File::FileSize_t file_size_t;
-
-protected:
-  filetype do_stat( bool follow_symlinks = true, file_size_t *size = 0 ) const;
-
-public:
-  file(const filesystem_path &path, int flags = 0);
-
-public: // common methods
-  void set_path(std::string const& _path ) { *((filesystem_path *) this) = _path; }
-  void set_filetype(filetype)   { /* do nothing */ }  // deprecated
-
-  filetype get_filetype( bool follow_symlinks = true ) const {
-    return do_stat( follow_symlinks );
-  }
-
-  bool is_directory( bool follow_symlinks = true ) const {
-    return do_stat( follow_symlinks ) == type_directory;
-  }
-
-  bool is_file( bool follow_symlinks = true ) const {
-    return do_stat( follow_symlinks ) == type_file;
-  }
-
-  bool is_link() const {
-    return do_stat( false ) == type_link;
-  }
-
-  bool is_volume( bool follow_symlinks = true ) const {
-    return do_stat( follow_symlinks ) == type_volume;
-  }
-
-  bool is_invalid() const {             // deprecated
-    return false;
-  }
-
-  bool exists( bool follow_symlinks = true ) const {
-    return do_stat( follow_symlinks ) != type_non_existent;
-  }
-
-  time_t lastModified() const;
-
-public: // file methods
-  void create();
-  void remove(bool ignore = true);
-  void rename(std::string const& newpath);
-
-  file_size_t get_size() const {
-    file_size_t size;
-    do_stat( true, &size );
-    return size;
-  }
-
-public: // directory methods
-  void mkdir();
-  void deep_mkdir();
-  void rmdir(bool ignore = true);
-  void lsdir(std::vector<std::string> &list);
-#ifndef _WIN32_WCE
-  void chdir();
-#endif
-
-  bool is_empty() const { return get_size() == 0; }
-};
-
-
-} // namespace zorba
-#endif /* ZORBA_FILE_H */
-/*
- * Local variables:
- * mode: c++
- * End:
- */
-/* vim:set et sw=2 ts=2: */

=== added file 'include/zorba/util/fs_util.h'
--- include/zorba/util/fs_util.h	1970-01-01 00:00:00 +0000
+++ include/zorba/util/fs_util.h	2013-06-11 16:49:27 +0000
@@ -0,0 +1,627 @@
+/*
+ * 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_API_FS_UTIL_H
+#define ZORBA_API_FS_UTIL_H
+
+// standard
+#include <cctype>
+#include <iostream>
+#include <string>
+#ifdef WIN32
+# include <windows.h>
+#else
+# include <dirent.h>
+# include <sys/types.h>                 /* for off_t */
+#endif /* WIN32 */
+
+#ifndef MAX_PATH
+/**
+ * Maximum path length.  This is defined under Windows to be 1024.  There is no
+ * equivalent constant/macro for *nix systems, so simply borrow Windows' value.
+ */
+#define MAX_PATH 1024
+#endif /* MAX_PATH */
+
+// Zorba
+#include <zorba/config.h>
+#include <zorba/internal/cxx_util.h>
+#include <zorba/internal/ztd.h>
+#include <zorba/util/error_util.h>
+
+namespace zorba {
+namespace fs {
+
+////////// Exceptions /////////////////////////////////////////////////////////
+
+typedef os_error::exception exception;
+
+////////// constants //////////////////////////////////////////////////////////
+
+#ifdef WIN32
+char const dir_separator = '\\';
+char const path_separator = ';';
+#else
+char const dir_separator = '/';
+char const path_separator = ':';
+#endif /* WIN32 */
+
+////////// types //////////////////////////////////////////////////////////////
+
+/**
+ * File size type.
+ */
+#ifdef WIN32
+typedef __int64 size_type;
+#else
+typedef off_t size_type;
+#endif /* WIN32 */
+
+/**
+ * File type.
+ */
+enum type {
+  non_existent,
+  directory,
+  file,
+  link,
+  volume,
+  other   // named pipe, character/block special, socket, etc.
+};
+extern char const *const type_string[];
+
+/**
+ * Emits the string representation of a file type to the given ostream.
+ *
+ * @param o The ostream to emit to.
+ * @param t The file type to emit.
+ * @return Returns \a o.
+ */
+inline std::ostream& operator<<( std::ostream &o, type t ) {
+  return o << type_string[ t ];
+}
+
+////////// Windows ////////////////////////////////////////////////////////////
+
+#ifdef WIN32
+namespace win32 {
+
+// Do not use this function directly.
+ZORBA_DLL_PUBLIC
+void make_absolute_impl( char const *path, char *abs_path );
+
+} // namespace win32
+#endif /* WIN32 */
+
+////////// Directory //////////////////////////////////////////////////////////
+
+/**
+ * Gets the current directory.
+ *
+ * @return Returns said directory.
+ * @throws ZorbaException with a diagnostic of zerr::ZOSE0004_IO_ERROR if it
+ * fails.
+ */
+ZORBA_DLL_PUBLIC
+std::string curdir();
+
+#ifdef ZORBA_WITH_FILE_ACCESS
+
+/**
+ * Creates a directory.
+ *
+ * @param path The full path of the directory to create.
+ * @throws fs::exception if the creation fails.
+ */
+ZORBA_DLL_PUBLIC
+void mkdir( char const *path );
+
+/**
+ * Creates a directory.
+ *
+ * @tparam PathStringType The \a path string type.
+ * @param path The full path of the directory to create.
+ * @throws fs::exception if the creation fails.
+ */
+template<class PathStringType> inline
+typename std::enable_if<ZORBA_HAS_C_STR(PathStringType),void>::type
+mkdir( PathStringType const &path ) {
+  mkdir( path.c_str() );
+}
+
+#endif /* ZORBA_WITH_FILE_ACCESS */
+
+////////// File deletion //////////////////////////////////////////////////////
+
+#ifdef ZORBA_WITH_FILE_ACCESS
+
+/**
+ * Removes the given file or directory.
+ *
+ * @param path The full path of the file or directory to remove.
+ * @param ignore_not_found If \c true, a non-existant \a path will not throw an
+ * exception.
+ * @return Returns \c true if removal succeeds and \c false if it fails and
+ * \a ignore_not_found is \c true.
+ * @throws fs::exception if the removal fails unless \a path is non-existant
+ * and \a ignore_not_found is \c true.
+ */
+ZORBA_DLL_PUBLIC
+bool remove( char const *path, bool ignore_not_found = false );
+
+/**
+ * Removes the given file or directory.
+ *
+ * @tparam PathStringType The \a path string type.
+ * @param path The full path of the file or directory to remove.
+ * @param ignore_not_found If \c true, a non-existant \a path will not throw an
+ * exception.
+ * @return Returns \c true if removal succeeds and \c false if it fails and
+ * \a ignore_not_found is \c true.
+ * @throws fs::exception if the removal fails unless \a path is non-existant
+ * and \a ignore_not_found is \c true.
+ */
+template<class PathStringType> inline
+typename std::enable_if<ZORBA_HAS_C_STR(PathStringType),bool>::type
+remove( PathStringType const &path, bool ignore_not_found = false ) {
+  return remove( path.c_str(), ignore_not_found );
+}
+
+#endif /* ZORBA_WITH_FILE_ACCESS */
+
+////////// File information ///////////////////////////////////////////////////
+
+/**
+ * Checks whether the given path is an absolute path.
+ *
+ * @param path The full path to check.
+ * @return Returns \c true only if the path is absolute.
+ */
+inline bool is_absolute( char const *path ) {
+#ifndef WIN32
+  return path[0] == '/';
+#else
+  //
+  // No, this should NOT also check for '/'.  The path should have been
+  // normalized for Windows first, i.e., have '/' replaced by '\'.
+  //
+  return isalpha( path[0] ) && path[1] == ':' && path[2] == '\\';
+#endif /* WIN32 */
+}
+
+/**
+ * Checks whether the given path is an absolute path.
+ *
+ * @tparam PathStringType The \a path string type.
+ * @param path The full path to check.
+ * @return Returns \c true only if the path is absolute.
+ */
+template<class PathStringType> inline
+typename std::enable_if<ZORBA_HAS_C_STR(PathStringType),bool>::type
+is_absolute( PathStringType const &path ) {
+  return is_absolute( path.c_str() );
+}
+
+/**
+ * Gets the base name of the given path name, i.e., the file name without the
+ * path leading up to it.
+ *
+ * @param path The full path to get the base name of.
+ * @return Returns the base name.  Note that if \a path is just a file name,
+ * then returns \a path.
+ */
+inline char const* base_name( char const *path ) {
+  char const *const sep = ::strrchr( path, dir_separator );
+  return sep && sep[1] ? sep + 1 : path;
+}
+
+/**
+ * Gets the base name of the given path name, i.e., the file name without the
+ * path leading up to it.
+ *
+ * @tparam PathStringType The \a path string type.
+ * @param path The full path to get the base name of.
+ * @return Returns the base name.  If \a path is just a file name, returns
+ * \a path.
+ */
+template<class PathStringType> inline
+typename std::enable_if<ZORBA_IS_STRING(PathStringType),PathStringType>::type
+base_name( PathStringType const &path ) {
+  typename PathStringType::size_type const pos = path.rfind( dir_separator );
+  return pos != PathStringType::npos && pos < path.size() - 1 ?
+    path.substr( pos + 1 ) : path;
+}
+
+/**
+ * Gets the directory name of the given path name, i.e., the path up to but not
+ * including the last path component.
+ *
+ * @param path The path to get the directory name of.
+ * @return Returns the direcory path.  If \a path is just a file name, returns
+ * <code>'.'</code>.
+ */
+inline std::string dir_name( char const *path ) {
+  if ( char const *const sep = ::strrchr( path, dir_separator ) )
+    return sep == path ?
+      std::string( 1, dir_separator ) : std::string( path, sep );
+  return std::string( 1, '.' );
+}
+
+/**
+ * Gets the directory name of the given path name, i.e., the path up to but not
+ * including the last path component.
+ *
+ * @tparam PathStringType The \a path string type.
+ * @param path The path to get the directory name of.
+ * @return Returns the direcory path.  If \a path is just a file name, returns
+ * <code>'.'</code>.
+ */
+template<class PathStringType> inline
+typename std::enable_if<ZORBA_IS_STRING(PathStringType),PathStringType>::type
+dir_name( PathStringType const &path ) {
+  typename PathStringType::size_type const pos = path.rfind( dir_separator );
+  if ( pos == PathStringType::npos )
+    return PathStringType( 1, '.' );
+  if ( pos == 0 )                       // e.g., /foo
+    return PathStringType( 1, dir_separator );
+#ifdef WIN32
+  if ( pos == 2 && is_absolute( path ) )
+    return path.substr( 0, 3 );
+#endif /* WIN32 */
+  return path.substr( 0, pos );
+}
+
+#ifdef ZORBA_WITH_FILE_ACCESS
+
+/**
+ * File information for use with get_type().
+ */
+struct info {
+  time_t    mtime;  ///< file's last modification time (in seconds since epoch)
+  size_type size;   ///< file's size in bytes
+  fs::type  type;   ///< file's type
+};
+
+/**
+ * Gets the type of the given file.
+ *
+ * @param path The full path to check.
+ * @param follow_symlink If \c true, follows symbolic links.
+ * @param pinfo A pointer to a receive file information, or \c null.
+ * @return If \a path refers to a symbolic link and \a follow_symlink is
+ * \c true, the type returned is of that to which the link refers; if \a path
+ * refers to a symbolic and \a follow_symlink is \c false, returns \c link; if
+ * \a path does not refer to a symbolic link, returns the type of \a path.
+ * @throws fs::exception for typical failures (file not found, invalid path,
+ * permission denied, etc).
+ * @throws ZorbaException with a diagnostic of zerr::ZOSE0004_IO_ERROR for
+ * unrecoverable failures.
+ */
+ZORBA_DLL_PUBLIC
+type get_type( char const *path, bool follow_symlink, info *pinfo = nullptr );
+
+/**
+ * Gets the type of the given file.
+ *
+ * @param path The full path to check.
+ * @param pinfo A pointer to a receive file information, or \c null.
+ * @return If \a path refers to a symbolic link, the type returned is of that
+ * to which the link refers; if \a path does not refer to a symbolic link,
+ * returns the type of \a path.
+ * @throws fs::exception for typical failures (file not found, invalid path,
+ * permission denied, etc).
+ * @throws ZorbaException with a diagnostic of zerr::ZOSE0004_IO_ERROR for
+ * unrecoverable failures.
+ */
+inline type get_type( char const *path, info *pinfo = nullptr ) {
+  return get_type( path, true, pinfo );
+}
+
+/**
+ * Gets the type of the given file.
+ *
+ * @tparam PathStringType The \a path string type.
+ * @param path The full path to check.
+ * @param follow_symlink If \c true, follows symbolic links.
+ * @param pinfo A pointer to a receive file information, or \c null.
+ * @return If \a path refers to a symbolic link and \a follow_symlink is
+ * \c true, the type returned is of that to which the link refers; if \a path
+ * refers to a symbolic and \a follow_symlink is \c false, returns \c link; if
+ * \a path does not refer to a symbolic link, returns the type of \a path.
+ * @throws fs::exception for typical failures (file not found, invalid path,
+ * permission denied, etc).
+ * @throws ZorbaException with a diagnostic of zerr::ZOSE0004_IO_ERROR for
+ * unrecoverable failures.
+ */
+template<class PathStringType> inline
+typename std::enable_if<ZORBA_HAS_C_STR(PathStringType),type>::type
+get_type( PathStringType const &path, bool follow_symlink,
+          info *pinfo = nullptr ) {
+  return get_type( path.c_str(), follow_symlink, pinfo );
+}
+
+/**
+ * Gets the type of the given file.
+ *
+ * @tparam PathStringType The \a path string type.
+ * @param path The full path to check.
+ * @param pinfo A pointer to a receive file information, or \c null.
+ * @return If \a path refers to a symbolic link, the type returned is of that
+ * to which the link refers; if \a path does not refer to a symbolic link,
+ * returns the type of \a path.
+ * @throws fs::exception for typical failures (file not found, invalid path,
+ * permission denied, etc).
+ * @throws ZorbaException with a diagnostic of zerr::ZOSE0004_IO_ERROR for
+ * unrecoverable failures.
+ */
+template<class PathStringType> inline
+typename std::enable_if<ZORBA_HAS_C_STR(PathStringType),type>::type
+get_type( PathStringType const &path, info *pinfo = nullptr ) {
+  return get_type( path.c_str(), pinfo );
+}
+
+#endif /* ZORBA_WITH_FILE_ACCESS */
+
+////////// Directory iteration ////////////////////////////////////////////////
+
+#ifdef ZORBA_WITH_FILE_ACCESS
+
+/**
+ * An %fs::iterator iterates over the entries in a directory.
+ */
+class ZORBA_DLL_PUBLIC iterator {
+public:
+  /**
+   * Information for a directory entry.
+   */
+  struct entry {
+    char const *name;
+    fs::type type;
+  };
+
+  /**
+   * Constructs an %iterator.
+   *
+   * @param path The full path to the directory to iterate over.
+   * @throws fs::exception if the construction failed, e.g., path not found.
+   */
+  iterator( char const *path ) : dir_path_( path ) {
+    ctor_impl();
+  }
+
+  /**
+   * Constructs an %iterator.
+   *
+   * @tparam PathStringType The \a path string type.
+   * @param path The full path to the directory to iterate over.
+   * @throws fs::exception if the construction failed, e.g., path not found.
+   */
+  template<class PathStringType>
+  iterator( PathStringType const &path,
+            typename std::enable_if<ZORBA_HAS_C_STR(PathStringType)
+                                   >::type* = 0 ) : dir_path_( path.c_str() ) {
+    ctor_impl();
+  }
+
+  /**
+   * Destroys this %iterator.
+   */
+  ~iterator();
+
+  /**
+   * Attempts to get the next directory entry.
+   *
+   * @return Returns \c true only if there is a next directory.
+   */
+  bool next();
+
+  /**
+   * Gets the current directory entry.  The entry is undefined unless next()
+   * returned \c true.
+   *
+   * @return Returns said entry.
+   */
+  entry const& operator*() const {
+    return entry_;
+  }
+
+  /**
+   * Gets the current directory entry.  The entry is undefined unless next()
+   * returned \c true.
+   *
+   * @return Returns said entry.
+   */
+  entry const* operator->() const {
+    return &entry_;
+  }
+
+  /**
+   * Gets the directory's path.
+   *
+   * @return Returns said path.
+   */
+  char const* path() const {
+    return dir_path_.c_str();
+  }
+
+  /**
+   * Resets this iterator to the beginning.
+   */
+  void reset();
+
+private:
+  std::string dir_path_;
+  entry entry_;
+#ifndef WIN32
+  DIR *dir_;
+#else
+  HANDLE dir_;
+  bool dir_is_empty_;
+  WIN32_FIND_DATA ent_data_;
+  char entry_name_buf_[ MAX_PATH ];
+  bool use_first_;
+
+  void win32_opendir( char const *path );
+  void win32_closedir();
+#endif /* WIN32 */
+
+  void ctor_impl();
+
+  // forbid
+  iterator( iterator const& );
+  iterator& operator=( iterator const& );
+};
+
+#endif /* ZORBA_WITH_FILE_ACCESS */
+
+////////// Path normalization /////////////////////////////////////////////////
+
+/**
+ * Gets the normalized path of the given path.  A normalized path is one that:
+ *  - has \c file:// URIs converted to paths
+ *  - has directory separators corrected for the host operating system
+ *  - has adjacent directory separators combined, e.g., \c /a//b becomes \c /a/b
+ *  - has \c ./ removed, e.g., \c /a/./b becomes \c /a/b
+ *  - has \c ../ removed, e.g., \c /a/b/../c becomes \c /a/c
+ *
+ * @param path The path to normalize.
+ * @param base The base path.  If not empty, is prepended to \a path.
+ * @return Returns the normalized path.
+ * @throws std::invalid_argument for malformed paths.
+ */
+ZORBA_DLL_PUBLIC
+std::string normalize_path( char const *path, char const *base = nullptr );
+
+/**
+ * Gets the normalized path of the given path.  A normalized path is one that:
+ *  - has \c file:// URIs converted to paths
+ *  - has directory separators corrected for the host operating system
+ *  - has adjacent directory separators combined, e.g., \c /a//b becomes \c /a/b
+ *  - has \c ./ removed, e.g., \c /a/./b becomes \c /a/b
+ *  - has \c ../ removed, e.g., \c /a/b/../c becomes \c /a/c
+ *
+ * @tparam PathStringType The \a path string type.
+ * @param path The path to normalize.
+ * @return Returns the normalized path.
+ * @throws std::invalid_argument for malformed paths.
+ */
+template<class PathStringType> inline
+typename std::enable_if<ZORBA_HAS_C_STR(PathStringType),std::string>::type
+normalize_path( PathStringType const &path ) {
+  return normalize_path( path.c_str() );
+}
+
+/**
+ * Gets the normalized path of the given path.  A normalized path is one that:
+ *  - has \c file:// URIs converted to paths
+ *  - has directory separators corrected for the host operating system
+ *  - has adjacent directory separators combined, e.g., \c /a//b becomes \c /a/b
+ *  - has \c ./ removed, e.g., \c /a/./b becomes \c /a/b
+ *  - has \c ../ removed, e.g., \c /a/b/../c becomes \c /a/c
+ *
+ * @tparam PathStringType The \a path string type.
+ * @tparam BaseStringType The \a base string type.
+ * @param path The path to normalize.
+ * @param base The base path.  If not empty, is prepended to \a path.
+ * @return Returns the normalized path.
+ * @throws std::invalid_argument for malformed paths.
+ */
+template<class PathStringType,class BaseStringType> inline
+typename std::enable_if<ZORBA_HAS_C_STR(PathStringType)
+                     && ZORBA_HAS_C_STR(BaseStringType),
+                        std::string>::type
+normalize_path( PathStringType const &path, BaseStringType const &base ) {
+  return normalize_path( path.c_str(), base.c_str() );
+}
+
+////////// Path manipulation //////////////////////////////////////////////////
+
+/**
+ * Appends a path component onto another path ensuring that exactly one
+ * separator is used.
+ *
+ * @tparam PathStringType1 The \a path1 string type.
+ * @param path1 The path to append to.
+ * @param path2 The path to append.
+ */
+template<class PathStringType1> inline
+typename std::enable_if<ZORBA_IS_STRING(PathStringType1),void>::type
+append( PathStringType1 &path1, char const *path2 ) {
+  if ( !path1.empty() && path1[ path1.size() - 1 ] != dir_separator
+       && path2[0] != dir_separator ) {
+    path1 += dir_separator;
+  }
+  path1 += path2;
+}
+
+/**
+ * Appends a path component onto another path.
+ *
+ * @tparam PathStringType1 The \a path1 string type.
+ * @tparam PathStringType2 The \a path2 string type.
+ * @param path1 The path to append to.
+ * @param path2 The path to append.
+ */
+template<class PathStringType1,class PathStringType2> inline
+typename std::enable_if<ZORBA_IS_STRING(PathStringType1)
+                     && ZORBA_HAS_C_STR(PathStringType2),
+                        void>::type
+append( PathStringType1 &path1, PathStringType2 const &path2 ) {
+  append( path1, path2.c_str() );
+}
+
+/**
+ * Makes a relative path into an absolute path.
+ *
+ * @param path The path to make absolute.  It is assumes that the buffer to
+ * which \a path points is at least MAX_PATH bytes.
+ */
+ZORBA_DLL_PUBLIC
+void make_absolute( char *path );
+
+/**
+ * Makes a relative path into an absolute path.
+ *
+ * @tparam PathStringType The \a path string type.
+ * @param path The path to make absolute.
+ */
+template<class PathStringType> inline
+typename std::enable_if<ZORBA_IS_STRING(PathStringType),void>::type
+make_absolute( PathStringType &path ) {
+  if ( !is_absolute( path ) ) {
+#ifndef WIN32
+    typedef typename PathStringType::size_type size_type;
+    path.insert( static_cast<size_type>(0), 1, '/' );
+    path.insert( 0, curdir().c_str() );
+#else
+    char temp[ MAX_PATH ];
+    win32::make_absolute_impl( path.c_str(), temp );
+    path = temp;
+#endif /* WIN32 */
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace fs
+} // namespace zorba
+#endif /* ZORBA_API_FS_UTIL_H */
+/*
+* Local variables:
+* mode: c++
+* End:
+*/
+/* vim:set et sw=2 ts=2: */

=== removed file 'include/zorba/util/path.h'
--- include/zorba/util/path.h	2013-02-07 17:24:36 +0000
+++ include/zorba/util/path.h	1970-01-01 00:00:00 +0000
@@ -1,105 +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_PATH_H
-#define ZORBA_PATH_H
-
-#include <string>
-#include <iostream>
-#include <zorba/config.h>
-
-namespace zorba {
-
-class ZORBA_DLL_PUBLIC filesystem_path {
-private:
-  std::string path;
-
-  void canonicalize ();
-
-protected:
-  std::string
-    getPathString() const;
-
-public:
-  enum flags_t {
-    CONVERT_SLASHES = 1,
-    RESOLVE         = 2
-  };
-
-public:
-
-  /**
-    * @brief Utility function to normalize a path as a system conforming
-    *        path and optionally resolve it.
-    *
-    * This function takes a path (as system path, file uri) and normalizes it.
-    * It converts file URIs to system paths and replaces '/' and '\' to the
-    * platform specific directory separator ('\' on Windows, '/' on UNIX like
-    * operating systems like Linux and Mac OS X).
-    * If the parameter base is set, it also resolves the path.
-    *
-    * @param in The path to normalize.
-    * @param base The base name to resolve a path (default = ""), if this is the
-    *             empty string, it does not resolve anything, but only normalizes
-    *             the path.
-    * @return Returns a normalized and optionally a resolved path.
-    */
-  static std::string normalize_path(std::string const &in, std::string const &base = "");
-
-  // from current dir
-  filesystem_path ();
-
-  filesystem_path (const std::string &path_, int flags = 0);
-
-  filesystem_path (const filesystem_path &base, const filesystem_path &rel) {
-    if (rel.is_complete ())
-      *this = rel;
-    else {
-      *this = base.get_path () + get_directory_separator () + rel.get_path ();
-      canonicalize ();
-    }
-  }
-
-  filesystem_path &operator = (const std::string &p_)
-  { path = p_; canonicalize (); return *this; }
-
-  const std::string &get_path () const { return path; }
-  const char *c_str () const { return path.c_str (); }
-  operator const std::string & () const { return path; }
-
-  bool is_complete () const;
-  bool is_root () const;
-  void resolve_relative ();
-
-  filesystem_path branch_path () const;
-
-  static const char *get_directory_separator ();
-  static const char *get_path_separator ();
-};
-
-inline std::ostream &operator<< (std::ostream &os, const filesystem_path &p) {
-  return os << p.get_path ();
-}
-
-
-} // namespace zorba
-#endif /* ZORBA_PATH_H */
-/*
-* Local variables:
-* mode: c++
-* End:
-*/
-/* vim:set et sw=2 ts=2: */

=== added file 'include/zorba/util/stream_util.h'
--- include/zorba/util/stream_util.h	1970-01-01 00:00:00 +0000
+++ include/zorba/util/stream_util.h	2013-06-11 16:49:27 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#ifndef ZORBA_API_STREAM_UTIL_H
+#define ZORBA_API_STREAM_UTIL_H
+
+#include <iostream>
+
+#include <zorba/config.h>
+
+namespace zorba {
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Skips the UTF-8 byte order mark (BOM), if any.
+ *
+ * @param is The istream to read.
+ * @return Returns \c true only if a BOM was present and skipped.
+ */
+ZORBA_DLL_PUBLIC
+bool skip_utf8_bom( std::istream &is );
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace zorba
+
+#endif /* ZORBA_API_STREAM_UTIL_H */
+/*
+ * Local variables:
+ * mode: c++
+ * End:
+ */
+/* vim:set et sw=2 ts=2: */

=== modified file 'modules/ExternalModules.conf'
--- modules/ExternalModules.conf	2013-05-29 00:52:05 +0000
+++ modules/ExternalModules.conf	2013-06-11 16:49:27 +0000
@@ -27,9 +27,10 @@
 #       currently only works for bzr, since svn tags are just different URLS)
 
 archive         bzr  lp:zorba/archive-module          zorba-2.9
-csv             bzr  lp:zorba/csv-module              zorba-2.9
-data-cleaning   bzr  lp:zorba/data-cleaning-module    zorba-2.9
-data-formatting bzr  lp:zorba/data-formatting-module  zorba-2.9.1
+#csv             bzr  lp:zorba/csv-module
+csv             bzr  lp:~zorba-coders/zorba/bug-1180220-util-jvm
+data-cleaning   bzr  lp:zorba/data-cleaning-module
+data-formatting bzr  lp:zorba/data-formatting-module
 excel           bzr  lp:zorba/excel-module            zorba-2.9
 info-extraction bzr  lp:zorba/info-extraction-module  zorba-2.9
 geo             bzr  lp:zorba/geo-module              zorba-2.9
@@ -38,17 +39,17 @@
 html            bzr  lp:zorba/html-module             zorba-2.9
 http-client     bzr  lp:zorba/http-client-module      zorba-2.9
 image           bzr  lp:zorba/image-module            zorba-2.9
-jdbc            bzr  lp:zorba/jdbc-module             zorba-2.9
+jdbc            bzr  lp:zorba/jdbc-module
 languages       bzr  lp:zorba/languages-module        zorba-2.9
-oracle-nosql-db bzr  lp:zorba/oracle-nosql-db-module  zorba-2.9
+oracle-nosql-db bzr  lp:zorba/oracle-nosql-db-module
 oauth           bzr  lp:zorba/oauth-module            zorba-2.9
-process         bzr  lp:zorba/process-module          zorba-2.9
-read-pdf        bzr  lp:zorba/read-pdf-module         zorba-2.9.1
+process         bzr  lp:zorba/process-module
+read-pdf        bzr  lp:zorba/read-pdf-module
 security        bzr  lp:zorba/security-module         zorba-2.9
 system          bzr  lp:zorba/system-module           zorba-2.9
 email           bzr  lp:zorba/email-module            zorba-2.9
-util-jvm        bzr  lp:zorba/util-jvm-module         zorba-2.9.1
-schema-tools    bzr  lp:zorba/schema-tools-module     zorba-2.9.1
+util-jvm        bzr  lp:zorba/util-jvm-module
+schema-tools    bzr  lp:zorba/schema-tools-module
 stack           bzr  lp:zorba/stack-module            zorba-2.9
 queue           bzr  lp:zorba/queue-module            zorba-2.9
 couchbase       bzr  lp:zorba/couchbase-module        zorba-2.9

=== modified file 'modules/org/expath/ns/file.xq.src/file.cpp'
--- modules/org/expath/ns/file.xq.src/file.cpp	2013-04-19 22:25:21 +0000
+++ modules/org/expath/ns/file.xq.src/file.cpp	2013-06-11 16:49:27 +0000
@@ -16,25 +16,28 @@
 
 #include "file.h"
 
+// standard
 #include <fstream>
 #include <memory>
 #include <sstream>
 #include <stdexcept>
 
+// Zorba
 #include <zorba/base64.h>
+#include <zorba/diagnostic_list.h>
 #include <zorba/empty_sequence.h>
-#include <zorba/diagnostic_list.h>
-#include <zorba/file.h>
 #include <zorba/serializer.h>
 #include <zorba/singleton_item_sequence.h>
-#include <zorba/util/path.h>
+#include <zorba/transcode_stream.h>
 #include <zorba/user_exception.h>
-#include <zorba/transcode_stream.h>
+#include <zorba/util/fs_util.h>
+#include <zorba/util/stream_util.h>
 
+// local
 #include "file_module.h"
 
-
-namespace zorba { namespace filemodule {
+namespace zorba {
+namespace filemodule {
 
 //*****************************************************************************
 
@@ -45,129 +48,87 @@
 
 ItemSequence_t
 CreateDirectoryFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String lFileStr = getFilePathString(aArgs, 0);
-  File_t lFile = File::createFile(lFileStr.c_str());
-
-  // precondition
-  if (lFile->isFile()) {
-    raiseFileError("FOFL0002", "A file already exists at this path", lFile->getFilePath());
-  }
-
-  // actual mkdir
+  String const path( getFilePathString( aArgs, 0 ) );
+
+  if ( fs::get_type( path ) )
+    raiseFileError( "FOFL0002", "file already exists", path );
+
   try {
-    lFile->mkdir(true);
-  } catch (ZorbaException const& ze) {
-    std::stringstream lSs;
-    lSs << "An unknown error occured: " << ze.what() << "Can not create directory";
-    raiseFileError("FOFL9999", lSs.str(), lFile->getFilePath());
-  } catch (...) {
-    //assert(false); if this happens errors are not proprly thrown
-    raiseFileError("FOFL9999", "Can not create directory", lFile->getFilePath());
-  }
-
-  // postcondition
-  if (!(lFile->isDirectory())) {
-    raiseFileError("FOFL9999", "Can not create directory", lFile->getFilePath());
-  }
-
-  return ItemSequence_t(new EmptySequence());
+    fs::mkdir( path );
+  }
+  catch ( std::exception const &e ) {
+    throw raiseFileError( "FOFL9999", e.what(), path );
+  }
+
+  return ItemSequence_t( new EmptySequence() );
 }
 
 //*****************************************************************************
 
-DeleteFileImplFunction::DeleteFileImplFunction(const FileModule* aModule)
-  : FileFunction(aModule)
+DeleteFileImplFunction::DeleteFileImplFunction(const FileModule* aModule) :
+  FileFunction(aModule)
 {
 }
 
 ItemSequence_t
 DeleteFileImplFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String lFileStr = getFilePathString(aArgs, 0);
-  File_t lFile = File::createFile(lFileStr.c_str());
-
-  // precondition
-  if (!lFile->exists( false )) {
-    raiseFileError("FOFL0001", "A file or directory does not exist at this path", lFile->getFilePath());
-  }
-
-  // actual remove
+  String const path( getFilePathString( aArgs, 0 ) );
+
+  if ( !fs::get_type( path, false ) )
+    raiseFileError( "FOFL0001", "file not found", path );
+
   try {
-    lFile->remove();
-  } catch (ZorbaException const& ze) {
-    std::stringstream lSs;
-    lSs << "An unknown error occured: " << ze.what() << "Can not delete file";
-    raiseFileError("FOFL9999", lSs.str(), lFile->getFilePath());
-  } catch (...) {
-    //assert(false); if this happens errors are not proprly thrown
-    raiseFileError("FOFL9999", "Can not delete directory", lFile->getFilePath());
-  }
-
-  // postcondition
-  if (lFile->exists( false )) {
-    raiseFileError("FOFL9999", "The file at this path could not be deleted", lFile->getFilePath());
-  }
-
-  return ItemSequence_t(new EmptySequence());
+    fs::remove( path );
+  }
+  catch ( std::exception const &e ) {
+    throw raiseFileError( "FOFL9999", e.what(), path );
+  }
+
+  return ItemSequence_t( new EmptySequence() );
 }
 
 //*****************************************************************************
 
-ReadBinaryFunction::ReadBinaryFunction(const FileModule* aModule)
-  : FileFunction(aModule)
+ReadBinaryFunction::ReadBinaryFunction( FileModule const *aModule ) :
+  FileFunction( aModule )
 {
 }
 
 ItemSequence_t
 ReadBinaryFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String lFileStr = getFilePathString(aArgs, 0);
-  File_t lFile = File::createFile(lFileStr.c_str());
-
-  // preconditions
-  if (!lFile->exists()) {
-    raiseFileError("FOFL0001", "A file does not exist at this path", lFile->getFilePath());
-  }
-  if (lFile->isDirectory()) {
-    raiseFileError("FOFL0004", "The given path points to a directory", lFile->getFilePath());
-  }
-
-  // actual read
-  Item lItem;
+  String const path( getFilePathString( aArgs, 0 ) );
+
+  fs::type const fs_type = fs::get_type( path );
+  if ( !fs_type )
+    raiseFileError( "FOFL0001", "file not found", path );
+  if ( fs_type != fs::file )
+    raiseFileError( "FOFL0004", "not a plain file", path );
+
   try {
-    std::unique_ptr<std::ifstream> lInStream;
-    lInStream.reset( new std::ifstream() );
-    lFile->openInputStream(*lInStream.get(), true, false);
-
-    lItem = theModule->getItemFactory()->createStreamableBase64Binary(
-        *lInStream.release(), &FileModule::streamReleaser, true
-      );
-
-  } catch (ZorbaException const& ze) {
-    std::stringstream lSs;
-    lSs << "An unknown error occured: " << ze.what() << "Can not read file";
-    raiseFileError("FOFL9999", lSs.str(), lFile->getFilePath());
-  } catch (...) {
-    //assert(false); if this happens errors are not proprly thrown
-    raiseFileError("FOFL9999", "Can not read file", lFile->getFilePath());
-  }
-
-  if (lItem.isNull()) {
-    Item lQName = theModule->getItemFactory()->createQName("http://www.w3.org/2005/xqt-errors", "err", "XPTY0004");
-    throw USER_EXCEPTION(lQName, "Error while building the base64binary item." );
-  }
-
-  return ItemSequence_t(new SingletonItemSequence(lItem));
+    std::unique_ptr<std::ifstream> pin(
+      new std::ifstream( path.c_str(), std::ios_base::binary )
+    );
+    Item item = theModule->getItemFactory()->createStreamableBase64Binary(
+      *pin, &FileModule::streamReleaser, true
+    );
+    pin.release();
+    return ItemSequence_t( new SingletonItemSequence( item ) );
+  }
+  catch ( std::exception const &e ) {
+    throw raiseFileError( "FOFL9999", e.what(), path );
+  }
 }
 
 //*****************************************************************************
@@ -179,47 +140,43 @@
 
 ItemSequence_t
 ReadTextFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String lFileStr = getFilePathString(aArgs, 0);
-  File_t lFile = File::createFile(lFileStr.c_str());
-  String lEncoding("UTF-8");
-
-  // preconditions
-  if (!lFile->exists()) {
-    raiseFileError("FOFL0001", "A file does not exist at this path", lFile->getFilePath());
-  }
-  if (lFile->isDirectory()) {
-    raiseFileError("FOFL0004", "The given path points to a directory", lFile->getFilePath());
-  }
-
-  if (aArgs.size() == 2) {
-    lEncoding = getEncodingArg(aArgs, 1);
-  }
+  String const path( getFilePathString( aArgs, 0 ) );
+  String lEncoding( "UTF-8" );
+
+  fs::type const fs_type = fs::get_type( path );
+  if ( !fs_type )
+    raiseFileError( "FOFL0001", "file not found", path );
+  if ( fs_type != fs::file )
+    raiseFileError( "FOFL0004", "not a plain file", path );
+
+  if ( aArgs.size() == 2 )
+    lEncoding = getEncodingArg( aArgs, 1 );
   
   zorba::Item lResult;
-  std::unique_ptr<std::ifstream> lInStream;
-  if ( transcode::is_necessary( lEncoding.c_str() ) )
-  {
+
+  std::unique_ptr<std::ifstream> pin;
+  if ( transcode::is_necessary( lEncoding.c_str() ) ) {
     try {
-      lInStream.reset( new transcode::stream<std::ifstream>(lEncoding.c_str()) );
-    } catch (std::invalid_argument const&)
-    {
-      raiseFileError("FOFL0006", "Unsupported encoding", lEncoding.c_str());
-    }
-  }
-  else
-  {
-    lInStream.reset( new std::ifstream() );
-  }
-  lFile->openInputStream(*lInStream.get(), false, true);
+      pin.reset( new transcode::stream<std::ifstream>( lEncoding.c_str() ) );
+    }
+    catch ( std::exception const &e ) {
+      throw raiseFileError("FOFL0006", e.what(), lEncoding.c_str() );
+    }
+  } else
+    pin.reset( new std::ifstream() );
+
+  pin->open( path.c_str() );
+  skip_utf8_bom( *pin );
   lResult = theModule->getItemFactory()->createStreamableString(
-      *lInStream.release(), &FileModule::streamReleaser, lFileStr.c_str(), true
-    );
-  return ItemSequence_t(new SingletonItemSequence(lResult));
+    *pin, &FileModule::streamReleaser, path.c_str(), true
+  );
+  pin.release();
 
+  return ItemSequence_t( new SingletonItemSequence( lResult ) );
 }
 
 //*****************************************************************************
@@ -231,34 +188,30 @@
 
 ItemSequence_t
 ReadTextLinesFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String lFileStr = getFilePathString(aArgs, 0);
-  File_t lFile = File::createFile(lFileStr.c_str());
-  String lEncoding("UTF-8");
-
-  // preconditions
-  if (!lFile->exists()) {
-    raiseFileError("FOFL0001", "A file does not exist at this path", lFile->getFilePath());
-  }
-  if (lFile->isDirectory()) {
-    raiseFileError("FOFL0004", "The given path points to a directory", lFile->getFilePath());
-  }
-
-  lEncoding = getEncodingArg(aArgs, 1);
-
-  return ItemSequence_t(new LinesItemSequence(lFile, lEncoding, this));
+  String const path( getFilePathString( aArgs, 0 ) );
+  String const lEncoding( getEncodingArg( aArgs, 1 ) );
+
+  fs::type const fs_type = fs::get_type( path );
+  if ( !fs_type )
+    raiseFileError( "FOFL0001", "file not found", path );
+  if ( fs_type != fs::file )
+    raiseFileError( "FOFL0004", "not a plain file", path );
+
+  return ItemSequence_t( new LinesItemSequence( path, lEncoding, this ) );
 }
 
 ReadTextLinesFunction::LinesItemSequence::LinesItemSequence(
-    const File_t& aFile,
-    const String& aEncoding,
-    const ReadTextLinesFunction* aFunc)
-  : theFile(aFile),
-    theEncoding(aEncoding),
-    theFunc(aFunc)
+  String const &aFile,
+  String const &aEncoding,
+  ReadTextLinesFunction const *aFunc
+) :
+  theFile( aFile ),
+  theEncoding( aEncoding ),
+  theFunc( aFunc )
 {
 }
 
@@ -266,18 +219,19 @@
 ReadTextLinesFunction::LinesItemSequence::getIterator()
 {
   return new ReadTextLinesFunction::LinesItemSequence::LinesIterator(
-      theFile, theEncoding, theFunc
-    );
+    theFile, theEncoding, theFunc
+  );
 }
 
 ReadTextLinesFunction::LinesItemSequence::LinesIterator::LinesIterator(
-    const File_t& aFile,
-    const String& aEncoding,
-    const ReadTextLinesFunction* aFunc)
-  : theFile(aFile),
-    theEncoding(aEncoding),
-    theFunc(aFunc),
-    theStream(0)
+  String const &aFile,
+  String const &aEncoding,
+  ReadTextLinesFunction const *aFunc
+) :
+  theFile(aFile),
+  theEncoding(aEncoding),
+  theFunc(aFunc),
+  theStream(0)
 {
 }
 
@@ -289,42 +243,32 @@
 void
 ReadTextLinesFunction::LinesItemSequence::LinesIterator::open()
 {
-  if ( transcode::is_necessary( theEncoding.c_str() ) )
-  {
-    try
-    {
-      theStream = new transcode::stream<std::ifstream>(theEncoding.c_str());
-    }
-    catch (std::invalid_argument const& e)
-    {
-      theFunc->raiseFileError("FOFL0006", "Unsupported encoding", theEncoding.c_str());
-    }
-  }
-  else
-  {
+  if ( transcode::is_necessary( theEncoding.c_str() ) ) {
+    try {
+      theStream = new transcode::stream<std::ifstream>( theEncoding.c_str() );
+    }
+    catch ( std::invalid_argument const &e ) {
+      theFunc->raiseFileError( "FOFL0006", e.what(), theEncoding.c_str() );
+    }
+  } else
     theStream = new std::ifstream();
-  }
-  theFile->openInputStream(*theStream, false, true);
+
+  theStream->open( theFile.c_str() );
 }
 
 bool
 ReadTextLinesFunction::LinesItemSequence::LinesIterator::next(Item& aRes)
 {
-  if (!theStream || !theStream->good())
+  if ( !theStream || !theStream->good() )
     return false;
 
-  std::string lStr;
-  getline(*theStream, lStr);
+  std::string s;
+  getline( *theStream, s );
+  if ( theStream->bad() )
+    return false;
   
-  if (theStream->bad())
-  {
-    return false;
-  }
-  else
-  {
-    aRes = theFunc->theModule->getItemFactory()->createString(lStr);
-    return true;
-  }
+  aRes = theFunc->theModule->getItemFactory()->createString( s );
+  return true;
 }
 
 void
@@ -342,220 +286,176 @@
 
 //*****************************************************************************
 
-ExistsFunction::ExistsFunction(const FileModule* aModule)
-  : FileFunction(aModule)
+ExistsFunction::ExistsFunction(const FileModule* aModule) :
+  FileFunction( aModule )
 {
 }
 
 ItemSequence_t
 ExistsFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String const lFileStr = getFilePathString(aArgs, 0);
-  bool const lFollowSymlinks = getItem(aArgs, 1).getBooleanValue();
-
-  File_t lFile = File::createFile(lFileStr.c_str());
-  bool const lFileExists = lFile->exists(lFollowSymlinks);
-
-  return ItemSequence_t(new SingletonItemSequence(
-      theModule->getItemFactory()->createBoolean(lFileExists)));
+  String const path = getFilePathString( aArgs, 0 );
+  bool const follow_symlink = getItem( aArgs, 1 ).getBooleanValue();
+  bool const exists = !!fs::get_type( path, follow_symlink );
+  return ItemSequence_t(
+    new SingletonItemSequence(
+      theModule->getItemFactory()->createBoolean( exists )
+    )
+  );
 }
 
 //*****************************************************************************
 
-IsDirectoryFunction::IsDirectoryFunction(const FileModule* aModule)
-  : FileFunction(aModule)
+IsDirectoryFunction::IsDirectoryFunction( FileModule const *aModule ) :
+  FileFunction( aModule )
 {
 }
 
 ItemSequence_t
 IsDirectoryFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  bool   lResult = false;
-  String lFileStr = getFilePathString(aArgs, 0);
-
-  File_t lFile = File::createFile(lFileStr.c_str());
-  if (lFile->isDirectory()) {
-    lResult = true;
-  }
-  return ItemSequence_t(new SingletonItemSequence(
-      theModule->getItemFactory()->createBoolean(lResult)));
+  String const path( getFilePathString( aArgs, 0 ) );
+  bool const is_directory = fs::get_type( path ) == fs::directory;
+  return ItemSequence_t(
+    new SingletonItemSequence(
+      theModule->getItemFactory()->createBoolean( is_directory )
+    )
+  );
 }
 
 //*****************************************************************************
 
-IsFileFunction::IsFileFunction(const FileModule* aModule)
-  : FileFunction(aModule)
+IsFileFunction::IsFileFunction( FileModule const *aModule ) :
+  FileFunction( aModule )
 {
 }
 
 ItemSequence_t
 IsFileFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  bool   lResult = false;
-  String lFileStr = getFilePathString(aArgs, 0);
-
-  File_t lFile = File::createFile(lFileStr.c_str());
-  if (lFile->isFile()) {
-    lResult = true;
-  }
-  return ItemSequence_t(new SingletonItemSequence(
-      theModule->getItemFactory()->createBoolean(lResult)));
+  String const path( getFilePathString( aArgs, 0 ) );
+  bool const is_file = fs::get_type( path ) == fs::file;
+  return ItemSequence_t(
+    new SingletonItemSequence(
+      theModule->getItemFactory()->createBoolean( is_file )
+    )
+  );
 }
 
 //*****************************************************************************
 
-IsSymlinkFunction::IsSymlinkFunction(const FileModule* aModule)
-  : FileFunction(aModule)
+IsSymlinkFunction::IsSymlinkFunction( FileModule const *aModule ) :
+  FileFunction( aModule )
 {
 }
 
 ItemSequence_t
 IsSymlinkFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                 aSctxCtx,
-  const DynamicContext*                aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  bool   lResult = false;
-  String lFileStr = getFilePathString(aArgs, 0);
-
-  File_t lFile = File::createFile(lFileStr.c_str());
-  if (lFile->isLink()) {
-    lResult = true;
-  }
-  return ItemSequence_t(new SingletonItemSequence(
-      theModule->getItemFactory()->createBoolean(lResult)));
+  String const path( getFilePathString( aArgs, 0 ) );
+  bool const is_symlink = fs::get_type( path, false ) == fs::link;
+  return ItemSequence_t(
+    new SingletonItemSequence(
+      theModule->getItemFactory()->createBoolean( is_symlink )
+    )
+  );
 }
 
 //*****************************************************************************
 
-CopyFileImplFunction::CopyFileImplFunction(const FileModule* aModule)
-  : FileFunction(aModule)
+CopyFileImplFunction::CopyFileImplFunction( FileModule const *aModule ) :
+  FileFunction( aModule )
 {
 }
 
 ItemSequence_t
 CopyFileImplFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String lSrcFileStr = getFilePathString(aArgs, 0);
-  File_t lSrcFile = File::createFile(lSrcFileStr.c_str());
-  String lDstStr = getFilePathString(aArgs, 1);
-  File_t lDst = File::createFile(lDstStr.c_str());
-
-  // preconditions
-  if (!lSrcFile->exists()) {
-    raiseFileError("FOFL0001", "A file does not exist at this path", lSrcFile->getFilePath());
-  }
-  // is this a file? (the recursive version is implemented in XQuery)
-  if (lSrcFile->isDirectory()) {
-    raiseFileError("FOFL0004", "This operation is non-recursive. The source path points to a directory", lSrcFile->getFilePath());
-  }
-
-  // do we copy into a directory?
-  if (lDst->isDirectory()) {
-    lDstStr = lDst->getFilePath();
-    String lSrcPath = lSrcFile->getFilePath();
-    int lLastSep = lSrcPath.rfind(File::getDirectorySeparator());
-    String lName = lSrcPath.substr(lLastSep);
-    lDstStr = lDstStr.append(lName.c_str());
-    lDst = File::createFile(lDstStr.c_str());
-  }
-
-  // is the destination still is a directory?
-  if (lDst->isDirectory()) {
-    raiseFileError("FOFL0002", "The destination path already exists", lSrcFile->getFilePath());
-  }
-
-  // do we copy a file to its own location?
-  if (lSrcFile->getFilePath() == lDst->getFilePath()) {
-    raiseFileError("FOFL9999", "The source and destination paths can not point to the same file", lSrcFile->getFilePath());
-  }
-
-  // actual copy
+  String const src_path( getFilePathString( aArgs, 0 ) );
+  String dst_path( getFilePathString( aArgs, 1 ) );
+
+  fs::type const src_type = fs::get_type( src_path );
+  if ( !src_type )
+    raiseFileError( "FOFL0001", "file not found", src_path );
+  if ( src_type != fs::file )
+    raiseFileError( "FOFL0004", "not a plain file", src_path );
+
+  fs::type dst_type = fs::get_type( dst_path );
+  if ( dst_type == fs::directory ) {    // we are copying into a directory
+    fs::append( dst_path, fs::base_name( src_path ) );
+    dst_type = fs::get_type( dst_path );
+    if ( dst_type == fs::directory )
+      raiseFileError( "FOFL0002", "path already exists", dst_path );
+  }
+
+  if ( src_path == dst_path )
+    raiseFileError( "FOFL9999", "source and destination paths must not be equal", src_path );
+
   try {
-
-    // open the output stream in the desired write mode
-    std::ifstream lInStream;
-    std::ofstream lOutStream;
-    lSrcFile->openInputStream(lInStream, true, false);
-    lDst->openOutputStream(lOutStream, true, false);
-
-    // copy the data
-    char lBuf[1024];
-    while (!lInStream.eof()) {
-      lInStream.read(lBuf, 1024);
-      lOutStream.write(lBuf, lInStream.gcount());
+    std::ifstream fin( src_path.c_str(), std::ios_base::binary );
+    std::ofstream fout( dst_path.c_str(), std::ios_base::binary | std::ios_base::trunc );
+    char buf[ 8192 ];
+    while ( !fin.eof() ) {
+      fin.read( buf, sizeof buf );
+      fout.write( buf, fin.gcount() );
     }  
-
-    // close the streams
-    lInStream.close();
-    lOutStream.close();
-
-  } catch (ZorbaException const& ze) {
-    std::stringstream lSs;
-    lSs << "An unknown error occured: " << ze.what() << "Can not copy file";
-    raiseFileError("FOFL9999", lSs.str(), lSrcFile->getFilePath());
-  } catch (...) {
-    //assert(false); if this happens errors are not proprly thrown
-    raiseFileError("FOFL9999", "Can not copy file", lSrcFile->getFilePath());
-  }
-
-  return ItemSequence_t(new EmptySequence());
+  }
+  catch ( std::exception const &e ) {
+    throw raiseFileError( "FOFL9999", e.what(), src_path );
+  }
+
+  return ItemSequence_t( new EmptySequence() );
 }
 
 //*****************************************************************************
 
-ListFunction::ListFunction(const FileModule* aModule)
-  : FileFunction(aModule)
+ListFunction::ListFunction( FileModule const *aModule ) :
+  FileFunction( aModule )
 {
 }
 
 ItemSequence_t
 ListFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String lFileStr = getFilePathString(aArgs, 0);
-  File_t lFile = File::createFile(lFileStr.c_str());
-
-  // precondition
-  if (!lFile->isDirectory()) {
-    raiseFileError("FOFL0003", "The specified path does not point to a directory", lFile->getFilePath());
-  }
-
-  // actual list
+  String const path( getFilePathString( aArgs, 0 ) );
+
+  if ( fs::get_type( path ) != fs::directory )
+    raiseFileError( "FOFL0003", "path is not a directory", path );
+
   try {
-    DirectoryIterator_t lIter = lFile->files();
-    return ItemSequence_t(new IteratorBackedItemSequence(lIter, theModule->getItemFactory()));
-  } catch (ZorbaException const& ze) {
-    std::stringstream lSs;
-    lSs << "An unknown error occured: " << ze.what() << "Can not list directory";
-    raiseFileError("FOFL9999", lSs.str(), lFile->getFilePath());
-  } catch (...) {
-    //assert(false); if this happens errors are not proprly thrown
-    raiseFileError("FOFL9999", "Can not list directory", lFile->getFilePath());
-  }
-
-  // dummy, this will never be called
-  return ItemSequence_t(new EmptySequence());
+    return ItemSequence_t(
+      new IteratorBackedItemSequence( path, theModule->getItemFactory() )
+    );
+  }
+  catch ( std::exception const &e ) {
+    throw raiseFileError( "FOFL9999", e.what(), path );
+  }
 }
 
 ListFunction::IteratorBackedItemSequence::IteratorBackedItemSequence(
-    DirectoryIterator_t& aIter,
-    ItemFactory* aFactory)
-  : theIterator(aIter), theItemFactory(aFactory)
+  String const& path,
+  ItemFactory* aFactory
+) :
+  theIterator( path ),
+  theItemFactory( aFactory )
 {
   is_open = false;
   open_count = 0;
@@ -573,7 +473,7 @@
 void ListFunction::IteratorBackedItemSequence::open()
 {
   if (open_count) {
-    theIterator->reset();
+    theIterator.reset();
   }
   open_count++;
   is_open = true;
@@ -592,64 +492,57 @@
 bool
 ListFunction::IteratorBackedItemSequence::next(Item& lItem)
 {
-  std::string lPath;
-  if (!theIterator->next(lPath)) {
+  if ( !theIterator.next() )
     return false;
-  }
 
-  String lUriStr(lPath.c_str());
-  lItem = theItemFactory->createString(lUriStr);
+  String lUriStr( theIterator->name );
+  lItem = theItemFactory->createString( lUriStr );
   return true;
 }
 
 //*****************************************************************************
 
-LastModifiedFunction::LastModifiedFunction(const FileModule* aModule)
-  : FileFunction(aModule)
+LastModifiedFunction::LastModifiedFunction(const FileModule* aModule) :
+  FileFunction(aModule)
 {
 }
 
 ItemSequence_t
 LastModifiedFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String lFileStr = getFilePathString(aArgs, 0);
-  File_t lFile = File::createFile(lFileStr.c_str());
-
-  // precondition
-  if (!lFile->exists()) {
-    raiseFileError("FOFL0001", "A file or directory does not exist at this path", lFile->getFilePath());
-  }
-
-  // actual last modified
+  String const path( getFilePathString( aArgs, 0 ) );
+
+  fs::info info;
+  if ( !fs::get_type( path, &info ) )
+    raiseFileError( "FOFL0001", "file not found", path );
+
   try {
-    time_t lTime = lFile->lastModified();
+    time_t lTime = info.mtime;
     // result of localtime needs to be copied.
     // Otherwise, nasty side effecs do happen
     struct tm lT(*localtime(&lTime));
     int gmtOffset = LastModifiedFunction::getGmtOffset();
 
-    return ItemSequence_t(new SingletonItemSequence(
-      theModule->getItemFactory()->createDateTime(1900 + lT.tm_year,
-                                                  lT.tm_mon,
-                                                  lT.tm_mday,
-                                                  lT.tm_hour,
-                                                  lT.tm_min, 
-                                                  lT.tm_sec,
-                                                  gmtOffset)));
-  } catch (ZorbaException const& ze) {
-    std::stringstream lSs;
-    lSs << "An unknown error occured: " << ze.what() << "Can not retrieve the last modification timestamp of";
-    raiseFileError("FOFL9999", lSs.str(), lFile->getFilePath());
-  } catch (...) {
-    //assert(false); if this happens errors are not proprly thrown
-    raiseFileError("FOFL9999", "Can not retrieve the last modification timestamp of", lFile->getFilePath());
-  }
-
-  // dummy, this will never be called
-  return ItemSequence_t(new EmptySequence());
+    return ItemSequence_t(
+      new SingletonItemSequence(
+        theModule->getItemFactory()->createDateTime(
+          1900 + lT.tm_year,
+          lT.tm_mon,
+          lT.tm_mday,
+          lT.tm_hour,
+          lT.tm_min, 
+          lT.tm_sec,
+          gmtOffset
+        )
+      )
+    );
+  }
+  catch ( std::exception const &e ) {
+    throw raiseFileError( "FOFL9999", e.what(), path );
+  }
 }
 
 int
@@ -675,36 +568,20 @@
 
 ItemSequence_t
 SizeFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String lFileStr = getFilePathString(aArgs, 0);
-  File_t lFile = File::createFile(lFileStr.c_str());
-
-  // preconditions
-  if (!lFile->exists()) {
-    raiseFileError("FOFL0001", "A file does not exist at this path", lFile->getFilePath());
-  }
-  if (lFile->isDirectory()) {
-    raiseFileError("FOFL0004", "The given path points to a directory", lFile->getFilePath());
-  }
-
-  // actual size
-  File::FileSize_t lFs = -1;
-  try {
-    lFs = lFile->getSize();
-  } catch (ZorbaException const& ze) {
-    std::stringstream lSs;
-    lSs << "An unknown error occured: " << ze.what() << "Can not retrieve the file size of";
-    raiseFileError("FOFL9999", lSs.str(), lFile->getFilePath());
-  } catch (...) {
-    //assert(false); if this happens errors are not proprly thrown
-    raiseFileError("FOFL9999", "Can not retrieve the file size of", lFile->getFilePath());
-  }
+  String const path( getFilePathString( aArgs, 0 ) );
+
+  fs::info info;
+  if ( !fs::get_type( path, &info ) )
+    raiseFileError( "FOFL0001", "file not found", path );
+  if ( info.type != fs::file )
+    raiseFileError( "FOFL0004", "not plain file", path );
 
   return ItemSequence_t(new SingletonItemSequence(
-    theModule->getItemFactory()->createInteger(lFs)));
+    theModule->getItemFactory()->createInteger(info.size)));
 }
 
 //*****************************************************************************
@@ -716,11 +593,16 @@
 
 ItemSequence_t
 PathSeparator::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  return ItemSequence_t(new SingletonItemSequence(theModule->getItemFactory()->createString(FileFunction::pathSeparator())));
+  String const path_separator( 1, fs::path_separator );
+  return ItemSequence_t(
+    new SingletonItemSequence(
+      theModule->getItemFactory()->createString( path_separator )
+    )
+  );
 }
 
 //*****************************************************************************
@@ -732,11 +614,16 @@
 
 ItemSequence_t
 DirectorySeparator::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  return ItemSequence_t(new SingletonItemSequence(theModule->getItemFactory()->createString(FileFunction::directorySeparator())));
+  String const dir_separator( 1, fs::dir_separator );
+  return ItemSequence_t(
+    new SingletonItemSequence(
+      theModule->getItemFactory()->createString( dir_separator )
+    )
+  );
 }
 
 //*****************************************************************************
@@ -748,11 +635,11 @@
 
 ItemSequence_t
 ResolvePathFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                          aSctxCtx,
-  const DynamicContext*                         aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String lPathStr = getFilePathString(aArgs, 0);
+  String lPathStr = getFilePathString( aArgs, 0 );
   String lResult = pathToOSPath(lPathStr);
 
   return ItemSequence_t(new SingletonItemSequence(theModule->getItemFactory()->createString(lResult)));
@@ -766,17 +653,28 @@
 }
 
 ItemSequence_t
-PathToNativeFunction::evaluate(const ExternalFunction::Arguments_t& args,
-                                const StaticContext* aSctxCtx,
-                                const DynamicContext* aDynCtx) const
+PathToNativeFunction::evaluate(
+  ExternalFunction::Arguments_t const &args,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
   Item pathItem;
   Iterator_t arg0_iter = args[0]->getIterator();
   arg0_iter->open();
   arg0_iter->next(pathItem);
   arg0_iter->close();
-  String osPath = filesystem_path::normalize_path(pathItem.getStringValue().c_str());
-  return ItemSequence_t(new SingletonItemSequence(theModule->getItemFactory()->createString(osPath)));
+  String const path( pathItem.getStringValue() );
+  try {
+    String const osPath( fs::normalize_path( path ) );
+    return ItemSequence_t(
+      new SingletonItemSequence(
+        theModule->getItemFactory()->createString( osPath )
+      )
+    );
+  }
+  catch ( std::invalid_argument const &e ) {
+    throw raiseFileError( "FOFL9999", e.what(), path );
+  }
 }
 
 //*****************************************************************************
@@ -788,11 +686,11 @@
 
 ItemSequence_t
 PathToUriFunction::evaluate(
-  const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                 aSctxCtx,
-  const DynamicContext*                aDynCtx) const
+  ExternalFunction::Arguments_t const &aArgs,
+  StaticContext const*,
+  DynamicContext const* ) const
 {
-  String lPathStr = getFilePathString(aArgs, 0);
+  String lPathStr = getFilePathString( aArgs, 0 );
   String lResult = pathToUriString(lPathStr);
 
   return ItemSequence_t(new SingletonItemSequence(theModule->getItemFactory()->createAnyURI(lResult)));
@@ -869,7 +767,8 @@
 //*****************************************************************************
 
 
-} /* namespace filemodule */ } /* namespace zorba */
+} // namespace filemodule
+} // namespace zorba
 
 #ifdef WIN32
 #  define DLL_EXPORT __declspec(dllexport)

=== modified file 'modules/org/expath/ns/file.xq.src/file.h'
--- modules/org/expath/ns/file.xq.src/file.h	2013-03-06 02:54:03 +0000
+++ modules/org/expath/ns/file.xq.src/file.h	2013-06-11 16:49:27 +0000
@@ -16,6 +16,8 @@
 #ifndef ZORBA_FILEMODULE_FILE_H
 #define ZORBA_FILEMODULE_FILE_H
 
+#include <zorba/util/fs_util.h>
+
 #include "file_function.h"
 
 namespace zorba { 
@@ -107,7 +109,7 @@
 
         public:
           IteratorBackedItemSequence(
-              DirectoryIterator_t& aIter,
+              String const& path,
               zorba::ItemFactory* aFactory);
 
           virtual ~IteratorBackedItemSequence();
@@ -123,7 +125,7 @@
         private:
           bool is_open;
           int  open_count;
-          DirectoryIterator_t theIterator;
+          fs::iterator theIterator;
           ItemFactory* theItemFactory;
     };
   };
@@ -349,14 +351,14 @@
       class LinesItemSequence : public ItemSequence
       {
         protected:
-          File_t            theFile;
+          String            theFile;
           String            theEncoding;
           const ReadTextLinesFunction* theFunc;
 
           class LinesIterator : public Iterator
           {
             protected:
-              const File_t&     theFile;
+              const String&     theFile;
               const String&     theEncoding;
               const ReadTextLinesFunction* theFunc;
 
@@ -364,7 +366,7 @@
 
             public:
               LinesIterator(
-                  const File_t&,
+                  const String&,
                   const String&,
                   const ReadTextLinesFunction*);
 
@@ -385,7 +387,7 @@
 
         public:
           LinesItemSequence(
-              const File_t& aFile,
+              const String& aFile,
               const String& aEncoding,
               const ReadTextLinesFunction*);
 

=== modified file 'modules/org/expath/ns/file.xq.src/file_function.cpp'
--- modules/org/expath/ns/file.xq.src/file_function.cpp	2013-02-07 17:24:36 +0000
+++ modules/org/expath/ns/file.xq.src/file_function.cpp	2013-06-11 16:49:27 +0000
@@ -20,11 +20,10 @@
 
 #include <zorba/empty_sequence.h>
 #include <zorba/diagnostic_list.h>
-#include <zorba/file.h>
 #include <zorba/serializer.h>
 #include <zorba/store_consts.h>
 #include <zorba/user_exception.h>
-#include <zorba/util/path.h>
+#include <zorba/util/fs_util.h>
 #include <zorba/xquery_functions.h>
 #include <zorba/singleton_item_sequence.h>
 #include <zorba/zorba.h>
@@ -42,23 +41,6 @@
 #include <unistd.h>
 #endif
 
-static zorba::String getCurrentPath()
-{
-#ifdef WIN32
-  wchar_t* wbuffer = _wgetcwd(NULL, 0);
-  char *buffer = (char*)malloc(1024);
-  WideCharToMultiByte(CP_UTF8, 0, wbuffer, -1, buffer, 1024, NULL, NULL);
-#else
-  char buffer[2048];
-  getcwd(buffer, 2048);
-#endif
-  zorba::String result(buffer);
-#ifdef WIN32
-  free(buffer);
-#endif
-  return result;
-}
-
 namespace zorba { namespace filemodule {
 
 FileFunction::FileFunction(const FileModule* aModule)
@@ -70,16 +52,18 @@
 {
 }
 
-void
+int
 FileFunction::raiseFileError(
-  const std::string& aQName,
-  const std::string& aMessage,
-  const std::string& aPath) const
+  char const *aQName,
+  char const *aMessage,
+  String const &aPath ) const
 {
-  std::stringstream lErrorMessage;
-  lErrorMessage << aMessage << ": " << aPath;
-  Item lQName = theModule->getItemFactory()->createQName(getURI(), "file", aQName);
-  throw USER_EXCEPTION(lQName, lErrorMessage.str());
+  Item const lQName(
+    theModule->getItemFactory()->createQName( getURI(), "file", aQName )
+  );
+  std::ostringstream lErrorMessage;
+  lErrorMessage << '"' << aPath << "\": " << aMessage;
+  throw USER_EXCEPTION( lQName, lErrorMessage.str() );
 }
 
 String
@@ -103,26 +87,22 @@
   }
   args_iter->close();
 
-  return (filesystem_path::normalize_path
-    (lFileArg.c_str(), getCurrentPath().c_str()));
-}
-
-String
-FileFunction::directorySeparator() {
-  return File::getDirectorySeparator();
-}
-
-String
-FileFunction::pathSeparator() {
-  return File::getPathSeparator();
+  try {
+    return fs::normalize_path(lFileArg, fs::curdir());
+  }
+  catch ( std::invalid_argument const &e ) {
+    throw raiseFileError( "FOFL9999", e.what(), lFileArg );
+  }
 }
 
 String
 FileFunction::pathToFullOSPath(const String& aPath) const {
-  File_t lFile = File::createFile(aPath.c_str());
-  std::string lPath = lFile->getFilePath();
-
-  return String(lPath);
+  try {
+    return fs::normalize_path( aPath );
+  }
+  catch ( std::invalid_argument const &e ) {
+    throw raiseFileError( "FOFL9999", e.what(), aPath );
+  }
 }
 
 String
@@ -147,31 +127,30 @@
 
 String
 FileFunction::pathToOSPath(const String& aPath) const {
-  File_t lFile = File::createFile(aPath.c_str());
-  std::string lPath = lFile->getFilePath();
-
-  return String(lPath);
+  try {
+    return fs::normalize_path( aPath );
+  }
+  catch ( std::invalid_argument const &e ) {
+    throw raiseFileError( "FOFL9999", e.what(), aPath );
+  }
 }
 
 String
 FileFunction::pathToUriString(const String& aPath) const {
-  std::stringstream lErrorMessage;
 
-  if(fn::starts_with(aPath,"file://")) {
+  if ( fn::starts_with( aPath,"file://" ) ) {
+    std::stringstream lErrorMessage;
     lErrorMessage << "Please provide a path, not a URI";
     Item lQName = theModule->getItemFactory()->createQName(
         "http://www.w3.org/2005/xqt-errors",
         "err",
         "XPTY0004");
-    throw USER_EXCEPTION(lQName, lErrorMessage.str() );
+    throw USER_EXCEPTION( lQName, lErrorMessage.str() );
   }
 
-  File_t lFile = File::createFile(aPath.c_str());
-
-  std::string lPath = lFile->getFileUri();
-
-
-  return String(lPath);
+  String uri( aPath );
+
+  return uri;
 }
 
 #ifdef WIN32
@@ -187,12 +166,9 @@
     return false;
   }
 
-  char lDrive = aString[0];
+  char const lDrive = aString[0];
   // the string is already upper case
-  if (lDrive < 65 || lDrive > 90) {
-    return false;
-  }
-  return true;
+  return lDrive >= 'A' && lDrive <= 'Z';
 }
 #endif
 
@@ -234,33 +210,27 @@
 ItemSequence_t
 WriterFileFunction::evaluate(
   const ExternalFunction::Arguments_t& aArgs,
-  const StaticContext*                 aSctxCtx,
-  const DynamicContext*                aDynCtx) const
+  const StaticContext*,
+  const DynamicContext* ) const
 {
-  String lFileStr = getFilePathString(aArgs, 0);
-  File_t lFile = File::createFile(lFileStr.c_str());
-
-  // precondition
-  if (lFile->isDirectory())
-  {
-    raiseFileError("FOFL0004",
-        "The given path points to a directory", lFile->getFilePath());
-  }
-
-  bool lBinary = isBinary();
-  // open the output stream in the desired write mode
-  std::ofstream lOutStream;
-
-  // actual write
-  try
-  {
-    lFile->openOutputStream(lOutStream, lBinary, isAppend());
-  }
-  catch (ZorbaException& ze)
-  {
-    std::stringstream lSs;
-    lSs << "Can not open file for writing: " << ze.what();
-    raiseFileError("FOFL9999", lSs.str(), lFile->getFilePath());
+  String const lFileStr( getFilePathString(aArgs, 0) );
+
+  fs::type const fs_type = fs::get_type( lFileStr );
+  if ( fs_type && fs_type != fs::file )
+    raiseFileError( "FOFL0004", "not a plain file", lFileStr );
+
+  bool const lBinary = isBinary();
+
+  std::ios_base::openmode mode = std::ios_base::out
+    | (isAppend() ? std::ios_base::app : std::ios_base::trunc);
+  if ( lBinary )
+    mode |= std::ios_base::binary;
+
+  std::ofstream lOutStream( lFileStr.c_str(), mode );
+  if ( !lOutStream ) {
+    std::ostringstream oss;
+    oss << '"' << lFileStr << "\": can not open file for writing";
+    raiseFileError( "FOFL9999", oss.str().c_str(), lFileStr );
   }
 
   // if this is a binary write
@@ -320,3 +290,4 @@
 
 } // namespace filemodule
 } // namespace zorba
+/* vim:set et sw=2 ts=2: */

=== modified file 'modules/org/expath/ns/file.xq.src/file_function.h'
--- modules/org/expath/ns/file.xq.src/file_function.h	2013-02-07 17:24:36 +0000
+++ modules/org/expath/ns/file.xq.src/file_function.h	2013-06-11 16:49:27 +0000
@@ -44,11 +44,11 @@
     protected:
       const FileModule* theModule;
 
-      void
+      int
       raiseFileError(
-          const std::string& qName,
-          const std::string& message,
-          const std::string& path) const;
+          char const *qName,
+          char const *message,
+          const String& path) const;
 
       /*
        * Gets the argument on position pos as a normalised file system path.
@@ -73,12 +73,6 @@
       String
       pathToUriString(const String& path) const;
 
-      static String
-      directorySeparator();
-
-      static String
-      pathSeparator();
-
     public:
       FileFunction(const FileModule* module);
       ~FileFunction();

=== modified file 'src/api/CMakeLists.txt'
--- src/api/CMakeLists.txt	2013-04-10 10:13:31 +0000
+++ src/api/CMakeLists.txt	2013-06-11 16:49:27 +0000
@@ -63,11 +63,6 @@
     module_info_impl.cpp
     )
 
-IF (ZORBA_WITH_FILE_ACCESS)
-  LIST(APPEND API_SRCS
-    fileimpl.cpp)
-ENDIF (ZORBA_WITH_FILE_ACCESS)  
-
 IF (NOT ZORBA_NO_FULL_TEXT)
   LIST(APPEND API_SRCS
     stemmer.cpp

=== removed file 'src/api/fileimpl.cpp'
--- src/api/fileimpl.cpp	2013-04-19 22:25:21 +0000
+++ src/api/fileimpl.cpp	1970-01-01 00:00:00 +0000
@@ -1,404 +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 "stdafx.h"
-
-#include "fileimpl.h"
-
-#include <fstream>
-
-#include <zorba/diagnostic_handler.h>
-#include <zorba/util/file.h>
-
-#include <runtime/util/flowctl_exception.h>
-
-#include "diagnostics/xquery_diagnostics.h"
-
-#ifdef WIN32
-#include <util/ascii_util.h>
-#endif
-
-#include "util/uri_util.h"
-#include "zorbaimpl.h"
-
-namespace zorba {
-
-DirectoryIteratorImpl::DirectoryIteratorImpl(std::string const& aPath) :
-  theInternalDirIter( aPath.c_str() )
-{
-}
-
-bool
-DirectoryIteratorImpl::next(std::string& aPathStr) const
-{
-  if (!theInternalDirIter.next()) {
-    return false;
-  }
-
-  // get the current pointed entry
-  aPathStr = theInternalDirIter.entry_name();
-
-  return true;
-}
-
-void DirectoryIteratorImpl::reset()
-{
-  theInternalDirIter.reset();
-}
-
-FileImpl::FileImpl(std::string const& path)
-  : theDiagnosticHandler(new DiagnosticHandler())
-{
-  theInternalFile = new file(path
-#ifdef WIN32
-      , filesystem_path::CONVERT_SLASHES
-#endif
-    );
-}
-
-FileImpl::~FileImpl()
-{
-  delete theInternalFile;
-  delete theDiagnosticHandler;
-}
-
-File_t
-File::createFile(const std::string& path)
-{
-  return new FileImpl(path);
-}
-
-const char*
-File::getDirectorySeparator()
-{
-  return filesystem_path::get_directory_separator();
-}
-
-const char*
-File::getPathSeparator()
-{
-  return filesystem_path::get_path_separator();
-}
-
-const std::string
-FileImpl::getFilePath() const
-{
-  std::string lResult;
-
-  ZORBA_TRY
-    lResult = theInternalFile->get_path();
-  ZORBA_CATCH
-
-  return lResult;
-}
-
-const std::string
-FileImpl::getFileUri() const
-{
-  std::string lPath;
-
-  ZORBA_TRY
-    lPath = theInternalFile->get_path();
-#ifdef WIN32
-    ascii::replace_all( lPath, '\\', '/' );
-#endif
-
-    std::stringstream lEncodedResult;
-    lEncodedResult << "file:///";
-
-    size_t lCurrentPos = 0;
-    size_t lNextSlashPos = lPath.find_first_of("/");
-    while (lNextSlashPos != std::string::npos) {
-      String lEncodedSegment(lPath.substr(lCurrentPos, lNextSlashPos - lCurrentPos));
-      uri::encode( lEncodedSegment );
-      lEncodedResult << lEncodedSegment << "/";
-      lCurrentPos = lNextSlashPos + 1;
-      lNextSlashPos = lPath.find_first_of("/", lNextSlashPos + 1);
-    }
-
-    String lEncodedSegment(lPath.substr(lCurrentPos));
-    uri::encode( lEncodedSegment );
-    lEncodedResult << lEncodedSegment;
-
-    lPath = lEncodedResult.str();
-  ZORBA_CATCH
-
-  return lPath;
-}
-
-bool
-FileImpl::isDirectory( bool follow_symlinks ) const
-{
-  bool lResult = false;
-
-  ZORBA_TRY
-    lResult = theInternalFile->is_directory( follow_symlinks )
-           || theInternalFile->is_volume( follow_symlinks )
-           || theInternalFile->is_root();
-  ZORBA_CATCH
-
-  return lResult;
-}
-
-bool
-FileImpl::isFile( bool follow_symlinks ) const
-{
-  bool lResult = false;
-
-  ZORBA_TRY
-    lResult = theInternalFile->is_file( follow_symlinks ) || theInternalFile->is_link();
-  ZORBA_CATCH
-
-  return lResult;
-}
-
-bool
-FileImpl::isLink() const
-{
-  bool lResult = false;
-
-  ZORBA_TRY
-    lResult = theInternalFile->is_link();
-  ZORBA_CATCH
-
-  return lResult;
-}
-
-bool
-FileImpl::isVolume( bool follow_symlinks ) const
-{
-  bool lResult = false;
-
-  ZORBA_TRY
-    lResult = theInternalFile->is_volume( follow_symlinks );
-  ZORBA_CATCH
-
-  return lResult;
-}
-
-bool
-FileImpl::isInvalid() const
-{
-  bool lResult = false;
-
-  ZORBA_TRY
-    lResult = theInternalFile->is_invalid();
-  ZORBA_CATCH
-
-  return lResult;
-}
-
-bool
-FileImpl::exists( bool follow_symlinks ) const
-{
-  bool lResult = false;
-
-  ZORBA_TRY
-    lResult = theInternalFile->exists( follow_symlinks );
-  ZORBA_CATCH
-
-  return lResult;
-}
-
-void
-FileImpl::remove()
-{
-  ZORBA_TRY
-    if (theInternalFile->is_directory()) {
-      theInternalFile->rmdir(false);
-    } else {
-      theInternalFile->remove(false);
-    }
-  ZORBA_CATCH
-}
-
-bool
-FileImpl::create()
-{
-  bool lResult = false;
-
-  ZORBA_TRY
-    // if the file/dir exist, return false
-    if (theInternalFile->exists()) {
-      return false;
-    }
-
-    theInternalFile->create();
-
-    // if the file does not exist, return false
-    if (!theInternalFile->exists() || !theInternalFile->is_file()) {
-      return false;
-    }
-
-    lResult = true;
-  ZORBA_CATCH
-
-  return lResult;
-}
-
-bool
-FileImpl::rename(std::string const& newpath)
-{
-  bool lResult = false;
-
-  ZORBA_TRY
-    // if the file/dir does not exist, return false
-    if (!theInternalFile->exists()) {
-      return false;
-    }
-    // if the new path is already used, return false
-    file lNewFile(newpath);
-    if (lNewFile.exists()) {
-      return false;
-    }
-
-    theInternalFile->rename(newpath);
-
-    // if the file does not exist, return false
-    if (!lNewFile.exists()) {
-      return false;
-    }
-
-    lResult = true;
-  ZORBA_CATCH
-
-  return lResult;
-}
-
-File::FileSize_t
-FileImpl::getSize() const
-{
-  ZORBA_TRY
-    return theInternalFile->get_size();
-  ZORBA_CATCH
-  assert(false);
-  return -1;
-}
-
-void
-FileImpl::mkdir(bool aRecursive)
-{
-  ZORBA_TRY
-    if (aRecursive) {
-      theInternalFile->deep_mkdir();
-    } else {
-      theInternalFile->mkdir();
-    }
-  ZORBA_CATCH
-}
-
-DirectoryIterator_t
-FileImpl::files() const
-{
-  return new DirectoryIteratorImpl(theInternalFile->get_path());
-}
-
-void
-FileImpl::openInputStream(std::ifstream& aInStream, bool binary, bool trimByteOrderMark) const
-{
-  ZORBA_TRY
-    std::string lPath(theInternalFile->get_path());
-
-    if (!theInternalFile->exists())
-      throw XQUERY_EXCEPTION(
-        err::FODC0002, ERROR_PARAMS( lPath, ZED( FileNotFoundOrReadable ) )
-      );
-    if (!theInternalFile->is_file())
-      throw XQUERY_EXCEPTION(
-        err::FODC0002, ERROR_PARAMS( lPath, ZED( NotPlainFile ) )
-      );
-
-    std::ios_base::openmode lMode = std::ifstream::in;
-    if (binary) {
-      lMode |= std::ios_base::binary;
-    }
-#ifndef WIN32
-    aInStream.open(lPath.c_str(), lMode);
-#else
-    WCHAR wpath_str[1024];
-    wpath_str[0] = 0;
-    if(MultiByteToWideChar(CP_UTF8,
-                        0, lPath.c_str(), -1,
-                        wpath_str, sizeof(wpath_str)/sizeof(WCHAR)) == 0)
-    {//probably there is some invalid utf8 char, try the Windows ACP
-      MultiByteToWideChar(CP_ACP,
-                        0, lPath.c_str(), -1,
-                        wpath_str, sizeof(wpath_str)/sizeof(WCHAR));
-    }
-    aInStream.open(wpath_str, lMode);
-#endif
-
-    if (aInStream.is_open() == false)
-      throw XQUERY_EXCEPTION(
-        err::FODC0002, ERROR_PARAMS( lPath, ZED( FileNotFoundOrReadable ) )
-      );
-
-    if (trimByteOrderMark) {
-      char lBuf[3];
-      aInStream.read(lBuf, 3);
-      if (!aInStream.good() || lBuf[0] != (char)0xEF || lBuf[1] != (char)0xBB || lBuf[2] != (char)0xBF ) {
-        aInStream.seekg(0);
-      }
-    }
-  ZORBA_CATCH
-}
-
-void
-FileImpl::openOutputStream(std::ofstream& aOutStream, bool binary, bool append) const
-{
-  ZORBA_TRY
-    std::string lPath(theInternalFile->get_path());
-
-    if (theInternalFile->exists() && !theInternalFile->is_file())
-      throw XQUERY_EXCEPTION(
-        err::FODC0002, ERROR_PARAMS( lPath, ZED( NotPlainFile ) )
-      );
-
-    std::ios_base::openmode lMode = std::ifstream::out;
-    lMode |= append ? std::ios_base::app : std::ios_base::trunc;
-    if (binary) {
-      lMode |= std::ios_base::binary;
-    }
-#ifndef WIN32
-    aOutStream.open(lPath.c_str(), lMode);
-#else
-    WCHAR wpath_str[1024];
-    wpath_str[0] = 0;
-    if(MultiByteToWideChar(CP_UTF8,
-                        0, lPath.c_str(), -1,
-                        wpath_str, sizeof(wpath_str)/sizeof(WCHAR)) == 0)
-    {//probably there is some invalid utf8 char, try the Windows ACP
-      MultiByteToWideChar(CP_ACP,
-                        0, lPath.c_str(), -1,
-                        wpath_str, sizeof(wpath_str)/sizeof(WCHAR));
-    }
-    aOutStream.open(wpath_str, lMode);
-#endif
-
-    if (aOutStream.is_open() == false)
-      throw XQUERY_EXCEPTION(
-        err::FODC0002, ERROR_PARAMS( lPath, ZED( FileNotFoundOrReadable ) )
-      );
-  ZORBA_CATCH
-}
-
-time_t
-FileImpl::lastModified() const
-{
-  return theInternalFile->lastModified();
-}
-
-} // namespace zorba
-/* vim:set et sw=2 ts=2: */

=== removed file 'src/api/fileimpl.h'
--- src/api/fileimpl.h	2013-04-19 22:25:21 +0000
+++ src/api/fileimpl.h	1970-01-01 00:00:00 +0000
@@ -1,94 +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.
- */
-#pragma once
-#ifndef XQP_FILE_IMPL_H
-#define XQP_FILE_IMPL_H
-
-#include <iostream>
-#include <zorba/file.h>
-
-#include "util/fs_util.h"
-
-namespace zorba {
-
-  class file;
-  class DiagnosticHandler;
-
-
-class DirectoryIteratorImpl : public DirectoryIterator
-{
-private:
-
-  mutable fs::iterator  theInternalDirIter;
-
-public:
-
-  DirectoryIteratorImpl(std::string const& aPath);
-
-  bool next(std::string& aPathStr) const;
-  void reset();
-};
-  
-
-class FileImpl : public File
-{
-private:
-
-  zorba::file*          theInternalFile;
-
-  DiagnosticHandler*    theDiagnosticHandler; 
-    
-public:
-
-  FileImpl(std::string const& _path);
-
-  ~FileImpl();
-
-
-public: // public methods
-
-  const std::string getFilePath() const;
-  const std::string getFileUri() const;
-
-  bool isDirectory( bool follow_symlinks = true ) const;
-  bool isFile( bool follow_symlinks = true ) const;
-  bool isLink() const;
-  bool isVolume( bool follow_symlinks = true ) const;
-  bool isInvalid() const;               // deprecated
-  bool exists( bool follow_symlinks = true ) const;
-
-  void remove();
-  bool create();
-  bool rename(std::string const& newpath);
-
-  FileSize_t getSize() const;
-
-  void mkdir(bool recursive = true);
-
-  DirectoryIterator_t files() const;
-
-  void openInputStream(std::ifstream& aInStream, bool binary, bool trimByteOrderMark) const;
-
-  void openOutputStream(std::ofstream& aOutStream, bool binary, bool append) const;
-
-  time_t lastModified() const;
-};
-
-
-} /* namespace zorba */
-
-#endif
-/* vim:set et sw=2 ts=2: */

=== modified file 'src/api/staticcontextimpl.cpp'
--- src/api/staticcontextimpl.cpp	2013-03-25 23:02:19 +0000
+++ src/api/staticcontextimpl.cpp	2013-06-11 16:49:27 +0000
@@ -23,7 +23,7 @@
 #include <zorba/diagnostic_handler.h>
 #include <zorba/static_context_consts.h>
 #include <zorba/typeident.h>
-#include <zorba/util/path.h>
+#include <zorba/util/fs_util.h>
 #include <zorba/empty_sequence.h>
 #include <zorba/singleton_item_sequence.h>
 
@@ -1131,9 +1131,9 @@
     {
       aInternalStrings.push_back(Unmarshaller::getInternalString(*lIter).c_str());
       zstring& lPath = aInternalStrings.back();
-      if (lPath[lPath.length() - 1] != *filesystem_path::get_directory_separator())
+      if (lPath[lPath.length() - 1] != fs::dir_separator)
       {
-        lPath.append(filesystem_path::get_directory_separator());
+        lPath += fs::dir_separator;
       }
     }
   }

=== modified file 'src/api/stemmer_wrappers.cpp'
--- src/api/stemmer_wrappers.cpp	2013-02-07 17:24:36 +0000
+++ src/api/stemmer_wrappers.cpp	2013-06-11 16:49:27 +0000
@@ -19,9 +19,9 @@
 
 #ifndef ZORBA_NO_FULL_TEXT
 
+#include <zorba/internal/cxx_util.h>
 #include "api/unmarshaller.h"
 #include "diagnostics/assert.h"
-#include "util/cxx_util.h"
 
 #include "stemmer_wrappers.h"
 

=== modified file 'src/api/thesaurus_wrappers.cpp'
--- src/api/thesaurus_wrappers.cpp	2013-02-07 17:24:36 +0000
+++ src/api/thesaurus_wrappers.cpp	2013-06-11 16:49:27 +0000
@@ -19,9 +19,9 @@
 
 #ifndef ZORBA_NO_FULL_TEXT
 
+#include <zorba/internal/cxx_util.h>
 #include "api/unmarshaller.h"
 #include "diagnostics/assert.h"
-#include "util/cxx_util.h"
 
 #include "thesaurus_wrappers.h"
 

=== modified file 'src/api/zorba_string.cpp'
--- src/api/zorba_string.cpp	2013-02-07 17:24:36 +0000
+++ src/api/zorba_string.cpp	2013-06-11 16:49:27 +0000
@@ -15,11 +15,11 @@
  */
 #include "stdafx.h"
 
+#include <zorba/internal/cxx_util.h>
 #include <zorba/zorba_string.h>
 
 #include "api/unmarshaller.h"
 #include "util/ascii_util.h"
-#include "util/cxx_util.h"
 #include "util/regex.h"
 #include "util/string_util.h"
 #include "util/uri_util.h"

=== modified file 'src/compiler/expression/ftnode.cpp'
--- src/compiler/expression/ftnode.cpp	2013-02-07 17:24:36 +0000
+++ src/compiler/expression/ftnode.cpp	2013-06-11 16:49:27 +0000
@@ -16,11 +16,11 @@
 #include "stdafx.h"
 
 #include <zorba/error.h>
+#include <zorba/internal/cxx_util.h>
 
 #include "diagnostics/xquery_diagnostics.h"
 #include "types/casting.h"
 #include "util/ascii_util.h"
-#include "util/cxx_util.h"
 #include "util/indent.h"
 #include "util/stl_util.h"
 #include "zorbautils/locale.h"

=== modified file 'src/compiler/expression/ftnode.h'
--- src/compiler/expression/ftnode.h	2013-02-07 17:24:36 +0000
+++ src/compiler/expression/ftnode.h	2013-06-11 16:49:27 +0000
@@ -18,6 +18,7 @@
 #define ZORBA_COMPILER_FTNODE_H
 
 #include <zorba/locale.h>
+#include <zorba/internal/cxx_util.h>
 
 #include "common/shared_types.h"
 
@@ -29,8 +30,6 @@
 
 #include "runtime/base/plan_iterator.h"
 
-#include "util/cxx_util.h"
-
 #include "zorbatypes/rchandle.h"
 #include "zorbatypes/zstring.h"
 

=== modified file 'src/compiler/expression/ftnode_visitor.cpp'
--- src/compiler/expression/ftnode_visitor.cpp	2013-02-07 17:24:36 +0000
+++ src/compiler/expression/ftnode_visitor.cpp	2013-06-11 16:49:27 +0000
@@ -15,7 +15,7 @@
  */
 #include "stdafx.h"
 
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
 
 #include "expr_visitor.h"
 #include "ftnode.h"

=== modified file 'src/compiler/parser/ft_types.cpp'
--- src/compiler/parser/ft_types.cpp	2013-02-07 17:24:36 +0000
+++ src/compiler/parser/ft_types.cpp	2013-06-11 16:49:27 +0000
@@ -15,7 +15,7 @@
  */
 #include "stdafx.h"
 
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
 
 #include "ft_types.h"
 

=== modified file 'src/context/default_uri_mappers.cpp'
--- src/context/default_uri_mappers.cpp	2013-02-07 17:24:36 +0000
+++ src/context/default_uri_mappers.cpp	2013-06-11 16:49:27 +0000
@@ -180,7 +180,7 @@
     // If module-path entry is relative, normalize it against the
     // static context's base URI.
     if (!fs::is_absolute(*lIter)) {
-      zstring lAbsPath = fs::get_normalized_path(*lIter, aSctx.get_base_uri());
+      zstring lAbsPath = fs::normalize_path(*lIter, aSctx.get_base_uri());
       lCandidateURI.append(lAbsPath);
     }
     else {

=== modified file 'src/context/default_url_resolvers.cpp'
--- src/context/default_url_resolvers.cpp	2013-02-07 17:24:36 +0000
+++ src/context/default_url_resolvers.cpp	2013-06-11 16:49:27 +0000
@@ -15,9 +15,9 @@
  */
 #include "stdafx.h"
 
+#include <zorba/internal/cxx_util.h>
 
 #include "context/default_url_resolvers.h"
-#include "util/cxx_util.h"
 #include "util/uri_util.h"
 #include "util/http_util.h"
 #include "util/fs_util.h"
@@ -125,13 +125,18 @@
   if (lScheme != uri::file) {
     return NULL;
   }
-  zstring lPath = fs::get_normalized_path(aUrl);
-  if (fs::get_type(lPath) == fs::file) {
-    std::ifstream* lStream = new std::ifstream(lPath.c_str());
-    return new StreamResource(
-        lStream, &fileStreamReleaser, "", true /* seekable */);
-  }
-  return NULL;
+  try {
+    std::string lPath( fs::normalize_path(aUrl) );
+    if (fs::get_type(lPath) == fs::file) {
+      std::ifstream* lStream = new std::ifstream(lPath.c_str());
+      return new StreamResource(
+          lStream, &fileStreamReleaser, "", true /* seekable */);
+    }
+    return NULL;
+  }
+  catch ( std::invalid_argument const &e ) {
+    throw XQUERY_EXCEPTION( err::XPTY0004, ERROR_PARAMS( e.what() ) );
+  }
 }
 
 /******

=== modified file 'src/context/dynamic_loader.cpp'
--- src/context/dynamic_loader.cpp	2013-02-07 17:24:36 +0000
+++ src/context/dynamic_loader.cpp	2013-06-11 16:49:27 +0000
@@ -28,14 +28,15 @@
 #ifdef WIN32
 #  include <strsafe.h>
 #endif
-
-#include <diagnostics/xquery_diagnostics.h>
-#include <zorbatypes/URI.h>
+#include <fstream>
+
+#include "diagnostics/xquery_diagnostics.h"
+#include "zorbatypes/URI.h"
+
 #include <zorba/external_module.h>
 #include <zorba/zorba_string.h>
 #include <context/get_current_lib_suffix.h>
-#include <fstream>
-#include <util/error_util.h>
+#include <zorba/util/error_util.h>
 
 namespace zorba {
 

=== modified file 'src/diagnostics/assert.h'
--- src/diagnostics/assert.h	2013-02-07 17:24:36 +0000
+++ src/diagnostics/assert.h	2013-06-11 16:49:27 +0000
@@ -22,7 +22,7 @@
 
 #include <sstream>
 
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
 
 namespace zorba {
 

=== modified file 'src/diagnostics/diagnostic_en.xml'
--- src/diagnostics/diagnostic_en.xml	2013-06-04 00:34:52 +0000
+++ src/diagnostics/diagnostic_en.xml	2013-06-11 16:49:27 +0000
@@ -4061,10 +4061,6 @@
       <value>promotion not possible</value>
     </entry>
 
-    <entry key="QuotedColon_23">
-      <value>"$2": $3</value>
-    </entry>
-
     <entry key="SEPM0009_Not10">
       <value>the version parameter has a value other than "1.0" and the doctype-system parameter is specified</value>
     </entry>

=== modified file 'src/diagnostics/pregenerated/dict_en.cpp'
--- src/diagnostics/pregenerated/dict_en.cpp	2013-06-04 01:32:30 +0000
+++ src/diagnostics/pregenerated/dict_en.cpp	2013-06-11 16:49:27 +0000
@@ -779,7 +779,6 @@
   { "~ParseFragmentInvalidOptions", "invalid options passed to the parse-xml:parse() function, the element must be in the schema target namespace" },
   { "~ParseFragmentOptionCombinationNotAllowed", "only one of the <schema-validate/>, <DTD-validate/> or <parse-external-parsed-entity/> options can be specified" },
   { "~PromotionImpossible", "promotion not possible" },
-  { "~QuotedColon_23", "\"$2\": $3" },
 #if defined(ZORBA_NO_ICU)
   { "~REGEX_BROKEN_PIs_CONSTRUCT", "broken \\\\p{Is} construct; valid characters are [a-zA-Z0-9-]" },
 #endif

=== modified file 'src/diagnostics/pregenerated/dict_zed_keys.h'
--- src/diagnostics/pregenerated/dict_zed_keys.h	2013-05-16 22:26:07 +0000
+++ src/diagnostics/pregenerated/dict_zed_keys.h	2013-06-11 16:49:27 +0000
@@ -319,7 +319,6 @@
 #define ZED_XMLParserInitFailed "~XMLParserInitFailed"
 #define ZED_XMLParserNoCreateTree "~XMLParserNoCreateTree"
 #define ZED_PromotionImpossible "~PromotionImpossible"
-#define ZED_QuotedColon_23 "~QuotedColon_23"
 #define ZED_SEPM0009_Not10 "~SEPM0009_Not10"
 #define ZED_SEPM0009_NotOmit "~SEPM0009_NotOmit"
 #define ZED_SchemaUnexpected "~SchemaUnexpected"

=== modified file 'src/diagnostics/user_exception.h'
--- src/diagnostics/user_exception.h	2013-02-07 17:24:36 +0000
+++ src/diagnostics/user_exception.h	2013-06-11 16:49:27 +0000
@@ -18,13 +18,13 @@
 #ifndef ZORBA_USER_EXCEPTION_H
 #define ZORBA_USER_EXCEPTION_H
 
+#include <zorba/internal/cxx_util.h>
 #include <zorba/item.h>
 #include <zorba/user_exception.h>
 
 #include "api/unmarshaller.h"
 #include "compiler/parser/query_loc.h"
 #include "store/api/item.h"
-#include "util/cxx_util.h"
 #include "util/stl_util.h"
 
 namespace zorba {

=== modified file 'src/diagnostics/xquery_diagnostics.h'
--- src/diagnostics/xquery_diagnostics.h	2013-02-07 17:24:36 +0000
+++ src/diagnostics/xquery_diagnostics.h	2013-06-11 16:49:27 +0000
@@ -22,12 +22,11 @@
 
 #include <zorba/config.h>
 #include <zorba/internal/unique_ptr.h>
+#include <zorba/util/error_util.h>
 
 // TODO: this #include is temporary
 #include <zorba/diagnostic_list.h>
 
-#include "util/error_util.h"
-
 #include "diagnostic.h"
 #include "dict.h"
 #include "xquery_exception.h"

=== modified file 'src/diagnostics/xquery_exception.cpp'
--- src/diagnostics/xquery_exception.cpp	2013-05-24 00:27:45 +0000
+++ src/diagnostics/xquery_exception.cpp	2013-06-11 16:49:27 +0000
@@ -279,7 +279,7 @@
       case uri::file:
         try {
           o << (as_xml ? " uri=\"" : "<") 
-            << fs::get_normalized_path( uri ) 
+            << fs::normalize_path( uri ) 
             << (as_xml ? '"' : '>');
           break;
         }

=== modified file 'src/precompiled/stdafx.h'
--- src/precompiled/stdafx.h	2013-04-17 18:37:33 +0000
+++ src/precompiled/stdafx.h	2013-06-11 16:49:27 +0000
@@ -31,6 +31,7 @@
   #include <set>
   #include <sys/timeb.h>
 
+  #include <zorba/internal/cxx_util.h>
   #include "runtime/sequences/sequences.h"
   #include "diagnostics/xquery_diagnostics.h"
   #include "xercesc/util/xercesdefs.hpp"
@@ -48,7 +49,6 @@
   #include <zorba/store_manager.h>
   #include <zorba/xquery.h>
   #include <zorba/xquery_exception.h>
-  #include "util/cxx_util.h"
   #include "diagnostics/assert.h"
   #include "zorbatypes/mapm/m_apm_lc.h"
   #include "zorbatypes/datetime/parse.h"

=== modified file 'src/runtime/full_text/apply.cpp'
--- src/runtime/full_text/apply.cpp	2013-06-07 21:22:39 +0000
+++ src/runtime/full_text/apply.cpp	2013-06-11 16:49:27 +0000
@@ -19,17 +19,17 @@
 #include <set>
 #include <vector>
 
+#include <zorba/internal/cxx_util.h>
 #include <zorba/tokenizer.h>
-#include <context/uri_resolver.h>
 
 #include "compiler/expression/ftnode.h"
+#include "context/uri_resolver.h"
 #include "diagnostics/dict.h"
 #include "diagnostics/xquery_diagnostics.h"
 #include "store/api/item.h"
 #include "store/api/item_factory.h"
 #include "store/api/store.h"
 #include "system/globalenv.h"
-#include "util/cxx_util.h"
 #include "util/indent.h"
 #include "util/stl_util.h"
 #include "zorbamisc/ns_consts.h"

=== modified file 'src/runtime/full_text/ft_module_util.h'
--- src/runtime/full_text/ft_module_util.h	2012-06-24 14:44:40 +0000
+++ src/runtime/full_text/ft_module_util.h	2013-06-11 16:49:27 +0000
@@ -23,12 +23,12 @@
 // needs to be #include'd into the .cpp generated from the ft_module.xml file.
 //
 
+#include <deque>
+
+#include <zorba/internal/cxx_util.h>
 #include <zorba/tokenizer.h>
 
-#include <deque>
-
 #include "store/api/item.h"
-#include "util/cxx_util.h"
 #include "zorbatypes/ft_token.h"
 
 #include "ft_module_util.h"

=== modified file 'src/runtime/full_text/ft_query_item.cpp'
--- src/runtime/full_text/ft_query_item.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/ft_query_item.cpp	2013-06-11 16:49:27 +0000
@@ -15,7 +15,8 @@
  */
 #include "stdafx.h"
 
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
+
 #include "util/stl_util.h"
 #include "diagnostics/assert.h"
 

=== modified file 'src/runtime/full_text/ft_stop_words_set.cpp'
--- src/runtime/full_text/ft_stop_words_set.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/ft_stop_words_set.cpp	2013-06-11 16:49:27 +0000
@@ -16,11 +16,11 @@
 #include "stdafx.h"
 
 #include <zorba/config.h>
+#include <zorba/internal/cxx_util.h>
 
 #include "context/static_context.h"
 #include "context/uri_resolver.h"
 #include "util/ascii_util.h"
-#include "util/cxx_util.h"
 #include "util/mmap_file.h"
 #include "util/stl_util.h"
 #include "util/uri_util.h"

=== modified file 'src/runtime/full_text/ft_token_matcher.cpp'
--- src/runtime/full_text/ft_token_matcher.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/ft_token_matcher.cpp	2013-06-11 16:49:27 +0000
@@ -17,14 +17,14 @@
 
 #include <cctype>
 
+#include <zorba/internal/cxx_util.h>
+
 #include "compiler/expression/ftnode.h"
 #include "diagnostics/assert.h"
 #include "store/api/store.h"
-#include "util/cxx_util.h"
+#include "system/globalenv.h"
 #include "util/stl_util.h"
 
-#include "system/globalenv.h"
-
 #include "ft_stop_words_set.h"
 #include "ft_token_matcher.h"
 #include "ft_util.h"

=== modified file 'src/runtime/full_text/ft_token_seq_iterator.cpp'
--- src/runtime/full_text/ft_token_seq_iterator.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/ft_token_seq_iterator.cpp	2013-06-11 16:49:27 +0000
@@ -15,7 +15,8 @@
  */
 #include "stdafx.h"
 
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
+
 #include "diagnostics/assert.h"
 
 #include "ft_token_seq_iterator.h"

=== modified file 'src/runtime/full_text/ft_util.h'
--- src/runtime/full_text/ft_util.h	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/ft_util.h	2013-06-11 16:49:27 +0000
@@ -17,12 +17,12 @@
 #ifndef ZORBA_FULL_TEXT_UTIL_H
 #define ZORBA_FULL_TEXT_UTIL_H
 
+#include <zorba/internal/cxx_util.h>
 #include <zorba/item.h>
 #include <zorba/locale.h>
 
 #include "compiler/expression/ftnode.h"
 #include "store/api/item.h"
-#include "util/cxx_util.h"
 #include "zorbatypes/schema_types.h"
 
 #include "ft_match.h"

=== modified file 'src/runtime/full_text/ftcontains_visitor.cpp'
--- src/runtime/full_text/ftcontains_visitor.cpp	2013-05-08 20:14:47 +0000
+++ src/runtime/full_text/ftcontains_visitor.cpp	2013-06-11 16:49:27 +0000
@@ -19,13 +19,14 @@
 #include <limits>
 #include <memory>
 
+#include <zorba/internal/cxx_util.h>
+
 #include "compiler/expression/ft_expr.h"
 #include "compiler/expression/ftnode.h"
 #include "compiler/parser/query_loc.h"
 #include "diagnostics/xquery_diagnostics.h"
 #include "store/api/store.h"
 #include "system/globalenv.h"
-#include "util/cxx_util.h"
 #include "util/indent.h"
 #include "util/stl_util.h"
 #include "zorbatypes/integer.h"

=== modified file 'src/runtime/full_text/icu_tokenizer.cpp'
--- src/runtime/full_text/icu_tokenizer.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/icu_tokenizer.cpp	2013-06-11 16:49:27 +0000
@@ -25,6 +25,7 @@
 #endif /* DEBUG_TOKENIZER */
 
 #include <zorba/diagnostic_list.h>
+#include <zorba/internal/cxx_util.h>
 #include <zorba/internal/unique_ptr.h>
 
 #include "diagnostics/assert.h"
@@ -32,7 +33,6 @@
 #include "diagnostics/xquery_exception.h"
 #include "diagnostics/zorba_exception.h"
 #include "util/ascii_util.h"
-#include "util/cxx_util.h"
 #include "util/stl_util.h"
 #include "util/unicode_util.h"
 #include "util/utf8_util.h"

=== modified file 'src/runtime/full_text/icu_tokenizer.h'
--- src/runtime/full_text/icu_tokenizer.h	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/icu_tokenizer.h	2013-06-11 16:49:27 +0000
@@ -19,12 +19,11 @@
 
 #include <unicode/rbbi.h>               /* for RuleBasedBreakIterator */
 
+#include <zorba/internal/cxx_util.h>
 #include <zorba/internal/unique_ptr.h>
 #include <zorba/locale.h>
 #include <zorba/tokenizer.h>
 
-#include "util/cxx_util.h"
-
 namespace zorba {
 
 ///////////////////////////////////////////////////////////////////////////////

=== modified file 'src/runtime/full_text/stemmer.cpp'
--- src/runtime/full_text/stemmer.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/stemmer.cpp	2013-06-11 16:49:27 +0000
@@ -15,7 +15,8 @@
  */
 #include "stdafx.h"
 
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
+
 #include "zorbautils/locale.h"
 #include "zorbautils/mutex.h"
 

=== modified file 'src/runtime/full_text/stemmer/sb_stemmer.cpp'
--- src/runtime/full_text/stemmer/sb_stemmer.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/stemmer/sb_stemmer.cpp	2013-06-11 16:49:27 +0000
@@ -15,7 +15,8 @@
  */
 #include "stdafx.h"
 
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
+
 #include "zorbautils/fatal.h"
 #include "zorbautils/locale.h"
 

=== modified file 'src/runtime/full_text/thesauri/encoded_list.h'
--- src/runtime/full_text/thesauri/encoded_list.h	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/thesauri/encoded_list.h	2013-06-11 16:49:27 +0000
@@ -20,7 +20,7 @@
 #include <cstddef>                      /* for size_t */
 #include <iterator>
 
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
 
 namespace zorba {
 

=== modified file 'src/runtime/full_text/thesauri/wn_thesaurus.cpp'
--- src/runtime/full_text/thesauri/wn_thesaurus.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/thesauri/wn_thesaurus.cpp	2013-06-11 16:49:27 +0000
@@ -21,24 +21,21 @@
 #include <cstring>                      /* for strcmp(3) */
 #include <limits>
 
-#include <zorba/util/path.h>
-
-#include <context/static_context.h>
-
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
+
+#include "context/static_context.h"
+#include "diagnostics/assert.h"
+#include "diagnostics/dict.h"
+#include "diagnostics/xquery_diagnostics.h"
+#include "system/globalenv.h"
 #include "util/fs_util.h"
 #include "util/less.h"
 #if DEBUG_FT_THESAURUS
-#include "util/oseparator.h"
+# include "util/oseparator.h"
 #endif
 #include "util/utf8_util.h"
-#include "diagnostics/assert.h"
-#include "diagnostics/dict.h"
-#include "diagnostics/xquery_diagnostics.h"
 #include "zorbautils/locale.h"
 
-#include "system/globalenv.h"
-
 #include "decode_base128.h"
 #include "wn_db_segment.h"
 #include "wn_synset.h"

=== modified file 'src/runtime/full_text/thesaurus.cpp'
--- src/runtime/full_text/thesaurus.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/thesaurus.cpp	2013-06-11 16:49:27 +0000
@@ -18,15 +18,16 @@
 #include <map>
 
 #include <zorba/config.h>
+#include <zorba/internal/cxx_util.h>
 
-#include <context/static_context.h>
-#include <diagnostics/dict.h>
-#include <diagnostics/xquery_diagnostics.h>
-#include <util/cxx_util.h>
-#include <util/fs_util.h>
-#include <util/less.h>
-#include <util/string_util.h>
-#include <util/uri_util.h>
+#include "context/default_url_resolvers.h"
+#include "context/static_context.h"
+#include "diagnostics/dict.h"
+#include "diagnostics/xquery_diagnostics.h"
+#include "util/fs_util.h"
+#include "util/less.h"
+#include "util/string_util.h"
+#include "util/uri_util.h"
 
 #include "thesaurus.h"
 #ifdef ZORBA_WITH_FILE_ACCESS
@@ -35,8 +36,6 @@
 #endif
 #include "thesauri/xqftts_thesaurus.h"
 
-#include "context/default_url_resolvers.h"
-
 using namespace std;
 using namespace zorba::locale;
 
@@ -112,8 +111,13 @@
       //
       zstring t_uri( url_copy );
       t_uri.replace( 0, 6, "file" );    // xqftts -> file
-      zstring const t_path( fs::get_normalized_path( t_uri ) );
-      return new xqftts::provider( t_path );
+      try {
+        zstring const t_path( fs::normalize_path( t_uri ) );
+        return new xqftts::provider( t_path );
+      }
+      catch ( invalid_argument const &e ) {
+        throw XQUERY_EXCEPTION( err::XPTY0004, ERROR_PARAMS( e.what() ) );
+      }
     }
 #   endif /* ZORBA_WITH_FILE_ACCESS */
     case thesaurus_impl::wordnet:

=== modified file 'src/runtime/json/json_impl.cpp'
--- src/runtime/json/json_impl.cpp	2013-02-26 04:12:43 +0000
+++ src/runtime/json/json_impl.cpp	2013-06-11 16:49:27 +0000
@@ -19,13 +19,12 @@
 #include <sstream>
 
 #include <zorba/diagnostic_list.h>
+#include <zorba/internal/cxx_util.h>
 
 #include "runtime/json/json.h"
 #include "store/api/item_factory.h"
 #include "system/globalenv.h"
-
 #include "util/ascii_util.h"
-#include "util/cxx_util.h"
 #include "util/mem_streambuf.h"
 #include "util/stream_util.h"
 

=== modified file 'src/runtime/json/jsonml_array.cpp'
--- src/runtime/json/jsonml_array.cpp	2013-04-02 02:48:56 +0000
+++ src/runtime/json/jsonml_array.cpp	2013-06-11 16:49:27 +0000
@@ -18,13 +18,13 @@
 #include <sstream>
 
 #include <zorba/diagnostic_list.h>
+#include <zorba/internal/cxx_util.h>
 
 #include "runtime/json/json.h"
 #include "store/api/item_factory.h"
 #include "system/globalenv.h"
 #include "types/root_typemanager.h"
 #include "util/ascii_util.h"
-#include "util/cxx_util.h"
 #include "util/json_parser.h"
 #include "util/json_util.h"
 #include "util/mem_streambuf.h"

=== modified file 'src/runtime/json/snelson.cpp'
--- src/runtime/json/snelson.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/json/snelson.cpp	2013-06-11 16:49:27 +0000
@@ -19,13 +19,13 @@
 #include <string>
 
 #include <zorba/diagnostic_list.h>
+#include <zorba/internal/cxx_util.h>
 
 #include "runtime/json/json.h"
 #include "store/api/item_factory.h"
 #include "system/globalenv.h"
 #include "types/root_typemanager.h"
 #include "util/ascii_util.h"
-#include "util/cxx_util.h"
 #include "util/indent.h"
 #include "util/json_parser.h"
 #include "util/json_util.h"

=== modified file 'src/runtime/util/doc_uri_heuristics.cpp'
--- src/runtime/util/doc_uri_heuristics.cpp	2012-10-16 14:30:02 +0000
+++ src/runtime/util/doc_uri_heuristics.cpp	2013-06-11 16:49:27 +0000
@@ -47,24 +47,31 @@
          uri::get_scheme(aUri) == uri::unknown) &&
         uri::get_scheme(lBaseUri) == uri::file)
     {
-      // Ok, we assume it's a filesystem path. First normalize it.
-      zstring lNormalizedPath = fs::get_normalized_path(
-          aUri,
-          zstring(""));
-      // QQQ For now, get_normalized_path() doesn't do what we
-      // want when base URI represents a file. So, when the
-      // normalized path is relative, we pretend it's a relative
-      // URI and resolve it as such.
-      if (fs::is_absolute(lNormalizedPath))
+      try
       {
-        URI::encode_file_URI(lNormalizedPath, *aResult);
+        // Ok, we assume it's a filesystem path. First normalize it.
+        zstring lNormalizedPath = fs::normalize_path(
+            aUri,
+            zstring(""));
+        // QQQ For now, normalize_path() doesn't do what we
+        // want when base URI represents a file. So, when the
+        // normalized path is relative, we pretend it's a relative
+        // URI and resolve it as such.
+        if (fs::is_absolute(lNormalizedPath))
+        {
+          URI::encode_file_URI(lNormalizedPath, *aResult);
+        }
+        else
+        {
+  #ifdef WIN32
+          ascii::replace_all(lNormalizedPath, '\\', '/');
+  #endif
+          *aResult = aSctx->resolve_relative_uri(lNormalizedPath, true);
+        }
       }
-      else
+      catch ( std::invalid_argument const &e )
       {
-#ifdef WIN32
-        ascii::replace_all(lNormalizedPath, '\\', '/');
-#endif
-        *aResult = aSctx->resolve_relative_uri(lNormalizedPath, true);
+        throw XQUERY_EXCEPTION( err::XPTY0004, ERROR_PARAMS( e.what() ) );
       }
     }
     else
@@ -87,6 +94,5 @@
   }
 }
 
-} /* namespace zorba */
+} // namespace zorba
 /* vim:set et sw=2 ts=2: */
-

=== modified file 'src/store/naive/ft_token_store.h'
--- src/store/naive/ft_token_store.h	2013-02-07 17:24:36 +0000
+++ src/store/naive/ft_token_store.h	2013-06-11 16:49:27 +0000
@@ -21,7 +21,8 @@
 #include <utility>                      /* for pair */
 #include <vector>
 
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
+
 #include "zorbatypes/ft_token.h"
 
 namespace zorba { 

=== modified file 'src/store/naive/naive_ft_token_iterator.cpp'
--- src/store/naive/naive_ft_token_iterator.cpp	2013-02-07 17:24:36 +0000
+++ src/store/naive/naive_ft_token_iterator.cpp	2013-06-11 16:49:27 +0000
@@ -15,8 +15,9 @@
  */
 #include "stdafx.h"
 
+#include <zorba/internal/cxx_util.h>
+
 #include "diagnostics/assert.h"
-#include "util/cxx_util.h"
 
 #include "naive_ft_token_iterator.h"
 

=== modified file 'src/store/naive/store.cpp'
--- src/store/naive/store.cpp	2013-03-20 18:39:54 +0000
+++ src/store/naive/store.cpp	2013-06-11 16:49:27 +0000
@@ -21,6 +21,8 @@
 
 #include <libxml/parser.h>
 
+#include <zorba/internal/cxx_util.h>
+
 #include "zorbautils/hashfun.h"
 #include "zorbautils/fatal.h"
 #include "zorbatypes/rchandle.h"
@@ -57,7 +59,6 @@
 #include "pul_primitive_factory.h"
 #include "tree_id_generator.h"
 
-#include "util/cxx_util.h"
 #include "zorbautils/string_util.h"
 
 #ifndef ZORBA_NO_FULL_TEXT

=== modified file 'src/unit_tests/CMakeLists.txt'
--- src/unit_tests/CMakeLists.txt	2013-04-16 18:24:35 +0000
+++ src/unit_tests/CMakeLists.txt	2013-06-11 16:49:27 +0000
@@ -17,6 +17,7 @@
   test_ato_.cpp
   test_base64.cpp
   test_base64_streambuf.cpp
+  test_fs_util.cpp
   test_hashmaps.cpp
   test_hexbinary.cpp
   test_json_parser.cpp
@@ -26,16 +27,11 @@
   test_time.cpp
   test_time_parse.cpp
   test_uri.cpp
+  test_utf8_streambuf.cpp
   test_uuid.cpp
   unit_tests.cpp
-  test_utf8_streambuf.cpp
 )
 
-IF (ZORBA_WITH_FILE_ACCESS)
-  LIST (APPEND UNIT_TEST_SRCS
-    test_fs_iterator.cpp)
-ENDIF (ZORBA_WITH_FILE_ACCESS)
-
 IF (NOT ZORBA_NO_FULL_TEXT)
   LIST (APPEND UNIT_TEST_SRCS
     test_stemmer.cpp

=== modified file 'src/unit_tests/test_ato_.cpp'
--- src/unit_tests/test_ato_.cpp	2013-05-03 23:19:41 +0000
+++ src/unit_tests/test_ato_.cpp	2013-06-11 16:49:27 +0000
@@ -19,7 +19,8 @@
 #include <stdexcept>
 #include <string>
 
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
+
 #include "util/string_util.h"
 
 using namespace std;

=== removed file 'src/unit_tests/test_fs_iterator.cpp'
--- src/unit_tests/test_fs_iterator.cpp	2012-04-22 15:49:55 +0000
+++ src/unit_tests/test_fs_iterator.cpp	1970-01-01 00:00:00 +0000
@@ -1,54 +0,0 @@
-/*
- * Copyright 2006-2010 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 "stdafx.h"
-
-#include <iostream>
-#include <zorba/zorba_exception.h>
-
-#include "util/fs_util.h"
-
-using namespace std;
-using namespace zorba;
-
-///////////////////////////////////////////////////////////////////////////////
-
-namespace zorba {
-namespace UnitTests {
-
-int test_fs_iterator( int argc, char *argv[] ) {
-  int result = 0;
-  try {
-#ifndef WIN32
-    fs::iterator dir_iter( "/" );
-#else
-    fs::iterator dir_iter( "C:\\" );
-#endif /* WIN32 */
-    while ( dir_iter.next() )
-      cout << dir_iter.entry_name() << " (" << dir_iter.entry_type() << ')' << endl;
-  }
-  catch ( ZorbaException const &e ) {
-    cerr << e << endl;
-    result = 2;
-  }
-
-  return result;
-}
-
-} // namespace UnitTests
-} // namespace zorba
-
-/* vim:set et sw=2 ts=2: */

=== added file 'src/unit_tests/test_fs_util.cpp'
--- src/unit_tests/test_fs_util.cpp	1970-01-01 00:00:00 +0000
+++ src/unit_tests/test_fs_util.cpp	2013-06-11 16:49:27 +0000
@@ -0,0 +1,178 @@
+/*
+ * 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 "stdafx.h"
+
+#include <cstring>
+
+#include "util/fs_util.h"
+
+using namespace std;
+using namespace zorba;
+
+struct test {
+  char const *input;
+  char const *expected;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static int failures;
+
+static bool assert_true( int no, char const *expr, int line, bool result ) {
+  if ( !result ) {
+    cout << '#' << no << " FAILED, line " << line << ": " << expr << endl;
+    ++failures;
+  }
+  return result;
+}
+
+static void print_exception( int no, char const *expr, int line,
+                             std::exception const &e ) {
+  assert_true( no, expr, line, false );
+  cout << "+ exception: " << e.what() << endl;
+}
+
+#define ASSERT_TRUE( NO, EXPR ) assert_true( NO, #EXPR, __LINE__, !!(EXPR) )
+
+#define ASSERT_NO_EXCEPTION( NO, EXPR ) \
+  try { EXPR; } \
+  catch ( exception const &e ) { print_exception( NO, #EXPR, __LINE__, e ); } \
+  catch ( ... ) { assert_true( NO, #EXPR, __LINE__, false ); }
+
+#define ASSERT_EXCEPTION( NO, EXPR, EXCEPTION ) \
+  try { EXPR; assert_true( NO, #EXPR, __LINE__, false ); } \
+  catch ( EXCEPTION const& ) { } \
+  catch ( ... ) { assert_true( NO, #EXPR, __LINE__, false ); }
+
+///////////////////////////////////////////////////////////////////////////////}
+
+void test_base_name( int no, char const *path, char const *expected ) {
+  ASSERT_TRUE( no, ::strcmp( fs::base_name( path ), expected ) == 0 );
+}
+
+void test_base_name( int no, string const &path, string const &expected ) {
+  ASSERT_TRUE( no, fs::base_name( path ) == expected );
+}
+
+void test_dir_name( int no, char const *path, char const *expected ) {
+  ASSERT_TRUE( no, fs::dir_name( path ) == expected );
+}
+
+void test_dir_name( int no, string const &path, string const &expected ) {
+  ASSERT_TRUE( no, fs::dir_name( path ) == expected );
+}
+
+void test_normalize_path( int no, char const *path, char const *expected ) {
+  ASSERT_TRUE( no, fs::normalize_path( path ) == expected );
+}
+
+///////////////////////////////////////////////////////////////////////////////}
+
+static test const base_name_tests[] = {
+#ifndef WIN32
+  /* 0 */ { "/a/b", "b" },
+  /* 1 */ { "/a"  , "a" },
+  /* 2 */ { "/"   , "/" },
+  /* 3 */ { "a/b" , "b" },
+  /* 4 */ { "a"   , "a" },
+#else
+  /* 0 */ { "C:\\a\\b", "b"    },
+  /* 1 */ { "C:\\a"   , "a"    },
+  /* 2 */ { "C:\\"    , "C:\\" },
+  /* 3 */ { "a\\b"    , "b"    },
+  /* 4 */ { "a"       , "a"    },
+#endif /* WIN32 */
+  { 0, 0 }
+};
+
+static test const dir_name_tests[] = {
+#ifndef WIN32
+  /* 0 */ { "/a/b", "/a" },
+  /* 1 */ { "/a"  , "/"  },
+  /* 2 */ { "/"   , "/"  },
+  /* 3 */ { "a/b" , "a"  },
+  /* 4 */ { "a"   , "."  },
+#else
+  /* 0 */ { "C:\\a\\b", "C:\\a" },
+  /* 1 */ { "C:\\a"   , "C:\\"  },
+  /* 2 */ { "C:\\"    , "C:\\"  },
+  /* 3 */ { "a\\b"    , "a"     },
+  /* 4 */ { "a"       , "."     },
+#endif /* WIN32 */
+  { 0, 0 }
+};
+
+static test normalize_path_tests[] = {
+#ifndef WIN32
+  /*  0 */ { "/a//b"                , "/a/b" },
+  /*  1 */ { "/a///b"               , "/a/b" },
+  /*  2 */ { "/a/./b"               , "/a/b" },
+  /*  3 */ { "/a/././b"             , "/a/b" },
+  /*  4 */ { "/a/b/."               , "/a/b" },
+  /*  5 */ { "/a/../b"              , "/b"   },
+  /*  6 */ { "/a/b/../../c"         , "/c"   },
+  /*  7 */ { "/a/b/../c/../d"       , "/a/d" },
+  /*  8 */ { "/a/b/.."              , "/a"   },
+  /*  9 */ { "file:///a/b"          , "/a/b" },
+  /* 10 */ { "file://localhost/a/b" , "/a/b" },
+  /* 11 */ { "\\a\\b"               , "/a/b" },
+#else
+  /*  0 */ { "C:\\a\\\\b"                 , "C:\\a\\b" },
+  /*  1 */ { "C:\\a\\\\\\b"               , "C:\\a\\b" },
+  /*  2 */ { "C:\\a\\.\\b"                , "C:\\a\\b" },
+  /*  3 */ { "C:\\a\\.\\.\\b"             , "C:\\a\\b" },
+  /*  4 */ { "C:\\a\\b\\."                , "C:\\a\\b" },
+  /*  5 */ { "C:\\a\\..\\b"               , "C:\\b"    },
+  /*  6 */ { "C:\\a\\b\\..\\..\\c"        , "C:\\c"    },
+  /*  7 */ { "C:\\a\\b\\..\\c\\..\\d"     , "C:\\a\\d" },
+  /*  8 */ { "C:\\a\\b\\.."               , "C:\\a"    },
+  /*  9 */ { "file:///C%3A/a/b"           , "C:\\a\\b" },
+  /* 10 */ { "file://localhost/C%3A/a/b"  , "C:\\a\\b" },
+  /* 11 */ { "C:/a/b"                     , "C:\\a\\b" },
+#endif /* WIN32 */
+  { 0, 0 }
+};
+
+namespace zorba {
+namespace UnitTests {
+
+int test_fs_util( int, char*[] ) {
+  int test_no = 0;
+
+  for ( test const *t = base_name_tests; t->input; ++t, ++test_no ) {
+    test_base_name( test_no, t->input, t->expected );
+    test_base_name( test_no, string( t->input ), string( t->expected ) );
+  }
+
+  test_no = 0;
+  for ( test const *t = dir_name_tests; t->input; ++t, ++test_no ) {
+    test_dir_name( test_no, t->input, t->expected );
+    test_dir_name( test_no, string( t->input ), string( t->expected ) );
+  }
+
+  test_no = 0;
+  for ( test const *t = normalize_path_tests; t->input; ++t, ++test_no )
+    test_normalize_path( test_no, t->input, t->expected );
+
+  cout << failures << " test(s) failed\n";
+  return failures ? 1 : 0;
+}
+
+} // namespace UnitTests
+} // namespace zorba
+
+/* vim:set et sw=2 ts=2: */

=== modified file 'src/unit_tests/test_mem_sizeof.cpp'
--- src/unit_tests/test_mem_sizeof.cpp	2013-04-17 18:37:33 +0000
+++ src/unit_tests/test_mem_sizeof.cpp	2013-06-11 16:49:27 +0000
@@ -18,7 +18,8 @@
 #include <iostream>
 #include <string>
 
-#include "util/cxx_util.h"
+#include <zorba/internal/cxx_util.h>
+
 #include "util/mem_sizeof.h"
 
 using namespace std;

=== modified file 'src/unit_tests/test_string.cpp'
--- src/unit_tests/test_string.cpp	2013-05-08 01:05:04 +0000
+++ src/unit_tests/test_string.cpp	2013-06-11 16:49:27 +0000
@@ -403,9 +403,9 @@
   ascii::replace_all( s2, '/', '\\' );
   ASSERT_TRUE( s2 == t );
 
-  s1 = StringType ("\"");
-  t = StringType("\\\"");
-  ascii::replace_all( s1, "\"", "\\\"");
+  s1 = '"';
+  t = "\\\"";
+  ascii::replace_all( s1, "\"", "\\\"" );
   ASSERT_TRUE( s1 == t );
 }
 

=== modified file 'src/unit_tests/unit_test_list.h'
--- src/unit_tests/unit_test_list.h	2013-04-16 18:24:35 +0000
+++ src/unit_tests/unit_test_list.h	2013-06-11 16:49:27 +0000
@@ -31,6 +31,7 @@
   int test_ato_( int, char*[] );
   int test_base64( int, char*[] );
   int test_base64_streambuf( int, char*[] );
+  int test_fs_util( int, char*[] );
   int test_hashmaps( int argc, char* argv[] );
   int test_hexbinary( int argc, char* argv[] );
 
@@ -45,10 +46,6 @@
   int test_time( int, char*[] );
   int test_time_parse( int, char*[] );
 
-#ifdef ZORBA_WITH_FILE_ACCESS
-  int test_fs_iterator( int, char*[] );
-#endif /* ZORBA_WITH_FILE_ACCESS */
-
 #ifndef ZORBA_NO_FULL_TEXT
   int test_stemmer( int, char*[] );
   int test_thesaurus( int, char*[] );

=== modified file 'src/unit_tests/unit_tests.cpp'
--- src/unit_tests/unit_tests.cpp	2013-04-16 18:24:35 +0000
+++ src/unit_tests/unit_tests.cpp	2013-06-11 16:49:27 +0000
@@ -40,11 +40,7 @@
   libunittests["ato"] = test_ato_;
   libunittests["base64"] = test_base64;
   libunittests["base64_streambuf"] = test_base64_streambuf;
-
-#ifdef ZORBA_WITH_FILE_ACCESS
-  libunittests["fs_iterator"] = test_fs_iterator;
-#endif /* ZORBA_WITH_FILE_ACCESS */
-
+  libunittests["fs_util"] = test_fs_util;
   libunittests["hashmaps"] = test_hashmaps;
   libunittests["hexbinary"] = test_hexbinary;
 

=== modified file 'src/util/CMakeLists.txt'
--- src/util/CMakeLists.txt	2013-04-12 04:34:41 +0000
+++ src/util/CMakeLists.txt	2013-06-11 16:49:27 +0000
@@ -17,7 +17,6 @@
   base64_util.cpp
   dynamic_bitset.cpp
   error_util.cpp
-  file.cpp
   fs_util.cpp
   hexbinary_util.cpp
   indent.cpp

=== modified file 'src/util/base64_util.h'
--- src/util/base64_util.h	2013-05-09 00:48:27 +0000
+++ src/util/base64_util.h	2013-06-11 16:49:27 +0000
@@ -25,8 +25,8 @@
 #include <vector>
 
 // Zorba
+#include <zorba/internal/cxx_util.h>
 #include <zorba/internal/ztd.h>
-#include "cxx_util.h"
 #include "stream_util.h"
 
 namespace zorba {

=== modified file 'src/util/cxx_util.cpp'
--- src/util/cxx_util.cpp	2013-01-15 19:16:16 +0000
+++ src/util/cxx_util.cpp	2013-06-11 16:49:27 +0000
@@ -20,9 +20,9 @@
 
 #ifndef ZORBA_CXX_NULLPTR
 
-#include "cxx_util.h"
+#include <zorba/internal/cxx_util.h>
 
-zorba::nullptr_type const zorba_nullptr = { };
+zorba::internal::nullptr_type const zorba_nullptr = { };
 
 #endif /* ZORBA_CXX_NULLPTR */
 

=== modified file 'src/util/error_util.cpp'
--- src/util/error_util.cpp	2013-02-07 17:24:36 +0000
+++ src/util/error_util.cpp	2013-06-11 16:49:27 +0000
@@ -17,7 +17,6 @@
 
 #include <sstream>
 
-# include <cstring>
 #ifndef WIN32
 # include <cstdio>
 #else
@@ -25,11 +24,11 @@
 #endif /* WIN32 */
 
 #include <zorba/internal/unique_ptr.h>
+#include <zorba/util/error_util.h>
 
 #include "diagnostics/dict.h"
 #include "diagnostics/diagnostic.h"
 
-#include "error_util.h"
 #include "stl_util.h"
 
 namespace zorba {
@@ -39,12 +38,8 @@
 
 ////////// exception //////////////////////////////////////////////////////////
 
-exception::~exception() throw() {
-  // out-of-line since it's virtual
-}
-
-string exception::make_what( char const *function, char const *path,
-                             char const *err_string ) {
+static string make_what( char const *function, char const *path,
+                         char const *err_string ) {
   ostringstream oss;
   if ( path && *path )