This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: Additional headers under include/experimental/
- From: Jonathan Wakely <jwakely at redhat dot com>
- To: libstdc++ at gcc dot gnu dot org
- Cc: gcc-patches at gcc dot gnu dot org
- Date: Fri, 9 Oct 2015 12:20:12 +0100
- Subject: Re: Additional headers under include/experimental/
- Authentication-results: sourceware.org; auth=none
- References: <20140703103529 dot GI4871 at redhat dot com> <20151006141225 dot GS12094 at redhat dot com>
On 06/10/15 15:12 +0100, Jonathan Wakely wrote:
On 03/07/14 11:35 +0100, Jonathan Wakely wrote:
I'm working on parts of the Filesystem TS and think it makes sense to
split it up into separate headers for path, directory utils and the
free functions, then include those from <experimental/filesystem>,
otherwise it's going to be a whopper.
Currently I've created include/experimental/fs_path.h for the path
class, does that seem OK?
Would a new include/experimental/bits directory be better, so that
only official headers required by a TS are in include/experimental?
(That would imply moving string_view.tcc to another directory).
I'm thinking about adding an include/experimental/bits directory
again, for internal pieces of the Networking TS.
I didn't do it last time because I was too lazy, but as I'm adding
more non-public headers to include/experimental I think it makes
sense.
Committed, after testing on powerpc64le-linux.
2015-10-09 Jonathan Wakely <jwakely@redhat.com>
* include/experimental/erase_if.h: Move to ...
* include/experimental/bits/erase_if.h: New.
* include/experimental/fs_dir.h: Move to ...
* include/experimental/bits/fs_dir.h: New.
* include/experimental/fs_fwd.h: Move to ...
* include/experimental/bits/fs_fwd.h: New.
* include/experimental/fs_ops.h: Move to ...
* include/experimental/bits/fs_ops.h: New.
* include/experimental/fs_path.h: Move to ...
* include/experimental/bits/fs_path.h: New.
* include/experimental/string_view.tcc: Move to ...
* include/experimental/bits/string_view.tcc: New.
* include/Makefile.am: Add include/experimental/bits sub-directory.
* include/Makefile.in: Regenerate.
* include/experimental/filesystem: Adjust includes.
* include/experimental/map: Likewise.
* include/experimental/set: Likewise.
* include/experimental/string_view: Likewise.
* include/experimental/unordered_map: Likewise.
* include/experimental/unordered_set: Likewise.
commit 9f7271cd101c768a3582f177fdaa1389cefd1e1a
Author: Jonathan Wakely <jwakely@redhat.com>
Date: Tue Oct 6 13:03:31 2015 +0100
Add include/experimental/bits dir
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index 74100f2..2dc0d01 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -650,7 +650,6 @@ experimental_headers = \
${experimental_srcdir}/array \
${experimental_srcdir}/chrono \
${experimental_srcdir}/deque \
- ${experimental_srcdir}/erase_if.h \
${experimental_srcdir}/forward_list \
${experimental_srcdir}/functional \
${experimental_srcdir}/iterator \
@@ -664,7 +663,6 @@ experimental_headers = \
${experimental_srcdir}/set \
${experimental_srcdir}/string \
${experimental_srcdir}/string_view \
- ${experimental_srcdir}/string_view.tcc \
${experimental_srcdir}/system_error \
${experimental_srcdir}/tuple \
${experimental_srcdir}/type_traits \
@@ -673,15 +671,24 @@ experimental_headers = \
${experimental_srcdir}/vector \
${experimental_filesystem_headers}
+experimental_bits_srcdir = ${glibcxx_srcdir}/include/experimental/bits
+experimental_bits_builddir = ./experimental/bits
+experimental_bits_headers = \
+ ${experimental_bits_srcdir}/erase_if.h \
+ ${experimental_bits_srcdir}/string_view.tcc \
+ ${experimental_bits_filesystem_headers}
+
if ENABLE_FILESYSTEM_TS
experimental_filesystem_headers = \
- ${experimental_srcdir}/filesystem \
- ${experimental_srcdir}/fs_dir.h \
- ${experimental_srcdir}/fs_fwd.h \
- ${experimental_srcdir}/fs_ops.h \
- ${experimental_srcdir}/fs_path.h
+ ${experimental_srcdir}/filesystem
+experimental_bits_filesystem_headers = \
+ ${experimental_bits_srcdir}/fs_dir.h \
+ ${experimental_bits_srcdir}/fs_fwd.h \
+ ${experimental_bits_srcdir}/fs_ops.h \
+ ${experimental_bits_srcdir}/fs_path.h
else
experimental_filesystem_headers =
+experimental_bits_filesystem_headers =
endif
# This is the common subset of C++ files that all three "C" header models use.
@@ -968,8 +975,8 @@ endif
allstamped = \
stamp-std stamp-bits stamp-bits-sup stamp-c_base stamp-c_compatibility \
stamp-backward stamp-ext stamp-pb stamp-tr1 stamp-tr2 stamp-decimal \
- stamp-experimental stamp-debug stamp-parallel stamp-profile \
- stamp-profile-impl stamp-host
+ stamp-experimental stamp-experimental-bits stamp-debug stamp-parallel \
+ stamp-profile stamp-profile-impl stamp-host
# List of all files that are created by explicit building, editing, or
# catenation.
@@ -1097,6 +1104,11 @@ stamp-experimental: ${experimental_headers}
@-cd ${experimental_builddir} && $(LN_S) $? . 2>/dev/null
@$(STAMP) stamp-experimental
+stamp-experimental-bits: ${experimental_bits_headers}
+ @-mkdir -p ${experimental_bits_builddir}
+ @-cd ${experimental_bits_builddir} && $(LN_S) $? . 2>/dev/null
+ @$(STAMP) stamp-experimental-bits
+
stamp-debug: ${debug_headers}
@-mkdir -p ${debug_builddir}
@-cd ${debug_builddir} && $(LN_S) $? . 2>/dev/null
@@ -1369,6 +1381,9 @@ install-headers:
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${experimental_builddir}
for file in ${experimental_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${experimental_builddir}; done
+ $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${experimental_bits_builddir}
+ for file in ${experimental_bits_headers}; do \
+ $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${experimental_bits_builddir}; done
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${c_base_builddir}
for file in ${c_base_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${c_base_builddir}; done
@@ -1415,9 +1430,11 @@ clean-local:
# be made.)
.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(tr2_headers)
$(decimal_headers) $(ext_headers) $(experimental_headers)
+ $(experimental_bits_headers)
$(std_headers): ; @:
$(c_base_headers): ; @:
$(tr1_headers): ; @:
$(decimal_headers): ; @:
$(ext_headers): ; @:
$(experimental_headers): ; @:
+$(experimental_bits_headers): ; @:
diff --git a/libstdc++-v3/include/experimental/bits/erase_if.h b/libstdc++-v3/include/experimental/bits/erase_if.h
new file mode 100644
index 0000000..e8bd728
--- /dev/null
+++ b/libstdc++-v3/include/experimental/bits/erase_if.h
@@ -0,0 +1,70 @@
+// <experimental/bits/erase_if.h> -*- C++ -*-
+
+// Copyright (C) 2015 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file experimental/bits/erase_if.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly.
+ */
+
+#ifndef _GLIBCXX_EXPERIMENTAL_ERASE_IF_H
+#define _GLIBCXX_EXPERIMENTAL_ERASE_IF_H 1
+
+#pragma GCC system_header
+
+#if __cplusplus <= 201103L
+# include <bits/c++14_warning.h>
+#else
+
+namespace std
+{
+namespace experimental
+{
+inline namespace fundamentals_v2
+{
+
+ namespace __detail
+ {
+ template<typename _Container, typename _Predicate>
+ void
+ __erase_nodes_if(_Container& __cont, _Predicate __pred)
+ {
+ for (auto __iter = __cont.begin(), __last = __cont.end();
+ __iter != __last;)
+ {
+ if (__pred(*__iter))
+ __iter = __cont.erase(__iter);
+ else
+ ++__iter;
+ }
+ }
+ }
+
+
+} // inline namespace fundamentals_v2
+} // namespace experimental
+} // namespace std
+
+#endif // C++14
+
+#endif // _GLIBCXX_EXPERIMENTAL_ERASE_IF_H
diff --git a/libstdc++-v3/include/experimental/bits/fs_dir.h b/libstdc++-v3/include/experimental/bits/fs_dir.h
new file mode 100644
index 0000000..0c5253f
--- /dev/null
+++ b/libstdc++-v3/include/experimental/bits/fs_dir.h
@@ -0,0 +1,338 @@
+// Filesystem directory utilities -*- C++ -*-
+
+// Copyright (C) 2014-2015 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file experimental/fs_dir.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{experimental/filesystem}
+ */
+
+#ifndef _GLIBCXX_EXPERIMENTAL_FS_DIR_H
+#define _GLIBCXX_EXPERIMENTAL_FS_DIR_H 1
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+# include <typeinfo>
+# include <ext/concurrence.h>
+# include <bits/unique_ptr.h>
+# include <bits/shared_ptr.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace experimental
+{
+namespace filesystem
+{
+inline namespace v1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ /**
+ * @ingroup filesystem
+ * @{
+ */
+
+ class file_status
+ {
+ public:
+ // constructors
+ explicit
+ file_status(file_type __ft = file_type::none,
+ perms __prms = perms::unknown) noexcept
+ : _M_type(__ft), _M_perms(__prms) { }
+
+ file_status(const file_status&) noexcept = default;
+ file_status(file_status&&) noexcept = default;
+ ~file_status() = default;
+
+ file_status& operator=(const file_status&) noexcept = default;
+ file_status& operator=(file_status&&) noexcept = default;
+
+ // observers
+ file_type type() const noexcept { return _M_type; }
+ perms permissions() const noexcept { return _M_perms; }
+
+ // modifiers
+ void type(file_type __ft) noexcept { _M_type = __ft; }
+ void permissions(perms __prms) noexcept { _M_perms = __prms; }
+
+ private:
+ file_type _M_type;
+ perms _M_perms;
+ };
+
+_GLIBCXX_BEGIN_NAMESPACE_CXX11
+
+ class directory_entry
+ {
+ public:
+ // constructors and destructor
+ directory_entry() noexcept = default;
+ directory_entry(const directory_entry&) = default;
+ directory_entry(directory_entry&&) noexcept = default;
+ explicit directory_entry(const filesystem::path& __p) : _M_path(__p) { }
+ ~directory_entry() = default;
+
+ // modifiers
+ directory_entry& operator=(const directory_entry&) = default;
+ directory_entry& operator=(directory_entry&&) noexcept = default;
+
+ void assign(const filesystem::path& __p) { _M_path = __p; }
+
+ void
+ replace_filename(const filesystem::path& __p)
+ { _M_path = _M_path.parent_path() / __p; }
+
+ // observers
+ const filesystem::path& path() const noexcept { return _M_path; }
+ operator const filesystem::path&() const noexcept { return _M_path; }
+
+ file_status
+ status() const
+ { return filesystem::status(_M_path); }
+
+ file_status
+ status(error_code& __ec) const noexcept
+ { return filesystem::status(_M_path, __ec); }
+
+ file_status
+ symlink_status() const
+ { return filesystem::symlink_status(_M_path); }
+
+ file_status
+ symlink_status(error_code& __ec) const noexcept
+ { return filesystem::symlink_status(_M_path, __ec); }
+
+ bool
+ operator< (const directory_entry& __rhs) const noexcept
+ { return _M_path < __rhs._M_path; }
+
+ bool
+ operator==(const directory_entry& __rhs) const noexcept
+ { return _M_path == __rhs._M_path; }
+
+ bool
+ operator!=(const directory_entry& __rhs) const noexcept
+ { return _M_path != __rhs._M_path; }
+
+ bool
+ operator<=(const directory_entry& __rhs) const noexcept
+ { return _M_path <= __rhs._M_path; }
+
+ bool
+ operator> (const directory_entry& __rhs) const noexcept
+ { return _M_path > __rhs._M_path; }
+
+ bool
+ operator>=(const directory_entry& __rhs) const noexcept
+ { return _M_path >= __rhs._M_path; }
+
+ private:
+ filesystem::path _M_path;
+ };
+
+ struct _Dir;
+ class recursive_directory_iterator;
+
+ class directory_iterator
+ {
+ public:
+ typedef directory_entry value_type;
+ typedef ptrdiff_t difference_type;
+ typedef const directory_entry* pointer;
+ typedef const directory_entry& reference;
+ typedef input_iterator_tag iterator_category;
+
+ directory_iterator() noexcept = default;
+
+ explicit
+ directory_iterator(const path& __p)
+ : directory_iterator(__p, directory_options::none, nullptr) { }
+
+ directory_iterator(const path& __p, directory_options __options)
+ : directory_iterator(__p, __options, nullptr) { }
+
+ directory_iterator(const path& __p, error_code& __ec) noexcept
+ : directory_iterator(__p, directory_options::none, __ec) { }
+
+ directory_iterator(const path& __p,
+ directory_options __options, error_code& __ec) noexcept
+ : directory_iterator(__p, __options, &__ec) { }
+
+ directory_iterator(const directory_iterator& __rhs) = default;
+
+ directory_iterator(directory_iterator&& __rhs) noexcept = default;
+
+ ~directory_iterator() = default;
+
+ directory_iterator& operator=(const directory_iterator& __rhs) = default;
+ directory_iterator& operator=(directory_iterator&& __rhs) noexcept = default;
+
+ const directory_entry& operator*() const;
+ const directory_entry* operator->() const { return &**this; }
+ directory_iterator& operator++();
+ directory_iterator& increment(error_code& __ec) noexcept;
+
+ directory_iterator operator++(int)
+ {
+ auto __tmp = *this;
+ ++*this;
+ return __tmp;
+ }
+
+ private:
+ directory_iterator(const path&, directory_options, error_code*);
+
+ friend bool
+ operator==(const directory_iterator& __lhs,
+ const directory_iterator& __rhs);
+
+ friend class recursive_directory_iterator;
+
+ std::shared_ptr<_Dir> _M_dir;
+ };
+
+ inline directory_iterator
+ begin(directory_iterator __iter) { return __iter; }
+
+ inline directory_iterator
+ end(directory_iterator) { return directory_iterator(); }
+
+ inline bool
+ operator==(const directory_iterator& __lhs, const directory_iterator& __rhs)
+ {
+ return !__rhs._M_dir.owner_before(__lhs._M_dir)
+ && !__lhs._M_dir.owner_before(__rhs._M_dir);
+ }
+
+ inline bool
+ operator!=(const directory_iterator& __lhs, const directory_iterator& __rhs)
+ { return !(__lhs == __rhs); }
+
+ class recursive_directory_iterator
+ {
+ public:
+ typedef directory_entry value_type;
+ typedef ptrdiff_t difference_type;
+ typedef const directory_entry* pointer;
+ typedef const directory_entry& reference;
+ typedef input_iterator_tag iterator_category;
+
+ recursive_directory_iterator() noexcept = default;
+
+ explicit
+ recursive_directory_iterator(const path& __p)
+ : recursive_directory_iterator(__p, directory_options::none, nullptr) { }
+
+ recursive_directory_iterator(const path& __p, directory_options __options)
+ : recursive_directory_iterator(__p, __options, nullptr) { }
+
+ recursive_directory_iterator(const path& __p,
+ directory_options __options,
+ error_code& __ec) noexcept
+ : recursive_directory_iterator(__p, __options, &__ec) { }
+
+ recursive_directory_iterator(const path& __p, error_code& __ec) noexcept
+ : recursive_directory_iterator(__p, directory_options::none, &__ec) { }
+
+ recursive_directory_iterator(
+ const recursive_directory_iterator&) = default;
+
+ recursive_directory_iterator(
+ recursive_directory_iterator&&) noexcept = default;
+
+ ~recursive_directory_iterator();
+
+ // observers
+ directory_options options() const { return _M_options; }
+ int depth() const;
+ bool recursion_pending() const { return _M_pending; }
+
+ const directory_entry& operator*() const;
+ const directory_entry* operator->() const { return &**this; }
+
+ // modifiers
+ recursive_directory_iterator&
+ operator=(const recursive_directory_iterator& __rhs) noexcept;
+ recursive_directory_iterator&
+ operator=(recursive_directory_iterator&& __rhs) noexcept;
+
+ recursive_directory_iterator& operator++();
+ recursive_directory_iterator& increment(error_code& __ec) noexcept;
+
+ recursive_directory_iterator operator++(int)
+ {
+ auto __tmp = *this;
+ ++*this;
+ return __tmp;
+ }
+
+ void pop();
+
+ void disable_recursion_pending() { _M_pending = false; }
+
+ private:
+ recursive_directory_iterator(const path&, directory_options, error_code*);
+
+ friend bool
+ operator==(const recursive_directory_iterator& __lhs,
+ const recursive_directory_iterator& __rhs);
+
+ struct _Dir_stack;
+ std::shared_ptr<_Dir_stack> _M_dirs;
+ directory_options _M_options;
+ bool _M_pending;
+ };
+
+ inline recursive_directory_iterator
+ begin(recursive_directory_iterator __iter) { return __iter; }
+
+ inline recursive_directory_iterator
+ end(recursive_directory_iterator) { return recursive_directory_iterator(); }
+
+ inline bool
+ operator==(const recursive_directory_iterator& __lhs,
+ const recursive_directory_iterator& __rhs)
+ {
+ return !__rhs._M_dirs.owner_before(__lhs._M_dirs)
+ && !__lhs._M_dirs.owner_before(__rhs._M_dirs);
+ }
+
+ inline bool
+ operator!=(const recursive_directory_iterator& __lhs,
+ const recursive_directory_iterator& __rhs)
+ { return !(__lhs == __rhs); }
+
+_GLIBCXX_END_NAMESPACE_CXX11
+
+ // @} group filesystem
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace v1
+} // namespace filesystem
+} // namespace experimental
+} // namespace std
+
+#endif // C++11
+
+#endif // _GLIBCXX_EXPERIMENTAL_FS_DIR_H
diff --git a/libstdc++-v3/include/experimental/bits/fs_fwd.h b/libstdc++-v3/include/experimental/bits/fs_fwd.h
new file mode 100644
index 0000000..a5ed2c5
--- /dev/null
+++ b/libstdc++-v3/include/experimental/bits/fs_fwd.h
@@ -0,0 +1,289 @@
+// Filesystem declarations -*- C++ -*-
+
+// Copyright (C) 2014-2015 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file experimental/filesystem
+ * This is a TS C++ Library header.
+ */
+
+#ifndef _GLIBCXX_EXPERIMENTAL_FS_FWD_H
+#define _GLIBCXX_EXPERIMENTAL_FS_FWD_H 1
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <system_error>
+#include <cstdint>
+#include <chrono>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace experimental
+{
+namespace filesystem
+{
+inline namespace v1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if _GLIBCXX_USE_CXX11_ABI
+ inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+#endif
+
+ /**
+ * @defgroup filesystem
+ * @ingroup experimental
+ *
+ * Utilities for performing operations on file systems and their components,
+ * such as paths, regular files, and directories.
+ *
+ * @{
+ */
+
+ class file_status;
+_GLIBCXX_BEGIN_NAMESPACE_CXX11
+ class path;
+ class filesystem_error;
+ class directory_entry;
+ class directory_iterator;
+ class recursive_directory_iterator;
+_GLIBCXX_END_NAMESPACE_CXX11
+
+ struct space_info
+ {
+ uintmax_t capacity;
+ uintmax_t free;
+ uintmax_t available;
+ };
+
+ enum class file_type : signed char {
+ none = 0, not_found = -1, regular = 1, directory = 2, symlink = 3,
+ block = 4, character = 5, fifo = 6, socket = 7, unknown = 8
+ };
+
+ /// Bitmask type
+ enum class copy_options : unsigned short {
+ none = 0,
+ skip_existing = 1, overwrite_existing = 2, update_existing = 4,
+ recursive = 8,
+ copy_symlinks = 16, skip_symlinks = 32,
+ directories_only = 64, create_symlinks = 128, create_hard_links = 256
+ };
+
+ constexpr copy_options
+ operator&(copy_options __x, copy_options __y)
+ {
+ using __utype = typename std::underlying_type<copy_options>::type;
+ return static_cast<copy_options>(
+ static_cast<__utype>(__x) & static_cast<__utype>(__y));
+ }
+
+ constexpr copy_options
+ operator|(copy_options __x, copy_options __y)
+ {
+ using __utype = typename std::underlying_type<copy_options>::type;
+ return static_cast<copy_options>(
+ static_cast<__utype>(__x) | static_cast<__utype>(__y));
+ }
+
+ constexpr copy_options
+ operator^(copy_options __x, copy_options __y)
+ {
+ using __utype = typename std::underlying_type<copy_options>::type;
+ return static_cast<copy_options>(
+ static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
+ }
+
+ constexpr copy_options
+ operator~(copy_options __x)
+ {
+ using __utype = typename std::underlying_type<copy_options>::type;
+ return static_cast<copy_options>(~static_cast<__utype>(__x));
+ }
+
+ inline copy_options&
+ operator&=(copy_options& __x, copy_options __y)
+ { return __x = __x & __y; }
+
+ inline copy_options&
+ operator|=(copy_options& __x, copy_options __y)
+ { return __x = __x | __y; }
+
+ inline copy_options&
+ operator^=(copy_options& __x, copy_options __y)
+ { return __x = __x ^ __y; }
+
+
+ /// Bitmask type
+ enum class perms : unsigned {
+ none = 0,
+ owner_read = 0400,
+ owner_write = 0200,
+ owner_exec = 0100,
+ owner_all = 0700,
+ group_read = 040,
+ group_write = 020,
+ group_exec = 010,
+ group_all = 070,
+ others_read = 04,
+ others_write = 02,
+ others_exec = 01,
+ others_all = 07,
+ all = 0777,
+ set_uid = 04000,
+ set_gid = 02000,
+ sticky_bit = 01000,
+ mask = 07777,
+ unknown = 0xFFFF,
+ add_perms = 0x10000,
+ remove_perms = 0x20000,
+ resolve_symlinks = 0x40000
+ };
+
+ constexpr perms
+ operator&(perms __x, perms __y)
+ {
+ using __utype = typename std::underlying_type<perms>::type;
+ return static_cast<perms>(
+ static_cast<__utype>(__x) & static_cast<__utype>(__y));
+ }
+
+ constexpr perms
+ operator|(perms __x, perms __y)
+ {
+ using __utype = typename std::underlying_type<perms>::type;
+ return static_cast<perms>(
+ static_cast<__utype>(__x) | static_cast<__utype>(__y));
+ }
+
+ constexpr perms
+ operator^(perms __x, perms __y)
+ {
+ using __utype = typename std::underlying_type<perms>::type;
+ return static_cast<perms>(
+ static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
+ }
+
+ constexpr perms
+ operator~(perms __x)
+ {
+ using __utype = typename std::underlying_type<perms>::type;
+ return static_cast<perms>(~static_cast<__utype>(__x));
+ }
+
+ inline perms&
+ operator&=(perms& __x, perms __y)
+ { return __x = __x & __y; }
+
+ inline perms&
+ operator|=(perms& __x, perms __y)
+ { return __x = __x | __y; }
+
+ inline perms&
+ operator^=(perms& __x, perms __y)
+ { return __x = __x ^ __y; }
+
+ // Bitmask type
+ enum class directory_options : unsigned char {
+ none = 0, follow_directory_symlink = 1, skip_permission_denied = 2
+ };
+
+ constexpr directory_options
+ operator&(directory_options __x, directory_options __y)
+ {
+ using __utype = typename std::underlying_type<directory_options>::type;
+ return static_cast<directory_options>(
+ static_cast<__utype>(__x) & static_cast<__utype>(__y));
+ }
+
+ constexpr directory_options
+ operator|(directory_options __x, directory_options __y)
+ {
+ using __utype = typename std::underlying_type<directory_options>::type;
+ return static_cast<directory_options>(
+ static_cast<__utype>(__x) | static_cast<__utype>(__y));
+ }
+
+ constexpr directory_options
+ operator^(directory_options __x, directory_options __y)
+ {
+ using __utype = typename std::underlying_type<directory_options>::type;
+ return static_cast<directory_options>(
+ static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
+ }
+
+ constexpr directory_options
+ operator~(directory_options __x)
+ {
+ using __utype = typename std::underlying_type<directory_options>::type;
+ return static_cast<directory_options>(~static_cast<__utype>(__x));
+ }
+
+ inline directory_options&
+ operator&=(directory_options& __x, directory_options __y)
+ { return __x = __x & __y; }
+
+ inline directory_options&
+ operator|=(directory_options& __x, directory_options __y)
+ { return __x = __x | __y; }
+
+ inline directory_options&
+ operator^=(directory_options& __x, directory_options __y)
+ { return __x = __x ^ __y; }
+
+ typedef chrono::time_point<chrono::system_clock> file_time_type;
+
+ // operational functions
+
+ void copy(const path& __from, const path& __to, copy_options __options);
+ void copy(const path& __from, const path& __to, copy_options __options,
+ error_code&) noexcept;
+
+ bool copy_file(const path& __from, const path& __to, copy_options __option);
+ bool copy_file(const path& __from, const path& __to, copy_options __option,
+ error_code&) noexcept;
+
+ path current_path();
+
+ file_status status(const path&);
+ file_status status(const path&, error_code&) noexcept;
+
+ bool status_known(file_status) noexcept;
+
+ file_status symlink_status(const path&);
+ file_status symlink_status(const path&, error_code&) noexcept;
+
+ bool is_regular_file(file_status) noexcept;
+ bool is_symlink(file_status) noexcept;
+
+ // @} group filesystem
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace v1
+} // namespace filesystem
+} // namespace experimental
+} // namespace std
+
+#endif // C++11
+
+#endif // _GLIBCXX_EXPERIMENTAL_FS_FWD_H
diff --git a/libstdc++-v3/include/experimental/bits/fs_ops.h b/libstdc++-v3/include/experimental/bits/fs_ops.h
new file mode 100644
index 0000000..6b7d470
--- /dev/null
+++ b/libstdc++-v3/include/experimental/bits/fs_ops.h
@@ -0,0 +1,291 @@
+// Filesystem operational functions -*- C++ -*-
+
+// Copyright (C) 2014-2015 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your __option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file experimental/filesystem
+ * This is a TS C++ Library header.
+ */
+
+#ifndef _GLIBCXX_EXPERIMENTAL_FS_OPS_H
+#define _GLIBCXX_EXPERIMENTAL_FS_OPS_H 1
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <cstdint>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace experimental
+{
+namespace filesystem
+{
+inline namespace v1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ /**
+ * @ingroup filesystem
+ * @{
+ */
+
+ path absolute(const path& __p, const path& __base = current_path());
+
+ path canonical(const path& __p, const path& __base = current_path());
+ path canonical(const path& __p, error_code& __ec);
+ path canonical(const path& __p, const path& __base, error_code& __ec);
+
+ inline void
+ copy(const path& __from, const path& __to)
+ { copy(__from, __to, copy_options::none); }
+
+ inline void
+ copy(const path& __from, const path& __to, error_code& __ec) noexcept
+ { copy(__from, __to, copy_options::none, __ec); }
+
+ void copy(const path& __from, const path& __to, copy_options __options);
+ void copy(const path& __from, const path& __to, copy_options __options,
+ error_code& __ec) noexcept;
+
+ inline bool
+ copy_file(const path& __from, const path& __to)
+ { return copy_file(__from, __to, copy_options::none); }
+
+ inline bool
+ copy_file(const path& __from, const path& __to, error_code& __ec) noexcept
+ { return copy_file(__from, __to, copy_options::none, __ec); }
+
+ bool copy_file(const path& __from, const path& __to, copy_options __option);
+ bool copy_file(const path& __from, const path& __to, copy_options __option,
+ error_code& __ec) noexcept;
+
+ void copy_symlink(const path& __existing_symlink, const path& __new_symlink);
+ void copy_symlink(const path& __existing_symlink, const path& __new_symlink,
+ error_code& __ec) noexcept;
+
+ bool create_directories(const path& __p);
+ bool create_directories(const path& __p, error_code& __ec) noexcept;
+
+ bool create_directory(const path& __p);
+ bool create_directory(const path& __p, error_code& __ec) noexcept;
+
+ bool create_directory(const path& __p, const path& attributes);
+ bool create_directory(const path& __p, const path& attributes,
+ error_code& __ec) noexcept;
+
+ void create_directory_symlink(const path& __to, const path& __new_symlink);
+ void create_directory_symlink(const path& __to, const path& __new_symlink,
+ error_code& __ec) noexcept;
+
+ void create_hard_link(const path& __to, const path& __new_hard_link);
+ void create_hard_link(const path& __to, const path& __new_hard_link,
+ error_code& __ec) noexcept;
+
+ void create_symlink(const path& __to, const path& __new_symlink);
+ void create_symlink(const path& __to, const path& __new_symlink,
+ error_code& __ec) noexcept;
+
+ path current_path();
+ path current_path(error_code& __ec);
+ void current_path(const path& __p);
+ void current_path(const path& __p, error_code& __ec) noexcept;
+
+ inline bool
+ exists(file_status __s) noexcept
+ { return status_known(__s) && __s.type() != file_type::not_found; }
+
+ inline bool
+ exists(const path& __p)
+ { return exists(status(__p)); }
+
+ inline bool
+ exists(const path& __p, error_code& __ec) noexcept
+ { return exists(status(__p, __ec)); }
+
+ bool
+ equivalent(const path& __p1, const path& __p2);
+
+ bool
+ equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept;
+
+ uintmax_t file_size(const path& __p);
+ uintmax_t file_size(const path& __p, error_code& __ec) noexcept;
+
+ uintmax_t hard_link_count(const path& __p);
+ uintmax_t hard_link_count(const path& __p, error_code& __ec) noexcept;
+
+ inline bool
+ is_block_file(file_status __s) noexcept
+ { return __s.type() == file_type::block; }
+
+ inline bool
+ is_block_file(const path& __p)
+ { return is_block_file(status(__p)); }
+
+ inline bool
+ is_block_file(const path& __p, error_code& __ec) noexcept
+ { return is_block_file(status(__p, __ec)); }
+
+ inline bool
+ is_character_file(file_status __s) noexcept
+ { return __s.type() == file_type::character; }
+
+ inline bool
+ is_character_file(const path& __p)
+ { return is_character_file(status(__p)); }
+
+ inline bool
+ is_character_file(const path& __p, error_code& __ec) noexcept
+ { return is_character_file(status(__p, __ec)); }
+
+ inline bool
+ is_directory(file_status __s) noexcept
+ { return __s.type() == file_type::directory; }
+
+ inline bool
+ is_directory(const path& __p)
+ { return is_directory(status(__p)); }
+
+ inline bool
+ is_directory(const path& __p, error_code& __ec) noexcept
+ { return is_directory(status(__p, __ec)); }
+
+ bool is_empty(const path& __p);
+ bool is_empty(const path& __p, error_code& __ec) noexcept;
+
+ inline bool
+ is_fifo(file_status __s) noexcept
+ { return __s.type() == file_type::fifo; }
+
+ inline bool
+ is_fifo(const path& __p)
+ { return is_fifo(status(__p)); }
+
+ inline bool
+ is_fifo(const path& __p, error_code& __ec) noexcept
+ { return is_fifo(status(__p, __ec)); }
+
+ inline bool
+ is_other(file_status __s) noexcept
+ {
+ return exists(__s) && !is_regular_file(__s) && !is_directory(__s)
+ && !is_symlink(__s);
+ }
+
+ inline bool
+ is_other(const path& __p)
+ { return is_other(status(__p)); }
+
+ inline bool
+ is_other(const path& __p, error_code& __ec) noexcept
+ { return is_other(status(__p, __ec)); }
+
+ inline bool
+ is_regular_file(file_status __s) noexcept
+ { return __s.type() == file_type::regular; }
+
+ inline bool
+ is_regular_file(const path& __p)
+ { return is_regular_file(status(__p)); }
+
+ inline bool
+ is_regular_file(const path& __p, error_code& __ec) noexcept
+ { return is_regular_file(status(__p, __ec)); }
+
+ inline bool
+ is_socket(file_status __s) noexcept
+ { return __s.type() == file_type::socket; }
+
+ inline bool
+ is_socket(const path& __p)
+ { return is_socket(status(__p)); }
+
+ inline bool
+ is_socket(const path& __p, error_code& __ec) noexcept
+ { return is_socket(status(__p, __ec)); }
+
+ inline bool
+ is_symlink(file_status __s) noexcept
+ { return __s.type() == file_type::symlink; }
+
+ inline bool
+ is_symlink(const path& __p)
+ { return is_symlink(symlink_status(__p)); }
+
+ inline bool
+ is_symlink(const path& __p, error_code& __ec) noexcept
+ { return is_symlink(symlink_status(__p, __ec)); }
+
+ file_time_type last_write_time(const path& __p);
+ file_time_type last_write_time(const path& __p, error_code& __ec) noexcept;
+ void last_write_time(const path& __p, file_time_type __new_time);
+ void last_write_time(const path& __p, file_time_type __new_time,
+ error_code& __ec) noexcept;
+
+ void permissions(const path& __p, perms __prms);
+ void permissions(const path& __p, perms __prms, error_code& __ec) noexcept;
+
+ path read_symlink(const path& __p);
+ path read_symlink(const path& __p, error_code& __ec);
+
+ bool remove(const path& __p);
+ bool remove(const path& __p, error_code& __ec) noexcept;
+
+ uintmax_t remove_all(const path& __p);
+ uintmax_t remove_all(const path& __p, error_code& __ec) noexcept;
+
+ void rename(const path& __from, const path& __to);
+ void rename(const path& __from, const path& __to, error_code& __ec) noexcept;
+
+ void resize_file(const path& __p, uintmax_t __size);
+ void resize_file(const path& __p, uintmax_t __size, error_code& __ec) noexcept;
+
+ space_info space(const path& __p);
+ space_info space(const path& __p, error_code& __ec) noexcept;
+
+ file_status status(const path& __p);
+ file_status status(const path& __p, error_code& __ec) noexcept;
+
+ inline bool status_known(file_status __s) noexcept
+ { return __s.type() != file_type::none; }
+
+ file_status symlink_status(const path& __p);
+ file_status symlink_status(const path& __p, error_code& __ec) noexcept;
+
+ path system_complete(const path& __p);
+ path system_complete(const path& __p, error_code& __ec);
+
+ path temp_directory_path();
+ path temp_directory_path(error_code& __ec);
+
+ // @} group filesystem
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace v1
+} // namespace filesystem
+} // namespace experimental
+} // namespace std
+
+#endif // C++11
+
+#endif // _GLIBCXX_EXPERIMENTAL_FS_OPS_H
diff --git a/libstdc++-v3/include/experimental/bits/fs_path.h b/libstdc++-v3/include/experimental/bits/fs_path.h
new file mode 100644
index 0000000..40462a6
--- /dev/null
+++ b/libstdc++-v3/include/experimental/bits/fs_path.h
@@ -0,0 +1,1024 @@
+// Class filesystem::path -*- C++ -*-
+
+// Copyright (C) 2014-2015 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file experimental/fs_path.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{experimental/filesystem}
+ */
+
+#ifndef _GLIBCXX_EXPERIMENTAL_FS_PATH_H
+#define _GLIBCXX_EXPERIMENTAL_FS_PATH_H 1
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <utility>
+#include <type_traits>
+#include <vector>
+#include <locale>
+#include <iosfwd>
+#include <codecvt>
+#include <system_error>
+#include <bits/stl_algobase.h>
+#include <bits/quoted_string.h>
+#include <bits/locale_conv.h>
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+# define _GLIBCXX_FILESYSTEM_IS_WINDOWS 1
+# include <algorithm>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace experimental
+{
+namespace filesystem
+{
+inline namespace v1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+_GLIBCXX_BEGIN_NAMESPACE_CXX11
+
+ /**
+ * @ingroup filesystem
+ * @{
+ */
+
+ /// A filesystem path.
+ class path
+ {
+ template<typename _CharT>
+ struct __is_encoded_char : std::false_type { };
+
+ template<typename _Iter,
+ typename _Iter_traits = std::iterator_traits<_Iter>>
+ using __is_path_iter_src
+ = __and_<__is_encoded_char<typename _Iter_traits::value_type>,
+ std::is_base_of<std::input_iterator_tag,
+ typename _Iter_traits::iterator_category>>;
+
+ template<typename _Iter>
+ static __is_path_iter_src<_Iter>
+ __is_path_src(_Iter, int);
+
+ template<typename _CharT, typename _Traits, typename _Alloc>
+ static __is_encoded_char<_CharT>
+ __is_path_src(const basic_string<_CharT, _Traits, _Alloc>&, int);
+
+ template<typename _Unknown>
+ static std::false_type
+ __is_path_src(const _Unknown&, ...);
+
+ template<typename _Tp1, typename _Tp2>
+ struct __constructible_from;
+
+ template<typename _Iter>
+ struct __constructible_from<_Iter, _Iter>
+ : __is_path_iter_src<_Iter>
+ { };
+
+ template<typename _Source>
+ struct __constructible_from<_Source, void>
+ : decltype(__is_path_src(std::declval<_Source>(), 0))
+ { };
+
+ template<typename _Tp1, typename _Tp2 = void>
+ using _Path = typename
+ std::enable_if<__and_<__not_<is_same<_Tp1, path>>,
+ __constructible_from<_Tp1, _Tp2>>::value,
+ path>::type;
+
+ template<typename _Source>
+ static _Source
+ _S_range_begin(_Source __begin) { return __begin; }
+
+ struct __null_terminated { };
+
+ template<typename _Source>
+ static __null_terminated
+ _S_range_end(_Source) { return {}; }
+
+ template<typename _CharT, typename _Traits, typename _Alloc>
+ static const _CharT*
+ _S_range_begin(const basic_string<_CharT, _Traits, _Alloc>& __str)
+ { return __str.data(); }
+
+ template<typename _CharT, typename _Traits, typename _Alloc>
+ static const _CharT*
+ _S_range_end(const basic_string<_CharT, _Traits, _Alloc>& __str)
+ { return __str.data() + __str.size(); }
+
+ template<typename _Tp,
+ typename _Iter = decltype(_S_range_begin(std::declval<_Tp>())),
+ typename _Val = typename std::iterator_traits<_Iter>::value_type>
+ using __value_type_is_char
+ = typename std::enable_if<std::is_same<_Val, char>::value>::type;
+
+ public:
+#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
+ typedef wchar_t value_type;
+ static constexpr value_type preferred_separator = L'\\';
+#else
+ typedef char value_type;
+ static constexpr value_type preferred_separator = '/';
+#endif
+ typedef std::basic_string<value_type> string_type;
+
+ // constructors and destructor
+
+ path() noexcept { }
+
+ path(const path& __p) = default;
+
+ path(path&& __p) noexcept
+ : _M_pathname(std::move(__p._M_pathname)), _M_type(__p._M_type)
+ {
+ _M_split_cmpts();
+ __p.clear();
+ }
+
+ template<typename _Source,
+ typename _Require = _Path<_Source>>
+ path(_Source const& __source)
+ : _M_pathname(_S_convert(_S_range_begin(__source),
+ _S_range_end(__source)))
+ { _M_split_cmpts(); }
+
+ template<typename _InputIterator,
+ typename _Require = _Path<_InputIterator, _InputIterator>>
+ path(_InputIterator __first, _InputIterator __last)
+ : _M_pathname(_S_convert(__first, __last))
+ { _M_split_cmpts(); }
+
+ template<typename _Source,
+ typename _Require = _Path<_Source>,
+ typename _Require2 = __value_type_is_char<_Source>>
+ path(_Source const& __source, const locale& __loc)
+ : _M_pathname(_S_convert_loc(_S_range_begin(__source),
+ _S_range_end(__source), __loc))
+ { _M_split_cmpts(); }
+
+ template<typename _InputIterator,
+ typename _Require = _Path<_InputIterator, _InputIterator>,
+ typename _Require2 = __value_type_is_char<_InputIterator>>
+ path(_InputIterator __first, _InputIterator __last, const locale& __loc)
+ : _M_pathname(_S_convert_loc(__first, __last, __loc))
+ { _M_split_cmpts(); }
+
+ ~path() = default;
+
+ // assignments
+
+ path& operator=(const path& __p) = default;
+ path& operator=(path&& __p) noexcept;
+
+ template<typename _Source>
+ _Path<_Source>&
+ operator=(_Source const& __source)
+ { return *this = path(__source); }
+
+ template<typename _Source>
+ _Path<_Source>&
+ assign(_Source const& __source)
+ { return *this = path(__source); }
+
+ template<typename _InputIterator>
+ _Path<_InputIterator, _InputIterator>&
+ assign(_InputIterator __first, _InputIterator __last)
+ { return *this = path(__first, __last); }
+
+ // appends
+
+ path& operator/=(const path& __p) { return _M_append(__p._M_pathname); }
+
+ template <class _Source>
+ _Path<_Source>&
+ operator/=(_Source const& __source)
+ { return append(__source); }
+
+ template<typename _Source>
+ _Path<_Source>&
+ append(_Source const& __source)
+ {
+ return _M_append(_S_convert(_S_range_begin(__source),
+ _S_range_end(__source)));
+ }
+
+ template<typename _InputIterator>
+ _Path<_InputIterator, _InputIterator>&
+ append(_InputIterator __first, _InputIterator __last)
+ { return _M_append(_S_convert(__first, __last)); }
+
+ // concatenation
+
+ path& operator+=(const path& __x);
+ path& operator+=(const string_type& __x);
+ path& operator+=(const value_type* __x);
+ path& operator+=(value_type __x);
+
+ template<typename _Source>
+ _Path<_Source>&
+ operator+=(_Source const& __x) { return concat(__x); }
+
+ template<typename _CharT>
+ _Path<_CharT*, _CharT*>&
+ operator+=(_CharT __x);
+
+ template<typename _Source>
+ _Path<_Source>&
+ concat(_Source const& __x)
+ { return *this += _S_convert(_S_range_begin(__x), _S_range_end(__x)); }
+
+ template<typename _InputIterator>
+ _Path<_InputIterator, _InputIterator>&
+ concat(_InputIterator __first, _InputIterator __last)
+ { return *this += _S_convert(__first, __last); }
+
+ // modifiers
+
+ void clear() noexcept { _M_pathname.clear(); _M_split_cmpts(); }
+
+ path& make_preferred();
+ path& remove_filename();
+ path& replace_filename(const path& __replacement);
+ path& replace_extension(const path& __replacement = path());
+
+ void swap(path& __rhs) noexcept;
+
+ // native format observers
+
+ const string_type& native() const noexcept { return _M_pathname; }
+ const value_type* c_str() const noexcept { return _M_pathname.c_str(); }
+ operator string_type() const { return _M_pathname; }
+
+ template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
+ typename _Allocator = std::allocator<_CharT>>
+ std::basic_string<_CharT, _Traits, _Allocator>
+ string(const _Allocator& __a = _Allocator()) const;
+
+ std::string string() const;
+#if _GLIBCXX_USE_WCHAR_T
+ std::wstring wstring() const;
+#endif
+ std::string u8string() const;
+ std::u16string u16string() const;
+ std::u32string u32string() const;
+
+ // generic format observers
+ template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
+ typename _Allocator = std::allocator<_CharT>>
+ std::basic_string<_CharT, _Traits, _Allocator>
+ generic_string(const _Allocator& __a = _Allocator()) const;
+
+ std::string generic_string() const;
+#if _GLIBCXX_USE_WCHAR_T
+ std::wstring generic_wstring() const;
+#endif
+ std::string generic_u8string() const;
+ std::u16string generic_u16string() const;
+ std::u32string generic_u32string() const;
+
+ // compare
+
+ int compare(const path& __p) const noexcept;
+ int compare(const string_type& __s) const;
+ int compare(const value_type* __s) const;
+
+ // decomposition
+
+ path root_name() const;
+ path root_directory() const;
+ path root_path() const;
+ path relative_path() const;
+ path parent_path() const;
+ path filename() const;
+ path stem() const;
+ path extension() const;
+
+ // query
+
+ bool empty() const noexcept { return _M_pathname.empty(); }
+ bool has_root_name() const;
+ bool has_root_directory() const;
+ bool has_root_path() const;
+ bool has_relative_path() const;
+ bool has_parent_path() const;
+ bool has_filename() const;
+ bool has_stem() const;
+ bool has_extension() const;
+ bool is_absolute() const;
+ bool is_relative() const { return !is_absolute(); }
+
+ // iterators
+ class iterator;
+ typedef iterator const_iterator;
+
+ iterator begin() const;
+ iterator end() const;
+
+ private:
+ enum class _Type : unsigned char {
+ _Multi, _Root_name, _Root_dir, _Filename
+ };
+
+ path(string_type __str, _Type __type) : _M_pathname(__str), _M_type(__type)
+ {
+ __glibcxx_assert(!empty());
+ __glibcxx_assert(_M_type != _Type::_Multi);
+ }
+
+ enum class _Split { _Stem, _Extension };
+
+ path& _M_append(const string_type& __str)
+ {
+ if (!_M_pathname.empty() && !_S_is_dir_sep(_M_pathname.back())
+ && !__str.empty() && !_S_is_dir_sep(__str.front()))
+ _M_pathname += preferred_separator;
+ _M_pathname += __str;
+ _M_split_cmpts();
+ return *this;
+ }
+
+ pair<const string_type*, size_t> _M_find_extension() const;
+
+ template<typename _CharT>
+ struct _Cvt;
+
+ static string_type
+ _S_convert(value_type* __src, __null_terminated)
+ { return string_type(__src); }
+
+ static string_type
+ _S_convert(const value_type* __src, __null_terminated)
+ { return string_type(__src); }
+
+ template<typename _Iter>
+ static string_type
+ _S_convert(_Iter __first, _Iter __last)
+ {
+ using __value_type = typename std::iterator_traits<_Iter>::value_type;
+ return _Cvt<__value_type>::_S_convert(__first, __last);
+ }
+
+ template<typename _InputIterator>
+ static string_type
+ _S_convert(_InputIterator __src, __null_terminated)
+ {
+ using _Tp = typename std::iterator_traits<_InputIterator>::value_type;
+ std::basic_string<_Tp> __tmp;
+ while (*__src != _Tp{})
+ __tmp.push_back(*__src++);
+ return _S_convert(__tmp.data(), __tmp.data() + __tmp.size());
+ }
+
+ static string_type
+ _S_convert_loc(const char* __first, const char* __last,
+ const std::locale& __loc);
+
+ template<typename _Iter>
+ static string_type
+ _S_convert_loc(_Iter __first, _Iter __last, const std::locale& __loc)
+ {
+ const std::string __str(__first, __last);
+ return _S_convert_loc(__str.data(), __str.data()+__str.size(), __loc);
+ }
+
+ template<typename _InputIterator>
+ static string_type
+ _S_convert_loc(_InputIterator __src, __null_terminated,
+ const std::locale& __loc)
+ {
+ std::string __tmp;
+ while (*__src != '\0')
+ __tmp.push_back(*__src++);
+ return _S_convert_loc(__tmp.data(), __tmp.data()+__tmp.size(), __loc);
+ }
+
+ bool _S_is_dir_sep(value_type __ch)
+ {
+#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
+ return __ch == L'/' || __ch == preferred_separator;
+#else
+ return __ch == '/';
+#endif
+ }
+
+ void _M_split_cmpts();
+ void _M_trim();
+ void _M_add_root_name(size_t __n);
+ void _M_add_root_dir(size_t __pos);
+ void _M_add_filename(size_t __pos, size_t __n);
+
+ string_type _M_pathname;
+
+ struct _Cmpt;
+ using _List = _GLIBCXX_STD_C::vector<_Cmpt>;
+ _List _M_cmpts; // empty unless _M_type == _Type::_Multi
+ _Type _M_type = _Type::_Multi;
+ };
+
+ inline void swap(path& __lhs, path& __rhs) noexcept { __lhs.swap(__rhs); }
+
+ size_t hash_value(const path& __p) noexcept;
+
+ /// Compare paths
+ inline bool operator<(const path& __lhs, const path& __rhs) noexcept
+ { return __lhs.compare(__rhs) < 0; }
+
+ /// Compare paths
+ inline bool operator<=(const path& __lhs, const path& __rhs) noexcept
+ { return !(__rhs < __lhs); }
+
+ /// Compare paths
+ inline bool operator>(const path& __lhs, const path& __rhs) noexcept
+ { return __rhs < __lhs; }
+
+ /// Compare paths
+ inline bool operator>=(const path& __lhs, const path& __rhs) noexcept
+ { return !(__lhs < __rhs); }
+
+ /// Compare paths
+ inline bool operator==(const path& __lhs, const path& __rhs) noexcept
+ { return __lhs.compare(__rhs) == 0; }
+
+ /// Compare paths
+ inline bool operator!=(const path& __lhs, const path& __rhs) noexcept
+ { return !(__lhs == __rhs); }
+
+ /// Append one path to another
+ inline path operator/(const path& __lhs, const path& __rhs)
+ { return path(__lhs) /= __rhs; }
+
+ /// Write a path to a stream
+ template<typename _CharT, typename _Traits>
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p)
+ {
+ auto __tmp = __p.string<_CharT, _Traits>();
+ using __quoted_string
+ = std::__detail::_Quoted_string<decltype(__tmp)&, _CharT>;
+ __os << __quoted_string{__tmp, '"', '\\'};
+ return __os;
+ }
+
+ /// Read a path from a stream
+ template<typename _CharT, typename _Traits>
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is, path& __p)
+ {
+ basic_string<_CharT, _Traits> __tmp;
+ using __quoted_string
+ = std::__detail::_Quoted_string<decltype(__tmp)&, _CharT>;
+ if (__is >> __quoted_string{ __tmp, '"', '\\' })
+ __p = std::move(__tmp);
+ return __is;
+ }
+
+ // TODO constrain with _Path<Source> and __value_type_is_char
+ template<typename _Source>
+ inline path
+ u8path(const _Source& __source)
+ {
+#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
+ return path{ path::string_type{__source} };
+#else
+ return path{ __source };
+#endif
+ }
+
+ // TODO constrain with _Path<InputIterator, InputIterator> and __value_type_is_char
+ template<typename _InputIterator>
+ inline path
+ u8path(_InputIterator __first, _InputIterator __last)
+ {
+#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
+ return path{ path::string_type{__first, __last} };
+#else
+ return path{ __first, __last };
+#endif
+ }
+
+ class filesystem_error : public std::system_error
+ {
+ public:
+ filesystem_error(const string& __what_arg, error_code __ec)
+ : system_error(__ec, __what_arg) { }
+
+ filesystem_error(const string& __what_arg, const path& __p1,
+ error_code __ec)
+ : system_error(__ec, __what_arg), _M_path1(__p1) { }
+
+ filesystem_error(const string& __what_arg, const path& __p1,
+ const path& __p2, error_code __ec)
+ : system_error(__ec, __what_arg), _M_path1(__p1), _M_path2(__p2)
+ { }
+
+ ~filesystem_error();
+
+ const path& path1() const noexcept { return _M_path1; }
+ const path& path2() const noexcept { return _M_path2; }
+ const char* what() const noexcept { return _M_what.c_str(); }
+
+ private:
+ std::string _M_gen_what();
+
+ path _M_path1;
+ path _M_path2;
+ std::string _M_what = _M_gen_what();
+ };
+
+ struct path::_Cmpt : path
+ {
+ _Cmpt(string_type __s, _Type __t, size_t __pos)
+ : path(std::move(__s), __t), _M_pos(__pos) { }
+
+ _Cmpt() : _M_pos(-1) { }
+
+ size_t _M_pos;
+ };
+
+ template<>
+ struct path::__is_encoded_char<char> : std::true_type
+ { using value_type = char; };
+
+ template<>
+ struct path::__is_encoded_char<wchar_t> : std::true_type
+ { using value_type = wchar_t; };
+
+ template<>
+ struct path::__is_encoded_char<char16_t> : std::true_type
+ { using value_type = char16_t; };
+
+ template<>
+ struct path::__is_encoded_char<char32_t> : std::true_type
+ { using value_type = char32_t; };
+
+ // specialize _Cvt for degenerate 'noconv' case
+ template<>
+ struct path::_Cvt<path::value_type>
+ {
+ template<typename _Iter>
+ static string_type
+ _S_convert(_Iter __first, _Iter __last)
+ { return string_type{__first, __last}; }
+ };
+
+ template<typename _CharT>
+ struct path::_Cvt
+ {
+#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
+ static string_type
+ _S_wconvert(const char* __f, const char* __l, true_type)
+ {
+ using _Cvt = std::codecvt<wchar_t, char, mbstate_t>;
+ const auto& __cvt = std::use_facet<_Cvt>(std::locale{});
+ std::wstring __wstr;
+ if (__str_codecvt_in(__f, __l, __wstr, __cvt))
+ return __wstr;
+ _GLIBCXX_THROW_OR_ABORT(filesystem_error(
+ "Cannot convert character sequence",
+ std::make_error_code(errc::illegal_byte_sequence)));
+ }
+
+ static string_type
+ _S_wconvert(const _CharT* __f, const _CharT* __l, false_type)
+ {
+ std::codecvt_utf8<_CharT> __cvt;
+ std::string __str;
+ if (__str_codecvt_out(__f, __l, __str, __cvt))
+ {
+ const char* __f2 = __str.data();
+ const char* __l2 = __f2 + __str.size();
+ std::codecvt_utf8<wchar_t> __wcvt;
+ std::wstring __wstr;
+ if (__str_codecvt_in(__f2, __l2, __wstr, __wcvt))
+ return __wstr;
+ }
+ _GLIBCXX_THROW_OR_ABORT(filesystem_error(
+ "Cannot convert character sequence",
+ std::make_error_code(errc::illegal_byte_sequence)));
+ }
+
+ static string_type
+ _S_convert(const _CharT* __f, const _CharT* __l)
+ {
+ return _S_wconvert(__f, __l, is_same<_CharT, char>{});
+ }
+#else
+ static string_type
+ _S_convert(const _CharT* __f, const _CharT* __l)
+ {
+ std::codecvt_utf8<_CharT> __cvt;
+ std::string __str;
+ if (__str_codecvt_out(__f, __l, __str, __cvt))
+ return __str;
+ _GLIBCXX_THROW_OR_ABORT(filesystem_error(
+ "Cannot convert character sequence",
+ std::make_error_code(errc::illegal_byte_sequence)));
+ }
+#endif
+
+ static string_type
+ _S_convert(_CharT* __f, _CharT* __l)
+ {
+ return _S_convert(const_cast<const _CharT*>(__f),
+ const_cast<const _CharT*>(__l));
+ }
+
+ template<typename _Iter>
+ static string_type
+ _S_convert(_Iter __first, _Iter __last)
+ {
+ const std::basic_string<_CharT> __str(__first, __last);
+ return _S_convert(__str.data(), __str.data() + __str.size());
+ }
+
+ template<typename _Iter, typename _Cont>
+ static string_type
+ _S_convert(__gnu_cxx::__normal_iterator<_Iter, _Cont> __first,
+ __gnu_cxx::__normal_iterator<_Iter, _Cont> __last)
+ { return _S_convert(__first.base(), __last.base()); }
+ };
+
+ /// An iterator for the components of a path
+ class path::iterator
+ {
+ public:
+ using difference_type = std::ptrdiff_t;
+ using value_type = path;
+ using reference = const path&;
+ using pointer = const path*;
+ using iterator_category = std::bidirectional_iterator_tag;
+
+ iterator() : _M_path(nullptr), _M_cur(), _M_at_end() { }
+
+ iterator(const iterator&) = default;
+ iterator& operator=(const iterator&) = default;
+
+ reference operator*() const;
+ pointer operator->() const { return std::__addressof(**this); }
+
+ iterator& operator++();
+ iterator operator++(int) { auto __tmp = *this; ++_M_cur; return __tmp; }
+
+ iterator& operator--();
+ iterator operator--(int) { auto __tmp = *this; --_M_cur; return __tmp; }
+
+ friend bool operator==(const iterator& __lhs, const iterator& __rhs)
+ { return __lhs._M_equals(__rhs); }
+
+ friend bool operator!=(const iterator& __lhs, const iterator& __rhs)
+ { return !__lhs._M_equals(__rhs); }
+
+ private:
+ friend class path;
+
+ iterator(const path* __path, path::_List::const_iterator __iter)
+ : _M_path(__path), _M_cur(__iter), _M_at_end()
+ { }
+
+ iterator(const path* __path, bool __at_end)
+ : _M_path(__path), _M_cur(), _M_at_end(__at_end)
+ { }
+
+ bool _M_equals(iterator) const;
+
+ const path* _M_path;
+ path::_List::const_iterator _M_cur;
+ bool _M_at_end; // only used when type != _Multi
+ };
+
+
+ inline path&
+ path::operator=(path&& __p) noexcept
+ {
+ _M_pathname = std::move(__p._M_pathname);
+ _M_cmpts = std::move(__p._M_cmpts);
+ _M_type = __p._M_type;
+ __p.clear();
+ return *this;
+ }
+
+ inline path&
+ path::operator+=(const path& __p)
+ {
+ return operator+=(__p.native());
+ }
+
+ inline path&
+ path::operator+=(const string_type& __x)
+ {
+ _M_pathname += __x;
+ _M_split_cmpts();
+ return *this;
+ }
+
+ inline path&
+ path::operator+=(const value_type* __x)
+ {
+ _M_pathname += __x;
+ _M_split_cmpts();
+ return *this;
+ }
+
+ inline path&
+ path::operator+=(value_type __x)
+ {
+ _M_pathname += __x;
+ _M_split_cmpts();
+ return *this;
+ }
+
+ template<typename _CharT>
+ inline path::_Path<_CharT*, _CharT*>&
+ path::operator+=(_CharT __x)
+ {
+ auto* __addr = std::__addressof(__x);
+ return concat(__addr, __addr + 1);
+ }
+
+ inline path&
+ path::make_preferred()
+ {
+#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
+ std::replace(_M_pathname.begin(), _M_pathname.end(), L'/',
+ preferred_separator);
+#endif
+ return *this;
+ }
+
+ inline void path::swap(path& __rhs) noexcept
+ {
+ _M_pathname.swap(__rhs._M_pathname);
+ _M_cmpts.swap(__rhs._M_cmpts);
+ std::swap(_M_type, __rhs._M_type);
+ }
+
+ template<typename _CharT, typename _Traits, typename _Allocator>
+ inline std::basic_string<_CharT, _Traits, _Allocator>
+ path::string(const _Allocator& __a) const
+ {
+ if (is_same<_CharT, value_type>::value)
+ return { _M_pathname.begin(), _M_pathname.end(), __a };
+
+ const value_type* __first = _M_pathname.data();
+ const value_type* __last = __first + _M_pathname.size();
+
+#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
+ using _CharAlloc = __alloc_rebind<_Allocator, char>;
+ using _String = basic_string<char, char_traits<char>, _CharAlloc>;
+ using _WString = basic_string<_CharT, _Traits, _Allocator>;
+
+ // use codecvt_utf8<wchar_t> to convert native string to UTF-8
+ codecvt_utf8<value_type> __cvt;
+ _String __u8str{_CharAlloc{__a}};
+ if (__str_codecvt_out(__first, __last, __u8str, __cvt))
+ {
+ struct
+ {
+ const _String*
+ operator()(const _String& __from, _String&, true_type)
+ { return std::__addressof(__from); }
+
+ _WString*
+ operator()(const _String& __from, _WString& __to, false_type)
+ {
+ // use codecvt_utf8<_CharT> to convert UTF-8 to wide string
+ codecvt_utf8<_CharT> __cvt;
+ const char* __f = __from.data();
+ const char* __l = __f + __from.size();
+ if (__str_codecvt_in(__f, __l, __to, __cvt))
+ return std::__addressof(__to);
+ return nullptr;
+ }
+ } __dispatch;
+ _WString __wstr;
+ if (auto* __p = __dispatch(__u8str, __wstr, is_same<_CharT, char>{}))
+ return *__p;
+ }
+#else
+ codecvt_utf8<_CharT> __cvt;
+ basic_string<_CharT, _Traits, _Allocator> __wstr{__a};
+ if (__str_codecvt_in(__first, __last, __wstr, __cvt))
+ return __wstr;
+#endif
+ _GLIBCXX_THROW_OR_ABORT(filesystem_error(
+ "Cannot convert character sequence",
+ std::make_error_code(errc::illegal_byte_sequence)));
+ }
+
+ inline std::string
+ path::string() const { return string<char>(); }
+
+#if _GLIBCXX_USE_WCHAR_T
+ inline std::wstring
+ path::wstring() const { return string<wchar_t>(); }
+#endif
+
+ inline std::string
+ path::u8string() const
+ {
+#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
+ std::string __str;
+ // convert from native encoding to UTF-8
+ codecvt_utf8<value_type> __cvt;
+ const value_type* __first = _M_pathname.data();
+ const value_type* __last = __first + _M_pathname.size();
+ if (__str_codecvt_out(__first, __last, __str, __cvt))
+ return __str;
+ _GLIBCXX_THROW_OR_ABORT(filesystem_error(
+ "Cannot convert character sequence",
+ std::make_error_code(errc::illegal_byte_sequence)));
+#else
+ return _M_pathname;
+#endif
+ }
+
+ inline std::u16string
+ path::u16string() const { return string<char16_t>(); }
+
+ inline std::u32string
+ path::u32string() const { return string<char32_t>(); }
+
+#ifndef _GLIBCXX_FILESYSTEM_IS_WINDOWS
+ template<typename _CharT, typename _Traits, typename _Allocator>
+ inline std::basic_string<_CharT, _Traits, _Allocator>
+ path::generic_string(const _Allocator& __a) const
+ { return string<_CharT, _Traits, _Allocator>(__a); }
+
+ inline std::string
+ path::generic_string() const { return string(); }
+
+#if _GLIBCXX_USE_WCHAR_T
+ inline std::wstring
+ path::generic_wstring() const { return wstring(); }
+#endif
+
+ inline std::string
+ path::generic_u8string() const { return u8string(); }
+
+ inline std::u16string
+ path::generic_u16string() const { return u16string(); }
+
+ inline std::u32string
+ path::generic_u32string() const { return u32string(); }
+#endif
+
+ inline int
+ path::compare(const string_type& __s) const { return compare(path(__s)); }
+
+ inline int
+ path::compare(const value_type* __s) const { return compare(path(__s)); }
+
+ inline path
+ path::filename() const { return empty() ? path() : *--end(); }
+
+ inline path
+ path::stem() const
+ {
+ auto ext = _M_find_extension();
+ if (ext.first && ext.second != 0)
+ return path{ext.first->substr(0, ext.second)};
+ return {};
+ }
+
+ inline path
+ path::extension() const
+ {
+ auto ext = _M_find_extension();
+ if (ext.first && ext.second != string_type::npos)
+ return path{ext.first->substr(ext.second)};
+ return {};
+ }
+
+ inline bool
+ path::has_stem() const
+ {
+ auto ext = _M_find_extension();
+ return ext.first && ext.second != 0;
+ }
+
+ inline bool
+ path::has_extension() const
+ {
+ auto ext = _M_find_extension();
+ return ext.first && ext.second != string_type::npos;
+ }
+
+ inline bool
+ path::is_absolute() const
+ {
+#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
+ return has_root_name();
+#else
+ return has_root_directory();
+#endif
+ }
+
+ inline path::iterator
+ path::begin() const
+ {
+ if (_M_type == _Type::_Multi)
+ return iterator(this, _M_cmpts.begin());
+ return iterator(this, false);
+ }
+
+ inline path::iterator
+ path::end() const
+ {
+ if (_M_type == _Type::_Multi)
+ return iterator(this, _M_cmpts.end());
+ return iterator(this, true);
+ }
+
+ inline path::iterator&
+ path::iterator::operator++()
+ {
+ __glibcxx_assert(_M_path != nullptr);
+ if (_M_path->_M_type == _Type::_Multi)
+ {
+ __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
+ ++_M_cur;
+ }
+ else
+ {
+ __glibcxx_assert(!_M_at_end);
+ _M_at_end = true;
+ }
+ return *this;
+ }
+
+ inline path::iterator&
+ path::iterator::operator--()
+ {
+ __glibcxx_assert(_M_path != nullptr);
+ if (_M_path->_M_type == _Type::_Multi)
+ {
+ __glibcxx_assert(_M_cur != _M_path->_M_cmpts.begin());
+ --_M_cur;
+ }
+ else
+ {
+ __glibcxx_assert(_M_at_end);
+ _M_at_end = false;
+ }
+ return *this;
+ }
+
+ inline path::iterator::reference
+ path::iterator::operator*() const
+ {
+ __glibcxx_assert(_M_path != nullptr);
+ if (_M_path->_M_type == _Type::_Multi)
+ {
+ __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
+ return *_M_cur;
+ }
+ return *_M_path;
+ }
+
+ inline bool
+ path::iterator::_M_equals(iterator __rhs) const
+ {
+ if (_M_path != __rhs._M_path)
+ return false;
+ if (_M_path == nullptr)
+ return true;
+ if (_M_path->_M_type == path::_Type::_Multi)
+ return _M_cur == __rhs._M_cur;
+ return _M_at_end == __rhs._M_at_end;
+ }
+
+ // @} group filesystem
+_GLIBCXX_END_NAMESPACE_CXX11
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace v1
+} // namespace filesystem
+} // namespace experimental
+} // namespace std
+
+#endif // C++11
+
+#endif // _GLIBCXX_EXPERIMENTAL_FS_PATH_H
diff --git a/libstdc++-v3/include/experimental/bits/string_view.tcc b/libstdc++-v3/include/experimental/bits/string_view.tcc
new file mode 100644
index 0000000..75a34f9
--- /dev/null
+++ b/libstdc++-v3/include/experimental/bits/string_view.tcc
@@ -0,0 +1,230 @@
+// Components for manipulating non-owning sequences of characters -*- C++ -*-
+
+// Copyright (C) 2013-2015 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file experimental/string_view.tcc
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{string_view}
+ */
+
+//
+// N3762 basic_string_view library
+//
+
+#ifndef _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC
+#define _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC 1
+
+#pragma GCC system_header
+
+#if __cplusplus <= 201103L
+# include <bits/c++14_warning.h>
+#else
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace experimental
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ template<typename _CharT, typename _Traits>
+ typename basic_string_view<_CharT, _Traits>::size_type
+ basic_string_view<_CharT, _Traits>::
+ find(const _CharT* __str, size_type __pos, size_type __n) const noexcept
+ {
+ __glibcxx_requires_string_len(__str, __n);
+
+ if (__n == 0)
+ return __pos <= this->_M_len ? __pos : npos;
+
+ if (__n <= this->_M_len)
+ {
+ for (; __pos <= this->_M_len - __n; ++__pos)
+ if (traits_type::eq(this->_M_str[__pos], __str[0])
+ && traits_type::compare(this->_M_str + __pos + 1,
+ __str + 1, __n - 1) == 0)
+ return __pos;
+ }
+ return npos;
+ }
+
+ template<typename _CharT, typename _Traits>
+ typename basic_string_view<_CharT, _Traits>::size_type
+ basic_string_view<_CharT, _Traits>::
+ find(_CharT __c, size_type __pos) const noexcept
+ {
+ size_type __ret = npos;
+ if (__pos < this->_M_len)
+ {
+ const size_type __n = this->_M_len - __pos;
+ const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c);
+ if (__p)
+ __ret = __p - this->_M_str;
+ }
+ return __ret;
+ }
+
+ template<typename _CharT, typename _Traits>
+ typename basic_string_view<_CharT, _Traits>::size_type
+ basic_string_view<_CharT, _Traits>::
+ rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept
+ {
+ __glibcxx_requires_string_len(__str, __n);
+
+ if (__n <= this->_M_len)
+ {
+ __pos = std::min(size_type(this->_M_len - __n), __pos);
+ do
+ {
+ if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0)
+ return __pos;
+ }
+ while (__pos-- > 0);
+ }
+ return npos;
+ }
+
+ template<typename _CharT, typename _Traits>
+ typename basic_string_view<_CharT, _Traits>::size_type
+ basic_string_view<_CharT, _Traits>::
+ rfind(_CharT __c, size_type __pos) const noexcept
+ {
+ size_type __size = this->_M_len;
+ if (__size > 0)
+ {
+ if (--__size > __pos)
+ __size = __pos;
+ for (++__size; __size-- > 0; )
+ if (traits_type::eq(this->_M_str[__size], __c))
+ return __size;
+ }
+ return npos;
+ }
+
+ template<typename _CharT, typename _Traits>
+ typename basic_string_view<_CharT, _Traits>::size_type
+ basic_string_view<_CharT, _Traits>::
+ find_first_of(const _CharT* __str, size_type __pos, size_type __n) const
+ {
+ __glibcxx_requires_string_len(__str, __n);
+ for (; __n && __pos < this->_M_len; ++__pos)
+ {
+ const _CharT* __p = traits_type::find(__str, __n,
+ this->_M_str[__pos]);
+ if (__p)
+ return __pos;
+ }
+ return npos;
+ }
+
+ template<typename _CharT, typename _Traits>
+ typename basic_string_view<_CharT, _Traits>::size_type
+ basic_string_view<_CharT, _Traits>::
+ find_last_of(const _CharT* __str, size_type __pos, size_type __n) const
+ {
+ __glibcxx_requires_string_len(__str, __n);
+ size_type __size = this->size();
+ if (__size && __n)
+ {
+ if (--__size > __pos)
+ __size = __pos;
+ do
+ {
+ if (traits_type::find(__str, __n, this->_M_str[__size]))
+ return __size;
+ }
+ while (__size-- != 0);
+ }
+ return npos;
+ }
+
+ template<typename _CharT, typename _Traits>
+ typename basic_string_view<_CharT, _Traits>::size_type
+ basic_string_view<_CharT, _Traits>::
+ find_first_not_of(const _CharT* __str, size_type __pos, size_type __n) const
+ {
+ __glibcxx_requires_string_len(__str, __n);
+ for (; __pos < this->_M_len; ++__pos)
+ if (!traits_type::find(__str, __n, this->_M_str[__pos]))
+ return __pos;
+ return npos;
+ }
+
+ template<typename _CharT, typename _Traits>
+ typename basic_string_view<_CharT, _Traits>::size_type
+ basic_string_view<_CharT, _Traits>::
+ find_first_not_of(_CharT __c, size_type __pos) const noexcept
+ {
+ for (; __pos < this->_M_len; ++__pos)
+ if (!traits_type::eq(this->_M_str[__pos], __c))
+ return __pos;
+ return npos;
+ }
+
+ template<typename _CharT, typename _Traits>
+ typename basic_string_view<_CharT, _Traits>::size_type
+ basic_string_view<_CharT, _Traits>::
+ find_last_not_of(const _CharT* __str, size_type __pos, size_type __n) const
+ {
+ __glibcxx_requires_string_len(__str, __n);
+ size_type __size = this->_M_len;
+ if (__size)
+ {
+ if (--__size > __pos)
+ __size = __pos;
+ do
+ {
+ if (!traits_type::find(__str, __n, this->_M_str[__size]))
+ return __size;
+ }
+ while (__size--);
+ }
+ return npos;
+ }
+
+ template<typename _CharT, typename _Traits>
+ typename basic_string_view<_CharT, _Traits>::size_type
+ basic_string_view<_CharT, _Traits>::
+ find_last_not_of(_CharT __c, size_type __pos) const noexcept
+ {
+ size_type __size = this->_M_len;
+ if (__size)
+ {
+ if (--__size > __pos)
+ __size = __pos;
+ do
+ {
+ if (!traits_type::eq(this->_M_str[__size], __c))
+ return __size;
+ }
+ while (__size--);
+ }
+ return npos;
+ }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace experimental
+} // namespace std
+
+#endif // __cplusplus <= 201103L
+
+#endif // _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC
diff --git a/libstdc++-v3/include/experimental/erase_if.h b/libstdc++-v3/include/experimental/erase_if.h
deleted file mode 100644
index 35b5b37..0000000
--- a/libstdc++-v3/include/experimental/erase_if.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// <experimental/erase_if.h> -*- C++ -*-
-
-// Copyright (C) 2015 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file experimental/erase_if.h
- * This is an internal header file, included by other library headers.
- * Do not attempt to use it directly.
- */
-
-#ifndef _GLIBCXX_EXPERIMENTAL_ERASE_IF_H
-#define _GLIBCXX_EXPERIMENTAL_ERASE_IF_H 1
-
-#pragma GCC system_header
-
-#if __cplusplus <= 201103L
-# include <bits/c++14_warning.h>
-#else
-
-namespace std
-{
-namespace experimental
-{
-inline namespace fundamentals_v2
-{
-
- namespace __detail
- {
- template<typename _Container, typename _Predicate>
- void
- __erase_nodes_if(_Container& __cont, _Predicate __pred)
- {
- for (auto __iter = __cont.begin(), __last = __cont.end();
- __iter != __last;)
- {
- if (__pred(*__iter))
- __iter = __cont.erase(__iter);
- else
- ++__iter;
- }
- }
- }
-
-
-} // inline namespace fundamentals_v2
-} // namespace experimental
-} // namespace std
-
-#endif // C++14
-
-#endif // _GLIBCXX_EXPERIMENTAL_ERASE_IF_H
diff --git a/libstdc++-v3/include/experimental/filesystem b/libstdc++-v3/include/experimental/filesystem
index db7ab11..6713463 100644
--- a/libstdc++-v3/include/experimental/filesystem
+++ b/libstdc++-v3/include/experimental/filesystem
@@ -35,10 +35,10 @@
# include <bits/c++0x_warning.h>
#else
-#include <experimental/fs_fwd.h>
-#include <experimental/fs_path.h>
-#include <experimental/fs_dir.h>
-#include <experimental/fs_ops.h>
+#include <experimental/bits/fs_fwd.h>
+#include <experimental/bits/fs_path.h>
+#include <experimental/bits/fs_dir.h>
+#include <experimental/bits/fs_ops.h>
#define __cpp_lib_experimental_filesystem 201406
diff --git a/libstdc++-v3/include/experimental/fs_dir.h b/libstdc++-v3/include/experimental/fs_dir.h
deleted file mode 100644
index 0c5253f..0000000
--- a/libstdc++-v3/include/experimental/fs_dir.h
+++ /dev/null
@@ -1,338 +0,0 @@
-// Filesystem directory utilities -*- C++ -*-
-
-// Copyright (C) 2014-2015 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file experimental/fs_dir.h
- * This is an internal header file, included by other library headers.
- * Do not attempt to use it directly. @headername{experimental/filesystem}
- */
-
-#ifndef _GLIBCXX_EXPERIMENTAL_FS_DIR_H
-#define _GLIBCXX_EXPERIMENTAL_FS_DIR_H 1
-
-#if __cplusplus < 201103L
-# include <bits/c++0x_warning.h>
-#else
-# include <typeinfo>
-# include <ext/concurrence.h>
-# include <bits/unique_ptr.h>
-# include <bits/shared_ptr.h>
-
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-namespace experimental
-{
-namespace filesystem
-{
-inline namespace v1
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
- /**
- * @ingroup filesystem
- * @{
- */
-
- class file_status
- {
- public:
- // constructors
- explicit
- file_status(file_type __ft = file_type::none,
- perms __prms = perms::unknown) noexcept
- : _M_type(__ft), _M_perms(__prms) { }
-
- file_status(const file_status&) noexcept = default;
- file_status(file_status&&) noexcept = default;
- ~file_status() = default;
-
- file_status& operator=(const file_status&) noexcept = default;
- file_status& operator=(file_status&&) noexcept = default;
-
- // observers
- file_type type() const noexcept { return _M_type; }
- perms permissions() const noexcept { return _M_perms; }
-
- // modifiers
- void type(file_type __ft) noexcept { _M_type = __ft; }
- void permissions(perms __prms) noexcept { _M_perms = __prms; }
-
- private:
- file_type _M_type;
- perms _M_perms;
- };
-
-_GLIBCXX_BEGIN_NAMESPACE_CXX11
-
- class directory_entry
- {
- public:
- // constructors and destructor
- directory_entry() noexcept = default;
- directory_entry(const directory_entry&) = default;
- directory_entry(directory_entry&&) noexcept = default;
- explicit directory_entry(const filesystem::path& __p) : _M_path(__p) { }
- ~directory_entry() = default;
-
- // modifiers
- directory_entry& operator=(const directory_entry&) = default;
- directory_entry& operator=(directory_entry&&) noexcept = default;
-
- void assign(const filesystem::path& __p) { _M_path = __p; }
-
- void
- replace_filename(const filesystem::path& __p)
- { _M_path = _M_path.parent_path() / __p; }
-
- // observers
- const filesystem::path& path() const noexcept { return _M_path; }
- operator const filesystem::path&() const noexcept { return _M_path; }
-
- file_status
- status() const
- { return filesystem::status(_M_path); }
-
- file_status
- status(error_code& __ec) const noexcept
- { return filesystem::status(_M_path, __ec); }
-
- file_status
- symlink_status() const
- { return filesystem::symlink_status(_M_path); }
-
- file_status
- symlink_status(error_code& __ec) const noexcept
- { return filesystem::symlink_status(_M_path, __ec); }
-
- bool
- operator< (const directory_entry& __rhs) const noexcept
- { return _M_path < __rhs._M_path; }
-
- bool
- operator==(const directory_entry& __rhs) const noexcept
- { return _M_path == __rhs._M_path; }
-
- bool
- operator!=(const directory_entry& __rhs) const noexcept
- { return _M_path != __rhs._M_path; }
-
- bool
- operator<=(const directory_entry& __rhs) const noexcept
- { return _M_path <= __rhs._M_path; }
-
- bool
- operator> (const directory_entry& __rhs) const noexcept
- { return _M_path > __rhs._M_path; }
-
- bool
- operator>=(const directory_entry& __rhs) const noexcept
- { return _M_path >= __rhs._M_path; }
-
- private:
- filesystem::path _M_path;
- };
-
- struct _Dir;
- class recursive_directory_iterator;
-
- class directory_iterator
- {
- public:
- typedef directory_entry value_type;
- typedef ptrdiff_t difference_type;
- typedef const directory_entry* pointer;
- typedef const directory_entry& reference;
- typedef input_iterator_tag iterator_category;
-
- directory_iterator() noexcept = default;
-
- explicit
- directory_iterator(const path& __p)
- : directory_iterator(__p, directory_options::none, nullptr) { }
-
- directory_iterator(const path& __p, directory_options __options)
- : directory_iterator(__p, __options, nullptr) { }
-
- directory_iterator(const path& __p, error_code& __ec) noexcept
- : directory_iterator(__p, directory_options::none, __ec) { }
-
- directory_iterator(const path& __p,
- directory_options __options, error_code& __ec) noexcept
- : directory_iterator(__p, __options, &__ec) { }
-
- directory_iterator(const directory_iterator& __rhs) = default;
-
- directory_iterator(directory_iterator&& __rhs) noexcept = default;
-
- ~directory_iterator() = default;
-
- directory_iterator& operator=(const directory_iterator& __rhs) = default;
- directory_iterator& operator=(directory_iterator&& __rhs) noexcept = default;
-
- const directory_entry& operator*() const;
- const directory_entry* operator->() const { return &**this; }
- directory_iterator& operator++();
- directory_iterator& increment(error_code& __ec) noexcept;
-
- directory_iterator operator++(int)
- {
- auto __tmp = *this;
- ++*this;
- return __tmp;
- }
-
- private:
- directory_iterator(const path&, directory_options, error_code*);
-
- friend bool
- operator==(const directory_iterator& __lhs,
- const directory_iterator& __rhs);
-
- friend class recursive_directory_iterator;
-
- std::shared_ptr<_Dir> _M_dir;
- };
-
- inline directory_iterator
- begin(directory_iterator __iter) { return __iter; }
-
- inline directory_iterator
- end(directory_iterator) { return directory_iterator(); }
-
- inline bool
- operator==(const directory_iterator& __lhs, const directory_iterator& __rhs)
- {
- return !__rhs._M_dir.owner_before(__lhs._M_dir)
- && !__lhs._M_dir.owner_before(__rhs._M_dir);
- }
-
- inline bool
- operator!=(const directory_iterator& __lhs, const directory_iterator& __rhs)
- { return !(__lhs == __rhs); }
-
- class recursive_directory_iterator
- {
- public:
- typedef directory_entry value_type;
- typedef ptrdiff_t difference_type;
- typedef const directory_entry* pointer;
- typedef const directory_entry& reference;
- typedef input_iterator_tag iterator_category;
-
- recursive_directory_iterator() noexcept = default;
-
- explicit
- recursive_directory_iterator(const path& __p)
- : recursive_directory_iterator(__p, directory_options::none, nullptr) { }
-
- recursive_directory_iterator(const path& __p, directory_options __options)
- : recursive_directory_iterator(__p, __options, nullptr) { }
-
- recursive_directory_iterator(const path& __p,
- directory_options __options,
- error_code& __ec) noexcept
- : recursive_directory_iterator(__p, __options, &__ec) { }
-
- recursive_directory_iterator(const path& __p, error_code& __ec) noexcept
- : recursive_directory_iterator(__p, directory_options::none, &__ec) { }
-
- recursive_directory_iterator(
- const recursive_directory_iterator&) = default;
-
- recursive_directory_iterator(
- recursive_directory_iterator&&) noexcept = default;
-
- ~recursive_directory_iterator();
-
- // observers
- directory_options options() const { return _M_options; }
- int depth() const;
- bool recursion_pending() const { return _M_pending; }
-
- const directory_entry& operator*() const;
- const directory_entry* operator->() const { return &**this; }
-
- // modifiers
- recursive_directory_iterator&
- operator=(const recursive_directory_iterator& __rhs) noexcept;
- recursive_directory_iterator&
- operator=(recursive_directory_iterator&& __rhs) noexcept;
-
- recursive_directory_iterator& operator++();
- recursive_directory_iterator& increment(error_code& __ec) noexcept;
-
- recursive_directory_iterator operator++(int)
- {
- auto __tmp = *this;
- ++*this;
- return __tmp;
- }
-
- void pop();
-
- void disable_recursion_pending() { _M_pending = false; }
-
- private:
- recursive_directory_iterator(const path&, directory_options, error_code*);
-
- friend bool
- operator==(const recursive_directory_iterator& __lhs,
- const recursive_directory_iterator& __rhs);
-
- struct _Dir_stack;
- std::shared_ptr<_Dir_stack> _M_dirs;
- directory_options _M_options;
- bool _M_pending;
- };
-
- inline recursive_directory_iterator
- begin(recursive_directory_iterator __iter) { return __iter; }
-
- inline recursive_directory_iterator
- end(recursive_directory_iterator) { return recursive_directory_iterator(); }
-
- inline bool
- operator==(const recursive_directory_iterator& __lhs,
- const recursive_directory_iterator& __rhs)
- {
- return !__rhs._M_dirs.owner_before(__lhs._M_dirs)
- && !__lhs._M_dirs.owner_before(__rhs._M_dirs);
- }
-
- inline bool
- operator!=(const recursive_directory_iterator& __lhs,
- const recursive_directory_iterator& __rhs)
- { return !(__lhs == __rhs); }
-
-_GLIBCXX_END_NAMESPACE_CXX11
-
- // @} group filesystem
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace v1
-} // namespace filesystem
-} // namespace experimental
-} // namespace std
-
-#endif // C++11
-
-#endif // _GLIBCXX_EXPERIMENTAL_FS_DIR_H
diff --git a/libstdc++-v3/include/experimental/fs_fwd.h b/libstdc++-v3/include/experimental/fs_fwd.h
deleted file mode 100644
index a5ed2c5..0000000
--- a/libstdc++-v3/include/experimental/fs_fwd.h
+++ /dev/null
@@ -1,289 +0,0 @@
-// Filesystem declarations -*- C++ -*-
-
-// Copyright (C) 2014-2015 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file experimental/filesystem
- * This is a TS C++ Library header.
- */
-
-#ifndef _GLIBCXX_EXPERIMENTAL_FS_FWD_H
-#define _GLIBCXX_EXPERIMENTAL_FS_FWD_H 1
-
-#if __cplusplus < 201103L
-# include <bits/c++0x_warning.h>
-#else
-
-#include <system_error>
-#include <cstdint>
-#include <chrono>
-
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-namespace experimental
-{
-namespace filesystem
-{
-inline namespace v1
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
-#if _GLIBCXX_USE_CXX11_ABI
- inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
-#endif
-
- /**
- * @defgroup filesystem
- * @ingroup experimental
- *
- * Utilities for performing operations on file systems and their components,
- * such as paths, regular files, and directories.
- *
- * @{
- */
-
- class file_status;
-_GLIBCXX_BEGIN_NAMESPACE_CXX11
- class path;
- class filesystem_error;
- class directory_entry;
- class directory_iterator;
- class recursive_directory_iterator;
-_GLIBCXX_END_NAMESPACE_CXX11
-
- struct space_info
- {
- uintmax_t capacity;
- uintmax_t free;
- uintmax_t available;
- };
-
- enum class file_type : signed char {
- none = 0, not_found = -1, regular = 1, directory = 2, symlink = 3,
- block = 4, character = 5, fifo = 6, socket = 7, unknown = 8
- };
-
- /// Bitmask type
- enum class copy_options : unsigned short {
- none = 0,
- skip_existing = 1, overwrite_existing = 2, update_existing = 4,
- recursive = 8,
- copy_symlinks = 16, skip_symlinks = 32,
- directories_only = 64, create_symlinks = 128, create_hard_links = 256
- };
-
- constexpr copy_options
- operator&(copy_options __x, copy_options __y)
- {
- using __utype = typename std::underlying_type<copy_options>::type;
- return static_cast<copy_options>(
- static_cast<__utype>(__x) & static_cast<__utype>(__y));
- }
-
- constexpr copy_options
- operator|(copy_options __x, copy_options __y)
- {
- using __utype = typename std::underlying_type<copy_options>::type;
- return static_cast<copy_options>(
- static_cast<__utype>(__x) | static_cast<__utype>(__y));
- }
-
- constexpr copy_options
- operator^(copy_options __x, copy_options __y)
- {
- using __utype = typename std::underlying_type<copy_options>::type;
- return static_cast<copy_options>(
- static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
- }
-
- constexpr copy_options
- operator~(copy_options __x)
- {
- using __utype = typename std::underlying_type<copy_options>::type;
- return static_cast<copy_options>(~static_cast<__utype>(__x));
- }
-
- inline copy_options&
- operator&=(copy_options& __x, copy_options __y)
- { return __x = __x & __y; }
-
- inline copy_options&
- operator|=(copy_options& __x, copy_options __y)
- { return __x = __x | __y; }
-
- inline copy_options&
- operator^=(copy_options& __x, copy_options __y)
- { return __x = __x ^ __y; }
-
-
- /// Bitmask type
- enum class perms : unsigned {
- none = 0,
- owner_read = 0400,
- owner_write = 0200,
- owner_exec = 0100,
- owner_all = 0700,
- group_read = 040,
- group_write = 020,
- group_exec = 010,
- group_all = 070,
- others_read = 04,
- others_write = 02,
- others_exec = 01,
- others_all = 07,
- all = 0777,
- set_uid = 04000,
- set_gid = 02000,
- sticky_bit = 01000,
- mask = 07777,
- unknown = 0xFFFF,
- add_perms = 0x10000,
- remove_perms = 0x20000,
- resolve_symlinks = 0x40000
- };
-
- constexpr perms
- operator&(perms __x, perms __y)
- {
- using __utype = typename std::underlying_type<perms>::type;
- return static_cast<perms>(
- static_cast<__utype>(__x) & static_cast<__utype>(__y));
- }
-
- constexpr perms
- operator|(perms __x, perms __y)
- {
- using __utype = typename std::underlying_type<perms>::type;
- return static_cast<perms>(
- static_cast<__utype>(__x) | static_cast<__utype>(__y));
- }
-
- constexpr perms
- operator^(perms __x, perms __y)
- {
- using __utype = typename std::underlying_type<perms>::type;
- return static_cast<perms>(
- static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
- }
-
- constexpr perms
- operator~(perms __x)
- {
- using __utype = typename std::underlying_type<perms>::type;
- return static_cast<perms>(~static_cast<__utype>(__x));
- }
-
- inline perms&
- operator&=(perms& __x, perms __y)
- { return __x = __x & __y; }
-
- inline perms&
- operator|=(perms& __x, perms __y)
- { return __x = __x | __y; }
-
- inline perms&
- operator^=(perms& __x, perms __y)
- { return __x = __x ^ __y; }
-
- // Bitmask type
- enum class directory_options : unsigned char {
- none = 0, follow_directory_symlink = 1, skip_permission_denied = 2
- };
-
- constexpr directory_options
- operator&(directory_options __x, directory_options __y)
- {
- using __utype = typename std::underlying_type<directory_options>::type;
- return static_cast<directory_options>(
- static_cast<__utype>(__x) & static_cast<__utype>(__y));
- }
-
- constexpr directory_options
- operator|(directory_options __x, directory_options __y)
- {
- using __utype = typename std::underlying_type<directory_options>::type;
- return static_cast<directory_options>(
- static_cast<__utype>(__x) | static_cast<__utype>(__y));
- }
-
- constexpr directory_options
- operator^(directory_options __x, directory_options __y)
- {
- using __utype = typename std::underlying_type<directory_options>::type;
- return static_cast<directory_options>(
- static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
- }
-
- constexpr directory_options
- operator~(directory_options __x)
- {
- using __utype = typename std::underlying_type<directory_options>::type;
- return static_cast<directory_options>(~static_cast<__utype>(__x));
- }
-
- inline directory_options&
- operator&=(directory_options& __x, directory_options __y)
- { return __x = __x & __y; }
-
- inline directory_options&
- operator|=(directory_options& __x, directory_options __y)
- { return __x = __x | __y; }
-
- inline directory_options&
- operator^=(directory_options& __x, directory_options __y)
- { return __x = __x ^ __y; }
-
- typedef chrono::time_point<chrono::system_clock> file_time_type;
-
- // operational functions
-
- void copy(const path& __from, const path& __to, copy_options __options);
- void copy(const path& __from, const path& __to, copy_options __options,
- error_code&) noexcept;
-
- bool copy_file(const path& __from, const path& __to, copy_options __option);
- bool copy_file(const path& __from, const path& __to, copy_options __option,
- error_code&) noexcept;
-
- path current_path();
-
- file_status status(const path&);
- file_status status(const path&, error_code&) noexcept;
-
- bool status_known(file_status) noexcept;
-
- file_status symlink_status(const path&);
- file_status symlink_status(const path&, error_code&) noexcept;
-
- bool is_regular_file(file_status) noexcept;
- bool is_symlink(file_status) noexcept;
-
- // @} group filesystem
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace v1
-} // namespace filesystem
-} // namespace experimental
-} // namespace std
-
-#endif // C++11
-
-#endif // _GLIBCXX_EXPERIMENTAL_FS_FWD_H
diff --git a/libstdc++-v3/include/experimental/fs_ops.h b/libstdc++-v3/include/experimental/fs_ops.h
deleted file mode 100644
index 6b7d470..0000000
--- a/libstdc++-v3/include/experimental/fs_ops.h
+++ /dev/null
@@ -1,291 +0,0 @@
-// Filesystem operational functions -*- C++ -*-
-
-// Copyright (C) 2014-2015 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your __option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file experimental/filesystem
- * This is a TS C++ Library header.
- */
-
-#ifndef _GLIBCXX_EXPERIMENTAL_FS_OPS_H
-#define _GLIBCXX_EXPERIMENTAL_FS_OPS_H 1
-
-#if __cplusplus < 201103L
-# include <bits/c++0x_warning.h>
-#else
-
-#include <cstdint>
-
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-namespace experimental
-{
-namespace filesystem
-{
-inline namespace v1
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
- /**
- * @ingroup filesystem
- * @{
- */
-
- path absolute(const path& __p, const path& __base = current_path());
-
- path canonical(const path& __p, const path& __base = current_path());
- path canonical(const path& __p, error_code& __ec);
- path canonical(const path& __p, const path& __base, error_code& __ec);
-
- inline void
- copy(const path& __from, const path& __to)
- { copy(__from, __to, copy_options::none); }
-
- inline void
- copy(const path& __from, const path& __to, error_code& __ec) noexcept
- { copy(__from, __to, copy_options::none, __ec); }
-
- void copy(const path& __from, const path& __to, copy_options __options);
- void copy(const path& __from, const path& __to, copy_options __options,
- error_code& __ec) noexcept;
-
- inline bool
- copy_file(const path& __from, const path& __to)
- { return copy_file(__from, __to, copy_options::none); }
-
- inline bool
- copy_file(const path& __from, const path& __to, error_code& __ec) noexcept
- { return copy_file(__from, __to, copy_options::none, __ec); }
-
- bool copy_file(const path& __from, const path& __to, copy_options __option);
- bool copy_file(const path& __from, const path& __to, copy_options __option,
- error_code& __ec) noexcept;
-
- void copy_symlink(const path& __existing_symlink, const path& __new_symlink);
- void copy_symlink(const path& __existing_symlink, const path& __new_symlink,
- error_code& __ec) noexcept;
-
- bool create_directories(const path& __p);
- bool create_directories(const path& __p, error_code& __ec) noexcept;
-
- bool create_directory(const path& __p);
- bool create_directory(const path& __p, error_code& __ec) noexcept;
-
- bool create_directory(const path& __p, const path& attributes);
- bool create_directory(const path& __p, const path& attributes,
- error_code& __ec) noexcept;
-
- void create_directory_symlink(const path& __to, const path& __new_symlink);
- void create_directory_symlink(const path& __to, const path& __new_symlink,
- error_code& __ec) noexcept;
-
- void create_hard_link(const path& __to, const path& __new_hard_link);
- void create_hard_link(const path& __to, const path& __new_hard_link,
- error_code& __ec) noexcept;
-
- void create_symlink(const path& __to, const path& __new_symlink);
- void create_symlink(const path& __to, const path& __new_symlink,
- error_code& __ec) noexcept;
-
- path current_path();
- path current_path(error_code& __ec);
- void current_path(const path& __p);
- void current_path(const path& __p, error_code& __ec) noexcept;
-
- inline bool
- exists(file_status __s) noexcept
- { return status_known(__s) && __s.type() != file_type::not_found; }
-
- inline bool
- exists(const path& __p)
- { return exists(status(__p)); }
-
- inline bool
- exists(const path& __p, error_code& __ec) noexcept
- { return exists(status(__p, __ec)); }
-
- bool
- equivalent(const path& __p1, const path& __p2);
-
- bool
- equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept;
-
- uintmax_t file_size(const path& __p);
- uintmax_t file_size(const path& __p, error_code& __ec) noexcept;
-
- uintmax_t hard_link_count(const path& __p);
- uintmax_t hard_link_count(const path& __p, error_code& __ec) noexcept;
-
- inline bool
- is_block_file(file_status __s) noexcept
- { return __s.type() == file_type::block; }
-
- inline bool
- is_block_file(const path& __p)
- { return is_block_file(status(__p)); }
-
- inline bool
- is_block_file(const path& __p, error_code& __ec) noexcept
- { return is_block_file(status(__p, __ec)); }
-
- inline bool
- is_character_file(file_status __s) noexcept
- { return __s.type() == file_type::character; }
-
- inline bool
- is_character_file(const path& __p)
- { return is_character_file(status(__p)); }
-
- inline bool
- is_character_file(const path& __p, error_code& __ec) noexcept
- { return is_character_file(status(__p, __ec)); }
-
- inline bool
- is_directory(file_status __s) noexcept
- { return __s.type() == file_type::directory; }
-
- inline bool
- is_directory(const path& __p)
- { return is_directory(status(__p)); }
-
- inline bool
- is_directory(const path& __p, error_code& __ec) noexcept
- { return is_directory(status(__p, __ec)); }
-
- bool is_empty(const path& __p);
- bool is_empty(const path& __p, error_code& __ec) noexcept;
-
- inline bool
- is_fifo(file_status __s) noexcept
- { return __s.type() == file_type::fifo; }
-
- inline bool
- is_fifo(const path& __p)
- { return is_fifo(status(__p)); }
-
- inline bool
- is_fifo(const path& __p, error_code& __ec) noexcept
- { return is_fifo(status(__p, __ec)); }
-
- inline bool
- is_other(file_status __s) noexcept
- {
- return exists(__s) && !is_regular_file(__s) && !is_directory(__s)
- && !is_symlink(__s);
- }
-
- inline bool
- is_other(const path& __p)
- { return is_other(status(__p)); }
-
- inline bool
- is_other(const path& __p, error_code& __ec) noexcept
- { return is_other(status(__p, __ec)); }
-
- inline bool
- is_regular_file(file_status __s) noexcept
- { return __s.type() == file_type::regular; }
-
- inline bool
- is_regular_file(const path& __p)
- { return is_regular_file(status(__p)); }
-
- inline bool
- is_regular_file(const path& __p, error_code& __ec) noexcept
- { return is_regular_file(status(__p, __ec)); }
-
- inline bool
- is_socket(file_status __s) noexcept
- { return __s.type() == file_type::socket; }
-
- inline bool
- is_socket(const path& __p)
- { return is_socket(status(__p)); }
-
- inline bool
- is_socket(const path& __p, error_code& __ec) noexcept
- { return is_socket(status(__p, __ec)); }
-
- inline bool
- is_symlink(file_status __s) noexcept
- { return __s.type() == file_type::symlink; }
-
- inline bool
- is_symlink(const path& __p)
- { return is_symlink(symlink_status(__p)); }
-
- inline bool
- is_symlink(const path& __p, error_code& __ec) noexcept
- { return is_symlink(symlink_status(__p, __ec)); }
-
- file_time_type last_write_time(const path& __p);
- file_time_type last_write_time(const path& __p, error_code& __ec) noexcept;
- void last_write_time(const path& __p, file_time_type __new_time);
- void last_write_time(const path& __p, file_time_type __new_time,
- error_code& __ec) noexcept;
-
- void permissions(const path& __p, perms __prms);
- void permissions(const path& __p, perms __prms, error_code& __ec) noexcept;
-
- path read_symlink(const path& __p);
- path read_symlink(const path& __p, error_code& __ec);
-
- bool remove(const path& __p);
- bool remove(const path& __p, error_code& __ec) noexcept;
-
- uintmax_t remove_all(const path& __p);
- uintmax_t remove_all(const path& __p, error_code& __ec) noexcept;
-
- void rename(const path& __from, const path& __to);
- void rename(const path& __from, const path& __to, error_code& __ec) noexcept;
-
- void resize_file(const path& __p, uintmax_t __size);
- void resize_file(const path& __p, uintmax_t __size, error_code& __ec) noexcept;
-
- space_info space(const path& __p);
- space_info space(const path& __p, error_code& __ec) noexcept;
-
- file_status status(const path& __p);
- file_status status(const path& __p, error_code& __ec) noexcept;
-
- inline bool status_known(file_status __s) noexcept
- { return __s.type() != file_type::none; }
-
- file_status symlink_status(const path& __p);
- file_status symlink_status(const path& __p, error_code& __ec) noexcept;
-
- path system_complete(const path& __p);
- path system_complete(const path& __p, error_code& __ec);
-
- path temp_directory_path();
- path temp_directory_path(error_code& __ec);
-
- // @} group filesystem
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace v1
-} // namespace filesystem
-} // namespace experimental
-} // namespace std
-
-#endif // C++11
-
-#endif // _GLIBCXX_EXPERIMENTAL_FS_OPS_H
diff --git a/libstdc++-v3/include/experimental/fs_path.h b/libstdc++-v3/include/experimental/fs_path.h
deleted file mode 100644
index 40462a6..0000000
--- a/libstdc++-v3/include/experimental/fs_path.h
+++ /dev/null
@@ -1,1024 +0,0 @@
-// Class filesystem::path -*- C++ -*-
-
-// Copyright (C) 2014-2015 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file experimental/fs_path.h
- * This is an internal header file, included by other library headers.
- * Do not attempt to use it directly. @headername{experimental/filesystem}
- */
-
-#ifndef _GLIBCXX_EXPERIMENTAL_FS_PATH_H
-#define _GLIBCXX_EXPERIMENTAL_FS_PATH_H 1
-
-#if __cplusplus < 201103L
-# include <bits/c++0x_warning.h>
-#else
-
-#include <utility>
-#include <type_traits>
-#include <vector>
-#include <locale>
-#include <iosfwd>
-#include <codecvt>
-#include <system_error>
-#include <bits/stl_algobase.h>
-#include <bits/quoted_string.h>
-#include <bits/locale_conv.h>
-
-#if defined(_WIN32) && !defined(__CYGWIN__)
-# define _GLIBCXX_FILESYSTEM_IS_WINDOWS 1
-# include <algorithm>
-#endif
-
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-namespace experimental
-{
-namespace filesystem
-{
-inline namespace v1
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-_GLIBCXX_BEGIN_NAMESPACE_CXX11
-
- /**
- * @ingroup filesystem
- * @{
- */
-
- /// A filesystem path.
- class path
- {
- template<typename _CharT>
- struct __is_encoded_char : std::false_type { };
-
- template<typename _Iter,
- typename _Iter_traits = std::iterator_traits<_Iter>>
- using __is_path_iter_src
- = __and_<__is_encoded_char<typename _Iter_traits::value_type>,
- std::is_base_of<std::input_iterator_tag,
- typename _Iter_traits::iterator_category>>;
-
- template<typename _Iter>
- static __is_path_iter_src<_Iter>
- __is_path_src(_Iter, int);
-
- template<typename _CharT, typename _Traits, typename _Alloc>
- static __is_encoded_char<_CharT>
- __is_path_src(const basic_string<_CharT, _Traits, _Alloc>&, int);
-
- template<typename _Unknown>
- static std::false_type
- __is_path_src(const _Unknown&, ...);
-
- template<typename _Tp1, typename _Tp2>
- struct __constructible_from;
-
- template<typename _Iter>
- struct __constructible_from<_Iter, _Iter>
- : __is_path_iter_src<_Iter>
- { };
-
- template<typename _Source>
- struct __constructible_from<_Source, void>
- : decltype(__is_path_src(std::declval<_Source>(), 0))
- { };
-
- template<typename _Tp1, typename _Tp2 = void>
- using _Path = typename
- std::enable_if<__and_<__not_<is_same<_Tp1, path>>,
- __constructible_from<_Tp1, _Tp2>>::value,
- path>::type;
-
- template<typename _Source>
- static _Source
- _S_range_begin(_Source __begin) { return __begin; }
-
- struct __null_terminated { };
-
- template<typename _Source>
- static __null_terminated
- _S_range_end(_Source) { return {}; }
-
- template<typename _CharT, typename _Traits, typename _Alloc>
- static const _CharT*
- _S_range_begin(const basic_string<_CharT, _Traits, _Alloc>& __str)
- { return __str.data(); }
-
- template<typename _CharT, typename _Traits, typename _Alloc>
- static const _CharT*
- _S_range_end(const basic_string<_CharT, _Traits, _Alloc>& __str)
- { return __str.data() + __str.size(); }
-
- template<typename _Tp,
- typename _Iter = decltype(_S_range_begin(std::declval<_Tp>())),
- typename _Val = typename std::iterator_traits<_Iter>::value_type>
- using __value_type_is_char
- = typename std::enable_if<std::is_same<_Val, char>::value>::type;
-
- public:
-#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
- typedef wchar_t value_type;
- static constexpr value_type preferred_separator = L'\\';
-#else
- typedef char value_type;
- static constexpr value_type preferred_separator = '/';
-#endif
- typedef std::basic_string<value_type> string_type;
-
- // constructors and destructor
-
- path() noexcept { }
-
- path(const path& __p) = default;
-
- path(path&& __p) noexcept
- : _M_pathname(std::move(__p._M_pathname)), _M_type(__p._M_type)
- {
- _M_split_cmpts();
- __p.clear();
- }
-
- template<typename _Source,
- typename _Require = _Path<_Source>>
- path(_Source const& __source)
- : _M_pathname(_S_convert(_S_range_begin(__source),
- _S_range_end(__source)))
- { _M_split_cmpts(); }
-
- template<typename _InputIterator,
- typename _Require = _Path<_InputIterator, _InputIterator>>
- path(_InputIterator __first, _InputIterator __last)
- : _M_pathname(_S_convert(__first, __last))
- { _M_split_cmpts(); }
-
- template<typename _Source,
- typename _Require = _Path<_Source>,
- typename _Require2 = __value_type_is_char<_Source>>
- path(_Source const& __source, const locale& __loc)
- : _M_pathname(_S_convert_loc(_S_range_begin(__source),
- _S_range_end(__source), __loc))
- { _M_split_cmpts(); }
-
- template<typename _InputIterator,
- typename _Require = _Path<_InputIterator, _InputIterator>,
- typename _Require2 = __value_type_is_char<_InputIterator>>
- path(_InputIterator __first, _InputIterator __last, const locale& __loc)
- : _M_pathname(_S_convert_loc(__first, __last, __loc))
- { _M_split_cmpts(); }
-
- ~path() = default;
-
- // assignments
-
- path& operator=(const path& __p) = default;
- path& operator=(path&& __p) noexcept;
-
- template<typename _Source>
- _Path<_Source>&
- operator=(_Source const& __source)
- { return *this = path(__source); }
-
- template<typename _Source>
- _Path<_Source>&
- assign(_Source const& __source)
- { return *this = path(__source); }
-
- template<typename _InputIterator>
- _Path<_InputIterator, _InputIterator>&
- assign(_InputIterator __first, _InputIterator __last)
- { return *this = path(__first, __last); }
-
- // appends
-
- path& operator/=(const path& __p) { return _M_append(__p._M_pathname); }
-
- template <class _Source>
- _Path<_Source>&
- operator/=(_Source const& __source)
- { return append(__source); }
-
- template<typename _Source>
- _Path<_Source>&
- append(_Source const& __source)
- {
- return _M_append(_S_convert(_S_range_begin(__source),
- _S_range_end(__source)));
- }
-
- template<typename _InputIterator>
- _Path<_InputIterator, _InputIterator>&
- append(_InputIterator __first, _InputIterator __last)
- { return _M_append(_S_convert(__first, __last)); }
-
- // concatenation
-
- path& operator+=(const path& __x);
- path& operator+=(const string_type& __x);
- path& operator+=(const value_type* __x);
- path& operator+=(value_type __x);
-
- template<typename _Source>
- _Path<_Source>&
- operator+=(_Source const& __x) { return concat(__x); }
-
- template<typename _CharT>
- _Path<_CharT*, _CharT*>&
- operator+=(_CharT __x);
-
- template<typename _Source>
- _Path<_Source>&
- concat(_Source const& __x)
- { return *this += _S_convert(_S_range_begin(__x), _S_range_end(__x)); }
-
- template<typename _InputIterator>
- _Path<_InputIterator, _InputIterator>&
- concat(_InputIterator __first, _InputIterator __last)
- { return *this += _S_convert(__first, __last); }
-
- // modifiers
-
- void clear() noexcept { _M_pathname.clear(); _M_split_cmpts(); }
-
- path& make_preferred();
- path& remove_filename();
- path& replace_filename(const path& __replacement);
- path& replace_extension(const path& __replacement = path());
-
- void swap(path& __rhs) noexcept;
-
- // native format observers
-
- const string_type& native() const noexcept { return _M_pathname; }
- const value_type* c_str() const noexcept { return _M_pathname.c_str(); }
- operator string_type() const { return _M_pathname; }
-
- template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
- typename _Allocator = std::allocator<_CharT>>
- std::basic_string<_CharT, _Traits, _Allocator>
- string(const _Allocator& __a = _Allocator()) const;
-
- std::string string() const;
-#if _GLIBCXX_USE_WCHAR_T
- std::wstring wstring() const;
-#endif
- std::string u8string() const;
- std::u16string u16string() const;
- std::u32string u32string() const;
-
- // generic format observers
- template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
- typename _Allocator = std::allocator<_CharT>>
- std::basic_string<_CharT, _Traits, _Allocator>
- generic_string(const _Allocator& __a = _Allocator()) const;
-
- std::string generic_string() const;
-#if _GLIBCXX_USE_WCHAR_T
- std::wstring generic_wstring() const;
-#endif
- std::string generic_u8string() const;
- std::u16string generic_u16string() const;
- std::u32string generic_u32string() const;
-
- // compare
-
- int compare(const path& __p) const noexcept;
- int compare(const string_type& __s) const;
- int compare(const value_type* __s) const;
-
- // decomposition
-
- path root_name() const;
- path root_directory() const;
- path root_path() const;
- path relative_path() const;
- path parent_path() const;
- path filename() const;
- path stem() const;
- path extension() const;
-
- // query
-
- bool empty() const noexcept { return _M_pathname.empty(); }
- bool has_root_name() const;
- bool has_root_directory() const;
- bool has_root_path() const;
- bool has_relative_path() const;
- bool has_parent_path() const;
- bool has_filename() const;
- bool has_stem() const;
- bool has_extension() const;
- bool is_absolute() const;
- bool is_relative() const { return !is_absolute(); }
-
- // iterators
- class iterator;
- typedef iterator const_iterator;
-
- iterator begin() const;
- iterator end() const;
-
- private:
- enum class _Type : unsigned char {
- _Multi, _Root_name, _Root_dir, _Filename
- };
-
- path(string_type __str, _Type __type) : _M_pathname(__str), _M_type(__type)
- {
- __glibcxx_assert(!empty());
- __glibcxx_assert(_M_type != _Type::_Multi);
- }
-
- enum class _Split { _Stem, _Extension };
-
- path& _M_append(const string_type& __str)
- {
- if (!_M_pathname.empty() && !_S_is_dir_sep(_M_pathname.back())
- && !__str.empty() && !_S_is_dir_sep(__str.front()))
- _M_pathname += preferred_separator;
- _M_pathname += __str;
- _M_split_cmpts();
- return *this;
- }
-
- pair<const string_type*, size_t> _M_find_extension() const;
-
- template<typename _CharT>
- struct _Cvt;
-
- static string_type
- _S_convert(value_type* __src, __null_terminated)
- { return string_type(__src); }
-
- static string_type
- _S_convert(const value_type* __src, __null_terminated)
- { return string_type(__src); }
-
- template<typename _Iter>
- static string_type
- _S_convert(_Iter __first, _Iter __last)
- {
- using __value_type = typename std::iterator_traits<_Iter>::value_type;
- return _Cvt<__value_type>::_S_convert(__first, __last);
- }
-
- template<typename _InputIterator>
- static string_type
- _S_convert(_InputIterator __src, __null_terminated)
- {
- using _Tp = typename std::iterator_traits<_InputIterator>::value_type;
- std::basic_string<_Tp> __tmp;
- while (*__src != _Tp{})
- __tmp.push_back(*__src++);
- return _S_convert(__tmp.data(), __tmp.data() + __tmp.size());
- }
-
- static string_type
- _S_convert_loc(const char* __first, const char* __last,
- const std::locale& __loc);
-
- template<typename _Iter>
- static string_type
- _S_convert_loc(_Iter __first, _Iter __last, const std::locale& __loc)
- {
- const std::string __str(__first, __last);
- return _S_convert_loc(__str.data(), __str.data()+__str.size(), __loc);
- }
-
- template<typename _InputIterator>
- static string_type
- _S_convert_loc(_InputIterator __src, __null_terminated,
- const std::locale& __loc)
- {
- std::string __tmp;
- while (*__src != '\0')
- __tmp.push_back(*__src++);
- return _S_convert_loc(__tmp.data(), __tmp.data()+__tmp.size(), __loc);
- }
-
- bool _S_is_dir_sep(value_type __ch)
- {
-#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
- return __ch == L'/' || __ch == preferred_separator;
-#else
- return __ch == '/';
-#endif
- }
-
- void _M_split_cmpts();
- void _M_trim();
- void _M_add_root_name(size_t __n);
- void _M_add_root_dir(size_t __pos);
- void _M_add_filename(size_t __pos, size_t __n);
-
- string_type _M_pathname;
-
- struct _Cmpt;
- using _List = _GLIBCXX_STD_C::vector<_Cmpt>;
- _List _M_cmpts; // empty unless _M_type == _Type::_Multi
- _Type _M_type = _Type::_Multi;
- };
-
- inline void swap(path& __lhs, path& __rhs) noexcept { __lhs.swap(__rhs); }
-
- size_t hash_value(const path& __p) noexcept;
-
- /// Compare paths
- inline bool operator<(const path& __lhs, const path& __rhs) noexcept
- { return __lhs.compare(__rhs) < 0; }
-
- /// Compare paths
- inline bool operator<=(const path& __lhs, const path& __rhs) noexcept
- { return !(__rhs < __lhs); }
-
- /// Compare paths
- inline bool operator>(const path& __lhs, const path& __rhs) noexcept
- { return __rhs < __lhs; }
-
- /// Compare paths
- inline bool operator>=(const path& __lhs, const path& __rhs) noexcept
- { return !(__lhs < __rhs); }
-
- /// Compare paths
- inline bool operator==(const path& __lhs, const path& __rhs) noexcept
- { return __lhs.compare(__rhs) == 0; }
-
- /// Compare paths
- inline bool operator!=(const path& __lhs, const path& __rhs) noexcept
- { return !(__lhs == __rhs); }
-
- /// Append one path to another
- inline path operator/(const path& __lhs, const path& __rhs)
- { return path(__lhs) /= __rhs; }
-
- /// Write a path to a stream
- template<typename _CharT, typename _Traits>
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p)
- {
- auto __tmp = __p.string<_CharT, _Traits>();
- using __quoted_string
- = std::__detail::_Quoted_string<decltype(__tmp)&, _CharT>;
- __os << __quoted_string{__tmp, '"', '\\'};
- return __os;
- }
-
- /// Read a path from a stream
- template<typename _CharT, typename _Traits>
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is, path& __p)
- {
- basic_string<_CharT, _Traits> __tmp;
- using __quoted_string
- = std::__detail::_Quoted_string<decltype(__tmp)&, _CharT>;
- if (__is >> __quoted_string{ __tmp, '"', '\\' })
- __p = std::move(__tmp);
- return __is;
- }
-
- // TODO constrain with _Path<Source> and __value_type_is_char
- template<typename _Source>
- inline path
- u8path(const _Source& __source)
- {
-#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
- return path{ path::string_type{__source} };
-#else
- return path{ __source };
-#endif
- }
-
- // TODO constrain with _Path<InputIterator, InputIterator> and __value_type_is_char
- template<typename _InputIterator>
- inline path
- u8path(_InputIterator __first, _InputIterator __last)
- {
-#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
- return path{ path::string_type{__first, __last} };
-#else
- return path{ __first, __last };
-#endif
- }
-
- class filesystem_error : public std::system_error
- {
- public:
- filesystem_error(const string& __what_arg, error_code __ec)
- : system_error(__ec, __what_arg) { }
-
- filesystem_error(const string& __what_arg, const path& __p1,
- error_code __ec)
- : system_error(__ec, __what_arg), _M_path1(__p1) { }
-
- filesystem_error(const string& __what_arg, const path& __p1,
- const path& __p2, error_code __ec)
- : system_error(__ec, __what_arg), _M_path1(__p1), _M_path2(__p2)
- { }
-
- ~filesystem_error();
-
- const path& path1() const noexcept { return _M_path1; }
- const path& path2() const noexcept { return _M_path2; }
- const char* what() const noexcept { return _M_what.c_str(); }
-
- private:
- std::string _M_gen_what();
-
- path _M_path1;
- path _M_path2;
- std::string _M_what = _M_gen_what();
- };
-
- struct path::_Cmpt : path
- {
- _Cmpt(string_type __s, _Type __t, size_t __pos)
- : path(std::move(__s), __t), _M_pos(__pos) { }
-
- _Cmpt() : _M_pos(-1) { }
-
- size_t _M_pos;
- };
-
- template<>
- struct path::__is_encoded_char<char> : std::true_type
- { using value_type = char; };
-
- template<>
- struct path::__is_encoded_char<wchar_t> : std::true_type
- { using value_type = wchar_t; };
-
- template<>
- struct path::__is_encoded_char<char16_t> : std::true_type
- { using value_type = char16_t; };
-
- template<>
- struct path::__is_encoded_char<char32_t> : std::true_type
- { using value_type = char32_t; };
-
- // specialize _Cvt for degenerate 'noconv' case
- template<>
- struct path::_Cvt<path::value_type>
- {
- template<typename _Iter>
- static string_type
- _S_convert(_Iter __first, _Iter __last)
- { return string_type{__first, __last}; }
- };
-
- template<typename _CharT>
- struct path::_Cvt
- {
-#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
- static string_type
- _S_wconvert(const char* __f, const char* __l, true_type)
- {
- using _Cvt = std::codecvt<wchar_t, char, mbstate_t>;
- const auto& __cvt = std::use_facet<_Cvt>(std::locale{});
- std::wstring __wstr;
- if (__str_codecvt_in(__f, __l, __wstr, __cvt))
- return __wstr;
- _GLIBCXX_THROW_OR_ABORT(filesystem_error(
- "Cannot convert character sequence",
- std::make_error_code(errc::illegal_byte_sequence)));
- }
-
- static string_type
- _S_wconvert(const _CharT* __f, const _CharT* __l, false_type)
- {
- std::codecvt_utf8<_CharT> __cvt;
- std::string __str;
- if (__str_codecvt_out(__f, __l, __str, __cvt))
- {
- const char* __f2 = __str.data();
- const char* __l2 = __f2 + __str.size();
- std::codecvt_utf8<wchar_t> __wcvt;
- std::wstring __wstr;
- if (__str_codecvt_in(__f2, __l2, __wstr, __wcvt))
- return __wstr;
- }
- _GLIBCXX_THROW_OR_ABORT(filesystem_error(
- "Cannot convert character sequence",
- std::make_error_code(errc::illegal_byte_sequence)));
- }
-
- static string_type
- _S_convert(const _CharT* __f, const _CharT* __l)
- {
- return _S_wconvert(__f, __l, is_same<_CharT, char>{});
- }
-#else
- static string_type
- _S_convert(const _CharT* __f, const _CharT* __l)
- {
- std::codecvt_utf8<_CharT> __cvt;
- std::string __str;
- if (__str_codecvt_out(__f, __l, __str, __cvt))
- return __str;
- _GLIBCXX_THROW_OR_ABORT(filesystem_error(
- "Cannot convert character sequence",
- std::make_error_code(errc::illegal_byte_sequence)));
- }
-#endif
-
- static string_type
- _S_convert(_CharT* __f, _CharT* __l)
- {
- return _S_convert(const_cast<const _CharT*>(__f),
- const_cast<const _CharT*>(__l));
- }
-
- template<typename _Iter>
- static string_type
- _S_convert(_Iter __first, _Iter __last)
- {
- const std::basic_string<_CharT> __str(__first, __last);
- return _S_convert(__str.data(), __str.data() + __str.size());
- }
-
- template<typename _Iter, typename _Cont>
- static string_type
- _S_convert(__gnu_cxx::__normal_iterator<_Iter, _Cont> __first,
- __gnu_cxx::__normal_iterator<_Iter, _Cont> __last)
- { return _S_convert(__first.base(), __last.base()); }
- };
-
- /// An iterator for the components of a path
- class path::iterator
- {
- public:
- using difference_type = std::ptrdiff_t;
- using value_type = path;
- using reference = const path&;
- using pointer = const path*;
- using iterator_category = std::bidirectional_iterator_tag;
-
- iterator() : _M_path(nullptr), _M_cur(), _M_at_end() { }
-
- iterator(const iterator&) = default;
- iterator& operator=(const iterator&) = default;
-
- reference operator*() const;
- pointer operator->() const { return std::__addressof(**this); }
-
- iterator& operator++();
- iterator operator++(int) { auto __tmp = *this; ++_M_cur; return __tmp; }
-
- iterator& operator--();
- iterator operator--(int) { auto __tmp = *this; --_M_cur; return __tmp; }
-
- friend bool operator==(const iterator& __lhs, const iterator& __rhs)
- { return __lhs._M_equals(__rhs); }
-
- friend bool operator!=(const iterator& __lhs, const iterator& __rhs)
- { return !__lhs._M_equals(__rhs); }
-
- private:
- friend class path;
-
- iterator(const path* __path, path::_List::const_iterator __iter)
- : _M_path(__path), _M_cur(__iter), _M_at_end()
- { }
-
- iterator(const path* __path, bool __at_end)
- : _M_path(__path), _M_cur(), _M_at_end(__at_end)
- { }
-
- bool _M_equals(iterator) const;
-
- const path* _M_path;
- path::_List::const_iterator _M_cur;
- bool _M_at_end; // only used when type != _Multi
- };
-
-
- inline path&
- path::operator=(path&& __p) noexcept
- {
- _M_pathname = std::move(__p._M_pathname);
- _M_cmpts = std::move(__p._M_cmpts);
- _M_type = __p._M_type;
- __p.clear();
- return *this;
- }
-
- inline path&
- path::operator+=(const path& __p)
- {
- return operator+=(__p.native());
- }
-
- inline path&
- path::operator+=(const string_type& __x)
- {
- _M_pathname += __x;
- _M_split_cmpts();
- return *this;
- }
-
- inline path&
- path::operator+=(const value_type* __x)
- {
- _M_pathname += __x;
- _M_split_cmpts();
- return *this;
- }
-
- inline path&
- path::operator+=(value_type __x)
- {
- _M_pathname += __x;
- _M_split_cmpts();
- return *this;
- }
-
- template<typename _CharT>
- inline path::_Path<_CharT*, _CharT*>&
- path::operator+=(_CharT __x)
- {
- auto* __addr = std::__addressof(__x);
- return concat(__addr, __addr + 1);
- }
-
- inline path&
- path::make_preferred()
- {
-#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
- std::replace(_M_pathname.begin(), _M_pathname.end(), L'/',
- preferred_separator);
-#endif
- return *this;
- }
-
- inline void path::swap(path& __rhs) noexcept
- {
- _M_pathname.swap(__rhs._M_pathname);
- _M_cmpts.swap(__rhs._M_cmpts);
- std::swap(_M_type, __rhs._M_type);
- }
-
- template<typename _CharT, typename _Traits, typename _Allocator>
- inline std::basic_string<_CharT, _Traits, _Allocator>
- path::string(const _Allocator& __a) const
- {
- if (is_same<_CharT, value_type>::value)
- return { _M_pathname.begin(), _M_pathname.end(), __a };
-
- const value_type* __first = _M_pathname.data();
- const value_type* __last = __first + _M_pathname.size();
-
-#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
- using _CharAlloc = __alloc_rebind<_Allocator, char>;
- using _String = basic_string<char, char_traits<char>, _CharAlloc>;
- using _WString = basic_string<_CharT, _Traits, _Allocator>;
-
- // use codecvt_utf8<wchar_t> to convert native string to UTF-8
- codecvt_utf8<value_type> __cvt;
- _String __u8str{_CharAlloc{__a}};
- if (__str_codecvt_out(__first, __last, __u8str, __cvt))
- {
- struct
- {
- const _String*
- operator()(const _String& __from, _String&, true_type)
- { return std::__addressof(__from); }
-
- _WString*
- operator()(const _String& __from, _WString& __to, false_type)
- {
- // use codecvt_utf8<_CharT> to convert UTF-8 to wide string
- codecvt_utf8<_CharT> __cvt;
- const char* __f = __from.data();
- const char* __l = __f + __from.size();
- if (__str_codecvt_in(__f, __l, __to, __cvt))
- return std::__addressof(__to);
- return nullptr;
- }
- } __dispatch;
- _WString __wstr;
- if (auto* __p = __dispatch(__u8str, __wstr, is_same<_CharT, char>{}))
- return *__p;
- }
-#else
- codecvt_utf8<_CharT> __cvt;
- basic_string<_CharT, _Traits, _Allocator> __wstr{__a};
- if (__str_codecvt_in(__first, __last, __wstr, __cvt))
- return __wstr;
-#endif
- _GLIBCXX_THROW_OR_ABORT(filesystem_error(
- "Cannot convert character sequence",
- std::make_error_code(errc::illegal_byte_sequence)));
- }
-
- inline std::string
- path::string() const { return string<char>(); }
-
-#if _GLIBCXX_USE_WCHAR_T
- inline std::wstring
- path::wstring() const { return string<wchar_t>(); }
-#endif
-
- inline std::string
- path::u8string() const
- {
-#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
- std::string __str;
- // convert from native encoding to UTF-8
- codecvt_utf8<value_type> __cvt;
- const value_type* __first = _M_pathname.data();
- const value_type* __last = __first + _M_pathname.size();
- if (__str_codecvt_out(__first, __last, __str, __cvt))
- return __str;
- _GLIBCXX_THROW_OR_ABORT(filesystem_error(
- "Cannot convert character sequence",
- std::make_error_code(errc::illegal_byte_sequence)));
-#else
- return _M_pathname;
-#endif
- }
-
- inline std::u16string
- path::u16string() const { return string<char16_t>(); }
-
- inline std::u32string
- path::u32string() const { return string<char32_t>(); }
-
-#ifndef _GLIBCXX_FILESYSTEM_IS_WINDOWS
- template<typename _CharT, typename _Traits, typename _Allocator>
- inline std::basic_string<_CharT, _Traits, _Allocator>
- path::generic_string(const _Allocator& __a) const
- { return string<_CharT, _Traits, _Allocator>(__a); }
-
- inline std::string
- path::generic_string() const { return string(); }
-
-#if _GLIBCXX_USE_WCHAR_T
- inline std::wstring
- path::generic_wstring() const { return wstring(); }
-#endif
-
- inline std::string
- path::generic_u8string() const { return u8string(); }
-
- inline std::u16string
- path::generic_u16string() const { return u16string(); }
-
- inline std::u32string
- path::generic_u32string() const { return u32string(); }
-#endif
-
- inline int
- path::compare(const string_type& __s) const { return compare(path(__s)); }
-
- inline int
- path::compare(const value_type* __s) const { return compare(path(__s)); }
-
- inline path
- path::filename() const { return empty() ? path() : *--end(); }
-
- inline path
- path::stem() const
- {
- auto ext = _M_find_extension();
- if (ext.first && ext.second != 0)
- return path{ext.first->substr(0, ext.second)};
- return {};
- }
-
- inline path
- path::extension() const
- {
- auto ext = _M_find_extension();
- if (ext.first && ext.second != string_type::npos)
- return path{ext.first->substr(ext.second)};
- return {};
- }
-
- inline bool
- path::has_stem() const
- {
- auto ext = _M_find_extension();
- return ext.first && ext.second != 0;
- }
-
- inline bool
- path::has_extension() const
- {
- auto ext = _M_find_extension();
- return ext.first && ext.second != string_type::npos;
- }
-
- inline bool
- path::is_absolute() const
- {
-#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
- return has_root_name();
-#else
- return has_root_directory();
-#endif
- }
-
- inline path::iterator
- path::begin() const
- {
- if (_M_type == _Type::_Multi)
- return iterator(this, _M_cmpts.begin());
- return iterator(this, false);
- }
-
- inline path::iterator
- path::end() const
- {
- if (_M_type == _Type::_Multi)
- return iterator(this, _M_cmpts.end());
- return iterator(this, true);
- }
-
- inline path::iterator&
- path::iterator::operator++()
- {
- __glibcxx_assert(_M_path != nullptr);
- if (_M_path->_M_type == _Type::_Multi)
- {
- __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
- ++_M_cur;
- }
- else
- {
- __glibcxx_assert(!_M_at_end);
- _M_at_end = true;
- }
- return *this;
- }
-
- inline path::iterator&
- path::iterator::operator--()
- {
- __glibcxx_assert(_M_path != nullptr);
- if (_M_path->_M_type == _Type::_Multi)
- {
- __glibcxx_assert(_M_cur != _M_path->_M_cmpts.begin());
- --_M_cur;
- }
- else
- {
- __glibcxx_assert(_M_at_end);
- _M_at_end = false;
- }
- return *this;
- }
-
- inline path::iterator::reference
- path::iterator::operator*() const
- {
- __glibcxx_assert(_M_path != nullptr);
- if (_M_path->_M_type == _Type::_Multi)
- {
- __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
- return *_M_cur;
- }
- return *_M_path;
- }
-
- inline bool
- path::iterator::_M_equals(iterator __rhs) const
- {
- if (_M_path != __rhs._M_path)
- return false;
- if (_M_path == nullptr)
- return true;
- if (_M_path->_M_type == path::_Type::_Multi)
- return _M_cur == __rhs._M_cur;
- return _M_at_end == __rhs._M_at_end;
- }
-
- // @} group filesystem
-_GLIBCXX_END_NAMESPACE_CXX11
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace v1
-} // namespace filesystem
-} // namespace experimental
-} // namespace std
-
-#endif // C++11
-
-#endif // _GLIBCXX_EXPERIMENTAL_FS_PATH_H
diff --git a/libstdc++-v3/include/experimental/map b/libstdc++-v3/include/experimental/map
index e4b3620..89bf260 100644
--- a/libstdc++-v3/include/experimental/map
+++ b/libstdc++-v3/include/experimental/map
@@ -36,7 +36,7 @@
#else
#include <map>
-#include <experimental/erase_if.h>
+#include <experimental/bits/erase_if.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
diff --git a/libstdc++-v3/include/experimental/set b/libstdc++-v3/include/experimental/set
index c742d91..709fe32 100644
--- a/libstdc++-v3/include/experimental/set
+++ b/libstdc++-v3/include/experimental/set
@@ -36,7 +36,7 @@
#else
#include <set>
-#include <experimental/erase_if.h>
+#include <experimental/bits/erase_if.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
diff --git a/libstdc++-v3/include/experimental/string_view b/libstdc++-v3/include/experimental/string_view
index 9dca400..9931ad0 100644
--- a/libstdc++-v3/include/experimental/string_view
+++ b/libstdc++-v3/include/experimental/string_view
@@ -686,7 +686,7 @@ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace experimental
} // namespace std
-#include <experimental/string_view.tcc>
+#include <experimental/bits/string_view.tcc>
#endif // __cplusplus <= 201103L
diff --git a/libstdc++-v3/include/experimental/string_view.tcc b/libstdc++-v3/include/experimental/string_view.tcc
deleted file mode 100644
index 75a34f9..0000000
--- a/libstdc++-v3/include/experimental/string_view.tcc
+++ /dev/null
@@ -1,230 +0,0 @@
-// Components for manipulating non-owning sequences of characters -*- C++ -*-
-
-// Copyright (C) 2013-2015 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// Under Section 7 of GPL version 3, you are granted additional
-// permissions described in the GCC Runtime Library Exception, version
-// 3.1, as published by the Free Software Foundation.
-
-// You should have received a copy of the GNU General Public License and
-// a copy of the GCC Runtime Library Exception along with this program;
-// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
-// <http://www.gnu.org/licenses/>.
-
-/** @file experimental/string_view.tcc
- * This is an internal header file, included by other library headers.
- * Do not attempt to use it directly. @headername{string_view}
- */
-
-//
-// N3762 basic_string_view library
-//
-
-#ifndef _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC
-#define _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC 1
-
-#pragma GCC system_header
-
-#if __cplusplus <= 201103L
-# include <bits/c++14_warning.h>
-#else
-
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-namespace experimental
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
- template<typename _CharT, typename _Traits>
- typename basic_string_view<_CharT, _Traits>::size_type
- basic_string_view<_CharT, _Traits>::
- find(const _CharT* __str, size_type __pos, size_type __n) const noexcept
- {
- __glibcxx_requires_string_len(__str, __n);
-
- if (__n == 0)
- return __pos <= this->_M_len ? __pos : npos;
-
- if (__n <= this->_M_len)
- {
- for (; __pos <= this->_M_len - __n; ++__pos)
- if (traits_type::eq(this->_M_str[__pos], __str[0])
- && traits_type::compare(this->_M_str + __pos + 1,
- __str + 1, __n - 1) == 0)
- return __pos;
- }
- return npos;
- }
-
- template<typename _CharT, typename _Traits>
- typename basic_string_view<_CharT, _Traits>::size_type
- basic_string_view<_CharT, _Traits>::
- find(_CharT __c, size_type __pos) const noexcept
- {
- size_type __ret = npos;
- if (__pos < this->_M_len)
- {
- const size_type __n = this->_M_len - __pos;
- const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c);
- if (__p)
- __ret = __p - this->_M_str;
- }
- return __ret;
- }
-
- template<typename _CharT, typename _Traits>
- typename basic_string_view<_CharT, _Traits>::size_type
- basic_string_view<_CharT, _Traits>::
- rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept
- {
- __glibcxx_requires_string_len(__str, __n);
-
- if (__n <= this->_M_len)
- {
- __pos = std::min(size_type(this->_M_len - __n), __pos);
- do
- {
- if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0)
- return __pos;
- }
- while (__pos-- > 0);
- }
- return npos;
- }
-
- template<typename _CharT, typename _Traits>
- typename basic_string_view<_CharT, _Traits>::size_type
- basic_string_view<_CharT, _Traits>::
- rfind(_CharT __c, size_type __pos) const noexcept
- {
- size_type __size = this->_M_len;
- if (__size > 0)
- {
- if (--__size > __pos)
- __size = __pos;
- for (++__size; __size-- > 0; )
- if (traits_type::eq(this->_M_str[__size], __c))
- return __size;
- }
- return npos;
- }
-
- template<typename _CharT, typename _Traits>
- typename basic_string_view<_CharT, _Traits>::size_type
- basic_string_view<_CharT, _Traits>::
- find_first_of(const _CharT* __str, size_type __pos, size_type __n) const
- {
- __glibcxx_requires_string_len(__str, __n);
- for (; __n && __pos < this->_M_len; ++__pos)
- {
- const _CharT* __p = traits_type::find(__str, __n,
- this->_M_str[__pos]);
- if (__p)
- return __pos;
- }
- return npos;
- }
-
- template<typename _CharT, typename _Traits>
- typename basic_string_view<_CharT, _Traits>::size_type
- basic_string_view<_CharT, _Traits>::
- find_last_of(const _CharT* __str, size_type __pos, size_type __n) const
- {
- __glibcxx_requires_string_len(__str, __n);
- size_type __size = this->size();
- if (__size && __n)
- {
- if (--__size > __pos)
- __size = __pos;
- do
- {
- if (traits_type::find(__str, __n, this->_M_str[__size]))
- return __size;
- }
- while (__size-- != 0);
- }
- return npos;
- }
-
- template<typename _CharT, typename _Traits>
- typename basic_string_view<_CharT, _Traits>::size_type
- basic_string_view<_CharT, _Traits>::
- find_first_not_of(const _CharT* __str, size_type __pos, size_type __n) const
- {
- __glibcxx_requires_string_len(__str, __n);
- for (; __pos < this->_M_len; ++__pos)
- if (!traits_type::find(__str, __n, this->_M_str[__pos]))
- return __pos;
- return npos;
- }
-
- template<typename _CharT, typename _Traits>
- typename basic_string_view<_CharT, _Traits>::size_type
- basic_string_view<_CharT, _Traits>::
- find_first_not_of(_CharT __c, size_type __pos) const noexcept
- {
- for (; __pos < this->_M_len; ++__pos)
- if (!traits_type::eq(this->_M_str[__pos], __c))
- return __pos;
- return npos;
- }
-
- template<typename _CharT, typename _Traits>
- typename basic_string_view<_CharT, _Traits>::size_type
- basic_string_view<_CharT, _Traits>::
- find_last_not_of(const _CharT* __str, size_type __pos, size_type __n) const
- {
- __glibcxx_requires_string_len(__str, __n);
- size_type __size = this->_M_len;
- if (__size)
- {
- if (--__size > __pos)
- __size = __pos;
- do
- {
- if (!traits_type::find(__str, __n, this->_M_str[__size]))
- return __size;
- }
- while (__size--);
- }
- return npos;
- }
-
- template<typename _CharT, typename _Traits>
- typename basic_string_view<_CharT, _Traits>::size_type
- basic_string_view<_CharT, _Traits>::
- find_last_not_of(_CharT __c, size_type __pos) const noexcept
- {
- size_type __size = this->_M_len;
- if (__size)
- {
- if (--__size > __pos)
- __size = __pos;
- do
- {
- if (!traits_type::eq(this->_M_str[__size], __c))
- return __size;
- }
- while (__size--);
- }
- return npos;
- }
-
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace experimental
-} // namespace std
-
-#endif // __cplusplus <= 201103L
-
-#endif // _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC
diff --git a/libstdc++-v3/include/experimental/unordered_map b/libstdc++-v3/include/experimental/unordered_map
index d3a578e..c80c382 100644
--- a/libstdc++-v3/include/experimental/unordered_map
+++ b/libstdc++-v3/include/experimental/unordered_map
@@ -36,7 +36,7 @@
#else
#include <unordered_map>
-#include <experimental/erase_if.h>
+#include <experimental/bits/erase_if.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
diff --git a/libstdc++-v3/include/experimental/unordered_set b/libstdc++-v3/include/experimental/unordered_set
index 2e5e08a..8461f9c 100644
--- a/libstdc++-v3/include/experimental/unordered_set
+++ b/libstdc++-v3/include/experimental/unordered_set
@@ -36,7 +36,7 @@
#else
#include <unordered_set>
-#include <experimental/erase_if.h>
+#include <experimental/bits/erase_if.h>
namespace std _GLIBCXX_VISIBILITY(default)
{