libstdc++-v3/include/experimental/bits/fs_path.h

   1 // Class filesystem::path -*- C++ -*-
   2
   3 // Copyright (C) 2014-2024 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file experimental/bits/fs_path.h
  26  *  This is an internal header file, included by other library headers.
  27  *  Do not attempt to use it directly. @headername{experimental/filesystem}
  28  */
  29
  30 #ifndef _GLIBCXX_EXPERIMENTAL_FS_PATH_H
  31 #define _GLIBCXX_EXPERIMENTAL_FS_PATH_H 1
  32
  33 #if __cplusplus < 201103L
  34 # include <bits/c++0x_warning.h>
  35 #else
  36
  37 #include <utility>
  38 #include <type_traits>
  39 #include <vector>
  40 #include <locale>
  41 #include <iosfwd>
  42 #include <codecvt>
  43 #include <system_error>
  44 #include <bits/stl_algobase.h>
  45 #include <bits/quoted_string.h>
  46 #include <bits/locale_conv.h>
  47 #if __cplusplus == 201402L
  48 # include <experimental/string_view>
  49 #endif
  50
  51 #if defined(_WIN32) && !defined(__CYGWIN__)
  52 # define _GLIBCXX_FILESYSTEM_IS_WINDOWS 1
  53 # include <algorithm>
  54 #endif
  55
  56 namespace std _GLIBCXX_VISIBILITY(default)
  57 {
  58 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  59
  60 namespace experimental
  61 {
  62 namespace filesystem
  63 {
  64 inline namespace v1
  65 {
  66 _GLIBCXX_BEGIN_NAMESPACE_CXX11
  67
  68 #if __cplusplus == 201402L
  69   using std::experimental::basic_string_view;
  70 #elif __cplusplus > 201402L
  71   using std::basic_string_view;
  72 #endif
  73
  74   /// @cond undocumented
  75 namespace __detail
  76 {
  77   /** @addtogroup filesystem-ts
  78    *  @{
  79    */
  80
  81   template<typename _CharT,
  82            typename _Ch = typename remove_const<_CharT>::type>
  83     using __is_encoded_char
  84       = __or_<is_same<_Ch, char>,
  85               is_same<_Ch, wchar_t>,
  86 #ifdef _GLIBCXX_USE_CHAR8_T
  87               is_same<_Ch, char8_t>,
  88 #endif
  89               is_same<_Ch, char16_t>,
  90               is_same<_Ch, char32_t>>;
  91
  92   template<typename _Iter,
  93            typename _Iter_traits = std::iterator_traits<_Iter>>
  94     using __is_path_iter_src
  95       = __and_<__is_encoded_char<typename _Iter_traits::value_type>,
  96                std::is_base_of<std::input_iterator_tag,
  97                                typename _Iter_traits::iterator_category>>;
  98
  99   template<typename _Iter>
 100     static __is_path_iter_src<_Iter>
 101     __is_path_src(_Iter, int);
 102
 103   template<typename _CharT, typename _Traits, typename _Alloc>
 104     static __is_encoded_char<_CharT>
 105     __is_path_src(const basic_string<_CharT, _Traits, _Alloc>&, int);
 106
 107 #if __cplusplus >= 201402L
 108   template<typename _CharT, typename _Traits>
 109     static __is_encoded_char<_CharT>
 110     __is_path_src(const basic_string_view<_CharT, _Traits>&, int);
 111 #endif
 112
 113   template<typename _Unknown>
 114     static std::false_type
 115     __is_path_src(const _Unknown&, ...);
 116
 117   template<typename _Tp1, typename _Tp2>
 118     struct __constructible_from;
 119
 120   template<typename _Iter>
 121     struct __constructible_from<_Iter, _Iter>
 122     : __is_path_iter_src<_Iter>
 123     { };
 124
 125   template<typename _Source>
 126     struct __constructible_from<_Source, void>
 127     : decltype(__is_path_src(std::declval<const _Source&>(), 0))
 128     { };
 129
 130   template<typename _Tp1, typename _Tp2 = void,
 131            typename _Tp1_nocv = typename remove_cv<_Tp1>::type,
 132            typename _Tp1_noptr = typename remove_pointer<_Tp1>::type>
 133     using _Path = typename
 134       std::enable_if<__and_<__not_<is_same<_Tp1_nocv, path>>,
 135                             __not_<is_void<_Tp1_noptr>>,
 136                             __constructible_from<_Tp1, _Tp2>>::value,
 137                      path>::type;
 138
 139   template<typename _Source>
 140     inline _Source
 141     _S_range_begin(_Source __begin) { return __begin; }
 142
 143   struct __nul_terminated { };
 144
 145   template<typename _Source>
 146     inline __nul_terminated
 147     _S_range_end(_Source) { return {}; }
 148
 149   template<typename _CharT, typename _Traits, typename _Alloc>
 150     inline const _CharT*
 151     _S_range_begin(const basic_string<_CharT, _Traits, _Alloc>& __str)
 152     { return __str.data(); }
 153
 154   template<typename _CharT, typename _Traits, typename _Alloc>
 155     inline const _CharT*
 156     _S_range_end(const basic_string<_CharT, _Traits, _Alloc>& __str)
 157     { return __str.data() + __str.size(); }
 158
 159 #if __cplusplus >= 201402L
 160   template<typename _CharT, typename _Traits>
 161     inline const _CharT*
 162     _S_range_begin(const basic_string_view<_CharT, _Traits>& __str)
 163     { return __str.data(); }
 164
 165   template<typename _CharT, typename _Traits>
 166     inline const _CharT*
 167     _S_range_end(const basic_string_view<_CharT, _Traits>& __str)
 168     { return __str.data() + __str.size(); }
 169 #endif
 170
 171   template<typename _Tp,
 172            typename _Iter = decltype(_S_range_begin(std::declval<_Tp>())),
 173            typename _Val = typename std::iterator_traits<_Iter>::value_type,
 174            typename _UnqualVal = typename std::remove_const<_Val>::type>
 175     using __value_type_is_char = typename std::enable_if<
 176       std::is_same<_UnqualVal, char>::value,
 177       _UnqualVal>::type;
 178
 179   template<typename _Tp,
 180            typename _Iter = decltype(_S_range_begin(std::declval<_Tp>())),
 181            typename _Val = typename std::iterator_traits<_Iter>::value_type,
 182            typename _UnqualVal = typename std::remove_const<_Val>::type>
 183     using __value_type_is_char_or_char8_t = typename std::enable_if<
 184       __or_<
 185         std::is_same<_UnqualVal, char>
 186 #ifdef _GLIBCXX_USE_CHAR8_T
 187         ,std::is_same<_UnqualVal, char8_t>
 188 #endif
 189       >::value, _UnqualVal>::type;
 190
 191   /// @} group filesystem-ts
 192 } // namespace __detail
 193   /// @endcond
 194
 195   /** @addtogroup filesystem-ts
 196    *  @{
 197    */
 198
 199   /// A filesystem path.
 200   /// @ingroup filesystem-ts
 201   class path
 202   {
 203   public:
 204 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 205     typedef wchar_t                             value_type;
 206     static constexpr value_type                 preferred_separator = L'\\';
 207 #else
 208     typedef char                                value_type;
 209     static constexpr value_type                 preferred_separator = '/';
 210 #endif
 211     typedef std::basic_string<value_type>       string_type;
 212
 213     // constructors and destructor
 214
 215     path() noexcept;
 216     path(const path& __p);
 217     path(path&& __p) noexcept;
 218
 219     path(string_type&& __source);
 220
 221     template<typename _Source,
 222              typename _Require = __detail::_Path<_Source>>
 223       path(_Source const& __source)
 224       : _M_pathname(_S_convert(__detail::_S_range_begin(__source),
 225                                __detail::_S_range_end(__source)))
 226       { _M_split_cmpts(); }
 227
 228     template<typename _InputIterator,
 229              typename _Require = __detail::_Path<_InputIterator, _InputIterator>>
 230       path(_InputIterator __first, _InputIterator __last)
 231       : _M_pathname(_S_convert(__first, __last))
 232       { _M_split_cmpts(); }
 233
 234     template<typename _Source,
 235              typename _Require = __detail::_Path<_Source>,
 236              typename _Require2 = __detail::__value_type_is_char<_Source>>
 237       path(_Source const& __source, const locale& __loc)
 238       : _M_pathname(_S_convert_loc(__detail::_S_range_begin(__source),
 239                                    __detail::_S_range_end(__source), __loc))
 240       { _M_split_cmpts(); }
 241
 242     template<typename _InputIterator,
 243              typename _Require = __detail::_Path<_InputIterator, _InputIterator>,
 244              typename _Require2 = __detail::__value_type_is_char<_InputIterator>>
 245       path(_InputIterator __first, _InputIterator __last, const locale& __loc)
 246       : _M_pathname(_S_convert_loc(__first, __last, __loc))
 247       { _M_split_cmpts(); }
 248
 249     ~path();
 250
 251     // assignments
 252
 253     path& operator=(const path& __p);
 254     path& operator=(path&& __p) noexcept;
 255     path& operator=(string_type&& __source);
 256     path& assign(string_type&& __source);
 257
 258     template<typename _Source>
 259       __detail::_Path<_Source>&
 260       operator=(_Source const& __source)
 261       { return *this = path(__source); }
 262
 263     template<typename _Source>
 264       __detail::_Path<_Source>&
 265       assign(_Source const& __source)
 266       { return *this = path(__source); }
 267
 268     template<typename _InputIterator>
 269       __detail::_Path<_InputIterator, _InputIterator>&
 270       assign(_InputIterator __first, _InputIterator __last)
 271       { return *this = path(__first, __last); }
 272
 273     // appends
 274
 275     path& operator/=(const path& __p) { return _M_append(__p._M_pathname); }
 276
 277     template<typename _Source>
 278       __detail::_Path<_Source>&
 279       operator/=(_Source const& __source)
 280       { return append(__source); }
 281
 282     template<typename _Source>
 283       __detail::_Path<_Source>&
 284       append(_Source const& __source)
 285       {
 286         return _M_append(_S_convert(__detail::_S_range_begin(__source),
 287                                     __detail::_S_range_end(__source)));
 288       }
 289
 290     template<typename _InputIterator>
 291       __detail::_Path<_InputIterator, _InputIterator>&
 292       append(_InputIterator __first, _InputIterator __last)
 293       { return _M_append(_S_convert(__first, __last)); }
 294
 295     // concatenation
 296
 297     path& operator+=(const path& __x);
 298     path& operator+=(const string_type& __x);
 299     path& operator+=(const value_type* __x);
 300     path& operator+=(value_type __x);
 301 #if __cplusplus >= 201402L
 302     path& operator+=(basic_string_view<value_type> __x);
 303 #endif
 304
 305     template<typename _Source>
 306       __detail::_Path<_Source>&
 307       operator+=(_Source const& __x) { return concat(__x); }
 308
 309     template<typename _CharT>
 310       __detail::_Path<_CharT*, _CharT*>&
 311       operator+=(_CharT __x);
 312
 313     template<typename _Source>
 314       __detail::_Path<_Source>&
 315       concat(_Source const& __x)
 316       {
 317         return *this += _S_convert(__detail::_S_range_begin(__x),
 318                                    __detail::_S_range_end(__x));
 319       }
 320
 321     template<typename _InputIterator>
 322       __detail::_Path<_InputIterator, _InputIterator>&
 323       concat(_InputIterator __first, _InputIterator __last)
 324       { return *this += _S_convert(__first, __last); }
 325
 326     // modifiers
 327
 328     void clear() noexcept { _M_pathname.clear(); _M_split_cmpts(); }
 329
 330     path& make_preferred();
 331     path& remove_filename();
 332     path& replace_filename(const path& __replacement);
 333     path& replace_extension(const path& __replacement = path());
 334
 335     void swap(path& __rhs) noexcept;
 336
 337     // native format observers
 338
 339     const string_type&  native() const noexcept { return _M_pathname; }
 340     const value_type*   c_str() const noexcept { return _M_pathname.c_str(); }
 341     operator string_type() const { return _M_pathname; }
 342
 343     template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
 344              typename _Allocator = std::allocator<_CharT>>
 345       std::basic_string<_CharT, _Traits, _Allocator>
 346       string(const _Allocator& __a = _Allocator()) const;
 347
 348     std::string    string() const;
 349 #if _GLIBCXX_USE_WCHAR_T
 350     std::wstring   wstring() const;
 351 #endif
 352 #ifdef _GLIBCXX_USE_CHAR8_T
 353     __attribute__((__abi_tag__("__u8")))
 354     std::u8string  u8string() const;
 355 #else
 356     std::string    u8string() const;
 357 #endif // _GLIBCXX_USE_CHAR8_T
 358     std::u16string u16string() const;
 359     std::u32string u32string() const;
 360
 361     // generic format observers
 362     template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
 363              typename _Allocator = std::allocator<_CharT>>
 364       std::basic_string<_CharT, _Traits, _Allocator>
 365       generic_string(const _Allocator& __a = _Allocator()) const;
 366
 367     std::string    generic_string() const;
 368 #if _GLIBCXX_USE_WCHAR_T
 369     std::wstring   generic_wstring() const;
 370 #endif
 371 #ifdef _GLIBCXX_USE_CHAR8_T
 372     __attribute__((__abi_tag__("__u8")))
 373     std::u8string  generic_u8string() const;
 374 #else
 375     std::string    generic_u8string() const;
 376 #endif // _GLIBCXX_USE_CHAR8_T
 377     std::u16string generic_u16string() const;
 378     std::u32string generic_u32string() const;
 379
 380     // compare
 381
 382     int compare(const path& __p) const noexcept;
 383     int compare(const string_type& __s) const;
 384     int compare(const value_type* __s) const;
 385 #if __cplusplus >= 201402L
 386     int compare(const basic_string_view<value_type> __s) const;
 387 #endif
 388
 389     // decomposition
 390
 391     path root_name() const;
 392     path root_directory() const;
 393     path root_path() const;
 394     path relative_path() const;
 395     path parent_path() const;
 396     path filename() const;
 397     path stem() const;
 398     path extension() const;
 399
 400     // query
 401
 402     _GLIBCXX_NODISCARD bool empty() const noexcept { return _M_pathname.empty(); }
 403     bool has_root_name() const;
 404     bool has_root_directory() const;
 405     bool has_root_path() const;
 406     bool has_relative_path() const;
 407     bool has_parent_path() const;
 408     bool has_filename() const;
 409     bool has_stem() const;
 410     bool has_extension() const;
 411     bool is_absolute() const;
 412     bool is_relative() const { return !is_absolute(); }
 413
 414     // iterators
 415     class iterator;
 416     typedef iterator const_iterator;
 417
 418     iterator begin() const noexcept;
 419     iterator end() const noexcept;
 420
 421     /// @cond undocumented
 422     // Create a basic_string by reading until a null character.
 423     template<typename _InputIterator,
 424              typename _Traits = std::iterator_traits<_InputIterator>,
 425              typename _CharT
 426                = typename std::remove_cv<typename _Traits::value_type>::type>
 427       static std::basic_string<_CharT>
 428       _S_string_from_iter(_InputIterator __source)
 429       {
 430         std::basic_string<_CharT> __str;
 431         for (_CharT __ch = *__source; __ch != _CharT(); __ch = *++__source)
 432           __str.push_back(__ch);
 433         return __str;
 434       }
 435     /// @endcond
 436
 437   private:
 438     enum class _Type : unsigned char {
 439         _Multi, _Root_name, _Root_dir, _Filename
 440     };
 441
 442     path(string_type __str, _Type __type);
 443
 444     enum class _Split { _Stem, _Extension };
 445
 446     path& _M_append(const string_type& __str)
 447     {
 448       if (!_M_pathname.empty() && !_S_is_dir_sep(_M_pathname.back())
 449           && !__str.empty() && !_S_is_dir_sep(__str.front()))
 450         _M_pathname += preferred_separator;
 451       _M_pathname += __str;
 452       _M_split_cmpts();
 453       return *this;
 454     }
 455
 456     pair<const string_type*, size_t> _M_find_extension() const;
 457
 458     template<typename _CharT>
 459       struct _Cvt;
 460
 461     static string_type
 462     _S_convert(value_type* __src, __detail::__nul_terminated)
 463     { return string_type(__src); }
 464
 465     static string_type
 466     _S_convert(const value_type* __src, __detail::__nul_terminated)
 467     { return string_type(__src); }
 468
 469     template<typename _Iter>
 470       static string_type
 471       _S_convert(_Iter __first, _Iter __last)
 472       {
 473         using __value_type = typename std::iterator_traits<_Iter>::value_type;
 474         return _Cvt<typename remove_cv<__value_type>::type>::
 475           _S_convert(__first, __last);
 476       }
 477
 478     template<typename _InputIterator>
 479       static string_type
 480       _S_convert(_InputIterator __src, __detail::__nul_terminated)
 481       {
 482         auto __s = _S_string_from_iter(__src);
 483         return _S_convert(__s.c_str(), __s.c_str() + __s.size());
 484       }
 485
 486     static string_type
 487     _S_convert_loc(const char* __first, const char* __last,
 488                    const std::locale& __loc);
 489
 490     static string_type
 491     _S_convert_loc(char* __first, char* __last, const std::locale& __loc)
 492     {
 493       return _S_convert_loc(const_cast<const char*>(__first),
 494                             const_cast<const char*>(__last), __loc);
 495     }
 496
 497     template<typename _Iter>
 498       static string_type
 499       _S_convert_loc(_Iter __first, _Iter __last, const std::locale& __loc)
 500       {
 501         const std::string __str(__first, __last);
 502         return _S_convert_loc(__str.data(), __str.data()+__str.size(), __loc);
 503       }
 504
 505     template<typename _InputIterator>
 506       static string_type
 507       _S_convert_loc(_InputIterator __src, __detail::__nul_terminated,
 508                      const std::locale& __loc)
 509       {
 510         const std::string __s = _S_string_from_iter(__src);
 511         return _S_convert_loc(__s.data(), __s.data() + __s.size(), __loc);
 512       }
 513
 514     static bool _S_is_dir_sep(value_type __ch)
 515     {
 516 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 517       return __ch == L'/' || __ch == preferred_separator;
 518 #else
 519       return __ch == '/';
 520 #endif
 521     }
 522
 523     void _M_split_cmpts();
 524     void _M_trim();
 525     void _M_add_root_name(size_t __n);
 526     void _M_add_root_dir(size_t __pos);
 527     void _M_add_filename(size_t __pos, size_t __n);
 528
 529     string_type _M_pathname;
 530
 531     struct _Cmpt;
 532     using _List = _GLIBCXX_STD_C::vector<_Cmpt>;
 533     _List _M_cmpts; // empty unless _M_type == _Type::_Multi
 534     _Type _M_type = _Type::_Multi;
 535   };
 536
 537   /// @relates std::experimental::filesystem::path @{
 538
 539   /// Swap overload for paths
 540   inline void swap(path& __lhs, path& __rhs) noexcept { __lhs.swap(__rhs); }
 541
 542   /// Compute a hash value for a path
 543   size_t hash_value(const path& __p) noexcept;
 544
 545   /// Compare paths
 546   inline bool operator<(const path& __lhs, const path& __rhs) noexcept;
 547
 548   /// Compare paths
 549   inline bool operator<=(const path& __lhs, const path& __rhs) noexcept
 550   { return !(__rhs < __lhs); }
 551
 552   /// Compare paths
 553   inline bool operator>(const path& __lhs, const path& __rhs) noexcept
 554   { return __rhs < __lhs; }
 555
 556   /// Compare paths
 557   inline bool operator>=(const path& __lhs, const path& __rhs) noexcept
 558   { return !(__lhs < __rhs); }
 559
 560   /// Compare paths
 561   inline bool operator==(const path& __lhs, const path& __rhs) noexcept;
 562
 563   /// Compare paths
 564   inline bool operator!=(const path& __lhs, const path& __rhs) noexcept
 565   { return !(__lhs == __rhs); }
 566
 567   /// Append one path to another
 568   inline path operator/(const path& __lhs, const path& __rhs)
 569   {
 570     path __result(__lhs);
 571     __result /= __rhs;
 572     return __result;
 573   }
 574
 575   /// Write a path to a stream
 576   template<typename _CharT, typename _Traits>
 577     basic_ostream<_CharT, _Traits>&
 578     operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p)
 579     {
 580       auto __tmp = __p.string<_CharT, _Traits>();
 581       using __quoted_string
 582         = std::__detail::_Quoted_string<decltype(__tmp)&, _CharT>;
 583       __os << __quoted_string{__tmp, _CharT('"'), _CharT('\\')};
 584       return __os;
 585     }
 586
 587   /// Read a path from a stream
 588   template<typename _CharT, typename _Traits>
 589     basic_istream<_CharT, _Traits>&
 590     operator>>(basic_istream<_CharT, _Traits>& __is, path& __p)
 591     {
 592       basic_string<_CharT, _Traits> __tmp;
 593       using __quoted_string
 594         = std::__detail::_Quoted_string<decltype(__tmp)&, _CharT>;
 595       if (__is >> __quoted_string{ __tmp, _CharT('"'), _CharT('\\') })
 596         __p = std::move(__tmp);
 597       return __is;
 598     }
 599
 600   /// Create a path from a UTF-8-encoded sequence of char
 601 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 602   template<typename _InputIterator>
 603     inline path
 604     __u8path(_InputIterator __first, _InputIterator __last, char)
 605     {
 606       // XXX This assumes native wide encoding is UTF-16.
 607       std::codecvt_utf8_utf16<path::value_type> __cvt;
 608       path::string_type __tmp;
 609       const std::string __u8str{__first, __last};
 610       const char* const __ptr = __u8str.data();
 611       if (__str_codecvt_in_all(__ptr, __ptr + __u8str.size(), __tmp, __cvt))
 612         return path{ __tmp };
 613       _GLIBCXX_THROW_OR_ABORT(filesystem_error(
 614             "Cannot convert character sequence",
 615             std::make_error_code(errc::illegal_byte_sequence)));
 616     }
 617
 618 #ifdef _GLIBCXX_USE_CHAR8_T
 619   template<typename _InputIterator>
 620     inline path
 621     __u8path(_InputIterator __first, _InputIterator __last, char8_t)
 622     {
 623       return path{ __first, __last };
 624     }
 625 #endif // _GLIBCXX_USE_CHAR8_T
 626 #endif // _GLIBCXX_FILESYSTEM_IS_WINDOWS
 627
 628   template<typename _InputIterator,
 629            typename _Require = __detail::_Path<_InputIterator, _InputIterator>,
 630            typename _CharT =
 631              __detail::__value_type_is_char_or_char8_t<_InputIterator>>
 632     inline path
 633     u8path(_InputIterator __first, _InputIterator __last)
 634     {
 635 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 636       return __u8path(__first, __last, _CharT{});
 637 #else
 638       return path{ __first, __last };
 639 #endif
 640     }
 641
 642   /// Create a path from a UTF-8-encoded sequence of char
 643 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 644   inline path
 645   __u8path(const string& __s, char)
 646   {
 647     return filesystem::u8path(__s.data(), __s.data() + __s.size());
 648   }
 649
 650   template<typename _Source>
 651     inline __enable_if_t<is_convertible<const _Source&, string>::value, path>
 652     __u8path(const _Source& __source, char)
 653     {
 654       std::string __s = __source;
 655       return filesystem::u8path(__s.data(), __s.data() + __s.size());
 656     }
 657
 658   template<typename _Source>
 659     inline __enable_if_t<!is_convertible<const _Source&, string>::value, path>
 660     __u8path(const _Source& __source, char)
 661     {
 662       std::string __s = path::_S_string_from_iter(__source);
 663       return filesystem::u8path(__s.data(), __s.data() + __s.size());
 664     }
 665
 666 #ifdef _GLIBCXX_USE_CHAR8_T
 667   template<typename _Source>
 668     inline path
 669     __u8path(const _Source& __source, char8_t)
 670     {
 671       return path{ __source };
 672     }
 673 #endif // _GLIBCXX_USE_CHAR8_T
 674 #endif // _GLIBCXX_FILESYSTEM_IS_WINDOWS
 675
 676   template<typename _Source,
 677            typename _Require = __detail::_Path<_Source>,
 678            typename _CharT =
 679              __detail::__value_type_is_char_or_char8_t<_Source>>
 680     inline path
 681     u8path(const _Source& __source)
 682     {
 683 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 684       return __u8path(__source, _CharT{});
 685 #else
 686       return path{ __source };
 687 #endif
 688     }
 689
 690   /// @}
 691
 692   /// Exception type thrown by the Filesystem TS library
 693   class filesystem_error : public std::system_error
 694   {
 695   public:
 696     filesystem_error(const string& __what_arg, error_code __ec)
 697     : system_error(__ec, __what_arg) { }
 698
 699     filesystem_error(const string& __what_arg, const path& __p1,
 700                      error_code __ec)
 701     : system_error(__ec, __what_arg), _M_path1(__p1) { }
 702
 703     filesystem_error(const string& __what_arg, const path& __p1,
 704                      const path& __p2, error_code __ec)
 705     : system_error(__ec, __what_arg), _M_path1(__p1), _M_path2(__p2)
 706     { }
 707
 708     ~filesystem_error();
 709
 710     const path& path1() const noexcept { return _M_path1; }
 711     const path& path2() const noexcept { return _M_path2; }
 712     const char* what() const noexcept { return _M_what.c_str(); }
 713
 714   private:
 715     std::string _M_gen_what();
 716
 717     path _M_path1;
 718     path _M_path2;
 719     std::string _M_what = _M_gen_what();
 720   };
 721
 722   /// @cond undocumented
 723   struct path::_Cmpt : path
 724   {
 725     _Cmpt(string_type __s, _Type __t, size_t __pos)
 726       : path(std::move(__s), __t), _M_pos(__pos) { }
 727
 728     _Cmpt() : _M_pos(-1) { }
 729
 730     size_t _M_pos;
 731   };
 732
 733   // specialize _Cvt for degenerate 'noconv' case
 734   template<>
 735     struct path::_Cvt<path::value_type>
 736     {
 737       // We need this type to be defined because we don't have `if constexpr`
 738       // in C++11 and so path::string<C,T,A>(const A&) needs to be able to
 739       // declare a variable of this type and pass it to __str_codecvt_in_all.
 740       using __codecvt_utf8_to_wide = _Cvt;
 741       // Dummy overload used for unreachable calls in path::string<C,T,A>.
 742       template<typename _WStr>
 743         friend bool
 744         __str_codecvt_in_all(const char*, const char*,
 745                              _WStr&, __codecvt_utf8_to_wide&) noexcept
 746         { return true; }
 747
 748       template<typename _Iter>
 749         static string_type
 750         _S_convert(_Iter __first, _Iter __last)
 751         { return string_type{__first, __last}; }
 752     };
 753
 754   // Performs conversions from _CharT to path::string_type.
 755   template<typename _CharT>
 756     struct path::_Cvt
 757     {
 758       // FIXME: We currently assume that the native wide encoding for wchar_t
 759       // is either UTF-32 or UTF-16 (depending on the width of wchar_t).
 760       // See comments in <bits/fs_path.h> for further details.
 761       using __codecvt_utf8_to_wchar
 762         = __conditional_t<sizeof(wchar_t) == sizeof(char32_t),
 763                           std::codecvt_utf8<wchar_t>,        // from UTF-32
 764                           std::codecvt_utf8_utf16<wchar_t>>; // from UTF-16
 765
 766       // Converts from char16_t or char32_t using std::codecvt<charNN_t, char>.
 767       // Need derived class here because std::codecvt has protected destructor.
 768       struct __codecvt_utf8_to_utfNN : std::codecvt<_CharT, char, mbstate_t>
 769       { };
 770
 771       // Convert from native pathname format (assumed to be UTF-8 everywhere)
 772       // to the encoding implied by the wide character type _CharT.
 773       using __codecvt_utf8_to_wide
 774         = __conditional_t<is_same<_CharT, wchar_t>::value,
 775                           __codecvt_utf8_to_wchar,
 776                           __codecvt_utf8_to_utfNN>;
 777
 778 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 779 #ifdef _GLIBCXX_USE_CHAR8_T
 780       static string_type
 781       _S_wconvert(const char8_t* __f, const char8_t* __l, const char8_t*)
 782       {
 783         const char* __f2 = (const char*)__f;
 784         const char* __l2 = (const char*)__l;
 785         std::wstring __wstr;
 786         std::codecvt_utf8_utf16<wchar_t> __wcvt;
 787         if (__str_codecvt_in_all(__f2, __l2, __wstr, __wcvt))
 788           return __wstr;
 789       }
 790 #endif
 791
 792       static string_type
 793       _S_wconvert(const char* __f, const char* __l, const char*)
 794       {
 795         std::codecvt_utf8_utf16<wchar_t> __cvt;
 796         std::wstring __wstr;
 797         if (__str_codecvt_in_all(__f, __l, __wstr, __cvt))
 798             return __wstr;
 799         _GLIBCXX_THROW_OR_ABORT(filesystem_error(
 800               "Cannot convert character sequence",
 801               std::make_error_code(errc::illegal_byte_sequence)));
 802       }
 803
 804       static string_type
 805       _S_wconvert(const _CharT* __f, const _CharT* __l, const void*)
 806       {
 807         __codecvt_utf8_to_wide __cvt;
 808         std::string __str;
 809         if (__str_codecvt_out_all(__f, __l, __str, __cvt))
 810           {
 811             const char* __f2 = __str.data();
 812             const char* __l2 = __f2 + __str.size();
 813             std::codecvt_utf8_utf16<wchar_t> __wcvt;
 814             std::wstring __wstr;
 815             if (__str_codecvt_in_all(__f2, __l2, __wstr, __wcvt))
 816               return __wstr;
 817           }
 818         _GLIBCXX_THROW_OR_ABORT(filesystem_error(
 819               "Cannot convert character sequence",
 820               std::make_error_code(errc::illegal_byte_sequence)));
 821       }
 822
 823       static string_type
 824       _S_convert(const _CharT* __f, const _CharT* __l)
 825       {
 826         return _S_wconvert(__f, __l, (const _CharT*)nullptr);
 827       }
 828 #else
 829       static string_type
 830       _S_convert(const _CharT* __f, const _CharT* __l)
 831       {
 832 #ifdef _GLIBCXX_USE_CHAR8_T
 833         if constexpr (is_same<_CharT, char8_t>::value)
 834           return string_type(__f, __l);
 835         else
 836 #endif
 837           {
 838             __codecvt_utf8_to_wide __cvt;
 839             std::string __str;
 840             if (__str_codecvt_out_all(__f, __l, __str, __cvt))
 841               return __str;
 842             _GLIBCXX_THROW_OR_ABORT(filesystem_error(
 843                   "Cannot convert character sequence",
 844                   std::make_error_code(errc::illegal_byte_sequence)));
 845           }
 846       }
 847 #endif
 848
 849       static string_type
 850       _S_convert(_CharT* __f, _CharT* __l)
 851       {
 852         return _S_convert(const_cast<const _CharT*>(__f),
 853                           const_cast<const _CharT*>(__l));
 854       }
 855
 856       template<typename _Iter>
 857         static string_type
 858         _S_convert(_Iter __first, _Iter __last)
 859         {
 860           const std::basic_string<_CharT> __str(__first, __last);
 861           return _S_convert(__str.data(), __str.data() + __str.size());
 862         }
 863
 864       template<typename _Iter, typename _Cont>
 865         static string_type
 866         _S_convert(__gnu_cxx::__normal_iterator<_Iter, _Cont> __first,
 867                   __gnu_cxx::__normal_iterator<_Iter, _Cont> __last)
 868         { return _S_convert(__first.base(), __last.base()); }
 869     };
 870   /// @endcond
 871
 872   /// An iterator for the components of a path
 873   class path::iterator
 874   {
 875   public:
 876     using difference_type       = std::ptrdiff_t;
 877     using value_type            = path;
 878     using reference             = const path&;
 879     using pointer               = const path*;
 880     using iterator_category     = std::bidirectional_iterator_tag;
 881
 882     iterator() noexcept : _M_path(nullptr), _M_cur(), _M_at_end() { }
 883
 884     iterator(const iterator&) = default;
 885     iterator& operator=(const iterator&) = default;
 886
 887     reference operator*() const noexcept;
 888     pointer   operator->() const noexcept { return std::__addressof(**this); }
 889
 890     iterator& operator++() noexcept;
 891
 892     iterator  operator++(int) noexcept
 893     { auto __tmp = *this; ++*this; return __tmp; }
 894
 895     iterator& operator--() noexcept;
 896
 897     iterator  operator--(int) noexcept
 898     { auto __tmp = *this; --*this; return __tmp; }
 899
 900     friend bool
 901     operator==(const iterator& __lhs, const iterator& __rhs) noexcept
 902     { return __lhs._M_equals(__rhs); }
 903
 904     friend bool
 905     operator!=(const iterator& __lhs, const iterator& __rhs) noexcept
 906     { return !__lhs._M_equals(__rhs); }
 907
 908   private:
 909     friend class path;
 910
 911     iterator(const path* __path, path::_List::const_iterator __iter) noexcept
 912     : _M_path(__path), _M_cur(__iter), _M_at_end()
 913     { }
 914
 915     iterator(const path* __path, bool __at_end) noexcept
 916     : _M_path(__path), _M_cur(), _M_at_end(__at_end)
 917     { }
 918
 919     bool _M_equals(iterator) const noexcept;
 920
 921     const path*                 _M_path;
 922     path::_List::const_iterator _M_cur;
 923     bool                        _M_at_end;  // only used when type != _Multi
 924   };
 925
 926   inline
 927   path::path() noexcept = default;
 928
 929   inline
 930   path::path(const path&) = default;
 931
 932   inline
 933   path::path(path&& __p) noexcept
 934   : _M_pathname(std::move(__p._M_pathname)),
 935     _M_cmpts(__p._M_cmpts),
 936     _M_type(__p._M_type)
 937   { __p.clear(); }
 938
 939   inline
 940   path::path(string_type&& __source)
 941   : _M_pathname(std::move(__source))
 942   { _M_split_cmpts(); }
 943
 944   inline
 945   path::path(string_type __str, _Type __type)
 946   : _M_pathname(__str), _M_type(__type)
 947   {
 948     __glibcxx_assert(!empty());
 949     __glibcxx_assert(_M_type != _Type::_Multi);
 950   }
 951
 952   inline
 953   path::~path() = default;
 954
 955   inline path&
 956   path::operator=(const path& __p) = default;
 957
 958   inline path&
 959   path::operator=(path&& __p) noexcept
 960   {
 961     _M_pathname = std::move(__p._M_pathname);
 962     _M_cmpts = std::move(__p._M_cmpts);
 963     _M_type = __p._M_type;
 964     __p.clear();
 965     return *this;
 966   }
 967
 968   inline path&
 969   path::operator=(string_type&& __source)
 970   { return *this = path(std::move(__source)); }
 971
 972   inline path&
 973   path::assign(string_type&& __source)
 974   { return *this = path(std::move(__source)); }
 975
 976   inline path&
 977   path::operator+=(const path& __p)
 978   {
 979     return operator+=(__p.native());
 980   }
 981
 982   inline path&
 983   path::operator+=(const string_type& __x)
 984   {
 985     _M_pathname += __x;
 986     _M_split_cmpts();
 987     return *this;
 988   }
 989
 990   inline path&
 991   path::operator+=(const value_type* __x)
 992   {
 993     _M_pathname += __x;
 994     _M_split_cmpts();
 995     return *this;
 996   }
 997
 998   inline path&
 999   path::operator+=(value_type __x)
1000   {
1001     _M_pathname += __x;
1002     _M_split_cmpts();
1003     return *this;
1004   }
1005
1006 #if __cplusplus >= 201402L
1007   inline path&
1008   path::operator+=(basic_string_view<value_type> __x)
1009   {
1010     _M_pathname.append(__x.data(), __x.size());
1011     _M_split_cmpts();
1012     return *this;
1013   }
1014 #endif
1015
1016   template<typename _CharT>
1017     inline __detail::_Path<_CharT*, _CharT*>&
1018     path::operator+=(_CharT __x)
1019     {
1020       auto* __addr = std::__addressof(__x);
1021       return concat(__addr, __addr + 1);
1022     }
1023
1024   inline path&
1025   path::make_preferred()
1026   {
1027 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1028     std::replace(_M_pathname.begin(), _M_pathname.end(), L'/',
1029                  preferred_separator);
1030 #endif
1031     return *this;
1032   }
1033
1034   inline void path::swap(path& __rhs) noexcept
1035   {
1036     _M_pathname.swap(__rhs._M_pathname);
1037     _M_cmpts.swap(__rhs._M_cmpts);
1038     std::swap(_M_type, __rhs._M_type);
1039   }
1040
1041   template<typename _CharT, typename _Traits, typename _Allocator>
1042     inline std::basic_string<_CharT, _Traits, _Allocator>
1043     path::string(const _Allocator& __a) const
1044     {
1045       if _GLIBCXX17_CONSTEXPR (is_same<_CharT, value_type>::value)
1046         return { _M_pathname.begin(), _M_pathname.end(), __a };
1047
1048       using _WString = basic_string<_CharT, _Traits, _Allocator>;
1049
1050       const value_type* __first = _M_pathname.data();
1051       const value_type* __last = __first + _M_pathname.size();
1052
1053 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1054       using _CharAlloc = __alloc_rebind<_Allocator, char>;
1055       using _String = basic_string<char, char_traits<char>, _CharAlloc>;
1056
1057       // First convert native string from UTF-16 to to UTF-8.
1058       // XXX This assumes that the execution wide-character set is UTF-16.
1059       codecvt_utf8_utf16<value_type> __cvt;
1060       _String __u8str{_CharAlloc{__a}};
1061       if (__str_codecvt_out_all(__first, __last, __u8str, __cvt))
1062         {
1063           struct
1064           {
1065             const _String*
1066             operator()(const _String& __from, _String&, true_type)
1067             { return std::__addressof(__from); }
1068
1069             _WString*
1070             operator()(const _String& __from, _WString& __to, false_type)
1071             {
1072 #ifdef _GLIBCXX_USE_CHAR8_T
1073               if constexpr (is_same<_CharT, char8_t>::value)
1074                 {
1075                   __to.assign(__from.begin(), __from.end());
1076                   return std::__addressof(__to);
1077                 }
1078               else
1079 #endif
1080                 {
1081                   // Convert UTF-8 to char16_t or char32_t string.
1082                   typename path::_Cvt<_CharT>::__codecvt_utf8_to_wide __cvt;
1083                   const char* __f = __from.data();
1084                   const char* __l = __f + __from.size();
1085                   if (__str_codecvt_in_all(__f, __l, __to, __cvt))
1086                     return std::__addressof(__to);
1087                 }
1088               return nullptr;
1089             }
1090           } __dispatch;
1091           _WString __wstr(__a);
1092           if (auto* __p = __dispatch(__u8str, __wstr, is_same<_CharT, char>{}))
1093             return *__p;
1094         }
1095 #else // ! Windows
1096 #ifdef _GLIBCXX_USE_CHAR8_T
1097       if constexpr (is_same<_CharT, char8_t>::value)
1098           return _WString(__first, __last, __a);
1099       else
1100 #endif
1101         {
1102           typename path::_Cvt<_CharT>::__codecvt_utf8_to_wide __cvt;
1103           _WString __wstr(__a);
1104           if (__str_codecvt_in_all(__first, __last, __wstr, __cvt))
1105             return __wstr;
1106         }
1107 #endif
1108       _GLIBCXX_THROW_OR_ABORT(filesystem_error(
1109             "Cannot convert character sequence",
1110             std::make_error_code(errc::illegal_byte_sequence)));
1111     }
1112
1113   inline std::string
1114   path::string() const { return string<char>(); }
1115
1116 #if _GLIBCXX_USE_WCHAR_T
1117   inline std::wstring
1118   path::wstring() const { return string<wchar_t>(); }
1119 #endif
1120
1121 #ifdef _GLIBCXX_USE_CHAR8_T
1122   inline std::u8string
1123   path::u8string() const { return string<char8_t>(); }
1124 #else
1125   inline std::string
1126   path::u8string() const
1127   {
1128 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1129     std::string __str;
1130     // convert from native wide encoding (assumed to be UTF-16) to UTF-8
1131     std::codecvt_utf8_utf16<value_type> __cvt;
1132     const value_type* __first = _M_pathname.data();
1133     const value_type* __last = __first + _M_pathname.size();
1134     if (__str_codecvt_out_all(__first, __last, __str, __cvt))
1135       return __str;
1136     _GLIBCXX_THROW_OR_ABORT(filesystem_error(
1137           "Cannot convert character sequence",
1138           std::make_error_code(errc::illegal_byte_sequence)));
1139 #else
1140     return _M_pathname;
1141 #endif
1142   }
1143 #endif // _GLIBCXX_USE_CHAR8_T
1144
1145   inline std::u16string
1146   path::u16string() const { return string<char16_t>(); }
1147
1148   inline std::u32string
1149   path::u32string() const { return string<char32_t>(); }
1150
1151   template<typename _CharT, typename _Traits, typename _Allocator>
1152     inline std::basic_string<_CharT, _Traits, _Allocator>
1153     path::generic_string(const _Allocator& __a) const
1154     {
1155 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1156       const _CharT __slash = is_same<_CharT, wchar_t>::value
1157         ? _CharT(L'/')
1158         : _CharT('/'); // Assume value is correct for the encoding.
1159 #else
1160       const _CharT __slash = _CharT('/');
1161 #endif
1162       basic_string<_CharT, _Traits, _Allocator> __str(__a);
1163       __str.reserve(_M_pathname.size());
1164       bool __add_slash = false;
1165       for (auto& __elem : *this)
1166         {
1167           if (__elem._M_type == _Type::_Root_dir)
1168             {
1169               __str += __slash;
1170               continue;
1171             }
1172           if (__add_slash)
1173             __str += __slash;
1174           __str += __elem.string<_CharT, _Traits, _Allocator>(__a);
1175           __add_slash = __elem._M_type == _Type::_Filename;
1176         }
1177       return __str;
1178     }
1179
1180   inline std::string
1181   path::generic_string() const { return generic_string<char>(); }
1182
1183 #if _GLIBCXX_USE_WCHAR_T
1184   inline std::wstring
1185   path::generic_wstring() const { return generic_string<wchar_t>(); }
1186 #endif
1187
1188 #ifdef _GLIBCXX_USE_CHAR8_T
1189   inline std::u8string
1190   path::generic_u8string() const { return generic_string<char8_t>(); }
1191 #else
1192   inline std::string
1193   path::generic_u8string() const { return generic_string<char>(); }
1194 #endif
1195
1196   inline std::u16string
1197   path::generic_u16string() const { return generic_string<char16_t>(); }
1198
1199   inline std::u32string
1200   path::generic_u32string() const { return generic_string<char32_t>(); }
1201
1202   inline int
1203   path::compare(const string_type& __s) const { return compare(path(__s)); }
1204
1205   inline int
1206   path::compare(const value_type* __s) const { return compare(path(__s)); }
1207
1208 #if __cplusplus >= 201402L
1209   inline int
1210   path::compare(basic_string_view<value_type> __s) const
1211   { return compare(path(__s)); }
1212 #endif
1213
1214   inline path
1215   path::filename() const { return empty() ? path() : *--end(); }
1216
1217   inline path
1218   path::stem() const
1219   {
1220     auto ext = _M_find_extension();
1221     if (ext.first && ext.second != 0)
1222       return path{ext.first->substr(0, ext.second)};
1223     return {};
1224   }
1225
1226   inline path
1227   path::extension() const
1228   {
1229     auto ext = _M_find_extension();
1230     if (ext.first && ext.second != string_type::npos)
1231       return path{ext.first->substr(ext.second)};
1232     return {};
1233   }
1234
1235   inline bool
1236   path::has_stem() const
1237   {
1238     auto ext = _M_find_extension();
1239     return ext.first && ext.second != 0;
1240   }
1241
1242   inline bool
1243   path::has_extension() const
1244   {
1245     auto ext = _M_find_extension();
1246     return ext.first && ext.second != string_type::npos;
1247   }
1248
1249   inline bool
1250   path::is_absolute() const
1251   {
1252 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1253     return has_root_name() && has_root_directory();
1254 #else
1255     return has_root_directory();
1256 #endif
1257   }
1258
1259   inline path::iterator
1260   path::begin() const noexcept
1261   {
1262     if (_M_type == _Type::_Multi)
1263       return iterator(this, _M_cmpts.begin());
1264     return iterator(this, false);
1265   }
1266
1267   inline path::iterator
1268   path::end() const noexcept
1269   {
1270     if (_M_type == _Type::_Multi)
1271       return iterator(this, _M_cmpts.end());
1272     return iterator(this, true);
1273   }
1274
1275   inline path::iterator&
1276   path::iterator::operator++() noexcept
1277   {
1278     __glibcxx_assert(_M_path != nullptr);
1279     if (_M_path->_M_type == _Type::_Multi)
1280       {
1281         __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1282         ++_M_cur;
1283       }
1284     else
1285       {
1286         __glibcxx_assert(!_M_at_end);
1287         _M_at_end = true;
1288       }
1289     return *this;
1290   }
1291
1292   inline path::iterator&
1293   path::iterator::operator--() noexcept
1294   {
1295     __glibcxx_assert(_M_path != nullptr);
1296     if (_M_path->_M_type == _Type::_Multi)
1297       {
1298         __glibcxx_assert(_M_cur != _M_path->_M_cmpts.begin());
1299         --_M_cur;
1300       }
1301     else
1302       {
1303         __glibcxx_assert(_M_at_end);
1304         _M_at_end = false;
1305       }
1306     return *this;
1307   }
1308
1309   inline path::iterator::reference
1310   path::iterator::operator*() const noexcept
1311   {
1312     __glibcxx_assert(_M_path != nullptr);
1313     if (_M_path->_M_type == _Type::_Multi)
1314       {
1315         __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1316         return *_M_cur;
1317       }
1318     return *_M_path;
1319   }
1320
1321   inline bool
1322   path::iterator::_M_equals(iterator __rhs) const noexcept
1323   {
1324     if (_M_path != __rhs._M_path)
1325       return false;
1326     if (_M_path == nullptr)
1327       return true;
1328     if (_M_path->_M_type == path::_Type::_Multi)
1329       return _M_cur == __rhs._M_cur;
1330     return _M_at_end == __rhs._M_at_end;
1331   }
1332
1333   // Define these now that path and path::iterator are complete.
1334   // They needs to consider the string_view(Range&&) constructor during
1335   // overload resolution, which depends on whether range<path> is satisfied,
1336   // which depends on whether path::iterator is complete.
1337   inline bool operator<(const path& __lhs, const path& __rhs) noexcept
1338   { return __lhs.compare(__rhs) < 0; }
1339
1340   inline bool operator==(const path& __lhs, const path& __rhs) noexcept
1341   { return __lhs.compare(__rhs) == 0; }
1342
1343   /// @} group filesystem-ts
1344 _GLIBCXX_END_NAMESPACE_CXX11
1345 } // namespace v1
1346 } // namespace filesystem
1347 } // namespace experimental
1348
1349 _GLIBCXX_END_NAMESPACE_VERSION
1350 } // namespace std
1351
1352 #endif // C++11
1353
1354 #endif // _GLIBCXX_EXPERIMENTAL_FS_PATH_H