[3/N] [libcxx] Make filesystem::path::value_type wchar_t on windows

[mstorsjo]

Summary

Also set the preferred separator to backslash.

libc++ doesn't compile successfully for windows prior to this change, and this change on its own isn't enough to make it compile successfully either, but is the first stepping stone towards making it work correctly.

Most of operations.cpp will need to be touched, both for calling functions that take wchar paths, but also for using other windows specific functions instead of the posix functions used so far; that is handled in later commits.

Changing parts of operations.cpp to generalize the string type handling in code that doesn't touch system functions.

[amccarth]

libcxx/src/filesystem/operations.cpp

176–179

Is "/" the preferred representation of the root directory even on Windows?

[mstorsjo]

libcxx/src/filesystem/operations.cpp

176–179

No; this patch just handles the char->wchar transition. This particular case is changed to return backslashes in D91176 as part of making the path parser handle windows specific concepts as "root name".

[mstorsjo]

libcxx/src/filesystem/operations.cpp

176–179

Ok, I see that I generally change the preferred separator to backslashes here, so I guess I could move that bit from that other patch into this one as well if you want it strictly that way - it originated in that patch as it came from trying to make the path parser/iterator return the right things.

[mstorsjo]

Rebased; moved bit from later patch for making PathParser::operator* return backslashes where relevant into this patch.

[mstorsjo]

Rebase

[curdeius]

libcxx/include/filesystem

727

Wouldn't it be wise to reserve at least the minimum expected output size?
It seems that there are some places that a reserve would fit well.
But that's out of scope of this patch.

1131

Shouldn't there be a difference between string and generic_string, the former returning native format (with backslash on Windows?) and the latter always path with forward slashes?

1139

The comment doesn't match the #if.

1300

Hmm?

1310

Ditto.

libcxx/src/filesystem/operations.cpp

176–179

Why does it depend on RawEntry and not on OS only?

[curdeius]

libcxx/include/filesystem

579

Do you really need this type? Can't you use __u8_string::value_type instead?

[mstorsjo]

libcxx/include/filesystem

1131

Yes, there's a difference; that aspect is corrected later in patch [24/N] in D91181. (I understand that it'd be cleaner to review if all changed code lands in the right form directly the first time it's touched - but that'd make the first patches even more unwieldy - so here I try to primarily focus on getting the wchar_t aspect right.)

And in general, string() and native() returns the string with whatever separator form the string originally contained, it can be any combination of forward and backslashes, while generic_string() indeed returns a version with forward slashes only.

1139

Right, I guess I should make it _LIBCPP_WIN32API instead, and the ! is confusing. I meant it in the form #else /* condition * as it could be #elseif condition i.e. describing the condition for the code following the #else, not the condition for the block above, but I guess that's not common practice. I'll change it to just plain #else /* _LIBCPP_WIN32API */.

1300

Right, this was a generalization from before I added the more windows specific bits, trying to move things to use explicitly value_type and string_type instead of hardcoding the types - but here it's a bit out of place, so I can drop these two changes from the patch.

libcxx/src/filesystem/operations.cpp

176–179

Because when iterating over the path name, we want to return the root dir with the slash in the same form as in the actual path itself.

[mstorsjo]

libcxx/include/filesystem

579

I guess I can do that; this particular typedef goes away in one of the later patches anyway.

[mstorsjo]

Removed the unnecessary __u8_value typedef, fixed an #else comment, removed unnecessary changes from char to value_type in a non-windows ifdef section.

[mstorsjo]

libcxx/include/filesystem

1300

Oh, sorry, I misread, now I see what you meant. Will fix.

[mstorsjo]

Fixed two missed cases that should use use char_traits<value_type>

[curdeius]

LGTM

libcxx/include/filesystem

1131

Ok. And thank you for the explanation.

1139

Yeah that's not very clear sometimes how it should be read.
Personally I love the MS STL style with "^^^^ if-condition vvvvv negated condition".

libcxx/src/filesystem/operations.cpp

176–179

Ok.

[curdeius]

Nit.

libcxx/include/filesystem

854

To be consistent with D91138.

[mstorsjo]

Define preferred_separator as L'\\'.

[mstorsjo]

... and set the repository

[ldionne]

libcxx/include/filesystem

797

This code is valid even outside of Windows, right? If so, I'd rather we keep it in the header unconditionally. I don't mind if it's unused outside of Windows -- I think it's better to try to remove these #ifdefs as much as possible.

1112–1124

Would it be possible to share these definitions between Windows and non-Windows to avoid code duplication?

[mstorsjo]

libcxx/include/filesystem

797

The code added here in this patch should be valid code on any platform, yes, but it's code that assumes the source char type is wchar_t (which is kind of not nice to have outside of specific ifdefs), and D91137 adds more code here that calls the windows-specific __wide_to_char and __char_to_wide here, so those would need to be ifdeffed anyway (as long as we keep those declarations under an ifdef).

There's of course the benefit of having more syntax checked on non-windows platforms though, even though it's never actually referenced. With other ifdefs, it could look a bit odd, like this:

// Windows specific code, unused elsewhere
template <class _ECharT> struct _PathExport {
    void first_method() {
    }
#ifdef _LIBCPP_WIN32API
    void other_method() {
        // Code referencing things that don't build on other platforms, referencing helpers like __wide_to_char
    }
#endif
    void third_method() {
    }
};
// End of windows specific block

1112–1124

At least u16string() and u32string() could be shared, the rest is a bit messier. On posix, string() and u8string() just return __pn_ directly and work outside of !_LIBCPP_HAS_NO_LOCALIZATION, while on windows, it's wstring() that works without localization and string() and u8string(). And later, D91181 adds more windows specifics to generic_*string(). So all in all, yes, some small bits could be shared, but I'm not entirely convinced it's worth it.

[mstorsjo]

Rebased, retriggering CI

libcxx/include/filesystem

 struct __can_convert_char<char32_t> {
   static const bool value = true;
   using __char_type = char32_t;
 };
 
 template <class _ECharT>
 typename enable_if<__can_convert_char<_ECharT>::value, bool>::type
 __is_separator(_ECharT __e) {
+#if defined(_LIBCPP_WIN32API)
+  return __e == _ECharT('/') || __e == _ECharT('\\');
+#else
   return __e == _ECharT('/');
+#endif
 }
 
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+typedef char8_t __u8_value;
+typedef u8string __u8_string;
+#else
+typedef char __u8_value;
+typedef string __u8_string;
+#endif
+
 struct _NullSentinel {};
 
 template <class _Tp>
 using _Void = void;
 
 template <class _Tp, class = void>
 struct __is_pathable_string : public false_type {};
 

 
 template <class _Tp>
 struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {
 };
 
 template <class _Tp>
 struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {};
 
+#if defined(_LIBCPP_WIN32API)
+typedef wstring __path_string;
+typedef wchar_t __path_value;
+#else
+typedef string __path_string;
+typedef char __path_value;
+#endif
+
 template <class _ECharT>
 struct _PathCVT;
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 template <class _ECharT>
 struct _PathCVT {
   static_assert(__can_convert_char<_ECharT>::value,
                 "Char type not convertible");
 
   typedef __narrow_to_utf8<sizeof(_ECharT) * __CHAR_BIT__> _Narrower;
+#if defined(_LIBCPP_WIN32API)
+  typedef __widen_from_utf8<sizeof(wchar_t) * __CHAR_BIT__> _Widener;
+#endif
 
-  static void __append_range(string& __dest, _ECharT const* __b,
+  static void __append_range(__path_string& __dest, _ECharT const* __b,
                              _ECharT const* __e) {
+#if defined(_LIBCPP_WIN32API)
+    string __utf8;
+    _Narrower()(back_inserter(__utf8), __b, __e);
+    _Widener()(back_inserter(__dest), __utf8.data(), __utf8.data() + __utf8.size());
+#else
     _Narrower()(back_inserter(__dest), __b, __e);
+#endif
   }
 
   template <class _Iter>
-  static void __append_range(string& __dest, _Iter __b, _Iter __e) {
+  static void __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
     static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
     if (__b == __e)
       return;
     basic_string<_ECharT> __tmp(__b, __e);
+#if defined(_LIBCPP_WIN32API)
+    string __utf8;
+    _Narrower()(back_inserter(__utf8), __tmp.data(),
+                __tmp.data() + __tmp.length());
+    _Widener()(back_inserter(__dest), __utf8.data(), __utf8.data() + __utf8.size());
+#else
     _Narrower()(back_inserter(__dest), __tmp.data(),
                 __tmp.data() + __tmp.length());
+#endif
   }
 
   template <class _Iter>
-  static void __append_range(string& __dest, _Iter __b, _NullSentinel) {
+  static void __append_range(__path_string& __dest, _Iter __b, _NullSentinel) {
     static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
     const _ECharT __sentinel = _ECharT{};
     if (*__b == __sentinel)
       return;
     basic_string<_ECharT> __tmp;
     for (; *__b != __sentinel; ++__b)
       __tmp.push_back(*__b);
+#if defined(_LIBCPP_WIN32API)
+    string __utf8;
+    _Narrower()(back_inserter(__utf8), __tmp.data(),
+                __tmp.data() + __tmp.length());
+    _Widener()(back_inserter(__dest), __utf8.data(), __utf8.data() + __utf8.size());
+#else
     _Narrower()(back_inserter(__dest), __tmp.data(),
                 __tmp.data() + __tmp.length());
+#endif
   }
 
   template <class _Source>
-  static void __append_source(string& __dest, _Source const& __s) {
+  static void __append_source(__path_string& __dest, _Source const& __s) {
     using _Traits = __is_pathable<_Source>;
     __append_range(__dest, _Traits::__range_begin(__s),
                    _Traits::__range_end(__s));
   }
 };
 #endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
 template <>
-struct _PathCVT<char> {
+struct _PathCVT<__path_value> {
 
   template <class _Iter>
   static typename enable_if<__is_exactly_cpp17_input_iterator<_Iter>::value>::type
-  __append_range(string& __dest, _Iter __b, _Iter __e) {
+  __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
     for (; __b != __e; ++__b)
       __dest.push_back(*__b);
   }
 
   template <class _Iter>
   static typename enable_if<__is_cpp17_forward_iterator<_Iter>::value>::type
-  __append_range(string& __dest, _Iter __b, _Iter __e) {
+  __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
     __dest.__append_forward_unsafe(__b, __e);
   }
 
   template <class _Iter>
-  static void __append_range(string& __dest, _Iter __b, _NullSentinel) {
+  static void __append_range(__path_string& __dest, _Iter __b, _NullSentinel) {
     const char __sentinel = char{};
     for (; *__b != __sentinel; ++__b)
       __dest.push_back(*__b);
   }
 
   template <class _Source>
-  static void __append_source(string& __dest, _Source const& __s) {
+  static void __append_source(__path_string& __dest, _Source const& __s) {
     using _Traits = __is_pathable<_Source>;
     __append_range(__dest, _Traits::__range_begin(__s),
                    _Traits::__range_end(__s));
   }
 };
 
+#if defined(_LIBCPP_WIN32API)
+template <class _ECharT>
+struct _PathExport {
+  typedef __narrow_to_utf8<sizeof(wchar_t) * __CHAR_BIT__> _Narrower;
+  typedef __widen_from_utf8<sizeof(_ECharT) * __CHAR_BIT__> _Widener;
+
+  template <class _Str>
+  static void __append(_Str& __dest, const __path_string& __src) {
+    string __utf8;
+    _Narrower()(back_inserter(__utf8), __src.data(), __src.data() + __src.size());
+    _Widener()(back_inserter(__dest), __utf8.data(), __utf8.data() + __utf8.size());
+  }
+};
+
+template <>
+struct _PathExport<wchar_t> {
+  template <class _Str>
+  static void __append(_Str& __dest, const __path_string& __src) {
+    __dest.append(__src.begin(), __src.end());
+  }
+};
+
+template <>
+struct _PathExport<char16_t> {
+  template <class _Str>
+  static void __append(_Str& __dest, const __path_string& __src) {
+    __dest.append(__src.begin(), __src.end());
+  }
+};
+
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+template <>
+struct _PathExport<char8_t> {
+  typedef __narrow_to_utf8<sizeof(wchar_t) * __CHAR_BIT__> _Narrower;
+
+  template <class _Str>
+  static void __append(_Str& __dest, const __path_string& __src) {
+    _Narrower()(back_inserter(__dest), __src.data(), __src.data() + __src.size());
+  }
+};
+#endif
+#endif
+
 class _LIBCPP_TYPE_VIS path {
   template <class _SourceOrIter, class _Tp = path&>
   using _EnableIfPathable =
       typename enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
 
   template <class _Tp>
   using _SourceChar = typename __is_pathable<_Tp>::__char_type;
 
   template <class _Tp>
   using _SourceCVT = _PathCVT<_SourceChar<_Tp> >;
 
 public:
+#if defined(_LIBCPP_WIN32API)
+  typedef wchar_t value_type;
+  static constexpr value_type preferred_separator = '\\';
+#else
   typedef char value_type;
-  typedef basic_string<value_type> string_type;
-  typedef _VSTD::string_view __string_view;
   static constexpr value_type preferred_separator = '/';
+#endif
+  typedef basic_string<value_type> string_type;
+  typedef basic_string_view<value_type> __string_view;
 
   enum class _LIBCPP_ENUM_VIS format : unsigned char {
     auto_format,
     native_format,
     generic_format
   };
 
   // constructors and destructor
public:
   _LIBCPP_INLINE_VISIBILITY
   const string_type& native() const noexcept { return __pn_; }
 
   _LIBCPP_INLINE_VISIBILITY
   const value_type* c_str() const noexcept { return __pn_.c_str(); }
 
   _LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_; }
 
+#if defined(_LIBCPP_WIN32API)
+  _LIBCPP_INLINE_VISIBILITY _VSTD::wstring wstring() const { return __pn_; }
+
+  _VSTD::wstring generic_wstring() const { return __pn_; }
+
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  template <class _ECharT, class _Traits = char_traits<_ECharT>,
+            class _Allocator = allocator<_ECharT> >
+  basic_string<_ECharT, _Traits, _Allocator>
+  string(const _Allocator& __a = _Allocator()) const {
+    using _Str = basic_string<_ECharT, _Traits, _Allocator>;
+    _Str __s(__a);
+    __s.reserve(__pn_.size());
+    _PathExport<_ECharT>::__append(__s, __pn_);
+    return __s;
+  }
+
+  _LIBCPP_INLINE_VISIBILITY _VSTD::string string() const {
+    return string<char>();
+  }
+  _LIBCPP_INLINE_VISIBILITY __u8_string u8string() const {
+    return string<__u8_value>();
+  }
+
+  _LIBCPP_INLINE_VISIBILITY _VSTD::u16string u16string() const {
+    return string<char16_t>();
+  }
+  _LIBCPP_INLINE_VISIBILITY _VSTD::u32string u32string() const {
+    return string<char32_t>();
+  }
+
+  // generic format observers
+  template <class _ECharT, class _Traits = char_traits<_ECharT>,
+            class _Allocator = allocator<_ECharT> >
+  basic_string<_ECharT, _Traits, _Allocator>
+  generic_string(const _Allocator& __a = _Allocator()) const {
+    return string<_ECharT, _Traits, _Allocator>(__a);
+  }
+
+  _VSTD::string generic_string() const { return generic_string<char>(); }
+  _VSTD::u16string generic_u16string() const { return generic_string<char16_t>(); }
+  _VSTD::u32string generic_u32string() const { return generic_string<char32_t>(); }
+  __u8_string generic_u8string() const { return u8string(); }
+#endif /* !_LIBCPP_HAS_NO_LOCALIZATION */
+#else /* !_WIN32 */
+
   _LIBCPP_INLINE_VISIBILITY _VSTD::string string() const { return __pn_; }
 #ifndef _LIBCPP_NO_HAS_CHAR8_T
   _LIBCPP_INLINE_VISIBILITY _VSTD::u8string u8string() const { return _VSTD::u8string(__pn_.begin(), __pn_.end()); }
 #else
   _LIBCPP_INLINE_VISIBILITY _VSTD::string u8string() const { return __pn_; }
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
_LIBCPP_INLINE_VISIBILITY _VSTD::wstring wstring() const {
     return string<wchar_t>();
   }
   _LIBCPP_INLINE_VISIBILITY _VSTD::u16string u16string() const {
     return string<char16_t>();
   }
   _LIBCPP_INLINE_VISIBILITY _VSTD::u32string u32string() const {
     return string<char32_t>();
   }
-#endif
+#endif /* !_LIBCPP_HAS_NO_LOCALIZATION */
 
   // generic format observers
   _VSTD::string generic_string() const { return __pn_; }
 #ifndef _LIBCPP_NO_HAS_CHAR8_T
   _VSTD::u8string generic_u8string() const { return _VSTD::u8string(__pn_.begin(), __pn_.end()); }
 #else
   _VSTD::string generic_u8string() const { return __pn_; }
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   template <class _ECharT, class _Traits = char_traits<_ECharT>,
             class _Allocator = allocator<_ECharT> >
   basic_string<_ECharT, _Traits, _Allocator>
   generic_string(const _Allocator& __a = _Allocator()) const {
     return string<_ECharT, _Traits, _Allocator>(__a);
   }
 
   _VSTD::wstring generic_wstring() const { return string<wchar_t>(); }
   _VSTD::u16string generic_u16string() const { return string<char16_t>(); }
   _VSTD::u32string generic_u32string() const { return string<char32_t>(); }
-#endif
+#endif /* !_LIBCPP_HAS_NO_LOCALIZATION */
+#endif /* !_LIBCPP_WIN32API */
 
 private:
   int __compare(__string_view) const;
   __string_view __root_name() const;
   __string_view __root_directory() const;
   __string_view __root_path_raw() const;
   __string_view __relative_path() const;
   __string_view __parent_path() const;
public:
   typedef iterator const_iterator;
 
   iterator begin() const;
   iterator end() const;
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   template <class _CharT, class _Traits>
   _LIBCPP_INLINE_VISIBILITY friend
-      typename enable_if<is_same<_CharT, char>::value &&
+      typename enable_if<is_same<_CharT, value_type>::value &&
                              is_same<_Traits, char_traits<char> >::value,
                          basic_ostream<_CharT, _Traits>&>::type
       operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
     __os << _VSTD::__quoted(__p.native());
     return __os;
   }
 
   template <class _CharT, class _Traits>
   _LIBCPP_INLINE_VISIBILITY friend
-      typename enable_if<!is_same<_CharT, char>::value ||
+      typename enable_if<!is_same<_CharT, value_type>::value ||
                              !is_same<_Traits, char_traits<char> >::value,
                          basic_ostream<_CharT, _Traits>&>::type
       operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
     __os << _VSTD::__quoted(__p.string<_CharT, _Traits>());
     return __os;
   }
 
   template <class _CharT, class _Traits>
   _LIBCPP_INLINE_VISIBILITY friend basic_istream<_CharT, _Traits>&

libcxx/src/filesystem/filesystem_common.h

 #endif
 #endif
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-function"
 #endif
 
+#if defined(_LIBCPP_WIN32API)
+#define PS(x) (L##x)
+#else
+#define PS(x) (x)
+#endif
+
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 namespace detail {
 namespace {
 
 static string format_string_imp(const char* msg, ...) {
   // we might need a second shot at this, so pre-emptivly make a copy
   struct GuardVAList {
static string format_string_imp(const char* msg, ...) {
   size_with_null = static_cast<size_t>(ret) + 1;
   result.__resize_default_init(size_with_null - 1);
   ret = ::vsnprintf(&result[0], size_with_null, msg, args);
   _LIBCPP_ASSERT(static_cast<size_t>(ret) == (size_with_null - 1), "TODO");
 
   return result;
 }
 
-const char* unwrap(string const& s) { return s.c_str(); }
-const char* unwrap(path const& p) { return p.native().c_str(); }
+const path::value_type* unwrap(path::string_type const& s) { return s.c_str(); }
+const path::value_type* unwrap(path const& p) { return p.native().c_str(); }
 template <class Arg>
 Arg const& unwrap(Arg const& a) {
   static_assert(!is_class<Arg>::value, "cannot pass class here");
   return a;
 }
 
 template <class... Args>
 string format_string(const char* fmt, Args const&... args) {

libcxx/src/filesystem/operations.cpp

public:
   }
 
   /// \brief Return a view with the "preferred representation" of the current
   ///   element. For example trailing separators are represented as a '.'
   string_view_t operator*() const noexcept {
     switch (State) {
     case PS_BeforeBegin:
     case PS_AtEnd:
-      return "";
+      return PS("");
     case PS_InRootDir:
-      return "/";
+      if (RawEntry[0] == '\\')
+        return PS("\\");
+      else
+        return PS("/");
     case PS_InTrailingSep:
-      return "";
+      return PS("");
     case PS_InRootName:
     case PS_InFilenames:
       return RawEntry;
     }
     _LIBCPP_UNREACHABLE();
   }
 
   explicit operator bool() const noexcept {
PosPtr consumeName(PosPtr P, PosPtr End) const noexcept {
     P += Inc;
     while (P != End && *P != '/')
       P += Inc;
     return P;
   }
 };
 
 string_view_pair separate_filename(string_view_t const& s) {
-  if (s == "." || s == ".." || s.empty())
-    return string_view_pair{s, ""};
+  if (s == PS(".") || s == PS("..") || s.empty())
+    return string_view_pair{s, PS("")};
   auto pos = s.find_last_of('.');
   if (pos == string_view_t::npos || pos == 0)
     return string_view_pair{s, string_view_t{}};
   return string_view_pair{s.substr(0, pos), s.substr(pos)};
 }
 
 string_view_t createView(PosPtr S, PosPtr E) noexcept {
   return {S, static_cast<size_t>(E - S) + 1};
#else
   timeval tv;
   gettimeofday(&tv, 0);
   return time_point(__secs(tv.tv_sec) + __microsecs(tv.tv_usec));
 #endif // CLOCK_REALTIME
 }
 
 filesystem_error::~filesystem_error() {}
 
+#if defined(_LIBCPP_WIN32API)
+#define PS_FMT "%ls"
+#else
+#define PS_FMT "%s"
+#endif
+
 void filesystem_error::__create_what(int __num_paths) {
   const char* derived_what = system_error::what();
   __storage_->__what_ = [&]() -> string {
-    const char* p1 = path1().native().empty() ? "\"\"" : path1().c_str();
-    const char* p2 = path2().native().empty() ? "\"\"" : path2().c_str();
+    const path::value_type* p1 = path1().native().empty() ? PS("\"\"") : path1().c_str();
+    const path::value_type* p2 = path2().native().empty() ? PS("\"\"") : path2().c_str();
     switch (__num_paths) {
     default:
       return detail::format_string("filesystem error: %s", derived_what);
     case 1:
-      return detail::format_string("filesystem error: %s [%s]", derived_what,
+      return detail::format_string("filesystem error: %s [" PS_FMT "]", derived_what,
                                    p1);
     case 2:
-      return detail::format_string("filesystem error: %s [%s] [%s]",
+      return detail::format_string("filesystem error: %s [" PS_FMT "] [" PS_FMT "]",
                                    derived_what, p1, p2);
     }
   }();
 }
 
 static path __do_absolute(const path& p, path* cwd, error_code* ec) {
   if (ec)
     ec->clear();
if ((ret = getenv(ep)))
       break;
   if (ret == nullptr)
     ret = "/tmp";
 
   path p(ret);
   error_code m_ec;
   file_status st = detail::posix_stat(p, &m_ec);
   if (!status_known(st))
-    return err.report(m_ec, "cannot access path \"%s\"", p);
+    return err.report(m_ec, "cannot access path \"" PS_FMT "\"", p);
 
   if (!exists(st) || !is_directory(st))
-    return err.report(errc::not_a_directory, "path \"%s\" is not a directory",
+    return err.report(errc::not_a_directory, "path \"" PS_FMT "\" is not a directory",
                       p);
 
   return p;
 }
 
 path __weakly_canonical(const path& p, error_code* ec) {
   ErrorHandler<path> err("weakly_canonical", ec, &p);
 

 
 path& path::replace_extension(path const& replacement) {
   path p = extension();
   if (not p.empty()) {
     __pn_.erase(__pn_.size() - p.native().size());
   }
   if (!replacement.empty()) {
     if (replacement.native()[0] != '.') {
-      __pn_ += ".";
+      __pn_ += PS(".");
     }
     __pn_.append(replacement.__pn_);
   }
   return *this;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // path.decompose
enum PathPartKind : unsigned char {
   PK_Dot,
   PK_DotDot,
   PK_TrailingSep
 };
 
 static PathPartKind ClassifyPathPart(string_view_t Part) {
   if (Part.empty())
     return PK_TrailingSep;
-  if (Part == ".")
+  if (Part == PS("."))
     return PK_Dot;
-  if (Part == "..")
+  if (Part == PS(".."))
     return PK_DotDot;
-  if (Part == "/")
+  if (Part == PS("/"))
     return PK_RootSep;
   return PK_Filename;
 }
 
 path path::lexically_normal() const {
   if (__pn_.empty())
     return *this;
 
for (auto PP = PathParser::CreateBegin(__pn_); PP; ++PP) {
     case PK_DotDot: {
       // Only push a ".." element if there are no elements preceding the "..",
       // or if the preceding element is itself "..".
       auto LastKind = LastPartKind();
       if (LastKind == PK_Filename) {
         NewPathSize -= Parts.back().first.size();
         Parts.pop_back();
       } else if (LastKind != PK_RootSep)
-        AddPart(PK_DotDot, "..");
+        AddPart(PK_DotDot, PS(".."));
       MaybeNeedTrailingSep = LastKind == PK_Filename;
       break;
     }
     case PK_Dot:
     case PK_TrailingSep: {
       MaybeNeedTrailingSep = true;
       break;
     }
     case PK_None:
       _LIBCPP_UNREACHABLE();
     }
   }
   // [fs.path.generic]p6.8: If the path is empty, add a dot.
   if (Parts.empty())
-    return ".";
+    return PS(".");
 
   // [fs.path.generic]p6.7: If the last filename is dot-dot, remove any
   // trailing directory-separator.
   bool NeedTrailingSep = MaybeNeedTrailingSep && LastPartKind() == PK_Filename;
 
   path Result;
   Result.__pn_.reserve(Parts.size() + NewPathSize + NeedTrailingSep);
   for (auto& PK : Parts)
     Result /= PK.first;
 
   if (NeedTrailingSep)
-    Result /= "";
+    Result /= PS("");
 
   return Result;
 }
 
 static int DetermineLexicalElementCount(PathParser PP) {
   int Count = 0;
   for (; PP; ++PP) {
     auto Elem = *PP;
-    if (Elem == "..")
+    if (Elem == PS(".."))
       --Count;
-    else if (Elem != "." && Elem != "")
+    else if (Elem != PS(".") && Elem != PS(""))
       ++Count;
   }
   return Count;
 }
 
 path path::lexically_relative(const path& base) const {
   { // perform root-name/root-directory mismatch checks
     auto PP = PathParser::CreateBegin(__pn_);
path path::lexically_relative(const path& base) const {
 
   // Otherwise, determine the number of elements, 'n', which are not dot or
   // dot-dot minus the number of dot-dot elements.
   int ElemCount = DetermineLexicalElementCount(PPBase);
   if (ElemCount < 0)
     return {};
 
   // if n == 0 and (a == end() || a->empty()), returns path("."); otherwise
-  if (ElemCount == 0 && (PP.atEnd() || *PP == ""))
-    return ".";
+  if (ElemCount == 0 && (PP.atEnd() || *PP == PS("")))
+    return PS(".");
 
   // return a path constructed with 'n' dot-dot elements, followed by the the
   // elements of '*this' after the mismatch.
   path Result;
   // FIXME: Reserve enough room in Result that it won't have to re-allocate.
   while (ElemCount--)
-    Result /= "..";
+    Result /= PS("..");
   for (; PP; ++PP)
     Result /= *PP;
   return Result;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // path.comparisons
 static int CompareRootName(PathParser *LHS, PathParser *RHS) {
   if (!LHS->inRootName() && !RHS->inRootName())
     return 0;
 
   auto GetRootName = [](PathParser *Parser) -> string_view_t {
-    return Parser->inRootName() ? **Parser : "";
+    return Parser->inRootName() ? **Parser : PS("");
   };
   int res = GetRootName(LHS).compare(GetRootName(RHS));
   ConsumeRootName(LHS);
   ConsumeRootName(RHS);
   return res;
 }
 
 static int CompareRootDir(PathParser *LHS, PathParser *RHS) {