summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '3rdParty/Boost/src/libs/filesystem/v2')
-rw-r--r--3rdParty/Boost/src/libs/filesystem/v2/src/v2_operations.cpp1372
-rw-r--r--3rdParty/Boost/src/libs/filesystem/v2/src/v2_path.cpp177
-rw-r--r--3rdParty/Boost/src/libs/filesystem/v2/src/v2_portability.cpp119
3 files changed, 1668 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/libs/filesystem/v2/src/v2_operations.cpp b/3rdParty/Boost/src/libs/filesystem/v2/src/v2_operations.cpp
new file mode 100644
index 0000000..10df199
--- /dev/null
+++ b/3rdParty/Boost/src/libs/filesystem/v2/src/v2_operations.cpp
@@ -0,0 +1,1372 @@
+// operations.cpp ----------------------------------------------------------//
+
+// Copyright 2002-2005 Beman Dawes
+// Copyright 2001 Dietmar Kuehl
+// 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
+
+#ifndef BOOST_SYSTEM_NO_DEPRECATED
+# define BOOST_SYSTEM_NO_DEPRECATED
+#endif
+
+#define _POSIX_PTHREAD_SEMANTICS // Sun readdir_r() needs this
+
+#if !(defined(__HP_aCC) && defined(_ILP32) && \
+ !defined(_STATVFS_ACPP_PROBLEMS_FIXED))
+#define _FILE_OFFSET_BITS 64 // at worst, these defines may have no effect,
+#endif
+#define __USE_FILE_OFFSET64 // but that is harmless on Windows and on POSIX
+ // 64-bit systems or on 32-bit systems which don't have files larger
+ // than can be represented by a traditional POSIX/UNIX off_t type.
+ // OTOH, defining them should kick in 64-bit off_t's (and thus
+ // st_size) on 32-bit systems that provide the Large File
+ // Support (LFS) interface, such as Linux, Solaris, and IRIX.
+ // The defines are given before any headers are included to
+ // ensure that they are available to all included headers.
+ // That is required at least on Solaris, and possibly on other
+ // systems as well.
+
+// for some compilers (CodeWarrior, for example), windows.h
+// is getting included by some other boost header, so do this early:
+#if !defined(_WIN32_WINNT)
+#define _WIN32_WINNT 0x0500 // Default to Windows 2K or later
+#endif
+
+
+#include <boost/filesystem/v2/operations.hpp>
+#include <boost/scoped_array.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/detail/workaround.hpp>
+#include <cstdlib> // for malloc, free
+
+namespace fs = boost::filesystem2;
+using boost::system::error_code;
+using boost::system::system_category;
+
+# if defined(BOOST_WINDOWS_API)
+# include <windows.h>
+# include <ctime> // for time_t
+
+# else // BOOST_POSIX_API
+# include <sys/types.h>
+# if !defined(__APPLE__) && !defined(__OpenBSD__)
+# include <sys/statvfs.h>
+# define BOOST_STATVFS statvfs
+# define BOOST_STATVFS_F_FRSIZE vfs.f_frsize
+# else
+#ifdef __OpenBSD__
+# include <sys/param.h>
+#endif
+# include <sys/mount.h>
+# define BOOST_STATVFS statfs
+# define BOOST_STATVFS_F_FRSIZE static_cast<boost::uintmax_t>( vfs.f_bsize )
+# endif
+# include <dirent.h>
+# include <unistd.h>
+# include <fcntl.h>
+# include <utime.h>
+# include "limits.h"
+# endif
+
+// BOOST_FILESYSTEM_STATUS_CACHE enables file_status cache in
+// dir_itr_increment. The config tests are placed here because some of the
+// macros being tested come from dirent.h.
+//
+// TODO: find out what macros indicate dirent::d_type present in more libraries
+# if defined(BOOST_WINDOWS_API) \
+ || (defined(_DIRENT_HAVE_D_TYPE) /* defined by GNU C library if d_type present */ \
+ && !(defined(__SUNPRO_CC) && !defined(__sun))) // _DIRENT_HAVE_D_TYPE wrong for Sun compiler on Linux
+# define BOOST_FILESYSTEM_STATUS_CACHE
+# endif
+
+#include <sys/stat.h> // even on Windows some functions use stat()
+#include <string>
+#include <cstring>
+#include <cstdio> // for remove, rename
+#include <cerrno>
+#include <cassert>
+// #include <iostream> // for debugging only; comment out when not in use
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std { using ::strcmp; using ::remove; using ::rename; }
+#endif
+
+// helpers -----------------------------------------------------------------//
+
+namespace
+{
+ const error_code ok;
+
+ bool is_empty_directory( const std::string & dir_path )
+ {
+ static const fs::directory_iterator end_itr;
+ return fs::directory_iterator(fs::path(dir_path)) == end_itr;
+ }
+
+#ifdef BOOST_WINDOWS_API
+
+// For Windows, the xxxA form of various function names is used to avoid
+// inadvertently getting wide forms of the functions. (The undecorated
+// forms are actually macros, so can misfire if the user has various
+// other macros defined. There was a bug report of this happening.)
+
+ inline DWORD get_file_attributes( const char * ph )
+ { return ::GetFileAttributesA( ph ); }
+
+# ifndef BOOST_FILESYSTEM2_NARROW_ONLY
+
+ inline DWORD get_file_attributes( const wchar_t * ph )
+ { return ::GetFileAttributesW( ph ); }
+
+ bool is_empty_directory( const std::wstring & dir_path )
+ {
+ static const fs::wdirectory_iterator wend_itr;
+ return fs::wdirectory_iterator(fs::wpath(dir_path)) == wend_itr;
+ }
+
+ inline BOOL get_file_attributes_ex( const wchar_t * ph,
+ WIN32_FILE_ATTRIBUTE_DATA & fad )
+ { return ::GetFileAttributesExW( ph, ::GetFileExInfoStandard, &fad ); }
+
+ HANDLE create_file( const wchar_t * ph, DWORD dwDesiredAccess,
+ DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+ DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes,
+ HANDLE hTemplateFile )
+ {
+ return ::CreateFileW( ph, dwDesiredAccess, dwShareMode,
+ lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes,
+ hTemplateFile );
+ }
+
+ inline DWORD get_current_directory( DWORD sz, wchar_t * buf )
+ { return ::GetCurrentDirectoryW( sz, buf ); }
+
+ inline bool set_current_directory( const wchar_t * buf )
+ { return ::SetCurrentDirectoryW( buf ) != 0 ; }
+
+ inline bool get_free_disk_space( const std::wstring & ph,
+ PULARGE_INTEGER avail, PULARGE_INTEGER total, PULARGE_INTEGER free )
+ { return ::GetDiskFreeSpaceExW( ph.c_str(), avail, total, free ) != 0; }
+
+ inline std::size_t get_full_path_name(
+ const std::wstring & ph, std::size_t len, wchar_t * buf, wchar_t ** p )
+ {
+ return static_cast<std::size_t>(
+ ::GetFullPathNameW( ph.c_str(),
+ static_cast<DWORD>(len), buf, p ));
+ }
+
+ inline bool remove_directory( const std::wstring & ph )
+ { return ::RemoveDirectoryW( ph.c_str() ) != 0; }
+
+ inline bool delete_file( const std::wstring & ph )
+ { return ::DeleteFileW( ph.c_str() ) != 0; }
+
+ inline bool create_directory( const std::wstring & dir )
+ { return ::CreateDirectoryW( dir.c_str(), 0 ) != 0; }
+
+#if _WIN32_WINNT >= 0x500
+ inline bool create_hard_link( const std::wstring & to_ph,
+ const std::wstring & from_ph )
+ { return ::CreateHardLinkW( from_ph.c_str(), to_ph.c_str(), 0 ) != 0; }
+#endif
+
+# endif // ifndef BOOST_FILESYSTEM2_NARROW_ONLY
+
+ template< class String >
+ fs::file_status status_template( const String & ph, error_code & ec )
+ {
+ DWORD attr( get_file_attributes( ph.c_str() ) );
+ if ( attr == 0xFFFFFFFF )
+ {
+ ec = error_code( ::GetLastError(), system_category() );
+ if ((ec.value() == ERROR_FILE_NOT_FOUND)
+ || (ec.value() == ERROR_PATH_NOT_FOUND)
+ || (ec.value() == ERROR_INVALID_NAME) // "tools/jam/src/:sys:stat.h", "//foo"
+ || (ec.value() == ERROR_INVALID_DRIVE) // USB card reader with no card inserted
+ || (ec.value() == ERROR_NOT_READY) // CD/DVD drive with no disc inserted
+ || (ec.value() == ERROR_INVALID_PARAMETER) // ":sys:stat.h"
+ || (ec.value() == ERROR_BAD_PATHNAME) // "//nosuch" on Win64
+ || (ec.value() == ERROR_BAD_NETPATH)) // "//nosuch" on Win32
+ {
+ ec = ok; // these are not considered errors;
+ // the status is considered not found
+ return fs::file_status( fs::file_not_found );
+ }
+ else if ((ec.value() == ERROR_SHARING_VIOLATION))
+ {
+ ec = ok; // these are not considered errors;
+ // the file exists but the type is not known
+ return fs::file_status( fs::type_unknown );
+ }
+ return fs::file_status( fs::status_unknown );
+ }
+ ec = ok;;
+ return (attr & FILE_ATTRIBUTE_DIRECTORY)
+ ? fs::file_status( fs::directory_file )
+ : fs::file_status( fs::regular_file );
+ }
+
+ BOOL get_file_attributes_ex( const char * ph,
+ WIN32_FILE_ATTRIBUTE_DATA & fad )
+ { return ::GetFileAttributesExA( ph, ::GetFileExInfoStandard, &fad ); }
+
+ template< class String >
+ boost::filesystem2::detail::query_pair
+ is_empty_template( const String & ph )
+ {
+ WIN32_FILE_ATTRIBUTE_DATA fad;
+ if ( get_file_attributes_ex( ph.c_str(), fad ) == 0 )
+ return std::make_pair( error_code( ::GetLastError(), system_category() ), false );
+ return std::make_pair( ok,
+ ( fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
+ ? is_empty_directory( ph )
+ :( !fad.nFileSizeHigh && !fad.nFileSizeLow ) );
+ }
+
+ HANDLE create_file( const char * ph, DWORD dwDesiredAccess,
+ DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+ DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes,
+ HANDLE hTemplateFile )
+ {
+ return ::CreateFileA( ph, dwDesiredAccess, dwShareMode,
+ lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes,
+ hTemplateFile );
+ }
+
+ // Thanks to Jeremy Maitin-Shepard for much help and for permission to
+ // base the equivalent() implementation on portions of his
+ // file-equivalence-win32.cpp experimental code.
+ struct handle_wrapper
+ {
+ HANDLE handle;
+ handle_wrapper( HANDLE h )
+ : handle(h) {}
+ ~handle_wrapper()
+ {
+ if ( handle != INVALID_HANDLE_VALUE )
+ ::CloseHandle(handle);
+ }
+ };
+
+ template< class String >
+ boost::filesystem2::detail::query_pair
+ equivalent_template( const String & ph1, const String & ph2 )
+ {
+ // Note well: Physical location on external media is part of the
+ // equivalence criteria. If there are no open handles, physical location
+ // can change due to defragmentation or other relocations. Thus handles
+ // must be held open until location information for both paths has
+ // been retrieved.
+ handle_wrapper p1(
+ create_file(
+ ph1.c_str(),
+ 0,
+ FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+ 0,
+ OPEN_EXISTING,
+ FILE_FLAG_BACKUP_SEMANTICS,
+ 0 ) );
+ int error1(0); // save error code in case we have to throw
+ if ( p1.handle == INVALID_HANDLE_VALUE )
+ error1 = ::GetLastError();
+ handle_wrapper p2(
+ create_file(
+ ph2.c_str(),
+ 0,
+ FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+ 0,
+ OPEN_EXISTING,
+ FILE_FLAG_BACKUP_SEMANTICS,
+ 0 ) );
+ if ( p1.handle == INVALID_HANDLE_VALUE
+ || p2.handle == INVALID_HANDLE_VALUE )
+ {
+ if ( p1.handle != INVALID_HANDLE_VALUE
+ || p2.handle != INVALID_HANDLE_VALUE )
+ { return std::make_pair( ok, false ); }
+ assert( p1.handle == INVALID_HANDLE_VALUE
+ && p2.handle == INVALID_HANDLE_VALUE );
+ { return std::make_pair( error_code( error1, system_category()), false ); }
+ }
+ // at this point, both handles are known to be valid
+ BY_HANDLE_FILE_INFORMATION info1, info2;
+ if ( !::GetFileInformationByHandle( p1.handle, &info1 ) )
+ { return std::make_pair( error_code( ::GetLastError(), system_category() ), false ); }
+ if ( !::GetFileInformationByHandle( p2.handle, &info2 ) )
+ { return std::make_pair( error_code( ::GetLastError(), system_category() ), false ); }
+ // In theory, volume serial numbers are sufficient to distinguish between
+ // devices, but in practice VSN's are sometimes duplicated, so last write
+ // time and file size are also checked.
+ return std::make_pair( ok,
+ info1.dwVolumeSerialNumber == info2.dwVolumeSerialNumber
+ && info1.nFileIndexHigh == info2.nFileIndexHigh
+ && info1.nFileIndexLow == info2.nFileIndexLow
+ && info1.nFileSizeHigh == info2.nFileSizeHigh
+ && info1.nFileSizeLow == info2.nFileSizeLow
+ && info1.ftLastWriteTime.dwLowDateTime
+ == info2.ftLastWriteTime.dwLowDateTime
+ && info1.ftLastWriteTime.dwHighDateTime
+ == info2.ftLastWriteTime.dwHighDateTime );
+ }
+
+ template< class String >
+ boost::filesystem2::detail::uintmax_pair
+ file_size_template( const String & ph )
+ {
+ WIN32_FILE_ATTRIBUTE_DATA fad;
+ // by now, intmax_t is 64-bits on all Windows compilers
+ if ( get_file_attributes_ex( ph.c_str(), fad ) == 0 )
+ return std::make_pair( error_code( ::GetLastError(), system_category() ), 0 );
+ if ( (fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) !=0 )
+ return std::make_pair( error_code( ERROR_FILE_NOT_FOUND, system_category()), 0 );
+ return std::make_pair( ok,
+ (static_cast<boost::uintmax_t>(fad.nFileSizeHigh)
+ << (sizeof(fad.nFileSizeLow)*8))
+ + fad.nFileSizeLow );
+ }
+
+ inline bool get_free_disk_space( const std::string & ph,
+ PULARGE_INTEGER avail, PULARGE_INTEGER total, PULARGE_INTEGER free )
+ { return ::GetDiskFreeSpaceExA( ph.c_str(), avail, total, free ) != 0; }
+
+ template< class String >
+ boost::filesystem2::detail::space_pair
+ space_template( String & ph )
+ {
+ ULARGE_INTEGER avail, total, free;
+ boost::filesystem2::detail::space_pair result;
+ if ( get_free_disk_space( ph, &avail, &total, &free ) )
+ {
+ result.first = ok;
+ result.second.capacity
+ = (static_cast<boost::uintmax_t>(total.HighPart) << 32)
+ + total.LowPart;
+ result.second.free
+ = (static_cast<boost::uintmax_t>(free.HighPart) << 32)
+ + free.LowPart;
+ result.second.available
+ = (static_cast<boost::uintmax_t>(avail.HighPart) << 32)
+ + avail.LowPart;
+ }
+ else
+ {
+ result.first = error_code( ::GetLastError(), system_category() );
+ result.second.capacity = result.second.free
+ = result.second.available = 0;
+ }
+ return result;
+ }
+
+ inline DWORD get_current_directory( DWORD sz, char * buf )
+ { return ::GetCurrentDirectoryA( sz, buf ); }
+
+ template< class String >
+ error_code
+ get_current_path_template( String & ph )
+ {
+ DWORD sz;
+ if ( (sz = get_current_directory( 0,
+ static_cast<typename String::value_type*>(0) )) == 0 )
+ { sz = 1; }
+ typedef typename String::value_type value_type;
+ boost::scoped_array<value_type> buf( new value_type[sz] );
+ if ( get_current_directory( sz, buf.get() ) == 0 )
+ return error_code( ::GetLastError(), system_category() );
+ ph = buf.get();
+ return ok;
+ }
+
+ inline bool set_current_directory( const char * buf )
+ { return ::SetCurrentDirectoryA( buf ) != 0; }
+
+ template< class String >
+ error_code
+ set_current_path_template( const String & ph )
+ {
+ return error_code( set_current_directory( ph.c_str() )
+ ? 0 : ::GetLastError(), system_category() );
+ }
+
+ inline std::size_t get_full_path_name(
+ const std::string & ph, std::size_t len, char * buf, char ** p )
+ {
+ return static_cast<std::size_t>(
+ ::GetFullPathNameA( ph.c_str(),
+ static_cast<DWORD>(len), buf, p ));
+ }
+
+ const std::size_t buf_size( 128 );
+
+ template<class String>
+ error_code
+ get_full_path_name_template( const String & ph, String & target )
+ {
+ typename String::value_type buf[buf_size];
+ typename String::value_type * pfn;
+ std::size_t len = get_full_path_name( ph,
+ buf_size , buf, &pfn );
+ if ( len == 0 ) return error_code( ::GetLastError(), system_category() );
+ if ( len > buf_size )
+ {
+ typedef typename String::value_type value_type;
+ boost::scoped_array<value_type> big_buf( new value_type[len] );
+ if ( (len=get_full_path_name( ph, len , big_buf.get(), &pfn ))
+ == 0 ) return error_code( ::GetLastError(), system_category() );
+ big_buf[len] = '\0';
+ target = big_buf.get();
+ return ok;
+ }
+ buf[len] = '\0';
+ target = buf;
+ return ok;
+ }
+
+ template<class String>
+ error_code
+ get_file_write_time( const String & ph, FILETIME & last_write_time )
+ {
+ handle_wrapper hw(
+ create_file( ph.c_str(), 0,
+ FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
+ OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0 ) );
+ if ( hw.handle == INVALID_HANDLE_VALUE )
+ return error_code( ::GetLastError(), system_category() );
+ return error_code( ::GetFileTime( hw.handle, 0, 0, &last_write_time ) != 0
+ ? 0 : ::GetLastError(), system_category() );
+ }
+
+ template<class String>
+ error_code
+ set_file_write_time( const String & ph, const FILETIME & last_write_time )
+ {
+ handle_wrapper hw(
+ create_file( ph.c_str(), FILE_WRITE_ATTRIBUTES,
+ FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
+ OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0 ) );
+ if ( hw.handle == INVALID_HANDLE_VALUE )
+ return error_code( ::GetLastError(), system_category() );
+ return error_code( ::SetFileTime( hw.handle, 0, 0, &last_write_time ) != 0
+ ? 0 : ::GetLastError(), system_category() );
+ }
+
+ // these constants come from inspecting some Microsoft sample code
+ std::time_t to_time_t( const FILETIME & ft )
+ {
+ __int64 t = (static_cast<__int64>( ft.dwHighDateTime ) << 32)
+ + ft.dwLowDateTime;
+# if !defined( BOOST_MSVC ) || BOOST_MSVC > 1300 // > VC++ 7.0
+ t -= 116444736000000000LL;
+# else
+ t -= 116444736000000000;
+# endif
+ t /= 10000000;
+ return static_cast<std::time_t>( t );
+ }
+
+ void to_FILETIME( std::time_t t, FILETIME & ft )
+ {
+ __int64 temp = t;
+ temp *= 10000000;
+# if !defined( BOOST_MSVC ) || BOOST_MSVC > 1300 // > VC++ 7.0
+ temp += 116444736000000000LL;
+# else
+ temp += 116444736000000000;
+# endif
+ ft.dwLowDateTime = static_cast<DWORD>( temp );
+ ft.dwHighDateTime = static_cast<DWORD>( temp >> 32 );
+ }
+
+ template<class String>
+ boost::filesystem2::detail::time_pair
+ last_write_time_template( const String & ph )
+ {
+ FILETIME lwt;
+ error_code ec(
+ get_file_write_time( ph, lwt ) );
+ return std::make_pair( ec, to_time_t( lwt ) );
+ }
+
+ template<class String>
+ error_code
+ last_write_time_template( const String & ph, const std::time_t new_time )
+ {
+ FILETIME lwt;
+ to_FILETIME( new_time, lwt );
+ return set_file_write_time( ph, lwt );
+ }
+
+ bool remove_directory( const std::string & ph )
+ { return ::RemoveDirectoryA( ph.c_str() ) != 0; }
+
+ bool delete_file( const std::string & ph )
+ { return ::DeleteFileA( ph.c_str() ) != 0; }
+
+ template<class String>
+ error_code
+ remove_template( const String & ph )
+ {
+ // TODO: test this code in the presence of Vista symlinks,
+ // including dangling, self-referal, and cyclic symlinks
+ error_code ec;
+ fs::file_status sf( fs::detail::status_api( ph, ec ) );
+ if ( ec )
+ return ec;
+ if ( sf.type() == fs::file_not_found )
+ return ok;
+ if ( fs::is_directory( sf ) )
+ {
+ if ( !remove_directory( ph ) )
+ return error_code(::GetLastError(), system_category());
+ }
+ else
+ {
+ if ( !delete_file( ph ) ) return error_code(::GetLastError(), system_category());
+ }
+ return ok;
+ }
+
+ inline bool create_directory( const std::string & dir )
+ { return ::CreateDirectoryA( dir.c_str(), 0 ) != 0; }
+
+ template<class String>
+ boost::filesystem2::detail::query_pair
+ create_directory_template( const String & dir_ph )
+ {
+ error_code error, dummy;
+ if ( create_directory( dir_ph ) ) return std::make_pair( error, true );
+ error = error_code( ::GetLastError(), system_category() );
+ // an error here may simply mean the postcondition is already met
+ if ( error.value() == ERROR_ALREADY_EXISTS
+ && fs::is_directory( fs::detail::status_api( dir_ph, dummy ) ) )
+ return std::make_pair( ok, false );
+ return std::make_pair( error, false );
+ }
+
+#if _WIN32_WINNT >= 0x500
+ inline bool create_hard_link( const std::string & to_ph,
+ const std::string & from_ph )
+ { return ::CreateHardLinkA( from_ph.c_str(), to_ph.c_str(), 0 ) != 0; }
+#endif
+
+#if _WIN32_WINNT >= 0x500
+ template<class String>
+ error_code
+ create_hard_link_template( const String & to_ph,
+ const String & from_ph )
+ {
+ return error_code( create_hard_link( to_ph.c_str(), from_ph.c_str() )
+ ? 0 : ::GetLastError(), system_category() );
+ }
+#endif
+
+#else // BOOST_POSIX_API
+
+ int posix_remove( const char * p )
+ {
+# if defined(__QNXNTO__) || (defined(__MSL__) && (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)))
+ // Some Metrowerks C library versions fail on directories because of a
+ // known Metrowerks coding error in ::remove. Workaround is to call
+ // rmdir() or unlink() as indicated.
+ // Same bug also reported for QNX, with the same fix.
+ int err = ::unlink( p );
+ if ( err == 0 || errno != EPERM )
+ return err;
+ return ::rmdir( p );
+# else
+ return std::remove( p );
+# endif
+ }
+
+#endif
+} // unnamed namespace
+
+namespace boost
+{
+ namespace filesystem2
+ {
+ namespace detail
+ {
+ BOOST_FILESYSTEM_DECL system::error_code throws;
+
+// free functions ----------------------------------------------------------//
+
+ BOOST_FILESYSTEM_DECL error_code not_found_error()
+ {
+# ifdef BOOST_WINDOWS_API
+ return error_code(ERROR_PATH_NOT_FOUND, system_category());
+# else
+ return error_code(ENOENT, system_category());
+# endif
+ }
+
+ BOOST_FILESYSTEM_DECL bool possible_large_file_size_support()
+ {
+# ifdef BOOST_POSIX_API
+ struct stat lcl_stat;
+ return sizeof( lcl_stat.st_size ) > 4;
+# else
+ return true;
+# endif
+ }
+
+# ifdef BOOST_WINDOWS_API
+
+ BOOST_FILESYSTEM_DECL fs::file_status
+ status_api( const std::string & ph, error_code & ec )
+ { return status_template( ph, ec ); }
+
+# ifndef BOOST_FILESYSTEM2_NARROW_ONLY
+
+ BOOST_FILESYSTEM_DECL fs::file_status
+ status_api( const std::wstring & ph, error_code & ec )
+ { return status_template( ph, ec ); }
+
+ BOOST_FILESYSTEM_DECL bool symbolic_link_exists_api( const std::wstring & )
+ { return false; }
+
+ BOOST_FILESYSTEM_DECL
+ fs::detail::query_pair is_empty_api( const std::wstring & ph )
+ { return is_empty_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL
+ fs::detail::query_pair
+ equivalent_api( const std::wstring & ph1, const std::wstring & ph2 )
+ { return equivalent_template( ph1, ph2 ); }
+
+ BOOST_FILESYSTEM_DECL
+ fs::detail::uintmax_pair file_size_api( const std::wstring & ph )
+ { return file_size_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL
+ fs::detail::space_pair space_api( const std::wstring & ph )
+ { return space_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL
+ error_code
+ get_current_path_api( std::wstring & ph )
+ { return get_current_path_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL
+ error_code
+ set_current_path_api( const std::wstring & ph )
+ { return set_current_path_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL error_code
+ get_full_path_name_api( const std::wstring & ph, std::wstring & target )
+ { return get_full_path_name_template( ph, target ); }
+
+ BOOST_FILESYSTEM_DECL time_pair
+ last_write_time_api( const std::wstring & ph )
+ { return last_write_time_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL error_code
+ last_write_time_api( const std::wstring & ph, std::time_t new_value )
+ { return last_write_time_template( ph, new_value ); }
+
+ BOOST_FILESYSTEM_DECL fs::detail::query_pair
+ create_directory_api( const std::wstring & ph )
+ { return create_directory_template( ph ); }
+
+#if _WIN32_WINNT >= 0x500
+ BOOST_FILESYSTEM_DECL error_code
+ create_hard_link_api( const std::wstring & to_ph,
+ const std::wstring & from_ph )
+ { return create_hard_link_template( to_ph, from_ph ); }
+#endif
+
+ BOOST_FILESYSTEM_DECL error_code
+ create_symlink_api( const std::wstring & /*to_ph*/,
+ const std::wstring & /*from_ph*/ )
+ { return error_code( ERROR_NOT_SUPPORTED, system_category() ); }
+
+ BOOST_FILESYSTEM_DECL error_code
+ remove_api( const std::wstring & ph ) { return remove_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL error_code
+ rename_api( const std::wstring & from, const std::wstring & to )
+ {
+ return error_code( ::MoveFileW( from.c_str(), to.c_str() )
+ ? 0 : ::GetLastError(), system_category() );
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ copy_file_api( const std::wstring & from, const std::wstring & to, bool fail_if_exists )
+ {
+ return error_code( ::CopyFileW( from.c_str(), to.c_str(), fail_if_exists )
+ ? 0 : ::GetLastError(), system_category() );
+ }
+
+ BOOST_FILESYSTEM_DECL bool create_file_api( const std::wstring & ph,
+ std::ios_base::openmode mode ) // true if succeeds
+ {
+ DWORD access(
+ ((mode & std::ios_base::in) == 0 ? 0 : GENERIC_READ)
+ | ((mode & std::ios_base::out) == 0 ? 0 : GENERIC_WRITE) );
+
+ DWORD disposition(0); // see 27.8.1.3 Table 92
+ if ( (mode&~std::ios_base::binary)
+ == (std::ios_base::out|std::ios_base::app) )
+ disposition = OPEN_ALWAYS;
+ else if ( (mode&~(std::ios_base::binary|std::ios_base::out))
+ == std::ios_base::in ) disposition = OPEN_EXISTING;
+ else if ( ((mode&~(std::ios_base::binary|std::ios_base::trunc))
+ == std::ios_base::out )
+ || ((mode&~std::ios_base::binary)
+ == (std::ios_base::in|std::ios_base::out|std::ios_base::trunc)) )
+ disposition = CREATE_ALWAYS;
+ else assert( 0 && "invalid mode argument" );
+
+ HANDLE handle ( ::CreateFileW( ph.c_str(), access,
+ FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
+ disposition, (mode &std::ios_base::out) != 0
+ ? FILE_ATTRIBUTE_ARCHIVE : FILE_ATTRIBUTE_NORMAL, 0 ) );
+ if ( handle == INVALID_HANDLE_VALUE ) return false;
+ ::CloseHandle( handle );
+ return true;
+ }
+
+ BOOST_FILESYSTEM_DECL std::string narrow_path_api(
+ const std::wstring & ph ) // return is empty if fails
+ {
+ std::string narrow_short_form;
+ std::wstring short_form;
+ for ( DWORD buf_sz( static_cast<DWORD>( ph.size()+1 ));; )
+ {
+ boost::scoped_array<wchar_t> buf( new wchar_t[buf_sz] );
+ DWORD sz( ::GetShortPathNameW( ph.c_str(), buf.get(), buf_sz ) );
+ if ( sz == 0 ) return narrow_short_form;
+ if ( sz <= buf_sz )
+ {
+ short_form += buf.get();
+ break;
+ }
+ buf_sz = sz + 1;
+ }
+ // contributed by Takeshi Mouri:
+ int narrow_sz( ::WideCharToMultiByte( CP_ACP, 0,
+ short_form.c_str(), static_cast<int>(short_form.size()), 0, 0, 0, 0 ) );
+ boost::scoped_array<char> narrow_buf( new char[narrow_sz] );
+ ::WideCharToMultiByte( CP_ACP, 0,
+ short_form.c_str(), static_cast<int>(short_form.size()),
+ narrow_buf.get(), narrow_sz, 0, 0 );
+ narrow_short_form.assign(narrow_buf.get(), narrow_sz);
+
+ return narrow_short_form;
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ dir_itr_first( void *& handle, const std::wstring & dir,
+ std::wstring & target, file_status & sf, file_status & symlink_sf )
+ {
+ // use a form of search Sebastian Martel reports will work with Win98
+ std::wstring dirpath( dir );
+ dirpath += (dirpath.empty()
+ || dirpath[dirpath.size()-1] != L'\\') ? L"\\*" : L"*";
+
+ WIN32_FIND_DATAW data;
+ if ( (handle = ::FindFirstFileW( dirpath.c_str(), &data ))
+ == INVALID_HANDLE_VALUE )
+ {
+ handle = 0;
+ return error_code( ::GetLastError() == ERROR_FILE_NOT_FOUND
+ ? 0 : ::GetLastError(), system_category() );
+ }
+ target = data.cFileName;
+ if ( data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
+ { sf.type( directory_file ); symlink_sf.type( directory_file ); }
+ else { sf.type( regular_file ); symlink_sf.type( regular_file ); }
+ return ok;
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ dir_itr_increment( void *& handle, std::wstring & target,
+ file_status & sf, file_status & symlink_sf )
+ {
+ WIN32_FIND_DATAW data;
+ if ( ::FindNextFileW( handle, &data ) == 0 ) // fails
+ {
+ int error = ::GetLastError();
+ dir_itr_close( handle );
+ return error_code( error == ERROR_NO_MORE_FILES ? 0 : error, system_category() );
+ }
+ target = data.cFileName;
+ if ( data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
+ { sf.type( directory_file ); symlink_sf.type( directory_file ); }
+ else { sf.type( regular_file ); symlink_sf.type( regular_file ); }
+ return ok;
+ }
+
+# endif // ifndef BOOST_FILESYSTEM2_NARROW_ONLY
+
+ // suggested by Walter Landry
+ BOOST_FILESYSTEM_DECL bool symbolic_link_exists_api( const std::string & )
+ { return false; }
+
+ BOOST_FILESYSTEM_DECL
+ fs::detail::query_pair is_empty_api( const std::string & ph )
+ { return is_empty_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL
+ fs::detail::query_pair
+ equivalent_api( const std::string & ph1, const std::string & ph2 )
+ { return equivalent_template( ph1, ph2 ); }
+
+ BOOST_FILESYSTEM_DECL
+ fs::detail::uintmax_pair file_size_api( const std::string & ph )
+ { return file_size_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL
+ fs::detail::space_pair space_api( const std::string & ph )
+ { return space_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL
+ error_code
+ get_current_path_api( std::string & ph )
+ { return get_current_path_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL
+ error_code
+ set_current_path_api( const std::string & ph )
+ { return set_current_path_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL error_code
+ get_full_path_name_api( const std::string & ph, std::string & target )
+ { return get_full_path_name_template( ph, target ); }
+
+ BOOST_FILESYSTEM_DECL time_pair
+ last_write_time_api( const std::string & ph )
+ { return last_write_time_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL error_code
+ last_write_time_api( const std::string & ph, std::time_t new_value )
+ { return last_write_time_template( ph, new_value ); }
+
+ BOOST_FILESYSTEM_DECL fs::detail::query_pair
+ create_directory_api( const std::string & ph )
+ { return create_directory_template( ph ); }
+
+#if _WIN32_WINNT >= 0x500
+ BOOST_FILESYSTEM_DECL error_code
+ create_hard_link_api( const std::string & to_ph,
+ const std::string & from_ph )
+ {
+ return create_hard_link_template( to_ph, from_ph );
+ }
+#endif
+
+ BOOST_FILESYSTEM_DECL error_code
+ create_symlink_api( const std::string & /*to_ph*/,
+ const std::string & /*from_ph*/ )
+ { return error_code( ERROR_NOT_SUPPORTED, system_category() ); }
+
+ BOOST_FILESYSTEM_DECL error_code
+ remove_api( const std::string & ph ) { return remove_template( ph ); }
+
+ BOOST_FILESYSTEM_DECL error_code
+ rename_api( const std::string & from, const std::string & to )
+ {
+ return error_code( ::MoveFileA( from.c_str(), to.c_str() )
+ ? 0 : ::GetLastError(), system_category() );
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ copy_file_api( const std::string & from, const std::string & to, bool fail_if_exists )
+ {
+ return error_code( ::CopyFileA( from.c_str(), to.c_str(), fail_if_exists )
+ ? 0 : ::GetLastError(), system_category() );
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ dir_itr_first( void *& handle, const std::string & dir,
+ std::string & target, file_status & sf, file_status & symlink_sf )
+ // Note: an empty root directory has no "." or ".." entries, so this
+ // causes a ERROR_FILE_NOT_FOUND error which we do not considered an
+ // error. It is treated as eof instead.
+ {
+ // use a form of search Sebastian Martel reports will work with Win98
+ std::string dirpath( dir );
+ dirpath += (dirpath.empty()
+ || (dirpath[dirpath.size()-1] != '\\'
+ && dirpath[dirpath.size()-1] != ':')) ? "\\*" : "*";
+
+ WIN32_FIND_DATAA data;
+ if ( (handle = ::FindFirstFileA( dirpath.c_str(), &data ))
+ == INVALID_HANDLE_VALUE )
+ {
+ handle = 0;
+ return error_code( (::GetLastError() == ERROR_FILE_NOT_FOUND
+ // Windows Mobile returns ERROR_NO_MORE_FILES; see ticket #3551
+ || ::GetLastError() == ERROR_NO_MORE_FILES)
+ ? 0 : ::GetLastError(), system_category() );
+ }
+ target = data.cFileName;
+ if ( data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
+ { sf.type( directory_file ); symlink_sf.type( directory_file ); }
+ else { sf.type( regular_file ); symlink_sf.type( regular_file ); }
+ return ok;
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ dir_itr_close( void *& handle )
+ {
+ if ( handle != 0 )
+ {
+ bool ok = ::FindClose( handle ) != 0;
+ handle = 0;
+ return error_code( ok ? 0 : ::GetLastError(), system_category() );
+ }
+ return ok;
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ dir_itr_increment( void *& handle, std::string & target,
+ file_status & sf, file_status & symlink_sf )
+ {
+ WIN32_FIND_DATAA data;
+ if ( ::FindNextFileA( handle, &data ) == 0 ) // fails
+ {
+ int error = ::GetLastError();
+ dir_itr_close( handle );
+ return error_code( error == ERROR_NO_MORE_FILES ? 0 : error, system_category() );
+ }
+ target = data.cFileName;
+ if ( data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
+ { sf.type( directory_file ); symlink_sf.type( directory_file ); }
+ else { sf.type( regular_file ); symlink_sf.type( regular_file ); }
+ return ok;
+ }
+
+# else // BOOST_POSIX_API
+
+ BOOST_FILESYSTEM_DECL fs::file_status
+ status_api( const std::string & ph, error_code & ec )
+ {
+ struct stat path_stat;
+ if ( ::stat( ph.c_str(), &path_stat ) != 0 )
+ {
+ if ( errno == ENOENT || errno == ENOTDIR )
+ {
+ ec = ok;
+ return fs::file_status( fs::file_not_found );
+ }
+ ec = error_code( errno, system_category() );
+ return fs::file_status( fs::status_unknown );
+ }
+ ec = ok;
+ if ( S_ISDIR( path_stat.st_mode ) )
+ return fs::file_status( fs::directory_file );
+ if ( S_ISREG( path_stat.st_mode ) )
+ return fs::file_status( fs::regular_file );
+ if ( S_ISBLK( path_stat.st_mode ) )
+ return fs::file_status( fs::block_file );
+ if ( S_ISCHR( path_stat.st_mode ) )
+ return fs::file_status( fs::character_file );
+ if ( S_ISFIFO( path_stat.st_mode ) )
+ return fs::file_status( fs::fifo_file );
+ if ( S_ISSOCK( path_stat.st_mode ) )
+ return fs::file_status( fs::socket_file );
+ return fs::file_status( fs::type_unknown );
+ }
+
+ BOOST_FILESYSTEM_DECL fs::file_status
+ symlink_status_api( const std::string & ph, error_code & ec )
+ {
+ struct stat path_stat;
+ if ( ::lstat( ph.c_str(), &path_stat ) != 0 )
+ {
+ if ( errno == ENOENT || errno == ENOTDIR )
+ {
+ ec = ok;
+ return fs::file_status( fs::file_not_found );
+ }
+ ec = error_code( errno, system_category() );
+ return fs::file_status( fs::status_unknown );
+ }
+ ec = ok;
+ if ( S_ISREG( path_stat.st_mode ) )
+ return fs::file_status( fs::regular_file );
+ if ( S_ISDIR( path_stat.st_mode ) )
+ return fs::file_status( fs::directory_file );
+ if ( S_ISLNK( path_stat.st_mode ) )
+ return fs::file_status( fs::symlink_file );
+ if ( S_ISBLK( path_stat.st_mode ) )
+ return fs::file_status( fs::block_file );
+ if ( S_ISCHR( path_stat.st_mode ) )
+ return fs::file_status( fs::character_file );
+ if ( S_ISFIFO( path_stat.st_mode ) )
+ return fs::file_status( fs::fifo_file );
+ if ( S_ISSOCK( path_stat.st_mode ) )
+ return fs::file_status( fs::socket_file );
+ return fs::file_status( fs::type_unknown );
+ }
+
+ // suggested by Walter Landry
+ BOOST_FILESYSTEM_DECL bool
+ symbolic_link_exists_api( const std::string & ph )
+ {
+ struct stat path_stat;
+ return ::lstat( ph.c_str(), &path_stat ) == 0
+ && S_ISLNK( path_stat.st_mode );
+ }
+
+ BOOST_FILESYSTEM_DECL query_pair
+ is_empty_api( const std::string & ph )
+ {
+ struct stat path_stat;
+ if ( (::stat( ph.c_str(), &path_stat )) != 0 )
+ return std::make_pair( error_code( errno, system_category() ), false );
+ return std::make_pair( ok, S_ISDIR( path_stat.st_mode )
+ ? is_empty_directory( ph )
+ : path_stat.st_size == 0 );
+ }
+
+ BOOST_FILESYSTEM_DECL query_pair
+ equivalent_api( const std::string & ph1, const std::string & ph2 )
+ {
+ struct stat s2;
+ int e2( ::stat( ph2.c_str(), &s2 ) );
+ struct stat s1;
+ int e1( ::stat( ph1.c_str(), &s1 ) );
+ if ( e1 != 0 || e2 != 0 )
+ return std::make_pair( error_code( e1 != 0 && e2 != 0 ? errno : 0, system_category() ), false );
+ // at this point, both stats are known to be valid
+ return std::make_pair( ok,
+ s1.st_dev == s2.st_dev
+ && s1.st_ino == s2.st_ino
+ // According to the POSIX stat specs, "The st_ino and st_dev fields
+ // taken together uniquely identify the file within the system."
+ // Just to be sure, size and mod time are also checked.
+ && s1.st_size == s2.st_size
+ && s1.st_mtime == s2.st_mtime );
+ }
+
+ BOOST_FILESYSTEM_DECL uintmax_pair
+ file_size_api( const std::string & ph )
+ {
+ struct stat path_stat;
+ if ( ::stat( ph.c_str(), &path_stat ) != 0 )
+ return std::make_pair( error_code( errno, system_category() ), 0 );
+ if ( !S_ISREG( path_stat.st_mode ) )
+ return std::make_pair( error_code( EPERM, system_category() ), 0 );
+ return std::make_pair( ok,
+ static_cast<boost::uintmax_t>(path_stat.st_size) );
+ }
+
+ BOOST_FILESYSTEM_DECL space_pair
+ space_api( const std::string & ph )
+ {
+ struct BOOST_STATVFS vfs;
+ space_pair result;
+ if ( ::BOOST_STATVFS( ph.c_str(), &vfs ) != 0 )
+ {
+ result.first = error_code( errno, system_category() );
+ result.second.capacity = result.second.free
+ = result.second.available = 0;
+ }
+ else
+ {
+ result.first = ok;
+ result.second.capacity
+ = static_cast<boost::uintmax_t>(vfs.f_blocks) * BOOST_STATVFS_F_FRSIZE;
+ result.second.free
+ = static_cast<boost::uintmax_t>(vfs.f_bfree) * BOOST_STATVFS_F_FRSIZE;
+ result.second.available
+ = static_cast<boost::uintmax_t>(vfs.f_bavail) * BOOST_STATVFS_F_FRSIZE;
+ }
+ return result;
+ }
+
+ BOOST_FILESYSTEM_DECL time_pair
+ last_write_time_api( const std::string & ph )
+ {
+ struct stat path_stat;
+ if ( ::stat( ph.c_str(), &path_stat ) != 0 )
+ return std::make_pair( error_code( errno, system_category() ), 0 );
+ return std::make_pair( ok, path_stat.st_mtime );
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ last_write_time_api( const std::string & ph, std::time_t new_value )
+ {
+ struct stat path_stat;
+ if ( ::stat( ph.c_str(), &path_stat ) != 0 )
+ return error_code( errno, system_category() );
+ ::utimbuf buf;
+ buf.actime = path_stat.st_atime; // utime() updates access time too:-(
+ buf.modtime = new_value;
+ return error_code( ::utime( ph.c_str(), &buf ) != 0 ? errno : 0, system_category() );
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ get_current_path_api( std::string & ph )
+ {
+ for ( long path_max = 32;; path_max *=2 ) // loop 'til buffer large enough
+ {
+ boost::scoped_array<char>
+ buf( new char[static_cast<std::size_t>(path_max)] );
+ if ( ::getcwd( buf.get(), static_cast<std::size_t>(path_max) ) == 0 )
+ {
+ if ( errno != ERANGE
+ // bug in some versions of the Metrowerks C lib on the Mac: wrong errno set
+# if defined(__MSL__) && (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))
+ && errno != 0
+# endif
+ ) return error_code( errno, system_category() );
+ }
+ else
+ {
+ ph = buf.get();
+ break;
+ }
+ }
+ return ok;
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ set_current_path_api( const std::string & ph )
+ {
+ return error_code( ::chdir( ph.c_str() )
+ ? errno : 0, system_category() );
+ }
+
+ BOOST_FILESYSTEM_DECL fs::detail::query_pair
+ create_directory_api( const std::string & ph )
+ {
+ if ( ::mkdir( ph.c_str(), S_IRWXU|S_IRWXG|S_IRWXO ) == 0 )
+ { return std::make_pair( ok, true ); }
+ int ec=errno;
+ error_code dummy;
+ if ( ec != EEXIST
+ || !fs::is_directory( status_api( ph, dummy ) ) )
+ { return std::make_pair( error_code( ec, system_category() ), false ); }
+ return std::make_pair( ok, false );
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ create_hard_link_api( const std::string & to_ph,
+ const std::string & from_ph )
+ {
+ return error_code( ::link( to_ph.c_str(), from_ph.c_str() ) == 0
+ ? 0 : errno, system_category() );
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ create_symlink_api( const std::string & to_ph,
+ const std::string & from_ph )
+ {
+ return error_code( ::symlink( to_ph.c_str(), from_ph.c_str() ) == 0
+ ? 0 : errno, system_category() );
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ remove_api( const std::string & ph )
+ {
+ if ( posix_remove( ph.c_str() ) == 0 )
+ return ok;
+ int error = errno;
+ // POSIX says "If the directory is not an empty directory, rmdir()
+ // shall fail and set errno to EEXIST or ENOTEMPTY."
+ // Linux uses ENOTEMPTY, Solaris uses EEXIST.
+ if ( error == EEXIST ) error = ENOTEMPTY;
+
+ error_code ec;
+
+ // ignore errors if post-condition satisfied
+ return status_api(ph, ec).type() == file_not_found
+ ? ok : error_code( error, system_category() ) ;
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ rename_api( const std::string & from, const std::string & to )
+ {
+ // POSIX is too permissive so must check
+ error_code dummy;
+ if ( fs::exists( status_api( to, dummy ) ) )
+ return error_code( EEXIST, system_category() );
+ return error_code( std::rename( from.c_str(), to.c_str() ) != 0
+ ? errno : 0, system_category() );
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ copy_file_api( const std::string & from_file_ph,
+ const std::string & to_file_ph, bool fail_if_exists )
+ {
+ const std::size_t buf_sz = 32768;
+ boost::scoped_array<char> buf( new char [buf_sz] );
+ int infile=-1, outfile=-1; // -1 means not open
+
+ // bug fixed: code previously did a stat() on the from_file first, but that
+ // introduced a gratuitous race condition; the stat() is now done after the open()
+
+ if ( (infile = ::open( from_file_ph.c_str(), O_RDONLY )) < 0 )
+ { return error_code( errno, system_category() ); }
+
+ struct stat from_stat;
+ if ( ::stat( from_file_ph.c_str(), &from_stat ) != 0 )
+ { return error_code( errno, system_category() ); }
+
+ int oflag = O_CREAT | O_WRONLY;
+ if ( fail_if_exists ) oflag |= O_EXCL;
+ if ( (outfile = ::open( to_file_ph.c_str(), oflag, from_stat.st_mode )) < 0 )
+ {
+ int open_errno = errno;
+ BOOST_ASSERT( infile >= 0 );
+ ::close( infile );
+ return error_code( open_errno, system_category() );
+ }
+
+ ssize_t sz, sz_read=1, sz_write;
+ while ( sz_read > 0
+ && (sz_read = ::read( infile, buf.get(), buf_sz )) > 0 )
+ {
+ // Allow for partial writes - see Advanced Unix Programming (2nd Ed.),
+ // Marc Rochkind, Addison-Wesley, 2004, page 94
+ sz_write = 0;
+ do
+ {
+ if ( (sz = ::write( outfile, buf.get() + sz_write,
+ sz_read - sz_write )) < 0 )
+ {
+ sz_read = sz; // cause read loop termination
+ break; // and error to be thrown after closes
+ }
+ sz_write += sz;
+ } while ( sz_write < sz_read );
+ }
+
+ if ( ::close( infile) < 0 ) sz_read = -1;
+ if ( ::close( outfile) < 0 ) sz_read = -1;
+
+ return error_code( sz_read < 0 ? errno : 0, system_category() );
+ }
+
+ // this code is based on Stevens and Rago, Advanced Programming in the
+ // UNIX envirnment, 2nd Ed., ISBN 0-201-43307-9, page 49
+ error_code path_max( std::size_t & result )
+ {
+# ifdef PATH_MAX
+ static std::size_t max = PATH_MAX;
+# else
+ static std::size_t max = 0;
+# endif
+ if ( max == 0 )
+ {
+ errno = 0;
+ long tmp = ::pathconf( "/", _PC_NAME_MAX );
+ if ( tmp < 0 )
+ {
+ if ( errno == 0 ) // indeterminate
+ max = 4096; // guess
+ else return error_code( errno, system_category() );
+ }
+ else max = static_cast<std::size_t>( tmp + 1 ); // relative root
+ }
+ result = max;
+ return ok;
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ dir_itr_first( void *& handle, void *& buffer,
+ const std::string & dir, std::string & target,
+ file_status &, file_status & )
+ {
+ if ( (handle = ::opendir( dir.c_str() )) == 0 )
+ return error_code( errno, system_category() );
+ target = std::string( "." ); // string was static but caused trouble
+ // when iteration called from dtor, after
+ // static had already been destroyed
+ std::size_t path_size (0); // initialization quiets gcc warning
+ error_code ec = path_max( path_size );
+ if ( ec ) return ec;
+ dirent de;
+ buffer = std::malloc( (sizeof(dirent) - sizeof(de.d_name))
+ + path_size + 1 ); // + 1 for "/0"
+ return ok;
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ dir_itr_close( void *& handle, void*& buffer )
+ {
+ std::free( buffer );
+ buffer = 0;
+ if ( handle == 0 ) return ok;
+ DIR * h( static_cast<DIR*>(handle) );
+ handle = 0;
+ return error_code( ::closedir( h ) == 0 ? 0 : errno, system_category() );
+ }
+
+ // warning: the only dirent member updated is d_name
+ inline int readdir_r_simulator( DIR * dirp, struct dirent * entry,
+ struct dirent ** result ) // *result set to 0 on end of directory
+ {
+ errno = 0;
+
+ # if !defined(__CYGWIN__) \
+ && defined(_POSIX_THREAD_SAFE_FUNCTIONS) \
+ && defined(_SC_THREAD_SAFE_FUNCTIONS) \
+ && (_POSIX_THREAD_SAFE_FUNCTIONS+0 >= 0) \
+ && (!defined(__hpux) || defined(_REENTRANT)) \
+ && (!defined(_AIX) || defined(__THREAD_SAFE))
+ if ( ::sysconf( _SC_THREAD_SAFE_FUNCTIONS ) >= 0 )
+ { return ::readdir_r( dirp, entry, result ); }
+ # endif
+
+ struct dirent * p;
+ *result = 0;
+ if ( (p = ::readdir( dirp )) == 0 )
+ return errno;
+ std::strcpy( entry->d_name, p->d_name );
+ *result = entry;
+ return 0;
+ }
+
+ BOOST_FILESYSTEM_DECL error_code
+ dir_itr_increment( void *& handle, void *& buffer,
+ std::string & target, file_status & sf, file_status & symlink_sf )
+ {
+ BOOST_ASSERT( buffer != 0 );
+ dirent * entry( static_cast<dirent *>(buffer) );
+ dirent * result;
+ int return_code;
+ if ( (return_code = readdir_r_simulator( static_cast<DIR*>(handle),
+ entry, &result )) != 0 ) return error_code( errno, system_category() );
+ if ( result == 0 ) return dir_itr_close( handle, buffer );
+ target = entry->d_name;
+# ifdef BOOST_FILESYSTEM_STATUS_CACHE
+ if ( entry->d_type == DT_UNKNOWN ) // filesystem does not supply d_type value
+ {
+ sf = symlink_sf = fs::file_status(fs::status_unknown);
+ }
+ else // filesystem supplies d_type value
+ {
+ if ( entry->d_type == DT_DIR )
+ sf = symlink_sf = fs::file_status( fs::directory_file );
+ else if ( entry->d_type == DT_REG )
+ sf = symlink_sf = fs::file_status( fs::regular_file );
+ else if ( entry->d_type == DT_LNK )
+ {
+ sf = fs::file_status( fs::status_unknown );
+ symlink_sf = fs::file_status( fs::symlink_file );
+ }
+ else sf = symlink_sf = fs::file_status( fs::status_unknown );
+ }
+# else
+ sf = symlink_sf = fs::file_status( fs::status_unknown );
+# endif
+ return ok;
+ }
+
+# endif
+ } // namespace detail
+ } // namespace filesystem2
+} // namespace boost
diff --git a/3rdParty/Boost/src/libs/filesystem/v2/src/v2_path.cpp b/3rdParty/Boost/src/libs/filesystem/v2/src/v2_path.cpp
new file mode 100644
index 0000000..7adeaff
--- /dev/null
+++ b/3rdParty/Boost/src/libs/filesystem/v2/src/v2_path.cpp
@@ -0,0 +1,177 @@
+// path.cpp ----------------------------------------------------------------//
+
+// Copyright 2005 Beman Dawes
+
+// 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/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
+
+#ifndef BOOST_SYSTEM_NO_DEPRECATED
+# define BOOST_SYSTEM_NO_DEPRECATED
+#endif
+
+#include <boost/filesystem/v2/config.hpp>
+
+#ifndef BOOST_FILESYSTEM2_NARROW_ONLY
+
+#include <boost/filesystem/v2/path.hpp>
+#include <boost/scoped_array.hpp>
+
+#include <locale>
+#include <boost/cerrno.hpp>
+#include <boost/system/error_code.hpp>
+
+#include <cwchar> // for std::mbstate_t
+
+#if defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
+# include <boost/filesystem/detail/utf8_codecvt_facet.hpp>
+#endif
+
+
+namespace
+{
+ // 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 & loc()
+ {
+#if !defined(macintosh) && !defined(__APPLE__) && !defined(__APPLE_CC__)
+ // ISO C calls this "the locale-specific native environment":
+ static std::locale lc("");
+#else // Mac OS
+ // "All BSD system functions expect their string parameters to be in UTF-8 encoding
+ // and nothing else."
+ // See http://developer.apple.com/mac/library/documentation/MacOSX/Conceptual/BPInternational/Articles/FileEncodings.html
+ std::locale global_loc = std::locale(); // Mac OS doesn't support locale("")
+ static std::locale lc(global_loc,
+ new boost::filesystem::detail::utf8_codecvt_facet);
+#endif
+ return lc;
+ }
+
+ const std::codecvt<wchar_t, char, std::mbstate_t> *&
+ converter()
+ {
+ static const std::codecvt<wchar_t, char, std::mbstate_t> *
+ cvtr(
+ &std::use_facet<std::codecvt<wchar_t, char, std::mbstate_t> >
+ ( loc() ) );
+ return cvtr;
+ }
+
+ bool locked(false);
+} // unnamed namespace
+
+namespace boost
+{
+ namespace filesystem2
+ {
+ bool wpath_traits::imbue( const std::locale & new_loc, const std::nothrow_t & )
+ {
+ if ( locked ) return false;
+ locked = true;
+ loc() = new_loc;
+ converter() = &std::use_facet
+ <std::codecvt<wchar_t, char, std::mbstate_t> >( loc() );
+ return true;
+ }
+
+ void wpath_traits::imbue( const std::locale & new_loc )
+ {
+ if ( locked ) boost::throw_exception(
+ wfilesystem_error(
+ "boost::filesystem::wpath_traits::imbue() after lockdown",
+ make_error_code( system::errc::not_supported ) ) );
+ imbue( new_loc, std::nothrow );
+ }
+
+ //namespace detail
+ //{
+ // BOOST_FILESYSTEM_DECL
+ // const char * what( const char * sys_err_what,
+ // const path & path1, const path & path2, std::string & target)
+ // {
+ // try
+ // {
+ // if ( target.empty() )
+ // {
+ // target = sys_err_what;
+ // if ( !path1.empty() )
+ // {
+ // target += ": \"";
+ // target += path1.file_string();
+ // target += "\"";
+ // }
+ // if ( !path2.empty() )
+ // {
+ // target += ", \"";
+ // target += path2.file_string();
+ // target += "\"";
+ // }
+ // }
+ // return target.c_str();
+ // }
+ // catch (...)
+ // {
+ // return sys_err_what;
+ // }
+ // }
+ //}
+
+# ifdef BOOST_POSIX_API
+
+// Because this is POSIX only code, we don't have to worry about ABI issues
+// described in http://www.boost.org/more/separate_compilation.html
+
+ wpath_traits::external_string_type
+ wpath_traits::to_external( const wpath & ph,
+ const internal_string_type & src )
+ {
+ locked = true;
+ std::size_t work_size( converter()->max_length() * (src.size()+1) );
+ boost::scoped_array<char> work( new char[ work_size ] );
+ std::mbstate_t state = std::mbstate_t(); // perhaps unneeded, but cuts bug reports
+ const internal_string_type::value_type * from_next;
+ external_string_type::value_type * to_next;
+ if ( converter()->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( boost::filesystem::wfilesystem_error(
+ "boost::filesystem::wpath::to_external conversion error",
+ ph, system::error_code( system::errc::invalid_argument, system::system_category() ) ) );
+ *to_next = '\0';
+ return external_string_type( work.get() );
+ }
+
+ wpath_traits::internal_string_type
+ wpath_traits::to_internal( const external_string_type & src )
+ {
+ locked = true;
+ std::size_t work_size( src.size()+1 );
+ boost::scoped_array<wchar_t> work( new wchar_t[ work_size ] );
+ std::mbstate_t state = std::mbstate_t(); // perhaps unneeded, but cuts bug reports
+ const external_string_type::value_type * from_next;
+ internal_string_type::value_type * to_next;
+ if ( converter()->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( boost::filesystem::wfilesystem_error(
+ "boost::filesystem::wpath::to_internal conversion error",
+ system::error_code( system::errc::invalid_argument, system::system_category() ) ) );
+ *to_next = L'\0';
+ return internal_string_type( work.get() );
+ }
+# endif // BOOST_POSIX_API
+
+ } // namespace filesystem2
+} // namespace boost
+
+#endif // ifndef BOOST_FILESYSTEM2_NARROW_ONLY
diff --git a/3rdParty/Boost/src/libs/filesystem/v2/src/v2_portability.cpp b/3rdParty/Boost/src/libs/filesystem/v2/src/v2_portability.cpp
new file mode 100644
index 0000000..4d27543
--- /dev/null
+++ b/3rdParty/Boost/src/libs/filesystem/v2/src/v2_portability.cpp
@@ -0,0 +1,119 @@
+// 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
+
+#ifndef BOOST_SYSTEM_NO_DEPRECATED
+# define BOOST_SYSTEM_NO_DEPRECATED
+#endif
+
+#include <boost/filesystem/v2/config.hpp>
+#include <boost/filesystem/v2/path.hpp>
+
+namespace fs = boost::filesystem2;
+
+#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 filesystem2
+ {
+
+ // 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 filesystem2
+} // namespace boost