.cirrus.yml

@@ -1,6 +1,6 @@
 freebsd_task:
   freebsd_instance:
-    image_family: freebsd-14-0
+    image_family: freebsd-12-1
   install_script: |
     pkg install -y cmake
     pw groupadd testgrp
@@ -11,24 +11,25 @@ freebsd_task:
   test_script: |
     sudo -u testuser .ci/unix-test.sh
 
-rockylinux8_task:
+centos7_task:
   container:
-    image: docker.io/rockylinux:8
+    image: centos:7
   install_script: |
-    dnf group install -y "Development Tools"
+    yum install -y centos-release-scl
-    dnf install cmake -y
+    yum install -y devtoolset-9
+    curl -L https://github.com/Kitware/CMake/releases/download/v3.16.4/cmake-3.16.4-Linux-x86_64.tar.gz | tar xzvf - -C /usr/local --strip-components 1
   build_script: |
-    .ci/unix-build.sh
+    source /opt/rh/devtoolset-9/enable && PATH=$PATH:/usr/local/bin .ci/unix-build.sh
   test_script: |
-    .ci/unix-test.sh
+    PATH=$PATH:/usr/local/bin .ci/unix-test.sh
 
-rockylinux9_task:
+centos8_task:
   container:
-    image: docker.io/rockylinux:9
+    image: quay.io/centos/centos:stream8
   install_script: |
-    dnf group install -y "Development Tools"
+    yum group install -y "Development Tools"
-    dnf install cmake -y
+    curl -L https://github.com/Kitware/CMake/releases/download/v3.16.4/cmake-3.16.4-Linux-x86_64.tar.gz | tar xzvf - -C /usr/local --strip-components 1
   build_script: |
-    .ci/unix-build.sh
+    PATH=$PATH:/usr/local/bin .ci/unix-build.sh
   test_script: |
-    .ci/unix-test.sh
+    PATH=$PATH:/usr/local/bin .ci/unix-test.sh

.github/workflows/build_cmake.yml

@@ -10,42 +10,6 @@ jobs:
       fail-fast: false
       matrix:
         config:
-          - name: "Ubuntu 22.04 GCC 11"
-            os: ubuntu-22.04
-            build_type: Release
-            packages: ninja-build
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: gcc
-            cxx: g++
-
-          - name: "Ubuntu 22.04 Clang 13.0"
-            os: ubuntu-22.04
-            build_type: Release
-            packages: ninja-build libc++-13-dev libc++abi-13-dev
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: clang-13
-            cxx: clang++-13
-
-          - name: "Ubuntu 22.04 Clang 15.0"
-            os: ubuntu-22.04
-            build_type: Release
-            packages: ninja-build libc++-15-dev libc++abi-15-dev
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: clang-15
-            cxx: clang++-15
-
-          - name: "Ubuntu 22.04 GCC 11 coverage"
-            os: ubuntu-22.04
-            build_type: Debug
-            packages: ninja-build lcov
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: gcc
-            cxx: g++
-
           - name: "Ubuntu 20.04 GCC 9.3"
             os: ubuntu-20.04
             build_type: Release
@@ -82,6 +46,69 @@ jobs:
             cc: gcc
             cxx: g++
 
+          - name: "Ubuntu 18.04 GCC 8.4"
+            os: ubuntu-18.04
+            build_type: Release
+            packages: ninja-build gcc-8 g++-8
+            generator: Ninja
+            compatibility: "cxx_std_11;cxx_std_17"
+            cc: gcc-8
+            cxx: g++-8
+
+          - name: "Ubuntu 18.04 GCC 7.5"
+            os: ubuntu-18.04
+            build_type: Release
+            packages: ninja-build
+            generator: Ninja
+            compatibility: "cxx_std_11;cxx_std_17"
+            cc: gcc-7
+            cxx: g++-7
+
+          - name: "Ubuntu 18.04 GCC 6.5"
+            os: ubuntu-18.04
+            build_type: Release
+            packages: ninja-build gcc-6 g++-6
+            generator: Ninja
+            compatibility: "cxx_std_11;cxx_std_17"
+            cc: gcc-6
+            cxx: g++-6
+
+          - name: "Ubuntu 18.04 GCC 5.5"
+            os: ubuntu-18.04
+            build_type: Release
+            packages: ninja-build gcc-5 g++-5
+            generator: Ninja
+            compatibility: "cxx_std_11;cxx_std_17"
+            cc: gcc-5
+            cxx: g++-5
+
+          - name: "Ubuntu 18.04 Clang 9.0"
+            os: ubuntu-18.04
+            build_type: Release
+            packages: ninja-build libc++-9-dev libc++abi-9-dev
+            generator: Ninja
+            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
+            cc: clang
+            cxx: clang++
+
+          - name: "Ubuntu 18.04 Clang 6.0"
+            os: ubuntu-18.04
+            build_type: Release
+            packages: ninja-build clang-6.0
+            generator: Ninja
+            compatibility: "cxx_std_11;cxx_std_17"
+            cc: clang-6.0
+            cxx: clang++-6.0
+
+          - name: "Ubuntu 18.04 Clang 5.0"
+            os: ubuntu-18.04
+            build_type: Release
+            packages: ninja-build clang-5.0
+            generator: Ninja
+            compatibility: "cxx_std_11;cxx_std_17"
+            cc: clang-5.0
+            cxx: clang++-5.0
+
           - name: "Windows MSVC 2019"
             os: windows-2019
             build_type: Release
@@ -91,12 +118,21 @@ jobs:
             cc: cl
             cxx: cl
 
-          - name: "macOS 13 AppleClang"
+          - name: "macOS 10.15 AppleClang"
-            os: macos-13
+            os: macos-10.15
             build_type: Release
             packages: ninja
             generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
+            compatibility: "cxx_std_11;cxx_std_17"
+            cc: clang
+            cxx: clang++
+
+          - name: "macOS 11.6 AppleClang"
+            os: macos-11
+            build_type: Release
+            packages: ninja
+            generator: Ninja
+            compatibility: "cxx_std_11;cxx_std_17"
             cc: clang
             cxx: clang++
 

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.7.2)
 project(
    ghcfilesystem,
-   VERSION 1.5.15
+   VERSION 1.5.14
 )
 
 if (POLICY CMP0077)
@@ -35,11 +35,9 @@ endif()
 if(CMAKE_CXX_STANDARD LESS 11)
     message(FATAL_ERROR "CMAKE_CXX_STANDARD is less than 11, ghc::filesystem only works with C++11 and above.")
 endif()
-if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+message(STATUS "System name: ${CMAKE_SYSTEM_NAME}")
-    message(STATUS "System name: ${CMAKE_SYSTEM_NAME}")
+message(STATUS "Compiler ID: ${CMAKE_CXX_COMPILER_ID}")
-    message(STATUS "Compiler ID: ${CMAKE_CXX_COMPILER_ID}")
+message(STATUS "CMAKE_CXX_COMPILE_FEATURES: ${CMAKE_CXX_COMPILE_FEATURES}")
-    message(STATUS "CMAKE_CXX_COMPILE_FEATURES: ${CMAKE_CXX_COMPILE_FEATURES}")
-endif()
 
 add_library(ghc_filesystem INTERFACE)
 add_library(ghcFilesystem::ghc_filesystem ALIAS ghc_filesystem)

README.md

@@ -176,83 +176,60 @@ Everything is in the namespace `ghc::filesystem`, so one way to use it only as
 a fallback could be:
 
 ```cpp
-#if _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
+#ifdef __APPLE__
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
+#include <Availability.h> // for deployment target to support pre-catalina targets without std::fs 
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || __IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __TV_OS_VERSION_MIN_REQUIRED && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __WATCH_OS_VERSION_MAX_ALLOWED && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif  
-        #endif
-    #endif
 #endif
-
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
-#ifdef GHC_USE_STD_FS
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
-    #include <filesystem>
+#define GHC_USE_STD_FS
-    namespace fs = std::filesystem;
+#include <filesystem>
-#else
+namespace fs = std::filesystem;
-    #include "filesystem.hpp"
+#endif
-    namespace fs = ghc::filesystem;
+#endif
+#ifndef GHC_USE_STD_FS
+#include <ghc/filesystem.hpp>
+namespace fs = ghc::filesystem;
 #endif
 ```
 
+**Note that this code uses a two-stage preprocessor condition because Visual Studio 2015
+doesn't like the `(<...>)` syntax, even if it could cut evaluation early before. This code also
+used the minimum deployment target to detect if `std::filesystem` really is available on macOS
+compilation.**
+
+**Note also, this detection now works on MSVC versions prior to 15.7 on, or without setting
+the `/Zc:__cplusplus` compile switch that would fix `__cplusplus` on MSVC. (Without the switch
+the compiler always reports `199711L`
+([see](https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/)),
+but `_MSVC_LANG` works without it.**
+
 If you want to also use the `fstream` wrapper with `path` support as fallback,
 you might use:
 
 ```cpp
-#if _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
+#ifdef __APPLE__
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
+#include <Availability.h> // for deployment target to support pre-catalina targets without std::fs 
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || __IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __TV_OS_VERSION_MIN_REQUIRED && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __WATCH_OS_VERSION_MAX_ALLOWED && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif  
-        #endif
-    #endif
 #endif
-
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
-#ifdef GHC_USE_STD_FS
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
-    #include <filesystem>
+#define GHC_USE_STD_FS
-    namespace fs {
+#include <filesystem>
-        using namespace std::filesystem;
+namespace fs {
-        using ifstream = std::ifstream;
+using namespace std::filesystem;
-        using ofstream = std::ofstream;
+using ifstream = std::ifstream;
-        using fstream = std::fstream;
+using ofstream = std::ofstream;
-    }
+using fstream = std::fstream;
-#else
+}
-    #include "filesystem.hpp"
+#endif
-    namespace fs {
+#endif
-        using namespace ghc::filesystem;
+#ifndef GHC_USE_STD_FS
-        using ifstream = ghc::filesystem::ifstream;
+#include <ghc/filesystem.hpp>
-        using ofstream = ghc::filesystem::ofstream;
+namespace fs {
-        using fstream = ghc::filesystem::fstream;
+using namespace ghc::filesystem;
-    }
+using ifstream = ghc::filesystem::ifstream;
+using ofstream = ghc::filesystem::ofstream;
+using fstream = ghc::filesystem::fstream;
+}
 #endif
 ```
 
@@ -292,46 +269,29 @@ If you use the forwarding/implementation approach, you can still use the dynamic
 switching like this:
 
 ```cpp
-#if _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
+#ifdef __APPLE__
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
+#include <Availability.h> // for deployment target to support pre-catalina targets without std::fs
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || __IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __TV_OS_VERSION_MIN_REQUIRED && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __WATCH_OS_VERSION_MAX_ALLOWED && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif  
-        #endif
-    #endif
 #endif
-
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
-#ifdef GHC_USE_STD_FS
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
-    #include <filesystem>
+#define GHC_USE_STD_FS
-    namespace fs {
+#include <filesystem>
-        using namespace std::filesystem;
+namespace fs {
-        using ifstream = std::ifstream;
+using namespace std::filesystem;
-        using ofstream = std::ofstream;
+using ifstream = std::ifstream;
-        using fstream = std::fstream;
+using ofstream = std::ofstream;
-    }
+using fstream = std::fstream;
-#else
+}
-    #include "fs_fwd.hpp"
+#endif
-    namespace fs {
+#endif
-        using namespace ghc::filesystem;
+#ifndef GHC_USE_STD_FS
-        using ifstream = ghc::filesystem::ifstream;
+#include <ghc/fs-fwd.hpp>
-        using ofstream = ghc::filesystem::ofstream;
+namespace fs {
-        using fstream = ghc::filesystem::fstream;
+using namespace ghc::filesystem;
-    }
+using ifstream = ghc::filesystem::ifstream;
+using ofstream = ghc::filesystem::ofstream;
+using fstream = ghc::filesystem::fstream;
+}
 #endif
 ```
 
@@ -339,38 +299,25 @@ and in the implementation hiding cpp, you might use (before any include that inc
 to take precedence:
 
 ```cpp
-#if _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
+#ifdef __APPLE__ // for deployment target to support pre-catalina targets without std::fs 
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
+#include <Availability.h>
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
+#endif
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
-        #define GHC_USE_STD_FS
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
-
+#define GHC_USE_STD_FS
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
+#endif
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || __IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __TV_OS_VERSION_MIN_REQUIRED && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __WATCH_OS_VERSION_MAX_ALLOWED && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif  
-        #endif
-    #endif
 #endif
-
 #ifndef GHC_USE_STD_FS
-    #include "fs_impl.hpp"
+#define GHC_FILESYSTEM_IMPLEMENTATION
+#include <ghc/filesystem.hpp>
 #endif
 ```
 
 :information_source: **Hint:** There are additional helper headers, named `ghc/fs_std_fwd.hpp` and
 `ghc/fs_std_impl.hpp` that use this technique, so you can simply include them
-if you want to dynamically select the filesystem implementation.
+if you want to dynamically select the filesystem implementation. they also
+enable the `wchar_t` support on `ghc::filesystem` on Windows, so the resulting
+implementation in the `fs` namespace will be compatible.
 
 
 
@@ -397,10 +344,6 @@ The `CMakeLists.txt` offers a few options to customize its behavior:
   `CMAKE_CXX_COMPILE_FEATURES` when the detection of C++17 or C++20 for additional tests
   is not working (e.g. `cxx_std_20` to enforce building a `filesystem_test_cpp20` with C++20).
 
-### Bazel
-
-Please use [hedronvision/bazel-cc-filesystem-backport](https://github.com/hedronvision/bazel-cc-filesystem-backport), which will automatically set everything up for you.
-
 ### Versioning
 
 There is a version macro `GHC_FILESYSTEM_VERSION` defined in case future changes
@@ -466,7 +409,7 @@ int main(int argc, char* argv[])
         exit(EXIT_FAILURE);
     }
 
-    // now use argc/argv as usual, they have utf-8 encoding on windows
+    // now use argc/argv as usual, they have utf-8 enconding on windows
     // ...
 
     return 0;
@@ -646,12 +589,6 @@ to the expected behavior.
 
 ## Release Notes
 
-### v1.5.15 (wip)
-
-* Fix for [#166](https://github.com/gulrak/filesystem/issues/166),
-  `extension()` did return non empty result for the directory name
-  `".."`
-
 ###  [v1.5.14](https://github.com/gulrak/filesystem/releases/tag/v1.5.14)
 
 * Pull request [#163](https://github.com/gulrak/filesystem/pull/163), build

include/ghc/filesystem.hpp

@@ -25,6 +25,23 @@
 // SOFTWARE.
 //
 //---------------------------------------------------------------------------------------
+//
+// To dynamically select std::filesystem where available on most platforms,
+// you could use:
+//
+// #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
+// #if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
+// #define GHC_USE_STD_FS
+// #include <filesystem>
+// namespace fs = std::filesystem;
+// #endif
+// #endif
+// #ifndef GHC_USE_STD_FS
+// #include <ghc/filesystem.hpp>
+// namespace fs = ghc::filesystem;
+// #endif
+//
+//---------------------------------------------------------------------------------------
 #ifndef GHC_FILESYSTEM_H
 #define GHC_FILESYSTEM_H
 
@@ -36,7 +53,7 @@
 
 #ifndef GHC_OS_DETECTED
 #if defined(__APPLE__) && defined(__MACH__)
-#define GHC_OS_APPLE
+#define GHC_OS_MACOS
 #elif defined(__linux__)
 #define GHC_OS_LINUX
 #if defined(__ANDROID__)
@@ -164,7 +181,7 @@
 #include <langinfo.h>
 #endif
 #endif
-#ifdef GHC_OS_APPLE
+#ifdef GHC_OS_MACOS
 #include <Availability.h>
 #endif
 
@@ -291,7 +308,7 @@
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // ghc::filesystem version in decimal (major * 10000 + minor * 100 + patch)
-#define GHC_FILESYSTEM_VERSION 10515L
+#define GHC_FILESYSTEM_VERSION 10514L
 
 #if !defined(GHC_WITH_EXCEPTIONS) && (defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND))
 #define GHC_WITH_EXCEPTIONS
@@ -1142,10 +1159,6 @@ GHC_FS_API void create_hard_link(const path& to, const path& new_hard_link, std:
 GHC_FS_API uintmax_t hard_link_count(const path& p, std::error_code& ec) noexcept;
 #endif
 
-#if defined(GHC_OS_WINDOWS) && (!defined(__GLIBCXX__) || (defined(_GLIBCXX_HAVE__WFOPEN) && defined(_GLIBCXX_USE_WCHAR_T)))
-#define GHC_HAS_FSTREAM_OPEN_WITH_WCHAR
-#endif
-
 // Non-C++17 add-on std::fstream wrappers with path
 template <class charT, class traits = std::char_traits<charT>>
 class basic_filebuf : public std::basic_filebuf<charT, traits>
@@ -1157,7 +1170,7 @@ public:
     const basic_filebuf& operator=(const basic_filebuf&) = delete;
     basic_filebuf<charT, traits>* open(const path& p, std::ios_base::openmode mode)
     {
-#ifdef GHC_HAS_FSTREAM_OPEN_WITH_WCHAR
+#if defined(GHC_OS_WINDOWS) && !defined(__GLIBCXX__)
         return std::basic_filebuf<charT, traits>::open(p.wstring().c_str(), mode) ? this : 0;
 #else
         return std::basic_filebuf<charT, traits>::open(p.string().c_str(), mode) ? this : 0;
@@ -1170,7 +1183,7 @@ class basic_ifstream : public std::basic_ifstream<charT, traits>
 {
 public:
     basic_ifstream() {}
-#ifdef GHC_HAS_FSTREAM_OPEN_WITH_WCHAR
+#if defined(GHC_OS_WINDOWS) && !defined(__GLIBCXX__)
     explicit basic_ifstream(const path& p, std::ios_base::openmode mode = std::ios_base::in)
         : std::basic_ifstream<charT, traits>(p.wstring().c_str(), mode)
     {
@@ -1193,7 +1206,7 @@ class basic_ofstream : public std::basic_ofstream<charT, traits>
 {
 public:
     basic_ofstream() {}
-#ifdef GHC_HAS_FSTREAM_OPEN_WITH_WCHAR
+#if defined(GHC_OS_WINDOWS) && !defined(__GLIBCXX__)
     explicit basic_ofstream(const path& p, std::ios_base::openmode mode = std::ios_base::out)
         : std::basic_ofstream<charT, traits>(p.wstring().c_str(), mode)
     {
@@ -1216,7 +1229,7 @@ class basic_fstream : public std::basic_fstream<charT, traits>
 {
 public:
     basic_fstream() {}
-#ifdef GHC_HAS_FSTREAM_OPEN_WITH_WCHAR
+#if defined(GHC_OS_WINDOWS) && !defined(__GLIBCXX__)
     explicit basic_fstream(const path& p, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out)
         : std::basic_fstream<charT, traits>(p.wstring().c_str(), mode)
     {
@@ -3157,7 +3170,7 @@ GHC_INLINE path path::extension() const
         auto iter = end();
         const auto& fn = *--iter;
         impl_string_type::size_type pos = fn._path.rfind('.');
-        if (pos != std::string::npos && pos > 0 && fn._path != "..") {
+        if (pos != std::string::npos && pos > 0) {
             return path(fn._path.substr(pos), native_format);
         }
     }
@@ -3306,9 +3319,6 @@ GHC_INLINE path path::lexically_relative(const path& base) const
             --count;
         }
     }
-    if (count == 0 && (a == end() || a->empty())) {
-        return path(".");
-    }
     if (count < 0) {
         return path();
     }
@@ -3977,7 +3987,7 @@ GHC_INLINE bool copy_file(const path& from, const path& to, copy_options options
     }
     ssize_t br, bw;
     while (true) {
-        do { br = ::read(in, buffer.data(), buffer.size()); } while(errno == EINTR && !br);
+        do { br = ::read(in, buffer.data(), buffer.size()); } while(errno == EINTR);
         if(!br) {
             break;
         }
@@ -4229,7 +4239,7 @@ GHC_INLINE path current_path(std::error_code& ec)
     }
     return path(std::wstring(buffer.get()), path::native_format);
 #elif defined(__GLIBC__)
-    std::unique_ptr<char, decltype(&std::free)> buffer { ::get_current_dir_name(), std::free };
+    std::unique_ptr<char, decltype(&std::free)> buffer { ::getcwd(NULL, 0), std::free };
     if (buffer == nullptr) {
         ec = detail::make_system_error();
         return path();
@@ -4640,11 +4650,9 @@ GHC_INLINE void last_write_time(const path& p, file_time_type new_time, std::err
     if (!::SetFileTime(file.get(), 0, 0, &ft)) {
         ec = detail::make_system_error();
     }
-#elif defined(GHC_OS_APPLE) && \
+#elif defined(GHC_OS_MACOS) && \
-    (__MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101300 \
+    (__MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_13) || (__IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_11_0) || \
-     || __IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED < 110000 \
+    (__TV_OS_VERSION_MIN_REQUIRED < __TVOS_11_0) || (__WATCH_OS_VERSION_MIN_REQUIRED < __WATCHOS_4_0)
-     || __TV_OS_VERSION_MIN_REQUIRED && __TVOS_VERSION_MIN_REQUIRED < 110000 \
-     || __WATCH_OS_VERSION_MIN_REQUIRED && __WATCHOS_VERSION_MIN_REQUIRED < 40000)
     struct ::stat fs;
     if (::stat(p.c_str(), &fs) == 0) {
         struct ::timeval tv[2];
@@ -5696,7 +5704,7 @@ public:
         , _entry(nullptr)
     {
         if (!path.empty()) {
-            do { _dir = ::opendir(path.native().c_str()); } while(errno == EINTR && !_dir);
+            do { _dir = ::opendir(path.native().c_str()); } while(errno == EINTR);
             if (!_dir) {
                 auto error = errno;
                 _base = filesystem::path();
@@ -5723,7 +5731,7 @@ public:
             do {
                 skip = false;
                 errno = 0;
-                do { _entry = ::readdir(_dir); } while(errno == EINTR && !_entry);
+                do { _entry = ::readdir(_dir); } while(errno == EINTR);
                 if (_entry) {
                     _dir_entry._path = _base;
                     _dir_entry._path.append_name(_entry->d_name);

include/ghc/fs_fwd.hpp

@@ -25,7 +25,7 @@
 // SOFTWARE.
 //
 //---------------------------------------------------------------------------------------
-// fs_fwd.hpp - The forwarding header for the header/implementation separated usage of
+// fs_fwd.hpp - The forwarding header for the header/implementation seperated usage of
 //              ghc::filesystem.
 // This file can be include at any place, where ghc::filesystem api is needed while
 // not bleeding implementation details (e.g. system includes) into the global namespace,
@@ -34,5 +34,5 @@
 #ifndef GHC_FILESYSTEM_FWD_H
 #define GHC_FILESYSTEM_FWD_H
 #define GHC_FILESYSTEM_FWD
-#include "filesystem.hpp"
+#include <ghc/filesystem.hpp>
 #endif // GHC_FILESYSTEM_FWD_H

include/ghc/fs_impl.hpp

@@ -25,11 +25,11 @@
 // SOFTWARE.
 //
 //---------------------------------------------------------------------------------------
-// fs_impl.hpp - The implementation header for the header/implementation separated usage of
+// fs_impl.hpp - The implementation header for the header/implementation seperated usage of
 //               ghc::filesystem.
 // This file can be used to hide the implementation of ghc::filesystem into a single cpp.
 // The cpp has to include this before including fs_fwd.hpp directly or via a different
 // header to work.
 //---------------------------------------------------------------------------------------
 #define GHC_FILESYSTEM_IMPLEMENTATION
-#include "filesystem.hpp"
+#include <ghc/filesystem.hpp>

include/ghc/fs_std.hpp

@@ -31,47 +31,30 @@
 //---------------------------------------------------------------------------------------
 #ifndef GHC_FILESYSTEM_STD_H
 #define GHC_FILESYSTEM_STD_H
-
+#if defined(__APPLE__)
-#if defined(_MSVC_LANG) && _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
+#include <Availability.h>
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__TV_OS_VERSION_MIN_REQUIRED) && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__WATCH_OS_VERSION_MAX_ALLOWED) && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif
-        #endif
-    #endif
 #endif
-
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
-#ifdef GHC_USE_STD_FS
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
-    #include <filesystem>
+#define GHC_USE_STD_FS
-    namespace fs {
+#include <filesystem>
-        using namespace std::filesystem;
+namespace fs {
-        using ifstream = std::ifstream;
+using namespace std::filesystem;
-        using ofstream = std::ofstream;
+using ifstream = std::ifstream;
-        using fstream = std::fstream;
+using ofstream = std::ofstream;
-    }
+using fstream = std::fstream;
-#else
+}
-    #include "filesystem.hpp"
+#endif
-    namespace fs {
+#endif
-        using namespace ghc::filesystem;
+#ifndef GHC_USE_STD_FS
-        using ifstream = ghc::filesystem::ifstream;
+//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
-        using ofstream = ghc::filesystem::ofstream;
+#include <ghc/filesystem.hpp>
-        using fstream = ghc::filesystem::fstream;
+namespace fs {
-    }
+using namespace ghc::filesystem;
+using ifstream = ghc::filesystem::ifstream;
+using ofstream = ghc::filesystem::ofstream;
+using fstream = ghc::filesystem::fstream;
+} 
 #endif
-
 #endif // GHC_FILESYSTEM_STD_H
+

include/ghc/fs_std_fwd.hpp

@@ -25,7 +25,7 @@
 // SOFTWARE.
 //
 //---------------------------------------------------------------------------------------
-// fs_std_fwd.hpp - The forwarding header for the header/implementation separated usage of
+// fs_std_fwd.hpp - The forwarding header for the header/implementation seperated usage of
 //                  ghc::filesystem that uses std::filesystem if it detects it.
 // This file can be include at any place, where fs::filesystem api is needed while
 // not bleeding implementation details (e.g. system includes) into the global namespace,
@@ -33,47 +33,31 @@
 //---------------------------------------------------------------------------------------
 #ifndef GHC_FILESYSTEM_STD_FWD_H
 #define GHC_FILESYSTEM_STD_FWD_H
-
+#if defined(__APPLE__)
-#if defined(_MSVC_LANG) && _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
+#include <Availability.h>
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__TV_OS_VERSION_MIN_REQUIRED) && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__WATCH_OS_VERSION_MAX_ALLOWED) && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif
-        #endif
-    #endif
 #endif
-
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
-#ifdef GHC_USE_STD_FS
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
-    #include <filesystem>
+#define GHC_USE_STD_FS
-    namespace fs {
+#include <filesystem>
-        using namespace std::filesystem;
+namespace fs {
-        using ifstream = std::ifstream;
+using namespace std::filesystem;
-        using ofstream = std::ofstream;
+using ifstream = std::ifstream;
-        using fstream = std::fstream;
+using ofstream = std::ofstream;
-    }
+using fstream = std::fstream;
-#else
+}
-    #include "fs_fwd.hpp"
+#endif
-    namespace fs {
+#endif
-        using namespace ghc::filesystem;
+#ifndef GHC_USE_STD_FS
-        using ifstream = ghc::filesystem::ifstream;
+//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
-        using ofstream = ghc::filesystem::ofstream;
+#define GHC_FILESYSTEM_FWD
-        using fstream = ghc::filesystem::fstream;
+#include <ghc/filesystem.hpp>
-    }
+namespace fs {
+using namespace ghc::filesystem;
+using ifstream = ghc::filesystem::ifstream;
+using ofstream = ghc::filesystem::ofstream;
+using fstream = ghc::filesystem::fstream;
+} 
 #endif
-
 #endif // GHC_FILESYSTEM_STD_FWD_H
+

include/ghc/fs_std_impl.hpp

@@ -25,36 +25,22 @@
 // SOFTWARE.
 //
 //---------------------------------------------------------------------------------------
-// fs_std_impl.hpp - The implementation header for the header/implementation separated usage of
+// fs_std_impl.hpp - The implementation header for the header/implementation seperated usage of
 //                   ghc::filesystem that does nothing if std::filesystem is detected.
 // This file can be used to hide the implementation of ghc::filesystem into a single cpp.
 // The cpp has to include this before including fs_std_fwd.hpp directly or via a different
 // header to work.
 //---------------------------------------------------------------------------------------
-#if defined(_MSVC_LANG) && _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
+#if defined(__APPLE__)
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
+#include <Availability.h>
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
+#endif
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
-        #define GHC_USE_STD_FS
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
-
+#define GHC_USE_STD_FS
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
+#endif
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__TV_OS_VERSION_MIN_REQUIRED) && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__WATCH_OS_VERSION_MAX_ALLOWED) && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif
-        #endif
-    #endif
 #endif
-
 #ifndef GHC_USE_STD_FS
-    #include "fs_impl.hpp"
+//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
+#define GHC_FILESYSTEM_IMPLEMENTATION
+#include <ghc/filesystem.hpp>
 #endif

test/CMakeLists.txt

@@ -3,11 +3,6 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
 set(PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS ON)
 include(ParseAndAddCatchTests)
 
-if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND UNIX AND NOT APPLE AND NOT BSD)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
-    set(CMAKE_EXE_LINKER_FLAGS "-lc++abi")
-endif()
-
 function(SetTestCompileOptions target_name)
     target_compile_options(${target_name} PRIVATE
         $<$<BOOL:${EMSCRIPTEN}>:-s DISABLE_EXCEPTION_CATCHING=0>

test/filesystem_test.cpp

@@ -817,8 +817,6 @@ TEST_CASE("fs.path.decompose - path decomposition", "[filesystem][path][fs.path.
 #else
     CHECK(fs::path("t:est.txt").stem() == "t:est");
 #endif
-    CHECK(fs::path("/foo/.").stem() == ".");
-    CHECK(fs::path("/foo/..").stem() == "..");
 
     // extension()
     CHECK(fs::path("/foo/bar.txt").extension() == ".txt");
@@ -827,8 +825,6 @@ TEST_CASE("fs.path.decompose - path decomposition", "[filesystem][path][fs.path.
     CHECK(fs::path(".bar").extension() == "");
     CHECK(fs::path("..bar").extension() == ".bar");
     CHECK(fs::path("t:est.txt").extension() == ".txt");
-    CHECK(fs::path("/foo/.").extension() == "");
-    CHECK(fs::path("/foo/..").extension() == "");
 
     if (has_host_root_name_support()) {
         // //host-based root-names
@@ -965,10 +961,6 @@ TEST_CASE("fs.path.gen - path generation", "[filesystem][path][fs.path.gen]")
     // lexically_relative()
     CHECK(fs::path("/a/d").lexically_relative("/a/b/c") == "../../d");
     CHECK(fs::path("/a/b/c").lexically_relative("/a/d") == "../b/c");
-    CHECK(fs::path("/a/b/c").lexically_relative("/a/b/c/d/..") == ".");
-    CHECK(fs::path("/a/b/c/").lexically_relative("/a/b/c/d/..") == ".");
-    CHECK(fs::path("").lexically_relative("/a/..") == "");
-    CHECK(fs::path("").lexically_relative("a/..") == ".");
     CHECK(fs::path("a/b/c").lexically_relative("a") == "b/c");
     CHECK(fs::path("a/b/c").lexically_relative("a/b/c/x/y") == "../..");
     CHECK(fs::path("a/b/c").lexically_relative("a/b/c") == ".");