From: Jonathan Wakely Date: Fri, 9 Oct 2015 11:11:54 +0000 (+0100) Subject: Add include/experimental/bits dir X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=ea4554eaeab4ead3efe21dbe96c23e8009f530cf;p=gcc.git Add include/experimental/bits dir From-SVN: r228645 --- diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 74100f29925..2dc0d01241a 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/Makefile.in b/libstdc++-v3/include/Makefile.in index b72df264531..d545484a568 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -939,7 +939,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 \ @@ -953,7 +952,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 \ @@ -962,13 +960,23 @@ 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} + @ENABLE_FILESYSTEM_TS_FALSE@experimental_filesystem_headers = @ENABLE_FILESYSTEM_TS_TRUE@experimental_filesystem_headers = \ -@ENABLE_FILESYSTEM_TS_TRUE@ ${experimental_srcdir}/filesystem \ -@ENABLE_FILESYSTEM_TS_TRUE@ ${experimental_srcdir}/fs_dir.h \ -@ENABLE_FILESYSTEM_TS_TRUE@ ${experimental_srcdir}/fs_fwd.h \ -@ENABLE_FILESYSTEM_TS_TRUE@ ${experimental_srcdir}/fs_ops.h \ -@ENABLE_FILESYSTEM_TS_TRUE@ ${experimental_srcdir}/fs_path.h +@ENABLE_FILESYSTEM_TS_TRUE@ ${experimental_srcdir}/filesystem + +@ENABLE_FILESYSTEM_TS_FALSE@experimental_bits_filesystem_headers = +@ENABLE_FILESYSTEM_TS_TRUE@experimental_bits_filesystem_headers = \ +@ENABLE_FILESYSTEM_TS_TRUE@ ${experimental_bits_srcdir}/fs_dir.h \ +@ENABLE_FILESYSTEM_TS_TRUE@ ${experimental_bits_srcdir}/fs_fwd.h \ +@ENABLE_FILESYSTEM_TS_TRUE@ ${experimental_bits_srcdir}/fs_ops.h \ +@ENABLE_FILESYSTEM_TS_TRUE@ ${experimental_bits_srcdir}/fs_path.h # This is the common subset of C++ files that all three "C" header models use. @@ -1245,8 +1253,8 @@ PCHFLAGS = -x c++-header -nostdinc++ $(CXXFLAGS) $(VTV_PCH_CXXFLAGS) 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 @@ -1542,6 +1550,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 @@ -1793,6 +1806,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 @@ -1836,12 +1852,14 @@ 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): ; @: # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. 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 00000000000..e8bd72893bc --- /dev/null +++ b/libstdc++-v3/include/experimental/bits/erase_if.h @@ -0,0 +1,70 @@ +// -*- 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 +// . + +/** @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 +#else + +namespace std +{ +namespace experimental +{ +inline namespace fundamentals_v2 +{ + + namespace __detail + { + template + 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 00000000000..0c5253fb62d --- /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 +// . + +/** @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 +#else +# include +# include +# include +# include + +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 00000000000..a5ed2c5de0e --- /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 +// . + +/** @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 +#else + +#include +#include +#include + +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::type; + return static_cast( + static_cast<__utype>(__x) & static_cast<__utype>(__y)); + } + + constexpr copy_options + operator|(copy_options __x, copy_options __y) + { + using __utype = typename std::underlying_type::type; + return static_cast( + static_cast<__utype>(__x) | static_cast<__utype>(__y)); + } + + constexpr copy_options + operator^(copy_options __x, copy_options __y) + { + using __utype = typename std::underlying_type::type; + return static_cast( + static_cast<__utype>(__x) ^ static_cast<__utype>(__y)); + } + + constexpr copy_options + operator~(copy_options __x) + { + using __utype = typename std::underlying_type::type; + return static_cast(~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::type; + return static_cast( + static_cast<__utype>(__x) & static_cast<__utype>(__y)); + } + + constexpr perms + operator|(perms __x, perms __y) + { + using __utype = typename std::underlying_type::type; + return static_cast( + static_cast<__utype>(__x) | static_cast<__utype>(__y)); + } + + constexpr perms + operator^(perms __x, perms __y) + { + using __utype = typename std::underlying_type::type; + return static_cast( + static_cast<__utype>(__x) ^ static_cast<__utype>(__y)); + } + + constexpr perms + operator~(perms __x) + { + using __utype = typename std::underlying_type::type; + return static_cast(~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::type; + return static_cast( + static_cast<__utype>(__x) & static_cast<__utype>(__y)); + } + + constexpr directory_options + operator|(directory_options __x, directory_options __y) + { + using __utype = typename std::underlying_type::type; + return static_cast( + static_cast<__utype>(__x) | static_cast<__utype>(__y)); + } + + constexpr directory_options + operator^(directory_options __x, directory_options __y) + { + using __utype = typename std::underlying_type::type; + return static_cast( + static_cast<__utype>(__x) ^ static_cast<__utype>(__y)); + } + + constexpr directory_options + operator~(directory_options __x) + { + using __utype = typename std::underlying_type::type; + return static_cast(~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 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 00000000000..6b7d4709ee5 --- /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 +// . + +/** @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 +#else + +#include + +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 00000000000..40462a6ab19 --- /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 +// . + +/** @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 +#else + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(_WIN32) && !defined(__CYGWIN__) +# define _GLIBCXX_FILESYSTEM_IS_WINDOWS 1 +# include +#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 + struct __is_encoded_char : std::false_type { }; + + template> + using __is_path_iter_src + = __and_<__is_encoded_char, + std::is_base_of>; + + template + static __is_path_iter_src<_Iter> + __is_path_src(_Iter, int); + + template + static __is_encoded_char<_CharT> + __is_path_src(const basic_string<_CharT, _Traits, _Alloc>&, int); + + template + static std::false_type + __is_path_src(const _Unknown&, ...); + + template + struct __constructible_from; + + template + struct __constructible_from<_Iter, _Iter> + : __is_path_iter_src<_Iter> + { }; + + template + struct __constructible_from<_Source, void> + : decltype(__is_path_src(std::declval<_Source>(), 0)) + { }; + + template + using _Path = typename + std::enable_if<__and_<__not_>, + __constructible_from<_Tp1, _Tp2>>::value, + path>::type; + + template + static _Source + _S_range_begin(_Source __begin) { return __begin; } + + struct __null_terminated { }; + + template + static __null_terminated + _S_range_end(_Source) { return {}; } + + template + static const _CharT* + _S_range_begin(const basic_string<_CharT, _Traits, _Alloc>& __str) + { return __str.data(); } + + template + static const _CharT* + _S_range_end(const basic_string<_CharT, _Traits, _Alloc>& __str) + { return __str.data() + __str.size(); } + + template())), + typename _Val = typename std::iterator_traits<_Iter>::value_type> + using __value_type_is_char + = typename std::enable_if::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 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> + path(_Source const& __source) + : _M_pathname(_S_convert(_S_range_begin(__source), + _S_range_end(__source))) + { _M_split_cmpts(); } + + template> + path(_InputIterator __first, _InputIterator __last) + : _M_pathname(_S_convert(__first, __last)) + { _M_split_cmpts(); } + + template, + 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 _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 + _Path<_Source>& + operator=(_Source const& __source) + { return *this = path(__source); } + + template + _Path<_Source>& + assign(_Source const& __source) + { return *this = path(__source); } + + template + _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 + _Path<_Source>& + operator/=(_Source const& __source) + { return append(__source); } + + template + _Path<_Source>& + append(_Source const& __source) + { + return _M_append(_S_convert(_S_range_begin(__source), + _S_range_end(__source))); + } + + template + _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 + _Path<_Source>& + operator+=(_Source const& __x) { return concat(__x); } + + template + _Path<_CharT*, _CharT*>& + operator+=(_CharT __x); + + template + _Path<_Source>& + concat(_Source const& __x) + { return *this += _S_convert(_S_range_begin(__x), _S_range_end(__x)); } + + template + _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 _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 _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 _M_find_extension() const; + + template + 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 + 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 + 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 + 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 + 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 + 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; + __os << __quoted_string{__tmp, '"', '\\'}; + return __os; + } + + /// Read a path from a stream + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, path& __p) + { + basic_string<_CharT, _Traits> __tmp; + using __quoted_string + = std::__detail::_Quoted_string; + if (__is >> __quoted_string{ __tmp, '"', '\\' }) + __p = std::move(__tmp); + return __is; + } + + // TODO constrain with _Path and __value_type_is_char + template + 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 and __value_type_is_char + template + 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 : std::true_type + { using value_type = char; }; + + template<> + struct path::__is_encoded_char : std::true_type + { using value_type = wchar_t; }; + + template<> + struct path::__is_encoded_char : std::true_type + { using value_type = char16_t; }; + + template<> + struct path::__is_encoded_char : std::true_type + { using value_type = char32_t; }; + + // specialize _Cvt for degenerate 'noconv' case + template<> + struct path::_Cvt + { + template + static string_type + _S_convert(_Iter __first, _Iter __last) + { return string_type{__first, __last}; } + }; + + template + 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; + 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 __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(__f), + const_cast(__l)); + } + + template + 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 + 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 + 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 + 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, _CharAlloc>; + using _WString = basic_string<_CharT, _Traits, _Allocator>; + + // use codecvt_utf8 to convert native string to UTF-8 + codecvt_utf8 __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(); } + +#if _GLIBCXX_USE_WCHAR_T + inline std::wstring + path::wstring() const { return string(); } +#endif + + inline std::string + path::u8string() const + { +#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS + std::string __str; + // convert from native encoding to UTF-8 + codecvt_utf8 __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(); } + + inline std::u32string + path::u32string() const { return string(); } + +#ifndef _GLIBCXX_FILESYSTEM_IS_WINDOWS + template + 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 00000000000..75a34f90b2d --- /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 +// . + +/** @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 +#else + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace experimental +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + 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 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 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 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 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 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 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 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 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 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 35b5b377889..00000000000 --- a/libstdc++-v3/include/experimental/erase_if.h +++ /dev/null @@ -1,70 +0,0 @@ -// -*- 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 -// . - -/** @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 -#else - -namespace std -{ -namespace experimental -{ -inline namespace fundamentals_v2 -{ - - namespace __detail - { - template - 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 db7ab1117da..671346382d4 100644 --- a/libstdc++-v3/include/experimental/filesystem +++ b/libstdc++-v3/include/experimental/filesystem @@ -35,10 +35,10 @@ # include #else -#include -#include -#include -#include +#include +#include +#include +#include #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 0c5253fb62d..00000000000 --- 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 -// . - -/** @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 -#else -# include -# include -# include -# include - -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 a5ed2c5de0e..00000000000 --- 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 -// . - -/** @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 -#else - -#include -#include -#include - -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::type; - return static_cast( - static_cast<__utype>(__x) & static_cast<__utype>(__y)); - } - - constexpr copy_options - operator|(copy_options __x, copy_options __y) - { - using __utype = typename std::underlying_type::type; - return static_cast( - static_cast<__utype>(__x) | static_cast<__utype>(__y)); - } - - constexpr copy_options - operator^(copy_options __x, copy_options __y) - { - using __utype = typename std::underlying_type::type; - return static_cast( - static_cast<__utype>(__x) ^ static_cast<__utype>(__y)); - } - - constexpr copy_options - operator~(copy_options __x) - { - using __utype = typename std::underlying_type::type; - return static_cast(~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::type; - return static_cast( - static_cast<__utype>(__x) & static_cast<__utype>(__y)); - } - - constexpr perms - operator|(perms __x, perms __y) - { - using __utype = typename std::underlying_type::type; - return static_cast( - static_cast<__utype>(__x) | static_cast<__utype>(__y)); - } - - constexpr perms - operator^(perms __x, perms __y) - { - using __utype = typename std::underlying_type::type; - return static_cast( - static_cast<__utype>(__x) ^ static_cast<__utype>(__y)); - } - - constexpr perms - operator~(perms __x) - { - using __utype = typename std::underlying_type::type; - return static_cast(~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::type; - return static_cast( - static_cast<__utype>(__x) & static_cast<__utype>(__y)); - } - - constexpr directory_options - operator|(directory_options __x, directory_options __y) - { - using __utype = typename std::underlying_type::type; - return static_cast( - static_cast<__utype>(__x) | static_cast<__utype>(__y)); - } - - constexpr directory_options - operator^(directory_options __x, directory_options __y) - { - using __utype = typename std::underlying_type::type; - return static_cast( - static_cast<__utype>(__x) ^ static_cast<__utype>(__y)); - } - - constexpr directory_options - operator~(directory_options __x) - { - using __utype = typename std::underlying_type::type; - return static_cast(~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 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 6b7d4709ee5..00000000000 --- 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 -// . - -/** @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 -#else - -#include - -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 40462a6ab19..00000000000 --- 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 -// . - -/** @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 -#else - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#if defined(_WIN32) && !defined(__CYGWIN__) -# define _GLIBCXX_FILESYSTEM_IS_WINDOWS 1 -# include -#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 - struct __is_encoded_char : std::false_type { }; - - template> - using __is_path_iter_src - = __and_<__is_encoded_char, - std::is_base_of>; - - template - static __is_path_iter_src<_Iter> - __is_path_src(_Iter, int); - - template - static __is_encoded_char<_CharT> - __is_path_src(const basic_string<_CharT, _Traits, _Alloc>&, int); - - template - static std::false_type - __is_path_src(const _Unknown&, ...); - - template - struct __constructible_from; - - template - struct __constructible_from<_Iter, _Iter> - : __is_path_iter_src<_Iter> - { }; - - template - struct __constructible_from<_Source, void> - : decltype(__is_path_src(std::declval<_Source>(), 0)) - { }; - - template - using _Path = typename - std::enable_if<__and_<__not_>, - __constructible_from<_Tp1, _Tp2>>::value, - path>::type; - - template - static _Source - _S_range_begin(_Source __begin) { return __begin; } - - struct __null_terminated { }; - - template - static __null_terminated - _S_range_end(_Source) { return {}; } - - template - static const _CharT* - _S_range_begin(const basic_string<_CharT, _Traits, _Alloc>& __str) - { return __str.data(); } - - template - static const _CharT* - _S_range_end(const basic_string<_CharT, _Traits, _Alloc>& __str) - { return __str.data() + __str.size(); } - - template())), - typename _Val = typename std::iterator_traits<_Iter>::value_type> - using __value_type_is_char - = typename std::enable_if::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 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> - path(_Source const& __source) - : _M_pathname(_S_convert(_S_range_begin(__source), - _S_range_end(__source))) - { _M_split_cmpts(); } - - template> - path(_InputIterator __first, _InputIterator __last) - : _M_pathname(_S_convert(__first, __last)) - { _M_split_cmpts(); } - - template, - 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 _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 - _Path<_Source>& - operator=(_Source const& __source) - { return *this = path(__source); } - - template - _Path<_Source>& - assign(_Source const& __source) - { return *this = path(__source); } - - template - _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 - _Path<_Source>& - operator/=(_Source const& __source) - { return append(__source); } - - template - _Path<_Source>& - append(_Source const& __source) - { - return _M_append(_S_convert(_S_range_begin(__source), - _S_range_end(__source))); - } - - template - _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 - _Path<_Source>& - operator+=(_Source const& __x) { return concat(__x); } - - template - _Path<_CharT*, _CharT*>& - operator+=(_CharT __x); - - template - _Path<_Source>& - concat(_Source const& __x) - { return *this += _S_convert(_S_range_begin(__x), _S_range_end(__x)); } - - template - _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 _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 _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 _M_find_extension() const; - - template - 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 - 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 - 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 - 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 - 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 - 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; - __os << __quoted_string{__tmp, '"', '\\'}; - return __os; - } - - /// Read a path from a stream - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, path& __p) - { - basic_string<_CharT, _Traits> __tmp; - using __quoted_string - = std::__detail::_Quoted_string; - if (__is >> __quoted_string{ __tmp, '"', '\\' }) - __p = std::move(__tmp); - return __is; - } - - // TODO constrain with _Path and __value_type_is_char - template - 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 and __value_type_is_char - template - 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 : std::true_type - { using value_type = char; }; - - template<> - struct path::__is_encoded_char : std::true_type - { using value_type = wchar_t; }; - - template<> - struct path::__is_encoded_char : std::true_type - { using value_type = char16_t; }; - - template<> - struct path::__is_encoded_char : std::true_type - { using value_type = char32_t; }; - - // specialize _Cvt for degenerate 'noconv' case - template<> - struct path::_Cvt - { - template - static string_type - _S_convert(_Iter __first, _Iter __last) - { return string_type{__first, __last}; } - }; - - template - 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; - 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 __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(__f), - const_cast(__l)); - } - - template - 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 - 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 - 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 - 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, _CharAlloc>; - using _WString = basic_string<_CharT, _Traits, _Allocator>; - - // use codecvt_utf8 to convert native string to UTF-8 - codecvt_utf8 __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(); } - -#if _GLIBCXX_USE_WCHAR_T - inline std::wstring - path::wstring() const { return string(); } -#endif - - inline std::string - path::u8string() const - { -#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS - std::string __str; - // convert from native encoding to UTF-8 - codecvt_utf8 __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(); } - - inline std::u32string - path::u32string() const { return string(); } - -#ifndef _GLIBCXX_FILESYSTEM_IS_WINDOWS - template - 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 e4b3620e671..89bf2605091 100644 --- a/libstdc++-v3/include/experimental/map +++ b/libstdc++-v3/include/experimental/map @@ -36,7 +36,7 @@ #else #include -#include +#include namespace std _GLIBCXX_VISIBILITY(default) { diff --git a/libstdc++-v3/include/experimental/set b/libstdc++-v3/include/experimental/set index c742d9187f5..709fe327475 100644 --- a/libstdc++-v3/include/experimental/set +++ b/libstdc++-v3/include/experimental/set @@ -36,7 +36,7 @@ #else #include -#include +#include namespace std _GLIBCXX_VISIBILITY(default) { diff --git a/libstdc++-v3/include/experimental/string_view b/libstdc++-v3/include/experimental/string_view index 9dca400d75e..9931ad0557d 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 +#include #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 75a34f90b2d..00000000000 --- 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 -// . - -/** @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 -#else - -namespace std _GLIBCXX_VISIBILITY(default) -{ -namespace experimental -{ -_GLIBCXX_BEGIN_NAMESPACE_VERSION - - template - 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 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 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 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 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 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 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 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 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 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 d3a578efe3a..c80c3828ded 100644 --- a/libstdc++-v3/include/experimental/unordered_map +++ b/libstdc++-v3/include/experimental/unordered_map @@ -36,7 +36,7 @@ #else #include -#include +#include namespace std _GLIBCXX_VISIBILITY(default) { diff --git a/libstdc++-v3/include/experimental/unordered_set b/libstdc++-v3/include/experimental/unordered_set index 2e5e08a9609..8461f9ccb91 100644 --- a/libstdc++-v3/include/experimental/unordered_set +++ b/libstdc++-v3/include/experimental/unordered_set @@ -36,7 +36,7 @@ #else #include -#include +#include namespace std _GLIBCXX_VISIBILITY(default) {