Initial version 3 commit, from sandbox filesystem-v3 at revision 62344

[SVN r62345]

v3/boost/filesystem.hpp

@@ -0,0 +1,21 @@
+//  boost/filesystem/filesystem.hpp  -----------------------------------------//
+
+//  Copyright Beman Dawes 2005
+
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/filesystem
+
+//----------------------------------------------------------------------------// 
+
+#ifndef BOOST_FILESYSTEM_FILESYSTEM_HPP
+#define BOOST_FILESYSTEM_FILESYSTEM_HPP
+
+#include <boost/filesystem/config.hpp>
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <boost/filesystem/convenience.hpp>
+#endif
+

v3/boost/filesystem/config.hpp

@@ -0,0 +1,82 @@
+//  boost/filesystem/config.hpp  -------------------------------------------------------//
+
+//  Copyright Beman Dawes 2003
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+//--------------------------------------------------------------------------------------// 
+
+#ifndef BOOST_FILESYSTEM_CONFIG_HPP
+#define BOOST_FILESYSTEM_CONFIG_HPP
+
+#define BOOST_FILESYSTEM_I18N  // aid users wishing to compile several versions
+
+//  ability to change namespace aids path_table.cpp  ----------------------------------// 
+#ifndef BOOST_FILESYSTEM_NAMESPACE
+# define BOOST_FILESYSTEM_NAMESPACE filesystem
+#endif
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+#include <boost/config.hpp>
+#include <boost/system/api_config.hpp>  // for BOOST_POSIX_API or BOOST_WINDOWS_API
+#include <boost/detail/workaround.hpp> 
+
+//  BOOST_FILESYSTEM_DEPRECATED needed for source compiles -----------------------------//
+
+# ifdef BOOST_FILESYSTEM_SOURCE
+#   define BOOST_FILESYSTEM_DEPRECATED
+# endif
+
+//  throw an exception  ----------------------------------------------------------------//
+//
+//  Exceptions were originally thrown via boost::throw_exception().
+//  As throw_exception() became more complex, it caused user error reporting
+//  to be harder to interpret, since the exception reported became much more complex.
+//  The immediate fix was to throw directly, wrapped in a macro to make any later change
+//  easier.
+
+#define BOOST_FILESYSTEM_THROW(EX) throw EX
+
+# if defined( BOOST_NO_STD_WSTRING )
+#   error Configuration not supported: Boost.Filesystem V3 and later requires std::wstring support
+# endif
+
+//  enable dynamic linking -------------------------------------------------------------//
+
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_FILESYSTEM_DYN_LINK)
+# if defined(BOOST_FILESYSTEM_SOURCE)
+#   define BOOST_FILESYSTEM_DECL BOOST_SYMBOL_EXPORT
+# else 
+#   define BOOST_FILESYSTEM_DECL BOOST_SYMBOL_IMPORT
+# endif
+#else
+# define BOOST_FILESYSTEM_DECL
+#endif
+
+//  enable automatic library variant selection  ----------------------------------------// 
+
+#if !defined(BOOST_FILESYSTEM_SOURCE) && !defined(BOOST_ALL_NO_LIB) \
+  && !defined(BOOST_FILESYSTEM_NO_LIB)
+//
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_filesystem
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_FILESYSTEM_DYN_LINK)
+#  define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#endif // BOOST_FILESYSTEM_CONFIG_HPP

v3/boost/filesystem/convenience.hpp

@@ -0,0 +1,52 @@
+//  boost/filesystem/convenience.hpp  ----------------------------------------//
+
+//  Copyright Beman Dawes, 2002-2005
+//  Copyright Vladimir Prus, 2002
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/filesystem
+
+//----------------------------------------------------------------------------// 
+
+#ifndef BOOST_FILESYSTEM_CONVENIENCE_HPP
+#define BOOST_FILESYSTEM_CONVENIENCE_HPP
+
+#include <boost/filesystem/operations.hpp>
+#include <boost/system/error_code.hpp>
+
+#include <boost/config/abi_prefix.hpp> // must be the last #include
+
+namespace boost
+{
+  namespace filesystem
+  {
+
+# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
+
+    std::string extension(const path & p)
+    {
+      return p.extension().string();
+    }
+
+    std::string basename(const path & p)
+    {
+      return p.stem().string();
+    }
+
+    path change_extension( const path & p, const path & new_extension )
+    { 
+      path new_p( p );
+      new_p.replace_extension( new_extension );
+      return new_p;
+    }
+
+# endif
+
+
+  } // namespace filesystem
+} // namespace boost
+
+#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
+#endif // BOOST_FILESYSTEM_CONVENIENCE_HPP

v3/boost/filesystem/exception.hpp

@@ -0,0 +1,9 @@
+//  boost/filesystem/exception.hpp  -----------------------------------------------------//
+
+//  Copyright Beman Dawes 2003
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  This header is no longer used. The contents have been moved to path.hpp.
+//  It is provided so that user code #includes do not have to be changed.

v3/boost/filesystem/fstream.hpp

@@ -0,0 +1,176 @@
+//  boost/filesystem/fstream.hpp  ------------------------------------------------------//
+
+//  Copyright Beman Dawes 2002
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+//--------------------------------------------------------------------------------------// 
+
+#ifndef BOOST_FILESYSTEM_FSTREAM_HPP
+#define BOOST_FILESYSTEM_FSTREAM_HPP
+
+#include <boost/filesystem/path.hpp>
+#include <boost/config.hpp>
+
+#include <iosfwd>
+#include <fstream>
+
+#include <boost/config/abi_prefix.hpp> // must be the last #include
+
+//  glibc++ doesn't have wchar_t overloads for file stream paths, so on Windows use
+//  path::string() to get a narrow character c_str()
+#if defined(BOOST_WINDOWS_API) && defined(__GLIBCXX__)
+# define BOOST_FILESYSTEM_C_STR string().c_str()
+#else
+# define BOOST_FILESYSTEM_C_STR c_str()
+#endif
+
+namespace boost
+{
+namespace filesystem
+{
+
+//--------------------------------------------------------------------------------------//
+//                                  basic_filebuf                                       //
+//--------------------------------------------------------------------------------------//
+
+  template < class charT, class traits = std::char_traits<charT> >
+  class basic_filebuf : public std::basic_filebuf<charT,traits>
+  {
+  private: // disallow copying
+    basic_filebuf(const basic_filebuf&);
+    const basic_filebuf& operator=(const basic_filebuf&);
+
+  public:
+    basic_filebuf() {}
+    virtual ~basic_filebuf() {}
+
+    basic_filebuf<charT,traits>*
+      open(const path& p, std::ios_base::openmode mode) 
+    {
+      return std::basic_filebuf<charT,traits>::open(p.BOOST_FILESYSTEM_C_STR, mode)
+        ? this : 0;
+    }
+  };
+
+//--------------------------------------------------------------------------------------//
+//                                 basic_ifstream                                       //
+//--------------------------------------------------------------------------------------//
+
+  template < class charT, class traits = std::char_traits<charT> >
+  class basic_ifstream : public std::basic_ifstream<charT,traits>
+  {
+  private: // disallow copying
+    basic_ifstream(const basic_ifstream&);
+    const basic_ifstream& operator=(const basic_ifstream&);
+
+  public:
+    basic_ifstream() {}
+
+    // use two signatures, rather than one signature with default second
+    // argument, to workaround VC++ 7.1 bug (ID VSWhidbey 38416)
+
+    explicit basic_ifstream(const path& p)
+      : std::basic_ifstream<charT,traits>(p.BOOST_FILESYSTEM_C_STR, std::ios_base::in) {}
+
+    basic_ifstream(const path& p, std::ios_base::openmode mode)
+      : std::basic_ifstream<charT,traits>(p.BOOST_FILESYSTEM_C_STR, mode) {}
+
+    void open(const path& p)
+      { std::basic_ifstream<charT,traits>::open(p.BOOST_FILESYSTEM_C_STR, std::ios_base::in); }
+
+    void open(const path& p, std::ios_base::openmode mode)
+      { std::basic_ifstream<charT,traits>::open(p.BOOST_FILESYSTEM_C_STR, mode); }
+
+    virtual ~basic_ifstream() {}
+  };
+
+//--------------------------------------------------------------------------------------//
+//                                 basic_ofstream                                       //
+//--------------------------------------------------------------------------------------//
+
+  template < class charT, class traits = std::char_traits<charT> >
+  class basic_ofstream : public std::basic_ofstream<charT,traits>
+  {
+  private: // disallow copying
+    basic_ofstream(const basic_ofstream&);
+    const basic_ofstream& operator=(const basic_ofstream&);
+
+  public:
+    basic_ofstream() {}
+
+    // use two signatures, rather than one signature with default second
+    // argument, to workaround VC++ 7.1 bug (ID VSWhidbey 38416)
+
+    explicit basic_ofstream(const path& p)
+      : std::basic_ofstream<charT,traits>(p.BOOST_FILESYSTEM_C_STR, std::ios_base::out) {}
+
+    basic_ofstream(const path& p, std::ios_base::openmode mode)
+      : std::basic_ofstream<charT,traits>(p.BOOST_FILESYSTEM_C_STR, mode) {}
+
+    void open(const path& p)
+      { std::basic_ofstream<charT,traits>::open(p.BOOST_FILESYSTEM_C_STR, std::ios_base::out); }
+
+    void open(const path& p, std::ios_base::openmode mode)
+      { std::basic_ofstream<charT,traits>::open(p.BOOST_FILESYSTEM_C_STR, mode); }
+
+    virtual ~basic_ofstream() {}
+  };
+
+//--------------------------------------------------------------------------------------//
+//                                  basic_fstream                                       //
+//--------------------------------------------------------------------------------------//
+
+  template < class charT, class traits = std::char_traits<charT> >
+  class basic_fstream : public std::basic_fstream<charT,traits>
+  {
+  private: // disallow copying
+    basic_fstream(const basic_fstream&);
+    const basic_fstream & operator=(const basic_fstream&);
+
+  public:
+    basic_fstream() {}
+
+    // use two signatures, rather than one signature with default second
+    // argument, to workaround VC++ 7.1 bug (ID VSWhidbey 38416)
+
+    explicit basic_fstream(const path& p)
+      : std::basic_fstream<charT,traits>(p.BOOST_FILESYSTEM_C_STR,
+          std::ios_base::in | std::ios_base::out) {}
+
+    basic_fstream(const path& p, std::ios_base::openmode mode)
+      : std::basic_fstream<charT,traits>(p.BOOST_FILESYSTEM_C_STR, mode) {}
+
+    void open(const path& p)
+      { std::basic_fstream<charT,traits>::open(p.BOOST_FILESYSTEM_C_STR,
+          std::ios_base::in | std::ios_base::out); }
+
+    void open(const path& p, std::ios_base::openmode mode)
+      { std::basic_fstream<charT,traits>::open(p.BOOST_FILESYSTEM_C_STR, mode); }
+
+    virtual ~basic_fstream() {}
+
+  };
+
+//--------------------------------------------------------------------------------------//
+//                                    typedefs                                          //
+//--------------------------------------------------------------------------------------//
+
+  typedef basic_filebuf<char> filebuf;
+  typedef basic_ifstream<char> ifstream;
+  typedef basic_ofstream<char> ofstream;
+  typedef basic_fstream<char> fstream;
+
+  typedef basic_filebuf<wchar_t> wfilebuf;
+  typedef basic_ifstream<wchar_t> wifstream;
+  typedef basic_fstream<wchar_t> wfstream;
+  typedef basic_ofstream<wchar_t> wofstream;
+  
+} // namespace filesystem
+} // namespace boost
+
+#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
+#endif  // BOOST_FILESYSTEM_FSTREAM_HPP

v3/boost/filesystem/operations.hpp

@@ -0,0 +1,918 @@
+//  boost/filesystem/operations.hpp  ---------------------------------------------------//
+
+//  Copyright Beman Dawes 2002-2009
+//  Copyright Jan Langer 2002
+//  Copyright Dietmar Kuehl 2001                                        
+//  Copyright Vladimir Prus 2002
+   
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+//--------------------------------------------------------------------------------------//
+
+#ifndef BOOST_FILESYSTEM_OPERATIONS_HPP
+#define BOOST_FILESYSTEM_OPERATIONS_HPP
+
+#include <boost/filesystem/path.hpp>
+
+#include <boost/detail/scoped_enum_emulation.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/system/system_error.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/iterator.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/assert.hpp>
+
+#include <string>
+#include <utility> // for pair
+#include <ctime>
+#include <vector>
+#include <stack>
+
+#ifdef BOOST_WINDOWS_API
+#  include <fstream>
+#endif
+
+#include <boost/config/abi_prefix.hpp> // must be the last #include
+
+//--------------------------------------------------------------------------------------//
+
+namespace boost
+{
+  namespace filesystem
+  {
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                            support classes and enums                                 //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+  enum file_type
+  { 
+    status_error,
+#   ifndef BOOST_FILESYSTEM_NO_DEPRECATED
+    status_unknown = status_error,
+#   endif
+    file_not_found,
+    regular_file,
+    directory_file,
+    // the following will never be reported by some operating or file systems
+    symlink_file,
+    block_file,
+    character_file,
+    fifo_file,
+    socket_file,
+    type_unknown // file does exist, but isn't one of the above types or
+                 // we don't have strong enough permission to find its type
+  };
+
+  class BOOST_FILESYSTEM_DECL file_status
+  {
+  public:
+    explicit file_status(file_type v = status_error) : m_value(v) {}
+
+    void type(file_type v)    { m_value = v; }
+    file_type type() const    { return m_value; }
+
+    bool operator==(const file_status& rhs) const { return type() == rhs.type(); }
+    bool operator!=(const file_status& rhs) const { return !(*this == rhs); }
+
+  private:
+    // the internal representation is unspecified so that additional state
+    // information such as permissions can be added in the future; this
+    // implementation just uses file_type as the internal representation
+
+    file_type m_value;
+  };
+
+  inline bool status_known(file_status f) { return f.type() != status_error; }
+  inline bool exists(file_status f)       { return f.type() != status_error
+                                                && f.type() != file_not_found; }
+  inline bool is_regular_file(file_status f){ return f.type() == regular_file; }
+  inline bool is_directory(file_status f) { return f.type() == directory_file; }
+  inline bool is_symlink(file_status f)   { return f.type() == symlink_file; }
+  inline bool is_other(file_status f)     { return exists(f) && !is_regular_file(f)
+                                                && !is_directory(f) && !is_symlink(f); }
+
+# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
+  inline bool is_regular(file_status f)   { return f.type() == regular_file; }
+# endif
+
+  struct space_info
+  {
+    // all values are byte counts
+    boost::uintmax_t capacity;
+    boost::uintmax_t free;      // <= capacity
+    boost::uintmax_t available; // <= free
+  };
+
+  BOOST_SCOPED_ENUM_START(copy_option)
+    {fail_if_exists, overwrite_if_exists};
+  BOOST_SCOPED_ENUM_END
+
+//--------------------------------------------------------------------------------------//
+//                             implementation details                                   //
+//--------------------------------------------------------------------------------------//
+
+  namespace detail
+  {
+    BOOST_FILESYSTEM_DECL
+    file_status status(const path&p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    file_status symlink_status(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    bool is_empty(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    path initial_path(system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    void copy(const path& from, const path& to, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    void copy_directory(const path& from, const path& to, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    void copy_file(const path& from, const path& to,
+                    BOOST_SCOPED_ENUM(copy_option) option,  // See ticket #2925
+                    system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    void copy_symlink(const path& from, const path& to, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    bool create_directories(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    bool create_directory(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    void create_directory_symlink(const path& to, const path& from,
+                                   system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    void create_hard_link(const path& to, const path& from, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    void create_symlink(const path& to, const path& from, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    path current_path(system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    void current_path(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    bool equivalent(const path& p1, const path& p2, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    boost::uintmax_t file_size(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    boost::uintmax_t hard_link_count(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    std::time_t last_write_time(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    void last_write_time(const path& p, const std::time_t new_time,
+                     system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    path read_symlink(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+      // For standardization, if the committee doesn't like "remove", consider "eliminate"
+    bool remove(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    boost::uintmax_t remove_all(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    void rename(const path& old_p, const path& new_p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    void resize_file(const path& p, uintmax_t size, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    space_info space(const path& p, system::error_code* ec=0); 
+    BOOST_FILESYSTEM_DECL
+    path system_complete(const path& p, system::error_code* ec=0);
+    BOOST_FILESYSTEM_DECL
+    path unique_path(const path& p, system::error_code* ec=0);
+  }  // namespace detail
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                             status query functions                                   //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+  inline
+  file_status status(const path& p)    {return detail::status(p);}
+  inline 
+  file_status status(const path& p, system::error_code& ec)
+                                       {return detail::status(p, &ec);}
+  inline 
+  file_status symlink_status(const path& p) {return detail::symlink_status(p);}
+  inline
+  file_status symlink_status(const path& p, system::error_code& ec)
+                                       {return detail::symlink_status(p, &ec);}
+  inline 
+  bool exists(const path& p)           {return exists(detail::status(p));}
+  inline 
+  bool exists(const path& p, system::error_code& ec)
+                                       {return exists(detail::status(p, &ec));}
+  inline 
+  bool is_directory(const path& p)     {return is_directory(detail::status(p));}
+  inline 
+  bool is_directory(const path& p, system::error_code& ec)
+                                       {return is_directory(detail::status(p, &ec));}
+  inline 
+  bool is_regular_file(const path& p)  {return is_regular_file(detail::status(p));}
+  inline 
+  bool is_regular_file(const path& p, system::error_code& ec)
+                                       {return is_regular_file(detail::status(p, &ec));}
+  inline 
+  bool is_other(const path& p)         {return is_other(detail::status(p));}
+  inline 
+  bool is_other(const path& p, system::error_code& ec)
+                                       {return is_other(detail::status(p, &ec));}
+  inline
+  bool is_symlink(const path& p)       {return is_symlink(detail::symlink_status(p));}
+  inline 
+  bool is_symlink(const path& p, system::error_code& ec)
+                                       {return is_symlink(detail::symlink_status(p, &ec));}
+# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
+  inline
+  bool is_regular(const path& p)       {return is_regular(detail::status(p));}
+  inline
+  bool is_regular(const path& p, system::error_code& ec)
+                                       {return is_regular(detail::status(p, &ec));}
+# endif
+
+  inline
+  bool is_empty(const path& p)         {return detail::is_empty(p);}
+  inline
+  bool is_empty(const path& p, system::error_code& ec)
+                                       {return detail::is_empty(p, &ec);}
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                             operational functions                                    //
+//                  in alphabetical order, unless otherwise noted                       //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
+  inline
+  path complete(const path& p)
+  {
+    return path(p).make_absolute(detail::initial_path(0));
+  }
+
+  inline
+  path complete(const path& p, const path& base)
+  {
+    return path(p).make_absolute(base);
+  }
+# endif
+
+  inline
+  void copy(const path& from, const path& to) {detail::copy(from, to);}
+
+  inline
+  void copy(const path& from, const path& to, system::error_code& ec) 
+                                       {detail::copy(from, to, &ec);}
+  inline
+  void copy_directory(const path& from, const path& to)
+                                       {detail::copy_directory(from, to);}
+  inline
+  void copy_directory(const path& from, const path& to, system::error_code& ec)
+                                       {detail::copy_directory(from, to, &ec);}
+  inline
+  void copy_file(const path& from, const path& to,   // See ticket #2925
+                 BOOST_SCOPED_ENUM(copy_option) option)
+                                       {detail::copy_file(from, to, option);}
+  inline
+  void copy_file(const path& from, const path& to)
+                                       {detail::copy_file(from, to, copy_option::fail_if_exists);}
+  inline
+  void copy_file(const path& from, const path& to,   // See ticket #2925
+                 BOOST_SCOPED_ENUM(copy_option) option, system::error_code& ec)
+                                       {detail::copy_file(from, to, option, &ec);}
+  inline
+  void copy_file(const path& from, const path& to, system::error_code& ec)
+                                       {detail::copy_file(from, to, copy_option::fail_if_exists, &ec);}
+  inline
+  void copy_symlink(const path& from, const path& to) {detail::copy_symlink(from, to);}
+
+  inline
+  void copy_symlink(const path& from, const path& to, system::error_code& ec)
+                                       {detail::copy_symlink(from, to, &ec);}
+  inline
+  bool create_directories(const path& p) {return detail::create_directories(p);}
+
+  inline
+  bool create_directories(const path& p, system::error_code& ec)
+                                       {return detail::create_directories(p, &ec);}
+  inline
+  bool create_directory(const path& p) {return detail::create_directory(p);}
+
+  inline
+  bool create_directory(const path& p, system::error_code& ec)
+                                       {return detail::create_directory(p, &ec);}
+  inline
+  void create_directory_symlink(const path& to, const path& from)
+                                       {detail::create_directory_symlink(to, from);}
+  inline
+  void create_directory_symlink(const path& to, const path& from, system::error_code& ec)
+                                       {detail::create_directory_symlink(to, from, &ec);}
+  inline
+  void create_hard_link(const path& to, const path& from) {detail::create_hard_link(to, from);}
+
+  inline
+  void create_hard_link(const path& to, const path& from, system::error_code& ec)
+                                       {detail::create_hard_link(to, from, &ec);}
+  inline
+  void create_symlink(const path& to, const path& from) {detail::create_symlink(to, from);}
+
+  inline
+  void create_symlink(const path& to, const path& from, system::error_code& ec)
+                                       {detail::create_symlink(to, from, &ec);}
+  inline
+  path current_path()                  {return detail::current_path();}
+
+  inline
+  path current_path(system::error_code& ec) {return detail::current_path(&ec);}
+
+  inline
+  void current_path(const path& p)     {detail::current_path(p);}
+
+  inline
+  void current_path(const path& p, system::error_code& ec) {detail::current_path(p, &ec);}
+
+  inline
+  bool equivalent(const path& p1, const path& p2) {return detail::equivalent(p1, p2);}
+
+  inline
+  bool equivalent(const path& p1, const path& p2, system::error_code& ec)
+                                       {return detail::equivalent(p1, p2, &ec);}
+  inline
+  boost::uintmax_t file_size(const path& p) {return detail::file_size(p);}
+
+  inline
+  boost::uintmax_t file_size(const path& p, system::error_code& ec)
+                                       {return detail::file_size(p, &ec);}
+  inline
+  boost::uintmax_t hard_link_count(const path& p) {return detail::hard_link_count(p);}
+
+  inline
+  boost::uintmax_t hard_link_count(const path& p, system::error_code& ec)
+                                       {return detail::hard_link_count(p, &ec);}
+  inline
+  path initial_path()                  {return detail::initial_path();}
+
+  inline
+  path initial_path(system::error_code& ec) {return detail::initial_path(&ec);}
+
+# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
+  //  support legacy initial_path<...>()
+  template <class Path>
+  path initial_path() {return initial_path();}
+  template <class Path>
+  path initial_path(system::error_code& ec) {return detail::initial_path(&ec);}
+# endif
+
+  inline
+  std::time_t last_write_time(const path& p) {return detail::last_write_time(p);}
+
+  inline
+  std::time_t last_write_time(const path& p, system::error_code& ec)
+                                       {return detail::last_write_time(p, &ec);}
+  inline
+  void last_write_time(const path& p, const std::time_t new_time)
+                                       {detail::last_write_time(p, new_time);}
+  inline
+  void last_write_time(const path& p, const std::time_t new_time, system::error_code& ec)
+                                       {detail::last_write_time(p, new_time, &ec);}
+  inline
+  path read_symlink(const path& p)     {return detail::read_symlink(p);}
+
+  inline
+  path read_symlink(const path& p, system::error_code& ec)
+                                       {return detail::read_symlink(p, &ec);}
+  inline
+    // For standardization, if the committee doesn't like "remove", consider "eliminate"
+  bool remove(const path& p)           {return detail::remove(p);}
+
+  inline
+  bool remove(const path& p, system::error_code& ec) {return detail::remove(p, &ec);}
+
+  inline
+  boost::uintmax_t remove_all(const path& p) {return detail::remove_all(p);}
+    
+  inline
+  boost::uintmax_t remove_all(const path& p, system::error_code& ec)
+                                       {return detail::remove_all(p, &ec);}
+  inline
+  void rename(const path& old_p, const path& new_p) {detail::rename(old_p, new_p);}
+
+  inline
+  void rename(const path& old_p, const path& new_p, system::error_code& ec)
+                                       {detail::rename(old_p, new_p, &ec);}
+  inline  // name suggested by Scott McMurray
+  void resize_file(const path& p, uintmax_t size) {detail::resize_file(p, size);}
+
+  inline
+  void resize_file(const path& p, uintmax_t size, system::error_code& ec)
+                                       {detail::resize_file(p, size, &ec);}
+  inline
+  space_info space(const path& p)      {return detail::space(p);} 
+
+  inline
+  space_info space(const path& p, system::error_code& ec) {return detail::space(p, &ec);} 
+
+# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
+  inline bool symbolic_link_exists(const path& p)
+                                       { return is_symlink(symlink_status(p)); }
+# endif
+
+  inline
+  path system_complete(const path& p)  {return detail::system_complete(p);}
+
+  inline
+  path system_complete(const path& p, system::error_code& ec)
+                                       {return detail::system_complete(p, &ec);}
+  inline
+  path unique_path(const path& p="%%%%-%%%%-%%%%-%%%%")
+                                       { return detail::unique_path(p); }
+  inline
+  path unique_path(const path& p, system::error_code& ec)
+                                       { return detail::unique_path(p, &ec); }
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                                 directory_entry                                      //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+//  GCC has a problem with a member function named path within a namespace or 
+//  sub-namespace that also has a class named path. The workaround is to always
+//  fully qualify the name path when it refers to the class name.
+
+class BOOST_FILESYSTEM_DECL directory_entry
+{
+public:
+
+  // compiler generated copy constructor, copy assignment, and destructor apply
+
+  directory_entry() {}
+  explicit directory_entry(const boost::filesystem::path& p,
+    file_status st = file_status(), file_status symlink_st=file_status())
+    : m_path(p), m_status(st), m_symlink_status(symlink_st)
+    {}
+
+  void assign(const boost::filesystem::path& p,
+    file_status st = file_status(), file_status symlink_st = file_status())
+    { m_path = p; m_status = st; m_symlink_status = symlink_st; }
+
+  void replace_filename(const boost::filesystem::path& p,
+    file_status st = file_status(), file_status symlink_st = file_status())
+  {
+    m_path.remove_filename();
+    m_path /= p;
+    m_status = st;
+    m_symlink_status = symlink_st;
+  }
+
+# ifndef BOOST_FILESYSTEM_NO_DEPRECATED
+  void replace_leaf(const boost::filesystem::path& p,
+    file_status st, file_status symlink_st)
+      { replace_filename(p, st, symlink_st); }
+# endif
+
+  const boost::filesystem::path&  path() const               {return m_path;}
+  file_status   status() const                               {return m_get_status();}
+  file_status   status(system::error_code& ec) const         {return m_get_status(&ec);}
+  file_status   symlink_status() const                       {return m_get_symlink_status();}
+  file_status   symlink_status(system::error_code& ec) const {return m_get_symlink_status(&ec);}
+
+  bool operator==(const directory_entry& rhs) {return m_path == rhs.m_path;} 
+  bool operator!=(const directory_entry& rhs) {return m_path != rhs.m_path;} 
+  bool operator< (const directory_entry& rhs) {return m_path < rhs.m_path;} 
+  bool operator<=(const directory_entry& rhs) {return m_path <= rhs.m_path;} 
+  bool operator> (const directory_entry& rhs) {return m_path > rhs.m_path;} 
+  bool operator>=(const directory_entry& rhs) {return m_path >= rhs.m_path;} 
+
+private:
+  boost::filesystem::path   m_path;
+  mutable file_status       m_status;           // stat()-like
+  mutable file_status       m_symlink_status;   // lstat()-like
+
+  file_status m_get_status(system::error_code* ec=0) const;
+  file_status m_get_symlink_status(system::error_code* ec=0) const;
+}; // directory_entry
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                            directory_iterator helpers                                //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+class directory_iterator;
+
+namespace detail
+{
+  BOOST_FILESYSTEM_DECL
+    system::error_code dir_itr_close(// never throws()
+    void *& handle
+#   if     defined(BOOST_POSIX_API)
+    , void *& buffer
+#   endif
+  ); 
+
+  struct dir_itr_imp
+  {
+    directory_entry  dir_entry;
+    void*            handle;
+
+#   ifdef BOOST_POSIX_API
+    void*            buffer;  // see dir_itr_increment implementation
+#   endif
+
+    dir_itr_imp() : handle(0)
+#   ifdef BOOST_POSIX_API
+      , buffer(0)
+#   endif
+    {}
+
+    ~dir_itr_imp() // never throws
+    {
+      dir_itr_close(handle
+#       if defined(BOOST_POSIX_API)
+         , buffer
+#       endif
+    );
+    }
+  };
+
+  // see path::iterator: comment below
+  BOOST_FILESYSTEM_DECL void directory_iterator_construct(directory_iterator& it,
+    const path& p, system::error_code* ec);
+  BOOST_FILESYSTEM_DECL void directory_iterator_increment(directory_iterator& it,
+    system::error_code* ec);
+
+}  // namespace detail
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                                directory_iterator                                    //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+  class directory_iterator
+    : public boost::iterator_facade< directory_iterator,
+                                     directory_entry,
+                                     boost::single_pass_traversal_tag >
+  {
+  public:
+
+    directory_iterator(){}  // creates the "end" iterator
+
+    // iterator_facade derived classes don't seem to like implementations in
+    // separate translation unit dll's, so forward to detail functions
+    explicit directory_iterator(const path& p)
+        : m_imp(new detail::dir_itr_imp)
+          { detail::directory_iterator_construct(*this, p, 0); }
+
+    directory_iterator(const path& p, system::error_code& ec)
+        : m_imp(new detail::dir_itr_imp)
+          { detail::directory_iterator_construct(*this, p, &ec); }
+
+   ~directory_iterator() {} // never throws
+
+    directory_iterator& increment(system::error_code& ec)
+    { 
+      detail::directory_iterator_increment(*this, &ec);
+      return *this;
+    }
+
+  private:
+    friend struct detail::dir_itr_imp;
+    friend BOOST_FILESYSTEM_DECL void detail::directory_iterator_construct(directory_iterator& it,
+      const path& p, system::error_code* ec);
+    friend BOOST_FILESYSTEM_DECL void detail::directory_iterator_increment(directory_iterator& it,
+      system::error_code* ec);
+
+    // shared_ptr provides shallow-copy semantics required for InputIterators.
+    // m_imp.get()==0 indicates the end iterator.
+    boost::shared_ptr< detail::dir_itr_imp >  m_imp;
+
+    friend class boost::iterator_core_access;
+
+    boost::iterator_facade<
+      directory_iterator,
+      directory_entry,
+      boost::single_pass_traversal_tag >::reference dereference() const 
+    {
+      BOOST_ASSERT(m_imp.get() && "attempt to dereference end iterator");
+      return m_imp->dir_entry;
+    }
+
+    void increment() { detail::directory_iterator_increment(*this, 0); }
+
+    bool equal(const directory_iterator& rhs) const
+      { return m_imp == rhs.m_imp; }
+  };
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                      recursive_directory_iterator helpers                            //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+  namespace detail
+  {
+    struct recur_dir_itr_imp
+    {
+      typedef directory_iterator element_type;
+      std::stack< element_type, std::vector< element_type > > m_stack;
+      int  m_level;
+      bool m_no_push_request;
+
+      recur_dir_itr_imp() : m_level(0), m_no_push_request(false) {}
+
+      void increment(system::error_code* ec);  // ec == 0 means throw on error
+
+      void pop();
+
+    };
+
+    //  Implementation is inline to avoid dynamic linking difficulties with m_stack:
+    //  Microsoft warning C4251, m_stack needs to have dll-interface to be used by
+    //  clients of struct 'boost::filesystem::detail::recur_dir_itr_imp'
+
+    inline
+    void recur_dir_itr_imp::increment(system::error_code* ec)
+    // ec == 0 means throw on error
+    {
+      if (m_no_push_request)
+        { m_no_push_request = false; }
+      else if (is_directory(m_stack.top()->status()))
+      {
+        if (ec == 0)
+          m_stack.push(directory_iterator(m_stack.top()->path()));
+        else
+        {
+          m_stack.push(directory_iterator(m_stack.top()->path(), *ec));
+          if (*ec) return;
+        }
+        if (m_stack.top() != directory_iterator())
+        {
+          ++m_level;
+          return;
+        }
+        m_stack.pop();
+      }
+
+      while (!m_stack.empty() && ++m_stack.top() == directory_iterator())
+      {
+        m_stack.pop();
+        --m_level;
+      }
+    }
+
+    inline
+    void recur_dir_itr_imp::pop()
+    {
+      BOOST_ASSERT(m_level > 0 && "pop() on recursive_directory_iterator with level < 1");
+
+      do
+      {
+        m_stack.pop();
+        --m_level;
+      }
+      while (!m_stack.empty() && ++m_stack.top() == directory_iterator());
+    }
+  } // namespace detail
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                           recursive_directory_iterator                               //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+  class recursive_directory_iterator
+    : public boost::iterator_facade<
+        recursive_directory_iterator,
+        directory_entry,
+        boost::single_pass_traversal_tag >
+  {
+  public:
+
+    recursive_directory_iterator(){}  // creates the "end" iterator
+
+    explicit recursive_directory_iterator(const path& dir_path)
+      : m_imp(new detail::recur_dir_itr_imp)
+    {
+      m_imp->m_stack.push(directory_iterator(dir_path));
+      if (m_imp->m_stack.top() == directory_iterator())
+        { m_imp.reset (); }
+    }
+
+    recursive_directory_iterator(const path& dir_path,
+      system::error_code & ec)
+    : m_imp(new detail::recur_dir_itr_imp)
+    {
+      m_imp->m_stack.push(directory_iterator(dir_path, ec));
+      if (m_imp->m_stack.top() == directory_iterator())
+        { m_imp.reset (); }
+    }
+
+    recursive_directory_iterator& increment(system::error_code* ec)
+    {
+      BOOST_ASSERT(m_imp.get() && "increment() on end recursive_directory_iterator");
+      m_imp->increment(ec);
+      return *this;
+    }
+
+    int level() const
+    { 
+      BOOST_ASSERT(m_imp.get() && "level() on end recursive_directory_iterator");
+      return m_imp->m_level;
+    }
+
+    bool no_push_request() const
+    {
+      BOOST_ASSERT(m_imp.get() && "no_push_request() on end recursive_directory_iterator");
+      return m_imp->m_no_push_request;
+    }
+
+    void pop()
+    { 
+      BOOST_ASSERT(m_imp.get() && "pop() on end recursive_directory_iterator");
+      m_imp->pop();
+      if (m_imp->m_stack.empty()) m_imp.reset(); // done, so make end iterator
+    }
+
+    void no_push()
+    {
+      BOOST_ASSERT(m_imp.get() && "no_push() on end recursive_directory_iterator");
+      m_imp->m_no_push_request = true;
+    }
+
+    file_status status() const
+    {
+      BOOST_ASSERT(m_imp.get()
+        && "status() on end recursive_directory_iterator");
+      return m_imp->m_stack.top()->status();
+    }
+
+    file_status symlink_status() const
+    {
+      BOOST_ASSERT(m_imp.get()
+        && "symlink_status() on end recursive_directory_iterator");
+      return m_imp->m_stack.top()->symlink_status();
+    }
+
+  private:
+
+    // shared_ptr provides shallow-copy semantics required for InputIterators.
+    // m_imp.get()==0 indicates the end iterator.
+    boost::shared_ptr< detail::recur_dir_itr_imp >  m_imp;
+
+    friend class boost::iterator_core_access;
+
+    boost::iterator_facade< 
+      recursive_directory_iterator,
+      directory_entry,
+      boost::single_pass_traversal_tag >::reference
+    dereference() const 
+    {
+      BOOST_ASSERT(m_imp.get() && "dereference of end recursive_directory_iterator");
+      return *m_imp->m_stack.top();
+    }
+
+    void increment()
+    { 
+      BOOST_ASSERT(m_imp.get() && "increment of end recursive_directory_iterator");
+      m_imp->increment(0);
+      if (m_imp->m_stack.empty()) m_imp.reset(); // done, so make end iterator
+    }
+
+    bool equal(const recursive_directory_iterator& rhs) const
+      { return m_imp == rhs.m_imp; }
+
+  };
+
+# if !defined(BOOST_FILESYSTEM_NO_DEPRECATED)
+  typedef recursive_directory_iterator wrecursive_directory_iterator;
+# endif
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                            class filesystem_error                                    //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+  
+  class filesystem_error : public system::system_error
+  {
+  // see http://www.boost.org/more/error_handling.html for design rationale
+
+  // all functions are inline to avoid issues with crossing dll boundaries
+
+  public:
+    // compiler generates copy constructor and copy assignment
+
+    filesystem_error(
+      const std::string & what_arg, system::error_code ec)
+      : system::system_error(ec, what_arg)
+    {
+      try
+      {
+        m_imp_ptr.reset(new m_imp);
+      }
+      catch (...) { m_imp_ptr.reset(); }
+    }
+
+    filesystem_error(
+      const std::string & what_arg, const path& path1_arg,
+      system::error_code ec)
+      : system::system_error(ec, what_arg)
+    {
+      try
+      {
+        m_imp_ptr.reset(new m_imp);
+        m_imp_ptr->m_path1 = path1_arg;
+      }
+      catch (...) { m_imp_ptr.reset(); }
+    }
+    
+    filesystem_error(
+      const std::string & what_arg, const path& path1_arg,
+      const path& path2_arg, system::error_code ec)
+      : system::system_error(ec, what_arg)
+    {
+      try
+      {
+        m_imp_ptr.reset(new m_imp);
+        m_imp_ptr->m_path1 = path1_arg;
+        m_imp_ptr->m_path2 = path2_arg;
+      }
+      catch (...) { m_imp_ptr.reset(); }
+    }
+
+    ~filesystem_error() throw() {}
+
+    const path& path1() const
+    {
+      static const path empty_path;
+      return m_imp_ptr.get() ? m_imp_ptr->m_path1 : empty_path ;
+    }
+    const path& path2() const
+    {
+      static const path empty_path;
+      return m_imp_ptr.get() ? m_imp_ptr->m_path2 : empty_path ;
+    }
+
+    const char* what() const throw()
+    {
+      if (!m_imp_ptr.get())
+        return system::system_error::what();
+
+      try
+      {
+        if (m_imp_ptr->m_what.empty())
+        {
+          m_imp_ptr->m_what = system::system_error::what();
+          if (!m_imp_ptr->m_path1.empty())
+          {
+            m_imp_ptr->m_what += ": \"";
+            m_imp_ptr->m_what += m_imp_ptr->m_path1.string();
+            m_imp_ptr->m_what += "\"";
+          }
+          if (!m_imp_ptr->m_path2.empty())
+          {
+            m_imp_ptr->m_what += ", \"";
+            m_imp_ptr->m_what += m_imp_ptr->m_path2.string();
+            m_imp_ptr->m_what += "\"";
+          }
+        }
+        return m_imp_ptr->m_what.c_str();
+      }
+      catch (...)
+      {
+        return system::system_error::what();
+      }
+    }
+
+  private:
+    struct m_imp
+    {
+      path         m_path1; // may be empty()
+      path         m_path2; // may be empty()
+      std::string  m_what;  // not built until needed
+    };
+    boost::shared_ptr<m_imp> m_imp_ptr;
+  };
+
+//  test helper  -----------------------------------------------------------------------//
+
+//  Not part of the documented interface since false positives are possible;
+//  there is no law that says that an OS that has large stat.st_size
+//  actually supports large file sizes.
+
+  namespace detail
+  {
+    BOOST_FILESYSTEM_DECL bool possible_large_file_size_support();
+  }
+
+  } // namespace filesystem
+} // namespace boost
+
+
+#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
+#endif // BOOST_FILESYSTEM_OPERATIONS_HPP

v3/boost/filesystem/path.hpp

@@ -0,0 +1,635 @@
+//  filesystem path.hpp  ---------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2002-2005, 2009
+//  Copyright Vladimir Prus 2002
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+//  path::stem(), extension(), and replace_extension() are based on
+//  basename(), extension(), and change_extension() from the original
+//  filesystem/convenience.hpp header by Vladimir Prus.
+
+#ifndef BOOST_FILESYSTEM_PATH_HPP
+#define BOOST_FILESYSTEM_PATH_HPP
+
+#include <boost/filesystem/config.hpp>
+#include <boost/filesystem/path_traits.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/system/system_error.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/static_assert.hpp>
+#include <string>
+#include <iterator>
+#include <cstring>
+#include <iosfwd>    // needed by basic_path inserter and extractor
+#include <stdexcept>
+#include <cassert>
+#include <locale>
+#include <algorithm>
+
+#include <boost/config/abi_prefix.hpp> // must be the last #include
+
+namespace boost
+{
+namespace filesystem
+{
+  //------------------------------------------------------------------------------------//
+  //                                                                                    //
+  //                                    class path                                      //
+  //                                                                                    //
+  //------------------------------------------------------------------------------------//
+
+/*
+   Why are there no const codecvt_type& arguments?
+   ------------------------------------------------
+
+   To hold down the size of the class path interface. Per function codecvt facets
+   just aren't needed very often in practice.
+
+   An RAII idiom can be used to ensure push/pop behavior as an alternative.
+
+   Note that codecvt() is passed to the path_traits::convert functions, since that
+   decouples the convert functions from class path.
+
+   const codecvt_type & can be added later, but once added, they can never be removed
+   since that would break user code.
+*/
+
+  class BOOST_FILESYSTEM_DECL path
+  {
+  public:
+
+    //  value_type is the character type used by the operating system API to
+    //  represent paths.
+
+#   ifdef BOOST_WINDOWS_API
+    typedef wchar_t                        value_type;
+#   else 
+    typedef char                           value_type;
+#   endif
+    typedef std::basic_string<value_type>  string_type;  
+    typedef path_traits::codecvt_type      codecvt_type;
+
+    //  ----- character encoding conversions -----
+
+    //  Following the principle of least astonishment, path input arguments
+    //  passed to or obtained from the operating system via objects of
+    //  class path behave as if they were directly passed to or
+    //  obtained from the O/S API, unless conversion is explicitly requested.
+    //
+    //  POSIX specfies that path strings are passed unchanged to and from the
+    //  API. Note that this is different from the POSIX command line utilities,
+    //  which convert according to a locale.
+    //
+    //  Thus for POSIX, char strings do not undergo conversion.  wchar_t strings
+    //  are converted to/from char using the path locale or, if a conversion
+    //  argument is given, using a conversion object modeled on
+    //  std::wstring_convert.
+    //
+    //  The path locale, which is global to the thread, can be changed by the
+    //  imbue() function. It is initialized to an implementation defined locale.
+    //  
+    //  For Windows, wchar_t strings do not undergo conversion. char strings
+    //  are converted using the "ANSI" or "OEM" code pages, as determined by
+    //  the AreFileApisANSI() function, or, if a conversion argument is given,
+    //  using a conversion object modeled on std::wstring_convert.
+    //
+    //  See m_pathname comments for further important rationale.
+
+    //  Design alternative; each function can have an additional overload that
+    //  supplies a conversion locale. For example:
+    //
+    //      template< class ForwardIterator, class WStringConvert >
+    //      path(ForwardIterator begin, ForwardIterator end,
+    //            const std::locale & loc,
+    //            system::error_code & ec = boost::throws());
+    // 
+    //  This alternative was rejected as too complex for the limited benefits;
+    //  it nearly doubles the size of the interface, and adds a lot of
+    //  implementation and test code, yet would likely be rarely used. The same
+    //  effect can be achieved via the much simpler imbue() mechanism.
+
+
+    //  TODO: rules needed for operating systems that use / or .
+    //  differently, or format directory paths differently from file paths. 
+    //
+    //  ************************************************************************
+    //
+    //  More work needed: How to handle an operating system that may have
+    //  slash characters or dot characters in valid filenames, either because
+    //  it doesn't follow the POSIX standard, or because it allows MBCS
+    //  filename encodings that may contain slash or dot characters. For
+    //  example, ISO/IEC 2022 (JIS) encoding which allows switching to
+    //  JIS x0208-1983 encoding. A valid filename in this set of encodings is
+    //  0x1B 0x24 0x42 [switch to X0208-1983] 0x24 0x2F [U+304F Kiragana letter KU]
+    //                                             ^^^^
+    //  Note that 0x2F is the ASCII slash character
+    //
+    //  ************************************************************************
+
+    //  Supported source arguments: half-open iterator range, container, c-array,
+    //  and single pointer to null terminated string.
+
+    //  All source arguments except pointers to null terminated byte strings support
+    //  multi-byte character strings which may have embedded nulls. Embedded null
+    //  support is required for some Asian languages on Windows.
+
+    //  -----  constructors  -----
+
+    path(){}                                          
+
+    path(const path& p) : m_pathname(p.m_pathname) {}
+
+    template <class InputIterator>
+    path(InputIterator begin, InputIterator end)
+    { 
+      if (begin != end)
+      {
+        std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
+          s(begin, end);
+        path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, codecvt());
+      }
+    }
+
+    template <class Source>
+    path(Source const& source)
+    {
+      path_traits::dispatch(source, m_pathname, codecvt());
+    }
+
+    //  -----  assignments  -----
+
+    path& operator=(const path& p)
+    {
+      m_pathname = p.m_pathname;
+      return *this;
+    }
+
+    template <class InputIterator>
+    path& assign(InputIterator begin, InputIterator end)
+    { 
+      m_pathname.clear();
+      if (begin != end)
+      {
+        std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
+          s(begin, end);
+        path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, codecvt());
+      }
+      return *this;
+    }
+
+    template <class Source>
+    path& operator=(Source const& source)
+    {
+      m_pathname.clear();
+      path_traits::dispatch(source, m_pathname, codecvt());
+      return *this;
+    }
+
+    //  -----  appends  -----
+
+    //  if a separator is added, it is the preferred separator for the platform;
+    //  slash for POSIX, backslash for Windows
+
+    path& operator/=(const path& p);
+
+    template <class InputIterator>
+    path& append(InputIterator begin, InputIterator end);
+
+    template <class Source>
+    path& operator/=(Source const& source);
+
+    //  -----  modifiers  -----
+
+    void   clear()             { m_pathname.clear(); }
+    path&  make_absolute(const path& base); 
+    path&  make_preferred()
+#                              ifdef BOOST_POSIX_API
+                               { return *this; }  // POSIX no effect
+#                              else // BOOST_WINDOWS_API
+                               ;  // change slashes to backslashes
+#                              endif
+    path&  remove_filename();
+    path&  replace_extension(const path& new_extension = path());
+    void   swap(path& rhs)     { m_pathname.swap(rhs.m_pathname); }
+
+    //  -----  observers  -----
+  
+    //  For operating systems that format file paths differently than directory
+    //  paths, return values from observers are formatted as file names unless there
+    //  is a trailing separator, in which case returns are formatted as directory
+    //  paths. POSIX and Windows make no such distinction.
+
+    //  Implementations are permitted to return const values or const references.
+
+    //  The string or path returned by an observer are specified as being formatted
+    //  as "native" or "generic".
+    //
+    //  For POSIX, these are all the same format; slashes and backslashes are as input and
+    //  are not modified.
+    //
+    //  For Windows,   native:    as input; slashes and backslashes are not modified;
+    //                            this is the format of the internally stored string.
+    //                 generic:   backslashes are converted to slashes
+
+    //  -----  native format observers  -----
+
+    const string_type&  native() const { return m_pathname; }          // Throws: nothing
+    const value_type*   c_str() const  { return m_pathname.c_str(); }  // Throws: nothing
+
+    template <class String>
+    String string() const;
+
+#   ifdef BOOST_WINDOWS_API
+    const std::string    string() const;
+    const std::wstring&  wstring() const { return m_pathname; }
+
+#   else   // BOOST_POSIX_API
+    const std::string&  string() const   { return m_pathname; }
+    const std::wstring  wstring() const
+    { 
+      std::wstring tmp;
+      if (!m_pathname.empty())
+        path_traits::convert(&*m_pathname.begin(), &*m_pathname.begin()+m_pathname.size(),
+          tmp, codecvt());
+      return tmp;
+    }
+
+#   endif
+
+    //  -----  generic format observers  -----
+
+    template <class String>
+    String generic_string() const;
+
+#   ifdef BOOST_WINDOWS_API
+    const std::string   generic_string() const; 
+    const std::wstring  generic_wstring() const;
+
+#   else // BOOST_POSIX_API
+    const std::string&  generic_string() const  { return m_pathname; }
+    const std::wstring  generic_wstring() const { return wstring(); }
+
+#   endif
+
+    //  -----  decomposition  -----
+
+    path  root_path() const; 
+    path  root_name() const;         // returns 0 or 1 element path
+                                     // even on POSIX, root_name() is non-empty() for network paths
+    path  root_directory() const;    // returns 0 or 1 element path
+    path  relative_path() const;
+    path  parent_path() const;
+    path  filename() const;          // returns 0 or 1 element path
+    path  stem() const;              // returns 0 or 1 element path
+    path  extension() const;         // returns 0 or 1 element path
+
+    //  -----  query  -----
+
+    bool empty() const               { return m_pathname.empty(); } // name consistent with std containers
+    bool has_root_path() const       { return has_root_directory() || has_root_name(); }
+    bool has_root_name() const       { return !root_name().empty(); }
+    bool has_root_directory() const  { return !root_directory().empty(); }
+    bool has_relative_path() const   { return !relative_path().empty(); }
+    bool has_parent_path() const     { return !parent_path().empty(); }
+    bool has_filename() const        { return !m_pathname.empty(); }
+    bool has_stem() const            { return !stem().empty(); }
+    bool has_extension() const       { return !extension().empty(); }
+    bool is_absolute() const
+    {
+#     ifdef BOOST_WINDOWS_API
+      return has_root_name() && has_root_directory();
+#     else
+      return has_root_directory();
+#     endif
+    }
+    bool is_relative() const         { return !is_absolute(); } 
+
+    //  -----  imbue  -----
+
+    static std::locale imbue(const std::locale & loc);
+
+    //  -----  codecvt  -----
+
+    static const codecvt_type & codecvt()
+    {
+      return *wchar_t_codecvt_facet();
+    }
+
+    //  -----  iterators  -----
+
+    class iterator;
+    typedef iterator const_iterator;
+
+    iterator begin() const;
+    iterator end() const;
+
+    //  -----  deprecated functions  -----
+
+# if defined(BOOST_FILESYSTEM_DEPRECATED) && defined(BOOST_FILESYSTEM_NO_DEPRECATED)
+#   error both BOOST_FILESYSTEM_DEPRECATED and BOOST_FILESYSTEM_NO_DEPRECATED are defined
+# endif
+
+# if !defined(BOOST_FILESYSTEM_NO_DEPRECATED)
+    //  recently deprecated functions supplied by default
+    path&  normalize()              { return m_normalize(); }
+    path&  remove_leaf()            { return remove_filename(); }
+    path   leaf() const             { return filename(); }
+    path   branch_path() const      { return parent_path(); }
+    bool   has_leaf() const         { return !m_pathname.empty(); }
+    bool   has_branch_path() const  { return !parent_path().empty(); }
+    bool   is_complete() const      { return is_absolute(); }
+# endif
+
+# if defined(BOOST_FILESYSTEM_DEPRECATED)
+    //  deprecated functions with enough signature or semantic changes that they are
+    //  not supplied by default 
+    const std::string file_string() const               { return string(); }
+    const std::string directory_string() const          { return string(); }
+    const std::string native_file_string() const        { return string(); }
+    const std::string native_directory_string() const   { return string(); }
+    const string_type external_file_string() const      { return native(); }
+    const string_type external_directory_string() const { return native(); }
+
+    //  older functions no longer supported
+    //typedef bool (*name_check)(const std::string & name);
+    //basic_path(const string_type& str, name_check) { operator/=(str); }
+    //basic_path(const typename string_type::value_type* s, name_check)
+    //  { operator/=(s);}
+    //static bool default_name_check_writable() { return false; } 
+    //static void default_name_check(name_check) {}
+    //static name_check default_name_check() { return 0; }
+    //basic_path& canonize();
+# endif
+
+//--------------------------------------------------------------------------------------//
+//                            class path private members                                //
+//--------------------------------------------------------------------------------------//
+
+  private:
+#   if defined(_MSC_VER)
+#     pragma warning(push) // Save warning settings
+#     pragma warning(disable : 4251) // disable warning: class 'std::basic_string<_Elem,_Traits,_Ax>'
+#   endif                            // needs to have dll-interface...
+/*
+      m_pathname has the type, encoding, and format required by the native
+      operating system. Thus for POSIX and Windows there is no conversion for
+      passing m_pathname.c_str() to the O/S API or when obtaining a path from the
+      O/S API. POSIX encoding is unspecified other than for dot and slash
+      characters; POSIX just treats paths as a sequence of bytes. Windows
+      encoding is UCS-2 or UTF-16 depending on the version.
+*/
+    string_type  m_pathname;  // Windows: as input; backslashes NOT converted to slashes,
+                              // slashes NOT converted to backslashes
+#   if defined(_MSC_VER)
+#     pragma warning(pop) // restore warning settings.
+#   endif 
+
+    string_type::size_type m_append_separator_if_needed();
+    //  Returns: If separator is to be appended, m_pathname.size() before append. Otherwise 0.
+    //  Note: An append is never performed if size()==0, so a returned 0 is unambiguous.
+
+    void m_erase_redundant_separator(string_type::size_type sep_pos);
+    string_type::size_type m_parent_path_end() const;
+    void m_portable();
+
+    path& m_normalize();
+
+    // Was qualified; como433beta8 reports:
+    //    warning #427-D: qualified name is not allowed in member declaration 
+    friend class iterator;
+    friend bool operator<(const path& lhs, const path& rhs);
+
+    // see path::iterator::increment/decrement comment below
+    static void m_path_iterator_increment(path::iterator & it);
+    static void m_path_iterator_decrement(path::iterator & it);
+
+    static const codecvt_type *&  wchar_t_codecvt_facet();
+
+  };  // class path
+
+# if defined(BOOST_FILESYSTEM_DEPRECATED)
+  typedef path wpath;
+# endif
+
+  //------------------------------------------------------------------------------------//
+  //                             class path::iterator                                   //
+  //------------------------------------------------------------------------------------//
+ 
+  class path::iterator
+    : public boost::iterator_facade<
+      iterator,
+      path const,
+      boost::bidirectional_traversal_tag >
+  {
+  private:
+    friend class boost::iterator_core_access;
+    friend class boost::filesystem::path;
+    friend void m_path_iterator_increment(path::iterator & it);
+    friend void m_path_iterator_decrement(path::iterator & it);
+
+    const path& dereference() const { return m_element; }
+
+    bool equal(const iterator & rhs) const
+    {
+      return m_path_ptr == rhs.m_path_ptr && m_pos == rhs.m_pos;
+    }
+
+    // iterator_facade derived classes don't seem to like implementations in
+    // separate translation unit dll's, so forward to class path static members
+    void increment() { m_path_iterator_increment(*this); }
+    void decrement() { m_path_iterator_decrement(*this); }
+
+    path                    m_element;   // current element
+    const path *            m_path_ptr;  // path being iterated over
+    string_type::size_type  m_pos;       // position of name in
+                                         // m_path_ptr->m_pathname. The
+                                         // end() iterator is indicated by 
+                                         // m_pos == m_path_ptr->m_pathname.size()
+  }; // path::iterator
+
+  //------------------------------------------------------------------------------------//
+  //                                                                                    //
+  //                            class scoped_path_locale                                //
+  //                                                                                    //
+  //------------------------------------------------------------------------------------//
+ 
+  class scoped_path_locale
+  {
+  public:
+    scoped_path_locale(const std::locale & loc)
+                      : m_saved_locale(loc)
+    {
+      path::imbue(loc);
+    }
+
+    ~scoped_path_locale()   // never throws()
+    {
+      try { path::imbue(m_saved_locale); }
+      catch (...) {}
+    };
+
+  private:
+    std::locale m_saved_locale;
+  };
+   
+  //------------------------------------------------------------------------------------//
+  //                                                                                    //
+  //                              non-member functions                                  //
+  //                                                                                    //
+  //------------------------------------------------------------------------------------//
+
+  //  std::lexicographical_compare would infinately recurse because path iterators
+  //  yield paths, so provide a path aware version
+  inline bool lexicographical_compare(path::iterator first1, path::iterator last1,
+    path::iterator first2, path::iterator last2)
+  {
+    for (; first1 != last1 && first2 != last2 ; ++first1, ++first2)
+    {
+      if (first1->native() < first2->native()) return true;
+      if (first2->native() < first1->native()) return false;
+    }
+    return first1 == last1 && first2 != last2;
+  }
+  
+  inline bool operator<(const path& lhs, const path& rhs)
+  {
+    return lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+  }
+
+  inline bool operator<=(const path& lhs, const path& rhs) { return !(rhs < lhs); }
+  inline bool operator> (const path& lhs, const path& rhs) { return rhs < lhs; }
+  inline bool operator>=(const path& lhs, const path& rhs) { return !(lhs < rhs);  }
+
+  // equality operators act as if comparing generic format strings, to achieve the
+  // effect of lexicographical_compare element by element compare.
+  // operator==() efficiency is a concern; a user reported the original version 2
+  // !(lhs < rhs) && !(rhs < lhs) implementation caused a serious performance problem
+  // for a map of 10,000 paths.
+
+# ifdef BOOST_WINDOWS_API
+  inline bool operator==(const path& lhs, const path::value_type* rhs)
+  {
+    const path::value_type* l(lhs.c_str());
+    while ((*l == *rhs || (*l == L'\\' && *rhs == L'/') || (*l == L'/' && *rhs == L'\\'))
+      && *l) { ++l; ++rhs; }
+    return *l == *rhs || (*l == L'\\' && *rhs == L'/') || (*l == L'/' && *rhs == L'\\');  
+  }
+  inline bool operator==(const path& lhs, const path& rhs)              { return lhs == rhs.c_str(); }
+  inline bool operator==(const path& lhs, const path::string_type& rhs) { return lhs == rhs.c_str(); }
+  inline bool operator==(const path::string_type& lhs, const path& rhs) { return rhs == lhs.c_str(); }
+  inline bool operator==(const path::value_type* lhs, const path& rhs)  { return rhs == lhs; }
+# else   // BOOST_POSIX_API
+  inline bool operator==(const path& lhs, const path& rhs)              { return lhs.native() == rhs.native(); }
+  inline bool operator==(const path& lhs, const path::string_type& rhs) { return lhs.native() == rhs; }
+  inline bool operator==(const path& lhs, const path::value_type* rhs)  { return lhs.native() == rhs; }
+  inline bool operator==(const path::string_type& lhs, const path& rhs) { return lhs == rhs.native(); }
+  inline bool operator==(const path::value_type* lhs, const path& rhs)  { return lhs == rhs.native(); }
+# endif
+
+  inline bool operator!=(const path& lhs, const path& rhs)              { return !(lhs == rhs); }
+  inline bool operator!=(const path& lhs, const path::string_type& rhs) { return !(lhs == rhs); }
+  inline bool operator!=(const path& lhs, const path::value_type* rhs)  { return !(lhs == rhs); }
+  inline bool operator!=(const path::string_type& lhs, const path& rhs) { return !(lhs == rhs); }
+  inline bool operator!=(const path::value_type* lhs, const path& rhs)  { return !(lhs == rhs); }
+
+  inline void swap(path& lhs, path& rhs)                   { lhs.swap(rhs); }
+
+  inline path operator/(const path& lhs, const path& rhs)  { return path(lhs) /= rhs; }
+
+  //  inserters and extractors
+
+  inline std::ostream& operator<<(std::ostream & os, const path& p)
+  {
+    os << p.string();
+    return os;
+  }
+  
+  inline std::wostream& operator<<(std::wostream & os, const path& p)
+  {
+    os << p.wstring();
+    return os;
+  }
+  
+  inline std::istream& operator>>(std::istream & is, path& p)
+  {
+    std::string str;
+    is >> str;
+    p = str;
+    return is;
+  }
+  
+  inline std::wistream& operator>>(std::wistream & is, path& p)
+  {
+    std::wstring str;
+    is >> str;
+    p = str;
+    return is;
+  }
+
+  //  name_checks
+
+  BOOST_FILESYSTEM_DECL bool portable_posix_name(const std::string & name);
+  BOOST_FILESYSTEM_DECL bool windows_name(const std::string & name);
+  BOOST_FILESYSTEM_DECL bool portable_name(const std::string & name);
+  BOOST_FILESYSTEM_DECL bool portable_directory_name(const std::string & name);
+  BOOST_FILESYSTEM_DECL bool portable_file_name(const std::string & name);
+  BOOST_FILESYSTEM_DECL bool native(const std::string & name);
+ 
+//--------------------------------------------------------------------------------------//
+//                     class path member template implementation                        //
+//--------------------------------------------------------------------------------------//
+
+  template <class InputIterator>
+  path& path::append(InputIterator begin, InputIterator end)
+  { 
+    if (begin == end)
+      return *this;
+    string_type::size_type sep_pos(m_append_separator_if_needed());
+    std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
+      s(begin, end);
+    path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, codecvt());
+    if (sep_pos)
+      m_erase_redundant_separator(sep_pos);
+    return *this;
+  }
+
+  template <class Source>
+  path& path::operator/=(Source const & source)
+  {
+    if (path_traits::empty(source))
+      return *this;
+    string_type::size_type sep_pos(m_append_separator_if_needed());
+    path_traits::dispatch(source, m_pathname, codecvt());
+    if (sep_pos)
+      m_erase_redundant_separator(sep_pos);
+    return *this;
+  }
+
+//--------------------------------------------------------------------------------------//
+//                     class path member template specializations                       //
+//--------------------------------------------------------------------------------------//
+
+  template <> inline
+  std::string path::string<std::string>() const    { return string(); }
+
+  template <> inline
+  std::wstring path::string<std::wstring>() const  { return wstring(); }
+
+  template <> inline
+  std::string path::generic_string<std::string>() const   { return generic_string(); }
+
+  template <> inline
+  std::wstring path::generic_string<std::wstring>() const { return generic_wstring(); }
+
+
+}  // namespace filesystem
+}  // namespace boost
+
+#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
+
+#endif  // BOOST_FILESYSTEM_PATH_HPP

v3/boost/filesystem/path_traits.hpp

@@ -0,0 +1,204 @@
+//  filesystem path_traits.hpp  --------------------------------------------------------//
+
+//  Copyright Beman Dawes 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+#ifndef BOOST_FILESYSTEM_PATH_TRAITS_HPP
+#define BOOST_FILESYSTEM_PATH_TRAITS_HPP
+
+#include <boost/filesystem/config.hpp>
+#include <string>
+#include <vector>
+#include <iterator>
+#include <boost/assert.hpp>
+#include <boost/system/error_code.hpp>
+// #include <iostream>   //**** comment me out ****
+
+#include <boost/config/abi_prefix.hpp> // must be the last #include
+
+namespace boost { namespace filesystem {
+
+  BOOST_FILESYSTEM_DECL const system::error_category& codecvt_error_category();
+  //  uses std::codecvt_base::result used for error codes:
+  //
+  //    ok:       Conversion successful.
+  //    partial:  Not all source characters converted; one or more additional source
+  //              characters are needed to produce the final target character, or the
+  //              size of the target intermediate buffer was too small to hold the result.
+  //    error:    A character in the source could not be converted to the target encoding.
+  //    noconv:   The source and target characters have the same type and encoding, so no
+  //              conversion was necessary.
+
+  class directory_entry;
+  
+namespace path_traits {
+ 
+  typedef std::codecvt<wchar_t, char, std::mbstate_t> codecvt_type;
+
+  //  Pathable empty
+
+  template <class Container> inline
+    bool empty(const Container & c)
+      { return c.begin() == c.end(); }
+
+  template <class T> inline
+    bool empty(T * const & c_str)
+  {
+    BOOST_ASSERT(c_str);
+    return !*c_str;
+  }
+
+  template <typename T, size_t N> inline
+     bool empty(T (&)[N])
+       { return N <= 1; }
+
+  //  Source dispatch
+
+  //  contiguous containers
+  template <class U> inline
+    void dispatch(const std::string& c, U& to, const codecvt_type& cvt)
+  {
+    if (c.size())
+      convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
+  }
+  template <class U> inline
+    void dispatch(const std::wstring& c, U& to, const codecvt_type& cvt)
+  {
+    if (c.size())
+      convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
+  }
+  template <class U> inline
+    void dispatch(const std::vector<char>& c, U& to, const codecvt_type& cvt)
+  {
+    if (c.size())
+      convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
+  }
+  template <class U> inline
+    void dispatch(const std::vector<wchar_t>& c, U& to, const codecvt_type& cvt)
+  {
+    if (c.size())
+      convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
+  }
+
+  //  non-contiguous containers
+  template <class Container, class U> inline
+  void dispatch(const Container & c, U& to, const codecvt_type& cvt)
+  {
+    if (c.size())
+    {
+      std::basic_string<typename Container::value_type> s(c.begin(), c.end());
+      convert(s.c_str(), s.c_str()+s.size(), to, cvt);
+    }
+  }
+
+  //  c_str
+  template <class T, class U> inline
+  void dispatch(T * const & c_str, U& to, const codecvt_type& cvt)
+  {
+//    std::cout << "dispatch() const T *\n";
+    BOOST_ASSERT(c_str);
+    convert(c_str, to, cvt);
+  }
+  
+  //  C-style array
+  template <typename T, size_t N, class U> inline
+  void dispatch(T (&array)[N], U& to, const codecvt_type& cvt) // T, N, U deduced
+  {
+//    std::cout << "dispatch() array, N=" << N << "\n"; 
+    convert(array, array + N - 1, to, cvt);
+  }
+
+  BOOST_FILESYSTEM_DECL
+  void dispatch(const directory_entry & de,
+#                ifdef BOOST_WINDOWS_API
+                   std::wstring & to,
+#                else   
+                   std::string & to,
+#                endif
+                 const codecvt_type&);
+
+  // value types differ  ---------------------------------------------------------------//
+  //
+  //   A from_end argument of 0 is less efficient than a known end, so use only if needed
+  
+  BOOST_FILESYSTEM_DECL
+  void convert(const char* from,
+                const char* from_end,    // 0 for null terminated MBCS
+                std::wstring & to,
+                const codecvt_type& cvt);
+
+  BOOST_FILESYSTEM_DECL
+  void convert(const wchar_t* from,
+                const wchar_t* from_end,  // 0 for null terminated MBCS
+                std::string & to,
+                const codecvt_type& cvt);
+
+  inline 
+  void convert(const char* from,
+                std::wstring & to,
+                const codecvt_type& cvt)
+  {
+    BOOST_ASSERT(from);
+    convert(from, 0, to, cvt);
+  }
+
+  inline 
+  void convert(const wchar_t* from,
+                std::string & to,
+                const codecvt_type& cvt)
+  {
+    BOOST_ASSERT(from);
+    convert(from, 0, to, cvt);
+  }
+
+  // value types same  -----------------------------------------------------------------//
+
+  // char
+
+  inline 
+  void convert(const char* from, const char* from_end, std::string & to,
+    const codecvt_type&)
+  {
+    BOOST_ASSERT(from);
+    BOOST_ASSERT(from_end);
+    to.append(from, from_end);
+  }
+
+  inline 
+  void convert(const char* from,
+                std::string & to,
+                const codecvt_type&)
+  {
+    BOOST_ASSERT(from);
+    to += from;
+  }
+
+  // wchar_t
+
+  inline 
+  void convert(const wchar_t* from, const wchar_t* from_end, std::wstring & to,
+    const codecvt_type&)
+  {
+    BOOST_ASSERT(from);
+    BOOST_ASSERT(from_end);
+    to.append(from, from_end);
+  }
+
+  inline 
+  void convert(const wchar_t* from,
+                std::wstring & to,
+                const codecvt_type&)
+  {
+    BOOST_ASSERT(from);
+    to += from;
+  }
+
+}}} // namespace boost::filesystem::path_traits
+
+#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
+
+#endif  // BOOST_FILESYSTEM_PATH_TRAITS_HPP

v3/libs/filesystem/build/Jamfile.v2

@@ -0,0 +1,32 @@
+# Boost Filesystem Library Build Jamfile
+
+# (C) Copyright Beman Dawes 2002-2006
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or www.boost.org/LICENSE_1_0.txt)
+
+
+# See library home page at http://www.boost.org/libs/filesystem
+
+project boost/filesystem
+    : source-location ../src
+    : usage-requirements # pass these requirement to dependents (i.e. users)
+      <link>shared:<define>BOOST_FILESYSTEM_DYN_LINK=1
+    ;
+
+SOURCES =
+    operations path path_traits portability unique_path utf8_codecvt_facet windows_file_codecvt codecvt_error_category ;
+
+lib boost_filesystem
+    : $(SOURCES).cpp ../../system/build//boost_system
+    : <link>shared:<define>BOOST_FILESYSTEM_DYN_LINK=1 # tell source we're building dll's
+    :
+    : # Boost.Filesystem uses some of Boost.System functions in inlined/templated
+      # functions, so clients that use Boost.Filesystem will have direct references 
+      # to Boost.System symbols. On Windows, Darwin, and some other platforms, this
+      # means those clients have to be directly linked to Boost.System. For static
+      # linking this happens anyway, but for shared we need to make it happen. Since
+      # doing so is harmless even when not needed, we do it for all platforms.
+      <link>shared:<library>../../system/build//boost_system
+    ;
+
+boost-install boost_filesystem ;

v3/libs/filesystem/doc/Jamfile.v2

@@ -0,0 +1,19 @@
+# Boost Filesystem Library Example Jamfile
+ 
+# Copyright Beman Dawes 2010
+
+# Distributed under the Boost Software License, Version 1.0.
+# See www.boost.org/LICENSE_1_0.txt
+
+# Library home page: http://www.boost.org/libs/filesystem
+
+project
+    : requirements
+      <library>/boost/filesystem//boost_filesystem
+      <library>/boost/system//boost_system
+      <toolset>msvc:<asynch-exceptions>on
+      <link>static
+    ;
+    
+exe path_table : path_table.cpp ;    
+install path_table-copy : path_table : <location>. ;

v3/libs/filesystem/doc/POSIX_filename_encoding.txt

@@ -0,0 +1,55 @@
+http://www.linuxfromscratch.org/blfs/view/svn/introduction/locale-issues.html
+
+"The POSIX standard mandates that the filename encoding is the encoding implied by the current LC_CTYPE locale category." 
+
+-------
+
+http://mail.nl.linux.org/linux-utf8/2001-02/msg00103.html
+
+From: Markus Kuhn
+
+Tom Tromey wrote on 2001-02-05 00:36 UTC:
+> Kai> IMAO, a *real* filesystem should use some encoding of ISO 10646 -
+> Kai> UTF-8, UTF-16, or UTF-32 are all viable options. The same should
+> Kai> be true for the kernel filename interfaces.
+> 
+> I like this, but what should I do right now?
+
+The POSIX kernel file system interface is engraved into stone and
+extremely unlikely to change. File names are arbitrary binary strings,
+with only the '/' and '\0' bytes having any special semantics. You can
+use arbitrary coded character sets on it as long as they do not
+introduce '/' and '\0' bytes spuriously. Writers and readers have to
+somehow agree on what encoding to use and the only really practical way
+is to use the same encoding on all systems that share files. Eventually,
+everyone will be using UTF-8 for file names on POSIX systems. Right now,
+I would recommend users to use only ASCII for filenames, as this is
+already UTF-8 and therefore simplifies migration. Using the ISO 8859,
+JIS, etc. filenames should soon be considered deprecated practice.
+
+> I work on libgcj, the runtime component of gcj, the Java front end to
+> GCC.  In libgcj of course we use UCS-2 everywhere, since that is what
+> Java does.  Currently, for Unixy systems, we assume that all file
+> names are UTF-8.
+
+The best solution is to assume that the file names are in the
+locale-specific multi-byte encoding. Simply use mbrtowc and wcrtomb to
+convert between Unicode and the locale-dependent multi-byte encoding
+used in file names and text files if the ISO C 99 symbol
+__STDC_ISO_10646__ is defined (which guarantees that wchar_t = UCS). On
+Linux, this has been the case since glibc 2.2.
+
+> (Actually, we do something notably worse, which is
+> assume that file names are Java-style UTF-8, with the weird encoding
+> for \u0000.)
+
+\u0000 = NUL was never a character allowed in filenames under POSIX.
+Raise an exception if someone tries to use it in a filename. Problem
+solved.
+
+I never understood, why Java found it necessary to introduce two
+distinct ASCII NUL characters.
+
+------
+
+Interesting idea. Use iconv to create shift-jis or other mbcs test cases.

v3/libs/filesystem/doc/deprecated.html

@@ -0,0 +1,208 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Language" content="en-us">
+<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<title>Filesystem Deprecated Features</title>
+<link rel="stylesheet" type="text/css" href="minimal.css">
+</head>
+
+<body>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
+  <tr>
+    <td width="277">
+<a href="../../../index.htm">
+<img src="../../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="300" height="86" border="0"></a></td>
+    <td align="middle">
+    <font size="7">Filesystem Deprecated Features</font>
+    </td>
+  </tr>
+</table>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="100%">
+  <tr>
+    <td><a href="../../../index.htm">Boost Home</a> &nbsp;&nbsp;
+    <a href="index.htm">Library Home</a> &nbsp;&nbsp;
+    <a href="reference.html">Reference</a> &nbsp;&nbsp;
+    <a href="tutorial.html">Tutorial</a> &nbsp;&nbsp;
+    <a href="faq.htm">FAQ</a> &nbsp;&nbsp;
+    <a href="portability_guide.htm">Portability</a> &nbsp;&nbsp;
+    <a href="v3.html">V3 Intro</a> &nbsp;&nbsp;
+    <a href="v3_design.html">V3 Design</a> &nbsp;&nbsp;
+    <a href="deprecated.html">Deprecated</a> &nbsp;&nbsp;
+    </td>
+</table>
+
+<h2><a name="Deprecated-names">Deprecated names</a> and features</h2>
+<p style="font-size: 10pt">As the library evolves over time, names sometimes 
+change or features are removed. To ease transition, Boost.Filesystem deprecates 
+the old names and features, but continues to provide them unless macro <code>
+BOOST_FILESYSTEM_NO_DEPRECATED</code> is defined.</p>
+<table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
+  <tr>
+    <td style="font-size: 10pt">
+    <b><i>Component</i></b></td>
+    <td style="font-size: 10pt">
+    <p style="font-size: 10pt"><b><i>Old name, now deprecated</i></b></td>
+    <td style="font-size: 10pt">
+    <p style="font-size: 10pt"><b><i>New name</i></b></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top"><code>basic_path</code></td>
+    <td style="font-size: 10pt"><code>leaf()</code></td>
+    <td style="font-size: 10pt"><code>filename()</code></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top"><code>basic_path</code></td>
+    <td style="font-size: 10pt"><code>branch_path()</code></td>
+    <td style="font-size: 10pt"><code>parent_path()</code></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top"><code>basic_path</code></td>
+    <td style="font-size: 10pt"><code>has_leaf()</code></td>
+    <td style="font-size: 10pt"><code>has_filename()</code></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top"><code>basic_path</code></td>
+    <td style="font-size: 10pt"><code>has_branch_path()</code></td>
+    <td style="font-size: 10pt"><code>has_parent_path()</code></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_path</code></td>
+    <td style="font-size: 10pt">
+    <p style="font-size: 10pt"><code>remove_leaf()</code></td>
+    <td style="font-size: 10pt">
+    <p style="font-size: 10pt"><code>remove_filename()</code></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_path</code></td>
+    <td style="font-size: 10pt">
+    <code>basic_path( const string_type &amp; str,<br>
+&nbsp; name_check )</code></td>
+    <td style="font-size: 10pt">
+    <i><code>feature removed</code></i></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_path</code></td>
+    <td style="font-size: 10pt">
+    <code>basic_path( const string_type::value_type * s,<br>
+&nbsp; name_check )</code></td>
+    <td style="font-size: 10pt">
+    <i><code>feature removed</code></i></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_path</code></td>
+    <td style="font-size: 10pt">
+    <code>native_file_string()</code></td>
+    <td style="font-size: 10pt">
+    <code>file_string()</code></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_path</code></td>
+    <td style="font-size: 10pt">
+    <code>native_directory_string()</code></td>
+    <td style="font-size: 10pt">
+    <code>directory_string()</code></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_path</code></td>
+    <td style="font-size: 10pt">
+    <code>default_name_check_writable()</code></td>
+    <td style="font-size: 10pt">
+    <i><code>feature removed</code></i></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_path</code></td>
+    <td style="font-size: 10pt">
+    <code>default_name_check( name_check )</code></td>
+    <td style="font-size: 10pt">
+    <i><code>feature removed</code></i></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_path</code></td>
+    <td style="font-size: 10pt">
+    <code>default_name_check()</code></td>
+    <td style="font-size: 10pt">
+    <i><code>feature removed</code></i></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_path</code></td>
+    <td style="font-size: 10pt">
+    <code>canonize()</code></td>
+    <td style="font-size: 10pt">
+    <i><code>feature removed</code></i></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_path</code></td>
+    <td style="font-size: 10pt">
+    <code>normalize()</code></td>
+    <td style="font-size: 10pt">
+    <i><code>feature removed</code></i></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>operations.hpp</code></td>
+    <td style="font-size: 10pt">
+    <code>is_regular( file_status f )</code></td>
+    <td style="font-size: 10pt">
+    <code>is_regular_file( file_status f )</code></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>operations.hpp</code></td>
+    <td style="font-size: 10pt">
+    <code>symbolic_link_exists( const path &amp; ph )</code></td>
+    <td style="font-size: 10pt">
+    <i><code>feature removed</code></i></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_directory_status</code></td>
+    <td style="font-size: 10pt">
+    <code>filename()</code></td>
+    <td style="font-size: 10pt">
+    <i><code>feature removed, use path().filename() instead</code></i></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_directory_status</code></td>
+    <td style="font-size: 10pt">
+    <code>leaf()</code></td>
+    <td style="font-size: 10pt">
+    <i><code>feature removed, use path().filename() instead</code></i></td>
+  </tr>
+  <tr>
+    <td style="font-size: 10pt" valign="top">
+    <code>basic_directory_status</code></td>
+    <td style="font-size: 10pt">
+    <code>string()</code></td>
+    <td style="font-size: 10pt">
+    <i><code>feature removed, use path().string() instead</code></i></td>
+  </tr>
+</table>
+
+<hr>
+<p>Revised
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->17 February, 2010<!--webbot bot="Timestamp" endspan i-checksum="40536" --></p>
+
+<p>&copy; Copyright Beman Dawes, 2002-2005, 2010</p>
+<p> Use, modification, and distribution are subject to the Boost Software 
+License, Version 1.0. See <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a></p>
+
+</body>
+
+</html>

v3/libs/filesystem/doc/design.htm

@@ -0,0 +1,353 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Language" content="en-us">
+<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<title>Boost Filesystem Library Design</title>
+<link rel="stylesheet" type="text/css" href="minimal.css">
+</head>
+
+<body bgcolor="#FFFFFF">
+
+<h1>
+<img border="0" src="../../../boost.png" align="center" width="277" height="86">Filesystem 
+Library Design</h1>
+
+<p><a href="#Introduction">Introduction</a><br>
+<a href="#Requirements">Requirements</a><br>
+<a href="#Realities">Realities</a><br>
+<a href="#Rationale">Rationale</a><br>
+<a href="#Abandoned_Designs">Abandoned_Designs</a><br>
+<a href="#References">References</a></p>
+
+<h2><a name="Introduction">Introduction</a></h2>
+
+<p>The primary motivation for beginning work on the Filesystem Library was 
+frustration with Boost administrative tools.&nbsp; Scripts were written in 
+Python, Perl, Bash, and Windows command languages.&nbsp; There was no single 
+scripting language familiar and acceptable to all Boost administrators. Yet they 
+were all skilled C++ programmers - why couldn't C++ be used as the scripting 
+language?</p>
+
+<p>The key feature C++ lacked for script-like applications was the ability to 
+perform portable filesystem operations on directories and their contents. The 
+Filesystem Library was developed to fill that void.</p>
+
+<p>The intent is not to compete with traditional scripting languages, but to 
+provide a solution for situations where C++ is already the language 
+of choice..</p>
+
+<h2><a name="Requirements">Requirements</a></h2>
+<ul>
+  <li>Be able to write portable script-style filesystem operations in modern 
+  C++.<br>
+  <br>
+  Rationale: This is a common programming need. It is both an 
+  embarrassment and a hardship that this is not possible with either the current 
+  C++ or Boost libraries.&nbsp; The need is particularly acute 
+  when C++ is the only toolset allowed in the tool chain.&nbsp; File system 
+  operations are provided by many languages&nbsp;used on multiple platforms, 
+  such as Perl and Python, as well as by many platform specific scripting 
+  languages. All operating systems provide some form of API for filesystem 
+  operations, and the POSIX bindings are increasingly available even on 
+  operating systems not normally associated with POSIX, such as the Mac, z/OS, 
+  or OS/390.<br>
+&nbsp;</li>
+  <li>Work within the <a href="#Realities">realities</a> described below.<br>
+  <br>
+  Rationale: This isn't a research project. The need is for something that works on 
+  today's platforms, including some of the embedded operating systems 
+  with limited file systems. Because of the emphasis on portability, such a 
+  library would be much more useful if standardized. That means being able to 
+  work with a much wider range of platforms that just Unix or Windows and their 
+  clones.<br>
+&nbsp;</li>
+  <li>Avoid dangerous programming practices. Particularly, all-too-easy-to-ignore error notifications 
+  and use of global variables.&nbsp;If a dangerous feature is provided, identify it as such.<br>
+  <br>
+  Rationale: Normally this would be covered by &quot;the usual Boost requirements...&quot;, 
+  but it is mentioned explicitly because the equivalent native platform and 
+  scripting language interfaces often depend on all-too-easy-to-ignore error 
+  notifications and global variables like &quot;current 
+  working directory&quot;.<br>
+&nbsp;</li>
+  <li>Structure the library so that it is still useful even if some functionality 
+  does not map well onto a given platform or directory tree. Particularly, much 
+  useful functionality should be portable even to flat 
+(non-hierarchical) filesystems.<br>
+  <br>
+  Rationale: Much functionality which does not 
+  require a hierarchical directory structure is still useful on flat-structure 
+  filesystems.&nbsp; There are many systems, particularly embedded systems, 
+  where even very limited functionality is still useful.</li>
+</ul>
+<ul>
+  <li>Interface smoothly with current C++ Standard Library input/output 
+  facilities.&nbsp; For example, paths should be 
+  easy to use in std::basic_fstream constructors.<br>
+  <br>
+  Rationale: One of the most common uses of file system functionality is to 
+  manipulate paths for eventual use in input/output operations.&nbsp; 
+  Thus the need to interface smoothly with standard library I/O.<br>
+&nbsp;</li>
+  <li>Suitable for eventual standardization. The implication of this requirement 
+  is that the interface be close to minimal, and that great care be take 
+  regarding portability.<br>
+  <br>
+  Rationale: The lack of file system operations is a serious hole 
+  in the current standard, with no other known candidates to fill that hole. 
+  Libraries with elaborate interfaces and difficult to port specifications are much less likely to be accepted for 
+  standardization.<br>
+&nbsp;</li>
+  <li>The usual Boost <a href="http://www.boost.org/more/lib_guide.htm">requirements and 
+  guidelines</a> apply.<br>
+&nbsp;</li>
+  <li>Encourage, but do not require, portability in path names.<br>
+  <br>
+  Rationale: For paths which originate from user input it is unreasonable to 
+  require portable path syntax.<br>
+&nbsp;</li>
+  <li>Avoid giving the illusion of portability where portability in fact does not 
+  exist.<br>
+  <br>
+  Rationale: Leaving important behavior unspecified or &quot;implementation defined&quot; does a 
+  great disservice to programmers using a library because it makes it appear 
+  that code relying on the behavior is portable, when in fact there is nothing 
+  portable about it. The only case where such under-specification is acceptable is when both users and implementors know from 
+  other sources exactly what behavior is required, yet for some reason it isn't 
+  possible to specify it exactly.</li>
+</ul>
+<h2><a name="Realities">Realities</a></h2>
+<ul>
+  <li>Some operating systems have a single directory tree root, others have 
+  multiple roots.<br>
+&nbsp;</li>
+  <li>Some file systems provide both a long and short form of filenames.<br>
+&nbsp;</li>
+  <li>Some file systems have different syntax for file paths and directory 
+  paths.<br>
+&nbsp;</li>
+  <li>Some file systems have different rules for valid file names and valid 
+  directory names.<br>
+&nbsp;</li>
+  <li>Some file systems (ISO-9660, level 1, for example) use very restricted 
+  (so-called 8.3) file names.<br>
+&nbsp;</li>
+  <li>Some operating systems allow file systems with different 
+  characteristics to be &quot;mounted&quot; within a directory tree.&nbsp; Thus a 
+  ISO-9660 or Windows 
+  file system may end up as a sub-tree of a POSIX directory tree.<br>
+&nbsp;</li>
+  <li>Wide-character versions of directory and file operations are available on some operating 
+  systems, and not available on others.<br>
+&nbsp;</li>
+  <li>There is no law that says directory hierarchies have to be specified in 
+  terms of left-to-right decent from the root.<br>
+&nbsp;</li>
+  <li>Some file systems have a concept of file &quot;version number&quot; or &quot;generation 
+  number&quot;.&nbsp; Some don't.<br>
+&nbsp;</li>
+  <li>Not all operating systems use single character separators in path names.&nbsp; Some use 
+  paired notations. A typical fully-specified OpenVMS filename
+  might look something like this:<br>
+  <br>
+  <code>&nbsp;&nbsp; DISK$SCRATCH:[GEORGE.PROJECT1.DAT]BIG_DATA_FILE.NTP;5<br>
+  </code><br>
+  The general OpenVMS format is:<br>
+  <br>
+&nbsp;&nbsp;&nbsp;&nbsp; 
+  <i>Device:[directories.dot.separated]filename.extension;version_number</i><br>
+&nbsp;</li>
+  <li>For common file systems, determining if two descriptors are for same 
+  entity is extremely difficult or impossible.&nbsp; For example, the concept of 
+  equality can be different for each portion of a path - some portions may be 
+  case or locale sensitive, others not. Case sensitivity is a property of the 
+  pathname itself, and not the platform. Determining collating sequence is even 
+  worse.<br>
+&nbsp;</li>
+  <li>Race-conditions may occur. Directory trees, directories, files, and file attributes are in effect shared between all threads, processes, and computers which have access to the 
+  filesystem.&nbsp; That may well include computers on the other side of the 
+  world or in orbit around the world. This implies that file system operations 
+  may fail in unexpected ways.&nbsp;For example:<br>
+  <br>
+  <code>&nbsp;&nbsp;&nbsp;&nbsp; assert( exists(&quot;foo&quot;) == exists(&quot;foo&quot;) ); 
+  // may fail!<br>
+&nbsp;&nbsp;&nbsp;&nbsp; assert( is_directory(&quot;foo&quot;) == is_directory(&quot;foo&quot;); 
+  // may fail!<br>
+  </code><br>
+  In the first example, the file may have been deleted between calls to 
+  exists().&nbsp; In the second example, the file may have been deleted and then 
+  replaced by a directory of the same name between the calls to is_directory().<br>
+&nbsp;</li>
+  <li>Even though an application may be portable, it still will have to traffic 
+  in system specific paths occasionally; user provided input is a common 
+  example.<br>
+&nbsp;</li>
+  <li><a name="symbolic-link-use-case">Symbolic</a> links cause canonical and 
+  normal form of some paths to represent different files or directories. For 
+  example, given the directory hierarchy <code>/a/b/c</code>, with a symbolic 
+  link in <code>/a</code> named <code>x</code>&nbsp; pointing to <code>b/c</code>, 
+  then under POSIX Pathname Resolution rules a path of <code>&quot;/a/x/..&quot;</code> 
+  should resolve to <code>&quot;/a/b&quot;</code>. If <code>&quot;/a/x/..&quot;</code> were first 
+  normalized to <code>&quot;/a&quot;</code>, it would resolve incorrectly. (Case supplied 
+  by Walter Landry.)</li>
+</ul>
+
+<h2><a name="Rationale">Rationale</a></h2>
+
+<p>The <a href="#Requirements">Requirements</a> and <a href="#Realities">
+Realities</a> above drove much of the C++ interface design.&nbsp; In particular, 
+the desire to make script-like code straightforward caused a great deal of 
+effort to go into ensuring that apparently simple expressions like <i>exists( &quot;foo&quot; 
+)</i> work as expected.</p>
+
+<p>See the <a href="faq.htm">FAQ</a> for the rationale behind many detailed 
+design decisions.</p>
+
+<p>Several key insights went into the <i>path</i> class design:</p>
+<ul>
+  <li>Decoupling of the input formats, internal conceptual (<i>vector&lt;string&gt;</i> 
+  or other sequence) 
+  model, and output formats.</li>
+  <li>Providing two input formats (generic and O/S specific) broke a major 
+  design deadlock.</li>
+  <li>Providing several output formats solved another set of previously 
+  intractable problems.</li>
+  <li>Several non-obvious functions (particularly decomposition and composition) 
+  are required to support portable code. (Peter Dimov, Thomas Witt, Glen 
+  Knowles, others.)</li>
+</ul>
+
+<p>Error checking was a particularly difficult area. One key insight was that 
+with file and directory names, portability isn't a universal truth.&nbsp; 
+Rather, the programmer must think out the question &quot;What operating systems do I 
+want this path to be portable to?&quot;&nbsp; By providing support for several 
+answers to that question, the Filesystem Library alerts programmers of the need 
+to ask it in the first place.</p>
+<h2><a name="Abandoned_Designs">Abandoned Designs</a></h2>
+<h3>operations.hpp</h3>
+<p>Dietmar Kühl's original dir_it design and implementation supported 
+wide-character file and directory names. It was abandoned after extensive 
+discussions among Library Working Group members failed to identify portable 
+semantics for wide-character names on systems not providing native support. See
+<a href="faq.htm#wide-character_names">FAQ</a>.</p>
+<p>Previous iterations of the interface design used explicitly named functions providing a 
+large number of convenience operations, with no compile-time or run-time 
+options. There were so many function names that they were very confusing to use, 
+and the interface was much larger. Any benefits seemed theoretical rather than 
+real. </p>
+<p>Designs based on compile time (rather than runtime) flag and option selection 
+(via policy, enum, or int template parameters) became so complicated that they 
+were abandoned, often after investing quite a bit of time and effort. The need 
+to qualify attribute or option names with namespaces, even aliases, made use in 
+template parameters ugly; that wasn't fully appreciated until actually writing 
+real code.</p>
+<p>Yet another set of convenience functions ( for example, <i>remove</i> with 
+permissive, prune, recurse, and other options, plus predicate, and possibly 
+other, filtering features) were abandoned because the details became both 
+complex and contentious.</p>
+
+<p>What is left is a toolkit of low-level operations from which the user can 
+create more complex convenience operations, plus a very small number of 
+convenience functions which were found to be useful enough to justify inclusion.</p>
+
+<h3>path.hpp</h3>
+
+<p>There were so many abandoned path designs, I've lost track. Policy-based 
+class templates in several flavors, constructor supplied runtime policies, 
+operation specific runtime policies, they were all considered, often 
+implemented, and ultimately abandoned as far too complicated for any small 
+benefits observed.</p>
+
+<p>Additional design considerations apply to <a href="v3_design.html">Internationalization</a>. </p>
+
+<h3>error checking</h3>
+
+<p>A number of designs for the error checking machinery were abandoned, some 
+after experiments with implementations. Totally automatic error checking was 
+attempted in particular. But automatic error checking tended to make the overall 
+library design much more complicated.</p>
+
+<p>Some designs associated error checking mechanisms with paths.&nbsp; Some with 
+operations functions.&nbsp; A policy-based error checking template design was 
+partially implemented, then abandoned as too complicated for everyday 
+script-like programs.</p>
+
+<p>The final design, which depends partially on explicit error checking function 
+calls,&nbsp; is much simpler and straightforward, although it does depend to 
+some extent on programmer discipline.&nbsp; But it should allow programmers who 
+are concerned about portability to be reasonably sure that their programs will 
+work correctly on their choice of target systems.</p>
+
+<h2><a name="References">References</a></h2>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="100%">
+  <tr>
+    <td width="13%" valign="top">[<a name="IBM-01">IBM-01</a>]</td>
+    <td width="87%">IBM Corporation, <i>z/OS V1R3.0 C/C++ Run-Time 
+Library Reference</i>, SA22-7821-02, 2001,
+<a href="http://www-1.ibm.com/servers/eserver/zseries/zos/bkserv/">
+    www-1.ibm.com/servers/eserver/zseries/zos/bkserv/</a></td>
+  </tr>
+  <tr>
+    <td width="13%" valign="top">[<a name="ISO-9660">ISO-9660</a>]</td>
+    <td width="87%">International Standards Organization, 1988</td>
+  </tr>
+  <tr>
+    <td width="13%" valign="top">[<a name="Kuhn">Kuhn</a>]</td>
+    <td width="87%">UTF-8 and Unicode FAQ for Unix/Linux,
+<a href="http://www.cl.cam.ac.uk/~mgk25/unicode.html">
+    www.cl.cam.ac.uk/~mgk25/unicode.html</a></td>
+  </tr>
+  <tr>
+    <td width="13%" valign="top">[<a name="MSDN">MSDN</a>] </td>
+    <td width="87%">Microsoft Platform SDK for Windows, Storage Start 
+Page,
+<a href="http://msdn.microsoft.com/library/en-us/fileio/base/storage_start_page.asp">
+    msdn.microsoft.com/library/en-us/fileio/base/storage_start_page.asp</a></td>
+  </tr>
+  <tr>
+    <td width="13%" valign="top">[<a name="POSIX-01">POSIX-01</a>]</td>
+    <td width="87%">IEEE&nbsp;Std&nbsp;1003.1-2001, ISO/IEC 9945:2002, and The Open Group Base Specifications, Issue 6. Also known as The 
+    Single Unix<font face="Times New Roman">® Specification, Version 3. 
+    Available from each of the organizations involved in its creation. For 
+    example, read online or download from
+    <a href="http://www.unix.org/single_unix_specification/">
+    www.unix.org/single_unix_specification/</a>.</font> The ISO JTC1/SC22/WG15 - POSIX 
+homepage is <a href="http://www.open-std.org/jtc1/sc22/WG15/">
+    www.open-std.org/jtc1/sc22/WG15/</a></td>
+  </tr>
+  <tr>
+    <td width="13%" valign="top">[<a name="URI">URI</a>]</td>
+    <td width="87%">RFC-2396, Uniform Resource Identifiers (URI): Generic 
+Syntax, <a href="http://www.ietf.org/rfc/rfc2396.txt">
+    www.ietf.org/rfc/rfc2396.txt</a></td>
+  </tr>
+  <tr>
+    <td width="13%" valign="top">[<a name="UTF-16">UTF-16</a>]</td>
+    <td width="87%">Wikipedia, UTF-16,
+<a href="http://en.wikipedia.org/wiki/UTF-16">
+    en.wikipedia.org/wiki/UTF-16</a></td>
+  </tr>
+  <tr>
+    <td width="13%" valign="top">[<a name="Wulf-Shaw-73">Wulf-Shaw-73</a>]</td>
+    <td width="87%">William Wulf, Mary Shaw, <i>Global 
+Variable Considered Harmful</i>, ACM SIGPLAN Notices, 8, 2, 1973, pp. 23-34</td>
+  </tr>
+</table>
+
+<hr>
+<p>Revised
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->18 February, 2010<!--webbot bot="Timestamp" endspan i-checksum="40538" --></p>
+
+<p>© Copyright Beman Dawes, 2002</p>
+<p> Use, modification, and distribution are subject to the Boost Software 
+License, Version 1.0. (See accompanying file <a href="../../../LICENSE_1_0.txt">
+LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a>)</p>
+
+</body>
+
+</html>

v3/libs/filesystem/doc/do_list.html

@@ -0,0 +1,148 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Language" content="en-us">
+<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<title>Do List</title>
+<style type="text/css">
+  body    { font-family: sans-serif; margin: 1em; }
+  p, td, li, blockquote { font-size: 10pt; }
+  pre     { font-size: 9pt; }
+</style>
+</head>
+
+<body>
+
+<h1>Boost Filesystem Do List<br>
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->31 May 2010<!--webbot bot="Timestamp" endspan i-checksum="15103" --></h1>
+
+<h2>Beta 1 comments</h2>
+<ul>
+  <li dir="ltr">
+
+<p dir="ltr">Zach Laine:</li>
+</ul>
+<blockquote>
+  <pre dir="ltr">The descriptions for portable_name() and portable_directory_name()
+appear to be at odds.
+
+portable_name() : ... &amp;&amp; (name is &quot;.&quot; or &quot;..&quot;, and the first character
+not a period or hyphen)
+
+portable_directory_name(): ... &amp;&amp; (name is &quot;.&quot; or &quot;..&quot; &nbsp;or contains no periods)
+
+Should portable_name() be &quot;... &amp;&amp; (name is &quot;.&quot; or &quot;..&quot;, or contains no
+periods) &amp;&amp; (first character not a hyphen)&quot;? &nbsp;Maybe I'm missing
+something?</pre>
+</blockquote>
+<ul>
+  <li dir="ltr">
+<p dir="ltr">Scott McMurray - treat as Wish List:</li>
+</ul>
+<blockquote>
+  <pre dir="ltr">- uncomplete(p, base)
+
+My pet request. &nbsp;It may be useful to simplify other functions as well,
+since there's no current way to go from an absolute path to a relative
+one, meaning that most functions need to handle relative ones even
+when that might not be natural. &nbsp;With this functionality,
+preconditions requiring absolute paths would be less onerous.
+
+&nbsp; &nbsp;Precondition: p.is_absolute() &amp;&amp; base.is_absolute()
+
+&nbsp; &nbsp;Effects: Extracts a path, rp, from p relative to base such that
+canonical(p) == complete(rp, base). &nbsp;Any &quot;..&quot; path elements in rp form
+a prefix.
+
+&nbsp; &nbsp;Returns: The extracted path.
+
+&nbsp; &nbsp;Postconditions: For the returned path, rp, rp.is_relative() ==
+(p.root_name() == b.root_name()).
+
+[Notes: This function simplifies paths by omitting context. &nbsp;It is
+particularly useful for serializing paths such that it can be usefully
+moved between hosts where the context may be different, such as inside
+source control trees. &nbsp;It can also be helpful for display to users,
+such as in shells where paths are often shown relative to $HOME.
+
+In the presence of symlinks, the result of this function may differ
+between implementations, as some may expand symlinks that others may
+not. &nbsp;The simplest implementation uses canonical to expand both p and
+base, then removes the common prefix and prepends the requisite &quot;..&quot;
+elements. &nbsp;Smarter implementations will avoid expanding symlinks
+unnecessarily. &nbsp;No implementation is expected to discover new symlinks
+to return paths with fewer elements.]</pre>
+</blockquote>
+<h2 dir="ltr">Docs</h2>
+<ul>
+  <li>Reorganize files - delete examples that no longer apply.</li>
+  <li>Should minimal.css be changed to used relative font sizes? See
+  <a href="http://www.w3schools.com/CSS/pr_font_font-size.asp/">http://www.w3schools.com/CSS/pr_font_font-size.asp\</a></li>
+  <li>Document behavior of path::replace_extension has change WRT argument w/o a 
+  dot.</li>
+  <li style="font-size: 10pt">Document leading //: no longer treated specially. 
+  But is that really correct?</li>
+  <li style="font-size: 10pt">Behavior of root_path() has been changed. Change 
+  needs to be propagated to trunk?</li>
+  <li style="font-size: 10pt">Add docs for scoped_path_locale.</li>
+  <li style="font-size: 10pt">Regenerate path decomposition table.</li>
+</ul>
+
+<h2>Code</h2>
+<h3>All</h3>
+<ul>
+  <li style="font-size: 10pt">Move semantics.</li>
+  <li style="font-size: 10pt">Use BOOST_DELETED, BOOST_DEFAULTED, where 
+  appropriate.</li>
+  <li style="font-size: 10pt">Other C++0x features.</li>
+</ul>
+<h3>Class path</h3>
+<ul>
+  <li>Windows, POSIX, conversions for char16_t, char32_t for C++0x compilers.</li>
+  <li>Add Windows Alternate Data Stream test cases. See http://en.wikipedia.org/wiki/NTFS 
+  Features.</li>
+  <li>Add test case: relational operators on paths differing only in trailing 
+  separator. Rationale?</li>
+  <li>Provide the name check functions for more character types? Templatize? 
+  take a path argument?</li>
+  <li style="font-size: 10pt">Add test for scoped_path_locale.</li>
+  <li style="font-size: 10pt">Add codepage 936/950/etc test cases.</li>
+  <li style="font-size: 10pt">Should UDT's be supported?</li>
+  <li style="font-size: 10pt">Should path iteration to a separator result in:<br>
+  -- the actual separator used<br>
+  -- the preferred separator<br>
+  -- the generic separator &lt;-- makes it easier to write portable code<br>
+  -- a dot</li>
+</ul>
+<h3>Operations</h3>
+<ul>
+  <li>Would complete(), system_complete() be clearer if renamed absolute(), 
+  absolute_system() (or absolute_native())?</li>
+  <li>Review all operations.cpp code for race conditions similar to #2925. Fix 
+  or document.</li>
+  <li>Enable all BOOST_FILESYSTEM_NO_DEPRECATED code.</li>
+  <li>rename and remove names are problems. If users says &quot;using 
+  namespace boost::filesystem&quot;<br>
+  and some header included stdio, there is just too much chance of silent error.</li>
+  <li>create_directories error handling needs work.</li>
+  <li>Fold convenience.hpp into operations.hpp</li>
+  <li>Two argument recursive_directory_iterator ctor isn't recognizing throws(). 
+  Would it be better to fold into a single two argument ctor with default?</li>
+  <li>Add the push_directory class from tools/release/required_files.cpp</li>
+</ul>
+
+<h3>Miscellaneous</h3>
+<ul>
+  <li style="font-size: 10pt"><i>Regular</i> classes need hash functions.</li>
+</ul>
+
+<hr>
+<p>© Copyright Beman Dawes, 2010</p>
+<p>Distributed under the Boost Software License, Version 1.0. See
+<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
+
+</body>
+
+</html>

v3/libs/filesystem/doc/faq.htm

@@ -0,0 +1,147 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Language" content="en-us">
+<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<title>Filesystem FAQ</title>
+<link rel="stylesheet" type="text/css" href="minimal.css">
+</head>
+
+<body>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
+  <tr>
+    <td width="277">
+<a href="../../../index.htm">
+<img src="../../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="300" height="86" border="0"></a></td>
+    <td align="middle">
+    <font size="7">Filesystem FAQ</font>
+    </td>
+  </tr>
+</table>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="100%">
+  <tr>
+    <td><a href="../../../index.htm">Boost Home</a> &nbsp;&nbsp;
+    <a href="index.htm">Library Home</a> &nbsp;&nbsp;
+    <a href="reference.html">Reference</a> &nbsp;&nbsp;
+    <a href="tutorial.html">Tutorial</a> &nbsp;&nbsp;
+    <a href="faq.htm">FAQ</a> &nbsp;&nbsp;
+    <a href="portability_guide.htm">Portability</a> &nbsp;&nbsp;
+    <a href="v3.html">V3 Intro</a> &nbsp;&nbsp;
+    <a href="v3_design.html">V3 Design</a> &nbsp;&nbsp;
+    <a href="deprecated.html">Deprecated</a> &nbsp;&nbsp;
+    </td>
+  </tr>
+</table>
+
+<h1 dir="ltr">
+Frequently Asked Questions</h1>
+<h2>General questions</h2>
+<p><b>Why not support a  concept of specific kinds of file systems, such as posix_file_system or windows_file_system.</b></p>
+<p>Portability is one of the most important requirements for the 
+library.&nbsp;Features specific to a particular operating system or file system 
+can always be accessed by using the operating system's API.</p>
+
+<h2 dir="ltr">
+Class <code><font size="6">path</font></code> questions </h2>
+<p><b>Why base the generic pathname format on POSIX?</b></p>
+<p><a href="design.htm#POSIX-01">POSIX</a> is an ISO Standard. It is the basis for the most familiar 
+pathname formats, 
+not just for POSIX-based operating systems but also for Windows  and the 
+URL portion of URI's. It is ubiquitous and 
+familiar.&nbsp; On many systems, it is very easy to implement because it is 
+either the native operating system format (Unix and Windows) or via a 
+operating system supplied 
+POSIX library (z/OS, OS/390, and many more.)</p>
+<p><b>Why not use a full URI (Universal Resource Identifier) based path?</b></p>
+<p><a href="design.htm#URI">URI's</a> would promise more than the Filesystem Library can actually deliver, 
+since URI's extend far beyond what most operating systems consider a file or a 
+directory.&nbsp; Thus for the primary &quot;portable script-style file system 
+operations&quot; requirement of the Filesystem Library, full URI's appear to be over-specification.</p>
+<p><b>Why isn't <i>path</i> a base class with derived <i>directory_path</i> and
+<i>file_path</i> classes?</b></p>
+<p>Why bother?&nbsp; The behavior of all three classes is essentially identical. 
+Several early versions did require users to identify each path as a file or 
+directory path, and this seemed to increase coding errors and decrease code 
+readability. There was no apparent upside benefit.</p>
+<p><b>Why do path decomposition functions yielding a single element return a 
+path rather than a string?</b></p>
+<p>Interface simplicity. If they returned strings, flavors would be needed for
+<code>string</code>, <code>wstring</code>, <code>u16string</code>, <code>
+u32string</code>, and generic strings.</p>
+<p><b>Why don't path member functions have overloads with error_code&amp; arguments?</b></p>
+<p>They have not been requested by users; the need for error reporting via 
+error_code seems limited to operations failures rather than path failures.</p>
+<h2>Operations function questions</h2>
+<p><b>Why not supply a 'handle' type, and let the file and directory operations 
+traffic in it?</b></p>
+<p>It isn't clear there is any feasible way to meet the &quot;portable script-style 
+file system operations&quot; requirement with such a system. File systems exist where operations are usually performed on 
+  some non-string handle type. The classic Mac OS has been mentioned explicitly as a case where 
+trafficking in paths isn't always natural.&nbsp;&nbsp;&nbsp; </p>
+<p>The case for the &quot;handle&quot; (opaque data type to identify a file) 
+style may be strongest for directory iterator value type.&nbsp; (See Jesse Jones' Jan 28, 
+2002, Boost postings). However, as class path has evolved, it seems sufficient 
+even as the directory iterator value type.</p>
+<p><b>Why are the operations functions so low-level?</b></p>
+<p>To provide a toolkit from which higher-level functionality can be created.</p>
+<p>An 
+extended attempt to add convenience functions on top of, or as a replacement 
+for, the low-level functionality failed because there is no widely acceptable 
+set of simple semantics for most convenience functions considered.&nbsp; 
+Attempts to provide alternate semantics via either run-time options or 
+compile-time polices became overly complicated in relation to the value 
+delivered, or became contentious.&nbsp; OTOH, the specific functionality needed for several trial 
+applications was very easy for the user to construct from the lower-level 
+toolkit functions.&nbsp; See <a href="design.htm#Abandoned_Designs">Failed 
+Attempts</a>.</p>
+<p><b>Isn't it inconsistent then to provide a few convenience functions?</b></p>
+<p>Yes, but experience with both this library, POSIX, and Windows, indicates 
+the utility of certain convenience functions, and that it is possible to provide 
+simple, yet widely acceptable, semantics for them. For example, <code>remove_all()</code>.</p>
+<p><b>Why are there directory_iterator overloads for operations.hpp 
+predicate functions? Isn't two ways to do the same thing poor design?</b></p>
+<p>Yes, two ways to do the same thing is often a poor design practice. But the 
+iterator versions are often much more efficient. Calling status() during 
+iteration over a directory containing 15,000 files took 6 seconds for the path 
+overload, and 1 second for the iterator overload, for tests on a freshly booted 
+machine. Times were .90 seconds and .30 seconds, for tests after prior use of 
+the directory. This performance gain is large enough to justify deviating from 
+preferred design practices. Neither overload alone meets all needs.</p>
+<p><b>Why are the operations functions so picky about errors?</b></p>
+<p>Safety. The default is to be safe rather than sorry. This is particularly 
+important given the reality that on many computer systems files and directories 
+are globally shared resources, and thus subject to 
+race conditions.</p>
+<p><b>Why are attributes accessed via named functions rather than property maps?</b></p>
+<p>For  commonly used attributes (existence, directory or file, emptiness), 
+simple syntax and guaranteed presence outweigh other considerations. Because 
+access to many other attributes is inherently system dependent, 
+property maps are viewed as the best hope for access and modification, but it is 
+better design to provide such functionality in a separate library. (Historical 
+note: even the apparently simple attribute &quot;read-only&quot; turned out to be so 
+system depend as to be disqualified as a &quot;guaranteed presence&quot; operation.)</p>
+<p><b>Why isn't automatic name portability error detection provided?</b></p>
+<p>A number (at least six) of designs for  name validity error 
+detection were evaluated, including at least four complete implementations.&nbsp; 
+While the details for rejection differed, all of the more powerful name validity checking 
+designs distorted other 
+otherwise simple aspects of the library. Even the simple name checking provided 
+in prior library versions was a constant source of user complaints. While name checking can be helpful, it 
+isn't important enough to justify added a lot of additional complexity.</p>
+<p><b>Why are paths sometimes manipulated by member functions and sometimes by 
+non-member functions?</b></p>
+<p>The design rule is that purely lexical operations are supplied as <i>class 
+path</i> member 
+functions, while operations performed by the operating system are provided as 
+free functions.</p>
+<hr>
+<p>Revised
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->17 February, 2010<!--webbot bot="Timestamp" endspan i-checksum="40536" --></p>
+<p>© Copyright Beman Dawes, 2002</p>
+<p> Use, modification, and distribution are subject to the Boost Software 
+License, Version 1.0. See <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a></p>

v3/libs/filesystem/doc/index.htm

@@ -0,0 +1,440 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Language" content="en-us">
+<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<title>Filesystem Home</title>
+<link rel="stylesheet" type="text/css" href="minimal.css">
+</head>
+
+<body>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
+  <tr>
+    <td width="277">
+<a href="../../../index.htm">
+<img src="../../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="300" height="86" border="0"></a></td>
+    <td align="middle">
+    <font size="7">Filesystem Library</font>
+    </td>
+  </tr>
+</table>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="100%">
+  <tr>
+    <td><a href="../../../index.htm">Boost Home</a> &nbsp;&nbsp;
+    <a href="index.htm">Library Home</a> &nbsp;&nbsp;
+    <a href="reference.html">Reference</a> &nbsp;&nbsp;
+    <a href="tutorial.html">Tutorial</a> &nbsp;&nbsp;
+    <a href="faq.htm">FAQ</a> &nbsp;&nbsp;
+    <a href="portability_guide.htm">Portability</a> &nbsp;&nbsp;
+    <a href="v3.html">V3 Intro</a> &nbsp;&nbsp;
+    <a href="v3_design.html">V3 Design</a> &nbsp;&nbsp;
+    <a href="deprecated.html">Deprecated</a> &nbsp;&nbsp;
+    </td>
+  </tr>
+</table>
+
+<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" align="right">
+  <tr>
+    <td width="100%" bgcolor="#D7EEFF" align="center">
+      <i><b>Contents</b></i></td>
+  </tr>
+  <tr>
+    <td width="100%" bgcolor="#E8F5FF">
+    <a href="#Introduction">Introduction</a><br>
+    <a href="#Documentation">Documentation</a><br>
+    <a href="#Using">Using the library</a><br>
+    <a href="#Cautions">Cautions</a><br>
+    <a href="#Headers">Headers</a><br>
+    <a href="#Examples">Example programs</a><br>
+    <a href="#Implementation">Implementation</a><br>
+    <a href="#Macros">Macros</a><br>
+    <a href="#Building">Building the object-library</a><br>
+    <a href="#Cgywin">Notes for Cygwin users</a><br>
+    <a href="#Change-history">Version history<br>
+&nbsp; with acknowledgements</a></td>
+  </tr>
+  </table>
+
+<h2><a name="Introduction">Introduction</a></h2>
+<p>The Boost.Filesystem library provides facilities to manipulate files and directories, 
+and the paths that identify them.</p>
+
+<p>The features of the library include:</p>
+
+<ul>
+  <li><b>A modern C++ interface, highly compatible with the C++ standard 
+  library.</b></li>
+</ul>
+<blockquote>
+  <blockquote>
+
+<p>Many users say the interface is their primary motivation for using 
+Boost.Filesystem. They like its use of familiar idioms based on standard library 
+containers, iterators, and algorithms. They like having errors reported by 
+throwing exceptions.</p>
+
+  </blockquote>
+</blockquote>
+<ul>
+  <li><b>Portability between operating systems.</b><br>
+&nbsp;<ul>
+    <li>At the C++ syntax level, it is convenient to learn and use one interface 
+    regardless of the operating system.</li>
+    <li>At the semantic level, behavior of code is reasonably portable across 
+    operating systems.</li>
+    <li>Dual generic or native path format support encourages program 
+    portability, yet still allows communication with users in system specific 
+    formats.<br>
+&nbsp;</li>
+  </ul>
+  </li>
+  <li><b>Error handling and reporting via C++ exceptions (the default) or error 
+  codes.</b><br>
+&nbsp;<ul>
+    <li>C++ exceptions are the preferred error reporting mechanism for most 
+    applications. The exception thrown includes the detailed error code 
+    information important for diagnosing the exact cause of file system errors.</li>
+    <li>Error reporting via error code allows user code that provides detailed 
+    error recovery to avoid becoming so littered with try-catch blocks as to be 
+    unmaintainable. <br>
+&nbsp;</li>
+  </ul>
+  </li>
+  <li><b>Suitable for a broad spectrum of applications, ranging from simple 
+  script-like operations to extremely complex production code.</b><br>
+&nbsp;<ul>
+    <li>At the simple script-like end of the spectrum, the intent is not to 
+    compete with Python, Perl, or shell languages, but rather to provide 
+    filesystem operations when C++ is already the language of choice.</li>
+    <li>Finer grained control over operations and error handling is available to 
+    support more complex applications or other cases where throwing exceptions 
+    isn't desired.</li>
+  </ul>
+  </li>
+</ul>
+
+<p>A proposal,
+<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1975.html">
+N1975</a>, to include Boost.Filesystem in Technical Report 2 has been accepted 
+by the C++ Standards Committee. That proposal was based on version 2 of 
+Boost.Filesystem; presumably the final TR2 form will be based on version 3.</p>
+
+<h2><a name="Documentation">Documentation</a></h2>
+
+<p><b><a href="tutorial.html">Tutorial</a></b> - A gentle introduction to 
+the library, with example programs provided for you to experiment with.</p>
+
+<p><b><a href="reference.html">Reference</a></b> - Formal documentation in the 
+style of the C++ standard for 
+every component of the library.</p>
+
+<p><b><a href="faq.htm">FAQ</a></b> - Frequently asked questions.</p>
+
+<p><b><a href="portability_guide.htm">Portability Guide</a></b> - Help for those 
+concerned with writing code to run on multiple operating systems.</p>
+
+<p><b><a href="deprecated.html">Deprecated Features</a></b> - Identifies 
+deprecated features and their replacements.</p>
+
+<p><b><a href="v3.html">Version 3 Introduction</a></b> - Aimed at users of prior 
+Boost.Filesystem versions.</p>
+
+<p><b><a href="v3_design.html">Version 3 Design</a></b> - Historical document 
+from the start of the Version 3 design process.</p>
+
+<p><b><a href="design.htm">Original Design</a></b> - Historical document from 
+the start of the Version 1 design process.</p>
+
+<p><b><a href="do_list.html">Do List</a></b> - Boost.Filesystem development work 
+in the pipeline.</p>
+
+<h2><a name="Using">Using</a> the library</h2>
+<p>Boost.Filesystem is implemented as a separately compiled library, so  you must install 
+binaries in a location that can be found by your linker. If you followed the 
+<a href="http://www.boost.org/doc/libs/release/more/getting_started/index.html">Boost Getting Started</a> instructions, that's already been done for you.</p>
+<h2><a name="Cautions">Cautions</a></h2>
+<p>After reading the tutorial you can dive right into  simple, 
+script-like programs using the Filesystem Library! Before doing any serious 
+work, however, there a few cautions to be aware of:</p>
+<h4><b>Effects and Postconditions not guaranteed in the presence of race-conditions</b></h4>
+<p>Filesystem function specifications follow the C++ Standard Library form, specifying behavior in terms of 
+effects and postconditions. If 
+a <a href="reference.html#Race-condition">race-condition</a> exists, a function's 
+postconditions may no longer be true by the time the function returns to the 
+caller.</p>
+<blockquote>
+<p><b><i>Explanation: </i></b>The state of files and directories is often
+globally shared, and thus may be changed unexpectedly by other threads, 
+processes, or even other computers having network access to the filesystem. As an 
+example of the difficulties this can cause, note that the following asserts 
+may fail:</p>
+<blockquote>
+<p><code>assert( exists( &quot;foo&quot; ) == exists( &quot;foo&quot; ) );&nbsp; // 
+(1)<br>
+<br>
+remove_all( &quot;foo&quot; );<br>
+assert( !exists( &quot;foo&quot; ) );&nbsp; // (2)<br>
+<br>
+assert( is_directory( &quot;foo&quot; ) == is_directory( &quot;foo&quot; ) ); // 
+(3)</code></p>
+</blockquote>
+<p>(1) will fail if a non-existent &quot;foo&quot; comes into existence, or an 
+existent &quot;foo&quot; is removed, between the first and second call to <i>exists()</i>. 
+This could happen if, during the execution of the example code, another thread, 
+process, or computer is also performing operations in the same directory.</p>
+<p>(2) will fail if between the call to <i>remove_all()</i> and the call to
+<i>exists()</i> a new file or directory named &quot;foo&quot; is created by another 
+thread, process, or computer.</p>
+<p>(3) will fail if another thread, process, or computer removes an 
+existing file &quot;foo&quot; and then creates a directory named &quot;foo&quot;, between the 
+example code's two calls to <i>is_directory()</i>.</p>
+</blockquote>
+<h4><b>May throw exceptions</b></h4>
+<p>Unless otherwise specified, Boost.Filesystem functions throw <i>
+<a href="reference.html#basic_filesystem_error-constructors">basic_filesystem_error</a></i> 
+exceptions if they cannot successfully complete their operational 
+specifications. Also, implementations may use C++ Standard Library functions, 
+which may throw <i>std::bad_alloc</i>. These exceptions may be thrown even 
+though the error condition leading to the exception is not explicitly specified 
+in the function's &quot;Throws&quot; paragraph.</p>
+<p>All exceptions thrown by the Filesystem 
+Library are implemented by calling <a href="../../utility/throw_exception.html">
+boost::throw_exception()</a>. Thus exact behavior may differ depending on 
+BOOST_NO_EXCEPTIONS at the time the filesystem source files are compiled.</p>
+<p>Non-throwing versions are provided of several functions that are often used 
+in contexts where error codes may be the preferred way to report an error.</p>
+
+<h2><a name="Headers">Headers</a></h2>
+
+<p>The Boost.Filesystem library provides several&nbsp;headers:</p>
+
+<ul>
+  <li>Header &lt;<a href="../../../boost/filesystem.hpp">boost/filesystem.hpp</a>&gt; 
+  provides access to all features of the library, except file streams.<br>
+&nbsp;</li>
+  <li>Header &lt;<a href="../../../boost/filesystem/fstream.hpp">boost/filesystem<i>/</i>fstream.hpp</a>&gt; 
+  inherits the same components as the C++ Standard 
+  Library's <i>fstream</i> header, but files are identified by <code>const path&amp;</code> 
+  arguments rather that <code>const char*</code> arguments.</li>
+</ul>
+<h2><a name="Examples">Example programs</a></h2>
+<p>See the <a href="tutorial.html">tutorial</a> for example programs.</p>
+<h3>Other examples</h3>
+<p>The programs used to generate the Boost regression test status tables use the 
+Filesystem Library extensively.&nbsp; See:</p>
+<ul>
+  <li><a href="../../../tools/regression/src/process_jam_log.cpp">process_jam_log.cpp</a></li>
+  <li><a href="../../../tools/regression/src/compiler_status.cpp">compiler_status.cpp</a></li>
+</ul>
+<h2><a name="Implementation">Implementation</a></h2>
+<p>The current implementation supports operating systems which provide 
+the POSIX or Windows API's.</p>
+<p>The library is in regular use on Apple  OS X, HP-UX, IBM AIX, Linux, 
+Microsoft Windows, SGI IRIX, and Sun Solaris operating systems using a variety 
+of compilers.</p>
+<h2><a name="Macros">Macros</a></h2>
+<p>Users may defined the following macros if desired. Sensible defaults are 
+provided, so users can ignore these macros unless they have special needs.</p>
+<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
+  <tr>
+    <td><b><i>Macro Name</i></b></td>
+    <td><b><i>Default</i></b></td>
+    <td><b><i>Effect if defined</i></b></td>
+  </tr>
+  <tr>
+    <td valign="top"><code>BOOST_FILESYSTEM_NO_DEPRECATED</code></td>
+    <td valign="top">Not defined.</td>
+    <td valign="top">Deprecated features are excluded from headers.</td>
+  </tr>
+  <tr>
+    <td valign="top"><code>BOOST_FILESYSTEM_DYN_LINK</code></td>
+    <td valign="top">Defined if <code>BOOST_ALL_DYN_LINK</code> is defined, 
+    otherwise not defined.</td>
+    <td valign="top">The Boost.Filesystem library is dynamically linked. If not defined, 
+    static linking is assumed.</td>
+  </tr>
+  <tr>
+    <td valign="top"><code>BOOST_FILESYSTEM_NO_LIB</code></td>
+    <td valign="top">Defined if <code>BOOST_ALL_NO_LIB</code> is defined, 
+    otherwise not defined.</td>
+    <td valign="top">Boost.Filesystem library does not use the Boost auto-link 
+    facility.</td>
+  </tr>
+  </table>
+<p>User-defined BOOST_POSIX_API and BOOST_WINDOWS_API macros are no longer 
+supported.</p>
+<h2><a name="Building">Building</a> the object-library</h2>
+<p>The object-library will  be built automatically if you are using the Boost 
+build system. See
+<a href="../../../more/getting_started.html">Getting Started</a>. It can also be 
+built manually using a <a href="../build/Jamfile.v2">Jamfile</a> 
+supplied in directory libs/filesystem/build, or the user can construct an IDE 
+project or make file which includes the object-library source files.</p>
+<p>The object-library source files are 
+supplied in directory <a href="../src">libs/filesystem/src</a>. These source files implement the 
+library for POSIX or Windows compatible operating systems; no implementation is 
+supplied for other operating systems. Note that many operating systems not 
+normally thought of as POSIX  systems, such as mainframe legacy 
+operating systems or embedded operating systems, support POSIX compatible file 
+systems and so will work with the Filesystem Library.</p>
+<p>The object-library can be built for static or dynamic (shared/dll) linking. 
+This is controlled by the BOOST_ALL_DYN_LINK or BOOST_FILESYSTEM_DYN_LINK 
+macros. See the <a href="http://www.boost.org/development/separate_compilation.html">Separate 
+Compilation</a> page for a description of the techniques used.</p>
+<h3>Note for <a name="Cgywin">Cygwin</a> users</h3>
+<p> <a href="http://www.cygwin.com/">Cygwin</a> version 1.7 or later is 
+required. Only later versions of GCC with wide character strings are supported. 
+The library's implementation code treats Cygwin as a Windows platform, and thus 
+uses the Windows API.</p>
+
+<h2><a name="Change-history">Version history</a></h2>
+
+<h3>Version 3</h3>
+
+<p>Boost 1.??.0 - ???, 2010 - Internationalization via single class <code>path</code>. 
+More uniform error handling.</p>
+
+<p>Peter Dimov suggested use of a single path class rather than a <code>basic_path</code> 
+class template. That idea was the basis for the Version 3 redesign.</p>
+
+<p>Thanks for comments from Robert Stewart, Zach Laine, Peter Dimov, Gregory 
+Peele, Scott McMurray, John Bytheway, Jeff Flinn, Jeffery Bosboom.</p>
+
+<h3>Version 2</h3>
+
+<p>Boost 1.34.0 - May, 2007 - Internationalization via <code>basic_path</code> 
+template.</p>
+
+<p>So many people have contributed comments and bug reports that it isn't any 
+longer possible to acknowledge them individually. That said, Peter Dimov and Rob 
+Stewart need to be specially thanked for their many constructive criticisms and 
+suggestions. Terence 
+Wilson and Chris Frey contributed timing programs which helped illuminate 
+performance issues.</p>
+
+<h3>Version 1</h3>
+
+<p>Boost 1.30.0 - March, 2003 - Initial official Boost release.</p>
+
+<p>The Filesystem Library was designed and implemented by Beman Dawes. The 
+original <i>directory_iterator</i> and <i>filesystem_error</i> classes were 
+based on prior work from Dietmar Kuehl, as modified by Jan Langer. Thomas Witt 
+was a particular help in later stages of initial development. Peter Dimov and 
+Rob Stewart made many useful suggestions and comments over a long period of 
+time. Howard Hinnant helped with internationalization issues.</p>
+
+<p>Key <a href="design.htm#Requirements">design requirements</a> and
+<a href="design.htm#Realities">design realities</a> were developed during 
+extensive discussions on the Boost mailing list, followed by comments on the 
+initial implementation. Numerous helpful comments were then received during the 
+Formal Review.<p>Participants included 
+Aaron Brashears,
+Alan Bellingham,
+Aleksey Gurtovoy,
+Alex Rosenberg,
+Alisdair Meredith,
+Andy Glew,
+Anthony Williams,
+Baptiste Lepilleur, 
+Beman Dawes,
+Bill Kempf,
+Bill Seymour, 
+Carl Daniel,
+Chris Little,
+Chuck Allison,
+Craig Henderson, 
+Dan Nuffer,
+Dan'l Miller,
+Daniel Frey, 
+Darin Adler, 
+David Abrahams,
+David Held, 
+Davlet Panech,
+Dietmar Kuehl,
+Douglas Gregor, 
+Dylan Nicholson,
+Ed Brey, 
+Eric Jensen,
+Eric Woodruff,
+Fedder Skovgaard,
+Gary Powell,
+Gennaro Prota,
+Geoff Leyland, 
+George Heintzelman, 
+Giovanni Bajo,
+Glen Knowles,
+Hillel Sims,
+Howard Hinnant,
+Jaap Suter,
+James Dennett, 
+Jan Langer, 
+Jani Kajala, 
+Jason Stewart, 
+Jeff Garland,
+Jens Maurer,
+Jesse Jones,
+Jim Hyslop,
+Joel de Guzman,
+Joel Young,
+John Levon, 
+John Maddock,
+John Williston,
+Jonathan Caves,
+Jonathan Biggar,
+Jurko,
+Justus Schwartz,
+Keith Burton, 
+Ken Hagen,
+Kostya Altukhov, 
+Mark Rodgers,
+Martin Schuerch, 
+Matt Austern,
+Matthias Troyer, 
+Mattias Flodin, 
+Michiel Salters,
+Mickael Pointier,
+Misha Bergal,
+Neal Becker,
+Noel Yap,
+Parksie,
+Patrick Hartling, Pavel Vozenilek,
+Pete Becker, 
+Peter Dimov,
+Rainer Deyke,
+Rene Rivera,
+Rob Lievaart,
+Rob Stewart,
+Ron Garcia,
+Ross Smith,
+Sashan,
+Steve Robbins, 
+Thomas Witt, 
+Tom Harris, 
+Toon Knapen,
+Victor Wagner,
+Vincent Finn,
+Vladimir Prus, and
+Yitzhak Sapir
+ 
+<p>A lengthy discussion on the C++ committee's library reflector illuminated the &quot;illusion 
+of portability&quot; problem, particularly in postings by PJ Plauger and Pete Becker.</p>
+
+<p>Walter Landry provided much help illuminating symbolic link use cases for 
+version 1.31.0.&nbsp;</p>
+
+<hr>
+<p>Revised
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->31 May, 2010<!--webbot bot="Timestamp" endspan i-checksum="13955" --></p>
+
+<p>&copy; Copyright Beman Dawes, 2002-2005</p>
+<p> Use, modification, and distribution are subject to the Boost Software 
+License, Version 1.0. See <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a></p>
+
+</body>
+
+</html>

v3/libs/filesystem/doc/minimal.css

@@ -0,0 +1,29 @@
+/*
+
+  © Copyright Beman Dawes, 2007
+
+  Distributed under the Boost Software License, Version 1.0.
+  See www.boost.org/LICENSE_1_0.txt
+  
+*/
+
+/*******************************************************************************
+      Body
+*******************************************************************************/
+
+body    { font-family: sans-serif; margin: 1em; }
+
+/*******************************************************************************
+      Table
+*******************************************************************************/
+
+table   { margin: 0.5em; }
+
+/*******************************************************************************
+      Font sizes
+*******************************************************************************/
+
+p, td, li, blockquote { font-size: 10pt; }
+pre     { font-size: 9pt; }
+
+/*** end ***/

v3/libs/filesystem/doc/path_table.cpp

@@ -0,0 +1,260 @@
+//  Generate an HTML table showing path decomposition  ---------------------------------//
+
+//  Copyright Beman Dawes 2005.
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/filesystem for documentation.
+
+//  For purposes of generating the table, support both POSIX and Windows paths
+
+#include "boost/filesystem.hpp"
+#include <iostream>
+#include <fstream>
+
+using boost::filesystem::path;
+using std::string;
+using std::cout;
+
+namespace
+{
+  std::ifstream infile;
+  std::ofstream posix_outfile;
+  std::ifstream posix_infile;
+  std::ofstream outfile;
+
+  bool posix;
+
+  const string empty_string;
+
+  struct column_base
+  {
+    virtual string heading() const = 0;
+    virtual string cell_value( const path & p ) const = 0;
+  };
+
+  struct c0 : public column_base
+  {
+    string heading() const { return string("<code>string()</code>"); }
+    string cell_value( const path & p ) const { return p.string(); }
+  } o0;
+
+    struct c1 : public column_base
+  {
+    string heading() const { return string("<code>generic_<br>string()</code>"); }
+    string cell_value( const path & p ) const { return p.generic_string(); }
+  } o1;
+
+  struct c2 : public column_base
+  {
+    string heading() const { return string("Iteration<br>over<br>Elements"); }
+    string cell_value( const path & p ) const
+    {
+      string s;
+      for( path::iterator i(p.begin()); i != p.end(); ++i )
+      {
+        if ( i != p.begin() ) s += ',';
+        s += (*i).string();
+      }
+      return s;
+    }
+  } o2;
+
+  struct c3 : public column_base
+  {
+    string heading() const { return string("<code>root_<br>path()</code>"); }
+    string cell_value( const path & p ) const { return p.root_path().string(); }
+  } o3;
+
+  struct c4 : public column_base
+  {
+    string heading() const { return string("<code>root_<br>name()</code>"); }
+    string cell_value( const path & p ) const { return p.root_name().string(); }
+  } o4;
+
+  struct c5 : public column_base
+  {
+    string heading() const { return string("<code>root_<br>directory()</code>"); }
+    string cell_value( const path & p ) const { return p.root_directory().string(); }
+  } o5;
+
+  struct c6 : public column_base
+  {
+    string heading() const { return string("<code>relative_<br>path()</code>"); }
+    string cell_value( const path & p ) const { return p.relative_path().string(); }
+  } o6;
+
+  struct c7 : public column_base
+  {
+    string heading() const { return string("<code>parent_<br>path()</code>"); }
+    string cell_value( const path & p ) const { return p.parent_path().string(); }
+  } o7;
+
+  struct c8 : public column_base
+  {
+    string heading() const { return string("<code>filename()</code>"); }
+    string cell_value( const path & p ) const { return p.filename().string(); }
+  } o8;
+
+  const column_base * column[] = { &o2, &o0, &o1, &o3, &o4, &o5, &o6, &o7, &o8 };
+
+  //  do_cell  ---------------------------------------------------------------//
+
+  void do_cell( const string & test_case, int i )
+  {
+    string temp = column[i]->cell_value(path(test_case));
+    string value;
+    outfile << "<td>";
+    if (temp.empty())
+      value = "<font size=\"-1\"><i>empty</i></font>";
+    else
+     value = string("<code>") + temp + "</code>";
+
+    if (posix)
+      posix_outfile << value << '\n';
+    else
+    {
+      std::getline(posix_infile, temp);
+      if (value != temp) // POSIX and Windows differ
+      {
+        value.insert(0, "<br>");
+        value.insert(0, temp);
+        value.insert(0, "<span style=\"background-color: #CCFFCC\">");
+        value += "</span>";
+      }
+      outfile << value;
+    }
+    outfile << "</td>\n";
+  }
+
+//  do_row  ------------------------------------------------------------------//
+
+  void do_row( const string & test_case )
+  {
+    outfile << "<tr>\n";
+
+    if (test_case.empty())
+      outfile << "<td><font size=\"-1\"><i>empty</i></font></td>\n";
+    else
+      outfile << "<td><code>" << test_case << "</code></td>\n";
+    
+    for ( int i = 0; i < sizeof(column)/sizeof(column_base&); ++i )
+    {
+      do_cell( test_case, i );
+    }
+
+    outfile << "</tr>\n";
+  }
+
+//  do_table  ----------------------------------------------------------------//
+
+  void do_table()
+  {
+    outfile <<
+      "<h1>Path Decomposition Table</h1>\n"
+      "<p>Shaded entries indicate cases where <i>POSIX</i> and <i>Windows</i>\n"
+      "implementations yield different results. The top value is the\n"
+      "<i>POSIX</i> result and the bottom value is the <i>Windows</i> result.\n" 
+      "<table border=\"1\" cellspacing=\"0\" cellpadding=\"5\">\n"
+      "<p>\n"
+      ;
+
+    // generate the column headings
+
+    outfile << "<tr><td><b>Constructor<br>argument</b></td>\n";
+
+    for ( int i = 0; i < sizeof(column)/sizeof(column_base&); ++i )
+    {
+      outfile << "<td><b>" << column[i]->heading() << "</b></td>\n";
+    }
+
+    outfile << "</tr>\n";
+
+    // generate a row for each input line
+
+    string test_case;
+    while ( std::getline( infile, test_case ) )
+    {
+      if (!test_case.empty() && *--test_case.end() == '\r')
+        test_case.erase(test_case.size()-1);
+      if (test_case.empty() || test_case[0] != '#')
+        do_row( test_case );
+    }
+
+    outfile << "</table>\n";
+  }
+
+} // unnamed namespace
+
+//  main  ------------------------------------------------------------------------------//
+
+#define BOOST_NO_CPP_MAIN_SUCCESS_MESSAGE
+#include <boost/test/included/prg_exec_monitor.hpp>
+
+int cpp_main( int argc, char * argv[] ) // note name!
+{
+  if ( argc != 5 )
+  {
+    std::cerr <<
+      "Usage: path_table \"POSIX\"|\"Windows\" input-file posix-file output-file\n"
+      "Run on POSIX first, then on Windows\n"
+      "  \"POSIX\" causes POSIX results to be save in posix-file;\n"
+      "  \"Windows\" causes POSIX results read from posix-file\n"
+      "  input-file contains the paths to appear in the table.\n"
+      "  posix-file will be used for POSIX results\n"
+      "  output-file will contain the generated HTML.\n"
+      ;
+    return 1;
+  }
+
+  infile.open( argv[2] );
+  if ( !infile )
+  {
+    std::cerr << "Could not open input file: " << argv[2] << std::endl;
+    return 1;
+  }
+
+  if (string(argv[1]) == "POSIX")
+  {
+    posix = true;
+    posix_outfile.open( argv[3] );
+    if ( !posix_outfile )
+    {
+      std::cerr << "Could not open POSIX output file: " << argv[3] << std::endl;
+      return 1;
+    }
+  }
+  else
+  {
+    posix = false;
+    posix_infile.open( argv[3] );
+    if ( !posix_infile )
+    {
+      std::cerr << "Could not open POSIX input file: " << argv[3] << std::endl;
+      return 1;
+    }
+  }
+
+  outfile.open( argv[4] );
+  if ( !outfile )
+  {
+    std::cerr << "Could not open output file: " << argv[2] << std::endl;
+    return 1;
+  }
+
+  outfile << "<html>\n"
+          "<head>\n"
+          "<title>Path Decomposition Table</title>\n"
+          "</head>\n"
+          "<body bgcolor=\"#ffffff\" text=\"#000000\">\n"
+          ;
+
+  do_table();
+
+  outfile << "</body>\n"
+          "</html>\n"
+          ;
+
+  return 0;
+}

v3/libs/filesystem/doc/path_table.txt

@@ -0,0 +1,50 @@
+# Paths for the reference.html Path Decomposition Table
+#
+# This is the input file for path_table, which generates the actual html
+#
+# Copyright Beman Dawes 2010
+#
+# Distributed under the Boost Software License, Version 1.0.
+# See www.boost.org/LICENSE_1_0.txt
+#
+# Note that an empty line is treated as input rather than as a comment
+
+.
+..
+foo
+/
+/foo
+foo/
+/foo/
+foo/bar
+/foo/bar
+//net
+//net/foo
+///foo///
+///foo///bar
+/.
+./
+/..
+../
+foo/.
+foo/..
+foo/./
+foo/./bar
+foo/..
+foo/../
+foo/../bar
+c:
+c:/
+c:foo
+c:/foo
+c:foo/
+c:/foo/
+c:/foo/bar
+prn:
+c:\
+c:foo
+c:\foo
+c:foo\
+c:\foo\
+c:\foo/
+c:/foo\bar

v3/libs/filesystem/doc/portability_guide.htm

@@ -0,0 +1,241 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Language" content="en-us">
+<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<title>Portability Guide</title>
+<link rel="stylesheet" type="text/css" href="minimal.css">
+</head>
+
+<body bgcolor="#FFFFFF">
+
+<h1>
+<img border="0" src="../../../boost.png" align="center" width="300" height="86">Path 
+Name Portability 
+Guide</h1>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="100%">
+  <tr>
+    <td><a href="../../../index.htm">Boost Home</a> &nbsp;&nbsp;
+    <a href="index.htm">Library Home</a> &nbsp;&nbsp;
+    <a href="reference.html">Reference</a> &nbsp;&nbsp;
+    <a href="tutorial.html">Tutorial</a> &nbsp;&nbsp;
+    <a href="faq.htm">FAQ</a> &nbsp;&nbsp;
+    <a href="portability_guide.htm">Portability</a> &nbsp;&nbsp;
+    <a href="v3.html">V3 Intro</a> &nbsp;&nbsp;
+    <a href="v3_design.html">V3 Design</a> &nbsp;&nbsp;
+    <a href="deprecated.html">Deprecated</a> &nbsp;&nbsp;
+    </td>
+  </tr>
+</table>
+
+<p>
+<a href="#Introduction">Introduction</a><br>
+<a href="#name_check­_functions">name_check functions</a><br>
+<a href="#recommendations">File and directory name recommendations</a></p>
+<h2><a name="Introduction">Introduction</a></h2>
+<p>Like any other C++ program which performs I/O operations, there is no 
+guarantee that a program using Boost.Filesystem will be portable between 
+operating systems. Critical aspects of I/O such as how the operating system 
+interprets paths are unspecified by the C and C++ Standards.</p>
+<p>It is not possible to know  if a file or directory name will be 
+valid (and thus portable) for an unknown operating system. There is always the possibility that an operating system could use 
+names which are unusual (numbers less than 4096, for example) or very 
+limited in size (maximum of six character names, for example). In other words, 
+portability is never absolute; it is always relative to specific operating 
+systems or 
+file systems.</p>
+<p>It is possible, however, to know in advance if a directory or file name is likely to be valid for a particular 
+operating system.&nbsp;It is also possible to construct names which are 
+likely to be portable to a large number of modern and legacy operating systems.</p>
+
+<p>Almost all modern operating systems support multiple file systems. At the 
+minimum, they support a native file system plus a CD-ROM file system (Generally 
+ISO-9669, often with Juliet extensions).</p>
+
+<p>Each file system 
+may have its own naming rules. For example, modern versions of Windows support NTFS, FAT, FAT32, and ISO-9660 file systems, among others, and the naming rules 
+for those file systems differ. Each file system may also have 
+differing rules for overall path validity, such as a maximum length or number of 
+sub-directories. Some legacy systems have different rules for directory names 
+versus regular file names.</p>
+
+<p>As a result, Boost.Filesystem's <i>name_check</i> functions 
+cannot guarantee directory and file name portability. Rather, they are intended to 
+give the programmer a &quot;fighting chance&quot; to achieve portability by early 
+detection of common naming problems.</p>
+
+<h2><a name="name_check­_functions">name_check functions</a></h2>
+
+<p>A <i>name_check</i> function 
+returns true if its argument is valid as a directory and regular file name for a 
+particular operating or file system. A number of these functions are provided.</p>
+
+<p>The <a href="#portable_name">portable_name</a> function is of particular 
+interest because it has been carefully designed to provide wide 
+portability yet not overly restrict expressiveness.</p>
+
+<table border="1" cellpadding="5" cellspacing="0">
+  <tr>
+    <td align="center" colspan="2"><b>Library Supplied name_check Functions</b></td>
+  </tr>
+  <tr>
+    <td align="center"><b>Function</b></td>
+    <td align="center"><b>Description</b></td>
+  </tr>
+  <tr>
+    <td align="left" valign="top"><code><a name="portable_posix_name">portable_posix_name</a>(const 
+    std::string&amp;<i> name</i>)</code></td>
+    <td><b>Returns:</b> <i>true</i> if <code>!name.empty() &amp;&amp; name</code> contains only the characters 
+    specified in<i> Portable Filename Character Set</i> rules as defined in by 
+    POSIX (<a href="http://www.opengroup.org/onlinepubs/007904975/basedefs/xbd_chap03.html">www.opengroup.org/onlinepubs/007904975/basedefs/xbd_chap03.html</a>).<br>
+    The allowed characters are <code>0-9</code>, <code>a-z</code>, <code>A-Z</code>, 
+    <code>'.'</code>, <code>'_'</code>, and <code>'-'</code>.<p><b>Use:</b> 
+    applications which must be portable to any POSIX system.</td>
+  </tr>
+  <tr>
+    <td align="left" valign="top"><code><a name="windows_name">windows_name</a>(const 
+    std::string&amp;<i> name</i>)</code></td>
+    <td><b>Returns:</b>&nbsp; <i>true</i> if <code>!name.empty() &amp;&amp; name</code> contains 
+    only the characters specified by the Windows platform SDK as valid 
+    regardless of the file system <code>&amp;&amp; (name</code> is <code>&quot;.&quot;</code> or
+    <code>&quot;..&quot;</code>&nbsp; or does not end with a trailing space or period<code>)</code>.&nbsp; 
+    The allowed characters are anything except <code>0x0-0x1F</code>, <code>'&lt;'</code>,
+    <code>'&gt;'</code>, <code>':'</code>, <code>'&quot;'</code>, <code>'/'</code>,
+    <code>'\'</code>, and <code>'|'</code>.<p>
+    <b>Use:</b> applications which must be portable to Windows.</p>
+    <p><b>Note:</b> Reserved device names are not valid as file names, but are 
+    not being detected because they are still valid as a path. Specifically, 
+    CON, PRN, AUX, CLOCK$, NUL, COM[1-9], LPT[1-9], and these names followed by 
+    an extension (for example, NUL.tx7).</td>
+  </tr>
+  <tr>
+    <td align="left" valign="top"><code><a name="portable_name">portable_name</a>(const 
+    std::string&amp;<i> name</i>)</code></td>
+    <td><b>Returns:</b> <code>&nbsp;windows_name(name) &amp;&amp; portable_posix_name(name) 
+    &amp;&amp; (name</code> is <code>&quot;.&quot;</code> or <code>&quot;..&quot;</code>, and the first character not a period or hyphen<code>)</code>.<p><b>Use:</b> applications which must be portable to a wide variety of 
+    modern operating systems, large and small, and to some legacy O/S's. The 
+    first character not a period or hyphen restriction is a requirement of 
+    several older operating systems.</td>
+  </tr>
+  <tr>
+    <td align="left" valign="top"><code><a name="portable_directory_name">
+    portable_directory_name</a>(const std::string&amp;<i> name</i>)</code></td>
+    <td><b>Returns:</b> <code>portable_name(name) &amp;&amp; (name</code> is <code>&quot;.&quot;</code> 
+    or <code>&quot;..&quot;</code>&nbsp; or contains no periods<code>)</code>.<p><b>Use:</b> applications 
+    which must be portable to a wide variety of platforms, including OpenVMS.</td>
+  </tr>
+  <tr>
+    <td align="left" valign="top"><code><a name="portable_file_name">
+    portable_file_name</a>(const std::string&amp;<i> name</i>)</code></td>
+    <td><b>Returns:</b> <code>portable_name(name) &amp;&amp; </code>any period is followed by one to three additional 
+    non-period characters.<p><b>Use:</b> 
+    applications which must be portable to a wide variety of platforms, 
+    including OpenVMS and other systems which have a concept of &quot;file extension&quot; 
+    but limit its length.</td>
+  </tr>
+  <tr>
+    <td align="left" valign="top"><code><a name="native">native</a>(const 
+    std::string&amp;<i> name</i>)</code></td>
+    <td><b>Returns:</b> Implementation defined. Returns <i>
+    true</i> for names considered valid by the operating system's native file 
+    systems.<p><b>Note:</b> May return <i>true</i> for some names not considered valid 
+    by the operating system under all conditions (particularly on operating systems which support 
+    multiple file systems.)</td>
+  </tr>
+</table>
+
+<h2>File and directory name <a name="recommendations">recommendations</a></h2>
+
+<table border="1" cellpadding="5" cellspacing="0">
+
+  <tr>
+    <td align="center" valign="top"><strong>Recommendation</strong></td>
+    <td align="center" valign="top"><strong>Rationale</strong></td>
+  </tr>
+  <tr>
+    <td valign="top">Limit file and directory names to the characters A-Z, a-z, 0-9, period, hyphen, and
+    underscore.<p>Use any of the &quot;portable_&quot; <a href="#name_check­_functions">
+    name check functions</a> to enforce this recommendation.</td>
+    <td valign="top">These are the characters specified by the POSIX standard for portable directory and
+    file names, and are also valid for Windows, Mac, and many other modern file systems.</td>
+  </tr>
+  <tr>
+    <td valign="top">Do not use a period or hyphen as the first 
+    character of a name. Do not use period as the last character of a name.<p>
+    Use <a href="#portable_name">portable_name</a>,
+    <a href="#portable_directory_name">portable_directory_name</a>, or
+    <a href="#portable_file_name">portable_file_name</a> to enforce this 
+    recommendation.</td>
+    <td valign="top">Some operating systems treat have special rules for the 
+    first character of names. POSIX, for example. Windows does not permit period 
+    as the last character.</td>
+  </tr>
+  <tr>
+    <td valign="top">Do not use periods in directory names.<p>Use
+    <a href="#portable_directory_name">portable_directory_name</a> to enforce 
+    this recommendation.</td>
+    <td valign="top">Requirement for ISO-9660 without Juliet extensions, OpenVMS filesystem, and other legacy systems.</td>
+  </tr>
+  <tr>
+    <td valign="top">Do not use more that one period in a file name, and limit 
+    the portion after the period to three characters.<p>Use
+    <a href="#portable_file_name">portable_file_name</a> to enforce this 
+    recommendation.</td>
+    <td valign="top">Requirement for ISO-9660 level 1, OpenVMS filesystem, and 
+    other legacy systems. </td>
+  </tr>
+  <tr>
+    <td valign="top">Do not assume names are case sensitive. For example, do not expected a directory to be
+    able to hold separate elements named &quot;Foo&quot; and &quot;foo&quot;. </td>
+    <td valign="top">Some file systems are case insensitive.&nbsp; For example, Windows 
+    NTFS is case preserving in the way it stores names, but case insensitive in 
+    searching for names (unless running under the POSIX sub-system, it which 
+    case it does case sensitive searches). </td>
+  </tr>
+  <tr>
+    <td valign="top">Do not assume names are case insensitive.&nbsp; For example, do not expect a file
+    created with the name of &quot;Foo&quot; to be opened successfully with the name of &quot;foo&quot;.</td>
+    <td valign="top">Some file systems are case sensitive.&nbsp; For example, POSIX.</td>
+  </tr>
+  <tr>
+    <td valign="top">Don't use hyphens in names.</td>
+    <td valign="top">ISO-9660 level 1, and possibly some legacy systems, do not permit 
+    hyphens.</td>
+  </tr>
+  <tr>
+    <td valign="top">Limit the length of the string returned by path::string() to 
+    255 characters.&nbsp; 
+    Note that ISO 9660 has an explicit directory tree depth limit of 8, although 
+    this depth limit is removed by the Juliet extensions.</td>
+    <td valign="top">Some operating systems place limits on the total path length.&nbsp; For example,
+    Windows 2000 limits paths to 260 characters total length.</td>
+  </tr>
+  <tr>
+    <td valign="top">Limit the length of any one name in a path.&nbsp; Pick the specific limit according to
+    the operating systems and or file systems you wish portability to:<br>
+    &nbsp;&nbsp; Not a concern::&nbsp; POSIX, Windows, MAC OS X.<br>
+    &nbsp;&nbsp; 31 characters: Classic Mac OS<br>
+&nbsp;&nbsp; 8 characters + period + 3 characters: ISO 9660 level 1<br>
+&nbsp;&nbsp; 32 characters: ISO 9660 level 2 and 3<br>
+&nbsp;&nbsp; 128 characters (64 if Unicode): ISO 9660 with Juliet extensions</td>
+    <td valign="top">Limiting name length can markedly reduce the expressiveness of file names, yet placing
+    only very high limits on lengths inhibits widest portability.</td>
+  </tr>
+</table>
+
+<hr>
+<p>Revised
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->17 February, 2010<!--webbot bot="Timestamp" endspan i-checksum="40536" --></p>
+
+<p>© Copyright Beman Dawes, 2002, 2003</p>
+<p> Use, modification, and distribution are subject to the Boost Software 
+License, Version 1.0. (See accompanying file <a href="../../../LICENSE_1_0.txt">
+LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a>)</p>
+
+</body>
+
+</html>

v3/libs/filesystem/doc/v3.html

@@ -0,0 +1,129 @@
+<html>
+
+<head>
+<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<title>Filesystem V3 Intro</title>
+<link rel="stylesheet" type="text/css" href="minimal.css">
+
+<body>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
+  <tr>
+    <td width="277">
+<a href="../../../index.htm">
+<img src="../../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="300" height="86" border="0"></a></td>
+    <td align="middle">
+    <font size="7">Filesystem
+    Version 3<br>
+    Introduction</font></td>
+  </tr>
+</table>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="100%">
+  <tr>
+    <td><a href="../../../index.htm">Boost Home</a> &nbsp;&nbsp;
+    <a href="index.htm">Library Home</a> &nbsp;&nbsp;
+    <a href="reference.html">Reference</a> &nbsp;&nbsp;
+    <a href="tutorial.html">Tutorial</a> &nbsp;&nbsp;
+    <a href="faq.htm">FAQ</a> &nbsp;&nbsp;
+    <a href="portability_guide.htm">Portability</a> &nbsp;&nbsp;
+    <a href="v3.html">V3 Intro</a> &nbsp;&nbsp;
+    <a href="v3_design.html">V3 Design</a> &nbsp;&nbsp;
+    <a href="deprecated.html">Deprecated</a> &nbsp;&nbsp;
+    </td>
+  </tr>
+</table>
+
+<h1>Boost Filesystem Version 3</h1>
+
+<p>Version 3 is a major revision of the Boost Filesystem library. Important 
+changes include:</p>
+
+<ul>
+  <li>A single class <code>path</code> handles all aspects of 
+  internationalization, replacing the previous template and its <code>path</code> 
+  and <code>wpath</code> instantiations. Character types <code>char</code>,
+  <code>wchar_t</code>, <code>char16_t</code>, and <code>char32_t</code> are 
+  supported. This is a major simplification of the path abstraction, 
+  particularly for functions that take path arguments.<br>
+&nbsp;</li>
+  <li>New <code>class path</code> members include:<br>
+&nbsp;<ul>
+  <li><code><a href="reference.html#path-has_stem">has_stem</a>()</code></li>
+  <li><code><a href="reference.html#path-has_extension">has_extension</a>()</code></li>
+  <li><code><a href="reference.html#path-is_absolute">is_absolute</a>()</code>. This renames <code>is_complete()</code>, which 
+  is now deprecated.</li>
+  <li><code><a href="reference.html#path-is_relative">is_relative</a>()</code></li>
+  <li><code><a href="reference.html#path-make_absolute">make_absolute</a>()</code>. This replaces the operations function <code>
+  complete()</code>, which is now deprecated.</li>
+  <li><code><a href="reference.html#path-make_preferred">make_preferred</a>()<br>
+&nbsp;</code></li>
+</ul>
+
+  </li>
+  <li>New or improved operations functions include:<br>
+&nbsp;<ul>
+    <li><code><a href="reference.html#create_symlink">create_symlink</a>()</code> now supported on both POSIX and Windows.</li>
+    <li><code><a href="reference.html#read_symlink">read_symlink</a>()</code> function added. Supported on both POSIX and 
+    Windows. Used to read the contents of a symlink itself.</li>
+    <li><code><a href="reference.html#resize_file">resize_file</a>()</code> function added. Supported on both POSIX and 
+    Windows. Used to shrink or grow a regular file.</li>
+    <li><code><a href="reference.html#unique_path">unique_path</a>()</code> function added. Supported on both POSIX and 
+    Windows. Used to generate a secure temporary pathname.<br>
+&nbsp;</li>
+  </ul>
+  </li>
+  <li>Support for error reporting via <code>error_code</code> is now uniform 
+  throughout the operations functions.<br>
+&nbsp;</li>
+  <li>Documentation has been reworked, including re-writes of major portions.<br>
+&nbsp;</li>
+  <li>A new <a href="tutorial.html">Tutorial</a> provides a hopefully much 
+  gentler and more complete introduction for new users. Current users might want 
+  to review the <a href="tutorial.html">three sections related to class path</a>.<br>
+&nbsp;</li>
+</ul>
+
+<h2>Breaking changes</h2>
+
+<p>To ease the transition, Versions 2 and 3 will both be included in the next 
+several Boost releases. Version 2 will be the default version for one release 
+cycle, and then Version 3 will become the default version.</p>
+<h3>Class <code>path</code></h3>
+<ul>
+  <li>Class template <code>basic_path</code> and its specializations are gone.</li>
+  <li>Certain functions now return <code>path</code> objects rather than <code>
+  basic_string</code> objects:<ul>
+    <li><code>root_name()</code></li>
+    <li><code>root_directory()</code></li>
+    <li><code>filename()</code></li>
+    <li><code>stem()</code></li>
+    <li><code>extension()</code></li>
+  </ul>
+  </li>
+  <li>&nbsp;<code>path::iterator::value_type</code> and&nbsp; <code>
+  path::const_iterator::value_type</code> is <code>path</code> rather than <code>
+  basic_string</code>.</li>
+</ul>
+<h3>Compiler support</h3>
+<ul>
+  <li>Compilers and standard libraries that do not fully support wide characters 
+  and wide character strings (<code>wstring</code>) are no longer supported. 
+  This impacts primarily Cygwin users; versions prior to 1.7 are no longer 
+  supported.<br>
+&nbsp;</li>
+  <li>Microsoft VC++ 7.1 and earlier are no longer supported.</li>
+</ul>
+
+<hr>
+<p>© Copyright Beman Dawes, 2009</p>
+<p>Distributed under the Boost Software License, Version 1.0. See
+<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
+<p>Revised
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->22 February 2010<!--webbot bot="Timestamp" endspan i-checksum="40543" --></p>
+
+</body>
+
+</html>

v3/libs/filesystem/doc/v3_design.html

@@ -0,0 +1,192 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Language" content="en-us">
+<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<title>Filesystem V3 Design</title>
+<link rel="stylesheet" type="text/css" href="minimal.css">
+</head>
+
+<body>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
+  <tr>
+    <td>
+<a href="../../../index.htm">
+<img src="boost.png" alt="boost.png (6897 bytes)" align="middle" border="0" width="300" height="86"></a></td>
+    <td align="middle">
+    <font size="7">Filesystem Version 3<br>
+    Design</font></td>
+  </tr>
+</table>
+
+<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="100%">
+  <tr>
+    <td><a href="../../../index.htm">Boost Home</a> &nbsp;&nbsp;
+    <a href="index.htm">Library Home</a> &nbsp;&nbsp;
+    <a href="reference.html">Reference</a> &nbsp;&nbsp;
+    <a href="tutorial.html">Tutorial</a> &nbsp;&nbsp;
+    <a href="faq.htm">FAQ</a> &nbsp;&nbsp;
+    <a href="portability_guide.htm">Portability</a> &nbsp;&nbsp;
+    <a href="v3.html">V3 Intro</a> &nbsp;&nbsp;
+    <a href="v3_design.html">V3 Design</a> &nbsp;&nbsp;
+    <a href="deprecated.html">Deprecated</a> &nbsp;&nbsp;
+    </td>
+  </tr>
+</table>
+
+<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" align="right">
+  <tr>
+    <td width="100%" bgcolor="#D7EEFF" align="center">
+      <i><b>Contents</b></i></td>
+  </tr>
+  <tr>
+    <td width="100%" bgcolor="#E8F5FF">
+    <a href="#Introduction">Introduction</a><br>
+    <a href="#Problem">Problem</a><br>
+    <a href="#Solution">Solution</a><br>
+    <a href="#Details">Details</a><br>
+    <a href="#Other-changes">Other changes</a><br>
+    <a href="#Acknowledgements">Acknowledgements</a></td>
+  </tr>
+  </table>
+
+<p><b>Caution:</b> This page documents thinking early in the V3 development 
+process, and is intended to serve historical purposes. It is not updated to 
+reflect the current state of the library.</p>
+
+<h2><a name="Introduction">Introduction</a></h2>
+
+<p>During the review of Boost.Filesystem.V2 (Internationalization), Peter Dimov 
+suggested that the<code> basic_path</code> class template was unwieldy, and that a single 
+path type that accommodated multiple character types and encodings would be more 
+flexible. Although I wasn't willing to stop development at that time to 
+explore how this idea might be implemented, or to break from the pattern for 
+Internationalization used the C++ standard library, I've often thought about 
+Peter's suggestion. With the advent of C++0x <code>char16_t</code> and <code>char32_t</code> character 
+types, the <code>basic_path</code> class template approach becomes even more unwieldy, so it 
+is time to revisit the problem in light of Peter's suggestion.</p>
+
+<h2><b><a name="Problem">Problem</a></b></h2>
+
+<p>With Filesystem.V2, a path argument to a user defined function that is to 
+accommodate multiple character types and encodings must be written as a 
+template. Do-the-right-thing overloads or template metaprogramming must be 
+employed to allow arguments to be written as string literals. Here's what it 
+looks like:</p>
+
+<blockquote>
+  <pre>template&lt;class Path&gt;
+void foo( const Path &amp; p );</pre>
+  <pre>inline void foo( const path &amp; p )
+{
+  return foo&lt;path&gt;( p );
+}
+inline void foo( const wpath &amp; p )
+{
+  return foo&lt;wpath&gt;( p );
+}</pre>
+</blockquote>
+<p>That's really ugly for such a simple need, and there would be a combinatorial 
+explosion if the function took multiple Path arguments and each could be either 
+narrow or wide. It gets even worse if the C++0x <code>char16_t</code> and <code>
+char32_t</code> types are to be supported.</p>
+
+<h2><a name="Solution">Solution</a></h2>
+
+<p>Overview:</p>
+
+<ul>
+  <li>A single, non-template, <code>class path</code>.</li>
+  <li>Each member function is a template accommodating the various 
+  applicable character types, including user-defined character types.</li>
+  <li>Hold the path internally in a string of the type used by the operating 
+  system API; <code>std::string</code> for POSIX, <code>std::wstring</code> for Windows.</li>
+</ul>
+
+<p>The signatures presented in <a href="#Problem">Problem</a> collapse to 
+simply:</p>
+<blockquote>
+  <pre>void foo( const path &amp; p );</pre>
+</blockquote>
+
+<p>That's a signification reduction in code complexity. Specification becomes 
+simpler, too. I believe it will be far easier to teach, and result in much more 
+flexible user code.</p>
+
+<p>Other benefits:</p>
+<ul>
+  <li>All the polymorphism still occurs at compile time.</li>
+  <li>Efficiency is increased, in that conversions of the encoding, if required, 
+  only occur once at the time of creation, not each time the path is used.</li>
+  <li>The size of the implementation code drops approximately in half and 
+  becomes much more readable.</li>
+</ul>
+  <p>Possible problems:</p>
+<ul>
+  <li>The combination of member function templates and implicit constructors can 
+  result in unclear error messages when the user makes simple commonplace coding 
+  errors. This should be much less of a problem with C++ concepts, but in the 
+  meantime work continues to restrict over aggressive templates via enable_if/disable_if.</li>
+</ul>
+  <h2><a name="Details">Details</a></h2>
+
+<table border="1" cellpadding="4" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="100%">
+  <tr>
+    <td width="33%" colspan="3">
+    <p align="center"><b><i>Encoding </i></b><i><b>Conversions</b></i></td>
+  </tr>
+  <tr>
+    <td width="33%">
+    <p align="center"><i><b>Host system</b></i></td>
+    <td width="33%">
+    <p align="center"><i><b>char string path arguments</b></i></td>
+    <td width="34%">
+    <p align="center"><i><b>wide string path arguments</b></i></td>
+  </tr>
+  <tr>
+    <td width="33%">Systems with <code>char</code> as the native API path character type (i.e. 
+    POSIX-like systems)</td>
+    <td width="33%">No conversion.</td>
+    <td width="34%">Conversion occurs, performed by the current path locale's 
+    <code>codecvt</code> facet.</td>
+  </tr>
+  <tr>
+    <td width="33%">Systems with <code>wchar_t</code> as the native API path character type 
+    (i.e. Windows-like systems).</td>
+    <td width="33%">Conversion occurs, performed by the current path locale's 
+    <code>codecvt</code> facet.</td>
+    <td width="34%">No conversion.</td>
+  </tr>
+</table>
+
+<p>When a class path function argument type matches the the operating system's 
+API argument type for paths, no conversion is performed rather than conversion 
+to a specified encoding such as one of the Unicode encodings. This avoids 
+unintended consequences, etc.</p>
+
+<h2><a name="Other-changes">Other changes</a></h2>
+
+<p><b>Uniform hybrid error handling: </b>The hybrid error handling idiom has 
+been consistently applied to all applicable functions.</p>
+
+<h2><a name="Acknowledgements">Acknowledgements</a></h2>
+
+<p>Peter Dimov suggested the idea of a single path class that could cope with 
+multiple character types and encodings. Walter Landry contributed both the design and implementation of the copy_any, 
+copy_directory, copy_symlink, and read_symlink functions.</p>
+
+<hr>
+<p>Revised
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->18 February, 2010<!--webbot bot="Timestamp" endspan i-checksum="40538" --></p>
+
+<p>© Copyright Beman Dawes, 2008</p>
+<p> Use, modification, and distribution are subject to the Boost Software 
+License, Version 1.0. See <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a></p>
+
+</body>
+
+</html>

v3/libs/filesystem/example/Jamfile.v2

@@ -0,0 +1,24 @@
+# Boost Filesystem Library Example Jamfile
+ 
+# (C) Copyright Vladimir Prus 2003
+
+# Distributed under the Boost Software License, Version 1.0.
+# See www.boost.org/LICENSE_1_0.txt
+
+# Library home page: http://www.boost.org/libs/filesystem
+
+project
+    : requirements
+      <library>/boost/filesystem//boost_filesystem
+      <library>/boost/system//boost_system
+      <toolset>msvc:<asynch-exceptions>on
+      <link>static
+    ;
+    
+exe tut0 : tut0.cpp ;
+exe tut1 : tut1.cpp ;
+exe tut2 : tut2.cpp ;
+exe tut3 : tut3.cpp ;
+exe tut4 : tut4.cpp ;
+exe tut5 : tut5.cpp ;
+exe path_info : path_info.cpp ;    

v3/libs/filesystem/example/error_demo.cpp

@@ -0,0 +1,185 @@
+//  error_demo.cpp  --------------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//  The purpose of this program is to demonstrate how error reporting works.            //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+#include <boost/filesystem.hpp>
+#include <boost/system/system_error.hpp>
+#include <iostream>
+
+using std::cout;
+using boost::filesystem::path;
+using boost::filesystem::filesystem_error;
+using boost::system::error_code;
+using boost::system::system_error;
+namespace fs = boost::filesystem;
+
+namespace
+{
+  void report_system_error(const system_error& ex)
+  {
+    cout << " threw system_error:\n"
+         << "    ex.code().value() is " << ex.code().value() << '\n'
+         << "    ex.code().category().name() is " << ex.code().category().name() << '\n'
+         << "    ex.what() is " << ex.what() << '\n'
+         ;
+  }
+
+  void report_filesystem_error(const system_error& ex)
+  {
+    cout << "  threw filesystem_error exception:\n"
+         << "    ex.code().value() is " << ex.code().value() << '\n'
+         << "    ex.code().category().name() is " << ex.code().category().name() << '\n'
+         << "    ex.what() is " << ex.what() << '\n'
+         ;
+  }
+
+  void report_status(fs::file_status s)
+  {
+    cout << "  file_status::type() is ";
+    switch (s.type())
+    {
+    case fs::status_error:
+      cout << "status_error\n"; break;
+    case fs::file_not_found:
+      cout << "file_not_found\n"; break;
+    case fs::regular_file:
+      cout << "regular_file\n"; break;
+    case fs::directory_file:
+      cout << "directory_file\n"; break;
+    case fs::symlink_file:
+      cout << "symlink_file\n"; break;
+    case fs::block_file:
+      cout << "block_file\n"; break;
+    case fs::character_file:
+      cout << "character_file\n"; break;
+    case fs::fifo_file:
+      cout << "fifo_file\n"; break;
+    case fs::socket_file:
+      cout << "socket_file\n"; break;
+    case fs::type_unknown:
+      cout << "type_unknown\n"; break;
+    default:
+      cout << "not a valid enumeration constant\n";
+    }
+  }
+
+  void report_error_code(const error_code& ec)
+  {
+    cout << "  ec:\n"
+         << "    value() is " << ec.value() << '\n'
+         << "    category().name() is " << ec.category().name() << '\n'
+         << "    message() is " <<  ec.message() << '\n'
+         ;
+  }
+
+  bool threw_exception;
+
+}
+
+int main(int argc, char* argv[])
+{
+  if (argc < 2)
+  {
+    cout << "Usage: error_demo path\n";
+    return 1;
+  }
+
+  error_code ec;
+
+  ////  construct path - no error_code
+
+  //try { path p1(argv[1]); }
+  //catch (const system_error& ex)
+  //{
+  //  cout << "construct path without error_code";
+  //  report_system_error(ex);
+  //}
+
+  ////  construct path - with error_code
+
+  path p (argv[1]);
+
+  fs::file_status s;
+  bool            b (false);
+  fs::directory_iterator di;
+
+  //  get status - no error_code
+
+  cout << "\nstatus(\"" << p.string() << "\");\n";
+  threw_exception = false;
+
+  try { s = fs::status(p); }
+  catch (const system_error& ex)
+  {
+    report_filesystem_error(ex);
+    threw_exception = true;
+  }
+  if (!threw_exception)
+    cout << "  Did not throw exception\n";
+  report_status(s);
+
+  //  get status - with error_code
+
+  cout << "\nstatus(\"" << p.string() << "\", ec);\n";
+  s = fs::status(p, ec);
+  report_status(s);
+  report_error_code(ec);
+
+  //  query existence - no error_code
+
+  cout << "\nexists(\"" << p.string() << "\");\n";
+  threw_exception = false;
+
+  try { b = fs::exists(p); }
+  catch (const system_error& ex)
+  {
+    report_filesystem_error(ex);
+    threw_exception = true;
+  }
+  if (!threw_exception)
+  {
+    cout << "  Did not throw exception\n"
+         << "  Returns: " << (b ? "true" : "false") << '\n';
+  }
+
+  //  query existence - with error_code
+
+  //  directory_iterator - no error_code
+
+  cout << "\ndirectory_iterator(\"" << p.string() << "\");\n";
+  threw_exception = false;
+
+  try { di = fs::directory_iterator(p); }
+  catch (const system_error& ex)
+  {
+    report_filesystem_error(ex);
+    threw_exception = true;
+  }
+  if (!threw_exception)
+  {
+    cout << "  Did not throw exception\n"
+      << (di == fs::directory_iterator() ? "  Equal" : "  Not equal")
+      << " to the end iterator\n";
+  }
+
+  //  directory_iterator - with error_code
+
+  cout << "\ndirectory_iterator(\"" << p.string() << "\", ec);\n";
+  di = fs::directory_iterator(p, ec);
+  cout << (di == fs::directory_iterator() ? "  Equal" : "  Not equal")
+       << " to the end iterator\n";
+  report_error_code(ec);
+
+  return 0;
+}

v3/libs/filesystem/example/file_size.cpp

@@ -0,0 +1,44 @@
+//  file_size program  -------------------------------------------------------//
+
+//  Copyright Beman Dawes, 2004
+
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/libs/filesystem for documentation.
+
+#include <boost/filesystem/operations.hpp>
+#include <iostream>
+
+namespace fs = boost::filesystem;
+
+int main( int argc, char* argv[] )
+{
+
+  if ( argc != 2 )
+  {
+    std::cout << "Usage: file_size path\n";
+    return 1;
+  }
+
+  std::cout << "sizeof(intmax_t) is " << sizeof(boost::intmax_t) << '\n';
+
+  fs::path p( argv[1] );
+
+  if ( !fs::exists( p ) )
+  {
+    std::cout << "not found: " << argv[1] << std::endl;
+    return 1;
+  }
+
+  if ( !fs::is_regular( p ) )
+  {
+    std::cout << "not a regular file: " << argv[1] << std::endl;
+    return 1;
+  }
+ 
+  std::cout << "size of " << argv[1] << " is " << fs::file_size( p )
+    << std::endl;
+  return 0;
+}

v3/libs/filesystem/example/mbcopy.cpp

@@ -0,0 +1,90 @@
+//  Boost.Filesystem mbcopy.cpp  ---------------------------------------------//
+
+//  Copyright Beman Dawes 2005
+
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  Copy the files in a directory, using mbpath to represent the new file names
+//  See http://../doc/path.htm#mbpath for more information
+
+//  See deprecated_test for tests of deprecated features
+#define BOOST_FILESYSTEM_NO_DEPRECATED
+
+#include <boost/filesystem/config.hpp>
+# ifdef BOOST_FILESYSTEM_NARROW_ONLY
+#   error This compiler or standard library does not support wide-character strings or paths
+# endif
+
+#include "mbpath.hpp"
+#include <iostream>
+#include <boost/filesystem/operations.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include "../src/utf8_codecvt_facet.hpp"
+
+namespace fs = boost::filesystem;
+
+namespace
+{
+  // we can't use boost::filesystem::copy_file() because the argument types
+  // differ, so provide a not-very-smart replacement.
+
+  void copy_file( const fs::wpath & from, const user::mbpath & to )
+  {
+    fs::ifstream from_file( from, std::ios_base::in | std::ios_base::binary );
+    if ( !from_file ) { std::cout << "input open failed\n"; return; }
+
+    fs::ofstream to_file( to, std::ios_base::out | std::ios_base::binary );
+    if ( !to_file ) { std::cout << "output open failed\n"; return; }
+
+    char c;
+    while ( from_file.get(c) )
+    {
+      to_file.put(c);
+      if ( to_file.fail() ) { std::cout << "write error\n"; return; }
+    }
+
+    if ( !from_file.eof() ) { std::cout << "read error\n"; }
+  }
+}
+
+int main( int argc, char * argv[] )
+{
+  if ( argc != 2 )
+  {
+    std::cout << "Copy files in the current directory to a target directory\n"
+              << "Usage: mbcopy <target-dir>\n";
+    return 1;
+  }
+
+  // For encoding, use Boost UTF-8 codecvt
+  std::locale global_loc = std::locale();
+  std::locale loc( global_loc, new fs::detail::utf8_codecvt_facet );
+  user::mbpath_traits::imbue( loc );
+
+  std::string target_string( argv[1] );
+  user::mbpath target_dir( user::mbpath_traits::to_internal( target_string ) );
+
+  if ( !fs::is_directory( target_dir ) )
+  {
+    std::cout << "Error: " << argv[1] << " is not a directory\n";
+    return 1;
+  }
+
+  for ( fs::wdirectory_iterator it( L"." );
+    it != fs::wdirectory_iterator(); ++it )
+  {
+    if ( fs::is_regular_file(it->status()) )
+    {
+      copy_file( *it, target_dir / it->path().filename() );
+    }
+  }
+
+  return 0;
+}
+
+
+
+
+

v3/libs/filesystem/example/mbpath.cpp

@@ -0,0 +1,80 @@
+//  Boost.Filesystem mbpath.cpp  ---------------------------------------------//
+
+//  (c) Copyright Beman Dawes 2005
+
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See Boost.Filesystem home page at http://www.boost.org/libs/filesystem
+
+#include <boost/filesystem/config.hpp>
+# ifdef BOOST_FILESYSTEM_NARROW_ONLY
+#   error This compiler or standard library does not support wide-character strings or paths
+# endif
+
+#include "mbpath.hpp"
+#include <boost/system/system_error.hpp>
+#include <boost/scoped_array.hpp>
+
+namespace fs = boost::filesystem;
+
+namespace
+{
+  // ISO C calls this "the locale-specific native environment":
+  std::locale loc("");
+
+  const std::codecvt<wchar_t, char, std::mbstate_t> *
+    cvt( &std::use_facet<std::codecvt<wchar_t, char, std::mbstate_t> >
+           ( loc ) );
+}
+
+namespace user
+{
+  mbpath_traits::external_string_type
+  mbpath_traits::to_external( const mbpath & ph,
+    const internal_string_type & src )
+  {
+    std::size_t work_size( cvt->max_length() * (src.size()+1) );
+    boost::scoped_array<char> work( new char[ work_size ] );
+    std::mbstate_t state;
+    const internal_string_type::value_type * from_next;
+    external_string_type::value_type * to_next;
+    if ( cvt->out( 
+      state, src.c_str(), src.c_str()+src.size(), from_next, work.get(),
+      work.get()+work_size, to_next ) != std::codecvt_base::ok )
+      boost::throw_exception<fs::basic_filesystem_error<mbpath> >(
+        fs::basic_filesystem_error<mbpath>(
+          "user::mbpath::to_external conversion error",
+          ph, boost::system::error_code( EINVAL, boost::system::errno_ecat ) ) );
+    *to_next = '\0';
+    return external_string_type( work.get() );
+  }
+
+  mbpath_traits::internal_string_type 
+  mbpath_traits::to_internal( const external_string_type & src )
+  {
+      std::size_t work_size( src.size()+1 );
+      boost::scoped_array<wchar_t> work( new wchar_t[ work_size ] );
+      std::mbstate_t state;
+      const external_string_type::value_type * from_next;
+      internal_string_type::value_type * to_next;
+      if ( cvt->in( 
+        state, src.c_str(), src.c_str()+src.size(), from_next, work.get(),
+        work.get()+work_size, to_next ) != std::codecvt_base::ok )
+        boost::throw_exception<fs::basic_filesystem_error<mbpath> >(
+          fs::basic_filesystem_error<mbpath>(
+            "user::mbpath::to_internal conversion error",
+            boost::system::error_code( EINVAL, boost::system::errno_ecat ) ) );
+      *to_next = L'\0';
+      return internal_string_type( work.get() );
+  }
+
+  void mbpath_traits::imbue( const std::locale & new_loc )
+  {
+    loc = new_loc;
+    cvt = &std::use_facet
+      <std::codecvt<wchar_t, char, std::mbstate_t> >( loc );
+  }
+
+} // namespace user

v3/libs/filesystem/example/mbpath.hpp

@@ -0,0 +1,44 @@
+//  Boost.Filesystem mbpath.hpp  ---------------------------------------------//
+
+//  Copyright Beman Dawes 2005
+
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  Encodes wide character paths as MBCS
+//  See http://../doc/path.htm#mbpath for more information
+
+#include <boost/filesystem/path.hpp>
+#include <cwchar>     // for std::mbstate_t
+#include <string>
+#include <locale>
+
+namespace user
+{
+  struct mbpath_traits;
+  
+  typedef boost::filesystem::basic_path<std::wstring, mbpath_traits> mbpath;
+
+  struct mbpath_traits
+  {
+    typedef std::wstring internal_string_type;
+    typedef std::string external_string_type;
+
+    static external_string_type to_external( const mbpath & ph,
+      const internal_string_type & src );
+
+    static internal_string_type to_internal( const external_string_type & src );
+
+    static void imbue( const std::locale & loc );
+  };
+} // namespace user
+
+namespace boost
+{
+  namespace filesystem
+  {
+    template<> struct is_basic_path<user::mbpath>
+      { static const bool value = true; };
+  }
+}

v3/libs/filesystem/example/path_info.cpp

@@ -0,0 +1,83 @@
+//  path_info.cpp  ---------------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+#include <iostream>
+#include <boost/filesystem.hpp>
+using namespace std;
+using namespace boost::filesystem;
+
+const char * say_what(bool b) { return b ? "true" : "false"; }
+
+int main(int argc, char* argv[])
+{
+  if (argc < 2)
+  {
+    cout << "Usage: path_info path-portion...\n"
+             "Example: path_info foo/bar baz\n"
+#            ifdef BOOST_POSIX_API
+             "         would report info about the composed path foo/bar/baz\n";
+#            else  // BOOST_WINDOWS_API
+             "         would report info about the composed path foo/bar\\baz\n";
+#            endif
+    return 1;
+  }
+
+  path p;  //  compose a path from the command line arguments
+
+  for (; argc > 1; --argc, ++argv)
+    p /= argv[1];
+
+  cout  <<  "\ncomposed path:\n";
+  cout  <<  "  cout << -------------: " << p << "\n";
+  cout  <<  "  make_preferred()----------: " << path(p).make_preferred() << "\n";
+
+  cout << "\nelements:\n";
+
+  for (path::iterator it(p.begin()), it_end(p.end()); it != it_end; ++it)
+    cout << "  " << *it << '\n';
+
+  cout  <<  "\nobservers, native format:" << endl;
+# ifdef BOOST_POSIX_API
+  cout  <<  "  native()-------------: " << p.native() << endl;
+  cout  <<  "  c_str()--------------: " << p.c_str() << endl;
+# else  // BOOST_WINDOWS_API
+  wcout << L"  native()-------------: " << p.native() << endl;
+  wcout << L"  c_str()--------------: " << p.c_str() << endl;
+# endif
+  cout  <<  "  string()-------------: " << p.string() << endl;
+  wcout << L"  wstring()------------: " << p.wstring() << endl;
+
+  cout  <<  "\nobservers, generic format:\n";
+  cout  <<  "  generic_string()-----: " << p.generic_string() << endl;
+  wcout << L"  generic_wstring()----: " << p.generic_wstring() << endl;
+
+  cout  <<  "\ndecomposition:\n";
+  cout  <<  "  root_name()----------: " << p.root_name() << '\n';
+  cout  <<  "  root_directory()-----: " << p.root_directory() << '\n';
+  cout  <<  "  root_path()----------: " << p.root_path() << '\n';
+  cout  <<  "  relative_path()------: " << p.relative_path() << '\n';
+  cout  <<  "  parent_path()--------: " << p.parent_path() << '\n';
+  cout  <<  "  filename()-----------: " << p.filename() << '\n';
+  cout  <<  "  stem()---------------: " << p.stem() << '\n';
+  cout  <<  "  extension()----------: " << p.extension() << '\n';
+
+  cout  <<  "\nquery:\n";
+  cout  <<  "  empty()--------------: " << say_what(p.empty()) << '\n';
+  cout  <<  "  is_absolute()--------: " << say_what(p.is_absolute()) << '\n';
+  cout  <<  "  has_root_name()------: " << say_what(p.has_root_name()) << '\n';
+  cout  <<  "  has_root_directory()-: " << say_what(p.has_root_directory()) << '\n';
+  cout  <<  "  has_root_path()------: " << say_what(p.has_root_path()) << '\n';
+  cout  <<  "  has_relative_path()--: " << say_what(p.has_relative_path()) << '\n';
+  cout  <<  "  has_parent_path()----: " << say_what(p.has_parent_path()) << '\n';
+  cout  <<  "  has_filename()-------: " << say_what(p.has_filename()) << '\n';
+  cout  <<  "  has_stem()-----------: " << say_what(p.has_stem()) << '\n';
+  cout  <<  "  has_extension()------: " << say_what(p.has_extension()) << '\n';
+
+  return 0;
+}

v3/libs/filesystem/example/simple_ls.cpp

@@ -0,0 +1,84 @@
+//  simple_ls program  -------------------------------------------------------//
+
+//  Copyright Jeff Garland and Beman Dawes, 2002
+
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/libs/filesystem for documentation.
+
+//  As an example program, we don't want to use any deprecated features
+#define BOOST_FILESYSTEM_NO_DEPRECATED
+
+#include "boost/filesystem/operations.hpp"
+#include "boost/filesystem/path.hpp"
+#include "boost/progress.hpp"
+#include <iostream>
+
+namespace fs = boost::filesystem;
+
+int main(int argc, char* argv[])
+{
+  fs::path p(fs::initial_path());
+
+  if (argc > 1)
+    p = fs::system_complete(argv[1]);
+  else
+    std::cout << "\nusage:   simple_ls [path]" << std::endl;
+
+  unsigned long file_count = 0;
+  unsigned long dir_count = 0;
+  unsigned long other_count = 0;
+  unsigned long err_count = 0;
+
+  if (!fs::exists(p))
+  {
+    std::cout << "\nNot found: " << p << std::endl;
+    return 1;
+  }
+
+  if (fs::is_directory(p))
+  {
+    std::cout << "\nIn directory: " << p << "\n\n";
+    fs::directory_iterator end_iter;
+    for (fs::directory_iterator dir_itr(p);
+          dir_itr != end_iter;
+          ++dir_itr)
+    {
+      try
+      {
+        if (fs::is_directory(dir_itr->status()))
+        {
+          ++dir_count;
+          std::cout << dir_itr->path().filename() << " [directory]\n";
+        }
+        else if (fs::is_regular_file(dir_itr->status()))
+        {
+          ++file_count;
+          std::cout << dir_itr->path().filename() << "\n";
+        }
+        else
+        {
+          ++other_count;
+          std::cout << dir_itr->path().filename() << " [other]\n";
+        }
+
+      }
+      catch (const std::exception & ex)
+      {
+        ++err_count;
+        std::cout << dir_itr->path().filename() << " " << ex.what() << std::endl;
+      }
+    }
+    std::cout << "\n" << file_count << " files\n"
+              << dir_count << " directories\n"
+              << other_count << " others\n"
+              << err_count << " errors\n";
+  }
+  else // must be a file
+  {
+    std::cout << "\nFound: " << p << "\n";    
+  }
+  return 0;
+}

v3/libs/filesystem/example/tchar.cpp

@@ -0,0 +1,39 @@
+//  Example use of Microsoft TCHAR  ----------------------------------------------------//
+
+//  Copyright Beman Dawes 2008
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <string>
+#include <cassert>
+#include <windows.h>
+#include <winnt.h>
+
+namespace fs = boost::filesystem;
+
+typedef std::basic_string<TCHAR> tstring;
+
+void func( const fs::path & p )
+{
+  assert( fs::exists( p ) );
+}
+
+int main()
+{
+  // get a path that is known to exist
+  fs::path cp = fs::current_path(); 
+
+  // demo: get tstring from the path
+  tstring cp_as_tstring = cp.string<tstring>();
+
+  // demo: pass tstring to filesystem function taking path
+  assert( fs::exists( cp_as_tstring ) );
+
+  // demo: pass tstring to user function taking path
+  func( cp_as_tstring );
+
+  return 0;
+}

v3/libs/filesystem/example/test/Jamfile.v2

@@ -0,0 +1,31 @@
+# Boost Filesystem Library Tutorial Jamfile
+ 
+# (C) Copyright Beman Dawes 2010
+# (C) Copyright Vladimir Prus 2003
+
+# Distributed under the Boost Software License, Version 1.0.
+# See www.boost.org/LICENSE_1_0.txt
+
+# Library home page: http://www.boost.org/libs/filesystem
+
+project
+    : requirements
+      <library>/boost/filesystem//boost_filesystem
+      <library>/boost/system//boost_system
+      <toolset>msvc:<asynch-exceptions>on
+    ;
+    
+exe tut1 : tut1.cpp ;
+exe tut2 : tut2.cpp ;
+exe tut3 : tut3.cpp ;
+exe tut4 : tut4.cpp ;
+exe tut5 : tut5.cpp ;
+exe path_info : path_info.cpp ;
+
+install tut1-copy : tut1 : <location>. ;
+install tut2-copy : tut2 : <location>. ;
+install tut3-copy : tut3 : <location>. ;
+install tut4-copy : tut4 : <location>. ;
+install tut5-copy : tut5 : <location>. ;
+install path_info-copy : path_info : <location>. ;
+  

v3/libs/filesystem/example/test/bld.bat

@@ -0,0 +1,7 @@
+@echo off
+rem Copyright Beman Dawes, 2010
+rem Distributed under the Boost Software License, Version 1.0.
+rem See www.boost.org/LICENSE_1_0.txt
+
+bjam %* >bjam.log
+find "error" <bjam.log

v3/libs/filesystem/example/test/bld.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+# Copyright Beman Dawes, 2010
+# Distributed under the Boost Software License, Version 1.0.
+# See www.boost.org/LICENSE_1_0.txt
+
+bjam $* >bjam.log
+grep "error" <bjam.log

v3/libs/filesystem/example/test/setup.bat

@@ -0,0 +1,13 @@
+@echo off
+rem Copyright Beman Dawes, 2010
+rem Distributed under the Boost Software License, Version 1.0.
+rem See www.boost.org/LICENSE_1_0.txt
+
+copy /y ..\tut1.cpp >nul
+copy /y ..\tut2.cpp >nul
+copy /y ..\tut3.cpp >nul
+copy /y ..\tut4.cpp >nul
+copy /y ..\tut5.cpp >nul
+copy /y ..\path_info.cpp >nul
+del *.exe 2>nul
+del *.pdb 2>nul

v3/libs/filesystem/example/test/setup.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+# Copyright Beman Dawes, 2010
+# Distributed under the Boost Software License, Version 1.0.
+# See www.boost.org/LICENSE_1_0.txt
+
+cp ../tut1.cpp .
+cp ../tut2.cpp .
+cp ../tut3.cpp .
+cp ../tut4.cpp .
+cp ../tut5.cpp .
+cp ../path_info.cpp .
+rm tut1 2>~/junk
+rm tut2 2>~/junk
+rm tut3 2>~/junk
+rm tut4 2>~/junk
+rm tut5 2>~/junk
+rm path_info 2>~/junk
+

v3/libs/filesystem/example/tut0.cpp

@@ -0,0 +1,25 @@
+//  filesystem tut0.cpp  ---------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+#include <iostream>
+#include <boost/filesystem.hpp>
+namespace fs = boost::filesystem;
+
+int main(int argc, char* argv[])
+{
+  if (argc < 2)
+  {
+    std::cout << "Usage: tut0 path\n";
+    return 1;
+  }
+
+  std::cout << argv[1] << '\n';
+
+  return 0;
+}

v3/libs/filesystem/example/tut1.cpp

@@ -0,0 +1,23 @@
+//  filesystem tut1.cpp  ---------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+#include <iostream>
+#include <boost/filesystem.hpp>
+using namespace boost::filesystem;
+
+int main(int argc, char* argv[])
+{
+  if (argc < 2)
+  {
+    std::cout << "Usage: tut1 path\n";
+    return 1;
+  }
+  std::cout << argv[1] << " " << file_size(argv[1]) << '\n';
+  return 0;
+}

v3/libs/filesystem/example/tut2.cpp

@@ -0,0 +1,40 @@
+//  filesystem tut2.cpp  ---------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+#include <iostream>
+#include <boost/filesystem.hpp>
+using namespace std;
+using namespace boost::filesystem;
+
+int main(int argc, char* argv[])
+{
+  if (argc < 2)
+  {
+    cout << "Usage: tut2 path\n";
+    return 1;
+  }
+
+  path p (argv[1]);   // p reads clearer than argv[1] in the following code
+
+  if (exists(p))    // does p actually exist?
+  {
+    if (is_regular_file(p))        // is p a regular file?
+      cout << p << " size is " << file_size(p) << '\n';
+
+    else if (is_directory(p))      // is p a directory?
+      cout << p << " is a directory\n";
+
+    else
+      cout << p << " exists, but is neither a regular file nor a directory\n";
+  }
+  else
+    cout << p << " does not exist\n";
+
+  return 0;
+}

v3/libs/filesystem/example/tut3.cpp

@@ -0,0 +1,56 @@
+//  filesystem tut3.cpp  ---------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+#include <iostream>
+#include <iterator>
+#include <algorithm>
+#include <boost/filesystem.hpp>
+using namespace std;
+using namespace boost::filesystem;
+
+int main(int argc, char* argv[])
+{
+  if (argc < 2)
+  {
+    cout << "Usage: tut3 path\n";
+    return 1;
+  }
+
+  path p (argv[1]);   // p reads clearer than argv[1] in the following code
+
+  try
+  {
+    if (exists(p))    // does p actually exist?
+    {
+      if (is_regular_file(p))        // is p a regular file?
+        cout << p << " size is " << file_size(p) << '\n';
+
+      else if (is_directory(p))      // is p a directory?
+      {
+        cout << p << " is a directory containing:\n";
+
+        copy(directory_iterator(p), directory_iterator(),  // directory_iterator::value_type
+          ostream_iterator<directory_entry>(cout, "\n"));  // is directory_entry, which is
+                                                           // converted to a path by the
+                                                           // path stream inserter
+      }
+      else
+        cout << p << " exists, but is neither a regular file nor a directory\n";
+    }
+    else
+      cout << p << " does not exist\n";
+  }
+
+  catch (const filesystem_error& ex)
+  {
+    cout << ex.what() << '\n';
+  }
+
+  return 0;
+}

v3/libs/filesystem/example/tut4.cpp

@@ -0,0 +1,65 @@
+//  filesystem tut4.cpp  ---------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+#include <iostream>
+#include <iterator>
+#include <vector>
+#include <algorithm>
+#include <boost/filesystem.hpp>
+using namespace std;
+using namespace boost::filesystem;
+
+int main(int argc, char* argv[])
+{
+  if (argc < 2)
+  {
+    cout << "Usage: tut4 path\n";
+    return 1;
+  }
+
+  path p (argv[1]);   // p reads clearer than argv[1] in the following code
+
+  try
+  {
+    if (exists(p))    // does p actually exist?
+    {
+      if (is_regular_file(p))        // is p a regular file?
+        cout << p << " size is " << file_size(p) << '\n';
+
+      else if (is_directory(p))      // is p a directory?
+      {
+        cout << p << " is a directory containing:\n";
+
+        typedef vector<path> vec;             // store paths,
+        vec v;                                // so we can sort them later
+
+        copy(directory_iterator(p), directory_iterator(), back_inserter(v));
+
+        sort(v.begin(), v.end());             // sort, since directory iteration
+                                              // is not ordered on some file systems
+
+        for (vec::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it)
+        {
+          cout << "   " << *it << '\n';
+        }
+      }
+      else
+        cout << p << " exists, but is neither a regular file nor a directory\n";
+    }
+    else
+      cout << p << " does not exist\n";
+  }
+
+  catch (const filesystem_error& ex)
+  {
+    cout << ex.what() << '\n';
+  }
+
+  return 0;
+}

v3/libs/filesystem/example/tut5.cpp

@@ -0,0 +1,52 @@
+//  filesystem tut5.cpp  ---------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+#include <boost/filesystem/fstream.hpp>
+#include <string>
+#include <list>
+namespace fs = boost::filesystem;
+
+int main()
+{
+  // \u263A is "Unicode WHITE SMILING FACE = have a nice day!"
+  std::string narrow_string ("smile2");
+  std::wstring wide_string (L"smile2\u263A");
+  std::list<char> narrow_list;
+  narrow_list.push_back('s');
+  narrow_list.push_back('m');
+  narrow_list.push_back('i');
+  narrow_list.push_back('l');
+  narrow_list.push_back('e');
+  narrow_list.push_back('3');
+  std::list<wchar_t> wide_list;
+  wide_list.push_back(L's');
+  wide_list.push_back(L'm');
+  wide_list.push_back(L'i');
+  wide_list.push_back(L'l');
+  wide_list.push_back(L'e');
+  wide_list.push_back(L'3');
+  wide_list.push_back(L'\u263A');
+
+  { fs::ofstream f("smile"); }
+  { fs::ofstream f(L"smile\u263A"); }
+  { fs::ofstream f(narrow_string); }
+  { fs::ofstream f(wide_string); }
+  { fs::ofstream f(narrow_list); }
+  { fs::ofstream f(wide_list); }
+  narrow_list.pop_back();
+  narrow_list.push_back('4');
+  wide_list.pop_back();
+  wide_list.pop_back();
+  wide_list.push_back(L'4');
+  wide_list.push_back(L'\u263A');
+  { fs::ofstream f(fs::path(narrow_list.begin(), narrow_list.end())); }
+  { fs::ofstream f(fs::path(wide_list.begin(), wide_list.end())); }
+
+  return 0;
+}

v3/libs/filesystem/index.html

@@ -0,0 +1,14 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=doc/index.htm">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="doc/index.htm">doc/index.htm</a>.
+<hr>
+<p>&copy; Copyright Beman Dawes, 2003</p>
+<p> Distributed under the Boost Software 
+License, Version 1.0. (See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
+</html>

v3/libs/filesystem/src/codecvt_error_category.cpp

@@ -0,0 +1,80 @@
+//  codecvt_error_category implementation file  ----------------------------------------//
+
+//  Copyright Beman Dawes 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt)
+
+//  Library home page at http://www.boost.org/libs/filesystem
+
+//--------------------------------------------------------------------------------------//
+
+#include <boost/config/warning_disable.hpp>
+
+// define BOOST_FILESYSTEM_SOURCE so that <boost/filesystem/config.hpp> knows
+// the library is being built (possibly exporting rather than importing code)
+#define BOOST_FILESYSTEM_SOURCE 
+
+#include <boost/filesystem/config.hpp>
+#include <boost/filesystem/path_traits.hpp>
+#include <boost/system/error_code.hpp>
+#include <locale>
+#include <vector>
+#include <cstdlib>
+#include <cassert>
+
+//--------------------------------------------------------------------------------------//
+
+namespace
+{
+  class codecvt_error_cat : public boost::system::error_category
+  {
+  public:
+    codecvt_error_cat(){}
+    const char*   name() const;
+    std::string    message(int ev) const;
+  };
+
+  const char* codecvt_error_cat::name() const
+  {
+    return "codecvt";
+  }
+
+  std::string codecvt_error_cat::message(int ev) const
+  {
+    std::string str;
+    switch (ev)
+    {
+    case std::codecvt_base::ok:
+      str = "ok";
+      break;
+    case std::codecvt_base::partial:
+      str = "partial";
+      break;
+    case std::codecvt_base::error:
+      str = "error";
+      break;
+    case std::codecvt_base::noconv:
+      str = "noconv";
+      break;
+    default:
+      str = "unknown error";
+    }
+    return str;
+  }
+
+} // unnamed namespace
+
+namespace boost
+{
+  namespace filesystem
+  {
+
+    BOOST_FILESYSTEM_DECL const boost::system::error_category& codecvt_error_category()
+    {
+      static const codecvt_error_cat  codecvt_error_cat_const;
+      return codecvt_error_cat_const;
+    }
+
+  } // namespace system
+} // namespace boost

v3/libs/filesystem/src/error_code.cpp

@@ -0,0 +1,421 @@
+//  error_code support implementation file  ----------------------------------//
+
+//  Copyright Beman Dawes 2002, 2006
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/system
+
+//----------------------------------------------------------------------------//
+
+#include <boost/config/warning_disable.hpp>
+
+// define BOOST_SYSTEM_SOURCE so that <boost/system/config.hpp> knows
+// the library is being built (possibly exporting rather than importing code)
+#define BOOST_SYSTEM_SOURCE 
+
+#include <boost/system/config.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/cerrno.hpp>
+#include <vector>
+#include <cstdlib>
+#include <cassert>
+
+using namespace boost::system;
+using namespace boost::system::posix_error;
+
+#include <cstring> // for strerror/strerror_r
+
+# if defined( BOOST_WINDOWS_API )
+#   include <windows.h>
+#   ifndef ERROR_INCORRECT_SIZE
+#    define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS
+#   endif
+# endif
+
+//----------------------------------------------------------------------------//
+
+namespace
+{
+  
+  //  standard error categories  ---------------------------------------------//
+
+  class generic_error_category : public error_category
+  {
+  public:
+    generic_error_category(){}
+    const char *   name() const;
+    std::string    message( int ev ) const;
+  };
+
+  class system_error_category : public error_category
+  {
+  public:
+    system_error_category(){}
+    const char *        name() const;
+    std::string         message( int ev ) const;
+    error_condition     default_error_condition( int ev ) const;
+  };
+
+  //  generic_error_category implementation  ---------------------------------//
+
+  const char * generic_error_category::name() const
+  {
+    return "GENERIC";
+  }
+
+  std::string generic_error_category::message( int ev ) const
+  {
+  // strerror_r is preferred because it is always thread safe,
+  // however, we fallback to strerror in certain cases because:
+  //   -- Windows doesn't provide strerror_r.
+  //   -- HP and Sundo provide strerror_r on newer systems, but there is
+  //      no way to tell if is available at runtime and in any case their
+  //      versions of strerror are thread safe anyhow.
+  //   -- Linux only sometimes provides strerror_r.
+  //   -- Tru64 provides strerror_r only when compiled -pthread.
+  //   -- VMS doesn't provide strerror_r, but on this platform, strerror is
+  //      thread safe.
+  # if defined(BOOST_WINDOWS_API) || defined(__hpux) || defined(__sun)\
+     || (defined(__linux) && (!defined(__USE_XOPEN2K) || defined(BOOST_SYSTEM_USE_STRERROR)))\
+     || (defined(__osf__) && !defined(_REENTRANT))\
+     || (defined(__vms))
+      const char * c_str = std::strerror( ev );
+      return std::string( c_str ? c_str : "Unknown error" );
+  # else
+      char buf[64];
+      char * bp = buf;
+      std::size_t sz = sizeof(buf);
+  #  if defined(__CYGWIN__) || defined(__USE_GNU)
+      // Oddball version of strerror_r
+      const char * c_str = strerror_r( ev, bp, sz );
+      return std::string( c_str ? c_str : "Unknown error" );
+  #  else
+      // POSIX version of strerror_r
+      int result;
+      for (;;)
+      {
+        // strerror_r returns 0 on success, otherwise ERANGE if buffer too small,
+        // invalid_argument if ev not a valid error number
+  #  if defined (__sgi)
+        const char * c_str = strerror( ev );
+        result = 0;
+        return std::string( c_str ? c_str : "Unknown error" );
+  #  else
+        result = strerror_r( ev, bp, sz );
+  #  endif
+        if (result == 0 )
+          break;
+        else
+        {
+  #  if defined(__linux)
+          // Linux strerror_r returns -1 on error, with error number in errno
+          result = errno;
+  #  endif
+          if ( result !=  ERANGE ) break;
+        if ( sz > sizeof(buf) ) std::free( bp );
+        sz *= 2;
+        if ( (bp = static_cast<char*>(std::malloc( sz ))) == 0 )
+          return std::string( "ENOMEM" );
+        }
+      }
+      try
+      {
+      std::string msg( ( result == invalid_argument ) ? "Unknown error" : bp );
+      if ( sz > sizeof(buf) ) std::free( bp );
+        sz = 0;
+      return msg;
+      }
+      catch(...)
+      {
+        if ( sz > sizeof(buf) ) std::free( bp );
+        throw;
+      }
+  #  endif
+  # endif
+  }
+  //  system_error_category implementation  --------------------------------// 
+
+  const char * system_error_category::name() const
+  {
+    return "system";
+  }
+
+  error_condition system_error_category::default_error_condition( int ev ) const
+  {
+    switch ( ev )
+    {
+    case 0: return make_error_condition( success );
+  # if defined(BOOST_POSIX_API)
+    // POSIX-like O/S -> posix_errno decode table  ---------------------------//
+    case E2BIG: return make_error_condition( argument_list_too_long );
+    case EACCES: return make_error_condition( permission_denied );
+    case EADDRINUSE: return make_error_condition( address_in_use );
+    case EADDRNOTAVAIL: return make_error_condition( address_not_available );
+    case EAFNOSUPPORT: return make_error_condition( address_family_not_supported );
+    case EAGAIN: return make_error_condition( resource_unavailable_try_again );
+    case EALREADY: return make_error_condition( connection_already_in_progress );
+    case EBADF: return make_error_condition( bad_file_descriptor );
+    case EBADMSG: return make_error_condition( bad_message );
+    case EBUSY: return make_error_condition( device_or_resource_busy );
+    case ECANCELED: return make_error_condition( operation_canceled );
+    case ECHILD: return make_error_condition( no_child_process );
+    case ECONNABORTED: return make_error_condition( connection_aborted );
+    case ECONNREFUSED: return make_error_condition( connection_refused );
+    case ECONNRESET: return make_error_condition( connection_reset );
+    case EDEADLK: return make_error_condition( resource_deadlock_would_occur );
+    case EDESTADDRREQ: return make_error_condition( destination_address_required );
+    case EDOM: return make_error_condition( argument_out_of_domain );
+    case EEXIST: return make_error_condition( file_exists );
+    case EFAULT: return make_error_condition( bad_address );
+    case EFBIG: return make_error_condition( file_too_large );
+    case EHOSTUNREACH: return make_error_condition( host_unreachable );
+    case EIDRM: return make_error_condition( identifier_removed );
+    case EILSEQ: return make_error_condition( illegal_byte_sequence );
+    case EINPROGRESS: return make_error_condition( operation_in_progress );
+    case EINTR: return make_error_condition( interrupted );
+    case EINVAL: return make_error_condition( invalid_argument );
+    case EIO: return make_error_condition( io_error );
+    case EISCONN: return make_error_condition( already_connected );
+    case EISDIR: return make_error_condition( is_a_directory );
+    case ELOOP: return make_error_condition( too_many_synbolic_link_levels );
+    case EMFILE: return make_error_condition( too_many_files_open );
+    case EMLINK: return make_error_condition( too_many_links );
+    case EMSGSIZE: return make_error_condition( message_size );
+    case ENAMETOOLONG: return make_error_condition( filename_too_long );
+    case ENETDOWN: return make_error_condition( network_down );
+    case ENETRESET: return make_error_condition( network_reset );
+    case ENETUNREACH: return make_error_condition( network_unreachable );
+    case ENFILE: return make_error_condition( too_many_files_open_in_system );
+    case ENOBUFS: return make_error_condition( no_buffer_space );
+    case ENODATA: return make_error_condition( no_message_available );
+    case ENODEV: return make_error_condition( no_such_device );
+    case ENOENT: return make_error_condition( no_such_file_or_directory );
+    case ENOEXEC: return make_error_condition( executable_format_error );
+    case ENOLCK: return make_error_condition( no_lock_available );
+    case ENOLINK: return make_error_condition( no_link );
+    case ENOMEM: return make_error_condition( not_enough_memory );
+    case ENOMSG: return make_error_condition( no_message );
+    case ENOPROTOOPT: return make_error_condition( no_protocol_option );
+    case ENOSPC: return make_error_condition( no_space_on_device );
+    case ENOSR: return make_error_condition( no_stream_resources );
+    case ENOSTR: return make_error_condition( not_a_stream );
+    case ENOSYS: return make_error_condition( function_not_supported );
+    case ENOTCONN: return make_error_condition( not_connected );
+    case ENOTDIR: return make_error_condition( not_a_directory );
+  # if ENOTEMPTY != EEXIST // AIX treats ENOTEMPTY and EEXIST as the same value
+    case ENOTEMPTY: return make_error_condition( directory_not_empty );
+  # endif // ENOTEMPTY != EEXIST
+    case ENOTRECOVERABLE: return make_error_condition( state_not_recoverable );
+    case ENOTSOCK: return make_error_condition( not_a_socket );
+    case ENOTSUP: return make_error_condition( not_supported );
+    case ENOTTY: return make_error_condition( inappropriate_io_control_operation );
+    case ENXIO: return make_error_condition( no_such_device_or_address );
+  # if EOPNOTSUPP != ENOTSUP
+    case EOPNOTSUPP: return make_error_condition( operation_not_supported );
+  # endif // EOPNOTSUPP != ENOTSUP
+    case EOVERFLOW: return make_error_condition( value_too_large );
+    case EOWNERDEAD: return make_error_condition( owner_dead );
+    case EPERM: return make_error_condition( operation_not_permitted );
+    case EPIPE: return make_error_condition( broken_pipe );
+    case EPROTO: return make_error_condition( protocol_error );
+    case EPROTONOSUPPORT: return make_error_condition( protocol_not_supported );
+    case EPROTOTYPE: return make_error_condition( wrong_protocol_type );
+    case ERANGE: return make_error_condition( result_out_of_range );
+    case EROFS: return make_error_condition( read_only_file_system );
+    case ESPIPE: return make_error_condition( invalid_seek );
+    case ESRCH: return make_error_condition( no_such_process );
+    case ETIME: return make_error_condition( stream_timeout );
+    case ETIMEDOUT: return make_error_condition( timed_out );
+    case ETXTBSY: return make_error_condition( text_file_busy );
+  # if EAGAIN != EWOULDBLOCK
+    case EWOULDBLOCK: return make_error_condition( operation_would_block );
+  # endif // EAGAIN != EWOULDBLOCK
+    case EXDEV: return make_error_condition( cross_device_link );
+  #else
+    // Windows system -> posix_errno decode table  ---------------------------//
+    // see WinError.h comments for descriptions of errors
+    case ERROR_ACCESS_DENIED: return make_error_condition( permission_denied );
+    case ERROR_ALREADY_EXISTS: return make_error_condition( file_exists );
+    case ERROR_BAD_UNIT: return make_error_condition( no_such_device );
+    case ERROR_BUFFER_OVERFLOW: return make_error_condition( filename_too_long );
+    case ERROR_BUSY: return make_error_condition( device_or_resource_busy );
+    case ERROR_BUSY_DRIVE: return make_error_condition( device_or_resource_busy );
+    case ERROR_CANNOT_MAKE: return make_error_condition( permission_denied );
+    case ERROR_CANTOPEN: return make_error_condition( io_error );
+    case ERROR_CANTREAD: return make_error_condition( io_error );
+    case ERROR_CANTWRITE: return make_error_condition( io_error );
+    case ERROR_CURRENT_DIRECTORY: return make_error_condition( permission_denied );
+    case ERROR_DEV_NOT_EXIST: return make_error_condition( no_such_device );
+    case ERROR_DEVICE_IN_USE: return make_error_condition( device_or_resource_busy );
+    case ERROR_DIR_NOT_EMPTY: return make_error_condition( directory_not_empty );
+    case ERROR_DIRECTORY: return make_error_condition( invalid_argument ); // WinError.h: "The directory name is invalid"
+    case ERROR_DISK_FULL: return make_error_condition( no_space_on_device );
+    case ERROR_FILE_EXISTS: return make_error_condition( file_exists );
+    case ERROR_FILE_NOT_FOUND: return make_error_condition( no_such_file_or_directory );
+    case ERROR_HANDLE_DISK_FULL: return make_error_condition( no_space_on_device );
+    case ERROR_INVALID_ACCESS: return make_error_condition( permission_denied );
+    case ERROR_INVALID_DRIVE: return make_error_condition( no_such_device );
+    case ERROR_INVALID_FUNCTION: return make_error_condition( function_not_supported );
+    case ERROR_INVALID_HANDLE: return make_error_condition( invalid_argument );
+    case ERROR_INVALID_NAME: return make_error_condition( invalid_argument );
+    case ERROR_LOCK_VIOLATION: return make_error_condition( no_lock_available );
+    case ERROR_LOCKED: return make_error_condition( no_lock_available );
+    case ERROR_NEGATIVE_SEEK: return make_error_condition( invalid_argument );
+    case ERROR_NOACCESS: return make_error_condition( permission_denied );
+    case ERROR_NOT_ENOUGH_MEMORY: return make_error_condition( not_enough_memory );
+    case ERROR_NOT_READY: return make_error_condition( resource_unavailable_try_again );
+    case ERROR_NOT_SAME_DEVICE: return make_error_condition( cross_device_link );
+    case ERROR_OPEN_FAILED: return make_error_condition( io_error );
+    case ERROR_OPEN_FILES: return make_error_condition( device_or_resource_busy );
+    case ERROR_OPERATION_ABORTED: return make_error_condition( operation_canceled );
+    case ERROR_OUTOFMEMORY: return make_error_condition( not_enough_memory );
+    case ERROR_PATH_NOT_FOUND: return make_error_condition( no_such_file_or_directory );
+    case ERROR_READ_FAULT: return make_error_condition( io_error );
+    case ERROR_RETRY: return make_error_condition( resource_unavailable_try_again );
+    case ERROR_SEEK: return make_error_condition( io_error );
+    case ERROR_SHARING_VIOLATION: return make_error_condition( permission_denied );
+    case ERROR_TOO_MANY_OPEN_FILES: return make_error_condition( too_many_files_open );
+    case ERROR_WRITE_FAULT: return make_error_condition( io_error );
+    case ERROR_WRITE_PROTECT: return make_error_condition( permission_denied );
+    case WSAEACCES: return make_error_condition( permission_denied );
+    case WSAEADDRINUSE: return make_error_condition( address_in_use );
+    case WSAEADDRNOTAVAIL: return make_error_condition( address_not_available );
+    case WSAEAFNOSUPPORT: return make_error_condition( address_family_not_supported );
+    case WSAEALREADY: return make_error_condition( connection_already_in_progress );
+    case WSAEBADF: return make_error_condition( bad_file_descriptor );
+    case WSAECONNABORTED: return make_error_condition( connection_aborted );
+    case WSAECONNREFUSED: return make_error_condition( connection_refused );
+    case WSAECONNRESET: return make_error_condition( connection_reset );
+    case WSAEDESTADDRREQ: return make_error_condition( destination_address_required );
+    case WSAEFAULT: return make_error_condition( bad_address );
+    case WSAEHOSTUNREACH: return make_error_condition( host_unreachable );
+    case WSAEINPROGRESS: return make_error_condition( operation_in_progress );
+    case WSAEINTR: return make_error_condition( interrupted );
+    case WSAEINVAL: return make_error_condition( invalid_argument );
+    case WSAEISCONN: return make_error_condition( already_connected );
+    case WSAEMFILE: return make_error_condition( too_many_files_open );
+    case WSAEMSGSIZE: return make_error_condition( message_size );
+    case WSAENAMETOOLONG: return make_error_condition( filename_too_long );
+    case WSAENETDOWN: return make_error_condition( network_down );
+    case WSAENETRESET: return make_error_condition( network_reset );
+    case WSAENETUNREACH: return make_error_condition( network_unreachable );
+    case WSAENOBUFS: return make_error_condition( no_buffer_space );
+    case WSAENOPROTOOPT: return make_error_condition( no_protocol_option );
+    case WSAENOTCONN: return make_error_condition( not_connected );
+    case WSAENOTSOCK: return make_error_condition( not_a_socket );
+    case WSAEOPNOTSUPP: return make_error_condition( operation_not_supported );
+    case WSAEPROTONOSUPPORT: return make_error_condition( protocol_not_supported );
+    case WSAEPROTOTYPE: return make_error_condition( wrong_protocol_type );
+    case WSAETIMEDOUT: return make_error_condition( timed_out );
+    case WSAEWOULDBLOCK: return make_error_condition( operation_would_block );
+  #endif
+    default: return error_condition( ev, system_category );
+    }
+  }
+
+# if !defined( BOOST_WINDOWS_API )
+
+  std::string system_error_category::message( int ev ) const
+  {
+    return generic_category.message( ev );
+  }
+# else
+// TODO:
+  
+//Some quick notes on the implementation (sorry for the noise if
+//someone has already mentioned them):
+//
+//- The ::LocalFree() usage isn't exception safe.
+//
+//See:
+//
+//<http://boost.cvs.sourceforge.net/boost/boost/boost/asio/system_exception.hpp?revision=1.1&view=markup>
+//
+//in the implementation of what() for an example.
+//
+//Cheers,
+//Chris
+  std::string system_error_category::message( int ev ) const
+  {
+# ifndef BOOST_NO_ANSI_APIS  
+    LPVOID lpMsgBuf;
+    DWORD retval = ::FormatMessageA( 
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+        FORMAT_MESSAGE_FROM_SYSTEM | 
+        FORMAT_MESSAGE_IGNORE_INSERTS,
+        NULL,
+        ev,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+        (LPSTR) &lpMsgBuf,
+        0,
+        NULL 
+    );
+    if (retval == 0)
+        return std::string("Unknown error");
+        
+    std::string str( static_cast<LPCSTR>(lpMsgBuf) );
+    ::LocalFree( lpMsgBuf ); // free the buffer
+# else  // WinCE workaround
+    LPVOID lpMsgBuf;
+    DWORD retval = ::FormatMessageW( 
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+        FORMAT_MESSAGE_FROM_SYSTEM | 
+        FORMAT_MESSAGE_IGNORE_INSERTS,
+        NULL,
+        ev,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+        (LPWSTR) &lpMsgBuf,
+        0,
+        NULL 
+    );
+    if (retval == 0)
+        return std::string("Unknown error");
+    
+    int num_chars = (wcslen( static_cast<LPCWSTR>(lpMsgBuf) ) + 1) * 2;
+    LPSTR narrow_buffer = (LPSTR)_alloca( num_chars );
+    if (::WideCharToMultiByte(CP_ACP, 0, static_cast<LPCWSTR>(lpMsgBuf), -1, narrow_buffer, num_chars, NULL, NULL) == 0)
+        return std::string("Unknown error");
+
+    std::string str( narrow_buffer );
+    ::LocalFree( lpMsgBuf ); // free the buffer
+# endif
+    while ( str.size()
+      && (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') )
+        str.erase( str.size()-1 );
+    if ( str.size() && str[str.size()-1] == '.' ) 
+      { str.erase( str.size()-1 ); }
+    return str;
+  }
+# endif
+
+} // unnamed namespace
+
+namespace boost
+{
+  namespace system
+  {
+
+  
+
+    BOOST_SYSTEM_DECL error_code throws; // "throw on error" special error_code;
+                                         //  note that it doesn't matter if this
+                                         //  isn't initialized before use since
+                                         //  the only use is to take its
+                                         //  address for comparison purposes
+
+    BOOST_SYSTEM_DECL const error_category & get_system_category()
+    {
+      static const system_error_category  system_category_const;
+      return system_category_const;
+    }
+
+    BOOST_SYSTEM_DECL const error_category & get_generic_category()
+    {
+      static const generic_error_category generic_category_const;
+      return generic_category_const;
+    }
+
+  } // namespace system
+} // namespace boost

v3/libs/filesystem/src/path.cpp

@@ -0,0 +1,848 @@
+//  filesystem path.cpp  -------------------------------------------------------------  //
+
+//  Copyright Beman Dawes 2008
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+// define BOOST_FILESYSTEM_SOURCE so that <boost/system/config.hpp> knows
+// the library is being built (possibly exporting rather than importing code)
+#define BOOST_FILESYSTEM_SOURCE 
+
+#include <boost/filesystem/config.hpp>
+#include <boost/filesystem/path.hpp>
+#include <boost/scoped_array.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/assert.hpp>
+#include <cstddef>
+#include <cstring>
+#include <cassert>
+
+#ifdef BOOST_WINDOWS_API
+# include "windows_file_codecvt.hpp"
+# include <windows.h>
+#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
+# include "utf8_codecvt_facet.hpp"
+#endif
+
+#ifdef BOOST_FILESYSTEM_DEBUG
+# include <iostream>
+# include <iomanip>
+#endif
+
+namespace fs = boost::filesystem;
+
+using fs::path;
+
+using std::string;
+using std::wstring;
+
+using boost::system::error_code;
+
+#ifndef BOOST_FILESYSTEM_CODECVT_BUF_SIZE
+# define BOOST_FILESYSTEM_CODECVT_BUF_SIZE 256
+#endif
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                                class path helpers                                    //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+namespace
+{
+  //------------------------------------------------------------------------------------//
+  //                        miscellaneous class path helpers                            //
+  //------------------------------------------------------------------------------------//
+
+  typedef path::value_type        value_type;
+  typedef path::string_type       string_type;
+  typedef string_type::size_type  size_type;
+
+  const std::size_t default_codecvt_buf_size = BOOST_FILESYSTEM_CODECVT_BUF_SIZE;
+
+# ifdef BOOST_WINDOWS_API
+
+  const wchar_t separator = L'/';
+  const wchar_t preferred_separator = L'\\';
+  const wchar_t* const separators = L"/\\";
+  const wchar_t* separator_string = L"/";
+  const wchar_t* preferred_separator_string = L"\\";
+  const wchar_t colon = L':';
+  const wchar_t dot = L'.';
+  const fs::path dot_path(L".");
+  const fs::path dot_dot_path(L"..");
+
+# else
+
+  const char separator = '/';
+  const char preferred_separator = '/';
+  const char* const separators = "/";
+  const char* separator_string = "/";
+  const char* preferred_separator_string = "/";
+  const char colon = ':';
+  const char dot = '.';
+  const fs::path dot_path(".");
+  const fs::path dot_dot_path("..");
+
+# endif
+
+  inline bool is_separator(fs::path::value_type c)
+  {
+    return c == separator
+#     ifdef BOOST_WINDOWS_API
+      || c == preferred_separator
+#     endif
+      ;
+  }
+
+  bool is_non_root_separator(const string_type& str, size_type pos);
+    // pos is position of the separator
+
+  size_type filename_pos(const string_type& str,
+                          size_type end_pos); // end_pos is past-the-end position
+  //  Returns: 0 if str itself is filename (or empty)
+
+  size_type root_directory_start(const string_type& path, size_type size);
+  //  Returns:  npos if no root_directory found
+
+  void first_element(
+      const string_type& src,
+      size_type& element_pos,
+      size_type& element_size,
+#     if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) // VC++ 7.1
+      size_type size = string_type::npos
+#     else
+      size_type size = -1
+#     endif
+    );
+
+}  // unnamed namespace
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                            class path implementation                                 //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+namespace boost
+{
+namespace filesystem
+{
+
+  path & path::operator/=(const path & p)
+  {
+    if (p.empty())
+      return *this;
+    if (!is_separator(*p.m_pathname.begin()))
+      m_append_separator_if_needed();
+    m_pathname += p.m_pathname;
+    return *this;
+  }
+
+# ifdef BOOST_WINDOWS_API
+
+  const std::string  path::string() const
+  { 
+    std::string tmp;
+    if (!m_pathname.empty())
+      path_traits::convert(&*m_pathname.begin(), &*m_pathname.begin()+m_pathname.size(),
+        tmp, codecvt());
+    return tmp;
+  }
+
+  void path::m_portable()
+  {
+    for (string_type::iterator it = m_pathname.begin();
+          it != m_pathname.end(); ++it)
+    {
+      if (*it == L'\\')
+        *it = L'/';
+    }
+  }
+
+  const std::string path::generic_string() const
+  { 
+    path tmp(*this);
+    tmp.m_portable();
+    return tmp.string();
+  }
+
+  const std::wstring path::generic_wstring() const
+  { 
+    path tmp(*this);
+    tmp.m_portable();
+    return tmp.wstring();
+  }
+
+# endif  // BOOST_WINDOWS_API
+
+  //  m_append_separator_if_needed  ----------------------------------------------------//
+
+  path::string_type::size_type path::m_append_separator_if_needed()
+  {
+    if (!m_pathname.empty() &&
+#     ifdef BOOST_WINDOWS_API
+      *(m_pathname.end()-1) != colon && 
+#     endif
+      !is_separator(*(m_pathname.end()-1)))
+    {
+      string_type::size_type tmp(m_pathname.size());
+      m_pathname += preferred_separator;
+      return tmp;
+    }
+    return 0;
+  }
+
+  //  m_erase_redundant_separator  -----------------------------------------------------//
+
+  void path::m_erase_redundant_separator(string_type::size_type sep_pos)
+  {
+    if (sep_pos                         // a separator was added
+      && sep_pos < m_pathname.size()         // and something was appended
+      && (m_pathname[sep_pos+1] == separator // and it was also separator
+#      ifdef BOOST_WINDOWS_API
+       || m_pathname[sep_pos+1] == preferred_separator  // or preferred_separator
+#      endif
+)) { m_pathname.erase(sep_pos, 1); } // erase the added separator
+  }
+
+  //  modifiers  -----------------------------------------------------------------------//
+
+  path&  path::make_absolute(const path& base)
+  {
+    //  store expensive to compute values that are needed multiple times
+    path this_root_name (root_name());
+    path base_root_name (base.root_name());
+    path this_root_directory (root_directory());
+
+#   ifdef BOOST_WINDOWS_API
+    BOOST_ASSERT(!this_root_name.empty() || !base_root_name.empty());
+#   endif
+
+    BOOST_ASSERT(!this_root_directory.empty() || base.has_root_directory());
+
+    if (m_pathname.empty())
+      m_pathname = base.m_pathname;
+
+    else if (!this_root_name.empty()) // has_root_name
+    {
+      if (this_root_directory.empty()) // !root_directory()
+      {
+        path tmp (this_root_name / base.root_directory()
+                   / base.relative_path() / relative_path());
+        m_pathname.swap(tmp.m_pathname);
+      }
+      // else is_absolute() so do nothing at all
+    }
+
+    else if (has_root_directory())
+    {
+#     ifdef BOOST_POSIX_API
+      if (base_root_name.empty()) return *this;
+#     endif
+      path tmp (base_root_name / m_pathname);
+      m_pathname.swap(tmp.m_pathname);
+    }
+
+    else
+    {
+      path tmp (base / m_pathname);
+      m_pathname.swap(tmp.m_pathname);
+    }
+
+    return *this;
+  }
+
+# ifdef BOOST_WINDOWS_API
+  path & path::make_preferred()
+  {
+    for (string_type::iterator it = m_pathname.begin();
+          it != m_pathname.end(); ++it)
+    {
+      if (*it == L'/')
+        *it = L'\\';
+    }
+    return *this;
+  }
+# endif
+
+  path& path::remove_filename()
+  {
+    m_pathname.erase(m_parent_path_end());
+    return *this;
+  }
+
+  path & path::replace_extension(const path & source)
+  {
+    // erase existing extension if any
+    size_type pos(m_pathname.rfind(dot));
+    if (pos != string_type::npos)
+      m_pathname.erase(pos);
+
+    // append source extension if any
+    pos = source.m_pathname.rfind(dot);
+    if (pos != string_type::npos)
+      m_pathname += source.c_str() + pos;
+
+    return *this;
+  }
+
+  //  decomposition  -------------------------------------------------------------------//
+
+  path  path::root_path() const
+  { 
+    path temp(root_name());
+    if (!root_directory().empty()) temp.m_pathname += root_directory().c_str();
+    return temp;
+  } 
+
+  path path::root_name() const
+  {
+    iterator itr(begin());
+
+    return (itr.m_pos != m_pathname.size()
+      && (
+          (itr.m_element.m_pathname.size() > 1
+            && is_separator(itr.m_element.m_pathname[0])
+            && is_separator(itr.m_element.m_pathname[1])
+   )
+#       ifdef BOOST_WINDOWS_API
+        || itr.m_element.m_pathname[itr.m_element.m_pathname.size()-1] == colon
+#       endif
+  ))
+      ? itr.m_element
+      : path();
+  }
+
+  path path::root_directory() const
+  {
+    size_type pos(root_directory_start(m_pathname, m_pathname.size()));
+
+    return pos == string_type::npos
+      ? path()
+      : path(m_pathname.c_str() + pos, m_pathname.c_str() + pos + 1);
+  }
+
+  path path::relative_path() const
+  {
+    iterator itr(begin());
+
+    for (; itr.m_pos != m_pathname.size()
+      && (is_separator(itr.m_element.m_pathname[0])
+#     ifdef BOOST_WINDOWS_API
+      || itr.m_element.m_pathname[itr.m_element.m_pathname.size()-1] == colon
+#     endif
+    ); ++itr) {}
+
+    return path(m_pathname.c_str() + itr.m_pos);
+  }
+
+  string_type::size_type path::m_parent_path_end() const
+  {
+    size_type end_pos(filename_pos(m_pathname, m_pathname.size()));
+
+    bool filename_was_separator(m_pathname.size()
+      && is_separator(m_pathname[end_pos]));
+
+    // skip separators unless root directory
+    size_type root_dir_pos(root_directory_start(m_pathname, end_pos));
+    for (; 
+      end_pos > 0
+      && (end_pos-1) != root_dir_pos
+      && is_separator(m_pathname[end_pos-1])
+      ;
+      --end_pos) {}
+
+   return (end_pos == 1 && root_dir_pos == 0 && filename_was_separator)
+     ? string_type::npos
+     : end_pos;
+  }
+
+  path path::parent_path() const
+  {
+   size_type end_pos(m_parent_path_end());
+   return end_pos == string_type::npos
+     ? path()
+     : path(m_pathname.c_str(), m_pathname.c_str() + end_pos);
+  }
+
+  path path::filename() const
+  {
+    size_type pos(filename_pos(m_pathname, m_pathname.size()));
+    return (m_pathname.size()
+              && pos
+              && is_separator(m_pathname[pos])
+              && is_non_root_separator(m_pathname, pos))
+      ? dot_path
+      : path(m_pathname.c_str() + pos);
+  }
+
+  path path::stem() const
+  {
+    path name(filename());
+    if (name == dot_path || name == dot_dot_path) return name;
+    size_type pos(name.m_pathname.rfind(dot));
+    return pos == string_type::npos
+      ? name
+      : path(name.m_pathname.c_str(), name.m_pathname.c_str() + pos);
+  }
+
+  path path::extension() const
+  {
+    path name(filename());
+    if (name == dot_path || name == dot_dot_path) return path();
+    size_type pos(name.m_pathname.rfind(dot));
+    return pos == string_type::npos
+      ? path()
+      : path(name.m_pathname.c_str() + pos);
+  }
+
+  // m_normalize  ----------------------------------------------------------------------//
+
+  path& path::m_normalize()
+  {
+    if (m_pathname.empty()) return *this;
+      
+    path temp;
+    iterator start(begin());
+    iterator last(end());
+    iterator stop(last--);
+    for (iterator itr(start); itr != stop; ++itr)
+    {
+      // ignore "." except at start and last
+      if (itr->native().size() == 1
+        && (itr->native())[0] == dot
+        && itr != start
+        && itr != last) continue;
+
+      // ignore a name and following ".."
+      if (!temp.empty()
+        && itr->native().size() == 2
+        && (itr->native())[0] == dot
+        && (itr->native())[1] == dot) // dot dot
+      {
+        string_type lf(temp.filename().native());  
+        if (lf.size() > 0  
+          && (lf.size() != 1
+            || (lf[0] != dot
+              && lf[0] != separator))
+          && (lf.size() != 2 
+            || (lf[0] != dot
+              && lf[1] != dot
+#             ifdef BOOST_WINDOWS_API
+              && lf[1] != colon
+#             endif
+               )
+             )
+          )
+        {
+          temp.remove_filename();
+          // if not root directory, must also remove "/" if any
+          if (temp.m_pathname.size() > 0
+            && temp.m_pathname[temp.m_pathname.size()-1]
+              == separator)
+          {
+            string_type::size_type rds(
+              root_directory_start(temp.m_pathname, temp.m_pathname.size()));
+            if (rds == string_type::npos
+              || rds != temp.m_pathname.size()-1) 
+              { temp.m_pathname.erase(temp.m_pathname.size()-1); }
+          }
+
+          iterator next(itr);
+          if (temp.empty() && ++next != stop
+            && next == last && *last == dot_path) temp /= dot_path;
+          continue;
+        }
+      }
+
+      temp /= *itr;
+    };
+
+    if (temp.empty()) temp /= dot_path;
+    m_pathname = temp.m_pathname;
+    return *this;
+  }
+
+}  // namespace filesystem
+}  // namespace boost
+  
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                         class path helpers implementation                            //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+namespace
+{
+
+  //  is_non_root_separator  -------------------------------------------------//
+
+  bool is_non_root_separator(const string_type & str, size_type pos)
+    // pos is position of the separator
+  {
+    BOOST_ASSERT(!str.empty() && is_separator(str[pos])
+      && "precondition violation");
+
+    // subsequent logic expects pos to be for leftmost slash of a set
+    while (pos > 0 && is_separator(str[pos-1]))
+      --pos;
+
+    return  pos != 0
+      && (pos <= 2 || !is_separator(str[1])
+        || str.find_first_of(separators, 2) != pos)
+#     ifdef BOOST_WINDOWS_API
+      && (pos !=2 || str[1] != colon)
+#     endif
+        ;
+  }
+
+  //  filename_pos  --------------------------------------------------------------------//
+
+  size_type filename_pos(const string_type & str,
+                          size_type end_pos) // end_pos is past-the-end position
+    // return 0 if str itself is filename (or empty)
+  {
+    // case: "//"
+    if (end_pos == 2 
+      && is_separator(str[0])
+      && is_separator(str[1])) return 0;
+
+    // case: ends in "/"
+    if (end_pos && is_separator(str[end_pos-1]))
+      return end_pos-1;
+    
+    // set pos to start of last element
+    size_type pos(str.find_last_of(separators, end_pos-1));
+
+#   ifdef BOOST_WINDOWS_API
+    if (pos == string_type::npos)
+      pos = str.find_last_of(colon, end_pos-2);
+#   endif
+
+    return (pos == string_type::npos // path itself must be a filename (or empty)
+      || (pos == 1 && is_separator(str[0]))) // or net
+        ? 0 // so filename is entire string
+        : pos + 1; // or starts after delimiter
+  }
+
+  //  root_directory_start  ------------------------------------------------------------//
+
+  size_type root_directory_start(const string_type & path, size_type size)
+  // return npos if no root_directory found
+  {
+
+#   ifdef BOOST_WINDOWS_API
+    // case "c:/"
+    if (size > 2
+      && path[1] == colon
+      && is_separator(path[2])) return 2;
+#   endif
+
+    // case "//"
+    if (size == 2
+      && is_separator(path[0])
+      && is_separator(path[1])) return string_type::npos;
+
+    // case "//net {/}"
+    if (size > 3
+      && is_separator(path[0])
+      && is_separator(path[1])
+      && !is_separator(path[2]))
+    {
+      string_type::size_type pos(path.find_first_of(separators, 2));
+      return pos < size ? pos : string_type::npos;
+    }
+    
+    // case "/"
+    if (size > 0 && is_separator(path[0])) return 0;
+
+    return string_type::npos;
+  }
+
+  //  first_element --------------------------------------------------------------------//
+  //   sets pos and len of first element, excluding extra separators
+  //   if src.empty(), sets pos,len, to 0,0.
+
+  void first_element(
+      const string_type & src,
+      size_type & element_pos,
+      size_type & element_size,
+      size_type size
+)
+  {
+    if (size == string_type::npos) size = src.size();
+    element_pos = 0;
+    element_size = 0;
+    if (src.empty()) return;
+
+    string_type::size_type cur(0);
+    
+    // deal with // [network]
+    if (size >= 2 && is_separator(src[0])
+      && is_separator(src[1])
+      && (size == 2
+        || !is_separator(src[2])))
+    { 
+      cur += 2;
+      element_size += 2;
+    }
+
+    // leading (not non-network) separator
+    else if (is_separator(src[0]))
+    {
+      ++element_size;
+      // bypass extra leading separators
+      while (cur+1 < size
+        && is_separator(src[cur+1]))
+      {
+        ++cur;
+        ++element_pos;
+      }
+      return;
+    }
+
+    // at this point, we have either a plain name, a network name,
+    // or (on Windows only) a device name
+
+    // find the end
+    while (cur < size
+#     ifdef BOOST_WINDOWS_API
+      && src[cur] != colon
+#     endif
+      && !is_separator(src[cur]))
+    {
+      ++cur;
+      ++element_size;
+    }
+
+#   ifdef BOOST_WINDOWS_API
+    if (cur == size) return;
+    // include device delimiter
+    if (src[cur] == colon)
+      { ++element_size; }
+#   endif
+
+    return;
+  }
+
+}  // unnammed namespace
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                        class path::iterator implementation                           //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+namespace boost
+{
+namespace filesystem
+{
+
+  path::iterator path::begin() const
+  {
+    iterator itr;
+    itr.m_path_ptr = this;
+    size_type element_size;
+    first_element(m_pathname, itr.m_pos, element_size);
+    itr.m_element = m_pathname.substr(itr.m_pos, element_size);
+    if (itr.m_element.m_pathname == preferred_separator_string)
+      itr.m_element.m_pathname = separator_string;  // needed for Windows, harmless on POSIX
+    return itr;
+  }
+
+  path::iterator path::end() const
+  {
+    iterator itr;
+    itr.m_path_ptr = this;
+    itr.m_pos = m_pathname.size();
+    return itr;
+  }
+
+  void path::m_path_iterator_increment(path::iterator & it)
+  {
+    BOOST_ASSERT(it.m_pos < it.m_path_ptr->m_pathname.size() && "path::basic_iterator increment past end()");
+
+    // increment to position past current element
+    it.m_pos += it.m_element.m_pathname.size();
+
+    // if end reached, create end basic_iterator
+    if (it.m_pos == it.m_path_ptr->m_pathname.size())
+    {
+      it.m_element.clear(); 
+      return;
+    }
+
+    // both POSIX and Windows treat paths that begin with exactly two separators specially
+    bool was_net(it.m_element.m_pathname.size() > 2
+      && is_separator(it.m_element.m_pathname[0])
+      && is_separator(it.m_element.m_pathname[1])
+      && !is_separator(it.m_element.m_pathname[2]));
+
+    // process separator (Windows drive spec is only case not a separator)
+    if (is_separator(it.m_path_ptr->m_pathname[it.m_pos]))
+    {
+      // detect root directory
+      if (was_net
+#       ifdef BOOST_WINDOWS_API
+        // case "c:/"
+        || it.m_element.m_pathname[it.m_element.m_pathname.size()-1] == colon
+#       endif
+         )
+      {
+        it.m_element.m_pathname = separator;
+        return;
+      }
+
+      // bypass separators
+      while (it.m_pos != it.m_path_ptr->m_pathname.size()
+        && is_separator(it.m_path_ptr->m_pathname[it.m_pos]))
+        { ++it.m_pos; }
+
+      // detect trailing separator, and treat it as ".", per POSIX spec
+      if (it.m_pos == it.m_path_ptr->m_pathname.size()
+        && is_non_root_separator(it.m_path_ptr->m_pathname, it.m_pos-1)) 
+      {
+        --it.m_pos;
+        it.m_element = dot_path;
+        return;
+      }
+    }
+
+    // get next element
+    size_type end_pos(it.m_path_ptr->m_pathname.find_first_of(separators, it.m_pos));
+    if (end_pos == string_type::npos) end_pos = it.m_path_ptr->m_pathname.size();
+    it.m_element = it.m_path_ptr->m_pathname.substr(it.m_pos, end_pos - it.m_pos);
+  }
+
+  void path::m_path_iterator_decrement(path::iterator & it)
+  {
+    BOOST_ASSERT(it.m_pos && "path::iterator decrement past begin()");
+
+    size_type end_pos(it.m_pos);
+
+    // if at end and there was a trailing non-root '/', return "."
+    if (it.m_pos == it.m_path_ptr->m_pathname.size()
+      && it.m_path_ptr->m_pathname.size() > 1
+      && is_separator(it.m_path_ptr->m_pathname[it.m_pos-1])
+      && is_non_root_separator(it.m_path_ptr->m_pathname, it.m_pos-1) 
+       )
+    {
+      --it.m_pos;
+      it.m_element = dot_path;
+      return;
+    }
+
+    size_type root_dir_pos(root_directory_start(it.m_path_ptr->m_pathname, end_pos));
+
+    // skip separators unless root directory
+    for (
+      ; 
+      end_pos > 0
+      && (end_pos-1) != root_dir_pos
+      && is_separator(it.m_path_ptr->m_pathname[end_pos-1])
+      ;
+      --end_pos) {}
+
+    it.m_pos = filename_pos(it.m_path_ptr->m_pathname, end_pos);
+    it.m_element = it.m_path_ptr->m_pathname.substr(it.m_pos, end_pos - it.m_pos);
+    if (it.m_element.m_pathname == preferred_separator_string)
+      it.m_element.m_pathname = separator_string;  // needed for Windows, harmless on POSIX
+  }
+
+}  // namespace filesystem
+}  // namespace boost
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                                 detail helpers                                       //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+namespace
+{
+
+  //------------------------------------------------------------------------------------//
+  //                              locale helpers                                        //
+  //------------------------------------------------------------------------------------//
+
+  // std::locale construction can throw (if LC_MESSAGES is wrong, for example),
+  // so a static at function scope is used to ensure that exceptions can be
+  // caught. (A previous version was at namespace scope, so initialization
+  // occurred before main(), preventing exceptions from being caught.)
+
+  std::locale default_locale()
+  {
+#   ifdef BOOST_WINDOWS_API
+    std::locale global_loc = std::locale();
+    std::locale loc(global_loc, new windows_file_codecvt);
+    return loc;
+
+#   elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
+    // "All BSD system functions expect their string parameters to be in UTF-8 encoding
+    // and nothing else." http://developer.apple.com/mac/library/documentation/MacOSX/Conceptual/BPInternational/Articles/FileEncodings.html
+    //
+    // "The kernel will reject any filename that is not a valid UTF-8 string, and it will
+    // even be normalized (to Unicode NFD) before stored on disk, at least when using HFS.
+    // The right way to deal with it would be to always convert the filename to UTF-8
+    // before trying to open/create a file." http://lists.apple.com/archives/unix-porting/2007/Sep/msg00023.html
+    //
+    // "How a file name looks at the API level depends on the API. Current Carbon APIs
+    // handle file names as an array of UTF-16 characters; POSIX ones handle them as an
+    // array of UTF-8, which is why UTF-8 works well in Terminal. How it's stored on disk
+    // depends on the disk format; HFS+ uses UTF-16, but that's not important in most
+    // cases." http://lists.apple.com/archives/applescript-users/2002/Sep/msg00319.html
+    //
+    // Many thanks to Peter Dimov for digging out the above references!
+    std::locale global_loc = std::locale();
+    std::locale loc(global_loc, new boost::filesystem::detail::utf8_codecvt_facet);
+    return loc;
+
+#   else
+    // ISO C calls this "the locale-specific native environment":
+    return std::locale("");
+
+#   endif
+  }
+
+  std::locale & path_locale()
+  {
+    static std::locale loc(default_locale());
+    return loc;
+  }
+
+}  // unnamed namespace
+
+//--------------------------------------------------------------------------------------//
+//                           path::imbue implementation                                 //
+//--------------------------------------------------------------------------------------//
+
+namespace boost
+{
+namespace filesystem
+{
+
+  const path::codecvt_type *&
+    path::wchar_t_codecvt_facet()
+  {
+   static const std::codecvt<wchar_t, char, std::mbstate_t> *
+     facet(
+       &std::use_facet<std::codecvt<wchar_t, char, std::mbstate_t> >
+        (path_locale()));
+   return facet;
+  }
+
+  std::locale path::imbue(const std::locale & loc)
+  {
+    std::locale temp(path_locale());
+    path_locale() = loc;
+    wchar_t_codecvt_facet() = &std::use_facet
+        <std::codecvt<wchar_t, char, std::mbstate_t> >(path_locale());
+    return temp;
+  }
+
+}  // namespace filesystem
+}  // namespace boost

v3/libs/filesystem/src/path_traits.cpp

@@ -0,0 +1,194 @@
+//  filesystem path_traits.cpp  --------------------------------------------------------//
+
+//  Copyright Beman Dawes 2008, 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+// define BOOST_FILESYSTEM_SOURCE so that <boost/system/config.hpp> knows
+// the library is being built (possibly exporting rather than importing code)
+#define BOOST_FILESYSTEM_SOURCE 
+
+#include <boost/filesystem/path_traits.hpp>
+#include <boost/filesystem/config.hpp>
+#include <boost/system/system_error.hpp>
+#include <boost/scoped_array.hpp>
+#include <locale>   // for codecvt_base::result
+#include <cstring>  // for strlen
+#include <cwchar>   // for wcslen
+
+namespace pt = boost::filesystem::path_traits;
+namespace fs = boost::filesystem;
+namespace bs = boost::system;
+
+//--------------------------------------------------------------------------------------//
+//                                  configuration                                       //
+//--------------------------------------------------------------------------------------//
+
+#ifndef BOOST_FILESYSTEM_CODECVT_BUF_SIZE
+# define BOOST_FILESYSTEM_CODECVT_BUF_SIZE 256
+#endif
+
+namespace {
+
+  const std::size_t default_codecvt_buf_size = BOOST_FILESYSTEM_CODECVT_BUF_SIZE;
+
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//  The public convert() functions do buffer management, and then forward to the        //
+//  convert_aux() functions for the actual call to the codecvt facet.                   //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+//--------------------------------------------------------------------------------------//
+//                      convert_aux const char* to wstring                             //
+//--------------------------------------------------------------------------------------//
+
+  void convert_aux(
+                   const char* from,
+                   const char* from_end,
+                   wchar_t* to, wchar_t* to_end,
+                   std::wstring & target,
+                   const pt::codecvt_type & cvt)
+  {
+    //std::cout << std::hex
+    //          << " from=" << std::size_t(from)
+    //          << " from_end=" << std::size_t(from_end)
+    //          << " to=" << std::size_t(to)
+    //          << " to_end=" << std::size_t(to_end)
+    //          << std::endl;
+
+    std::mbstate_t state  = std::mbstate_t();  // perhaps unneeded, but cuts bug reports
+    const char* from_next;
+    wchar_t* to_next;
+
+    std::codecvt_base::result res;
+
+    if ((res=cvt.in(state, from, from_end, from_next,
+           to, to_end, to_next)) != std::codecvt_base::ok)
+    {
+      //std::cout << " result is " << static_cast<int>(res) << std::endl;
+      BOOST_FILESYSTEM_THROW(bs::system_error(res, fs::codecvt_error_category(),
+        "boost::filesystem::path codecvt to wstring"));
+    }
+    target.append(to, to_next); 
+  }
+
+//--------------------------------------------------------------------------------------//
+//                      convert_aux const wchar_t* to string                           //
+//--------------------------------------------------------------------------------------//
+
+  void convert_aux(
+                   const wchar_t* from,
+                   const wchar_t* from_end,
+                   char* to, char* to_end,
+                   std::string & target,
+                   const pt::codecvt_type & cvt)
+  {
+    //std::cout << std::hex
+    //          << " from=" << std::size_t(from)
+    //          << " from_end=" << std::size_t(from_end)
+    //          << " to=" << std::size_t(to)
+    //          << " to_end=" << std::size_t(to_end)
+    //          << std::endl;
+
+    std::mbstate_t state  = std::mbstate_t();  // perhaps unneeded, but cuts bug reports
+    const wchar_t* from_next;
+    char* to_next;
+
+    std::codecvt_base::result res;
+
+    if ((res=cvt.out(state, from, from_end, from_next,
+           to, to_end, to_next)) != std::codecvt_base::ok)
+    {
+      //std::cout << " result is " << static_cast<int>(res) << std::endl;
+      BOOST_FILESYSTEM_THROW(bs::system_error(res, fs::codecvt_error_category(),
+        "boost::filesystem::path codecvt to string"));
+    }
+    target.append(to, to_next); 
+  }
+  
+}  // unnamed namespace
+
+//--------------------------------------------------------------------------------------//
+//                                   path_traits                                        //
+//--------------------------------------------------------------------------------------//
+
+namespace boost { namespace filesystem { namespace path_traits {
+
+//--------------------------------------------------------------------------------------//
+//                          convert const char* to wstring                             //
+//--------------------------------------------------------------------------------------//
+
+  BOOST_FILESYSTEM_DECL
+  void convert(const char* from,
+                const char* from_end,    // 0 for null terminated MBCS
+                std::wstring & to,
+                const codecvt_type & cvt)
+  {
+    BOOST_ASSERT(from);
+
+    if (!from_end)  // null terminated
+    {
+      from_end = from + std::strlen(from);
+    }
+
+    if (from == from_end) return;
+
+    std::size_t buf_size = (from_end - from) * 3;  // perhaps too large, but that's OK
+
+    //  dynamically allocate a buffer only if source is unusually large
+    if (buf_size > default_codecvt_buf_size)
+    {
+      boost::scoped_array< wchar_t > buf(new wchar_t [buf_size]);
+      convert_aux(from, from_end, buf.get(), buf.get()+buf_size, to, cvt);
+    }
+    else
+    {
+      wchar_t buf[default_codecvt_buf_size];
+      convert_aux(from, from_end, buf, buf+default_codecvt_buf_size, to, cvt);
+    }
+  }
+
+//--------------------------------------------------------------------------------------//
+//                         convert const wchar_t* to string                            //
+//--------------------------------------------------------------------------------------//
+
+  BOOST_FILESYSTEM_DECL
+  void convert(const wchar_t* from,
+                const wchar_t* from_end,  // 0 for null terminated MBCS
+                std::string & to,
+                const codecvt_type & cvt)
+  {
+    BOOST_ASSERT(from);
+
+    if (!from_end)  // null terminated
+    {
+      from_end = from + std::wcslen(from);
+    }
+
+    if (from == from_end) return;
+
+    //  The codecvt length functions may not be implemented, and I don't really
+    //  understand them either. Thus this code is just a guess; if it turns
+    //  out the buffer is too small then an error will be reported and the code
+    //  will have to be fixed.
+    std::size_t buf_size = (from_end - from) * 4;  // perhaps too large, but that's OK
+    buf_size += 4;  // encodings like shift-JIS need some prefix space
+
+    //  dynamically allocate a buffer only if source is unusually large
+    if (buf_size > default_codecvt_buf_size)
+    {
+      boost::scoped_array< char > buf(new char [buf_size]);
+      convert_aux(from, from_end, buf.get(), buf.get()+buf_size, to, cvt);
+    }
+    else
+    {
+      char buf[default_codecvt_buf_size];
+      convert_aux(from, from_end, buf, buf+default_codecvt_buf_size, to, cvt);
+    }
+  }
+}}} // namespace boost::filesystem::path_traits

v3/libs/filesystem/src/portability.cpp

@@ -0,0 +1,115 @@
+//  portability.cpp  -------------------------------------------------------------------//
+
+//  Copyright 2002-2005 Beman Dawes
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy
+//  at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/filesystem
+
+//--------------------------------------------------------------------------------------// 
+
+// define BOOST_FILESYSTEM_SOURCE so that <boost/filesystem/config.hpp> knows
+// the library is being built (possibly exporting rather than importing code)
+#define BOOST_FILESYSTEM_SOURCE 
+
+#include <boost/filesystem/config.hpp>
+#include <boost/filesystem/path.hpp>
+
+namespace fs = boost::filesystem;
+
+#include <cstring> // SGI MIPSpro compilers need this
+
+# ifdef BOOST_NO_STDC_NAMESPACE
+    namespace std { using ::strerror; }
+# endif
+
+//--------------------------------------------------------------------------------------//
+
+namespace
+{
+  const char invalid_chars[] =
+    "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
+    "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F"
+    "<>:\"/\\|";
+  // note that the terminating '\0' is part of the string - thus the size below
+  // is sizeof(invalid_chars) rather than sizeof(invalid_chars)-1.  I 
+  const std::string windows_invalid_chars(invalid_chars, sizeof(invalid_chars));
+
+  const std::string valid_posix(
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-");
+
+} // unnamed namespace
+
+namespace boost
+{
+  namespace filesystem
+  {
+
+    //  name_check functions  ----------------------------------------------//
+
+#   ifdef BOOST_WINDOWS
+    BOOST_FILESYSTEM_DECL bool native(const std::string & name)
+    {
+      return windows_name(name);
+    }
+#   else
+    BOOST_FILESYSTEM_DECL bool native(const std::string & name)
+    {
+      return  name.size() != 0
+        && name[0] != ' '
+        && name.find('/') == std::string::npos;
+    }
+#   endif
+
+    BOOST_FILESYSTEM_DECL bool portable_posix_name(const std::string & name)
+    {
+      return name.size() != 0
+        && name.find_first_not_of(valid_posix) == std::string::npos;     
+    }
+
+    BOOST_FILESYSTEM_DECL bool windows_name(const std::string & name)
+    {
+      return name.size() != 0
+        && name[0] != ' '
+        && name.find_first_of(windows_invalid_chars) == std::string::npos
+        && *(name.end()-1) != ' '
+        && (*(name.end()-1) != '.'
+          || name.length() == 1 || name == "..");
+    }
+
+    BOOST_FILESYSTEM_DECL bool portable_name(const std::string & name)
+    {
+      return
+        name.size() != 0
+        && (name == "."
+          || name == ".."
+          || (windows_name(name)
+            && portable_posix_name(name)
+            && name[0] != '.' && name[0] != '-'));
+    }
+
+    BOOST_FILESYSTEM_DECL bool portable_directory_name(const std::string & name)
+    {
+      return
+        name == "."
+        || name == ".."
+        || (portable_name(name)
+          && name.find('.') == std::string::npos);
+    }
+
+    BOOST_FILESYSTEM_DECL bool portable_file_name(const std::string & name)
+    {
+      std::string::size_type pos;
+      return
+         portable_name(name)
+         && name != "."
+         && name != ".."
+         && ((pos = name.find('.')) == std::string::npos
+             || (name.find('.', pos+1) == std::string::npos
+               && (pos + 5) > name.length()))
+        ;
+    }
+
+  } // namespace filesystem
+} // namespace boost

v3/libs/filesystem/src/unique_path.cpp

@@ -0,0 +1,138 @@
+//  filesystem system_crypt_random.cpp  ------------------------------------------------//
+
+//  Copyright Beman Dawes 2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+//--------------------------------------------------------------------------------------// 
+
+// define BOOST_FILESYSTEM_SOURCE so that <boost/filesystem/config.hpp> knows
+// the library is being built (possibly exporting rather than importing code)
+#define BOOST_FILESYSTEM_SOURCE 
+
+#include <boost/filesystem/operations.hpp>
+
+# ifdef BOOST_POSIX_API
+#   include <fcntl.h>
+# else // BOOST_WINDOWS_API
+#   include <windows.h>
+#   include <wincrypt.h>
+#   pragma comment(lib, "Advapi32.lib")
+# endif
+
+namespace {
+
+void fail(int err, boost::system::error_code* ec)
+{
+  if (ec == 0)
+    BOOST_FILESYSTEM_THROW( boost::system::system_error(err,
+      boost::system::system_category(),
+      "boost::filesystem::unique_path"));
+
+  ec->assign(err, boost::system::system_category());
+  return;
+}
+
+void system_crypt_random(void* buf, std::size_t len, boost::system::error_code* ec)
+{
+# ifdef BOOST_POSIX_API
+
+  int file = open("/dev/urandom", O_RDONLY);
+  if (file == -1)
+  {
+    file = open("/dev/random", O_RDONLY);
+    if (file == -1)
+    {
+      fail(errno, ec);
+      return;
+    }
+  }
+
+  size_t bytes_read = 0;
+  while (bytes_read < len)
+  {
+    ssize_t n = read(file, buf, len - bytes_read);
+    if (n == -1)
+    {
+      close(file);
+      fail(errno, ec);
+      return;
+    }
+    bytes_read += n;
+    buf = static_cast<char*>(buf) + n;
+  }
+
+  close(file);
+
+# else // BOOST_WINDOWS_API
+
+  HCRYPTPROV handle;
+  int errval = 0;
+
+  if (!::CryptAcquireContextW(&handle, 0, 0, PROV_RSA_FULL, 0))
+  {
+    errval = ::GetLastError();
+    if (errval == NTE_BAD_KEYSET)
+    {
+      if (!::CryptAcquireContextW(&handle, 0, 0, PROV_RSA_FULL, CRYPT_NEWKEYSET))
+      {
+        errval = ::GetLastError();
+      }
+      else errval = 0;
+    }
+  }
+
+  if (!errval)
+  {
+    BOOL gen_ok = ::CryptGenRandom(handle, len, static_cast<unsigned char*>(buf));
+    if (!gen_ok)
+      errval = ::GetLastError();
+    ::CryptReleaseContext(handle, 0);
+  }
+
+  if (!errval) return;
+
+  fail(errval, ec);
+# endif
+}
+
+}  // unnamed namespace
+
+namespace boost { namespace filesystem { namespace detail {
+
+BOOST_FILESYSTEM_DECL
+path unique_path(const path& model, system::error_code* ec)
+{
+  std::wstring s (model.wstring());  // std::string ng for MBCS encoded POSIX
+  const wchar_t hex[] = L"0123456789abcdef";
+  const int n_ran = 16;
+  const int max_nibbles = 2 * n_ran;   // 4-bits per nibble
+  char ran[n_ran];
+
+  int nibbles_used = max_nibbles;
+  for(std::wstring::size_type i=0; i < s.size(); ++i)
+  {
+    if (s[i] == L'%')                        // digit request
+    {
+      if (nibbles_used == max_nibbles)
+      {
+        system_crypt_random(ran, sizeof(ran), ec);
+        if (ec != 0 && *ec)
+          return "";
+        nibbles_used = 0;
+      }
+      int c = ran[nibbles_used/2];
+      c >>= 4 * (nibbles_used++ & 1);  // if odd, shift right 1 nibble
+      s[i] = hex[c & 0xf];             // convert to hex digit and replace
+    }
+  }
+
+  if (ec != 0) ec->clear();
+
+  return s;
+}
+
+}}}

v3/libs/filesystem/src/utf8_codecvt_facet.cpp

@@ -0,0 +1,20 @@
+// Copyright Vladimir Prus 2004.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_FILESYSTEM_SOURCE
+#include <boost/filesystem/config.hpp>
+
+#define BOOST_UTF8_BEGIN_NAMESPACE \
+     namespace boost { namespace filesystem { namespace detail {
+
+#define BOOST_UTF8_END_NAMESPACE }}}
+#define BOOST_UTF8_DECL BOOST_FILESYSTEM_DECL
+
+#include "libs/detail/utf8_codecvt_facet.cpp"
+
+
+#undef BOOST_UTF8_BEGIN_NAMESPACE
+#undef BOOST_UTF8_END_NAMESPACE
+#undef BOOST_UTF8_DECL

v3/libs/filesystem/src/utf8_codecvt_facet.hpp

@@ -0,0 +1,24 @@
+// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
+// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_FILESYSTEM_UTF8_CODECVT_FACET_HPP
+#define BOOST_FILESYSTEM_UTF8_CODECVT_FACET_HPP
+
+#include <boost/filesystem/config.hpp>
+
+#define BOOST_UTF8_BEGIN_NAMESPACE \
+     namespace boost { namespace filesystem { namespace detail {
+
+#define BOOST_UTF8_END_NAMESPACE }}}
+#define BOOST_UTF8_DECL BOOST_FILESYSTEM_DECL
+
+#include <boost/detail/utf8_codecvt_facet.hpp>
+
+#undef BOOST_UTF8_BEGIN_NAMESPACE
+#undef BOOST_UTF8_END_NAMESPACE
+#undef BOOST_UTF8_DECL
+
+#endif

v3/libs/filesystem/src/windows_file_codecvt.cpp

@@ -0,0 +1,63 @@
+//  filesystem windows_file_codecvt.cpp  -----------------------------------------//
+
+//  Copyright Beman Dawes 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+// define BOOST_FILESYSTEM_SOURCE so that <boost/system/config.hpp> knows
+// the library is being built (possibly exporting rather than importing code)
+#define BOOST_FILESYSTEM_SOURCE 
+
+#include <boost/filesystem/config.hpp>
+
+#ifdef BOOST_WINDOWS_API
+
+#include "windows_file_codecvt.hpp"
+
+#define WINVER 0x0500  // MinGW for GCC 4.4 requires this
+#include <windows.h>
+
+  std::codecvt_base::result windows_file_codecvt::do_in(
+    std::mbstate_t &, 
+    const char* from, const char* from_end, const char*& from_next,
+    wchar_t* to, wchar_t* to_end, wchar_t*& to_next) const
+  {
+    UINT codepage = AreFileApisANSI() ? CP_THREAD_ACP : CP_OEMCP;
+
+    int count;
+    if ((count = ::MultiByteToWideChar(codepage, MB_PRECOMPOSED, from,
+      from_end - from, to, to_end - to)) == 0) 
+    {
+      return error;  // conversion failed
+    }
+
+    from_next = from_end;
+    to_next = to + count;
+    *to_next = L'\0';
+    return ok;
+ }
+
+  std::codecvt_base::result windows_file_codecvt::do_out(
+    std::mbstate_t &,
+    const wchar_t* from, const wchar_t* from_end, const wchar_t*  & from_next,
+    char* to, char* to_end, char* & to_next) const
+  {
+    UINT codepage = AreFileApisANSI() ? CP_THREAD_ACP : CP_OEMCP;
+
+    int count;
+    if ((count = ::WideCharToMultiByte(codepage, WC_NO_BEST_FIT_CHARS, from,
+      from_end - from, to, to_end - to, 0, 0)) == 0)
+    {
+      return error;  // conversion failed
+    }
+
+    from_next = from_end;
+    to_next = to + count;
+    *to_next = '\0';
+    return ok;
+  }
+
+  # endif  // BOOST_WINDOWS_API

v3/libs/filesystem/src/windows_file_codecvt.hpp

@@ -0,0 +1,55 @@
+//  filesystem windows_file_codecvt.hpp  -----------------------------------------------//
+
+//  Copyright Beman Dawes 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+#ifndef BOOST_FILESYSTEM_WIN_FILE_CODECVT_HPP
+#define BOOST_FILESYSTEM_WIN_FILE_CODECVT_HPP
+
+#include <locale>  
+
+  //------------------------------------------------------------------------------------//
+  //                                                                                    //
+  //                          class windows_file_codecvt                                //
+  //                                                                                    //
+  //  Warning: partial implementation; even do_in and do_out only partially meet the    //
+  //  standard library specifications as the "to" buffer must hold the entire result.   //
+  //                                                                                    //
+  //------------------------------------------------------------------------------------//
+
+  class BOOST_FILESYSTEM_DECL windows_file_codecvt
+    : public std::codecvt< wchar_t, char, std::mbstate_t >  
+  {
+  public:
+    explicit windows_file_codecvt()
+        : std::codecvt<wchar_t, char, std::mbstate_t>() {}
+  protected:
+
+    virtual bool do_always_noconv() const throw() { return false; }
+
+    //  seems safest to assume variable number of characters since we don't
+    //  actually know what codepage is active
+    virtual int do_encoding() const throw() { return 0; }
+
+    virtual std::codecvt_base::result do_in(std::mbstate_t& state, 
+      const char* from, const char* from_end, const char*& from_next,
+      wchar_t* to, wchar_t* to_end, wchar_t*& to_next) const;
+
+    virtual std::codecvt_base::result do_out(std::mbstate_t & state,
+      const wchar_t* from, const wchar_t* from_end, const wchar_t*& from_next,
+      char* to, char* to_end, char*& to_next) const;
+
+    virtual std::codecvt_base::result do_unshift(std::mbstate_t&,
+        char* /*from*/, char* /*to*/, char* & /*next*/) const  { return ok; } 
+
+    virtual int do_length(std::mbstate_t&,
+      const char* /*from*/, const char* /*from_end*/, std::size_t /*max*/) const  { return 0; }
+
+    virtual int do_max_length() const throw () { return 0; }
+  };
+
+#endif  // BOOST_FILESYSTEM_WIN_FILE_CODECVT_HPP

v3/libs/filesystem/test/Jamfile.v2

@@ -0,0 +1,34 @@
+# Boost Filesystem Library test Jamfile
+
+# (C) Copyright Beman Dawes 2002-2006
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or www.boost.org/LICENSE_1_0.txt)
+
+project 
+    : requirements
+      <library>/boost/filesystem//boost_filesystem
+      <library>/boost/system//boost_system
+      <toolset>msvc:<asynch-exceptions>on
+    ;
+    
+# Some tests are run both statically and as shared libraries since it is helpful
+# to know if failures in shared library tests are related to sharing or not.
+
+   test-suite "filesystem" :
+       [ run path_unit_test.cpp :  :  : <link>shared ]                  
+       [ run path_unit_test.cpp :  :  : <link>static : path_unit_test_static ]                  
+       [ run path_test.cpp :  :  : <link>shared ]                  
+       [ run path_test.cpp :  :  : <link>static : path_test_static ]                  
+       [ run operations_unit_test.cpp :  :  : <link>shared ]
+       [ run operations_unit_test.cpp :  :  : <link>static : operations_unit_test_static ]
+       [ run operations_test.cpp :  :  : <link>shared ]
+       [ run operations_test.cpp :  :  : <link>static : operations_test_static ]
+       [ run fstream_test.cpp ]
+       [ run convenience_test.cpp ]
+       [ run large_file_support_test.cpp ]
+       [ run deprecated_test.cpp ]                  
+       [ run ../example/simple_ls.cpp ]
+ 
+#       [ compile ../example/mbcopy.cpp ]
+#       [ compile ../example/mbpath.cpp ]
+       ;

v3/libs/filesystem/test/convenience_test.cpp

@@ -0,0 +1,159 @@
+//  libs/filesystem/test/convenience_test.cpp  -----------------------------------------//
+
+//  Copyright Beman Dawes, 2002
+//  Copyright Vladimir Prus, 2002
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/filesystem
+
+#include <boost/config/warning_disable.hpp>
+
+//  See deprecated_test for tests of deprecated features
+#define BOOST_FILESYSTEM_NO_DEPRECATED
+
+#include <boost/filesystem/convenience.hpp>
+namespace fs = boost::filesystem;
+using fs::path;
+namespace sys = boost::system;
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/bind.hpp>
+#include <fstream>
+#include <iostream>
+
+namespace
+{
+  template< typename F >
+    bool throws_fs_error(F func)
+  {
+    try { func(); }
+
+    catch (const fs::filesystem_error &)
+    {
+      return true;
+    }
+    return false;
+  }
+
+    void create_recursive_iterator(const fs::path & ph)
+    {
+      fs::recursive_directory_iterator it(ph);
+    }
+}
+
+//  ------------------------------------------------------------------------------------//
+
+int main(int, char*[])
+{
+
+//  create_directories() tests  --------------------------------------------------------//
+
+  BOOST_TEST(!fs::create_directories(""));  // should be harmless
+  BOOST_TEST(!fs::create_directories("/")); // ditto
+
+  fs::remove_all("xx");  // make sure slate is blank
+  BOOST_TEST(!fs::exists("xx")); // reality check
+
+  BOOST_TEST(fs::create_directories("xx"));
+  BOOST_TEST(fs::exists("xx"));
+  BOOST_TEST(fs::is_directory("xx"));
+
+  BOOST_TEST(fs::create_directories("xx/yy/zz"));
+  BOOST_TEST(fs::exists("xx"));
+  BOOST_TEST(fs::exists("xx/yy"));
+  BOOST_TEST(fs::exists("xx/yy/zz"));
+  BOOST_TEST(fs::is_directory("xx"));
+  BOOST_TEST(fs::is_directory("xx/yy"));
+  BOOST_TEST(fs::is_directory("xx/yy/zz"));
+
+  path is_a_file("xx/uu");
+  {
+    std::ofstream f(is_a_file.string().c_str());
+    BOOST_TEST(!!f);
+  }
+  BOOST_TEST(throws_fs_error(
+    boost::bind(fs::create_directories, is_a_file)));
+  BOOST_TEST(throws_fs_error(
+    boost::bind(fs::create_directories, is_a_file / "aa")));
+
+// recursive_directory_iterator tests ----------------------------------------//
+
+  sys::error_code ec;
+  fs::recursive_directory_iterator it("/no-such-path", ec);
+  BOOST_TEST(ec);
+
+  BOOST_TEST(throws_fs_error(
+    boost::bind(create_recursive_iterator, "/no-such-path")));
+
+  fs::remove("xx/uu");
+
+#ifdef BOOST_WINDOWS_API
+  // These tests depends on ordering of directory entries, and that's guaranteed
+  // on Windows but not necessarily on other operating systems
+  {
+    std::ofstream f("xx/yya");
+    BOOST_TEST(!!f);
+  }
+
+  for (it = fs::recursive_directory_iterator("xx");
+        it != fs::recursive_directory_iterator(); ++it)
+    { std::cout << it->path() << '\n'; }
+
+  it = fs::recursive_directory_iterator("xx");
+  BOOST_TEST(it->path() == "xx/yy");
+  BOOST_TEST(it.level() == 0);
+  ++it;
+  BOOST_TEST(it->path() == "xx/yy/zz");
+  BOOST_TEST(it.level() == 1);
+  it.pop();
+  BOOST_TEST(it->path() == "xx/yya");
+  BOOST_TEST(it.level() == 0);
+  it++;
+  BOOST_TEST(it == fs::recursive_directory_iterator());
+
+  it = fs::recursive_directory_iterator("xx");
+  BOOST_TEST(it->path() == "xx/yy");
+  it.no_push();
+  ++it;
+  BOOST_TEST(it->path() == "xx/yya");
+  ++it;
+  BOOST_TEST(it == fs::recursive_directory_iterator());
+
+  fs::remove("xx/yya");
+#endif
+
+  it = fs::recursive_directory_iterator("xx/yy/zz");
+  BOOST_TEST(it == fs::recursive_directory_iterator());
+  
+  it = fs::recursive_directory_iterator("xx");
+  BOOST_TEST(it->path() == "xx/yy");
+  BOOST_TEST(it.level() == 0);
+  ++it;
+  BOOST_TEST(it->path() == "xx/yy/zz");
+  BOOST_TEST(it.level() == 1);
+  it++;
+  BOOST_TEST(it == fs::recursive_directory_iterator());
+
+  it = fs::recursive_directory_iterator("xx");
+  BOOST_TEST(it->path() == "xx/yy");
+  it.no_push();
+  ++it;
+  BOOST_TEST(it == fs::recursive_directory_iterator());
+
+  it = fs::recursive_directory_iterator("xx");
+  BOOST_TEST(it->path() == "xx/yy");
+  ++it;
+  it.pop();
+  BOOST_TEST(it == fs::recursive_directory_iterator());
+
+  ec.clear();
+  BOOST_TEST(!ec);
+  // check that two argument failed constructor creates the end iterator 
+  BOOST_TEST(fs::recursive_directory_iterator("nosuchdir", ec)
+    == fs::recursive_directory_iterator());
+  BOOST_TEST(ec);
+
+  return ::boost::report_errors();
+}

v3/libs/filesystem/test/deprecated_test.cpp

@@ -0,0 +1,240 @@
+//  deprecated_test program --------------------------------------------------//
+
+//  Copyright Beman Dawes 2002
+//  Copyright Vladimir Prus 2002
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+//  This test verifies that various deprecated names still work. This is
+//  important to preserve existing code that uses the old names.
+
+#define BOOST_FILESYSTEM_DEPRECATED
+
+#include <boost/filesystem.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+namespace fs = boost::filesystem;
+using boost::filesystem::path;
+
+#define PATH_CHECK(a, b) check(a, b, __LINE__)
+
+namespace
+{
+  std::string platform(BOOST_PLATFORM);
+
+  void check(const fs::path & source,
+              const std::string & expected, int line)
+  {
+    if (source.generic_string()== expected) return;
+
+    ++::boost::detail::test_errors();
+
+    std::cout << '(' << line << ") source.string(): \"" << source.string()
+              << "\" != expected: \"" << expected
+              << "\"" << std::endl;
+  }
+
+  void normalize_test()
+  {
+    PATH_CHECK(path("").normalize(), "");
+    PATH_CHECK(path("/").normalize(), "/");
+    PATH_CHECK(path("//").normalize(), "//");
+    PATH_CHECK(path("///").normalize(), "/");
+    PATH_CHECK(path("f").normalize(), "f");
+    PATH_CHECK(path("foo").normalize(), "foo");
+    PATH_CHECK(path("foo/").normalize(), "foo/.");
+    PATH_CHECK(path("f/").normalize(), "f/.");
+    PATH_CHECK(path("/foo").normalize(), "/foo");
+    PATH_CHECK(path("foo/bar").normalize(), "foo/bar");
+    PATH_CHECK(path("..").normalize(), "..");
+    PATH_CHECK(path("../..").normalize(), "../..");
+    PATH_CHECK(path("/..").normalize(), "/..");
+    PATH_CHECK(path("/../..").normalize(), "/../..");
+    PATH_CHECK(path("../foo").normalize(), "../foo");
+    PATH_CHECK(path("foo/..").normalize(), ".");
+    PATH_CHECK(path("foo/../").normalize(), "./.");
+    PATH_CHECK((path("foo") / "..").normalize() , ".");
+    PATH_CHECK(path("foo/...").normalize(), "foo/...");
+    PATH_CHECK(path("foo/.../").normalize(), "foo/.../.");
+    PATH_CHECK(path("foo/..bar").normalize(), "foo/..bar");
+    PATH_CHECK(path("../f").normalize(), "../f");
+    PATH_CHECK(path("/../f").normalize(), "/../f");
+    PATH_CHECK(path("f/..").normalize(), ".");
+    PATH_CHECK((path("f") / "..").normalize() , ".");
+    PATH_CHECK(path("foo/../..").normalize(), "..");
+    PATH_CHECK(path("foo/../../").normalize(), "../.");
+    PATH_CHECK(path("foo/../../..").normalize(), "../..");
+    PATH_CHECK(path("foo/../../../").normalize(), "../../.");
+    PATH_CHECK(path("foo/../bar").normalize(), "bar");
+    PATH_CHECK(path("foo/../bar/").normalize(), "bar/.");
+    PATH_CHECK(path("foo/bar/..").normalize(), "foo");
+    PATH_CHECK(path("foo/bar/../").normalize(), "foo/.");
+    PATH_CHECK(path("foo/bar/../..").normalize(), ".");
+    PATH_CHECK(path("foo/bar/../../").normalize(), "./.");
+    PATH_CHECK(path("foo/bar/../blah").normalize(), "foo/blah");
+    PATH_CHECK(path("f/../b").normalize(), "b");
+    PATH_CHECK(path("f/b/..").normalize(), "f");
+    PATH_CHECK(path("f/b/../").normalize(), "f/.");
+    PATH_CHECK(path("f/b/../a").normalize(), "f/a");
+    PATH_CHECK(path("foo/bar/blah/../..").normalize(), "foo");
+    PATH_CHECK(path("foo/bar/blah/../../bletch").normalize(), "foo/bletch");
+    PATH_CHECK(path("//net").normalize(), "//net");
+    PATH_CHECK(path("//net/").normalize(), "//net/");
+    PATH_CHECK(path("//..net").normalize(), "//..net");
+    PATH_CHECK(path("//net/..").normalize(), "//net/..");
+    PATH_CHECK(path("//net/foo").normalize(), "//net/foo");
+    PATH_CHECK(path("//net/foo/").normalize(), "//net/foo/.");
+    PATH_CHECK(path("//net/foo/..").normalize(), "//net/");
+    PATH_CHECK(path("//net/foo/../").normalize(), "//net/.");
+
+    PATH_CHECK(path("/net/foo/bar").normalize(), "/net/foo/bar");
+    PATH_CHECK(path("/net/foo/bar/").normalize(), "/net/foo/bar/.");
+    PATH_CHECK(path("/net/foo/..").normalize(), "/net");
+    PATH_CHECK(path("/net/foo/../").normalize(), "/net/.");
+
+    PATH_CHECK(path("//net//foo//bar").normalize(), "//net/foo/bar");
+    PATH_CHECK(path("//net//foo//bar//").normalize(), "//net/foo/bar/.");
+    PATH_CHECK(path("//net//foo//..").normalize(), "//net/");
+    PATH_CHECK(path("//net//foo//..//").normalize(), "//net/.");
+
+    PATH_CHECK(path("///net///foo///bar").normalize(), "/net/foo/bar");
+    PATH_CHECK(path("///net///foo///bar///").normalize(), "/net/foo/bar/.");
+    PATH_CHECK(path("///net///foo///..").normalize(), "/net");
+    PATH_CHECK(path("///net///foo///..///").normalize(), "/net/.");
+
+    if (platform == "Windows")
+    {
+      PATH_CHECK(path("c:..").normalize(), "c:..");
+      PATH_CHECK(path("c:foo/..").normalize(), "c:");
+
+      PATH_CHECK(path("c:foo/../").normalize(), "c:.");
+
+      PATH_CHECK(path("c:/foo/..").normalize(), "c:/");
+      PATH_CHECK(path("c:/foo/../").normalize(), "c:/.");
+      PATH_CHECK(path("c:/..").normalize(), "c:/..");
+      PATH_CHECK(path("c:/../").normalize(), "c:/../.");
+      PATH_CHECK(path("c:/../..").normalize(), "c:/../..");
+      PATH_CHECK(path("c:/../../").normalize(), "c:/../../.");
+      PATH_CHECK(path("c:/../foo").normalize(), "c:/../foo");
+      PATH_CHECK(path("c:/../foo/").normalize(), "c:/../foo/.");
+      PATH_CHECK(path("c:/../../foo").normalize(), "c:/../../foo");
+      PATH_CHECK(path("c:/../../foo/").normalize(), "c:/../../foo/.");
+      PATH_CHECK(path("c:/..foo").normalize(), "c:/..foo");
+    }
+    else // POSIX
+    {
+      PATH_CHECK(path("c:..").normalize(), "c:..");
+      PATH_CHECK(path("c:foo/..").normalize(), ".");
+      PATH_CHECK(path("c:foo/../").normalize(), "./.");
+      PATH_CHECK(path("c:/foo/..").normalize(), "c:");
+      PATH_CHECK(path("c:/foo/../").normalize(), "c:/.");
+      PATH_CHECK(path("c:/..").normalize(), ".");
+      PATH_CHECK(path("c:/../").normalize(), "./.");
+      PATH_CHECK(path("c:/../..").normalize(), "..");
+      PATH_CHECK(path("c:/../../").normalize(), "../.");
+      PATH_CHECK(path("c:/../foo").normalize(), "foo");
+      PATH_CHECK(path("c:/../foo/").normalize(), "foo/.");
+      PATH_CHECK(path("c:/../../foo").normalize(), "../foo");
+      PATH_CHECK(path("c:/../../foo/").normalize(), "../foo/.");
+      PATH_CHECK(path("c:/..foo").normalize(), "c:/..foo");
+    }
+  }
+
+  //  Compile-only tests not intended to be executed -----------------------------------//
+
+  void compile_only()
+  {
+    fs::path p;
+
+    fs::initial_path<fs::path>();
+    fs::initial_path<fs::wpath>();
+
+    p.file_string();
+    p.directory_string();
+  }
+
+  //  path_rename_test -----------------------------------------------------------------//
+
+  void path_rename_test()
+  {
+    fs::path p("foo/bar/blah");
+
+    BOOST_TEST_EQ(path("foo/bar/blah").remove_leaf(), "foo/bar");
+    BOOST_TEST_EQ(p.leaf(), "blah");
+    BOOST_TEST_EQ(p.branch_path(), "foo/bar");
+    BOOST_TEST(p.has_leaf());
+    BOOST_TEST(p.has_branch_path());
+    BOOST_TEST(!p.is_complete());
+
+    if (platform == "Windows")
+    {
+      BOOST_TEST_EQ(path("foo\\bar\\blah").remove_leaf(), "foo\\bar");
+      p = "foo\\bar\\blah";
+      BOOST_TEST_EQ(p.branch_path(), "foo\\bar");
+    }
+  }
+
+} // unnamed namespace
+
+
+//--------------------------------------------------------------------------------------//
+
+int main(int /*argc*/, char* /*argv*/[])
+{
+  // The choice of platform is make at runtime rather than compile-time
+  // so that compile errors for all platforms will be detected even though
+  // only the current platform is runtime tested.
+  platform = (platform == "Win32" || platform == "Win64" || platform == "Cygwin")
+               ? "Windows"
+               : "POSIX";
+  std::cout << "Platform is " << platform << '\n';
+
+  //path::default_name_check(fs::no_check);
+
+  fs::directory_entry de("foo/bar");
+
+  de.replace_leaf("", fs::file_status(), fs::file_status());
+
+  //de.leaf();
+  //de.string();
+
+  fs::path ng(" no-way, Jose");
+  BOOST_TEST(!fs::is_regular(ng));  // verify deprecated name still works
+  BOOST_TEST(!fs::symbolic_link_exists("nosuchfileordirectory"));
+
+  path_rename_test();
+  normalize_test();
+ 
+// extension() tests ---------------------------------------------------------//
+
+  BOOST_TEST(fs::extension("a/b") == "");
+  BOOST_TEST(fs::extension("a/b.txt") == ".txt");
+  BOOST_TEST(fs::extension("a/b.") == ".");
+  BOOST_TEST(fs::extension("a.b.c") == ".c");
+  BOOST_TEST(fs::extension("a.b.c.") == ".");
+  BOOST_TEST(fs::extension("") == "");
+  BOOST_TEST(fs::extension("a/") == "");
+  
+// basename() tests ----------------------------------------------------------//
+
+  BOOST_TEST(fs::basename("b") == "b");
+  BOOST_TEST(fs::basename("a/b.txt") == "b");
+  BOOST_TEST(fs::basename("a/b.") == "b"); 
+  BOOST_TEST(fs::basename("a.b.c") == "a.b");
+  BOOST_TEST(fs::basename("a.b.c.") == "a.b.c");
+  BOOST_TEST(fs::basename("") == "");
+  
+// change_extension tests ---------------------------------------------------//
+
+  BOOST_TEST(fs::change_extension("a.txt", ".tex").string() == "a.tex");
+  BOOST_TEST(fs::change_extension("a.", ".tex").string() == "a.tex");
+  BOOST_TEST(fs::change_extension("a", ".txt").string() == "a.txt");
+  BOOST_TEST(fs::change_extension("a.b.txt", ".tex").string() == "a.b.tex");  
+  // see the rationale in html docs for explanation why this works
+  BOOST_TEST(fs::change_extension("", ".png").string() == ".png");
+
+  return ::boost::report_errors();
+}

v3/libs/filesystem/test/design_use_cases.cpp

@@ -0,0 +1,81 @@
+#include <string>
+#include <iostream>
+
+//  Minimal class path
+
+class path
+{
+public:
+  path( const char * )
+  {
+    std::cout << "path( const char * )\n";
+  }
+  path( const std::string & )
+  {
+    std::cout << "path( std::string & )\n";
+  }
+
+//  for maximum efficiency, either signature must work
+# ifdef BY_VALUE
+  operator const std::string() const
+# else
+  operator const std::string&() const
+# endif
+  {
+    std::cout << "operator string\n";
+    return m_path;
+  }
+
+#ifdef NAMED_CONVERSION
+  std::string string() const
+  {
+    std::cout << "std::string string() const\n";
+    return m_path;
+  }
+#endif
+
+private:
+  std::string m_path;
+};
+
+bool operator==( const path &, const path & )
+{
+  std::cout << "operator==( const path &, const path & )\n";
+  return true;
+}
+
+//  These are the critical use cases. If any of these don't compile, usability
+//  is unacceptably degraded.
+
+void f( const path & )
+{
+  std::cout << "f( const path & )\n";
+}
+
+int main()
+{
+  f( "foo" );
+  f( std::string( "foo" ) );
+  f( path( "foo" ) );
+
+  std::cout << '\n';
+
+  std::string s1( path( "foo" ) );
+  std::string s2 = path( "foo" );
+  s2 = path( "foo" );
+
+#ifdef NAMED_CONVERSION
+  s2 = path( "foo" ).string();
+#endif
+
+  std::cout << '\n';
+
+  // these must call bool path( const path &, const path & );
+  path( "foo" ) == path( "foo" );
+  path( "foo" ) == "foo";
+  path( "foo" ) == std::string( "foo" );
+  "foo" == path( "foo" );
+  std::string( "foo" ) == path( "foo" );
+
+  return 0;
+}

v3/libs/filesystem/test/equivalent.cpp

@@ -0,0 +1,39 @@
+//  equivalent program -------------------------------------------------------//
+
+//  Copyright (c) 2004 Beman Dawes
+
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy
+//  at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/filesystem
+
+//----------------------------------------------------------------------------//
+
+#include <boost/filesystem/operations.hpp>
+#include <iostream>
+#include <exception>
+
+int main( int argc, char * argv[] )
+{
+  boost::filesystem::path::default_name_check( boost::filesystem::native );
+  if ( argc != 3 )
+  {
+    std::cout << "Usage: equivalent path1 path2\n";
+    return 2;
+  }
+  
+  bool eq;
+  try
+  {
+    eq = boost::filesystem::equivalent( argv[1], argv[2] );
+  }
+  catch ( const std::exception & ex )
+  {
+    std::cout << ex.what() << "\n";
+    return 3;
+  }
+
+  std::cout << (eq ? "Paths are equivalent\n" : "Paths are not equivalent\n");
+  return !eq;
+}

v3/libs/filesystem/test/fstream_test.cpp

@@ -0,0 +1,160 @@
+//  fstream_test.cpp  ------------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2002
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+#include <boost/config/warning_disable.hpp>
+
+//  See deprecated_test for tests of deprecated features
+#define BOOST_FILESYSTEM_NO_DEPRECATED
+
+#include <boost/filesystem/fstream.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <string>
+#include <iostream>
+#include <cstdio> // for std::remove
+
+#include "../src/utf8_codecvt_facet.hpp"
+
+namespace fs = boost::filesystem;
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STDC_NAMESPACE
+  namespace std { using ::remove; }
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+
+#if defined(_MSC_VER)
+# pragma warning(push) // Save warning settings.
+# pragma warning(disable : 4428) // Disable universal-character-name encountered in source warning.
+#endif 
+
+namespace
+{
+  bool cleanup = true;
+  
+  void test(const fs::path & p)
+  {
+    { 
+      std::cout << " in test 1\n";
+      fs::filebuf fb;
+      fb.open(p, std::ios_base::in);
+      BOOST_TEST(fb.is_open() == fs::exists(p));
+    }
+    {
+      std::cout << " in test 2\n";
+      fs::filebuf fb1;
+      fb1.open(p, std::ios_base::out);
+      BOOST_TEST(fb1.is_open());
+    }
+    {
+      std::cout << " in test 3\n";
+      fs::filebuf fb2;
+      fb2.open(p, std::ios_base::in);
+      BOOST_TEST(fb2.is_open());
+    }
+    {
+      std::cout << " in test 4\n";
+      fs::ifstream tfs(p);
+      BOOST_TEST(tfs.is_open());
+    }
+    {
+      std::cout << " in test 4.1\n";
+      fs::ifstream tfs(p / p.filename()); // should fail
+      BOOST_TEST(!tfs.is_open());
+    }
+    {
+      std::cout << " in test 5\n";
+      fs::ifstream tfs(p, std::ios_base::in);
+      BOOST_TEST(tfs.is_open());
+    }
+    {
+      std::cout << " in test 6\n";
+      fs::ifstream tfs;
+      tfs.open(p);
+      BOOST_TEST(tfs.is_open());
+    }
+    {
+      std::cout << " in test 7\n";
+      fs::ifstream tfs;
+      tfs.open(p, std::ios_base::in);
+      BOOST_TEST(tfs.is_open());
+    }
+    {
+      std::cout << " in test 8\n";
+      fs::ofstream tfs(p);
+      BOOST_TEST(tfs.is_open());
+    }
+    {
+      std::cout << " in test 9\n";
+      fs::ofstream tfs(p, std::ios_base::out);
+      BOOST_TEST(tfs.is_open());
+    }
+    {
+      std::cout << " in test 10\n";
+      fs::ofstream tfs;
+      tfs.open(p);
+      BOOST_TEST(tfs.is_open());
+    }
+    {
+      std::cout << " in test 11\n";
+      fs::ofstream tfs;
+      tfs.open(p, std::ios_base::out);
+      BOOST_TEST(tfs.is_open());
+    }
+    {
+      std::cout << " in test 12\n";
+      fs::fstream tfs(p);
+      BOOST_TEST(tfs.is_open());
+    }
+    {
+      std::cout << " in test 13\n";
+      fs::fstream tfs(p, std::ios_base::in|std::ios_base::out);
+      BOOST_TEST(tfs.is_open());
+    }
+    {
+      std::cout << " in test 14\n";
+      fs::fstream tfs;
+      tfs.open(p);
+      BOOST_TEST(tfs.is_open());
+    }
+    {
+      std::cout << " in test 15\n";
+      fs::fstream tfs;
+      tfs.open(p, std::ios_base::in|std::ios_base::out);
+      BOOST_TEST(tfs.is_open());
+    }
+
+    if (cleanup) fs::remove(p);
+
+  } // test
+} // unnamed namespace
+
+int main(int argc, char*[])
+{
+  if (argc > 1) cleanup = false;
+
+  // test narrow characters
+  std::cout << "narrow character tests:\n";
+  test("fstream_test_foo");
+
+
+  // So that tests are run with known encoding, use Boost UTF-8 codecvt
+  std::locale global_loc = std::locale();
+  std::locale loc(global_loc, new fs::detail::utf8_codecvt_facet);
+  fs::path::imbue(loc);
+
+  // test with some wide characters
+  //  \u2780 is circled 1 against white background == e2 9e 80 in UTF-8
+  //  \u2781 is circled 2 against white background == e2 9e 81 in UTF-8
+  //  \u263A is a white smiling face
+  std::cout << "\nwide character tests:\n";
+  test(L"fstream_test_\u2780\u263A");
+
+  return ::boost::report_errors();
+}

v3/libs/filesystem/test/large_file_support_test.cpp

@@ -0,0 +1,36 @@
+//  Boost large_file_support_test.cpp  ---------------------------------------//
+
+//  Copyright Beman Dawes 2004.
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/filesystem
+
+
+//  See deprecated_test for tests of deprecated features
+#define BOOST_FILESYSTEM_NO_DEPRECATED
+
+#include <boost/filesystem/operations.hpp>
+namespace fs = boost::filesystem;
+
+#include <iostream>
+
+int main()
+{
+  if ( fs::detail::possible_large_file_size_support() )
+  {
+    std::cout << "It appears that file sizes greater that 2 gigabytes are possible\n"
+                 "for this configuration on this platform since the operating system\n"
+                 "does use a large enough integer type to report large file sizes.\n\n"
+                 "Whether or not such support is actually present depends on the OS\n";
+    return 0;
+  }
+  std::cout << "The operating system is using an integer type to report file sizes\n"
+               "that can not represent file sizes greater that 2 gigabytes (31-bits).\n"
+               "Thus the Filesystem Library will not correctly deal with such large\n"
+               "files. If you think that this operatiing system should be able to\n"
+               "support large files, please report the problem to the Boost developers\n"
+               "mailing list.\n";
+  return 1;
+}

v3/libs/filesystem/test/msvc/common.vsprops

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioPropertySheet
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="common"
+	OutputDirectory="$(TEMP)\$(SolutionName)\$(ConfigurationName)"
+	IntermediateDirectory="$(TEMP)\$(SolutionName)\$(ProjectName)\$(ConfigurationName)"
+	>
+	<Tool
+		Name="VCCLCompilerTool"
+		AdditionalIncludeDirectories="../../../../.."
+		PreprocessorDefinitions="BOOST_SYSTEM_NO_DEPRECATED;BOOST_SYSTEM_NO_LIB;BOOST_FILESYSTEM_NO_LIB"
+		ExceptionHandling="2"
+		DisableLanguageExtensions="false"
+		WarningLevel="4"
+	/>
+	<Tool
+		Name="VCLinkerTool"
+		AdditionalLibraryDirectories=""
+	/>
+</VisualStudioPropertySheet>

v3/libs/filesystem/test/msvc/convenience_test/convenience_test.vcproj

@@ -0,0 +1,219 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="convenience_test"
+	ProjectGUID="{08986FB5-0C83-4BC4-92DF-05E12E1C03C1}"
+	RootNamespace="convenience_test"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\src\codecvt_error_category.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\convenience_test.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\..\system\src\error_code.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\operations.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path_traits.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\windows_file_codecvt.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/deprecated_test/deprecated_test.vcproj

@@ -0,0 +1,195 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="deprecated_test"
+	ProjectGUID="{D73BC50F-956E-4A44-BF9F-A8BB80DF0000}"
+	RootNamespace="deprecated_test"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_SYSTEM_DYN_LINK;BOOST_FILESYSTEM_DYN_LINK;WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_SYSTEM_DYN_LINK;BOOST_FILESYSTEM_DYN_LINK;WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\deprecated_test.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/error_demo/error_demo.vcproj

@@ -0,0 +1,191 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="error_demo"
+	ProjectGUID="{709A954B-4F1E-4375-A418-BCBFFE598715}"
+	RootNamespace="error_demo"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=""
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories=""
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\example\error_demo.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/filesystem-v3-sandbox.sln

@@ -0,0 +1,210 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual C++ Express 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "path_unit_test", "path_unit_test\path_unit_test.vcproj", "{3C77F610-2E31-4087-9DF2-7CD45198A02D}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "operations_unit_test", "operations_unit_test\operations_unit_test.vcproj", "{5DAF595A-4640-4F86-8A5F-E54E3E4CE7D0}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "operations_test", "operations_test\operations_test.vcproj", "{8BB7E604-46EF-42BE-ABB5-D7044B3E8A40}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "path_test", "path_test\path_test.vcproj", "{F3D230C4-9185-4C2B-AB0E-0F0D28D8268C}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "system_dll", "system_dll\system_dll.vcproj", "{F94CCADD-A90B-480C-A304-C19D015D36B1}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "filesystem_dll", "filesystem_dll\filesystem_dll.vcproj", "{FFD738F7-96F0-445C-81EA-551665EF53D1}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "convenience_test", "convenience_test\convenience_test.vcproj", "{08986FB5-0C83-4BC4-92DF-05E12E1C03C1}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "path_test_dynamic_link", "path_test_dynamic_link\path_test_dynamic_linkl.vcproj", "{54347DE3-6AA2-4466-A2EC-7176E0EC1110}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fstream_test", "fstream_test\fstream_test.vcproj", "{A9939CD7-BE1C-4334-947C-4C320D49B3CA}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "deprecated_test", "deprecated_test\deprecated_test.vcproj", "{D73BC50F-956E-4A44-BF9F-A8BB80DF0000}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "proof_of_concept", "proof_of_concept\proof_of_concept.vcproj", "{440316C4-E19E-41DE-92A6-B78B3900E97F}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "simple_ls", "simple_ls\simple_ls.vcproj", "{6B8EC880-702E-418A-BC63-CA46C6CC7B27}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "complete_func_combos", "complete_func_combos\complete_func_combos.vcproj", "{B0725661-C439-484E-BD67-E367AC78C60A}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "error_demo", "error_demo\error_demo.vcproj", "{709A954B-4F1E-4375-A418-BCBFFE598715}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tut1", "tut1\tut1.vcproj", "{6376B8E4-7FD4-466B-978E-E8DA6E938689}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tut3", "tut3\tut3.vcproj", "{4FF64FA7-6806-401D-865C-79DD064D4A9E}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tut2", "tut2\tut2.vcproj", "{CD69B175-389E-4F8F-85DC-03C56A47CD1D}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tut4", "tut4\tut4.vcproj", "{256EA89A-E073-4CE8-B675-BE2FBC6B2691}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "path_info", "path_info\path_info.vcproj", "{18EA74B4-B284-4FD4-BC0A-3B2193801B8D}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "space", "space\space.vcproj", "{1AEABC96-F4D5-4B15-B246-3AA34A1827CB}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tut5", "tut5\tut5.vcproj", "{9D7703A1-F076-4362-BE31-A1C5893D05DF}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "scratch", "scratch\scratch.vcproj", "{D2F172A6-1D20-458D-8C46-83A2FBAC73E4}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "path_table", "path_table\path_table.vcproj", "{0CAE0949-3678-4AC9-A17D-DFCD9F72C4B7}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1}
+		{FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1}
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{3C77F610-2E31-4087-9DF2-7CD45198A02D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{3C77F610-2E31-4087-9DF2-7CD45198A02D}.Debug|Win32.Build.0 = Debug|Win32
+		{3C77F610-2E31-4087-9DF2-7CD45198A02D}.Release|Win32.ActiveCfg = Release|Win32
+		{3C77F610-2E31-4087-9DF2-7CD45198A02D}.Release|Win32.Build.0 = Release|Win32
+		{5DAF595A-4640-4F86-8A5F-E54E3E4CE7D0}.Debug|Win32.ActiveCfg = Debug|Win32
+		{5DAF595A-4640-4F86-8A5F-E54E3E4CE7D0}.Debug|Win32.Build.0 = Debug|Win32
+		{5DAF595A-4640-4F86-8A5F-E54E3E4CE7D0}.Release|Win32.ActiveCfg = Release|Win32
+		{5DAF595A-4640-4F86-8A5F-E54E3E4CE7D0}.Release|Win32.Build.0 = Release|Win32
+		{8BB7E604-46EF-42BE-ABB5-D7044B3E8A40}.Debug|Win32.ActiveCfg = Debug|Win32
+		{8BB7E604-46EF-42BE-ABB5-D7044B3E8A40}.Debug|Win32.Build.0 = Debug|Win32
+		{8BB7E604-46EF-42BE-ABB5-D7044B3E8A40}.Release|Win32.ActiveCfg = Release|Win32
+		{8BB7E604-46EF-42BE-ABB5-D7044B3E8A40}.Release|Win32.Build.0 = Release|Win32
+		{F3D230C4-9185-4C2B-AB0E-0F0D28D8268C}.Debug|Win32.ActiveCfg = Debug|Win32
+		{F3D230C4-9185-4C2B-AB0E-0F0D28D8268C}.Debug|Win32.Build.0 = Debug|Win32
+		{F3D230C4-9185-4C2B-AB0E-0F0D28D8268C}.Release|Win32.ActiveCfg = Release|Win32
+		{F3D230C4-9185-4C2B-AB0E-0F0D28D8268C}.Release|Win32.Build.0 = Release|Win32
+		{F94CCADD-A90B-480C-A304-C19D015D36B1}.Debug|Win32.ActiveCfg = Debug|Win32
+		{F94CCADD-A90B-480C-A304-C19D015D36B1}.Debug|Win32.Build.0 = Debug|Win32
+		{F94CCADD-A90B-480C-A304-C19D015D36B1}.Release|Win32.ActiveCfg = Release|Win32
+		{F94CCADD-A90B-480C-A304-C19D015D36B1}.Release|Win32.Build.0 = Release|Win32
+		{FFD738F7-96F0-445C-81EA-551665EF53D1}.Debug|Win32.ActiveCfg = Debug|Win32
+		{FFD738F7-96F0-445C-81EA-551665EF53D1}.Debug|Win32.Build.0 = Debug|Win32
+		{FFD738F7-96F0-445C-81EA-551665EF53D1}.Release|Win32.ActiveCfg = Release|Win32
+		{FFD738F7-96F0-445C-81EA-551665EF53D1}.Release|Win32.Build.0 = Release|Win32
+		{08986FB5-0C83-4BC4-92DF-05E12E1C03C1}.Debug|Win32.ActiveCfg = Debug|Win32
+		{08986FB5-0C83-4BC4-92DF-05E12E1C03C1}.Debug|Win32.Build.0 = Debug|Win32
+		{08986FB5-0C83-4BC4-92DF-05E12E1C03C1}.Release|Win32.ActiveCfg = Release|Win32
+		{08986FB5-0C83-4BC4-92DF-05E12E1C03C1}.Release|Win32.Build.0 = Release|Win32
+		{54347DE3-6AA2-4466-A2EC-7176E0EC1110}.Debug|Win32.ActiveCfg = Debug|Win32
+		{54347DE3-6AA2-4466-A2EC-7176E0EC1110}.Debug|Win32.Build.0 = Debug|Win32
+		{54347DE3-6AA2-4466-A2EC-7176E0EC1110}.Release|Win32.ActiveCfg = Release|Win32
+		{54347DE3-6AA2-4466-A2EC-7176E0EC1110}.Release|Win32.Build.0 = Release|Win32
+		{A9939CD7-BE1C-4334-947C-4C320D49B3CA}.Debug|Win32.ActiveCfg = Debug|Win32
+		{A9939CD7-BE1C-4334-947C-4C320D49B3CA}.Debug|Win32.Build.0 = Debug|Win32
+		{A9939CD7-BE1C-4334-947C-4C320D49B3CA}.Release|Win32.ActiveCfg = Release|Win32
+		{A9939CD7-BE1C-4334-947C-4C320D49B3CA}.Release|Win32.Build.0 = Release|Win32
+		{D73BC50F-956E-4A44-BF9F-A8BB80DF0000}.Debug|Win32.ActiveCfg = Debug|Win32
+		{D73BC50F-956E-4A44-BF9F-A8BB80DF0000}.Debug|Win32.Build.0 = Debug|Win32
+		{D73BC50F-956E-4A44-BF9F-A8BB80DF0000}.Release|Win32.ActiveCfg = Release|Win32
+		{D73BC50F-956E-4A44-BF9F-A8BB80DF0000}.Release|Win32.Build.0 = Release|Win32
+		{440316C4-E19E-41DE-92A6-B78B3900E97F}.Debug|Win32.ActiveCfg = Debug|Win32
+		{440316C4-E19E-41DE-92A6-B78B3900E97F}.Release|Win32.ActiveCfg = Release|Win32
+		{440316C4-E19E-41DE-92A6-B78B3900E97F}.Release|Win32.Build.0 = Release|Win32
+		{6B8EC880-702E-418A-BC63-CA46C6CC7B27}.Debug|Win32.ActiveCfg = Debug|Win32
+		{6B8EC880-702E-418A-BC63-CA46C6CC7B27}.Debug|Win32.Build.0 = Debug|Win32
+		{6B8EC880-702E-418A-BC63-CA46C6CC7B27}.Release|Win32.ActiveCfg = Release|Win32
+		{6B8EC880-702E-418A-BC63-CA46C6CC7B27}.Release|Win32.Build.0 = Release|Win32
+		{B0725661-C439-484E-BD67-E367AC78C60A}.Debug|Win32.ActiveCfg = Debug|Win32
+		{B0725661-C439-484E-BD67-E367AC78C60A}.Debug|Win32.Build.0 = Debug|Win32
+		{B0725661-C439-484E-BD67-E367AC78C60A}.Release|Win32.ActiveCfg = Release|Win32
+		{B0725661-C439-484E-BD67-E367AC78C60A}.Release|Win32.Build.0 = Release|Win32
+		{709A954B-4F1E-4375-A418-BCBFFE598715}.Debug|Win32.ActiveCfg = Debug|Win32
+		{709A954B-4F1E-4375-A418-BCBFFE598715}.Debug|Win32.Build.0 = Debug|Win32
+		{709A954B-4F1E-4375-A418-BCBFFE598715}.Release|Win32.ActiveCfg = Release|Win32
+		{709A954B-4F1E-4375-A418-BCBFFE598715}.Release|Win32.Build.0 = Release|Win32
+		{6376B8E4-7FD4-466B-978E-E8DA6E938689}.Debug|Win32.ActiveCfg = Debug|Win32
+		{6376B8E4-7FD4-466B-978E-E8DA6E938689}.Debug|Win32.Build.0 = Debug|Win32
+		{6376B8E4-7FD4-466B-978E-E8DA6E938689}.Release|Win32.ActiveCfg = Release|Win32
+		{6376B8E4-7FD4-466B-978E-E8DA6E938689}.Release|Win32.Build.0 = Release|Win32
+		{4FF64FA7-6806-401D-865C-79DD064D4A9E}.Debug|Win32.ActiveCfg = Debug|Win32
+		{4FF64FA7-6806-401D-865C-79DD064D4A9E}.Debug|Win32.Build.0 = Debug|Win32
+		{4FF64FA7-6806-401D-865C-79DD064D4A9E}.Release|Win32.ActiveCfg = Release|Win32
+		{4FF64FA7-6806-401D-865C-79DD064D4A9E}.Release|Win32.Build.0 = Release|Win32
+		{CD69B175-389E-4F8F-85DC-03C56A47CD1D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{CD69B175-389E-4F8F-85DC-03C56A47CD1D}.Debug|Win32.Build.0 = Debug|Win32
+		{CD69B175-389E-4F8F-85DC-03C56A47CD1D}.Release|Win32.ActiveCfg = Release|Win32
+		{CD69B175-389E-4F8F-85DC-03C56A47CD1D}.Release|Win32.Build.0 = Release|Win32
+		{256EA89A-E073-4CE8-B675-BE2FBC6B2691}.Debug|Win32.ActiveCfg = Debug|Win32
+		{256EA89A-E073-4CE8-B675-BE2FBC6B2691}.Debug|Win32.Build.0 = Debug|Win32
+		{256EA89A-E073-4CE8-B675-BE2FBC6B2691}.Release|Win32.ActiveCfg = Release|Win32
+		{256EA89A-E073-4CE8-B675-BE2FBC6B2691}.Release|Win32.Build.0 = Release|Win32
+		{18EA74B4-B284-4FD4-BC0A-3B2193801B8D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{18EA74B4-B284-4FD4-BC0A-3B2193801B8D}.Debug|Win32.Build.0 = Debug|Win32
+		{18EA74B4-B284-4FD4-BC0A-3B2193801B8D}.Release|Win32.ActiveCfg = Release|Win32
+		{18EA74B4-B284-4FD4-BC0A-3B2193801B8D}.Release|Win32.Build.0 = Release|Win32
+		{1AEABC96-F4D5-4B15-B246-3AA34A1827CB}.Debug|Win32.ActiveCfg = Debug|Win32
+		{1AEABC96-F4D5-4B15-B246-3AA34A1827CB}.Debug|Win32.Build.0 = Debug|Win32
+		{1AEABC96-F4D5-4B15-B246-3AA34A1827CB}.Release|Win32.ActiveCfg = Release|Win32
+		{1AEABC96-F4D5-4B15-B246-3AA34A1827CB}.Release|Win32.Build.0 = Release|Win32
+		{9D7703A1-F076-4362-BE31-A1C5893D05DF}.Debug|Win32.ActiveCfg = Debug|Win32
+		{9D7703A1-F076-4362-BE31-A1C5893D05DF}.Debug|Win32.Build.0 = Debug|Win32
+		{9D7703A1-F076-4362-BE31-A1C5893D05DF}.Release|Win32.ActiveCfg = Release|Win32
+		{9D7703A1-F076-4362-BE31-A1C5893D05DF}.Release|Win32.Build.0 = Release|Win32
+		{D2F172A6-1D20-458D-8C46-83A2FBAC73E4}.Debug|Win32.ActiveCfg = Debug|Win32
+		{D2F172A6-1D20-458D-8C46-83A2FBAC73E4}.Debug|Win32.Build.0 = Debug|Win32
+		{D2F172A6-1D20-458D-8C46-83A2FBAC73E4}.Release|Win32.ActiveCfg = Release|Win32
+		{D2F172A6-1D20-458D-8C46-83A2FBAC73E4}.Release|Win32.Build.0 = Release|Win32
+		{0CAE0949-3678-4AC9-A17D-DFCD9F72C4B7}.Debug|Win32.ActiveCfg = Debug|Win32
+		{0CAE0949-3678-4AC9-A17D-DFCD9F72C4B7}.Debug|Win32.Build.0 = Debug|Win32
+		{0CAE0949-3678-4AC9-A17D-DFCD9F72C4B7}.Release|Win32.ActiveCfg = Release|Win32
+		{0CAE0949-3678-4AC9-A17D-DFCD9F72C4B7}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

v3/libs/filesystem/test/msvc/filesystem_dll/filesystem_dll.vcproj

@@ -0,0 +1,225 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="filesystem_dll"
+	ProjectGUID="{FFD738F7-96F0-445C-81EA-551665EF53D1}"
+	RootNamespace="filesystem_dll"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(TEMP)\$(SolutionName)\$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\..\..\..\.."
+				PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_ALL_DYN_LINK;WIN32;_DEBUG;_WINDOWS;_USRDLL;FILESYSTEM_DLL_EXPORTS"
+				MinimalRebuild="true"
+				ExceptionHandling="2"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(TEMP)\$(SolutionName)\$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="..\..\..\..\.."
+				PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_ALL_DYN_LINK;WIN32;NDEBUG;_WINDOWS;_USRDLL;FILESYSTEM_DLL_EXPORTS"
+				ExceptionHandling="2"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\src\codecvt_error_category.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\operations.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path_traits.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\portability.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\unique_path.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\utf8_codecvt_facet.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\windows_file_codecvt.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/fstream_test/fstream_test.vcproj

@@ -0,0 +1,223 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="fstream_test"
+	ProjectGUID="{A9939CD7-BE1C-4334-947C-4C320D49B3CA}"
+	RootNamespace="fstream_test"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\src\codecvt_error_category.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\..\system\src\error_code.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\fstream_test.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\operations.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path_traits.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\utf8_codecvt_facet.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\windows_file_codecvt.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/operations_test/operations_test.vcproj

@@ -0,0 +1,218 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="operations_test"
+	ProjectGUID="{8BB7E604-46EF-42BE-ABB5-D7044B3E8A40}"
+	RootNamespace="operations_test"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="BOOST_FILEYSTEM_INCLUDE_IOSTREAM"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;  -x"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;  -x"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\src\codecvt_error_category.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\..\system\src\error_code.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\operations.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\operations_test.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path_traits.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\windows_file_codecvt.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/operations_unit_test/operations_unit_test.vcproj

@@ -0,0 +1,233 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="operations_unit_test"
+	ProjectGUID="{5DAF595A-4640-4F86-8A5F-E54E3E4CE7D0}"
+	RootNamespace="operations_unit_test"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=""
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories=""
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\src\codecvt_error_category.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\..\system\src\error_code.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\operations.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\operations_unit_test.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path_traits.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\portability.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\unique_path.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\utf8_codecvt_facet.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\windows_file_codecvt.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/path_test/path_test.vcproj

@@ -0,0 +1,223 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="path_test"
+	ProjectGUID="{F3D230C4-9185-4C2B-AB0E-0F0D28D8268C}"
+	RootNamespace="path_test"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="BOOST_FILESYSTEM_PATH_CTOR_COUNT;WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\src\codecvt_error_category.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\..\system\src\error_code.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\operations.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\path_test.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path_traits.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\portability.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\windows_file_codecvt.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/path_test_dynamic_link/path_test_dynamic_linkl.vcproj

@@ -0,0 +1,201 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="path_test_dynamic_link"
+	ProjectGUID="{54347DE3-6AA2-4466-A2EC-7176E0EC1110}"
+	RootNamespace="path_test_dynamic_link"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(TEMP)\$(SolutionName)\$(ConfigurationName)"
+			IntermediateDirectory="$(TEMP)\$(SolutionName)\$(ProjectName)\$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\..\..\..\.."
+				PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_SYSTEM_DYN_LINK;BOOST_FILESYSTEM_DYN_LINK;WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				ExceptionHandling="2"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(TEMP)\$(SolutionName)\$(ConfigurationName)"
+			IntermediateDirectory="$(TEMP)\$(SolutionName)\$(ProjectName)\$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="..\..\..\..\.."
+				PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_SYSTEM_DYN_LINK;BOOST_FILESYSTEM_DYN_LINK;WIN32;NDEBUG;_CONSOLE"
+				ExceptionHandling="2"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\path_test.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/path_unit_test/path_unit_test.vcproj

@@ -0,0 +1,223 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="path_unit_test"
+	ProjectGUID="{3C77F610-2E31-4087-9DF2-7CD45198A02D}"
+	RootNamespace="path_unit_test"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\src\codecvt_error_category.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\..\system\src\error_code.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path_traits.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\path_unit_test.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\portability.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\utf8_codecvt_facet.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\windows_file_codecvt.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/simple_ls/simple_ls.vcproj

@@ -0,0 +1,199 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="simple_ls"
+	ProjectGUID="{6B8EC880-702E-418A-BC63-CA46C6CC7B27}"
+	RootNamespace="simple_ls"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(TEMP)\$(SolutionName)\$(ConfigurationName)"
+			IntermediateDirectory="$(TEMP)\$(SolutionName)\$(ProjectName)\$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\..\..\..\.."
+				PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_SYSTEM_DYN_LINK;BOOST_FILESYSTEM_DYN_LINK;WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(TEMP)\$(SolutionName)\$(ConfigurationName)"
+			IntermediateDirectory="$(TEMP)\$(SolutionName)\$(ProjectName)\$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="..\..\..\..\.."
+				PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_SYSTEM_DYN_LINK;BOOST_FILESYSTEM_DYN_LINK;WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\example\simple_ls.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/system_dll/system_dll.vcproj

@@ -0,0 +1,197 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="system_dll"
+	ProjectGUID="{F94CCADD-A90B-480C-A304-C19D015D36B1}"
+	RootNamespace="system_dll"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(TEMP)\$(SolutionName)\$(ConfigurationName)"
+			IntermediateDirectory="$(TEMP)\$(SolutionName)\$(ProjectName)\$(ConfigurationName)"
+			ConfigurationType="2"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\..\..\..\.."
+				PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_ALL_DYN_LINK;WIN32;_DEBUG;_WINDOWS;_USRDLL;SYSTEM_DLL_EXPORTS"
+				MinimalRebuild="true"
+				ExceptionHandling="2"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(TEMP)\$(SolutionName)\$(ConfigurationName)"
+			IntermediateDirectory="$(TEMP)\$(SolutionName)\$(ProjectName)\$(ConfigurationName)"
+			ConfigurationType="2"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="..\..\..\..\.."
+				PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_ALL_DYN_LINK;WIN32;NDEBUG;_WINDOWS;_USRDLL;SYSTEM_DLL_EXPORTS"
+				ExceptionHandling="2"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\..\system\src\error_code.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/tchar_example/tchar_example.vcproj

@@ -0,0 +1,212 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="tchar_example"
+	ProjectGUID="{2D4CD761-6DF6-40AC-B4A5-F169D5F93226}"
+	RootNamespace="tchar_example"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(TEMP)\$(SolutionName)\$(ConfigurationName)"
+			IntermediateDirectory="$(TEMP)\$(SolutionName)\$(ProjectName)\$(ConfigurationName)"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=""
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(TEMP)\$(SolutionName)\$(ConfigurationName)"
+			IntermediateDirectory="$(TEMP)\$(SolutionName)\$(ProjectName)\$(ConfigurationName)"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot;"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\..\system\src\error_code.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\operations.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\path.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\example\tchar.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/tut0/tut0.vcproj

@@ -0,0 +1,190 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="tut0"
+	ProjectGUID="{6B5ABD07-0289-484D-BD96-6F1BC92677D3}"
+	RootNamespace="tut0"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=""
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\example\tut0.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/tut1/tut1.vcproj

@@ -0,0 +1,193 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="tut1"
+	ProjectGUID="{6376B8E4-7FD4-466B-978E-E8DA6E938689}"
+	RootNamespace="tut1"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=""
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories=""
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\example\tut1.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/tut2/tut2.vcproj

@@ -0,0 +1,189 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="tut2"
+	ProjectGUID="{CD69B175-389E-4F8F-85DC-03C56A47CD1D}"
+	RootNamespace="tut2"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\example\tut2.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/tut3/tut3.vcproj

@@ -0,0 +1,187 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="tut3"
+	ProjectGUID="{4FF64FA7-6806-401D-865C-79DD064D4A9E}"
+	RootNamespace="tut3"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\example\tut3.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/tut4/tut4.vcproj

@@ -0,0 +1,189 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="tut4"
+	ProjectGUID="{256EA89A-E073-4CE8-B675-BE2FBC6B2691}"
+	RootNamespace="tut4"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=""
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories=""
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\example\tut4.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/msvc/wide_test/wide_test.vcproj

@@ -0,0 +1,191 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="wide_test"
+	ProjectGUID="{DE12E87D-87C1-4FF3-AF16-85097F2A5184}"
+	RootNamespace="wide_test"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\wide_test.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

v3/libs/filesystem/test/operations_unit_test.cpp

@@ -0,0 +1,229 @@
+//  operations_unit_test.cpp  ----------------------------------------------------------//
+
+//  Copyright Beman Dawes 2008, 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+#include <boost/config/warning_disable.hpp>
+
+//  See deprecated_test for tests of deprecated features
+#define BOOST_FILESYSTEM_NO_DEPRECATED
+
+#include <iostream>
+#include <boost/filesystem/operations.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::filesystem;
+using namespace boost::system;
+using std::cout;
+using std::string;
+
+#define CHECK(x) check(x, __FILE__, __LINE__)
+
+namespace
+{
+
+  void check(bool ok, const char* file, int line)
+  {
+    if (ok) return;
+
+    ++::boost::detail::test_errors();
+
+    std::cout << file << '(' << line << "): test failed\n";
+  }
+
+  //  query_test  ----------------------------------------------------------------------//
+
+  void query_test()
+  {
+    std::cout << "query test..." << std::endl;
+
+    error_code ec;
+
+    CHECK(file_size("no-such-file", ec) == static_cast<boost::uintmax_t>(-1));
+    CHECK(ec == errc::no_such_file_or_directory);
+
+    CHECK(status("no-such-file") == file_status(file_not_found));
+
+    CHECK(exists("/"));
+    CHECK(is_directory("/"));
+    CHECK(!exists("no-such-file"));
+
+    exists("/", ec);
+    if (ec)
+    {
+      std::cout << "exists(\"/\", ec) resulted in non-zero ec.value()" << std::endl;
+      std::cout << "ec value: " << ec.value() << ", message: "<< ec.message() << std::endl;
+    }
+    CHECK(!ec);
+
+    CHECK(exists("/"));
+    CHECK(is_directory("/"));
+    CHECK(!is_regular_file("/"));
+    CHECK(!boost::filesystem::is_empty("/"));
+    CHECK(!is_other("/"));
+  }
+
+  //  directory_iterator_test  -----------------------------------------------//
+
+  void directory_iterator_test()
+  {
+    std::cout << "directory_iterator_test..." << std::endl;
+
+    directory_iterator end;
+
+    directory_iterator it(".");
+
+    CHECK(!it->path().empty());
+
+    if (is_regular_file(it->status()))
+    {
+      CHECK(is_regular_file(it->symlink_status()));
+      CHECK(!is_directory(it->status()));
+      CHECK(!is_symlink(it->status()));
+      CHECK(!is_directory(it->symlink_status()));
+      CHECK(!is_symlink(it->symlink_status()));
+    }
+    else
+    {
+      CHECK(is_directory(it->status()));
+      CHECK(is_directory(it->symlink_status()));
+      CHECK(!is_regular_file(it->status()));
+      CHECK(!is_regular_file(it->symlink_status()));
+      CHECK(!is_symlink(it->status()));
+      CHECK(!is_symlink(it->symlink_status()));
+    }
+
+    for (; it != end; ++it)
+    {
+//      cout << "  " << it->path().string() << "\n";
+    }
+
+    std::cout << "directory_iterator_test complete" << std::endl;
+  }
+
+  //  operations_test  -------------------------------------------------------//
+
+  void operations_test()
+  {
+    std::cout << "operations test..." << std::endl;
+
+    error_code ec;
+
+    CHECK(!create_directory("/", ec));
+
+    CHECK(!boost::filesystem::remove("no-such-file-or-directory"));
+    CHECK(!remove_all("no-such-file-or-directory"));
+
+    space_info info = space("/");
+
+    CHECK(info.available <= info.capacity);
+
+    CHECK(equivalent("/", "/"));
+    CHECK(!equivalent("/", "."));
+
+    std::time_t ft = last_write_time(".");
+    ft = -1;
+    last_write_time(".", ft, ec);
+  }
+
+  //  directory_entry_test  ------------------------------------------------------------//
+
+  void directory_entry_test()
+  {
+    std::cout << "directory_entry test..." << std::endl;
+
+    directory_entry de("foo.bar", file_status(regular_file), file_status(directory_file));
+
+    CHECK(de.path() == "foo.bar");
+    CHECK(de.status() == file_status(regular_file));
+    CHECK(de.symlink_status() == file_status(directory_file));
+    CHECK(de < directory_entry("goo.bar"));
+    CHECK(de == directory_entry("foo.bar"));
+    CHECK(de != directory_entry("goo.bar"));
+    de.replace_filename("bar.foo");
+    CHECK(de.path() == "bar.foo");
+  }
+
+  //  directory_entry_overload_test  ---------------------------------------------------//
+
+  void directory_entry_overload_test()
+  {
+    std::cout << "directory_entry overload test..." << std::endl;
+
+    directory_iterator it(".");
+    path p(*it);
+  }
+
+  //  error_handling_test  -------------------------------------------------------------//
+
+  void error_handling_test()
+  {
+    std::cout << "error handling test..." << std::endl;
+
+    bool threw(false);
+    try
+    { 
+      file_size("no-such-file");
+    }
+    catch (const boost::filesystem::filesystem_error & ex)
+    {
+      threw = true;
+      cout << "\nas expected, attempt to get size of non-existent file threw a filesystem_error\n"
+        "what() returns " << ex.what() << "\n";
+    }
+    catch (...)
+    {
+      cout << "\nunexpected exception type caught" << std::endl;
+    }
+
+    CHECK(threw);
+
+    error_code ec;
+    CHECK(!create_directory("/", ec));
+  }
+
+}  // unnamed namespace
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                                    main                                              //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+int main()
+{
+// document state of critical macros
+#ifdef BOOST_POSIX_API
+  cout << "BOOST_POSIX_API is defined\n";
+#endif
+#ifdef BOOST_WINDOWS_API
+  cout << "BOOST_WINDOWS_API is defined\n";
+#endif
+#ifdef BOOST_POSIX_API
+  cout << "BOOST_POSIX_API is defined\n";
+#endif
+#ifdef BOOST_WINDOWS_API
+  cout << "BOOST_WINDOWS_API is defined\n";
+#endif
+  cout << "BOOST_FILESYSTEM_DECL" << BOOST_STRINGIZE(=BOOST_FILESYSTEM_DECL) << "\n";
+  cout << "BOOST_SYMBOL_VISIBLE" << BOOST_STRINGIZE(=BOOST_SYMBOL_VISIBLE) << "\n";
+  
+  cout << "current_path() is " << current_path().string() << std::endl;
+
+  query_test();
+  directory_iterator_test();
+  operations_test();
+  directory_entry_test();
+  directory_entry_overload_test();
+  error_handling_test();
+
+  std::cout << unique_path() << std::endl;
+  std::cout << unique_path("foo-%%%%%-%%%%%-bar") << std::endl;
+  
+  return ::boost::report_errors();
+}

v3/libs/filesystem/test/path_unit_test.cpp

@@ -0,0 +1,905 @@
+//  filesystem path_unit_test.cpp  ---------------------------------------------------  //
+
+//  Copyright Beman Dawes 2008, 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+//  ----------------------------------------------------------------------------------  //
+//
+//  The purpose of this test is to ensure that each function in the public
+//  interface can be called with arguments of the appropriate types. It does
+//  not attempt to verify that the full range of values for each argument
+//  are processed correctly.
+//
+//  For full functionality tests, including probes with many different argument
+//  values, see path_test.cpp and other test programs.
+//
+//  ----------------------------------------------------------------------------------  //
+
+#include <boost/config/warning_disable.hpp>
+
+//  See deprecated_test for tests of deprecated features
+#define BOOST_FILESYSTEM_NO_DEPRECATED
+
+#include <boost/filesystem/path.hpp>
+#include "../src/utf8_codecvt_facet.hpp"  // for imbue tests
+#include <boost/detail/lightweight_test.hpp>
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <locale>
+#include <list>
+
+namespace fs = boost::filesystem;
+namespace bs = boost::system;
+using boost::filesystem::path;
+using std::cout;
+using std::endl;
+using std::string;
+using std::wstring;
+
+#define CHECK(x) check(x, __FILE__, __LINE__)
+#define PATH_IS(a, b) check_path(a, b, __FILE__, __LINE__)
+#define IS(a,b) check_equal(a, b, __FILE__, __LINE__)
+
+#if defined(_MSC_VER)
+# pragma warning(push) // Save warning settings.
+# pragma warning(disable : 4428) // Disable universal-character-name encountered in source warning.
+#endif
+
+namespace
+{
+
+  boost::system::error_code ec;
+  const boost::system::error_code ok;
+  const boost::system::error_code ng(-1, boost::system::system_category());
+
+  std::string platform(BOOST_PLATFORM);
+
+  void check_path(const path & source,
+              const wstring & expected, const char* file, int line)
+  {
+    if (source == expected) return;
+
+    ++::boost::detail::test_errors();
+
+    std::cout << file;
+    std::wcout << L'(' << line << L"): source.wstring(): \""
+               << source.wstring()
+               << L"\" != expected: \"" << expected
+               << L"\"\n" ;
+  }
+
+  template< class T1, class T2 >
+  void check_equal(const T1 & value,
+                    const T2 & expected, const char* file, int line)
+  {
+    if (value == expected) return;
+
+    ++::boost::detail::test_errors();
+
+    std::cout << file;
+
+    std::wcout << L'(' << line << L"): value: \"" << value
+               << L"\" != expected: \"" << expected
+               << L"\"\n" ;
+  }
+
+  void check(bool ok, const char* file, int line)
+  {
+    if (ok) return;
+
+    ++::boost::detail::test_errors();
+
+    std::cout << file << '(' << line << "): test failed\n";
+  }
+
+  string s("string");
+  wstring ws(L"wstring");
+  std::list<char> l;      // see main() for initialization to s, t, r, i, n, g
+  std::list<wchar_t> wl;  // see main() for initialization to w, s, t, r, i, n, g
+  std::vector<char> v;      // see main() for initialization to f, u, z
+  std::vector<wchar_t> wv;  // see main() for initialization to w, f, u, z
+
+  //  test_constructors  ---------------------------------------------------------------//
+
+  void test_constructors()
+  {
+    std::cout << "testing constructors..." << std::endl;
+
+    path x0;                                           // default constructor
+    PATH_IS(x0, L"");
+    BOOST_TEST_EQ(x0.native().size(), 0U);
+
+    path x1(l.begin(), l.end());                       // iterator range char
+    PATH_IS(x1, L"string");
+    BOOST_TEST_EQ(x1.native().size(), 6U);
+
+    path x2(x1);                                       // copy constructor
+    PATH_IS(x2, L"string");
+    BOOST_TEST_EQ(x2.native().size(), 6U);
+
+    path x3(wl.begin(), wl.end());                     // iterator range wchar_t
+    PATH_IS(x3, L"wstring");
+    BOOST_TEST_EQ(x3.native().size(), 7U);
+
+    // contiguous containers
+    path x4(string("std::string"));                    // std::string
+    PATH_IS(x4, L"std::string");
+    BOOST_TEST_EQ(x4.native().size(), 11U);
+
+    path x5(wstring(L"std::wstring"));                 // std::wstring
+    PATH_IS(x5, L"std::wstring");
+    BOOST_TEST_EQ(x5.native().size(), 12U);
+
+    path x4v(v);                                       // std::vector<char>
+    PATH_IS(x4v, L"fuz");
+    BOOST_TEST_EQ(x4v.native().size(), 3U);
+
+    path x5v(wv);                                      // std::vector<wchar_t>
+    PATH_IS(x5v, L"wfuz");
+    BOOST_TEST_EQ(x5v.native().size(), 4U);
+
+    path x6("array char");                             // array char
+    PATH_IS(x6, L"array char");
+    BOOST_TEST_EQ(x6.native().size(), 10U);
+
+    path x7(L"array wchar_t");                         // array wchar_t
+    PATH_IS(x7, L"array wchar_t");
+    BOOST_TEST_EQ(x7.native().size(), 13U);
+
+    path x8(s.c_str());                                // const char* null terminated
+    PATH_IS(x8, L"string");
+    BOOST_TEST_EQ(x8.native().size(), 6U);
+
+    path x9(ws.c_str());                               // const wchar_t* null terminated
+    PATH_IS(x9, L"wstring");
+    BOOST_TEST_EQ(x9.native().size(), 7U);
+
+    // non-contiguous containers
+    path x10(l);                                       // std::list<char>
+    PATH_IS(x10, L"string");
+    BOOST_TEST_EQ(x10.native().size(), 6U);
+
+    path xll(wl);                                      // std::list<wchar_t>
+    PATH_IS(xll, L"wstring");
+    BOOST_TEST_EQ(xll.native().size(), 7U);
+  }
+
+  path x;
+  path y;
+
+  //  test_assignments  ----------------------------------------------------------------//
+
+  void test_assignments()
+  {
+    std::cout << "testing assignments..." << std::endl;
+
+    x = path("yet another path");                      // another path
+    PATH_IS(x, L"yet another path");
+    BOOST_TEST_EQ(x.native().size(), 16U);
+
+    x = x;                                             // self-assignment
+    PATH_IS(x, L"yet another path");
+    BOOST_TEST_EQ(x.native().size(), 16U);
+
+    x.assign(l.begin(), l.end());                      // iterator range char
+    PATH_IS(x, L"string");
+
+    x.assign(wl.begin(), wl.end());                    // iterator range wchar_t
+    PATH_IS(x, L"wstring");
+
+    x = string("std::string");                         // container char
+    PATH_IS(x, L"std::string");
+
+    x = wstring(L"std::wstring");                      // container wchar_t
+    PATH_IS(x, L"std::wstring");
+
+    x = "array char";                                  // array char
+    PATH_IS(x, L"array char");
+
+    x = L"array wchar";                                // array wchar_t
+    PATH_IS(x, L"array wchar");
+
+    x = s.c_str();                                     // const char* null terminated
+    PATH_IS(x, L"string");
+
+    x = ws.c_str();                                    // const wchar_t* null terminated
+    PATH_IS(x, L"wstring");
+   }
+
+  //  test_appends  --------------------------------------------------------------------//
+
+  void test_appends()
+  {
+    std::cout << "testing appends..." << std::endl;
+
+# ifdef BOOST_WINDOWS_API
+#   define BOOST_FS_FOO L"/foo\\"
+# else   // POSIX paths
+#   define BOOST_FS_FOO L"/foo/"
+# endif
+
+    x = "/foo";
+    x /= path("");                                      // empty path
+    PATH_IS(x, L"/foo");
+
+    x = "/foo";
+    x /= path("/");                                     // slash path
+    PATH_IS(x, L"/foo/");
+
+    x = "/foo";
+    x /= path("/boo");                                  // slash path
+    PATH_IS(x, L"/foo/boo");
+
+    x = "/foo";
+    x /= x;                                             // self-append
+    PATH_IS(x, L"/foo/foo");
+
+    x = "/foo";
+    x /= path("yet another path");                      // another path
+    PATH_IS(x, BOOST_FS_FOO L"yet another path");
+
+    x = "/foo";
+    x.append(l.begin(), l.end());                      // iterator range char
+    PATH_IS(x, BOOST_FS_FOO L"string");
+
+    x = "/foo";
+    x.append(wl.begin(), wl.end());                    // iterator range wchar_t
+    PATH_IS(x, BOOST_FS_FOO L"wstring");
+
+    x = "/foo";
+    x /= string("std::string");                         // container char
+    PATH_IS(x, BOOST_FS_FOO L"std::string");
+
+    x = "/foo";
+    x /= wstring(L"std::wstring");                      // container wchar_t
+    PATH_IS(x, BOOST_FS_FOO L"std::wstring");
+
+    x = "/foo";
+    x /= "array char";                                  // array char
+    PATH_IS(x, BOOST_FS_FOO L"array char");
+
+    x = "/foo";
+    x /= L"array wchar";                                // array wchar_t
+    PATH_IS(x, BOOST_FS_FOO L"array wchar");
+
+    x = "/foo";
+    x /= s.c_str();                                     // const char* null terminated
+    PATH_IS(x, BOOST_FS_FOO L"string");
+
+    x = "/foo";
+    x /= ws.c_str();                                    // const wchar_t* null terminated
+    PATH_IS(x, BOOST_FS_FOO L"wstring");
+   }
+
+  //  test_observers  ------------------------------------------------------------------//
+
+  void test_observers()
+  {
+    std::cout << "testing observers..." << std::endl;
+
+    path p0("abc");
+
+    CHECK(p0.native().size() == 3);
+    CHECK(p0.string() == "abc");
+    CHECK(p0.string().size() == 3);
+    CHECK(p0.wstring() == L"abc");
+    CHECK(p0.wstring().size() == 3);
+
+# ifdef BOOST_WINDOWS_API
+
+    path p("abc\\def/ghi");
+
+    CHECK(std::wstring(p.c_str()) == L"abc\\def/ghi");
+
+    CHECK(p.string() == "abc\\def/ghi");
+    CHECK(p.wstring() == L"abc\\def/ghi");
+
+    CHECK(p.generic_string() == "abc/def/ghi");
+    CHECK(p.generic_wstring() == L"abc/def/ghi");
+
+    CHECK(p.generic_string<string>() == "abc/def/ghi");
+    CHECK(p.generic_string<wstring>() == L"abc/def/ghi");
+    CHECK(p.generic_string<path::string_type>() == L"abc/def/ghi");
+
+# else  // BOOST_POSIX_API
+
+    path p("abc\\def/ghi");
+
+    CHECK(string(p.c_str()) == "abc\\def/ghi");
+
+    CHECK(p.string() == "abc\\def/ghi");
+    CHECK(p.wstring() == L"abc\\def/ghi");
+
+    CHECK(p.generic_string() == "abc\\def/ghi");
+    CHECK(p.generic_wstring() == L"abc\\def/ghi");
+
+    CHECK(p.generic_string<string>() == "abc\\def/ghi");
+    CHECK(p.generic_string<wstring>() == L"abc\\def/ghi");
+    CHECK(p.generic_string<path::string_type>() == "abc\\def/ghi");
+
+# endif
+  }
+
+  //  test_relationals  ----------------------------------------------------------------//
+
+  void test_relationals()
+  {
+    std::cout << "testing relationals..." << std::endl;
+
+# ifdef BOOST_WINDOWS_API
+    // this is a critical use case to meet user expectations
+    CHECK(path("c:\\abc") == path("c:/abc"));
+# endif
+
+    const path p("bar");
+    const path p2("baz");
+
+    CHECK(!(p < p));
+    CHECK(p < p2);
+    CHECK(!(p2 < p));
+    CHECK(p < "baz");
+    CHECK(p < string("baz"));
+    CHECK(p < L"baz");
+    CHECK(p < wstring(L"baz"));
+    CHECK(!("baz" < p));
+    CHECK(!(string("baz") < p));
+    CHECK(!(L"baz" < p));
+    CHECK(!(wstring(L"baz") < p));
+
+    CHECK(p == p);
+    CHECK(!(p == p2));
+    CHECK(!(p2 == p));
+    CHECK(p2 == "baz");
+    CHECK(p2 == string("baz"));
+    CHECK(p2 == L"baz");
+    CHECK(p2 == wstring(L"baz"));
+    CHECK("baz" == p2);
+    CHECK(string("baz") == p2);
+    CHECK(L"baz" == p2);
+    CHECK(wstring(L"baz") == p2);
+
+    CHECK(!(p != p));
+    CHECK(p != p2);
+    CHECK(p2 != p);
+
+    CHECK(p <= p);
+    CHECK(p <= p2);
+    CHECK(!(p2 <= p));
+
+    CHECK(!(p > p));
+    CHECK(!(p > p2));
+    CHECK(p2 > p);
+
+    CHECK(p >= p);
+    CHECK(!(p >= p2));
+    CHECK(p2 >= p);
+}
+
+  //  test_inserter_and_extractor  -----------------------------------------------------//
+
+  void test_inserter_and_extractor()
+  {
+    std::cout << "testing inserter and extractor..." << std::endl;
+
+    path p1("foo");
+    path p2;
+
+    std::stringstream ss;
+
+    CHECK(p1 != p2);
+    ss << p1;
+    ss >> p2;
+    CHECK(p1 == p2);
+  }
+
+  //  test_other_non_members  ----------------------------------------------------------//
+
+  void test_other_non_members()
+  {
+    std::cout << "testing other_non_members..." << std::endl;
+
+    path p1("foo");
+    path p2("bar");
+
+    //  operator /
+
+    CHECK(p1 / p2 == path("foo/bar").make_preferred());
+    CHECK("foo" / p2 == path("foo/bar").make_preferred());
+    CHECK(L"foo" / p2 == path("foo/bar").make_preferred());
+    CHECK(string("foo") / p2 == path("foo/bar").make_preferred());
+    CHECK(wstring(L"foo") / p2 == path("foo/bar").make_preferred());
+    CHECK(p1 / "bar" == path("foo/bar").make_preferred());
+    CHECK(p1 / L"bar" == path("foo/bar").make_preferred());
+    CHECK(p1 / string("bar") == path("foo/bar").make_preferred());
+    CHECK(p1 / wstring(L"bar") == path("foo/bar").make_preferred());
+
+    swap(p1, p2);
+
+    CHECK(p1 == "bar");
+    CHECK(p2 == "foo");
+
+    CHECK(path("").remove_filename() == "");
+    CHECK(path("foo").remove_filename() == "");
+    CHECK(path("foo/bar").remove_filename() == "foo");
+  }
+
+//  //  test_modifiers  ------------------------------------------------------------------//
+//
+//  void test_modifiers()
+//  {
+//    std::cout << "testing modifiers..." << std::endl;
+//
+//  }
+
+  //  test_iterators  ------------------------------------------------------------------//
+
+  void test_iterators()
+  {
+    std::cout << "testing iterators..." << std::endl;
+
+    path p1;
+    CHECK(p1.begin() == p1.end());
+
+    path p2("/");
+    CHECK(p2.begin() != p2.end());
+    CHECK(*p2.begin() == "/");
+    CHECK(++p2.begin() == p2.end());
+
+    path p3("foo/bar/baz");
+
+    path::iterator it(p3.begin());
+    CHECK(p3.begin() != p3.end());
+    CHECK(*it == "foo");
+    CHECK(*++it == "bar");
+    CHECK(*++it == "baz");
+    CHECK(*--it == "bar");
+    CHECK(*--it == "foo");
+    CHECK(*++it == "bar");
+    CHECK(*++it == "baz");
+    CHECK(++it == p3.end());
+  }
+
+  //  test_modifiers  ------------------------------------------------------------------//
+
+  void test_modifiers()
+  {
+    std::cout << "testing modifiers..." << std::endl;
+
+//    CHECK(path("").make_absolute("") == "");  // should assert
+//    CHECK(path("").make_absolute("foo") == ""); // should assert
+
+#   ifdef BOOST_WINDOWS_API
+    CHECK(path("baa").make_absolute("c:/") == "c:/baa");
+    CHECK(path("/baa").make_absolute("c:/foo").string() == path("c:/baa").string());
+    CHECK(path("baa/baz").make_absolute("c:/foo/bar").string()
+      == path("c:/foo/bar\\baa/baz").string());
+#   else
+    CHECK(path("baa").make_absolute("/") == "/baa");
+    CHECK(path("/baa").make_absolute("/foo").string() == path("/baa").string());
+    CHECK(path("baa/baz").make_absolute("/foo/bar").string()
+      == path("/foo/bar/baa/baz").string());
+#   endif
+  }
+
+  //  test_decompositions  -------------------------------------------------------------//
+
+  void test_decompositions()
+  {
+    std::cout << "testing decompositions..." << std::endl;
+
+    CHECK(path("").root_name().string() == "");
+    CHECK(path("foo").root_name().string() == "");
+    CHECK(path("/").root_name().string() == "");
+    CHECK(path("/foo").root_name().string() == "");
+    CHECK(path("//netname").root_name().string() == "//netname");
+    CHECK(path("//netname/foo").root_name().string() == "//netname");
+
+    CHECK(path("").root_directory().string() == "");
+    CHECK(path("foo").root_directory().string() == "");
+    CHECK(path("/").root_directory().string() == "/");
+    CHECK(path("/foo").root_directory().string() == "/");
+    CHECK(path("//netname").root_directory().string() == "");
+    CHECK(path("//netname/foo").root_directory().string() == "/");
+
+    CHECK(path("").root_path().string() == "");
+    CHECK(path("/").root_path().string() == "/");
+    CHECK(path("/foo").root_path().string() == "/");
+    CHECK(path("//netname").root_path().string() == "//netname");
+    CHECK(path("//netname/foo").root_path().string() == "//netname/");
+
+#   ifdef BOOST_WINDOWS_API
+    CHECK(path("c:/foo").root_path().string() == "c:/");
+#   endif
+
+    CHECK(path("").relative_path().string() == "");
+    CHECK(path("/").relative_path().string() == "");
+    CHECK(path("/foo").relative_path().string() == "foo");
+
+    CHECK(path("").parent_path().string() == "");
+    CHECK(path("/").parent_path().string() == "");
+    CHECK(path("/foo").parent_path().string() == "/");
+    CHECK(path("/foo/bar").parent_path().string() == "/foo");
+
+    CHECK(path("/foo/bar/baz.zoo").filename().string() == "baz.zoo");
+
+    CHECK(path("/foo/bar/baz.zoo").stem().string() == "baz");
+    CHECK(path("/foo/bar.woo/baz").stem().string() == "baz");
+
+    CHECK(path("foo.bar.baz.tar.bz2").extension().string() == ".bz2");
+    CHECK(path("/foo/bar/baz.zoo").extension().string() == ".zoo");
+    CHECK(path("/foo/bar.woo/baz").extension().string() == "");
+  }
+
+  //  test_queries  --------------------------------------------------------------------//
+
+  void test_queries()
+  {
+    std::cout << "testing queries..." << std::endl;
+
+    path p1("");
+    path p2("//netname/foo.doo");
+
+    CHECK(p1.empty());
+    CHECK(!p1.has_root_path());
+    CHECK(!p1.has_root_name());
+    CHECK(!p1.has_root_directory());
+    CHECK(!p1.has_relative_path());
+    CHECK(!p1.has_parent_path());
+    CHECK(!p1.has_filename());
+    CHECK(!p1.has_stem());
+    CHECK(!p1.has_extension());
+    CHECK(!p1.is_absolute());
+    CHECK(p1.is_relative());
+
+    CHECK(!p2.empty());
+    CHECK(p2.has_root_path());
+    CHECK(p2.has_root_name());
+    CHECK(p2.has_root_directory());
+    CHECK(p2.has_relative_path());
+    CHECK(p2.has_parent_path());
+    CHECK(p2.has_filename());
+    CHECK(p2.has_stem());
+    CHECK(p2.has_extension());
+    CHECK(p2.is_absolute());
+    CHECK(!p2.is_relative());
+
+  }
+
+  //  test_imbue_locale  ---------------------------------------------------------------//
+
+  void test_imbue_locale()
+  {
+    std::cout << "testing imbue locale..." << std::endl;
+
+    //  \u2722 and \xE2\x9C\xA2 are UTF-16 and UTF-8 FOUR TEARDROP-SPOKED ASTERISK
+
+    std::cout << "  testing p0 ..." << std::endl;
+    path p0(L"\u2722");  // for tests that depend on path_traits::convert
+#   ifdef BOOST_WINDOWS_API
+    CHECK(p0.string() != "\xE2\x9C\xA2");
+#   endif
+    string p0_string(p0.string());
+
+    std::cout << "  testing p1 ..." << std::endl;
+    path p1("\xE2\x9C\xA2");
+#   ifdef BOOST_WINDOWS_API
+    CHECK(p1 != L"\u2722");
+#   endif
+    wstring p1_wstring(p1.wstring());
+
+    // So that tests are run with known encoding, use Boost UTF-8 codecvt
+    std::locale global_loc = std::locale();
+    std::locale loc(global_loc, new fs::detail::utf8_codecvt_facet);
+    std::cout << "  imbuing locale ..." << std::endl;
+    std::locale old_loc = path::imbue(loc);
+
+    std::cout << "  testing with the imbued locale ..." << std::endl;
+    CHECK(p0.string() == "\xE2\x9C\xA2");
+    path p2("\xE2\x9C\xA2");
+    CHECK(p2 == L"\u2722");
+    CHECK(p2.wstring() == L"\u2722");
+
+    std::cout << "  imbuing the original locale ..." << std::endl;
+    path::imbue(old_loc);
+
+    std::cout << "  testing with the original locale ..." << std::endl;
+    CHECK(p0.string() == p0_string);
+    path p3("\xE2\x9C\xA2");
+#   ifdef BOOST_WINDOWS_API
+    CHECK(p3 != L"\u2722");
+#   endif
+    CHECK(p3.wstring() == p1_wstring);
+
+    std::cout << "  locale testing complete" << std::endl;
+  }
+
+  //  test_overloads  ------------------------------------------------------------------//
+
+  void test_overloads()
+  {
+    std::cout << "testing overloads..." << std::endl;
+    std::string s("hello");
+    const char a[] = "goodbye";
+    path p1(s);
+    path p2(s.c_str());
+    path p3(a);
+    path p4("foo");
+
+    std::wstring ws(L"hello");
+    const wchar_t wa[] = L"goodbye";
+    path wp1(ws);
+    path wp2(ws.c_str());
+    path wp3(wa);
+    path wp4(L"foo");
+  }
+
+  //  test_error_handling  -------------------------------------------------------------//
+
+  class error_codecvt
+    : public std::codecvt< wchar_t, char, std::mbstate_t >
+  {
+  public:
+    explicit error_codecvt()
+        : std::codecvt<wchar_t, char, std::mbstate_t>() {}
+  protected:
+
+    virtual bool do_always_noconv() const throw() { return false; }
+    virtual int do_encoding() const throw() { return 0; }
+
+    virtual std::codecvt_base::result do_in(std::mbstate_t&,
+      const char*, const char*, const char*&,
+      wchar_t*, wchar_t*, wchar_t*&) const
+    {
+      static std::codecvt_base::result r = std::codecvt_base::noconv;
+      if (r == std::codecvt_base::partial) r = std::codecvt_base::error;
+      else if (r == std::codecvt_base::error) r = std::codecvt_base::noconv;
+      else r = std::codecvt_base::partial;
+      return r;
+    }
+
+    virtual std::codecvt_base::result do_out(std::mbstate_t &,
+      const wchar_t*, const wchar_t*, const wchar_t*&,
+      char*, char*, char*&) const
+    {
+      static std::codecvt_base::result r = std::codecvt_base::noconv;
+      if (r == std::codecvt_base::partial) r = std::codecvt_base::error;
+      else if (r == std::codecvt_base::error) r = std::codecvt_base::noconv;
+      else r = std::codecvt_base::partial;
+      return r;
+    }
+
+    virtual std::codecvt_base::result do_unshift(std::mbstate_t&,
+        char*, char*, char* &) const  { return ok; }
+    virtual int do_length(std::mbstate_t &,
+      const char*, const char*, std::size_t) const  { return 0; }
+    virtual int do_max_length() const throw () { return 0; }
+  };
+
+  void test_error_handling()
+  {
+    std::cout << "testing error handling..." << std::endl;
+
+    std::locale global_loc = std::locale();
+    std::locale loc(global_loc, new error_codecvt);
+    std::cout << "  imbuing error locale ..." << std::endl;
+    std::locale old_loc = path::imbue(loc);
+
+    //  These tests rely on a path constructor that fails in the locale conversion.
+    //  Thus construction has to call codecvt. Force that by using a narrow string
+    //  for Windows, and a wide string for POSIX.
+#   ifdef BOOST_WINDOWS_API
+#     define STRING_FOO_ "foo"
+#   else
+#     define STRING_FOO_ L"foo"
+#   endif
+
+    {
+      std::cout << "    testing std::codecvt_base::partial error..." << std::endl;
+      bool exception_thrown (false);
+      try { path(STRING_FOO_); }
+      catch (const bs::system_error & ex)
+      {
+        exception_thrown = true;
+        BOOST_TEST_EQ(ex.code(), bs::error_code(std::codecvt_base::partial,
+          fs::codecvt_error_category()));
+      }
+      catch (...) { std::cout << "***** unexpected exception type *****" << std::endl; }
+      BOOST_TEST(exception_thrown);
+    }
+
+    {
+      std::cout << "    testing std::codecvt_base::error error..." << std::endl;
+      bool exception_thrown (false);
+      try { path(STRING_FOO_); }
+      catch (const bs::system_error & ex)
+      {
+        exception_thrown = true;
+        BOOST_TEST_EQ(ex.code(), bs::error_code(std::codecvt_base::error,
+          fs::codecvt_error_category()));
+      }
+      catch (...) { std::cout << "***** unexpected exception type *****" << std::endl; }
+      BOOST_TEST(exception_thrown);
+    }
+
+    {
+      std::cout << "    testing std::codecvt_base::noconv error..." << std::endl;
+      bool exception_thrown (false);
+      try { path(STRING_FOO_); }
+      catch (const bs::system_error & ex)
+      {
+        exception_thrown = true;
+        BOOST_TEST_EQ(ex.code(), bs::error_code(std::codecvt_base::noconv,
+          fs::codecvt_error_category()));
+      }
+      catch (...) { std::cout << "***** unexpected exception type *****" << std::endl; }
+      BOOST_TEST(exception_thrown);
+    }
+
+    std::cout << "  restoring original locale ..." << std::endl;
+    path::imbue(old_loc);
+  }
+
+# if 0
+
+//  //  test_locales  --------------------------------------------------------------------//
+//
+//  void test_locales()
+//  {
+//    std::cout << "testing locales..." << std::endl;
+//
+//  }
+
+  //  test_user_supplied_type  ---------------------------------------------------------//
+
+  typedef std::basic_string<int> user_string;
+
+}  // unnamed namespace
+
+namespace boost
+{
+namespace filesystem
+{
+  namespace path_traits
+  {
+    template<> struct is_iterator<const user_string::value_type *> { static const bool value = true; };
+    template<> struct is_iterator<user_string::value_type *> { static const bool value = true; };
+    template<> struct is_iterator<user_string::iterator> { static const bool value = true; };
+    template<> struct is_iterator<user_string::const_iterator> { static const bool value = true; };
+    template<> struct is_container<user_string> { static const bool value = true; };
+
+    template<>
+    void append<user_string::value_type>(const user_string::value_type * begin,
+      const user_string::value_type * end, string_type & target, system::error_code & ec)
+    {
+      for (; begin != end && *begin; ++begin)
+        target += *begin + 1;  // change so that results distinguishable from char cvts
+    }
+
+#  ifdef __GNUC__
+    //  This specialization shouldn't be needed, and VC++, Intel, and others work
+    //  fine without it. But gcc 4.3.2, and presumably other versions, need it.
+    template<>
+    void append<user_string::value_type>(const user_string::value_type * begin,
+      string_type & target, system::error_code & ec)
+    {
+      path_traits::append<user_string::value_type>(begin,
+        static_cast<const user_string::value_type *>(0), target, ec);
+    }
+#  endif
+
+    template<>
+    user_string convert<user_string>(const string_type & source,
+      system::error_code & ec)
+    {
+      user_string temp;
+      for (string_type::const_iterator it = source.begin();
+            it != source.end(); ++it)
+        temp += *it - 1;
+      return temp;
+    }
+  }  // namespace path_traits
+}  // namespace filesystem
+}  // namespace boost
+
+namespace
+{
+
+  void test_user_supplied_type()
+  {
+    std::cout << "testing user supplied type..." << std::endl;
+
+    user_string::value_type usr_c_str[] = { 'a', 'b', 'c', 0 };
+    user_string usr(usr_c_str);
+
+    path p1(usr.c_str());
+    CHECK(p1 == path("bcd"));
+    CHECK(p1 == "bcd");
+    user_string s1(p1.string<user_string>());
+    CHECK(s1 == usr);
+  }
+
+# endif
+
+}  // unnamed namespace
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                                     main                                             //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+int main(int, char*[])
+{
+// document state of critical macros
+#ifdef BOOST_POSIX_API
+  cout << "BOOST_POSIX_API" << endl;
+#endif
+#ifdef BOOST_WINDOWS_API
+  cout << "BOOST_WINDOWS_API" << endl;
+#endif
+#ifdef BOOST_POSIX_API
+  cout << "BOOST_PATH_API" << endl;
+#endif
+#ifdef BOOST_WINDOWS_API
+  cout << "BOOST_WINDOWS_API" << endl;
+#endif
+
+  l.push_back('s');
+  l.push_back('t');
+  l.push_back('r');
+  l.push_back('i');
+  l.push_back('n');
+  l.push_back('g');
+
+  wl.push_back(L'w');
+  wl.push_back(L's');
+  wl.push_back(L't');
+  wl.push_back(L'r');
+  wl.push_back(L'i');
+  wl.push_back(L'n');
+  wl.push_back(L'g');
+
+  v.push_back('f');
+  v.push_back('u');
+  v.push_back('z');
+
+  wv.push_back(L'w');
+  wv.push_back(L'f');
+  wv.push_back(L'u');
+  wv.push_back(L'z');
+
+  test_overloads();
+  test_constructors();
+  test_assignments();
+  test_appends();
+  test_modifiers();
+  test_observers();
+  test_relationals();
+  test_inserter_and_extractor();
+  test_other_non_members();
+  test_iterators();
+  test_decompositions();
+  test_queries();
+  test_imbue_locale();
+  test_error_handling();
+
+# if 0
+
+  test_user_supplied_type();
+
+#endif
+
+  std::string foo("\\abc");
+  const char* bar = "/abc";
+
+  if (foo == bar)
+    cout << "unintended consequence\n";
+
+  return ::boost::report_errors();
+}